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

/*****************************************************************************/
// Copyright 2006-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_linearization_info.cpp#1 $ */
/* $DateTime: 2012/05/30 13:28:51 $ */
/* $Change: 832332 $ */
/* $Author: tknoll $ */

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

#include "dng_linearization_info.h"

#include "dng_area_task.h"
#include "dng_exceptions.h"
#include "dng_host.h"
#include "dng_image.h"
#include "dng_info.h"
#include "dng_negative.h"
#include "dng_pixel_buffer.h"
#include "dng_safe_arithmetic.h"
#include "dng_tag_types.h"
#include "dng_tile_iterator.h"
#include "dng_utils.h"

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

class dng_linearize_plane
	{

	private:

		const dng_image & fSrcImage;
		      dng_image & fDstImage;

		uint32 fPlane;

		dng_rect fActiveArea;

		uint32 fSrcPixelType;
		uint32 fDstPixelType;

		bool fReal32;

		real32 fScale;

		AutoPtr<dng_memory_block> fScale_buffer;

		uint32 fBlack_2D_rows;
		uint32 fBlack_2D_cols;

		AutoPtr<dng_memory_block> fBlack_2D_buffer;

		uint32 fBlack_1D_rows;

		AutoPtr<dng_memory_block> fBlack_1D_buffer;

	public:

		dng_linearize_plane (dng_host &host,
							 dng_linearization_info &info,
							 const dng_image &srcImage,
							 dng_image &dstImage,
							 uint32 plane);

		~dng_linearize_plane ();

		void Process (const dng_rect &tile);

	};

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

dng_linearize_plane::dng_linearize_plane (dng_host &host,
										  dng_linearization_info &info,
										  const dng_image &srcImage,
										  dng_image &dstImage,
										  uint32 plane)

	:	fSrcImage (srcImage)
	,	fDstImage (dstImage)
	,	fPlane (plane)
	,	fActiveArea (info.fActiveArea)
	,	fSrcPixelType (srcImage.PixelType ())
	,	fDstPixelType (dstImage.PixelType ())
	,	fReal32 (false)
	,	fScale (0.0f)
	,	fScale_buffer ()
	,	fBlack_2D_rows (0)
	,	fBlack_2D_cols (0)
	,	fBlack_2D_buffer ()
	,	fBlack_1D_rows (0)
	,	fBlack_1D_buffer ()

	{

	uint32 j;
	uint32 k;

	// Make sure the source pixel type is supported.

	if (fSrcPixelType != ttByte  &&
		fSrcPixelType != ttShort &&
		fSrcPixelType != ttLong  &&
		fSrcPixelType != ttFloat)
		{

		DNG_REPORT ("Unsupported source pixel type");

		ThrowProgramError ();

		}

	if (fDstPixelType != ttShort &&
		fDstPixelType != ttFloat)
		{

		DNG_REPORT ("Unsupported destination pixel type");

		ThrowProgramError ();

		}

	if (fSrcPixelType == ttFloat &&
		fDstPixelType != ttFloat)
		{

		DNG_REPORT ("Cannot convert floating point stage1 to non-floating stage2");

		ThrowProgramError ();

		}

	// Are we using floating point math?

	fReal32 = (fSrcPixelType == ttLong ||
			   fDstPixelType == ttFloat);

	// Find the scale for this plane.

	real64 maxBlack = info.MaxBlackLevel (plane);

	real64 minRange = info.fWhiteLevel [plane] - maxBlack;

	if (minRange <= 0.0)
		{
		ThrowBadFormat ();
		}

	real64 scale = 1.0 / minRange;

	fScale = (real32) scale;

	// Calculate two-dimensional black pattern, if any.

	if (info.fBlackDeltaH.Get ())
		{

		fBlack_2D_rows = info.fBlackLevelRepeatRows;
		fBlack_2D_cols = info.fActiveArea.W ();

		}

	else if (info.fBlackLevelRepeatCols > 1)
		{

		fBlack_2D_rows = info.fBlackLevelRepeatRows;
		fBlack_2D_cols = info.fBlackLevelRepeatCols;

		}

	if (fBlack_2D_rows)
		{

		fBlack_2D_buffer.Reset (host.Allocate (
			SafeUint32Mult (fBlack_2D_rows, fBlack_2D_cols, 4)));

		for (j = 0; j < fBlack_2D_rows; j++)
			{

			for (k = 0;  k < fBlack_2D_cols; k++)
				{

				real64 x = info.fBlackLevel [j]
											[k % info.fBlackLevelRepeatCols]
											[plane];

				if (info.fBlackDeltaH.Get ())
					{

					x += info.fBlackDeltaH->Buffer_real64 () [k];

					}

				x *= scale;

				uint32 index = j * fBlack_2D_cols + k;

				if (fReal32)
					{

					fBlack_2D_buffer->Buffer_real32 () [index] = (real32) x;

					}

				else
					{

					x *= 0x0FFFF * 256.0;

					int32 y = Round_int32 (x);

					fBlack_2D_buffer->Buffer_int32 () [index] = y;

					}

				}

			}

		}

	// Calculate one-dimensional (per row) black pattern, if any.

	if (info.fBlackDeltaV.Get ())
		{

		fBlack_1D_rows = info.fActiveArea.H ();

		}

	else if (fBlack_2D_rows == 0 &&
			 (info.fBlackLevelRepeatRows > 1 || fSrcPixelType != ttShort))
		{

		fBlack_1D_rows = info.fBlackLevelRepeatRows;

		}

	if (fBlack_1D_rows)
		{

		fBlack_1D_buffer.Reset (host.Allocate (
			SafeUint32Mult(fBlack_1D_rows, 4)));

		bool allZero = true;

		for (j = 0; j < fBlack_1D_rows; j++)
			{

			real64 x = 0.0;

			if (fBlack_2D_rows == 0)
				{

				x = info.fBlackLevel [j % info.fBlackLevelRepeatRows]
									 [0]
									 [plane];

				}

			if (info.fBlackDeltaV.Get ())
				{

				x += info.fBlackDeltaV->Buffer_real64 () [j];

				}

			allZero = allZero && (x == 0.0);

			x *= scale;

			if (fReal32)
				{

				fBlack_1D_buffer->Buffer_real32 () [j] = (real32) x;

				}

			else
				{

				x *= 0x0FFFF * 256.0;

				int32 y = Round_int32 (x);

				fBlack_1D_buffer->Buffer_int32 () [j] = y;

				}

			}

		if (allZero)
			{

			fBlack_1D_rows = 0;

			fBlack_1D_buffer.Reset ();

			}

		}

	// Calculate scale table, if any.

	if (fSrcPixelType != ttLong &&
		fSrcPixelType != ttFloat)
		{

		// Find linearization table, if any.

		uint16 *lut = NULL;

		uint32 lutEntries = 0;

		if (info.fLinearizationTable.Get ())
			{

			lut = info.fLinearizationTable->Buffer_uint16 ();

			lutEntries = info.fLinearizationTable->LogicalSize () >> 1;

			}

		// If the black level does not vary from pixel to pixel, then
		// the entire process can be a single LUT.

		if (fBlack_1D_rows == 0 &&
		    fBlack_2D_rows == 0)
			{

			fScale_buffer.Reset (host.Allocate (0x10000 *
											    TagTypeSize (fDstPixelType)));

			for (j = 0; j < 0x10000; j++)
				{

				uint32 x = j;

				// Apply linearization table, if any.

				if (lut)
					{

					x = Min_uint32 (x, lutEntries - 1);

					x = lut [x];

					}

				// Subtract constant black level.

				real64 y = x - info.fBlackLevel [0] [0] [plane];

				// Apply scale.

				y *= scale;

				// We can burn in the clipping also.

				y = Pin_real64 (0.0, y, 1.0);

				// Store output value in table.

				if (fDstPixelType == ttShort)
					{

					uint16 z = (uint16) Round_uint32 (y * 0x0FFFF);

					fScale_buffer->Buffer_uint16 () [j] = z;

					}

				else
					{

					fScale_buffer->Buffer_real32 () [j] = (real32) y;

					}

				}

			}

		// Else we only do the scaling operation in the scale table.

		else
			{

			fScale_buffer.Reset (host.Allocate (0x10000 * 4));

			for (j = 0; j < 0x10000; j++)
				{

				uint32 x = j;

				// Apply linearization table, if any.

				if (lut)
					{

					x = Min_uint32 (x, lutEntries - 1);

					x = lut [x];

					}

				// Apply scale.

				real64 y = x * scale;

				// Store output value in table.

				if (fReal32)
					{

					fScale_buffer->Buffer_real32 () [j] = (real32) y;

					}

				else
					{

					int32 z = Round_int32 (y * 0x0FFFF * 256.0);

					fScale_buffer->Buffer_int32 () [j] = z;

					}

				}

			}

		}

	}

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

dng_linearize_plane::~dng_linearize_plane ()
	{

	}

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

void dng_linearize_plane::Process (const dng_rect &srcTile)
	{

	// Process tile.

	dng_rect dstTile = srcTile - fActiveArea.TL ();

	dng_const_tile_buffer srcBuffer (fSrcImage, srcTile);
	dng_dirty_tile_buffer dstBuffer (fDstImage, dstTile);

	int32 sStep = srcBuffer.fColStep;
	int32 dStep = dstBuffer.fColStep;

	uint32 count = srcTile.W ();

	uint32 dstCol = dstTile.l;

	uint32 rows = srcTile.H ();

	for (uint32 row = 0; row < rows; row++)
		{

		uint32 dstRow = dstTile.t + row;

		const void *sPtr = srcBuffer.ConstPixel (srcTile.t + row,
											     srcTile.l,
											     fPlane);

		void *dPtr = dstBuffer.DirtyPixel (dstRow,
										   dstCol,
										   fPlane);

		// Floating point source case.

		if (fSrcPixelType == ttFloat)
			{

			real32 scale = fScale;

			const real32 *srcPtr = (const real32 *) sPtr;

			real32 *dstPtr = (real32 *) dPtr;

			// Optimize scale only case, which is the most common.

			if (fBlack_1D_rows == 0 &&
				fBlack_2D_cols == 0)
				{

				for (uint32 j = 0; j < count; j++)
					{

					*dstPtr = (*srcPtr) * scale;

					srcPtr += sStep;
					dstPtr += dStep;

					}

				}

			else
				{

				real32 b1 = 0.0f;

				if (fBlack_1D_rows)
					{
					b1 = fBlack_1D_buffer->Buffer_real32 () [dstRow % fBlack_1D_rows];
					}

				const real32 *b2 = NULL;

				uint32 b2_count = fBlack_2D_cols;
				uint32 b2_phase = 0;

				if (b2_count)
					{

					b2 = fBlack_2D_buffer->Buffer_real32 () +
						 b2_count * (dstRow % fBlack_2D_rows);

					b2_phase = dstCol % b2_count;

					}

				for (uint32 j = 0; j < count; j++)
					{

					real32 x = (*srcPtr) * scale - b1;

					if (b2_count)
						{

						x -= b2 [b2_phase];

						if (++b2_phase == b2_count)
							{
							b2_phase = 0;
							}

						}

					*dstPtr = x;

					srcPtr += sStep;
					dstPtr += dStep;

					}

				}

			}

		// Simple LUT case.

		else if (fBlack_1D_rows == 0 &&
				 fBlack_2D_rows == 0 && fSrcPixelType != ttLong)
			{

			if (fDstPixelType == ttShort)
				{

				const uint16 *lut = fScale_buffer->Buffer_uint16 ();

				uint16 *dstPtr = (uint16 *) dPtr;

				if (fSrcPixelType == ttByte)
					{

					const uint8 *srcPtr = (const uint8 *) sPtr;

					for (uint32 j = 0; j < count; j++)
						{

						*dstPtr = lut [*srcPtr];

						srcPtr += sStep;
						dstPtr += dStep;

						}

					}

				else
					{

					const uint16 *srcPtr = (const uint16 *) sPtr;

					for (uint32 j = 0; j < count; j++)
						{

						*dstPtr = lut [*srcPtr];

						srcPtr += sStep;
						dstPtr += dStep;

						}

					}

				}

			else
				{

				const real32 *lut = fScale_buffer->Buffer_real32 ();

				real32 *dstPtr = (real32 *) dPtr;

				if (fSrcPixelType == ttByte)
					{

					const uint8 *srcPtr = (const uint8 *) sPtr;

					for (uint32 j = 0; j < count; j++)
						{

						*dstPtr = lut [*srcPtr];

						srcPtr += sStep;
						dstPtr += dStep;

						}

					}

				else
					{

					const uint16 *srcPtr = (const uint16 *) sPtr;

					for (uint32 j = 0; j < count; j++)
						{

						*dstPtr = lut [*srcPtr];

						srcPtr += sStep;
						dstPtr += dStep;

						}

					}

				}

			}

		// Integer math case.

		else if (!fReal32)
			{

			const int32 *lut = fScale_buffer->Buffer_int32 ();

			int32 b1 = 0;

			if (fBlack_1D_rows)
				{
				b1 = fBlack_1D_buffer->Buffer_int32 () [dstRow % fBlack_1D_rows];
				}

			const int32 *b2 = NULL;

			uint32 b2_count = fBlack_2D_cols;
			uint32 b2_phase = 0;

			if (b2_count)
				{

				b2 = fBlack_2D_buffer->Buffer_int32 () +
					 b2_count * (dstRow % fBlack_2D_rows);

				b2_phase = dstCol % b2_count;

				}

			uint16 *dstPtr = (uint16 *) dPtr;

			b1 -= 128;		// Rounding for 8 bit shift

			if (fSrcPixelType == ttByte)
				{

				const uint8 *srcPtr = (const uint8 *) sPtr;

				for (uint32 j = 0; j < count; j++)
					{

					int32 x = lut [*srcPtr] - b1;

					if (b2_count)
						{

						x -= b2 [b2_phase];

						if (++b2_phase == b2_count)
							{
							b2_phase = 0;
							}

						}

					x >>= 8;

					*dstPtr = Pin_uint16 (x);

					srcPtr += sStep;
					dstPtr += dStep;

					}

				}

			else
				{

				const uint16 *srcPtr = (const uint16 *) sPtr;

				for (uint32 j = 0; j < count; j++)
					{

					int32 x = lut [*srcPtr] - b1;

					if (b2_count)
						{

						x -= b2 [b2_phase];

						if (++b2_phase == b2_count)
							{
							b2_phase = 0;
							}

						}

					x >>= 8;

					*dstPtr = Pin_uint16 (x);

					srcPtr += sStep;
					dstPtr += dStep;

					}

				}

			}

		// Floating point math cases.

		else
			{

			real32 b1 = 0.0f;

			if (fBlack_1D_rows)
				{
				b1 = fBlack_1D_buffer->Buffer_real32 () [dstRow % fBlack_1D_rows];
				}

			const real32 *b2 = NULL;

			uint32 b2_count = fBlack_2D_cols;
			uint32 b2_phase = 0;

			if (b2_count)
				{

				b2 = fBlack_2D_buffer->Buffer_real32 () +
					 b2_count * (dstRow % fBlack_2D_rows);

				b2_phase = dstCol % b2_count;

				}

			// Case 1: uint8/uint16 -> real32

			if (fSrcPixelType != ttLong)
				{

				const real32 *lut = fScale_buffer->Buffer_real32 ();

				real32 *dstPtr = (real32 *) dPtr;

				if (fSrcPixelType == ttByte)
					{

					const uint8 *srcPtr = (const uint8 *) sPtr;

					for (uint32 j = 0; j < count; j++)
						{

						real32 x = lut [*srcPtr] - b1;

						if (b2_count)
							{

							x -= b2 [b2_phase];

							if (++b2_phase == b2_count)
								{
								b2_phase = 0;
								}

							}

						x = Pin_real32 (0.0f, x, 1.0f);

						*dstPtr = x;

						srcPtr += sStep;
						dstPtr += dStep;

						}

					}

				else
					{

					const uint16 *srcPtr = (const uint16 *) sPtr;

					for (uint32 j = 0; j < count; j++)
						{

						real32 x = lut [*srcPtr] - b1;

						if (b2_count)
							{

							x -= b2 [b2_phase];

							if (++b2_phase == b2_count)
								{
								b2_phase = 0;
								}

							}

						x = Pin_real32 (0.0f, x, 1.0f);

						*dstPtr = x;

						srcPtr += sStep;
						dstPtr += dStep;

						}

					}

				}

			// Otherwise source is uint32

			else
				{

				real32 scale = fScale;

				const uint32 *srcPtr = (const uint32 *) sPtr;

				// Case 2: uint32 -> real32

				if (fDstPixelType == ttFloat)
					{

					real32 *dstPtr = (real32 *) dPtr;

					for (uint32 j = 0; j < count; j++)
						{

						real32 x = ((real32) *srcPtr) * scale - b1;

						if (b2_count)
							{

							x -= b2 [b2_phase];

							if (++b2_phase == b2_count)
								{
								b2_phase = 0;
								}

							}

						x = Pin_real32 (0.0f, x, 1.0f);

						*dstPtr = x;

						srcPtr += sStep;
						dstPtr += dStep;

						}

					}

				// Case 3: uint32 -> uint16

				else
					{

					uint16 *dstPtr = (uint16 *) dPtr;

					real32 dstScale = (real32) 0x0FFFF;

					for (uint32 j = 0; j < count; j++)
						{

						real32 x = ((real32) *srcPtr) * scale - b1;

						if (b2_count)
							{

							x -= b2 [b2_phase];

							if (++b2_phase == b2_count)
								{
								b2_phase = 0;
								}

							}

						x = Pin_real32 (0.0f, x, 1.0f);

						*dstPtr = (uint16) (x * dstScale + 0.5f);

						srcPtr += sStep;
						dstPtr += dStep;

						}

					}

				}

			}

		}

	}

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

class dng_linearize_image: public dng_area_task
	{

	private:

		const dng_image & fSrcImage;
		      dng_image & fDstImage;

		dng_rect fActiveArea;

		AutoPtr<dng_linearize_plane> fPlaneTask [kMaxColorPlanes];

	public:

		dng_linearize_image (dng_host &host,
							 dng_linearization_info &info,
							 const dng_image &srcImage,
							 dng_image &dstImage);

		virtual ~dng_linearize_image ();

		virtual dng_rect RepeatingTile1 () const;

		virtual dng_rect RepeatingTile2 () const;

		virtual void Process (uint32 threadIndex,
							  const dng_rect &tile,
							  dng_abort_sniffer *sniffer);

	};

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

dng_linearize_image::dng_linearize_image (dng_host &host,
										  dng_linearization_info &info,
										  const dng_image &srcImage,
										  dng_image &dstImage)

	:	fSrcImage   (srcImage)
	,	fDstImage   (dstImage)
	,	fActiveArea (info.fActiveArea)

	{

	// Build linearization table for each plane.

	for (uint32 plane = 0; plane < srcImage.Planes (); plane++)
		{

		fPlaneTask [plane].Reset (new dng_linearize_plane (host,
														   info,
														   srcImage,
														   dstImage,
														   plane));

		}

	// Adjust maximum tile size.

	fMaxTileSize = dng_point (1024, 1024);

	}

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

dng_linearize_image::~dng_linearize_image ()
	{

	}

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

dng_rect dng_linearize_image::RepeatingTile1 () const
	{

	return fSrcImage.RepeatingTile ();

	}

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

dng_rect dng_linearize_image::RepeatingTile2 () const
	{

	return fDstImage.RepeatingTile () + fActiveArea.TL ();

	}

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

void dng_linearize_image::Process (uint32 /* threadIndex */,
							  	   const dng_rect &srcTile,
							  	   dng_abort_sniffer * /* sniffer */)
	{

	// Process each plane.

	for (uint32 plane = 0; plane < fSrcImage.Planes (); plane++)
		{

		fPlaneTask [plane]->Process (srcTile);

		}

	}

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

dng_linearization_info::dng_linearization_info ()

	:	fActiveArea ()
	,	fMaskedAreaCount (0)
	,	fLinearizationTable ()
	,	fBlackLevelRepeatRows (1)
	,	fBlackLevelRepeatCols (1)
	,	fBlackDeltaH ()
	,	fBlackDeltaV ()
	,	fBlackDenom (256)

	{

	uint32 j;
	uint32 k;
	uint32 n;

	for (j = 0; j < kMaxBlackPattern; j++)
		for (k = 0; k < kMaxBlackPattern; k++)
			for (n = 0; n < kMaxSamplesPerPixel; n++)
				{
				fBlackLevel [j] [k] [n] = 0.0;
				}

	for (n = 0; n < kMaxSamplesPerPixel; n++)
		{
		fWhiteLevel [n] = 65535.0;
		}

	}

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

dng_linearization_info::~dng_linearization_info ()
	{

	}

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

void dng_linearization_info::RoundBlacks ()
	{

	uint32 j;
	uint32 k;
	uint32 n;

	real64 maxAbs = 0.0;

	for (j = 0; j < fBlackLevelRepeatRows; j++)
		for (k = 0; k < fBlackLevelRepeatCols; k++)
			for (n = 0; n < kMaxSamplesPerPixel; n++)
				{

				maxAbs = Max_real64 (maxAbs,
									 Abs_real64 (fBlackLevel [j] [k] [n]));

				}

	uint32 count = RowBlackCount ();

	for (j = 0; j < count; j++)
		{

		maxAbs = Max_real64 (maxAbs,
							 Abs_real64 (fBlackDeltaV->Buffer_real64 () [j]));

		}

	count = ColumnBlackCount ();

	for (j = 0; j < count; j++)
		{

		maxAbs = Max_real64 (maxAbs,
							 Abs_real64 (fBlackDeltaH->Buffer_real64 () [j]));


		}

	fBlackDenom = 256;

	while (fBlackDenom > 1 && (maxAbs * fBlackDenom) >= 30000.0 * 65536.0)
		{
		fBlackDenom >>= 1;
		}

	for (j = 0; j < fBlackLevelRepeatRows; j++)
		for (k = 0; k < fBlackLevelRepeatCols; k++)
			for (n = 0; n < kMaxSamplesPerPixel; n++)
				{

				fBlackLevel [j] [k] [n] = BlackLevel (j, k, n).As_real64 ();

				}

	count = RowBlackCount ();

	for (j = 0; j < count; j++)
		{

		fBlackDeltaV->Buffer_real64 () [j] = RowBlack (j).As_real64 ();

		}

	count = ColumnBlackCount ();

	for (j = 0; j < count; j++)
		{

		fBlackDeltaH->Buffer_real64 () [j] = ColumnBlack (j).As_real64 ();

		}

	}

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

void dng_linearization_info::Parse (dng_host &host,
								    dng_stream &stream,
								    dng_info &info)
	{

	uint32 j;
	uint32 k;
	uint32 n;

	// Find main image IFD.

	dng_ifd &rawIFD = *info.fIFD [info.fMainIndex].Get ();

	// Copy active area.

	fActiveArea = rawIFD.fActiveArea;

	// Copy masked areas.

	fMaskedAreaCount = rawIFD.fMaskedAreaCount;

	for (j = 0; j < fMaskedAreaCount; j++)
		{
		fMaskedArea [j] = rawIFD.fMaskedArea [j];
		}

	// Read linearization LUT.

	if (rawIFD.fLinearizationTableCount)
		{

		uint32 size = SafeUint32Mult (rawIFD.fLinearizationTableCount,
									  static_cast<uint32> (sizeof (uint16)));

		fLinearizationTable.Reset (host.Allocate (size));

		uint16 *table = fLinearizationTable->Buffer_uint16 ();

		stream.SetReadPosition (rawIFD.fLinearizationTableOffset);

		for (j = 0; j < rawIFD.fLinearizationTableCount; j++)
			{
			table [j] = stream.Get_uint16 ();
			}

		}

	// Copy black level pattern.

	fBlackLevelRepeatRows = rawIFD.fBlackLevelRepeatRows;
	fBlackLevelRepeatCols = rawIFD.fBlackLevelRepeatCols;

	for (j = 0; j < kMaxBlackPattern; j++)
		for (k = 0; k < kMaxBlackPattern; k++)
			for (n = 0; n < kMaxSamplesPerPixel; n++)
				{
				fBlackLevel [j] [k] [n] = rawIFD.fBlackLevel [j] [k] [n];
				}

	// Read BlackDeltaH.

	if (rawIFD.fBlackLevelDeltaHCount)
		{

		uint32 size = SafeUint32Mult (rawIFD.fBlackLevelDeltaHCount,
									  static_cast<uint32> (sizeof (real64)));

		fBlackDeltaH.Reset (host.Allocate (size));

		real64 *blacks = fBlackDeltaH->Buffer_real64 ();

		stream.SetReadPosition (rawIFD.fBlackLevelDeltaHOffset);

		for (j = 0; j < rawIFD.fBlackLevelDeltaHCount; j++)
			{
			blacks [j] = stream.TagValue_real64 (rawIFD.fBlackLevelDeltaHType);
			}

		}

	// Read BlackDeltaV.

	if (rawIFD.fBlackLevelDeltaVCount)
		{

		uint32 size = SafeUint32Mult (rawIFD.fBlackLevelDeltaVCount,
									  static_cast<uint32> (sizeof (real64)));

		fBlackDeltaV.Reset (host.Allocate (size));

		real64 *blacks = fBlackDeltaV->Buffer_real64 ();

		stream.SetReadPosition (rawIFD.fBlackLevelDeltaVOffset);

		for (j = 0; j < rawIFD.fBlackLevelDeltaVCount; j++)
			{
			blacks [j] = stream.TagValue_real64 (rawIFD.fBlackLevelDeltaVType);
			}

		}

	// Copy white level.

	for (n = 0; n < kMaxSamplesPerPixel; n++)
		{
		fWhiteLevel [n] = rawIFD.fWhiteLevel [n];
		}

	// Round off black levels.

	RoundBlacks ();

	}

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

void dng_linearization_info::PostParse (dng_host & /* host */,
										dng_negative &negative)
	{

	if (fActiveArea.IsEmpty ())
		{

		fActiveArea = negative.Stage1Image ()->Bounds ();

		}

	}

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

real64 dng_linearization_info::MaxBlackLevel (uint32 plane) const
	{

	uint32 j;
	uint32 k;

	// Find maximum value of fBlackDeltaH for each phase of black pattern.

	real64 maxDeltaH [kMaxBlackPattern];

	for (j = 0; j < fBlackLevelRepeatCols; j++)
		{
		maxDeltaH [j] = 0.0;
		}

	if (fBlackDeltaH.Get ())
		{

		real64 *table = fBlackDeltaH->Buffer_real64 ();

		uint32 entries = fBlackDeltaH->LogicalSize () / (uint32) sizeof (table [0]);

		for (j = 0; j < entries; j++)
			{

			real64 &entry = maxDeltaH [j % fBlackLevelRepeatCols];

			if (j < fBlackLevelRepeatCols)
				{
				entry = table [j];
				}
			else
				{
				entry = Max_real64 (entry, table [j]);
				}

			}

		}

	// Find maximum value of fBlackDeltaV for each phase of black pattern.

	real64 maxDeltaV [kMaxBlackPattern];

	for (j = 0; j < fBlackLevelRepeatRows; j++)
		{
		maxDeltaV [j] = 0.0;
		}

	if (fBlackDeltaV.Get ())
		{

		real64 *table = fBlackDeltaV->Buffer_real64 ();

		uint32 entries = fBlackDeltaV->LogicalSize () / (uint32) sizeof (table [0]);

		for (j = 0; j < entries; j++)
			{

			real64 &entry = maxDeltaV [j % fBlackLevelRepeatRows];

			if (j < fBlackLevelRepeatRows)
				{
				entry = table [j];
				}
			else
				{
				entry = Max_real64 (entry, table [j]);
				}

			}

		}

	// Now scan the pattern and find the maximum value after row and column
	// deltas.

	real64 maxBlack = 0.0;

	for (j = 0; j < fBlackLevelRepeatRows; j++)
		{

		for (k = 0; k < fBlackLevelRepeatCols; k++)
			{

			real64 black = fBlackLevel [j] [k] [plane];

			black += maxDeltaH [k];
			black += maxDeltaV [j];

			if (j == 0 && k == 0)
				{
				maxBlack = black;
				}
			else
				{
				maxBlack = Max_real64 (maxBlack, black);
				}

			}

		}

	return maxBlack;

	}

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

void dng_linearization_info::Linearize (dng_host &host,
										const dng_image &srcImage,
										dng_image &dstImage)
	{

	dng_linearize_image processor (host,
								   *this,
								   srcImage,
								   dstImage);

	host.PerformAreaTask (processor,
						  fActiveArea);

	}

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

dng_urational dng_linearization_info::BlackLevel (uint32 row,
												  uint32 col,
												  uint32 plane) const
	{

	dng_urational r;

	r.Set_real64 (fBlackLevel [row] [col] [plane], fBlackDenom);

	return r;

	}

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

uint32 dng_linearization_info::RowBlackCount () const
	{

	if (fBlackDeltaV.Get ())
		{

		return fBlackDeltaV->LogicalSize () >> 3;

		}

	return 0;

	}

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

dng_srational dng_linearization_info::RowBlack (uint32 row) const
	{

	if (fBlackDeltaV.Get ())
		{

		dng_srational r;

		r.Set_real64 (fBlackDeltaV->Buffer_real64 () [row], fBlackDenom);

		return r;

		}

	return dng_srational (0, 1);

	}

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

uint32 dng_linearization_info::ColumnBlackCount () const
	{

	if (fBlackDeltaH.Get ())
		{

		return fBlackDeltaH->LogicalSize () >> 3;

		}

	return 0;

	}

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

dng_srational dng_linearization_info::ColumnBlack (uint32 col) const
	{

	if (fBlackDeltaH.Get ())
		{

		dng_srational r;

		r.Set_real64 (fBlackDeltaH->Buffer_real64 () [col], fBlackDenom);

		return r;

		}

	return dng_srational (0, 1);

	}

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