1 /* 2 * Copyright (c) 2010, Google Inc. All rights reserved. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions are 6 * met: 7 * 8 * * Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * * Redistributions in binary form must reproduce the above 11 * copyright notice, this list of conditions and the following disclaimer 12 * in the documentation and/or other materials provided with the 13 * distribution. 14 * * Neither the name of Google Inc. nor the names of its 15 * contributors may be used to endorse or promote products derived from 16 * this software without specific prior written permission. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 */ 30 31 #include "config.h" 32 #include "platform/image-encoders/skia/JPEGImageEncoder.h" 33 34 #include "SkBitmap.h" 35 #include "SkColorPriv.h" 36 #include "platform/geometry/IntSize.h" 37 #include "platform/graphics/ImageBuffer.h" 38 extern "C" { 39 #include <setjmp.h> 40 #include <stdio.h> // jpeglib.h needs stdio.h FILE 41 #include "jpeglib.h" 42 } 43 44 namespace blink { 45 46 struct JPEGOutputBuffer : public jpeg_destination_mgr { 47 Vector<unsigned char>* output; 48 Vector<unsigned char> buffer; 49 }; 50 51 static void prepareOutput(j_compress_ptr cinfo) 52 { 53 JPEGOutputBuffer* out = static_cast<JPEGOutputBuffer*>(cinfo->dest); 54 const size_t internalBufferSize = 8192; 55 out->buffer.resize(internalBufferSize); 56 out->next_output_byte = out->buffer.data(); 57 out->free_in_buffer = out->buffer.size(); 58 } 59 60 static boolean writeOutput(j_compress_ptr cinfo) 61 { 62 JPEGOutputBuffer* out = static_cast<JPEGOutputBuffer*>(cinfo->dest); 63 out->output->append(out->buffer.data(), out->buffer.size()); 64 out->next_output_byte = out->buffer.data(); 65 out->free_in_buffer = out->buffer.size(); 66 return TRUE; 67 } 68 69 static void finishOutput(j_compress_ptr cinfo) 70 { 71 JPEGOutputBuffer* out = static_cast<JPEGOutputBuffer*>(cinfo->dest); 72 const size_t size = out->buffer.size() - out->free_in_buffer; 73 out->output->append(out->buffer.data(), size); 74 } 75 76 static void handleError(j_common_ptr common) 77 { 78 jmp_buf* jumpBufferPtr = static_cast<jmp_buf*>(common->client_data); 79 longjmp(*jumpBufferPtr, -1); 80 } 81 82 static void preMultipliedBGRAtoRGB(const unsigned char* pixels, unsigned pixelCount, unsigned char* output) 83 { 84 const SkPMColor* input = reinterpret_cast_ptr<const SkPMColor*>(pixels); 85 for (; pixelCount-- > 0; ++input) { 86 *output++ = SkGetPackedR32(*input); 87 *output++ = SkGetPackedG32(*input); 88 *output++ = SkGetPackedB32(*input); 89 } 90 } 91 92 static void RGBAtoRGB(const unsigned char* pixels, unsigned pixelCount, unsigned char* output) 93 { 94 for (; pixelCount-- > 0; pixels += 4) { 95 // Do source-over composition on black. 96 unsigned char alpha = pixels[3]; 97 if (alpha != 255) { 98 *output++ = SkMulDiv255Round(pixels[0], alpha); 99 *output++ = SkMulDiv255Round(pixels[1], alpha); 100 *output++ = SkMulDiv255Round(pixels[2], alpha); 101 } else { 102 *output++ = pixels[0]; 103 *output++ = pixels[1]; 104 *output++ = pixels[2]; 105 } 106 } 107 } 108 109 static void disableSubsamplingForHighQuality(jpeg_compress_struct* cinfo, int quality) 110 { 111 if (quality < 100) 112 return; 113 114 for (int i = 0; i < MAX_COMPONENTS; ++i) { 115 cinfo->comp_info[i].h_samp_factor = 1; 116 cinfo->comp_info[i].v_samp_factor = 1; 117 } 118 } 119 120 static bool encodePixels(IntSize imageSize, unsigned char* inputPixels, bool premultiplied, int quality, Vector<unsigned char>* output) 121 { 122 JPEGOutputBuffer destination; 123 destination.output = output; 124 Vector<JSAMPLE> row; 125 126 jpeg_compress_struct cinfo; 127 jpeg_error_mgr error; 128 cinfo.err = jpeg_std_error(&error); 129 error.error_exit = handleError; 130 jmp_buf jumpBuffer; 131 cinfo.client_data = &jumpBuffer; 132 133 if (setjmp(jumpBuffer)) { 134 jpeg_destroy_compress(&cinfo); 135 return false; 136 } 137 138 jpeg_create_compress(&cinfo); 139 cinfo.dest = &destination; 140 cinfo.dest->init_destination = prepareOutput; 141 cinfo.dest->empty_output_buffer = writeOutput; 142 cinfo.dest->term_destination = finishOutput; 143 144 imageSize.clampNegativeToZero(); 145 cinfo.image_height = imageSize.height(); 146 cinfo.image_width = imageSize.width(); 147 148 #if defined(JCS_EXTENSIONS) 149 if (premultiplied) { 150 cinfo.in_color_space = SK_B32_SHIFT ? JCS_EXT_RGBX : JCS_EXT_BGRX; 151 152 cinfo.input_components = 4; 153 154 jpeg_set_defaults(&cinfo); 155 jpeg_set_quality(&cinfo, quality, TRUE); 156 disableSubsamplingForHighQuality(&cinfo, quality); 157 jpeg_start_compress(&cinfo, TRUE); 158 159 unsigned char* pixels = inputPixels; 160 const size_t pixelRowStride = cinfo.image_width * 4; 161 while (cinfo.next_scanline < cinfo.image_height) { 162 jpeg_write_scanlines(&cinfo, &pixels, 1); 163 pixels += pixelRowStride; 164 } 165 166 jpeg_finish_compress(&cinfo); 167 jpeg_destroy_compress(&cinfo); 168 return true; 169 } 170 #endif 171 172 cinfo.in_color_space = JCS_RGB; 173 cinfo.input_components = 3; 174 175 void (*extractRowRGB)(const unsigned char*, unsigned, unsigned char* output); 176 extractRowRGB = &RGBAtoRGB; 177 if (premultiplied) 178 extractRowRGB = &preMultipliedBGRAtoRGB; 179 180 jpeg_set_defaults(&cinfo); 181 jpeg_set_quality(&cinfo, quality, TRUE); 182 disableSubsamplingForHighQuality(&cinfo, quality); 183 jpeg_start_compress(&cinfo, TRUE); 184 185 unsigned char* pixels = inputPixels; 186 row.resize(cinfo.image_width * cinfo.input_components); 187 const size_t pixelRowStride = cinfo.image_width * 4; 188 while (cinfo.next_scanline < cinfo.image_height) { 189 JSAMPLE* rowData = row.data(); 190 extractRowRGB(pixels, cinfo.image_width, rowData); 191 jpeg_write_scanlines(&cinfo, &rowData, 1); 192 pixels += pixelRowStride; 193 } 194 195 jpeg_finish_compress(&cinfo); 196 jpeg_destroy_compress(&cinfo); 197 return true; 198 } 199 200 bool JPEGImageEncoder::encode(const SkBitmap& bitmap, int quality, Vector<unsigned char>* output) 201 { 202 SkAutoLockPixels bitmapLock(bitmap); 203 204 if (bitmap.colorType() != kN32_SkColorType || !bitmap.getPixels()) 205 return false; // Only support 32 bit/pixel skia bitmaps. 206 207 return encodePixels(IntSize(bitmap.width(), bitmap.height()), static_cast<unsigned char *>(bitmap.getPixels()), true, quality, output); 208 } 209 210 bool JPEGImageEncoder::encode(const ImageDataBuffer& imageData, int quality, Vector<unsigned char>* output) 211 { 212 return encodePixels(imageData.size(), imageData.data(), false, quality, output); 213 } 214 215 } // namespace blink 216