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