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 83 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 92 matching lines @@
     , 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)
     , fFrameDims(SkIRect::MakeEmpty())
     , fFrameIsSubset(false)
-    , fColorTable(NULL)
-    , fSwizzler(NULL)
+    , 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 133 matching lines @@
     }
 
     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 44 matching lines @@
     if(!this->setFrameDimensions(desc)) {
         return gif_error("Invalid dimensions for image frame.\n", kInvalidInput);
     }
 
     // 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, this->getInfo()));
+    fSwizzler.reset(SkSwizzler::CreateSwizzler(SkSwizzler::kIndex, colorPtr, dstInfo, zeroInit,
+            this->getInfo(), subsetLeft, subsetWidth));

[scroggo, 2015/10/02 18:27:03]

If we stick these on options, we can update SkSwizzler to just take the Options,
which will include zeroInit along with subset info.

     if (nullptr != fSwizzler.get()) {
         return kSuccess;
     }
     return kUnimplemented;
 }
 
 bool SkGifCodec::readRow() {
     return GIF_ERROR != DGifGetLine(fGif, fSrcBuffer.get(), fFrameDims.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(fFrameDims.width(), fFrameDims.height());
-        if (kSuccess != this->initializeSwizzler(subsetDstInfo, opts.fZeroInitialized)) {
+        if (kSuccess != this->initializeSwizzler(subsetDstInfo, opts.fZeroInitialized, 0,
+                fFrameDims.width())) {
             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->getFillValue(dstInfo.colorType(),
                 dstInfo.alphaType()), 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)) {
+        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 = fFrameDims.width();
     uint32_t height = fFrameDims.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;
     }
 
     // Check to see if scaling was requested.
     if (dstInfo.dimensions() != this->getInfo().dimensions()) {
         if (!SkScaledCodec::DimensionsSupportedForSampling(this->getInfo(), dstInfo)) {
             return gif_error("Scaling not supported.\n", SkCodec::kInvalidScale);
         }
     }
 
     // Initialize the swizzler
     if (fFrameIsSubset) {
         int sampleX;
-        SkScaledCodec::ComputeSampleSize(dstInfo, this->getInfo(), &sampleX, NULL);
+        SkScaledCodec::ComputeSampleSize(dstInfo.dimensions(), this->getInfo().dimensions(),
+                &sampleX, NULL);
         const SkImageInfo subsetDstInfo = dstInfo.makeWH(
                     get_scaled_dimension(fFrameDims.width(), sampleX),
                     fFrameDims.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;
     if (fFrameIsSubset) {
         // Fill the requested rows
-        SkSwizzler::Fill(dst, this->dstInfo().makeWH(this->dstInfo().width(), count), rowBytes,
+        SkSwizzler::Fill(dst, this->dstInfo().makeWH(this->subsetWidth(), count), rowBytes,
                 this->onGetFillValue(this->dstInfo().colorType(), this->dstInfo().alphaType()),
                 this->options().fZeroInitialized);
 
         // Do nothing for rows before the image frame
         // FIXME: Do we handle fFrameIsSubset properly for interlaced images?
         rowsBeforeFrame = SkTMax(0, fFrameDims.top() - this->nextScanline());
         count = SkTMax(0, count - rowsBeforeFrame);
         dst = SkTAddOffset<void>(dst, rowBytes * rowsBeforeFrame);
 
         // Do nothing for rows after the image frame
@@ skipping 14 matching lines @@
     }
     return count + rowsBeforeFrame + rowsAfterFrame;
 }
 
 SkCodec::SkScanlineOrder SkGifCodec::onGetScanlineOrder() const {
     if (fGif->Image.Interlace) {
         return kOutOfOrder_SkScanlineOrder;
     }
     return kTopDown_SkScanlineOrder;
 }