void dng_hue_sat_map::SetDivisions (uint32 hueDivisions,
uint32 satDivisions,
uint32 valDivisions)
{
DNG_ASSERT (hueDivisions >= 1, "Must have at least 1 hue division.");
DNG_ASSERT (satDivisions >= 2, "Must have at least 2 sat divisions.");
if (valDivisions == 0)
valDivisions = 1;
if (hueDivisions == fHueDivisions &&
satDivisions == fSatDivisions &&
valDivisions == fValDivisions)
{
return;
}
fHueDivisions = hueDivisions;
fSatDivisions = satDivisions;
fValDivisions = valDivisions;
fHueStep = satDivisions;
fValStep = hueDivisions * fHueStep;
uint32 size = DeltasCount () * sizeof (HSBModify);
fDeltas.Allocate (size);
DoZeroBytes (fDeltas.Buffer (), size);
}
void dng_mutex::Unlock ()
{
#if qDNGThreadSafe
DNG_ASSERT (gInnermostMutexHolder.GetInnermostMutex () == this, "Mutexes unlocked out of order!!!");
if (fRecursiveLockCount > 0)
{
fRecursiveLockCount--;
return;
}
gInnermostMutexHolder.SetInnermostMutex (fPrevHeldMutex);
fPrevHeldMutex = NULL;
pthread_mutex_unlock (&fPthreadMutex);
#endif
}
const dng_matrix & dng_color_spec::CameraToPCS () const
{
DNG_ASSERT (fCameraToPCS.NotEmpty (), "Using invalid CameraToPCS");
return fCameraToPCS;
}
const dng_matrix & dng_color_spec::PCStoCamera () const
{
DNG_ASSERT (fPCStoCamera.NotEmpty (), "Using invalid PCStoCamera");
return fPCStoCamera;
}
const dng_vector & dng_color_spec::CameraWhite () const
{
DNG_ASSERT (fCameraWhite.NotEmpty (), "Using invalid CameraWhite");
return fCameraWhite;
}
const dng_xy_coord & dng_color_spec::WhiteXY () const
{
DNG_ASSERT (fWhiteXY.IsValid (), "Using invalid WhiteXY");
return fWhiteXY;
}
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 ());
}
static void InitInnermostMutex ()
{
int result = pthread_key_create (&gInnermostMutexKey, NULL);
DNG_ASSERT (result == 0, "pthread_key_create failed.");
if (result != 0)
ThrowProgramError ();
}
void dng_condition::Broadcast ()
{
int result;
result = pthread_cond_broadcast (&fPthreadCondition);
DNG_ASSERT (result == 0, "pthread_cond_broadcast failed.");
if (result != 0)
ThrowProgramError ();
}
void dng_condition::Signal ()
{
int result;
result = pthread_cond_signal (&fPthreadCondition);
DNG_ASSERT (result == 0, "pthread_cond_signal failed.");
if (result != 0)
ThrowProgramError ();
}
static void SetInnermostMutex (dng_mutex *mutex)
{
int result;
result = pthread_setspecific (gInnermostMutexKey, (void *)mutex);
DNG_ASSERT (result == 0, "pthread_setspecific failed.");
if (result != 0)
ThrowProgramError ();
}
void dng_jpeg_preview::SpoolAdobeThumbnail (dng_stream &stream) const
{
DNG_ASSERT (fCompressedData.Get (),
"SpoolAdobeThumbnail: no data");
DNG_ASSERT (fPhotometricInterpretation == piYCbCr,
"SpoolAdobeThumbnail: Non-YCbCr");
uint32 compressedSize = fCompressedData->LogicalSize ();
stream.Put_uint32 (DNG_CHAR4 ('8','B','I','M'));
stream.Put_uint16 (1036);
stream.Put_uint16 (0);
stream.Put_uint32 (compressedSize + 28);
uint32 widthBytes = (fPreviewSize.h * 24 + 31) / 32 * 4;
stream.Put_uint32 (1);
stream.Put_uint32 (fPreviewSize.h);
stream.Put_uint32 (fPreviewSize.v);
stream.Put_uint32 (widthBytes);
stream.Put_uint32 (widthBytes * fPreviewSize.v);
stream.Put_uint32 (compressedSize);
stream.Put_uint16 (24);
stream.Put_uint16 (1);
stream.Put (fCompressedData->Buffer (),
compressedSize);
if (compressedSize & 1)
{
stream.Put_uint8 (0);
}
}
bool dng_condition::Wait (dng_mutex &mutex, double timeoutSecs)
{
bool timedOut = false;
dng_mutex *innermostMutex = gInnermostMutexHolder.GetInnermostMutex ();
DNG_ASSERT (innermostMutex == &mutex, "Attempt to wait on non-innermost mutex.");
innermostMutex = mutex.fPrevHeldMutex;
gInnermostMutexHolder.SetInnermostMutex (innermostMutex);
mutex.fPrevHeldMutex = NULL;
if (timeoutSecs < 0)
{
pthread_cond_wait (&fPthreadCondition, &mutex.fPthreadMutex);
}
else
{
struct timespec now;
dng_pthread_now (&now);
timeoutSecs += now.tv_sec;
timeoutSecs += now.tv_nsec / 1000000000.0;
now.tv_sec = (long) timeoutSecs;
now.tv_nsec = (long) ((timeoutSecs - now.tv_sec) * 1000000000);
timedOut = (pthread_cond_timedwait (&fPthreadCondition, &mutex.fPthreadMutex, &now) == ETIMEDOUT);
}
mutex.fPrevHeldMutex = innermostMutex;
gInnermostMutexHolder.SetInnermostMutex (&mutex);
return !timedOut;
}
void dng_preview_list::Append (AutoPtr<dng_preview> &preview)
{
if (preview.Get ())
{
DNG_ASSERT (fCount < kMaxDNGPreviews, "DNG preview list overflow");
if (fCount < kMaxDNGPreviews)
{
fPreview [fCount++] . Reset (preview.Release ());
}
}
}
dng_condition::dng_condition ()
: fPthreadCondition ()
{
int result;
result = pthread_cond_init (&fPthreadCondition, NULL);
DNG_ASSERT (result == 0, "pthread_cond_init failed.");
if (result != 0)
{
ThrowProgramError ();
}
}
void dng_bilinear_kernel::Add (const dng_point &delta,
real32 weight)
{
// Don't add zero weight elements.
if (weight <= 0.0f)
{
return;
}
// If the delta already matches an existing element, just combine the
// weights.
for (uint32 j = 0; j < fCount; j++)
{
if (fDelta [j] == delta)
{
fWeight32 [j] += weight;
return;
}
}
// Add element to list.
DNG_ASSERT (fCount < kMaxCount, "Too many kernel entries")
fDelta [fCount] = delta;
fWeight32 [fCount] = weight;
fCount++;
}
void dng_camera_profile::CalculateFingerprint () const
{
DNG_ASSERT (!fWasStubbed, "CalculateFingerprint on stubbed profile");
dng_md5_printer_stream printer;
// MD5 hash is always calculated on little endian data.
printer.SetLittleEndian ();
// The data that we fingerprint closely matches that saved
// by the profile_tag_set class in dng_image_writer.cpp, with
// the exception of the fingerprint itself.
if (HasColorMatrix1 ())
{
uint32 colorChannels = ColorMatrix1 ().Rows ();
printer.Put_uint16 ((uint16) fCalibrationIlluminant1);
FingerprintMatrix (printer, fColorMatrix1);
if (fForwardMatrix1.Rows () == fColorMatrix1.Cols () &&
fForwardMatrix1.Cols () == fColorMatrix1.Rows ())
{
FingerprintMatrix (printer, fForwardMatrix1);
}
if (colorChannels > 3 && fReductionMatrix1.Rows () *
fReductionMatrix1.Cols () == colorChannels * 3)
{
FingerprintMatrix (printer, fReductionMatrix1);
}
if (HasColorMatrix2 ())
{
printer.Put_uint16 ((uint16) fCalibrationIlluminant2);
FingerprintMatrix (printer, fColorMatrix2);
if (fForwardMatrix2.Rows () == fColorMatrix2.Cols () &&
fForwardMatrix2.Cols () == fColorMatrix2.Rows ())
{
FingerprintMatrix (printer, fForwardMatrix2);
}
if (colorChannels > 3 && fReductionMatrix2.Rows () *
fReductionMatrix2.Cols () == colorChannels * 3)
{
FingerprintMatrix (printer, fReductionMatrix2);
}
}
printer.Put (fName.Get (),
fName.Length ());
printer.Put (fProfileCalibrationSignature.Get (),
fProfileCalibrationSignature.Length ());
printer.Put_uint32 (fEmbedPolicy);
printer.Put (fCopyright.Get (),
fCopyright.Length ());
bool haveHueSat1 = HueSatDeltas1 ().IsValid ();
bool haveHueSat2 = HueSatDeltas2 ().IsValid () &&
HasColorMatrix2 ();
if (haveHueSat1)
{
FingerprintHueSatMap (printer, fHueSatDeltas1);
}
if (haveHueSat2)
{
FingerprintHueSatMap (printer, fHueSatDeltas2);
}
if (fLookTable.IsValid ())
{
FingerprintHueSatMap (printer, fLookTable);
}
if (fToneCurve.IsValid ())
{
for (uint32 i = 0; i < fToneCurve.fCoord.size (); i++)
{
printer.Put_real32 ((real32) fToneCurve.fCoord [i].h);
printer.Put_real32 ((real32) fToneCurve.fCoord [i].v);
}
}
}
fFingerprint = printer.Result ();
}
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;
}
}
}
