Add subsetting to SkScaledCodec

src/codec/SkCodec_libpng.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_libpng.h"
 #include "SkCodecPriv.h"
 #include "SkColorPriv.h"
@@ skipping 376 matching lines @@
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Getting the pixels
 ///////////////////////////////////////////////////////////////////////////////
 
 SkCodec::Result SkPngCodec::initializeSwizzler(const SkImageInfo& requestedInfo,
                                                const Options& options,
                                                SkPMColor ctable[],
-                                               int* ctableCount) {
+                                               int* ctableCount,
+                                               int subsetLeft,
+                                               int subsetWidth) {
     // FIXME: Could we use the return value of setjmp to specify the type of
     // error?
     if (setjmp(png_jmpbuf(fPng_ptr))) {
         SkCodecPrintf("setjmp long jump!\n");
         return kInvalidInput;
     }
     png_read_update_info(fPng_ptr, fInfo_ptr);  
 
     //srcColorType was determined in read_header() which determined png color type
     const SkColorType srcColorType = this->getInfo().colorType();
@@ skipping 21 matching lines @@
             //would have exited before now if the colorType was supported by png
             SkASSERT(false);
     }  
 
     // Copy the color table to the client if they request kIndex8 mode
     copy_color_table(requestedInfo, fColorTable, ctable, ctableCount);
 
     // Create the swizzler.  SkPngCodec retains ownership of the color table.
     const SkPMColor* colors = get_color_ptr(fColorTable.get());
     fSwizzler.reset(SkSwizzler::CreateSwizzler(fSrcConfig, colors, requestedInfo,
-                    options.fZeroInitialized, this->getInfo()));
+                    options.fZeroInitialized, this->getInfo(), subsetLeft, subsetWidth));
     if (!fSwizzler) {
         // FIXME: CreateSwizzler could fail for another reason.
         return kUnimplemented;
     }
     return kSuccess;
 }
 
 
 bool SkPngCodec::onRewind() {
     // This sets fPng_ptr and fInfo_ptr to nullptr. If read_header
@@ skipping 23 matching lines @@
     }
     if (options.fSubset) {
         // Subsets are not supported.
         return kUnimplemented;
     }
     if (requestedInfo.dimensions() != this->getInfo().dimensions()) {
         return kInvalidScale;
     }
 
     // Note that ctable and ctableCount may be modified if there is a color table
-    const Result result = this->initializeSwizzler(requestedInfo, options,
-                                                   ctable, ctableCount);
+    const Result result = this->initializeSwizzler(requestedInfo, options, ctable, ctableCount, 0,
+            requestedInfo.width());
     if (result != kSuccess) {
         return result;
     }
     // FIXME: Could we use the return value of setjmp to specify the type of
     // error?
     int row = 0;
     if (setjmp(png_jmpbuf(fPng_ptr))) {
         // Assume that any error that occurs while reading rows is caused by an incomplete input.
         if (fNumberPasses > 1) {
             // FIXME (msarett): Handle incomplete interlaced pngs.
@@ skipping 112 matching lines @@
 class SkPngScanlineDecoder : public SkPngCodec {
 public:
     SkPngScanlineDecoder(const SkImageInfo& srcInfo, SkStream* stream,
             png_structp png_ptr, png_infop info_ptr, int bitDepth)
         : INHERITED(srcInfo, stream, png_ptr, info_ptr, bitDepth, 1)
         , fSrcRow(nullptr)
         , fAlphaState(kUnknown_AlphaState)
     {}
 
     Result onStartScanlineDecode(const SkImageInfo& dstInfo, const Options& options,
-            SkPMColor ctable[], int* ctableCount) override {
+            SkPMColor ctable[], int* ctableCount, int subsetLeft, int subsetWidth) override {
         if (!conversion_possible(dstInfo, this->getInfo())) {
             return kInvalidConversion;
         }
 
         // Check to see if scaling was requested.
         if (dstInfo.dimensions() != this->getInfo().dimensions()) {
             if (!SkScaledCodec::DimensionsSupportedForSampling(this->getInfo(), dstInfo)) {
                 return kInvalidScale;   
             }
         }
 
         const Result result = this->initializeSwizzler(dstInfo, options, ctable,
-                                                       ctableCount);
+                                                       ctableCount, subsetLeft, subsetWidth);
         if (result != kSuccess) {
             return result;
         }
 
         fAlphaState = kUnknown_AlphaState;
         fStorage.reset(this->getInfo().width() * SkSwizzler::BytesPerPixel(this->srcConfig()));
         fSrcRow = static_cast<uint8_t*>(fStorage.get());
 
         return kSuccess;
     }
@@ skipping 60 matching lines @@
             png_structp png_ptr, png_infop info_ptr, int bitDepth, int numberPasses)
         : INHERITED(srcInfo, stream, png_ptr, info_ptr, bitDepth, numberPasses)
         , fAlphaState(kUnknown_AlphaState)
         , fHeight(-1)
         , fCanSkipRewind(false)
     {
         SkASSERT(numberPasses != 1);
     }
 
     Result onStartScanlineDecode(const SkImageInfo& dstInfo, const Options& options,
-            SkPMColor ctable[], int* ctableCount) override
-    {
+            SkPMColor ctable[], int* ctableCount, int subsetLeft, int subsetWidth) override {
         if (!conversion_possible(dstInfo, this->getInfo())) {
             return kInvalidConversion;    
         }
 
         // Check to see if scaling was requested.
         if (dstInfo.dimensions() != this->getInfo().dimensions()) {
             if (!SkScaledCodec::DimensionsSupportedForSampling(this->getInfo(), dstInfo)) {
                 return kInvalidScale;
             }
         }
 
         const Result result = this->initializeSwizzler(dstInfo, options, ctable,
-                                                       ctableCount);
+                                                       ctableCount, subsetLeft, subsetWidth);
         if (result != kSuccess) {
             return result;
         }
 
         fAlphaState = kUnknown_AlphaState;
         fHeight = dstInfo.height();
         // FIXME: This need not be called on a second call to onStartScanlineDecode.
         fSrcRowBytes = this->getInfo().width() * SkSwizzler::BytesPerPixel(this->srcConfig());
         fGarbageRow.reset(fSrcRowBytes);
         fGarbageRowPtr = static_cast<uint8_t*>(fGarbageRow.get());
@@ skipping 120 matching lines @@
 
     if (1 == numberPasses) {
         return new SkPngScanlineDecoder(imageInfo, streamDeleter.detach(), png_ptr, info_ptr,
                                         bitDepth);
     }
 
     return new SkPngInterlacedScanlineDecoder(imageInfo, streamDeleter.detach(), png_ptr,
                                               info_ptr, bitDepth, numberPasses);
 }