Bug Summary

File:root/firefox-clang/media/libjpeg/src/jcmarker.c
Warning:line 207, column 8
Access to field 'sent_table' results in a dereference of a null pointer (loaded from variable 'htbl')

Annotated Source Code

Press '?' to see keyboard shortcuts

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