Scanline decoding for bmp

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 121 matching lines @@
     // 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;
 }
 
+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) {

[scroggo, 2015/08/27 20:14:23]

Any idea whether calling all these functions slows things down when the sample
size is 1? If so, maybe this should special case if sampleFactor == 1?

[msarett, 2015/08/27 21:21:46]

We do special case on sample size == 1 by using the native codec (see line 222).
 However, we'll need to revisit this again on gif (because the call on line 222
will not work on interlaced gifs).  This call works on upside down bmps kind of
accidentally.  SkBmpCodec::decodeRows() reverses the rows for you if it is
bottom up (which is how getPixels() uses it).

[scroggo, 2015/08/28 13:28:47]

Oh, that's even better!

+    // Get the first coordinate that we want to keep
+    int startCoord = GetStartCoord(sampleFactor);
+
+    // Return false on edge cases
+    if (srcCoord < startCoord ||
+            SkScaledCodec::GetDstCoord(srcCoord, sampleFactor) >= scaledDim) {
+        return false;
+    }
+
+    // Every sampleFactor rows are necessary
+    return ((srcCoord - startCoord) % sampleFactor) == 0;
+}
+
 // calculates sampleSize in x and y direction
 void SkScaledCodec::ComputeSampleSize(const SkImageInfo& dstInfo, const SkImageInfo& srcInfo,
                                       int* sampleXPtr, int* sampleYPtr) {
     int srcWidth = srcInfo.width();
     int dstWidth = dstInfo.width();
     int srcHeight = srcInfo.height();
     int dstHeight = dstInfo.height();
 
     int sampleX = srcWidth / dstWidth;
     int sampleY = srcHeight / dstHeight;
@@ skipping 39 matching lines @@
 
     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);
-
     }
 
     if (kInvalidScale != result) {
         // no scaling requested
         return result;
     }
     
     // scaling requested
     int sampleX;
     int sampleY;
     if (!scaling_supported(requestedInfo, fScanlineDecoder->getInfo(), &sampleX, &sampleY)) {
         return kInvalidScale;
     }
     // set first sample pixel in y direction
-    int Y0 = sampleY >> 1;
+    int Y0 = SkScaledCodec::GetStartCoord(sampleY);
 
     int dstHeight = requestedInfo.height();
     int srcHeight = fScanlineDecoder->getInfo().height();
     
     SkImageInfo info = requestedInfo;
     // use original height as scanlineDecoder does not support y sampling natively
     info = info.makeWH(requestedInfo.width(), srcHeight);
 
     // update scanlineDecoder with new info
     result = fScanlineDecoder->start(info, &options, ctable, ctableCount);
     if (kSuccess != result) {
         return result;
     }
-    
-    const bool requiresPostYSampling = fScanlineDecoder->requiresPostYSampling();
 
-    if (requiresPostYSampling) {
-        SkAutoMalloc storage(srcHeight * rowBytes);
-        uint8_t* storagePtr = static_cast<uint8_t*>(storage.get());
-        result = fScanlineDecoder->getScanlines(storagePtr, srcHeight, rowBytes);
-        if (kSuccess != result) {
-            return result;
+    switch(fScanlineDecoder->getScanlineOrder()) {
+        case SkScanlineDecoder::kTopDown_SkScanlineOrder: {
+            result = fScanlineDecoder->skipScanlines(Y0);
+            if (kSuccess != result && kIncompleteInput != result) {
+                return result;
+            }
+            for (int y = 0; y < dstHeight; y++) {
+                result = fScanlineDecoder->getScanlines(dst, 1, rowBytes);
+                if (kSuccess != result && kIncompleteInput != result) {
+                    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;
         }
-        storagePtr += Y0 * rowBytes;
-        for (int y = 0; y < dstHeight; y++) {
-            memcpy(dst, storagePtr, rowBytes);
-            storagePtr += sampleY * rowBytes;
-            dst = SkTAddOffset<void>(dst, rowBytes);
+        case SkScanlineDecoder::kOutOfOrder_SkScanlineOrder: {
+            for (int y = 0; y < srcHeight; y++) {
+                int srcY = fScanlineDecoder->getY();
+                if (SkScaledCodec::IsCoordNecessary(srcY, sampleY, dstHeight)) {
+                    void* dstPtr = SkTAddOffset<void>(dst,
+                            rowBytes * SkScaledCodec::GetDstCoord(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;
         }
-    } else {
-        // does not require post y sampling
-        result = fScanlineDecoder->skipScanlines(Y0);
-        if (kSuccess != result) {
-            return result;
-        }
-        for (int y = 0; y < dstHeight; y++) {
-            result = fScanlineDecoder->getScanlines(dst, 1, rowBytes);
+        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) {
                 return result;
             }
-            if (y < dstHeight - 1) {
-                result = fScanlineDecoder->skipScanlines(sampleY - 1);
-                if (kSuccess != 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);
             }
-            dst = SkTAddOffset<void>(dst, rowBytes);
+            return kSuccess;
         }
+        default:
+            SkASSERT(false);
+            return kUnimplemented;
     }
-    return kSuccess;
 }