OLD | NEW |
| (Empty) |
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 "core/platform/image-encoders/skia/JPEGImageEncoder.h" | |
33 | |
34 #include "SkBitmap.h" | |
35 #include "SkColorPriv.h" | |
36 #include "core/platform/graphics/ImageBuffer.h" | |
37 #include "platform/geometry/IntSize.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 WebCore { | |
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 int pix
elCount, 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 int pixelCount, unsi
gned 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 qu
ality) | |
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 pre
multiplied, 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 int, unsigned char* out
put); | |
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<unsign
ed char>* output) | |
201 { | |
202 SkAutoLockPixels bitmapLock(bitmap); | |
203 | |
204 if (bitmap.config() != SkBitmap::kARGB_8888_Config || !bitmap.getPixels()) | |
205 return false; // Only support 32 bit/pixel skia bitmaps. | |
206 | |
207 return encodePixels(IntSize(bitmap.width(), bitmap.height()), static_cast<un
signed char *>(bitmap.getPixels()), true, quality, output); | |
208 } | |
209 | |
210 bool JPEGImageEncoder::encode(const ImageDataBuffer& imageData, int quality, Vec
tor<unsigned char>* output) | |
211 { | |
212 return encodePixels(imageData.size(), imageData.data(), false, quality, outp
ut); | |
213 } | |
214 | |
215 } // namespace WebCore | |
OLD | NEW |