SkRawCodec.cpp 28 KB

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