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.
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.
13 #define JPEG_INTERNALS
14 #include "jinclude12.h"
15 #include "jpeglib12.h"
19 * Quantization table setup routines
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.
32 JQUANT_TBL ** qtblptr;
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);
40 if (which_tbl < 0 || which_tbl >= NUM_QUANT_TBLS)
41 ERREXIT1(cinfo, JERR_DQT_INDEX, which_tbl);
43 qtblptr = & cinfo->quant_tbl_ptrs[which_tbl];
46 *qtblptr = jpeg_alloc_quant_table((j_common_ptr) cinfo);
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;
58 /* Initialize sent_table FALSE so table will be written to JPEG file. */
59 (*qtblptr)->sent_table = FALSE;
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.
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.
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
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
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);
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).
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;
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.
123 quality = 5000 / quality;
125 quality = 200 - quality*2;
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.
139 /* Convert user 0-100 rating to percentage scaling */
140 quality = jpeg_quality_scaling(quality);
142 /* Set up standard quality tables */
143 jpeg_set_linear_quality(cinfo, quality, force_baseline);
148 * Huffman table setup routines
152 add_huff_table (j_compress_ptr cinfo,
153 JHUFF_TBL **htblptr, const UINT8 *bits, const UINT8 *val)
154 /* Define a Huffman table */
158 if (*htblptr == NULL)
159 *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo);
161 /* Copy the number-of-symbols-of-each-code-length counts */
162 MEMCOPY((*htblptr)->bits, bits, SIZEOF((*htblptr)->bits));
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.
169 for (len = 1; len <= 16; len++)
170 nsymbols += bits[len];
171 if (nsymbols < 1 || nsymbols > 256) {
172 printf ("JERR_BAD_HUFF_TABLE nsymbols %d\n",nsymbols);
173 ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
176 MEMCOPY((*htblptr)->huffval, val, nsymbols * SIZEOF(UINT8));
178 /* Initialize sent_table FALSE so table will be written to JPEG file. */
179 (*htblptr)->sent_table = FALSE;
184 std_huff_tables (j_compress_ptr cinfo)
185 /* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
186 /* IMPORTANT: these are only valid for 8-bit data precision! */
188 static const UINT8 bits_dc_luminance[17] =
189 { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
190 static const UINT8 val_dc_luminance[] =
191 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
193 static const UINT8 bits_dc_chrominance[17] =
194 { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
195 static const UINT8 val_dc_chrominance[] =
196 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
198 static const UINT8 bits_ac_luminance[17] =
199 { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
200 static const UINT8 val_ac_luminance[] =
201 { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
202 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
203 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
204 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
205 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
206 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
207 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
208 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
209 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
210 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
211 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
212 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
213 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
214 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
215 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
216 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
217 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
218 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
219 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
220 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
223 static const UINT8 bits_ac_chrominance[17] =
224 { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
225 static const UINT8 val_ac_chrominance[] =
226 { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
227 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
228 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
229 0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
230 0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
231 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
232 0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
233 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
234 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
235 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
236 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
237 0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
238 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
239 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
240 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
241 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
242 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
243 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
244 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
245 0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
248 add_huff_table(cinfo, &cinfo->dc_huff_tbl_ptrs[0],
249 bits_dc_luminance, val_dc_luminance);
250 add_huff_table(cinfo, &cinfo->ac_huff_tbl_ptrs[0],
251 bits_ac_luminance, val_ac_luminance);
252 add_huff_table(cinfo, &cinfo->dc_huff_tbl_ptrs[1],
253 bits_dc_chrominance, val_dc_chrominance);
254 add_huff_table(cinfo, &cinfo->ac_huff_tbl_ptrs[1],
255 bits_ac_chrominance, val_ac_chrominance);
260 * Default parameter setup for compression.
262 * Applications that don't choose to use this routine must do their
263 * own setup of all these parameters. Alternately, you can call this
264 * to establish defaults and then alter parameters selectively. This
265 * is the recommended approach since, if we add any new parameters,
266 * your code will still work (they'll be set to reasonable defaults).
270 jpeg_set_defaults (j_compress_ptr cinfo)
274 /* Safety check to ensure start_compress not called yet. */
275 if (cinfo->global_state != CSTATE_START)
276 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
278 /* Allocate comp_info array large enough for maximum component count.
279 * Array is made permanent in case application wants to compress
280 * multiple images at same param settings.
282 if (cinfo->comp_info == NULL)
283 cinfo->comp_info = (jpeg_component_info *)
284 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
285 MAX_COMPONENTS * SIZEOF(jpeg_component_info));
287 /* Initialize everything not dependent on the color space */
289 cinfo->data_precision = BITS_IN_JSAMPLE;
290 /* Set up two quantization tables using default quality of 75 */
291 jpeg_set_quality(cinfo, 75, TRUE);
292 /* Set up two Huffman tables */
293 std_huff_tables(cinfo);
295 /* Initialize default arithmetic coding conditioning */
296 for (i = 0; i < NUM_ARITH_TBLS; i++) {
297 cinfo->arith_dc_L[i] = 0;
298 cinfo->arith_dc_U[i] = 1;
299 cinfo->arith_ac_K[i] = 5;
302 /* Default is no multiple-scan output */
303 cinfo->scan_info = NULL;
304 cinfo->num_scans = 0;
306 /* Expect normal source image, not raw downsampled data */
307 cinfo->raw_data_in = FALSE;
309 /* Use Huffman coding, not arithmetic coding, by default */
310 cinfo->arith_code = FALSE;
312 /* By default, don't do extra passes to optimize entropy coding */
313 cinfo->optimize_coding = FALSE;
314 /* The standard Huffman tables are only valid for 8-bit data precision.
315 * If the precision is higher, force optimization on so that usable
316 * tables will be computed. This test can be removed if default tables
317 * are supplied that are valid for the desired precision.
319 if (cinfo->data_precision > 8)
320 cinfo->optimize_coding = TRUE;
322 /* By default, use the simpler non-cosited sampling alignment */
323 cinfo->CCIR601_sampling = FALSE;
325 /* No input smoothing */
326 cinfo->smoothing_factor = 0;
328 /* DCT algorithm preference */
329 cinfo->dct_method = JDCT_DEFAULT;
331 /* No restart markers */
332 cinfo->restart_interval = 0;
333 cinfo->restart_in_rows = 0;
335 /* Fill in default JFIF marker parameters. Note that whether the marker
336 * will actually be written is determined by jpeg_set_colorspace.
338 * By default, the library emits JFIF version code 1.01.
339 * An application that wants to emit JFIF 1.02 extension markers should set
340 * JFIF_minor_version to 2. We could probably get away with just defaulting
341 * to 1.02, but there may still be some decoders in use that will complain
342 * about that; saying 1.01 should minimize compatibility problems.
344 cinfo->JFIF_major_version = 1; /* Default JFIF version = 1.01 */
345 cinfo->JFIF_minor_version = 1;
346 cinfo->density_unit = 0; /* Pixel size is unknown by default */
347 cinfo->X_density = 1; /* Pixel aspect ratio is square by default */
348 cinfo->Y_density = 1;
350 /* Choose JPEG colorspace based on input space, set defaults accordingly */
352 jpeg_default_colorspace(cinfo);
357 * Select an appropriate JPEG colorspace for in_color_space.
361 jpeg_default_colorspace (j_compress_ptr cinfo)
363 switch (cinfo->in_color_space) {
365 jpeg_set_colorspace(cinfo, JCS_GRAYSCALE);
368 jpeg_set_colorspace(cinfo, JCS_YCbCr);
371 jpeg_set_colorspace(cinfo, JCS_YCbCr);
374 jpeg_set_colorspace(cinfo, JCS_CMYK); /* By default, no translation */
377 jpeg_set_colorspace(cinfo, JCS_YCCK);
380 jpeg_set_colorspace(cinfo, JCS_UNKNOWN);
383 ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
389 * Set the JPEG colorspace, and choose colorspace-dependent default values.
393 jpeg_set_colorspace (j_compress_ptr cinfo, J_COLOR_SPACE colorspace)
395 jpeg_component_info * compptr;
398 #define SET_COMP(index,id,hsamp,vsamp,quant,dctbl,actbl) \
399 (compptr = &cinfo->comp_info[index], \
400 compptr->component_id = (id), \
401 compptr->h_samp_factor = (hsamp), \
402 compptr->v_samp_factor = (vsamp), \
403 compptr->quant_tbl_no = (quant), \
404 compptr->dc_tbl_no = (dctbl), \
405 compptr->ac_tbl_no = (actbl) )
407 /* Safety check to ensure start_compress not called yet. */
408 if (cinfo->global_state != CSTATE_START)
409 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
411 /* For all colorspaces, we use Q and Huff tables 0 for luminance components,
412 * tables 1 for chrominance components.
415 cinfo->jpeg_color_space = colorspace;
417 cinfo->write_JFIF_header = FALSE; /* No marker for non-JFIF colorspaces */
418 cinfo->write_Adobe_marker = FALSE; /* write no Adobe marker by default */
420 switch (colorspace) {
422 cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */
423 cinfo->num_components = 1;
424 /* JFIF specifies component ID 1 */
425 SET_COMP(0, 1, 1,1, 0, 0,0);
428 cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag RGB */
429 cinfo->num_components = 3;
430 SET_COMP(0, 0x52 /* 'R' */, 1,1, 0, 0,0);
431 SET_COMP(1, 0x47 /* 'G' */, 1,1, 0, 0,0);
432 SET_COMP(2, 0x42 /* 'B' */, 1,1, 0, 0,0);
435 cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */
436 cinfo->num_components = 3;
437 /* JFIF specifies component IDs 1,2,3 */
438 /* We default to 2x2 subsamples of chrominance */
439 SET_COMP(0, 1, 2,2, 0, 0,0);
440 SET_COMP(1, 2, 1,1, 1, 1,1);
441 SET_COMP(2, 3, 1,1, 1, 1,1);
444 cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag CMYK */
445 cinfo->num_components = 4;
446 SET_COMP(0, 0x43 /* 'C' */, 1,1, 0, 0,0);
447 SET_COMP(1, 0x4D /* 'M' */, 1,1, 0, 0,0);
448 SET_COMP(2, 0x59 /* 'Y' */, 1,1, 0, 0,0);
449 SET_COMP(3, 0x4B /* 'K' */, 1,1, 0, 0,0);
452 cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag YCCK */
453 cinfo->num_components = 4;
454 SET_COMP(0, 1, 2,2, 0, 0,0);
455 SET_COMP(1, 2, 1,1, 1, 1,1);
456 SET_COMP(2, 3, 1,1, 1, 1,1);
457 SET_COMP(3, 4, 2,2, 0, 0,0);
460 cinfo->num_components = cinfo->input_components;
461 if (cinfo->num_components < 1 || cinfo->num_components > MAX_COMPONENTS)
462 ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components,
464 for (ci = 0; ci < cinfo->num_components; ci++) {
465 SET_COMP(ci, ci, 1,1, 0, 0,0);
469 ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
474 #ifdef C_PROGRESSIVE_SUPPORTED
476 LOCAL(jpeg_scan_info *)
477 fill_a_scan (jpeg_scan_info * scanptr, int ci,
478 int Ss, int Se, int Ah, int Al)
479 /* Support routine: generate one scan for specified component */
481 scanptr->comps_in_scan = 1;
482 scanptr->component_index[0] = ci;
491 LOCAL(jpeg_scan_info *)
492 fill_scans (jpeg_scan_info * scanptr, int ncomps,
493 int Ss, int Se, int Ah, int Al)
494 /* Support routine: generate one scan for each component */
498 for (ci = 0; ci < ncomps; ci++) {
499 scanptr->comps_in_scan = 1;
500 scanptr->component_index[0] = ci;
510 LOCAL(jpeg_scan_info *)
511 fill_dc_scans (jpeg_scan_info * scanptr, int ncomps, int Ah, int Al)
512 /* Support routine: generate interleaved DC scan if possible, else N scans */
516 if (ncomps <= MAX_COMPS_IN_SCAN) {
517 /* Single interleaved DC scan */
518 scanptr->comps_in_scan = ncomps;
519 for (ci = 0; ci < ncomps; ci++)
520 scanptr->component_index[ci] = ci;
521 scanptr->Ss = scanptr->Se = 0;
526 /* Noninterleaved DC scan for each component */
527 scanptr = fill_scans(scanptr, ncomps, 0, 0, Ah, Al);
534 * Create a recommended progressive-JPEG script.
535 * cinfo->num_components and cinfo->jpeg_color_space must be correct.
539 jpeg_simple_progression (j_compress_ptr cinfo)
541 int ncomps = cinfo->num_components;
543 jpeg_scan_info * scanptr;
545 /* Safety check to ensure start_compress not called yet. */
546 if (cinfo->global_state != CSTATE_START)
547 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
549 /* Figure space needed for script. Calculation must match code below! */
550 if (ncomps == 3 && cinfo->jpeg_color_space == JCS_YCbCr) {
551 /* Custom script for YCbCr color images. */
554 /* All-purpose script for other color spaces. */
555 if (ncomps > MAX_COMPS_IN_SCAN)
556 nscans = 6 * ncomps; /* 2 DC + 4 AC scans per component */
558 nscans = 2 + 4 * ncomps; /* 2 DC scans; 4 AC scans per component */
561 /* Allocate space for script.
562 * We need to put it in the permanent pool in case the application performs
563 * multiple compressions without changing the settings. To avoid a memory
564 * leak if jpeg_simple_progression is called repeatedly for the same JPEG
565 * object, we try to re-use previously allocated space, and we allocate
566 * enough space to handle YCbCr even if initially asked for grayscale.
568 if (cinfo->script_space == NULL || cinfo->script_space_size < nscans) {
569 cinfo->script_space_size = MAX(nscans, 10);
570 cinfo->script_space = (jpeg_scan_info *)
571 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
572 cinfo->script_space_size * SIZEOF(jpeg_scan_info));
574 scanptr = cinfo->script_space;
575 cinfo->scan_info = scanptr;
576 cinfo->num_scans = nscans;
578 if (ncomps == 3 && cinfo->jpeg_color_space == JCS_YCbCr) {
579 /* Custom script for YCbCr color images. */
580 /* Initial DC scan */
581 scanptr = fill_dc_scans(scanptr, ncomps, 0, 1);
582 /* Initial AC scan: get some luma data out in a hurry */
583 scanptr = fill_a_scan(scanptr, 0, 1, 5, 0, 2);
584 /* Chroma data is too small to be worth expending many scans on */
585 scanptr = fill_a_scan(scanptr, 2, 1, 63, 0, 1);
586 scanptr = fill_a_scan(scanptr, 1, 1, 63, 0, 1);
587 /* Complete spectral selection for luma AC */
588 scanptr = fill_a_scan(scanptr, 0, 6, 63, 0, 2);
589 /* Refine next bit of luma AC */
590 scanptr = fill_a_scan(scanptr, 0, 1, 63, 2, 1);
591 /* Finish DC successive approximation */
592 scanptr = fill_dc_scans(scanptr, ncomps, 1, 0);
593 /* Finish AC successive approximation */
594 scanptr = fill_a_scan(scanptr, 2, 1, 63, 1, 0);
595 scanptr = fill_a_scan(scanptr, 1, 1, 63, 1, 0);
596 /* Luma bottom bit comes last since it's usually largest scan */
597 scanptr = fill_a_scan(scanptr, 0, 1, 63, 1, 0);
599 /* All-purpose script for other color spaces. */
600 /* Successive approximation first pass */
601 scanptr = fill_dc_scans(scanptr, ncomps, 0, 1);
602 scanptr = fill_scans(scanptr, ncomps, 1, 5, 0, 2);
603 scanptr = fill_scans(scanptr, ncomps, 6, 63, 0, 2);
604 /* Successive approximation second pass */
605 scanptr = fill_scans(scanptr, ncomps, 1, 63, 2, 1);
606 /* Successive approximation final pass */
607 scanptr = fill_dc_scans(scanptr, ncomps, 1, 0);
608 scanptr = fill_scans(scanptr, ncomps, 1, 63, 1, 0);
612 #endif /* C_PROGRESSIVE_SUPPORTED */