bool SkJPEGImageDecoder::onDecode(SkStream* stream, SkBitmap* bm, Mode mode) { #ifdef TIME_DECODE AutoTimeMillis atm("JPEG Decode"); #endif SkAutoMalloc srcStorage; JPEGAutoClean autoClean; jpeg_decompress_struct cinfo; skjpeg_error_mgr sk_err; skjpeg_source_mgr sk_stream(stream, this); cinfo.err = jpeg_std_error(&sk_err); sk_err.error_exit = skjpeg_error_exit; // All objects need to be instantiated before this setjmp call so that // they will be cleaned up properly if an error occurs. if (setjmp(sk_err.fJmpBuf)) { return return_false(cinfo, *bm, "setjmp"); } jpeg_create_decompress(&cinfo); autoClean.set(&cinfo); #ifdef ANDROID overwrite_mem_buffer_size(&cinfo); #endif //jpeg_stdio_src(&cinfo, file); cinfo.src = &sk_stream; int status = jpeg_read_header(&cinfo, true); if (status != JPEG_HEADER_OK) { return return_false(cinfo, *bm, "read_header"); } /* Try to fulfill the requested sampleSize. Since jpeg can do it (when it can) much faster that we, just use their num/denom api to approximate the size. */ int sampleSize = this->getSampleSize(); cinfo.dct_method = JDCT_IFAST; cinfo.scale_num = 1; cinfo.scale_denom = sampleSize; /* this gives about 30% performance improvement. In theory it may reduce the visual quality, in practice I'm not seeing a difference */ cinfo.do_fancy_upsampling = 0; /* this gives another few percents */ cinfo.do_block_smoothing = 0; /* default format is RGB */ cinfo.out_color_space = JCS_RGB; SkBitmap::Config config = this->getPrefConfig(k32Bit_SrcDepth, false); // only these make sense for jpegs if (config != SkBitmap::kARGB_8888_Config && config != SkBitmap::kARGB_4444_Config && config != SkBitmap::kRGB_565_Config) { config = SkBitmap::kARGB_8888_Config; } #ifdef ANDROID_RGB cinfo.dither_mode = JDITHER_NONE; if (config == SkBitmap::kARGB_8888_Config) { cinfo.out_color_space = JCS_RGBA_8888; } else if (config == SkBitmap::kRGB_565_Config) { if (sampleSize == 1) { // SkScaledBitmapSampler can't handle RGB_565 yet, // so don't even try. cinfo.out_color_space = JCS_RGB_565; if (this->getDitherImage()) { cinfo.dither_mode = JDITHER_ORDERED; } } } #endif if (sampleSize == 1 && mode == SkImageDecoder::kDecodeBounds_Mode) { bm->setConfig(config, cinfo.image_width, cinfo.image_height); bm->setIsOpaque(true); return true; } /* 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)) { /* If we failed here, we may still have enough information to return to the caller if they just wanted (subsampled bounds). If sampleSize was 1, then we would have already returned. Thus we just check if we're in kDecodeBounds_Mode, and that we have valid output sizes. One reason to fail here is that we have insufficient stream data to complete the setup. However, output dimensions seem to get computed very early, which is why this special check can pay off. */ if (SkImageDecoder::kDecodeBounds_Mode == mode && valid_output_dimensions(cinfo)) { SkScaledBitmapSampler smpl(cinfo.output_width, cinfo.output_height, recompute_sampleSize(sampleSize, cinfo)); bm->setConfig(config, smpl.scaledWidth(), smpl.scaledHeight()); bm->setIsOpaque(true); return true; } else { return return_false(cinfo, *bm, "start_decompress"); } } sampleSize = recompute_sampleSize(sampleSize, cinfo); // should we allow the Chooser (if present) to pick a config for us??? if (!this->chooseFromOneChoice(config, cinfo.output_width, cinfo.output_height)) { return return_false(cinfo, *bm, "chooseFromOneChoice"); } #ifdef ANDROID_RGB /* short-circuit the SkScaledBitmapSampler when possible, as this gives a significant performance boost. */ if (sampleSize == 1 && ((config == SkBitmap::kARGB_8888_Config && cinfo.out_color_space == JCS_RGBA_8888) || (config == SkBitmap::kRGB_565_Config && cinfo.out_color_space == JCS_RGB_565))) { bm->setConfig(config, cinfo.output_width, cinfo.output_height); bm->setIsOpaque(true); if (SkImageDecoder::kDecodeBounds_Mode == mode) { return true; } if (!this->allocPixelRef(bm, NULL)) { return return_false(cinfo, *bm, "allocPixelRef"); } SkAutoLockPixels alp(*bm); JSAMPLE* rowptr = (JSAMPLE*)bm->getPixels(); INT32 const bpr = bm->rowBytes(); while (cinfo.output_scanline < cinfo.output_height) { int row_count = jpeg_read_scanlines(&cinfo, &rowptr, 1); // if row_count == 0, then we didn't get a scanline, so abort. // if we supported partial images, we might return true in this case if (0 == row_count) { return return_false(cinfo, *bm, "read_scanlines"); } if (this->shouldCancelDecode()) { return return_false(cinfo, *bm, "shouldCancelDecode"); } rowptr += bpr; } jpeg_finish_decompress(&cinfo); return true; } #endif // check for supported formats SkScaledBitmapSampler::SrcConfig sc; if (3 == cinfo.out_color_components && JCS_RGB == cinfo.out_color_space) { sc = SkScaledBitmapSampler::kRGB; #ifdef ANDROID_RGB } else if (JCS_RGBA_8888 == cinfo.out_color_space) { sc = SkScaledBitmapSampler::kRGBX; //} else if (JCS_RGB_565 == cinfo.out_color_space) { // sc = SkScaledBitmapSampler::kRGB_565; #endif } else if (1 == cinfo.out_color_components && JCS_GRAYSCALE == cinfo.out_color_space) { sc = SkScaledBitmapSampler::kGray; } else { return return_false(cinfo, *bm, "jpeg colorspace"); } SkScaledBitmapSampler sampler(cinfo.output_width, cinfo.output_height, sampleSize); bm->setConfig(config, sampler.scaledWidth(), sampler.scaledHeight()); // jpegs are always opauqe (i.e. have no per-pixel alpha) bm->setIsOpaque(true); if (SkImageDecoder::kDecodeBounds_Mode == mode) { return true; } if (!this->allocPixelRef(bm, NULL)) { return return_false(cinfo, *bm, "allocPixelRef"); } SkAutoLockPixels alp(*bm); if (!sampler.begin(bm, sc, this->getDitherImage())) { return return_false(cinfo, *bm, "sampler.begin"); } uint8_t* srcRow = (uint8_t*)srcStorage.alloc(cinfo.output_width * 4); // Possibly skip initial rows [sampler.srcY0] if (!skip_src_rows(&cinfo, srcRow, sampler.srcY0())) { return return_false(cinfo, *bm, "skip rows"); } // now loop through scanlines until y == bm->height() - 1 for (int y = 0;; y++) { JSAMPLE* rowptr = (JSAMPLE*)srcRow; int row_count = jpeg_read_scanlines(&cinfo, &rowptr, 1); if (0 == row_count) { return return_false(cinfo, *bm, "read_scanlines"); } if (this->shouldCancelDecode()) { return return_false(cinfo, *bm, "shouldCancelDecode"); } sampler.next(srcRow); if (bm->height() - 1 == y) { // we're done break; } if (!skip_src_rows(&cinfo, srcRow, sampler.srcDY() - 1)) { return return_false(cinfo, *bm, "skip rows"); } } // we formally skip the rest, so we don't get a complaint from libjpeg if (!skip_src_rows(&cinfo, srcRow, cinfo.output_height - cinfo.output_scanline)) { return return_false(cinfo, *bm, "skip rows"); } jpeg_finish_decompress(&cinfo); // SkDebugf("------------------- bm2 size %d [%d %d] %d\n", bm->getSize(), bm->width(), bm->height(), bm->config()); return true; }
bool SkJPEGImageDecoder::onDecode(SkStream* stream, SkBitmap* bm, SkBitmap::Config prefConfig, Mode mode) { #ifdef TIME_DECODE AutoTimeMillis atm("JPEG Decode"); #endif SkAutoMalloc srcStorage; JPEGAutoClean autoClean; jpeg_decompress_struct cinfo; sk_error_mgr sk_err; sk_source_mgr sk_stream(stream); cinfo.err = jpeg_std_error(&sk_err); sk_err.error_exit = sk_error_exit; // All objects need to be instantiated before this setjmp call so that // they will be cleaned up properly if an error occurs. if (setjmp(sk_err.fJmpBuf)) { return false; } jpeg_create_decompress(&cinfo); autoClean.set(&cinfo); //jpeg_stdio_src(&cinfo, file); cinfo.src = &sk_stream; jpeg_read_header(&cinfo, true); /* Try to fulfill the requested sampleSize. Since jpeg can do it (when it can) much faster that we, just use their num/denom api to approximate the size. */ int sampleSize = this->getSampleSize(); cinfo.dct_method = JDCT_IFAST; cinfo.scale_num = 1; cinfo.scale_denom = sampleSize; /* 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. */ jpeg_start_decompress(&cinfo); /* If we need to better match the request, we might examine the image and output dimensions, and determine if the downsampling jpeg provided is not sufficient. If so, we can recompute a modified sampleSize value to make up the difference. To skip this additional scaling, just set sampleSize = 1; below. */ sampleSize = sampleSize * cinfo.output_width / cinfo.image_width; // check for supported formats bool isRGB; // as opposed to gray8 if (3 == cinfo.num_components && JCS_RGB == cinfo.out_color_space) { isRGB = true; } else if (1 == cinfo.num_components && JCS_GRAYSCALE == cinfo.out_color_space) { isRGB = false; // could use Index8 config if we want... } else { SkDEBUGF(("SkJPEGImageDecoder: unsupported jpeg colorspace %d with %d components\n", cinfo.jpeg_color_space, cinfo.num_components)); return false; } SkBitmap::Config config = prefConfig; // if no user preference, see what the device recommends if (config == SkBitmap::kNo_Config) config = SkImageDecoder::GetDeviceConfig(); // only these make sense for jpegs if (config != SkBitmap::kARGB_8888_Config && config != SkBitmap::kARGB_4444_Config && config != SkBitmap::kRGB_565_Config) { config = SkBitmap::kARGB_8888_Config; } // should we allow the Chooser (if present) to pick a config for us??? if (!this->chooseFromOneChoice(config, cinfo.output_width, cinfo.output_height)) { return false; } SkScaledBitmapSampler sampler(cinfo.output_width, cinfo.output_height, sampleSize); bm->setConfig(config, sampler.scaledWidth(), sampler.scaledHeight()); // jpegs are always opauqe (i.e. have no per-pixel alpha) bm->setIsOpaque(true); if (SkImageDecoder::kDecodeBounds_Mode == mode) { return true; } if (!this->allocPixelRef(bm, NULL)) { return false; } SkAutoLockPixels alp(*bm); if (!sampler.begin(bm, isRGB ? SkScaledBitmapSampler::kRGB : SkScaledBitmapSampler::kGray, this->getDitherImage())) { return false; } uint8_t* srcRow = (uint8_t*)srcStorage.alloc(cinfo.output_width * 3); skip_src_rows(&cinfo, srcRow, sampler.srcY0()); for (int y = 0;; y++) { JSAMPLE* rowptr = (JSAMPLE*)srcRow; int row_count = jpeg_read_scanlines(&cinfo, &rowptr, 1); SkASSERT(row_count == 1); sampler.next(srcRow); if (bm->height() - 1 == y) { break; } skip_src_rows(&cinfo, srcRow, sampler.srcDY() - 1); } // ??? If I don't do this, I get an error from finish_decompress skip_src_rows(&cinfo, srcRow, cinfo.output_height - cinfo.output_scanline); jpeg_finish_decompress(&cinfo); return true; }