Remove JPEG encoder SkBitmap API

Source/platform/image-encoders/skia/JPEGImageEncoder.cpp

 /*
  * Copyright (c) 2010, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 13 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "platform/image-encoders/skia/JPEGImageEncoder.h"
 
-#include "SkBitmap.h"
 #include "SkColorPriv.h"
 #include "platform/geometry/IntSize.h"
 #include "platform/graphics/ImageBuffer.h"
+
 extern "C" {
 #include <setjmp.h>
 #include <stdio.h> // jpeglib.h needs stdio.h FILE
 #include "jpeglib.h"
 }
 
 namespace blink {
 
 struct JPEGOutputBuffer : public jpeg_destination_mgr {
     Vector<unsigned char>* output;
@@ skipping 24 matching lines @@
     const size_t size = out->buffer.size() - out->free_in_buffer;
     out->output->append(out->buffer.data(), size);
 }
 
 static void handleError(j_common_ptr common)
 {
     jmp_buf* jumpBufferPtr = static_cast<jmp_buf*>(common->client_data);
     longjmp(*jumpBufferPtr, -1);
 }
 
-static void preMultipliedBGRAtoRGB(const unsigned char* pixels, unsigned pixelCount, unsigned char* output)
-{
-    const SkPMColor* input = reinterpret_cast_ptr<const SkPMColor*>(pixels);
-    for (; pixelCount-- > 0; ++input) {
-        *output++ = SkGetPackedR32(*input);
-        *output++ = SkGetPackedG32(*input);
-        *output++ = SkGetPackedB32(*input);
-    }
-}
-
 static void RGBAtoRGB(const unsigned char* pixels, unsigned pixelCount, unsigned char* output)
 {
+    // Per <canvas> spec, composite the input image pixels source-over on black.
+
     for (; pixelCount-- > 0; pixels += 4) {
-        // Do source-over composition on black.
         unsigned char alpha = pixels[3];
         if (alpha != 255) {
             *output++ = SkMulDiv255Round(pixels[0], alpha);
             *output++ = SkMulDiv255Round(pixels[1], alpha);
             *output++ = SkMulDiv255Round(pixels[2], alpha);
         } else {
             *output++ = pixels[0];
             *output++ = pixels[1];
             *output++ = pixels[2];
         }
     }
 }
 
 static void disableSubsamplingForHighQuality(jpeg_compress_struct* cinfo, int quality)
 {
     if (quality < 100)
         return;
 
     for (int i = 0; i < MAX_COMPONENTS; ++i) {
         cinfo->comp_info[i].h_samp_factor = 1;
         cinfo->comp_info[i].v_samp_factor = 1;
     }
 }
 
-static bool encodePixels(IntSize imageSize, const unsigned char* inputPixels, bool premultiplied, int quality, Vector<unsigned char>* output)
+static bool encodePixels(IntSize imageSize, const unsigned char* inputPixels, int quality, Vector<unsigned char>* output)
 {
     if (imageSize.width() <= 0 || imageSize.height() <= 0)
         return false;
 
     JPEGOutputBuffer destination;
     destination.output = output;
     Vector<JSAMPLE> row;
 
     jpeg_compress_struct cinfo;
     jpeg_error_mgr error;
     cinfo.err = jpeg_std_error(&error);
     error.error_exit = handleError;
     jmp_buf jumpBuffer;
     cinfo.client_data = &jumpBuffer;
 
     if (setjmp(jumpBuffer)) {
         jpeg_destroy_compress(&cinfo);
         return false;
     }
 
     jpeg_create_compress(&cinfo);
     cinfo.dest = &destination;
     cinfo.dest->init_destination = prepareOutput;
     cinfo.dest->empty_output_buffer = writeOutput;
     cinfo.dest->term_destination = finishOutput;
 
     cinfo.image_height = imageSize.height();
     cinfo.image_width = imageSize.width();
-
-#if defined(JCS_EXTENSIONS)
-    if (premultiplied) {
-        cinfo.in_color_space = SK_B32_SHIFT ? JCS_EXT_RGBX : JCS_EXT_BGRX;
-
-        cinfo.input_components = 4;
-
-        jpeg_set_defaults(&cinfo);
-        jpeg_set_quality(&cinfo, quality, TRUE);
-        disableSubsamplingForHighQuality(&cinfo, quality);
-        jpeg_start_compress(&cinfo, TRUE);
-
-        unsigned char* pixels = const_cast<unsigned char*>(inputPixels);
-        const size_t pixelRowStride = cinfo.image_width * 4;
-        while (cinfo.next_scanline < cinfo.image_height) {
-            jpeg_write_scanlines(&cinfo, &pixels, 1);
-            pixels += pixelRowStride;
-        }
-
-        jpeg_finish_compress(&cinfo);
-        jpeg_destroy_compress(&cinfo);
-        return true;
-    }
-#endif
-
     cinfo.in_color_space = JCS_RGB;
     cinfo.input_components = 3;
 
-    void (*extractRowRGB)(const unsigned char*, unsigned, unsigned char* output);
-    extractRowRGB = &RGBAtoRGB;
-    if (premultiplied)
-        extractRowRGB = &preMultipliedBGRAtoRGB;
-
     jpeg_set_defaults(&cinfo);
     jpeg_set_quality(&cinfo, quality, TRUE);
     disableSubsamplingForHighQuality(&cinfo, quality);
     jpeg_start_compress(&cinfo, TRUE);
 
     unsigned char* pixels = const_cast<unsigned char*>(inputPixels);
     row.resize(cinfo.image_width * cinfo.input_components);
     const size_t pixelRowStride = cinfo.image_width * 4;
     while (cinfo.next_scanline < cinfo.image_height) {
         JSAMPLE* rowData = row.data();
-        extractRowRGB(pixels, cinfo.image_width, rowData);
+        RGBAtoRGB(pixels, cinfo.image_width, rowData);
         jpeg_write_scanlines(&cinfo, &rowData, 1);
         pixels += pixelRowStride;
     }
 
     jpeg_finish_compress(&cinfo);
     jpeg_destroy_compress(&cinfo);
     return true;
 }
 
-bool JPEGImageEncoder::encode(const SkBitmap& bitmap, int quality, Vector<unsigned char>* output)
-{
-    SkAutoLockPixels bitmapLock(bitmap);
-
-    if (bitmap.colorType() != kN32_SkColorType || !bitmap.getPixels())
-        return false; // Only support 32 bit/pixel skia bitmaps.
-
-    return encodePixels(IntSize(bitmap.width(), bitmap.height()), static_cast<unsigned char *>(bitmap.getPixels()), true, quality, output);
-}
-
 bool JPEGImageEncoder::encode(const ImageDataBuffer& imageData, int quality, Vector<unsigned char>* output)
 {
     if (!imageData.pixels())
         return false;
 
-    return encodePixels(IntSize(imageData.width(), imageData.height()), imageData.pixels(), false, quality, output);
+    return encodePixels(IntSize(imageData.width(), imageData.height()), imageData.pixels(), quality, output);
 }
 
 } // namespace blink