Assume all TURBO_HAS_* are true.

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 "SkMSAN.h"
 #include "SkJpegCodec.h"
@@ skipping 260 matching lines @@
     , fSwizzleSrcRow(nullptr)
     , fColorXformSrcRow(nullptr)
     , fSwizzlerSubset(SkIRect::MakeEmpty())
     , fICCData(std::move(iccData))
 {}
 
 /*
  * Return the row bytes of a particular image type and width
  */
 static size_t get_row_bytes(const j_decompress_ptr dinfo) {
-#ifdef TURBO_HAS_565
     const size_t colorBytes = (dinfo->out_color_space == JCS_RGB565) ? 2 :
             dinfo->out_color_components;
-#else
-    const size_t colorBytes = dinfo->out_color_components;
-#endif
     return dinfo->output_width * colorBytes;
 
 }
 
 /*
  *  Calculate output dimensions based on the provided factors.
  *
  *  Not to be used on the actual jpeg_decompress_struct used for decoding, since it will
  *  incorrectly modify num_components.
  */
@@ skipping 49 matching lines @@
     }
     SkASSERT(nullptr != decoderMgr);
     fDecoderMgr.reset(decoderMgr);
 
     fSwizzler.reset(nullptr);
     fSwizzleSrcRow = nullptr;
     fColorXformSrcRow = nullptr;
     fStorage.reset();
     fColorXform.reset(nullptr);
 
-#if !defined(TURBO_HAS_SKIP)
-    fSkipStorage.reset();
-#endif
-
     return true;
 }
 
 /*
  * Checks if the conversion between the input image and the requested output
  * image has been implemented
  * Sets the output color space
  */
 bool SkJpegCodec::setOutputColorSpace(const SkImageInfo& dstInfo, bool needsColorXform) {
     if (kUnknown_SkAlphaType == dstInfo.alphaType()) {
@@ skipping 31 matching lines @@
             }
             return true;
         case kRGB_565_SkColorType:
             if (needsColorXform) {
                 return false;
             }
 
             if (isCMYK) {
                 fDecoderMgr->dinfo()->out_color_space = JCS_CMYK;
             } else {
-#ifdef TURBO_HAS_565
                 fDecoderMgr->dinfo()->dither_mode = JDITHER_NONE;
                 fDecoderMgr->dinfo()->out_color_space = JCS_RGB565;
-#else
-                fDecoderMgr->dinfo()->out_color_space = JCS_RGB;
-#endif
             }
             return true;
         case kGray_8_SkColorType:
             if (needsColorXform || JCS_GRAYSCALE != encodedColorType) {
                 return false;
             }
 
             fDecoderMgr->dinfo()->out_color_space = JCS_GRAYSCALE;
             return true;
         case kRGBA_F16_SkColorType:
@@ skipping 142 matching lines @@
 
     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);
 
     J_COLOR_SPACE colorSpace = dinfo->out_color_space;
     if (JCS_CMYK == colorSpace || JCS_RGB == colorSpace) {

[msarett, 2016/08/23 18:13:48]

Remove " || JCS_RGB == colorSpace".  We will never decode to RGB now that we
always have RGB565 support.

         this->initializeSwizzler(dstInfo, options);
     }
 
     this->allocateStorage(dstInfo);
 
     int rows = this->readRows(dstInfo, dst, dstRowBytes, dstInfo.height());
     if (rows < dstInfo.height()) {
         *rowsDecoded = rows;
         return fDecoderMgr->returnFailure("Incomplete image data", kIncompleteInput);
     }
@@ skipping 25 matching lines @@
                 SkTAddOffset<uint32_t>(fStorage.get(), swizzleBytes) : nullptr;
     }
 }
 
 void SkJpegCodec::initializeSwizzler(const SkImageInfo& dstInfo, const Options& options) {
     // libjpeg-turbo may have already performed color conversion.  We must indicate the
     // appropriate format to the swizzler.
     SkEncodedInfo swizzlerInfo = this->getEncodedInfo();
     bool preSwizzled = true;
     switch (fDecoderMgr->dinfo()->out_color_space) {
         case JCS_RGB:

[msarett, 2016/08/23 18:13:47]

Remove this case.  Also probably makes sense to make this an "if" statement.

             preSwizzled = false;
             swizzlerInfo = SkEncodedInfo::Make(SkEncodedInfo::kRGB_Color,
                                                swizzlerInfo.alpha(),
                                                swizzlerInfo.bitsPerComponent());
             break;
         case JCS_CMYK:
             preSwizzled = false;
             swizzlerInfo = SkEncodedInfo::Make(SkEncodedInfo::kInvertedCMYK_Color,
                                                swizzlerInfo.alpha(),
                                                swizzlerInfo.bitsPerComponent());
@@ skipping 55 matching lines @@
 
     if (!this->initializeColorXform(dstInfo, needsColorXform)) {
         return fDecoderMgr->returnFailure("initializeColorXform", kInvalidParameters);
     }
 
     if (!jpeg_start_decompress(fDecoderMgr->dinfo())) {
         SkCodecPrintf("start decompress failed\n");
         return kInvalidInput;
     }
 
-#ifdef TURBO_HAS_CROP
     if (options.fSubset) {
         uint32_t startX = options.fSubset->x();
         uint32_t width = options.fSubset->width();
 
         // libjpeg-turbo may need to align startX to a multiple of the IDCT
         // block size.  If this is the case, it will decrease the value of
         // startX to the appropriate alignment and also increase the value
         // of width so that the right edge of the requested subset remains
         // the same.
         jpeg_crop_scanline(fDecoderMgr->dinfo(), &startX, &width);
@@ skipping 21 matching lines @@
         if (startX != (uint32_t) options.fSubset->x() ||
                 width != (uint32_t) options.fSubset->width()) {
             this->initializeSwizzler(dstInfo, options);
         }
     }
 
     // Make sure we have a swizzler if we are converting from CMYK.
     if (!fSwizzler && JCS_CMYK == fDecoderMgr->dinfo()->out_color_space) {
         this->initializeSwizzler(dstInfo, options);
     }
-#else
-    if (options.fSubset) {
-        fSwizzlerSubset = *options.fSubset;
-    }
-
-    // We will need a swizzler if we are performing a subset decode or
-    // converting from CMYK.
-    J_COLOR_SPACE colorSpace = fDecoderMgr->dinfo()->out_color_space;
-    if (options.fSubset || JCS_CMYK == colorSpace || JCS_RGB == colorSpace) {
-        this->initializeSwizzler(dstInfo, options);
-    }
-#endif
 
     this->allocateStorage(dstInfo);
 
     return kSuccess;
 }
 
 int SkJpegCodec::onGetScanlines(void* dst, int count, size_t dstRowBytes) {
     int rows = this->readRows(this->dstInfo(), dst, dstRowBytes, count);
     if (rows < count) {
         // This allows us to skip calling jpeg_finish_decompress().
         fDecoderMgr->dinfo()->output_scanline = this->dstInfo().height();
     }
 
     return rows;
 }
 
 bool SkJpegCodec::onSkipScanlines(int count) {
     // Set the jump location for libjpeg errors
     if (setjmp(fDecoderMgr->getJmpBuf())) {
         return fDecoderMgr->returnFalse("onSkipScanlines");
     }
 
-#ifdef TURBO_HAS_SKIP
     return (uint32_t) count == jpeg_skip_scanlines(fDecoderMgr->dinfo(), count);
-#else
-    uint8_t* ptr = fSkipStorage.get();
-    if (!ptr) {
-        fSkipStorage.reset(get_row_bytes(fDecoderMgr->dinfo()));
-        ptr = fSkipStorage.get();
-    }
-
-    for (int y = 0; y < count; y++) {
-        if (1 != jpeg_read_scanlines(fDecoderMgr->dinfo(), &ptr, 1)) {
-            return false;
-        }
-    }
-    return true;
-#endif
 }
 
 static bool is_yuv_supported(jpeg_decompress_struct* dinfo) {
     // Scaling is not supported in raw data mode.
     SkASSERT(dinfo->scale_num == dinfo->scale_denom);
 
     // I can't imagine that this would ever change, but we do depend on it.
     static_assert(8 == DCTSIZE, "DCTSIZE (defined in jpeg library) should always be 8.");
 
     if (JCS_YCbCr != dinfo->jpeg_color_space) {
@@ skipping 179 matching lines @@
 
         JDIMENSION linesRead = jpeg_read_raw_data(dinfo, yuv, numRowsPerBlock);
         if (linesRead < remainingRows) {
             // FIXME: Handle incomplete YUV decodes without signalling an error.
             return kInvalidInput;
         }
     }
 
     return kSuccess;
 }