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

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

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

#include "dng_gain_map.h"

#include "dng_exceptions.h"
#include "dng_globals.h"
#include "dng_host.h"
#include "dng_pixel_buffer.h"
#include "dng_safe_arithmetic.h"
#include "dng_stream.h"
#include "dng_tag_values.h"

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

class dng_gain_map_interpolator
	{

	private:

		const dng_gain_map &fMap;

		dng_point_real64 fScale;
		dng_point_real64 fOffset;

		int32 fColumn;
		int32 fPlane;

		uint32 fRowIndex1;
		uint32 fRowIndex2;
		real32 fRowFract;

		int32 fResetColumn;

		real32 fValueBase;
		real32 fValueStep;
		real32 fValueIndex;

	public:

		dng_gain_map_interpolator (const dng_gain_map &map,
								   const dng_rect &mapBounds,
								   int32 row,
								   int32 column,
								   uint32 plane);

		real32 Interpolate () const
			{

			return fValueBase + fValueStep * fValueIndex;

			}

		void Increment ()
			{

			if (++fColumn >= fResetColumn)
				{

				ResetColumn ();

				}

			else
				{

				fValueIndex += 1.0f;

				}

			}

	private:

		real32 InterpolateEntry (uint32 colIndex);

		void ResetColumn ();

	};

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

dng_gain_map_interpolator::dng_gain_map_interpolator (const dng_gain_map &map,
													  const dng_rect &mapBounds,
													  int32 row,
													  int32 column,
													  uint32 plane)

	:	fMap (map)

	,	fScale (1.0 / mapBounds.H (),
				1.0 / mapBounds.W ())

	,	fOffset (0.5 - mapBounds.t,
				 0.5 - mapBounds.l)

	,	fColumn (column)
	,	fPlane  (plane)

	,	fRowIndex1 (0)
	,	fRowIndex2 (0)
	,	fRowFract  (0.0f)

	,	fResetColumn (0)

	,	fValueBase  (0.0f)
	,	fValueStep  (0.0f)
	,	fValueIndex (0.0f)

	{

	real64 rowIndexF = (fScale.v * (row + fOffset.v) -
						fMap.Origin ().v) / fMap.Spacing ().v;

	if (rowIndexF <= 0.0)
		{

		fRowIndex1 = 0;
		fRowIndex2 = 0;

		fRowFract = 0.0f;

		}

	else
		{

		if (fMap.Points ().v < 1)
			{
			ThrowProgramError ("Empty gain map");
			}
		uint32 lastRow = static_cast<uint32> (fMap.Points ().v - 1);

		if (rowIndexF >= static_cast<real64> (lastRow))
			{

			fRowIndex1 = lastRow;
			fRowIndex2 = fRowIndex1;

			fRowFract = 0.0f;

			}

		else
			{

			// If we got here, we know that rowIndexF can safely be converted to
			// a uint32 and that static_cast<uint32> (rowIndexF) < lastRow. This
			// implies fRowIndex2 <= lastRow below.
			fRowIndex1 = static_cast<uint32> (rowIndexF);
			fRowIndex2 = fRowIndex1 + 1;

			fRowFract = (real32) (rowIndexF - (real64) fRowIndex1);

			}

		}

	ResetColumn ();

	}

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

real32 dng_gain_map_interpolator::InterpolateEntry (uint32 colIndex)
	{

	return fMap.Entry (fRowIndex1, colIndex, fPlane) * (1.0f - fRowFract) +
		   fMap.Entry (fRowIndex2, colIndex, fPlane) * (       fRowFract);

	}

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

void dng_gain_map_interpolator::ResetColumn ()
	{

	real64 colIndexF = ((fScale.h * (fColumn + fOffset.h)) -
						fMap.Origin ().h) / fMap.Spacing ().h;

	if (colIndexF <= 0.0)
		{

		fValueBase = InterpolateEntry (0);

		fValueStep = 0.0f;

		fResetColumn = (int32) ceil (fMap.Origin ().h / fScale.h - fOffset.h);

		}

	else
		{

		if (fMap.Points ().h < 1)
			{
			ThrowProgramError ("Empty gain map");
			}
		uint32 lastCol = static_cast<uint32> (fMap.Points ().h - 1);

		if (colIndexF >= static_cast<real64> (lastCol))
			{

			fValueBase = InterpolateEntry (lastCol);

			fValueStep = 0.0f;

			fResetColumn = 0x7FFFFFFF;

			}

		else
			{

			// If we got here, we know that colIndexF can safely be converted to
			// a uint32 and that static_cast<uint32> (colIndexF) < lastCol. This
			// implies colIndex + 1 <= lastCol, i.e. the argument to
			// InterpolateEntry() below is valid.
			uint32 colIndex = static_cast<uint32> (colIndexF);
			real64 base  = InterpolateEntry (colIndex);
			real64 delta = InterpolateEntry (colIndex + 1) - base;

			fValueBase = (real32) (base + delta * (colIndexF - (real64) colIndex));

			fValueStep = (real32) ((delta * fScale.h) / fMap.Spacing ().h);

			fResetColumn = (int32) ceil (((colIndex + 1) * fMap.Spacing ().h +
										  fMap.Origin ().h) / fScale.h - fOffset.h);

			}

		}

	fValueIndex = 0.0f;

	}

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

dng_gain_map::dng_gain_map (dng_memory_allocator &allocator,
							const dng_point &points,
							const dng_point_real64 &spacing,
							const dng_point_real64 &origin,
							uint32 planes)

	:	fPoints  (points)
	,	fSpacing (spacing)
	,	fOrigin  (origin)
	,	fPlanes  (planes)

	,	fRowStep (SafeUint32Mult(planes, points.h))

	,	fBuffer ()

	{

	fBuffer.Reset (allocator.Allocate (
		ComputeBufferSize (ttFloat, fPoints, fPlanes, pad16Bytes)));

	}

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

real32 dng_gain_map::Interpolate (int32 row,
								  int32 col,
								  uint32 plane,
								  const dng_rect &bounds) const
	{

	dng_gain_map_interpolator interp (*this,
									  bounds,
									  row,
									  col,
									  plane);

	return interp.Interpolate ();

	}

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

uint32 dng_gain_map::PutStreamSize () const
	{

	return 44 + fPoints.v * fPoints.h * fPlanes * 4;

	}

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

void dng_gain_map::PutStream (dng_stream &stream) const
	{

	stream.Put_uint32 (fPoints.v);
	stream.Put_uint32 (fPoints.h);

	stream.Put_real64 (fSpacing.v);
	stream.Put_real64 (fSpacing.h);

	stream.Put_real64 (fOrigin.v);
	stream.Put_real64 (fOrigin.h);

	stream.Put_uint32 (fPlanes);

	for (int32 rowIndex = 0; rowIndex < fPoints.v; rowIndex++)
		{

		for (int32 colIndex = 0; colIndex < fPoints.h; colIndex++)
			{

			for (uint32 plane = 0; plane < fPlanes; plane++)
				{

				stream.Put_real32 (Entry (rowIndex,
										  colIndex,
										  plane));

				}

			}

		}

	}

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

dng_gain_map * dng_gain_map::GetStream (dng_host &host,
										dng_stream &stream)
	{

	dng_point mapPoints;

	mapPoints.v = stream.Get_uint32 ();
	mapPoints.h = stream.Get_uint32 ();

	dng_point_real64 mapSpacing;

	mapSpacing.v = stream.Get_real64 ();
	mapSpacing.h = stream.Get_real64 ();

	dng_point_real64 mapOrigin;

	mapOrigin.v = stream.Get_real64 ();
	mapOrigin.h = stream.Get_real64 ();

	uint32 mapPlanes = stream.Get_uint32 ();

	#if qDNGValidate

	if (gVerbose)
		{

		printf ("Points: v=%d, h=%d\n",
				(int) mapPoints.v,
				(int) mapPoints.h);

		printf ("Spacing: v=%.6f, h=%.6f\n",
				mapSpacing.v,
				mapSpacing.h);

		printf ("Origin: v=%.6f, h=%.6f\n",
				mapOrigin.v,
				mapOrigin.h);

		printf ("Planes: %u\n",
				(unsigned) mapPlanes);

		}

	#endif

	if (mapPoints.v == 1)
		{
		mapSpacing.v = 1.0;
		mapOrigin.v  = 0.0;
		}

	if (mapPoints.h == 1)
		{
		mapSpacing.h = 1.0;
		mapOrigin.h  = 0.0;
		}

	if (mapPoints.v < 1 ||
		mapPoints.h < 1 ||
		mapSpacing.v <= 0.0 ||
		mapSpacing.h <= 0.0 ||
		mapPlanes < 1)
		{
		ThrowBadFormat ();
		}

	AutoPtr<dng_gain_map> map (new dng_gain_map (host.Allocator (),
												 mapPoints,
												 mapSpacing,
												 mapOrigin,
												 mapPlanes));

	#if qDNGValidate

	uint32 linesPrinted = 0;
	uint32 linesSkipped = 0;

	#endif

	for (int32 rowIndex = 0; rowIndex < mapPoints.v; rowIndex++)
		{

		for (int32 colIndex = 0; colIndex < mapPoints.h; colIndex++)
			{

			for (uint32 plane = 0; plane < mapPlanes; plane++)
				{

				real32 x = stream.Get_real32 ();

				map->Entry (rowIndex, colIndex, plane) = x;

				#if qDNGValidate

				if (gVerbose)
					{

					if (linesPrinted < gDumpLineLimit)
						{

						printf ("    Map [%3u] [%3u] [%u] = %.4f\n",
								(unsigned) rowIndex,
								(unsigned) colIndex,
								(unsigned) plane,
								x);

						linesPrinted++;

						}

					else
						linesSkipped++;

					}

				#endif

				}

			}

		}

	#if qDNGValidate

	if (linesSkipped)
		{

		printf ("    ... %u map entries skipped\n", (unsigned) linesSkipped);

		}

	#endif

	return map.Release ();

	}

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

dng_opcode_GainMap::dng_opcode_GainMap (const dng_area_spec &areaSpec,
										AutoPtr<dng_gain_map> &gainMap)

	:	dng_inplace_opcode (dngOpcode_GainMap,
						    dngVersion_1_3_0_0,
						    kFlag_None)

	,	fAreaSpec (areaSpec)

	,	fGainMap ()

	{

	fGainMap.Reset (gainMap.Release ());

	}

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

dng_opcode_GainMap::dng_opcode_GainMap (dng_host &host,
										dng_stream &stream)

	:	dng_inplace_opcode (dngOpcode_GainMap,
							stream,
							"GainMap")

	,	fAreaSpec ()

	,	fGainMap ()

	{

	uint32 byteCount = stream.Get_uint32 ();

	uint64 startPosition = stream.Position ();

	fAreaSpec.GetData (stream);

	fGainMap.Reset (dng_gain_map::GetStream (host, stream));

	if (stream.Position () != startPosition + byteCount)
		{
		ThrowBadFormat ();
		}

	}

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

void dng_opcode_GainMap::PutData (dng_stream &stream) const
	{

	stream.Put_uint32 (dng_area_spec::kDataSize +
					   fGainMap->PutStreamSize ());

	fAreaSpec.PutData (stream);

	fGainMap->PutStream (stream);

	}

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

void dng_opcode_GainMap::ProcessArea (dng_negative & /* negative */,
									  uint32 /* threadIndex */,
									  dng_pixel_buffer &buffer,
									  const dng_rect &dstArea,
									  const dng_rect &imageBounds)
	{

	dng_rect overlap = fAreaSpec.Overlap (dstArea);

	if (overlap.NotEmpty ())
		{

		uint32 cols = overlap.W ();

		uint32 colPitch = fAreaSpec.ColPitch ();

		for (uint32 plane = fAreaSpec.Plane ();
			 plane < fAreaSpec.Plane () + fAreaSpec.Planes () &&
			 plane < buffer.Planes ();
			 plane++)
			{

			uint32 mapPlane = Min_uint32 (plane, fGainMap->Planes () - 1);

			for (int32 row = overlap.t; row < overlap.b; row += fAreaSpec.RowPitch ())
				{

				real32 *dPtr = buffer.DirtyPixel_real32 (row, overlap.l, plane);

				dng_gain_map_interpolator interp (*fGainMap,
												  imageBounds,
												  row,
												  overlap.l,
												  mapPlane);

				for (uint32 col = 0; col < cols; col += colPitch)
					{

					real32 gain = interp.Interpolate ();

					dPtr [col] = Min_real32 (dPtr [col] * gain, 1.0f);

					for (uint32 j = 0; j < colPitch; j++)
						{
						interp.Increment ();
						}

					}

				}

			}

		}

	}

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