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