Merge SkCodec with SkScanlineDecoder

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"
 #include "SkWebpCodec.h"
 
 
 SkCodec* SkScaledCodec::NewFromStream(SkStream* stream) {
     bool isWebp = SkWebpCodec::IsWebp(stream);
     if (!stream->rewind()) {
         return nullptr;
     }
     if (isWebp) {
         // Webp codec supports scaling and subsetting natively
         return SkWebpCodec::NewFromStream(stream);  
     }
 
-    SkAutoTDelete<SkScanlineDecoder> scanlineDecoder(SkScanlineDecoder::NewFromStream(stream));
-    if (nullptr == scanlineDecoder) {
+    SkAutoTDelete<SkCodec> codec(SkCodec::NewFromStream(stream));
+    if (nullptr == codec) {
         return nullptr;
     }
 
     // wrap in new SkScaledCodec
-    return new SkScaledCodec(scanlineDecoder.detach());
+    return new SkScaledCodec(codec.detach());
 }
 
 SkCodec* SkScaledCodec::NewFromData(SkData* data) {
     if (!data) {
         return nullptr;
     }
     return NewFromStream(new SkMemoryStream(data));
 }
 
-SkScaledCodec::SkScaledCodec(SkScanlineDecoder* scanlineDecoder)
-    : INHERITED(scanlineDecoder->getInfo(), nullptr)
-    , fScanlineDecoder(scanlineDecoder)
+SkScaledCodec::SkScaledCodec(SkCodec* codec)
+    : INHERITED(codec->getInfo(), nullptr)
+    , fCodec(codec)
 {}
 
 SkScaledCodec::~SkScaledCodec() {}
 
 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;
     }
@@ skipping 18 matching lines @@
 
     // return dimensions closest to ideal dimensions.
     // If the differences are equal, return nativeDims, as native scaling is more efficient.
     return nativeDiff > scaledCodecDiff ? scaledCodecDims : nativeDims;
 }
 
 /*
  * Return a valid set of output dimensions for this decoder, given an input scale
  */
 SkISize SkScaledCodec::onGetScaledDimensions(float desiredScale) const {
-    SkISize nativeDimensions = fScanlineDecoder->getScaledDimensions(desiredScale);
+    SkISize nativeDimensions = fCodec->getScaledDimensions(desiredScale);
     // 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();
+        scaledCodecDimensions = fCodec->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.0f / desiredScale) + 0.5f);
 
     int scaledWidth = get_scaled_dimension(this->getInfo().width(), sampleSize);
     int scaledHeight = get_scaled_dimension(this->getInfo().height(), sampleSize);
 
     // Return the calculated output dimensions for the given scale
     scaledCodecDimensions = SkISize::Make(scaledWidth, scaledHeight);
@@ skipping 81 matching lines @@
 
 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);
+    Result result = fCodec->start(requestedInfo, &options, ctable, ctableCount);
     if (kSuccess == result) {
         // native decode supported
-        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: {
+        switch (fCodec->getScanlineOrder()) {
+            case SkCodec::kTopDown_SkScanlineOrder:
+            case SkCodec::kBottomUp_SkScanlineOrder:
+            case SkCodec::kNone_SkScanlineOrder:
+                return fCodec->getScanlines(dst, requestedInfo.height(), rowBytes);
+            case SkCodec::kOutOfOrder_SkScanlineOrder: {
                 for (int y = 0; y < requestedInfo.height(); y++) {
-                    int dstY = fScanlineDecoder->getY();
+                    int dstY = fCodec->getY();
                     void* dstPtr = SkTAddOffset<void>(dst, rowBytes * dstY);
-                    result = fScanlineDecoder->getScanlines(dstPtr, 1, rowBytes);
+                    result = fCodec->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;
-    if (!scaling_supported(requestedInfo, fScanlineDecoder->getInfo(), &sampleX, &sampleY)) {
+    if (!scaling_supported(requestedInfo, fCodec->getInfo(), &sampleX, &sampleY)) {
         return kInvalidScale;
     }
     // set first sample pixel in y direction
     int Y0 = get_start_coord(sampleY);
 
     int dstHeight = requestedInfo.height();
-    int srcHeight = fScanlineDecoder->getInfo().height();
+    int srcHeight = fCodec->getInfo().height();
     
     SkImageInfo info = requestedInfo;
-    // use original height as scanlineDecoder does not support y sampling natively
+    // use original height as codec does not support y sampling natively
     info = info.makeWH(requestedInfo.width(), srcHeight);
 
-    // update scanlineDecoder with new info
-    result = fScanlineDecoder->start(info, &options, ctable, ctableCount);
+    // update codec with new info
+    result = fCodec->start(info, &options, ctable, ctableCount);
     if (kSuccess != result) {
         return result;
     }
 
-    switch(fScanlineDecoder->getScanlineOrder()) {
-        case SkScanlineDecoder::kTopDown_SkScanlineOrder: {
-            result = fScanlineDecoder->skipScanlines(Y0);
+    switch(fCodec->getScanlineOrder()) {
+        case SkCodec::kTopDown_SkScanlineOrder: {
+            result = fCodec->skipScanlines(Y0);
             if (kSuccess != result && kIncompleteInput != result) {
                 return result;
             }
             for (int y = 0; y < dstHeight; y++) {
-                result = fScanlineDecoder->getScanlines(dst, 1, rowBytes);
+                result = fCodec->getScanlines(dst, 1, rowBytes);
                 if (kSuccess != result && kIncompleteInput != result) {
                     return result;
                 }
                 if (y < dstHeight - 1) {
-                    result = fScanlineDecoder->skipScanlines(sampleY - 1);
+                    result = fCodec->skipScanlines(sampleY - 1);
                     if (kSuccess != result && kIncompleteInput != result) {
                         return result;
                     }
                 }
                 dst = SkTAddOffset<void>(dst, rowBytes);
             }
             return result;
         }
-        case SkScanlineDecoder::kBottomUp_SkScanlineOrder:
-        case SkScanlineDecoder::kOutOfOrder_SkScanlineOrder: {
+        case SkCodec::kBottomUp_SkScanlineOrder:
+        case SkCodec::kOutOfOrder_SkScanlineOrder: {
             for (int y = 0; y < srcHeight; y++) {
-                int srcY = fScanlineDecoder->getY();
+                int srcY = fCodec->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);
+                    result = fCodec->getScanlines(dstPtr, 1, rowBytes);
                     if (kSuccess != result && kIncompleteInput != result) {
                         return result;
                     }
                 } else {
-                    result = fScanlineDecoder->skipScanlines(1);
+                    result = fCodec->skipScanlines(1);
                     if (kSuccess != result && kIncompleteInput != result) {
                         return result;
                     }
                 }
             }
             return result;
         }
-        case SkScanlineDecoder::kNone_SkScanlineOrder: {
+        case SkCodec::kNone_SkScanlineOrder: {
             SkAutoMalloc storage(srcHeight * rowBytes);
             uint8_t* storagePtr = static_cast<uint8_t*>(storage.get());
-            result = fScanlineDecoder->getScanlines(storagePtr, srcHeight, rowBytes);
+            result = fCodec->getScanlines(storagePtr, srcHeight, rowBytes);
             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 result;
         }
         default:
             SkASSERT(false);
             return kUnimplemented;
     }
 }