1/*****************************************************************************/ 2// Copyright 2006-2012 Adobe Systems Incorporated 3// All Rights Reserved. 4// 5// NOTICE: Adobe permits you to use, modify, and distribute this file in 6// accordance with the terms of the Adobe license agreement accompanying it. 7/*****************************************************************************/ 8 9/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_utils.h#3 $ */ 10/* $DateTime: 2012/06/14 20:24:41 $ */ 11/* $Change: 835078 $ */ 12/* $Author: tknoll $ */ 13 14/*****************************************************************************/ 15 16#ifndef __dng_utils__ 17#define __dng_utils__ 18 19/*****************************************************************************/ 20 21#include <cmath> 22#include <limits> 23 24#include "dng_classes.h" 25#include "dng_flags.h" 26#include "dng_memory.h" 27#include "dng_safe_arithmetic.h" 28#include "dng_types.h" 29 30/*****************************************************************************/ 31 32// The unsigned integer overflow is intended here since a wrap around is used to 33// calculate the abs() in the branchless version. 34#if defined(__clang__) && defined(__has_attribute) 35#if __has_attribute(no_sanitize) 36__attribute__((no_sanitize("unsigned-integer-overflow"))) 37#endif 38#endif 39inline uint32 Abs_int32 (int32 x) 40 { 41 42 #if 0 43 44 // Reference version. 45 46 return (uint32) (x < 0 ? -x : x); 47 48 #else 49 50 // Branchless version. 51 52 uint32 mask = (uint32) (x >> 31); 53 54 return (uint32) (((uint32) x + mask) ^ mask); 55 56 #endif 57 58 } 59 60inline int32 Min_int32 (int32 x, int32 y) 61 { 62 63 return (x <= y ? x : y); 64 65 } 66 67inline int32 Max_int32 (int32 x, int32 y) 68 { 69 70 return (x >= y ? x : y); 71 72 } 73 74inline int32 Pin_int32 (int32 min, int32 x, int32 max) 75 { 76 77 return Max_int32 (min, Min_int32 (x, max)); 78 79 } 80 81inline int32 Pin_int32_between (int32 a, int32 x, int32 b) 82 { 83 84 int32 min, max; 85 if (a < b) { min = a; max = b; } 86 else { min = b; max = a; } 87 88 return Pin_int32 (min, x, max); 89 90 } 91 92/*****************************************************************************/ 93 94inline uint16 Min_uint16 (uint16 x, uint16 y) 95 { 96 97 return (x <= y ? x : y); 98 99 } 100 101inline uint16 Max_uint16 (uint16 x, uint16 y) 102 { 103 104 return (x >= y ? x : y); 105 106 } 107 108inline int16 Pin_int16 (int32 x) 109 { 110 111 x = Pin_int32 (-32768, x, 32767); 112 113 return (int16) x; 114 115 } 116 117/*****************************************************************************/ 118 119inline uint32 Min_uint32 (uint32 x, uint32 y) 120 { 121 122 return (x <= y ? x : y); 123 124 } 125 126inline uint32 Min_uint32 (uint32 x, uint32 y, uint32 z) 127 { 128 129 return Min_uint32 (x, Min_uint32 (y, z)); 130 131 } 132 133inline uint32 Max_uint32 (uint32 x, uint32 y) 134 { 135 136 return (x >= y ? x : y); 137 138 } 139 140inline uint32 Max_uint32 (uint32 x, uint32 y, uint32 z) 141 { 142 143 return Max_uint32 (x, Max_uint32 (y, z)); 144 145 } 146 147inline uint32 Pin_uint32 (uint32 min, uint32 x, uint32 max) 148 { 149 150 return Max_uint32 (min, Min_uint32 (x, max)); 151 152 } 153 154/*****************************************************************************/ 155 156inline uint16 Pin_uint16 (int32 x) 157 { 158 159 #if 0 160 161 // Reference version. 162 163 x = Pin_int32 (0, x, 0x0FFFF); 164 165 #else 166 167 // Single branch version. 168 169 if (x & ~65535) 170 { 171 172 x = ~x >> 31; 173 174 } 175 176 #endif 177 178 return (uint16) x; 179 180 } 181 182/*****************************************************************************/ 183 184inline uint32 RoundDown2 (uint32 x) 185 { 186 187 return x & (uint32) ~1; 188 189 } 190 191inline uint32 RoundDown4 (uint32 x) 192 { 193 194 return x & (uint32) ~3; 195 196 } 197 198inline uint32 RoundDown8 (uint32 x) 199 { 200 201 return x & (uint32) ~7; 202 203 } 204 205inline uint32 RoundDown16 (uint32 x) 206 { 207 208 return x & (uint32) ~15; 209 210 } 211 212/******************************************************************************/ 213 214inline bool RoundUpForPixelSize (uint32 x, uint32 pixelSize, uint32 *result) 215 { 216 217 uint32 multiple; 218 switch (pixelSize) 219 { 220 221 case 1: 222 case 2: 223 case 4: 224 case 8: 225 multiple = 16 / pixelSize; 226 break; 227 228 default: 229 multiple = 16; 230 break; 231 232 } 233 234 return RoundUpUint32ToMultiple(x, multiple, result); 235 236 } 237 238/******************************************************************************/ 239 240// Type of padding to be performed by ComputeBufferSize(). 241enum PaddingType 242 { 243 // Don't perform any padding. 244 padNone, 245 // Pad each scanline to an integer multiple of 16 bytes (in the same way 246 // that RoundUpForPixelSize() does). 247 pad16Bytes 248 }; 249 250// Returns the number of bytes required for an image tile with the given pixel 251// type, tile size, number of image planes, and desired padding. Throws a 252// dng_exception with dng_error_memory error code if one of the components of 253// tileSize is negative or if arithmetic overflow occurs during the computation. 254uint32 ComputeBufferSize(uint32 pixelType, const dng_point &tileSize, 255 uint32 numPlanes, PaddingType paddingType); 256 257/******************************************************************************/ 258 259inline uint64 Abs_int64 (int64 x) 260 { 261 262 return (uint64) (x < 0 ? -x : x); 263 264 } 265 266inline int64 Min_int64 (int64 x, int64 y) 267 { 268 269 return (x <= y ? x : y); 270 271 } 272 273inline int64 Max_int64 (int64 x, int64 y) 274 { 275 276 return (x >= y ? x : y); 277 278 } 279 280inline int64 Pin_int64 (int64 min, int64 x, int64 max) 281 { 282 283 return Max_int64 (min, Min_int64 (x, max)); 284 285 } 286 287/******************************************************************************/ 288 289inline uint64 Min_uint64 (uint64 x, uint64 y) 290 { 291 292 return (x <= y ? x : y); 293 294 } 295 296inline uint64 Max_uint64 (uint64 x, uint64 y) 297 { 298 299 return (x >= y ? x : y); 300 301 } 302 303inline uint64 Pin_uint64 (uint64 min, uint64 x, uint64 max) 304 { 305 306 return Max_uint64 (min, Min_uint64 (x, max)); 307 308 } 309 310/*****************************************************************************/ 311 312inline real32 Abs_real32 (real32 x) 313 { 314 315 return (x < 0.0f ? -x : x); 316 317 } 318 319inline real32 Min_real32 (real32 x, real32 y) 320 { 321 322 return (x < y ? x : y); 323 324 } 325 326inline real32 Max_real32 (real32 x, real32 y) 327 { 328 329 return (x > y ? x : y); 330 331 } 332 333inline real32 Pin_real32 (real32 min, real32 x, real32 max) 334 { 335 336 return Max_real32 (min, Min_real32 (x, max)); 337 338 } 339 340inline real32 Pin_real32 (real32 x) 341 { 342 343 return Pin_real32 (0.0f, x, 1.0f); 344 345 } 346 347inline real32 Pin_real32_Overrange (real32 min, 348 real32 x, 349 real32 max) 350 { 351 352 // Normal numbers in (min,max). No change. 353 354 if (x > min && x < max) 355 { 356 return x; 357 } 358 359 // Map large numbers (including positive infinity) to max. 360 361 else if (x > min) 362 { 363 return max; 364 } 365 366 // Map everything else (including negative infinity and all NaNs) to min. 367 368 return min; 369 370 } 371 372inline real32 Pin_Overrange (real32 x) 373 { 374 375 // Normal in-range numbers, except for plus and minus zero. 376 377 if (x > 0.0f && x <= 1.0f) 378 { 379 return x; 380 } 381 382 // Large numbers, including positive infinity. 383 384 else if (x > 0.5f) 385 { 386 return 1.0f; 387 } 388 389 // Plus and minus zero, negative numbers, negative infinity, and all NaNs. 390 391 return 0.0f; 392 393 } 394 395inline real32 Lerp_real32 (real32 a, real32 b, real32 t) 396 { 397 398 return a + t * (b - a); 399 400 } 401 402/*****************************************************************************/ 403 404inline real64 Abs_real64 (real64 x) 405 { 406 407 return (x < 0.0 ? -x : x); 408 409 } 410 411inline real64 Min_real64 (real64 x, real64 y) 412 { 413 414 return (x < y ? x : y); 415 416 } 417 418inline real64 Max_real64 (real64 x, real64 y) 419 { 420 421 return (x > y ? x : y); 422 423 } 424 425inline real64 Pin_real64 (real64 min, real64 x, real64 max) 426 { 427 428 return Max_real64 (min, Min_real64 (x, max)); 429 430 } 431 432inline real64 Pin_real64 (real64 x) 433 { 434 435 return Pin_real64 (0.0, x, 1.0); 436 437 } 438 439inline real64 Pin_real64_Overrange (real64 min, 440 real64 x, 441 real64 max) 442 { 443 444 // Normal numbers in (min,max). No change. 445 446 if (x > min && x < max) 447 { 448 return x; 449 } 450 451 // Map large numbers (including positive infinity) to max. 452 453 else if (x > min) 454 { 455 return max; 456 } 457 458 // Map everything else (including negative infinity and all NaNs) to min. 459 460 return min; 461 462 } 463 464inline real64 Lerp_real64 (real64 a, real64 b, real64 t) 465 { 466 467 return a + t * (b - a); 468 469 } 470 471/*****************************************************************************/ 472 473inline int32 Round_int32 (real32 x) 474 { 475 476 return (int32) (x > 0.0f ? x + 0.5f : x - 0.5f); 477 478 } 479 480inline int32 Round_int32 (real64 x) 481 { 482 483 const real64 temp = x > 0.0 ? x + 0.5 : x - 0.5; 484 485 // NaNs will fail this test (because NaNs compare false against 486 // everything) and will therefore also take the else branch. 487 if (temp > real64(std::numeric_limits<int32>::min()) - 1.0 && 488 temp < real64(std::numeric_limits<int32>::max()) + 1.0) 489 { 490 return (int32) temp; 491 } 492 493 else 494 { 495 ThrowProgramError("Overflow in Round_int32"); 496 // Dummy return. 497 return 0; 498 } 499 500 } 501 502inline uint32 Floor_uint32 (real32 x) 503 { 504 505 return (uint32) Max_real32 (0.0f, x); 506 507 } 508 509inline uint32 Floor_uint32 (real64 x) 510 { 511 512 const real64 temp = Max_real64 (0.0, x); 513 514 // NaNs will fail this test (because NaNs compare false against 515 // everything) and will therefore also take the else branch. 516 if (temp < real64(std::numeric_limits<uint32>::max()) + 1.0) 517 { 518 return (uint32) temp; 519 } 520 521 else 522 { 523 ThrowProgramError("Overflow in Floor_uint32"); 524 // Dummy return. 525 return 0; 526 } 527 528 } 529 530inline uint32 Round_uint32 (real32 x) 531 { 532 533 return Floor_uint32 (x + 0.5f); 534 535 } 536 537inline uint32 Round_uint32 (real64 x) 538 { 539 540 return Floor_uint32 (x + 0.5); 541 542 } 543 544/******************************************************************************/ 545 546inline int64 Round_int64 (real64 x) 547 { 548 549 return (int64) (x >= 0.0 ? x + 0.5 : x - 0.5); 550 551 } 552 553/*****************************************************************************/ 554 555const int64 kFixed64_One = (((int64) 1) << 32); 556const int64 kFixed64_Half = (((int64) 1) << 31); 557 558/******************************************************************************/ 559 560inline int64 Real64ToFixed64 (real64 x) 561 { 562 563 return Round_int64 (x * (real64) kFixed64_One); 564 565 } 566 567/******************************************************************************/ 568 569inline real64 Fixed64ToReal64 (int64 x) 570 { 571 572 return x * (1.0 / (real64) kFixed64_One); 573 574 } 575 576/*****************************************************************************/ 577 578inline char ForceUppercase (char c) 579 { 580 581 if (c >= 'a' && c <= 'z') 582 { 583 584 c -= 'a' - 'A'; 585 586 } 587 588 return c; 589 590 } 591 592/*****************************************************************************/ 593 594inline uint16 SwapBytes16 (uint16 x) 595 { 596 597 return (uint16) ((x << 8) | 598 (x >> 8)); 599 600 } 601 602inline uint32 SwapBytes32 (uint32 x) 603 { 604 605 return (x << 24) + 606 ((x << 8) & 0x00FF0000) + 607 ((x >> 8) & 0x0000FF00) + 608 (x >> 24); 609 610 } 611 612/*****************************************************************************/ 613 614inline bool IsAligned16 (const void *p) 615 { 616 617 return (((uintptr) p) & 1) == 0; 618 619 } 620 621inline bool IsAligned32 (const void *p) 622 { 623 624 return (((uintptr) p) & 3) == 0; 625 626 } 627 628inline bool IsAligned64 (const void *p) 629 { 630 631 return (((uintptr) p) & 7) == 0; 632 633 } 634 635inline bool IsAligned128 (const void *p) 636 { 637 638 return (((uintptr) p) & 15) == 0; 639 640 } 641 642/******************************************************************************/ 643 644// Converts from RGB values (range 0.0 to 1.0) to HSV values (range 0.0 to 645// 6.0 for hue, and 0.0 to 1.0 for saturation and value). 646 647inline void DNG_RGBtoHSV (real32 r, 648 real32 g, 649 real32 b, 650 real32 &h, 651 real32 &s, 652 real32 &v) 653 { 654 655 v = Max_real32 (r, Max_real32 (g, b)); 656 657 real32 gap = v - Min_real32 (r, Min_real32 (g, b)); 658 659 if (gap > 0.0f) 660 { 661 662 if (r == v) 663 { 664 665 h = (g - b) / gap; 666 667 if (h < 0.0f) 668 { 669 h += 6.0f; 670 } 671 672 } 673 674 else if (g == v) 675 { 676 h = 2.0f + (b - r) / gap; 677 } 678 679 else 680 { 681 h = 4.0f + (r - g) / gap; 682 } 683 684 s = gap / v; 685 686 } 687 688 else 689 { 690 h = 0.0f; 691 s = 0.0f; 692 } 693 694 } 695 696/*****************************************************************************/ 697 698// Converts from HSV values (range 0.0 to 6.0 for hue, and 0.0 to 1.0 for 699// saturation and value) to RGB values (range 0.0 to 1.0). 700 701inline void DNG_HSVtoRGB (real32 h, 702 real32 s, 703 real32 v, 704 real32 &r, 705 real32 &g, 706 real32 &b) 707 { 708 709 if (s > 0.0f) 710 { 711 712 if (!std::isfinite(h)) 713 ThrowProgramError("Unexpected NaN or Inf"); 714 h = std::fmod(h, 6.0f); 715 if (h < 0.0f) 716 h += 6.0f; 717 718 int32 i = (int32) h; 719 real32 f = h - (real32) i; 720 721 real32 p = v * (1.0f - s); 722 723 #define q (v * (1.0f - s * f)) 724 #define t (v * (1.0f - s * (1.0f - f))) 725 726 switch (i) 727 { 728 case 0: r = v; g = t; b = p; break; 729 case 1: r = q; g = v; b = p; break; 730 case 2: r = p; g = v; b = t; break; 731 case 3: r = p; g = q; b = v; break; 732 case 4: r = t; g = p; b = v; break; 733 case 5: r = v; g = p; b = q; break; 734 } 735 736 #undef q 737 #undef t 738 739 } 740 741 else 742 { 743 r = v; 744 g = v; 745 b = v; 746 } 747 748 } 749 750/******************************************************************************/ 751 752// High resolution timer, for code profiling. 753 754real64 TickTimeInSeconds (); 755 756// Lower resolution timer, but more stable. 757 758real64 TickCountInSeconds (); 759 760/******************************************************************************/ 761 762class dng_timer 763 { 764 765 public: 766 767 dng_timer (const char *message); 768 769 ~dng_timer (); 770 771 private: 772 773 // Hidden copy constructor and assignment operator. 774 775 dng_timer (const dng_timer &timer); 776 777 dng_timer & operator= (const dng_timer &timer); 778 779 private: 780 781 const char *fMessage; 782 783 real64 fStartTime; 784 785 }; 786 787/*****************************************************************************/ 788 789// Returns the maximum squared Euclidean distance from the specified point to the 790// specified rectangle rect. 791 792real64 MaxSquaredDistancePointToRect (const dng_point_real64 &point, 793 const dng_rect_real64 &rect); 794 795/*****************************************************************************/ 796 797// Returns the maximum Euclidean distance from the specified point to the specified 798// rectangle rect. 799 800real64 MaxDistancePointToRect (const dng_point_real64 &point, 801 const dng_rect_real64 &rect); 802 803/*****************************************************************************/ 804 805inline uint32 DNG_HalfToFloat (uint16 halfValue) 806 { 807 808 int32 sign = (halfValue >> 15) & 0x00000001; 809 int32 exponent = (halfValue >> 10) & 0x0000001f; 810 int32 mantissa = halfValue & 0x000003ff; 811 812 if (exponent == 0) 813 { 814 815 if (mantissa == 0) 816 { 817 818 // Plus or minus zero 819 820 return (uint32) (sign << 31); 821 822 } 823 824 else 825 { 826 827 // Denormalized number -- renormalize it 828 829 while (!(mantissa & 0x00000400)) 830 { 831 mantissa <<= 1; 832 exponent -= 1; 833 } 834 835 exponent += 1; 836 mantissa &= ~0x00000400; 837 838 } 839 840 } 841 842 else if (exponent == 31) 843 { 844 845 if (mantissa == 0) 846 { 847 848 // Positive or negative infinity, convert to maximum (16 bit) values. 849 850 return (uint32) ((sign << 31) | ((0x1eL + 127 - 15) << 23) | (0x3ffL << 13)); 851 852 } 853 854 else 855 { 856 857 // Nan -- Just set to zero. 858 859 return 0; 860 861 } 862 863 } 864 865 // Normalized number 866 867 exponent += (127 - 15); 868 mantissa <<= 13; 869 870 // Assemble sign, exponent and mantissa. 871 872 return (uint32) ((sign << 31) | (exponent << 23) | mantissa); 873 874 } 875 876/*****************************************************************************/ 877 878inline uint16 DNG_FloatToHalf (uint32 i) 879 { 880 881 int32 sign = (i >> 16) & 0x00008000; 882 int32 exponent = ((i >> 23) & 0x000000ff) - (127 - 15); 883 int32 mantissa = i & 0x007fffff; 884 885 if (exponent <= 0) 886 { 887 888 if (exponent < -10) 889 { 890 891 // Zero or underflow to zero. 892 893 return (uint16)sign; 894 895 } 896 897 // E is between -10 and 0. We convert f to a denormalized half. 898 899 mantissa = (mantissa | 0x00800000) >> (1 - exponent); 900 901 // Round to nearest, round "0.5" up. 902 // 903 // Rounding may cause the significand to overflow and make 904 // our number normalized. Because of the way a half's bits 905 // are laid out, we don't have to treat this case separately; 906 // the code below will handle it correctly. 907 908 if (mantissa & 0x00001000) 909 mantissa += 0x00002000; 910 911 // Assemble the half from sign, exponent (zero) and mantissa. 912 913 return (uint16)(sign | (mantissa >> 13)); 914 915 } 916 917 else if (exponent == 0xff - (127 - 15)) 918 { 919 920 if (mantissa == 0) 921 { 922 923 // F is an infinity; convert f to a half 924 // infinity with the same sign as f. 925 926 return (uint16)(sign | 0x7c00); 927 928 } 929 930 else 931 { 932 933 // F is a NAN; produce a half NAN that preserves 934 // the sign bit and the 10 leftmost bits of the 935 // significand of f. 936 937 return (uint16)(sign | 0x7c00 | (mantissa >> 13)); 938 939 } 940 941 } 942 943 // E is greater than zero. F is a normalized float. 944 // We try to convert f to a normalized half. 945 946 // Round to nearest, round "0.5" up 947 948 if (mantissa & 0x00001000) 949 { 950 951 mantissa += 0x00002000; 952 953 if (mantissa & 0x00800000) 954 { 955 mantissa = 0; // overflow in significand, 956 exponent += 1; // adjust exponent 957 } 958 959 } 960 961 // Handle exponent overflow 962 963 if (exponent > 30) 964 { 965 return (uint16)(sign | 0x7c00); // infinity with the same sign as f. 966 } 967 968 // Assemble the half from sign, exponent and mantissa. 969 970 return (uint16)(sign | (exponent << 10) | (mantissa >> 13)); 971 972 } 973 974/*****************************************************************************/ 975 976inline uint32 DNG_FP24ToFloat (const uint8 *input) 977 { 978 979 int32 sign = (input [0] >> 7) & 0x01; 980 int32 exponent = (input [0] ) & 0x7F; 981 int32 mantissa = (((int32) input [1]) << 8) | input[2]; 982 983 if (exponent == 0) 984 { 985 986 if (mantissa == 0) 987 { 988 989 // Plus or minus zero 990 991 return (uint32) (sign << 31); 992 993 } 994 995 else 996 { 997 998 // Denormalized number -- renormalize it 999 1000 while (!(mantissa & 0x00010000)) 1001 { 1002 mantissa <<= 1; 1003 exponent -= 1; 1004 } 1005 1006 exponent += 1; 1007 mantissa &= ~0x00010000; 1008 1009 } 1010 1011 } 1012 1013 else if (exponent == 127) 1014 { 1015 1016 if (mantissa == 0) 1017 { 1018 1019 // Positive or negative infinity, convert to maximum (24 bit) values. 1020 1021 return (uint32) ((sign << 31) | ((0x7eL + 128 - 64) << 23) | (0xffffL << 7)); 1022 1023 } 1024 1025 else 1026 { 1027 1028 // Nan -- Just set to zero. 1029 1030 return 0; 1031 1032 } 1033 1034 } 1035 1036 // Normalized number 1037 1038 exponent += (128 - 64); 1039 mantissa <<= 7; 1040 1041 // Assemble sign, exponent and mantissa. 1042 1043 return (uint32) ((sign << 31) | (exponent << 23) | mantissa); 1044 1045 } 1046 1047/*****************************************************************************/ 1048 1049inline void DNG_FloatToFP24 (uint32 input, uint8 *output) 1050 { 1051 1052 int32 exponent = (int32) ((input >> 23) & 0xFF) - 128; 1053 int32 mantissa = input & 0x007FFFFF; 1054 1055 if (exponent == 127) // infinity or NaN 1056 { 1057 1058 // Will the NaN alais to infinity? 1059 1060 if (mantissa != 0x007FFFFF && ((mantissa >> 7) == 0xFFFF)) 1061 { 1062 1063 mantissa &= 0x003FFFFF; // knock out msb to make it a NaN 1064 1065 } 1066 1067 } 1068 1069 else if (exponent > 63) // overflow, map to infinity 1070 { 1071 1072 exponent = 63; 1073 mantissa = 0x007FFFFF; 1074 1075 } 1076 1077 else if (exponent <= -64) 1078 { 1079 1080 if (exponent >= -79) // encode as denorm 1081 { 1082 mantissa = (mantissa | 0x00800000) >> (-63 - exponent); 1083 } 1084 1085 else // underflow to zero 1086 { 1087 mantissa = 0; 1088 } 1089 1090 exponent = -64; 1091 1092 } 1093 1094 output [0] = (uint8)(((input >> 24) & 0x80) | (uint32) (exponent + 64)); 1095 1096 output [1] = (mantissa >> 15) & 0x00FF; 1097 output [2] = (mantissa >> 7) & 0x00FF; 1098 1099 } 1100 1101/******************************************************************************/ 1102 1103// The following code was from PSDivide.h in Photoshop. 1104 1105// High order 32-bits of an unsigned 32 by 32 multiply. 1106 1107#ifndef MULUH 1108 1109#if defined(_X86_) && defined(_MSC_VER) 1110 1111inline uint32 Muluh86 (uint32 x, uint32 y) 1112 { 1113 uint32 result; 1114 __asm 1115 { 1116 MOV EAX, x 1117 MUL y 1118 MOV result, EDX 1119 } 1120 return (result); 1121 } 1122 1123#define MULUH Muluh86 1124 1125#else 1126 1127#define MULUH(x,y) ((uint32) (((x) * (uint64) (y)) >> 32)) 1128 1129#endif 1130 1131#endif 1132 1133// High order 32-bits of an signed 32 by 32 multiply. 1134 1135#ifndef MULSH 1136 1137#if defined(_X86_) && defined(_MSC_VER) 1138 1139inline int32 Mulsh86 (int32 x, int32 y) 1140 { 1141 int32 result; 1142 __asm 1143 { 1144 MOV EAX, x 1145 IMUL y 1146 MOV result, EDX 1147 } 1148 return (result); 1149 } 1150 1151#define MULSH Mulsh86 1152 1153#else 1154 1155#define MULSH(x,y) ((int32) (((x) * (int64) (y)) >> 32)) 1156 1157#endif 1158 1159#endif 1160 1161/******************************************************************************/ 1162 1163// Random number generator (identical to Apple's) for portable use. 1164 1165// This implements the "minimal standard random number generator" 1166// as proposed by Park and Miller in CACM October, 1988. 1167// It has a period of 2147483647 (0x7fffffff) 1168 1169// This is the ACM standard 30 bit generator: 1170// x' = (x * 16807) mod 2^31-1 1171// This function intentionally exploits the defined behavior of unsigned integer 1172// overflow. 1173#if defined(__clang__) && defined(__has_attribute) 1174#if __has_attribute(no_sanitize) 1175__attribute__((no_sanitize("unsigned-integer-overflow"))) 1176#endif 1177#endif 1178inline uint32 DNG_Random (uint32 seed) 1179 { 1180 1181 // high = seed / 127773 1182 1183 uint32 temp = MULUH (0x069C16BD, seed); 1184 uint32 high = (temp + ((seed - temp) >> 1)) >> 16; 1185 1186 // low = seed % 127773 1187 1188 uint32 low = seed - high * 127773; 1189 1190 // seed = (seed * 16807) % 2147483647 1191 1192 seed = 16807 * low - 2836 * high; 1193 1194 if (seed & 0x80000000) 1195 seed += 2147483647; 1196 1197 return seed; 1198 1199 } 1200 1201/*****************************************************************************/ 1202 1203class dng_dither 1204 { 1205 1206 public: 1207 1208 static const uint32 kRNGBits = 7; 1209 1210 static const uint32 kRNGSize = 1 << kRNGBits; 1211 1212 static const uint32 kRNGMask = kRNGSize - 1; 1213 1214 static const uint32 kRNGSize2D = kRNGSize * kRNGSize; 1215 1216 private: 1217 1218 dng_memory_data fNoiseBuffer; 1219 1220 private: 1221 1222 dng_dither (); 1223 1224 // Hidden copy constructor and assignment operator. 1225 1226 dng_dither (const dng_dither &); 1227 1228 dng_dither & operator= (const dng_dither &); 1229 1230 public: 1231 1232 static const dng_dither & Get (); 1233 1234 public: 1235 1236 const uint16 *NoiseBuffer16 () const 1237 { 1238 return fNoiseBuffer.Buffer_uint16 (); 1239 } 1240 1241 }; 1242 1243/*****************************************************************************/ 1244 1245void HistogramArea (dng_host &host, 1246 const dng_image &image, 1247 const dng_rect &area, 1248 uint32 *hist, 1249 uint32 histLimit, 1250 uint32 plane = 0); 1251 1252/*****************************************************************************/ 1253 1254void LimitFloatBitDepth (dng_host &host, 1255 const dng_image &srcImage, 1256 dng_image &dstImage, 1257 uint32 bitDepth, 1258 real32 scale = 1.0f); 1259 1260/*****************************************************************************/ 1261 1262#endif 1263 1264/*****************************************************************************/ 1265