Commit | Line | Data |
---|---|---|
e9c4b1a2 JS |
1 | ///////////////////////////////////////////////////////////////////////////// |
2 | // Name: imagjpeg.cpp | |
3 | // Purpose: wxImage JPEG handler | |
b59ff3c9 | 4 | // Author: Vaclav Slavik |
e9c4b1a2 | 5 | // RCS-ID: $Id$ |
b59ff3c9 | 6 | // Copyright: (c) Vaclav Slavik |
e9c4b1a2 JS |
7 | // Licence: wxWindows licence |
8 | ///////////////////////////////////////////////////////////////////////////// | |
9 | ||
1aaaa712 VS |
10 | #ifdef __GNUG__ |
11 | #pragma implementation "imagjpeg.h" | |
12 | #endif | |
e9c4b1a2 JS |
13 | |
14 | // For compilers that support precompilation, includes "wx.h". | |
15 | #include "wx/wxprec.h" | |
16 | ||
17 | #ifdef __BORLANDC__ | |
18 | #pragma hdrstop | |
19 | #endif | |
20 | ||
ce4169a4 RR |
21 | #include "wx/defs.h" |
22 | ||
c96ea657 | 23 | #if wxUSE_IMAGE && wxUSE_LIBJPEG |
ce4169a4 | 24 | |
1aaaa712 | 25 | #include "wx/imagjpeg.h" |
e9c4b1a2 JS |
26 | #include "wx/bitmap.h" |
27 | #include "wx/debug.h" | |
28 | #include "wx/log.h" | |
29 | #include "wx/app.h" | |
995612e2 VZ |
30 | extern "C" |
31 | { | |
32 | #include "jpeglib.h" | |
e9c4b1a2 | 33 | } |
e9c4b1a2 JS |
34 | #include "wx/filefn.h" |
35 | #include "wx/wfstream.h" | |
36 | #include "wx/intl.h" | |
37 | #include "wx/module.h" | |
38 | ||
39 | // For memcpy | |
40 | #include <string.h> | |
b59ff3c9 VS |
41 | // For JPEG library error handling |
42 | #include <setjmp.h> | |
e9c4b1a2 JS |
43 | |
44 | #ifdef __SALFORDC__ | |
45 | #ifdef FAR | |
46 | #undef FAR | |
47 | #endif | |
48 | #endif | |
49 | ||
50 | #ifdef __WXMSW__ | |
51 | #include <windows.h> | |
52 | #endif | |
53 | ||
54 | //----------------------------------------------------------------------------- | |
55 | // wxJPEGHandler | |
56 | //----------------------------------------------------------------------------- | |
57 | ||
e9c4b1a2 | 58 | IMPLEMENT_DYNAMIC_CLASS(wxJPEGHandler,wxImageHandler) |
e9c4b1a2 | 59 | |
9ab6ee85 GRG |
60 | #if wxUSE_STREAMS |
61 | ||
e9c4b1a2 JS |
62 | //------------- JPEG Data Source Manager |
63 | ||
1aaaa712 VS |
64 | #define JPEG_IO_BUFFER_SIZE 2048 |
65 | ||
e9c4b1a2 JS |
66 | typedef struct { |
67 | struct jpeg_source_mgr pub; /* public fields */ | |
995612e2 | 68 | |
e9c4b1a2 | 69 | JOCTET* buffer; /* start of buffer */ |
1aaaa712 | 70 | wxInputStream *stream; |
e9c4b1a2 JS |
71 | } my_source_mgr; |
72 | ||
73 | typedef my_source_mgr * my_src_ptr; | |
74 | ||
74e3313b | 75 | METHODDEF(void) my_init_source ( j_decompress_ptr WXUNUSED(cinfo) ) |
e9c4b1a2 JS |
76 | { |
77 | } | |
78 | ||
1aaaa712 | 79 | METHODDEF(boolean) my_fill_input_buffer ( j_decompress_ptr cinfo ) |
e9c4b1a2 | 80 | { |
1aaaa712 VS |
81 | my_src_ptr src = (my_src_ptr) cinfo->src; |
82 | ||
83 | src->pub.next_input_byte = src->buffer; | |
84 | src->pub.bytes_in_buffer = src->stream->Read(src->buffer, JPEG_IO_BUFFER_SIZE).LastRead(); | |
85 | ||
86 | if (src->pub.bytes_in_buffer == 0) // check for end-of-stream | |
87 | { | |
88 | // Insert a fake EOI marker | |
89 | src->buffer[0] = 0xFF; | |
90 | src->buffer[1] = JPEG_EOI; | |
91 | src->pub.bytes_in_buffer = 2; | |
92 | } | |
e9c4b1a2 JS |
93 | return TRUE; |
94 | } | |
95 | ||
96 | METHODDEF(void) my_skip_input_data ( j_decompress_ptr cinfo, long num_bytes ) | |
97 | { | |
1aaaa712 VS |
98 | if (num_bytes > 0) |
99 | { | |
100 | my_src_ptr src = (my_src_ptr) cinfo->src; | |
101 | ||
33ac7e6f | 102 | while (num_bytes > (long)src->pub.bytes_in_buffer) |
1aaaa712 VS |
103 | { |
104 | num_bytes -= (long) src->pub.bytes_in_buffer; | |
105 | src->pub.fill_input_buffer(cinfo); | |
106 | } | |
107 | src->pub.next_input_byte += (size_t) num_bytes; | |
108 | src->pub.bytes_in_buffer -= (size_t) num_bytes; | |
109 | } | |
e9c4b1a2 JS |
110 | } |
111 | ||
112 | METHODDEF(void) my_term_source ( j_decompress_ptr cinfo ) | |
113 | { | |
114 | my_src_ptr src = (my_src_ptr) cinfo->src; | |
995612e2 | 115 | |
1aaaa712 | 116 | if (src->pub.bytes_in_buffer > 0) |
3ca6a5f0 | 117 | src->stream->SeekI(-(long)src->pub.bytes_in_buffer, wxFromCurrent); |
1aaaa712 | 118 | delete[] src->buffer; |
e9c4b1a2 JS |
119 | } |
120 | ||
121 | void jpeg_wxio_src( j_decompress_ptr cinfo, wxInputStream& infile ) | |
122 | { | |
123 | my_src_ptr src; | |
995612e2 VZ |
124 | |
125 | if (cinfo->src == NULL) { /* first time for this JPEG object? */ | |
e9c4b1a2 JS |
126 | cinfo->src = (struct jpeg_source_mgr *) |
127 | (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, | |
128 | sizeof(my_source_mgr)); | |
129 | src = (my_src_ptr) cinfo->src; | |
130 | } | |
131 | src = (my_src_ptr) cinfo->src; | |
1aaaa712 VS |
132 | src->pub.bytes_in_buffer = 0; /* forces fill_input_buffer on first read */ |
133 | src->buffer = new JOCTET[JPEG_IO_BUFFER_SIZE]; | |
134 | src->pub.next_input_byte = NULL; /* until buffer loaded */ | |
135 | src->stream = &infile; | |
995612e2 | 136 | |
e9c4b1a2 JS |
137 | src->pub.init_source = my_init_source; |
138 | src->pub.fill_input_buffer = my_fill_input_buffer; | |
139 | src->pub.skip_input_data = my_skip_input_data; | |
140 | src->pub.resync_to_restart = jpeg_resync_to_restart; /* use default method */ | |
141 | src->pub.term_source = my_term_source; | |
142 | } | |
143 | ||
144 | ||
b59ff3c9 VS |
145 | // JPEG error manager: |
146 | ||
147 | struct my_error_mgr { | |
995612e2 | 148 | struct jpeg_error_mgr pub; /* "public" fields */ |
b59ff3c9 | 149 | |
995612e2 | 150 | jmp_buf setjmp_buffer; /* for return to caller */ |
b59ff3c9 VS |
151 | }; |
152 | ||
153 | typedef struct my_error_mgr * my_error_ptr; | |
154 | ||
155 | /* | |
156 | * Here's the routine that will replace the standard error_exit method: | |
157 | */ | |
158 | ||
159 | METHODDEF(void) | |
160 | my_error_exit (j_common_ptr cinfo) | |
161 | { | |
162 | /* cinfo->err really points to a my_error_mgr struct, so coerce pointer */ | |
163 | my_error_ptr myerr = (my_error_ptr) cinfo->err; | |
164 | ||
165 | /* Always display the message. */ | |
166 | /* We could postpone this until after returning, if we chose. */ | |
deb2fec0 | 167 | if (cinfo->err->output_message) (*cinfo->err->output_message) (cinfo); |
b59ff3c9 VS |
168 | |
169 | /* Return control to the setjmp point */ | |
170 | longjmp(myerr->setjmp_buffer, 1); | |
171 | } | |
172 | ||
3ca6a5f0 BP |
173 | // temporarily disable the warning C4611 (interaction between '_setjmp' and |
174 | // C++ object destruction is non-portable) - I don't see any dtors here | |
175 | #ifdef __VISUALC__ | |
176 | #pragma warning(disable:4611) | |
177 | #endif /* VC++ */ | |
e9c4b1a2 | 178 | |
700ec454 | 179 | bool wxJPEGHandler::LoadFile( wxImage *image, wxInputStream& stream, bool verbose, int WXUNUSED(index) ) |
e9c4b1a2 JS |
180 | { |
181 | struct jpeg_decompress_struct cinfo; | |
b59ff3c9 | 182 | struct my_error_mgr jerr; |
e9c4b1a2 JS |
183 | JSAMPARRAY tempbuf; |
184 | unsigned char *ptr; | |
185 | unsigned stride; | |
995612e2 | 186 | |
e9c4b1a2 | 187 | image->Destroy(); |
b59ff3c9 VS |
188 | cinfo.err = jpeg_std_error( &jerr.pub ); |
189 | jerr.pub.error_exit = my_error_exit; | |
190 | ||
deb2fec0 SB |
191 | if (!verbose) cinfo.err->output_message=NULL; |
192 | ||
b59ff3c9 VS |
193 | /* Establish the setjmp return context for my_error_exit to use. */ |
194 | if (setjmp(jerr.setjmp_buffer)) { | |
195 | /* If we get here, the JPEG code has signaled an error. | |
196 | * We need to clean up the JPEG object, close the input file, and return. | |
197 | */ | |
33ac7e6f | 198 | if (verbose) |
58c837a4 | 199 | wxLogError(_("JPEG: Couldn't load - file is probably corrupted.")); |
b59ff3c9 VS |
200 | jpeg_destroy_decompress(&cinfo); |
201 | if (image->Ok()) image->Destroy(); | |
202 | return FALSE; | |
203 | } | |
204 | ||
e9c4b1a2 JS |
205 | jpeg_create_decompress( &cinfo ); |
206 | jpeg_wxio_src( &cinfo, stream ); | |
207 | jpeg_read_header( &cinfo, TRUE ); | |
208 | cinfo.out_color_space = JCS_RGB; | |
209 | jpeg_start_decompress( &cinfo ); | |
995612e2 | 210 | |
e9c4b1a2 JS |
211 | image->Create( cinfo.image_width, cinfo.image_height ); |
212 | if (!image->Ok()) { | |
213 | jpeg_finish_decompress( &cinfo ); | |
214 | jpeg_destroy_decompress( &cinfo ); | |
215 | return FALSE; | |
216 | } | |
217 | image->SetMask( FALSE ); | |
218 | ptr = image->GetData(); | |
219 | stride = cinfo.output_width * 3; | |
220 | tempbuf = (*cinfo.mem->alloc_sarray) | |
221 | ((j_common_ptr) &cinfo, JPOOL_IMAGE, stride, 1 ); | |
995612e2 | 222 | |
e9c4b1a2 JS |
223 | while ( cinfo.output_scanline < cinfo.output_height ) { |
224 | jpeg_read_scanlines( &cinfo, tempbuf, 1 ); | |
225 | memcpy( ptr, tempbuf[0], stride ); | |
226 | ptr += stride; | |
227 | } | |
228 | jpeg_finish_decompress( &cinfo ); | |
229 | jpeg_destroy_decompress( &cinfo ); | |
230 | return TRUE; | |
231 | } | |
232 | ||
e9c4b1a2 JS |
233 | typedef struct { |
234 | struct jpeg_destination_mgr pub; | |
995612e2 | 235 | |
e9c4b1a2 JS |
236 | wxOutputStream *stream; |
237 | JOCTET * buffer; | |
238 | } my_destination_mgr; | |
239 | ||
240 | typedef my_destination_mgr * my_dest_ptr; | |
241 | ||
995612e2 | 242 | #define OUTPUT_BUF_SIZE 4096 /* choose an efficiently fwrite'able size */ |
e9c4b1a2 JS |
243 | |
244 | METHODDEF(void) init_destination (j_compress_ptr cinfo) | |
245 | { | |
246 | my_dest_ptr dest = (my_dest_ptr) cinfo->dest; | |
995612e2 | 247 | |
e9c4b1a2 JS |
248 | /* Allocate the output buffer --- it will be released when done with image */ |
249 | dest->buffer = (JOCTET *) | |
250 | (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, | |
251 | OUTPUT_BUF_SIZE * sizeof(JOCTET)); | |
252 | dest->pub.next_output_byte = dest->buffer; | |
253 | dest->pub.free_in_buffer = OUTPUT_BUF_SIZE; | |
254 | } | |
255 | ||
256 | METHODDEF(boolean) empty_output_buffer (j_compress_ptr cinfo) | |
257 | { | |
258 | my_dest_ptr dest = (my_dest_ptr) cinfo->dest; | |
995612e2 | 259 | |
e9c4b1a2 JS |
260 | dest->stream->Write(dest->buffer, OUTPUT_BUF_SIZE); |
261 | dest->pub.next_output_byte = dest->buffer; | |
262 | dest->pub.free_in_buffer = OUTPUT_BUF_SIZE; | |
263 | return TRUE; | |
264 | } | |
265 | ||
266 | METHODDEF(void) term_destination (j_compress_ptr cinfo) | |
267 | { | |
268 | my_dest_ptr dest = (my_dest_ptr) cinfo->dest; | |
269 | size_t datacount = OUTPUT_BUF_SIZE - dest->pub.free_in_buffer; | |
270 | /* Write any data remaining in the buffer */ | |
271 | if (datacount > 0) | |
272 | dest->stream->Write(dest->buffer, datacount); | |
273 | } | |
274 | ||
275 | GLOBAL(void) jpeg_wxio_dest (j_compress_ptr cinfo, wxOutputStream& outfile) | |
276 | { | |
277 | my_dest_ptr dest; | |
995612e2 VZ |
278 | |
279 | if (cinfo->dest == NULL) { /* first time for this JPEG object? */ | |
e9c4b1a2 JS |
280 | cinfo->dest = (struct jpeg_destination_mgr *) |
281 | (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, | |
282 | sizeof(my_destination_mgr)); | |
283 | } | |
995612e2 | 284 | |
e9c4b1a2 JS |
285 | dest = (my_dest_ptr) cinfo->dest; |
286 | dest->pub.init_destination = init_destination; | |
287 | dest->pub.empty_output_buffer = empty_output_buffer; | |
288 | dest->pub.term_destination = term_destination; | |
289 | dest->stream = &outfile; | |
290 | } | |
291 | ||
deb2fec0 | 292 | bool wxJPEGHandler::SaveFile( wxImage *image, wxOutputStream& stream, bool verbose ) |
e9c4b1a2 JS |
293 | { |
294 | struct jpeg_compress_struct cinfo; | |
b59ff3c9 | 295 | struct my_error_mgr jerr; |
995612e2 | 296 | JSAMPROW row_pointer[1]; /* pointer to JSAMPLE row[s] */ |
e9c4b1a2 | 297 | JSAMPLE *image_buffer; |
995612e2 VZ |
298 | int stride; /* physical row width in image buffer */ |
299 | ||
b59ff3c9 VS |
300 | cinfo.err = jpeg_std_error(&jerr.pub); |
301 | jerr.pub.error_exit = my_error_exit; | |
302 | ||
deb2fec0 SB |
303 | if (!verbose) cinfo.err->output_message=NULL; |
304 | ||
b59ff3c9 | 305 | /* Establish the setjmp return context for my_error_exit to use. */ |
33ac7e6f | 306 | if (setjmp(jerr.setjmp_buffer)) |
58c837a4 RR |
307 | { |
308 | /* If we get here, the JPEG code has signaled an error. | |
309 | * We need to clean up the JPEG object, close the input file, and return. | |
310 | */ | |
33ac7e6f | 311 | if (verbose) |
58c837a4 RR |
312 | wxLogError(_("JPEG: Couldn't save image.")); |
313 | jpeg_destroy_compress(&cinfo); | |
314 | return FALSE; | |
b59ff3c9 VS |
315 | } |
316 | ||
e9c4b1a2 JS |
317 | jpeg_create_compress(&cinfo); |
318 | jpeg_wxio_dest(&cinfo, stream); | |
995612e2 | 319 | |
e9c4b1a2 JS |
320 | cinfo.image_width = image->GetWidth(); |
321 | cinfo.image_height = image->GetHeight(); | |
322 | cinfo.input_components = 3; | |
323 | cinfo.in_color_space = JCS_RGB; | |
324 | jpeg_set_defaults(&cinfo); | |
5e5437e0 JS |
325 | |
326 | // TODO: 3rd parameter is force_baseline, what value should this be? | |
327 | // Code says: "If force_baseline is TRUE, the computed quantization table entries | |
328 | // are limited to 1..255 for JPEG baseline compatibility." | |
329 | // 'Quality' is a number between 0 (terrible) and 100 (very good). | |
330 | // The default (in jcparam.c, jpeg_set_defaults) is 75, | |
331 | // and force_baseline is TRUE. | |
332 | if (image->HasOption(wxT("quality"))) | |
333 | jpeg_set_quality(&cinfo, image->GetOptionInt(wxT("quality")), TRUE); | |
334 | ||
e9c4b1a2 | 335 | jpeg_start_compress(&cinfo, TRUE); |
995612e2 VZ |
336 | |
337 | stride = cinfo.image_width * 3; /* JSAMPLEs per row in image_buffer */ | |
e9c4b1a2 JS |
338 | image_buffer = image->GetData(); |
339 | while (cinfo.next_scanline < cinfo.image_height) { | |
340 | row_pointer[0] = &image_buffer[cinfo.next_scanline * stride]; | |
341 | jpeg_write_scanlines( &cinfo, row_pointer, 1 ); | |
342 | } | |
343 | jpeg_finish_compress(&cinfo); | |
344 | jpeg_destroy_compress(&cinfo); | |
995612e2 | 345 | |
e9c4b1a2 JS |
346 | return TRUE; |
347 | } | |
e9c4b1a2 | 348 | |
3ca6a5f0 BP |
349 | #ifdef __VISUALC__ |
350 | #pragma warning(default:4611) | |
351 | #endif /* VC++ */ | |
0828c087 | 352 | |
995612e2 | 353 | bool wxJPEGHandler::DoCanRead( wxInputStream& stream ) |
0828c087 VS |
354 | { |
355 | unsigned char hdr[2]; | |
995612e2 | 356 | |
33ac7e6f | 357 | stream.Read(hdr, 2); |
0828c087 VS |
358 | stream.SeekI(-2, wxFromCurrent); |
359 | return (hdr[0] == 0xFF && hdr[1] == 0xD8); | |
360 | } | |
361 | ||
9ab6ee85 GRG |
362 | #endif // wxUSE_STREAMS |
363 | ||
364 | #endif // wxUSE_LIBJPEG | |
b59ff3c9 VS |
365 | |
366 | ||
367 | ||
368 | ||
369 | ||
370 |