4 * Copyright (C) 1991-1998, Thomas G. Lane.
5 * Modified 2009-2019 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 */
93 struct jpeg_marker_reader pub
; /* public fields */
95 /* Application-overridable marker processing methods */
96 jpeg_marker_parser_method process_COM
;
97 jpeg_marker_parser_method process_APPn
[16];
99 /* Limit on marker data length to save for each marker type */
100 unsigned int length_limit_COM
;
101 unsigned int length_limit_APPn
[16];
103 /* Status of COM/APPn marker saving */
104 jpeg_saved_marker_ptr cur_marker
; /* NULL if not processing a marker */
105 unsigned int bytes_read
; /* data bytes read so far in marker */
106 /* Note: cur_marker is not linked into marker_list until it's all read. */
109 typedef my_marker_reader
* my_marker_ptr
;
113 * Macros for fetching data from the data source module.
115 * At all times, cinfo->src->next_input_byte and ->bytes_in_buffer reflect
116 * the current restart point; we update them only when we have reached a
117 * suitable place to restart if a suspension occurs.
120 /* Declare and initialize local copies of input pointer/count */
121 #define INPUT_VARS(cinfo) \
122 struct jpeg_source_mgr * datasrc = (cinfo)->src; \
123 const JOCTET * next_input_byte = datasrc->next_input_byte; \
124 size_t bytes_in_buffer = datasrc->bytes_in_buffer
126 /* Unload the local copies --- do this only at a restart boundary */
127 #define INPUT_SYNC(cinfo) \
128 ( datasrc->next_input_byte = next_input_byte, \
129 datasrc->bytes_in_buffer = bytes_in_buffer )
131 /* Reload the local copies --- used only in MAKE_BYTE_AVAIL */
132 #define INPUT_RELOAD(cinfo) \
133 ( next_input_byte = datasrc->next_input_byte, \
134 bytes_in_buffer = datasrc->bytes_in_buffer )
136 /* Internal macro for INPUT_BYTE and INPUT_2BYTES: make a byte available.
137 * Note we do *not* do INPUT_SYNC before calling fill_input_buffer,
138 * but we must reload the local copies after a successful fill.
140 #define MAKE_BYTE_AVAIL(cinfo,action) \
141 if (bytes_in_buffer == 0) { \
142 if (! (*datasrc->fill_input_buffer) (cinfo)) \
144 INPUT_RELOAD(cinfo); \
147 /* Read a byte into variable V.
148 * If must suspend, take the specified action (typically "return FALSE").
150 #define INPUT_BYTE(cinfo,V,action) \
151 MAKESTMT( MAKE_BYTE_AVAIL(cinfo,action); \
153 V = GETJOCTET(*next_input_byte++); )
155 /* As above, but read two bytes interpreted as an unsigned 16-bit integer.
156 * V should be declared unsigned int or perhaps INT32.
158 #define INPUT_2BYTES(cinfo,V,action) \
159 MAKESTMT( MAKE_BYTE_AVAIL(cinfo,action); \
161 V = ((unsigned int) GETJOCTET(*next_input_byte++)) << 8; \
162 MAKE_BYTE_AVAIL(cinfo,action); \
164 V += GETJOCTET(*next_input_byte++); )
168 * Routines to process JPEG markers.
170 * Entry condition: JPEG marker itself has been read and its code saved
171 * in cinfo->unread_marker; input restart point is just after the marker.
173 * Exit: if return TRUE, have read and processed any parameters, and have
174 * updated the restart point to point after the parameters.
175 * If return FALSE, was forced to suspend before reaching end of
176 * marker parameters; restart point has not been moved. Same routine
177 * will be called again after application supplies more input data.
179 * This approach to suspension assumes that all of a marker's parameters
180 * can fit into a single input bufferload. This should hold for "normal"
181 * markers. Some COM/APPn markers might have large parameter segments
182 * that might not fit. If we are simply dropping such a marker, we use
183 * skip_input_data to get past it, and thereby put the problem on the
184 * source manager's shoulders. If we are saving the marker's contents
185 * into memory, we use a slightly different convention: when forced to
186 * suspend, the marker processor updates the restart point to the end of
187 * what it's consumed (ie, the end of the buffer) before returning FALSE.
188 * On resumption, cinfo->unread_marker still contains the marker code,
189 * but the data source will point to the next chunk of marker data.
190 * The marker processor must retain internal state to deal with this.
192 * Note that we don't bother to avoid duplicate trace messages if a
193 * suspension occurs within marker parameters. Other side effects
199 get_soi (j_decompress_ptr cinfo
)
200 /* Process an SOI marker */
204 TRACEMS(cinfo
, 1, JTRC_SOI
);
206 if (cinfo
->marker
->saw_SOI
)
207 ERREXIT(cinfo
, JERR_SOI_DUPLICATE
);
209 /* Reset all parameters that are defined to be reset by SOI */
211 for (i
= 0; i
< NUM_ARITH_TBLS
; i
++) {
212 cinfo
->arith_dc_L
[i
] = 0;
213 cinfo
->arith_dc_U
[i
] = 1;
214 cinfo
->arith_ac_K
[i
] = 5;
216 cinfo
->restart_interval
= 0;
218 /* Set initial assumptions for colorspace etc */
220 cinfo
->jpeg_color_space
= JCS_UNKNOWN
;
221 cinfo
->color_transform
= JCT_NONE
;
222 cinfo
->CCIR601_sampling
= FALSE
; /* Assume non-CCIR sampling??? */
224 cinfo
->saw_JFIF_marker
= FALSE
;
225 cinfo
->JFIF_major_version
= 1; /* set default JFIF APP0 values */
226 cinfo
->JFIF_minor_version
= 1;
227 cinfo
->density_unit
= 0;
228 cinfo
->X_density
= 1;
229 cinfo
->Y_density
= 1;
230 cinfo
->saw_Adobe_marker
= FALSE
;
231 cinfo
->Adobe_transform
= 0;
233 cinfo
->marker
->saw_SOI
= TRUE
;
240 get_sof (j_decompress_ptr cinfo
, boolean is_baseline
, boolean is_prog
,
242 /* Process a SOFn marker */
246 jpeg_component_info
* compptr
;
249 cinfo
->is_baseline
= is_baseline
;
250 cinfo
->progressive_mode
= is_prog
;
251 cinfo
->arith_code
= is_arith
;
253 INPUT_2BYTES(cinfo
, length
, return FALSE
);
255 INPUT_BYTE(cinfo
, cinfo
->data_precision
, return FALSE
);
256 INPUT_2BYTES(cinfo
, cinfo
->image_height
, return FALSE
);
257 INPUT_2BYTES(cinfo
, cinfo
->image_width
, return FALSE
);
258 INPUT_BYTE(cinfo
, cinfo
->num_components
, return FALSE
);
262 TRACEMS4(cinfo
, 1, JTRC_SOF
, cinfo
->unread_marker
,
263 (int) cinfo
->image_width
, (int) cinfo
->image_height
,
264 cinfo
->num_components
);
266 if (cinfo
->marker
->saw_SOF
)
267 ERREXIT(cinfo
, JERR_SOF_DUPLICATE
);
269 /* We don't support files in which the image height is initially specified */
270 /* as 0 and is later redefined by DNL. As long as we have to check that, */
271 /* might as well have a general sanity check. */
272 if (cinfo
->image_height
<= 0 || cinfo
->image_width
<= 0 ||
273 cinfo
->num_components
<= 0)
274 ERREXIT(cinfo
, JERR_EMPTY_IMAGE
);
276 if (length
!= (cinfo
->num_components
* 3))
277 ERREXIT(cinfo
, JERR_BAD_LENGTH
);
279 if (cinfo
->comp_info
== NULL
) /* do only once, even if suspend */
280 cinfo
->comp_info
= (jpeg_component_info
*) (*cinfo
->mem
->alloc_small
)
281 ((j_common_ptr
) cinfo
, JPOOL_IMAGE
,
282 cinfo
->num_components
* SIZEOF(jpeg_component_info
));
284 for (ci
= 0; ci
< cinfo
->num_components
; ci
++) {
285 INPUT_BYTE(cinfo
, c
, return FALSE
);
286 /* Check to see whether component id has already been seen */
287 /* (in violation of the spec, but unfortunately seen in some */
288 /* files). If so, create "fake" component id equal to the */
289 /* max id seen so far + 1. */
290 for (i
= 0, compptr
= cinfo
->comp_info
; i
< ci
; i
++, compptr
++) {
291 if (c
== compptr
->component_id
) {
292 compptr
= cinfo
->comp_info
;
293 c
= compptr
->component_id
;
295 for (i
= 1; i
< ci
; i
++, compptr
++) {
296 if (compptr
->component_id
> c
) c
= compptr
->component_id
;
302 compptr
->component_id
= c
;
303 compptr
->component_index
= ci
;
304 INPUT_BYTE(cinfo
, c
, return FALSE
);
305 compptr
->h_samp_factor
= (c
>> 4) & 15;
306 compptr
->v_samp_factor
= (c
) & 15;
307 INPUT_BYTE(cinfo
, compptr
->quant_tbl_no
, return FALSE
);
309 TRACEMS4(cinfo
, 1, JTRC_SOF_COMPONENT
,
310 compptr
->component_id
, compptr
->h_samp_factor
,
311 compptr
->v_samp_factor
, compptr
->quant_tbl_no
);
314 cinfo
->marker
->saw_SOF
= TRUE
;
322 get_sos (j_decompress_ptr cinfo
)
323 /* Process a SOS marker */
327 jpeg_component_info
* compptr
;
330 if (! cinfo
->marker
->saw_SOF
)
331 ERREXITS(cinfo
, JERR_SOF_BEFORE
, "SOS");
333 INPUT_2BYTES(cinfo
, length
, return FALSE
);
335 INPUT_BYTE(cinfo
, n
, return FALSE
); /* Number of components */
337 TRACEMS1(cinfo
, 1, JTRC_SOS
, n
);
339 if (length
!= (n
* 2 + 6) || n
> MAX_COMPS_IN_SCAN
||
340 (n
== 0 && !cinfo
->progressive_mode
))
341 /* pseudo SOS marker only allowed in progressive mode */
342 ERREXIT(cinfo
, JERR_BAD_LENGTH
);
344 cinfo
->comps_in_scan
= n
;
346 /* Collect the component-spec parameters */
348 for (i
= 0; i
< n
; i
++) {
349 INPUT_BYTE(cinfo
, c
, return FALSE
);
351 /* Detect the case where component id's are not unique, and, if so, */
352 /* create a fake component id using the same logic as in get_sof. */
353 /* Note: This also ensures that all of the SOF components are */
354 /* referenced in the single scan case, which prevents access to */
355 /* uninitialized memory in later decoding stages. */
356 for (ci
= 0; ci
< i
; ci
++) {
357 if (c
== cinfo
->cur_comp_info
[ci
]->component_id
) {
358 c
= cinfo
->cur_comp_info
[0]->component_id
;
359 for (ci
= 1; ci
< i
; ci
++) {
360 compptr
= cinfo
->cur_comp_info
[ci
];
361 if (compptr
->component_id
> c
) c
= compptr
->component_id
;
368 for (ci
= 0, compptr
= cinfo
->comp_info
; ci
< cinfo
->num_components
;
370 if (c
== compptr
->component_id
)
374 ERREXIT1(cinfo
, JERR_BAD_COMPONENT_ID
, c
);
378 cinfo
->cur_comp_info
[i
] = compptr
;
379 INPUT_BYTE(cinfo
, c
, return FALSE
);
380 compptr
->dc_tbl_no
= (c
>> 4) & 15;
381 compptr
->ac_tbl_no
= (c
) & 15;
383 TRACEMS3(cinfo
, 1, JTRC_SOS_COMPONENT
, compptr
->component_id
,
384 compptr
->dc_tbl_no
, compptr
->ac_tbl_no
);
387 /* Collect the additional scan parameters Ss, Se, Ah/Al. */
388 INPUT_BYTE(cinfo
, c
, return FALSE
);
390 INPUT_BYTE(cinfo
, c
, return FALSE
);
392 INPUT_BYTE(cinfo
, c
, return FALSE
);
393 cinfo
->Ah
= (c
>> 4) & 15;
394 cinfo
->Al
= (c
) & 15;
396 TRACEMS4(cinfo
, 1, JTRC_SOS_PARAMS
, cinfo
->Ss
, cinfo
->Se
,
397 cinfo
->Ah
, cinfo
->Al
);
399 /* Prepare to scan data & restart markers */
400 cinfo
->marker
->next_restart_num
= 0;
402 /* Count another (non-pseudo) SOS marker */
403 if (n
) cinfo
->input_scan_number
++;
410 #ifdef D_ARITH_CODING_SUPPORTED
413 get_dac (j_decompress_ptr cinfo
)
414 /* Process a DAC marker */
420 INPUT_2BYTES(cinfo
, length
, return FALSE
);
424 INPUT_BYTE(cinfo
, index
, return FALSE
);
425 INPUT_BYTE(cinfo
, val
, return FALSE
);
429 TRACEMS2(cinfo
, 1, JTRC_DAC
, index
, val
);
431 if (index
< 0 || index
>= (2*NUM_ARITH_TBLS
))
432 ERREXIT1(cinfo
, JERR_DAC_INDEX
, index
);
434 if (index
>= NUM_ARITH_TBLS
) { /* define AC table */
435 cinfo
->arith_ac_K
[index
-NUM_ARITH_TBLS
] = (UINT8
) val
;
436 } else { /* define DC table */
437 cinfo
->arith_dc_L
[index
] = (UINT8
) (val
& 0x0F);
438 cinfo
->arith_dc_U
[index
] = (UINT8
) (val
>> 4);
439 if (cinfo
->arith_dc_L
[index
] > cinfo
->arith_dc_U
[index
])
440 ERREXIT1(cinfo
, JERR_DAC_VALUE
, val
);
445 ERREXIT(cinfo
, JERR_BAD_LENGTH
);
451 #else /* ! D_ARITH_CODING_SUPPORTED */
453 #define get_dac(cinfo) skip_variable(cinfo)
455 #endif /* D_ARITH_CODING_SUPPORTED */
459 get_dht (j_decompress_ptr cinfo
)
460 /* Process a DHT marker */
469 INPUT_2BYTES(cinfo
, length
, return FALSE
);
472 while (length
> 16) {
473 INPUT_BYTE(cinfo
, index
, return FALSE
);
475 TRACEMS1(cinfo
, 1, JTRC_DHT
, index
);
479 for (i
= 1; i
<= 16; i
++) {
480 INPUT_BYTE(cinfo
, bits
[i
], return FALSE
);
486 TRACEMS8(cinfo
, 2, JTRC_HUFFBITS
,
487 bits
[1], bits
[2], bits
[3], bits
[4],
488 bits
[5], bits
[6], bits
[7], bits
[8]);
489 TRACEMS8(cinfo
, 2, JTRC_HUFFBITS
,
490 bits
[9], bits
[10], bits
[11], bits
[12],
491 bits
[13], bits
[14], bits
[15], bits
[16]);
493 /* Here we just do minimal validation of the counts to avoid walking
494 * off the end of our table space. jdhuff.c will check more carefully.
496 if (count
> 256 || ((INT32
) count
) > length
)
497 ERREXIT(cinfo
, JERR_BAD_HUFF_TABLE
);
499 for (i
= 0; i
< count
; i
++)
500 INPUT_BYTE(cinfo
, huffval
[i
], return FALSE
);
504 if (index
& 0x10) { /* AC table definition */
506 htblptr
= &cinfo
->ac_huff_tbl_ptrs
[index
];
507 } else { /* DC table definition */
508 htblptr
= &cinfo
->dc_huff_tbl_ptrs
[index
];
511 if (index
< 0 || index
>= NUM_HUFF_TBLS
)
512 ERREXIT1(cinfo
, JERR_DHT_INDEX
, index
);
514 if (*htblptr
== NULL
)
515 *htblptr
= jpeg_alloc_huff_table((j_common_ptr
) cinfo
);
517 MEMCOPY((*htblptr
)->bits
, bits
, SIZEOF((*htblptr
)->bits
));
519 MEMCOPY((*htblptr
)->huffval
, huffval
, count
* SIZEOF(UINT8
));
523 ERREXIT(cinfo
, JERR_BAD_LENGTH
);
531 get_dqt (j_decompress_ptr cinfo
)
532 /* Process a DQT marker */
534 INT32 length
, count
, i
;
537 JQUANT_TBL
*quant_ptr
;
538 const int *natural_order
;
541 INPUT_2BYTES(cinfo
, length
, return FALSE
);
546 INPUT_BYTE(cinfo
, n
, return FALSE
);
550 TRACEMS2(cinfo
, 1, JTRC_DQT
, n
, prec
);
552 if (n
>= NUM_QUANT_TBLS
)
553 ERREXIT1(cinfo
, JERR_DQT_INDEX
, n
);
555 if (cinfo
->quant_tbl_ptrs
[n
] == NULL
)
556 cinfo
->quant_tbl_ptrs
[n
] = jpeg_alloc_quant_table((j_common_ptr
) cinfo
);
557 quant_ptr
= cinfo
->quant_tbl_ptrs
[n
];
560 if (length
< DCTSIZE2
* 2) {
561 /* Initialize full table for safety. */
562 for (i
= 0; i
< DCTSIZE2
; i
++) {
563 quant_ptr
->quantval
[i
] = 1;
569 if (length
< DCTSIZE2
) {
570 /* Initialize full table for safety. */
571 for (i
= 0; i
< DCTSIZE2
; i
++) {
572 quant_ptr
->quantval
[i
] = 1;
579 switch ((int) count
) {
580 case (2*2): natural_order
= jpeg_natural_order2
; break;
581 case (3*3): natural_order
= jpeg_natural_order3
; break;
582 case (4*4): natural_order
= jpeg_natural_order4
; break;
583 case (5*5): natural_order
= jpeg_natural_order5
; break;
584 case (6*6): natural_order
= jpeg_natural_order6
; break;
585 case (7*7): natural_order
= jpeg_natural_order7
; break;
586 default: natural_order
= jpeg_natural_order
;
589 for (i
= 0; i
< count
; i
++) {
591 INPUT_2BYTES(cinfo
, tmp
, return FALSE
);
593 INPUT_BYTE(cinfo
, tmp
, return FALSE
);
594 /* We convert the zigzag-order table to natural array order. */
595 quant_ptr
->quantval
[natural_order
[i
]] = (UINT16
) tmp
;
598 if (cinfo
->err
->trace_level
>= 2) {
599 for (i
= 0; i
< DCTSIZE2
; i
+= 8) {
600 TRACEMS8(cinfo
, 2, JTRC_QUANTVALS
,
601 quant_ptr
->quantval
[i
], quant_ptr
->quantval
[i
+1],
602 quant_ptr
->quantval
[i
+2], quant_ptr
->quantval
[i
+3],
603 quant_ptr
->quantval
[i
+4], quant_ptr
->quantval
[i
+5],
604 quant_ptr
->quantval
[i
+6], quant_ptr
->quantval
[i
+7]);
609 if (prec
) length
-= count
;
613 ERREXIT(cinfo
, JERR_BAD_LENGTH
);
621 get_dri (j_decompress_ptr cinfo
)
622 /* Process a DRI marker */
628 INPUT_2BYTES(cinfo
, length
, return FALSE
);
631 ERREXIT(cinfo
, JERR_BAD_LENGTH
);
633 INPUT_2BYTES(cinfo
, tmp
, return FALSE
);
635 TRACEMS1(cinfo
, 1, JTRC_DRI
, tmp
);
637 cinfo
->restart_interval
= tmp
;
645 get_lse (j_decompress_ptr cinfo
)
646 /* Process an LSE marker */
653 if (! cinfo
->marker
->saw_SOF
)
654 ERREXITS(cinfo
, JERR_SOF_BEFORE
, "LSE");
656 if (cinfo
->num_components
< 3) goto bad
;
658 INPUT_2BYTES(cinfo
, length
, return FALSE
);
661 ERREXIT(cinfo
, JERR_BAD_LENGTH
);
663 INPUT_BYTE(cinfo
, tmp
, return FALSE
);
664 if (tmp
!= 0x0D) /* ID inverse transform specification */
665 ERREXIT1(cinfo
, JERR_UNKNOWN_MARKER
, cinfo
->unread_marker
);
666 INPUT_2BYTES(cinfo
, tmp
, return FALSE
);
667 if (tmp
!= MAXJSAMPLE
) goto bad
; /* MAXTRANS */
668 INPUT_BYTE(cinfo
, tmp
, return FALSE
);
669 if (tmp
!= 3) goto bad
; /* Nt=3 */
670 INPUT_BYTE(cinfo
, cid
, return FALSE
);
671 if (cid
!= cinfo
->comp_info
[1].component_id
) goto bad
;
672 INPUT_BYTE(cinfo
, cid
, return FALSE
);
673 if (cid
!= cinfo
->comp_info
[0].component_id
) goto bad
;
674 INPUT_BYTE(cinfo
, cid
, return FALSE
);
675 if (cid
!= cinfo
->comp_info
[2].component_id
) goto bad
;
676 INPUT_BYTE(cinfo
, tmp
, return FALSE
);
677 if (tmp
!= 0x80) goto bad
; /* F1: CENTER1=1, NORM1=0 */
678 INPUT_2BYTES(cinfo
, tmp
, return FALSE
);
679 if (tmp
!= 0) goto bad
; /* A(1,1)=0 */
680 INPUT_2BYTES(cinfo
, tmp
, return FALSE
);
681 if (tmp
!= 0) goto bad
; /* A(1,2)=0 */
682 INPUT_BYTE(cinfo
, tmp
, return FALSE
);
683 if (tmp
!= 0) goto bad
; /* F2: CENTER2=0, NORM2=0 */
684 INPUT_2BYTES(cinfo
, tmp
, return FALSE
);
685 if (tmp
!= 1) goto bad
; /* A(2,1)=1 */
686 INPUT_2BYTES(cinfo
, tmp
, return FALSE
);
687 if (tmp
!= 0) goto bad
; /* A(2,2)=0 */
688 INPUT_BYTE(cinfo
, tmp
, return FALSE
);
689 if (tmp
!= 0) goto bad
; /* F3: CENTER3=0, NORM3=0 */
690 INPUT_2BYTES(cinfo
, tmp
, return FALSE
);
691 if (tmp
!= 1) goto bad
; /* A(3,1)=1 */
692 INPUT_2BYTES(cinfo
, tmp
, return FALSE
);
693 if (tmp
!= 0) { /* A(3,2)=0 */
695 ERREXIT(cinfo
, JERR_CONVERSION_NOTIMPL
);
698 /* OK, valid transform that we can handle. */
699 cinfo
->color_transform
= JCT_SUBTRACT_GREEN
;
707 * Routines for processing APPn and COM markers.
708 * These are either saved in memory or discarded, per application request.
709 * APP0 and APP14 are specially checked to see if they are
710 * JFIF and Adobe markers, respectively.
713 #define APP0_DATA_LEN 14 /* Length of interesting data in APP0 */
714 #define APP14_DATA_LEN 12 /* Length of interesting data in APP14 */
715 #define APPN_DATA_LEN 14 /* Must be the largest of the above!! */
719 examine_app0 (j_decompress_ptr cinfo
, JOCTET FAR
* data
,
720 unsigned int datalen
, INT32 remaining
)
721 /* Examine first few bytes from an APP0.
722 * Take appropriate action if it is a JFIF marker.
723 * datalen is # of bytes at data[], remaining is length of rest of marker data.
726 INT32 totallen
= (INT32
) datalen
+ remaining
;
728 if (datalen
>= APP0_DATA_LEN
&&
729 GETJOCTET(data
[0]) == 0x4A &&
730 GETJOCTET(data
[1]) == 0x46 &&
731 GETJOCTET(data
[2]) == 0x49 &&
732 GETJOCTET(data
[3]) == 0x46 &&
733 GETJOCTET(data
[4]) == 0) {
734 /* Found JFIF APP0 marker: save info */
735 cinfo
->saw_JFIF_marker
= TRUE
;
736 cinfo
->JFIF_major_version
= GETJOCTET(data
[5]);
737 cinfo
->JFIF_minor_version
= GETJOCTET(data
[6]);
738 cinfo
->density_unit
= GETJOCTET(data
[7]);
739 cinfo
->X_density
= (GETJOCTET(data
[8]) << 8) + GETJOCTET(data
[9]);
740 cinfo
->Y_density
= (GETJOCTET(data
[10]) << 8) + GETJOCTET(data
[11]);
742 * Major version must be 1 or 2, anything else signals an incompatible
744 * (We used to treat this as an error, but now it's a nonfatal warning,
745 * because some bozo at Hijaak couldn't read the spec.)
746 * Minor version should be 0..2, but process anyway if newer.
748 if (cinfo
->JFIF_major_version
!= 1 && cinfo
->JFIF_major_version
!= 2)
749 WARNMS2(cinfo
, JWRN_JFIF_MAJOR
,
750 cinfo
->JFIF_major_version
, cinfo
->JFIF_minor_version
);
751 /* Generate trace messages */
752 TRACEMS5(cinfo
, 1, JTRC_JFIF
,
753 cinfo
->JFIF_major_version
, cinfo
->JFIF_minor_version
,
754 cinfo
->X_density
, cinfo
->Y_density
, cinfo
->density_unit
);
755 /* Validate thumbnail dimensions and issue appropriate messages */
756 if (GETJOCTET(data
[12]) | GETJOCTET(data
[13]))
757 TRACEMS2(cinfo
, 1, JTRC_JFIF_THUMBNAIL
,
758 GETJOCTET(data
[12]), GETJOCTET(data
[13]));
759 totallen
-= APP0_DATA_LEN
;
761 ((INT32
)GETJOCTET(data
[12]) * (INT32
)GETJOCTET(data
[13]) * (INT32
) 3))
762 TRACEMS1(cinfo
, 1, JTRC_JFIF_BADTHUMBNAILSIZE
, (int) totallen
);
763 } else if (datalen
>= 6 &&
764 GETJOCTET(data
[0]) == 0x4A &&
765 GETJOCTET(data
[1]) == 0x46 &&
766 GETJOCTET(data
[2]) == 0x58 &&
767 GETJOCTET(data
[3]) == 0x58 &&
768 GETJOCTET(data
[4]) == 0) {
769 /* Found JFIF "JFXX" extension APP0 marker */
770 /* The library doesn't actually do anything with these,
771 * but we try to produce a helpful trace message.
773 switch (GETJOCTET(data
[5])) {
775 TRACEMS1(cinfo
, 1, JTRC_THUMB_JPEG
, (int) totallen
);
778 TRACEMS1(cinfo
, 1, JTRC_THUMB_PALETTE
, (int) totallen
);
781 TRACEMS1(cinfo
, 1, JTRC_THUMB_RGB
, (int) totallen
);
784 TRACEMS2(cinfo
, 1, JTRC_JFIF_EXTENSION
,
785 GETJOCTET(data
[5]), (int) totallen
);
788 /* Start of APP0 does not match "JFIF" or "JFXX", or too short */
789 TRACEMS1(cinfo
, 1, JTRC_APP0
, (int) totallen
);
795 examine_app14 (j_decompress_ptr cinfo
, JOCTET FAR
* data
,
796 unsigned int datalen
, INT32 remaining
)
797 /* Examine first few bytes from an APP14.
798 * Take appropriate action if it is an Adobe marker.
799 * datalen is # of bytes at data[], remaining is length of rest of marker data.
802 unsigned int version
, flags0
, flags1
, transform
;
804 if (datalen
>= APP14_DATA_LEN
&&
805 GETJOCTET(data
[0]) == 0x41 &&
806 GETJOCTET(data
[1]) == 0x64 &&
807 GETJOCTET(data
[2]) == 0x6F &&
808 GETJOCTET(data
[3]) == 0x62 &&
809 GETJOCTET(data
[4]) == 0x65) {
810 /* Found Adobe APP14 marker */
811 version
= (GETJOCTET(data
[5]) << 8) + GETJOCTET(data
[6]);
812 flags0
= (GETJOCTET(data
[7]) << 8) + GETJOCTET(data
[8]);
813 flags1
= (GETJOCTET(data
[9]) << 8) + GETJOCTET(data
[10]);
814 transform
= GETJOCTET(data
[11]);
815 TRACEMS4(cinfo
, 1, JTRC_ADOBE
, version
, flags0
, flags1
, transform
);
816 cinfo
->saw_Adobe_marker
= TRUE
;
817 cinfo
->Adobe_transform
= (UINT8
) transform
;
819 /* Start of APP14 does not match "Adobe", or too short */
820 TRACEMS1(cinfo
, 1, JTRC_APP14
, (int) (datalen
+ remaining
));
826 get_interesting_appn (j_decompress_ptr cinfo
)
827 /* Process an APP0 or APP14 marker without saving it */
830 JOCTET b
[APPN_DATA_LEN
];
831 unsigned int i
, numtoread
;
834 INPUT_2BYTES(cinfo
, length
, return FALSE
);
837 /* get the interesting part of the marker data */
838 if (length
>= APPN_DATA_LEN
)
839 numtoread
= APPN_DATA_LEN
;
841 numtoread
= (unsigned int) length
;
844 for (i
= 0; i
< numtoread
; i
++)
845 INPUT_BYTE(cinfo
, b
[i
], return FALSE
);
849 switch (cinfo
->unread_marker
) {
851 examine_app0(cinfo
, (JOCTET FAR
*) b
, numtoread
, length
);
854 examine_app14(cinfo
, (JOCTET FAR
*) b
, numtoread
, length
);
857 /* can't get here unless jpeg_save_markers chooses wrong processor */
858 ERREXIT1(cinfo
, JERR_UNKNOWN_MARKER
, cinfo
->unread_marker
);
861 /* skip any remaining data -- could be lots */
864 (*cinfo
->src
->skip_input_data
) (cinfo
, (long) length
);
870 #ifdef SAVE_MARKERS_SUPPORTED
873 save_marker (j_decompress_ptr cinfo
)
874 /* Save an APPn or COM marker into the marker list */
876 my_marker_ptr marker
= (my_marker_ptr
) cinfo
->marker
;
877 jpeg_saved_marker_ptr cur_marker
= marker
->cur_marker
;
878 unsigned int bytes_read
, data_length
;
883 if (cur_marker
== NULL
) {
884 /* begin reading a marker */
885 INPUT_2BYTES(cinfo
, length
, return FALSE
);
887 if (length
>= 0) { /* watch out for bogus length word */
888 /* figure out how much we want to save */
890 if (cinfo
->unread_marker
== (int) M_COM
)
891 limit
= marker
->length_limit_COM
;
893 limit
= marker
->length_limit_APPn
[cinfo
->unread_marker
- (int) M_APP0
];
894 if ((unsigned int) length
< limit
)
895 limit
= (unsigned int) length
;
896 /* allocate and initialize the marker item */
897 cur_marker
= (jpeg_saved_marker_ptr
)
898 (*cinfo
->mem
->alloc_large
) ((j_common_ptr
) cinfo
, JPOOL_IMAGE
,
899 SIZEOF(struct jpeg_marker_struct
) + limit
);
900 cur_marker
->next
= NULL
;
901 cur_marker
->marker
= (UINT8
) cinfo
->unread_marker
;
902 cur_marker
->original_length
= (unsigned int) length
;
903 cur_marker
->data_length
= limit
;
904 /* data area is just beyond the jpeg_marker_struct */
905 data
= cur_marker
->data
= (JOCTET FAR
*) (cur_marker
+ 1);
906 marker
->cur_marker
= cur_marker
;
907 marker
->bytes_read
= 0;
911 /* deal with bogus length word */
912 bytes_read
= data_length
= 0;
916 /* resume reading a marker */
917 bytes_read
= marker
->bytes_read
;
918 data_length
= cur_marker
->data_length
;
919 data
= cur_marker
->data
+ bytes_read
;
922 while (bytes_read
< data_length
) {
923 INPUT_SYNC(cinfo
); /* move the restart point to here */
924 marker
->bytes_read
= bytes_read
;
925 /* If there's not at least one byte in buffer, suspend */
926 MAKE_BYTE_AVAIL(cinfo
, return FALSE
);
927 /* Copy bytes with reasonable rapidity */
928 while (bytes_read
< data_length
&& bytes_in_buffer
> 0) {
929 *data
++ = *next_input_byte
++;
935 /* Done reading what we want to read */
936 if (cur_marker
!= NULL
) { /* will be NULL if bogus length word */
937 /* Add new marker to end of list */
938 if (cinfo
->marker_list
== NULL
) {
939 cinfo
->marker_list
= cur_marker
;
941 jpeg_saved_marker_ptr prev
= cinfo
->marker_list
;
942 while (prev
->next
!= NULL
)
944 prev
->next
= cur_marker
;
946 /* Reset pointer & calc remaining data length */
947 data
= cur_marker
->data
;
948 length
= cur_marker
->original_length
- data_length
;
950 /* Reset to initial state for next marker */
951 marker
->cur_marker
= NULL
;
953 /* Process the marker if interesting; else just make a generic trace msg */
954 switch (cinfo
->unread_marker
) {
956 examine_app0(cinfo
, data
, data_length
, length
);
959 examine_app14(cinfo
, data
, data_length
, length
);
962 TRACEMS2(cinfo
, 1, JTRC_MISC_MARKER
, cinfo
->unread_marker
,
963 (int) (data_length
+ length
));
966 /* skip any remaining data -- could be lots */
967 INPUT_SYNC(cinfo
); /* do before skip_input_data */
969 (*cinfo
->src
->skip_input_data
) (cinfo
, (long) length
);
974 #endif /* SAVE_MARKERS_SUPPORTED */
978 skip_variable (j_decompress_ptr cinfo
)
979 /* Skip over an unknown or uninteresting variable-length marker */
984 INPUT_2BYTES(cinfo
, length
, return FALSE
);
987 TRACEMS2(cinfo
, 1, JTRC_MISC_MARKER
, cinfo
->unread_marker
, (int) length
);
989 INPUT_SYNC(cinfo
); /* do before skip_input_data */
991 (*cinfo
->src
->skip_input_data
) (cinfo
, (long) length
);
998 * Find the next JPEG marker, save it in cinfo->unread_marker.
999 * Returns FALSE if had to suspend before reaching a marker;
1000 * in that case cinfo->unread_marker is unchanged.
1002 * Note that the result might not be a valid marker code,
1003 * but it will never be 0 or FF.
1007 next_marker (j_decompress_ptr cinfo
)
1013 INPUT_BYTE(cinfo
, c
, return FALSE
);
1014 /* Skip any non-FF bytes.
1015 * This may look a bit inefficient, but it will not occur in a valid file.
1016 * We sync after each discarded byte so that a suspending data source
1017 * can discard the byte from its buffer.
1020 cinfo
->marker
->discarded_bytes
++;
1022 INPUT_BYTE(cinfo
, c
, return FALSE
);
1024 /* This loop swallows any duplicate FF bytes. Extra FFs are legal as
1025 * pad bytes, so don't count them in discarded_bytes. We assume there
1026 * will not be so many consecutive FF bytes as to overflow a suspending
1027 * data source's input buffer.
1030 INPUT_BYTE(cinfo
, c
, return FALSE
);
1031 } while (c
== 0xFF);
1033 break; /* found a valid marker, exit loop */
1034 /* Reach here if we found a stuffed-zero data sequence (FF/00).
1035 * Discard it and loop back to try again.
1037 cinfo
->marker
->discarded_bytes
+= 2;
1041 if (cinfo
->marker
->discarded_bytes
!= 0) {
1042 WARNMS2(cinfo
, JWRN_EXTRANEOUS_DATA
, cinfo
->marker
->discarded_bytes
, c
);
1043 cinfo
->marker
->discarded_bytes
= 0;
1046 cinfo
->unread_marker
= c
;
1054 first_marker (j_decompress_ptr cinfo
)
1055 /* Like next_marker, but used to obtain the initial SOI marker. */
1056 /* For this marker, we do not allow preceding garbage or fill; otherwise,
1057 * we might well scan an entire input file before realizing it ain't JPEG.
1058 * If an application wants to process non-JFIF files, it must seek to the
1059 * SOI before calling the JPEG library.
1065 INPUT_BYTE(cinfo
, c
, return FALSE
);
1066 INPUT_BYTE(cinfo
, c2
, return FALSE
);
1067 if (c
!= 0xFF || c2
!= (int) M_SOI
)
1068 ERREXIT2(cinfo
, JERR_NO_SOI
, c
, c2
);
1070 cinfo
->unread_marker
= c2
;
1078 * Read markers until SOS or EOI.
1080 * Returns same codes as are defined for jpeg_consume_input:
1081 * JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI.
1083 * Note: This function may return a pseudo SOS marker (with zero
1084 * component number) for treat by input controller's consume_input.
1085 * consume_input itself should filter out (skip) the pseudo marker
1086 * after processing for the caller.
1090 read_markers (j_decompress_ptr cinfo
)
1092 /* Outer loop repeats once for each marker. */
1094 /* Collect the marker proper, unless we already did. */
1095 /* NB: first_marker() enforces the requirement that SOI appear first. */
1096 if (cinfo
->unread_marker
== 0) {
1097 if (! cinfo
->marker
->saw_SOI
) {
1098 if (! first_marker(cinfo
))
1099 return JPEG_SUSPENDED
;
1101 if (! next_marker(cinfo
))
1102 return JPEG_SUSPENDED
;
1105 /* At this point cinfo->unread_marker contains the marker code and the
1106 * input point is just past the marker proper, but before any parameters.
1107 * A suspension will cause us to return with this state still true.
1109 switch (cinfo
->unread_marker
) {
1111 if (! get_soi(cinfo
))
1112 return JPEG_SUSPENDED
;
1115 case M_SOF0
: /* Baseline */
1116 if (! get_sof(cinfo
, TRUE
, FALSE
, FALSE
))
1117 return JPEG_SUSPENDED
;
1120 case M_SOF1
: /* Extended sequential, Huffman */
1121 if (! get_sof(cinfo
, FALSE
, FALSE
, FALSE
))
1122 return JPEG_SUSPENDED
;
1125 case M_SOF2
: /* Progressive, Huffman */
1126 if (! get_sof(cinfo
, FALSE
, TRUE
, FALSE
))
1127 return JPEG_SUSPENDED
;
1130 case M_SOF9
: /* Extended sequential, arithmetic */
1131 if (! get_sof(cinfo
, FALSE
, FALSE
, TRUE
))
1132 return JPEG_SUSPENDED
;
1135 case M_SOF10
: /* Progressive, arithmetic */
1136 if (! get_sof(cinfo
, FALSE
, TRUE
, TRUE
))
1137 return JPEG_SUSPENDED
;
1140 /* Currently unsupported SOFn types */
1141 case M_SOF3
: /* Lossless, Huffman */
1142 case M_SOF5
: /* Differential sequential, Huffman */
1143 case M_SOF6
: /* Differential progressive, Huffman */
1144 case M_SOF7
: /* Differential lossless, Huffman */
1145 case M_JPG
: /* Reserved for JPEG extensions */
1146 case M_SOF11
: /* Lossless, arithmetic */
1147 case M_SOF13
: /* Differential sequential, arithmetic */
1148 case M_SOF14
: /* Differential progressive, arithmetic */
1149 case M_SOF15
: /* Differential lossless, arithmetic */
1150 ERREXIT1(cinfo
, JERR_SOF_UNSUPPORTED
, cinfo
->unread_marker
);
1154 if (! get_sos(cinfo
))
1155 return JPEG_SUSPENDED
;
1156 cinfo
->unread_marker
= 0; /* processed the marker */
1157 return JPEG_REACHED_SOS
;
1160 TRACEMS(cinfo
, 1, JTRC_EOI
);
1161 cinfo
->unread_marker
= 0; /* processed the marker */
1162 return JPEG_REACHED_EOI
;
1165 if (! get_dac(cinfo
))
1166 return JPEG_SUSPENDED
;
1170 if (! get_dht(cinfo
))
1171 return JPEG_SUSPENDED
;
1175 if (! get_dqt(cinfo
))
1176 return JPEG_SUSPENDED
;
1180 if (! get_dri(cinfo
))
1181 return JPEG_SUSPENDED
;
1185 if (! get_lse(cinfo
))
1186 return JPEG_SUSPENDED
;
1205 if (! (*((my_marker_ptr
) cinfo
->marker
)->process_APPn
[
1206 cinfo
->unread_marker
- (int) M_APP0
]) (cinfo
))
1207 return JPEG_SUSPENDED
;
1211 if (! (*((my_marker_ptr
) cinfo
->marker
)->process_COM
) (cinfo
))
1212 return JPEG_SUSPENDED
;
1215 case M_RST0
: /* these are all parameterless */
1224 TRACEMS1(cinfo
, 1, JTRC_PARMLESS_MARKER
, cinfo
->unread_marker
);
1227 case M_DNL
: /* Ignore DNL ... perhaps the wrong thing */
1228 if (! skip_variable(cinfo
))
1229 return JPEG_SUSPENDED
;
1232 default: /* must be DHP, EXP, JPGn, or RESn */
1233 /* For now, we treat the reserved markers as fatal errors since they are
1234 * likely to be used to signal incompatible JPEG Part 3 extensions.
1235 * Once the JPEG 3 version-number marker is well defined, this code
1238 ERREXIT1(cinfo
, JERR_UNKNOWN_MARKER
, cinfo
->unread_marker
);
1240 /* Successfully processed marker, so reset state variable */
1241 cinfo
->unread_marker
= 0;
1247 * Read a restart marker, which is expected to appear next in the datastream;
1248 * if the marker is not there, take appropriate recovery action.
1249 * Returns FALSE if suspension is required.
1251 * This is called by the entropy decoder after it has read an appropriate
1252 * number of MCUs. cinfo->unread_marker may be nonzero if the entropy decoder
1253 * has already read a marker from the data source. Under normal conditions
1254 * cinfo->unread_marker will be reset to 0 before returning; if not reset,
1255 * it holds a marker which the decoder will be unable to read past.
1259 read_restart_marker (j_decompress_ptr cinfo
)
1261 /* Obtain a marker unless we already did. */
1262 /* Note that next_marker will complain if it skips any data. */
1263 if (cinfo
->unread_marker
== 0) {
1264 if (! next_marker(cinfo
))
1268 if (cinfo
->unread_marker
==
1269 ((int) M_RST0
+ cinfo
->marker
->next_restart_num
)) {
1270 /* Normal case --- swallow the marker and let entropy decoder continue */
1271 TRACEMS1(cinfo
, 3, JTRC_RST
, cinfo
->marker
->next_restart_num
);
1272 cinfo
->unread_marker
= 0;
1274 /* Uh-oh, the restart markers have been messed up. */
1275 /* Let the data source manager determine how to resync. */
1276 if (! (*cinfo
->src
->resync_to_restart
) (cinfo
,
1277 cinfo
->marker
->next_restart_num
))
1281 /* Update next-restart state */
1282 cinfo
->marker
->next_restart_num
= (cinfo
->marker
->next_restart_num
+ 1) & 7;
1289 * This is the default resync_to_restart method for data source managers
1290 * to use if they don't have any better approach. Some data source managers
1291 * may be able to back up, or may have additional knowledge about the data
1292 * which permits a more intelligent recovery strategy; such managers would
1293 * presumably supply their own resync method.
1295 * read_restart_marker calls resync_to_restart if it finds a marker other than
1296 * the restart marker it was expecting. (This code is *not* used unless
1297 * a nonzero restart interval has been declared.) cinfo->unread_marker is
1298 * the marker code actually found (might be anything, except 0 or FF).
1299 * The desired restart marker number (0..7) is passed as a parameter.
1300 * This routine is supposed to apply whatever error recovery strategy seems
1301 * appropriate in order to position the input stream to the next data segment.
1302 * Note that cinfo->unread_marker is treated as a marker appearing before
1303 * the current data-source input point; usually it should be reset to zero
1305 * Returns FALSE if suspension is required.
1307 * This implementation is substantially constrained by wanting to treat the
1308 * input as a data stream; this means we can't back up. Therefore, we have
1309 * only the following actions to work with:
1310 * 1. Simply discard the marker and let the entropy decoder resume at next
1312 * 2. Read forward until we find another marker, discarding intervening
1313 * data. (In theory we could look ahead within the current bufferload,
1314 * without having to discard data if we don't find the desired marker.
1315 * This idea is not implemented here, in part because it makes behavior
1316 * dependent on buffer size and chance buffer-boundary positions.)
1317 * 3. Leave the marker unread (by failing to zero cinfo->unread_marker).
1318 * This will cause the entropy decoder to process an empty data segment,
1319 * inserting dummy zeroes, and then we will reprocess the marker.
1321 * #2 is appropriate if we think the desired marker lies ahead, while #3 is
1322 * appropriate if the found marker is a future restart marker (indicating
1323 * that we have missed the desired restart marker, probably because it got
1325 * We apply #2 or #3 if the found marker is a restart marker no more than
1326 * two counts behind or ahead of the expected one. We also apply #2 if the
1327 * found marker is not a legal JPEG marker code (it's certainly bogus data).
1328 * If the found marker is a restart marker more than 2 counts away, we do #1
1329 * (too much risk that the marker is erroneous; with luck we will be able to
1330 * resync at some future point).
1331 * For any valid non-restart JPEG marker, we apply #3. This keeps us from
1332 * overrunning the end of a scan. An implementation limited to single-scan
1333 * files might find it better to apply #2 for markers other than EOI, since
1334 * any other marker would have to be bogus data in that case.
1338 jpeg_resync_to_restart (j_decompress_ptr cinfo
, int desired
)
1340 int marker
= cinfo
->unread_marker
;
1343 /* Always put up a warning. */
1344 WARNMS2(cinfo
, JWRN_MUST_RESYNC
, marker
, desired
);
1346 /* Outer loop handles repeated decision after scanning forward. */
1348 if (marker
< (int) M_SOF0
)
1349 action
= 2; /* invalid marker */
1350 else if (marker
< (int) M_RST0
|| marker
> (int) M_RST7
)
1351 action
= 3; /* valid non-restart marker */
1353 if (marker
== ((int) M_RST0
+ ((desired
+1) & 7)) ||
1354 marker
== ((int) M_RST0
+ ((desired
+2) & 7)))
1355 action
= 3; /* one of the next two expected restarts */
1356 else if (marker
== ((int) M_RST0
+ ((desired
-1) & 7)) ||
1357 marker
== ((int) M_RST0
+ ((desired
-2) & 7)))
1358 action
= 2; /* a prior restart, so advance */
1360 action
= 1; /* desired restart or too far away */
1362 TRACEMS2(cinfo
, 4, JTRC_RECOVERY_ACTION
, marker
, action
);
1365 /* Discard marker and let entropy decoder resume processing. */
1366 cinfo
->unread_marker
= 0;
1369 /* Scan to the next marker, and repeat the decision loop. */
1370 if (! next_marker(cinfo
))
1372 marker
= cinfo
->unread_marker
;
1375 /* Return without advancing past this marker. */
1376 /* Entropy decoder will be forced to process an empty segment. */
1384 * Reset marker processing state to begin a fresh datastream.
1388 reset_marker_reader (j_decompress_ptr cinfo
)
1390 my_marker_ptr marker
= (my_marker_ptr
) cinfo
->marker
;
1392 cinfo
->comp_info
= NULL
; /* until allocated by get_sof */
1393 cinfo
->input_scan_number
= 0; /* no SOS seen yet */
1394 cinfo
->unread_marker
= 0; /* no pending marker */
1395 marker
->pub
.saw_SOI
= FALSE
; /* set internal state too */
1396 marker
->pub
.saw_SOF
= FALSE
;
1397 marker
->pub
.discarded_bytes
= 0;
1398 marker
->cur_marker
= NULL
;
1403 * Initialize the marker reader module.
1404 * This is called only once, when the decompression object is created.
1408 jinit_marker_reader (j_decompress_ptr cinfo
)
1410 my_marker_ptr marker
;
1413 /* Create subobject in permanent pool */
1414 marker
= (my_marker_ptr
) (*cinfo
->mem
->alloc_small
)
1415 ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
, SIZEOF(my_marker_reader
));
1416 cinfo
->marker
= &marker
->pub
;
1417 /* Initialize public method pointers */
1418 marker
->pub
.reset_marker_reader
= reset_marker_reader
;
1419 marker
->pub
.read_markers
= read_markers
;
1420 marker
->pub
.read_restart_marker
= read_restart_marker
;
1421 /* Initialize COM/APPn processing.
1422 * By default, we examine and then discard APP0 and APP14,
1423 * but simply discard COM and all other APPn.
1425 marker
->process_COM
= skip_variable
;
1426 marker
->length_limit_COM
= 0;
1427 for (i
= 0; i
< 16; i
++) {
1428 marker
->process_APPn
[i
] = skip_variable
;
1429 marker
->length_limit_APPn
[i
] = 0;
1431 marker
->process_APPn
[0] = get_interesting_appn
;
1432 marker
->process_APPn
[14] = get_interesting_appn
;
1433 /* Reset marker processing state */
1434 reset_marker_reader(cinfo
);
1439 * Control saving of COM and APPn markers into marker_list.
1442 #ifdef SAVE_MARKERS_SUPPORTED
1445 jpeg_save_markers (j_decompress_ptr cinfo
, int marker_code
,
1446 unsigned int length_limit
)
1448 my_marker_ptr marker
= (my_marker_ptr
) cinfo
->marker
;
1450 jpeg_marker_parser_method processor
;
1452 /* Length limit mustn't be larger than what we can allocate
1453 * (should only be a concern in a 16-bit environment).
1455 maxlength
= cinfo
->mem
->max_alloc_chunk
- SIZEOF(struct jpeg_marker_struct
);
1456 if (((long) length_limit
) > maxlength
)
1457 length_limit
= (unsigned int) maxlength
;
1459 /* Choose processor routine to use.
1460 * APP0/APP14 have special requirements.
1463 processor
= save_marker
;
1464 /* If saving APP0/APP14, save at least enough for our internal use. */
1465 if (marker_code
== (int) M_APP0
&& length_limit
< APP0_DATA_LEN
)
1466 length_limit
= APP0_DATA_LEN
;
1467 else if (marker_code
== (int) M_APP14
&& length_limit
< APP14_DATA_LEN
)
1468 length_limit
= APP14_DATA_LEN
;
1470 processor
= skip_variable
;
1471 /* If discarding APP0/APP14, use our regular on-the-fly processor. */
1472 if (marker_code
== (int) M_APP0
|| marker_code
== (int) M_APP14
)
1473 processor
= get_interesting_appn
;
1476 if (marker_code
== (int) M_COM
) {
1477 marker
->process_COM
= processor
;
1478 marker
->length_limit_COM
= length_limit
;
1479 } else if (marker_code
>= (int) M_APP0
&& marker_code
<= (int) M_APP15
) {
1480 marker
->process_APPn
[marker_code
- (int) M_APP0
] = processor
;
1481 marker
->length_limit_APPn
[marker_code
- (int) M_APP0
] = length_limit
;
1483 ERREXIT1(cinfo
, JERR_UNKNOWN_MARKER
, marker_code
);
1486 #endif /* SAVE_MARKERS_SUPPORTED */
1490 * Install a special processing method for COM or APPn markers.
1494 jpeg_set_marker_processor (j_decompress_ptr cinfo
, int marker_code
,
1495 jpeg_marker_parser_method routine
)
1497 my_marker_ptr marker
= (my_marker_ptr
) cinfo
->marker
;
1499 if (marker_code
== (int) M_COM
)
1500 marker
->process_COM
= routine
;
1501 else if (marker_code
>= (int) M_APP0
&& marker_code
<= (int) M_APP15
)
1502 marker
->process_APPn
[marker_code
- (int) M_APP0
] = routine
;
1504 ERREXIT1(cinfo
, JERR_UNKNOWN_MARKER
, marker_code
);