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