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 void update_components_sizes(const jpeg_decompress_struct& cinfo, SkISize componentSizes[3],
+static bool contains_three_planes(const jpeg_decompress_struct& cinfo) {

[hal.canary, 2015/03/17 21:32:48]

// Either explain why this is needed or note that you don't know why it is
needed.

+    return cinfo.cur_comp_info[0] && cinfo.cur_comp_info[1] && cinfo.cur_comp_info[2];
+}
+
+static bool update_components_sizes(const jpeg_decompress_struct& cinfo, SkISize componentSizes[3],
                                     SizeType sizeType) {
+    if (!contains_three_planes(cinfo)) {
+        return false;
+    }
     for (int i = 0; i < 3; ++i) {
         componentSizes[i] = compute_yuv_size(cinfo, i, sizeType);
     }
+    return true;
 }
 
 static bool output_raw_data(jpeg_decompress_struct& cinfo, void* planes[3], size_t rowBytes[3]) {
+    if (!contains_three_planes(cinfo)) {
+        return false;
+    }
     // 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 101 matching lines @@
 
     if (cinfo.jpeg_color_space != JCS_YCbCr) {
         // 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;
+        return update_components_sizes(cinfo, componentSizes, kSizeForMemoryAllocation_SizeType);
     }
 
     set_dct_method(*this, &cinfo);
 
     SkASSERT(1 == cinfo.scale_num);
     cinfo.scale_denom = 1;
 
     turn_off_visual_optimizations(&cinfo);
 
 #ifdef ANDROID_RGB
     cinfo.dither_mode = JDITHER_NONE;
 #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");
     }
 
     if (!output_raw_data(cinfo, planes, rowBytes)) {
         return return_false(cinfo, "output_raw_data");
     }
 
-    update_components_sizes(cinfo, componentSizes, kActualSize_SizeType);
+    if (!update_components_sizes(cinfo, componentSizes, kActualSize_SizeType)) {
+        return false;
+    }
     jpeg_finish_decompress(&cinfo);
 
     if (NULL != colorSpace) {
         *colorSpace = kJPEG_SkYUVColorSpace;
     }
 
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ skipping 507 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);