Prototype of RAW decoding in Skia.

src/codec/SkRawCodec.cpp

+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "SkCodec.h"
+#include "SkRawCodec.h"
+#include "SkCodecPriv.h"
+#include "SkColorPriv.h"
+#include "SkJpegCodec.h"
+#include "SkStream.h"
+#include "SkStreamPriv.h"
+#include "SkSwizzler.h"
+#include "SkTemplates.h"
+#include "SkTypes.h"
+
+#include "dng_color_space.h"
+#include "dng_exceptions.h"
+#include "dng_host.h"
+#include "dng_info.h"
+#include "dng_render.h"
+#include "dng_stream.h"
+
+#include "src/piex.h"
+
+#include <limits>
+
+namespace {
+
+// T must be unsigned type.
+template <class T>
+bool safe_add_to_size_t(T arg1, T arg2, size_t* result) {
+    SkASSERT(arg1 >= 0);
+    SkASSERT(arg2 >= 0);
+    if (arg1 >= 0 && arg2 <= std::numeric_limits<T>::max() - arg1) {
+        T sum = arg1 + arg2;
+        if (sum <= std::numeric_limits<size_t>::max()) {
+            *result = static_cast<size_t>(sum);
+            return true;
+        }
+    }
+    return false;
+}
+
+dng_negative* read_dng(dng_stream* stream, dng_host* host, dng_info* info) {
+    try {
+        SkAutoTDelete<dng_negative> negative;
+        host->ValidateSizes();
+
+        info->Parse(*host, *stream);
+        info->PostParse(*host);
+
+        if (!info->IsValidDNG()) {
+            return nullptr;
+        }
+
+        negative.reset(host->Make_dng_negative());
+        negative->Parse(*host, *stream, *info);
+        negative->PostParse(*host, *stream, *info);
+        negative->SynchronizeMetadata();
+
+        return negative.release();
+    } catch (...) {
+        return nullptr;
+    }
+}
+
+dng_image* render_dng_for_prefered_size(const int prefered_size, dng_stream* stream, 
+                                        dng_host* host, dng_info* info, dng_negative* negative) {
+    try {
+        host->SetPreferredSize(prefered_size);
+        host->ValidateSizes();
+
+        negative->ReadStage1Image(*host, *stream, *info);
+
+        if (info->fMaskIndex != -1) {
+            negative->ReadTransparencyMask(*host, *stream, *info);
+        }
+
+        negative->ValidateRawImageDigest(*host);
+        if (negative->IsDamaged()) {
+            return nullptr;
+        }
+
+        const int32 kMosaicPlane = -1;
+        negative->BuildStage2Image(*host);
+        negative->BuildStage3Image(*host, kMosaicPlane);
+
+        dng_render render(*host, *negative);
+        render.SetFinalSpace(dng_space_sRGB::Get());
+        render.SetFinalPixelType(ttByte);
+
+        dng_point stage3_size = negative->Stage3Image()->Size();
+        render.SetMaximumSize(SkTMax(stage3_size.h, stage3_size.v));
+
+        return render.Render();
+    } catch (...) {
+        return nullptr;
+    }
+}
+
+}  // namespace
+
+// Note: this class could throw exception if it is used as dng_stream.
+class SkRawStream : public dng_stream, public ::piex::StreamInterface {
+public:
+    // Note that this call will take the ownership of stream.
+    explicit SkRawStream(SkStream* stream)
+        : fStream(stream), fWholeStreamRead(false), fStreamBufferSize(0) {}
+
+    ~SkRawStream() override {}
+
+    // Creates a SkMemoryStream from the offset with size.
+    SkMemoryStream* copyBuffer(size_t offset, size_t size) {
+        size_t sum;
+        if (!safe_add_to_size_t(offset, size, &sum) || !this->bufferMoreData(sum)) {
+            return nullptr;
+        }
+        return new SkMemoryStream(fStreamBuffer.get() + offset, size, true);
+    }
+
+    // For PIEX
+    ::piex::Error GetData(const size_t offset, const size_t length,
+                          uint8* data) override {
+        if (offset == 0 && length == 0) {
+            return ::piex::Error::kOk;
+        }
+        size_t sum;
+        if (!safe_add_to_size_t(offset, length, &sum) || !this->bufferMoreData(sum)) {
+          return ::piex::Error::kFail;

[scroggo, 2016/01/11 17:44:02]

nit: four space indent.

[yujieqin, 2016/01/12 10:47:40]

Done.

+        }
+        memcpy(data, fStreamBuffer.get() + offset, length);
+        return ::piex::Error::kOk;
+    }
+
+protected:
+    // For dng_stream
+    uint64 DoGetLength() override {
+        if (!this->bufferMoreData(kReadToEnd)) {  // read whole stream
+            ThrowReadFile();
+        }
+        return fStreamBufferSize;
+    }
+
+    // For dng_stream
+    void DoRead(void* data, uint32 count, uint64 offset) override {
+        if (count == 0 && offset == 0) {
+            return;
+        }
+        size_t sum;
+        if (!safe_add_to_size_t(static_cast<uint64>(count), offset, &sum) ||
+            !this->bufferMoreData(sum)) {
+            ThrowReadFile();
+        }
+        memcpy(data, fStreamBuffer.get() + offset, count);
+    }
+
+private:
+    // Note: if the newSize == kReadToEnd (0), this function will read to the end of stream..
+    bool bufferMoreData(size_t newSize) {
+        if (newSize == kReadToEnd) {
+            if (fWholeStreamRead) {  // the stream is already read-to-end.
+                return true;
+            }
+
+            SkDynamicMemoryWStream tempStream;
+            // TODO: optimize for the special case when the input is SkMemoryStream.
+            if (!SkStreamCopyToDynamicMemoryW(&tempStream, fStream.get())) {
+                return false;
+            }
+
+            size_t wholeStreamSize;
+            if (!safe_add_to_size_t(fStreamBufferSize, tempStream.bytesWritten(), 
+                                    &wholeStreamSize)) {
+                return false;
+            }
+
+            fStreamBuffer.realloc(wholeStreamSize);
+            uint8_t* appendDst = fStreamBuffer.get() + fStreamBufferSize;
+            tempStream.copyTo(appendDst);
+            fStreamBufferSize = wholeStreamSize;
+            return true;
+        }
+
+        if (newSize <= fStreamBufferSize) {  // the stream is already buffered to newSize.
+            return true;
+        }
+        if (fWholeStreamRead) {  // newSize is larger than the whole stream.
+            return false;
+        }
+
+        fStreamBuffer.realloc(newSize);
+        uint8_t* appendDst = fStreamBuffer.get() + fStreamBufferSize;
+        const size_t sizeToRead = newSize - fStreamBufferSize;
+        const size_t bytesRead = fStream->read(appendDst, sizeToRead);
+        if (bytesRead < sizeToRead) {
+            return false;
+        }
+        fStreamBufferSize = newSize;
+        return true;
+    }
+
+    SkAutoTDelete<SkStream> fStream;
+    bool fWholeStreamRead;
+
+    SkAutoTMalloc<uint8> fStreamBuffer;
+    size_t fStreamBufferSize;
+
+    const size_t kReadToEnd = 0;
+};
+
+SkCodec* SkRawCodec::NewFromStream(SkStream* stream) {
+    SkAutoTDelete<SkRawStream> rawStream(new SkRawStream(stream));
+    ::piex::PreviewImageData imageData;
+    if (::piex::IsRaw(rawStream.get()) &&
+        ::piex::GetPreviewImageData(rawStream.get(), &imageData) == ::piex::Error::kOk)
+    {
+        SkMemoryStream* memoryStream =
+                rawStream->copyBuffer(imageData.jpeg_offset, imageData.jpeg_length);
+        return memoryStream ? SkJpegCodec::NewFromStream(memoryStream) : nullptr;
+    }
+
+    SkAutoTDelete<dng_host> host(new dng_host);
+    SkAutoTDelete<dng_info> info(new dng_info);
+    SkAutoTDelete<dng_negative> negative(read_dng(rawStream.get(), host.get(), info.get()));
+    if (!negative) {
+        return nullptr;
+    }
+
+    const SkImageInfo& imageInfo = SkImageInfo::Make(
+        negative->DefaultCropSizeH().As_real64(),
+        negative->DefaultCropSizeV().As_real64(),
+        kN32_SkColorType, kOpaque_SkAlphaType);
+    return new SkRawCodec(imageInfo, rawStream.release(), host.release(),
+                          info.release(), negative.release());
+}
+
+SkCodec::Result SkRawCodec::onGetPixels(const SkImageInfo& requestedInfo, void* dst,
+                                        size_t dstRowBytes, const Options& options,
+                                        SkPMColor ctable[], int* ctableCount,
+                                        int* rowsDecoded) {
+    const int width = requestedInfo.width();
+    const int height = requestedInfo.height();
+    if (!fDngImage) {
+        const int preferedSize = SkTMax(width, height);

[msarett, 2016/01/11 19:12:44]

I believe this should be:

preferredSize = originalWidth > originalHeight ? width : height

Otherwise, we might get tripped up if a bad client requests a width that is
larger than the height, when in reality the originalWidth is smaller than the
height.

[yujieqin, 2016/01/12 10:47:40]

onGetPixel() should only support the requests, which take the size from
onGetScaledDimensions(). If the callers asked a portrait oriented size for a
landscape oriented image, we will return "kInvalidScale" error anyway. So we can
keep the SkTMax() as it is.

Or do you prefer the onGetPixel() to be more relax to error request, so that it
will always try to write something into the output (e.g. only write the center
part into result)?

[msarett, 2016/01/12 14:01:29]

My mistake you're right - if we ever pass the wrong dimension to
render_dng_for_preferred_size() (because the client requests a strange
orientation), we will still catch the error and return kInvalidScale below.

+        fDngImage.reset(render_dng_for_prefered_size(preferedSize, fRawStream, fDngHost.get(),
+                                                     fDngInfo.get(), fDngNegative.get()));
+        if (!fDngImage) {
+            return kInvalidInput;
+        }
+    }
+
+    const dng_point& imageSize = fDngImage->Size();
+    if (imageSize.h != width || imageSize.v != height) {
+      return kInvalidScale;

[scroggo, 2016/01/11 17:44:02]

nit: four space indents

[yujieqin, 2016/01/12 10:47:40]

Done.

+    }
+
+    void* dstRow = dst;
+    uint8 srcRow[width * 3];
+    SkAutoTDelete<SkSwizzler> swizzler(SkSwizzler::CreateSwizzler(
+            SkSwizzler::kRGB, nullptr, requestedInfo, options));
+    SkASSERT(swizzler);
+    for (int i = 0; i < height; ++i) {
+        dng_pixel_buffer buffer;
+        buffer.fData = &srcRow[0];
+        buffer.fArea = dng_rect(i, 0, i + 1, width);
+        buffer.fPlane = 0;
+        buffer.fPlanes = 3;
+        buffer.fColStep = buffer.fPlanes;
+        buffer.fPlaneStep = 1;
+        buffer.fPixelType = ttByte;
+        buffer.fPixelSize = sizeof(uint8);
+        buffer.fRowStep = sizeof(srcRow);
+
+        try {
+            fDngImage->Get(buffer, dng_image::edge_zero);
+        } catch (...) {
+            return kInvalidInput;
+        }
+
+        swizzler->swizzle(dstRow, &srcRow[0]);
+        dstRow = SkTAddOffset<void>(dstRow, dstRowBytes);
+    }
+    return kSuccess;
+}
+
+SkISize SkRawCodec::onGetScaledDimensions(float desiredScale) const {
+    SkISize dim = this->getInfo().dimensions();
+    // SkCodec treats zero dimensional images as errors, so the minimum size
+    // that we will recommend is 1x1.
+    dim.fWidth = SkTMax(1, SkScalarRoundToInt(desiredScale * dim.fWidth));
+    dim.fHeight = SkTMax(1, SkScalarRoundToInt(desiredScale * dim.fHeight));
+
+    const int preferedSize = SkTMax(dim.fWidth, dim.fHeight);
+    fDngImage.reset(render_dng_for_prefered_size(preferedSize, fRawStream, fDngHost.get(),
+                                                 fDngInfo.get(), fDngNegative.get()));
+    if (!fDngImage) {
+        return SkISize::Make(0, 0);
+    }
+
+    dng_point imageSize = fDngImage->Size();
+    dim.fWidth = imageSize.h;
+    dim.fHeight = imageSize.v;
+
+    return dim;
+}
+
+bool SkRawCodec::onDimensionsSupported(const SkISize& dim) {
+    const SkImageInfo& info = this->getInfo();
+    return dim.width() >= 1 && dim.width() <= info.width()
+            && dim.height() >= 1 && dim.height() <= info.height();
+}
+
+SkRawCodec::~SkRawCodec() {
+    delete fRawStream;
+}
+
+SkRawCodec::SkRawCodec(const SkImageInfo& srcInfo, SkRawStream* stream, dng_host* host,
+                       dng_info* info, dng_negative* negative)
+    : INHERITED(srcInfo, nullptr)
+    , fRawStream(stream)
+    , fDngHost(host)
+    , fDngInfo(info)
+    , fDngNegative(negative) {}