/[pcsx2_0.9.7]/trunk/3rdparty/wxWidgets/src/common/imagjpeg.cpp
ViewVC logotype

Contents of /trunk/3rdparty/wxWidgets/src/common/imagjpeg.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 31 - (show annotations) (download)
Tue Sep 7 03:24:11 2010 UTC (10 years, 3 months ago) by william
File size: 14529 byte(s)
committing r3113 initial commit again...
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/imagjpeg.cpp
3 // Purpose: wxImage JPEG handler
4 // Author: Vaclav Slavik
5 // RCS-ID: $Id: imagjpeg.cpp 43781 2006-12-03 21:59:47Z MW $
6 // Copyright: (c) Vaclav Slavik
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
9
10 // For compilers that support precompilation, includes "wx.h".
11 #include "wx/wxprec.h"
12
13 #ifdef __BORLANDC__
14 #pragma hdrstop
15 #endif
16
17 #if wxUSE_IMAGE && wxUSE_LIBJPEG
18
19 #include "wx/imagjpeg.h"
20
21 #ifndef WX_PRECOMP
22 #include "wx/log.h"
23 #include "wx/app.h"
24 #include "wx/intl.h"
25 #include "wx/bitmap.h"
26 #include "wx/module.h"
27 #endif
28
29 // A hack based on one from tif_jpeg.c to overcome the problem on Windows
30 // of rpcndr.h defining boolean with a different type to the jpeg headers.
31 //
32 // This hack is only necessary for an external jpeg library, the builtin one
33 // usually used on Windows doesn't use the type boolean, so always works.
34 //
35 #ifdef wxHACK_BOOLEAN
36 #define HAVE_BOOLEAN
37 #define boolean wxHACK_BOOLEAN
38 #endif
39
40 extern "C"
41 {
42 #if defined(__WXMSW__)
43 #define XMD_H
44 #endif
45 #include "jpeglib.h"
46 }
47
48 #ifndef HAVE_WXJPEG_BOOLEAN
49 typedef boolean wxjpeg_boolean;
50 #endif
51
52 #include "wx/filefn.h"
53 #include "wx/wfstream.h"
54
55 // For memcpy
56 #include <string.h>
57 // For JPEG library error handling
58 #include <setjmp.h>
59
60 #ifdef __SALFORDC__
61 #undef FAR
62 #endif
63
64 // ----------------------------------------------------------------------------
65 // types
66 // ----------------------------------------------------------------------------
67
68 // the standard definition of METHODDEF(type) from jmorecfg.h is "static type"
69 // which means that we can't declare the method functions as extern "C" - the
70 // compiler (rightfully) complains about the multiple storage classes in
71 // declaration
72 //
73 // so we only add extern "C" when using our own, modified, jmorecfg.h - and use
74 // whatever we have in the system headers if this is what we use hoping that it
75 // should be ok (can't do anything else)
76 #ifdef JPEG_METHOD_LINKAGE
77 #define CPP_METHODDEF(type) extern "C" METHODDEF(type)
78 #else // not using our jmorecfg.h header
79 #define CPP_METHODDEF(type) METHODDEF(type)
80 #endif
81
82 //-----------------------------------------------------------------------------
83 // wxJPEGHandler
84 //-----------------------------------------------------------------------------
85
86 IMPLEMENT_DYNAMIC_CLASS(wxJPEGHandler,wxImageHandler)
87
88 #if wxUSE_STREAMS
89
90 //------------- JPEG Data Source Manager
91
92 #define JPEG_IO_BUFFER_SIZE 2048
93
94 typedef struct {
95 struct jpeg_source_mgr pub; /* public fields */
96
97 JOCTET* buffer; /* start of buffer */
98 wxInputStream *stream;
99 } wx_source_mgr;
100
101 typedef wx_source_mgr * wx_src_ptr;
102
103 CPP_METHODDEF(void) wx_init_source ( j_decompress_ptr WXUNUSED(cinfo) )
104 {
105 }
106
107 CPP_METHODDEF(wxjpeg_boolean) wx_fill_input_buffer ( j_decompress_ptr cinfo )
108 {
109 wx_src_ptr src = (wx_src_ptr) cinfo->src;
110
111 src->pub.next_input_byte = src->buffer;
112 src->pub.bytes_in_buffer = src->stream->Read(src->buffer, JPEG_IO_BUFFER_SIZE).LastRead();
113
114 if (src->pub.bytes_in_buffer == 0) // check for end-of-stream
115 {
116 // Insert a fake EOI marker
117 src->buffer[0] = 0xFF;
118 src->buffer[1] = JPEG_EOI;
119 src->pub.bytes_in_buffer = 2;
120 }
121 return TRUE;
122 }
123
124 CPP_METHODDEF(void) wx_skip_input_data ( j_decompress_ptr cinfo, long num_bytes )
125 {
126 if (num_bytes > 0)
127 {
128 wx_src_ptr src = (wx_src_ptr) cinfo->src;
129
130 while (num_bytes > (long)src->pub.bytes_in_buffer)
131 {
132 num_bytes -= (long) src->pub.bytes_in_buffer;
133 src->pub.fill_input_buffer(cinfo);
134 }
135 src->pub.next_input_byte += (size_t) num_bytes;
136 src->pub.bytes_in_buffer -= (size_t) num_bytes;
137 }
138 }
139
140 CPP_METHODDEF(void) wx_term_source ( j_decompress_ptr cinfo )
141 {
142 wx_src_ptr src = (wx_src_ptr) cinfo->src;
143
144 if (src->pub.bytes_in_buffer > 0)
145 src->stream->SeekI(-(long)src->pub.bytes_in_buffer, wxFromCurrent);
146 delete[] src->buffer;
147 }
148
149
150 // JPEG error manager:
151
152 struct wx_error_mgr {
153 struct jpeg_error_mgr pub; /* "public" fields */
154
155 jmp_buf setjmp_buffer; /* for return to caller */
156 };
157
158 typedef struct wx_error_mgr * wx_error_ptr;
159
160 /*
161 * Here's the routine that will replace the standard error_exit method:
162 */
163
164 CPP_METHODDEF(void) wx_error_exit (j_common_ptr cinfo)
165 {
166 /* cinfo->err really points to a wx_error_mgr struct, so coerce pointer */
167 wx_error_ptr myerr = (wx_error_ptr) cinfo->err;
168
169 /* Always display the message. */
170 /* We could postpone this until after returning, if we chose. */
171 (*cinfo->err->output_message) (cinfo);
172
173 /* Return control to the setjmp point */
174 longjmp(myerr->setjmp_buffer, 1);
175 }
176
177 /*
178 * This will replace the standard output_message method when the user
179 * wants us to be silent (verbose==false). We must have such method instead of
180 * simply using NULL for cinfo->err->output_message because it's called
181 * unconditionally from within libjpeg when there's "garbage input".
182 */
183 CPP_METHODDEF(void) wx_ignore_message (j_common_ptr WXUNUSED(cinfo))
184 {
185 }
186
187 void wx_jpeg_io_src( j_decompress_ptr cinfo, wxInputStream& infile )
188 {
189 wx_src_ptr src;
190
191 if (cinfo->src == NULL) { /* first time for this JPEG object? */
192 cinfo->src = (struct jpeg_source_mgr *)
193 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
194 sizeof(wx_source_mgr));
195 }
196 src = (wx_src_ptr) cinfo->src;
197 src->pub.bytes_in_buffer = 0; /* forces fill_input_buffer on first read */
198 src->buffer = new JOCTET[JPEG_IO_BUFFER_SIZE];
199 src->pub.next_input_byte = NULL; /* until buffer loaded */
200 src->stream = &infile;
201
202 src->pub.init_source = wx_init_source;
203 src->pub.fill_input_buffer = wx_fill_input_buffer;
204 src->pub.skip_input_data = wx_skip_input_data;
205 src->pub.resync_to_restart = jpeg_resync_to_restart; /* use default method */
206 src->pub.term_source = wx_term_source;
207 }
208
209 static inline void wx_cmyk_to_rgb(unsigned char* rgb, const unsigned char* cmyk)
210 {
211 register int k = 255 - cmyk[3];
212 register int k2 = cmyk[3];
213 register int c;
214
215 c = k + k2 * (255 - cmyk[0]) / 255;
216 rgb[0] = (unsigned char)((c > 255) ? 0 : (255 - c));
217
218 c = k + k2 * (255 - cmyk[1]) / 255;
219 rgb[1] = (unsigned char)((c > 255) ? 0 : (255 - c));
220
221 c = k + k2 * (255 - cmyk[2]) / 255;
222 rgb[2] = (unsigned char)((c > 255) ? 0 : (255 - c));
223 }
224
225 // temporarily disable the warning C4611 (interaction between '_setjmp' and
226 // C++ object destruction is non-portable) - I don't see any dtors here
227 #ifdef __VISUALC__
228 #pragma warning(disable:4611)
229 #endif /* VC++ */
230
231 bool wxJPEGHandler::LoadFile( wxImage *image, wxInputStream& stream, bool verbose, int WXUNUSED(index) )
232 {
233 struct jpeg_decompress_struct cinfo;
234 struct wx_error_mgr jerr;
235 unsigned char *ptr;
236
237 image->Destroy();
238 cinfo.err = jpeg_std_error( &jerr.pub );
239 jerr.pub.error_exit = wx_error_exit;
240
241 if (!verbose)
242 cinfo.err->output_message = wx_ignore_message;
243
244 /* Establish the setjmp return context for wx_error_exit to use. */
245 if (setjmp(jerr.setjmp_buffer)) {
246 /* If we get here, the JPEG code has signaled an error.
247 * We need to clean up the JPEG object, close the input file, and return.
248 */
249 if (verbose)
250 wxLogError(_("JPEG: Couldn't load - file is probably corrupted."));
251 (cinfo.src->term_source)(&cinfo);
252 jpeg_destroy_decompress(&cinfo);
253 if (image->Ok()) image->Destroy();
254 return false;
255 }
256
257 jpeg_create_decompress( &cinfo );
258 wx_jpeg_io_src( &cinfo, stream );
259 jpeg_read_header( &cinfo, TRUE );
260
261 int bytesPerPixel;
262 if ((cinfo.out_color_space == JCS_CMYK) || (cinfo.out_color_space == JCS_YCCK))
263 {
264 cinfo.out_color_space = JCS_CMYK;
265 bytesPerPixel = 4;
266 }
267 else // all the rest is treated as RGB
268 {
269 cinfo.out_color_space = JCS_RGB;
270 bytesPerPixel = 3;
271 }
272
273 jpeg_start_decompress( &cinfo );
274
275 image->Create( cinfo.image_width, cinfo.image_height );
276 if (!image->Ok()) {
277 jpeg_finish_decompress( &cinfo );
278 jpeg_destroy_decompress( &cinfo );
279 return false;
280 }
281 image->SetMask( false );
282 ptr = image->GetData();
283
284 unsigned stride = cinfo.output_width * bytesPerPixel;
285 JSAMPARRAY tempbuf = (*cinfo.mem->alloc_sarray)
286 ((j_common_ptr) &cinfo, JPOOL_IMAGE, stride, 1 );
287
288 while ( cinfo.output_scanline < cinfo.output_height )
289 {
290 jpeg_read_scanlines( &cinfo, tempbuf, 1 );
291 if (cinfo.out_color_space == JCS_RGB)
292 {
293 memcpy( ptr, tempbuf[0], stride );
294 ptr += stride;
295 }
296 else // CMYK
297 {
298 const unsigned char* inptr = (const unsigned char*) tempbuf[0];
299 for (size_t i = 0; i < cinfo.output_width; i++)
300 {
301 wx_cmyk_to_rgb(ptr, inptr);
302 ptr += 3;
303 inptr += 4;
304 }
305 }
306 }
307
308 jpeg_finish_decompress( &cinfo );
309 jpeg_destroy_decompress( &cinfo );
310 return true;
311 }
312
313 typedef struct {
314 struct jpeg_destination_mgr pub;
315
316 wxOutputStream *stream;
317 JOCTET * buffer;
318 } wx_destination_mgr;
319
320 typedef wx_destination_mgr * wx_dest_ptr;
321
322 #define OUTPUT_BUF_SIZE 4096 /* choose an efficiently fwrite'able size */
323
324 CPP_METHODDEF(void) wx_init_destination (j_compress_ptr cinfo)
325 {
326 wx_dest_ptr dest = (wx_dest_ptr) cinfo->dest;
327
328 /* Allocate the output buffer --- it will be released when done with image */
329 dest->buffer = (JOCTET *)
330 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
331 OUTPUT_BUF_SIZE * sizeof(JOCTET));
332 dest->pub.next_output_byte = dest->buffer;
333 dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;
334 }
335
336 CPP_METHODDEF(wxjpeg_boolean) wx_empty_output_buffer (j_compress_ptr cinfo)
337 {
338 wx_dest_ptr dest = (wx_dest_ptr) cinfo->dest;
339
340 dest->stream->Write(dest->buffer, OUTPUT_BUF_SIZE);
341 dest->pub.next_output_byte = dest->buffer;
342 dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;
343 return TRUE;
344 }
345
346 CPP_METHODDEF(void) wx_term_destination (j_compress_ptr cinfo)
347 {
348 wx_dest_ptr dest = (wx_dest_ptr) cinfo->dest;
349 size_t datacount = OUTPUT_BUF_SIZE - dest->pub.free_in_buffer;
350 /* Write any data remaining in the buffer */
351 if (datacount > 0)
352 dest->stream->Write(dest->buffer, datacount);
353 }
354
355 GLOBAL(void) wx_jpeg_io_dest (j_compress_ptr cinfo, wxOutputStream& outfile)
356 {
357 wx_dest_ptr dest;
358
359 if (cinfo->dest == NULL) { /* first time for this JPEG object? */
360 cinfo->dest = (struct jpeg_destination_mgr *)
361 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
362 sizeof(wx_destination_mgr));
363 }
364
365 dest = (wx_dest_ptr) cinfo->dest;
366 dest->pub.init_destination = wx_init_destination;
367 dest->pub.empty_output_buffer = wx_empty_output_buffer;
368 dest->pub.term_destination = wx_term_destination;
369 dest->stream = &outfile;
370 }
371
372 bool wxJPEGHandler::SaveFile( wxImage *image, wxOutputStream& stream, bool verbose )
373 {
374 struct jpeg_compress_struct cinfo;
375 struct wx_error_mgr jerr;
376 JSAMPROW row_pointer[1]; /* pointer to JSAMPLE row[s] */
377 JSAMPLE *image_buffer;
378 int stride; /* physical row width in image buffer */
379
380 cinfo.err = jpeg_std_error(&jerr.pub);
381 jerr.pub.error_exit = wx_error_exit;
382
383 if (!verbose)
384 cinfo.err->output_message = wx_ignore_message;
385
386 /* Establish the setjmp return context for wx_error_exit to use. */
387 if (setjmp(jerr.setjmp_buffer))
388 {
389 /* If we get here, the JPEG code has signaled an error.
390 * We need to clean up the JPEG object, close the input file, and return.
391 */
392 if (verbose)
393 wxLogError(_("JPEG: Couldn't save image."));
394 jpeg_destroy_compress(&cinfo);
395 return false;
396 }
397
398 jpeg_create_compress(&cinfo);
399 wx_jpeg_io_dest(&cinfo, stream);
400
401 cinfo.image_width = image->GetWidth();
402 cinfo.image_height = image->GetHeight();
403 cinfo.input_components = 3;
404 cinfo.in_color_space = JCS_RGB;
405 jpeg_set_defaults(&cinfo);
406
407 // TODO: 3rd parameter is force_baseline, what value should this be?
408 // Code says: "If force_baseline is TRUE, the computed quantization table entries
409 // are limited to 1..255 for JPEG baseline compatibility."
410 // 'Quality' is a number between 0 (terrible) and 100 (very good).
411 // The default (in jcparam.c, jpeg_set_defaults) is 75,
412 // and force_baseline is TRUE.
413 if (image->HasOption(wxIMAGE_OPTION_QUALITY))
414 jpeg_set_quality(&cinfo, image->GetOptionInt(wxIMAGE_OPTION_QUALITY), TRUE);
415
416 // set the resolution fields in the output file
417 UINT16 resX,
418 resY;
419 if ( image->HasOption(wxIMAGE_OPTION_RESOLUTIONX) &&
420 image->HasOption(wxIMAGE_OPTION_RESOLUTIONY) )
421 {
422 resX = (UINT16)image->GetOptionInt(wxIMAGE_OPTION_RESOLUTIONX);
423 resY = (UINT16)image->GetOptionInt(wxIMAGE_OPTION_RESOLUTIONY);
424 }
425 else if ( image->HasOption(wxIMAGE_OPTION_RESOLUTION) )
426 {
427 resX =
428 resY = (UINT16)image->GetOptionInt(wxIMAGE_OPTION_RESOLUTION);
429 }
430 else
431 {
432 resX =
433 resY = 0;
434 }
435
436 if ( resX && resY )
437 {
438 cinfo.X_density = resX;
439 cinfo.Y_density = resY;
440 }
441
442 // sets the resolution unit field in the output file
443 // wxIMAGE_RESOLUTION_INCHES for inches
444 // wxIMAGE_RESOLUTION_CM for centimeters
445 if ( image->HasOption(wxIMAGE_OPTION_RESOLUTIONUNIT) )
446 {
447 cinfo.density_unit = (UINT8)image->GetOptionInt(wxIMAGE_OPTION_RESOLUTIONUNIT);
448 }
449
450 jpeg_start_compress(&cinfo, TRUE);
451
452 stride = cinfo.image_width * 3; /* JSAMPLEs per row in image_buffer */
453 image_buffer = image->GetData();
454 while (cinfo.next_scanline < cinfo.image_height) {
455 row_pointer[0] = &image_buffer[cinfo.next_scanline * stride];
456 jpeg_write_scanlines( &cinfo, row_pointer, 1 );
457 }
458 jpeg_finish_compress(&cinfo);
459 jpeg_destroy_compress(&cinfo);
460
461 return true;
462 }
463
464 #ifdef __VISUALC__
465 #pragma warning(default:4611)
466 #endif /* VC++ */
467
468 bool wxJPEGHandler::DoCanRead( wxInputStream& stream )
469 {
470 unsigned char hdr[2];
471
472 if ( !stream.Read(hdr, WXSIZEOF(hdr)) )
473 return false;
474
475 return hdr[0] == 0xFF && hdr[1] == 0xD8;
476 }
477
478 #endif // wxUSE_STREAMS
479
480 #endif // wxUSE_LIBJPEG

  ViewVC Help
Powered by ViewVC 1.1.22