Optimizes JPEGCodec for libjpeg-turbo...

ui/gfx/codec/jpeg_codec.cc

 // Copyright (c) 2006-2008 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 <setjmp.h>
 
 #include "base/logging.h"
 #include "base/scoped_ptr.h"
@@ skipping 198 matching lines @@
     destroyer.DestroyManagedObject();
     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
     unsigned char* row = new unsigned char[w * 3];
 
     while (cinfo.next_scanline < cinfo.image_height) {
       converter(&input[cinfo.next_scanline * row_byte_width], w, row);
       jpeg_write_scanlines(&cinfo, &row, 1);
     }
     delete[] row;
   }
+#endif
 
   jpeg_finish_compress(&cinfo);
   return true;
 }
 
 // Decoder --------------------------------------------------------------------
 
 namespace {
 
 struct JpegDecoderState {
@@ skipping 162 matching lines @@
 
   // fill the file metadata into our buffer
   if (jpeg_read_header(&cinfo, true) != JPEG_HEADER_OK)
     return false;
 
   // we want to always get RGB data out
   switch (cinfo.jpeg_color_space) {
     case JCS_GRAYSCALE:
     case JCS_RGB:
     case JCS_YCbCr:
+#ifdef JCS_EXTENSIONS
+      // Choose an output colorspace and return if it is an unsupported one.
+      // Same as JPEGCodec::Encode(), libjpeg-turbo supports all input formats
+      // used by Chromium (i.e. RGB, RGBA, and BGRA) and we just map the input
+      // parameters to a colorspace.
+      if (format == FORMAT_RGB) {
+        cinfo.out_color_space = JCS_RGB;
+        cinfo.output_components = 3;
+      } else if (format == FORMAT_RGBA ||
+                 format == FORMAT_SkBitmap && SK_R32_SHIFT == 0) {
+        cinfo.out_color_space = JCS_EXT_RGBX;
+        cinfo.output_components = 4;
+      } else if (format == FORMAT_BGRA ||
+                 format == FORMAT_SkBitmap && SK_B32_SHIFT == 0) {
+        cinfo.out_color_space = JCS_EXT_BGRX;
+        cinfo.output_components = 4;
+      } else {
+        // We can exit this function without calling jpeg_destroy_decompress()
+        // because DecompressDestroyer automaticaly calls it.
+        NOTREACHED() << "Invalid pixel format";
+        return false;
+      }
+#else
       cinfo.out_color_space = JCS_RGB;
+#endif
       break;
     case JCS_CMYK:
     case JCS_YCCK:
     default:
       // Mozilla errors out on these color spaces, so I presume that the jpeg
       // library can't do automatic color space conversion for them. We don't
       // care about these anyway.
       return false;
   }
+#ifndef JCS_EXTENSIONS
   cinfo.output_components = 3;
+#endif
 
   jpeg_calc_output_dimensions(&cinfo);
   *w = cinfo.output_width;
   *h = cinfo.output_height;
 
   jpeg_start_decompress(&cinfo);
 
   // FIXME(brettw) we may want to allow the capability for callers to request
   // how to align row lengths as we do for the compressor.
   int row_read_stride = cinfo.output_width * cinfo.output_components;
 
+#ifdef JCS_EXTENSIONS
+  // Create memory for a decoded image and write decoded lines to the memory
+  // without conversions same as JPEGCodec::Encode().
+  int row_write_stride = row_read_stride;
+  output->resize(row_write_stride * cinfo.output_height);
+
+  for (int row = 0; row < static_cast<int>(cinfo.output_height); row++) {
+    unsigned char* rowptr = &(*output)[row * row_write_stride];
+    if (!jpeg_read_scanlines(&cinfo, &rowptr, 1))
+      return false;
+  }
+#else
   if (format == FORMAT_RGB) {
     // easy case, row needs no conversion
     int row_write_stride = row_read_stride;
     output->resize(row_write_stride * cinfo.output_height);
 
     for (int row = 0; row < static_cast<int>(cinfo.output_height); row++) {
       unsigned char* rowptr = &(*output)[row * row_write_stride];
       if (!jpeg_read_scanlines(&cinfo, &rowptr, 1))
         return false;
     }
@@ skipping 20 matching lines @@
     output->resize(row_write_stride * cinfo.output_height);
 
     scoped_array<unsigned char> row_data(new unsigned char[row_read_stride]);
     unsigned char* rowptr = row_data.get();
     for (int row = 0; row < static_cast<int>(cinfo.output_height); row++) {
       if (!jpeg_read_scanlines(&cinfo, &rowptr, 1))
         return false;
       converter(rowptr, *w, &(*output)[row * row_write_stride]);
     }
   }
+#endif
 
   jpeg_finish_decompress(&cinfo);
   jpeg_destroy_decompress(&cinfo);
   return true;
 }
 
 // static
 SkBitmap* JPEGCodec::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))
     return NULL;
 
   // Skia only handles 32 bit images.
   int data_length = w * h * 4;
 
   SkBitmap* bitmap = new SkBitmap();
   bitmap->setConfig(SkBitmap::kARGB_8888_Config, w, h);
   bitmap->allocPixels();
   memcpy(bitmap->getAddr32(0, 0), &data_vector[0], data_length);
 
   return bitmap;
 }
 
 }  // namespace gfx