Use demux API in SkWebpCodec

src/codec/SkWebpCodec.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 "SkCodecPriv.h"
 #include "SkWebpCodec.h"
+#include "SkStreamPriv.h"
 #include "SkTemplates.h"
 
 // A WebP decoder on top of (subset of) libwebp
 // For more information on WebP image format, and libwebp library, see:
 //   https://code.google.com/speed/webp/
 //   http://www.webmproject.org/code/#libwebp-webp-image-library
 //   https://chromium.googlesource.com/webm/libwebp
 
 // If moving libwebp out of skia source tree, path for webp headers must be
 // updated accordingly. Here, we enforce using local copy in webp sub-directory.
 #include "webp/decode.h"
 #include "webp/demux.h"
 #include "webp/encode.h"
 
 bool SkWebpCodec::IsWebp(const void* buf, size_t bytesRead) {
     // WEBP starts with the following:
     // RIFFXXXXWEBPVP
     // Where XXXX is unspecified.
     const char* bytes = static_cast<const char*>(buf);
     return bytesRead >= 14 && !memcmp(bytes, "RIFF", 4) && !memcmp(&bytes[8], "WEBPVP", 6);
 }
 
 // Parse headers of RIFF container, and check for valid Webp (VP8) content.
 // NOTE: This calls peek instead of read, since onGetPixels will need these
 // bytes again.
 // Returns an SkWebpCodec on success;
 SkCodec* SkWebpCodec::NewFromStream(SkStream* stream) {
     SkAutoTDelete<SkStream> streamDeleter(stream);
 
-    unsigned char buffer[WEBP_VP8_HEADER_SIZE];
-    SkASSERT(WEBP_VP8_HEADER_SIZE <= SkCodec::MinBufferedBytesNeeded());
+    // Webp demux needs a contiguous data buffer.
+    sk_sp<SkData> data = nullptr;
+    if (stream->getMemoryBase()) {
+        // It is safe to make without copy because we'll hold onto the stream.
+        data = SkData::MakeWithoutCopy(stream->getMemoryBase(), stream->getLength());
+    } else {
+        data = SkCopyStreamToData(stream);
 
-    const size_t bytesPeeked = stream->peek(buffer, WEBP_VP8_HEADER_SIZE);
-    if (bytesPeeked != WEBP_VP8_HEADER_SIZE) {
-        // Use read + rewind as a backup
-        if (stream->read(buffer, WEBP_VP8_HEADER_SIZE) != WEBP_VP8_HEADER_SIZE
-            || !stream->rewind())
+        // If we are forced to copy the stream to a data, we can go ahead and delete the stream.
+        streamDeleter.reset(nullptr);
+    }
+
+    // It's a little strange that the |demux| will outlive |webpData|, though it needs the
+    // pointer in |webpData| to remain valid.  This works because the pointer remains valid
+    // until the SkData is freed.
+    WebPData webpData = { data->bytes(), data->size() };
+    SkAutoTCallVProc<WebPDemuxer, WebPDemuxDelete> demux(WebPDemuxPartial(&webpData, nullptr));
+    if (nullptr == demux) {
         return nullptr;
     }
 
-    WebPBitstreamFeatures features;
-    VP8StatusCode status = WebPGetFeatures(buffer, WEBP_VP8_HEADER_SIZE, &features);
-    if (VP8_STATUS_OK != status) {
-        return nullptr; // Invalid WebP file.
+    WebPChunkIterator chunkIterator;
+    SkAutoTCallVProc<WebPChunkIterator, WebPDemuxReleaseChunkIterator> autoCI(&chunkIterator);
+    sk_sp<SkColorSpace> colorSpace = nullptr;
+    if (WebPDemuxGetChunk(demux, "ICCP", 1, &chunkIterator)) {
+        colorSpace = SkColorSpace::NewICC(chunkIterator.chunk.bytes, chunkIterator.chunk.size);
     }
 
-    // sanity check for image size that's about to be decoded.
+    if (!colorSpace) {
+        colorSpace = SkColorSpace::NewNamed(SkColorSpace::kSRGB_Named);
+    }
+
+    // Since we do not yet support animation, we get the |width|, |height|, |color|, and |alpha|
+    // from the first frame.  It's the only frame we will decode.
+    //
+    // TODO:
+    // When we support animation, we'll want to report the canvas width and canvas height instead.
+    // We can get these from the |demux| directly.
+    // What |color| and |alpha| will we want to report though?  WebP allows different frames
+    // to be encoded in different ways, making the encoded format difficult to describe.
+    WebPIterator frame;
+    SkAutoTCallVProc<WebPIterator, WebPDemuxReleaseIterator> autoFrame(&frame);
+    if (!WebPDemuxGetFrame(demux, 1, &frame)) {
+        return nullptr;
+    }
+
+    // Sanity check for image size that's about to be decoded.
     {
-        const int64_t size = sk_64_mul(features.width, features.height);
+        const int64_t size = sk_64_mul(frame.width, frame.height);
         if (!sk_64_isS32(size)) {
             return nullptr;
         }
         // now check that if we are 4-bytes per pixel, we also don't overflow
         if (sk_64_asS32(size) > (0x7FFFFFFF >> 2)) {
             return nullptr;
         }
     }
 
+    // TODO:
+    // The only reason we actually need to call WebPGetFeatures() is to get the |features.format|.
+    // This call actually re-reads the frame header.  Should we suggest that libwebp expose
+    // the format on the |frame|?
+    WebPBitstreamFeatures features;
+    VP8StatusCode status = WebPGetFeatures(frame.fragment.bytes, frame.fragment.size, &features);
+    if (VP8_STATUS_OK != status) {
+        return nullptr;
+    }
+
     SkEncodedInfo::Color color;
     SkEncodedInfo::Alpha alpha;
     switch (features.format) {
         case 0:
             // This indicates a "mixed" format.  We would see this for
             // animated webps or for webps encoded in multiple fragments.
             // I believe that this is a rare case.
             // We could also guess kYUV here, but I think it makes more
             // sense to guess kBGRA which is likely closer to the final
             // output.  Otherwise, we might end up converting
@@ skipping 13 matching lines @@
             break;
         case 2:
             // This is the lossless format (BGRA).
             color = SkEncodedInfo::kBGRA_Color;
             alpha = SkEncodedInfo::kUnpremul_Alpha;
             break;
         default:
             return nullptr;
     }
 
-    // FIXME (msarett):
-    // Temporary strategy for getting ICC profiles from webps.  Once the incremental decoding
-    // API lands, we will use the WebPDemuxer to manage the entire decode.
-    sk_sp<SkColorSpace> colorSpace = nullptr;
-    const void* memory = stream->getMemoryBase();
-    if (memory) {
-        WebPData data = { (const uint8_t*) memory, stream->getLength() };
-        WebPDemuxState state;
-        SkAutoTCallVProc<WebPDemuxer, WebPDemuxDelete> demux(WebPDemuxPartial(&data, &state));
-
-        WebPChunkIterator chunkIterator;
-        SkAutoTCallVProc<WebPChunkIterator, WebPDemuxReleaseChunkIterator> autoCI(&chunkIterator);
-        if (demux && WebPDemuxGetChunk(demux, "ICCP", 1, &chunkIterator)) {
-            colorSpace = SkColorSpace::NewICC(chunkIterator.chunk.bytes, chunkIterator.chunk.size);
-        }
-    }
-
-    if (!colorSpace) {
-        colorSpace = SkColorSpace::NewNamed(SkColorSpace::kSRGB_Named);
-    }
-
     SkEncodedInfo info = SkEncodedInfo::Make(color, alpha, 8);
-    return new SkWebpCodec(features.width, features.height, info, colorSpace,
-                           streamDeleter.release());
+    return new SkWebpCodec(features.width, features.height, info, std::move(colorSpace),
+                           streamDeleter.release(), demux.release(), std::move(data));
 }
 
 // This version is slightly different from SkCodecPriv's version of conversion_possible. It
 // supports both byte orders for 8888.
 static bool webp_conversion_possible(const SkImageInfo& dst, const SkImageInfo& src) {
     if (!valid_alpha(dst.alphaType(), src.alphaType())) {
         return false;
     }
 
     switch (dst.colorType()) {
@@ skipping 16 matching lines @@
     dim.fHeight = SkTMax(1, SkScalarRoundToInt(desiredScale * dim.fHeight));
     return dim;
 }
 
 bool SkWebpCodec::onDimensionsSupported(const SkISize& dim) {
     const SkImageInfo& info = this->getInfo();
     return dim.width() >= 1 && dim.width() <= info.width()
             && dim.height() >= 1 && dim.height() <= info.height();
 }
 
-
 static WEBP_CSP_MODE webp_decode_mode(SkColorType ct, bool premultiply) {
     switch (ct) {
         case kBGRA_8888_SkColorType:
             return premultiply ? MODE_bgrA : MODE_BGRA;
         case kRGBA_8888_SkColorType:
             return premultiply ? MODE_rgbA : MODE_RGBA;
         case kRGB_565_SkColorType:
             return MODE_RGB_565;
         default:
             return MODE_LAST;
     }
 }
 
-// The WebP decoding API allows us to incrementally pass chunks of bytes as we receive them to the
-// decoder with WebPIAppend. In order to do so, we need to read chunks from the SkStream. This size
-// is arbitrary.
-static const size_t BUFFER_SIZE = 4096;
-
 bool SkWebpCodec::onGetValidSubset(SkIRect* desiredSubset) const {
     if (!desiredSubset) {
         return false;
     }
 
     SkIRect dimensions  = SkIRect::MakeSize(this->getInfo().dimensions());
     if (!dimensions.contains(*desiredSubset)) {
         return false;
     }
 
@@ skipping 66 matching lines @@
         config.options.scaled_height = dstDimensions.height();
     }
 
     config.output.colorspace = webp_decode_mode(dstInfo.colorType(),
             dstInfo.alphaType() == kPremul_SkAlphaType);
     config.output.u.RGBA.rgba = (uint8_t*) dst;
     config.output.u.RGBA.stride = (int) rowBytes;
     config.output.u.RGBA.size = dstInfo.getSafeSize(rowBytes);
     config.output.is_external_memory = 1;
 
+    WebPIterator frame;
+    SkAutoTCallVProc<WebPIterator, WebPDemuxReleaseIterator> autoFrame(&frame);
+    // If this succeeded in NewFromStream(), it should succeed again here.
+    SkAssertResult(WebPDemuxGetFrame(fDemux, 1, &frame));
+
     SkAutoTCallVProc<WebPIDecoder, WebPIDelete> idec(WebPIDecode(nullptr, 0, &config));
     if (!idec) {
         return kInvalidInput;
     }
 
-    SkAutoTMalloc<uint8_t> storage(BUFFER_SIZE);
-    uint8_t* buffer = storage.get();
-    while (true) {
-        const size_t bytesRead = stream()->read(buffer, BUFFER_SIZE);
-        if (0 == bytesRead) {
-            WebPIDecGetRGB(idec, rowsDecoded, NULL, NULL, NULL);
+    switch (WebPIUpdate(idec, frame.fragment.bytes, frame.fragment.size)) {
+        case VP8_STATUS_OK:
+            return kSuccess;
+        case VP8_STATUS_SUSPENDED:
+            WebPIDecGetRGB(idec, rowsDecoded, nullptr, nullptr, nullptr);
             return kIncompleteInput;
-        }
-
-        switch (WebPIAppend(idec, buffer, bytesRead)) {
-            case VP8_STATUS_OK:
-                return kSuccess;
-            case VP8_STATUS_SUSPENDED:
-                // Break out of the switch statement. Continue the loop.
-                break;
-            default:
-                return kInvalidInput;
-        }
+        default:
+            return kInvalidInput;
     }
 }
 
 SkWebpCodec::SkWebpCodec(int width, int height, const SkEncodedInfo& info,
-                         sk_sp<SkColorSpace> colorSpace, SkStream* stream)
-    : INHERITED(width, height, info, stream, colorSpace)
+                         sk_sp<SkColorSpace> colorSpace, SkStream* stream, WebPDemuxer* demux,
+                         sk_sp<SkData> data)
+    : INHERITED(width, height, info, stream, std::move(colorSpace))
+    , fDemux(demux)
+    , fData(std::move(data))
 {}