source/dng_host.h - platform/external/dng_sdk - Git at Google

 /*****************************************************************************/
 // Copyright 2006-2019 Adobe Systems Incorporated
 // All Rights Reserved.
 //
 // NOTICE:	Adobe permits you to use, modify, and distribute this file in
 // accordance with the terms of the Adobe license agreement accompanying it.
 /*****************************************************************************/

 /** \file
  * Class definition for dng_host, initial point of contact and control between
  * host application and DNG SDK.
  */

 /*****************************************************************************/

 #ifndef __dng_host__
 #define __dng_host__

 /*****************************************************************************/

 #include "dng_auto_ptr.h"
 #include "dng_classes.h"
 #include "dng_errors.h"
 #include "dng_flags.h"
 #include "dng_types.h"
 #include "dng_uncopyable.h"

 /*****************************************************************************/

 /// \brief The main class for communication between the application and the
 /// DNG SDK. Used to customize memory allocation and other behaviors.
 ///
 /// dng_host allows setting parameters for the DNG conversion, mediates callback
 /// style interactions between the host application and the DNG SDK, and allows
 /// controlling certain internal behavior of the SDK such as memory allocation.
 /// Many applications will be able to use the default implementation of dng_host
 /// by just setting the dng_memory_allocator and dng_abort_sniffer in the
 /// constructor. More complex interactions will require deriving a class from
 /// dng_host.
 ///
 /// Multiple dng_host objects can be allocated in a single process. This may
 /// be useful for DNG processing on separate threads. (Distinct dng_host objects
 /// are completely threadsafe for read/write. The application is responsible for
 /// establishing mutual exclusion for read/write access to a single dng_host
 /// object if it is used in multiple threads.)

 class dng_host: private dng_uncopyable
 	{

 	private:

 		dng_memory_allocator *fAllocator;

 		dng_abort_sniffer *fSniffer;

 		// Does the host require all the image metadata (vs. just checking
 		// to see if the file is readable)?

 		bool fNeedsMeta;

 		// Does the host require actual image data (vs. just getting metadata
 		// or just checking to see if the file is readable)?

 		bool fNeedsImage;

 		// If we need the image data, can it be read at preview quality?

 		bool fForPreview;

 		// If non-zero, the minimum size (longer of the two pixel dimensions)
 		// image to read.  If zero, or if the full size image is smaller than
 		// this, read the full size image.

 		uint32 fMinimumSize;

 		// What is the preferred size for a preview image?	This can
 		// be slightly larger than the minimum size.  Zero if we want
 		// the full resolution image.

 		uint32 fPreferredSize;

 		// What is the maximum size for a preview image?  Zero if there
 		// is no maximum size limit.

 		uint32 fMaximumSize;

 		// The fraction of the image kept after a crop.	 This is used to
 		// adjust the sizes to take into account the cropping that
 		// will be peformed.

 		real64 fCropFactor;

 		// What DNG version should we keep enough data to save?

 		uint32 fSaveDNGVersion;

 		// Do we want to force saving to a linear DNG?

 		bool fSaveLinearDNG;

 		// Do we want to create JXL compressed in saved DNGs?

 		bool fLossyMosaicJXL = false;
 		bool fLosslessJXL    = false;

 		// Keep the original raw file data block?

 		bool fKeepOriginalFile;

 		// Should we ignore the enhanced IFD when reading DNGs?

 		bool fIgnoreEnhanced;

 		// Is this host being used to perform a negative read for fast
 		// conversion to DNG?

 		bool fForFastSaveToDNG;

 		uint32 fFastSaveToDNGSize;

 		bool fPreserveStage2;

 		std::shared_ptr<const dng_jxl_encode_settings> fJXLEncodeSettings;

 		std::shared_ptr<const dng_jxl_color_space_info> fJXLColorSpaceInfo;

 	public:

 		/// Allocate a dng_host object, possiblly with custom allocator and sniffer.
 		/// \param allocator Allows controlling all memory allocation done via this
 		/// dng_host. Defaults to singleton global dng_memory_allocator, which calls
 		/// new/delete dng_malloc_block for appropriate size.
 		/// \param sniffer Used to periodically check if pending DNG conversions
 		/// should be aborted and to communicate progress updates. Defaults to singleton
 		/// global dng_abort_sniffer, which never aborts and ignores progress updated.

 		dng_host (dng_memory_allocator *allocator = NULL,
 				  dng_abort_sniffer *sniffer = NULL);

 		/// Clean up direct memory for dng_host. Memory allocator and abort sniffer
 		/// are not deleted. Objects such as dng_image and others returned from
 		/// host can still be used after host is deleted.

 		virtual ~dng_host ();

 		/// Getter for host's memory allocator.

 		dng_memory_allocator & Allocator ();

 		/// Alocate a new dng_memory_block using the host's memory allocator.
 		/// Uses the Allocator() property of host to allocate a new block of memory.
 		/// Will call ThrowMemoryFull if block cannot be allocated.
 		/// \param logicalSize Number of usable bytes returned dng_memory_block
 		/// must contain.

 		virtual dng_memory_block * Allocate (uint32 logicalSize);

 		/// Setter for host's abort sniffer.

 		void SetSniffer (dng_abort_sniffer *sniffer)
 			{
 			fSniffer = sniffer;
 			}

 		/// Getter for host's abort sniffer.

 		dng_abort_sniffer * Sniffer ()
 			{
 			return fSniffer;
 			}

 		/// Check for pending abort. Should call ThrowUserCanceled if an abort
 		/// is pending.

 		virtual void SniffForAbort ();

 		/// Setter for flag determining whether all XMP metadata should be parsed.
 		/// Defaults to true. One might not want metadata when doing a quick check
 		/// to see if a file is readable.
 		/// \param needs If true, metadata is needed.

 		void SetNeedsMeta (bool needs)
 			{
 			fNeedsMeta = needs;
 			}

 		/// Getter for flag determining whether all XMP metadata should be parsed.

 		bool NeedsMeta () const
 			{
 			return fNeedsMeta;
 			}

 		/// Setter for flag determining whether DNG image data is needed. Defaults
 		/// to true. Image data might not be needed for applications which only
 		/// manipulate metadata.
 		/// \param needs If true, image data is needed.

 		void SetNeedsImage (bool needs)
 			{
 			fNeedsImage = needs;
 			}

 		/// Setter for flag determining whether DNG image data is needed.

 		bool NeedsImage () const
 			{
 			return fNeedsImage;
 			}

 		/// Setter for flag determining whether	image should be preview quality,
 		/// or full quality.
 		/// \param preview If true, rendered images are for preview.

 		void SetForPreview (bool preview)
 			{
 			fForPreview = preview;
 			}

 		/// Getter for flag determining whether image should be preview quality.
 		/// Preview quality images may be rendered more quickly. Current DNG SDK
 		/// does not change rendering behavior based on this flag, but derived
 		/// versions may use this getter to choose between a slower more accurate path
 		/// and a faster "good enough for preview" one. Data produce with ForPreview set
 		/// to true should not be written back to a DNG file, except as a preview image.

 		bool ForPreview () const
 			{
 			return fForPreview;
 			}

 		/// Setter for the minimum preview size.
 		/// \param size Minimum pixel size (long side of image).

 		void SetMinimumSize (uint32 size)
 			{
 			fMinimumSize = size;
 			}

 		/// Getter for the minimum preview size.

 		uint32 MinimumSize () const
 			{
 			return fMinimumSize;
 			}

 		/// Setter for the preferred preview size.
 		/// \param size Preferred pixel size (long side of image).

 		void SetPreferredSize (uint32 size)
 			{
 			fPreferredSize = size;
 			}

 		/// Getter for the preferred preview size.

 		uint32 PreferredSize () const
 			{
 			return fPreferredSize;
 			}

 		/// Setter for the maximum preview size.
 		/// \param size Maximum pixel size (long side of image).

 		void SetMaximumSize (uint32 size)
 			{
 			fMaximumSize = size;
 			}

 		/// Getter for the maximum preview size.

 		uint32 MaximumSize () const
 			{
 			return fMaximumSize;
 			}

 		/// Setter for the perform fast save to DNG.
 		/// \param flag True if the host is being used to perform a negative
 		/// read for fast conversion to DNG, false otherwise.

 		void SetForFastSaveToDNG (bool flag,
 								  uint32 size)
 			{
 			fForFastSaveToDNG = flag;
 			fFastSaveToDNGSize = size;
 			}

 		/// Getter for the Boolean value that indicates whether this host is
 		/// being used to perform a negative read for fast conversion to DNG.

 		bool ForFastSaveToDNG () const
 			{
 			return fForFastSaveToDNG;
 			}

 		uint32 FastSaveToDNGSize () const
 			{
 			return fFastSaveToDNGSize;
 			}

 		/// Setter for the cropping factor.
 		/// \param cropFactor Fraction of image to be used after crop.

 		void SetCropFactor (real64 cropFactor)
 			{
 			fCropFactor = cropFactor;
 			}

 		/// Getter for the cropping factor.

 		real64 CropFactor () const
 			{
 			return fCropFactor;
 			}

 		/// Makes sures minimum, preferred, and maximum sizes are reasonable.

 		void ValidateSizes ();

 		/// Setter for what version to save DNG file compatible with.
 		/// \param version What version to save DNG file compatible with.

 		void SetSaveDNGVersion (uint32 version)
 			{
 			fSaveDNGVersion = version;
 			}

 		/// Getter for what version to save DNG file compatible with.

 		virtual uint32 SaveDNGVersion () const;

 		/// Setter for flag determining whether to force saving a linear DNG file.
 		/// \param linear If true, we should force saving a linear DNG file.

 		void SetSaveLinearDNG (bool linear)
 			{
 			fSaveLinearDNG = linear;
 			}

 		/// Getter for flag determining whether to save a linear DNG file.

 		virtual bool SaveLinearDNG (const dng_negative &negative) const;

 		/// Getter for flag determining whether to save DNG with lossy
 		/// compressed mosaic if possible.

 		bool LossyMosaicJXL () const
 			{
 			return fLossyMosaicJXL;
 			}

 		/// Setter for flag determining whether to save DNG with lossy
 		/// compressed mosaic if possible.
 		/// \param want If true, attempt to save lossy compressed mosaic.

 		bool SetLossyMosaicJXL (bool want)
 			{
 			return fLossyMosaicJXL = want;
 			}

 		/// Getter for flag determining whether to save DNG with lossless
 		/// compression if possible.

 		bool LosslessJXL () const
 			{
 			return fLosslessJXL;
 			}

 		/// Setter for flag determining whether to save DNG with lossless
 		/// compression if possible.
 		/// \param want If true, attempt to save using lossless JXL.

 		bool SetLosslessJXL (bool want)
 			{
 			return fLosslessJXL = want;
 			}

 		/// Setter for flag determining whether to keep original raw file data.
 		/// \param keep If true, original raw data will be kept.

 		void SetKeepOriginalFile (bool keep)
 			{
 			fKeepOriginalFile = keep;
 			}

 		/// Getter for flag determining whether to keep original raw file data.

 		bool KeepOriginalFile ()
 			{
 			return fKeepOriginalFile;
 			}

 		/// Getter for ignored enhanced IFD flag.

 		bool IgnoreEnhanced () const
 			{
 			return fIgnoreEnhanced;
 			}

 		/// Setter for ignored enhanced IFD flag.

 		void SetIgnoreEnhanced (bool state)
 			{
 			fIgnoreEnhanced = state;
 			}

 		/// Determine if an error is the result of a temporary, but planned-for
 		/// occurence such as user cancellation or memory exhaustion. This method is
 		/// sometimes used to determine whether to try and continue processing a DNG
 		/// file despite errors in the file format, etc. In such cases, processing will
 		/// be continued if IsTransientError returns false. This is so that user cancellation
 		/// and memory exhaustion always terminate processing.
 		/// \param code Error to test for transience.

 		virtual bool IsTransientError (dng_error_code code);

 		/// General top-level botttleneck for image processing tasks.
 		/// Default implementation calls dng_area_task::PerformAreaTask method on
 		/// task. Can be overridden in derived classes to support multiprocessing,
 		/// for example.
 		/// \param task Image processing task to perform on area.
 		/// \param area Rectangle over which to perform image processing task.

 		virtual void PerformAreaTask (dng_area_task &task,
 									  const dng_rect &area,
 									  dng_area_task_progress *progress = NULL);

 		/// How many multiprocessing threads does PerformAreaTask use?
 		/// Default implementation always returns 1 since it is single threaded.

 		virtual uint32 PerformAreaTaskThreads ();

 		/// Factory method for dng_exif class. Can be used to customize allocation or
 		/// to ensure a derived class is used instead of dng_exif.

 		virtual dng_exif * Make_dng_exif ();

 		/// Factory method for dng_xmp class. Can be used to customize allocation or
 		/// to ensure a derived class is used instead of dng_xmp.

 		/// Factory method for dng_shared class. Can be used to customize allocation
 		/// or to ensure a derived class is used instead of dng_shared.

 		virtual dng_shared * Make_dng_shared ();

 		/// Factory method for dng_ifd class. Can be used to customize allocation or
 		/// to ensure a derived class is used instead of dng_ifd.

 		virtual dng_ifd * Make_dng_ifd ();

 		/// Factory method for dng_negative class. Can be used to customize allocation
 		/// or to ensure a derived class is used instead of dng_negative.

 		virtual dng_negative * Make_dng_negative ();

 		/// Factory method for dng_image class. Can be used to customize allocation
 		/// or to ensure a derived class is used instead of dng_simple_image.

 		virtual dng_image * Make_dng_image (const dng_rect &bounds,
 											uint32 planes,
 											uint32 pixelType);

 		/// Factory method for parsing dng_opcode based class. Can be used to
 		/// override opcode implementations.

 		virtual dng_opcode * Make_dng_opcode (uint32 opcodeID,
 											  dng_stream &stream);

 		/// Factory method for making a dng_rgb_to_rgb_table_data based class.

 		virtual dng_rgb_to_rgb_table_data *
 			Make_dng_rgb_to_rgb_table_data (const dng_rgb_table &table);

 		/// Factory method to apply a dng_opcode_list. Can be used to override
 		/// opcode list applications.

 		virtual void ApplyOpcodeList (dng_opcode_list &list,
 									  dng_negative &negative,
 									  AutoPtr<dng_image> &image);

 		/// Factory method to resample an image.  Can be used to override
 		/// image method used to resample images.

 		virtual void ResampleImage (const dng_image &srcImage,
 									dng_image &dstImage);

 		/// Getter for flag determining whether we should preserve the stage 2
 		/// image after building the stage 3 image.

 		bool WantsPreserveStage2 () const
 			{
 			return fPreserveStage2;
 			}

 		/// Setter for flag determining whether we should preserve the stage 2
 		/// image after building the stage 3 image.

 		void SetWantsPreserveStage2 (bool flag)
 			{
 			fPreserveStage2 = flag;
 			}

 		/// JXL compression API.

 		void SetJXLEncodeSettings (const dng_jxl_encode_settings &settings);

 		const dng_jxl_encode_settings * JXLEncodeSettings () const
 			{
 			return fJXLEncodeSettings.get ();
 			}

 		void SetJXLColorSpaceInfo (std::shared_ptr<const dng_jxl_color_space_info> info)
 			{
 			fJXLColorSpaceInfo = info;
 			}

 		const dng_jxl_color_space_info * JXLColorSpaceInfo () const
 			{
 			return fJXLColorSpaceInfo.get ();
 			}

 		std::shared_ptr<const dng_jxl_color_space_info> ShareJXLColorSpaceInfo () const
 			{
 			return fJXLColorSpaceInfo;
 			}

 		enum use_case_enum
 			{
 			use_case_LossyMosaic,
 			use_case_LosslessMosaic,
 			use_case_MainImage,
 			use_case_LosslessMainImage,
 			use_case_EncodedMainImage,
 			use_case_ProxyImage,
 			use_case_EnhancedImage,
 			use_case_LosslessEnhancedImage,
 			use_case_MergeResults,
 			use_case_Transparency,
 			use_case_LosslessTransparency,
 			use_case_Depth,
 			use_case_LosslessDepth,
 			use_case_SemanticMask,
 			use_case_LosslessSemanticMask,
 			use_case_RenderedPreview,
 			use_case_GainMap,
 			use_case_LosslessGainMap
 			};

 		virtual dng_jxl_encode_settings *
 			MakeJXLEncodeSettings (use_case_enum useCase,
 								   const dng_image &image,
 								   const dng_negative *negative = nullptr) const;

 	};

 /*****************************************************************************/

 #endif	//  __dng_host__

 /*****************************************************************************/
	/*****************************************************************************/
	// Copyright 2006-2019 Adobe Systems Incorporated
	// All Rights Reserved.
	//
	// NOTICE: Adobe permits you to use, modify, and distribute this file in
	// accordance with the terms of the Adobe license agreement accompanying it.
	/*****************************************************************************/

	/** \file
	* Class definition for dng_host, initial point of contact and control between
	* host application and DNG SDK.
	*/

	/*****************************************************************************/

	#ifndef __dng_host__
	#define __dng_host__

	/*****************************************************************************/

	#include "dng_auto_ptr.h"
	#include "dng_classes.h"
	#include "dng_errors.h"
	#include "dng_flags.h"
	#include "dng_types.h"
	#include "dng_uncopyable.h"

	/*****************************************************************************/

	/// \brief The main class for communication between the application and the
	/// DNG SDK. Used to customize memory allocation and other behaviors.
	///
	/// dng_host allows setting parameters for the DNG conversion, mediates callback
	/// style interactions between the host application and the DNG SDK, and allows
	/// controlling certain internal behavior of the SDK such as memory allocation.
	/// Many applications will be able to use the default implementation of dng_host
	/// by just setting the dng_memory_allocator and dng_abort_sniffer in the
	/// constructor. More complex interactions will require deriving a class from
	/// dng_host.
	///
	/// Multiple dng_host objects can be allocated in a single process. This may
	/// be useful for DNG processing on separate threads. (Distinct dng_host objects
	/// are completely threadsafe for read/write. The application is responsible for
	/// establishing mutual exclusion for read/write access to a single dng_host
	/// object if it is used in multiple threads.)

	class dng_host: private dng_uncopyable
	{

	private:

	dng_memory_allocator *fAllocator;

	dng_abort_sniffer *fSniffer;

	// Does the host require all the image metadata (vs. just checking
	// to see if the file is readable)?

	bool fNeedsMeta;

	// Does the host require actual image data (vs. just getting metadata
	// or just checking to see if the file is readable)?

	bool fNeedsImage;

	// If we need the image data, can it be read at preview quality?

	bool fForPreview;

	// If non-zero, the minimum size (longer of the two pixel dimensions)
	// image to read. If zero, or if the full size image is smaller than
	// this, read the full size image.

	uint32 fMinimumSize;

	// What is the preferred size for a preview image? This can
	// be slightly larger than the minimum size. Zero if we want
	// the full resolution image.

	uint32 fPreferredSize;

	// What is the maximum size for a preview image? Zero if there
	// is no maximum size limit.

	uint32 fMaximumSize;

	// The fraction of the image kept after a crop. This is used to
	// adjust the sizes to take into account the cropping that
	// will be peformed.

	real64 fCropFactor;

	// What DNG version should we keep enough data to save?

	uint32 fSaveDNGVersion;

	// Do we want to force saving to a linear DNG?

	bool fSaveLinearDNG;

	// Do we want to create JXL compressed in saved DNGs?

	bool fLossyMosaicJXL = false;
	bool fLosslessJXL = false;

	// Keep the original raw file data block?

	bool fKeepOriginalFile;

	// Should we ignore the enhanced IFD when reading DNGs?

	bool fIgnoreEnhanced;

	// Is this host being used to perform a negative read for fast
	// conversion to DNG?

	bool fForFastSaveToDNG;

	uint32 fFastSaveToDNGSize;

	bool fPreserveStage2;

	std::shared_ptr<const dng_jxl_encode_settings> fJXLEncodeSettings;

	std::shared_ptr<const dng_jxl_color_space_info> fJXLColorSpaceInfo;

	public:

	/// Allocate a dng_host object, possiblly with custom allocator and sniffer.
	/// \param allocator Allows controlling all memory allocation done via this
	/// dng_host. Defaults to singleton global dng_memory_allocator, which calls
	/// new/delete dng_malloc_block for appropriate size.
	/// \param sniffer Used to periodically check if pending DNG conversions
	/// should be aborted and to communicate progress updates. Defaults to singleton
	/// global dng_abort_sniffer, which never aborts and ignores progress updated.

	dng_host (dng_memory_allocator *allocator = NULL,
	dng_abort_sniffer *sniffer = NULL);

	/// Clean up direct memory for dng_host. Memory allocator and abort sniffer
	/// are not deleted. Objects such as dng_image and others returned from
	/// host can still be used after host is deleted.

	virtual ~dng_host ();

	/// Getter for host's memory allocator.

	dng_memory_allocator & Allocator ();

	/// Alocate a new dng_memory_block using the host's memory allocator.
	/// Uses the Allocator() property of host to allocate a new block of memory.
	/// Will call ThrowMemoryFull if block cannot be allocated.
	/// \param logicalSize Number of usable bytes returned dng_memory_block
	/// must contain.

	virtual dng_memory_block * Allocate (uint32 logicalSize);

	/// Setter for host's abort sniffer.

	void SetSniffer (dng_abort_sniffer *sniffer)
	{
	fSniffer = sniffer;
	}

	/// Getter for host's abort sniffer.

	dng_abort_sniffer * Sniffer ()
	{
	return fSniffer;
	}

	/// Check for pending abort. Should call ThrowUserCanceled if an abort
	/// is pending.

	virtual void SniffForAbort ();

	/// Setter for flag determining whether all XMP metadata should be parsed.
	/// Defaults to true. One might not want metadata when doing a quick check
	/// to see if a file is readable.
	/// \param needs If true, metadata is needed.

	void SetNeedsMeta (bool needs)
	{
	fNeedsMeta = needs;
	}

	/// Getter for flag determining whether all XMP metadata should be parsed.

	bool NeedsMeta () const
	{
	return fNeedsMeta;
	}

	/// Setter for flag determining whether DNG image data is needed. Defaults
	/// to true. Image data might not be needed for applications which only
	/// manipulate metadata.
	/// \param needs If true, image data is needed.

	void SetNeedsImage (bool needs)
	{
	fNeedsImage = needs;
	}

	/// Setter for flag determining whether DNG image data is needed.

	bool NeedsImage () const
	{
	return fNeedsImage;
	}

	/// Setter for flag determining whether image should be preview quality,
	/// or full quality.
	/// \param preview If true, rendered images are for preview.

	void SetForPreview (bool preview)
	{
	fForPreview = preview;
	}

	/// Getter for flag determining whether image should be preview quality.
	/// Preview quality images may be rendered more quickly. Current DNG SDK
	/// does not change rendering behavior based on this flag, but derived
	/// versions may use this getter to choose between a slower more accurate path
	/// and a faster "good enough for preview" one. Data produce with ForPreview set
	/// to true should not be written back to a DNG file, except as a preview image.

	bool ForPreview () const
	{
	return fForPreview;
	}

	/// Setter for the minimum preview size.
	/// \param size Minimum pixel size (long side of image).

	void SetMinimumSize (uint32 size)
	{
	fMinimumSize = size;
	}

	/// Getter for the minimum preview size.

	uint32 MinimumSize () const
	{
	return fMinimumSize;
	}

	/// Setter for the preferred preview size.
	/// \param size Preferred pixel size (long side of image).

	void SetPreferredSize (uint32 size)
	{
	fPreferredSize = size;
	}

	/// Getter for the preferred preview size.

	uint32 PreferredSize () const
	{
	return fPreferredSize;
	}

	/// Setter for the maximum preview size.
	/// \param size Maximum pixel size (long side of image).

	void SetMaximumSize (uint32 size)
	{
	fMaximumSize = size;
	}

	/// Getter for the maximum preview size.

	uint32 MaximumSize () const
	{
	return fMaximumSize;
	}

	/// Setter for the perform fast save to DNG.
	/// \param flag True if the host is being used to perform a negative
	/// read for fast conversion to DNG, false otherwise.

	void SetForFastSaveToDNG (bool flag,
	uint32 size)
	{
	fForFastSaveToDNG = flag;
	fFastSaveToDNGSize = size;
	}

	/// Getter for the Boolean value that indicates whether this host is
	/// being used to perform a negative read for fast conversion to DNG.

	bool ForFastSaveToDNG () const
	{
	return fForFastSaveToDNG;
	}

	uint32 FastSaveToDNGSize () const
	{
	return fFastSaveToDNGSize;
	}

	/// Setter for the cropping factor.
	/// \param cropFactor Fraction of image to be used after crop.

	void SetCropFactor (real64 cropFactor)
	{
	fCropFactor = cropFactor;
	}

	/// Getter for the cropping factor.

	real64 CropFactor () const
	{
	return fCropFactor;
	}

	/// Makes sures minimum, preferred, and maximum sizes are reasonable.

	void ValidateSizes ();

	/// Setter for what version to save DNG file compatible with.
	/// \param version What version to save DNG file compatible with.

	void SetSaveDNGVersion (uint32 version)
	{
	fSaveDNGVersion = version;
	}

	/// Getter for what version to save DNG file compatible with.

	virtual uint32 SaveDNGVersion () const;

	/// Setter for flag determining whether to force saving a linear DNG file.
	/// \param linear If true, we should force saving a linear DNG file.

	void SetSaveLinearDNG (bool linear)
	{
	fSaveLinearDNG = linear;
	}

	/// Getter for flag determining whether to save a linear DNG file.

	virtual bool SaveLinearDNG (const dng_negative &negative) const;

	/// Getter for flag determining whether to save DNG with lossy
	/// compressed mosaic if possible.

	bool LossyMosaicJXL () const
	{
	return fLossyMosaicJXL;
	}

	/// Setter for flag determining whether to save DNG with lossy
	/// compressed mosaic if possible.
	/// \param want If true, attempt to save lossy compressed mosaic.

	bool SetLossyMosaicJXL (bool want)
	{
	return fLossyMosaicJXL = want;
	}

	/// Getter for flag determining whether to save DNG with lossless
	/// compression if possible.

	bool LosslessJXL () const
	{
	return fLosslessJXL;
	}

	/// Setter for flag determining whether to save DNG with lossless
	/// compression if possible.
	/// \param want If true, attempt to save using lossless JXL.

	bool SetLosslessJXL (bool want)
	{
	return fLosslessJXL = want;
	}

	/// Setter for flag determining whether to keep original raw file data.
	/// \param keep If true, original raw data will be kept.

	void SetKeepOriginalFile (bool keep)
	{
	fKeepOriginalFile = keep;
	}

	/// Getter for flag determining whether to keep original raw file data.

	bool KeepOriginalFile ()
	{
	return fKeepOriginalFile;
	}

	/// Getter for ignored enhanced IFD flag.

	bool IgnoreEnhanced () const
	{
	return fIgnoreEnhanced;
	}

	/// Setter for ignored enhanced IFD flag.

	void SetIgnoreEnhanced (bool state)
	{
	fIgnoreEnhanced = state;
	}

	/// Determine if an error is the result of a temporary, but planned-for
	/// occurence such as user cancellation or memory exhaustion. This method is
	/// sometimes used to determine whether to try and continue processing a DNG
	/// file despite errors in the file format, etc. In such cases, processing will
	/// be continued if IsTransientError returns false. This is so that user cancellation
	/// and memory exhaustion always terminate processing.
	/// \param code Error to test for transience.

	virtual bool IsTransientError (dng_error_code code);

	/// General top-level botttleneck for image processing tasks.
	/// Default implementation calls dng_area_task::PerformAreaTask method on
	/// task. Can be overridden in derived classes to support multiprocessing,
	/// for example.
	/// \param task Image processing task to perform on area.
	/// \param area Rectangle over which to perform image processing task.

	virtual void PerformAreaTask (dng_area_task &task,
	const dng_rect &area,
	dng_area_task_progress *progress = NULL);

	/// How many multiprocessing threads does PerformAreaTask use?
	/// Default implementation always returns 1 since it is single threaded.

	virtual uint32 PerformAreaTaskThreads ();

	/// Factory method for dng_exif class. Can be used to customize allocation or
	/// to ensure a derived class is used instead of dng_exif.

	virtual dng_exif * Make_dng_exif ();

	/// Factory method for dng_xmp class. Can be used to customize allocation or
	/// to ensure a derived class is used instead of dng_xmp.

	/// Factory method for dng_shared class. Can be used to customize allocation
	/// or to ensure a derived class is used instead of dng_shared.

	virtual dng_shared * Make_dng_shared ();

	/// Factory method for dng_ifd class. Can be used to customize allocation or
	/// to ensure a derived class is used instead of dng_ifd.

	virtual dng_ifd * Make_dng_ifd ();

	/// Factory method for dng_negative class. Can be used to customize allocation
	/// or to ensure a derived class is used instead of dng_negative.

	virtual dng_negative * Make_dng_negative ();

	/// Factory method for dng_image class. Can be used to customize allocation
	/// or to ensure a derived class is used instead of dng_simple_image.

	virtual dng_image * Make_dng_image (const dng_rect &bounds,
	uint32 planes,
	uint32 pixelType);

	/// Factory method for parsing dng_opcode based class. Can be used to
	/// override opcode implementations.

	virtual dng_opcode * Make_dng_opcode (uint32 opcodeID,
	dng_stream &stream);

	/// Factory method for making a dng_rgb_to_rgb_table_data based class.

	virtual dng_rgb_to_rgb_table_data *
	Make_dng_rgb_to_rgb_table_data (const dng_rgb_table &table);

	/// Factory method to apply a dng_opcode_list. Can be used to override
	/// opcode list applications.

	virtual void ApplyOpcodeList (dng_opcode_list &list,
	dng_negative &negative,
	AutoPtr<dng_image> &image);

	/// Factory method to resample an image. Can be used to override
	/// image method used to resample images.

	virtual void ResampleImage (const dng_image &srcImage,
	dng_image &dstImage);

	/// Getter for flag determining whether we should preserve the stage 2
	/// image after building the stage 3 image.

	bool WantsPreserveStage2 () const
	{
	return fPreserveStage2;
	}

	/// Setter for flag determining whether we should preserve the stage 2
	/// image after building the stage 3 image.

	void SetWantsPreserveStage2 (bool flag)
	{
	fPreserveStage2 = flag;
	}

	/// JXL compression API.

	void SetJXLEncodeSettings (const dng_jxl_encode_settings &settings);

	const dng_jxl_encode_settings * JXLEncodeSettings () const
	{
	return fJXLEncodeSettings.get ();
	}

	void SetJXLColorSpaceInfo (std::shared_ptr<const dng_jxl_color_space_info> info)
	{
	fJXLColorSpaceInfo = info;
	}

	const dng_jxl_color_space_info * JXLColorSpaceInfo () const
	{
	return fJXLColorSpaceInfo.get ();
	}

	std::shared_ptr<const dng_jxl_color_space_info> ShareJXLColorSpaceInfo () const
	{
	return fJXLColorSpaceInfo;
	}

	enum use_case_enum
	{
	use_case_LossyMosaic,
	use_case_LosslessMosaic,
	use_case_MainImage,
	use_case_LosslessMainImage,
	use_case_EncodedMainImage,
	use_case_ProxyImage,
	use_case_EnhancedImage,
	use_case_LosslessEnhancedImage,
	use_case_MergeResults,
	use_case_Transparency,
	use_case_LosslessTransparency,
	use_case_Depth,
	use_case_LosslessDepth,
	use_case_SemanticMask,
	use_case_LosslessSemanticMask,
	use_case_RenderedPreview,
	use_case_GainMap,
	use_case_LosslessGainMap
	};

	virtual dng_jxl_encode_settings *
	MakeJXLEncodeSettings (use_case_enum useCase,
	const dng_image &image,
	const dng_negative *negative = nullptr) const;

	};

	/*****************************************************************************/

	#endif // __dng_host__

	/*****************************************************************************/