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())) {
         return fDecoderMgr->returnFailure("setjmp", kInvalidInput);
     }
 
     // Check if we can decode to the requested destination and set the output color space
     if (!this->setOutputColorSpace(dstInfo)) {
         return fDecoderMgr->returnFailure("conversion_possible", kInvalidConversion);
     }
+    fDstInfo = dstInfo;
 
     // Now, given valid output dimensions, we can start the decompress
     if (!jpeg_start_decompress(dinfo)) {
         return fDecoderMgr->returnFailure("startDecompress", kInvalidInput);
     }
 
     // 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);
         return fSwizzler;
     }
 
-    const SkImageInfo& info = this->dstInfo();
     SkSwizzler::SrcConfig srcConfig;
-    switch (info.colorType()) {
+    switch (fDstInfo.colorType()) {
         case kGray_8_SkColorType:
             srcConfig = SkSwizzler::kGray;
             break;
         case kRGBA_8888_SkColorType:
             srcConfig = SkSwizzler::kRGBX;
             break;
         case kBGRA_8888_SkColorType:
             srcConfig = SkSwizzler::kBGRX;
             break;
         case kRGB_565_SkColorType:
             srcConfig = SkSwizzler::kRGB_565;
             break;
         default:
             // This function should only be called if the colorType is supported by jpeg
             SkASSERT(false);
     }
 
-    fSwizzler.reset(SkSwizzler::CreateSwizzler(srcConfig, nullptr, info,
+    fSwizzler.reset(SkSwizzler::CreateSwizzler(srcConfig, nullptr, fDstInfo,

[scroggo, 2015/10/07 16:04:24]

After SkScaledCodec calls this, it will modify the swizzler (that's the only
reason we call it, right?), so fDstInfo will no longer apply to the output,
right?

[msarett, 2015/10/07 17:40:41]

That's correct.

The point of fDstInfo was to ensure that we always created a swizzler with a
valid width, even when calling onGetPixels().

Patch Set 11 uses a better approach though.

                                                this->options().fZeroInitialized));
     if (!fSwizzler) {
         return nullptr;
     }
 
     fStorage.reset(get_row_bytes(fDecoderMgr->dinfo()));
     fSrcRow = static_cast<uint8_t*>(fStorage.get());
     return fSwizzler;
 }
 
 SkCodec::Result SkJpegCodec::onStartScanlineDecode(const SkImageInfo& dstInfo,
         const Options& options, SkPMColor ctable[], int* ctableCount) {
     // Set the jump location for libjpeg errors
     if (setjmp(fDecoderMgr->getJmpBuf())) {
         SkCodecPrintf("setjmp: Error from libjpeg\n");
         return kInvalidInput;
     }
 
     // Check if we can decode to the requested destination and set the output color space
     if (!this->setOutputColorSpace(dstInfo)) {
         return kInvalidConversion;
     }
 
     // Remove objects used for sampling.
     fSwizzler.reset(nullptr);
     fSrcRow = nullptr;
     fStorage.free();
+    fDstInfo = dstInfo;
 
     // 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);
     }
 
-    jpeg_skip_scanlines(fDecoderMgr->dinfo(), count);
-
-    return kSuccess;
+    return count == jpeg_skip_scanlines(fDecoderMgr->dinfo(), count);
 }
-