Scanline decoding for gifs

src/codec/SkScaledCodec.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 "SkCodecPriv.h"
 #include "SkScaledCodec.h"
 #include "SkStream.h"
@@ skipping 26 matching lines @@
     return NewFromStream(new SkMemoryStream(data));
 }
 
 SkScaledCodec::SkScaledCodec(SkScanlineDecoder* scanlineDecoder)
     : INHERITED(scanlineDecoder->getInfo(), nullptr)
     , fScanlineDecoder(scanlineDecoder)
 {}
 
 SkScaledCodec::~SkScaledCodec() {}
 
-// returns a scaled dimension based on the original dimension and the sampleSize
-// NOTE: we round down here for scaled dimension to match the behavior of SkImageDecoder
-static int get_scaled_dimension(int srcDimension, int sampleSize) {
-    if (sampleSize > srcDimension) {
-        return 1;
-    }
-    return srcDimension / sampleSize;
-}
-
 static SkISize best_scaled_dimensions(const SkISize& origDims, const SkISize& nativeDims,
                                       const SkISize& scaledCodecDims, float desiredScale) {
     if (nativeDims == scaledCodecDims) {
         // does not matter which to return if equal. Return here to skip below calculations
         return nativeDims;
     }
     float idealWidth = origDims.width() * desiredScale;
     float idealHeight = origDims.height() * desiredScale;
 
     // calculate difference between native dimensions and ideal dimensions
@@ skipping 124 matching lines @@
                                            SkPMColor ctable[], int* ctableCount) {
 
     if (options.fSubset) {
         // Subsets are not supported.
         return kUnimplemented;
     } 
 
     Result result = fScanlineDecoder->start(requestedInfo, &options, ctable, ctableCount);
     if (kSuccess == result) {
         // native decode supported
-        return fScanlineDecoder->getScanlines(dst, requestedInfo.height(), rowBytes);
+        switch (fScanlineDecoder->getScanlineOrder()) {
+            case SkScanlineDecoder::kTopDown_SkScanlineOrder:
+            case SkScanlineDecoder::kBottomUp_SkScanlineOrder:
+            case SkScanlineDecoder::kNone_SkScanlineOrder:
+                return fScanlineDecoder->getScanlines(dst, requestedInfo.height(), rowBytes);
+            case SkScanlineDecoder::kOutOfOrder_SkScanlineOrder: {
+                for (int y = 0; y < requestedInfo.height(); y++) {
+                    int dstY = fScanlineDecoder->getY();
+                    void* dstPtr = SkTAddOffset<void>(dst, rowBytes * dstY);
+                    result = fScanlineDecoder->getScanlines(dstPtr, 1, rowBytes);
+                    // FIXME (msarett): Make the SkCodec base class take care of filling
+                    // uninitialized pixels so we can return immediately on kIncompleteInput.
+                    if (kSuccess != result && kIncompleteInput != result) {
+                        return result;
+                    }
+                }
+                return result;
+            }
+        }
     }
 
     if (kInvalidScale != result) {
         // no scaling requested
         return result;
     }
     
     // scaling requested
     int sampleX;
     int sampleY;
@@ skipping 28 matching lines @@
                     return result;
                 }
                 if (y < dstHeight - 1) {
                     result = fScanlineDecoder->skipScanlines(sampleY - 1);
                     if (kSuccess != result && kIncompleteInput != result) {
                         return result;
                     }
                 }
                 dst = SkTAddOffset<void>(dst, rowBytes);
             }
-            return kSuccess;
+            return result;
         }
         case SkScanlineDecoder::kBottomUp_SkScanlineOrder:
         case SkScanlineDecoder::kOutOfOrder_SkScanlineOrder: {
             for (int y = 0; y < srcHeight; y++) {
                 int srcY = fScanlineDecoder->getY();
                 if (is_coord_necessary(srcY, sampleY, dstHeight)) {
                     void* dstPtr = SkTAddOffset<void>(dst, rowBytes * get_dst_coord(srcY, sampleY));
                     result = fScanlineDecoder->getScanlines(dstPtr, 1, rowBytes);
                     if (kSuccess != result && kIncompleteInput != result) {
                         return result;
                     }
                 } else {
                     result = fScanlineDecoder->skipScanlines(1);
                     if (kSuccess != result && kIncompleteInput != result) {
                         return result;
                     }
                 }
             }
-            return kSuccess;
+            return result;
         }
         case SkScanlineDecoder::kNone_SkScanlineOrder: {
             SkAutoMalloc storage(srcHeight * rowBytes);
             uint8_t* storagePtr = static_cast<uint8_t*>(storage.get());
             result = fScanlineDecoder->getScanlines(storagePtr, srcHeight, rowBytes);
-            if (kSuccess != result) {
+            if (kSuccess != result && kIncompleteInput != result) {
                 return result;
             }
             storagePtr += Y0 * rowBytes;
             for (int y = 0; y < dstHeight; y++) {
                 memcpy(dst, storagePtr, rowBytes);
                 storagePtr += sampleY * rowBytes;
                 dst = SkTAddOffset<void>(dst, rowBytes);
             }
-            return kSuccess;
+            return result;
         }
         default:
             SkASSERT(false);
             return kUnimplemented;
     }
 }