| /*****************************************************************************/ |
| // 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 (); |
| } |
| |
| } |
| |
| } |
| |
| } |
| |
| } |
| |
| } |
| |
| /*****************************************************************************/ |
