Merge SkCodec with SkScanlineDecoder

dm/DMSrcSink.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 "DMSrcSink.h"
 #include "SamplePipeControllers.h"
 #include "SkCodec.h"
 #include "SkCommonFlags.h"
 #include "SkData.h"
 #include "SkDocument.h"
 #include "SkError.h"
 #include "SkFunction.h"
 #include "SkImageGenerator.h"
 #include "SkMultiPictureDraw.h"
 #include "SkNullCanvas.h"
 #include "SkOSFile.h"
 #include "SkPictureData.h"
 #include "SkPictureRecorder.h"
 #include "SkRandom.h"
 #include "SkRecordDraw.h"
 #include "SkRecorder.h"
 #include "SkSVGCanvas.h"
-#include "SkScanlineDecoder.h"
 #include "SkStream.h"
 #include "SkXMLWriter.h"
 #include "SkScaledCodec.h"
 
 DEFINE_bool(multiPage, false, "For document-type backends, render the source"
             " into multiple pages");
 
 static bool lazy_decode_bitmap(const void* src, size_t size, SkBitmap* dst) {
     SkAutoTUnref<SkData> encoded(SkData::NewWithCopy(src, size));
     return encoded && SkInstallDiscardablePixelRef(encoded, dst);
@@ skipping 192 matching lines @@
 {}
 
 bool CodecSrc::veto(SinkFlags flags) const {
     // No need to test decoding to non-raster or indirect backend.
     // TODO: Once we implement GPU paths (e.g. JPEG YUV), we should use a deferred decode to
     // let the GPU handle it.
     return flags.type != SinkFlags::kRaster
         || flags.approach != SinkFlags::kDirect;
 }
 
-SkScanlineDecoder* start_scanline_decoder(SkData* encoded, const SkImageInfo& info,
-        SkPMColor* colorPtr, int* colorCountPtr) {
-    SkAutoTDelete<SkScanlineDecoder> scanlineDecoder(SkScanlineDecoder::NewFromData(encoded));
-    if (nullptr == scanlineDecoder) {
-        return nullptr;
-    }
-    if (SkCodec::kSuccess != scanlineDecoder->start(info, NULL, colorPtr, colorCountPtr)) {
-        return nullptr;
-    }
-    return scanlineDecoder.detach();
-}
-
 Error CodecSrc::draw(SkCanvas* canvas) const {
     SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(fPath.c_str()));
     if (!encoded) {
         return SkStringPrintf("Couldn't read %s.", fPath.c_str());
     }
     SkAutoTDelete<SkCodec> codec(NULL);
     if (kScaledCodec_Mode == fMode) {
         codec.reset(SkScaledCodec::NewFromData(encoded));
         // TODO (msarett): This should fall through to a fatal error once we support scaled
         //                 codecs for all image types.
@@ skipping 78 matching lines @@
                 case SkCodec::kInvalidConversion:
                     return Error::Nonfatal("Incompatible colortype conversion");
                 default:
                     // Everything else is considered a failure.
                     return SkStringPrintf("Couldn't getPixels %s.", fPath.c_str());
             }
             canvas->drawBitmap(bitmap, 0, 0);
             break;
         }
         case kScanline_Mode: {
-            SkAutoTDelete<SkScanlineDecoder> scanlineDecoder(
-                    start_scanline_decoder(encoded.get(), decodeInfo, colorPtr, colorCountPtr));
-            if (nullptr == scanlineDecoder) {
+            if (SkCodec::kSuccess != codec->startScanlineDecode(decodeInfo, NULL, colorPtr,
+                                                                colorCountPtr)) {
                 return Error::Nonfatal("Could not start scanline decoder");
             }
 
             SkCodec::Result result = SkCodec::kUnimplemented;
-            switch (scanlineDecoder->getScanlineOrder()) {
-                case SkScanlineDecoder::kTopDown_SkScanlineOrder:
-                case SkScanlineDecoder::kBottomUp_SkScanlineOrder:
-                case SkScanlineDecoder::kNone_SkScanlineOrder:
-                    result = scanlineDecoder->getScanlines(bitmap.getAddr(0, 0),
+            switch (codec->getScanlineOrder()) {
+                case SkCodec::kTopDown_SkScanlineOrder:
+                case SkCodec::kBottomUp_SkScanlineOrder:
+                case SkCodec::kNone_SkScanlineOrder:
+                    result = codec->getScanlines(bitmap.getAddr(0, 0),
                             decodeInfo.height(), bitmap.rowBytes());
                     break;
-                case SkScanlineDecoder::kOutOfOrder_SkScanlineOrder: {
+                case SkCodec::kOutOfOrder_SkScanlineOrder: {
                     for (int y = 0; y < decodeInfo.height(); y++) {
-                        int dstY = scanlineDecoder->getY();
+                        int dstY = codec->nextScanline();
                         void* dstPtr = bitmap.getAddr(0, dstY);
-                        result = scanlineDecoder->getScanlines(dstPtr, 1, bitmap.rowBytes());
+                        result = codec->getScanlines(dstPtr, 1, bitmap.rowBytes());
                         if (SkCodec::kSuccess != result && SkCodec::kIncompleteInput != result) {
                             return SkStringPrintf("%s failed with error message %d",
                                                   fPath.c_str(), (int) result);
                         }
                     }
                     break;
                 }
             }
 
             switch (result) {
@@ skipping 45 matching lines @@
                 //currentSubsetWidth may be larger than subsetWidth for rightmost subsets
                 const int currentSubsetWidth = (col + 1 == divisor) ?
                         subsetWidth + extraX : subsetWidth;
                 const int x = col * subsetWidth;
                 for (int row = 0; row < divisor; row++) {
                     //currentSubsetHeight may be larger than subsetHeight for bottom subsets
                     const int currentSubsetHeight = (row + 1 == divisor) ?
                             subsetHeight + extraY : subsetHeight;
                     const int y = row * subsetHeight;
                     //create scanline decoder for each subset
-                    SkAutoTDelete<SkScanlineDecoder> decoder(start_scanline_decoder(encoded.get(),
-                            decodeInfo, colorPtr, colorCountPtr));
-                    // TODO (msarett): Support this mode for all scanline orderings.
-                    if (nullptr == decoder || SkScanlineDecoder::kTopDown_SkScanlineOrder !=
-                            decoder->getScanlineOrder()) {
+                    if (SkCodec::kSuccess != codec->startScanlineDecode(decodeInfo, NULL, colorPtr,
+                                                                        colorCountPtr)
+                            // TODO (msarett): Support this mode for all scanline orderings.
+                            || SkCodec::kTopDown_SkScanlineOrder != codec->getScanlineOrder()) {
                         if (x == 0 && y == 0) {
                             //first try, image may not be compatible
                             return Error::Nonfatal("Could not start top-down scanline decoder");
                         } else {
                             return "Error scanline decoder is nullptr";
                         }
                     }
                     //skip to first line of subset
-                    const SkCodec::Result skipResult = decoder->skipScanlines(y);
+                    const SkCodec::Result skipResult = codec->skipScanlines(y);
                     switch (skipResult) {
                         case SkCodec::kSuccess:
                         case SkCodec::kIncompleteInput:
                             break;
                         default:
                             return SkStringPrintf("%s failed after attempting to skip %d scanlines"
                                     "with error message %d", fPath.c_str(), y, (int) skipResult);
                     }
                     //create and set size of subsetBm
                     SkBitmap subsetBm;
                     SkIRect bounds = SkIRect::MakeWH(subsetWidth, subsetHeight);
                     bounds.setXYWH(0, 0, currentSubsetWidth, currentSubsetHeight);
                     SkAssertResult(largestSubsetBm.extractSubset(&subsetBm, bounds));
                     SkAutoLockPixels autlockSubsetBm(subsetBm, true);
                     const SkCodec::Result subsetResult =
-                            decoder->getScanlines(buffer, currentSubsetHeight, rowBytes);
+                            codec->getScanlines(buffer, currentSubsetHeight, rowBytes);
                     switch (subsetResult) {
                         case SkCodec::kSuccess:
                         case SkCodec::kIncompleteInput:
                             break;
                         default:
                             return SkStringPrintf("%s failed with error message %d",
                                     fPath.c_str(), (int) subsetResult);
                     }
                     const size_t bpp = decodeInfo.bytesPerPixel();
                     /*
@@ skipping 19 matching lines @@
             break;
         }
         case kStripe_Mode: {
             const int height = decodeInfo.height();
             // This value is chosen arbitrarily.  We exercise more cases by choosing a value that
             // does not align with image blocks.
             const int stripeHeight = 37;
             const int numStripes = (height + stripeHeight - 1) / stripeHeight;
 
             // Decode odd stripes
-            SkAutoTDelete<SkScanlineDecoder> decoder(
-                    start_scanline_decoder(encoded.get(), decodeInfo, colorPtr, colorCountPtr));
-            if (nullptr == decoder ||
-                    SkScanlineDecoder::kTopDown_SkScanlineOrder != decoder->getScanlineOrder()) {
+            if (SkCodec::kSuccess != codec->startScanlineDecode(decodeInfo, NULL, colorPtr,
+                                                                colorCountPtr)
+                    || SkCodec::kTopDown_SkScanlineOrder != codec->getScanlineOrder()) {
                 // This mode was designed to test the new skip scanlines API in libjpeg-turbo.
                 // Jpegs have kTopDown_SkScanlineOrder, and at this time, it is not interesting
                 // to run this test for image types that do not have this scanline ordering.
                 return Error::Nonfatal("Could not start top-down scanline decoder");
             }
             for (int i = 0; i < numStripes; i += 2) {
                 // Skip a stripe
                 const int linesToSkip = SkTMin(stripeHeight, height - i * stripeHeight);
-                SkCodec::Result result = decoder->skipScanlines(linesToSkip);
+                SkCodec::Result result = codec->skipScanlines(linesToSkip);
                 switch (result) {
                     case SkCodec::kSuccess:
                     case SkCodec::kIncompleteInput:
                         break;
                     default:
                         return SkStringPrintf("Cannot skip scanlines for %s.", fPath.c_str());
                 }
 
                 // Read a stripe
                 const int startY = (i + 1) * stripeHeight;
                 const int linesToRead = SkTMin(stripeHeight, height - startY);
                 if (linesToRead > 0) {
-                    result = decoder->getScanlines(bitmap.getAddr(0, startY),
+                    result = codec->getScanlines(bitmap.getAddr(0, startY),
                             linesToRead, bitmap.rowBytes());
                     switch (result) {
                         case SkCodec::kSuccess:
                         case SkCodec::kIncompleteInput:
                             break;
                         default:
                             return SkStringPrintf("Cannot get scanlines for %s.", fPath.c_str());
                     }
                 }
             }
 
             // Decode even stripes
-            const SkCodec::Result startResult = decoder->start(decodeInfo, nullptr, colorPtr,
-                                                               colorCountPtr);
+            const SkCodec::Result startResult = codec->startScanlineDecode(decodeInfo, nullptr,
+                    colorPtr, colorCountPtr);
             if (SkCodec::kSuccess != startResult) {
                 return "Failed to restart scanline decoder with same parameters.";
             }
             for (int i = 0; i < numStripes; i += 2) {
                 // Read a stripe
                 const int startY = i * stripeHeight;
                 const int linesToRead = SkTMin(stripeHeight, height - startY);
-                SkCodec::Result result = decoder->getScanlines(bitmap.getAddr(0, startY),
+                SkCodec::Result result = codec->getScanlines(bitmap.getAddr(0, startY),
                         linesToRead, bitmap.rowBytes());
                 switch (result) {
                     case SkCodec::kSuccess:
                     case SkCodec::kIncompleteInput:
                         break;
                     default:
                         return SkStringPrintf("Cannot get scanlines for %s.", fPath.c_str());
                 }
 
                 // Skip a stripe
                 const int linesToSkip = SkTMin(stripeHeight, height - (i + 1) * stripeHeight);
                 if (linesToSkip > 0) {
-                    result = decoder->skipScanlines(linesToSkip);
+                    result = codec->skipScanlines(linesToSkip);
                     switch (result) {
                         case SkCodec::kSuccess:
                         case SkCodec::kIncompleteInput:
                             break;
                         default:
                             return SkStringPrintf("Cannot skip scanlines for %s.", fPath.c_str());
                     }
                 }
             }
             canvas->drawBitmap(bitmap, 0, 0);
@@ skipping 689 matching lines @@
             skr.visit<void>(i, drawsAsSingletonPictures);
         }
         SkAutoTUnref<SkPicture> macroPic(macroRec.endRecordingAsPicture());
 
         canvas->drawPicture(macroPic);
         return "";
     });
 }
 
 }  // namespace DM