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