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 115 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) {
+    // 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;
 }