Lazy SKP image decoding in DM.

src/images/SkImageDecoder_libjpeg.cpp

 /*
  * Copyright 2007 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkImageDecoder.h"
 #include "SkImageEncoder.h"
@@ skipping 750 matching lines @@
 static SkISize compute_yuv_size(const jpeg_decompress_struct& info, int component,
                                 SizeType sizeType) {
     if (sizeType == kSizeForMemoryAllocation_SizeType) {
         return SkISize::Make(info.cur_comp_info[component]->width_in_blocks * DCTSIZE,
                              info.cur_comp_info[component]->height_in_blocks * DCTSIZE);
     }
     return SkISize::Make(info.cur_comp_info[component]->downsampled_width,
                          info.cur_comp_info[component]->downsampled_height);
 }
 
+static bool appears_to_be_yuv(const jpeg_decompress_struct& info) {
+    return (info.jpeg_color_space == JCS_YCbCr)
+        && (DCTSIZE == 8)
+        && (info.num_components == 3)
+        && (info.comps_in_scan >= info.num_components)
+        && (info.scale_denom <= 8)
+        && (info.cur_comp_info[0])
+        && (info.cur_comp_info[1])
+        && (info.cur_comp_info[2])
+        && (info.cur_comp_info[1]->h_samp_factor == 1)
+        && (info.cur_comp_info[1]->v_samp_factor == 1)
+        && (info.cur_comp_info[2]->h_samp_factor == 1)
+        && (info.cur_comp_info[2]->v_samp_factor == 1);
+}
+
 static void update_components_sizes(const jpeg_decompress_struct& cinfo, SkISize componentSizes[3],
                                     SizeType sizeType) {
+    SkASSERT(appears_to_be_yuv(cinfo));
     for (int i = 0; i < 3; ++i) {
         componentSizes[i] = compute_yuv_size(cinfo, i, sizeType);
     }
 }
 
 static bool output_raw_data(jpeg_decompress_struct& cinfo, void* planes[3], size_t rowBytes[3]) {
+    SkASSERT(appears_to_be_yuv(cinfo));
     // U size and V size have to be the same if we're calling output_raw_data()
     SkISize uvSize = compute_yuv_size(cinfo, 1, kSizeForMemoryAllocation_SizeType);
     SkASSERT(uvSize == compute_yuv_size(cinfo, 2, kSizeForMemoryAllocation_SizeType));
 
     JSAMPARRAY bufferraw[3];
     JSAMPROW bufferraw2[32];
     bufferraw[0] = &bufferraw2[0]; // Y channel rows (8 or 16)
     bufferraw[1] = &bufferraw2[16]; // U channel rows (8)
     bufferraw[2] = &bufferraw2[24]; // V channel rows (8)
     int yWidth = cinfo.output_width;
@@ skipping 65 matching lines @@
 
     return true;
 }
 
 bool SkJPEGImageDecoder::onDecodeYUV8Planes(SkStream* stream, SkISize componentSizes[3],
                                             void* planes[3], size_t rowBytes[3],
                                             SkYUVColorSpace* colorSpace) {
 #ifdef TIME_DECODE
     SkAutoTime atm("JPEG YUV8 Decode");
 #endif
-
     if (this->getSampleSize() != 1) {
         return false; // Resizing not supported
     }
 
     JPEGAutoClean autoClean;
 
     jpeg_decompress_struct  cinfo;
     skjpeg_source_mgr       srcManager(stream, this);
 
     skjpeg_error_mgr errorManager;
     set_error_mgr(&cinfo, &errorManager);
 
     // All objects need to be instantiated before this setjmp call so that
     // they will be cleaned up properly if an error occurs.
     if (setjmp(errorManager.fJmpBuf)) {
         return return_false(cinfo, "setjmp YUV8");
     }
 
     initialize_info(&cinfo, &srcManager);
     autoClean.set(&cinfo);
 
     int status = jpeg_read_header(&cinfo, true);
     if (status != JPEG_HEADER_OK) {
         return return_false(cinfo, "read_header YUV8");
     }
 
-    if (cinfo.jpeg_color_space != JCS_YCbCr) {
+    if (!appears_to_be_yuv(cinfo)) {
         // It's not an error to not be encoded in YUV, so no need to use return_false()
         return false;
     }
 
     cinfo.out_color_space = JCS_YCbCr;
     cinfo.raw_data_out = TRUE;
 
     if (!planes || !planes[0] || !rowBytes || !rowBytes[0]) { // Compute size only
         update_components_sizes(cinfo, componentSizes, kSizeForMemoryAllocation_SizeType);
         return true;
@@ skipping 11 matching lines @@
 #endif
 
     /*  image_width and image_height are the original dimensions, available
         after jpeg_read_header(). To see the scaled dimensions, we have to call
         jpeg_start_decompress(), and then read output_width and output_height.
     */
     if (!jpeg_start_decompress(&cinfo)) {
         return return_false(cinfo, "start_decompress YUV8");
     }
 
+    // Seems like jpeg_start_decompress is updating our opinion of whether cinfo represents YUV.

[msarett, 2015/12/21 22:35:57]

Mike, I realize this is a shot in the dark, but is there any chance you know
what failure/test image caused this code to be added?  We should be able to to
tell whether YUV is supported before calling jpeg_start_decompress().

My guess is that "info.comps_in_scan" is a bogus thing to check.  And the only
thing that jpeg_start_decompress() might change.  What we really want to know is
whether the image is multi-scan (progressive) or not.  It doesn't look like we
support multi-scan images.

But it would be nice to confirm.

[mtklein, 2015/12/21 23:44:52]

Not sure what image triggered this, but I'm pretty sure I put it right here
because the assert at the beginning of output_raw_data (the next call) was
triggering.  We could try removing it and see what goes wrong?

+    // Again, not really an error.
+    if (!appears_to_be_yuv(cinfo)) {
+        return false;
+    }
+
     if (!output_raw_data(cinfo, planes, rowBytes)) {
         return return_false(cinfo, "output_raw_data");
     }
 
     update_components_sizes(cinfo, componentSizes, kActualSize_SizeType);
     jpeg_finish_decompress(&cinfo);
 
     if (NULL != colorSpace) {
         *colorSpace = kJPEG_SkYUVColorSpace;
     }
@@ skipping 512 matching lines @@
     return SkImageDecoder::kUnknown_Format;
 }
 
 static SkImageEncoder* sk_libjpeg_efactory(SkImageEncoder::Type t) {
     return (SkImageEncoder::kJPEG_Type == t) ? SkNEW(SkJPEGImageEncoder) : NULL;
 }
 
 static SkImageDecoder_DecodeReg gDReg(sk_libjpeg_dfactory);
 static SkImageDecoder_FormatReg gFormatReg(get_format_jpeg);
 static SkImageEncoder_EncodeReg gEReg(sk_libjpeg_efactory);