Bug Summary

File:jdk/src/java.desktop/share/native/libjavajpeg/jcparam.c
Warning:line 610, column 5
Value stored to 'scanptr' is never read

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name jcparam.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -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 -mrelocation-model pic -pic-level 2 -mthread-model posix -fno-delete-null-pointer-checks -mframe-pointer=all -relaxed-aliasing -fmath-errno -fno-rounding-math -masm-verbose -mconstructor-aliases -munwind-tables -target-cpu x86-64 -dwarf-column-info -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib/llvm-10/lib/clang/10.0.0 -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/support/modules_include/java.base -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/support/modules_include/java.base/linux -I /home/daniel/Projects/java/jdk/src/java.base/share/native/libjava -I /home/daniel/Projects/java/jdk/src/java.base/unix/native/libjava -I /home/daniel/Projects/java/jdk/src/hotspot/share/include -I /home/daniel/Projects/java/jdk/src/hotspot/os/posix/include -D LIBC=gnu -D _GNU_SOURCE -D _REENTRANT -D _LARGEFILE64_SOURCE -D LINUX -D DEBUG -D _LITTLE_ENDIAN -D ARCH="amd64" -D amd64 -D _LP64=1 -I /home/daniel/Projects/java/jdk/src/java.desktop/share/native/libjavajpeg -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/support/headers/java.desktop -D _FORTIFY_SOURCE=2 -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-10/lib/clang/10.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O3 -Wno-unused-parameter -Wno-unused -Wno-clobbered -Wno-implicit-fallthrough -Wno-shift-negative-value -Wno-array-bounds -std=c99 -fdebug-compilation-dir /home/daniel/Projects/java/jdk/make -ferror-limit 19 -fmessage-length 0 -fvisibility hidden -stack-protector 1 -fgnuc-version=4.2.1 -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -o /home/daniel/Projects/java/scan/2021-12-21-193737-8510-1 -x c /home/daniel/Projects/java/jdk/src/java.desktop/share/native/libjavajpeg/jcparam.c
1/*
2 * reserved comment block
3 * DO NOT REMOVE OR ALTER!
4 */
5/*
6 * jcparam.c
7 *
8 * Copyright (C) 1991-1998, Thomas G. Lane.
9 * This file is part of the Independent JPEG Group's software.
10 * For conditions of distribution and use, see the accompanying README file.
11 *
12 * This file contains optional default-setting code for the JPEG compressor.
13 * Applications do not have to use this file, but those that don't use it
14 * must know a lot more about the innards of the JPEG code.
15 */
16
17#define JPEG_INTERNALS
18#include "jinclude.h"
19#include "jpeglib.h"
20
21
22/*
23 * Quantization table setup routines
24 */
25
26GLOBAL(void)void
27jpeg_add_quant_tablejAddQuantTable (j_compress_ptr cinfo, int which_tbl,
28 const unsigned int *basic_table,
29 int scale_factor, boolean force_baseline)
30/* Define a quantization table equal to the basic_table times
31 * a scale factor (given as a percentage).
32 * If force_baseline is TRUE, the computed quantization table entries
33 * are limited to 1..255 for JPEG baseline compatibility.
34 */
35{
36 JQUANT_TBL ** qtblptr;
37 int i;
38 long temp;
39
40 /* Safety check to ensure start_compress not called yet. */
41 if (cinfo->global_state != CSTATE_START100)
42 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state)((cinfo)->err->msg_code = (JERR_BAD_STATE), (cinfo)->
err->msg_parm.i[0] = (cinfo->global_state), (*(cinfo)->
err->error_exit) ((j_common_ptr) (cinfo)));
43
44 if (which_tbl < 0 || which_tbl >= NUM_QUANT_TBLS4)
45 ERREXIT1(cinfo, JERR_DQT_INDEX, which_tbl)((cinfo)->err->msg_code = (JERR_DQT_INDEX), (cinfo)->
err->msg_parm.i[0] = (which_tbl), (*(cinfo)->err->error_exit
) ((j_common_ptr) (cinfo)));
46
47 qtblptr = & cinfo->quant_tbl_ptrs[which_tbl];
48
49 if (*qtblptr == NULL((void*)0))
50 *qtblptr = jpeg_alloc_quant_tablejAlcQTable((j_common_ptr) cinfo);
51
52 for (i = 0; i < DCTSIZE264; i++) {
53 temp = ((long) basic_table[i] * scale_factor + 50L) / 100L;
54 /* limit the values to the valid range */
55 if (temp <= 0L) temp = 1L;
56 if (temp > 32767L) temp = 32767L; /* max quantizer needed for 12 bits */
57 if (force_baseline && temp > 255L)
58 temp = 255L; /* limit to baseline range if requested */
59 (*qtblptr)->quantval[i] = (UINT16) temp;
60 }
61
62 /* Initialize sent_table FALSE so table will be written to JPEG file. */
63 (*qtblptr)->sent_table = FALSE0;
64}
65
66
67GLOBAL(void)void
68jpeg_set_linear_qualityjSetLQuality (j_compress_ptr cinfo, int scale_factor,
69 boolean force_baseline)
70/* Set or change the 'quality' (quantization) setting, using default tables
71 * and a straight percentage-scaling quality scale. In most cases it's better
72 * to use jpeg_set_quality (below); this entry point is provided for
73 * applications that insist on a linear percentage scaling.
74 */
75{
76 /* These are the sample quantization tables given in JPEG spec section K.1.
77 * The spec says that the values given produce "good" quality, and
78 * when divided by 2, "very good" quality.
79 */
80 static const unsigned int std_luminance_quant_tbl[DCTSIZE264] = {
81 16, 11, 10, 16, 24, 40, 51, 61,
82 12, 12, 14, 19, 26, 58, 60, 55,
83 14, 13, 16, 24, 40, 57, 69, 56,
84 14, 17, 22, 29, 51, 87, 80, 62,
85 18, 22, 37, 56, 68, 109, 103, 77,
86 24, 35, 55, 64, 81, 104, 113, 92,
87 49, 64, 78, 87, 103, 121, 120, 101,
88 72, 92, 95, 98, 112, 100, 103, 99
89 };
90 static const unsigned int std_chrominance_quant_tbl[DCTSIZE264] = {
91 17, 18, 24, 47, 99, 99, 99, 99,
92 18, 21, 26, 66, 99, 99, 99, 99,
93 24, 26, 56, 99, 99, 99, 99, 99,
94 47, 66, 99, 99, 99, 99, 99, 99,
95 99, 99, 99, 99, 99, 99, 99, 99,
96 99, 99, 99, 99, 99, 99, 99, 99,
97 99, 99, 99, 99, 99, 99, 99, 99,
98 99, 99, 99, 99, 99, 99, 99, 99
99 };
100
101 /* Set up two quantization tables using the specified scaling */
102 jpeg_add_quant_tablejAddQuantTable(cinfo, 0, std_luminance_quant_tbl,
103 scale_factor, force_baseline);
104 jpeg_add_quant_tablejAddQuantTable(cinfo, 1, std_chrominance_quant_tbl,
105 scale_factor, force_baseline);
106}
107
108
109GLOBAL(int)int
110jpeg_quality_scalingjQualityScaling (int quality)
111/* Convert a user-specified quality rating to a percentage scaling factor
112 * for an underlying quantization table, using our recommended scaling curve.
113 * The input 'quality' factor should be 0 (terrible) to 100 (very good).
114 */
115{
116 /* Safety limit on quality factor. Convert 0 to 1 to avoid zero divide. */
117 if (quality <= 0) quality = 1;
118 if (quality > 100) quality = 100;
119
120 /* The basic table is used as-is (scaling 100) for a quality of 50.
121 * Qualities 50..100 are converted to scaling percentage 200 - 2*Q;
122 * note that at Q=100 the scaling is 0, which will cause jpeg_add_quant_table
123 * to make all the table entries 1 (hence, minimum quantization loss).
124 * Qualities 1..50 are converted to scaling percentage 5000/Q.
125 */
126 if (quality < 50)
127 quality = 5000 / quality;
128 else
129 quality = 200 - quality*2;
130
131 return quality;
132}
133
134
135GLOBAL(void)void
136jpeg_set_qualityjSetQuality (j_compress_ptr cinfo, int quality, boolean force_baseline)
137/* Set or change the 'quality' (quantization) setting, using default tables.
138 * This is the standard quality-adjusting entry point for typical user
139 * interfaces; only those who want detailed control over quantization tables
140 * would use the preceding three routines directly.
141 */
142{
143 /* Convert user 0-100 rating to percentage scaling */
144 quality = jpeg_quality_scalingjQualityScaling(quality);
145
146 /* Set up standard quality tables */
147 jpeg_set_linear_qualityjSetLQuality(cinfo, quality, force_baseline);
148}
149
150
151/*
152 * Huffman table setup routines
153 */
154
155LOCAL(void)static void
156add_huff_table (j_compress_ptr cinfo,
157 JHUFF_TBL **htblptr, const UINT8 *bits, const UINT8 *val)
158/* Define a Huffman table */
159{
160 int nsymbols, len;
161
162 if (*htblptr == NULL((void*)0))
163 *htblptr = jpeg_alloc_huff_tablejAlcHTable((j_common_ptr) cinfo);
164
165 /* Copy the number-of-symbols-of-each-code-length counts */
166 MEMCOPY((*htblptr)->bits, bits, SIZEOF((*htblptr)->bits))memcpy((void *)((*htblptr)->bits), (const void *)(bits), (
size_t)(((size_t) sizeof((*htblptr)->bits))));
167
168 /* Validate the counts. We do this here mainly so we can copy the right
169 * number of symbols from the val[] array, without risking marching off
170 * the end of memory. jchuff.c will do a more thorough test later.
171 */
172 nsymbols = 0;
173 for (len = 1; len <= 16; len++)
174 nsymbols += bits[len];
175 if (nsymbols < 1 || nsymbols > 256)
176 ERREXIT(cinfo, JERR_BAD_HUFF_TABLE)((cinfo)->err->msg_code = (JERR_BAD_HUFF_TABLE), (*(cinfo
)->err->error_exit) ((j_common_ptr) (cinfo)));
177
178 MEMCOPY((*htblptr)->huffval, val, nsymbols * SIZEOF(UINT8))memcpy((void *)((*htblptr)->huffval), (const void *)(val),
(size_t)(nsymbols * ((size_t) sizeof(UINT8))));
179
180 /* Initialize sent_table FALSE so table will be written to JPEG file. */
181 (*htblptr)->sent_table = FALSE0;
182}
183
184
185LOCAL(void)static void
186std_huff_tables (j_compress_ptr cinfo)
187/* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
188/* IMPORTANT: these are only valid for 8-bit data precision! */
189{
190 static const UINT8 bits_dc_luminance[17] =
191 { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
192 static const UINT8 val_dc_luminance[] =
193 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
194
195 static const UINT8 bits_dc_chrominance[17] =
196 { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
197 static const UINT8 val_dc_chrominance[] =
198 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
199
200 static const UINT8 bits_ac_luminance[17] =
201 { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
202 static const UINT8 val_ac_luminance[] =
203 { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
204 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
205 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
206 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
207 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
208 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
209 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
210 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
211 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
212 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
213 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
214 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
215 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
216 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
217 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
218 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
219 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
220 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
221 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
222 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
223 0xf9, 0xfa };
224
225 static const UINT8 bits_ac_chrominance[17] =
226 { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
227 static const UINT8 val_ac_chrominance[] =
228 { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
229 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
230 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
231 0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
232 0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
233 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
234 0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
235 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
236 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
237 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
238 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
239 0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
240 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
241 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
242 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
243 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
244 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
245 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
246 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
247 0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
248 0xf9, 0xfa };
249
250 add_huff_table(cinfo, &cinfo->dc_huff_tbl_ptrs[0],
251 bits_dc_luminance, val_dc_luminance);
252 add_huff_table(cinfo, &cinfo->ac_huff_tbl_ptrs[0],
253 bits_ac_luminance, val_ac_luminance);
254 add_huff_table(cinfo, &cinfo->dc_huff_tbl_ptrs[1],
255 bits_dc_chrominance, val_dc_chrominance);
256 add_huff_table(cinfo, &cinfo->ac_huff_tbl_ptrs[1],
257 bits_ac_chrominance, val_ac_chrominance);
258}
259
260
261/*
262 * Default parameter setup for compression.
263 *
264 * Applications that don't choose to use this routine must do their
265 * own setup of all these parameters. Alternately, you can call this
266 * to establish defaults and then alter parameters selectively. This
267 * is the recommended approach since, if we add any new parameters,
268 * your code will still work (they'll be set to reasonable defaults).
269 */
270
271GLOBAL(void)void
272jpeg_set_defaultsjSetDefaults (j_compress_ptr cinfo)
273{
274 int i;
275
276 /* Safety check to ensure start_compress not called yet. */
277 if (cinfo->global_state != CSTATE_START100)
278 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state)((cinfo)->err->msg_code = (JERR_BAD_STATE), (cinfo)->
err->msg_parm.i[0] = (cinfo->global_state), (*(cinfo)->
err->error_exit) ((j_common_ptr) (cinfo)));
279
280 /* Allocate comp_info array large enough for maximum component count.
281 * Array is made permanent in case application wants to compress
282 * multiple images at same param settings.
283 */
284 if (cinfo->comp_info == NULL((void*)0))
285 cinfo->comp_info = (jpeg_component_info *)
286 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT0,
287 MAX_COMPONENTS10 * SIZEOF(jpeg_component_info)((size_t) sizeof(jpeg_component_info)));
288
289 /* Initialize everything not dependent on the color space */
290
291 cinfo->data_precision = BITS_IN_JSAMPLE8;
292 /* Set up two quantization tables using default quality of 75 */
293 jpeg_set_qualityjSetQuality(cinfo, 75, TRUE1);
294 /* Set up two Huffman tables */
295 std_huff_tables(cinfo);
296
297 /* Initialize default arithmetic coding conditioning */
298 for (i = 0; i < NUM_ARITH_TBLS16; i++) {
299 cinfo->arith_dc_L[i] = 0;
300 cinfo->arith_dc_U[i] = 1;
301 cinfo->arith_ac_K[i] = 5;
302 }
303
304 /* Default is no multiple-scan output */
305 cinfo->scan_info = NULL((void*)0);
306 cinfo->num_scans = 0;
307
308 /* Expect normal source image, not raw downsampled data */
309 cinfo->raw_data_in = FALSE0;
310
311 /* Use Huffman coding, not arithmetic coding, by default */
312 cinfo->arith_code = FALSE0;
313
314 /* By default, don't do extra passes to optimize entropy coding */
315 cinfo->optimize_coding = FALSE0;
316 /* The standard Huffman tables are only valid for 8-bit data precision.
317 * If the precision is higher, force optimization on so that usable
318 * tables will be computed. This test can be removed if default tables
319 * are supplied that are valid for the desired precision.
320 */
321 if (cinfo->data_precision > 8)
322 cinfo->optimize_coding = TRUE1;
323
324 /* By default, use the simpler non-cosited sampling alignment */
325 cinfo->CCIR601_sampling = FALSE0;
326
327 /* No input smoothing */
328 cinfo->smoothing_factor = 0;
329
330 /* DCT algorithm preference */
331 cinfo->dct_method = JDCT_DEFAULTJDCT_ISLOW;
332
333 /* No restart markers */
334 cinfo->restart_interval = 0;
335 cinfo->restart_in_rows = 0;
336
337 /* Fill in default JFIF marker parameters. Note that whether the marker
338 * will actually be written is determined by jpeg_set_colorspace.
339 *
340 * By default, the library emits JFIF version code 1.01.
341 * An application that wants to emit JFIF 1.02 extension markers should set
342 * JFIF_minor_version to 2. We could probably get away with just defaulting
343 * to 1.02, but there may still be some decoders in use that will complain
344 * about that; saying 1.01 should minimize compatibility problems.
345 */
346 cinfo->JFIF_major_version = 1; /* Default JFIF version = 1.01 */
347 cinfo->JFIF_minor_version = 1;
348 cinfo->density_unit = 0; /* Pixel size is unknown by default */
349 cinfo->X_density = 1; /* Pixel aspect ratio is square by default */
350 cinfo->Y_density = 1;
351
352 /* Choose JPEG colorspace based on input space, set defaults accordingly */
353
354 jpeg_default_colorspacejDefColorspace(cinfo);
355}
356
357
358/*
359 * Select an appropriate JPEG colorspace for in_color_space.
360 */
361
362GLOBAL(void)void
363jpeg_default_colorspacejDefColorspace (j_compress_ptr cinfo)
364{
365 switch (cinfo->in_color_space) {
366 case JCS_GRAYSCALE:
367 jpeg_set_colorspacejSetColorspace(cinfo, JCS_GRAYSCALE);
368 break;
369 case JCS_RGB:
370 jpeg_set_colorspacejSetColorspace(cinfo, JCS_YCbCr);
371 break;
372 case JCS_YCbCr:
373 jpeg_set_colorspacejSetColorspace(cinfo, JCS_YCbCr);
374 break;
375 case JCS_CMYK:
376 jpeg_set_colorspacejSetColorspace(cinfo, JCS_CMYK); /* By default, no translation */
377 break;
378 case JCS_YCCK:
379 jpeg_set_colorspacejSetColorspace(cinfo, JCS_YCCK);
380 break;
381 case JCS_UNKNOWN:
382 jpeg_set_colorspacejSetColorspace(cinfo, JCS_UNKNOWN);
383 break;
384 default:
385 ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE)((cinfo)->err->msg_code = (JERR_BAD_IN_COLORSPACE), (*(
cinfo)->err->error_exit) ((j_common_ptr) (cinfo)));
386 }
387}
388
389
390/*
391 * Set the JPEG colorspace, and choose colorspace-dependent default values.
392 */
393
394GLOBAL(void)void
395jpeg_set_colorspacejSetColorspace (j_compress_ptr cinfo, J_COLOR_SPACE colorspace)
396{
397 jpeg_component_info * compptr;
398 int ci;
399
400#define SET_COMP(index,id,hsamp,vsamp,quant,dctbl,actbl)(compptr = &cinfo->comp_info[index], compptr->component_id
= (id), compptr->h_samp_factor = (hsamp), compptr->v_samp_factor
= (vsamp), compptr->quant_tbl_no = (quant), compptr->dc_tbl_no
= (dctbl), compptr->ac_tbl_no = (actbl) ) \
401 (compptr = &cinfo->comp_info[index], \
402 compptr->component_id = (id), \
403 compptr->h_samp_factor = (hsamp), \
404 compptr->v_samp_factor = (vsamp), \
405 compptr->quant_tbl_no = (quant), \
406 compptr->dc_tbl_no = (dctbl), \
407 compptr->ac_tbl_no = (actbl) )
408
409 /* Safety check to ensure start_compress not called yet. */
410 if (cinfo->global_state != CSTATE_START100)
411 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state)((cinfo)->err->msg_code = (JERR_BAD_STATE), (cinfo)->
err->msg_parm.i[0] = (cinfo->global_state), (*(cinfo)->
err->error_exit) ((j_common_ptr) (cinfo)));
412
413 /* For all colorspaces, we use Q and Huff tables 0 for luminance components,
414 * tables 1 for chrominance components.
415 */
416
417 cinfo->jpeg_color_space = colorspace;
418
419 cinfo->write_JFIF_header = FALSE0; /* No marker for non-JFIF colorspaces */
420 cinfo->write_Adobe_marker = FALSE0; /* write no Adobe marker by default */
421
422 switch (colorspace) {
423 case JCS_GRAYSCALE:
424 cinfo->write_JFIF_header = TRUE1; /* Write a JFIF marker */
425 cinfo->num_components = 1;
426 /* JFIF specifies component ID 1 */
427 SET_COMP(0, 1, 1,1, 0, 0,0)(compptr = &cinfo->comp_info[0], compptr->component_id
= (1), compptr->h_samp_factor = (1), compptr->v_samp_factor
= (1), compptr->quant_tbl_no = (0), compptr->dc_tbl_no
= (0), compptr->ac_tbl_no = (0) );
428 break;
429 case JCS_RGB:
430 cinfo->write_Adobe_marker = TRUE1; /* write Adobe marker to flag RGB */
431 cinfo->num_components = 3;
432 SET_COMP(0, 0x52 /* 'R' */, 1,1, 0, 0,0)(compptr = &cinfo->comp_info[0], compptr->component_id
= (0x52), compptr->h_samp_factor = (1), compptr->v_samp_factor
= (1), compptr->quant_tbl_no = (0), compptr->dc_tbl_no
= (0), compptr->ac_tbl_no = (0) );
433 SET_COMP(1, 0x47 /* 'G' */, 1,1, 0, 0,0)(compptr = &cinfo->comp_info[1], compptr->component_id
= (0x47), compptr->h_samp_factor = (1), compptr->v_samp_factor
= (1), compptr->quant_tbl_no = (0), compptr->dc_tbl_no
= (0), compptr->ac_tbl_no = (0) );
434 SET_COMP(2, 0x42 /* 'B' */, 1,1, 0, 0,0)(compptr = &cinfo->comp_info[2], compptr->component_id
= (0x42), compptr->h_samp_factor = (1), compptr->v_samp_factor
= (1), compptr->quant_tbl_no = (0), compptr->dc_tbl_no
= (0), compptr->ac_tbl_no = (0) );
435 break;
436 case JCS_YCbCr:
437 cinfo->write_JFIF_header = TRUE1; /* Write a JFIF marker */
438 cinfo->num_components = 3;
439 /* JFIF specifies component IDs 1,2,3 */
440 /* We default to 2x2 subsamples of chrominance */
441 SET_COMP(0, 1, 2,2, 0, 0,0)(compptr = &cinfo->comp_info[0], compptr->component_id
= (1), compptr->h_samp_factor = (2), compptr->v_samp_factor
= (2), compptr->quant_tbl_no = (0), compptr->dc_tbl_no
= (0), compptr->ac_tbl_no = (0) );
442 SET_COMP(1, 2, 1,1, 1, 1,1)(compptr = &cinfo->comp_info[1], compptr->component_id
= (2), compptr->h_samp_factor = (1), compptr->v_samp_factor
= (1), compptr->quant_tbl_no = (1), compptr->dc_tbl_no
= (1), compptr->ac_tbl_no = (1) );
443 SET_COMP(2, 3, 1,1, 1, 1,1)(compptr = &cinfo->comp_info[2], compptr->component_id
= (3), compptr->h_samp_factor = (1), compptr->v_samp_factor
= (1), compptr->quant_tbl_no = (1), compptr->dc_tbl_no
= (1), compptr->ac_tbl_no = (1) );
444 break;
445 case JCS_CMYK:
446 cinfo->write_Adobe_marker = TRUE1; /* write Adobe marker to flag CMYK */
447 cinfo->num_components = 4;
448 SET_COMP(0, 0x43 /* 'C' */, 1,1, 0, 0,0)(compptr = &cinfo->comp_info[0], compptr->component_id
= (0x43), compptr->h_samp_factor = (1), compptr->v_samp_factor
= (1), compptr->quant_tbl_no = (0), compptr->dc_tbl_no
= (0), compptr->ac_tbl_no = (0) );
449 SET_COMP(1, 0x4D /* 'M' */, 1,1, 0, 0,0)(compptr = &cinfo->comp_info[1], compptr->component_id
= (0x4D), compptr->h_samp_factor = (1), compptr->v_samp_factor
= (1), compptr->quant_tbl_no = (0), compptr->dc_tbl_no
= (0), compptr->ac_tbl_no = (0) );
450 SET_COMP(2, 0x59 /* 'Y' */, 1,1, 0, 0,0)(compptr = &cinfo->comp_info[2], compptr->component_id
= (0x59), compptr->h_samp_factor = (1), compptr->v_samp_factor
= (1), compptr->quant_tbl_no = (0), compptr->dc_tbl_no
= (0), compptr->ac_tbl_no = (0) );
451 SET_COMP(3, 0x4B /* 'K' */, 1,1, 0, 0,0)(compptr = &cinfo->comp_info[3], compptr->component_id
= (0x4B), compptr->h_samp_factor = (1), compptr->v_samp_factor
= (1), compptr->quant_tbl_no = (0), compptr->dc_tbl_no
= (0), compptr->ac_tbl_no = (0) );
452 break;
453 case JCS_YCCK:
454 cinfo->write_Adobe_marker = TRUE1; /* write Adobe marker to flag YCCK */
455 cinfo->num_components = 4;
456 SET_COMP(0, 1, 2,2, 0, 0,0)(compptr = &cinfo->comp_info[0], compptr->component_id
= (1), compptr->h_samp_factor = (2), compptr->v_samp_factor
= (2), compptr->quant_tbl_no = (0), compptr->dc_tbl_no
= (0), compptr->ac_tbl_no = (0) );
457 SET_COMP(1, 2, 1,1, 1, 1,1)(compptr = &cinfo->comp_info[1], compptr->component_id
= (2), compptr->h_samp_factor = (1), compptr->v_samp_factor
= (1), compptr->quant_tbl_no = (1), compptr->dc_tbl_no
= (1), compptr->ac_tbl_no = (1) );
458 SET_COMP(2, 3, 1,1, 1, 1,1)(compptr = &cinfo->comp_info[2], compptr->component_id
= (3), compptr->h_samp_factor = (1), compptr->v_samp_factor
= (1), compptr->quant_tbl_no = (1), compptr->dc_tbl_no
= (1), compptr->ac_tbl_no = (1) );
459 SET_COMP(3, 4, 2,2, 0, 0,0)(compptr = &cinfo->comp_info[3], compptr->component_id
= (4), compptr->h_samp_factor = (2), compptr->v_samp_factor
= (2), compptr->quant_tbl_no = (0), compptr->dc_tbl_no
= (0), compptr->ac_tbl_no = (0) );
460 break;
461 case JCS_UNKNOWN:
462 cinfo->num_components = cinfo->input_components;
463 if (cinfo->num_components < 1 || cinfo->num_components > MAX_COMPONENTS10)
464 ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components,((cinfo)->err->msg_code = (JERR_COMPONENT_COUNT), (cinfo
)->err->msg_parm.i[0] = (cinfo->num_components), (cinfo
)->err->msg_parm.i[1] = (10), (*(cinfo)->err->error_exit
) ((j_common_ptr) (cinfo)))
465 MAX_COMPONENTS)((cinfo)->err->msg_code = (JERR_COMPONENT_COUNT), (cinfo
)->err->msg_parm.i[0] = (cinfo->num_components), (cinfo
)->err->msg_parm.i[1] = (10), (*(cinfo)->err->error_exit
) ((j_common_ptr) (cinfo)));
466 for (ci = 0; ci < cinfo->num_components; ci++) {
467 SET_COMP(ci, ci, 1,1, 0, 0,0)(compptr = &cinfo->comp_info[ci], compptr->component_id
= (ci), compptr->h_samp_factor = (1), compptr->v_samp_factor
= (1), compptr->quant_tbl_no = (0), compptr->dc_tbl_no
= (0), compptr->ac_tbl_no = (0) );
468 }
469 break;
470 default:
471 ERREXIT(cinfo, JERR_BAD_J_COLORSPACE)((cinfo)->err->msg_code = (JERR_BAD_J_COLORSPACE), (*(cinfo
)->err->error_exit) ((j_common_ptr) (cinfo)));
472 }
473}
474
475
476#ifdef C_PROGRESSIVE_SUPPORTED
477
478LOCAL(jpeg_scan_info *)static jpeg_scan_info *
479fill_a_scan (jpeg_scan_info * scanptr, int ci,
480 int Ss, int Se, int Ah, int Al)
481/* Support routine: generate one scan for specified component */
482{
483 scanptr->comps_in_scan = 1;
484 scanptr->component_index[0] = ci;
485 scanptr->Ss = Ss;
486 scanptr->Se = Se;
487 scanptr->Ah = Ah;
488 scanptr->Al = Al;
489 scanptr++;
490 return scanptr;
491}
492
493LOCAL(jpeg_scan_info *)static jpeg_scan_info *
494fill_scans (jpeg_scan_info * scanptr, int ncomps,
495 int Ss, int Se, int Ah, int Al)
496/* Support routine: generate one scan for each component */
497{
498 int ci;
499
500 for (ci = 0; ci < ncomps; ci++) {
501 scanptr->comps_in_scan = 1;
502 scanptr->component_index[0] = ci;
503 scanptr->Ss = Ss;
504 scanptr->Se = Se;
505 scanptr->Ah = Ah;
506 scanptr->Al = Al;
507 scanptr++;
508 }
509 return scanptr;
510}
511
512LOCAL(jpeg_scan_info *)static jpeg_scan_info *
513fill_dc_scans (jpeg_scan_info * scanptr, int ncomps, int Ah, int Al)
514/* Support routine: generate interleaved DC scan if possible, else N scans */
515{
516 int ci;
517
518 if (ncomps <= MAX_COMPS_IN_SCAN4) {
519 /* Single interleaved DC scan */
520 scanptr->comps_in_scan = ncomps;
521 for (ci = 0; ci < ncomps; ci++)
522 scanptr->component_index[ci] = ci;
523 scanptr->Ss = scanptr->Se = 0;
524 scanptr->Ah = Ah;
525 scanptr->Al = Al;
526 scanptr++;
527 } else {
528 /* Noninterleaved DC scan for each component */
529 scanptr = fill_scans(scanptr, ncomps, 0, 0, Ah, Al);
530 }
531 return scanptr;
532}
533
534
535/*
536 * Create a recommended progressive-JPEG script.
537 * cinfo->num_components and cinfo->jpeg_color_space must be correct.
538 */
539
540GLOBAL(void)void
541jpeg_simple_progressionjSimProgress (j_compress_ptr cinfo)
542{
543 int ncomps = cinfo->num_components;
544 int nscans;
545 jpeg_scan_info * scanptr;
546
547 /* Safety check to ensure start_compress not called yet. */
548 if (cinfo->global_state != CSTATE_START100)
549 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state)((cinfo)->err->msg_code = (JERR_BAD_STATE), (cinfo)->
err->msg_parm.i[0] = (cinfo->global_state), (*(cinfo)->
err->error_exit) ((j_common_ptr) (cinfo)));
550
551 /* Figure space needed for script. Calculation must match code below! */
552 if (ncomps == 3 && cinfo->jpeg_color_space == JCS_YCbCr) {
553 /* Custom script for YCbCr color images. */
554 nscans = 10;
555 } else {
556 /* All-purpose script for other color spaces. */
557 if (ncomps > MAX_COMPS_IN_SCAN4)
558 nscans = 6 * ncomps; /* 2 DC + 4 AC scans per component */
559 else
560 nscans = 2 + 4 * ncomps; /* 2 DC scans; 4 AC scans per component */
561 }
562
563 /* Allocate space for script.
564 * We need to put it in the permanent pool in case the application performs
565 * multiple compressions without changing the settings. To avoid a memory
566 * leak if jpeg_simple_progression is called repeatedly for the same JPEG
567 * object, we try to re-use previously allocated space, and we allocate
568 * enough space to handle YCbCr even if initially asked for grayscale.
569 */
570 if (cinfo->script_space == NULL((void*)0) || cinfo->script_space_size < nscans) {
571 cinfo->script_space_size = MAX(nscans, 10)((nscans) > (10) ? (nscans) : (10));
572 cinfo->script_space = (jpeg_scan_info *)
573 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT0,
574 cinfo->script_space_size * SIZEOF(jpeg_scan_info)((size_t) sizeof(jpeg_scan_info)));
575 }
576 scanptr = cinfo->script_space;
577 cinfo->scan_info = scanptr;
578 cinfo->num_scans = nscans;
579
580 if (ncomps == 3 && cinfo->jpeg_color_space == JCS_YCbCr) {
581 /* Custom script for YCbCr color images. */
582 /* Initial DC scan */
583 scanptr = fill_dc_scans(scanptr, ncomps, 0, 1);
584 /* Initial AC scan: get some luma data out in a hurry */
585 scanptr = fill_a_scan(scanptr, 0, 1, 5, 0, 2);
586 /* Chroma data is too small to be worth expending many scans on */
587 scanptr = fill_a_scan(scanptr, 2, 1, 63, 0, 1);
588 scanptr = fill_a_scan(scanptr, 1, 1, 63, 0, 1);
589 /* Complete spectral selection for luma AC */
590 scanptr = fill_a_scan(scanptr, 0, 6, 63, 0, 2);
591 /* Refine next bit of luma AC */
592 scanptr = fill_a_scan(scanptr, 0, 1, 63, 2, 1);
593 /* Finish DC successive approximation */
594 scanptr = fill_dc_scans(scanptr, ncomps, 1, 0);
595 /* Finish AC successive approximation */
596 scanptr = fill_a_scan(scanptr, 2, 1, 63, 1, 0);
597 scanptr = fill_a_scan(scanptr, 1, 1, 63, 1, 0);
598 /* Luma bottom bit comes last since it's usually largest scan */
599 scanptr = fill_a_scan(scanptr, 0, 1, 63, 1, 0);
600 } else {
601 /* All-purpose script for other color spaces. */
602 /* Successive approximation first pass */
603 scanptr = fill_dc_scans(scanptr, ncomps, 0, 1);
604 scanptr = fill_scans(scanptr, ncomps, 1, 5, 0, 2);
605 scanptr = fill_scans(scanptr, ncomps, 6, 63, 0, 2);
606 /* Successive approximation second pass */
607 scanptr = fill_scans(scanptr, ncomps, 1, 63, 2, 1);
608 /* Successive approximation final pass */
609 scanptr = fill_dc_scans(scanptr, ncomps, 1, 0);
610 scanptr = fill_scans(scanptr, ncomps, 1, 63, 1, 0);
Value stored to 'scanptr' is never read
611 }
612}
613
614#endif /* C_PROGRESSIVE_SUPPORTED */