Fill incomplete images in SkCodec parent class

src/codec/SkCodec_libgif.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_libgif.h"
 #include "SkCodecPriv.h"
 #include "SkColorPriv.h"
@@ skipping 78 matching lines @@
             // There should only be one graphics control extension for the image frame
             break;
         }
     }
 
     // Use maximum unsigned int (surely an invalid index) to indicate that a valid
     // index was not found.
     return SK_MaxU32;
 }
 
-static inline uint32_t ceil_div(uint32_t a, uint32_t b) {
-    return (a + b - 1) / b;
-}
-
-/*
- * Gets the output row corresponding to the encoded row for interlaced gifs
- */
-static uint32_t get_output_row_interlaced(uint32_t encodedRow, uint32_t height) {
-    SkASSERT(encodedRow < height);
-    // First pass
-    if (encodedRow * 8 < height) {
-        return encodedRow * 8;
-    }
-    // Second pass
-    if (encodedRow * 4 < height) {
-        return 4 + 8 * (encodedRow - ceil_div(height, 8));
-    }
-    // Third pass
-    if (encodedRow * 2 < height) {
-        return 2 + 4 * (encodedRow - ceil_div(height, 4));
-    }
-    // Fourth pass
-    return 1 + 2 * (encodedRow - ceil_div(height, 2));
-}
-
 /*
  * This function cleans up the gif object after the decode completes
  * It is used in a SkAutoTCallIProc template
  */
 void SkGifCodec::CloseGif(GifFileType* gif) {
     DGifCloseFile(gif, NULL);
 }
 
 /*
  * This function free extension data that has been saved to assist the image
@@ skipping 356 matching lines @@
         ZeroInitialized zeroInit) {
     const SkPMColor* colorPtr = get_color_ptr(fColorTable.get());
     fSwizzler.reset(SkSwizzler::CreateSwizzler(SkSwizzler::kIndex,
             colorPtr, dstInfo, zeroInit, this->getInfo()));
     if (nullptr != fSwizzler.get()) {
         return kSuccess;
     }
     return kUnimplemented;
 }
 
-SkCodec::Result SkGifCodec::readRow() {
+bool SkGifCodec::readRow() {
     if (GIF_ERROR == DGifGetLine(fGif, fSrcBuffer.get(), fFrameDims.width())) {

[scroggo, 2015/09/25 15:55:06]

nit: This can be one line:

return GIF_ERROR != DGifGetLine(...);

[msarett, 2015/10/01 12:44:52]

Done.

-        return kIncompleteInput;
+        return false;
     }
-    return kSuccess;
+    return true;
 }
 
 /*
  * Initiates the gif decode
  */
 SkCodec::Result SkGifCodec::onGetPixels(const SkImageInfo& dstInfo,
                                         void* dst, size_t dstRowBytes,
                                         const Options& opts,
                                         SkPMColor* inputColorPtr,
-                                        int* inputColorCount) {
+                                        int* inputColorCount,
+                                        int* incompleteScanlines) {
     Result result = this->prepareToDecode(dstInfo, inputColorPtr, inputColorCount, opts);
     if (kSuccess != result) {
         return result;
     }
 
     if (dstInfo.dimensions() != this->getInfo().dimensions()) {
         return gif_error("Scaling not supported.\n", kInvalidScale);
     }
 
     // Initialize the swizzler
     if (fFrameIsSubset) {
         const SkImageInfo subsetDstInfo = dstInfo.makeWH(fFrameDims.width(), fFrameDims.height());
         if (kSuccess != this->initializeSwizzler(subsetDstInfo, opts.fZeroInitialized)) {
             return gif_error("Could not initialize swizzler.\n", kUnimplemented);
         }
 
         // Fill the background
         const SkPMColor* colorPtr = get_color_ptr(fColorTable.get());
-        SkSwizzler::Fill(dst, dstInfo, dstRowBytes, this->getInfo().height(),
-                fFillIndex, colorPtr, opts.fZeroInitialized);
+        SkSwizzler::Fill(dst, dstInfo, dstRowBytes, this->getFillValue(dstInfo),
+                opts.fZeroInitialized);
 
         // Modify the dst pointer
         const int32_t dstBytesPerPixel = SkColorTypeBytesPerPixel(dstInfo.colorType());
         dst = SkTAddOffset<void*>(dst, dstRowBytes * fFrameDims.top() +
                 dstBytesPerPixel * fFrameDims.left());
     } else {
         if (kSuccess != this->initializeSwizzler(dstInfo, opts.fZeroInitialized)) {
             return gif_error("Could not initialize swizzler.\n", kUnimplemented);
         }
     }
 
     // Check the interlace flag and iterate over rows of the input
     uint32_t width = fFrameDims.width();
     uint32_t height = fFrameDims.height();
     if (fGif->Image.Interlace) {
         // In interlace mode, the rows of input are rearranged in
         // the output image.  We a helper function to help us
         // rearrange the decoded rows.
         for (uint32_t y = 0; y < height; y++) {
-            if (kSuccess != this->readRow()) {
-                // Recover from error by filling remainder of image
-                memset(fSrcBuffer.get(), fFillIndex, width);
+            if (!this->readRow()) {
+                // Incomplete interlaced gifs are a unique case.  Rather than,
+                // relying on the base class, we will fill the remaining lines
+                // here.
+                const SkImageInfo fillInfo = dstInfo.makeWH(dstInfo.width(), 1);
+                const uint32_t fillValue = this->getFillValue(fillInfo);
                 for (; y < height; y++) {
                     void* dstRow = SkTAddOffset<void>(dst,
                             dstRowBytes * get_output_row_interlaced(y, height));
-                    fSwizzler->swizzle(dstRow, fSrcBuffer.get());
+                    SkSwizzler::Fill(dstRow, fillInfo, dstRowBytes, fillValue,
+                            opts.fZeroInitialized);
                 }
                 return gif_error("Could not decode line.\n", kIncompleteInput);
             }
             void* dstRow = SkTAddOffset<void>(dst,
                     dstRowBytes * get_output_row_interlaced(y, height));
             fSwizzler->swizzle(dstRow, fSrcBuffer.get());
         }
     } else {
         // Standard mode
         void* dstRow = dst;
         for (uint32_t y = 0; y < height; y++) {
-            if (kSuccess != this->readRow()) {
-                const SkPMColor* colorPtr = get_color_ptr(fColorTable.get());
-                SkSwizzler::Fill(dstRow, dstInfo, dstRowBytes,
-                        height - y, fFillIndex, colorPtr, opts.fZeroInitialized);
+            if (!this->readRow()) {
+                *incompleteScanlines = height - y;
                 return gif_error("Could not decode line\n", kIncompleteInput);
             }
             fSwizzler->swizzle(dstRow, fSrcBuffer.get());
             dstRow = SkTAddOffset<void>(dstRow, dstRowBytes);
         }
     }
     return kSuccess;
 }
 
+uint32_t SkGifCodec::onGetFillValue(const SkImageInfo& dstInfo) const {
+    const SkPMColor* colorPtr = get_color_ptr(fColorTable.get());
+    return get_color_table_fill_value(dstInfo.colorType(), colorPtr, fFillIndex);
+}
+
 // TODO (msarett): skbug.com/3582
 //                 Should we implement reallyHasAlpha?  Or should we read extension blocks in the
 //                 header?  Or should we do both?
 
 class SkGifScanlineDecoder : public SkScanlineDecoder {
 public:
-    SkGifScanlineDecoder(const SkImageInfo& srcInfo, SkGifCodec* codec)
-        : INHERITED(srcInfo)
+    SkGifScanlineDecoder(SkGifCodec* codec)
+        : INHERITED(codec, codec->getInfo())
         , fCodec(codec)
     {}
 
     SkEncodedFormat onGetEncodedFormat() const override {
         return kGIF_SkEncodedFormat;
     }
 
     SkCodec::Result onStart(const SkImageInfo& dstInfo, const SkCodec::Options& opts,
                             SkPMColor inputColorPtr[], int* inputColorCount) override {
         SkCodec::Result result = fCodec->prepareToDecode(dstInfo, inputColorPtr, inputColorCount,
@@ skipping 22 matching lines @@
             }
         } else {
             if (SkCodec::kSuccess != fCodec->initializeSwizzler(dstInfo, opts.fZeroInitialized)) {
                 return gif_error("Could not initialize swizzler.\n", SkCodec::kUnimplemented);
             }
         }
 
         return SkCodec::kSuccess;
     }
 
-    SkCodec::Result onGetScanlines(void* dst, int count, size_t rowBytes) override {
+    uint32_t onGetScanlines(void* dst, int count, size_t rowBytes) override {
         if (fCodec->fFrameIsSubset) {
             // Fill the requested rows
-            const SkPMColor* colorPtr = get_color_ptr(fCodec->fColorTable.get());
-            SkSwizzler::Fill(dst, this->dstInfo(), rowBytes, count, fCodec->fFillIndex,
-                    colorPtr, this->options().fZeroInitialized);
+            SkSwizzler::Fill(dst, this->dstInfo().makeWH(this->dstInfo().width(), count), rowBytes,
+                    fCodec->onGetFillValue(dstInfo()), this->options().fZeroInitialized);
 
             // Do nothing for rows before the image frame
             int rowsBeforeFrame = fCodec->fFrameDims.top() - INHERITED::getY();
             if (rowsBeforeFrame > 0) {
                 count = SkTMin(0, count - rowsBeforeFrame);
                 dst = SkTAddOffset<void>(dst, rowBytes * rowsBeforeFrame);
             }
 
             // Do nothing for rows after the image frame
             int rowsAfterFrame = INHERITED::getY() + count - fCodec->fFrameDims.bottom();
             if (rowsAfterFrame > 0) {
                 count = SkTMin(0, count - rowsAfterFrame);
             }
 
             // Adjust dst pointer for left offset
             dst = SkTAddOffset<void>(dst, SkColorTypeBytesPerPixel(
                     this->dstInfo().colorType()) * fCodec->fFrameDims.left());
         }
 
+        void* dstRow = dst;
         for (int i = 0; i < count; i++) {
-            if (SkCodec::kSuccess != fCodec->readRow()) {
-                const SkPMColor* colorPtr = get_color_ptr(fCodec->fColorTable.get());
-                SkSwizzler::Fill(dst, this->dstInfo(), rowBytes,
-                        count - i, fCodec->fFillIndex, colorPtr,
-                        this->options().fZeroInitialized);
-                return gif_error("Could not decode line\n", SkCodec::kIncompleteInput);
+            if (!fCodec->readRow()) {
+                return i;
             }
-            fCodec->fSwizzler->swizzle(dst, fCodec->fSrcBuffer.get());
-            dst = SkTAddOffset<void>(dst, rowBytes);
+            fCodec->fSwizzler->swizzle(dstRow, fCodec->fSrcBuffer.get());
+            dstRow = SkTAddOffset<void>(dstRow, rowBytes);
         }
-        return SkCodec::kSuccess;
+        return count;
     }
 
     SkScanlineOrder onGetScanlineOrder() const override {
         if (fCodec->fGif->Image.Interlace) {
             return kOutOfOrder_SkScanlineOrder;
         } else {
             return kTopDown_SkScanlineOrder;
         }
     }
 
-    int onGetY() const override {
-        if (fCodec->fGif->Image.Interlace) {
-            return get_output_row_interlaced(INHERITED::onGetY(), this->dstInfo().height());
-        } else {
-            return INHERITED::onGetY();
-        }
-    }
-
 private:
-    SkAutoTDelete<SkGifCodec>   fCodec;
+    SkGifCodec* fCodec; // Owned by parent class
 
     typedef SkScanlineDecoder INHERITED;
 };
 
 SkScanlineDecoder* SkGifCodec::NewSDFromStream(SkStream* stream) {
     SkAutoTDelete<SkGifCodec> codec (static_cast<SkGifCodec*>(SkGifCodec::NewFromStream(stream)));
     if (!codec) {
         return NULL;
     }
 
-    const SkImageInfo& srcInfo = codec->getInfo();
-
-    return SkNEW_ARGS(SkGifScanlineDecoder, (srcInfo, codec.detach()));
+    return SkNEW_ARGS(SkGifScanlineDecoder, (codec.detach()));
 }