Make SkAndroidCodec support gif

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 418 matching lines @@
 SkCodec::Result SkGifCodec::prepareToDecode(const SkImageInfo& dstInfo, SkPMColor* inputColorPtr,
         int* inputColorCount, const Options& opts) {
     // Check for valid input parameters
     if (!conversion_possible(dstInfo, this->getInfo())) {
         return gif_error("Cannot convert input type to output type.\n",
                 kInvalidConversion);
     }
 
     // Initialize color table and copy to the client if necessary
     this->initializeColorTable(dstInfo, inputColorPtr, inputColorCount);
-    return kSuccess;
+
+    return this->initializeSwizzler(dstInfo, opts);
 }
 
 SkCodec::Result SkGifCodec::initializeSwizzler(const SkImageInfo& dstInfo, const Options& opts) {
     const SkPMColor* colorPtr = get_color_ptr(fColorTable.get());
-    fSwizzler.reset(SkSwizzler::CreateSwizzler(SkSwizzler::kIndex, colorPtr, dstInfo, opts));
+    const SkIRect* frameRect = fFrameIsSubset ? &fFrameRect : nullptr;
+    fSwizzler.reset(SkSwizzler::CreateSwizzler(SkSwizzler::kIndex, colorPtr, dstInfo, opts,
+            frameRect));
+
     if (nullptr != fSwizzler.get()) {
         return kSuccess;
     }
     return kUnimplemented;
 }
 
 bool SkGifCodec::readRow() {
     return GIF_ERROR != DGifGetLine(fGif, fSrcBuffer.get(), fFrameRect.width());
 }
 
@@ skipping 10 matching lines @@
     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(fFrameRect.width(), fFrameRect.height());
-        if (kSuccess != this->initializeSwizzler(subsetDstInfo, opts)) {
-            return gif_error("Could not initialize swizzler.\n", kUnimplemented);
-        }
-
         // Fill the background
         SkSampler::Fill(dstInfo, dst, dstRowBytes,
                 this->getFillValue(dstInfo.colorType(), dstInfo.alphaType()),
                 opts.fZeroInitialized);
-
-        // Modify the dst pointer
-        const int32_t dstBytesPerPixel = SkColorTypeBytesPerPixel(dstInfo.colorType());
-        dst = SkTAddOffset<void*>(dst, dstRowBytes * fFrameRect.top() +
-                dstBytesPerPixel * fFrameRect.left());
-    } else {
-        if (kSuccess != this->initializeSwizzler(dstInfo, opts)) {
-            return gif_error("Could not initialize swizzler.\n", kUnimplemented);
-        }
     }
 
     // Iterate over rows of the input
-    uint32_t height = fFrameRect.height();
-    for (uint32_t y = 0; y < height; y++) {
+    for (int y = fFrameRect.top(); y < fFrameRect.bottom(); y++) {
         if (!this->readRow()) {
             *rowsDecoded = y;
             return gif_error("Could not decode line.\n", kIncompleteInput);
         }
         void* dstRow = SkTAddOffset<void>(dst, dstRowBytes * this->outputScanline(y));
         fSwizzler->swizzle(dstRow, fSrcBuffer.get());
     }
     return kSuccess;
 }
 
 // FIXME: This is similar to the implementation for bmp and png.  Can we share more code or
 //        possibly make this non-virtual?
 uint32_t SkGifCodec::onGetFillValue(SkColorType colorType, SkAlphaType alphaType) const {
     const SkPMColor* colorPtr = get_color_ptr(fColorTable.get());
     return get_color_table_fill_value(colorType, colorPtr, fFillIndex);
 }
 
 SkCodec::Result SkGifCodec::onStartScanlineDecode(const SkImageInfo& dstInfo,
         const SkCodec::Options& opts, SkPMColor inputColorPtr[], int* inputColorCount) {
-
-    Result result = this->prepareToDecode(dstInfo, inputColorPtr, inputColorCount, this->options());
-    if (kSuccess != result) {
-        return result;
-    }
-
-    // Initialize the swizzler
-    if (fFrameIsSubset) {
-        const SkImageInfo subsetDstInfo = dstInfo.makeWH(fFrameRect.width(), fFrameRect.height());
-        if (kSuccess != this->initializeSwizzler(subsetDstInfo, opts)) {
-            return gif_error("Could not initialize swizzler.\n", kUnimplemented);
-        }
-    } else {
-        if (kSuccess != this->initializeSwizzler(dstInfo, opts)) {
-            return gif_error("Could not initialize swizzler.\n", kUnimplemented);
-        }
-    }
-
-    return kSuccess;
+    return this->prepareToDecode(dstInfo, inputColorPtr, inputColorCount, this->options());
 }
 
 int SkGifCodec::onGetScanlines(void* dst, int count, size_t rowBytes) {
     int rowsBeforeFrame = 0;
     int rowsAfterFrame = 0;
     int rowsInFrame = count;
     if (fFrameIsSubset) {
         // Fill the requested rows
         SkImageInfo fillInfo = this->dstInfo().makeWH(this->dstInfo().width(), count);
         uint32_t fillValue = this->onGetFillValue(this->dstInfo().colorType(),
                 this->dstInfo().alphaType());
-        SkSampler::Fill(fillInfo, dst, rowBytes, fillValue, this->options().fZeroInitialized);
+        fSwizzler->fill(fillInfo, dst, rowBytes, fillValue, this->options().fZeroInitialized);
 
         // Do nothing for rows before the image frame
         rowsBeforeFrame = SkTMax(0, fFrameRect.top() - this->INHERITED::nextScanline());
         rowsInFrame = SkTMax(0, rowsInFrame - rowsBeforeFrame);
         dst = SkTAddOffset<void>(dst, rowBytes * rowsBeforeFrame);
 
         // Do nothing for rows after the image frame
         rowsAfterFrame = SkTMax(0,
                 this->INHERITED::nextScanline() + rowsInFrame - fFrameRect.bottom());
         rowsInFrame = SkTMax(0, rowsInFrame - rowsAfterFrame);
-
-        // Adjust dst pointer for left offset
-        int offset = SkColorTypeBytesPerPixel(this->dstInfo().colorType()) * fFrameRect.left();
-        dst = SkTAddOffset<void>(dst, offset);
     }
 
     for (int i = 0; i < rowsInFrame; i++) {
         if (!this->readRow()) {
             return i + rowsBeforeFrame;
         }
         fSwizzler->swizzle(dst, fSrcBuffer.get());
         dst = SkTAddOffset<void>(dst, rowBytes);
     }
 
     return count;
 }
 
 SkCodec::SkScanlineOrder SkGifCodec::onGetScanlineOrder() const {
     if (fGif->Image.Interlace) {
         return kOutOfOrder_SkScanlineOrder;
     }
     return kTopDown_SkScanlineOrder;
 }
 
 int SkGifCodec::onOutputScanline(int inputScanline) const {
     if (fGif->Image.Interlace) {
         if (inputScanline < fFrameRect.top() || inputScanline >= fFrameRect.bottom()) {
             return inputScanline;
         }
-        return get_output_row_interlaced(inputScanline - fFrameRect.top(), fFrameRect.height());
+        return get_output_row_interlaced(inputScanline - fFrameRect.top(), fFrameRect.height()) +
+                fFrameRect.top();
     }
     return inputScanline;
 }