Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
6417 | ashmew2 | 1 | /* |
2 | * jcmarker.c |
||
3 | * |
||
4 | * Copyright (C) 1991-1998, Thomas G. Lane. |
||
5 | * This file is part of the Independent JPEG Group's software. |
||
6 | * For conditions of distribution and use, see the accompanying README file. |
||
7 | * |
||
8 | * This file contains routines to write JPEG datastream markers. |
||
9 | */ |
||
10 | |||
11 | #define JPEG_INTERNALS |
||
12 | #include "jinclude.h" |
||
13 | #include "jpeglib.h" |
||
14 | |||
15 | |||
16 | typedef enum { /* JPEG marker codes */ |
||
17 | M_SOF0 = 0xc0, |
||
18 | M_SOF1 = 0xc1, |
||
19 | M_SOF2 = 0xc2, |
||
20 | M_SOF3 = 0xc3, |
||
21 | |||
22 | M_SOF5 = 0xc5, |
||
23 | M_SOF6 = 0xc6, |
||
24 | M_SOF7 = 0xc7, |
||
25 | |||
26 | M_JPG = 0xc8, |
||
27 | M_SOF9 = 0xc9, |
||
28 | M_SOF10 = 0xca, |
||
29 | M_SOF11 = 0xcb, |
||
30 | |||
31 | M_SOF13 = 0xcd, |
||
32 | M_SOF14 = 0xce, |
||
33 | M_SOF15 = 0xcf, |
||
34 | |||
35 | M_DHT = 0xc4, |
||
36 | |||
37 | M_DAC = 0xcc, |
||
38 | |||
39 | M_RST0 = 0xd0, |
||
40 | M_RST1 = 0xd1, |
||
41 | M_RST2 = 0xd2, |
||
42 | M_RST3 = 0xd3, |
||
43 | M_RST4 = 0xd4, |
||
44 | M_RST5 = 0xd5, |
||
45 | M_RST6 = 0xd6, |
||
46 | M_RST7 = 0xd7, |
||
47 | |||
48 | M_SOI = 0xd8, |
||
49 | M_EOI = 0xd9, |
||
50 | M_SOS = 0xda, |
||
51 | M_DQT = 0xdb, |
||
52 | M_DNL = 0xdc, |
||
53 | M_DRI = 0xdd, |
||
54 | M_DHP = 0xde, |
||
55 | M_EXP = 0xdf, |
||
56 | |||
57 | M_APP0 = 0xe0, |
||
58 | M_APP1 = 0xe1, |
||
59 | M_APP2 = 0xe2, |
||
60 | M_APP3 = 0xe3, |
||
61 | M_APP4 = 0xe4, |
||
62 | M_APP5 = 0xe5, |
||
63 | M_APP6 = 0xe6, |
||
64 | M_APP7 = 0xe7, |
||
65 | M_APP8 = 0xe8, |
||
66 | M_APP9 = 0xe9, |
||
67 | M_APP10 = 0xea, |
||
68 | M_APP11 = 0xeb, |
||
69 | M_APP12 = 0xec, |
||
70 | M_APP13 = 0xed, |
||
71 | M_APP14 = 0xee, |
||
72 | M_APP15 = 0xef, |
||
73 | |||
74 | M_JPG0 = 0xf0, |
||
75 | M_JPG13 = 0xfd, |
||
76 | M_COM = 0xfe, |
||
77 | |||
78 | M_TEM = 0x01, |
||
79 | |||
80 | M_ERROR = 0x100 |
||
81 | } JPEG_MARKER; |
||
82 | |||
83 | |||
84 | /* Private state */ |
||
85 | |||
86 | typedef struct { |
||
87 | struct jpeg_marker_writer pub; /* public fields */ |
||
88 | |||
89 | unsigned int last_restart_interval; /* last DRI value emitted; 0 after SOI */ |
||
90 | } my_marker_writer; |
||
91 | |||
92 | typedef my_marker_writer * my_marker_ptr; |
||
93 | |||
94 | |||
95 | /* |
||
96 | * Basic output routines. |
||
97 | * |
||
98 | * Note that we do not support suspension while writing a marker. |
||
99 | * Therefore, an application using suspension must ensure that there is |
||
100 | * enough buffer space for the initial markers (typ. 600-700 bytes) before |
||
101 | * calling jpeg_start_compress, and enough space to write the trailing EOI |
||
102 | * (a few bytes) before calling jpeg_finish_compress. Multipass compression |
||
103 | * modes are not supported at all with suspension, so those two are the only |
||
104 | * points where markers will be written. |
||
105 | */ |
||
106 | |||
107 | LOCAL(void) |
||
108 | emit_byte (j_compress_ptr cinfo, int val) |
||
109 | /* Emit a byte */ |
||
110 | { |
||
111 | struct jpeg_destination_mgr * dest = cinfo->dest; |
||
112 | |||
113 | *(dest->next_output_byte)++ = (JOCTET) val; |
||
114 | if (--dest->free_in_buffer == 0) { |
||
115 | if (! (*dest->empty_output_buffer) (cinfo)) |
||
116 | ERREXIT(cinfo, JERR_CANT_SUSPEND); |
||
117 | } |
||
118 | } |
||
119 | |||
120 | |||
121 | LOCAL(void) |
||
122 | emit_marker (j_compress_ptr cinfo, JPEG_MARKER mark) |
||
123 | /* Emit a marker code */ |
||
124 | { |
||
125 | emit_byte(cinfo, 0xFF); |
||
126 | emit_byte(cinfo, (int) mark); |
||
127 | } |
||
128 | |||
129 | |||
130 | LOCAL(void) |
||
131 | emit_2bytes (j_compress_ptr cinfo, int value) |
||
132 | /* Emit a 2-byte integer; these are always MSB first in JPEG files */ |
||
133 | { |
||
134 | emit_byte(cinfo, (value >> 8) & 0xFF); |
||
135 | emit_byte(cinfo, value & 0xFF); |
||
136 | } |
||
137 | |||
138 | |||
139 | /* |
||
140 | * Routines to write specific marker types. |
||
141 | */ |
||
142 | |||
143 | LOCAL(int) |
||
144 | emit_dqt (j_compress_ptr cinfo, int index) |
||
145 | /* Emit a DQT marker */ |
||
146 | /* Returns the precision used (0 = 8bits, 1 = 16bits) for baseline checking */ |
||
147 | { |
||
148 | JQUANT_TBL * qtbl = cinfo->quant_tbl_ptrs[index]; |
||
149 | int prec; |
||
150 | int i; |
||
151 | |||
152 | if (qtbl == NULL) |
||
153 | ERREXIT1(cinfo, JERR_NO_QUANT_TABLE, index); |
||
154 | |||
155 | prec = 0; |
||
156 | for (i = 0; i < DCTSIZE2; i++) { |
||
157 | if (qtbl->quantval[i] > 255) |
||
158 | prec = 1; |
||
159 | } |
||
160 | |||
161 | if (! qtbl->sent_table) { |
||
162 | emit_marker(cinfo, M_DQT); |
||
163 | |||
164 | emit_2bytes(cinfo, prec ? DCTSIZE2*2 + 1 + 2 : DCTSIZE2 + 1 + 2); |
||
165 | |||
166 | emit_byte(cinfo, index + (prec<<4)); |
||
167 | |||
168 | for (i = 0; i < DCTSIZE2; i++) { |
||
169 | /* The table entries must be emitted in zigzag order. */ |
||
170 | unsigned int qval = qtbl->quantval[jpeg_natural_order[i]]; |
||
171 | if (prec) |
||
172 | emit_byte(cinfo, (int) (qval >> 8)); |
||
173 | emit_byte(cinfo, (int) (qval & 0xFF)); |
||
174 | } |
||
175 | |||
176 | qtbl->sent_table = TRUE; |
||
177 | } |
||
178 | |||
179 | return prec; |
||
180 | } |
||
181 | |||
182 | |||
183 | LOCAL(void) |
||
184 | emit_dht (j_compress_ptr cinfo, int index, boolean is_ac) |
||
185 | /* Emit a DHT marker */ |
||
186 | { |
||
187 | JHUFF_TBL * htbl; |
||
188 | int length, i; |
||
189 | |||
190 | if (is_ac) { |
||
191 | htbl = cinfo->ac_huff_tbl_ptrs[index]; |
||
192 | index += 0x10; /* output index has AC bit set */ |
||
193 | } else { |
||
194 | htbl = cinfo->dc_huff_tbl_ptrs[index]; |
||
195 | } |
||
196 | |||
197 | if (htbl == NULL) |
||
198 | ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, index); |
||
199 | |||
200 | if (! htbl->sent_table) { |
||
201 | emit_marker(cinfo, M_DHT); |
||
202 | |||
203 | length = 0; |
||
204 | for (i = 1; i <= 16; i++) |
||
205 | length += htbl->bits[i]; |
||
206 | |||
207 | emit_2bytes(cinfo, length + 2 + 1 + 16); |
||
208 | emit_byte(cinfo, index); |
||
209 | |||
210 | for (i = 1; i <= 16; i++) |
||
211 | emit_byte(cinfo, htbl->bits[i]); |
||
212 | |||
213 | for (i = 0; i < length; i++) |
||
214 | emit_byte(cinfo, htbl->huffval[i]); |
||
215 | |||
216 | htbl->sent_table = TRUE; |
||
217 | } |
||
218 | } |
||
219 | |||
220 | |||
221 | LOCAL(void) |
||
222 | emit_dac (j_compress_ptr cinfo) |
||
223 | /* Emit a DAC marker */ |
||
224 | /* Since the useful info is so small, we want to emit all the tables in */ |
||
225 | /* one DAC marker. Therefore this routine does its own scan of the table. */ |
||
226 | { |
||
227 | #ifdef C_ARITH_CODING_SUPPORTED |
||
228 | char dc_in_use[NUM_ARITH_TBLS]; |
||
229 | char ac_in_use[NUM_ARITH_TBLS]; |
||
230 | int length, i; |
||
231 | jpeg_component_info *compptr; |
||
232 | |||
233 | for (i = 0; i < NUM_ARITH_TBLS; i++) |
||
234 | dc_in_use[i] = ac_in_use[i] = 0; |
||
235 | |||
236 | for (i = 0; i < cinfo->comps_in_scan; i++) { |
||
237 | compptr = cinfo->cur_comp_info[i]; |
||
238 | dc_in_use[compptr->dc_tbl_no] = 1; |
||
239 | ac_in_use[compptr->ac_tbl_no] = 1; |
||
240 | } |
||
241 | |||
242 | length = 0; |
||
243 | for (i = 0; i < NUM_ARITH_TBLS; i++) |
||
244 | length += dc_in_use[i] + ac_in_use[i]; |
||
245 | |||
246 | emit_marker(cinfo, M_DAC); |
||
247 | |||
248 | emit_2bytes(cinfo, length*2 + 2); |
||
249 | |||
250 | for (i = 0; i < NUM_ARITH_TBLS; i++) { |
||
251 | if (dc_in_use[i]) { |
||
252 | emit_byte(cinfo, i); |
||
253 | emit_byte(cinfo, cinfo->arith_dc_L[i] + (cinfo->arith_dc_U[i]<<4)); |
||
254 | } |
||
255 | if (ac_in_use[i]) { |
||
256 | emit_byte(cinfo, i + 0x10); |
||
257 | emit_byte(cinfo, cinfo->arith_ac_K[i]); |
||
258 | } |
||
259 | } |
||
260 | #endif /* C_ARITH_CODING_SUPPORTED */ |
||
261 | } |
||
262 | |||
263 | |||
264 | LOCAL(void) |
||
265 | emit_dri (j_compress_ptr cinfo) |
||
266 | /* Emit a DRI marker */ |
||
267 | { |
||
268 | emit_marker(cinfo, M_DRI); |
||
269 | |||
270 | emit_2bytes(cinfo, 4); /* fixed length */ |
||
271 | |||
272 | emit_2bytes(cinfo, (int) cinfo->restart_interval); |
||
273 | } |
||
274 | |||
275 | |||
276 | LOCAL(void) |
||
277 | emit_sof (j_compress_ptr cinfo, JPEG_MARKER code) |
||
278 | /* Emit a SOF marker */ |
||
279 | { |
||
280 | int ci; |
||
281 | jpeg_component_info *compptr; |
||
282 | |||
283 | emit_marker(cinfo, code); |
||
284 | |||
285 | emit_2bytes(cinfo, 3 * cinfo->num_components + 2 + 5 + 1); /* length */ |
||
286 | |||
287 | /* Make sure image isn't bigger than SOF field can handle */ |
||
288 | if ((long) cinfo->image_height > 65535L || |
||
289 | (long) cinfo->image_width > 65535L) |
||
290 | ERREXIT1(cinfo, JERR_IMAGE_TOO_BIG, (unsigned int) 65535); |
||
291 | |||
292 | emit_byte(cinfo, cinfo->data_precision); |
||
293 | emit_2bytes(cinfo, (int) cinfo->image_height); |
||
294 | emit_2bytes(cinfo, (int) cinfo->image_width); |
||
295 | |||
296 | emit_byte(cinfo, cinfo->num_components); |
||
297 | |||
298 | for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; |
||
299 | ci++, compptr++) { |
||
300 | emit_byte(cinfo, compptr->component_id); |
||
301 | emit_byte(cinfo, (compptr->h_samp_factor << 4) + compptr->v_samp_factor); |
||
302 | emit_byte(cinfo, compptr->quant_tbl_no); |
||
303 | } |
||
304 | } |
||
305 | |||
306 | |||
307 | LOCAL(void) |
||
308 | emit_sos (j_compress_ptr cinfo) |
||
309 | /* Emit a SOS marker */ |
||
310 | { |
||
311 | int i, td, ta; |
||
312 | jpeg_component_info *compptr; |
||
313 | |||
314 | emit_marker(cinfo, M_SOS); |
||
315 | |||
316 | emit_2bytes(cinfo, 2 * cinfo->comps_in_scan + 2 + 1 + 3); /* length */ |
||
317 | |||
318 | emit_byte(cinfo, cinfo->comps_in_scan); |
||
319 | |||
320 | for (i = 0; i < cinfo->comps_in_scan; i++) { |
||
321 | compptr = cinfo->cur_comp_info[i]; |
||
322 | emit_byte(cinfo, compptr->component_id); |
||
323 | td = compptr->dc_tbl_no; |
||
324 | ta = compptr->ac_tbl_no; |
||
325 | if (cinfo->progressive_mode) { |
||
326 | /* Progressive mode: only DC or only AC tables are used in one scan; |
||
327 | * furthermore, Huffman coding of DC refinement uses no table at all. |
||
328 | * We emit 0 for unused field(s); this is recommended by the P&M text |
||
329 | * but does not seem to be specified in the standard. |
||
330 | */ |
||
331 | if (cinfo->Ss == 0) { |
||
332 | ta = 0; /* DC scan */ |
||
333 | if (cinfo->Ah != 0 && !cinfo->arith_code) |
||
334 | td = 0; /* no DC table either */ |
||
335 | } else { |
||
336 | td = 0; /* AC scan */ |
||
337 | } |
||
338 | } |
||
339 | emit_byte(cinfo, (td << 4) + ta); |
||
340 | } |
||
341 | |||
342 | emit_byte(cinfo, cinfo->Ss); |
||
343 | emit_byte(cinfo, cinfo->Se); |
||
344 | emit_byte(cinfo, (cinfo->Ah << 4) + cinfo->Al); |
||
345 | } |
||
346 | |||
347 | |||
348 | LOCAL(void) |
||
349 | emit_jfif_app0 (j_compress_ptr cinfo) |
||
350 | /* Emit a JFIF-compliant APP0 marker */ |
||
351 | { |
||
352 | /* |
||
353 | * Length of APP0 block (2 bytes) |
||
354 | * Block ID (4 bytes - ASCII "JFIF") |
||
355 | * Zero byte (1 byte to terminate the ID string) |
||
356 | * Version Major, Minor (2 bytes - major first) |
||
357 | * Units (1 byte - 0x00 = none, 0x01 = inch, 0x02 = cm) |
||
358 | * Xdpu (2 bytes - dots per unit horizontal) |
||
359 | * Ydpu (2 bytes - dots per unit vertical) |
||
360 | * Thumbnail X size (1 byte) |
||
361 | * Thumbnail Y size (1 byte) |
||
362 | */ |
||
363 | |||
364 | emit_marker(cinfo, M_APP0); |
||
365 | |||
366 | emit_2bytes(cinfo, 2 + 4 + 1 + 2 + 1 + 2 + 2 + 1 + 1); /* length */ |
||
367 | |||
368 | emit_byte(cinfo, 0x4A); /* Identifier: ASCII "JFIF" */ |
||
369 | emit_byte(cinfo, 0x46); |
||
370 | emit_byte(cinfo, 0x49); |
||
371 | emit_byte(cinfo, 0x46); |
||
372 | emit_byte(cinfo, 0); |
||
373 | emit_byte(cinfo, cinfo->JFIF_major_version); /* Version fields */ |
||
374 | emit_byte(cinfo, cinfo->JFIF_minor_version); |
||
375 | emit_byte(cinfo, cinfo->density_unit); /* Pixel size information */ |
||
376 | emit_2bytes(cinfo, (int) cinfo->X_density); |
||
377 | emit_2bytes(cinfo, (int) cinfo->Y_density); |
||
378 | emit_byte(cinfo, 0); /* No thumbnail image */ |
||
379 | emit_byte(cinfo, 0); |
||
380 | } |
||
381 | |||
382 | |||
383 | LOCAL(void) |
||
384 | emit_adobe_app14 (j_compress_ptr cinfo) |
||
385 | /* Emit an Adobe APP14 marker */ |
||
386 | { |
||
387 | /* |
||
388 | * Length of APP14 block (2 bytes) |
||
389 | * Block ID (5 bytes - ASCII "Adobe") |
||
390 | * Version Number (2 bytes - currently 100) |
||
391 | * Flags0 (2 bytes - currently 0) |
||
392 | * Flags1 (2 bytes - currently 0) |
||
393 | * Color transform (1 byte) |
||
394 | * |
||
395 | * Although Adobe TN 5116 mentions Version = 101, all the Adobe files |
||
396 | * now in circulation seem to use Version = 100, so that's what we write. |
||
397 | * |
||
398 | * We write the color transform byte as 1 if the JPEG color space is |
||
399 | * YCbCr, 2 if it's YCCK, 0 otherwise. Adobe's definition has to do with |
||
400 | * whether the encoder performed a transformation, which is pretty useless. |
||
401 | */ |
||
402 | |||
403 | emit_marker(cinfo, M_APP14); |
||
404 | |||
405 | emit_2bytes(cinfo, 2 + 5 + 2 + 2 + 2 + 1); /* length */ |
||
406 | |||
407 | emit_byte(cinfo, 0x41); /* Identifier: ASCII "Adobe" */ |
||
408 | emit_byte(cinfo, 0x64); |
||
409 | emit_byte(cinfo, 0x6F); |
||
410 | emit_byte(cinfo, 0x62); |
||
411 | emit_byte(cinfo, 0x65); |
||
412 | emit_2bytes(cinfo, 100); /* Version */ |
||
413 | emit_2bytes(cinfo, 0); /* Flags0 */ |
||
414 | emit_2bytes(cinfo, 0); /* Flags1 */ |
||
415 | switch (cinfo->jpeg_color_space) { |
||
416 | case JCS_YCbCr: |
||
417 | emit_byte(cinfo, 1); /* Color transform = 1 */ |
||
418 | break; |
||
419 | case JCS_YCCK: |
||
420 | emit_byte(cinfo, 2); /* Color transform = 2 */ |
||
421 | break; |
||
422 | default: |
||
423 | emit_byte(cinfo, 0); /* Color transform = 0 */ |
||
424 | break; |
||
425 | } |
||
426 | } |
||
427 | |||
428 | |||
429 | /* |
||
430 | * These routines allow writing an arbitrary marker with parameters. |
||
431 | * The only intended use is to emit COM or APPn markers after calling |
||
432 | * write_file_header and before calling write_frame_header. |
||
433 | * Other uses are not guaranteed to produce desirable results. |
||
434 | * Counting the parameter bytes properly is the caller's responsibility. |
||
435 | */ |
||
436 | |||
437 | METHODDEF(void) |
||
438 | write_marker_header (j_compress_ptr cinfo, int marker, unsigned int datalen) |
||
439 | /* Emit an arbitrary marker header */ |
||
440 | { |
||
441 | if (datalen > (unsigned int) 65533) /* safety check */ |
||
442 | ERREXIT(cinfo, JERR_BAD_LENGTH); |
||
443 | |||
444 | emit_marker(cinfo, (JPEG_MARKER) marker); |
||
445 | |||
446 | emit_2bytes(cinfo, (int) (datalen + 2)); /* total length */ |
||
447 | } |
||
448 | |||
449 | METHODDEF(void) |
||
450 | write_marker_byte (j_compress_ptr cinfo, int val) |
||
451 | /* Emit one byte of marker parameters following write_marker_header */ |
||
452 | { |
||
453 | emit_byte(cinfo, val); |
||
454 | } |
||
455 | |||
456 | |||
457 | /* |
||
458 | * Write datastream header. |
||
459 | * This consists of an SOI and optional APPn markers. |
||
460 | * We recommend use of the JFIF marker, but not the Adobe marker, |
||
461 | * when using YCbCr or grayscale data. The JFIF marker should NOT |
||
462 | * be used for any other JPEG colorspace. The Adobe marker is helpful |
||
463 | * to distinguish RGB, CMYK, and YCCK colorspaces. |
||
464 | * Note that an application can write additional header markers after |
||
465 | * jpeg_start_compress returns. |
||
466 | */ |
||
467 | |||
468 | METHODDEF(void) |
||
469 | write_file_header (j_compress_ptr cinfo) |
||
470 | { |
||
471 | my_marker_ptr marker = (my_marker_ptr) cinfo->marker; |
||
472 | |||
473 | emit_marker(cinfo, M_SOI); /* first the SOI */ |
||
474 | |||
475 | /* SOI is defined to reset restart interval to 0 */ |
||
476 | marker->last_restart_interval = 0; |
||
477 | |||
478 | if (cinfo->write_JFIF_header) /* next an optional JFIF APP0 */ |
||
479 | emit_jfif_app0(cinfo); |
||
480 | if (cinfo->write_Adobe_marker) /* next an optional Adobe APP14 */ |
||
481 | emit_adobe_app14(cinfo); |
||
482 | } |
||
483 | |||
484 | |||
485 | /* |
||
486 | * Write frame header. |
||
487 | * This consists of DQT and SOFn markers. |
||
488 | * Note that we do not emit the SOF until we have emitted the DQT(s). |
||
489 | * This avoids compatibility problems with incorrect implementations that |
||
490 | * try to error-check the quant table numbers as soon as they see the SOF. |
||
491 | */ |
||
492 | |||
493 | METHODDEF(void) |
||
494 | write_frame_header (j_compress_ptr cinfo) |
||
495 | { |
||
496 | int ci, prec; |
||
497 | boolean is_baseline; |
||
498 | jpeg_component_info *compptr; |
||
499 | |||
500 | /* Emit DQT for each quantization table. |
||
501 | * Note that emit_dqt() suppresses any duplicate tables. |
||
502 | */ |
||
503 | prec = 0; |
||
504 | for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; |
||
505 | ci++, compptr++) { |
||
506 | prec += emit_dqt(cinfo, compptr->quant_tbl_no); |
||
507 | } |
||
508 | /* now prec is nonzero iff there are any 16-bit quant tables. */ |
||
509 | |||
510 | /* Check for a non-baseline specification. |
||
511 | * Note we assume that Huffman table numbers won't be changed later. |
||
512 | */ |
||
513 | if (cinfo->arith_code || cinfo->progressive_mode || |
||
514 | cinfo->data_precision != 8) { |
||
515 | is_baseline = FALSE; |
||
516 | } else { |
||
517 | is_baseline = TRUE; |
||
518 | for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; |
||
519 | ci++, compptr++) { |
||
520 | if (compptr->dc_tbl_no > 1 || compptr->ac_tbl_no > 1) |
||
521 | is_baseline = FALSE; |
||
522 | } |
||
523 | if (prec && is_baseline) { |
||
524 | is_baseline = FALSE; |
||
525 | /* If it's baseline except for quantizer size, warn the user */ |
||
526 | TRACEMS(cinfo, 0, JTRC_16BIT_TABLES); |
||
527 | } |
||
528 | } |
||
529 | |||
530 | /* Emit the proper SOF marker */ |
||
531 | if (cinfo->arith_code) { |
||
532 | emit_sof(cinfo, M_SOF9); /* SOF code for arithmetic coding */ |
||
533 | } else { |
||
534 | if (cinfo->progressive_mode) |
||
535 | emit_sof(cinfo, M_SOF2); /* SOF code for progressive Huffman */ |
||
536 | else if (is_baseline) |
||
537 | emit_sof(cinfo, M_SOF0); /* SOF code for baseline implementation */ |
||
538 | else |
||
539 | emit_sof(cinfo, M_SOF1); /* SOF code for non-baseline Huffman file */ |
||
540 | } |
||
541 | } |
||
542 | |||
543 | |||
544 | /* |
||
545 | * Write scan header. |
||
546 | * This consists of DHT or DAC markers, optional DRI, and SOS. |
||
547 | * Compressed data will be written following the SOS. |
||
548 | */ |
||
549 | |||
550 | METHODDEF(void) |
||
551 | write_scan_header (j_compress_ptr cinfo) |
||
552 | { |
||
553 | my_marker_ptr marker = (my_marker_ptr) cinfo->marker; |
||
554 | int i; |
||
555 | jpeg_component_info *compptr; |
||
556 | |||
557 | if (cinfo->arith_code) { |
||
558 | /* Emit arith conditioning info. We may have some duplication |
||
559 | * if the file has multiple scans, but it's so small it's hardly |
||
560 | * worth worrying about. |
||
561 | */ |
||
562 | emit_dac(cinfo); |
||
563 | } else { |
||
564 | /* Emit Huffman tables. |
||
565 | * Note that emit_dht() suppresses any duplicate tables. |
||
566 | */ |
||
567 | for (i = 0; i < cinfo->comps_in_scan; i++) { |
||
568 | compptr = cinfo->cur_comp_info[i]; |
||
569 | if (cinfo->progressive_mode) { |
||
570 | /* Progressive mode: only DC or only AC tables are used in one scan */ |
||
571 | if (cinfo->Ss == 0) { |
||
572 | if (cinfo->Ah == 0) /* DC needs no table for refinement scan */ |
||
573 | emit_dht(cinfo, compptr->dc_tbl_no, FALSE); |
||
574 | } else { |
||
575 | emit_dht(cinfo, compptr->ac_tbl_no, TRUE); |
||
576 | } |
||
577 | } else { |
||
578 | /* Sequential mode: need both DC and AC tables */ |
||
579 | emit_dht(cinfo, compptr->dc_tbl_no, FALSE); |
||
580 | emit_dht(cinfo, compptr->ac_tbl_no, TRUE); |
||
581 | } |
||
582 | } |
||
583 | } |
||
584 | |||
585 | /* Emit DRI if required --- note that DRI value could change for each scan. |
||
586 | * We avoid wasting space with unnecessary DRIs, however. |
||
587 | */ |
||
588 | if (cinfo->restart_interval != marker->last_restart_interval) { |
||
589 | emit_dri(cinfo); |
||
590 | marker->last_restart_interval = cinfo->restart_interval; |
||
591 | } |
||
592 | |||
593 | emit_sos(cinfo); |
||
594 | } |
||
595 | |||
596 | |||
597 | /* |
||
598 | * Write datastream trailer. |
||
599 | */ |
||
600 | |||
601 | METHODDEF(void) |
||
602 | write_file_trailer (j_compress_ptr cinfo) |
||
603 | { |
||
604 | emit_marker(cinfo, M_EOI); |
||
605 | } |
||
606 | |||
607 | |||
608 | /* |
||
609 | * Write an abbreviated table-specification datastream. |
||
610 | * This consists of SOI, DQT and DHT tables, and EOI. |
||
611 | * Any table that is defined and not marked sent_table = TRUE will be |
||
612 | * emitted. Note that all tables will be marked sent_table = TRUE at exit. |
||
613 | */ |
||
614 | |||
615 | METHODDEF(void) |
||
616 | write_tables_only (j_compress_ptr cinfo) |
||
617 | { |
||
618 | int i; |
||
619 | |||
620 | emit_marker(cinfo, M_SOI); |
||
621 | |||
622 | for (i = 0; i < NUM_QUANT_TBLS; i++) { |
||
623 | if (cinfo->quant_tbl_ptrs[i] != NULL) |
||
624 | (void) emit_dqt(cinfo, i); |
||
625 | } |
||
626 | |||
627 | if (! cinfo->arith_code) { |
||
628 | for (i = 0; i < NUM_HUFF_TBLS; i++) { |
||
629 | if (cinfo->dc_huff_tbl_ptrs[i] != NULL) |
||
630 | emit_dht(cinfo, i, FALSE); |
||
631 | if (cinfo->ac_huff_tbl_ptrs[i] != NULL) |
||
632 | emit_dht(cinfo, i, TRUE); |
||
633 | } |
||
634 | } |
||
635 | |||
636 | emit_marker(cinfo, M_EOI); |
||
637 | } |
||
638 | |||
639 | |||
640 | /* |
||
641 | * Initialize the marker writer module. |
||
642 | */ |
||
643 | |||
644 | GLOBAL(void) |
||
645 | jinit_marker_writer (j_compress_ptr cinfo) |
||
646 | { |
||
647 | my_marker_ptr marker; |
||
648 | |||
649 | /* Create the subobject */ |
||
650 | marker = (my_marker_ptr) |
||
651 | (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, |
||
652 | SIZEOF(my_marker_writer)); |
||
653 | cinfo->marker = (struct jpeg_marker_writer *) marker; |
||
654 | /* Initialize method pointers */ |
||
655 | marker->pub.write_file_header = write_file_header; |
||
656 | marker->pub.write_frame_header = write_frame_header; |
||
657 | marker->pub.write_scan_header = write_scan_header; |
||
658 | marker->pub.write_file_trailer = write_file_trailer; |
||
659 | marker->pub.write_tables_only = write_tables_only; |
||
660 | marker->pub.write_marker_header = write_marker_header; |
||
661 | marker->pub.write_marker_byte = write_marker_byte; |
||
662 | /* Initialize private state */ |
||
663 | marker->last_restart_interval = 0; |
||
664 | }>>>>>><>><>>><>>4)); |