Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(29)

Side by Side Diff: src/codec/SkRawCodec.cpp

Issue 1635443002: Revert of Prototype of RAW decoding in Skia. (Closed) Base URL: https://skia.googlesource.com/skia.git@master
Patch Set: Created 4 years, 10 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « src/codec/SkRawCodec.h ('k') | tests/CodexTest.cpp » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
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 #if !defined(GOOGLE3)
13 #include "SkJpegCodec.h"
14 #endif
15 #include "SkRawCodec.h"
16 #include "SkRefCnt.h"
17 #include "SkStream.h"
18 #include "SkStreamPriv.h"
19 #include "SkSwizzler.h"
20 #include "SkTemplates.h"
21 #include "SkTypes.h"
22
23 #include "dng_color_space.h"
24 #include "dng_exceptions.h"
25 #include "dng_host.h"
26 #include "dng_info.h"
27 #include "dng_memory.h"
28 #include "dng_render.h"
29 #include "dng_stream.h"
30
31 #include "src/piex.h"
32
33 #include <cmath> // for std::round,floor,ceil
34 #include <limits>
35
36 namespace {
37
38 // T must be unsigned type.
39 template <class T>
40 bool safe_add_to_size_t(T arg1, T arg2, size_t* result) {
41 SkASSERT(arg1 >= 0);
42 SkASSERT(arg2 >= 0);
43 if (arg1 >= 0 && arg2 <= std::numeric_limits<T>::max() - arg1) {
44 T sum = arg1 + arg2;
45 if (sum <= std::numeric_limits<size_t>::max()) {
46 *result = static_cast<size_t>(sum);
47 return true;
48 }
49 }
50 return false;
51 }
52
53 class SkDngMemoryAllocator : public dng_memory_allocator {
54 public:
55 ~SkDngMemoryAllocator() override {}
56
57 dng_memory_block* Allocate(uint32 size) override {
58 // To avoid arbitary allocation requests which might lead to out-of-memo ry, limit the
59 // amount of memory that can be allocated at once. The memory limit is b ased on experiments
60 // and supposed to be sufficient for all valid DNG images.
61 if (size > 300 * 1024 * 1024) { // 300 MB
62 ThrowMemoryFull();
63 }
64 return dng_memory_allocator::Allocate(size);
65 }
66 };
67
68 } // namespace
69
70 // Note: this class could throw exception if it is used as dng_stream.
71 class SkRawStream : public ::piex::StreamInterface {
72 public:
73 // Note that this call will take the ownership of stream.
74 explicit SkRawStream(SkStream* stream)
75 : fStream(stream), fWholeStreamRead(false) {}
76
77 ~SkRawStream() override {}
78
79 /*
80 * Creates an SkMemoryStream from the offset with size.
81 * Note: for performance reason, this function is destructive to the SkRawSt ream. One should
82 * abandon current object after the function call.
83 */
84 SkMemoryStream* transferBuffer(size_t offset, size_t size) {
85 SkAutoTUnref<SkData> data(SkData::NewUninitialized(size));
86 if (offset > fStreamBuffer.bytesWritten()) {
87 // If the offset is not buffered, read from fStream directly and ski p the buffering.
88 const size_t skipLength = offset - fStreamBuffer.bytesWritten();
89 if (fStream->skip(skipLength) != skipLength) {
90 return nullptr;
91 }
92 const size_t bytesRead = fStream->read(data->writable_data(), size);
93 if (bytesRead < size) {
94 data.reset(SkData::NewSubset(data.get(), 0, bytesRead));
95 }
96 } else {
97 const size_t alreadyBuffered = SkTMin(fStreamBuffer.bytesWritten() - offset, size);
98 if (alreadyBuffered > 0 &&
99 !fStreamBuffer.read(data->writable_data(), offset, alreadyBuffer ed)) {
100 return nullptr;
101 }
102
103 const size_t remaining = size - alreadyBuffered;
104 if (remaining) {
105 auto* dst = static_cast<uint8_t*>(data->writable_data()) + alrea dyBuffered;
106 const size_t bytesRead = fStream->read(dst, remaining);
107 size_t newSize;
108 if (bytesRead < remaining) {
109 if (!safe_add_to_size_t(alreadyBuffered, bytesRead, &newSize )) {
110 return nullptr;
111 }
112 data.reset(SkData::NewSubset(data.get(), 0, newSize));
113 }
114 }
115 }
116 return new SkMemoryStream(data);
117 }
118
119 // For PIEX
120 ::piex::Error GetData(const size_t offset, const size_t length,
121 uint8* data) override {
122 if (offset == 0 && length == 0) {
123 return ::piex::Error::kOk;
124 }
125 size_t sum;
126 if (!safe_add_to_size_t(offset, length, &sum) || !this->bufferMoreData(s um)) {
127 return ::piex::Error::kFail;
128 }
129 if (!fStreamBuffer.read(data, offset, length)) {
130 return ::piex::Error::kFail;
131 }
132 return ::piex::Error::kOk;
133 }
134
135 // For dng_stream
136 uint64 getLength() {
137 if (!this->bufferMoreData(kReadToEnd)) { // read whole stream
138 ThrowReadFile();
139 }
140 return fStreamBuffer.bytesWritten();
141 }
142
143 // For dng_stream
144 void read(void* data, uint32 count, uint64 offset) {
145 if (count == 0 && offset == 0) {
146 return;
147 }
148 size_t sum;
149 if (!safe_add_to_size_t(static_cast<uint64>(count), offset, &sum) ||
150 !this->bufferMoreData(sum)) {
151 ThrowReadFile();
152 }
153
154 if (!fStreamBuffer.read(data, offset, count)) {
155 ThrowReadFile();
156 }
157 }
158
159 private:
160 // Note: if the newSize == kReadToEnd (0), this function will read to the en d of stream.
161 bool bufferMoreData(size_t newSize) {
162 if (newSize == kReadToEnd) {
163 if (fWholeStreamRead) { // already read-to-end.
164 return true;
165 }
166
167 // TODO: optimize for the special case when the input is SkMemoryStr eam.
168 return SkStreamCopy(&fStreamBuffer, fStream.get());
169 }
170
171 if (newSize <= fStreamBuffer.bytesWritten()) { // already buffered to n ewSize
172 return true;
173 }
174 if (fWholeStreamRead) { // newSize is larger than the whole stream.
175 return false;
176 }
177
178 const size_t sizeToRead = newSize - fStreamBuffer.bytesWritten();
179 SkAutoTMalloc<uint8> tempBuffer(sizeToRead);
180 const size_t bytesRead = fStream->read(tempBuffer.get(), sizeToRead);
181 if (bytesRead != sizeToRead) {
182 return false;
183 }
184 return fStreamBuffer.write(tempBuffer.get(), bytesRead);
185 }
186
187 SkAutoTDelete<SkStream> fStream;
188 bool fWholeStreamRead;
189
190 SkDynamicMemoryWStream fStreamBuffer;
191
192 const size_t kReadToEnd = 0;
193 };
194
195 class SkDngStream : public dng_stream {
196 public:
197 SkDngStream(SkRawStream* rawStream) : fRawStream(rawStream) {}
198
199 uint64 DoGetLength() override { return fRawStream->getLength(); }
200
201 void DoRead(void* data, uint32 count, uint64 offset) override {
202 fRawStream->read(data, count, offset);
203 }
204
205 private:
206 SkRawStream* fRawStream;
207 };
208
209 class SkDngImage {
210 public:
211 static SkDngImage* NewFromStream(SkRawStream* stream) {
212 SkAutoTDelete<SkDngImage> dngImage(new SkDngImage(stream));
213 if (!dngImage->readDng()) {
214 return nullptr;
215 }
216
217 SkASSERT(dngImage->fNegative);
218 return dngImage.release();
219 }
220
221 /*
222 * Renders the DNG image to the size. The DNG SDK only allows scaling close to integer factors
223 * down to 80 pixels on the short edge. The rendered image will be close to the specified size,
224 * but there is no guarantee that any of the edges will match the requested size. E.g.
225 * 100% size: 4000 x 3000
226 * requested size: 1600 x 1200
227 * returned size could be: 2000 x 1500
228 */
229 dng_image* render(int width, int height) {
230 if (!fHost || !fInfo || !fNegative || !fDngStream) {
231 if (!this->readDng()) {
232 return nullptr;
233 }
234 }
235
236 // render() takes ownership of fHost, fInfo, fNegative and fDngStream wh en available.
237 SkAutoTDelete<dng_host> host(fHost.release());
238 SkAutoTDelete<dng_info> info(fInfo.release());
239 SkAutoTDelete<dng_negative> negative(fNegative.release());
240 SkAutoTDelete<dng_stream> dngStream(fDngStream.release());
241
242 // DNG SDK preserves the aspect ratio, so it only needs to know the long er dimension.
243 const int preferredSize = SkTMax(width, height);
244 try {
245 host->SetPreferredSize(preferredSize);
246 host->ValidateSizes();
247
248 negative->ReadStage1Image(*host, *dngStream, *info);
249
250 if (info->fMaskIndex != -1) {
251 negative->ReadTransparencyMask(*host, *dngStream, *info);
252 }
253
254 negative->ValidateRawImageDigest(*host);
255 if (negative->IsDamaged()) {
256 return nullptr;
257 }
258
259 const int32 kMosaicPlane = -1;
260 negative->BuildStage2Image(*host);
261 negative->BuildStage3Image(*host, kMosaicPlane);
262
263 dng_render render(*host, *negative);
264 render.SetFinalSpace(dng_space_sRGB::Get());
265 render.SetFinalPixelType(ttByte);
266
267 dng_point stage3_size = negative->Stage3Image()->Size();
268 render.SetMaximumSize(SkTMax(stage3_size.h, stage3_size.v));
269
270 return render.Render();
271 } catch (...) {
272 return nullptr;
273 }
274 }
275
276 const SkImageInfo& getImageInfo() const {
277 return fImageInfo;
278 }
279
280 bool isScalable() const {
281 return fIsScalable;
282 }
283
284 bool isXtransImage() const {
285 return fIsXtransImage;
286 }
287
288 private:
289 bool readDng() {
290 // Due to the limit of DNG SDK, we need to reset host and info.
291 fHost.reset(new dng_host(&fAllocator));
292 fInfo.reset(new dng_info);
293 fDngStream.reset(new SkDngStream(fStream));
294 try {
295 fHost->ValidateSizes();
296 fInfo->Parse(*fHost, *fDngStream);
297 fInfo->PostParse(*fHost);
298 if (!fInfo->IsValidDNG()) {
299 return false;
300 }
301
302 fNegative.reset(fHost->Make_dng_negative());
303 fNegative->Parse(*fHost, *fDngStream, *fInfo);
304 fNegative->PostParse(*fHost, *fDngStream, *fInfo);
305 fNegative->SynchronizeMetadata();
306
307 fImageInfo = SkImageInfo::Make(fNegative->DefaultCropSizeH().As_real 64(),
308 fNegative->DefaultCropSizeV().As_real 64(),
309 kN32_SkColorType, kOpaque_SkAlphaType );
310
311 // The DNG SDK scales only for at demosaicing, so only when a mosaic info
312 // is available also scale is available.
313 fIsScalable = fNegative->GetMosaicInfo() != nullptr;
314 fIsXtransImage = fIsScalable
315 ? (fNegative->GetMosaicInfo()->fCFAPatternSize.v == 6
316 && fNegative->GetMosaicInfo()->fCFAPatternSize.h == 6)
317 : false;
318 return true;
319 } catch (...) {
320 fNegative.reset(nullptr);
321 return false;
322 }
323 }
324
325 SkDngImage(SkRawStream* stream)
326 : fStream(stream) {}
327
328 SkDngMemoryAllocator fAllocator;
329 SkAutoTDelete<SkRawStream> fStream;
330 SkAutoTDelete<dng_host> fHost;
331 SkAutoTDelete<dng_info> fInfo;
332 SkAutoTDelete<dng_negative> fNegative;
333 SkAutoTDelete<dng_stream> fDngStream;
334
335 SkImageInfo fImageInfo;
336 bool fIsScalable;
337 bool fIsXtransImage;
338 };
339
340 /*
341 * Tries to handle the image with PIEX. If PIEX returns kOk and finds the previe w image, create a
342 * SkJpegCodec. If PIEX returns kFail, then the file is invalid, return nullptr. In other cases,
343 * fallback to create SkRawCodec for DNG images.
344 */
345 SkCodec* SkRawCodec::NewFromStream(SkStream* stream) {
346 SkAutoTDelete<SkRawStream> rawStream(new SkRawStream(stream));
347 ::piex::PreviewImageData imageData;
348 // FIXME: ::piex::GetPreviewImageData() calls GetData() frequently with smal l amounts,
349 // resulting in many calls to bufferMoreData(). Could we make this more effi cient by grouping
350 // smaller requests together?
351 if (::piex::IsRaw(rawStream.get())) {
352 ::piex::Error error = ::piex::GetPreviewImageData(rawStream.get(), &imag eData);
353
354 if (error == ::piex::Error::kOk && imageData.preview_length > 0) {
355 #if !defined(GOOGLE3)
356 // transferBuffer() is destructive to the rawStream. Abandon the raw Stream after this
357 // function call.
358 // FIXME: one may avoid the copy of memoryStream and use the buffere d rawStream.
359 SkMemoryStream* memoryStream =
360 rawStream->transferBuffer(imageData.preview_offset, imageDat a.preview_length);
361 return memoryStream ? SkJpegCodec::NewFromStream(memoryStream) : nul lptr;
362 #else
363 return nullptr;
364 #endif
365 } else if (error == ::piex::Error::kFail) {
366 return nullptr;
367 }
368 }
369
370 SkAutoTDelete<SkDngImage> dngImage(SkDngImage::NewFromStream(rawStream.relea se()));
371 if (!dngImage) {
372 return nullptr;
373 }
374
375 return new SkRawCodec(dngImage.release());
376 }
377
378 SkCodec::Result SkRawCodec::onGetPixels(const SkImageInfo& requestedInfo, void* dst,
379 size_t dstRowBytes, const Options& optio ns,
380 SkPMColor ctable[], int* ctableCount,
381 int* rowsDecoded) {
382 if (!conversion_possible(requestedInfo, this->getInfo())) {
383 SkCodecPrintf("Error: cannot convert input type to output type.\n");
384 return kInvalidConversion;
385 }
386
387 SkAutoTDelete<SkSwizzler> swizzler(SkSwizzler::CreateSwizzler(
388 SkSwizzler::kRGB, nullptr, requestedInfo, options));
389 SkASSERT(swizzler);
390
391 const int width = requestedInfo.width();
392 const int height = requestedInfo.height();
393 SkAutoTDelete<dng_image> image(fDngImage->render(width, height));
394 if (!image) {
395 return kInvalidInput;
396 }
397
398 // Because the DNG SDK can not guarantee to render to requested size, we all ow a small
399 // difference. Only the overlapping region will be converted.
400 const float maxDiffRatio = 1.03f;
401 const dng_point& imageSize = image->Size();
402 if (imageSize.h / width > maxDiffRatio || imageSize.h < width ||
403 imageSize.v / height > maxDiffRatio || imageSize.v < height) {
404 return SkCodec::kInvalidScale;
405 }
406
407 void* dstRow = dst;
408 uint8_t srcRow[width * 3];
409
410 dng_pixel_buffer buffer;
411 buffer.fData = &srcRow[0];
412 buffer.fPlane = 0;
413 buffer.fPlanes = 3;
414 buffer.fColStep = buffer.fPlanes;
415 buffer.fPlaneStep = 1;
416 buffer.fPixelType = ttByte;
417 buffer.fPixelSize = sizeof(uint8_t);
418 buffer.fRowStep = sizeof(srcRow);
419
420 for (int i = 0; i < height; ++i) {
421 buffer.fArea = dng_rect(i, 0, i + 1, width);
422
423 try {
424 image->Get(buffer, dng_image::edge_zero);
425 } catch (...) {
426 *rowsDecoded = i;
427 return kIncompleteInput;
428 }
429
430 swizzler->swizzle(dstRow, &srcRow[0]);
431 dstRow = SkTAddOffset<void>(dstRow, dstRowBytes);
432 }
433 return kSuccess;
434 }
435
436 SkISize SkRawCodec::onGetScaledDimensions(float desiredScale) const {
437 SkASSERT(desiredScale <= 1.f);
438 const SkISize dim = this->getInfo().dimensions();
439 if (!fDngImage->isScalable()) {
440 return dim;
441 }
442
443 // Limits the minimum size to be 80 on the short edge.
444 const float shortEdge = SkTMin(dim.fWidth, dim.fHeight);
445 if (desiredScale < 80.f / shortEdge) {
446 desiredScale = 80.f / shortEdge;
447 }
448
449 // For Xtrans images, the integer-factor scaling does not support the half-s ize scaling case
450 // (stronger downscalings are fine). In this case, returns the factor "3" sc aling instead.
451 if (fDngImage->isXtransImage() && desiredScale > 1.f / 3.f && desiredScale < 1.f) {
452 desiredScale = 1.f / 3.f;
453 }
454
455 // Round to integer-factors.
456 const float finalScale = std::floor(1.f/ desiredScale);
457 return SkISize::Make(std::floor(dim.fWidth / finalScale),
458 std::floor(dim.fHeight / finalScale));
459 }
460
461 bool SkRawCodec::onDimensionsSupported(const SkISize& dim) {
462 const SkISize fullDim = this->getInfo().dimensions();
463 const float fullShortEdge = SkTMin(fullDim.fWidth, fullDim.fHeight);
464 const float shortEdge = SkTMin(dim.fWidth, dim.fHeight);
465
466 SkISize sizeFloor = this->onGetScaledDimensions(1.f / std::floor(fullShortEd ge / shortEdge));
467 SkISize sizeCeil = this->onGetScaledDimensions(1.f / std::ceil(fullShortEdge / shortEdge));
468 return sizeFloor == dim || sizeCeil == dim;
469 }
470
471 SkRawCodec::~SkRawCodec() {}
472
473 SkRawCodec::SkRawCodec(SkDngImage* dngImage)
474 : INHERITED(dngImage->getImageInfo(), nullptr)
475 , fDngImage(dngImage) {}
OLDNEW
« no previous file with comments | « src/codec/SkRawCodec.h ('k') | tests/CodexTest.cpp » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698