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"
 #include "SkJpegUtility.h"
 #include "SkColorPriv.h"
 #include "SkDither.h"
 #include "SkScaledBitmapSampler.h"
 #include "SkStream.h"
 #include "SkTemplates.h"
 #include "SkTime.h"
 #include "SkUtils.h"
 #include "SkRTConf.h"
 #include "SkRect.h"
 #include "SkCanvas.h"
 
 
 #include <stdio.h>
 extern "C" {
+#ifdef SK_BUILD_FOR_ANDROID
+    #include "manglejpeglib.h"
+#else
     #include "jpeglib.h"
+#endif
     #include "jerror.h"
 }
 
 // These enable timing code that report milliseconds for an encoding/decoding
 //#define TIME_ENCODE
 //#define TIME_DECODE
 
 // this enables our rgb->yuv code, which is faster than libjpeg on ARM
 #define WE_CONVERT_TO_YUV
 
@@ skipping 69 matching lines @@
             // attempt to delete this SkJPEGImageIndex, thus entering this
             // destructor again. Setting fHuffmanCreated to false first
             // prevents an infinite loop.
             fHuffmanCreated = false;
             jpeg_destroy_huffman_index(&fHuffmanIndex);
         }
         if (fDecompressStarted) {
             // Like fHuffmanCreated, set to false before calling libjpeg
             // function to prevent potential infinite loop.
             fDecompressStarted = false;
-            jpeg_finish_decompress(&fCInfo);
+            jFinDecompress(&fCInfo);
         }
         if (fInfoInitialized) {
             this->destroyInfo();
         }
     }
 
     /**
      *  Destroy the cinfo struct.
      *  After this call, if a huffman index was already built, it
      *  can be used after calling initializeInfoAndReadHeader
      *  again. Must not be called after startTileDecompress except
      *  in the destructor.
      */
     void destroyInfo() {
         SkASSERT(fInfoInitialized);
         SkASSERT(!fDecompressStarted);
         // Like fHuffmanCreated, set to false before calling libjpeg
         // function to prevent potential infinite loop.
         fInfoInitialized = false;
-        jpeg_destroy_decompress(&fCInfo);
+        jDestDecompress(&fCInfo);
         SkDEBUGCODE(fReadHeaderSucceeded = false;)
     }
 
     /**
      *  Initialize the cinfo struct.
      *  Calls jpeg_create_decompress, makes customizations, and
-     *  finally calls jpeg_read_header. Returns true if jpeg_read_header
+     *  finally calls jReadHeader. Returns true if jReadHeader
      *  returns JPEG_HEADER_OK.
      *  If cinfo was already initialized, destroyInfo must be called to
      *  destroy the old one. Must not be called after startTileDecompress.
      */
     bool initializeInfoAndReadHeader() {
         SkASSERT(!fInfoInitialized && !fDecompressStarted);
         initialize_info(&fCInfo, &fSrcMgr);
         fInfoInitialized = true;
-        const bool success = (JPEG_HEADER_OK == jpeg_read_header(&fCInfo, true));
+        const bool success = (JPEG_HEADER_OK == jReadHeader(&fCInfo, true));
         SkDEBUGCODE(fReadHeaderSucceeded = success;)
         return success;
     }
 
     jpeg_decompress_struct* cinfo() { return &fCInfo; }
 
     huffman_index* huffmanIndex() { return &fHuffmanIndex; }
 
     /**
      *  Build the index to be used for tile based decoding.
@@ skipping 70 matching lines @@
 #ifdef SK_BUILD_FOR_ANDROID
     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.
+     *  Must be called after jReadHeader.
      */
     SkColorType getBitmapColorType(jpeg_decompress_struct*);
 
     typedef SkImageDecoder INHERITED;
 };
 
 //////////////////////////////////////////////////////////////////////////
 
 /* Automatically clean up after throwing an exception */
 class JPEGAutoClean {
 public:
     JPEGAutoClean(): cinfo_ptr(NULL) {}
     ~JPEGAutoClean() {
         if (cinfo_ptr) {
-            jpeg_destroy_decompress(cinfo_ptr);
+            jDestDecompress(cinfo_ptr);
         }
     }
     void set(jpeg_decompress_struct* info) {
         cinfo_ptr = info;
     }
 private:
     jpeg_decompress_struct* cinfo_ptr;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
@@ skipping 13 matching lines @@
 static bool valid_output_dimensions(const jpeg_decompress_struct& cinfo) {
     /* These are initialized to 0, so if they have non-zero values, we assume
        they are "valid" (i.e. have been computed by libjpeg)
      */
     return 0 != cinfo.output_width && 0 != cinfo.output_height;
 }
 
 static bool skip_src_rows(jpeg_decompress_struct* cinfo, void* buffer, int count) {
     for (int i = 0; i < count; i++) {
         JSAMPLE* rowptr = (JSAMPLE*)buffer;
-        int row_count = jpeg_read_scanlines(cinfo, &rowptr, 1);
+        int row_count = jReadScanlines(cinfo, &rowptr, 1);
         if (1 != row_count) {
             return false;
         }
     }
     return true;
 }
 
 #ifdef SK_BUILD_FOR_ANDROID
 static bool skip_src_rows_tile(jpeg_decompress_struct* cinfo,
                                huffman_index *index, void* buffer, int count) {
@@ skipping 66 matching lines @@
         scanline[3] = 255;
     }
 }
 
 /**
  *  Common code for setting the error manager.
  */
 static void set_error_mgr(jpeg_decompress_struct* cinfo, skjpeg_error_mgr* errorManager) {
     SkASSERT(cinfo != NULL);
     SkASSERT(errorManager != NULL);
-    cinfo->err = jpeg_std_error(errorManager);
+    cinfo->err = jStdError(errorManager);
     errorManager->error_exit = skjpeg_error_exit;
 }
 
 /**
  *  Common code for turning off upsampling and smoothing. Turning these
  *  off helps performance without showing noticable differences in the
  *  resulting bitmap.
  */
 static void turn_off_visual_optimizations(jpeg_decompress_struct* cinfo) {
     SkASSERT(cinfo != NULL);
@@ skipping 165 matching lines @@
 
     // All objects need to be instantiated before this setjmp call so that
     // they will be cleaned up properly if an error occurs.
     if (setjmp(errorManager.fJmpBuf)) {
         return return_failure(cinfo, *bm, "setjmp");
     }
 
     initialize_info(&cinfo, &srcManager);
     autoClean.set(&cinfo);
 
-    int status = jpeg_read_header(&cinfo, true);
+    int status = jReadHeader(&cinfo, true);
     if (status != JPEG_HEADER_OK) {
         return return_failure(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();
 
@@ skipping 14 matching lines @@
         // Assume an A8 bitmap is not opaque to avoid the check of each
         // individual pixel. It is very unlikely to be opaque, since
         // an opaque A8 bitmap would not be very interesting.
         // Otherwise, a jpeg image is opaque.
         bool success = bm->setInfo(SkImageInfo::Make(cinfo.image_width, cinfo.image_height,
                                                      colorType, alphaType));
         return success ? kSuccess : kFailure;
     }
 
     /*  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.
+        after jReadHeader(). To see the scaled dimensions, we have to call
+        jStrtDecompress(), and then read output_width and output_height.
     */
-    if (!jpeg_start_decompress(&cinfo)) {
+    if (!jStrtDecompress(&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)) {
@@ skipping 33 matching lines @@
        a significant performance boost.
     */
     if (sampleSize == 1 &&
         ((kN32_SkColorType == colorType && cinfo.out_color_space == JCS_RGBA_8888) ||
          (kRGB_565_SkColorType == colorType && cinfo.out_color_space == JCS_RGB_565)))
     {
         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);
+            int row_count = jReadScanlines(&cinfo, &rowptr, 1);
             if (0 == row_count) {
                 // if row_count == 0, then we didn't get a scanline,
                 // so return early.  We will return a partial image.
                 fill_below_level(cinfo.output_scanline, bm);
                 cinfo.output_scanline = cinfo.output_height;
-                jpeg_finish_decompress(&cinfo);
+                jFinDecompress(&cinfo);
                 return kPartialSuccess;
             }
             if (this->shouldCancelDecode()) {
                 return return_failure(cinfo, *bm, "shouldCancelDecode");
             }
             rowptr += bpr;
         }
-        jpeg_finish_decompress(&cinfo);
+        jFinDecompress(&cinfo);
         return kSuccess;
     }
 #endif
 
     // check for supported formats
     SkScaledBitmapSampler::SrcConfig sc;
     int srcBytesPerPixel;
 
     if (!get_src_config(cinfo, &sc, &srcBytesPerPixel)) {
         return return_failure(cinfo, *bm, "jpeg colorspace");
     }
 
     if (!sampler.begin(bm, sc, *this)) {
         return return_failure(cinfo, *bm, "sampler.begin");
     }
 
     SkAutoMalloc srcStorage(cinfo.output_width * srcBytesPerPixel);
     uint8_t* srcRow = (uint8_t*)srcStorage.get();
 
     //  Possibly skip initial rows [sampler.srcY0]
     if (!skip_src_rows(&cinfo, srcRow, sampler.srcY0())) {
         return return_failure(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);
+        int row_count = jReadScanlines(&cinfo, &rowptr, 1);
         if (0 == row_count) {
             // if row_count == 0, then we didn't get a scanline,
             // so return early.  We will return a partial image.
             fill_below_level(y, bm);
             cinfo.output_scanline = cinfo.output_height;
-            jpeg_finish_decompress(&cinfo);
+            jFinDecompress(&cinfo);
             return kPartialSuccess;
         }
         if (this->shouldCancelDecode()) {
             return return_failure(cinfo, *bm, "shouldCancelDecode");
         }
 
         if (JCS_CMYK == cinfo.out_color_space) {
             convert_CMYK_to_RGB(srcRow, cinfo.output_width);
         }
 
         sampler.next(srcRow);
         if (bm->height() - 1 == y) {
             // we're done
             break;
         }
 
         if (!skip_src_rows(&cinfo, srcRow, sampler.srcDY() - 1)) {
             return return_failure(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_failure(cinfo, *bm, "skip rows");
     }
-    jpeg_finish_decompress(&cinfo);
+    jFinDecompress(&cinfo);
 
     return kSuccess;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 enum SizeType {
     kSizeForMemoryAllocation_SizeType,
     kActualSize_SizeType
 };
@@ skipping 85 matching lines @@
                 bufferraw2[24 + i] = &outputV[scanline * rowBytesV];
             } else if (scanline == uvMaxH) {
                 bufferraw2[16 + i] = uLastRow;
                 bufferraw2[24 + i] = vLastRow;
                 hasUVLastRow = true;
             } else {
                 bufferraw2[16 + i] = dummyRow;
                 bufferraw2[24 + i] = dummyRow;
             }
         }
-        JDIMENSION scanlinesRead = jpeg_read_raw_data(&cinfo, bufferraw, yScanlinesToRead);
+        JDIMENSION scanlinesRead = jReadRawData(&cinfo, bufferraw, yScanlinesToRead);
 
         if (scanlinesRead == 0) {
             return false;
         }
 
         if (hasYLastRow) {
             memcpy(&outputY[yMaxH * rowBytesY], yLastRow, yWidth);
         }
         if (hasUVLastRow) {
             memcpy(&outputU[uvMaxH * rowBytesU], uLastRow, uvSize.width());
@@ skipping 26 matching lines @@
 
     // All objects need to be instantiated before this setjmp call so that
     // they will be cleaned up properly if an error occurs.
     if (setjmp(errorManager.fJmpBuf)) {
         return return_false(cinfo, "setjmp YUV8");
     }
 
     initialize_info(&cinfo, &srcManager);
     autoClean.set(&cinfo);
 
-    int status = jpeg_read_header(&cinfo, true);
+    int status = jReadHeader(&cinfo, true);
     if (status != JPEG_HEADER_OK) {
         return return_false(cinfo, "read_header YUV8");
     }
 
     if (!appears_to_be_yuv(cinfo)) {
         // 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;
     }
 
     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.
+        after jReadHeader(). To see the scaled dimensions, we have to call
+        jStrtDecompress(), and then read output_width and output_height.
     */
-    if (!jpeg_start_decompress(&cinfo)) {
+    if (!jStrtDecompress(&cinfo)) {
         return return_false(cinfo, "start_decompress YUV8");
     }
 
-    // Seems like jpeg_start_decompress is updating our opinion of whether cinfo represents YUV.
+    // Seems like jStrtDecompress is updating our opinion of whether cinfo represents YUV.
     // Again, not really an error.
     if (!appears_to_be_yuv(cinfo)) {
         return false;
     }
 
     if (!output_raw_data(cinfo, planes, rowBytes)) {
         return return_false(cinfo, "output_raw_data");
     }
 
     update_components_sizes(cinfo, componentSizes, kActualSize_SizeType);
-    jpeg_finish_decompress(&cinfo);
+    jFinDecompress(&cinfo);
 
     if (NULL != colorSpace) {
         *colorSpace = kJPEG_SkYUVColorSpace;
     }
 
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ skipping 33 matching lines @@
     set_error_mgr(cinfo, &sk_err);
 
     // FIXME: This sets cinfo->out_color_space, which we may change later
     // based on the config in onDecodeSubset. This should be fine, since
     // jpeg_init_read_tile_scanline will check out_color_space again after
     // that change (when it calls jinit_color_deconverter).
     (void) this->getBitmapColorType(cinfo);
 
     turn_off_visual_optimizations(cinfo);
 
-    // instead of jpeg_start_decompress() we start a tiled decompress
+    // instead of jStrtDecompress() we start a tiled decompress
     if (!imageIndex->startTileDecompress()) {
         return false;
     }
 
     SkASSERT(1 == cinfo->scale_num);
     fImageWidth = cinfo->output_width;
     fImageHeight = cinfo->output_height;
 
     if (width) {
         *width = fImageWidth;
@@ skipping 354 matching lines @@
             return false;
         }
 
         jpeg_compress_struct    cinfo;
         skjpeg_error_mgr        sk_err;
         skjpeg_destination_mgr  sk_wstream(stream);
 
         // allocate these before set call setjmp
         SkAutoMalloc    oneRow;
 
-        cinfo.err = jpeg_std_error(&sk_err);
+        cinfo.err = jStdError(&sk_err);
         sk_err.error_exit = skjpeg_error_exit;
         if (setjmp(sk_err.fJmpBuf)) {
             return false;
         }
 
         // Keep after setjmp or mark volatile.
         const WriteScanline writer = ChooseWriter(bm);
         if (NULL == writer) {
             return false;
         }
 
         jpeg_create_compress(&cinfo);
         cinfo.dest = &sk_wstream;
         cinfo.image_width = bm.width();
         cinfo.image_height = bm.height();
         cinfo.input_components = 3;
 #ifdef WE_CONVERT_TO_YUV
         cinfo.in_color_space = JCS_YCbCr;
 #else
         cinfo.in_color_space = JCS_RGB;
 #endif
         cinfo.input_gamma = 1;
 
-        jpeg_set_defaults(&cinfo);
-        jpeg_set_quality(&cinfo, quality, TRUE /* limit to baseline-JPEG values */);
+        jSetDefaults(&cinfo);
+        jSetQuality(&cinfo, quality, TRUE /* limit to baseline-JPEG values */);
 #ifdef DCT_IFAST_SUPPORTED
         cinfo.dct_method = JDCT_IFAST;
 #endif
 
-        jpeg_start_compress(&cinfo, TRUE);
+        jStrtCompress(&cinfo, TRUE);
 
         const int       width = bm.width();
         uint8_t*        oneRowP = (uint8_t*)oneRow.reset(width * 3);
 
         const SkPMColor* colors = bm.getColorTable() ? bm.getColorTable()->readColors() : NULL;
         const void*      srcRow = bm.getPixels();
 
         while (cinfo.next_scanline < cinfo.image_height) {
             JSAMPROW row_pointer[1];    /* pointer to JSAMPLE row[s] */
 
             writer(oneRowP, srcRow, width, colors);
             row_pointer[0] = oneRowP;
-            (void) jpeg_write_scanlines(&cinfo, row_pointer, 1);
+            (void) jWrtScanlines(&cinfo, row_pointer, 1);
             srcRow = (const void*)((const char*)srcRow + bm.rowBytes());
         }
 
-        jpeg_finish_compress(&cinfo);
-        jpeg_destroy_compress(&cinfo);
+        jFinCompress(&cinfo);
+        jDestCompress(&cinfo);
 
         return true;
     }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 DEFINE_DECODER_CREATOR(JPEGImageDecoder);
 DEFINE_ENCODER_CREATOR(JPEGImageEncoder);
 ///////////////////////////////////////////////////////////////////////////////
 
@@ skipping 28 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);