1/* 2 * Copyright 2016 Google Inc. 3 * 4 * Use of this source code is governed by a BSD-style license that can be 5 * found in the LICENSE file. 6 */ 7 8#include "SkCodec.h" 9#include "SkCodecPriv.h" 10#include "SkColorPriv.h" 11#include "SkData.h" 12#include "SkJpegCodec.h" 13#include "SkMutex.h" 14#include "SkRawCodec.h" 15#include "SkRefCnt.h" 16#include "SkStream.h" 17#include "SkStreamPriv.h" 18#include "SkSwizzler.h" 19#include "SkTArray.h" 20#include "SkTaskGroup.h" 21#include "SkTemplates.h" 22#include "SkTypes.h" 23 24#include "dng_area_task.h" 25#include "dng_color_space.h" 26#include "dng_errors.h" 27#include "dng_exceptions.h" 28#include "dng_host.h" 29#include "dng_info.h" 30#include "dng_memory.h" 31#include "dng_render.h" 32#include "dng_stream.h" 33 34#include "src/piex.h" 35 36#include <cmath> // for std::round,floor,ceil 37#include <limits> 38 39namespace { 40 41// Caluclates the number of tiles of tile_size that fit into the area in vertical and horizontal 42// directions. 43dng_point num_tiles_in_area(const dng_point &areaSize, 44 const dng_point_real64 &tileSize) { 45 // FIXME: Add a ceil_div() helper in SkCodecPriv.h 46 return dng_point(static_cast<int32>((areaSize.v + tileSize.v - 1) / tileSize.v), 47 static_cast<int32>((areaSize.h + tileSize.h - 1) / tileSize.h)); 48} 49 50int num_tasks_required(const dng_point& tilesInTask, 51 const dng_point& tilesInArea) { 52 return ((tilesInArea.v + tilesInTask.v - 1) / tilesInTask.v) * 53 ((tilesInArea.h + tilesInTask.h - 1) / tilesInTask.h); 54} 55 56// Calculate the number of tiles to process per task, taking into account the maximum number of 57// tasks. It prefers to increase horizontally for better locality of reference. 58dng_point num_tiles_per_task(const int maxTasks, 59 const dng_point &tilesInArea) { 60 dng_point tilesInTask = {1, 1}; 61 while (num_tasks_required(tilesInTask, tilesInArea) > maxTasks) { 62 if (tilesInTask.h < tilesInArea.h) { 63 ++tilesInTask.h; 64 } else if (tilesInTask.v < tilesInArea.v) { 65 ++tilesInTask.v; 66 } else { 67 ThrowProgramError("num_tiles_per_task calculation is wrong."); 68 } 69 } 70 return tilesInTask; 71} 72 73std::vector<dng_rect> compute_task_areas(const int maxTasks, const dng_rect& area, 74 const dng_point& tileSize) { 75 std::vector<dng_rect> taskAreas; 76 const dng_point tilesInArea = num_tiles_in_area(area.Size(), tileSize); 77 const dng_point tilesPerTask = num_tiles_per_task(maxTasks, tilesInArea); 78 const dng_point taskAreaSize = {tilesPerTask.v * tileSize.v, 79 tilesPerTask.h * tileSize.h}; 80 for (int v = 0; v < tilesInArea.v; v += tilesPerTask.v) { 81 for (int h = 0; h < tilesInArea.h; h += tilesPerTask.h) { 82 dng_rect taskArea; 83 taskArea.t = area.t + v * tileSize.v; 84 taskArea.l = area.l + h * tileSize.h; 85 taskArea.b = Min_int32(taskArea.t + taskAreaSize.v, area.b); 86 taskArea.r = Min_int32(taskArea.l + taskAreaSize.h, area.r); 87 88 taskAreas.push_back(taskArea); 89 } 90 } 91 return taskAreas; 92} 93 94class SkDngHost : public dng_host { 95public: 96 explicit SkDngHost(dng_memory_allocator* allocater) : dng_host(allocater) {} 97 98 void PerformAreaTask(dng_area_task& task, const dng_rect& area) override { 99 // The area task gets split up into max_tasks sub-tasks. The max_tasks is defined by the 100 // dng-sdks default implementation of dng_area_task::MaxThreads() which returns 8 or 32 101 // sub-tasks depending on the architecture. 102 const int maxTasks = static_cast<int>(task.MaxThreads()); 103 104 SkTaskGroup taskGroup; 105 106 // tileSize is typically 256x256 107 const dng_point tileSize(task.FindTileSize(area)); 108 const std::vector<dng_rect> taskAreas = compute_task_areas(maxTasks, area, tileSize); 109 const int numTasks = static_cast<int>(taskAreas.size()); 110 111 SkMutex mutex; 112 SkTArray<dng_exception> exceptions; 113 task.Start(numTasks, tileSize, &Allocator(), Sniffer()); 114 for (int taskIndex = 0; taskIndex < numTasks; ++taskIndex) { 115 taskGroup.add([&mutex, &exceptions, &task, this, taskIndex, taskAreas, tileSize] { 116 try { 117 task.ProcessOnThread(taskIndex, taskAreas[taskIndex], tileSize, this->Sniffer()); 118 } catch (dng_exception& exception) { 119 SkAutoMutexAcquire lock(mutex); 120 exceptions.push_back(exception); 121 } catch (...) { 122 SkAutoMutexAcquire lock(mutex); 123 exceptions.push_back(dng_exception(dng_error_unknown)); 124 } 125 }); 126 } 127 128 taskGroup.wait(); 129 task.Finish(numTasks); 130 131 // Currently we only re-throw the first catched exception. 132 if (!exceptions.empty()) { 133 Throw_dng_error(exceptions.front().ErrorCode(), nullptr, nullptr); 134 } 135 } 136 137 uint32 PerformAreaTaskThreads() override { 138 // FIXME: Need to get the real amount of available threads used in the SkTaskGroup. 139 return kMaxMPThreads; 140 } 141 142private: 143 typedef dng_host INHERITED; 144}; 145 146// T must be unsigned type. 147template <class T> 148bool safe_add_to_size_t(T arg1, T arg2, size_t* result) { 149 SkASSERT(arg1 >= 0); 150 SkASSERT(arg2 >= 0); 151 if (arg1 >= 0 && arg2 <= std::numeric_limits<T>::max() - arg1) { 152 T sum = arg1 + arg2; 153 if (sum <= std::numeric_limits<size_t>::max()) { 154 *result = static_cast<size_t>(sum); 155 return true; 156 } 157 } 158 return false; 159} 160 161class SkDngMemoryAllocator : public dng_memory_allocator { 162public: 163 ~SkDngMemoryAllocator() override {} 164 165 dng_memory_block* Allocate(uint32 size) override { 166 // To avoid arbitary allocation requests which might lead to out-of-memory, limit the 167 // amount of memory that can be allocated at once. The memory limit is based on experiments 168 // and supposed to be sufficient for all valid DNG images. 169 if (size > 300 * 1024 * 1024) { // 300 MB 170 ThrowMemoryFull(); 171 } 172 return dng_memory_allocator::Allocate(size); 173 } 174}; 175 176bool is_asset_stream(const SkStream& stream) { 177 return stream.hasLength() && stream.hasPosition(); 178} 179 180} // namespace 181 182class SkRawStream { 183public: 184 virtual ~SkRawStream() {} 185 186 /* 187 * Gets the length of the stream. Depending on the type of stream, this may require reading to 188 * the end of the stream. 189 */ 190 virtual uint64 getLength() = 0; 191 192 virtual bool read(void* data, size_t offset, size_t length) = 0; 193 194 /* 195 * Creates an SkMemoryStream from the offset with size. 196 * Note: for performance reason, this function is destructive to the SkRawStream. One should 197 * abandon current object after the function call. 198 */ 199 virtual SkMemoryStream* transferBuffer(size_t offset, size_t size) = 0; 200}; 201 202class SkRawLimitedDynamicMemoryWStream : public SkDynamicMemoryWStream { 203public: 204 virtual ~SkRawLimitedDynamicMemoryWStream() {} 205 206 bool write(const void* buffer, size_t size) override { 207 size_t newSize; 208 if (!safe_add_to_size_t(this->bytesWritten(), size, &newSize) || 209 newSize > kMaxStreamSize) 210 { 211 SkCodecPrintf("Error: Stream size exceeds the limit.\n"); 212 return false; 213 } 214 return this->INHERITED::write(buffer, size); 215 } 216 217private: 218 // Most of valid RAW images will not be larger than 100MB. This limit is helpful to avoid 219 // streaming too large data chunk. We can always adjust the limit here if we need. 220 const size_t kMaxStreamSize = 100 * 1024 * 1024; // 100MB 221 222 typedef SkDynamicMemoryWStream INHERITED; 223}; 224 225// Note: the maximum buffer size is 100MB (limited by SkRawLimitedDynamicMemoryWStream). 226class SkRawBufferedStream : public SkRawStream { 227public: 228 // Will take the ownership of the stream. 229 explicit SkRawBufferedStream(SkStream* stream) 230 : fStream(stream) 231 , fWholeStreamRead(false) 232 { 233 // Only use SkRawBufferedStream when the stream is not an asset stream. 234 SkASSERT(!is_asset_stream(*stream)); 235 } 236 237 ~SkRawBufferedStream() override {} 238 239 uint64 getLength() override { 240 if (!this->bufferMoreData(kReadToEnd)) { // read whole stream 241 ThrowReadFile(); 242 } 243 return fStreamBuffer.bytesWritten(); 244 } 245 246 bool read(void* data, size_t offset, size_t length) override { 247 if (length == 0) { 248 return true; 249 } 250 251 size_t sum; 252 if (!safe_add_to_size_t(offset, length, &sum)) { 253 return false; 254 } 255 256 return this->bufferMoreData(sum) && fStreamBuffer.read(data, offset, length); 257 } 258 259 SkMemoryStream* transferBuffer(size_t offset, size_t size) override { 260 SkAutoTUnref<SkData> data(SkData::NewUninitialized(size)); 261 if (offset > fStreamBuffer.bytesWritten()) { 262 // If the offset is not buffered, read from fStream directly and skip the buffering. 263 const size_t skipLength = offset - fStreamBuffer.bytesWritten(); 264 if (fStream->skip(skipLength) != skipLength) { 265 return nullptr; 266 } 267 const size_t bytesRead = fStream->read(data->writable_data(), size); 268 if (bytesRead < size) { 269 data.reset(SkData::NewSubset(data.get(), 0, bytesRead)); 270 } 271 } else { 272 const size_t alreadyBuffered = SkTMin(fStreamBuffer.bytesWritten() - offset, size); 273 if (alreadyBuffered > 0 && 274 !fStreamBuffer.read(data->writable_data(), offset, alreadyBuffered)) { 275 return nullptr; 276 } 277 278 const size_t remaining = size - alreadyBuffered; 279 if (remaining) { 280 auto* dst = static_cast<uint8_t*>(data->writable_data()) + alreadyBuffered; 281 const size_t bytesRead = fStream->read(dst, remaining); 282 size_t newSize; 283 if (bytesRead < remaining) { 284 if (!safe_add_to_size_t(alreadyBuffered, bytesRead, &newSize)) { 285 return nullptr; 286 } 287 data.reset(SkData::NewSubset(data.get(), 0, newSize)); 288 } 289 } 290 } 291 return new SkMemoryStream(data); 292 } 293 294private: 295 // Note: if the newSize == kReadToEnd (0), this function will read to the end of stream. 296 bool bufferMoreData(size_t newSize) { 297 if (newSize == kReadToEnd) { 298 if (fWholeStreamRead) { // already read-to-end. 299 return true; 300 } 301 302 // TODO: optimize for the special case when the input is SkMemoryStream. 303 return SkStreamCopy(&fStreamBuffer, fStream.get()); 304 } 305 306 if (newSize <= fStreamBuffer.bytesWritten()) { // already buffered to newSize 307 return true; 308 } 309 if (fWholeStreamRead) { // newSize is larger than the whole stream. 310 return false; 311 } 312 313 // Try to read at least 8192 bytes to avoid to many small reads. 314 const size_t kMinSizeToRead = 8192; 315 const size_t sizeRequested = newSize - fStreamBuffer.bytesWritten(); 316 const size_t sizeToRead = SkTMax(kMinSizeToRead, sizeRequested); 317 SkAutoSTMalloc<kMinSizeToRead, uint8> tempBuffer(sizeToRead); 318 const size_t bytesRead = fStream->read(tempBuffer.get(), sizeToRead); 319 if (bytesRead < sizeRequested) { 320 return false; 321 } 322 return fStreamBuffer.write(tempBuffer.get(), bytesRead); 323 } 324 325 SkAutoTDelete<SkStream> fStream; 326 bool fWholeStreamRead; 327 328 // Use a size-limited stream to avoid holding too huge buffer. 329 SkRawLimitedDynamicMemoryWStream fStreamBuffer; 330 331 const size_t kReadToEnd = 0; 332}; 333 334class SkRawAssetStream : public SkRawStream { 335public: 336 // Will take the ownership of the stream. 337 explicit SkRawAssetStream(SkStream* stream) 338 : fStream(stream) 339 { 340 // Only use SkRawAssetStream when the stream is an asset stream. 341 SkASSERT(is_asset_stream(*stream)); 342 } 343 344 ~SkRawAssetStream() override {} 345 346 uint64 getLength() override { 347 return fStream->getLength(); 348 } 349 350 351 bool read(void* data, size_t offset, size_t length) override { 352 if (length == 0) { 353 return true; 354 } 355 356 size_t sum; 357 if (!safe_add_to_size_t(offset, length, &sum)) { 358 return false; 359 } 360 361 return fStream->seek(offset) && (fStream->read(data, length) == length); 362 } 363 364 SkMemoryStream* transferBuffer(size_t offset, size_t size) override { 365 if (fStream->getLength() < offset) { 366 return nullptr; 367 } 368 369 size_t sum; 370 if (!safe_add_to_size_t(offset, size, &sum)) { 371 return nullptr; 372 } 373 374 // This will allow read less than the requested "size", because the JPEG codec wants to 375 // handle also a partial JPEG file. 376 const size_t bytesToRead = SkTMin(sum, fStream->getLength()) - offset; 377 if (bytesToRead == 0) { 378 return nullptr; 379 } 380 381 if (fStream->getMemoryBase()) { // directly copy if getMemoryBase() is available. 382 SkAutoTUnref<SkData> data(SkData::NewWithCopy( 383 static_cast<const uint8_t*>(fStream->getMemoryBase()) + offset, bytesToRead)); 384 fStream.free(); 385 return new SkMemoryStream(data); 386 } else { 387 SkAutoTUnref<SkData> data(SkData::NewUninitialized(bytesToRead)); 388 if (!fStream->seek(offset)) { 389 return nullptr; 390 } 391 const size_t bytesRead = fStream->read(data->writable_data(), bytesToRead); 392 if (bytesRead < bytesToRead) { 393 data.reset(SkData::NewSubset(data.get(), 0, bytesRead)); 394 } 395 return new SkMemoryStream(data); 396 } 397 } 398private: 399 SkAutoTDelete<SkStream> fStream; 400}; 401 402class SkPiexStream : public ::piex::StreamInterface { 403public: 404 // Will NOT take the ownership of the stream. 405 explicit SkPiexStream(SkRawStream* stream) : fStream(stream) {} 406 407 ~SkPiexStream() override {} 408 409 ::piex::Error GetData(const size_t offset, const size_t length, 410 uint8* data) override { 411 return fStream->read(static_cast<void*>(data), offset, length) ? 412 ::piex::Error::kOk : ::piex::Error::kFail; 413 } 414 415private: 416 SkRawStream* fStream; 417}; 418 419class SkDngStream : public dng_stream { 420public: 421 // Will NOT take the ownership of the stream. 422 SkDngStream(SkRawStream* stream) : fStream(stream) {} 423 424 ~SkDngStream() override {} 425 426 uint64 DoGetLength() override { return fStream->getLength(); } 427 428 void DoRead(void* data, uint32 count, uint64 offset) override { 429 size_t sum; 430 if (!safe_add_to_size_t(static_cast<uint64>(count), offset, &sum) || 431 !fStream->read(data, static_cast<size_t>(offset), static_cast<size_t>(count))) { 432 ThrowReadFile(); 433 } 434 } 435 436private: 437 SkRawStream* fStream; 438}; 439 440class SkDngImage { 441public: 442 /* 443 * Initializes the object with the information from Piex in a first attempt. This way it can 444 * save time and storage to obtain the DNG dimensions and color filter array (CFA) pattern 445 * which is essential for the demosaicing of the sensor image. 446 * Note: this will take the ownership of the stream. 447 */ 448 static SkDngImage* NewFromStream(SkRawStream* stream) { 449 SkAutoTDelete<SkDngImage> dngImage(new SkDngImage(stream)); 450 if (!dngImage->isTiffHeaderValid()) { 451 return nullptr; 452 } 453 454 if (!dngImage->initFromPiex()) { 455 if (!dngImage->readDng()) { 456 return nullptr; 457 } 458 } 459 460 return dngImage.release(); 461 } 462 463 /* 464 * Renders the DNG image to the size. The DNG SDK only allows scaling close to integer factors 465 * down to 80 pixels on the short edge. The rendered image will be close to the specified size, 466 * but there is no guarantee that any of the edges will match the requested size. E.g. 467 * 100% size: 4000 x 3000 468 * requested size: 1600 x 1200 469 * returned size could be: 2000 x 1500 470 */ 471 dng_image* render(int width, int height) { 472 if (!fHost || !fInfo || !fNegative || !fDngStream) { 473 if (!this->readDng()) { 474 return nullptr; 475 } 476 } 477 478 // DNG SDK preserves the aspect ratio, so it only needs to know the longer dimension. 479 const int preferredSize = SkTMax(width, height); 480 try { 481 // render() takes ownership of fHost, fInfo, fNegative and fDngStream when available. 482 SkAutoTDelete<dng_host> host(fHost.release()); 483 SkAutoTDelete<dng_info> info(fInfo.release()); 484 SkAutoTDelete<dng_negative> negative(fNegative.release()); 485 SkAutoTDelete<dng_stream> dngStream(fDngStream.release()); 486 487 host->SetPreferredSize(preferredSize); 488 host->ValidateSizes(); 489 490 negative->ReadStage1Image(*host, *dngStream, *info); 491 492 if (info->fMaskIndex != -1) { 493 negative->ReadTransparencyMask(*host, *dngStream, *info); 494 } 495 496 negative->ValidateRawImageDigest(*host); 497 if (negative->IsDamaged()) { 498 return nullptr; 499 } 500 501 const int32 kMosaicPlane = -1; 502 negative->BuildStage2Image(*host); 503 negative->BuildStage3Image(*host, kMosaicPlane); 504 505 dng_render render(*host, *negative); 506 render.SetFinalSpace(dng_space_sRGB::Get()); 507 render.SetFinalPixelType(ttByte); 508 509 dng_point stage3_size = negative->Stage3Image()->Size(); 510 render.SetMaximumSize(SkTMax(stage3_size.h, stage3_size.v)); 511 512 return render.Render(); 513 } catch (...) { 514 return nullptr; 515 } 516 } 517 518 const SkImageInfo& getImageInfo() const { 519 return fImageInfo; 520 } 521 522 bool isScalable() const { 523 return fIsScalable; 524 } 525 526 bool isXtransImage() const { 527 return fIsXtransImage; 528 } 529 530private: 531 // Quick check if the image contains a valid TIFF header as requested by DNG format. 532 bool isTiffHeaderValid() const { 533 const size_t kHeaderSize = 4; 534 SkAutoSTMalloc<kHeaderSize, unsigned char> header(kHeaderSize); 535 if (!fStream->read(header.get(), 0 /* offset */, kHeaderSize)) { 536 return false; 537 } 538 539 // Check if the header is valid (endian info and magic number "42"). 540 return 541 (header[0] == 0x49 && header[1] == 0x49 && header[2] == 0x2A && header[3] == 0x00) || 542 (header[0] == 0x4D && header[1] == 0x4D && header[2] == 0x00 && header[3] == 0x2A); 543 } 544 545 bool init(const int width, const int height, const dng_point& cfaPatternSize) { 546 fImageInfo = SkImageInfo::Make(width, height, kN32_SkColorType, kOpaque_SkAlphaType); 547 548 // The DNG SDK scales only during demosaicing, so scaling is only possible when 549 // a mosaic info is available. 550 fIsScalable = cfaPatternSize.v != 0 && cfaPatternSize.h != 0; 551 fIsXtransImage = fIsScalable ? (cfaPatternSize.v == 6 && cfaPatternSize.h == 6) : false; 552 553 return width > 0 && height > 0; 554 } 555 556 bool initFromPiex() { 557 // Does not take the ownership of rawStream. 558 SkPiexStream piexStream(fStream.get()); 559 ::piex::PreviewImageData imageData; 560 if (::piex::IsRaw(&piexStream) 561 && ::piex::GetPreviewImageData(&piexStream, &imageData) == ::piex::Error::kOk) 562 { 563 dng_point cfaPatternSize(imageData.cfa_pattern_dim[1], imageData.cfa_pattern_dim[0]); 564 return this->init(static_cast<int>(imageData.full_width), 565 static_cast<int>(imageData.full_height), cfaPatternSize); 566 } 567 return false; 568 } 569 570 bool readDng() { 571 try { 572 // Due to the limit of DNG SDK, we need to reset host and info. 573 fHost.reset(new SkDngHost(&fAllocator)); 574 fInfo.reset(new dng_info); 575 fDngStream.reset(new SkDngStream(fStream)); 576 577 fHost->ValidateSizes(); 578 fInfo->Parse(*fHost, *fDngStream); 579 fInfo->PostParse(*fHost); 580 if (!fInfo->IsValidDNG()) { 581 return false; 582 } 583 584 fNegative.reset(fHost->Make_dng_negative()); 585 fNegative->Parse(*fHost, *fDngStream, *fInfo); 586 fNegative->PostParse(*fHost, *fDngStream, *fInfo); 587 fNegative->SynchronizeMetadata(); 588 589 dng_point cfaPatternSize(0, 0); 590 if (fNegative->GetMosaicInfo() != nullptr) { 591 cfaPatternSize = fNegative->GetMosaicInfo()->fCFAPatternSize; 592 } 593 return this->init(static_cast<int>(fNegative->DefaultCropSizeH().As_real64()), 594 static_cast<int>(fNegative->DefaultCropSizeV().As_real64()), 595 cfaPatternSize); 596 } catch (...) { 597 return false; 598 } 599 } 600 601 SkDngImage(SkRawStream* stream) 602 : fStream(stream) {} 603 604 SkDngMemoryAllocator fAllocator; 605 SkAutoTDelete<SkRawStream> fStream; 606 SkAutoTDelete<dng_host> fHost; 607 SkAutoTDelete<dng_info> fInfo; 608 SkAutoTDelete<dng_negative> fNegative; 609 SkAutoTDelete<dng_stream> fDngStream; 610 611 SkImageInfo fImageInfo; 612 bool fIsScalable; 613 bool fIsXtransImage; 614}; 615 616/* 617 * Tries to handle the image with PIEX. If PIEX returns kOk and finds the preview image, create a 618 * SkJpegCodec. If PIEX returns kFail, then the file is invalid, return nullptr. In other cases, 619 * fallback to create SkRawCodec for DNG images. 620 */ 621SkCodec* SkRawCodec::NewFromStream(SkStream* stream) { 622 SkAutoTDelete<SkRawStream> rawStream; 623 if (is_asset_stream(*stream)) { 624 rawStream.reset(new SkRawAssetStream(stream)); 625 } else { 626 rawStream.reset(new SkRawBufferedStream(stream)); 627 } 628 629 // Does not take the ownership of rawStream. 630 SkPiexStream piexStream(rawStream.get()); 631 ::piex::PreviewImageData imageData; 632 if (::piex::IsRaw(&piexStream)) { 633 ::piex::Error error = ::piex::GetPreviewImageData(&piexStream, &imageData); 634 635 // Theoretically PIEX can return JPEG compressed image or uncompressed RGB image. We only 636 // handle the JPEG compressed preview image here. 637 if (error == ::piex::Error::kOk && imageData.preview.length > 0 && 638 imageData.preview.format == ::piex::Image::kJpegCompressed) 639 { 640 // transferBuffer() is destructive to the rawStream. Abandon the rawStream after this 641 // function call. 642 // FIXME: one may avoid the copy of memoryStream and use the buffered rawStream. 643 SkMemoryStream* memoryStream = 644 rawStream->transferBuffer(imageData.preview.offset, imageData.preview.length); 645 return memoryStream ? SkJpegCodec::NewFromStream(memoryStream) : nullptr; 646 } else if (error == ::piex::Error::kFail) { 647 return nullptr; 648 } 649 } 650 651 // Takes the ownership of the rawStream. 652 SkAutoTDelete<SkDngImage> dngImage(SkDngImage::NewFromStream(rawStream.release())); 653 if (!dngImage) { 654 return nullptr; 655 } 656 657 return new SkRawCodec(dngImage.release()); 658} 659 660SkCodec::Result SkRawCodec::onGetPixels(const SkImageInfo& requestedInfo, void* dst, 661 size_t dstRowBytes, const Options& options, 662 SkPMColor ctable[], int* ctableCount, 663 int* rowsDecoded) { 664 if (!conversion_possible(requestedInfo, this->getInfo())) { 665 SkCodecPrintf("Error: cannot convert input type to output type.\n"); 666 return kInvalidConversion; 667 } 668 669 SkAutoTDelete<SkSwizzler> swizzler(SkSwizzler::CreateSwizzler( 670 SkSwizzler::kRGB, nullptr, requestedInfo, options)); 671 SkASSERT(swizzler); 672 673 const int width = requestedInfo.width(); 674 const int height = requestedInfo.height(); 675 SkAutoTDelete<dng_image> image(fDngImage->render(width, height)); 676 if (!image) { 677 return kInvalidInput; 678 } 679 680 // Because the DNG SDK can not guarantee to render to requested size, we allow a small 681 // difference. Only the overlapping region will be converted. 682 const float maxDiffRatio = 1.03f; 683 const dng_point& imageSize = image->Size(); 684 if (imageSize.h / width > maxDiffRatio || imageSize.h < width || 685 imageSize.v / height > maxDiffRatio || imageSize.v < height) { 686 return SkCodec::kInvalidScale; 687 } 688 689 void* dstRow = dst; 690 SkAutoTMalloc<uint8_t> srcRow(width * 3); 691 692 dng_pixel_buffer buffer; 693 buffer.fData = &srcRow[0]; 694 buffer.fPlane = 0; 695 buffer.fPlanes = 3; 696 buffer.fColStep = buffer.fPlanes; 697 buffer.fPlaneStep = 1; 698 buffer.fPixelType = ttByte; 699 buffer.fPixelSize = sizeof(uint8_t); 700 buffer.fRowStep = width * 3; 701 702 for (int i = 0; i < height; ++i) { 703 buffer.fArea = dng_rect(i, 0, i + 1, width); 704 705 try { 706 image->Get(buffer, dng_image::edge_zero); 707 } catch (...) { 708 *rowsDecoded = i; 709 return kIncompleteInput; 710 } 711 712 swizzler->swizzle(dstRow, &srcRow[0]); 713 dstRow = SkTAddOffset<void>(dstRow, dstRowBytes); 714 } 715 return kSuccess; 716} 717 718SkISize SkRawCodec::onGetScaledDimensions(float desiredScale) const { 719 SkASSERT(desiredScale <= 1.f); 720 721 const SkISize dim = this->getInfo().dimensions(); 722 SkASSERT(dim.fWidth != 0 && dim.fHeight != 0); 723 724 if (!fDngImage->isScalable()) { 725 return dim; 726 } 727 728 // Limits the minimum size to be 80 on the short edge. 729 const float shortEdge = static_cast<float>(SkTMin(dim.fWidth, dim.fHeight)); 730 if (desiredScale < 80.f / shortEdge) { 731 desiredScale = 80.f / shortEdge; 732 } 733 734 // For Xtrans images, the integer-factor scaling does not support the half-size scaling case 735 // (stronger downscalings are fine). In this case, returns the factor "3" scaling instead. 736 if (fDngImage->isXtransImage() && desiredScale > 1.f / 3.f && desiredScale < 1.f) { 737 desiredScale = 1.f / 3.f; 738 } 739 740 // Round to integer-factors. 741 const float finalScale = std::floor(1.f/ desiredScale); 742 return SkISize::Make(static_cast<int32_t>(std::floor(dim.fWidth / finalScale)), 743 static_cast<int32_t>(std::floor(dim.fHeight / finalScale))); 744} 745 746bool SkRawCodec::onDimensionsSupported(const SkISize& dim) { 747 const SkISize fullDim = this->getInfo().dimensions(); 748 const float fullShortEdge = static_cast<float>(SkTMin(fullDim.fWidth, fullDim.fHeight)); 749 const float shortEdge = static_cast<float>(SkTMin(dim.fWidth, dim.fHeight)); 750 751 SkISize sizeFloor = this->onGetScaledDimensions(1.f / std::floor(fullShortEdge / shortEdge)); 752 SkISize sizeCeil = this->onGetScaledDimensions(1.f / std::ceil(fullShortEdge / shortEdge)); 753 return sizeFloor == dim || sizeCeil == dim; 754} 755 756SkRawCodec::~SkRawCodec() {} 757 758SkRawCodec::SkRawCodec(SkDngImage* dngImage) 759 : INHERITED(dngImage->getImageInfo(), nullptr) 760 , fDngImage(dngImage) {} 761