4 * Copyright (C) 1991-1998, Thomas G. Lane.
5 * Modified 2009 by Guido Vollbeding.
6 * This file is part of the Independent JPEG Group's software.
7 * For conditions of distribution and use, see the accompanying README file.
9 * This file contains routines to decode JPEG datastream markers.
10 * Most of the complexity arises from our desire to support input
11 * suspension: if not all of the data for a marker is available,
12 * we must exit back to the application. On resumption, we reprocess
16 #define JPEG_INTERNALS
21 typedef enum { /* JPEG marker codes */
92 struct jpeg_marker_reader pub
; /* public fields */
94 /* Application-overridable marker processing methods */
95 jpeg_marker_parser_method process_COM
;
96 jpeg_marker_parser_method process_APPn
[16];
98 /* Limit on marker data length to save for each marker type */
99 unsigned int length_limit_COM
;
100 unsigned int length_limit_APPn
[16];
102 /* Status of COM/APPn marker saving */
103 jpeg_saved_marker_ptr cur_marker
; /* NULL if not processing a marker */
104 unsigned int bytes_read
; /* data bytes read so far in marker */
105 /* Note: cur_marker is not linked into marker_list until it's all read. */
108 typedef my_marker_reader
* my_marker_ptr
;
112 * Macros for fetching data from the data source module.
114 * At all times, cinfo->src->next_input_byte and ->bytes_in_buffer reflect
115 * the current restart point; we update them only when we have reached a
116 * suitable place to restart if a suspension occurs.
119 /* Declare and initialize local copies of input pointer/count */
120 #define INPUT_VARS(cinfo) \
121 struct jpeg_source_mgr * datasrc = (cinfo)->src; \
122 const JOCTET * next_input_byte = datasrc->next_input_byte; \
123 size_t bytes_in_buffer = datasrc->bytes_in_buffer
125 /* Unload the local copies --- do this only at a restart boundary */
126 #define INPUT_SYNC(cinfo) \
127 ( datasrc->next_input_byte = next_input_byte, \
128 datasrc->bytes_in_buffer = bytes_in_buffer )
130 /* Reload the local copies --- used only in MAKE_BYTE_AVAIL */
131 #define INPUT_RELOAD(cinfo) \
132 ( next_input_byte = datasrc->next_input_byte, \
133 bytes_in_buffer = datasrc->bytes_in_buffer )
135 /* Internal macro for INPUT_BYTE and INPUT_2BYTES: make a byte available.
136 * Note we do *not* do INPUT_SYNC before calling fill_input_buffer,
137 * but we must reload the local copies after a successful fill.
139 #define MAKE_BYTE_AVAIL(cinfo,action) \
140 if (bytes_in_buffer == 0) { \
141 if (! (*datasrc->fill_input_buffer) (cinfo)) \
143 INPUT_RELOAD(cinfo); \
146 /* Read a byte into variable V.
147 * If must suspend, take the specified action (typically "return FALSE").
149 #define INPUT_BYTE(cinfo,V,action) \
150 MAKESTMT( MAKE_BYTE_AVAIL(cinfo,action); \
152 V = GETJOCTET(*next_input_byte++); )
154 /* As above, but read two bytes interpreted as an unsigned 16-bit integer.
155 * V should be declared unsigned int or perhaps INT32.
157 #define INPUT_2BYTES(cinfo,V,action) \
158 MAKESTMT( MAKE_BYTE_AVAIL(cinfo,action); \
160 V = ((unsigned int) GETJOCTET(*next_input_byte++)) << 8; \
161 MAKE_BYTE_AVAIL(cinfo,action); \
163 V += GETJOCTET(*next_input_byte++); )
167 * Routines to process JPEG markers.
169 * Entry condition: JPEG marker itself has been read and its code saved
170 * in cinfo->unread_marker; input restart point is just after the marker.
172 * Exit: if return TRUE, have read and processed any parameters, and have
173 * updated the restart point to point after the parameters.
174 * If return FALSE, was forced to suspend before reaching end of
175 * marker parameters; restart point has not been moved. Same routine
176 * will be called again after application supplies more input data.
178 * This approach to suspension assumes that all of a marker's parameters
179 * can fit into a single input bufferload. This should hold for "normal"
180 * markers. Some COM/APPn markers might have large parameter segments
181 * that might not fit. If we are simply dropping such a marker, we use
182 * skip_input_data to get past it, and thereby put the problem on the
183 * source manager's shoulders. If we are saving the marker's contents
184 * into memory, we use a slightly different convention: when forced to
185 * suspend, the marker processor updates the restart point to the end of
186 * what it's consumed (ie, the end of the buffer) before returning FALSE.
187 * On resumption, cinfo->unread_marker still contains the marker code,
188 * but the data source will point to the next chunk of marker data.
189 * The marker processor must retain internal state to deal with this.
191 * Note that we don't bother to avoid duplicate trace messages if a
192 * suspension occurs within marker parameters. Other side effects
198 get_soi (j_decompress_ptr cinfo
)
199 /* Process an SOI marker */
203 TRACEMS(cinfo
, 1, JTRC_SOI
);
205 if (cinfo
->marker
->saw_SOI
)
206 ERREXIT(cinfo
, JERR_SOI_DUPLICATE
);
208 /* Reset all parameters that are defined to be reset by SOI */
210 for (i
= 0; i
< NUM_ARITH_TBLS
; i
++) {
211 cinfo
->arith_dc_L
[i
] = 0;
212 cinfo
->arith_dc_U
[i
] = 1;
213 cinfo
->arith_ac_K
[i
] = 5;
215 cinfo
->restart_interval
= 0;
217 /* Set initial assumptions for colorspace etc */
219 cinfo
->jpeg_color_space
= JCS_UNKNOWN
;
220 cinfo
->CCIR601_sampling
= FALSE
; /* Assume non-CCIR sampling??? */
222 cinfo
->saw_JFIF_marker
= FALSE
;
223 cinfo
->JFIF_major_version
= 1; /* set default JFIF APP0 values */
224 cinfo
->JFIF_minor_version
= 1;
225 cinfo
->density_unit
= 0;
226 cinfo
->X_density
= 1;
227 cinfo
->Y_density
= 1;
228 cinfo
->saw_Adobe_marker
= FALSE
;
229 cinfo
->Adobe_transform
= 0;
231 cinfo
->marker
->saw_SOI
= TRUE
;
238 get_sof (j_decompress_ptr cinfo
, boolean is_baseline
, boolean is_prog
,
240 /* Process a SOFn marker */
244 jpeg_component_info
* compptr
;
247 cinfo
->is_baseline
= is_baseline
;
248 cinfo
->progressive_mode
= is_prog
;
249 cinfo
->arith_code
= is_arith
;
251 INPUT_2BYTES(cinfo
, length
, return FALSE
);
253 INPUT_BYTE(cinfo
, cinfo
->data_precision
, return FALSE
);
254 INPUT_2BYTES(cinfo
, cinfo
->image_height
, return FALSE
);
255 INPUT_2BYTES(cinfo
, cinfo
->image_width
, return FALSE
);
256 INPUT_BYTE(cinfo
, cinfo
->num_components
, return FALSE
);
260 TRACEMS4(cinfo
, 1, JTRC_SOF
, cinfo
->unread_marker
,
261 (int) cinfo
->image_width
, (int) cinfo
->image_height
,
262 cinfo
->num_components
);
264 if (cinfo
->marker
->saw_SOF
)
265 ERREXIT(cinfo
, JERR_SOF_DUPLICATE
);
267 /* We don't support files in which the image height is initially specified */
268 /* as 0 and is later redefined by DNL. As long as we have to check that, */
269 /* might as well have a general sanity check. */
270 if (cinfo
->image_height
<= 0 || cinfo
->image_width
<= 0
271 || cinfo
->num_components
<= 0)
272 ERREXIT(cinfo
, JERR_EMPTY_IMAGE
);
274 if (length
!= (cinfo
->num_components
* 3))
275 ERREXIT(cinfo
, JERR_BAD_LENGTH
);
277 if (cinfo
->comp_info
== NULL
) /* do only once, even if suspend */
278 cinfo
->comp_info
= (jpeg_component_info
*) (*cinfo
->mem
->alloc_small
)
279 ((j_common_ptr
) cinfo
, JPOOL_IMAGE
,
280 cinfo
->num_components
* SIZEOF(jpeg_component_info
));
282 for (ci
= 0, compptr
= cinfo
->comp_info
; ci
< cinfo
->num_components
;
284 compptr
->component_index
= ci
;
285 INPUT_BYTE(cinfo
, compptr
->component_id
, return FALSE
);
286 INPUT_BYTE(cinfo
, c
, return FALSE
);
287 compptr
->h_samp_factor
= (c
>> 4) & 15;
288 compptr
->v_samp_factor
= (c
) & 15;
289 INPUT_BYTE(cinfo
, compptr
->quant_tbl_no
, return FALSE
);
291 TRACEMS4(cinfo
, 1, JTRC_SOF_COMPONENT
,
292 compptr
->component_id
, compptr
->h_samp_factor
,
293 compptr
->v_samp_factor
, compptr
->quant_tbl_no
);
296 cinfo
->marker
->saw_SOF
= TRUE
;
304 get_sos (j_decompress_ptr cinfo
)
305 /* Process a SOS marker */
309 jpeg_component_info
* compptr
;
312 if (! cinfo
->marker
->saw_SOF
)
313 ERREXIT(cinfo
, JERR_SOS_NO_SOF
);
315 INPUT_2BYTES(cinfo
, length
, return FALSE
);
317 INPUT_BYTE(cinfo
, n
, return FALSE
); /* Number of components */
319 TRACEMS1(cinfo
, 1, JTRC_SOS
, n
);
321 if (length
!= (n
* 2 + 6) || n
> MAX_COMPS_IN_SCAN
||
322 (n
== 0 && !cinfo
->progressive_mode
))
323 /* pseudo SOS marker only allowed in progressive mode */
324 ERREXIT(cinfo
, JERR_BAD_LENGTH
);
326 cinfo
->comps_in_scan
= n
;
328 /* Collect the component-spec parameters */
330 for (i
= 0; i
< n
; i
++) {
331 INPUT_BYTE(cinfo
, cc
, return FALSE
);
332 INPUT_BYTE(cinfo
, c
, return FALSE
);
334 for (ci
= 0, compptr
= cinfo
->comp_info
; ci
< cinfo
->num_components
;
336 if (cc
== compptr
->component_id
)
340 ERREXIT1(cinfo
, JERR_BAD_COMPONENT_ID
, cc
);
344 cinfo
->cur_comp_info
[i
] = compptr
;
345 compptr
->dc_tbl_no
= (c
>> 4) & 15;
346 compptr
->ac_tbl_no
= (c
) & 15;
348 TRACEMS3(cinfo
, 1, JTRC_SOS_COMPONENT
, cc
,
349 compptr
->dc_tbl_no
, compptr
->ac_tbl_no
);
352 /* Collect the additional scan parameters Ss, Se, Ah/Al. */
353 INPUT_BYTE(cinfo
, c
, return FALSE
);
355 INPUT_BYTE(cinfo
, c
, return FALSE
);
357 INPUT_BYTE(cinfo
, c
, return FALSE
);
358 cinfo
->Ah
= (c
>> 4) & 15;
359 cinfo
->Al
= (c
) & 15;
361 TRACEMS4(cinfo
, 1, JTRC_SOS_PARAMS
, cinfo
->Ss
, cinfo
->Se
,
362 cinfo
->Ah
, cinfo
->Al
);
364 /* Prepare to scan data & restart markers */
365 cinfo
->marker
->next_restart_num
= 0;
367 /* Count another (non-pseudo) SOS marker */
368 if (n
) cinfo
->input_scan_number
++;
375 #ifdef D_ARITH_CODING_SUPPORTED
378 get_dac (j_decompress_ptr cinfo
)
379 /* Process a DAC marker */
385 INPUT_2BYTES(cinfo
, length
, return FALSE
);
389 INPUT_BYTE(cinfo
, index
, return FALSE
);
390 INPUT_BYTE(cinfo
, val
, return FALSE
);
394 TRACEMS2(cinfo
, 1, JTRC_DAC
, index
, val
);
396 if (index
< 0 || index
>= (2*NUM_ARITH_TBLS
))
397 ERREXIT1(cinfo
, JERR_DAC_INDEX
, index
);
399 if (index
>= NUM_ARITH_TBLS
) { /* define AC table */
400 cinfo
->arith_ac_K
[index
-NUM_ARITH_TBLS
] = (UINT8
) val
;
401 } else { /* define DC table */
402 cinfo
->arith_dc_L
[index
] = (UINT8
) (val
& 0x0F);
403 cinfo
->arith_dc_U
[index
] = (UINT8
) (val
>> 4);
404 if (cinfo
->arith_dc_L
[index
] > cinfo
->arith_dc_U
[index
])
405 ERREXIT1(cinfo
, JERR_DAC_VALUE
, val
);
410 ERREXIT(cinfo
, JERR_BAD_LENGTH
);
416 #else /* ! D_ARITH_CODING_SUPPORTED */
418 #define get_dac(cinfo) skip_variable(cinfo)
420 #endif /* D_ARITH_CODING_SUPPORTED */
424 get_dht (j_decompress_ptr cinfo
)
425 /* Process a DHT marker */
434 INPUT_2BYTES(cinfo
, length
, return FALSE
);
437 while (length
> 16) {
438 INPUT_BYTE(cinfo
, index
, return FALSE
);
440 TRACEMS1(cinfo
, 1, JTRC_DHT
, index
);
444 for (i
= 1; i
<= 16; i
++) {
445 INPUT_BYTE(cinfo
, bits
[i
], return FALSE
);
451 TRACEMS8(cinfo
, 2, JTRC_HUFFBITS
,
452 bits
[1], bits
[2], bits
[3], bits
[4],
453 bits
[5], bits
[6], bits
[7], bits
[8]);
454 TRACEMS8(cinfo
, 2, JTRC_HUFFBITS
,
455 bits
[9], bits
[10], bits
[11], bits
[12],
456 bits
[13], bits
[14], bits
[15], bits
[16]);
458 /* Here we just do minimal validation of the counts to avoid walking
459 * off the end of our table space. jdhuff.c will check more carefully.
461 if (count
> 256 || ((INT32
) count
) > length
)
462 ERREXIT(cinfo
, JERR_BAD_HUFF_TABLE
);
464 for (i
= 0; i
< count
; i
++)
465 INPUT_BYTE(cinfo
, huffval
[i
], return FALSE
);
469 if (index
& 0x10) { /* AC table definition */
471 htblptr
= &cinfo
->ac_huff_tbl_ptrs
[index
];
472 } else { /* DC table definition */
473 htblptr
= &cinfo
->dc_huff_tbl_ptrs
[index
];
476 if (index
< 0 || index
>= NUM_HUFF_TBLS
)
477 ERREXIT1(cinfo
, JERR_DHT_INDEX
, index
);
479 if (*htblptr
== NULL
)
480 *htblptr
= jpeg_alloc_huff_table((j_common_ptr
) cinfo
);
482 MEMCOPY((*htblptr
)->bits
, bits
, SIZEOF((*htblptr
)->bits
));
483 MEMCOPY((*htblptr
)->huffval
, huffval
, SIZEOF((*htblptr
)->huffval
));
487 ERREXIT(cinfo
, JERR_BAD_LENGTH
);
495 get_dqt (j_decompress_ptr cinfo
)
496 /* Process a DQT marker */
498 INT32 length
, count
, i
;
501 JQUANT_TBL
*quant_ptr
;
502 const int *natural_order
;
505 INPUT_2BYTES(cinfo
, length
, return FALSE
);
510 INPUT_BYTE(cinfo
, n
, return FALSE
);
514 TRACEMS2(cinfo
, 1, JTRC_DQT
, n
, prec
);
516 if (n
>= NUM_QUANT_TBLS
)
517 ERREXIT1(cinfo
, JERR_DQT_INDEX
, n
);
519 if (cinfo
->quant_tbl_ptrs
[n
] == NULL
)
520 cinfo
->quant_tbl_ptrs
[n
] = jpeg_alloc_quant_table((j_common_ptr
) cinfo
);
521 quant_ptr
= cinfo
->quant_tbl_ptrs
[n
];
524 if (length
< DCTSIZE2
* 2) {
525 /* Initialize full table for safety. */
526 for (i
= 0; i
< DCTSIZE2
; i
++) {
527 quant_ptr
->quantval
[i
] = 1;
533 if (length
< DCTSIZE2
) {
534 /* Initialize full table for safety. */
535 for (i
= 0; i
< DCTSIZE2
; i
++) {
536 quant_ptr
->quantval
[i
] = 1;
544 case (2*2): natural_order
= jpeg_natural_order2
; break;
545 case (3*3): natural_order
= jpeg_natural_order3
; break;
546 case (4*4): natural_order
= jpeg_natural_order4
; break;
547 case (5*5): natural_order
= jpeg_natural_order5
; break;
548 case (6*6): natural_order
= jpeg_natural_order6
; break;
549 case (7*7): natural_order
= jpeg_natural_order7
; break;
550 default: natural_order
= jpeg_natural_order
; break;
553 for (i
= 0; i
< count
; i
++) {
555 INPUT_2BYTES(cinfo
, tmp
, return FALSE
);
557 INPUT_BYTE(cinfo
, tmp
, return FALSE
);
558 /* We convert the zigzag-order table to natural array order. */
559 quant_ptr
->quantval
[natural_order
[i
]] = (UINT16
) tmp
;
562 if (cinfo
->err
->trace_level
>= 2) {
563 for (i
= 0; i
< DCTSIZE2
; i
+= 8) {
564 TRACEMS8(cinfo
, 2, JTRC_QUANTVALS
,
565 quant_ptr
->quantval
[i
], quant_ptr
->quantval
[i
+1],
566 quant_ptr
->quantval
[i
+2], quant_ptr
->quantval
[i
+3],
567 quant_ptr
->quantval
[i
+4], quant_ptr
->quantval
[i
+5],
568 quant_ptr
->quantval
[i
+6], quant_ptr
->quantval
[i
+7]);
573 if (prec
) length
-= count
;
577 ERREXIT(cinfo
, JERR_BAD_LENGTH
);
585 get_dri (j_decompress_ptr cinfo
)
586 /* Process a DRI marker */
592 INPUT_2BYTES(cinfo
, length
, return FALSE
);
595 ERREXIT(cinfo
, JERR_BAD_LENGTH
);
597 INPUT_2BYTES(cinfo
, tmp
, return FALSE
);
599 TRACEMS1(cinfo
, 1, JTRC_DRI
, tmp
);
601 cinfo
->restart_interval
= tmp
;
609 * Routines for processing APPn and COM markers.
610 * These are either saved in memory or discarded, per application request.
611 * APP0 and APP14 are specially checked to see if they are
612 * JFIF and Adobe markers, respectively.
615 #define APP0_DATA_LEN 14 /* Length of interesting data in APP0 */
616 #define APP14_DATA_LEN 12 /* Length of interesting data in APP14 */
617 #define APPN_DATA_LEN 14 /* Must be the largest of the above!! */
621 examine_app0 (j_decompress_ptr cinfo
, JOCTET FAR
* data
,
622 unsigned int datalen
, INT32 remaining
)
623 /* Examine first few bytes from an APP0.
624 * Take appropriate action if it is a JFIF marker.
625 * datalen is # of bytes at data[], remaining is length of rest of marker data.
628 INT32 totallen
= (INT32
) datalen
+ remaining
;
630 if (datalen
>= APP0_DATA_LEN
&&
631 GETJOCTET(data
[0]) == 0x4A &&
632 GETJOCTET(data
[1]) == 0x46 &&
633 GETJOCTET(data
[2]) == 0x49 &&
634 GETJOCTET(data
[3]) == 0x46 &&
635 GETJOCTET(data
[4]) == 0) {
636 /* Found JFIF APP0 marker: save info */
637 cinfo
->saw_JFIF_marker
= TRUE
;
638 cinfo
->JFIF_major_version
= GETJOCTET(data
[5]);
639 cinfo
->JFIF_minor_version
= GETJOCTET(data
[6]);
640 cinfo
->density_unit
= GETJOCTET(data
[7]);
641 cinfo
->X_density
= (GETJOCTET(data
[8]) << 8) + GETJOCTET(data
[9]);
642 cinfo
->Y_density
= (GETJOCTET(data
[10]) << 8) + GETJOCTET(data
[11]);
644 * Major version must be 1, anything else signals an incompatible change.
645 * (We used to treat this as an error, but now it's a nonfatal warning,
646 * because some bozo at Hijaak couldn't read the spec.)
647 * Minor version should be 0..2, but process anyway if newer.
649 if (cinfo
->JFIF_major_version
!= 1)
650 WARNMS2(cinfo
, JWRN_JFIF_MAJOR
,
651 cinfo
->JFIF_major_version
, cinfo
->JFIF_minor_version
);
652 /* Generate trace messages */
653 TRACEMS5(cinfo
, 1, JTRC_JFIF
,
654 cinfo
->JFIF_major_version
, cinfo
->JFIF_minor_version
,
655 cinfo
->X_density
, cinfo
->Y_density
, cinfo
->density_unit
);
656 /* Validate thumbnail dimensions and issue appropriate messages */
657 if (GETJOCTET(data
[12]) | GETJOCTET(data
[13]))
658 TRACEMS2(cinfo
, 1, JTRC_JFIF_THUMBNAIL
,
659 GETJOCTET(data
[12]), GETJOCTET(data
[13]));
660 totallen
-= APP0_DATA_LEN
;
662 ((INT32
)GETJOCTET(data
[12]) * (INT32
)GETJOCTET(data
[13]) * (INT32
) 3))
663 TRACEMS1(cinfo
, 1, JTRC_JFIF_BADTHUMBNAILSIZE
, (int) totallen
);
664 } else if (datalen
>= 6 &&
665 GETJOCTET(data
[0]) == 0x4A &&
666 GETJOCTET(data
[1]) == 0x46 &&
667 GETJOCTET(data
[2]) == 0x58 &&
668 GETJOCTET(data
[3]) == 0x58 &&
669 GETJOCTET(data
[4]) == 0) {
670 /* Found JFIF "JFXX" extension APP0 marker */
671 /* The library doesn't actually do anything with these,
672 * but we try to produce a helpful trace message.
674 switch (GETJOCTET(data
[5])) {
676 TRACEMS1(cinfo
, 1, JTRC_THUMB_JPEG
, (int) totallen
);
679 TRACEMS1(cinfo
, 1, JTRC_THUMB_PALETTE
, (int) totallen
);
682 TRACEMS1(cinfo
, 1, JTRC_THUMB_RGB
, (int) totallen
);
685 TRACEMS2(cinfo
, 1, JTRC_JFIF_EXTENSION
,
686 GETJOCTET(data
[5]), (int) totallen
);
690 /* Start of APP0 does not match "JFIF" or "JFXX", or too short */
691 TRACEMS1(cinfo
, 1, JTRC_APP0
, (int) totallen
);
697 examine_app14 (j_decompress_ptr cinfo
, JOCTET FAR
* data
,
698 unsigned int datalen
, INT32 remaining
)
699 /* Examine first few bytes from an APP14.
700 * Take appropriate action if it is an Adobe marker.
701 * datalen is # of bytes at data[], remaining is length of rest of marker data.
704 unsigned int version
, flags0
, flags1
, transform
;
706 if (datalen
>= APP14_DATA_LEN
&&
707 GETJOCTET(data
[0]) == 0x41 &&
708 GETJOCTET(data
[1]) == 0x64 &&
709 GETJOCTET(data
[2]) == 0x6F &&
710 GETJOCTET(data
[3]) == 0x62 &&
711 GETJOCTET(data
[4]) == 0x65) {
712 /* Found Adobe APP14 marker */
713 version
= (GETJOCTET(data
[5]) << 8) + GETJOCTET(data
[6]);
714 flags0
= (GETJOCTET(data
[7]) << 8) + GETJOCTET(data
[8]);
715 flags1
= (GETJOCTET(data
[9]) << 8) + GETJOCTET(data
[10]);
716 transform
= GETJOCTET(data
[11]);
717 TRACEMS4(cinfo
, 1, JTRC_ADOBE
, version
, flags0
, flags1
, transform
);
718 cinfo
->saw_Adobe_marker
= TRUE
;
719 cinfo
->Adobe_transform
= (UINT8
) transform
;
721 /* Start of APP14 does not match "Adobe", or too short */
722 TRACEMS1(cinfo
, 1, JTRC_APP14
, (int) (datalen
+ remaining
));
728 get_interesting_appn (j_decompress_ptr cinfo
)
729 /* Process an APP0 or APP14 marker without saving it */
732 JOCTET b
[APPN_DATA_LEN
];
733 unsigned int i
, numtoread
;
736 INPUT_2BYTES(cinfo
, length
, return FALSE
);
739 /* get the interesting part of the marker data */
740 if (length
>= APPN_DATA_LEN
)
741 numtoread
= APPN_DATA_LEN
;
743 numtoread
= (unsigned int) length
;
746 for (i
= 0; i
< numtoread
; i
++)
747 INPUT_BYTE(cinfo
, b
[i
], return FALSE
);
751 switch (cinfo
->unread_marker
) {
753 examine_app0(cinfo
, (JOCTET FAR
*) b
, numtoread
, length
);
756 examine_app14(cinfo
, (JOCTET FAR
*) b
, numtoread
, length
);
759 /* can't get here unless jpeg_save_markers chooses wrong processor */
760 ERREXIT1(cinfo
, JERR_UNKNOWN_MARKER
, cinfo
->unread_marker
);
764 /* skip any remaining data -- could be lots */
767 (*cinfo
->src
->skip_input_data
) (cinfo
, (long) length
);
773 #ifdef SAVE_MARKERS_SUPPORTED
776 save_marker (j_decompress_ptr cinfo
)
777 /* Save an APPn or COM marker into the marker list */
779 my_marker_ptr marker
= (my_marker_ptr
) cinfo
->marker
;
780 jpeg_saved_marker_ptr cur_marker
= marker
->cur_marker
;
781 unsigned int bytes_read
, data_length
;
786 if (cur_marker
== NULL
) {
787 /* begin reading a marker */
788 INPUT_2BYTES(cinfo
, length
, return FALSE
);
790 if (length
>= 0) { /* watch out for bogus length word */
791 /* figure out how much we want to save */
793 if (cinfo
->unread_marker
== (int) M_COM
)
794 limit
= marker
->length_limit_COM
;
796 limit
= marker
->length_limit_APPn
[cinfo
->unread_marker
- (int) M_APP0
];
797 if ((unsigned int) length
< limit
)
798 limit
= (unsigned int) length
;
799 /* allocate and initialize the marker item */
800 cur_marker
= (jpeg_saved_marker_ptr
)
801 (*cinfo
->mem
->alloc_large
) ((j_common_ptr
) cinfo
, JPOOL_IMAGE
,
802 SIZEOF(struct jpeg_marker_struct
) + limit
);
803 cur_marker
->next
= NULL
;
804 cur_marker
->marker
= (UINT8
) cinfo
->unread_marker
;
805 cur_marker
->original_length
= (unsigned int) length
;
806 cur_marker
->data_length
= limit
;
807 /* data area is just beyond the jpeg_marker_struct */
808 data
= cur_marker
->data
= (JOCTET FAR
*) (cur_marker
+ 1);
809 marker
->cur_marker
= cur_marker
;
810 marker
->bytes_read
= 0;
814 /* deal with bogus length word */
815 bytes_read
= data_length
= 0;
819 /* resume reading a marker */
820 bytes_read
= marker
->bytes_read
;
821 data_length
= cur_marker
->data_length
;
822 data
= cur_marker
->data
+ bytes_read
;
825 while (bytes_read
< data_length
) {
826 INPUT_SYNC(cinfo
); /* move the restart point to here */
827 marker
->bytes_read
= bytes_read
;
828 /* If there's not at least one byte in buffer, suspend */
829 MAKE_BYTE_AVAIL(cinfo
, return FALSE
);
830 /* Copy bytes with reasonable rapidity */
831 while (bytes_read
< data_length
&& bytes_in_buffer
> 0) {
832 *data
++ = *next_input_byte
++;
838 /* Done reading what we want to read */
839 if (cur_marker
!= NULL
) { /* will be NULL if bogus length word */
840 /* Add new marker to end of list */
841 if (cinfo
->marker_list
== NULL
) {
842 cinfo
->marker_list
= cur_marker
;
844 jpeg_saved_marker_ptr prev
= cinfo
->marker_list
;
845 while (prev
->next
!= NULL
)
847 prev
->next
= cur_marker
;
849 /* Reset pointer & calc remaining data length */
850 data
= cur_marker
->data
;
851 length
= cur_marker
->original_length
- data_length
;
853 /* Reset to initial state for next marker */
854 marker
->cur_marker
= NULL
;
856 /* Process the marker if interesting; else just make a generic trace msg */
857 switch (cinfo
->unread_marker
) {
859 examine_app0(cinfo
, data
, data_length
, length
);
862 examine_app14(cinfo
, data
, data_length
, length
);
865 TRACEMS2(cinfo
, 1, JTRC_MISC_MARKER
, cinfo
->unread_marker
,
866 (int) (data_length
+ length
));
870 /* skip any remaining data -- could be lots */
871 INPUT_SYNC(cinfo
); /* do before skip_input_data */
873 (*cinfo
->src
->skip_input_data
) (cinfo
, (long) length
);
878 #endif /* SAVE_MARKERS_SUPPORTED */
882 skip_variable (j_decompress_ptr cinfo
)
883 /* Skip over an unknown or uninteresting variable-length marker */
888 INPUT_2BYTES(cinfo
, length
, return FALSE
);
891 TRACEMS2(cinfo
, 1, JTRC_MISC_MARKER
, cinfo
->unread_marker
, (int) length
);
893 INPUT_SYNC(cinfo
); /* do before skip_input_data */
895 (*cinfo
->src
->skip_input_data
) (cinfo
, (long) length
);
902 * Find the next JPEG marker, save it in cinfo->unread_marker.
903 * Returns FALSE if had to suspend before reaching a marker;
904 * in that case cinfo->unread_marker is unchanged.
906 * Note that the result might not be a valid marker code,
907 * but it will never be 0 or FF.
911 next_marker (j_decompress_ptr cinfo
)
917 INPUT_BYTE(cinfo
, c
, return FALSE
);
918 /* Skip any non-FF bytes.
919 * This may look a bit inefficient, but it will not occur in a valid file.
920 * We sync after each discarded byte so that a suspending data source
921 * can discard the byte from its buffer.
924 cinfo
->marker
->discarded_bytes
++;
926 INPUT_BYTE(cinfo
, c
, return FALSE
);
928 /* This loop swallows any duplicate FF bytes. Extra FFs are legal as
929 * pad bytes, so don't count them in discarded_bytes. We assume there
930 * will not be so many consecutive FF bytes as to overflow a suspending
931 * data source's input buffer.
934 INPUT_BYTE(cinfo
, c
, return FALSE
);
937 break; /* found a valid marker, exit loop */
938 /* Reach here if we found a stuffed-zero data sequence (FF/00).
939 * Discard it and loop back to try again.
941 cinfo
->marker
->discarded_bytes
+= 2;
945 if (cinfo
->marker
->discarded_bytes
!= 0) {
946 WARNMS2(cinfo
, JWRN_EXTRANEOUS_DATA
, cinfo
->marker
->discarded_bytes
, c
);
947 cinfo
->marker
->discarded_bytes
= 0;
950 cinfo
->unread_marker
= c
;
958 first_marker (j_decompress_ptr cinfo
)
959 /* Like next_marker, but used to obtain the initial SOI marker. */
960 /* For this marker, we do not allow preceding garbage or fill; otherwise,
961 * we might well scan an entire input file before realizing it ain't JPEG.
962 * If an application wants to process non-JFIF files, it must seek to the
963 * SOI before calling the JPEG library.
969 INPUT_BYTE(cinfo
, c
, return FALSE
);
970 INPUT_BYTE(cinfo
, c2
, return FALSE
);
971 if (c
!= 0xFF || c2
!= (int) M_SOI
)
972 ERREXIT2(cinfo
, JERR_NO_SOI
, c
, c2
);
974 cinfo
->unread_marker
= c2
;
982 * Read markers until SOS or EOI.
984 * Returns same codes as are defined for jpeg_consume_input:
985 * JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI.
987 * Note: This function may return a pseudo SOS marker (with zero
988 * component number) for treat by input controller's consume_input.
989 * consume_input itself should filter out (skip) the pseudo marker
990 * after processing for the caller.
994 read_markers (j_decompress_ptr cinfo
)
996 /* Outer loop repeats once for each marker. */
998 /* Collect the marker proper, unless we already did. */
999 /* NB: first_marker() enforces the requirement that SOI appear first. */
1000 if (cinfo
->unread_marker
== 0) {
1001 if (! cinfo
->marker
->saw_SOI
) {
1002 if (! first_marker(cinfo
))
1003 return JPEG_SUSPENDED
;
1005 if (! next_marker(cinfo
))
1006 return JPEG_SUSPENDED
;
1009 /* At this point cinfo->unread_marker contains the marker code and the
1010 * input point is just past the marker proper, but before any parameters.
1011 * A suspension will cause us to return with this state still true.
1013 switch (cinfo
->unread_marker
) {
1015 if (! get_soi(cinfo
))
1016 return JPEG_SUSPENDED
;
1019 case M_SOF0
: /* Baseline */
1020 if (! get_sof(cinfo
, TRUE
, FALSE
, FALSE
))
1021 return JPEG_SUSPENDED
;
1024 case M_SOF1
: /* Extended sequential, Huffman */
1025 if (! get_sof(cinfo
, FALSE
, FALSE
, FALSE
))
1026 return JPEG_SUSPENDED
;
1029 case M_SOF2
: /* Progressive, Huffman */
1030 if (! get_sof(cinfo
, FALSE
, TRUE
, FALSE
))
1031 return JPEG_SUSPENDED
;
1034 case M_SOF9
: /* Extended sequential, arithmetic */
1035 if (! get_sof(cinfo
, FALSE
, FALSE
, TRUE
))
1036 return JPEG_SUSPENDED
;
1039 case M_SOF10
: /* Progressive, arithmetic */
1040 if (! get_sof(cinfo
, FALSE
, TRUE
, TRUE
))
1041 return JPEG_SUSPENDED
;
1044 /* Currently unsupported SOFn types */
1045 case M_SOF3
: /* Lossless, Huffman */
1046 case M_SOF5
: /* Differential sequential, Huffman */
1047 case M_SOF6
: /* Differential progressive, Huffman */
1048 case M_SOF7
: /* Differential lossless, Huffman */
1049 case M_JPG
: /* Reserved for JPEG extensions */
1050 case M_SOF11
: /* Lossless, arithmetic */
1051 case M_SOF13
: /* Differential sequential, arithmetic */
1052 case M_SOF14
: /* Differential progressive, arithmetic */
1053 case M_SOF15
: /* Differential lossless, arithmetic */
1054 ERREXIT1(cinfo
, JERR_SOF_UNSUPPORTED
, cinfo
->unread_marker
);
1058 if (! get_sos(cinfo
))
1059 return JPEG_SUSPENDED
;
1060 cinfo
->unread_marker
= 0; /* processed the marker */
1061 return JPEG_REACHED_SOS
;
1064 TRACEMS(cinfo
, 1, JTRC_EOI
);
1065 cinfo
->unread_marker
= 0; /* processed the marker */
1066 return JPEG_REACHED_EOI
;
1069 if (! get_dac(cinfo
))
1070 return JPEG_SUSPENDED
;
1074 if (! get_dht(cinfo
))
1075 return JPEG_SUSPENDED
;
1079 if (! get_dqt(cinfo
))
1080 return JPEG_SUSPENDED
;
1084 if (! get_dri(cinfo
))
1085 return JPEG_SUSPENDED
;
1104 if (! (*((my_marker_ptr
) cinfo
->marker
)->process_APPn
[
1105 cinfo
->unread_marker
- (int) M_APP0
]) (cinfo
))
1106 return JPEG_SUSPENDED
;
1110 if (! (*((my_marker_ptr
) cinfo
->marker
)->process_COM
) (cinfo
))
1111 return JPEG_SUSPENDED
;
1114 case M_RST0
: /* these are all parameterless */
1123 TRACEMS1(cinfo
, 1, JTRC_PARMLESS_MARKER
, cinfo
->unread_marker
);
1126 case M_DNL
: /* Ignore DNL ... perhaps the wrong thing */
1127 if (! skip_variable(cinfo
))
1128 return JPEG_SUSPENDED
;
1131 default: /* must be DHP, EXP, JPGn, or RESn */
1132 /* For now, we treat the reserved markers as fatal errors since they are
1133 * likely to be used to signal incompatible JPEG Part 3 extensions.
1134 * Once the JPEG 3 version-number marker is well defined, this code
1137 ERREXIT1(cinfo
, JERR_UNKNOWN_MARKER
, cinfo
->unread_marker
);
1140 /* Successfully processed marker, so reset state variable */
1141 cinfo
->unread_marker
= 0;
1147 * Read a restart marker, which is expected to appear next in the datastream;
1148 * if the marker is not there, take appropriate recovery action.
1149 * Returns FALSE if suspension is required.
1151 * This is called by the entropy decoder after it has read an appropriate
1152 * number of MCUs. cinfo->unread_marker may be nonzero if the entropy decoder
1153 * has already read a marker from the data source. Under normal conditions
1154 * cinfo->unread_marker will be reset to 0 before returning; if not reset,
1155 * it holds a marker which the decoder will be unable to read past.
1159 read_restart_marker (j_decompress_ptr cinfo
)
1161 /* Obtain a marker unless we already did. */
1162 /* Note that next_marker will complain if it skips any data. */
1163 if (cinfo
->unread_marker
== 0) {
1164 if (! next_marker(cinfo
))
1168 if (cinfo
->unread_marker
==
1169 ((int) M_RST0
+ cinfo
->marker
->next_restart_num
)) {
1170 /* Normal case --- swallow the marker and let entropy decoder continue */
1171 TRACEMS1(cinfo
, 3, JTRC_RST
, cinfo
->marker
->next_restart_num
);
1172 cinfo
->unread_marker
= 0;
1174 /* Uh-oh, the restart markers have been messed up. */
1175 /* Let the data source manager determine how to resync. */
1176 if (! (*cinfo
->src
->resync_to_restart
) (cinfo
,
1177 cinfo
->marker
->next_restart_num
))
1181 /* Update next-restart state */
1182 cinfo
->marker
->next_restart_num
= (cinfo
->marker
->next_restart_num
+ 1) & 7;
1189 * This is the default resync_to_restart method for data source managers
1190 * to use if they don't have any better approach. Some data source managers
1191 * may be able to back up, or may have additional knowledge about the data
1192 * which permits a more intelligent recovery strategy; such managers would
1193 * presumably supply their own resync method.
1195 * read_restart_marker calls resync_to_restart if it finds a marker other than
1196 * the restart marker it was expecting. (This code is *not* used unless
1197 * a nonzero restart interval has been declared.) cinfo->unread_marker is
1198 * the marker code actually found (might be anything, except 0 or FF).
1199 * The desired restart marker number (0..7) is passed as a parameter.
1200 * This routine is supposed to apply whatever error recovery strategy seems
1201 * appropriate in order to position the input stream to the next data segment.
1202 * Note that cinfo->unread_marker is treated as a marker appearing before
1203 * the current data-source input point; usually it should be reset to zero
1205 * Returns FALSE if suspension is required.
1207 * This implementation is substantially constrained by wanting to treat the
1208 * input as a data stream; this means we can't back up. Therefore, we have
1209 * only the following actions to work with:
1210 * 1. Simply discard the marker and let the entropy decoder resume at next
1212 * 2. Read forward until we find another marker, discarding intervening
1213 * data. (In theory we could look ahead within the current bufferload,
1214 * without having to discard data if we don't find the desired marker.
1215 * This idea is not implemented here, in part because it makes behavior
1216 * dependent on buffer size and chance buffer-boundary positions.)
1217 * 3. Leave the marker unread (by failing to zero cinfo->unread_marker).
1218 * This will cause the entropy decoder to process an empty data segment,
1219 * inserting dummy zeroes, and then we will reprocess the marker.
1221 * #2 is appropriate if we think the desired marker lies ahead, while #3 is
1222 * appropriate if the found marker is a future restart marker (indicating
1223 * that we have missed the desired restart marker, probably because it got
1225 * We apply #2 or #3 if the found marker is a restart marker no more than
1226 * two counts behind or ahead of the expected one. We also apply #2 if the
1227 * found marker is not a legal JPEG marker code (it's certainly bogus data).
1228 * If the found marker is a restart marker more than 2 counts away, we do #1
1229 * (too much risk that the marker is erroneous; with luck we will be able to
1230 * resync at some future point).
1231 * For any valid non-restart JPEG marker, we apply #3. This keeps us from
1232 * overrunning the end of a scan. An implementation limited to single-scan
1233 * files might find it better to apply #2 for markers other than EOI, since
1234 * any other marker would have to be bogus data in that case.
1238 jpeg_resync_to_restart (j_decompress_ptr cinfo
, int desired
)
1240 int marker
= cinfo
->unread_marker
;
1243 /* Always put up a warning. */
1244 WARNMS2(cinfo
, JWRN_MUST_RESYNC
, marker
, desired
);
1246 /* Outer loop handles repeated decision after scanning forward. */
1248 if (marker
< (int) M_SOF0
)
1249 action
= 2; /* invalid marker */
1250 else if (marker
< (int) M_RST0
|| marker
> (int) M_RST7
)
1251 action
= 3; /* valid non-restart marker */
1253 if (marker
== ((int) M_RST0
+ ((desired
+1) & 7)) ||
1254 marker
== ((int) M_RST0
+ ((desired
+2) & 7)))
1255 action
= 3; /* one of the next two expected restarts */
1256 else if (marker
== ((int) M_RST0
+ ((desired
-1) & 7)) ||
1257 marker
== ((int) M_RST0
+ ((desired
-2) & 7)))
1258 action
= 2; /* a prior restart, so advance */
1260 action
= 1; /* desired restart or too far away */
1262 TRACEMS2(cinfo
, 4, JTRC_RECOVERY_ACTION
, marker
, action
);
1265 /* Discard marker and let entropy decoder resume processing. */
1266 cinfo
->unread_marker
= 0;
1269 /* Scan to the next marker, and repeat the decision loop. */
1270 if (! next_marker(cinfo
))
1272 marker
= cinfo
->unread_marker
;
1275 /* Return without advancing past this marker. */
1276 /* Entropy decoder will be forced to process an empty segment. */
1284 * Reset marker processing state to begin a fresh datastream.
1288 reset_marker_reader (j_decompress_ptr cinfo
)
1290 my_marker_ptr marker
= (my_marker_ptr
) cinfo
->marker
;
1292 cinfo
->comp_info
= NULL
; /* until allocated by get_sof */
1293 cinfo
->input_scan_number
= 0; /* no SOS seen yet */
1294 cinfo
->unread_marker
= 0; /* no pending marker */
1295 marker
->pub
.saw_SOI
= FALSE
; /* set internal state too */
1296 marker
->pub
.saw_SOF
= FALSE
;
1297 marker
->pub
.discarded_bytes
= 0;
1298 marker
->cur_marker
= NULL
;
1303 * Initialize the marker reader module.
1304 * This is called only once, when the decompression object is created.
1308 jinit_marker_reader (j_decompress_ptr cinfo
)
1310 my_marker_ptr marker
;
1313 /* Create subobject in permanent pool */
1314 marker
= (my_marker_ptr
)
1315 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
1316 SIZEOF(my_marker_reader
));
1317 cinfo
->marker
= (struct jpeg_marker_reader
*) marker
;
1318 /* Initialize public method pointers */
1319 marker
->pub
.reset_marker_reader
= reset_marker_reader
;
1320 marker
->pub
.read_markers
= read_markers
;
1321 marker
->pub
.read_restart_marker
= read_restart_marker
;
1322 /* Initialize COM/APPn processing.
1323 * By default, we examine and then discard APP0 and APP14,
1324 * but simply discard COM and all other APPn.
1326 marker
->process_COM
= skip_variable
;
1327 marker
->length_limit_COM
= 0;
1328 for (i
= 0; i
< 16; i
++) {
1329 marker
->process_APPn
[i
] = skip_variable
;
1330 marker
->length_limit_APPn
[i
] = 0;
1332 marker
->process_APPn
[0] = get_interesting_appn
;
1333 marker
->process_APPn
[14] = get_interesting_appn
;
1334 /* Reset marker processing state */
1335 reset_marker_reader(cinfo
);
1340 * Control saving of COM and APPn markers into marker_list.
1343 #ifdef SAVE_MARKERS_SUPPORTED
1346 jpeg_save_markers (j_decompress_ptr cinfo
, int marker_code
,
1347 unsigned int length_limit
)
1349 my_marker_ptr marker
= (my_marker_ptr
) cinfo
->marker
;
1351 jpeg_marker_parser_method processor
;
1353 /* Length limit mustn't be larger than what we can allocate
1354 * (should only be a concern in a 16-bit environment).
1356 maxlength
= cinfo
->mem
->max_alloc_chunk
- SIZEOF(struct jpeg_marker_struct
);
1357 if (((long) length_limit
) > maxlength
)
1358 length_limit
= (unsigned int) maxlength
;
1360 /* Choose processor routine to use.
1361 * APP0/APP14 have special requirements.
1364 processor
= save_marker
;
1365 /* If saving APP0/APP14, save at least enough for our internal use. */
1366 if (marker_code
== (int) M_APP0
&& length_limit
< APP0_DATA_LEN
)
1367 length_limit
= APP0_DATA_LEN
;
1368 else if (marker_code
== (int) M_APP14
&& length_limit
< APP14_DATA_LEN
)
1369 length_limit
= APP14_DATA_LEN
;
1371 processor
= skip_variable
;
1372 /* If discarding APP0/APP14, use our regular on-the-fly processor. */
1373 if (marker_code
== (int) M_APP0
|| marker_code
== (int) M_APP14
)
1374 processor
= get_interesting_appn
;
1377 if (marker_code
== (int) M_COM
) {
1378 marker
->process_COM
= processor
;
1379 marker
->length_limit_COM
= length_limit
;
1380 } else if (marker_code
>= (int) M_APP0
&& marker_code
<= (int) M_APP15
) {
1381 marker
->process_APPn
[marker_code
- (int) M_APP0
] = processor
;
1382 marker
->length_limit_APPn
[marker_code
- (int) M_APP0
] = length_limit
;
1384 ERREXIT1(cinfo
, JERR_UNKNOWN_MARKER
, marker_code
);
1387 #endif /* SAVE_MARKERS_SUPPORTED */
1391 * Install a special processing method for COM or APPn markers.
1395 jpeg_set_marker_processor (j_decompress_ptr cinfo
, int marker_code
,
1396 jpeg_marker_parser_method routine
)
1398 my_marker_ptr marker
= (my_marker_ptr
) cinfo
->marker
;
1400 if (marker_code
== (int) M_COM
)
1401 marker
->process_COM
= routine
;
1402 else if (marker_code
>= (int) M_APP0
&& marker_code
<= (int) M_APP15
)
1403 marker
->process_APPn
[marker_code
- (int) M_APP0
] = routine
;
1405 ERREXIT1(cinfo
, JERR_UNKNOWN_MARKER
, marker_code
);