Allow one-pass SkWuffsCodec decoding

Prior to this commit, SkWuffsCodec always used what this commit calls
two pass decoding. After this commit, it can sometimes use one pass
decoding, which means we don't have to allocate that intermediate pixel
buffer. For the "droids.gif" example mentioned in a recent commit,
39da10b "Optimize SkWuffsCodec pixbuf zero-initialization", this means
that we allocate 19 MB less than we used to (2560 width x 1920 height x
4 bytes per pixel = 19660800 bytes).

Continuing with "droids.gif" and the image_decode_bench program from
39da10b, the time taken per decode drops from 35.627ms to 28.655ms.

Bug: chromium:1023191
Bug: chromium:1023129
Bug: skia:8235
Change-Id: Ic4fd6bd2856493eaf777416326f39198aa8d97c1
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/255956
Commit-Queue: Leon Scroggins <[email protected]>
Reviewed-by: Leon Scroggins <[email protected]>

Author: Nigel Tao

src/codec/SkWuffsCodec.cpp

@@ -177,12 +177,9 @@ class SkWuffsCodec final : public SkScalingCodec {
     SkWuffsCodec(SkEncodedInfo&&                                         encodedInfo,
                  std::unique_ptr<SkStream>                               stream,
                  std::unique_ptr<wuffs_gif__decoder, decltype(&sk_free)> dec,
-                 std::unique_ptr<uint8_t, decltype(&sk_free)>            pixbuf_ptr,
-                 bool                                                    pixbuf_zeroed,
                  std::unique_ptr<uint8_t, decltype(&sk_free)>            workbuf_ptr,
                  size_t                                                  workbuf_len,
                  wuffs_base__image_config                                imgcfg,
-                 wuffs_base__pixel_buffer                                pixbuf,
                  wuffs_base__io_buffer                                   iobuf);
 
     const SkWuffsFrame* frame(int i) const;
@@ -232,44 +229,64 @@ class SkWuffsCodec final : public SkScalingCodec {
     bool                 onGetFrameInfo(int, FrameInfo*) const override;
     int                  onGetRepetitionCount() override;
 
-    Result seekFrame(WhichDecoder which, int frameIndex);
-
-    void   onGetFrameCountInternal();
-    Result onIncrementalDecodeInternal(int* rowsDecoded);
-
+    // Two separate implementations of onStartIncrementalDecode and
+    // onIncrementalDecode, named "one pass" and "two pass" decoding. One pass
+    // decoding writes directly from the Wuffs image decoder to the dst buffer
+    // (the dst argument to onStartIncrementalDecode). Two pass decoding first
+    // writes into an intermediate buffer, and then composites and transforms
+    // the intermediate buffer into the dst buffer.
+    //
+    // In the general case, we need the two pass decoder, because of Skia API
+    // features that Wuffs doesn't support (e.g. color correction, scaling,
+    // RGB565). But as an optimization, we use one pass decoding (it's faster
+    // and uses less memory) if applicable (see the assignment to
+    // fIncrDecOnePass that calculates when we can do so).
+    Result onStartIncrementalDecodeOnePass(const SkImageInfo&       dstInfo,
+                                           uint8_t*                 dst,
+                                           size_t                   rowBytes,
+                                           const SkCodec::Options&  options,
+                                           wuffs_base__pixel_format pixelFormat,
+                                           size_t                   bytesPerPixel);
+    Result onStartIncrementalDecodeTwoPass();
+    Result onIncrementalDecodeOnePass();
+    Result onIncrementalDecodeTwoPass();
+
+    void        onGetFrameCountInternal();
+    Result      seekFrame(WhichDecoder which, int frameIndex);
     Result      resetDecoder(WhichDecoder which);
     const char* decodeFrameConfig(WhichDecoder which);
     const char* decodeFrame(WhichDecoder which);
     void        updateNumFullyReceivedFrames(WhichDecoder which);
 
     SkWuffsFrameHolder                           fFrameHolder;
     std::unique_ptr<SkStream>                    fStream;
-    std::unique_ptr<uint8_t, decltype(&sk_free)> fPixbufPtr;
     std::unique_ptr<uint8_t, decltype(&sk_free)> fWorkbufPtr;
     size_t                                       fWorkbufLen;
 
     std::unique_ptr<wuffs_gif__decoder, decltype(&sk_free)> fDecoders[WhichDecoder::kNumDecoders];
 
     const uint64_t           fFirstFrameIOPosition;
     wuffs_base__frame_config fFrameConfigs[WhichDecoder::kNumDecoders];
+    wuffs_base__pixel_config fPixelConfig;
     wuffs_base__pixel_buffer fPixelBuffer;
     wuffs_base__io_buffer    fIOBuffer;
 
     // Incremental decoding state.
     uint8_t* fIncrDecDst;
     uint64_t fIncrDecReaderIOPosition;
     size_t   fIncrDecRowBytes;
+    bool     fIncrDecOnePass;
     bool     fFirstCallToIncrementalDecode;
 
+    // Lazily allocated intermediate pixel buffer, for two pass decoding.
+    std::unique_ptr<uint8_t, decltype(&sk_free)> fTwoPassPixbufPtr;
+    size_t                                       fTwoPassPixbufLen;
+
     uint64_t                  fFrameCountReaderIOPosition;
     uint64_t                  fNumFullyReceivedFrames;
     std::vector<SkWuffsFrame> fFrames;
     bool                      fFramesComplete;
 
-    // True if fPixelBuffer's contents are known to be already zeroed. This is
-    // conservative, and may be false even if the buffer is zeroed.
-    bool fPixbufZeroed;
-
     // If calling an fDecoders[which] method returns an incomplete status, then
     // fDecoders[which] is suspended in a coroutine (i.e. waiting on I/O or
     // halted on a non-recoverable error). To keep its internal proof-of-safety
@@ -336,12 +353,9 @@ const SkFrame* SkWuffsFrameHolder::onGetFrame(int i) const {
 SkWuffsCodec::SkWuffsCodec(SkEncodedInfo&&                                         encodedInfo,
                            std::unique_ptr<SkStream>                               stream,
                            std::unique_ptr<wuffs_gif__decoder, decltype(&sk_free)> dec,
-                           std::unique_ptr<uint8_t, decltype(&sk_free)>            pixbuf_ptr,
-                           bool                                                    pixbuf_zeroed,
                            std::unique_ptr<uint8_t, decltype(&sk_free)>            workbuf_ptr,
                            size_t                                                  workbuf_len,
                            wuffs_base__image_config                                imgcfg,
-                           wuffs_base__pixel_buffer                                pixbuf,
                            wuffs_base__io_buffer                                   iobuf)
     : INHERITED(std::move(encodedInfo),
                 skcms_PixelFormat_RGBA_8888,
@@ -351,7 +365,6 @@ SkWuffsCodec::SkWuffsCodec(SkEncodedInfo&&
                 nullptr),
       fFrameHolder(),
       fStream(std::move(stream)),
-      fPixbufPtr(std::move(pixbuf_ptr)),
       fWorkbufPtr(std::move(workbuf_ptr)),
       fWorkbufLen(workbuf_len),
       fDecoders{
@@ -363,16 +376,19 @@ SkWuffsCodec::SkWuffsCodec(SkEncodedInfo&&
           wuffs_base__null_frame_config(),
           wuffs_base__null_frame_config(),
       },
-      fPixelBuffer(pixbuf),
+      fPixelConfig(imgcfg.pixcfg),
+      fPixelBuffer(wuffs_base__null_pixel_buffer()),
       fIOBuffer(wuffs_base__empty_io_buffer()),
       fIncrDecDst(nullptr),
       fIncrDecReaderIOPosition(0),
       fIncrDecRowBytes(0),
+      fIncrDecOnePass(false),
       fFirstCallToIncrementalDecode(false),
+      fTwoPassPixbufPtr(nullptr, &sk_free),
+      fTwoPassPixbufLen(0),
       fFrameCountReaderIOPosition(0),
       fNumFullyReceivedFrames(0),
       fFramesComplete(false),
-      fPixbufZeroed(pixbuf_zeroed),
       fDecoderIsSuspended{
           false,
           false,
@@ -441,15 +457,110 @@ SkCodec::Result SkWuffsCodec::onStartIncrementalDecode(const SkImageInfo&      d
         return SkCodec::kErrorInInput;
     }
 
-    uint32_t src_bits_per_pixel =
-        wuffs_base__pixel_format__bits_per_pixel(fPixelBuffer.pixcfg.pixel_format());
-    if ((src_bits_per_pixel == 0) || (src_bits_per_pixel % 8 != 0)) {
+    wuffs_base__pixel_format pixelFormat = WUFFS_BASE__PIXEL_FORMAT__INVALID;
+    size_t                   bytesPerPixel = 0;
+
+    switch (dstInfo.colorType()) {
+        case kBGRA_8888_SkColorType:
+            pixelFormat = WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL;
+            bytesPerPixel = 4;
+            break;
+        case kRGBA_8888_SkColorType:
+            pixelFormat = WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL;
+            bytesPerPixel = 4;
+            break;
+        default:
+            break;
+    }
+
+    // We can use "one pass" decoding if we have a Skia pixel format that Wuffs
+    // supports...
+    fIncrDecOnePass =
+        (pixelFormat != WUFFS_BASE__PIXEL_FORMAT__INVALID) &&
+        // ...and no color profile (as Wuffs does not support them)...
+        (!getEncodedInfo().profile()) &&
+        // ...and we have an independent frame (as Wuffs does not support the
+        // equivalent of SkBlendMode::kSrcOver)...
+        ((options.fFrameIndex == 0) ||
+         (this->frame(options.fFrameIndex)->getRequiredFrame() == SkCodec::kNoFrame)) &&
+        // ...and we use the identity transform (as Wuffs does not support
+        // scaling).
+        (this->dimensions() == dstInfo.dimensions());
+
+    result = fIncrDecOnePass ? this->onStartIncrementalDecodeOnePass(
+                                   dstInfo, static_cast<uint8_t*>(dst), rowBytes, options,
+                                   pixelFormat, bytesPerPixel)
+                             : this->onStartIncrementalDecodeTwoPass();
+    if (result != SkCodec::kSuccess) {
+        return result;
+    }
+
+    fIncrDecDst = static_cast<uint8_t*>(dst);
+    fIncrDecReaderIOPosition = fIOBuffer.reader_io_position();
+    fIncrDecRowBytes = rowBytes;
+    fFirstCallToIncrementalDecode = true;
+    return SkCodec::kSuccess;
+}
+
+SkCodec::Result SkWuffsCodec::onStartIncrementalDecodeOnePass(const SkImageInfo&       dstInfo,
+                                                              uint8_t*                 dst,
+                                                              size_t                   rowBytes,
+                                                              const SkCodec::Options&  options,
+                                                              wuffs_base__pixel_format pixelFormat,
+                                                              size_t bytesPerPixel) {
+    wuffs_base__pixel_config pixelConfig;
+    pixelConfig.set(pixelFormat, WUFFS_BASE__PIXEL_SUBSAMPLING__NONE, dstInfo.width(),
+                    dstInfo.height());
+
+    wuffs_base__table_u8 table;
+    table.ptr = dst;
+    table.width = static_cast<size_t>(dstInfo.width()) * bytesPerPixel;
+    table.height = dstInfo.height();
+    table.stride = rowBytes;
+
+    const char* status = fPixelBuffer.set_from_table(&pixelConfig, table);
+    if (status != nullptr) {
+        SkCodecPrintf("set_from_table: %s", status);
         return SkCodec::kInternalError;
     }
-    size_t src_bytes_per_pixel = src_bits_per_pixel / 8;
 
-    // Zero-initialize Wuffs' buffer covering the frame rect.
-    if (!fPixbufZeroed) {
+    SkSampler::Fill(dstInfo, dst, rowBytes, options.fZeroInitialized);
+    return SkCodec::kSuccess;
+}
+
+SkCodec::Result SkWuffsCodec::onStartIncrementalDecodeTwoPass() {
+    // Either re-use the previously allocated "two pass" pixel buffer (and
+    // memset to zero), or allocate (and zero initialize) a new one.
+    bool already_zeroed = false;
+
+    if (!fTwoPassPixbufPtr) {
+        uint64_t pixbuf_len = fPixelConfig.pixbuf_len();
+        void*    pixbuf_ptr_raw = (pixbuf_len <= SIZE_MAX)
+                                   ? sk_malloc_flags(pixbuf_len, SK_MALLOC_ZERO_INITIALIZE)
+                                   : nullptr;
+        if (!pixbuf_ptr_raw) {
+            return SkCodec::kInternalError;
+        }
+        fTwoPassPixbufPtr.reset(reinterpret_cast<uint8_t*>(pixbuf_ptr_raw));
+        fTwoPassPixbufLen = SkToSizeT(pixbuf_len);
+        already_zeroed = true;
+    }
+
+    const char* status = fPixelBuffer.set_from_slice(
+        &fPixelConfig, wuffs_base__make_slice_u8(fTwoPassPixbufPtr.get(), fTwoPassPixbufLen));
+    if (status != nullptr) {
+        SkCodecPrintf("set_from_slice: %s", status);
+        return SkCodec::kInternalError;
+    }
+
+    if (!already_zeroed) {
+        uint32_t src_bits_per_pixel =
+            wuffs_base__pixel_format__bits_per_pixel(fPixelConfig.pixel_format());
+        if ((src_bits_per_pixel == 0) || (src_bits_per_pixel % 8 != 0)) {
+            return SkCodec::kInternalError;
+        }
+        size_t src_bytes_per_pixel = src_bits_per_pixel / 8;
+
         wuffs_base__rect_ie_u32 frame_rect = fFrameConfigs[WhichDecoder::kIncrDecode].bounds();
         wuffs_base__table_u8    pixels = fPixelBuffer.plane(0);
 
@@ -468,16 +579,7 @@ SkCodec::Result SkWuffsCodec::onStartIncrementalDecode(const SkImageInfo&      d
             }
         }
     }
-    // The buffer is zeroed now, but this onStartIncrementalDecode call will
-    // almost certainly be followed by some onIncrementalDecode calls that can
-    // modify fPixelBuffer's contents. We set fPixbufZeroed to false so that
-    // the next onStartIncrementalDecode call will zero-initialize the buffer.
-    fPixbufZeroed = false;
 
-    fIncrDecDst = static_cast<uint8_t*>(dst);
-    fIncrDecReaderIOPosition = fIOBuffer.reader_io_position();
-    fIncrDecRowBytes = rowBytes;
-    fFirstCallToIncrementalDecode = true;
     return SkCodec::kSuccess;
 }
 
@@ -497,18 +599,37 @@ SkCodec::Result SkWuffsCodec::onIncrementalDecode(int* rowsDecoded) {
         return SkCodec::kInternalError;
     }
 
-    SkCodec::Result result = this->onIncrementalDecodeInternal(rowsDecoded);
+    if (rowsDecoded) {
+        *rowsDecoded = dstInfo().height();
+    }
+
+    SkCodec::Result result =
+        fIncrDecOnePass ? this->onIncrementalDecodeOnePass() : this->onIncrementalDecodeTwoPass();
     if (result == SkCodec::kSuccess) {
         fIncrDecDst = nullptr;
         fIncrDecReaderIOPosition = 0;
         fIncrDecRowBytes = 0;
+        fIncrDecOnePass = false;
     } else {
         fIncrDecReaderIOPosition = fIOBuffer.reader_io_position();
     }
     return result;
 }
 
-SkCodec::Result SkWuffsCodec::onIncrementalDecodeInternal(int* rowsDecoded) {
+SkCodec::Result SkWuffsCodec::onIncrementalDecodeOnePass() {
+    const char* status = this->decodeFrame(WhichDecoder::kIncrDecode);
+    if (status != nullptr) {
+        if (status == wuffs_base__suspension__short_read) {
+            return SkCodec::kIncompleteInput;
+        } else {
+            SkCodecPrintf("decodeFrame: %s", status);
+            return SkCodec::kErrorInInput;
+        }
+    }
+    return SkCodec::kSuccess;
+}
+
+SkCodec::Result SkWuffsCodec::onIncrementalDecodeTwoPass() {
     SkCodec::Result result = SkCodec::kSuccess;
     const char*     status = this->decodeFrame(WhichDecoder::kIncrDecode);
     bool            independent;
@@ -571,10 +692,6 @@ SkCodec::Result SkWuffsCodec::onIncrementalDecodeInternal(int* rowsDecoded) {
         SkASSERT(index == 0);
     }
 
-    if (rowsDecoded) {
-        *rowsDecoded = dstInfo().height();
-    }
-
     // If the frame's dirty rect is empty, no need to swizzle.
     wuffs_base__rect_ie_u32 dirty_rect = fDecoders[WhichDecoder::kIncrDecode]->frame_dirty_rect();
     if (!dirty_rect.is_empty()) {
@@ -910,26 +1027,6 @@ std::unique_ptr<SkCodec> SkWuffsCodec_MakeFromStream(std::unique_ptr<SkStream> s
     std::unique_ptr<uint8_t, decltype(&sk_free)> workbuf_ptr(
         reinterpret_cast<uint8_t*>(workbuf_ptr_raw), &sk_free);
 
-    constexpr int pixbuf_sk_malloc_flags = SK_MALLOC_ZERO_INITIALIZE;
-    uint64_t      pixbuf_len = imgcfg.pixcfg.pixbuf_len();
-    void*         pixbuf_ptr_raw =
-        pixbuf_len <= SIZE_MAX ? sk_malloc_flags(pixbuf_len, pixbuf_sk_malloc_flags) : nullptr;
-    if (!pixbuf_ptr_raw) {
-        *result = SkCodec::kInternalError;
-        return nullptr;
-    }
-    std::unique_ptr<uint8_t, decltype(&sk_free)> pixbuf_ptr(
-        reinterpret_cast<uint8_t*>(pixbuf_ptr_raw), &sk_free);
-    wuffs_base__pixel_buffer pixbuf = wuffs_base__null_pixel_buffer();
-
-    const char* status = pixbuf.set_from_slice(
-        &imgcfg.pixcfg, wuffs_base__make_slice_u8(pixbuf_ptr.get(), SkToSizeT(pixbuf_len)));
-    if (status != nullptr) {
-        SkCodecPrintf("set_from_slice: %s", status);
-        *result = SkCodec::kInternalError;
-        return nullptr;
-    }
-
     SkEncodedInfo::Color color =
         (imgcfg.pixcfg.pixel_format() == WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL)
             ? SkEncodedInfo::kBGRA_Color
@@ -943,8 +1040,7 @@ std::unique_ptr<SkCodec> SkWuffsCodec_MakeFromStream(std::unique_ptr<SkStream> s
     SkEncodedInfo encodedInfo = SkEncodedInfo::Make(width, height, color, alpha, 8);
 
     *result = SkCodec::kSuccess;
-    return std::unique_ptr<SkCodec>(new SkWuffsCodec(
-        std::move(encodedInfo), std::move(stream), std::move(decoder), std::move(pixbuf_ptr),
-        (pixbuf_sk_malloc_flags & SK_MALLOC_ZERO_INITIALIZE) != 0, std::move(workbuf_ptr),
-        workbuf_len, imgcfg, pixbuf, iobuf));
+    return std::unique_ptr<SkCodec>(new SkWuffsCodec(std::move(encodedInfo), std::move(stream),
+                                                     std::move(decoder), std::move(workbuf_ptr),
+                                                     workbuf_len, imgcfg, iobuf));
 }