1 /*****************************************************************************/ 2 // Copyright 2006 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_resample.cpp#1 $ */ 10 /* $DateTime: 2012/05/30 13:28:51 $ */ 11 /* $Change: 832332 $ */ 12 /* $Author: tknoll $ */ 13 14 /*****************************************************************************/ 15 16 #include "dng_resample.h" 17 18 #include "dng_assertions.h" 19 #include "dng_bottlenecks.h" 20 #include "dng_filter_task.h" 21 #include "dng_host.h" 22 #include "dng_image.h" 23 #include "dng_memory.h" 24 #include "dng_pixel_buffer.h" 25 #include "dng_safe_arithmetic.h" 26 #include "dng_tag_types.h" 27 #include "dng_utils.h" 28 29 /******************************************************************************/ 30 31 real64 dng_resample_bicubic::Extent () const 32 { 33 34 return 2.0; 35 36 } 37 38 /******************************************************************************/ 39 40 real64 dng_resample_bicubic::Evaluate (real64 x) const 41 { 42 43 const real64 A = -0.75; 44 45 x = Abs_real64 (x); 46 47 if (x >= 2.0) 48 return 0.0; 49 50 else if (x >= 1.0) 51 return (((A * x - 5.0 * A) * x + 8.0 * A) * x - 4.0 * A); 52 53 else 54 return (((A + 2.0) * x - (A + 3.0)) * x * x + 1.0); 55 56 } 57 58 /******************************************************************************/ 59 60 const dng_resample_function & dng_resample_bicubic::Get () 61 { 62 63 static dng_resample_bicubic static_dng_resample_bicubic; 64 65 return static_dng_resample_bicubic; 66 67 } 68 69 /*****************************************************************************/ 70 71 dng_resample_coords::dng_resample_coords () 72 73 : fOrigin (0) 74 , fCoords () 75 76 { 77 78 } 79 80 /*****************************************************************************/ 81 82 dng_resample_coords::~dng_resample_coords () 83 { 84 85 } 86 87 /*****************************************************************************/ 88 89 void dng_resample_coords::Initialize (int32 srcOrigin, 90 int32 dstOrigin, 91 uint32 srcCount, 92 uint32 dstCount, 93 dng_memory_allocator &allocator) 94 { 95 96 fOrigin = dstOrigin; 97 98 uint32 dstEntries = 0; 99 uint32 bufferSize = 0; 100 if (!RoundUpUint32ToMultiple(dstCount, 8, &dstEntries) || 101 !SafeUint32Mult(dstEntries, sizeof(int32), &bufferSize)) { 102 ThrowMemoryFull("Arithmetic overflow computing size for coordinate " 103 "buffer"); 104 } 105 fCoords.Reset (allocator.Allocate (bufferSize)); 106 107 int32 *coords = fCoords->Buffer_int32 (); 108 109 real64 invScale = (real64) srcCount / 110 (real64) dstCount; 111 112 for (uint32 j = 0; j < dstCount; j++) 113 { 114 115 real64 x = (real64) j + 0.5; 116 117 real64 y = x * invScale - 0.5 + (real64) srcOrigin; 118 119 coords [j] = Round_int32 (y * (real64) kResampleSubsampleCount); 120 121 } 122 123 // Pad out table by replicating last entry. 124 125 for (uint32 k = dstCount; k < dstEntries; k++) 126 { 127 128 coords [k] = coords [dstCount - 1]; 129 130 } 131 132 } 133 134 /*****************************************************************************/ 135 136 dng_resample_weights::dng_resample_weights () 137 138 : fRadius (0) 139 140 , fWeightStep (0) 141 142 , fWeights32 () 143 , fWeights16 () 144 145 { 146 147 } 148 149 /*****************************************************************************/ 150 151 dng_resample_weights::~dng_resample_weights () 152 { 153 154 } 155 156 /*****************************************************************************/ 157 158 void dng_resample_weights::Initialize (real64 scale, 159 const dng_resample_function &kernel, 160 dng_memory_allocator &allocator) 161 { 162 163 uint32 j; 164 165 // We only adjust the kernel size for scale factors less than 1.0. 166 167 scale = Min_real64 (scale, 1.0); 168 169 // Find radius of this kernel. 170 171 fRadius = (uint32) (kernel.Extent () / scale + 0.9999); 172 173 // Width is twice the radius. 174 175 uint32 width = fRadius * 2; 176 177 // Round to each set to weights to a multiple of 8 entries. 178 179 if (!RoundUpUint32ToMultiple (width, 8, &fWeightStep)) 180 { 181 182 ThrowMemoryFull ("Arithmetic overflow computing fWeightStep"); 183 184 } 185 186 // Allocate and zero weight tables. 187 188 uint32 bufferSize = 0; 189 190 if (!SafeUint32Mult (fWeightStep, kResampleSubsampleCount, &bufferSize) || 191 !SafeUint32Mult (bufferSize, (uint32) sizeof (real32), &bufferSize)) 192 { 193 194 ThrowMemoryFull("Arithmetic overflow computing buffer size."); 195 196 } 197 198 fWeights32.Reset (allocator.Allocate (bufferSize)); 199 200 DoZeroBytes (fWeights32->Buffer (), 201 fWeights32->LogicalSize ()); 202 203 if (!SafeUint32Mult (fWeightStep, kResampleSubsampleCount, &bufferSize) || 204 !SafeUint32Mult (bufferSize, (uint32) sizeof (int16), &bufferSize)) 205 { 206 207 ThrowMemoryFull("Arithmetic overflow computing buffer size."); 208 209 } 210 211 fWeights16.Reset (allocator.Allocate (bufferSize)); 212 213 DoZeroBytes (fWeights16->Buffer (), 214 fWeights16->LogicalSize ()); 215 216 // Compute kernel for each subsample values. 217 218 for (uint32 sample = 0; sample < kResampleSubsampleCount; sample++) 219 { 220 221 real64 fract = sample * (1.0 / (real64) kResampleSubsampleCount); 222 223 real32 *w32 = fWeights32->Buffer_real32 () + fWeightStep * sample; 224 225 // Evaluate kernel function for 32 bit weights. 226 227 { 228 229 real64 t32 = 0.0; 230 231 for (j = 0; j < width; j++) 232 { 233 234 int32 k = (int32) j - (int32) fRadius + 1; 235 236 real64 x = (k - fract) * scale; 237 238 w32 [j] = (real32) kernel.Evaluate (x); 239 240 t32 += w32 [j]; 241 242 } 243 244 // Scale 32 bit weights so total of weights is 1.0. 245 246 real32 s32 = (real32) (1.0 / t32); 247 248 for (j = 0; j < width; j++) 249 { 250 251 w32 [j] *= s32; 252 253 } 254 255 } 256 257 // Round off 32 bit weights to 16 bit weights. 258 259 { 260 261 int16 *w16 = fWeights16->Buffer_int16 () + fWeightStep * sample; 262 263 int32 t16 = 0; 264 265 for (j = 0; j < width; j++) 266 { 267 268 w16 [j] = (int16) Round_int32 (w32 [j] * 16384.0); 269 270 t16 += w16 [j]; 271 272 } 273 274 // Adjust center entry for any round off error so total is 275 // exactly 16384. 276 277 w16 [fRadius - (fract >= 0.5 ? 0 : 1)] += (int16) (16384 - t16); 278 279 } 280 281 } 282 283 } 284 285 /*****************************************************************************/ 286 287 dng_resample_weights_2d::dng_resample_weights_2d () 288 289 : fRadius (0) 290 291 , fRowStep (0) 292 , fColStep (0) 293 294 , fWeights32 () 295 , fWeights16 () 296 297 { 298 299 } 300 301 /*****************************************************************************/ 302 303 dng_resample_weights_2d::~dng_resample_weights_2d () 304 { 305 306 } 307 308 /*****************************************************************************/ 309 310 void dng_resample_weights_2d::Initialize (const dng_resample_function &kernel, 311 dng_memory_allocator &allocator) 312 { 313 314 // Find radius of this kernel. Unlike with 1d resample weights (see 315 // dng_resample_weights), we never scale up the kernel size. 316 317 fRadius = (uint32) (kernel.Extent () + 0.9999); 318 319 // Width is twice the radius. 320 321 uint32 width = 0; 322 uint32 widthSqr = 0; 323 uint32 step = 0; 324 325 if (!SafeUint32Mult (fRadius, 2, &width) || 326 !SafeUint32Mult (width, width, &widthSqr) || 327 !RoundUpUint32ToMultiple (widthSqr, 8, &step) || 328 !SafeUint32Mult (step, kResampleSubsampleCount2D, &fRowStep)) 329 { 330 331 ThrowMemoryFull ("Arithmetic overflow computing row step."); 332 333 } 334 335 fColStep = step; 336 337 // Allocate and zero weight tables. 338 339 uint32 bufferSize = 0; 340 341 if (!SafeUint32Mult (step, kResampleSubsampleCount2D, &bufferSize) || 342 !SafeUint32Mult (bufferSize, kResampleSubsampleCount2D, &bufferSize) || 343 !SafeUint32Mult (bufferSize, (uint32) sizeof (real32), &bufferSize)) 344 { 345 346 ThrowMemoryFull ("Arithmetic overflow computing buffer size."); 347 348 } 349 350 fWeights32.Reset (allocator.Allocate (bufferSize)); 351 352 DoZeroBytes (fWeights32->Buffer (), 353 fWeights32->LogicalSize ()); 354 355 356 if (!SafeUint32Mult (step, kResampleSubsampleCount2D, &bufferSize) || 357 !SafeUint32Mult (bufferSize, kResampleSubsampleCount2D, &bufferSize) || 358 !SafeUint32Mult (bufferSize, (uint32) sizeof (int16), &bufferSize)) 359 { 360 361 ThrowMemoryFull ("Arithmetic overflow computing buffer size."); 362 363 } 364 365 fWeights16.Reset (allocator.Allocate (bufferSize)); 366 367 DoZeroBytes (fWeights16->Buffer (), 368 fWeights16->LogicalSize ()); 369 370 // Compute kernel for each subsample values. 371 372 for (uint32 y = 0; y < kResampleSubsampleCount2D; y++) 373 { 374 375 real64 yFract = y * (1.0 / (real64) kResampleSubsampleCount2D); 376 377 for (uint32 x = 0; x < kResampleSubsampleCount2D; x++) 378 { 379 380 real64 xFract = x * (1.0 / (real64) kResampleSubsampleCount2D); 381 382 real32 *w32 = (real32 *) Weights32 (dng_point ((int32) y, 383 (int32) x)); 384 385 // Evaluate kernel function for 32 bit weights. 386 387 { 388 389 real64 t32 = 0.0; 390 391 uint32 index = 0; 392 393 for (uint32 i = 0; i < width; i++) 394 { 395 396 int32 yInt = ((int32) i) - (int32) fRadius + 1; 397 real64 yPos = yInt - yFract; 398 399 for (uint32 j = 0; j < width; j++) 400 { 401 402 int32 xInt = ((int32) j) - (int32) fRadius + 1; 403 real64 xPos = xInt - xFract; 404 405 #if 0 406 407 // Radial. 408 409 real64 dy2 = yPos * yPos; 410 real64 dx2 = xPos * xPos; 411 412 real64 r = sqrt (dx2 + dy2); 413 414 w32 [index] = (real32) kernel.Evaluate (r); 415 416 #else 417 418 // Separable. 419 420 w32 [index] = (real32) kernel.Evaluate (xPos) * 421 (real32) kernel.Evaluate (yPos); 422 423 #endif 424 425 t32 += w32 [index]; 426 427 index++; 428 429 } 430 431 } 432 433 // Scale 32 bit weights so total of weights is 1.0. 434 435 const real32 s32 = (real32) (1.0 / t32); 436 437 for (uint32 i = 0; i < widthSqr; i++) 438 { 439 440 w32 [i] *= s32; 441 442 } 443 444 } 445 446 // Round off 32 bit weights to 16 bit weights. 447 448 { 449 450 int16 *w16 = (int16 *) Weights16 (dng_point ((int32) y, 451 (int32) x)); 452 453 int32 t16 = 0; 454 455 for (uint32 j = 0; j < widthSqr; j++) 456 { 457 458 w16 [j] = (int16) Round_int32 (w32 [j] * 16384.0); 459 460 t16 += w16 [j]; 461 462 } 463 464 // Adjust one of the center entries for any round off error so total 465 // is exactly 16384. 466 467 const uint32 xOffset = fRadius - ((xFract >= 0.5) ? 0 : 1); 468 const uint32 yOffset = fRadius - ((yFract >= 0.5) ? 0 : 1); 469 const uint32 centerOffset = width * yOffset + xOffset; 470 471 w16 [centerOffset] += (int16) (16384 - t16); 472 473 } 474 475 } 476 477 } 478 479 } 480 481 /*****************************************************************************/ 482 483 class dng_resample_task: public dng_filter_task 484 { 485 486 protected: 487 488 dng_rect fSrcBounds; 489 dng_rect fDstBounds; 490 491 const dng_resample_function &fKernel; 492 493 real64 fRowScale; 494 real64 fColScale; 495 496 dng_resample_coords fRowCoords; 497 dng_resample_coords fColCoords; 498 499 dng_resample_weights fWeightsV; 500 dng_resample_weights fWeightsH; 501 502 dng_point fSrcTileSize; 503 504 AutoPtr<dng_memory_block> fTempBuffer [kMaxMPThreads]; 505 506 public: 507 508 dng_resample_task (const dng_image &srcImage, 509 dng_image &dstImage, 510 const dng_rect &srcBounds, 511 const dng_rect &dstBounds, 512 const dng_resample_function &kernel); 513 514 virtual dng_rect SrcArea (const dng_rect &dstArea); 515 516 virtual dng_point SrcTileSize (const dng_point &dstTileSize); 517 518 virtual void Start (uint32 threadCount, 519 const dng_point &tileSize, 520 dng_memory_allocator *allocator, 521 dng_abort_sniffer *sniffer); 522 523 virtual void ProcessArea (uint32 threadIndex, 524 dng_pixel_buffer &srcBuffer, 525 dng_pixel_buffer &dstBuffer); 526 527 }; 528 529 /*****************************************************************************/ 530 531 dng_resample_task::dng_resample_task (const dng_image &srcImage, 532 dng_image &dstImage, 533 const dng_rect &srcBounds, 534 const dng_rect &dstBounds, 535 const dng_resample_function &kernel) 536 537 : dng_filter_task (srcImage, 538 dstImage) 539 540 , fSrcBounds (srcBounds) 541 , fDstBounds (dstBounds) 542 543 , fKernel (kernel) 544 545 , fRowScale ((srcBounds.H () != 0) ? dstBounds.H () / (real64) srcBounds.H () : 0) 546 , fColScale ((srcBounds.W () != 0) ? dstBounds.W () / (real64) srcBounds.W () : 0) 547 548 , fRowCoords () 549 , fColCoords () 550 551 , fWeightsV () 552 , fWeightsH () 553 554 , fSrcTileSize () 555 556 { 557 if (fRowScale == 0 || fColScale == 0) 558 { 559 ThrowBadFormat (); 560 } 561 562 if (srcImage.PixelSize () <= 2 && 563 dstImage.PixelSize () <= 2 && 564 srcImage.PixelRange () == dstImage.PixelRange ()) 565 { 566 fSrcPixelType = ttShort; 567 fDstPixelType = ttShort; 568 } 569 570 else 571 { 572 fSrcPixelType = ttFloat; 573 fDstPixelType = ttFloat; 574 } 575 576 fUnitCell = dng_point (8, 8); 577 578 fMaxTileSize.v = Pin_int32 (fUnitCell.v, 579 Round_int32 (fMaxTileSize.v * fRowScale), 580 fMaxTileSize.v); 581 582 fMaxTileSize.h = Pin_int32 (fUnitCell.h, 583 Round_int32 (fMaxTileSize.h * fColScale), 584 fMaxTileSize.h); 585 586 } 587 588 /*****************************************************************************/ 589 590 dng_rect dng_resample_task::SrcArea (const dng_rect &dstArea) 591 { 592 593 int32 offsetV = fWeightsV.Offset (); 594 int32 offsetH = fWeightsH.Offset (); 595 596 uint32 widthV = fWeightsV.Width (); 597 uint32 widthH = fWeightsH.Width (); 598 599 dng_rect srcArea; 600 601 srcArea.t = SafeInt32Add (fRowCoords.Pixel (dstArea.t), offsetV); 602 srcArea.l = SafeInt32Add (fColCoords.Pixel (dstArea.l), offsetH); 603 604 srcArea.b = SafeInt32Add (SafeInt32Add ( 605 fRowCoords.Pixel (SafeInt32Sub (dstArea.b, 1)), 606 offsetV), 607 ConvertUint32ToInt32 (widthV));; 608 srcArea.r = SafeInt32Add(SafeInt32Add( 609 fColCoords.Pixel (SafeInt32Sub (dstArea.r, 1)), 610 offsetH), 611 ConvertUint32ToInt32(widthH));; 612 613 return srcArea; 614 615 } 616 617 /*****************************************************************************/ 618 619 dng_point dng_resample_task::SrcTileSize (const dng_point & /* dstTileSize */) 620 { 621 622 return fSrcTileSize; 623 624 } 625 626 /*****************************************************************************/ 627 628 void dng_resample_task::Start (uint32 threadCount, 629 const dng_point &tileSize, 630 dng_memory_allocator *allocator, 631 dng_abort_sniffer *sniffer) 632 { 633 634 // Compute sub-pixel resolution coordinates in the source image for 635 // each row and column of the destination area. 636 637 fRowCoords.Initialize (fSrcBounds.t, 638 fDstBounds.t, 639 fSrcBounds.H (), 640 fDstBounds.H (), 641 *allocator); 642 643 fColCoords.Initialize (fSrcBounds.l, 644 fDstBounds.l, 645 fSrcBounds.W (), 646 fDstBounds.W (), 647 *allocator); 648 649 // Compute resampling kernels. 650 651 fWeightsV.Initialize (fRowScale, 652 fKernel, 653 *allocator); 654 655 fWeightsH.Initialize (fColScale, 656 fKernel, 657 *allocator); 658 659 // Find upper bound on source source tile. 660 661 fSrcTileSize.v = Round_int32 (tileSize.v / fRowScale) + fWeightsV.Width () + 2; 662 fSrcTileSize.h = Round_int32 (tileSize.h / fColScale) + fWeightsH.Width () + 2; 663 664 // Allocate temp buffers. 665 666 uint32 tempBufferSize = 0; 667 if (!RoundUpUint32ToMultiple (fSrcTileSize.h, 8, &tempBufferSize) || 668 !SafeUint32Mult (tempBufferSize, 669 static_cast<uint32> (sizeof (real32)), 670 &tempBufferSize)) 671 { 672 673 ThrowMemoryFull("Arithmetic overflow computing buffer size."); 674 675 } 676 677 for (uint32 threadIndex = 0; threadIndex < threadCount; threadIndex++) 678 { 679 680 fTempBuffer [threadIndex] . Reset (allocator->Allocate (tempBufferSize)); 681 682 } 683 684 // Allocate the pixel buffers. 685 686 dng_filter_task::Start (threadCount, 687 tileSize, 688 allocator, 689 sniffer); 690 691 } 692 693 /*****************************************************************************/ 694 695 void dng_resample_task::ProcessArea (uint32 threadIndex, 696 dng_pixel_buffer &srcBuffer, 697 dng_pixel_buffer &dstBuffer) 698 { 699 700 dng_rect srcArea = srcBuffer.fArea; 701 dng_rect dstArea = dstBuffer.fArea; 702 703 uint32 srcCols = srcArea.W (); 704 uint32 dstCols = dstArea.W (); 705 706 uint32 widthV = fWeightsV.Width (); 707 uint32 widthH = fWeightsH.Width (); 708 709 int32 offsetV = fWeightsV.Offset (); 710 int32 offsetH = fWeightsH.Offset (); 711 712 uint32 stepH = fWeightsH.Step (); 713 714 const int32 *rowCoords = fRowCoords.Coords (0 ); 715 const int32 *colCoords = fColCoords.Coords (dstArea.l); 716 717 if (fSrcPixelType == ttFloat) 718 { 719 720 const real32 *weightsH = fWeightsH.Weights32 (0); 721 722 real32 *tPtr = fTempBuffer [threadIndex]->Buffer_real32 (); 723 724 real32 *ttPtr = tPtr + offsetH - srcArea.l; 725 726 for (int32 dstRow = dstArea.t; dstRow < dstArea.b; dstRow++) 727 { 728 729 int32 rowCoord = rowCoords [dstRow]; 730 731 int32 rowFract = rowCoord & kResampleSubsampleMask; 732 733 const real32 *weightsV = fWeightsV.Weights32 (rowFract); 734 735 int32 srcRow = (rowCoord >> kResampleSubsampleBits) + offsetV; 736 737 for (uint32 plane = 0; plane < dstBuffer.fPlanes; plane++) 738 { 739 740 const real32 *sPtr = srcBuffer.ConstPixel_real32 (srcRow, 741 srcArea.l, 742 plane); 743 744 DoResampleDown32 (sPtr, 745 tPtr, 746 srcCols, 747 srcBuffer.fRowStep, 748 weightsV, 749 widthV); 750 751 real32 *dPtr = dstBuffer.DirtyPixel_real32 (dstRow, 752 dstArea.l, 753 plane); 754 755 DoResampleAcross32 (ttPtr, 756 dPtr, 757 dstCols, 758 colCoords, 759 weightsH, 760 widthH, 761 stepH); 762 763 } 764 765 } 766 767 } 768 769 else 770 { 771 772 const int16 *weightsH = fWeightsH.Weights16 (0); 773 774 uint16 *tPtr = fTempBuffer [threadIndex]->Buffer_uint16 (); 775 776 uint16 *ttPtr = tPtr + offsetH - srcArea.l; 777 778 uint32 pixelRange = fDstImage.PixelRange (); 779 780 for (int32 dstRow = dstArea.t; dstRow < dstArea.b; dstRow++) 781 { 782 783 int32 rowCoord = rowCoords [dstRow]; 784 785 int32 rowFract = rowCoord & kResampleSubsampleMask; 786 787 const int16 *weightsV = fWeightsV.Weights16 (rowFract); 788 789 int32 srcRow = (rowCoord >> kResampleSubsampleBits) + offsetV; 790 791 for (uint32 plane = 0; plane < dstBuffer.fPlanes; plane++) 792 { 793 794 const uint16 *sPtr = srcBuffer.ConstPixel_uint16 (srcRow, 795 srcArea.l, 796 plane); 797 798 DoResampleDown16 (sPtr, 799 tPtr, 800 srcCols, 801 srcBuffer.fRowStep, 802 weightsV, 803 widthV, 804 pixelRange); 805 806 uint16 *dPtr = dstBuffer.DirtyPixel_uint16 (dstRow, 807 dstArea.l, 808 plane); 809 810 DoResampleAcross16 (ttPtr, 811 dPtr, 812 dstCols, 813 colCoords, 814 weightsH, 815 widthH, 816 stepH, 817 pixelRange); 818 819 } 820 821 } 822 823 } 824 825 } 826 827 /*****************************************************************************/ 828 829 void ResampleImage (dng_host &host, 830 const dng_image &srcImage, 831 dng_image &dstImage, 832 const dng_rect &srcBounds, 833 const dng_rect &dstBounds, 834 const dng_resample_function &kernel) 835 { 836 837 dng_resample_task task (srcImage, 838 dstImage, 839 srcBounds, 840 dstBounds, 841 kernel); 842 843 host.PerformAreaTask (task, 844 dstBounds); 845 846 } 847 848 /*****************************************************************************/ 849
