Switch SkJpegCode to libjpeg-turbo

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 67 matching lines @@
     }
     /* To suppress error messages with a SK_DEBUG binary, set the
      * environment variable "skia_images_jpeg_suppressDecoderErrors"
      * to "true".  Inside a program that links to skia:
      * SK_CONF_SET("images.jpeg.suppressDecoderErrors", true); */
     if (c_suppressJPEGImageDecoderErrors) {
         cinfo->err->output_message = &do_nothing_output_message;
     }
 }
 
-#ifdef SK_BUILD_FOR_ANDROID
+#if 0

[scroggo, 2015/06/16 20:39:23]

Derek knows the magic to make SkCodec using libjpeg-turbo while SkImageDecoder
uses libjpeg. With that magic, you don't need to disable this. (The CL to do
something similar for libpng is here:
https://codereview.chromium.org/1058823002/)

[msarett, 2015/06/18 21:06:10]

Done.

 class SkJPEGImageIndex {
 public:
     // Takes ownership of stream.
     SkJPEGImageIndex(SkStreamRewindable* stream, SkImageDecoder* decoder)
         : fSrcMgr(stream, decoder)
         , fStream(stream)
         , fInfoInitialized(false)
         , fHuffmanCreated(false)
         , fDecompressStarted(false)
         {
@@ skipping 97 matching lines @@
     huffman_index fHuffmanIndex;
     bool fInfoInitialized;
     bool fHuffmanCreated;
     bool fDecompressStarted;
     SkDEBUGCODE(bool fReadHeaderSucceeded;)
 };
 #endif
 
 class SkJPEGImageDecoder : public SkImageDecoder {
 public:
-#ifdef SK_BUILD_FOR_ANDROID
+#if 0
     SkJPEGImageDecoder() {
         fImageIndex = NULL;
         fImageWidth = 0;
         fImageHeight = 0;
     }
 
     virtual ~SkJPEGImageDecoder() {
         SkDELETE(fImageIndex);
     }
 #endif
 
     Format getFormat() const override {
         return kJPEG_Format;
     }
 
 protected:
-#ifdef SK_BUILD_FOR_ANDROID
+#if 0
     bool onBuildTileIndex(SkStreamRewindable *stream, int *width, int *height) override;
     bool onDecodeSubset(SkBitmap* bitmap, const SkIRect& rect) override;
 #endif
     Result onDecode(SkStream* stream, SkBitmap* bm, Mode) override;
     bool onDecodeYUV8Planes(SkStream* stream, SkISize componentSizes[3],
                             void* planes[3], size_t rowBytes[3],
                             SkYUVColorSpace* colorSpace) override;
 
 private:
-#ifdef SK_BUILD_FOR_ANDROID
+#if 0
     SkJPEGImageIndex* fImageIndex;
     int fImageWidth;
     int fImageHeight;
 #endif
 
     /**
      *  Determine the appropriate bitmap colortype and out_color_space based on
      *  both the preference of the caller and the jpeg_color_space on the
      *  jpeg_decompress_struct passed in.
      *  Must be called after jpeg_read_header.
@@ skipping 46 matching lines @@
     for (int i = 0; i < count; i++) {
         JSAMPLE* rowptr = (JSAMPLE*)buffer;
         int row_count = jpeg_read_scanlines(cinfo, &rowptr, 1);
         if (1 != row_count) {
             return false;
         }
     }
     return true;
 }
 
-#ifdef SK_BUILD_FOR_ANDROID
+#if 0
 static bool skip_src_rows_tile(jpeg_decompress_struct* cinfo,
                                huffman_index *index, void* buffer, int count) {
     for (int i = 0; i < count; i++) {
         JSAMPLE* rowptr = (JSAMPLE*)buffer;
         int row_count = jpeg_read_tile_scanline(cinfo, index, &rowptr);
         if (1 != row_count) {
             return false;
         }
     }
     return true;
@@ skipping 13 matching lines @@
                  cinfo.err->msg_code, buffer, caller, width, height);
     }
 }
 
 static bool return_false(const jpeg_decompress_struct& cinfo,
                          const char caller[]) {
     print_jpeg_decoder_errors(cinfo, 0, 0, caller);
     return false;
 }
 
-#ifdef SK_BUILD_FOR_ANDROID
+#if 0
 static bool return_false(const jpeg_decompress_struct& cinfo,
                          const SkBitmap& bm, const char caller[]) {
     print_jpeg_decoder_errors(cinfo, bm.width(), bm.height(), caller);
     return false;
 }
 #endif
 
 static SkImageDecoder::Result return_failure(const jpeg_decompress_struct& cinfo,
                                              const SkBitmap& bm, const char caller[]) {
     print_jpeg_decoder_errors(cinfo, bm.width(), bm.height(), caller);
@@ skipping 589 matching lines @@
 
     if (NULL != colorSpace) {
         *colorSpace = kJPEG_SkYUVColorSpace;
     }
 
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-#ifdef SK_BUILD_FOR_ANDROID
+#if 0
 bool SkJPEGImageDecoder::onBuildTileIndex(SkStreamRewindable* stream, int *width, int *height) {
 
     SkAutoTDelete<SkJPEGImageIndex> imageIndex(SkNEW_ARGS(SkJPEGImageIndex, (stream, this)));
 
     skjpeg_error_mgr sk_err;
     set_error_mgr(imageIndex->cinfo(), &sk_err);
 
     // 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)) {
@@ skipping 494 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);