Add subsetting to SkScaledCodec

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 82 matching lines @@
     // Use maximum unsigned int (surely an invalid index) to indicate that a valid
     // index was not found.
     return SK_MaxU32;
 }
 
 /*
  * 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);
+    DGifCloseFile(gif, nullptr);
 }
 
 /*
  * This function free extension data that has been saved to assist the image
  * decoder
  */
 void SkGifCodec::FreeExtension(SavedImage* image) {
-    if (NULL != image->ExtensionBlocks) {
+    if (nullptr != image->ExtensionBlocks) {
         GifFreeExtensions(&image->ExtensionBlockCount, &image->ExtensionBlocks);
     }
 }
 
 /*
  * Read enough of the stream to initialize the SkGifCodec.
  * Returns a bool representing success or failure.
  *
  * @param codecOut
  * If it returned true, and codecOut was not nullptr,
@@ skipping 91 matching lines @@
     , fGif(gif)
     , fSrcBuffer(new uint8_t[this->getInfo().width()])
     // If it is valid, fTransIndex will be used to set fFillIndex.  We don't know if
     // fTransIndex is valid until we process the color table, since fTransIndex may
     // be greater than the size of the color table.
     , fTransIndex(transIndex)
     // Default fFillIndex is 0.  We will overwrite this if fTransIndex is valid, or if
     // there is a valid background color.
     , fFillIndex(0)
     , fFrameRect(frameRect)
-    , fFrameIsSubset(frameIsSubset)
-    , fColorTable(NULL)
-    , fSwizzler(NULL)
+    , fFrameIsSubset(false)
+    , fColorTable(nullptr)
+    , fSwizzler(nullptr)
 {}
 
 bool SkGifCodec::onRewind() {
     GifFileType* gifOut = nullptr;
     if (!ReadHeader(this->stream(), nullptr, &gifOut)) {
         return false;
     }
 
     SkASSERT(nullptr != gifOut);
     fGif.reset(gifOut);
@@ skipping 112 matching lines @@
     frameRect->setXYWH(frameLeft, frameTop, frameWidth, frameHeight);
     size->set(width, height);
     return true;
 }
 
 void SkGifCodec::initializeColorTable(const SkImageInfo& dstInfo, SkPMColor* inputColorPtr,
         int* inputColorCount) {
     // Set up our own color table
     const uint32_t maxColors = 256;
     SkPMColor colorPtr[256];
-    if (NULL != inputColorCount) {
+    if (nullptr != inputColorCount) {
         // We set the number of colors to maxColors in order to ensure
         // safe memory accesses.  Otherwise, an invalid pixel could
         // access memory outside of our color table array.
         *inputColorCount = maxColors;
     }
 
     // Get local color table
     ColorMapObject* colorMap = fGif->Image.ColorMap;
     // If there is no local color table, use the global color table
-    if (NULL == colorMap) {
+    if (nullptr == colorMap) {
         colorMap = fGif->SColorMap;
     }
 
     uint32_t colorCount = 0;
-    if (NULL != colorMap) {
+    if (nullptr != colorMap) {
         colorCount = colorMap->ColorCount;
         // giflib guarantees these properties
         SkASSERT(colorCount == (unsigned) (1 << (colorMap->BitsPerPixel)));
         SkASSERT(colorCount <= 256);
         for (uint32_t i = 0; i < colorCount; i++) {
             colorPtr[i] = SkPackARGB32(0xFF, colorMap->Colors[i].Red,
                     colorMap->Colors[i].Green, colorMap->Colors[i].Blue);
         }
     }
 
@@ skipping 34 matching lines @@
         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;
 }
 
 SkCodec::Result SkGifCodec::initializeSwizzler(const SkImageInfo& dstInfo,
-        ZeroInitialized zeroInit) {
+        ZeroInitialized zeroInit, int subsetLeft, int subsetWidth) {
     const SkPMColor* colorPtr = get_color_ptr(fColorTable.get());
-    fSwizzler.reset(SkSwizzler::CreateSwizzler(SkSwizzler::kIndex,
-            colorPtr, dstInfo, zeroInit));
+    fSwizzler.reset(SkSwizzler::CreateSwizzler(SkSwizzler::kIndex, colorPtr, dstInfo, zeroInit,
+            subsetLeft, subsetWidth));
     if (nullptr != fSwizzler.get()) {
         return kSuccess;
     }
     return kUnimplemented;
 }
 
 bool SkGifCodec::readRow() {
     return GIF_ERROR != DGifGetLine(fGif, fSrcBuffer.get(), fFrameRect.width());
 }
 
@@ skipping 11 matching lines @@
         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.fZeroInitialized)) {
+        if (kSuccess != this->initializeSwizzler(subsetDstInfo, opts.fZeroInitialized, 0,
+                fFrameRect.width())) {
             return gif_error("Could not initialize swizzler.\n", kUnimplemented);
         }
 
         // Fill the background
         fSwizzler->fill(dst, dstInfo.colorType(), dstInfo.height(), 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.fZeroInitialized)) {
+        if (kSuccess != this->initializeSwizzler(dstInfo, opts.fZeroInitialized, 0,
+                dstInfo.width())) {
             return gif_error("Could not initialize swizzler.\n", kUnimplemented);
         }
     }
 
     // Iterate over rows of the input
     uint32_t width = fFrameRect.width();
     uint32_t height = fFrameRect.height();
     for (uint32_t y = 0; y < height; 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;
 }
 
 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) {
+        const SkCodec::Options& opts, SkPMColor inputColorPtr[], int* inputColorCount,
+        int subsetLeft, int subsetWidth) {
 
     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.fZeroInitialized)) {
+        if (kSuccess != this->initializeSwizzler(subsetDstInfo, opts.fZeroInitialized, subsetLeft,
+                subsetWidth)) {
             return gif_error("Could not initialize swizzler.\n", kUnimplemented);
         }
     } else {
-        if (kSuccess != this->initializeSwizzler(dstInfo, opts.fZeroInitialized)) {
+        if (kSuccess != this->initializeSwizzler(dstInfo, opts.fZeroInitialized, subsetLeft,
+                subsetWidth)) {
             return gif_error("Could not initialize swizzler.\n", kUnimplemented);
         }
     }
 
     return kSuccess;
 }
 
 int SkGifCodec::onGetScanlines(void* dst, int count, size_t rowBytes) {
     int rowsBeforeFrame = 0;
     int rowsAfterFrame = 0;
@@ skipping 39 matching lines @@
 
 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 inputScanline;
 }