Fill incomplete images in SkCodec parent class

src/codec/SkJpegCodec.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 "SkCodec.h"
 #include "SkJpegCodec.h"
 #include "SkJpegDecoderMgr.h"
@@ skipping 307 matching lines @@
     fDecoderMgr->dinfo()->scale_num = num;
     fDecoderMgr->dinfo()->scale_denom = denom;
     return true;
 }
 
 /*
  * Performs the jpeg decode
  */
 SkCodec::Result SkJpegCodec::onGetPixels(const SkImageInfo& dstInfo,
                                          void* dst, size_t dstRowBytes,
-                                         const Options& options, SkPMColor*, int*) {
+                                         const Options& options, SkPMColor*, int*,
+                                         int* rowsDecoded) {
     if (options.fSubset) {
         // Subsets are not supported.
         return kUnimplemented;
     }
 
     // Get a pointer to the decompress info since we will use it quite frequently
     jpeg_decompress_struct* dinfo = fDecoderMgr->dinfo();
 
     // Set the jump location for libjpeg errors
     if (setjmp(fDecoderMgr->getJmpBuf())) {
@@ skipping 12 matching lines @@
 
     // The recommended output buffer height should always be 1 in high quality modes.
     // If it's not, we want to know because it means our strategy is not optimal.
     SkASSERT(1 == dinfo->rec_outbuf_height);
 
     // Perform the decode a single row at a time
     uint32_t dstHeight = dstInfo.height();
     JSAMPLE* dstRow = (JSAMPLE*) dst;
     for (uint32_t y = 0; y < dstHeight; y++) {
         // Read rows of the image
-        uint32_t rowsDecoded = jpeg_read_scanlines(dinfo, &dstRow, 1);
+        uint32_t lines = jpeg_read_scanlines(dinfo, &dstRow, 1);
 
         // If we cannot read enough rows, assume the input is incomplete
-        if (rowsDecoded != 1) {
-            // Fill the remainder of the image with black. This error handling
-            // behavior is unspecified but SkCodec consistently uses black as
-            // the fill color for opaque images.  If the destination is kGray,
-            // the low 8 bits of SK_ColorBLACK will be used.  Conveniently,
-            // these are zeros, which is the representation for black in kGray.
-            // If the destination is kRGB_565, the low 16 bits of SK_ColorBLACK
-            // will be used.  Conveniently, these are zeros, which is the
-            // representation for black in kRGB_565.
-            SkSwizzler::Fill(dstRow, dstInfo, dstRowBytes, dstHeight - y,
-                    SK_ColorBLACK, nullptr, options.fZeroInitialized);
+        if (lines != 1) {
+            *rowsDecoded = y;
 
             return fDecoderMgr->returnFailure("Incomplete image data", kIncompleteInput);
         }
 
         // Convert to RGBA if necessary
         if (JCS_CMYK == dinfo->out_color_space) {
             convert_CMYK_to_RGBA(dstRow, dstInfo.width());
         }
 
         // Move to the next row
         dstRow = SkTAddOffset<JSAMPLE>(dstRow, dstRowBytes);
     }
 
     return kSuccess;
 }
 
-SkSampler* SkJpegCodec::getSampler() {
-    if (fSwizzler) {
-        SkASSERT(fSrcRow && static_cast<uint8_t*>(fStorage.get()) == fSrcRow);
+SkSampler* SkJpegCodec::getSampler(bool createIfNecessary) {
+    if (!createIfNecessary || fSwizzler) {
+        SkASSERT(!fSwizzler || (fSrcRow && static_cast<uint8_t*>(fStorage.get()) == fSrcRow));
         return fSwizzler;
     }
 
     const SkImageInfo& info = this->dstInfo();
     SkSwizzler::SrcConfig srcConfig;
     switch (info.colorType()) {
         case kGray_8_SkColorType:
             srcConfig = SkSwizzler::kGray;
             break;
         case kRGBA_8888_SkColorType:
@@ skipping 41 matching lines @@
 
     // Now, given valid output dimensions, we can start the decompress
     if (!jpeg_start_decompress(fDecoderMgr->dinfo())) {
         SkCodecPrintf("start decompress failed\n");
         return kInvalidInput;
     }
 
     return kSuccess;
 }
 
-SkCodec::Result SkJpegCodec::onGetScanlines(void* dst, int count, size_t rowBytes) {
+int SkJpegCodec::onGetScanlines(void* dst, int count, size_t rowBytes) {
     // Set the jump location for libjpeg errors
     if (setjmp(fDecoderMgr->getJmpBuf())) {
         return fDecoderMgr->returnFailure("setjmp", kInvalidInput);
     }
     // Read rows one at a time
     JSAMPLE* dstRow;
     if (fSwizzler) {
         // write data to storage row, then sample using swizzler         
         dstRow = fSrcRow;
     } else {
         // write data directly to dst
         dstRow = (JSAMPLE*) dst;
     }
 
     for (int y = 0; y < count; y++) {
         // Read row of the image
         uint32_t rowsDecoded = jpeg_read_scanlines(fDecoderMgr->dinfo(), &dstRow, 1);
         if (rowsDecoded != 1) {
-            SkSwizzler::Fill(dstRow, this->dstInfo(), rowBytes, count - y,
-                        SK_ColorBLACK, nullptr, this->options().fZeroInitialized);
             fDecoderMgr->dinfo()->output_scanline = this->dstInfo().height();
-            return kIncompleteInput;
+            return y;
         }
 
         // Convert to RGBA if necessary
         if (JCS_CMYK == fDecoderMgr->dinfo()->out_color_space) {
             convert_CMYK_to_RGBA(dstRow, fDecoderMgr->dinfo()->output_width);
         }
 
         if(fSwizzler) {
             // use swizzler to sample row
             fSwizzler->swizzle(dst, dstRow);
             dst = SkTAddOffset<JSAMPLE>(dst, rowBytes);
         } else {
             dstRow = SkTAddOffset<JSAMPLE>(dstRow, rowBytes);
         }
     }
-    return kSuccess;
+    return count;
 }
 
 #ifndef TURBO_HAS_SKIP
 // TODO (msarett): Make this a member function and avoid reallocating the
 //                 memory buffer on each call to skip.
 #define jpeg_skip_scanlines(dinfo, count)                                    \
     SkAutoMalloc storage(get_row_bytes(dinfo));                              \
     uint8_t* storagePtr = static_cast<uint8_t*>(storage.get());              \
     for (int y = 0; y < count; y++) {                                        \
         jpeg_read_scanlines(dinfo, &storagePtr, 1);                          \
     }
 #endif
 
-SkCodec::Result SkJpegCodec::onSkipScanlines(int count) {
+bool SkJpegCodec::onSkipScanlines(int count) {
     // Set the jump location for libjpeg errors
     if (setjmp(fDecoderMgr->getJmpBuf())) {
-        return fDecoderMgr->returnFailure("setjmp", kInvalidInput);
+        return fDecoderMgr->returnFalse("setjmp");
     }
 
-    jpeg_skip_scanlines(fDecoderMgr->dinfo(), count);
-
-    return kSuccess;
+    return count == jpeg_skip_scanlines(fDecoderMgr->dinfo(), count);
 }
-