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(SkNEW_ARGS(SkMemoryStream, (data)));
 }
 
 SkScaledCodec::SkScaledCodec(SkScanlineDecoder* scanlineDecoder)
     : INHERITED(scanlineDecoder->getInfo(), NULL)
     , 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 25 matching lines @@
     // support scaling down by integer numbers. Ex: 1/2, 1/3, 1/4 ...
     SkISize scaledCodecDimensions;
     if (desiredScale > 0.5f) {
         // sampleSize = 1
         scaledCodecDimensions = fScanlineDecoder->getInfo().dimensions();
     }
     // sampleSize determines the step size between samples
     // Ex: sampleSize = 2, sample every second pixel in x and y directions
     int sampleSize = int(1 / desiredScale);
 
-    int scaledWidth = get_scaled_dimension(this->getInfo().width(), sampleSize);
-    int scaledHeight = get_scaled_dimension(this->getInfo().height(), sampleSize);
+    int scaledWidth = SkScaledCodec::GetScaledDimension(this->getInfo().width(), sampleSize);
+    int scaledHeight = SkScaledCodec::GetScaledDimension(this->getInfo().height(), sampleSize);
 
     // Return the calculated output dimensions for the given scale
     scaledCodecDimensions = SkISize::Make(scaledWidth, scaledHeight);
 
     return best_scaled_dimensions(this->getInfo().dimensions(), nativeDimensions,
                                   scaledCodecDimensions, desiredScale);
 }
 
 // check if scaling to dstInfo size from srcInfo size using sampleSize is possible
 static bool scaling_supported(const SkImageInfo& dstInfo, const SkImageInfo& srcInfo,
                               int* sampleX, int* sampleY) {
     SkScaledCodec::ComputeSampleSize(dstInfo, srcInfo, sampleX, sampleY);
     const int dstWidth = dstInfo.width();
     const int dstHeight = dstInfo.height();
     const int srcWidth = srcInfo.width();
     const int srcHeight = srcInfo.height();
      // only support down sampling, not up sampling
     if (dstWidth > srcWidth || dstHeight  > srcHeight) {
         return false;
     }
     // check that srcWidth is scaled down by an integer value
-    if (get_scaled_dimension(srcWidth, *sampleX) != dstWidth) {
+    if (SkScaledCodec::GetScaledDimension(srcWidth, *sampleX) != dstWidth) {
         return false;
     }
     // check that src height is scaled down by an integer value
-    if (get_scaled_dimension(srcHeight, *sampleY) != dstHeight) {
+    if (SkScaledCodec::GetScaledDimension(srcHeight, *sampleY) != dstHeight) {
         return false;
     }
     // sampleX and sampleY should be equal unless the original sampleSize requested was larger
     // than srcWidth or srcHeight. If so, the result of this is dstWidth or dstHeight = 1.
     // This functionality allows for tall thin images to still be scaled down by scaling factors.
     if (*sampleX != *sampleY){
         if (1 != dstWidth && 1 != dstHeight) {
             return false;
         }
     }
     return true;
 }
 
+// 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
+inline int SkScaledCodec::GetScaledDimension(int srcDimension, int sampleSize) {
+    if (sampleSize > srcDimension) {
+        return 1;
+    }
+    return srcDimension / sampleSize;
+}
+
 inline int SkScaledCodec::GetStartCoord(int sampleFactor) {
     return sampleFactor / 2;
 }
 
 inline int SkScaledCodec::GetDstCoord(int srcCoord, int sampleFactor) {
     return srcCoord / sampleFactor;
 }
 
 bool SkScaledCodec::IsCoordNecessary(int srcCoord, int sampleFactor, int scaledDim) {
     // Get the first coordinate that we want to keep
@@ skipping 30 matching lines @@
     // allows for tall thin images to still be scaled down by scaling factors.
 
     if (sampleX != sampleY){
         if (1 != dstWidth && 1 != dstHeight) {
 
             // rounding during onGetScaledDimensions can cause different sampleSizes
             // Ex: srcWidth = 79, srcHeight = 20, sampleSize = 10
             // dstWidth = 7, dstHeight = 2, sampleX = 79/7 = 11, sampleY = 20/2 = 10
             // correct for this rounding by comparing width to sampleY and height to sampleX
 
-            if (get_scaled_dimension(srcWidth, sampleY) == dstWidth) {
+            if (SkScaledCodec::GetScaledDimension(srcWidth, sampleY) == dstWidth) {
                 sampleX = sampleY;
-            } else if (get_scaled_dimension(srcHeight, sampleX) == dstHeight) {
+            } else if (SkScaledCodec::GetScaledDimension(srcHeight, sampleX) == dstHeight) {
                 sampleY = sampleX;
             }
         }
     }
 
     if (sampleXPtr) {
         *sampleXPtr = sampleX;
     }
     if (sampleYPtr) {
         *sampleYPtr = sampleY;
     }
 }
 
 // TODO: Implement subsetting in onGetPixels which works when and when not sampling 
 
 SkCodec::Result SkScaledCodec::onGetPixels(const SkImageInfo& requestedInfo, void* dst,
                                            size_t rowBytes, const Options& options,
                                            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);

[msarett, 2015/08/24 23:20:13]

I need to add a switch statement here.

Interlaced gifs currently decode incorrectly when scale = 1.0f because
kOutOfOrder scanline decodes are meant to occur one at a time.

If we were to combine SkCodec and SkScanlineDecoder, we could call onGetPixels()
here.

     }
 
     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;
     }
 }