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 285 matching lines @@
         jpeg_calc_output_dimensions(fDecoderMgr->dinfo());
     }
     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* incompleteScanlines) {
     // Rewind the stream if needed
     if (!this->rewindIfNeeded()) {
         return fDecoderMgr->returnFailure("could not rewind stream", kCouldNotRewind);
     }
 
     if (options.fSubset) {
         // Subsets are not supported.
         return kUnimplemented;
     }
 
@@ skipping 26 matching lines @@
 
     // 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);
 
         // 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);
+            *incompleteScanlines = dstHeight - y;
 
             // Prevent libjpeg from failing on incomplete decode
             dinfo->output_scanline = dstHeight;
 
             // Finish the decode and indicate that the input was incomplete.
             jpeg_finish_decompress(dinfo);
             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);
     }
     jpeg_finish_decompress(dinfo);
 
     return kSuccess;
 }
 
 /*
  * Enable scanline decoding for jpegs
  */
 class SkJpegScanlineDecoder : public SkScanlineDecoder {
 public:
-    SkJpegScanlineDecoder(const SkImageInfo& srcInfo, SkJpegCodec* codec)
-        : INHERITED(srcInfo)
+    SkJpegScanlineDecoder(SkJpegCodec* codec)
+        : INHERITED(codec, codec->getInfo())
         , fCodec(codec)
         , fOpts()
     {}
 
     /*
     * Return a valid set of output dimensions for this decoder, given an input scale
     */  
     SkISize onGetScaledDimensions(float desiredScale) override {
         return fCodec->onGetScaledDimensions(desiredScale);
     }
@@ skipping 16 matching lines @@
                 srcConfig = SkSwizzler::kBGRX;
                 break;
             case kRGB_565_SkColorType:
                 srcConfig = SkSwizzler::kRGB_565;
                 break;
             default:
                 //would have exited before now if the colorType was supported by jpeg
                 SkASSERT(false);
         }
 
-        fSwizzler.reset(SkSwizzler::CreateSwizzler(srcConfig, nullptr, info, options.fZeroInitialized, 
-                                                   this->getInfo()));
+        fSwizzler.reset(SkSwizzler::CreateSwizzler(srcConfig, nullptr, info,
+                options.fZeroInitialized, this->getInfo()));
         if (!fSwizzler) {
             // FIXME: CreateSwizzler could fail for another reason.
             return SkCodec::kUnimplemented;
         }
         return SkCodec::kSuccess;
     }
 
     SkCodec::Result onStart(const SkImageInfo& dstInfo, const SkCodec::Options& options,
                             SkPMColor ctable[], int* ctableCount) override {
 
@@ skipping 49 matching lines @@
             SkCodecPrintf("setjmp: Error in libjpeg finish_decompress\n");
             return;
         }
 
         // We may not have decoded the entire image.  Prevent libjpeg-turbo from failing on a
         // partial decode.
         fCodec->fDecoderMgr->dinfo()->output_scanline = fCodec->getInfo().height();
         jpeg_finish_decompress(fCodec->fDecoderMgr->dinfo());
     }
 
-    SkCodec::Result onGetScanlines(void* dst, int count, size_t rowBytes) override {
+    uint32_t onGetScanlines(void* dst, int count, size_t rowBytes) override {
         // Set the jump location for libjpeg errors
         if (setjmp(fCodec->fDecoderMgr->getJmpBuf())) {
             return fCodec->fDecoderMgr->returnFailure("setjmp", SkCodec::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(fCodec->fDecoderMgr->dinfo(), &dstRow, 1);
             if (rowsDecoded != 1) {
-                SkSwizzler::Fill(dstRow, this->dstInfo(), rowBytes, count - y,
-                        SK_ColorBLACK, nullptr, fOpts.fZeroInitialized);
                 fCodec->fDecoderMgr->dinfo()->output_scanline = this->dstInfo().height();
-                return SkCodec::kIncompleteInput;
+                return y;
             }
 
             // Convert to RGBA if necessary
             if (JCS_CMYK == fCodec->fDecoderMgr->dinfo()->out_color_space) {
                 convert_CMYK_to_RGBA(dstRow, fCodec->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 SkCodec::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 onSkipScanlines(int count) override {
+    uint32_t onSkipScanlines(int count) override {
         // Set the jump location for libjpeg errors
         if (setjmp(fCodec->fDecoderMgr->getJmpBuf())) {
             return fCodec->fDecoderMgr->returnFailure("setjmp", SkCodec::kInvalidInput);
         }
 
-        jpeg_skip_scanlines(fCodec->fDecoderMgr->dinfo(), count);
-
-        return SkCodec::kSuccess;
+        return jpeg_skip_scanlines(fCodec->fDecoderMgr->dinfo(), count);
     }
 
     SkEncodedFormat onGetEncodedFormat() const override {
         return kJPEG_SkEncodedFormat;
     }
 
 private:
-    SkAutoTDelete<SkJpegCodec> fCodec;
+    SkJpegCodec*               fCodec;      // Owned by parent class
     SkAutoMalloc               fStorage;    // Only used if sampling is needed
     uint8_t*                   fSrcRow;     // Only used if sampling is needed
     SkCodec::Options           fOpts;
     SkAutoTDelete<SkSwizzler>  fSwizzler;
 
     typedef SkScanlineDecoder INHERITED;
 };
 
 SkScanlineDecoder* SkJpegCodec::NewSDFromStream(SkStream* stream) {
     SkAutoTDelete<SkJpegCodec> codec(static_cast<SkJpegCodec*>(SkJpegCodec::NewFromStream(stream)));
     if (!codec) {
         return nullptr;
     }
 
-    const SkImageInfo& srcInfo = codec->getInfo();
-
     // Return the new scanline decoder
-    return new SkJpegScanlineDecoder(srcInfo, codec.detach());
+    return new SkJpegScanlineDecoder(codec.detach());
 }