You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
757 lines
16 KiB
757 lines
16 KiB
/*****************************************************************************/ |
|
// Copyright 2006-2012 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_utils.cpp#3 $ */ |
|
/* $DateTime: 2012/08/12 15:38:38 $ */ |
|
/* $Change: 842799 $ */ |
|
/* $Author: tknoll $ */ |
|
|
|
/*****************************************************************************/ |
|
|
|
#include "dng_utils.h" |
|
|
|
#include "dng_area_task.h" |
|
#include "dng_assertions.h" |
|
#include "dng_bottlenecks.h" |
|
#include "dng_exceptions.h" |
|
#include "dng_host.h" |
|
#include "dng_image.h" |
|
#include "dng_flags.h" |
|
#include "dng_point.h" |
|
#include "dng_rect.h" |
|
#include "dng_safe_arithmetic.h" |
|
#include "dng_tag_types.h" |
|
#include "dng_tile_iterator.h" |
|
|
|
#if qMacOS |
|
#include <TargetConditionals.h> |
|
#if TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR |
|
#include <MobileCoreServices/MobileCoreServices.h> |
|
#else |
|
#include <CoreServices/CoreServices.h> |
|
#endif // TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR |
|
#endif // qMacOS |
|
|
|
#if qiPhone || qMacOS |
|
// these provide timers |
|
#include <mach/mach.h> |
|
#include <mach/mach_time.h> |
|
#endif |
|
|
|
#if qWinOS |
|
#include <windows.h> |
|
#else |
|
#include <sys/time.h> |
|
#include <stdarg.h> // for va_start/va_end |
|
#endif |
|
|
|
/*****************************************************************************/ |
|
|
|
#if qDNGDebug |
|
|
|
/*****************************************************************************/ |
|
|
|
#if qMacOS |
|
#define DNG_DEBUG_BREAK __asm__ volatile ("int3") |
|
#elif qWinOS |
|
#if qDNG64Bit |
|
// no inline assembly on Win 64-bit, so use DebugBreak |
|
#define DNG_DEBUG_BREAK DebugBreak() |
|
#else |
|
#define DNG_DEBUG_BREAK __asm__ volatile ("int3") |
|
#endif |
|
#elif qiPhone |
|
// simulator is running on Intel |
|
#if qiPhoneSimulator |
|
#define DNG_DEBUG_BREAK __asm__ volatile ("int3") |
|
#else |
|
// The debugger doesn't restore program counter after this is called. |
|
// Caller must move program counter past line to continue. |
|
// As of iOS5/xCode 4.2, recovery may not be possible. |
|
#define DNG_DEBUG_BREAK __asm__ volatile ("bkpt 1") |
|
#endif |
|
#elif qAndroid |
|
#define DNG_DEBUG_BREAK __asm__ volatile ("bkpt 1") |
|
#elif qLinux |
|
#define DNG_DEBUG_BREAK __asm__ volatile ("int3") |
|
#else |
|
#define DNG_DEBUG_BREAK |
|
#endif |
|
|
|
/*****************************************************************************/ |
|
|
|
bool gPrintAsserts = true; |
|
bool gBreakOnAsserts = true; |
|
|
|
/*****************************************************************************/ |
|
|
|
void dng_show_message (const char *s) |
|
{ |
|
|
|
#if qDNGPrintMessages |
|
|
|
// display the message |
|
if (gPrintAsserts) |
|
fprintf (stderr, "%s\n", s); |
|
|
|
#elif qiPhone || qAndroid || qLinux |
|
|
|
if (gPrintAsserts) |
|
fprintf (stderr, "%s\n", s); |
|
|
|
// iOS doesn't print a message to the console like DebugStr and MessageBox do, so we have to do both |
|
// You'll have to advance the program counter manually past this statement |
|
if (gBreakOnAsserts) |
|
DNG_DEBUG_BREAK; |
|
|
|
#elif qMacOS |
|
|
|
if (gBreakOnAsserts) |
|
{ |
|
// truncate the to 255 chars |
|
char ss [256]; |
|
|
|
uint32 len = strlen (s); |
|
if (len > 255) |
|
len = 255; |
|
strncpy (&(ss [1]), s, len ); |
|
ss [0] = (unsigned char) len; |
|
|
|
DebugStr ((unsigned char *) ss); |
|
} |
|
else if (gPrintAsserts) |
|
{ |
|
fprintf (stderr, "%s\n", s); |
|
} |
|
|
|
#elif qWinOS |
|
|
|
// display a dialog |
|
// This is not thread safe. Multiple message boxes can be launched. |
|
// Should also be launched in its own thread so main msg queue isn't thrown off. |
|
if (gBreakOnAsserts) |
|
MessageBoxA (NULL, (LPSTR) s, NULL, MB_OK); |
|
else if (gPrintAsserts) |
|
fprintf (stderr, "%s\n", s); |
|
|
|
#endif |
|
|
|
} |
|
|
|
/*****************************************************************************/ |
|
|
|
void dng_show_message_f (const char *fmt, ... ) |
|
{ |
|
|
|
char buffer [1024]; |
|
|
|
va_list ap; |
|
va_start (ap, fmt); |
|
|
|
vsnprintf (buffer, sizeof (buffer), fmt, ap); |
|
|
|
va_end (ap); |
|
|
|
dng_show_message (buffer); |
|
|
|
} |
|
|
|
/*****************************************************************************/ |
|
|
|
#endif |
|
|
|
/*****************************************************************************/ |
|
|
|
uint32 ComputeBufferSize(uint32 pixelType, const dng_point &tileSize, |
|
uint32 numPlanes, PaddingType paddingType) |
|
|
|
{ |
|
|
|
// Convert tile size to uint32. |
|
if (tileSize.h < 0 || tileSize.v < 0) |
|
{ |
|
ThrowMemoryFull("Negative tile size"); |
|
} |
|
const uint32 tileSizeH = static_cast<uint32>(tileSize.h); |
|
const uint32 tileSizeV = static_cast<uint32>(tileSize.v); |
|
|
|
const uint32 pixelSize = TagTypeSize(pixelType); |
|
|
|
// Add padding to width if necessary. |
|
uint32 paddedWidth = tileSizeH; |
|
if (paddingType == pad16Bytes) |
|
{ |
|
if (!RoundUpForPixelSize(paddedWidth, pixelSize, &paddedWidth)) |
|
{ |
|
ThrowMemoryFull("Arithmetic overflow computing buffer size"); |
|
} |
|
} |
|
|
|
// Compute buffer size. |
|
uint32 bufferSize; |
|
if (!SafeUint32Mult(paddedWidth, tileSizeV, &bufferSize) || |
|
!SafeUint32Mult(bufferSize, pixelSize, &bufferSize) || |
|
!SafeUint32Mult(bufferSize, numPlanes, &bufferSize)) |
|
{ |
|
ThrowMemoryFull("Arithmetic overflow computing buffer size"); |
|
} |
|
|
|
return bufferSize; |
|
} |
|
|
|
/*****************************************************************************/ |
|
|
|
real64 TickTimeInSeconds () |
|
{ |
|
|
|
#if qWinOS |
|
|
|
// One might think it prudent to cache the frequency here, however |
|
// low-power CPU modes can, and do, change the value returned. |
|
// Thus the frequencey needs to be retrieved each time. |
|
|
|
// Note that the frequency changing can cause the return |
|
// result to jump backwards, which is why the TickCountInSeconds |
|
// (below) also exists. |
|
|
|
// Just plug in laptop when doing timings to minimize this. |
|
// QPC/QPH is a slow call compared to rtdsc. |
|
|
|
#if qImagecore |
|
|
|
// You should be plugged-in when measuring. |
|
|
|
static real64 freqMultiplier = 0.0; |
|
|
|
if (freqMultiplier == 0.0) |
|
{ |
|
|
|
LARGE_INTEGER freq; |
|
|
|
QueryPerformanceFrequency (&freq); |
|
|
|
freqMultiplier = 1.0 / (real64) freq.QuadPart; |
|
|
|
} |
|
|
|
#else |
|
|
|
LARGE_INTEGER freq; |
|
|
|
QueryPerformanceFrequency (&freq); |
|
|
|
real64 freqMultiplier = 1.0 / (real64) freq.QuadPart; |
|
|
|
#endif // qImagecore |
|
|
|
LARGE_INTEGER cycles; |
|
|
|
QueryPerformanceCounter (&cycles); |
|
|
|
return (real64) cycles.QuadPart * freqMultiplier; |
|
|
|
#elif qiPhone || qMacOS |
|
|
|
// this is switching Mac to high performance timer |
|
// and this is also the timer for iPhone |
|
|
|
// assume frequency is unchanging, requesting frequency every time call |
|
// is too slow. multiple cores, different frequency ? |
|
|
|
static real64 freqMultiplier = 0.0; |
|
if (freqMultiplier == 0.0) |
|
{ |
|
mach_timebase_info_data_t freq; |
|
mach_timebase_info(&freq); |
|
|
|
// converts from nanos to micros |
|
// numer = 125, denom = 3 * 1000 |
|
freqMultiplier = ((real64)freq.numer / (real64)freq.denom) * 1.0e-9; |
|
} |
|
|
|
return mach_absolute_time() * freqMultiplier; |
|
|
|
#elif qAndroid || qLinux |
|
|
|
//this is a fast timer to nanos |
|
struct timespec now; |
|
clock_gettime(CLOCK_MONOTONIC, &now); |
|
return now.tv_sec + (real64)now.tv_nsec * 1.0e-9; |
|
|
|
#else |
|
|
|
// Perhaps a better call exists. (e.g. avoid adjtime effects) |
|
|
|
struct timeval tv; |
|
|
|
gettimeofday (&tv, NULL); |
|
|
|
return tv.tv_sec + (real64)tv.tv_usec * 1.0e-6; |
|
|
|
#endif |
|
|
|
} |
|
|
|
/*****************************************************************************/ |
|
|
|
real64 TickCountInSeconds () |
|
{ |
|
|
|
#if qWinOS |
|
|
|
return GetTickCount () * (1.0 / 1000.0); |
|
|
|
#elif qMacOS |
|
|
|
#if TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR |
|
// TODO: Needs implementation. |
|
ThrowProgramError ("TickCountInSeconds() not implemented on iOS"); |
|
return 0; |
|
#else |
|
return TickCount () * (1.0 / 60.0); |
|
#endif // TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR |
|
|
|
#else |
|
|
|
return TickTimeInSeconds (); |
|
|
|
#endif |
|
|
|
} |
|
|
|
/*****************************************************************************/ |
|
|
|
bool gDNGShowTimers = true; |
|
|
|
dng_timer::dng_timer (const char *message) |
|
|
|
: fMessage (message ) |
|
, fStartTime (TickTimeInSeconds ()) |
|
|
|
{ |
|
|
|
} |
|
|
|
/*****************************************************************************/ |
|
|
|
dng_timer::~dng_timer () |
|
{ |
|
|
|
if (!gDNGShowTimers) |
|
return; |
|
|
|
real64 totalTime = TickTimeInSeconds () - fStartTime; |
|
|
|
fprintf (stderr, "%s: %0.3f sec\n", fMessage, totalTime); |
|
|
|
} |
|
|
|
/*****************************************************************************/ |
|
|
|
real64 MaxSquaredDistancePointToRect (const dng_point_real64 &point, |
|
const dng_rect_real64 &rect) |
|
{ |
|
|
|
real64 distSqr = DistanceSquared (point, |
|
rect.TL ()); |
|
|
|
distSqr = Max_real64 (distSqr, |
|
DistanceSquared (point, |
|
rect.BL ())); |
|
|
|
distSqr = Max_real64 (distSqr, |
|
DistanceSquared (point, |
|
rect.BR ())); |
|
|
|
distSqr = Max_real64 (distSqr, |
|
DistanceSquared (point, |
|
rect.TR ())); |
|
|
|
return distSqr; |
|
|
|
} |
|
|
|
/*****************************************************************************/ |
|
|
|
real64 MaxDistancePointToRect (const dng_point_real64 &point, |
|
const dng_rect_real64 &rect) |
|
{ |
|
|
|
return sqrt (MaxSquaredDistancePointToRect (point, |
|
rect)); |
|
|
|
} |
|
|
|
/*****************************************************************************/ |
|
|
|
dng_dither::dng_dither () |
|
|
|
: fNoiseBuffer () |
|
|
|
{ |
|
|
|
const uint32 kSeed = 1; |
|
|
|
fNoiseBuffer.Allocate (kRNGSize2D * sizeof (uint16)); |
|
|
|
uint16 *buffer = fNoiseBuffer.Buffer_uint16 (); |
|
|
|
uint32 seed = kSeed; |
|
|
|
for (uint32 i = 0; i < kRNGSize2D; i++) |
|
{ |
|
|
|
seed = DNG_Random (seed); |
|
|
|
buffer [i] = (uint16) (seed); |
|
|
|
} |
|
|
|
} |
|
|
|
/******************************************************************************/ |
|
|
|
const dng_dither & dng_dither::Get () |
|
{ |
|
|
|
static dng_dither dither; |
|
|
|
return dither; |
|
|
|
} |
|
|
|
/*****************************************************************************/ |
|
|
|
void HistogramArea (dng_host & /* host */, |
|
const dng_image &image, |
|
const dng_rect &area, |
|
uint32 *hist, |
|
uint32 maxValue, |
|
uint32 plane) |
|
{ |
|
|
|
DNG_ASSERT (image.PixelType () == ttShort, "Unsupported pixel type"); |
|
|
|
DoZeroBytes (hist, (maxValue + 1) * (uint32) sizeof (uint32)); |
|
|
|
dng_rect tile; |
|
|
|
dng_tile_iterator iter (image, area); |
|
|
|
while (iter.GetOneTile (tile)) |
|
{ |
|
|
|
dng_const_tile_buffer buffer (image, tile); |
|
|
|
const void *sPtr = buffer.ConstPixel (tile.t, |
|
tile.l, |
|
plane); |
|
|
|
uint32 count0 = 1; |
|
uint32 count1 = tile.H (); |
|
uint32 count2 = tile.W (); |
|
|
|
int32 step0 = 0; |
|
int32 step1 = buffer.fRowStep; |
|
int32 step2 = buffer.fColStep; |
|
|
|
OptimizeOrder (sPtr, |
|
buffer.fPixelSize, |
|
count0, |
|
count1, |
|
count2, |
|
step0, |
|
step1, |
|
step2); |
|
|
|
DNG_ASSERT (count0 == 1, "OptimizeOrder logic error"); |
|
|
|
const uint16 *s1 = (const uint16 *) sPtr; |
|
|
|
for (uint32 row = 0; row < count1; row++) |
|
{ |
|
|
|
if (maxValue == 0x0FFFF && step2 == 1) |
|
{ |
|
|
|
for (uint32 col = 0; col < count2; col++) |
|
{ |
|
|
|
uint32 x = s1 [col]; |
|
|
|
hist [x] ++; |
|
|
|
} |
|
|
|
} |
|
|
|
else |
|
{ |
|
|
|
const uint16 *s2 = s1; |
|
|
|
for (uint32 col = 0; col < count2; col++) |
|
{ |
|
|
|
uint32 x = s2 [0]; |
|
|
|
if (x <= maxValue) |
|
{ |
|
|
|
hist [x] ++; |
|
|
|
} |
|
|
|
s2 += step2; |
|
|
|
} |
|
|
|
} |
|
|
|
s1 += step1; |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
/*****************************************************************************/ |
|
|
|
class dng_limit_float_depth_task: public dng_area_task |
|
{ |
|
|
|
private: |
|
|
|
const dng_image &fSrcImage; |
|
|
|
dng_image &fDstImage; |
|
|
|
uint32 fBitDepth; |
|
|
|
real32 fScale; |
|
|
|
public: |
|
|
|
dng_limit_float_depth_task (const dng_image &srcImage, |
|
dng_image &dstImage, |
|
uint32 bitDepth, |
|
real32 scale); |
|
|
|
virtual dng_rect RepeatingTile1 () const |
|
{ |
|
return fSrcImage.RepeatingTile (); |
|
} |
|
|
|
virtual dng_rect RepeatingTile2 () const |
|
{ |
|
return fDstImage.RepeatingTile (); |
|
} |
|
|
|
virtual void Process (uint32 threadIndex, |
|
const dng_rect &tile, |
|
dng_abort_sniffer *sniffer); |
|
|
|
}; |
|
|
|
/*****************************************************************************/ |
|
|
|
dng_limit_float_depth_task::dng_limit_float_depth_task (const dng_image &srcImage, |
|
dng_image &dstImage, |
|
uint32 bitDepth, |
|
real32 scale) |
|
|
|
: fSrcImage (srcImage) |
|
, fDstImage (dstImage) |
|
, fBitDepth (bitDepth) |
|
, fScale (scale) |
|
|
|
{ |
|
|
|
} |
|
|
|
/*****************************************************************************/ |
|
|
|
void dng_limit_float_depth_task::Process (uint32 /* threadIndex */, |
|
const dng_rect &tile, |
|
dng_abort_sniffer * /* sniffer */) |
|
{ |
|
|
|
dng_const_tile_buffer srcBuffer (fSrcImage, tile); |
|
dng_dirty_tile_buffer dstBuffer (fDstImage, tile); |
|
|
|
uint32 count0 = tile.H (); |
|
uint32 count1 = tile.W (); |
|
uint32 count2 = fDstImage.Planes (); |
|
|
|
int32 sStep0 = srcBuffer.fRowStep; |
|
int32 sStep1 = srcBuffer.fColStep; |
|
int32 sStep2 = srcBuffer.fPlaneStep; |
|
|
|
int32 dStep0 = dstBuffer.fRowStep; |
|
int32 dStep1 = dstBuffer.fColStep; |
|
int32 dStep2 = dstBuffer.fPlaneStep; |
|
|
|
const void *sPtr = srcBuffer.ConstPixel (tile.t, |
|
tile.l, |
|
0); |
|
|
|
void *dPtr = dstBuffer.DirtyPixel (tile.t, |
|
tile.l, |
|
0); |
|
|
|
OptimizeOrder (sPtr, |
|
dPtr, |
|
srcBuffer.fPixelSize, |
|
dstBuffer.fPixelSize, |
|
count0, |
|
count1, |
|
count2, |
|
sStep0, |
|
sStep1, |
|
sStep2, |
|
dStep0, |
|
dStep1, |
|
dStep2); |
|
|
|
const real32 *sPtr0 = (const real32 *) sPtr; |
|
real32 *dPtr0 = ( real32 *) dPtr; |
|
|
|
real32 scale = fScale; |
|
|
|
bool limit16 = (fBitDepth == 16); |
|
bool limit24 = (fBitDepth == 24); |
|
|
|
for (uint32 index0 = 0; index0 < count0; index0++) |
|
{ |
|
|
|
const real32 *sPtr1 = sPtr0; |
|
real32 *dPtr1 = dPtr0; |
|
|
|
for (uint32 index1 = 0; index1 < count1; index1++) |
|
{ |
|
|
|
// If the scale is a NOP, and the data is packed solid, we can just do memory |
|
// copy. |
|
|
|
if (scale == 1.0f && sStep2 == 1 && dStep2 == 1) |
|
{ |
|
|
|
if (dPtr1 != sPtr1) // srcImage != dstImage |
|
{ |
|
|
|
memcpy (dPtr1, sPtr1, count2 * (uint32) sizeof (real32)); |
|
|
|
} |
|
|
|
} |
|
|
|
else |
|
{ |
|
|
|
const real32 *sPtr2 = sPtr1; |
|
real32 *dPtr2 = dPtr1; |
|
|
|
for (uint32 index2 = 0; index2 < count2; index2++) |
|
{ |
|
|
|
real32 x = sPtr2 [0]; |
|
|
|
x *= scale; |
|
|
|
dPtr2 [0] = x; |
|
|
|
sPtr2 += sStep2; |
|
dPtr2 += dStep2; |
|
|
|
} |
|
|
|
} |
|
|
|
// The data is now in the destination buffer. |
|
|
|
if (limit16) |
|
{ |
|
|
|
uint32 *dPtr2 = (uint32 *) dPtr1; |
|
|
|
for (uint32 index2 = 0; index2 < count2; index2++) |
|
{ |
|
|
|
uint32 x = dPtr2 [0]; |
|
|
|
uint16 y = DNG_FloatToHalf (x); |
|
|
|
x = DNG_HalfToFloat (y); |
|
|
|
dPtr2 [0] = x; |
|
|
|
dPtr2 += dStep2; |
|
|
|
} |
|
|
|
} |
|
|
|
else if (limit24) |
|
{ |
|
|
|
uint32 *dPtr2 = (uint32 *) dPtr1; |
|
|
|
for (uint32 index2 = 0; index2 < count2; index2++) |
|
{ |
|
|
|
uint32 x = dPtr2 [0]; |
|
|
|
uint8 temp [3]; |
|
|
|
DNG_FloatToFP24 (x, temp); |
|
|
|
x = DNG_FP24ToFloat (temp); |
|
|
|
dPtr2 [0] = x; |
|
|
|
dPtr2 += dStep2; |
|
|
|
} |
|
|
|
} |
|
|
|
sPtr1 += sStep1; |
|
dPtr1 += dStep1; |
|
|
|
} |
|
|
|
sPtr0 += sStep0; |
|
dPtr0 += dStep0; |
|
|
|
} |
|
|
|
} |
|
|
|
/******************************************************************************/ |
|
|
|
void LimitFloatBitDepth (dng_host &host, |
|
const dng_image &srcImage, |
|
dng_image &dstImage, |
|
uint32 bitDepth, |
|
real32 scale) |
|
{ |
|
|
|
DNG_ASSERT (srcImage.PixelType () == ttFloat, "Floating point image expected"); |
|
DNG_ASSERT (dstImage.PixelType () == ttFloat, "Floating point image expected"); |
|
|
|
dng_limit_float_depth_task task (srcImage, |
|
dstImage, |
|
bitDepth, |
|
scale); |
|
|
|
host.PerformAreaTask (task, dstImage.Bounds ()); |
|
|
|
} |
|
|
|
/*****************************************************************************/
|
|
|