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);
+                    if (kSuccess != result && kIncompleteInput != result) {

[scroggo, 2015/09/02 22:45:48]

Again, I am concerned about accepting kIncomplete here. (And then returning
kSuccess!)

[msarett, 2015/09/03 17:13:31]

I would agree that we should return result at the bottom instead of kSuccess. 
This has been fixed.

I also agree that continuing to try to getScanlines() after kIncomplete has
already been returned is weird.  Right now, we do this to avoid leaving
uninitialized memory in the dst.  My goal is to deal with this by filling
uninitialized memory in the SkCodec base class implementation of onGetPixels()
when kIncompleteInput is returned by a subclass.

I'm adding a FIXME, but I think it's best to keep this for another CL.  Let me
know if you think this is ok as a temporary solution?  It's worth noting that we
are already using this temporary solution further down in this function -
Doesn't make it any better, but it's something that already needs to be fixed.

Side Note:
Looks like it might be useful/necessary for the SkCodec base class to know the
SkScanlineOrder in order to Fill().  Another argument for combining the two
classes.

[scroggo, 2015/09/04 18:42:09]

I'm happy with a FIXME. I think I understand what's going on here based on your
comments there. As I said there, I think this is an interesting but strange
behavior. Maybe it's right though.

[msarett, 2015/09/04 19:52:47]

I think we can improve on this...  FIXME sounds good for now.

+                        return result;
+                    }
+                }
+                return kSuccess;
+            }
+        }
     }
 
     if (kInvalidScale != result) {
         // no scaling requested
         return result;
     }
     
     // scaling requested
     int sampleX;
     int sampleY;
@@ skipping 69 matching lines @@
                 storagePtr += sampleY * rowBytes;
                 dst = SkTAddOffset<void>(dst, rowBytes);
             }
             return kSuccess;
         }
         default:
             SkASSERT(false);
             return kUnimplemented;
     }
 }