Call standard libjpeg/libjpeg-turbo APIs from SkJpegCodec

src/codec/SkJpegCodec.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkCodec.h"
 #include "SkJpegCodec.h"
 #include "SkJpegDecoderMgr.h"
 #include "SkJpegUtility_codec.h"
 #include "SkCodecPriv.h"
 #include "SkColorPriv.h"
 #include "SkScaledCodec.h"
 #include "SkScanlineDecoder.h"
 #include "SkStream.h"
 #include "SkTemplates.h"
 #include "SkTypes.h"
 
 // stdio is needed for libjpeg-turbo
 #include <stdio.h>
 
 extern "C" {
-    #include "jpeglibmangler.h"
     #include "jerror.h"
-    #include "jpegint.h"
     #include "jpeglib.h"
 }
 
 /*
  * Convert a row of CMYK samples to RGBA in place.
  * Note that this method moves the row pointer.
  * @param width the number of pixels in the row that is being converted
  *              CMYK is stored as four bytes per pixel
  */
 static void convert_CMYK_to_RGBA(uint8_t* row, uint32_t width) {
@@ skipping 68 matching lines @@
 
     // libjpeg errors will be caught and reported here
     if (setjmp(decoderMgr->getJmpBuf())) {
         return decoderMgr->returnFalse("setjmp");
     }
 
     // Initialize the decompress info and the source manager
     decoderMgr->init();
 
     // Read the jpeg header
-    if (JPEG_HEADER_OK != chromium_jpeg_read_header(decoderMgr->dinfo(), true)) {
+    if (JPEG_HEADER_OK != jpeg_read_header(decoderMgr->dinfo(), true)) {
         return decoderMgr->returnFalse("read_header");
     }
 
     if (nullptr != codecOut) {
         // Recommend the color type to decode to
         const SkColorType colorType = decoderMgr->getColorType();
 
         // Create image info object and the codec
         const SkImageInfo& imageInfo = SkImageInfo::Make(decoderMgr->dinfo()->image_width,
                 decoderMgr->dinfo()->image_height, colorType, kOpaque_SkAlphaType);
@@ skipping 14 matching lines @@
         streamDeleter.detach();
         return codec;
     }
     return nullptr;
 }
 
 SkJpegCodec::SkJpegCodec(const SkImageInfo& srcInfo, SkStream* stream,
         JpegDecoderMgr* decoderMgr)
     : INHERITED(srcInfo, stream)
     , fDecoderMgr(decoderMgr)
+    , fReadyState(decoderMgr->dinfo()->global_state)
 {}
 
 /*
  * Return the row bytes of a particular image type and width
  */
 static int get_row_bytes(const j_decompress_ptr dinfo) {
     int colorBytes = (dinfo->out_color_space == JCS_RGB565) ? 2 : dinfo->out_color_components;
     return dinfo->output_width * colorBytes;
 
 }
@@ skipping 21 matching lines @@
         num = 2;
     } else {
         num = 1;
     }
 
     // Set up a fake decompress struct in order to use libjpeg to calculate output dimensions
     jpeg_decompress_struct dinfo;
     sk_bzero(&dinfo, sizeof(dinfo));
     dinfo.image_width = this->getInfo().width();
     dinfo.image_height = this->getInfo().height();
-    dinfo.global_state = DSTATE_READY;
+    dinfo.global_state = fReadyState;
     dinfo.num_components = 0;
     dinfo.scale_num = num;
     dinfo.scale_denom = denom;
-    chromium_jpeg_calc_output_dimensions(&dinfo);
+    jpeg_calc_output_dimensions(&dinfo);
 
     // Return the calculated output dimensions for the given scale
     return SkISize::Make(dinfo.output_width, dinfo.output_height);
 }
 
 bool SkJpegCodec::onRewind() {
     JpegDecoderMgr* decoderMgr = nullptr;
     if (!ReadHeader(this->stream(), nullptr, &decoderMgr)) {
         return fDecoderMgr->returnFalse("could not rewind");
     }
@@ skipping 61 matching lines @@
 }
 
 /*
  * Checks if we can natively scale to the requested dimensions and natively scales the 
  * dimensions if possible
  */
 bool SkJpegCodec::nativelyScaleToDimensions(uint32_t dstWidth, uint32_t dstHeight) {
     // libjpeg-turbo can scale to 1/8, 1/4, 3/8, 1/2, 5/8, 3/4, 7/8, and 1/1
     fDecoderMgr->dinfo()->scale_denom = 8;
     fDecoderMgr->dinfo()->scale_num = 8;
-    chromium_jpeg_calc_output_dimensions(fDecoderMgr->dinfo());
+    jpeg_calc_output_dimensions(fDecoderMgr->dinfo());
     while (fDecoderMgr->dinfo()->output_width != dstWidth ||
             fDecoderMgr->dinfo()->output_height != dstHeight) {
 
         // Return a failure if we have tried all of the possible scales
         if (1 == fDecoderMgr->dinfo()->scale_num ||
                 dstWidth > fDecoderMgr->dinfo()->output_width ||
                 dstHeight > fDecoderMgr->dinfo()->output_height) {
             // reset native scale settings on failure because this may be supported by the swizzler 
             this->fDecoderMgr->dinfo()->scale_num = 8;
-            chromium_jpeg_calc_output_dimensions(this->fDecoderMgr->dinfo());
+            jpeg_calc_output_dimensions(this->fDecoderMgr->dinfo());
             return false;
         }
 
         // Try the next scale
         fDecoderMgr->dinfo()->scale_num -= 1;
-        chromium_jpeg_calc_output_dimensions(fDecoderMgr->dinfo());
+        jpeg_calc_output_dimensions(fDecoderMgr->dinfo());
     }
     return true;
 }
 
 /*
  * Performs the jpeg decode
  */
 SkCodec::Result SkJpegCodec::onGetPixels(const SkImageInfo& dstInfo,
                                          void* dst, size_t dstRowBytes,
                                          const Options& options, SkPMColor*, int*) {
@@ skipping 19 matching lines @@
     if (!this->setOutputColorSpace(dstInfo)) {
         return fDecoderMgr->returnFailure("conversion_possible", kInvalidConversion);
     }
 
     // Perform the necessary scaling
     if (!this->nativelyScaleToDimensions(dstInfo.width(), dstInfo.height())) {
         return fDecoderMgr->returnFailure("cannot scale to requested dims", kInvalidScale);
     }
 
     // Now, given valid output dimensions, we can start the decompress
-    if (!chromium_jpeg_start_decompress(dinfo)) {
+    if (!jpeg_start_decompress(dinfo)) {
         return fDecoderMgr->returnFailure("startDecompress", kInvalidInput);
     }
 
     // The recommended output buffer height should always be 1 in high quality modes.
     // If it's not, we want to know because it means our strategy is not optimal.
     SkASSERT(1 == dinfo->rec_outbuf_height);
 
     // Perform the decode a single row at a time
     uint32_t dstHeight = dstInfo.height();
     JSAMPLE* dstRow = (JSAMPLE*) dst;
     for (uint32_t y = 0; y < dstHeight; y++) {
         // Read rows of the image
-        uint32_t rowsDecoded = chromium_jpeg_read_scanlines(dinfo, &dstRow, 1);
+        uint32_t rowsDecoded = jpeg_read_scanlines(dinfo, &dstRow, 1);
 
         // If we cannot read enough rows, assume the input is incomplete
         if (rowsDecoded != 1) {
             // Fill the remainder of the image with black. This error handling
             // behavior is unspecified but SkCodec consistently uses black as
             // the fill color for opaque images.  If the destination is kGray,
             // the low 8 bits of SK_ColorBLACK will be used.  Conveniently,
             // these are zeros, which is the representation for black in kGray.
             // If the destination is kRGB_565, the low 16 bits of SK_ColorBLACK
             // will be used.  Conveniently, these are zeros, which is the
             // representation for black in kRGB_565.
             if (kNo_ZeroInitialized == options.fZeroInitialized ||
                     kN32_SkColorType == dstInfo.colorType()) {
                 SkSwizzler::Fill(dstRow, dstInfo, dstRowBytes, dstHeight - y,
                         SK_ColorBLACK, nullptr);
             }
 
             // Prevent libjpeg from failing on incomplete decode
             dinfo->output_scanline = dstHeight;
 
             // Finish the decode and indicate that the input was incomplete.
-            chromium_jpeg_finish_decompress(dinfo);
+            jpeg_finish_decompress(dinfo);
             return fDecoderMgr->returnFailure("Incomplete image data", kIncompleteInput);
         }
 
         // Convert to RGBA if necessary
         if (JCS_CMYK == dinfo->out_color_space) {
             convert_CMYK_to_RGBA(dstRow, dstInfo.width());
         }
 
         // Move to the next row
         dstRow = SkTAddOffset<JSAMPLE>(dstRow, dstRowBytes);
     }
-    chromium_jpeg_finish_decompress(dinfo);
+    jpeg_finish_decompress(dinfo);
 
     return kSuccess;
 }
 
 /*
  * Enable scanline decoding for jpegs
  */
 class SkJpegScanlineDecoder : public SkScanlineDecoder {
 public:
     SkJpegScanlineDecoder(const SkImageInfo& srcInfo, SkJpegCodec* codec)
@@ skipping 76 matching lines @@
                 return result;
             }
             fStorage.reset(get_row_bytes(fCodec->fDecoderMgr->dinfo()));
             fSrcRow = static_cast<uint8_t*>(fStorage.get());
         } else {
             fSrcRow = nullptr;
             fSwizzler.reset(nullptr);
         }
 
         // Now, given valid output dimensions, we can start the decompress
-        if (!chromium_jpeg_start_decompress(fCodec->fDecoderMgr->dinfo())) {
+        if (!jpeg_start_decompress(fCodec->fDecoderMgr->dinfo())) {
             SkCodecPrintf("start decompress failed\n");
             return SkCodec::kInvalidInput;
         }
 
         fOpts = options;
 
         return SkCodec::kSuccess;
     }
 
     virtual ~SkJpegScanlineDecoder() {
         if (setjmp(fCodec->fDecoderMgr->getJmpBuf())) {
             SkCodecPrintf("setjmp: Error in libjpeg finish_decompress\n");
             return;
         }
 
         // We may not have decoded the entire image.  Prevent libjpeg-turbo from failing on a
         // partial decode.
         fCodec->fDecoderMgr->dinfo()->output_scanline = fCodec->getInfo().height();
-        chromium_jpeg_finish_decompress(fCodec->fDecoderMgr->dinfo());
+        jpeg_finish_decompress(fCodec->fDecoderMgr->dinfo());
     }
 
     SkCodec::Result onGetScanlines(void* dst, int count, size_t rowBytes) override {
         // Set the jump location for libjpeg errors
         if (setjmp(fCodec->fDecoderMgr->getJmpBuf())) {
             return fCodec->fDecoderMgr->returnFailure("setjmp", SkCodec::kInvalidInput);
         }
         // Read rows one at a time
         JSAMPLE* dstRow;
         if (fSwizzler) {
             // write data to storage row, then sample using swizzler         
             dstRow = fSrcRow;
         } else {
             // write data directly to dst
             dstRow = (JSAMPLE*) dst;
         }
 
         for (int y = 0; y < count; y++) {
             // Read row of the image
-            uint32_t rowsDecoded =
-                    chromium_jpeg_read_scanlines(fCodec->fDecoderMgr->dinfo(), &dstRow, 1);
+            uint32_t rowsDecoded = jpeg_read_scanlines(fCodec->fDecoderMgr->dinfo(), &dstRow, 1);
             if (rowsDecoded != 1) {
                 if (SkCodec::kNo_ZeroInitialized == fOpts.fZeroInitialized ||
                         kN32_SkColorType == this->dstInfo().colorType()) {
                     SkSwizzler::Fill(dstRow, this->dstInfo(), rowBytes,
                             count - y, SK_ColorBLACK, nullptr);
                 }
                 fCodec->fDecoderMgr->dinfo()->output_scanline = this->dstInfo().height();
                 return SkCodec::kIncompleteInput;
             }
 
             // Convert to RGBA if necessary
             if (JCS_CMYK == fCodec->fDecoderMgr->dinfo()->out_color_space) {
                 convert_CMYK_to_RGBA(dstRow, fCodec->fDecoderMgr->dinfo()->output_width);
             }
 
             if(fSwizzler) {
                 // use swizzler to sample row
                 fSwizzler->swizzle(dst, dstRow);
                 dst = SkTAddOffset<JSAMPLE>(dst, rowBytes);
             } else {
                 dstRow = SkTAddOffset<JSAMPLE>(dstRow, rowBytes);
             }
         }
         return SkCodec::kSuccess;
     }
 
 #ifndef TURBO_HAS_SKIP
 // TODO (msarett): Make this a member function and avoid reallocating the
 //                 memory buffer on each call to skip.
-#define chromium_jpeg_skip_scanlines(dinfo, count)                           \
+#define jpeg_skip_scanlines(dinfo, count)                                    \
     SkAutoMalloc storage(get_row_bytes(dinfo));                              \
     uint8_t* storagePtr = static_cast<uint8_t*>(storage.get());              \
     for (int y = 0; y < count; y++) {                                        \
-        chromium_jpeg_read_scanlines(dinfo, &storagePtr, 1);                 \
+        jpeg_read_scanlines(dinfo, &storagePtr, 1);                          \
     }
 #endif
 
     SkCodec::Result onSkipScanlines(int count) override {
         // Set the jump location for libjpeg errors
         if (setjmp(fCodec->fDecoderMgr->getJmpBuf())) {
             return fCodec->fDecoderMgr->returnFailure("setjmp", SkCodec::kInvalidInput);
         }
 
-        chromium_jpeg_skip_scanlines(fCodec->fDecoderMgr->dinfo(), count);
+        jpeg_skip_scanlines(fCodec->fDecoderMgr->dinfo(), count);
 
         return SkCodec::kSuccess;
     }
 
     SkEncodedFormat onGetEncodedFormat() const override {
         return kJPEG_SkEncodedFormat;
     }
 
 private:
     SkAutoTDelete<SkJpegCodec> fCodec;
     SkAutoMalloc               fStorage;    // Only used if sampling is needed
     uint8_t*                   fSrcRow;     // Only used if sampling is needed
     SkCodec::Options           fOpts;
     SkAutoTDelete<SkSwizzler>  fSwizzler;
 
     typedef SkScanlineDecoder INHERITED;
 };
 
 SkScanlineDecoder* SkJpegCodec::NewSDFromStream(SkStream* stream) {
     SkAutoTDelete<SkJpegCodec> codec(static_cast<SkJpegCodec*>(SkJpegCodec::NewFromStream(stream)));
     if (!codec) {
         return nullptr;
     }
 
     const SkImageInfo& srcInfo = codec->getInfo();
 
     // Return the new scanline decoder
     return new SkJpegScanlineDecoder(srcInfo, codec.detach());
 }