| /*****************************************************************************/ |
| // 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_misc_opcodes.cpp#1 $ */ |
| /* $DateTime: 2012/05/30 13:28:51 $ */ |
| /* $Change: 832332 $ */ |
| /* $Author: tknoll $ */ |
| |
| /*****************************************************************************/ |
| |
| #include "dng_misc_opcodes.h" |
| |
| #include "dng_bottlenecks.h" |
| #include "dng_exceptions.h" |
| #include "dng_globals.h" |
| #include "dng_host.h" |
| #include "dng_image.h" |
| #include "dng_rect.h" |
| #include "dng_safe_arithmetic.h" |
| #include "dng_stream.h" |
| #include "dng_tag_values.h" |
| |
| /*****************************************************************************/ |
| |
| dng_opcode_TrimBounds::dng_opcode_TrimBounds (const dng_rect &bounds) |
| |
| : dng_opcode (dngOpcode_TrimBounds, |
| dngVersion_1_3_0_0, |
| kFlag_None) |
| |
| , fBounds (bounds) |
| |
| { |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| dng_opcode_TrimBounds::dng_opcode_TrimBounds (dng_stream &stream) |
| |
| : dng_opcode (dngOpcode_TrimBounds, |
| stream, |
| "TrimBounds") |
| |
| , fBounds () |
| |
| { |
| |
| if (stream.Get_uint32 () != 16) |
| { |
| ThrowBadFormat (); |
| } |
| |
| fBounds.t = stream.Get_int32 (); |
| fBounds.l = stream.Get_int32 (); |
| fBounds.b = stream.Get_int32 (); |
| fBounds.r = stream.Get_int32 (); |
| |
| if (fBounds.IsEmpty ()) |
| { |
| ThrowBadFormat (); |
| } |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| printf ("Bounds: t=%d, l=%d, b=%d, r=%d\n", |
| (int) fBounds.t, |
| (int) fBounds.l, |
| (int) fBounds.b, |
| (int) fBounds.r); |
| |
| } |
| |
| #endif |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| void dng_opcode_TrimBounds::PutData (dng_stream &stream) const |
| { |
| |
| stream.Put_uint32 (16); |
| |
| stream.Put_int32 (fBounds.t); |
| stream.Put_int32 (fBounds.l); |
| stream.Put_int32 (fBounds.b); |
| stream.Put_int32 (fBounds.r); |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| void dng_opcode_TrimBounds::Apply (dng_host & /* host */, |
| dng_negative & /* negative */, |
| AutoPtr<dng_image> &image) |
| { |
| |
| if (fBounds.IsEmpty () || (fBounds & image->Bounds ()) != fBounds) |
| { |
| ThrowBadFormat (); |
| } |
| |
| image->Trim (fBounds); |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| void dng_area_spec::GetData (dng_stream &stream) |
| { |
| |
| fArea.t = stream.Get_int32 (); |
| fArea.l = stream.Get_int32 (); |
| fArea.b = stream.Get_int32 (); |
| fArea.r = stream.Get_int32 (); |
| |
| fPlane = stream.Get_uint32 (); |
| fPlanes = stream.Get_uint32 (); |
| |
| fRowPitch = stream.Get_uint32 (); |
| fColPitch = stream.Get_uint32 (); |
| |
| if (fPlanes < 1) |
| { |
| ThrowBadFormat (); |
| } |
| |
| if (fRowPitch < 1 || fColPitch < 1) |
| { |
| ThrowBadFormat (); |
| } |
| |
| if (fArea.IsEmpty ()) |
| { |
| if (fRowPitch != 1 || fColPitch != 1) |
| { |
| ThrowBadFormat (); |
| } |
| } |
| |
| else |
| { |
| int32 width = 0; |
| int32 height = 0; |
| if (!SafeInt32Sub (fArea.b, fArea.t, &height) || |
| !SafeInt32Sub (fArea.r, fArea.l, &width) || |
| fRowPitch > static_cast<uint32>(height) || |
| fColPitch > static_cast<uint32>(width)) |
| { |
| ThrowBadFormat(); |
| } |
| } |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| printf ("AreaSpec: t=%d, l=%d, b=%d, r=%d, p=%u:%u, rp=%u, cp=%u\n", |
| (int) fArea.t, |
| (int) fArea.l, |
| (int) fArea.b, |
| (int) fArea.r, |
| (unsigned) fPlane, |
| (unsigned) fPlanes, |
| (unsigned) fRowPitch, |
| (unsigned) fColPitch); |
| |
| } |
| |
| #endif |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| void dng_area_spec::PutData (dng_stream &stream) const |
| { |
| |
| stream.Put_int32 (fArea.t); |
| stream.Put_int32 (fArea.l); |
| stream.Put_int32 (fArea.b); |
| stream.Put_int32 (fArea.r); |
| |
| stream.Put_uint32 (fPlane); |
| stream.Put_uint32 (fPlanes); |
| |
| stream.Put_uint32 (fRowPitch); |
| stream.Put_uint32 (fColPitch); |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| dng_rect dng_area_spec::Overlap (const dng_rect &tile) const |
| { |
| |
| // Special case - if the fArea is empty, then dng_area_spec covers |
| // the entire image, no matter how large it is. |
| |
| if (fArea.IsEmpty ()) |
| { |
| return tile; |
| } |
| |
| dng_rect overlap = fArea & tile; |
| |
| if (overlap.NotEmpty ()) |
| { |
| |
| overlap.t = fArea.t + ConvertUint32ToInt32( |
| RoundUpUint32ToMultiple(static_cast<uint32>(overlap.t - fArea.t), |
| fRowPitch)); |
| overlap.l = fArea.l + ConvertUint32ToInt32( |
| RoundUpUint32ToMultiple(static_cast<uint32>(overlap.l - fArea.l), |
| fColPitch)); |
| |
| if (overlap.NotEmpty ()) |
| { |
| |
| overlap.b = overlap.t + ((overlap.H () - 1) / fRowPitch) * fRowPitch + 1; |
| overlap.r = overlap.l + ((overlap.W () - 1) / fColPitch) * fColPitch + 1; |
| |
| return overlap; |
| |
| } |
| |
| } |
| |
| return dng_rect (); |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| dng_opcode_MapTable::dng_opcode_MapTable (dng_host &host, |
| const dng_area_spec &areaSpec, |
| const uint16 *table, |
| uint32 count) |
| |
| : dng_inplace_opcode (dngOpcode_MapTable, |
| dngVersion_1_3_0_0, |
| kFlag_None) |
| |
| , fAreaSpec (areaSpec) |
| , fTable () |
| , fCount (count) |
| |
| { |
| |
| if (count == 0 || count > 0x10000) |
| { |
| ThrowProgramError (); |
| } |
| |
| fTable.Reset (host.Allocate (0x10000 * sizeof (uint16))); |
| |
| DoCopyBytes (table, |
| fTable->Buffer (), |
| count * (uint32) sizeof (uint16)); |
| |
| ReplicateLastEntry (); |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| dng_opcode_MapTable::dng_opcode_MapTable (dng_host &host, |
| dng_stream &stream) |
| |
| : dng_inplace_opcode (dngOpcode_MapTable, |
| stream, |
| "MapTable") |
| |
| , fAreaSpec () |
| , fTable () |
| , fCount (0) |
| |
| { |
| |
| uint32 dataSize = stream.Get_uint32 (); |
| |
| fAreaSpec.GetData (stream); |
| |
| fCount = stream.Get_uint32 (); |
| |
| uint32 requiredSize = SafeUint32Mult(fCount, 2); |
| requiredSize = SafeUint32Add(requiredSize, dng_area_spec::kDataSize); |
| requiredSize = SafeUint32Add(requiredSize, 4); |
| if (dataSize != requiredSize) |
| { |
| ThrowBadFormat (); |
| } |
| |
| if (fCount == 0 || fCount > 0x10000) |
| { |
| ThrowBadFormat (); |
| } |
| |
| fTable.Reset (host.Allocate (0x10000 * sizeof (uint16))); |
| |
| uint16 *table = fTable->Buffer_uint16 (); |
| |
| for (uint32 index = 0; index < fCount; index++) |
| { |
| table [index] = stream.Get_uint16 (); |
| } |
| |
| ReplicateLastEntry (); |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| printf ("Count: %u\n", (unsigned) fCount); |
| |
| for (uint32 j = 0; j < fCount && j < gDumpLineLimit; j++) |
| { |
| printf (" Table [%5u] = %5u\n", (unsigned) j, (unsigned) table [j]); |
| } |
| |
| if (fCount > gDumpLineLimit) |
| { |
| printf (" ... %u table entries skipped\n", (unsigned) (fCount - gDumpLineLimit)); |
| } |
| |
| } |
| |
| #endif |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| void dng_opcode_MapTable::ReplicateLastEntry () |
| { |
| |
| uint16 *table = fTable->Buffer_uint16 (); |
| |
| uint16 lastEntry = table [fCount]; |
| |
| for (uint32 index = fCount; index < 0x10000; index++) |
| { |
| table [index] = lastEntry; |
| } |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| void dng_opcode_MapTable::PutData (dng_stream &stream) const |
| { |
| |
| stream.Put_uint32 (dng_area_spec::kDataSize + 4 + fCount * 2); |
| |
| fAreaSpec.PutData (stream); |
| |
| stream.Put_uint32 (fCount); |
| |
| uint16 *table = fTable->Buffer_uint16 (); |
| |
| for (uint32 index = 0; index < fCount; index++) |
| { |
| stream.Put_uint16 (table [index]); |
| } |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| uint32 dng_opcode_MapTable::BufferPixelType (uint32 /* imagePixelType */) |
| { |
| |
| return ttShort; |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| dng_rect dng_opcode_MapTable::ModifiedBounds (const dng_rect &imageBounds) |
| { |
| |
| return fAreaSpec.Overlap (imageBounds); |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| void dng_opcode_MapTable::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 ()) |
| { |
| |
| for (uint32 plane = fAreaSpec.Plane (); |
| plane < fAreaSpec.Plane () + fAreaSpec.Planes () && |
| plane < buffer.Planes (); |
| plane++) |
| { |
| |
| DoMapArea16 (buffer.DirtyPixel_uint16 (overlap.t, overlap.l, plane), |
| 1, |
| (overlap.H () + fAreaSpec.RowPitch () - 1) / fAreaSpec.RowPitch (), |
| (overlap.W () + fAreaSpec.ColPitch () - 1) / fAreaSpec.ColPitch (), |
| 0, |
| fAreaSpec.RowPitch () * buffer.RowStep (), |
| fAreaSpec.ColPitch (), |
| fTable->Buffer_uint16 ()); |
| |
| } |
| |
| } |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| dng_opcode_MapPolynomial::dng_opcode_MapPolynomial (const dng_area_spec &areaSpec, |
| uint32 degree, |
| const real64 *coefficient) |
| |
| : dng_inplace_opcode (dngOpcode_MapPolynomial, |
| dngVersion_1_3_0_0, |
| kFlag_None) |
| |
| , fAreaSpec (areaSpec) |
| , fDegree (degree) |
| |
| { |
| |
| for (uint32 j = 0; j <= kMaxDegree; j++) |
| { |
| |
| if (j <= fDegree) |
| { |
| fCoefficient [j] = coefficient [j]; |
| } |
| |
| else |
| { |
| fCoefficient [j] = 0.0; |
| } |
| |
| } |
| |
| // Reduce degree if possible. |
| |
| while (fDegree > 0 && fCoefficient [fDegree] == 0.0) |
| { |
| fDegree--; |
| } |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| dng_opcode_MapPolynomial::dng_opcode_MapPolynomial (dng_stream &stream) |
| |
| : dng_inplace_opcode (dngOpcode_MapPolynomial, |
| stream, |
| "MapPolynomial") |
| |
| , fAreaSpec () |
| , fDegree (0) |
| |
| { |
| |
| uint32 dataSize = stream.Get_uint32 (); |
| |
| fAreaSpec.GetData (stream); |
| |
| fDegree = stream.Get_uint32 (); |
| |
| if (fDegree > kMaxDegree) |
| { |
| ThrowBadFormat (); |
| } |
| |
| if (dataSize != dng_area_spec::kDataSize + 4 + (fDegree + 1) * 8) |
| { |
| ThrowBadFormat (); |
| } |
| |
| for (uint32 j = 0; j <= kMaxDegree; j++) |
| { |
| |
| if (j <= fDegree) |
| { |
| fCoefficient [j] = stream.Get_real64 (); |
| } |
| else |
| { |
| fCoefficient [j] = 0.0; |
| } |
| |
| } |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| for (uint32 k = 0; k <= fDegree; k++) |
| { |
| printf (" Coefficient [%u] = %f\n", (unsigned) k, fCoefficient [k]); |
| } |
| |
| } |
| |
| #endif |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| void dng_opcode_MapPolynomial::PutData (dng_stream &stream) const |
| { |
| |
| stream.Put_uint32 (dng_area_spec::kDataSize + 4 + (fDegree + 1) * 8); |
| |
| fAreaSpec.PutData (stream); |
| |
| stream.Put_uint32 (fDegree); |
| |
| for (uint32 j = 0; j <= fDegree; j++) |
| { |
| stream.Put_real64 (fCoefficient [j]); |
| } |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| uint32 dng_opcode_MapPolynomial::BufferPixelType (uint32 imagePixelType) |
| { |
| |
| // If we are operating on the stage 1 image, then we need |
| // to adjust the coefficients to convert from the image |
| // values to the 32-bit floating point values that this |
| // opcode operates on. |
| |
| // If we are operating on the stage 2 or 3 image, the logical |
| // range of the image is already 0.0 to 1.0, so we don't |
| // need to adjust the values. |
| |
| real64 scale32 = 1.0; |
| |
| if (Stage () == 1) |
| { |
| |
| switch (imagePixelType) |
| { |
| |
| case ttFloat: |
| break; |
| |
| case ttShort: |
| { |
| scale32 = (real64) 0xFFFF; |
| break; |
| } |
| |
| case ttLong: |
| { |
| scale32 = (real64) 0xFFFFFFFF; |
| break; |
| } |
| |
| default: |
| ThrowBadFormat (); |
| |
| } |
| |
| } |
| |
| real64 factor32 = 1.0 / scale32; |
| |
| for (uint32 j = 0; j <= kMaxDegree; j++) |
| { |
| |
| fCoefficient32 [j] = ConvertDoubleToFloat(fCoefficient [j] * factor32); |
| |
| factor32 *= scale32; |
| |
| } |
| |
| return ttFloat; |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| dng_rect dng_opcode_MapPolynomial::ModifiedBounds (const dng_rect &imageBounds) |
| { |
| |
| return fAreaSpec.Overlap (imageBounds); |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| void dng_opcode_MapPolynomial::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++) |
| { |
| |
| for (int32 row = overlap.t; row < overlap.b; row += fAreaSpec.RowPitch ()) |
| { |
| |
| real32 *dPtr = buffer.DirtyPixel_real32 (row, overlap.l, plane); |
| |
| switch (fDegree) |
| { |
| |
| case 0: |
| { |
| |
| real32 y = Pin_real32 (0.0f, |
| fCoefficient32 [0], |
| 1.0f); |
| |
| for (uint32 col = 0; col < cols; col += colPitch) |
| { |
| |
| dPtr [col] = y; |
| |
| } |
| |
| break; |
| |
| } |
| |
| case 1: |
| { |
| |
| real32 c0 = fCoefficient32 [0]; |
| real32 c1 = fCoefficient32 [1]; |
| |
| if (c0 == 0.0f) |
| { |
| |
| if (c1 > 0.0f) |
| { |
| |
| for (uint32 col = 0; col < cols; col += colPitch) |
| { |
| |
| real32 x = dPtr [col]; |
| |
| real32 y = c1 * x; |
| |
| dPtr [col] = Min_real32 (y, 1.0f); |
| |
| } |
| |
| } |
| |
| else |
| { |
| |
| for (uint32 col = 0; col < cols; col += colPitch) |
| { |
| |
| dPtr [col] = 0.0f; |
| |
| } |
| |
| } |
| |
| } |
| |
| else |
| { |
| |
| for (uint32 col = 0; col < cols; col += colPitch) |
| { |
| |
| real32 x = dPtr [col]; |
| |
| real32 y = c0 + |
| c1 * x; |
| |
| dPtr [col] = Pin_real32 (0.0f, y, 1.0f); |
| |
| } |
| |
| } |
| |
| break; |
| |
| } |
| |
| case 2: |
| { |
| |
| for (uint32 col = 0; col < cols; col += colPitch) |
| { |
| |
| real32 x = dPtr [col]; |
| |
| real32 y = fCoefficient32 [0] + x * |
| (fCoefficient32 [1] + x * |
| (fCoefficient32 [2])); |
| |
| dPtr [col] = Pin_real32 (0.0f, y, 1.0f); |
| |
| } |
| |
| break; |
| |
| } |
| |
| case 3: |
| { |
| |
| for (uint32 col = 0; col < cols; col += colPitch) |
| { |
| |
| real32 x = dPtr [col]; |
| |
| real32 y = fCoefficient32 [0] + x * |
| (fCoefficient32 [1] + x * |
| (fCoefficient32 [2] + x * |
| (fCoefficient32 [3]))); |
| |
| dPtr [col] = Pin_real32 (0.0f, y, 1.0f); |
| |
| } |
| |
| break; |
| |
| } |
| |
| case 4: |
| { |
| |
| for (uint32 col = 0; col < cols; col += colPitch) |
| { |
| |
| real32 x = dPtr [col]; |
| |
| real32 y = fCoefficient32 [0] + x * |
| (fCoefficient32 [1] + x * |
| (fCoefficient32 [2] + x * |
| (fCoefficient32 [3] + x * |
| (fCoefficient32 [4])))); |
| |
| dPtr [col] = Pin_real32 (0.0f, y, 1.0f); |
| |
| } |
| |
| break; |
| |
| } |
| |
| default: |
| { |
| |
| for (uint32 col = 0; col < cols; col += colPitch) |
| { |
| |
| real32 x = dPtr [col]; |
| |
| real32 y = fCoefficient32 [0]; |
| |
| real32 xx = x; |
| |
| for (uint32 j = 1; j <= fDegree; j++) |
| { |
| |
| y += fCoefficient32 [j] * xx; |
| |
| xx *= x; |
| |
| } |
| |
| dPtr [col] = Pin_real32 (0.0f, y, 1.0f); |
| |
| } |
| |
| } |
| |
| } |
| |
| } |
| |
| } |
| |
| } |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| dng_opcode_DeltaPerRow::dng_opcode_DeltaPerRow (const dng_area_spec &areaSpec, |
| AutoPtr<dng_memory_block> &table) |
| |
| : dng_inplace_opcode (dngOpcode_DeltaPerRow, |
| dngVersion_1_3_0_0, |
| kFlag_None) |
| |
| , fAreaSpec (areaSpec) |
| , fTable () |
| , fScale (1.0f) |
| |
| { |
| |
| fTable.Reset (table.Release ()); |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| dng_opcode_DeltaPerRow::dng_opcode_DeltaPerRow (dng_host &host, |
| dng_stream &stream) |
| |
| : dng_inplace_opcode (dngOpcode_DeltaPerRow, |
| stream, |
| "DeltaPerRow") |
| |
| , fAreaSpec () |
| , fTable () |
| , fScale (1.0f) |
| |
| { |
| |
| uint32 dataSize = stream.Get_uint32 (); |
| |
| fAreaSpec.GetData (stream); |
| |
| uint32 deltas = SafeUint32DivideUp (fAreaSpec.Area ().H (), |
| fAreaSpec.RowPitch ()); |
| |
| if (deltas != stream.Get_uint32 ()) |
| { |
| ThrowBadFormat (); |
| } |
| |
| if (dataSize != dng_area_spec::kDataSize + 4 + deltas * 4) |
| { |
| ThrowBadFormat (); |
| } |
| |
| fTable.Reset (host.Allocate (SafeUint32Mult (deltas, |
| static_cast<uint32> (sizeof (real32))))); |
| |
| real32 *table = fTable->Buffer_real32 (); |
| |
| for (uint32 j = 0; j < deltas; j++) |
| { |
| table [j] = stream.Get_real32 (); |
| } |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| printf ("Count: %u\n", (unsigned) deltas); |
| |
| for (uint32 k = 0; k < deltas && k < gDumpLineLimit; k++) |
| { |
| printf (" Delta [%u] = %f\n", (unsigned) k, table [k]); |
| } |
| |
| if (deltas > gDumpLineLimit) |
| { |
| printf (" ... %u deltas skipped\n", (unsigned) (deltas - gDumpLineLimit)); |
| } |
| |
| } |
| |
| #endif |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| void dng_opcode_DeltaPerRow::PutData (dng_stream &stream) const |
| { |
| |
| uint32 deltas = SafeUint32DivideUp (fAreaSpec.Area ().H (), |
| fAreaSpec.RowPitch ()); |
| |
| stream.Put_uint32 (dng_area_spec::kDataSize + 4 + deltas * 4); |
| |
| fAreaSpec.PutData (stream); |
| |
| stream.Put_uint32 (deltas); |
| |
| real32 *table = fTable->Buffer_real32 (); |
| |
| for (uint32 j = 0; j < deltas; j++) |
| { |
| stream.Put_real32 (table [j]); |
| } |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| uint32 dng_opcode_DeltaPerRow::BufferPixelType (uint32 imagePixelType) |
| { |
| |
| real64 scale32 = 1.0; |
| |
| switch (imagePixelType) |
| { |
| |
| case ttFloat: |
| break; |
| |
| case ttShort: |
| { |
| scale32 = (real64) 0xFFFF; |
| break; |
| } |
| |
| case ttLong: |
| { |
| scale32 = (real64) 0xFFFFFFFF; |
| break; |
| } |
| |
| default: |
| ThrowBadFormat (); |
| |
| } |
| |
| fScale = (real32) (1.0 / scale32); |
| |
| return ttFloat; |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| dng_rect dng_opcode_DeltaPerRow::ModifiedBounds (const dng_rect &imageBounds) |
| { |
| |
| return fAreaSpec.Overlap (imageBounds); |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| void dng_opcode_DeltaPerRow::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++) |
| { |
| |
| const real32 *table = fTable->Buffer_real32 () + |
| ((overlap.t - fAreaSpec.Area ().t) / |
| fAreaSpec.RowPitch ()); |
| |
| for (int32 row = overlap.t; row < overlap.b; row += fAreaSpec.RowPitch ()) |
| { |
| |
| real32 rowDelta = *(table++) * fScale; |
| |
| real32 *dPtr = buffer.DirtyPixel_real32 (row, overlap.l, plane); |
| |
| for (uint32 col = 0; col < cols; col += colPitch) |
| { |
| |
| real32 x = dPtr [col]; |
| |
| real32 y = x + rowDelta; |
| |
| dPtr [col] = Pin_real32 (0.0f, y, 1.0f); |
| |
| } |
| |
| } |
| |
| } |
| |
| } |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| dng_opcode_DeltaPerColumn::dng_opcode_DeltaPerColumn (const dng_area_spec &areaSpec, |
| AutoPtr<dng_memory_block> &table) |
| |
| : dng_inplace_opcode (dngOpcode_DeltaPerColumn, |
| dngVersion_1_3_0_0, |
| kFlag_None) |
| |
| , fAreaSpec (areaSpec) |
| , fTable () |
| , fScale (1.0f) |
| |
| { |
| |
| fTable.Reset (table.Release ()); |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| dng_opcode_DeltaPerColumn::dng_opcode_DeltaPerColumn (dng_host &host, |
| dng_stream &stream) |
| |
| : dng_inplace_opcode (dngOpcode_DeltaPerColumn, |
| stream, |
| "DeltaPerColumn") |
| |
| , fAreaSpec () |
| , fTable () |
| , fScale (1.0f) |
| |
| { |
| |
| uint32 dataSize = stream.Get_uint32 (); |
| |
| fAreaSpec.GetData (stream); |
| |
| uint32 deltas = SafeUint32DivideUp (fAreaSpec.Area ().W (), |
| fAreaSpec.ColPitch ()); |
| |
| if (deltas != stream.Get_uint32 ()) |
| { |
| ThrowBadFormat (); |
| } |
| |
| if (dataSize != dng_area_spec::kDataSize + 4 + deltas * 4) |
| { |
| ThrowBadFormat (); |
| } |
| |
| fTable.Reset (host.Allocate (SafeUint32Mult (deltas, |
| static_cast<uint32> (sizeof (real32))))); |
| |
| real32 *table = fTable->Buffer_real32 (); |
| |
| for (uint32 j = 0; j < deltas; j++) |
| { |
| table [j] = stream.Get_real32 (); |
| } |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| printf ("Count: %u\n", (unsigned) deltas); |
| |
| for (uint32 k = 0; k < deltas && k < gDumpLineLimit; k++) |
| { |
| printf (" Delta [%u] = %f\n", (unsigned) k, table [k]); |
| } |
| |
| if (deltas > gDumpLineLimit) |
| { |
| printf (" ... %u deltas skipped\n", (unsigned) (deltas - gDumpLineLimit)); |
| } |
| |
| } |
| |
| #endif |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| void dng_opcode_DeltaPerColumn::PutData (dng_stream &stream) const |
| { |
| |
| uint32 deltas = SafeUint32DivideUp (fAreaSpec.Area ().W (), |
| fAreaSpec.ColPitch ()); |
| |
| stream.Put_uint32 (dng_area_spec::kDataSize + 4 + deltas * 4); |
| |
| fAreaSpec.PutData (stream); |
| |
| stream.Put_uint32 (deltas); |
| |
| real32 *table = fTable->Buffer_real32 (); |
| |
| for (uint32 j = 0; j < deltas; j++) |
| { |
| stream.Put_real32 (table [j]); |
| } |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| uint32 dng_opcode_DeltaPerColumn::BufferPixelType (uint32 imagePixelType) |
| { |
| |
| real64 scale32 = 1.0; |
| |
| switch (imagePixelType) |
| { |
| |
| case ttFloat: |
| break; |
| |
| case ttShort: |
| { |
| scale32 = (real64) 0xFFFF; |
| break; |
| } |
| |
| case ttLong: |
| { |
| scale32 = (real64) 0xFFFFFFFF; |
| break; |
| } |
| |
| default: |
| ThrowBadFormat (); |
| |
| } |
| |
| fScale = (real32) (1.0 / scale32); |
| |
| return ttFloat; |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| dng_rect dng_opcode_DeltaPerColumn::ModifiedBounds (const dng_rect &imageBounds) |
| { |
| |
| return fAreaSpec.Overlap (imageBounds); |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| void dng_opcode_DeltaPerColumn::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 rows = (overlap.H () + fAreaSpec.RowPitch () - 1) / |
| fAreaSpec.RowPitch (); |
| |
| int32 rowStep = buffer.RowStep () * fAreaSpec.RowPitch (); |
| |
| for (uint32 plane = fAreaSpec.Plane (); |
| plane < fAreaSpec.Plane () + fAreaSpec.Planes () && |
| plane < buffer.Planes (); |
| plane++) |
| { |
| |
| const real32 *table = fTable->Buffer_real32 () + |
| ((overlap.l - fAreaSpec.Area ().l) / |
| fAreaSpec.ColPitch ()); |
| |
| for (int32 col = overlap.l; col < overlap.r; col += fAreaSpec.ColPitch ()) |
| { |
| |
| real32 colDelta = *(table++) * fScale; |
| |
| real32 *dPtr = buffer.DirtyPixel_real32 (overlap.t, col, plane); |
| |
| for (uint32 row = 0; row < rows; row++) |
| { |
| |
| real32 x = dPtr [0]; |
| |
| real32 y = x + colDelta; |
| |
| dPtr [0] = Pin_real32 (0.0f, y, 1.0f); |
| |
| dPtr += rowStep; |
| |
| } |
| |
| } |
| |
| } |
| |
| } |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| dng_opcode_ScalePerRow::dng_opcode_ScalePerRow (const dng_area_spec &areaSpec, |
| AutoPtr<dng_memory_block> &table) |
| |
| : dng_inplace_opcode (dngOpcode_ScalePerRow, |
| dngVersion_1_3_0_0, |
| kFlag_None) |
| |
| , fAreaSpec (areaSpec) |
| , fTable () |
| |
| { |
| |
| fTable.Reset (table.Release ()); |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| dng_opcode_ScalePerRow::dng_opcode_ScalePerRow (dng_host &host, |
| dng_stream &stream) |
| |
| : dng_inplace_opcode (dngOpcode_ScalePerRow, |
| stream, |
| "ScalePerRow") |
| |
| , fAreaSpec () |
| , fTable () |
| |
| { |
| |
| uint32 dataSize = stream.Get_uint32 (); |
| |
| fAreaSpec.GetData (stream); |
| |
| uint32 scales = SafeUint32DivideUp (fAreaSpec.Area ().H (), |
| fAreaSpec.RowPitch ()); |
| |
| if (scales != stream.Get_uint32 ()) |
| { |
| ThrowBadFormat (); |
| } |
| |
| if (dataSize != dng_area_spec::kDataSize + 4 + scales * 4) |
| { |
| ThrowBadFormat (); |
| } |
| |
| fTable.Reset (host.Allocate (SafeUint32Mult (scales, |
| static_cast<uint32> (sizeof (real32))))); |
| |
| real32 *table = fTable->Buffer_real32 (); |
| |
| for (uint32 j = 0; j < scales; j++) |
| { |
| table [j] = stream.Get_real32 (); |
| } |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| printf ("Count: %u\n", (unsigned) scales); |
| |
| for (uint32 k = 0; k < scales && k < gDumpLineLimit; k++) |
| { |
| printf (" Scale [%u] = %f\n", (unsigned) k, table [k]); |
| } |
| |
| if (scales > gDumpLineLimit) |
| { |
| printf (" ... %u scales skipped\n", (unsigned) (scales - gDumpLineLimit)); |
| } |
| |
| } |
| |
| #endif |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| void dng_opcode_ScalePerRow::PutData (dng_stream &stream) const |
| { |
| |
| uint32 scales = SafeUint32DivideUp (fAreaSpec.Area ().H (), |
| fAreaSpec.RowPitch ()); |
| |
| stream.Put_uint32 (dng_area_spec::kDataSize + 4 + scales * 4); |
| |
| fAreaSpec.PutData (stream); |
| |
| stream.Put_uint32 (scales); |
| |
| real32 *table = fTable->Buffer_real32 (); |
| |
| for (uint32 j = 0; j < scales; j++) |
| { |
| stream.Put_real32 (table [j]); |
| } |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| uint32 dng_opcode_ScalePerRow::BufferPixelType (uint32 /* imagePixelType */) |
| { |
| |
| return ttFloat; |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| dng_rect dng_opcode_ScalePerRow::ModifiedBounds (const dng_rect &imageBounds) |
| { |
| |
| return fAreaSpec.Overlap (imageBounds); |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| void dng_opcode_ScalePerRow::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++) |
| { |
| |
| const real32 *table = fTable->Buffer_real32 () + |
| ((overlap.t - fAreaSpec.Area ().t) / |
| fAreaSpec.RowPitch ()); |
| |
| for (int32 row = overlap.t; row < overlap.b; row += fAreaSpec.RowPitch ()) |
| { |
| |
| real32 rowScale = *(table++); |
| |
| real32 *dPtr = buffer.DirtyPixel_real32 (row, overlap.l, plane); |
| |
| for (uint32 col = 0; col < cols; col += colPitch) |
| { |
| |
| real32 x = dPtr [col]; |
| |
| real32 y = x * rowScale; |
| |
| dPtr [col] = Min_real32 (y, 1.0f); |
| |
| } |
| |
| } |
| |
| } |
| |
| } |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| dng_opcode_ScalePerColumn::dng_opcode_ScalePerColumn (const dng_area_spec &areaSpec, |
| AutoPtr<dng_memory_block> &table) |
| |
| : dng_inplace_opcode (dngOpcode_ScalePerColumn, |
| dngVersion_1_3_0_0, |
| kFlag_None) |
| |
| , fAreaSpec (areaSpec) |
| , fTable () |
| |
| { |
| |
| fTable.Reset (table.Release ()); |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| dng_opcode_ScalePerColumn::dng_opcode_ScalePerColumn (dng_host &host, |
| dng_stream &stream) |
| |
| : dng_inplace_opcode (dngOpcode_ScalePerColumn, |
| stream, |
| "ScalePerColumn") |
| |
| , fAreaSpec () |
| , fTable () |
| |
| { |
| |
| uint32 dataSize = stream.Get_uint32 (); |
| |
| fAreaSpec.GetData (stream); |
| |
| uint32 scales = SafeUint32DivideUp (fAreaSpec.Area ().W (), |
| fAreaSpec.ColPitch()); |
| |
| if (scales != stream.Get_uint32 ()) |
| { |
| ThrowBadFormat (); |
| } |
| |
| if (dataSize != dng_area_spec::kDataSize + 4 + scales * 4) |
| { |
| ThrowBadFormat (); |
| } |
| |
| fTable.Reset (host.Allocate (SafeUint32Mult (scales, |
| static_cast<uint32> (sizeof (real32))))); |
| |
| real32 *table = fTable->Buffer_real32 (); |
| |
| for (uint32 j = 0; j < scales; j++) |
| { |
| table [j] = stream.Get_real32 (); |
| } |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| printf ("Count: %u\n", (unsigned) scales); |
| |
| for (uint32 k = 0; k < scales && k < gDumpLineLimit; k++) |
| { |
| printf (" Scale [%u] = %f\n", (unsigned) k, table [k]); |
| } |
| |
| if (scales > gDumpLineLimit) |
| { |
| printf (" ... %u deltas skipped\n", (unsigned) (scales - gDumpLineLimit)); |
| } |
| |
| } |
| |
| #endif |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| void dng_opcode_ScalePerColumn::PutData (dng_stream &stream) const |
| { |
| |
| uint32 scales = SafeUint32DivideUp (fAreaSpec.Area ().W (), |
| fAreaSpec.ColPitch ()); |
| |
| stream.Put_uint32 (dng_area_spec::kDataSize + 4 + scales * 4); |
| |
| fAreaSpec.PutData (stream); |
| |
| stream.Put_uint32 (scales); |
| |
| real32 *table = fTable->Buffer_real32 (); |
| |
| for (uint32 j = 0; j < scales; j++) |
| { |
| stream.Put_real32 (table [j]); |
| } |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| uint32 dng_opcode_ScalePerColumn::BufferPixelType (uint32 /* imagePixelType */) |
| { |
| |
| return ttFloat; |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| dng_rect dng_opcode_ScalePerColumn::ModifiedBounds (const dng_rect &imageBounds) |
| { |
| |
| return fAreaSpec.Overlap (imageBounds); |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| void dng_opcode_ScalePerColumn::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 rows = (overlap.H () + fAreaSpec.RowPitch () - 1) / |
| fAreaSpec.RowPitch (); |
| |
| int32 rowStep = buffer.RowStep () * fAreaSpec.RowPitch (); |
| |
| for (uint32 plane = fAreaSpec.Plane (); |
| plane < fAreaSpec.Plane () + fAreaSpec.Planes () && |
| plane < buffer.Planes (); |
| plane++) |
| { |
| |
| const real32 *table = fTable->Buffer_real32 () + |
| ((overlap.l - fAreaSpec.Area ().l) / |
| fAreaSpec.ColPitch ()); |
| |
| for (int32 col = overlap.l; col < overlap.r; col += fAreaSpec.ColPitch ()) |
| { |
| |
| real32 colScale = *(table++); |
| |
| real32 *dPtr = buffer.DirtyPixel_real32 (overlap.t, col, plane); |
| |
| for (uint32 row = 0; row < rows; row++) |
| { |
| |
| real32 x = dPtr [0]; |
| |
| real32 y = x * colScale; |
| |
| dPtr [0] = Min_real32 (y, 1.0f); |
| |
| dPtr += rowStep; |
| |
| } |
| |
| } |
| |
| } |
| |
| } |
| |
| } |
| |
| /*****************************************************************************/ |
