some updates to the Linux build system - obtained a core binary and all required...
[xonotic/netradiant.git] / libs / jpeg6 / jdapimin.cpp
1 /*\r
2 \r
3  * jdapimin.c\r
4 \r
5  *\r
6 \r
7  * Copyright (C) 1994-1995, Thomas G. Lane.\r
8 \r
9  * This file is part of the Independent JPEG Group's software.\r
10 \r
11  * For conditions of distribution and use, see the accompanying README file.\r
12 \r
13  *\r
14 \r
15  * This file contains application interface code for the decompression half\r
16 \r
17  * of the JPEG library.  These are the "minimum" API routines that may be\r
18 \r
19  * needed in either the normal full-decompression case or the\r
20 \r
21  * transcoding-only case.\r
22 \r
23  *\r
24 \r
25  * Most of the routines intended to be called directly by an application\r
26 \r
27  * are in this file or in jdapistd.c.  But also see jcomapi.c for routines\r
28 \r
29  * shared by compression and decompression, and jdtrans.c for the transcoding\r
30 \r
31  * case.\r
32 \r
33  */\r
34 \r
35 \r
36 \r
37 #define JPEG_INTERNALS\r
38 \r
39 #include "jinclude.h"\r
40 \r
41 #include "radiant_jpeglib.h"\r
42 \r
43 \r
44 \r
45 \r
46 \r
47 /*\r
48 \r
49  * Initialization of a JPEG decompression object.\r
50 \r
51  * The error manager must already be set up (in case memory manager fails).\r
52 \r
53  */\r
54 \r
55 \r
56 \r
57 GLOBAL void\r
58 \r
59 jpeg_create_decompress (j_decompress_ptr cinfo)\r
60 \r
61 {\r
62 \r
63   int i;\r
64 \r
65 \r
66 \r
67   /* For debugging purposes, zero the whole master structure.\r
68 \r
69    * But error manager pointer is already there, so save and restore it.\r
70 \r
71    */\r
72 \r
73   {\r
74 \r
75     struct jpeg_error_mgr * err = cinfo->err;\r
76 \r
77     i = sizeof(struct jpeg_decompress_struct);\r
78 \r
79     i = SIZEOF(struct jpeg_decompress_struct);\r
80 \r
81     MEMZERO(cinfo, SIZEOF(struct jpeg_decompress_struct));\r
82 \r
83     cinfo->err = err;\r
84 \r
85   }\r
86 \r
87   cinfo->is_decompressor = TRUE;\r
88 \r
89 \r
90 \r
91   /* Initialize a memory manager instance for this object */\r
92 \r
93   jinit_memory_mgr((j_common_ptr) cinfo);\r
94 \r
95 \r
96 \r
97   /* Zero out pointers to permanent structures. */\r
98 \r
99   cinfo->progress = NULL;\r
100 \r
101   cinfo->src = NULL;\r
102 \r
103 \r
104 \r
105   for (i = 0; i < NUM_QUANT_TBLS; i++)\r
106 \r
107     cinfo->quant_tbl_ptrs[i] = NULL;\r
108 \r
109 \r
110 \r
111   for (i = 0; i < NUM_HUFF_TBLS; i++) {\r
112 \r
113     cinfo->dc_huff_tbl_ptrs[i] = NULL;\r
114 \r
115     cinfo->ac_huff_tbl_ptrs[i] = NULL;\r
116 \r
117   }\r
118 \r
119 \r
120 \r
121   /* Initialize marker processor so application can override methods\r
122 \r
123    * for COM, APPn markers before calling jpeg_read_header.\r
124 \r
125    */\r
126 \r
127   jinit_marker_reader(cinfo);\r
128 \r
129 \r
130 \r
131   /* And initialize the overall input controller. */\r
132 \r
133   jinit_input_controller(cinfo);\r
134 \r
135 \r
136 \r
137   /* OK, I'm ready */\r
138 \r
139   cinfo->global_state = DSTATE_START;\r
140 \r
141 }\r
142 \r
143 \r
144 \r
145 \r
146 \r
147 /*\r
148 \r
149  * Destruction of a JPEG decompression object\r
150 \r
151  */\r
152 \r
153 \r
154 \r
155 GLOBAL void\r
156 \r
157 jpeg_destroy_decompress (j_decompress_ptr cinfo)\r
158 \r
159 {\r
160 \r
161   jpeg_destroy((j_common_ptr) cinfo); /* use common routine */\r
162 \r
163 }\r
164 \r
165 \r
166 \r
167 \r
168 \r
169 /*\r
170 \r
171  * Abort processing of a JPEG decompression operation,\r
172 \r
173  * but don't destroy the object itself.\r
174 \r
175  */\r
176 \r
177 \r
178 \r
179 GLOBAL void\r
180 \r
181 jpeg_abort_decompress (j_decompress_ptr cinfo)\r
182 \r
183 {\r
184 \r
185   jpeg_abort((j_common_ptr) cinfo); /* use common routine */\r
186 \r
187 }\r
188 \r
189 \r
190 \r
191 \r
192 \r
193 /*\r
194 \r
195  * Install a special processing method for COM or APPn markers.\r
196 \r
197  */\r
198 \r
199 \r
200 \r
201 GLOBAL void\r
202 \r
203 jpeg_set_marker_processor (j_decompress_ptr cinfo, int marker_code,\r
204 \r
205                            jpeg_marker_parser_method routine)\r
206 \r
207 {\r
208 \r
209   if (marker_code == JPEG_COM)\r
210 \r
211     cinfo->marker->process_COM = routine;\r
212 \r
213   else if (marker_code >= JPEG_APP0 && marker_code <= JPEG_APP0+15)\r
214 \r
215     cinfo->marker->process_APPn[marker_code-JPEG_APP0] = routine;\r
216 \r
217   else\r
218 \r
219     ERREXIT1(cinfo, JERR_UNKNOWN_MARKER, marker_code);\r
220 \r
221 }\r
222 \r
223 \r
224 \r
225 \r
226 \r
227 /*\r
228 \r
229  * Set default decompression parameters.\r
230 \r
231  */\r
232 \r
233 \r
234 \r
235 LOCAL void\r
236 \r
237 default_decompress_parms (j_decompress_ptr cinfo)\r
238 \r
239 {\r
240 \r
241   /* Guess the input colorspace, and set output colorspace accordingly. */\r
242 \r
243   /* (Wish JPEG committee had provided a real way to specify this...) */\r
244 \r
245   /* Note application may override our guesses. */\r
246 \r
247   switch (cinfo->num_components) {\r
248 \r
249   case 1:\r
250 \r
251     cinfo->jpeg_color_space = JCS_GRAYSCALE;\r
252 \r
253     cinfo->out_color_space = JCS_GRAYSCALE;\r
254 \r
255     break;\r
256 \r
257     \r
258 \r
259   case 3:\r
260 \r
261     if (cinfo->saw_JFIF_marker) {\r
262 \r
263       cinfo->jpeg_color_space = JCS_YCbCr; /* JFIF implies YCbCr */\r
264 \r
265     } else if (cinfo->saw_Adobe_marker) {\r
266 \r
267       switch (cinfo->Adobe_transform) {\r
268 \r
269       case 0:\r
270 \r
271         cinfo->jpeg_color_space = JCS_RGB;\r
272 \r
273         break;\r
274 \r
275       case 1:\r
276 \r
277         cinfo->jpeg_color_space = JCS_YCbCr;\r
278 \r
279         break;\r
280 \r
281       default:\r
282 \r
283         WARNMS1(cinfo, JWRN_ADOBE_XFORM, cinfo->Adobe_transform);\r
284 \r
285         cinfo->jpeg_color_space = JCS_YCbCr; /* assume it's YCbCr */\r
286 \r
287         break;\r
288 \r
289       }\r
290 \r
291     } else {\r
292 \r
293       /* Saw no special markers, try to guess from the component IDs */\r
294 \r
295       int cid0 = cinfo->comp_info[0].component_id;\r
296 \r
297       int cid1 = cinfo->comp_info[1].component_id;\r
298 \r
299       int cid2 = cinfo->comp_info[2].component_id;\r
300 \r
301 \r
302 \r
303       if (cid0 == 1 && cid1 == 2 && cid2 == 3)\r
304 \r
305         cinfo->jpeg_color_space = JCS_YCbCr; /* assume JFIF w/out marker */\r
306 \r
307       else if (cid0 == 82 && cid1 == 71 && cid2 == 66)\r
308 \r
309         cinfo->jpeg_color_space = JCS_RGB; /* ASCII 'R', 'G', 'B' */\r
310 \r
311       else {\r
312 \r
313         TRACEMS3(cinfo, 1, JTRC_UNKNOWN_IDS, cid0, cid1, cid2);\r
314 \r
315         cinfo->jpeg_color_space = JCS_YCbCr; /* assume it's YCbCr */\r
316 \r
317       }\r
318 \r
319     }\r
320 \r
321     /* Always guess RGB is proper output colorspace. */\r
322 \r
323     cinfo->out_color_space = JCS_RGB;\r
324 \r
325     break;\r
326 \r
327     \r
328 \r
329   case 4:\r
330 \r
331     if (cinfo->saw_Adobe_marker) {\r
332 \r
333       switch (cinfo->Adobe_transform) {\r
334 \r
335       case 0:\r
336 \r
337         cinfo->jpeg_color_space = JCS_CMYK;\r
338 \r
339         break;\r
340 \r
341       case 2:\r
342 \r
343         cinfo->jpeg_color_space = JCS_YCCK;\r
344 \r
345         break;\r
346 \r
347       default:\r
348 \r
349         WARNMS1(cinfo, JWRN_ADOBE_XFORM, cinfo->Adobe_transform);\r
350 \r
351         cinfo->jpeg_color_space = JCS_YCCK; /* assume it's YCCK */\r
352 \r
353         break;\r
354 \r
355       }\r
356 \r
357     } else {\r
358 \r
359       /* No special markers, assume straight CMYK. */\r
360 \r
361       cinfo->jpeg_color_space = JCS_CMYK;\r
362 \r
363     }\r
364 \r
365     cinfo->out_color_space = JCS_CMYK;\r
366 \r
367     break;\r
368 \r
369     \r
370 \r
371   default:\r
372 \r
373     cinfo->jpeg_color_space = JCS_UNKNOWN;\r
374 \r
375     cinfo->out_color_space = JCS_UNKNOWN;\r
376 \r
377     break;\r
378 \r
379   }\r
380 \r
381 \r
382 \r
383   /* Set defaults for other decompression parameters. */\r
384 \r
385   cinfo->scale_num = 1;         /* 1:1 scaling */\r
386 \r
387   cinfo->scale_denom = 1;\r
388 \r
389   cinfo->output_gamma = 1.0;\r
390 \r
391   cinfo->buffered_image = FALSE;\r
392 \r
393   cinfo->raw_data_out = FALSE;\r
394 \r
395   cinfo->dct_method = JDCT_DEFAULT;\r
396 \r
397   cinfo->do_fancy_upsampling = TRUE;\r
398 \r
399   cinfo->do_block_smoothing = TRUE;\r
400 \r
401   cinfo->quantize_colors = FALSE;\r
402 \r
403   /* We set these in case application only sets quantize_colors. */\r
404 \r
405   cinfo->dither_mode = JDITHER_FS;\r
406 \r
407 #ifdef QUANT_2PASS_SUPPORTED\r
408 \r
409   cinfo->two_pass_quantize = TRUE;\r
410 \r
411 #else\r
412 \r
413   cinfo->two_pass_quantize = FALSE;\r
414 \r
415 #endif\r
416 \r
417   cinfo->desired_number_of_colors = 256;\r
418 \r
419   cinfo->colormap = NULL;\r
420 \r
421   /* Initialize for no mode change in buffered-image mode. */\r
422 \r
423   cinfo->enable_1pass_quant = FALSE;\r
424 \r
425   cinfo->enable_external_quant = FALSE;\r
426 \r
427   cinfo->enable_2pass_quant = FALSE;\r
428 \r
429 }\r
430 \r
431 \r
432 \r
433 \r
434 \r
435 /*\r
436 \r
437  * Decompression startup: read start of JPEG datastream to see what's there.\r
438 \r
439  * Need only initialize JPEG object and supply a data source before calling.\r
440 \r
441  *\r
442 \r
443  * This routine will read as far as the first SOS marker (ie, actual start of\r
444 \r
445  * compressed data), and will save all tables and parameters in the JPEG\r
446 \r
447  * object.  It will also initialize the decompression parameters to default\r
448 \r
449  * values, and finally return JPEG_HEADER_OK.  On return, the application may\r
450 \r
451  * adjust the decompression parameters and then call jpeg_start_decompress.\r
452 \r
453  * (Or, if the application only wanted to determine the image parameters,\r
454 \r
455  * the data need not be decompressed.  In that case, call jpeg_abort or\r
456 \r
457  * jpeg_destroy to release any temporary space.)\r
458 \r
459  * If an abbreviated (tables only) datastream is presented, the routine will\r
460 \r
461  * return JPEG_HEADER_TABLES_ONLY upon reaching EOI.  The application may then\r
462 \r
463  * re-use the JPEG object to read the abbreviated image datastream(s).\r
464 \r
465  * It is unnecessary (but OK) to call jpeg_abort in this case.\r
466 \r
467  * The JPEG_SUSPENDED return code only occurs if the data source module\r
468 \r
469  * requests suspension of the decompressor.  In this case the application\r
470 \r
471  * should load more source data and then re-call jpeg_read_header to resume\r
472 \r
473  * processing.\r
474 \r
475  * If a non-suspending data source is used and require_image is TRUE, then the\r
476 \r
477  * return code need not be inspected since only JPEG_HEADER_OK is possible.\r
478 \r
479  *\r
480 \r
481  * This routine is now just a front end to jpeg_consume_input, with some\r
482 \r
483  * extra error checking.\r
484 \r
485  */\r
486 \r
487 \r
488 \r
489 GLOBAL int\r
490 \r
491 jpeg_read_header (j_decompress_ptr cinfo, boolean require_image)\r
492 \r
493 {\r
494 \r
495   int retcode;\r
496 \r
497 \r
498 \r
499   if (cinfo->global_state != DSTATE_START &&\r
500 \r
501       cinfo->global_state != DSTATE_INHEADER)\r
502 \r
503     ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);\r
504 \r
505 \r
506 \r
507   retcode = jpeg_consume_input(cinfo);\r
508 \r
509 \r
510 \r
511   switch (retcode) {\r
512 \r
513   case JPEG_REACHED_SOS:\r
514 \r
515     retcode = JPEG_HEADER_OK;\r
516 \r
517     break;\r
518 \r
519   case JPEG_REACHED_EOI:\r
520 \r
521     if (require_image)          /* Complain if application wanted an image */\r
522 \r
523       ERREXIT(cinfo, JERR_NO_IMAGE);\r
524 \r
525     /* Reset to start state; it would be safer to require the application to\r
526 \r
527      * call jpeg_abort, but we can't change it now for compatibility reasons.\r
528 \r
529      * A side effect is to free any temporary memory (there shouldn't be any).\r
530 \r
531      */\r
532 \r
533     jpeg_abort((j_common_ptr) cinfo); /* sets state = DSTATE_START */\r
534 \r
535     retcode = JPEG_HEADER_TABLES_ONLY;\r
536 \r
537     break;\r
538 \r
539   case JPEG_SUSPENDED:\r
540 \r
541     /* no work */\r
542 \r
543     break;\r
544 \r
545   }\r
546 \r
547 \r
548 \r
549   return retcode;\r
550 \r
551 }\r
552 \r
553 \r
554 \r
555 \r
556 \r
557 /*\r
558 \r
559  * Consume data in advance of what the decompressor requires.\r
560 \r
561  * This can be called at any time once the decompressor object has\r
562 \r
563  * been created and a data source has been set up.\r
564 \r
565  *\r
566 \r
567  * This routine is essentially a state machine that handles a couple\r
568 \r
569  * of critical state-transition actions, namely initial setup and\r
570 \r
571  * transition from header scanning to ready-for-start_decompress.\r
572 \r
573  * All the actual input is done via the input controller's consume_input\r
574 \r
575  * method.\r
576 \r
577  */\r
578 \r
579 \r
580 \r
581 GLOBAL int\r
582 \r
583 jpeg_consume_input (j_decompress_ptr cinfo)\r
584 \r
585 {\r
586 \r
587   int retcode = JPEG_SUSPENDED;\r
588 \r
589 \r
590 \r
591   /* NB: every possible DSTATE value should be listed in this switch */\r
592 \r
593   switch (cinfo->global_state) {\r
594 \r
595   case DSTATE_START:\r
596 \r
597     /* Start-of-datastream actions: reset appropriate modules */\r
598 \r
599     (*cinfo->inputctl->reset_input_controller) (cinfo);\r
600 \r
601     /* Initialize application's data source module */\r
602 \r
603     (*cinfo->src->init_source) (cinfo);\r
604 \r
605     cinfo->global_state = DSTATE_INHEADER;\r
606 \r
607     /*FALLTHROUGH*/\r
608 \r
609   case DSTATE_INHEADER:\r
610 \r
611     retcode = (*cinfo->inputctl->consume_input) (cinfo);\r
612 \r
613     if (retcode == JPEG_REACHED_SOS) { /* Found SOS, prepare to decompress */\r
614 \r
615       /* Set up default parameters based on header data */\r
616 \r
617       default_decompress_parms(cinfo);\r
618 \r
619       /* Set global state: ready for start_decompress */\r
620 \r
621       cinfo->global_state = DSTATE_READY;\r
622 \r
623     }\r
624 \r
625     break;\r
626 \r
627   case DSTATE_READY:\r
628 \r
629     /* Can't advance past first SOS until start_decompress is called */\r
630 \r
631     retcode = JPEG_REACHED_SOS;\r
632 \r
633     break;\r
634 \r
635   case DSTATE_PRELOAD:\r
636 \r
637   case DSTATE_PRESCAN:\r
638 \r
639   case DSTATE_SCANNING:\r
640 \r
641   case DSTATE_RAW_OK:\r
642 \r
643   case DSTATE_BUFIMAGE:\r
644 \r
645   case DSTATE_BUFPOST:\r
646 \r
647   case DSTATE_STOPPING:\r
648 \r
649     retcode = (*cinfo->inputctl->consume_input) (cinfo);\r
650 \r
651     break;\r
652 \r
653   default:\r
654 \r
655     ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);\r
656 \r
657   }\r
658 \r
659   return retcode;\r
660 \r
661 }\r
662 \r
663 \r
664 \r
665 \r
666 \r
667 /*\r
668 \r
669  * Have we finished reading the input file?\r
670 \r
671  */\r
672 \r
673 \r
674 \r
675 GLOBAL boolean\r
676 \r
677 jpeg_input_complete (j_decompress_ptr cinfo)\r
678 \r
679 {\r
680 \r
681   /* Check for valid jpeg object */\r
682 \r
683   if (cinfo->global_state < DSTATE_START ||\r
684 \r
685       cinfo->global_state > DSTATE_STOPPING)\r
686 \r
687     ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);\r
688 \r
689   return cinfo->inputctl->eoi_reached;\r
690 \r
691 }\r
692 \r
693 \r
694 \r
695 \r
696 \r
697 /*\r
698 \r
699  * Is there more than one scan?\r
700 \r
701  */\r
702 \r
703 \r
704 \r
705 GLOBAL boolean\r
706 \r
707 jpeg_has_multiple_scans (j_decompress_ptr cinfo)\r
708 \r
709 {\r
710 \r
711   /* Only valid after jpeg_read_header completes */\r
712 \r
713   if (cinfo->global_state < DSTATE_READY ||\r
714 \r
715       cinfo->global_state > DSTATE_STOPPING)\r
716 \r
717     ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);\r
718 \r
719   return cinfo->inputctl->has_multiple_scans;\r
720 \r
721 }\r
722 \r
723 \r
724 \r
725 \r
726 \r
727 /*\r
728 \r
729  * Finish JPEG decompression.\r
730 \r
731  *\r
732 \r
733  * This will normally just verify the file trailer and release temp storage.\r
734 \r
735  *\r
736 \r
737  * Returns FALSE if suspended.  The return value need be inspected only if\r
738 \r
739  * a suspending data source is used.\r
740 \r
741  */\r
742 \r
743 \r
744 \r
745 GLOBAL boolean\r
746 \r
747 jpeg_finish_decompress (j_decompress_ptr cinfo)\r
748 \r
749 {\r
750 \r
751   if ((cinfo->global_state == DSTATE_SCANNING ||\r
752 \r
753        cinfo->global_state == DSTATE_RAW_OK) && ! cinfo->buffered_image) {\r
754 \r
755     /* Terminate final pass of non-buffered mode */\r
756 \r
757     if (cinfo->output_scanline < cinfo->output_height)\r
758 \r
759       ERREXIT(cinfo, JERR_TOO_LITTLE_DATA);\r
760 \r
761     (*cinfo->master->finish_output_pass) (cinfo);\r
762 \r
763     cinfo->global_state = DSTATE_STOPPING;\r
764 \r
765   } else if (cinfo->global_state == DSTATE_BUFIMAGE) {\r
766 \r
767     /* Finishing after a buffered-image operation */\r
768 \r
769     cinfo->global_state = DSTATE_STOPPING;\r
770 \r
771   } else if (cinfo->global_state != DSTATE_STOPPING) {\r
772 \r
773     /* STOPPING = repeat call after a suspension, anything else is error */\r
774 \r
775     ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);\r
776 \r
777   }\r
778 \r
779   /* Read until EOI */\r
780 \r
781   while (! cinfo->inputctl->eoi_reached) {\r
782 \r
783     if ((*cinfo->inputctl->consume_input) (cinfo) == JPEG_SUSPENDED)\r
784 \r
785       return FALSE;             /* Suspend, come back later */\r
786 \r
787   }\r
788 \r
789   /* Do final cleanup */\r
790 \r
791   (*cinfo->src->term_source) (cinfo);\r
792 \r
793   /* We can use jpeg_abort to release memory and reset global_state */\r
794 \r
795   jpeg_abort((j_common_ptr) cinfo);\r
796 \r
797   return TRUE;\r
798 \r
799 }\r
800 \r