Make SkSwizzler::Fill() support 565

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 336 matching lines @@
         // Read rows of the image
         uint32_t rowsDecoded = turbo_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.
-            SkSwizzler::Fill(dstRow, dstInfo, dstRowBytes, dstHeight - y, SK_ColorBLACK, NULL);
+            // 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.
+            if (kNo_ZeroInitialized == options.fZeroInitialized ||
+                    kN32_SkColorType == dstInfo.colorType()) {
+                SkSwizzler::Fill(dstRow, dstInfo, dstRowBytes, dstHeight - y,
+                        SK_ColorBLACK, NULL);
+            }
 
             // Prevent libjpeg from failing on incomplete decode
             dinfo->output_scanline = dstHeight;
 
             // Finish the decode and indicate that the input was incomplete.
             turbo_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);
     }
     turbo_jpeg_finish_decompress(dinfo);
 
     return kSuccess;
 }
 
 /*
  * Enable scanline decoding for jpegs
  */
 class SkJpegScanlineDecoder : public SkScanlineDecoder {
 public:
-    SkJpegScanlineDecoder(const SkImageInfo& dstInfo, SkJpegCodec* codec)
+    SkJpegScanlineDecoder(const SkImageInfo& dstInfo, SkJpegCodec* codec,
+            const SkCodec::Options& opts)
         : INHERITED(dstInfo)
         , fCodec(codec)
+        , fOpts(opts)
     {}
 
     virtual ~SkJpegScanlineDecoder() {
         if (setjmp(fCodec->fDecoderMgr->getJmpBuf())) {
             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();
         turbo_jpeg_finish_decompress(fCodec->fDecoderMgr->dinfo());
     }
 
     SkCodec::Result 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 = (JSAMPLE*) dst;
         for (int y = 0; y < count; y++) {
             // Read row of the image
             uint32_t rowsDecoded =
                     turbo_jpeg_read_scanlines(fCodec->fDecoderMgr->dinfo(), &dstRow, 1);
             if (rowsDecoded != 1) {
-                SkSwizzler::Fill(
-                        dstRow, this->dstInfo(), rowBytes, count - y, SK_ColorBLACK, NULL);
+                if (SkCodec::kNo_ZeroInitialized == fOpts.fZeroInitialized ||
+                        kN32_SkColorType == this->dstInfo().colorType()) {
+                    SkSwizzler::Fill(dstRow, this->dstInfo(), rowBytes,
+                            count - y, SK_ColorBLACK, NULL);
+                }
                 fCodec->fDecoderMgr->dinfo()->output_scanline = this->dstInfo().height();
                 return SkCodec::kIncompleteInput;
             }
 
             // Convert to RGBA if necessary
             if (JCS_CMYK == fCodec->fDecoderMgr->dinfo()->out_color_space) {
                 convert_CMYK_to_RGBA(dstRow, this->dstInfo().width());
             }
 
             // Move to the next row
@@ skipping 18 matching lines @@
             return fCodec->fDecoderMgr->returnFailure("setjmp", SkCodec::kInvalidInput);
         }
 
         turbo_jpeg_skip_scanlines(fCodec->fDecoderMgr->dinfo(), count);
 
         return SkCodec::kSuccess;
     }
 
 private:
     SkAutoTDelete<SkJpegCodec> fCodec;
+    const SkCodec::Options&    fOpts;

[scroggo, 2015/08/03 18:41:24]

I missed this when I first reviewed, but mention it in
https://codereview.chromium.org/1267583002/ (which also fixes it) - making this
a reference is not a good idea. We do not know the lifetime of the object passed
in, so we cannot be sure that the Options object we are referring to will still
exist when we need it.

We actually *do* know of an example when this does not work - if the client
called getScanlineDecoder with a NULL Options object, getScanlineDecoder puts
one on the stack and passes it to onGetScanlineDecoder. So as soon as the client
receives the JpegScanlineDecoder, the object they have is no longer valid.

 
     typedef SkScanlineDecoder INHERITED;
 };
 
 SkScanlineDecoder* SkJpegCodec::onGetScanlineDecoder(const SkImageInfo& dstInfo,
         const Options& options, SkPMColor ctable[], int* ctableCount) {
 
     // Rewind the stream if needed
     if (!this->handleRewind()) {
         SkCodecPrintf("Could not rewind\n");
@@ skipping 27 matching lines @@
         return NULL;
     }
 
     // Now, given valid output dimensions, we can start the decompress
     if (!turbo_jpeg_start_decompress(codec->fDecoderMgr->dinfo())) {
         SkCodecPrintf("start decompress failed\n");
         return NULL;
     }
 
     // Return the new scanline decoder
-    return SkNEW_ARGS(SkJpegScanlineDecoder, (dstInfo, codec.detach()));
+    return SkNEW_ARGS(SkJpegScanlineDecoder, (dstInfo, codec.detach(), options));
 }