diff options
author | yujieqin <yujieqin@google.com> | 2016-01-25 05:29:03 -0800 |
---|---|---|
committer | Commit bot <commit-bot@chromium.org> | 2016-01-25 05:29:03 -0800 |
commit | 6bd8639f8c142eedf543f4e5f3b02d2bf11df308 (patch) | |
tree | 5bd59bdc08a970d257a5851c25851c0f7bac730b /src | |
parent | 4d8b7bafb22bf587145fc0a2b6109fa1d7981370 (diff) |
Add RAW decoding into Skia.
TBR=reed@google.com
BUG=skia:
(Based on the work from ebrauer in https://codereview.chromium.org/1459473007)
(Based on the work from adaubert in https://codereview.chromium.org/1494003003)
GOLD_TRYBOT_URL= https://gold.skia.org/search2?unt=true&query=source_type%3Dgm&master=false&issue=1520403003
Review URL: https://codereview.chromium.org/1520403003
Diffstat (limited to 'src')
-rw-r--r-- | src/codec/SkAndroidCodec.cpp | 7 | ||||
-rw-r--r-- | src/codec/SkCodec.cpp | 8 | ||||
-rw-r--r-- | src/codec/SkRawAdapterCodec.cpp | 30 | ||||
-rw-r--r-- | src/codec/SkRawAdapterCodec.h | 42 | ||||
-rw-r--r-- | src/codec/SkRawCodec.cpp | 475 | ||||
-rw-r--r-- | src/codec/SkRawCodec.h | 60 |
6 files changed, 622 insertions, 0 deletions
diff --git a/src/codec/SkAndroidCodec.cpp b/src/codec/SkAndroidCodec.cpp index d309d58501..6c3113ccfc 100644 --- a/src/codec/SkAndroidCodec.cpp +++ b/src/codec/SkAndroidCodec.cpp @@ -8,6 +8,9 @@ #include "SkAndroidCodec.h" #include "SkCodec.h" #include "SkCodecPriv.h" +#ifdef SK_CODEC_DECODES_RAW +#include "SkRawAdapterCodec.h" +#endif #include "SkSampledCodec.h" #include "SkWebpAdapterCodec.h" @@ -37,6 +40,10 @@ SkAndroidCodec* SkAndroidCodec::NewFromStream(SkStream* stream, SkPngChunkReader case kGIF_SkEncodedFormat: case kICO_SkEncodedFormat: return new SkSampledCodec(codec.detach()); +#ifdef SK_CODEC_DECODES_RAW + case kRAW_SkEncodedFormat: + return new SkRawAdapterCodec((SkRawCodec*)codec.detach()); +#endif default: return nullptr; } diff --git a/src/codec/SkCodec.cpp b/src/codec/SkCodec.cpp index 75e5c34f53..cfeeb51d0d 100644 --- a/src/codec/SkCodec.cpp +++ b/src/codec/SkCodec.cpp @@ -15,6 +15,9 @@ #include "SkJpegCodec.h" #endif #include "SkPngCodec.h" +#ifdef SK_CODEC_DECODES_RAW +#include "SkRawCodec.h" +#endif #include "SkStream.h" #include "SkWbmpCodec.h" #include "SkWebpCodec.h" @@ -86,6 +89,11 @@ SkCodec* SkCodec::NewFromStream(SkStream* stream, return proc.NewFromStream(streamDeleter.detach()); } } + +#ifdef SK_CODEC_DECODES_RAW + // Try to treat the input as RAW if all the other checks failed. + return SkRawCodec::NewFromStream(streamDeleter.detach()); +#endif } return nullptr; diff --git a/src/codec/SkRawAdapterCodec.cpp b/src/codec/SkRawAdapterCodec.cpp new file mode 100644 index 0000000000..76cbaa1a23 --- /dev/null +++ b/src/codec/SkRawAdapterCodec.cpp @@ -0,0 +1,30 @@ +/* + * Copyright 2016 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 "SkCodecPriv.h" +#include "SkRawAdapterCodec.h" + +SkRawAdapterCodec::SkRawAdapterCodec(SkRawCodec* codec) + : INHERITED(codec) +{} + +SkISize SkRawAdapterCodec::onGetSampledDimensions(int sampleSize) const { + float scale = 1.f / static_cast<float>(sampleSize); + return this->codec()->getScaledDimensions(scale); +} + +SkCodec::Result SkRawAdapterCodec::onGetAndroidPixels( + const SkImageInfo& info, void* pixels, size_t rowBytes, + const AndroidOptions& options) { + SkCodec::Options codecOptions; + codecOptions.fZeroInitialized = options.fZeroInitialized; + codecOptions.fSubset = options.fSubset; + return this->codec()->getPixels( + info, pixels, rowBytes, &codecOptions, options.fColorPtr, + options.fColorCount); +} diff --git a/src/codec/SkRawAdapterCodec.h b/src/codec/SkRawAdapterCodec.h new file mode 100644 index 0000000000..b552f2aaea --- /dev/null +++ b/src/codec/SkRawAdapterCodec.h @@ -0,0 +1,42 @@ +/* + * Copyright 2016 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ + +#ifndef SkRawAdapterCodec_DEFINED +#define SkRawAdapterCodec_DEFINED + +#include "SkAndroidCodec.h" +#include "SkCodec.h" +#include "SkEncodedFormat.h" +#include "SkRawCodec.h" +#include "SkStream.h" +#include "SkTypes.h" + +/** + * This class implements the functionality of SkAndroidCodec. It uses an + * SkRawCodec. + */ +class SkRawAdapterCodec : public SkAndroidCodec { +public: + + explicit SkRawAdapterCodec(SkRawCodec*); + + virtual ~SkRawAdapterCodec() {} + +protected: + + SkISize onGetSampledDimensions(int sampleSize) const override; + + bool onGetSupportedSubset(SkIRect* /*desiredSubset*/) const override { return false; } + + SkCodec::Result onGetAndroidPixels(const SkImageInfo& info, void* pixels, size_t rowBytes, + const AndroidOptions& options) override; + +private: + + typedef SkAndroidCodec INHERITED; +}; +#endif // SkRawAdapterCodec_DEFINED diff --git a/src/codec/SkRawCodec.cpp b/src/codec/SkRawCodec.cpp new file mode 100644 index 0000000000..05f18ac635 --- /dev/null +++ b/src/codec/SkRawCodec.cpp @@ -0,0 +1,475 @@ +/* + * Copyright 2016 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 "SkCodecPriv.h" +#include "SkColorPriv.h" +#include "SkData.h" +#if !defined(GOOGLE3) +#include "SkJpegCodec.h" +#endif +#include "SkRawCodec.h" +#include "SkRefCnt.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_memory.h" +#include "dng_render.h" +#include "dng_stream.h" + +#include "src/piex.h" + +#include <cmath> // for std::round,floor,ceil +#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; +} + +class SkDngMemoryAllocator : public dng_memory_allocator { +public: + ~SkDngMemoryAllocator() override {} + + dng_memory_block* Allocate(uint32 size) override { + // To avoid arbitary allocation requests which might lead to out-of-memory, limit the + // amount of memory that can be allocated at once. The memory limit is based on experiments + // and supposed to be sufficient for all valid DNG images. + if (size > 300 * 1024 * 1024) { // 300 MB + ThrowMemoryFull(); + } + return dng_memory_allocator::Allocate(size); + } +}; + +} // namespace + +// Note: this class could throw exception if it is used as dng_stream. +class SkRawStream : public ::piex::StreamInterface { +public: + // Note that this call will take the ownership of stream. + explicit SkRawStream(SkStream* stream) + : fStream(stream), fWholeStreamRead(false) {} + + ~SkRawStream() override {} + + /* + * Creates an SkMemoryStream from the offset with size. + * Note: for performance reason, this function is destructive to the SkRawStream. One should + * abandon current object after the function call. + */ + SkMemoryStream* transferBuffer(size_t offset, size_t size) { + SkAutoTUnref<SkData> data(SkData::NewUninitialized(size)); + if (offset > fStreamBuffer.bytesWritten()) { + // If the offset is not buffered, read from fStream directly and skip the buffering. + const size_t skipLength = offset - fStreamBuffer.bytesWritten(); + if (fStream->skip(skipLength) != skipLength) { + return nullptr; + } + const size_t bytesRead = fStream->read(data->writable_data(), size); + if (bytesRead < size) { + data.reset(SkData::NewSubset(data.get(), 0, bytesRead)); + } + } else { + const size_t alreadyBuffered = SkTMin(fStreamBuffer.bytesWritten() - offset, size); + if (alreadyBuffered > 0 && + !fStreamBuffer.read(data->writable_data(), offset, alreadyBuffered)) { + return nullptr; + } + + const size_t remaining = size - alreadyBuffered; + if (remaining) { + auto* dst = static_cast<uint8_t*>(data->writable_data()) + alreadyBuffered; + const size_t bytesRead = fStream->read(dst, remaining); + size_t newSize; + if (bytesRead < remaining) { + if (!safe_add_to_size_t(alreadyBuffered, bytesRead, &newSize)) { + return nullptr; + } + data.reset(SkData::NewSubset(data.get(), 0, newSize)); + } + } + } + return new SkMemoryStream(data); + } + + // 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; + } + if (!fStreamBuffer.read(data, offset, length)) { + return ::piex::Error::kFail; + } + return ::piex::Error::kOk; + } + + // For dng_stream + uint64 getLength() { + if (!this->bufferMoreData(kReadToEnd)) { // read whole stream + ThrowReadFile(); + } + return fStreamBuffer.bytesWritten(); + } + + // For dng_stream + void read(void* data, uint32 count, uint64 offset) { + 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(); + } + + if (!fStreamBuffer.read(data, offset, count)) { + ThrowReadFile(); + } + } + +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) { // already read-to-end. + return true; + } + + // TODO: optimize for the special case when the input is SkMemoryStream. + return SkStreamCopy(&fStreamBuffer, fStream.get()); + } + + if (newSize <= fStreamBuffer.bytesWritten()) { // already buffered to newSize + return true; + } + if (fWholeStreamRead) { // newSize is larger than the whole stream. + return false; + } + + const size_t sizeToRead = newSize - fStreamBuffer.bytesWritten(); + SkAutoTMalloc<uint8> tempBuffer(sizeToRead); + const size_t bytesRead = fStream->read(tempBuffer.get(), sizeToRead); + if (bytesRead != sizeToRead) { + return false; + } + return fStreamBuffer.write(tempBuffer.get(), bytesRead); + } + + SkAutoTDelete<SkStream> fStream; + bool fWholeStreamRead; + + SkDynamicMemoryWStream fStreamBuffer; + + const size_t kReadToEnd = 0; +}; + +class SkDngStream : public dng_stream { +public: + SkDngStream(SkRawStream* rawStream) : fRawStream(rawStream) {} + + uint64 DoGetLength() override { return fRawStream->getLength(); } + + void DoRead(void* data, uint32 count, uint64 offset) override { + fRawStream->read(data, count, offset); + } + +private: + SkRawStream* fRawStream; +}; + +class SkDngImage { +public: + static SkDngImage* NewFromStream(SkRawStream* stream) { + SkAutoTDelete<SkDngImage> dngImage(new SkDngImage(stream)); + if (!dngImage->readDng()) { + return nullptr; + } + + SkASSERT(dngImage->fNegative); + return dngImage.release(); + } + + /* + * Renders the DNG image to the size. The DNG SDK only allows scaling close to integer factors + * down to 80 pixels on the short edge. The rendered image will be close to the specified size, + * but there is no guarantee that any of the edges will match the requested size. E.g. + * 100% size: 4000 x 3000 + * requested size: 1600 x 1200 + * returned size could be: 2000 x 1500 + */ + dng_image* render(int width, int height) { + if (!fHost || !fInfo || !fNegative || !fDngStream) { + if (!this->readDng()) { + return nullptr; + } + } + + // render() takes ownership of fHost, fInfo, fNegative and fDngStream when available. + SkAutoTDelete<dng_host> host(fHost.release()); + SkAutoTDelete<dng_info> info(fInfo.release()); + SkAutoTDelete<dng_negative> negative(fNegative.release()); + SkAutoTDelete<dng_stream> dngStream(fDngStream.release()); + + // DNG SDK preserves the aspect ratio, so it only needs to know the longer dimension. + const int preferredSize = SkTMax(width, height); + try { + host->SetPreferredSize(preferredSize); + host->ValidateSizes(); + + negative->ReadStage1Image(*host, *dngStream, *info); + + if (info->fMaskIndex != -1) { + negative->ReadTransparencyMask(*host, *dngStream, *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; + } + } + + const SkImageInfo& getImageInfo() const { + return fImageInfo; + } + + bool isScalable() const { + return fIsScalable; + } + + bool isXtransImage() const { + return fIsXtransImage; + } + +private: + bool readDng() { + // Due to the limit of DNG SDK, we need to reset host and info. + fHost.reset(new dng_host(&fAllocator)); + fInfo.reset(new dng_info); + fDngStream.reset(new SkDngStream(fStream)); + try { + fHost->ValidateSizes(); + fInfo->Parse(*fHost, *fDngStream); + fInfo->PostParse(*fHost); + if (!fInfo->IsValidDNG()) { + return false; + } + + fNegative.reset(fHost->Make_dng_negative()); + fNegative->Parse(*fHost, *fDngStream, *fInfo); + fNegative->PostParse(*fHost, *fDngStream, *fInfo); + fNegative->SynchronizeMetadata(); + + fImageInfo = SkImageInfo::Make(fNegative->DefaultCropSizeH().As_real64(), + fNegative->DefaultCropSizeV().As_real64(), + kN32_SkColorType, kOpaque_SkAlphaType); + + // The DNG SDK scales only for at demosaicing, so only when a mosaic info + // is available also scale is available. + fIsScalable = fNegative->GetMosaicInfo() != nullptr; + fIsXtransImage = fIsScalable + ? (fNegative->GetMosaicInfo()->fCFAPatternSize.v == 6 + && fNegative->GetMosaicInfo()->fCFAPatternSize.h == 6) + : false; + return true; + } catch (...) { + fNegative.reset(nullptr); + return false; + } + } + + SkDngImage(SkRawStream* stream) + : fStream(stream) {} + + SkDngMemoryAllocator fAllocator; + SkAutoTDelete<SkRawStream> fStream; + SkAutoTDelete<dng_host> fHost; + SkAutoTDelete<dng_info> fInfo; + SkAutoTDelete<dng_negative> fNegative; + SkAutoTDelete<dng_stream> fDngStream; + + SkImageInfo fImageInfo; + bool fIsScalable; + bool fIsXtransImage; +}; + +/* + * Tries to handle the image with PIEX. If PIEX returns kOk and finds the preview image, create a + * SkJpegCodec. If PIEX returns kFail, then the file is invalid, return nullptr. In other cases, + * fallback to create SkRawCodec for DNG images. + */ +SkCodec* SkRawCodec::NewFromStream(SkStream* stream) { + SkAutoTDelete<SkRawStream> rawStream(new SkRawStream(stream)); + ::piex::PreviewImageData imageData; + // FIXME: ::piex::GetPreviewImageData() calls GetData() frequently with small amounts, + // resulting in many calls to bufferMoreData(). Could we make this more efficient by grouping + // smaller requests together? + if (::piex::IsRaw(rawStream.get())) { + ::piex::Error error = ::piex::GetPreviewImageData(rawStream.get(), &imageData); + + if (error == ::piex::Error::kOk && imageData.preview_length > 0) { +#if !defined(GOOGLE3) + // transferBuffer() is destructive to the rawStream. Abandon the rawStream after this + // function call. + // FIXME: one may avoid the copy of memoryStream and use the buffered rawStream. + SkMemoryStream* memoryStream = + rawStream->transferBuffer(imageData.preview_offset, imageData.preview_length); + return memoryStream ? SkJpegCodec::NewFromStream(memoryStream) : nullptr; +#else + return nullptr; +#endif + } else if (error == ::piex::Error::kFail) { + return nullptr; + } + } + + SkAutoTDelete<SkDngImage> dngImage(SkDngImage::NewFromStream(rawStream.release())); + if (!dngImage) { + return nullptr; + } + + return new SkRawCodec(dngImage.release()); +} + +SkCodec::Result SkRawCodec::onGetPixels(const SkImageInfo& requestedInfo, void* dst, + size_t dstRowBytes, const Options& options, + SkPMColor ctable[], int* ctableCount, + int* rowsDecoded) { + if (!conversion_possible(requestedInfo, this->getInfo())) { + SkCodecPrintf("Error: cannot convert input type to output type.\n"); + return kInvalidConversion; + } + + SkAutoTDelete<SkSwizzler> swizzler(SkSwizzler::CreateSwizzler( + SkSwizzler::kRGB, nullptr, requestedInfo, options)); + SkASSERT(swizzler); + + const int width = requestedInfo.width(); + const int height = requestedInfo.height(); + SkAutoTDelete<dng_image> image(fDngImage->render(width, height)); + if (!image) { + return kInvalidInput; + } + + // Because the DNG SDK can not guarantee to render to requested size, we allow a small + // difference. Only the overlapping region will be converted. + const float maxDiffRatio = 1.03f; + const dng_point& imageSize = image->Size(); + if (imageSize.h / width > maxDiffRatio || imageSize.h < width || + imageSize.v / height > maxDiffRatio || imageSize.v < height) { + return SkCodec::kInvalidScale; + } + + void* dstRow = dst; + uint8_t srcRow[width * 3]; + + dng_pixel_buffer buffer; + buffer.fData = &srcRow[0]; + buffer.fPlane = 0; + buffer.fPlanes = 3; + buffer.fColStep = buffer.fPlanes; + buffer.fPlaneStep = 1; + buffer.fPixelType = ttByte; + buffer.fPixelSize = sizeof(uint8_t); + buffer.fRowStep = sizeof(srcRow); + + for (int i = 0; i < height; ++i) { + buffer.fArea = dng_rect(i, 0, i + 1, width); + + try { + image->Get(buffer, dng_image::edge_zero); + } catch (...) { + *rowsDecoded = i; + return kIncompleteInput; + } + + swizzler->swizzle(dstRow, &srcRow[0]); + dstRow = SkTAddOffset<void>(dstRow, dstRowBytes); + } + return kSuccess; +} + +SkISize SkRawCodec::onGetScaledDimensions(float desiredScale) const { + SkASSERT(desiredScale <= 1.f); + const SkISize dim = this->getInfo().dimensions(); + if (!fDngImage->isScalable()) { + return dim; + } + + // Limits the minimum size to be 80 on the short edge. + const float shortEdge = SkTMin(dim.fWidth, dim.fHeight); + if (desiredScale < 80.f / shortEdge) { + desiredScale = 80.f / shortEdge; + } + + // For Xtrans images, the integer-factor scaling does not support the half-size scaling case + // (stronger downscalings are fine). In this case, returns the factor "3" scaling instead. + if (fDngImage->isXtransImage() && desiredScale > 1.f / 3.f && desiredScale < 1.f) { + desiredScale = 1.f / 3.f; + } + + // Round to integer-factors. + const float finalScale = std::floor(1.f/ desiredScale); + return SkISize::Make(std::floor(dim.fWidth / finalScale), + std::floor(dim.fHeight / finalScale)); +} + +bool SkRawCodec::onDimensionsSupported(const SkISize& dim) { + const SkISize fullDim = this->getInfo().dimensions(); + const float fullShortEdge = SkTMin(fullDim.fWidth, fullDim.fHeight); + const float shortEdge = SkTMin(dim.fWidth, dim.fHeight); + + SkISize sizeFloor = this->onGetScaledDimensions(1.f / std::floor(fullShortEdge / shortEdge)); + SkISize sizeCeil = this->onGetScaledDimensions(1.f / std::ceil(fullShortEdge / shortEdge)); + return sizeFloor == dim || sizeCeil == dim; +} + +SkRawCodec::~SkRawCodec() {} + +SkRawCodec::SkRawCodec(SkDngImage* dngImage) + : INHERITED(dngImage->getImageInfo(), nullptr) + , fDngImage(dngImage) {} diff --git a/src/codec/SkRawCodec.h b/src/codec/SkRawCodec.h new file mode 100644 index 0000000000..42755c3ef1 --- /dev/null +++ b/src/codec/SkRawCodec.h @@ -0,0 +1,60 @@ +/* + * Copyright 2016 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ + +#ifndef SkRawCodec_DEFINED +#define SkRawCodec_DEFINED + +#include "SkCodec.h" +#include "SkImageInfo.h" +#include "SkTypes.h" + +class SkDngImage; +class SkStream; + +/* + * + * This class implements the decoding for RAW images + * + */ +class SkRawCodec : public SkCodec { +public: + + /* + * Creates a RAW decoder + * Takes ownership of the stream + */ + static SkCodec* NewFromStream(SkStream*); + + ~SkRawCodec() override; + +protected: + + Result onGetPixels(const SkImageInfo& dstInfo, void* dst, size_t dstRowBytes, const Options&, + SkPMColor*, int*, int*) override; + + SkEncodedFormat onGetEncodedFormat() const override { + return kRAW_SkEncodedFormat; + } + + SkISize onGetScaledDimensions(float desiredScale) const override; + + bool onDimensionsSupported(const SkISize&) override; + +private: + + /* + * Creates an instance of the decoder + * Called only by NewFromStream, takes ownership of dngImage. + */ + SkRawCodec(SkDngImage* dngImage); + + SkAutoTDelete<SkDngImage> fDngImage; + + typedef SkCodec INHERITED; +}; + +#endif |