Index: ui/gfx/chromeos/codec/jpeg_codec_robust_slow.cc |
diff --git a/ui/gfx/codec/jpeg_codec.cc b/ui/gfx/chromeos/codec/jpeg_codec_robust_slow.cc |
similarity index 51% |
copy from ui/gfx/codec/jpeg_codec.cc |
copy to ui/gfx/chromeos/codec/jpeg_codec_robust_slow.cc |
index 8a08fe0291afcc8a61c6b4f560396a4a50057da8..c5a78aac036c16d1557607bd9df131c27d08af4b 100644 |
--- a/ui/gfx/codec/jpeg_codec.cc |
+++ b/ui/gfx/chromeos/codec/jpeg_codec_robust_slow.cc |
@@ -1,8 +1,8 @@ |
-// Copyright (c) 2011 The Chromium Authors. All rights reserved. |
+// Copyright 2015 The Chromium Authors. All rights reserved. |
// Use of this source code is governed by a BSD-style license that can be |
// found in the LICENSE file. |
-#include "ui/gfx/codec/jpeg_codec.h" |
+#include "ui/gfx/chromeos/codec/jpeg_codec_robust_slow.h" |
#include <setjmp.h> |
@@ -12,13 +12,8 @@ |
#include "third_party/skia/include/core/SkColorPriv.h" |
extern "C" { |
-#if defined(USE_SYSTEM_LIBJPEG) |
-#include <jpeglib.h> |
-#elif defined(USE_LIBJPEG_TURBO) |
-#include "third_party/libjpeg_turbo/jpeglib.h" |
-#else |
+// IJG provides robust JPEG decode |
#include "third_party/libjpeg/jpeglib.h" |
-#endif |
} |
namespace gfx { |
@@ -42,284 +37,6 @@ void ErrorExit(jpeg_common_struct* cinfo) { |
} // namespace |
-// This method helps identify at run time which library chromium is using. |
-JPEGCodec::LibraryVariant JPEGCodec::JpegLibraryVariant() { |
-#if defined(USE_SYSTEM_LIBJPEG) |
- return SYSTEM_LIBJPEG; |
-#elif defined(USE_LIBJPEG_TURBO) |
- return LIBJPEG_TURBO; |
-#else |
- return IJG_LIBJPEG; |
-#endif |
-} |
- |
-// Encoder --------------------------------------------------------------------- |
-// |
-// This code is based on nsJPEGEncoder from Mozilla. |
-// Copyright 2005 Google Inc. (Brett Wilson, contributor) |
- |
-namespace { |
- |
-// Initial size for the output buffer in the JpegEncoderState below. |
-static const int initial_output_buffer_size = 8192; |
- |
-struct JpegEncoderState { |
- explicit JpegEncoderState(std::vector<unsigned char>* o) |
- : out(o), |
- image_buffer_used(0) { |
- } |
- |
- // Output buffer, of which 'image_buffer_used' bytes are actually used (this |
- // will often be less than the actual size of the vector because we size it |
- // so that libjpeg can write directly into it. |
- std::vector<unsigned char>* out; |
- |
- // Number of bytes in the 'out' buffer that are actually used (see above). |
- size_t image_buffer_used; |
-}; |
- |
-// Initializes the JpegEncoderState for encoding, and tells libjpeg about where |
-// the output buffer is. |
-// |
-// From the JPEG library: |
-// "Initialize destination. This is called by jpeg_start_compress() before |
-// any data is actually written. It must initialize next_output_byte and |
-// free_in_buffer. free_in_buffer must be initialized to a positive value." |
-void InitDestination(jpeg_compress_struct* cinfo) { |
- JpegEncoderState* state = static_cast<JpegEncoderState*>(cinfo->client_data); |
- DCHECK(state->image_buffer_used == 0) << "initializing after use"; |
- |
- state->out->resize(initial_output_buffer_size); |
- state->image_buffer_used = 0; |
- |
- cinfo->dest->next_output_byte = &(*state->out)[0]; |
- cinfo->dest->free_in_buffer = initial_output_buffer_size; |
-} |
- |
-// Resize the buffer that we give to libjpeg and update our and its state. |
-// |
-// From the JPEG library: |
-// "Callback used by libjpeg whenever the buffer has filled (free_in_buffer |
-// reaches zero). In typical applications, it should write out the *entire* |
-// buffer (use the saved start address and buffer length; ignore the current |
-// state of next_output_byte and free_in_buffer). Then reset the pointer & |
-// count to the start of the buffer, and return TRUE indicating that the |
-// buffer has been dumped. free_in_buffer must be set to a positive value |
-// when TRUE is returned. A FALSE return should only be used when I/O |
-// suspension is desired (this operating mode is discussed in the next |
-// section)." |
-boolean EmptyOutputBuffer(jpeg_compress_struct* cinfo) { |
- JpegEncoderState* state = static_cast<JpegEncoderState*>(cinfo->client_data); |
- |
- // note the new size, the buffer is full |
- state->image_buffer_used = state->out->size(); |
- |
- // expand buffer, just double size each time |
- state->out->resize(state->out->size() * 2); |
- |
- // tell libjpeg where to write the next data |
- cinfo->dest->next_output_byte = &(*state->out)[state->image_buffer_used]; |
- cinfo->dest->free_in_buffer = state->out->size() - state->image_buffer_used; |
- return 1; |
-} |
- |
-// Cleans up the JpegEncoderState to prepare for returning in the final form. |
-// |
-// From the JPEG library: |
-// "Terminate destination --- called by jpeg_finish_compress() after all data |
-// has been written. In most applications, this must flush any data |
-// remaining in the buffer. Use either next_output_byte or free_in_buffer to |
-// determine how much data is in the buffer." |
-void TermDestination(jpeg_compress_struct* cinfo) { |
- JpegEncoderState* state = static_cast<JpegEncoderState*>(cinfo->client_data); |
- DCHECK(state->out->size() >= state->image_buffer_used); |
- |
- // update the used byte based on the next byte libjpeg would write to |
- state->image_buffer_used = cinfo->dest->next_output_byte - &(*state->out)[0]; |
- DCHECK(state->image_buffer_used < state->out->size()) << |
- "JPEG library busted, got a bad image buffer size"; |
- |
- // update our buffer so that it exactly encompases the desired data |
- state->out->resize(state->image_buffer_used); |
-} |
- |
-#if !defined(JCS_EXTENSIONS) |
-// Converts RGBA to RGB (removing the alpha values) to prepare to send data to |
-// libjpeg. This converts one row of data in rgba with the given width in |
-// pixels the the given rgb destination buffer (which should have enough space |
-// reserved for the final data). |
-void StripAlpha(const unsigned char* rgba, int pixel_width, unsigned char* rgb) |
-{ |
- for (int x = 0; x < pixel_width; x++) |
- memcpy(&rgb[x * 3], &rgba[x * 4], 3); |
-} |
- |
-// Converts BGRA to RGB by reordering the color components and dropping the |
-// alpha. This converts one row of data in rgba with the given width in |
-// pixels the the given rgb destination buffer (which should have enough space |
-// reserved for the final data). |
-void BGRAtoRGB(const unsigned char* bgra, int pixel_width, unsigned char* rgb) |
-{ |
- for (int x = 0; x < pixel_width; x++) { |
- const unsigned char* pixel_in = &bgra[x * 4]; |
- unsigned char* pixel_out = &rgb[x * 3]; |
- pixel_out[0] = pixel_in[2]; |
- pixel_out[1] = pixel_in[1]; |
- pixel_out[2] = pixel_in[0]; |
- } |
-} |
-#endif // !defined(JCS_EXTENSIONS) |
- |
-// This class destroys the given jpeg_compress object when it goes out of |
-// scope. It simplifies the error handling in Encode (and even applies to the |
-// success case). |
-class CompressDestroyer { |
- public: |
- CompressDestroyer() : cinfo_(NULL) { |
- } |
- ~CompressDestroyer() { |
- DestroyManagedObject(); |
- } |
- void SetManagedObject(jpeg_compress_struct* ci) { |
- DestroyManagedObject(); |
- cinfo_ = ci; |
- } |
- void DestroyManagedObject() { |
- if (cinfo_) { |
- jpeg_destroy_compress(cinfo_); |
- cinfo_ = NULL; |
- } |
- } |
- private: |
- jpeg_compress_struct* cinfo_; |
-}; |
- |
-} // namespace |
- |
-bool JPEGCodec::Encode(const unsigned char* input, ColorFormat format, |
- int w, int h, int row_byte_width, |
- int quality, std::vector<unsigned char>* output) { |
- jpeg_compress_struct cinfo; |
- CompressDestroyer destroyer; |
- destroyer.SetManagedObject(&cinfo); |
- output->clear(); |
-#if !defined(JCS_EXTENSIONS) |
- unsigned char* row_buffer = NULL; |
-#endif |
- |
- // We set up the normal JPEG error routines, then override error_exit. |
- // This must be done before the call to create_compress. |
- CoderErrorMgr errmgr; |
- cinfo.err = jpeg_std_error(&errmgr.pub); |
- errmgr.pub.error_exit = ErrorExit; |
- |
- // Establish the setjmp return context for ErrorExit to use. |
- if (setjmp(errmgr.setjmp_buffer)) { |
- // If we get here, the JPEG code has signaled an error. |
- // MSDN notes: "if you intend your code to be portable, do not rely on |
- // correct destruction of frame-based objects when executing a nonlocal |
- // goto using a call to longjmp." So we delete the CompressDestroyer's |
- // object manually instead. |
- destroyer.DestroyManagedObject(); |
-#if !defined(JCS_EXTENSIONS) |
- delete[] row_buffer; |
-#endif |
- return false; |
- } |
- |
- // The destroyer will destroy() cinfo on exit. |
- jpeg_create_compress(&cinfo); |
- |
- cinfo.image_width = w; |
- cinfo.image_height = h; |
- cinfo.input_components = 3; |
-#ifdef JCS_EXTENSIONS |
- // Choose an input colorspace and return if it is an unsupported one. Since |
- // libjpeg-turbo supports all input formats used by Chromium (i.e. RGB, RGBA, |
- // and BGRA), we just map the input parameters to a colorspace used by |
- // libjpeg-turbo. |
- if (format == FORMAT_RGB) { |
- cinfo.input_components = 3; |
- cinfo.in_color_space = JCS_RGB; |
- } else if (format == FORMAT_RGBA || |
- (format == FORMAT_SkBitmap && SK_R32_SHIFT == 0)) { |
- cinfo.input_components = 4; |
- cinfo.in_color_space = JCS_EXT_RGBX; |
- } else if (format == FORMAT_BGRA || |
- (format == FORMAT_SkBitmap && SK_B32_SHIFT == 0)) { |
- cinfo.input_components = 4; |
- cinfo.in_color_space = JCS_EXT_BGRX; |
- } else { |
- // We can exit this function without calling jpeg_destroy_compress() because |
- // CompressDestroyer automaticaly calls it. |
- NOTREACHED() << "Invalid pixel format"; |
- return false; |
- } |
-#else |
- cinfo.in_color_space = JCS_RGB; |
-#endif |
- cinfo.data_precision = 8; |
- |
- jpeg_set_defaults(&cinfo); |
- jpeg_set_quality(&cinfo, quality, 1); // quality here is 0-100 |
- |
- // set up the destination manager |
- jpeg_destination_mgr destmgr; |
- destmgr.init_destination = InitDestination; |
- destmgr.empty_output_buffer = EmptyOutputBuffer; |
- destmgr.term_destination = TermDestination; |
- cinfo.dest = &destmgr; |
- |
- JpegEncoderState state(output); |
- cinfo.client_data = &state; |
- |
- jpeg_start_compress(&cinfo, 1); |
- |
- // feed it the rows, doing necessary conversions for the color format |
-#ifdef JCS_EXTENSIONS |
- // This function already returns when the input format is not supported by |
- // libjpeg-turbo and needs conversion. Therefore, we just encode lines without |
- // conversions. |
- while (cinfo.next_scanline < cinfo.image_height) { |
- const unsigned char* row = &input[cinfo.next_scanline * row_byte_width]; |
- jpeg_write_scanlines(&cinfo, const_cast<unsigned char**>(&row), 1); |
- } |
-#else |
- if (format == FORMAT_RGB) { |
- // no conversion necessary |
- while (cinfo.next_scanline < cinfo.image_height) { |
- const unsigned char* row = &input[cinfo.next_scanline * row_byte_width]; |
- jpeg_write_scanlines(&cinfo, const_cast<unsigned char**>(&row), 1); |
- } |
- } else { |
- // get the correct format converter |
- void (*converter)(const unsigned char* in, int w, unsigned char* rgb); |
- if (format == FORMAT_RGBA || |
- (format == FORMAT_SkBitmap && SK_R32_SHIFT == 0)) { |
- converter = StripAlpha; |
- } else if (format == FORMAT_BGRA || |
- (format == FORMAT_SkBitmap && SK_B32_SHIFT == 0)) { |
- converter = BGRAtoRGB; |
- } else { |
- NOTREACHED() << "Invalid pixel format"; |
- return false; |
- } |
- |
- // output row after converting |
- row_buffer = new unsigned char[w * 3]; |
- |
- while (cinfo.next_scanline < cinfo.image_height) { |
- converter(&input[cinfo.next_scanline * row_byte_width], w, row_buffer); |
- jpeg_write_scanlines(&cinfo, &row_buffer, 1); |
- } |
- delete[] row_buffer; |
- } |
-#endif |
- |
- jpeg_finish_compress(&cinfo); |
- return true; |
-} |
- |
// Decoder -------------------------------------------------------------------- |
namespace { |
@@ -448,9 +165,10 @@ class DecompressDestroyer { |
} // namespace |
-bool JPEGCodec::Decode(const unsigned char* input, size_t input_size, |
- ColorFormat format, std::vector<unsigned char>* output, |
- int* w, int* h) { |
+bool JPEGCodecRobustSlow::Decode(const unsigned char* input, size_t input_size, |
+ ColorFormat format, |
+ std::vector<unsigned char>* output, int* w, |
+ int* h) { |
jpeg_decompress_struct cinfo; |
DecompressDestroyer destroyer; |
destroyer.SetManagedObject(&cinfo); |
@@ -603,7 +321,8 @@ bool JPEGCodec::Decode(const unsigned char* input, size_t input_size, |
} |
// static |
-SkBitmap* JPEGCodec::Decode(const unsigned char* input, size_t input_size) { |
+SkBitmap* JPEGCodecRobustSlow::Decode(const unsigned char* input, |
+ size_t input_size) { |
int w, h; |
std::vector<unsigned char> data_vector; |
if (!Decode(input, input_size, FORMAT_SkBitmap, &data_vector, &w, &h)) |