From ab987e10f154f5536bb8fd936ae0966e909fa969 Mon Sep 17 00:00:00 2001 From: luxagraf Date: Thu, 15 Jun 2023 15:58:59 -0500 Subject: added all my scripts --- gpr/source/lib/dng_sdk/dng_utils.h | 1237 ++++++++++++++++++++++++++++++++++++ 1 file changed, 1237 insertions(+) create mode 100644 gpr/source/lib/dng_sdk/dng_utils.h (limited to 'gpr/source/lib/dng_sdk/dng_utils.h') diff --git a/gpr/source/lib/dng_sdk/dng_utils.h b/gpr/source/lib/dng_sdk/dng_utils.h new file mode 100644 index 0000000..560c37c --- /dev/null +++ b/gpr/source/lib/dng_sdk/dng_utils.h @@ -0,0 +1,1237 @@ +/*****************************************************************************/ +// 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.h#3 $ */ +/* $DateTime: 2012/06/14 20:24:41 $ */ +/* $Change: 835078 $ */ +/* $Author: tknoll $ */ + +/*****************************************************************************/ + +#ifndef __dng_utils__ +#define __dng_utils__ + +/*****************************************************************************/ + +#include "dng_classes.h" +#include "dng_flags.h" +#include "dng_memory.h" +#include "dng_types.h" + +/*****************************************************************************/ + +inline uint32 Abs_int32 (int32 x) + { + + #if 0 + + // Reference version. + + return (uint32) (x < 0 ? -x : x); + + #else + + // Branchless version. + + uint32 mask = (uint32) (x >> 31); + + return (uint32) (((uint32) x + mask) ^ mask); + + #endif + + } + +inline int32 Min_int32 (int32 x, int32 y) + { + + return (x <= y ? x : y); + + } + +inline int32 Max_int32 (int32 x, int32 y) + { + + return (x >= y ? x : y); + + } + +inline int32 Pin_int32 (int32 min, int32 x, int32 max) + { + + return Max_int32 (min, Min_int32 (x, max)); + + } + +inline int32 Pin_int32_between (int32 a, int32 x, int32 b) + { + + int32 min, max; + if (a < b) { min = a; max = b; } + else { min = b; max = a; } + + return Pin_int32 (min, x, max); + + } + +/*****************************************************************************/ + +inline uint16 Min_uint16 (uint16 x, uint16 y) + { + + return (x <= y ? x : y); + + } + +inline uint16 Max_uint16 (uint16 x, uint16 y) + { + + return (x >= y ? x : y); + + } + +inline int16 Pin_int16 (int32 x) + { + + x = Pin_int32 (-32768, x, 32767); + + return (int16) x; + + } + +/*****************************************************************************/ + +inline uint32 Min_uint32 (uint32 x, uint32 y) + { + + return (x <= y ? x : y); + + } + +inline uint32 Min_uint32 (uint32 x, uint32 y, uint32 z) + { + + return Min_uint32 (x, Min_uint32 (y, z)); + + } + +inline uint32 Max_uint32 (uint32 x, uint32 y) + { + + return (x >= y ? x : y); + + } + +inline uint32 Max_uint32 (uint32 x, uint32 y, uint32 z) + { + + return Max_uint32 (x, Max_uint32 (y, z)); + + } + +inline uint32 Pin_uint32 (uint32 min, uint32 x, uint32 max) + { + + return Max_uint32 (min, Min_uint32 (x, max)); + + } + +/*****************************************************************************/ + +inline uint16 Pin_uint16 (int32 x) + { + + #if 0 + + // Reference version. + + x = Pin_int32 (0, x, 0x0FFFF); + + #else + + // Single branch version. + + if (x & ~65535) + { + + x = ~x >> 31; + + } + + #endif + + return (uint16) x; + + } + +/*****************************************************************************/ + +inline uint32 RoundUp2 (uint32 x) + { + + return (x + 1) & (uint32) ~1; + + } + +inline uint32 RoundUp4 (uint32 x) + { + + return (x + 3) & (uint32) ~3; + + } + +inline uint32 RoundUp8 (uint32 x) + { + + return (x + 7) & (uint32) ~7; + + } + +inline uint32 RoundUp16 (uint32 x) + { + + return (x + 15) & (uint32) ~15; + + } + +inline uint32 RoundUp4096 (uint32 x) + { + + return (x + 4095) & (uint32) ~4095; + + } + +/******************************************************************************/ + +inline uint32 RoundDown2 (uint32 x) + { + + return x & (uint32) ~1; + + } + +inline uint32 RoundDown4 (uint32 x) + { + + return x & (uint32) ~3; + + } + +inline uint32 RoundDown8 (uint32 x) + { + + return x & (uint32) ~7; + + } + +inline uint32 RoundDown16 (uint32 x) + { + + return x & (uint32) ~15; + + } + +/******************************************************************************/ + +inline uint32 RoundUpForPixelSize (uint32 x, uint32 pixelSize) + { + + switch (pixelSize) + { + + case 1: + return RoundUp16 (x); + + case 2: + return RoundUp8 (x); + + case 4: + return RoundUp4 (x); + + case 8: + return RoundUp2 (x); + + default: + return RoundUp16 (x); + + } + + } + +/******************************************************************************/ + +inline uint64 Abs_int64 (int64 x) + { + + return (uint64) (x < 0 ? -x : x); + + } + +inline int64 Min_int64 (int64 x, int64 y) + { + + return (x <= y ? x : y); + + } + +inline int64 Max_int64 (int64 x, int64 y) + { + + return (x >= y ? x : y); + + } + +inline int64 Pin_int64 (int64 min, int64 x, int64 max) + { + + return Max_int64 (min, Min_int64 (x, max)); + + } + +/******************************************************************************/ + +inline uint64 Min_uint64 (uint64 x, uint64 y) + { + + return (x <= y ? x : y); + + } + +inline uint64 Max_uint64 (uint64 x, uint64 y) + { + + return (x >= y ? x : y); + + } + +inline uint64 Pin_uint64 (uint64 min, uint64 x, uint64 max) + { + + return Max_uint64 (min, Min_uint64 (x, max)); + + } + +/*****************************************************************************/ + +inline real32 Abs_real32 (real32 x) + { + + return (x < 0.0f ? -x : x); + + } + +inline real32 Min_real32 (real32 x, real32 y) + { + + return (x < y ? x : y); + + } + +inline real32 Max_real32 (real32 x, real32 y) + { + + return (x > y ? x : y); + + } + +inline real32 Pin_real32 (real32 min, real32 x, real32 max) + { + + return Max_real32 (min, Min_real32 (x, max)); + + } + +inline real32 Pin_real32 (real32 x) + { + + return Pin_real32 (0.0f, x, 1.0f); + + } + +inline real32 Pin_real32_Overrange (real32 min, + real32 x, + real32 max) + { + + // Normal numbers in (min,max). No change. + + if (x > min && x < max) + { + return x; + } + + // Map large numbers (including positive infinity) to max. + + else if (x > min) + { + return max; + } + + // Map everything else (including negative infinity and all NaNs) to min. + + return min; + + } + +inline real32 Pin_Overrange (real32 x) + { + + // Normal in-range numbers, except for plus and minus zero. + + if (x > 0.0f && x <= 1.0f) + { + return x; + } + + // Large numbers, including positive infinity. + + else if (x > 0.5f) + { + return 1.0f; + } + + // Plus and minus zero, negative numbers, negative infinity, and all NaNs. + + return 0.0f; + + } + +inline real32 Lerp_real32 (real32 a, real32 b, real32 t) + { + + return a + t * (b - a); + + } + +/*****************************************************************************/ + +inline real64 Abs_real64 (real64 x) + { + + return (x < 0.0 ? -x : x); + + } + +inline real64 Min_real64 (real64 x, real64 y) + { + + return (x < y ? x : y); + + } + +inline real64 Max_real64 (real64 x, real64 y) + { + + return (x > y ? x : y); + + } + +inline real64 Pin_real64 (real64 min, real64 x, real64 max) + { + + return Max_real64 (min, Min_real64 (x, max)); + + } + +inline real64 Pin_real64 (real64 x) + { + + return Pin_real64 (0.0, x, 1.0); + + } + +inline real64 Pin_real64_Overrange (real64 min, + real64 x, + real64 max) + { + + // Normal numbers in (min,max). No change. + + if (x > min && x < max) + { + return x; + } + + // Map large numbers (including positive infinity) to max. + + else if (x > min) + { + return max; + } + + // Map everything else (including negative infinity and all NaNs) to min. + + return min; + + } + +inline real64 Lerp_real64 (real64 a, real64 b, real64 t) + { + + return a + t * (b - a); + + } + +/*****************************************************************************/ + +inline int32 Round_int32 (real32 x) + { + + return (int32) (x > 0.0f ? x + 0.5f : x - 0.5f); + + } + +inline int32 Round_int32 (real64 x) + { + + return (int32) (x > 0.0 ? x + 0.5 : x - 0.5); + + } + +inline uint32 Floor_uint32 (real32 x) + { + + return (uint32) Max_real32 (0.0f, x); + + } + +inline uint32 Floor_uint32 (real64 x) + { + + return (uint32) Max_real64 (0.0, x); + + } + +inline uint32 Round_uint32 (real32 x) + { + + return Floor_uint32 (x + 0.5f); + + } + +inline uint32 Round_uint32 (real64 x) + { + + return Floor_uint32 (x + 0.5); + + } + +/******************************************************************************/ + +inline int64 Round_int64 (real64 x) + { + + return (int64) (x >= 0.0 ? x + 0.5 : x - 0.5); + + } + +/*****************************************************************************/ + +const int64 kFixed64_One = (((int64) 1) << 32); +const int64 kFixed64_Half = (((int64) 1) << 31); + +/******************************************************************************/ + +inline int64 Real64ToFixed64 (real64 x) + { + + return Round_int64 (x * (real64) kFixed64_One); + + } + +/******************************************************************************/ + +inline real64 Fixed64ToReal64 (int64 x) + { + + return x * (1.0 / (real64) kFixed64_One); + + } + +/*****************************************************************************/ + +inline char ForceUppercase (char c) + { + + if (c >= 'a' && c <= 'z') + { + + c -= 'a' - 'A'; + + } + + return c; + + } + +/*****************************************************************************/ + +inline uint16 SwapBytes16 (uint16 x) + { + + return (uint16) ((x << 8) | + (x >> 8)); + + } + +inline uint32 SwapBytes32 (uint32 x) + { + + return (x << 24) + + ((x << 8) & 0x00FF0000) + + ((x >> 8) & 0x0000FF00) + + (x >> 24); + + } + +/*****************************************************************************/ + +inline bool IsAligned16 (const void *p) + { + + return (((uintptr) p) & 1) == 0; + + } + +inline bool IsAligned32 (const void *p) + { + + return (((uintptr) p) & 3) == 0; + + } + +inline bool IsAligned64 (const void *p) + { + + return (((uintptr) p) & 7) == 0; + + } + +inline bool IsAligned128 (const void *p) + { + + return (((uintptr) p) & 15) == 0; + + } + +/******************************************************************************/ + +// Converts from RGB values (range 0.0 to 1.0) to HSV values (range 0.0 to +// 6.0 for hue, and 0.0 to 1.0 for saturation and value). + +inline void DNG_RGBtoHSV (real32 r, + real32 g, + real32 b, + real32 &h, + real32 &s, + real32 &v) + { + + v = Max_real32 (r, Max_real32 (g, b)); + + real32 gap = v - Min_real32 (r, Min_real32 (g, b)); + + if (gap > 0.0f) + { + + if (r == v) + { + + h = (g - b) / gap; + + if (h < 0.0f) + { + h += 6.0f; + } + + } + + else if (g == v) + { + h = 2.0f + (b - r) / gap; + } + + else + { + h = 4.0f + (r - g) / gap; + } + + s = gap / v; + + } + + else + { + h = 0.0f; + s = 0.0f; + } + + } + +/*****************************************************************************/ + +// Converts from HSV values (range 0.0 to 6.0 for hue, and 0.0 to 1.0 for +// saturation and value) to RGB values (range 0.0 to 1.0). + +inline void DNG_HSVtoRGB (real32 h, + real32 s, + real32 v, + real32 &r, + real32 &g, + real32 &b) + { + + if (s > 0.0f) + { + + if (h < 0.0f) + h += 6.0f; + + if (h >= 6.0f) + h -= 6.0f; + + int32 i = (int32) h; + real32 f = h - (real32) i; + + real32 p = v * (1.0f - s); + + #define q (v * (1.0f - s * f)) + #define t (v * (1.0f - s * (1.0f - f))) + + switch (i) + { + case 0: r = v; g = t; b = p; break; + case 1: r = q; g = v; b = p; break; + case 2: r = p; g = v; b = t; break; + case 3: r = p; g = q; b = v; break; + case 4: r = t; g = p; b = v; break; + case 5: r = v; g = p; b = q; break; + } + + #undef q + #undef t + + } + + else + { + r = v; + g = v; + b = v; + } + + } + +/******************************************************************************/ + +// High resolution timer, for code profiling. + +real64 TickTimeInSeconds (); + +// Lower resolution timer, but more stable. + +real64 TickCountInSeconds (); + +/******************************************************************************/ + +class dng_timer + { + + public: + + dng_timer (const char *message); + + ~dng_timer (); + + private: + + // Hidden copy constructor and assignment operator. + + dng_timer (const dng_timer &timer); + + dng_timer & operator= (const dng_timer &timer); + + private: + + const char *fMessage; + + real64 fStartTime; + + }; + +/*****************************************************************************/ + +// Returns the maximum squared Euclidean distance from the specified point to the +// specified rectangle rect. + +real64 MaxSquaredDistancePointToRect (const dng_point_real64 &point, + const dng_rect_real64 &rect); + +/*****************************************************************************/ + +// Returns the maximum Euclidean distance from the specified point to the specified +// rectangle rect. + +real64 MaxDistancePointToRect (const dng_point_real64 &point, + const dng_rect_real64 &rect); + +/*****************************************************************************/ + +inline uint32 DNG_HalfToFloat (uint16 halfValue) + { + + int32 sign = (halfValue >> 15) & 0x00000001; + int32 exponent = (halfValue >> 10) & 0x0000001f; + int32 mantissa = halfValue & 0x000003ff; + + if (exponent == 0) + { + + if (mantissa == 0) + { + + // Plus or minus zero + + return (uint32) (sign << 31); + + } + + else + { + + // Denormalized number -- renormalize it + + while (!(mantissa & 0x00000400)) + { + mantissa <<= 1; + exponent -= 1; + } + + exponent += 1; + mantissa &= ~0x00000400; + + } + + } + + else if (exponent == 31) + { + + if (mantissa == 0) + { + + // Positive or negative infinity, convert to maximum (16 bit) values. + + return (uint32) ((sign << 31) | ((0x1eL + 127 - 15) << 23) | (0x3ffL << 13)); + + } + + else + { + + // Nan -- Just set to zero. + + return 0; + + } + + } + + // Normalized number + + exponent += (127 - 15); + mantissa <<= 13; + + // Assemble sign, exponent and mantissa. + + return (uint32) ((sign << 31) | (exponent << 23) | mantissa); + + } + +/*****************************************************************************/ + +inline uint16 DNG_FloatToHalf (uint32 i) + { + + int32 sign = (i >> 16) & 0x00008000; + int32 exponent = ((i >> 23) & 0x000000ff) - (127 - 15); + int32 mantissa = i & 0x007fffff; + + if (exponent <= 0) + { + + if (exponent < -10) + { + + // Zero or underflow to zero. + + return (uint16)sign; + + } + + // E is between -10 and 0. We convert f to a denormalized half. + + mantissa = (mantissa | 0x00800000) >> (1 - exponent); + + // Round to nearest, round "0.5" up. + // + // Rounding may cause the significand to overflow and make + // our number normalized. Because of the way a half's bits + // are laid out, we don't have to treat this case separately; + // the code below will handle it correctly. + + if (mantissa & 0x00001000) + mantissa += 0x00002000; + + // Assemble the half from sign, exponent (zero) and mantissa. + + return (uint16)(sign | (mantissa >> 13)); + + } + + else if (exponent == 0xff - (127 - 15)) + { + + if (mantissa == 0) + { + + // F is an infinity; convert f to a half + // infinity with the same sign as f. + + return (uint16)(sign | 0x7c00); + + } + + else + { + + // F is a NAN; produce a half NAN that preserves + // the sign bit and the 10 leftmost bits of the + // significand of f. + + return (uint16)(sign | 0x7c00 | (mantissa >> 13)); + + } + + } + + // E is greater than zero. F is a normalized float. + // We try to convert f to a normalized half. + + // Round to nearest, round "0.5" up + + if (mantissa & 0x00001000) + { + + mantissa += 0x00002000; + + if (mantissa & 0x00800000) + { + mantissa = 0; // overflow in significand, + exponent += 1; // adjust exponent + } + + } + + // Handle exponent overflow + + if (exponent > 30) + { + return (uint16)(sign | 0x7c00); // infinity with the same sign as f. + } + + // Assemble the half from sign, exponent and mantissa. + + return (uint16)(sign | (exponent << 10) | (mantissa >> 13)); + + } + +/*****************************************************************************/ + +inline uint32 DNG_FP24ToFloat (const uint8 *input) + { + + int32 sign = (input [0] >> 7) & 0x01; + int32 exponent = (input [0] ) & 0x7F; + int32 mantissa = (((int32) input [1]) << 8) | input[2]; + + if (exponent == 0) + { + + if (mantissa == 0) + { + + // Plus or minus zero + + return (uint32) (sign << 31); + + } + + else + { + + // Denormalized number -- renormalize it + + while (!(mantissa & 0x00010000)) + { + mantissa <<= 1; + exponent -= 1; + } + + exponent += 1; + mantissa &= ~0x00010000; + + } + + } + + else if (exponent == 127) + { + + if (mantissa == 0) + { + + // Positive or negative infinity, convert to maximum (24 bit) values. + + return (uint32) ((sign << 31) | ((0x7eL + 128 - 64) << 23) | (0xffffL << 7)); + + } + + else + { + + // Nan -- Just set to zero. + + return 0; + + } + + } + + // Normalized number + + exponent += (128 - 64); + mantissa <<= 7; + + // Assemble sign, exponent and mantissa. + + return (uint32) ((sign << 31) | (exponent << 23) | mantissa); + + } + +/*****************************************************************************/ + +inline void DNG_FloatToFP24 (uint32 input, uint8 *output) + { + + int32 exponent = (int32) ((input >> 23) & 0xFF) - 128; + int32 mantissa = input & 0x007FFFFF; + + if (exponent == 127) // infinity or NaN + { + + // Will the NaN alais to infinity? + + if (mantissa != 0x007FFFFF && ((mantissa >> 7) == 0xFFFF)) + { + + mantissa &= 0x003FFFFF; // knock out msb to make it a NaN + + } + + } + + else if (exponent > 63) // overflow, map to infinity + { + + exponent = 63; + mantissa = 0x007FFFFF; + + } + + else if (exponent <= -64) + { + + if (exponent >= -79) // encode as denorm + { + mantissa = (mantissa | 0x00800000) >> (-63 - exponent); + } + + else // underflow to zero + { + mantissa = 0; + } + + exponent = -64; + + } + + output [0] = (uint8)(((input >> 24) & 0x80) | (uint32) (exponent + 64)); + + output [1] = (mantissa >> 15) & 0x00FF; + output [2] = (mantissa >> 7) & 0x00FF; + + } + +/******************************************************************************/ + +// The following code was from PSDivide.h in Photoshop. + +// High order 32-bits of an unsigned 32 by 32 multiply. + +#ifndef MULUH + +#if defined(_X86_) && defined(_MSC_VER) + +inline uint32 Muluh86 (uint32 x, uint32 y) + { + uint32 result; + __asm + { + MOV EAX, x + MUL y + MOV result, EDX + } + return (result); + } + +#define MULUH Muluh86 + +#else + +#define MULUH(x,y) ((uint32) (((x) * (uint64) (y)) >> 32)) + +#endif + +#endif + +// High order 32-bits of an signed 32 by 32 multiply. + +#ifndef MULSH + +#if defined(_X86_) && defined(_MSC_VER) + +inline int32 Mulsh86 (int32 x, int32 y) + { + int32 result; + __asm + { + MOV EAX, x + IMUL y + MOV result, EDX + } + return (result); + } + +#define MULSH Mulsh86 + +#else + +#define MULSH(x,y) ((int32) (((x) * (int64) (y)) >> 32)) + +#endif + +#endif + +/******************************************************************************/ + +// Random number generator (identical to Apple's) for portable use. + +// This implements the "minimal standard random number generator" +// as proposed by Park and Miller in CACM October, 1988. +// It has a period of 2147483647 (0x7fffffff) + +// This is the ACM standard 30 bit generator: +// x' = (x * 16807) mod 2^31-1 + +inline uint32 DNG_Random (uint32 seed) + { + + // high = seed / 127773 + + uint32 temp = MULUH (0x069C16BD, seed); + uint32 high = (temp + ((seed - temp) >> 1)) >> 16; + + // low = seed % 127773 + + uint32 low = seed - high * 127773; + + // seed = (seed * 16807) % 2147483647 + + seed = 16807 * low - 2836 * high; + + if (seed & 0x80000000) + seed += 2147483647; + + return seed; + + } + +/*****************************************************************************/ + +class dng_dither + { + + public: + + static const uint32 kRNGBits = 7; + + static const uint32 kRNGSize = 1 << kRNGBits; + + static const uint32 kRNGMask = kRNGSize - 1; + + static const uint32 kRNGSize2D = kRNGSize * kRNGSize; + + private: + + dng_memory_data fNoiseBuffer; + + private: + + dng_dither (); + + // Hidden copy constructor and assignment operator. + + dng_dither (const dng_dither &); + + dng_dither & operator= (const dng_dither &); + + public: + + static const dng_dither & Get (); + + public: + + const uint16 *NoiseBuffer16 () const + { + return fNoiseBuffer.Buffer_uint16 (); + } + + }; + +/*****************************************************************************/ + +void HistogramArea (dng_host &host, + const dng_image &image, + const dng_rect &area, + uint32 *hist, + uint32 histLimit, + uint32 plane = 0); + +/*****************************************************************************/ + +void LimitFloatBitDepth (dng_host &host, + const dng_image &srcImage, + dng_image &dstImage, + uint32 bitDepth, + real32 scale = 1.0f); + +/*****************************************************************************/ + +#endif + +/*****************************************************************************/ -- cgit v1.2.3-70-g09d2