xref: /external/dng_sdk/source/dng_preview.cpp

/*****************************************************************************/
// Copyright 2007-2011 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.
/*****************************************************************************/

/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_preview.cpp#1 $ */
/* $DateTime: 2012/05/30 13:28:51 $ */
/* $Change: 832332 $ */
/* $Author: tknoll $ */

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

#include "dng_preview.h"

#include "dng_assertions.h"
#include "dng_image.h"
#include "dng_image_writer.h"
#include "dng_memory.h"
#include "dng_stream.h"
#include "dng_tag_codes.h"
#include "dng_tag_values.h"

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

class dng_preview_tag_set: public dng_basic_tag_set
	{

	private:

		tag_string fApplicationNameTag;

		tag_string fApplicationVersionTag;

		tag_string fSettingsNameTag;

		dng_fingerprint fSettingsDigest;

		tag_uint8_ptr fSettingsDigestTag;

		tag_uint32 fColorSpaceTag;

		tag_string fDateTimeTag;

		tag_real64 fRawToPreviewGainTag;

		tag_uint32 fCacheVersionTag;

	public:

		dng_preview_tag_set (dng_tiff_directory &directory,
							 const dng_preview &preview,
							 const dng_ifd &ifd);

		virtual ~dng_preview_tag_set ();

	};

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

dng_preview_tag_set::dng_preview_tag_set (dng_tiff_directory &directory,
										  const dng_preview &preview,
										  const dng_ifd &ifd)

	:	dng_basic_tag_set (directory, ifd)

	,	fApplicationNameTag (tcPreviewApplicationName,
							 preview.fInfo.fApplicationName,
							 false)

	,	fApplicationVersionTag (tcPreviewApplicationVersion,
							    preview.fInfo.fApplicationVersion,
								false)

	,	fSettingsNameTag (tcPreviewSettingsName,
						  preview.fInfo.fSettingsName,
						  false)

	,	fSettingsDigest (preview.fInfo.fSettingsDigest)

	,	fSettingsDigestTag (tcPreviewSettingsDigest,
							fSettingsDigest.data,
							16)

	,	fColorSpaceTag (tcPreviewColorSpace,
						preview.fInfo.fColorSpace)

	,	fDateTimeTag (tcPreviewDateTime,
					  preview.fInfo.fDateTime,
					  true)

	,	fRawToPreviewGainTag (tcRawToPreviewGain,
							  preview.fInfo.fRawToPreviewGain)

	,	fCacheVersionTag (tcCacheVersion,
					      preview.fInfo.fCacheVersion)

	{

	if (preview.fInfo.fApplicationName.NotEmpty ())
		{

		directory.Add (&fApplicationNameTag);

		}

	if (preview.fInfo.fApplicationVersion.NotEmpty ())
		{

		directory.Add (&fApplicationVersionTag);

		}

	if (preview.fInfo.fSettingsName.NotEmpty ())
		{

		directory.Add (&fSettingsNameTag);

		}

	if (preview.fInfo.fSettingsDigest.IsValid ())
		{

		directory.Add (&fSettingsDigestTag);

		}

	if (preview.fInfo.fColorSpace != previewColorSpace_MaxEnum)
		{

		directory.Add (&fColorSpaceTag);

		}

	if (preview.fInfo.fDateTime.NotEmpty ())
		{

		directory.Add (&fDateTimeTag);

		}

	if (preview.fInfo.fRawToPreviewGain != 1.0)
		{

		directory.Add (&fRawToPreviewGainTag);

		}

	if (preview.fInfo.fCacheVersion != 0)
		{

		directory.Add (&fCacheVersionTag);

		}

	}

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

dng_preview_tag_set::~dng_preview_tag_set ()
	{

	}

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

dng_preview::dng_preview ()

	:	fInfo ()

	{

	}

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

dng_preview::~dng_preview ()
	{

	}

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

dng_image_preview::dng_image_preview ()

	:	fImage ()
	,	fIFD   ()

	{

	}

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

dng_image_preview::~dng_image_preview ()
	{

	}

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

dng_basic_tag_set * dng_image_preview::AddTagSet (dng_tiff_directory &directory) const
	{

	fIFD.fNewSubFileType = fInfo.fIsPrimary ? sfPreviewImage
											: sfAltPreviewImage;

	fIFD.fImageWidth  = fImage->Width  ();
	fIFD.fImageLength = fImage->Height ();

	fIFD.fSamplesPerPixel = fImage->Planes ();

	fIFD.fPhotometricInterpretation = fIFD.fSamplesPerPixel == 1 ? piBlackIsZero
																 : piRGB;

	fIFD.fBitsPerSample [0] = TagTypeSize (fImage->PixelType ()) * 8;

	for (uint32 j = 1; j < fIFD.fSamplesPerPixel; j++)
		{
		fIFD.fBitsPerSample [j] = fIFD.fBitsPerSample [0];
		}

	fIFD.SetSingleStrip ();

	return new dng_preview_tag_set (directory, *this, fIFD);

	}

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

void dng_image_preview::WriteData (dng_host &host,
								   dng_image_writer &writer,
								   dng_basic_tag_set &basic,
								   dng_stream &stream) const
	{

	writer.WriteImage (host,
					   fIFD,
					   basic,
					   stream,
				       *fImage.Get ());

	}

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

class dng_jpeg_preview_tag_set: public dng_preview_tag_set
	{

	private:

		dng_urational fCoefficientsData [3];

		tag_urational_ptr fCoefficientsTag;

		uint16 fSubSamplingData [2];

		tag_uint16_ptr fSubSamplingTag;

		tag_uint16 fPositioningTag;

		dng_urational fReferenceData [6];

		tag_urational_ptr fReferenceTag;

	public:

		dng_jpeg_preview_tag_set (dng_tiff_directory &directory,
								  const dng_jpeg_preview &preview,
								  const dng_ifd &ifd);

		virtual ~dng_jpeg_preview_tag_set ();

	};

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

dng_jpeg_preview_tag_set::dng_jpeg_preview_tag_set (dng_tiff_directory &directory,
													const dng_jpeg_preview &preview,
													const dng_ifd &ifd)

	:	dng_preview_tag_set (directory, preview, ifd)

	,	fCoefficientsTag (tcYCbCrCoefficients, fCoefficientsData, 3)

	,	fSubSamplingTag (tcYCbCrSubSampling, fSubSamplingData, 2)

	,	fPositioningTag (tcYCbCrPositioning, preview.fYCbCrPositioning)

	,	fReferenceTag (tcReferenceBlackWhite, fReferenceData, 6)

	{

	if (preview.fPhotometricInterpretation == piYCbCr)
		{

		fCoefficientsData [0] = dng_urational (299, 1000);
		fCoefficientsData [1] = dng_urational (587, 1000);
		fCoefficientsData [2] = dng_urational (114, 1000);

		directory.Add (&fCoefficientsTag);

		fSubSamplingData [0] = (uint16) preview.fYCbCrSubSampling.h;
		fSubSamplingData [1] = (uint16) preview.fYCbCrSubSampling.v;

		directory.Add (&fSubSamplingTag);

		directory.Add (&fPositioningTag);

		fReferenceData [0] = dng_urational (  0, 1);
		fReferenceData [1] = dng_urational (255, 1);
		fReferenceData [2] = dng_urational (128, 1);
		fReferenceData [3] = dng_urational (255, 1);
		fReferenceData [4] = dng_urational (128, 1);
		fReferenceData [5] = dng_urational (255, 1);

		directory.Add (&fReferenceTag);

		}

	}

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

dng_jpeg_preview_tag_set::~dng_jpeg_preview_tag_set ()
	{

	}

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

dng_jpeg_preview::dng_jpeg_preview ()

	:	fPreviewSize 			   ()
	,	fPhotometricInterpretation (piYCbCr)
	,	fYCbCrSubSampling 		   (1, 1)
	,	fYCbCrPositioning		   (2)
	,	fCompressedData			   ()

	{

	}

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

dng_jpeg_preview::~dng_jpeg_preview ()
	{

	}

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

dng_basic_tag_set * dng_jpeg_preview::AddTagSet (dng_tiff_directory &directory) const
	{

	dng_ifd ifd;

	ifd.fNewSubFileType = fInfo.fIsPrimary ? sfPreviewImage
										   : sfAltPreviewImage;

	ifd.fImageWidth  = fPreviewSize.h;
	ifd.fImageLength = fPreviewSize.v;

	ifd.fPhotometricInterpretation = fPhotometricInterpretation;

	ifd.fBitsPerSample [0] = 8;
	ifd.fBitsPerSample [1] = 8;
	ifd.fBitsPerSample [2] = 8;

	ifd.fSamplesPerPixel = (fPhotometricInterpretation == piBlackIsZero ? 1 : 3);

	ifd.fCompression = ccJPEG;
	ifd.fPredictor   = cpNullPredictor;

	ifd.SetSingleStrip ();

	return new dng_jpeg_preview_tag_set (directory, *this, ifd);

	}

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

void dng_jpeg_preview::WriteData (dng_host & /* host */,
								  dng_image_writer & /* writer */,
								  dng_basic_tag_set &basic,
								  dng_stream &stream) const
	{

	basic.SetTileOffset (0, (uint32) stream.Position ());

	basic.SetTileByteCount (0, fCompressedData->LogicalSize ());

	stream.Put (fCompressedData->Buffer      (),
				fCompressedData->LogicalSize ());

	if (fCompressedData->LogicalSize () & 1)
		{
		stream.Put_uint8 (0);
		}

	}

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

void dng_jpeg_preview::SpoolAdobeThumbnail (dng_stream &stream) const
	{

	DNG_ASSERT (fCompressedData.Get (),
				"SpoolAdobeThumbnail: no data");

	DNG_ASSERT (fPhotometricInterpretation == piYCbCr,
				"SpoolAdobeThumbnail: Non-YCbCr");

	uint32 compressedSize = fCompressedData->LogicalSize ();

	stream.Put_uint32 (DNG_CHAR4 ('8','B','I','M'));
	stream.Put_uint16 (1036);
	stream.Put_uint16 (0);

	stream.Put_uint32 (compressedSize + 28);

	uint32 widthBytes = (fPreviewSize.h * 24 + 31) / 32 * 4;

	stream.Put_uint32 (1);
	stream.Put_uint32 (fPreviewSize.h);
	stream.Put_uint32 (fPreviewSize.v);
	stream.Put_uint32 (widthBytes);
	stream.Put_uint32 (widthBytes * fPreviewSize.v);
	stream.Put_uint32 (compressedSize);
	stream.Put_uint16 (24);
	stream.Put_uint16 (1);

	stream.Put (fCompressedData->Buffer (),
			    compressedSize);

	if (compressedSize & 1)
		{
		stream.Put_uint8 (0);
		}

	}

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

class dng_raw_preview_tag_set: public dng_preview_tag_set
	{

	private:

		tag_data_ptr fOpcodeList2Tag;

		tag_uint32_ptr fWhiteLevelTag;

		uint32 fWhiteLevelData [kMaxColorPlanes];

	public:

		dng_raw_preview_tag_set (dng_tiff_directory &directory,
								 const dng_raw_preview &preview,
								 const dng_ifd &ifd);

		virtual ~dng_raw_preview_tag_set ();

	};

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

dng_raw_preview_tag_set::dng_raw_preview_tag_set (dng_tiff_directory &directory,
												  const dng_raw_preview &preview,
												  const dng_ifd &ifd)

	:	dng_preview_tag_set (directory, preview, ifd)

	,	fOpcodeList2Tag (tcOpcodeList2,
						 ttUndefined,
						 0,
						 NULL)

	,	fWhiteLevelTag (tcWhiteLevel,
						fWhiteLevelData,
						preview.fImage->Planes ())

	{

	if (preview.fOpcodeList2Data.Get ())
		{

		fOpcodeList2Tag.SetData  (preview.fOpcodeList2Data->Buffer      ());
		fOpcodeList2Tag.SetCount (preview.fOpcodeList2Data->LogicalSize ());

		directory.Add (&fOpcodeList2Tag);

		}

	if (preview.fImage->PixelType () == ttFloat)
		{

		for (uint32 j = 0; j < kMaxColorPlanes; j++)
			{
			fWhiteLevelData [j] = 32768;
			}

		directory.Add (&fWhiteLevelTag);

		}

	}

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

dng_raw_preview_tag_set::~dng_raw_preview_tag_set ()
	{

	}

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

dng_raw_preview::dng_raw_preview ()

	:	fImage				()
	,	fOpcodeList2Data	()
	,	fCompressionQuality (-1)
	,	fIFD				()

	{

	}

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

dng_raw_preview::~dng_raw_preview ()
	{

	}

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

dng_basic_tag_set * dng_raw_preview::AddTagSet (dng_tiff_directory &directory) const
	{

	fIFD.fNewSubFileType = sfPreviewImage;

	fIFD.fImageWidth  = fImage->Width  ();
	fIFD.fImageLength = fImage->Height ();

	fIFD.fSamplesPerPixel = fImage->Planes ();

	fIFD.fPhotometricInterpretation = piLinearRaw;

	if (fImage->PixelType () == ttFloat)
		{

		fIFD.fCompression = ccDeflate;

		fIFD.fCompressionQuality = fCompressionQuality;

		fIFD.fPredictor = cpFloatingPoint;

		for (uint32 j = 0; j < fIFD.fSamplesPerPixel; j++)
			{
			fIFD.fBitsPerSample [j] = 16;
			fIFD.fSampleFormat  [j] = sfFloatingPoint;
			}

		fIFD.FindTileSize (512 * 1024);

		}

	else
		{

		fIFD.fCompression = ccLossyJPEG;

		fIFD.fCompressionQuality = fCompressionQuality;

		fIFD.fBitsPerSample [0] = TagTypeSize (fImage->PixelType ()) * 8;

		for (uint32 j = 1; j < fIFD.fSamplesPerPixel; j++)
			{
			fIFD.fBitsPerSample [j] = fIFD.fBitsPerSample [0];
			}

		fIFD.FindTileSize (512 * 512 * fIFD.fSamplesPerPixel);

		}

	return new dng_raw_preview_tag_set (directory, *this, fIFD);

	}

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

void dng_raw_preview::WriteData (dng_host &host,
								 dng_image_writer &writer,
								 dng_basic_tag_set &basic,
								 dng_stream &stream) const
	{

	writer.WriteImage (host,
					   fIFD,
					   basic,
					   stream,
				       *fImage.Get ());

	}

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

dng_mask_preview::dng_mask_preview ()

	:	fImage				()
	,	fCompressionQuality (-1)
	,	fIFD				()

	{

	}

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

dng_mask_preview::~dng_mask_preview ()
	{

	}

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

dng_basic_tag_set * dng_mask_preview::AddTagSet (dng_tiff_directory &directory) const
	{

	fIFD.fNewSubFileType = sfPreviewMask;

	fIFD.fImageWidth  = fImage->Width  ();
	fIFD.fImageLength = fImage->Height ();

	fIFD.fSamplesPerPixel = 1;

	fIFD.fPhotometricInterpretation = piTransparencyMask;

	fIFD.fCompression = ccDeflate;
	fIFD.fPredictor   = cpHorizontalDifference;

	fIFD.fCompressionQuality = fCompressionQuality;

	fIFD.fBitsPerSample [0] = TagTypeSize (fImage->PixelType ()) * 8;

	fIFD.FindTileSize (512 * 512 * fIFD.fSamplesPerPixel);

	return new dng_basic_tag_set (directory, fIFD);

	}

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

void dng_mask_preview::WriteData (dng_host &host,
								  dng_image_writer &writer,
								  dng_basic_tag_set &basic,
								  dng_stream &stream) const
	{

	writer.WriteImage (host,
					   fIFD,
					   basic,
					   stream,
				       *fImage.Get ());

	}

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

dng_preview_list::dng_preview_list ()

	:	fCount (0)

	{

	}

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

dng_preview_list::~dng_preview_list ()
	{

	}

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

void dng_preview_list::Append (AutoPtr<dng_preview> &preview)
	{

	if (preview.Get ())
		{

		DNG_ASSERT (fCount < kMaxDNGPreviews, "DNG preview list overflow");

		if (fCount < kMaxDNGPreviews)
			{

			fPreview [fCount++] . Reset (preview.Release ());

			}

		}

	}

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