/*****************************************************************************/
// Copyright 2006-2008 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_pixel_buffer.cpp#1 $ */
/* $DateTime: 2012/05/30 13:28:51 $ */
/* $Change: 832332 $ */
/* $Author: tknoll $ */
/*****************************************************************************/
#include "dng_pixel_buffer.h"
#include "dng_bottlenecks.h"
#include "dng_exceptions.h"
#include "dng_flags.h"
#include "dng_safe_arithmetic.h"
#include "dng_tag_types.h"
#include "dng_tag_values.h"
#include "dng_utils.h"
/*****************************************************************************/
namespace {
bool SafeUint32ToInt32Mult(uint32 arg1, uint32 arg2, int32 *result) {
uint32 uint32_result;
return SafeUint32Mult(arg1, arg2, &uint32_result) &&
ConvertUint32ToInt32(uint32_result, result);
}
} // namespace
/*****************************************************************************/
void OptimizeOrder (const void *&sPtr,
void *&dPtr,
uint32 sPixelSize,
uint32 dPixelSize,
uint32 &count0,
uint32 &count1,
uint32 &count2,
int32 &sStep0,
int32 &sStep1,
int32 &sStep2,
int32 &dStep0,
int32 &dStep1,
int32 &dStep2)
{
uint32 step0;
uint32 step1;
uint32 step2;
// Optimize the order for the data that is most spread out.
uint32 sRange = Abs_int32 (sStep0) * (count0 - 1) +
Abs_int32 (sStep1) * (count1 - 1) +
Abs_int32 (sStep2) * (count2 - 1);
uint32 dRange = Abs_int32 (dStep0) * (count0 - 1) +
Abs_int32 (dStep1) * (count1 - 1) +
Abs_int32 (dStep2) * (count2 - 1);
if (dRange >= sRange)
{
if (dStep0 < 0)
{
sPtr = (const void *)
(((const uint8 *) sPtr) + (int32)(count0 - 1) * sStep0 * (int32)sPixelSize);
dPtr = (void *)
(((uint8 *) dPtr) + (int32)(count0 - 1) * dStep0 * (int32)dPixelSize);
sStep0 = -sStep0;
dStep0 = -dStep0;
}
if (dStep1 < 0)
{
sPtr = (const void *)
(((const uint8 *) sPtr) + (int32)(count1 - 1) * sStep1 * (int32)sPixelSize);
dPtr = (void *)
(((uint8 *) dPtr) + (int32)(count1 - 1) * dStep1 * (int32)dPixelSize);
sStep1 = -sStep1;
dStep1 = -dStep1;
}
if (dStep2 < 0)
{
sPtr = (const void *)
(((const uint8 *) sPtr) + (int32)(count2 - 1) * sStep2 * (int32)sPixelSize);
dPtr = (void *)
(((uint8 *) dPtr) + (int32)(count2 - 1) * dStep2 * (int32)dPixelSize);
sStep2 = -sStep2;
dStep2 = -dStep2;
}
step0 = (uint32) dStep0;
step1 = (uint32) dStep1;
step2 = (uint32) dStep2;
}
else
{
if (sStep0 < 0)
{
sPtr = (const void *)
(((const uint8 *) sPtr) + (int32)(count0 - 1) * sStep0 * (int32)sPixelSize);
dPtr = (void *)
(((uint8 *) dPtr) + (int32)(count0 - 1) * dStep0 * (int32)dPixelSize);
sStep0 = -sStep0;
dStep0 = -dStep0;
}
if (sStep1 < 0)
{
sPtr = (const void *)
(((const uint8 *) sPtr) + (int32)(count1 - 1) * sStep1 * (int32)sPixelSize);
dPtr = (void *)
(((uint8 *) dPtr) + (int32)(count1 - 1) * dStep1 * (int32)dPixelSize);
sStep1 = -sStep1;
dStep1 = -dStep1;
}
if (sStep2 < 0)
{
sPtr = (const void *)
(((const uint8 *) sPtr) + (int32)(count2 - 1) * sStep2 * (int32)sPixelSize);
dPtr = (void *)
(((uint8 *) dPtr) + (int32)(count2 - 1) * dStep2 * (int32)dPixelSize);
sStep2 = -sStep2;
dStep2 = -dStep2;
}
step0 = (uint32) sStep0;
step1 = (uint32) sStep1;
step2 = (uint32) sStep2;
}
if (count0 == 1) step0 = 0xFFFFFFFF;
if (count1 == 1) step1 = 0xFFFFFFFF;
if (count2 == 1) step2 = 0xFFFFFFFF;
uint32 index0;
uint32 index1;
uint32 index2;
if (step0 >= step1)
{
if (step1 >= step2)
{
index0 = 0;
index1 = 1;
index2 = 2;
}
else if (step2 >= step0)
{
index0 = 2;
index1 = 0;
index2 = 1;
}
else
{
index0 = 0;
index1 = 2;
index2 = 1;
}
}
else
{
if (step0 >= step2)
{
index0 = 1;
index1 = 0;
index2 = 2;
}
else if (step2 >= step1)
{
index0 = 2;
index1 = 1;
index2 = 0;
}
else
{
index0 = 1;
index1 = 2;
index2 = 0;
}
}
uint32 count [3];
count [0] = count0;
count [1] = count1;
count [2] = count2;
count0 = count [index0];
count1 = count [index1];
count2 = count [index2];
int32 step [3];
step [0] = sStep0;
step [1] = sStep1;
step [2] = sStep2;
sStep0 = step [index0];
sStep1 = step [index1];
sStep2 = step [index2];
step [0] = dStep0;
step [1] = dStep1;
step [2] = dStep2;
dStep0 = step [index0];
dStep1 = step [index1];
dStep2 = step [index2];
if (sStep0 == ((int32) count1) * sStep1 &&
dStep0 == ((int32) count1) * dStep1)
{
count1 *= count0;
count0 = 1;
}
if (sStep1 == ((int32) count2) * sStep2 &&
dStep1 == ((int32) count2) * dStep2)
{
count2 *= count1;
count1 = 1;
}
}
/*****************************************************************************/
void OptimizeOrder (const void *&sPtr,
uint32 sPixelSize,
uint32 &count0,
uint32 &count1,
uint32 &count2,
int32 &sStep0,
int32 &sStep1,
int32 &sStep2)
{
void *dPtr = NULL;
int32 dStep0 = sStep0;
int32 dStep1 = sStep1;
int32 dStep2 = sStep2;
OptimizeOrder (sPtr,
dPtr,
sPixelSize,
sPixelSize,
count0,
count1,
count2,
sStep0,
sStep1,
sStep2,
dStep0,
dStep1,
dStep2);
}
/*****************************************************************************/
void OptimizeOrder (void *&dPtr,
uint32 dPixelSize,
uint32 &count0,
uint32 &count1,
uint32 &count2,
int32 &dStep0,
int32 &dStep1,
int32 &dStep2)
{
const void *sPtr = NULL;
int32 sStep0 = dStep0;
int32 sStep1 = dStep1;
int32 sStep2 = dStep2;
OptimizeOrder (sPtr,
dPtr,
dPixelSize,
dPixelSize,
count0,
count1,
count2,
sStep0,
sStep1,
sStep2,
dStep0,
dStep1,
dStep2);
}
/*****************************************************************************/
dng_pixel_buffer::dng_pixel_buffer ()
: fArea ()
, fPlane (0)
, fPlanes (1)
, fRowStep (1)
, fColStep (1)
, fPlaneStep (1)
, fPixelType (ttUndefined)
, fPixelSize (0)
, fData (NULL)
, fDirty (true)
{
}
/*****************************************************************************/
dng_pixel_buffer::dng_pixel_buffer (const dng_rect &area,
uint32 plane,
uint32 planes,
uint32 pixelType,
uint32 planarConfiguration,
void *data)
: fArea (area)
, fPlane (plane)
, fPlanes (planes)
, fRowStep (0)
, fColStep (0)
, fPlaneStep (0)
, fPixelType (pixelType)
, fPixelSize (TagTypeSize(pixelType))
, fData (data)
, fDirty (true)
{
const char *overflowMessage = "Arithmetic overflow in pixel buffer setup";
// Initialize fRowStep, fColStep and fPlaneStep according to the desired
// pixel layout.
switch (planarConfiguration)
{
case pcInterleaved:
fPlaneStep = 1;
if (!ConvertUint32ToInt32 (fPlanes, &fColStep) ||
!SafeUint32ToInt32Mult (fArea.W(), fPlanes, &fRowStep))
{
ThrowMemoryFull (overflowMessage);
}
break;
case pcPlanar:
fColStep = 1;
// Even though we've hardened dng_rect::W() to guarantee that it
// will never return a result that's out of range for an int32,
// we still protect the conversion for defense in depth.
if (!ConvertUint32ToInt32 (fArea.W(), &fRowStep) ||
!SafeUint32ToInt32Mult (fArea.H(), fArea.W(), &fPlaneStep))
{
ThrowMemoryFull (overflowMessage);
}
break;
case pcRowInterleaved:
case pcRowInterleavedAlign16:
{
fColStep = 1;
uint32 planeStepUint32;
if (planarConfiguration == pcRowInterleaved)
{
planeStepUint32 = fArea.W();
}
else
{
if (!RoundUpForPixelSize (fArea.W(), fPixelSize,
&planeStepUint32))
{
ThrowMemoryFull (overflowMessage);
}
}
if (!ConvertUint32ToInt32 (planeStepUint32, &fPlaneStep) ||
!SafeUint32ToInt32Mult (planeStepUint32, fPlanes, &fRowStep))
{
ThrowMemoryFull (overflowMessage);
}
break;
}
default:
ThrowProgramError ("Invalid value for 'planarConfiguration'");
break;
}
}
/*****************************************************************************/
dng_pixel_buffer::dng_pixel_buffer (const dng_pixel_buffer &buffer)
: fArea (buffer.fArea)
, fPlane (buffer.fPlane)
, fPlanes (buffer.fPlanes)
, fRowStep (buffer.fRowStep)
, fColStep (buffer.fColStep)
, fPlaneStep (buffer.fPlaneStep)
, fPixelType (buffer.fPixelType)
, fPixelSize (buffer.fPixelSize)
, fData (buffer.fData)
, fDirty (buffer.fDirty)
{
}
/*****************************************************************************/
dng_pixel_buffer & dng_pixel_buffer::operator= (const dng_pixel_buffer &buffer)
{
fArea = buffer.fArea;
fPlane = buffer.fPlane;
fPlanes = buffer.fPlanes;
fRowStep = buffer.fRowStep;
fColStep = buffer.fColStep;
fPlaneStep = buffer.fPlaneStep;
fPixelType = buffer.fPixelType;
fPixelSize = buffer.fPixelSize;
fPixelType = buffer.fPixelType;
fData = buffer.fData;
fDirty = buffer.fDirty;
return *this;
}
/*****************************************************************************/
dng_pixel_buffer::~dng_pixel_buffer ()
{
}
/*****************************************************************************/
#if qDebugPixelType
void dng_pixel_buffer::CheckPixelType (uint32 pixelType) const
{
if (fPixelType != pixelType)
{
DNG_REPORT ("Pixel type access mismatch");
}
}
#endif
/*****************************************************************************/
uint32 dng_pixel_buffer::PixelRange () const
{
switch (fPixelType)
{
case ttByte:
case ttSByte:
{
return 0x0FF;
}
case ttShort:
case ttSShort:
{
return 0x0FFFF;
}
case ttLong:
case ttSLong:
{
return 0xFFFFFFFF;
}
default:
break;
}
return 0;
}
/*****************************************************************************/
void dng_pixel_buffer::SetConstant (const dng_rect &area,
uint32 plane,
uint32 planes,
uint32 value)
{
uint32 rows = area.H ();
uint32 cols = area.W ();
void *dPtr = DirtyPixel (area.t,
area.l,
plane);
int32 dRowStep = fRowStep;
int32 dColStep = fColStep;
int32 dPlaneStep = fPlaneStep;
OptimizeOrder (dPtr,
fPixelSize,
rows,
cols,
planes,
dRowStep,
dColStep,
dPlaneStep);
switch (fPixelSize)
{
case 1:
{
if (rows == 1 && cols == 1 && dPlaneStep == 1 && value == 0)
{
DoZeroBytes (dPtr, planes);
}
else
{
DoSetArea8 ((uint8 *) dPtr,
(uint8) value,
rows,
cols,
planes,
dRowStep,
dColStep,
dPlaneStep);
}
break;
}
case 2:
{
if (rows == 1 && cols == 1 && dPlaneStep == 1 && value == 0)
{
DoZeroBytes (dPtr, planes << 1);
}
else
{
DoSetArea16 ((uint16 *) dPtr,
(uint16) value,
rows,
cols,
planes,
dRowStep,
dColStep,
dPlaneStep);
}
break;
}
case 4:
{
if (rows == 1 && cols == 1 && dPlaneStep == 1 && value == 0)
{
DoZeroBytes (dPtr, planes << 2);
}
else
{
DoSetArea32 ((uint32 *) dPtr,
value,
rows,
cols,
planes,
dRowStep,
dColStep,
dPlaneStep);
}
break;
}
default:
{
ThrowNotYetImplemented ();
}
}
}
/*****************************************************************************/
void dng_pixel_buffer::SetZero (const dng_rect &area,
uint32 plane,
uint32 planes)
{
uint32 value = 0;
switch (fPixelType)
{
case ttByte:
case ttShort:
case ttLong:
case ttFloat:
{
break;
}
case ttSShort:
{
value = 0x8000;
break;
}
default:
{
ThrowNotYetImplemented ();
}
}
SetConstant (area,
plane,
planes,
value);
}
/*****************************************************************************/
void dng_pixel_buffer::CopyArea (const dng_pixel_buffer &src,
const dng_rect &area,
uint32 srcPlane,
uint32 dstPlane,
uint32 planes)
{
uint32 rows = area.H ();
uint32 cols = area.W ();
const void *sPtr = src.ConstPixel (area.t,
area.l,
srcPlane);
void *dPtr = DirtyPixel (area.t,
area.l,
dstPlane);
int32 sRowStep = src.fRowStep;
int32 sColStep = src.fColStep;
int32 sPlaneStep = src.fPlaneStep;
int32 dRowStep = fRowStep;
int32 dColStep = fColStep;
int32 dPlaneStep = fPlaneStep;
OptimizeOrder (sPtr,
dPtr,
src.fPixelSize,
fPixelSize,
rows,
cols,
planes,
sRowStep,
sColStep,
sPlaneStep,
dRowStep,
dColStep,
dPlaneStep);
if (fPixelType == src.fPixelType)
{
if (rows == 1 && cols == 1 && sPlaneStep == 1 && dPlaneStep == 1)
{
DoCopyBytes (sPtr,
dPtr,
planes * fPixelSize);
}
else switch (fPixelSize)
{
case 1:
{
DoCopyArea8 ((const uint8 *) sPtr,
(uint8 *) dPtr,
rows,
cols,
planes,
sRowStep,
sColStep,
sPlaneStep,
dRowStep,
dColStep,
dPlaneStep);
break;
}
case 2:
{
DoCopyArea16 ((const uint16 *) sPtr,
(uint16 *) dPtr,
rows,
cols,
planes,
sRowStep,
sColStep,
sPlaneStep,
dRowStep,
dColStep,
dPlaneStep);
break;
}
case 4:
{
DoCopyArea32 ((const uint32 *) sPtr,
(uint32 *) dPtr,
rows,
cols,
planes,
sRowStep,
sColStep,
sPlaneStep,
dRowStep,
dColStep,
dPlaneStep);
break;
}
default:
{
ThrowNotYetImplemented ();
}
}
}
else if (src.fPixelType == ttByte)
{
switch (fPixelType)
{
case ttShort:
{
DoCopyArea8_16 ((const uint8 *) sPtr,
(uint16 *) dPtr,
rows,
cols,
planes,
sRowStep,
sColStep,
sPlaneStep,
dRowStep,
dColStep,
dPlaneStep);
break;
}
case ttSShort:
{
DoCopyArea8_S16 ((const uint8 *) sPtr,
(int16 *) dPtr,
rows,
cols,
planes,
sRowStep,
sColStep,
sPlaneStep,
dRowStep,
dColStep,
dPlaneStep);
break;
}
case ttLong:
{
DoCopyArea8_32 ((const uint8 *) sPtr,
(uint32 *) dPtr,
rows,
cols,
planes,
sRowStep,
sColStep,
sPlaneStep,
dRowStep,
dColStep,
dPlaneStep);
break;
}
case ttFloat:
{
DoCopyArea8_R32 ((const uint8 *) sPtr,
(real32 *) dPtr,
rows,
cols,
planes,
sRowStep,
sColStep,
sPlaneStep,
dRowStep,
dColStep,
dPlaneStep,
src.PixelRange ());
break;
}
default:
{
ThrowNotYetImplemented ();
}
}
}
else if (src.fPixelType == ttShort)
{
switch (fPixelType)
{
case ttByte:
{
DoCopyArea8 (((const uint8 *) sPtr) + (qDNGBigEndian ? 1 : 0),
(uint8 *) dPtr,
rows,
cols,
planes,
sRowStep << 1,
sColStep << 1,
sPlaneStep << 1,
dRowStep,
dColStep,
dPlaneStep);
break;
}
case ttSShort:
{
DoCopyArea16_S16 ((const uint16 *) sPtr,
(int16 *) dPtr,
rows,
cols,
planes,
sRowStep,
sColStep,
sPlaneStep,
dRowStep,
dColStep,
dPlaneStep);
break;
}
case ttLong:
{
DoCopyArea16_32 ((const uint16 *) sPtr,
(uint32 *) dPtr,
rows,
cols,
planes,
sRowStep,
sColStep,
sPlaneStep,
dRowStep,
dColStep,
dPlaneStep);
break;
}
case ttFloat:
{
DoCopyArea16_R32 ((const uint16 *) sPtr,
(real32 *) dPtr,
rows,
cols,
planes,
sRowStep,
sColStep,
sPlaneStep,
dRowStep,
dColStep,
dPlaneStep,
src.PixelRange ());
break;
}
default:
{
ThrowNotYetImplemented ();
}
}
}
else if (src.fPixelType == ttSShort)
{
switch (fPixelType)
{
case ttByte:
{
DoCopyArea8 (((const uint8 *) sPtr) + (qDNGBigEndian ? 1 : 0),
(uint8 *) dPtr,
rows,
cols,
planes,
sRowStep << 1,
sColStep << 1,
sPlaneStep << 1,
dRowStep,
dColStep,
dPlaneStep);
break;
}
case ttShort:
{
// Moving between signed 16 bit values and unsigned 16
// bit values just requires toggling the sign bit. So
// we can use the "backwards" bottleneck.
DoCopyArea16_S16 ((const uint16 *) sPtr,
(int16 *) dPtr,
rows,
cols,
planes,
sRowStep,
sColStep,
sPlaneStep,
dRowStep,
dColStep,
dPlaneStep);
break;
}
case ttFloat:
{
DoCopyAreaS16_R32 ((const int16 *) sPtr,
(real32 *) dPtr,
rows,
cols,
planes,
sRowStep,
sColStep,
sPlaneStep,
dRowStep,
dColStep,
dPlaneStep,
src.PixelRange ());
break;
}
default:
{
ThrowNotYetImplemented ();
}
}
}
else if (src.fPixelType == ttLong)
{
switch (fPixelType)
{
case ttByte:
{
DoCopyArea8 (((const uint8 *) sPtr) + (qDNGBigEndian ? 3 : 0),
(uint8 *) dPtr,
rows,
cols,
planes,
sRowStep << 2,
sColStep << 2,
sPlaneStep << 2,
dRowStep,
dColStep,
dPlaneStep);
break;
}
case ttShort:
{
DoCopyArea16 (((const uint16 *) sPtr) + (qDNGBigEndian ? 1 : 0),
(uint16 *) dPtr,
rows,
cols,
planes,
sRowStep << 1,
sColStep << 1,
sPlaneStep << 1,
dRowStep,
dColStep,
dPlaneStep);
break;
}
default:
{
ThrowNotYetImplemented ();
}
}
}
else if (src.fPixelType == ttFloat)
{
switch (fPixelType)
{
case ttByte:
{
DoCopyAreaR32_8 ((const real32 *) sPtr,
(uint8 *) dPtr,
rows,
cols,
planes,
sRowStep,
sColStep,
sPlaneStep,
dRowStep,
dColStep,
dPlaneStep,
PixelRange ());
break;
}
case ttShort:
{
DoCopyAreaR32_16 ((const real32 *) sPtr,
(uint16 *) dPtr,
rows,
cols,
planes,
sRowStep,
sColStep,
sPlaneStep,
dRowStep,
dColStep,
dPlaneStep,
PixelRange ());
break;
}
case ttSShort:
{
DoCopyAreaR32_S16 ((const real32 *) sPtr,
(int16 *) dPtr,
rows,
cols,
planes,
sRowStep,
sColStep,
sPlaneStep,
dRowStep,
dColStep,
dPlaneStep,
PixelRange ());
break;
}
default:
{
ThrowNotYetImplemented ();
}
}
}
else
{
ThrowNotYetImplemented ();
}
}
/*****************************************************************************/
dng_point dng_pixel_buffer::RepeatPhase (const dng_rect &srcArea,
const dng_rect &dstArea)
{
int32 repeatV = srcArea.H ();
int32 repeatH = srcArea.W ();
int32 phaseV;
int32 phaseH;
if (srcArea.t >= dstArea.t)
{
phaseV = (repeatV - ((srcArea.t - dstArea.t) % repeatV)) % repeatV;
}
else
{
phaseV = (dstArea.t - srcArea.t) % repeatV;
}
if (srcArea.l >= dstArea.l)
{
phaseH = (repeatH - ((srcArea.l - dstArea.l) % repeatH)) % repeatH;
}
else
{
phaseH = (dstArea.l - srcArea.l) % repeatH;
}
return dng_point (phaseV, phaseH);
}
/*****************************************************************************/
void dng_pixel_buffer::RepeatArea (const dng_rect &srcArea,
const dng_rect &dstArea)
{
dng_point repeat = srcArea.Size ();
dng_point phase = RepeatPhase (srcArea,
dstArea);
const void *sPtr = ConstPixel (srcArea.t,
srcArea.l,
fPlane);
void *dPtr = DirtyPixel (dstArea.t,
dstArea.l,
fPlane);
uint32 rows = dstArea.H ();
uint32 cols = dstArea.W ();
switch (fPixelSize)
{
case 1:
{
DoRepeatArea8 ((const uint8 *) sPtr,
(uint8 *) dPtr,
rows,
cols,
fPlanes,
fRowStep,
fColStep,
fPlaneStep,
repeat.v,
repeat.h,
phase.v,
phase.h);
break;
}
case 2:
{
DoRepeatArea16 ((const uint16 *) sPtr,
(uint16 *) dPtr,
rows,
cols,
fPlanes,
fRowStep,
fColStep,
fPlaneStep,
repeat.v,
repeat.h,
phase.v,
phase.h);
break;
}
case 4:
{
DoRepeatArea32 ((const uint32 *) sPtr,
(uint32 *) dPtr,
rows,
cols,
fPlanes,
fRowStep,
fColStep,
fPlaneStep,
repeat.v,
repeat.h,
phase.v,
phase.h);
break;
}
default:
{
ThrowNotYetImplemented ();
}
}
}
/*****************************************************************************/
void dng_pixel_buffer::RepeatSubArea (const dng_rect subArea,
uint32 repeatV,
uint32 repeatH)
{
if (fArea.t < subArea.t)
{
RepeatArea (dng_rect (subArea.t , fArea.l,
subArea.t + repeatV, fArea.r),
dng_rect (fArea.t , fArea.l,
subArea.t , fArea.r));
}
if (fArea.b > subArea.b)
{
RepeatArea (dng_rect (subArea.b - repeatV, fArea.l,
subArea.b , fArea.r),
dng_rect (subArea.b , fArea.l,
fArea.b , fArea.r));
}
if (fArea.l < subArea.l)
{
RepeatArea (dng_rect (fArea.t, subArea.l ,
fArea.b, subArea.l + repeatH),
dng_rect (fArea.t, fArea.l ,
fArea.b, subArea.l ));
}
if (fArea.r > subArea.r)
{
RepeatArea (dng_rect (fArea.t, subArea.r - repeatH,
fArea.b, subArea.r ),
dng_rect (fArea.t, subArea.r ,
fArea.b, fArea.r ));
}
}
/*****************************************************************************/
void dng_pixel_buffer::ShiftRight (uint32 shift)
{
if (fPixelType != ttShort)
{
ThrowNotYetImplemented ();
}
uint32 rows = fArea.H ();
uint32 cols = fArea.W ();
uint32 planes = fPlanes;
void *dPtr = DirtyPixel (fArea.t,
fArea.l,
fPlane);
const void *sPtr = dPtr;
int32 sRowStep = fRowStep;
int32 sColStep = fColStep;
int32 sPlaneStep = fPlaneStep;
int32 dRowStep = fRowStep;
int32 dColStep = fColStep;
int32 dPlaneStep = fPlaneStep;
OptimizeOrder (sPtr,
dPtr,
fPixelSize,
fPixelSize,
rows,
cols,
planes,
sRowStep,
sColStep,
sPlaneStep,
dRowStep,
dColStep,
dPlaneStep);
DoShiftRight16 ((uint16 *) dPtr,
rows,
cols,
planes,
dRowStep,
dColStep,
dPlaneStep,
shift);
}
/*****************************************************************************/
void dng_pixel_buffer::FlipH ()
{
fData = InternalPixel (fArea.t, fArea.r - 1);
fColStep = -fColStep;
}
/*****************************************************************************/
void dng_pixel_buffer::FlipV ()
{
fData = InternalPixel (fArea.b - 1, fArea.l);
fRowStep = -fRowStep;
}
/*****************************************************************************/
void dng_pixel_buffer::FlipZ ()
{
fData = InternalPixel (fArea.t, fArea.l, fPlanes - 1);
fPlaneStep = -fPlaneStep;
}
/*****************************************************************************/
bool dng_pixel_buffer::EqualArea (const dng_pixel_buffer &src,
const dng_rect &area,
uint32 plane,
uint32 planes) const
{
uint32 rows = area.H ();
uint32 cols = area.W ();
const void *sPtr = src.ConstPixel (area.t,
area.l,
plane);
const void *dPtr = ConstPixel (area.t,
area.l,
plane);
int32 sRowStep = src.fRowStep;
int32 sColStep = src.fColStep;
int32 sPlaneStep = src.fPlaneStep;
int32 dRowStep = fRowStep;
int32 dColStep = fColStep;
int32 dPlaneStep = fPlaneStep;
if (fPixelType == src.fPixelType)
{
if (rows == 1 && cols == 1 && sPlaneStep == 1 && dPlaneStep == 1)
{
return DoEqualBytes (sPtr,
dPtr,
planes * fPixelSize);
}
else switch (fPixelSize)
{
case 1:
{
return DoEqualArea8 ((const uint8 *) sPtr,
(const uint8 *) dPtr,
rows,
cols,
planes,
sRowStep,
sColStep,
sPlaneStep,
dRowStep,
dColStep,
dPlaneStep);
break;
}
case 2:
{
return DoEqualArea16 ((const uint16 *) sPtr,
(const uint16 *) dPtr,
rows,
cols,
planes,
sRowStep,
sColStep,
sPlaneStep,
dRowStep,
dColStep,
dPlaneStep);
break;
}
case 4:
{
return DoEqualArea32 ((const uint32 *) sPtr,
(const uint32 *) dPtr,
rows,
cols,
planes,
sRowStep,
sColStep,
sPlaneStep,
dRowStep,
dColStep,
dPlaneStep);
break;
}
default:
{
ThrowNotYetImplemented ();
return false;
}
}
}
else
return false;
}
/*****************************************************************************/
namespace
{
template <typename T>
real64 MaxDiff (const T *src1,
int32 s1RowStep,
int32 s1PlaneStep,
const T *src2,
int32 s2RowStep,
int32 s2PlaneStep,
uint32 rows,
uint32 cols,
uint32 planes)
{
real64 result = 0.0;
for (uint32 plane = 0; plane < planes; plane++)
{
const T *src1Save = src1;
const T *src2Save = src2;
for (uint32 row = 0; row < rows; row++)
{
for (uint32 col = 0; col < cols; col++)
{
real64 diff = fabs ((real64)src1 [col] - src2 [col]);
if (diff > result)
result = diff;
}
src1 += s1RowStep;
src2 += s2RowStep;
}
src1 = src1Save + s1PlaneStep;
src2 = src2Save + s2PlaneStep;
}
return result;
}
template <typename T>
real64 MaxDiff (const T *src1,
int32 s1ColStep,
int32 s1RowStep,
int32 s1PlaneStep,
const T *src2,
int32 s2ColStep,
int32 s2RowStep,
int32 s2PlaneStep,
uint32 rows,
uint32 cols,
uint32 planes)
{
if (s1ColStep == s2ColStep &&
s1ColStep == 1)
return MaxDiff (src1,
s1RowStep,
s1PlaneStep,
src2,
s2RowStep,
s2PlaneStep,
rows,
cols,
planes);
real64 result = 0.0;
for (uint32 plane = 0; plane < planes; plane++)
{
const T *src1Save = src1;
const T *src2Save = src2;
for (uint32 row = 0; row < rows; row++)
{
for (uint32 col = 0; col < cols; col++)
{
real64 diff = fabs ((real64)src1 [col * s1ColStep] - src2 [col * s2ColStep]);
if (diff > result)
result = diff;
}
src1 += s1RowStep;
src2 += s2RowStep;
}
src1 = src1Save + s1PlaneStep;
src2 = src2Save + s2PlaneStep;
}
return result;
}
}
real64 dng_pixel_buffer::MaximumDifference (const dng_pixel_buffer &rhs,
const dng_rect &area,
uint32 plane,
uint32 planes) const
{
uint32 rows = area.H ();
uint32 cols = area.W ();
const void *s1Ptr = rhs.ConstPixel (area.t,
area.l,
plane);
const void *s2Ptr = ConstPixel (area.t,
area.l,
plane);
int32 s1RowStep = rhs.fRowStep;
int32 s1ColStep = rhs.fColStep;
int32 s1PlaneStep = rhs.fPlaneStep;
int32 s2RowStep = fRowStep;
int32 s2ColStep = fColStep;
int32 s2PlaneStep = fPlaneStep;
if (fPixelType == rhs.fPixelType)
{
switch (fPixelType)
{
case ttByte:
return MaxDiff ((const uint8 *)s1Ptr,
s1ColStep,
s1RowStep,
s1PlaneStep,
(const uint8 *)s2Ptr,
s2ColStep,
s2RowStep,
s2PlaneStep,
rows,
cols,
planes);
break;
case ttShort:
return MaxDiff ((const uint16 *)s1Ptr,
s1ColStep,
s1RowStep,
s1PlaneStep,
(const uint16 *)s2Ptr,
s2ColStep,
s2RowStep,
s2PlaneStep,
rows,
cols,
planes);
break;
case ttLong:
return MaxDiff ((const uint32 *)s1Ptr,
s1ColStep,
s1RowStep,
s1PlaneStep,
(const uint32 *)s2Ptr,
s2ColStep,
s2RowStep,
s2PlaneStep,
rows,
cols,
planes);
break;
case ttSByte:
return MaxDiff ((const int8 *)s1Ptr,
s1ColStep,
s1RowStep,
s1PlaneStep,
(const int8 *)s2Ptr,
s2ColStep,
s2RowStep,
s2PlaneStep,
rows,
cols,
planes);
break;
case ttSShort:
return MaxDiff ((const int16 *)s1Ptr,
s1ColStep,
s1RowStep,
s1PlaneStep,
(const int16 *)s2Ptr,
s2ColStep,
s2RowStep,
s2PlaneStep,
rows,
cols,
planes);
break;
case ttSLong:
return MaxDiff ((const int32 *)s1Ptr,
s1ColStep,
s1RowStep,
s1PlaneStep,
(const int32 *)s2Ptr,
s2ColStep,
s2RowStep,
s2PlaneStep,
rows,
cols,
planes);
break;
case ttFloat:
return MaxDiff ((const real32 *)s1Ptr,
s1ColStep,
s1RowStep,
s1PlaneStep,
(const real32 *)s2Ptr,
s2ColStep,
s2RowStep,
s2PlaneStep,
rows,
cols,
planes);
break;
case ttDouble:
return MaxDiff ((const real64 *)s1Ptr,
s1ColStep,
s1RowStep,
s1PlaneStep,
(const real64 *)s2Ptr,
s2ColStep,
s2RowStep,
s2PlaneStep,
rows,
cols,
planes);
break;
default:
{
ThrowNotYetImplemented ();
return 0.0;
}
}
}
else
ThrowProgramError ("attempt to difference pixel buffers of different formats.");
return 0.0;
}
/*****************************************************************************/