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
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
ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
174
MEMCOPY((*htblptr)->huffval, val, nsymbols * SIZEOF(UINT8));
176
/* Initialize sent_table FALSE so table will be written to JPEG file. */
177
(*htblptr)->sent_table = FALSE;
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! */
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 };
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 };
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,
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,
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);
258
* Default parameter setup for compression.
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).
268
jpeg_set_defaults (j_compress_ptr cinfo)
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);
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.
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));
285
/* Initialize everything not dependent on the color space */
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);
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;
300
/* Default is no multiple-scan output */
301
cinfo->scan_info = NULL;
302
cinfo->num_scans = 0;
304
/* Expect normal source image, not raw downsampled data */
305
cinfo->raw_data_in = FALSE;
307
/* Use Huffman coding, not arithmetic coding, by default */
308
cinfo->arith_code = FALSE;
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.
317
if (cinfo->data_precision > 8)
318
cinfo->optimize_coding = TRUE;
320
/* By default, use the simpler non-cosited sampling alignment */
321
cinfo->CCIR601_sampling = FALSE;
323
/* No input smoothing */
324
cinfo->smoothing_factor = 0;
326
/* DCT algorithm preference */
327
cinfo->dct_method = JDCT_DEFAULT;
329
/* No restart markers */
330
cinfo->restart_interval = 0;
331
cinfo->restart_in_rows = 0;
333
/* Fill in default JFIF marker parameters. Note that whether the marker
334
* will actually be written is determined by jpeg_set_colorspace.
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.
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;
348
/* Choose JPEG colorspace based on input space, set defaults accordingly */
350
jpeg_default_colorspace(cinfo);
355
* Select an appropriate JPEG colorspace for in_color_space.
359
jpeg_default_colorspace (j_compress_ptr cinfo)
361
switch (cinfo->in_color_space) {
363
jpeg_set_colorspace(cinfo, JCS_GRAYSCALE);
366
jpeg_set_colorspace(cinfo, JCS_YCbCr);
369
jpeg_set_colorspace(cinfo, JCS_YCbCr);
372
jpeg_set_colorspace(cinfo, JCS_CMYK); /* By default, no translation */
375
jpeg_set_colorspace(cinfo, JCS_YCCK);
378
jpeg_set_colorspace(cinfo, JCS_UNKNOWN);
381
ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
387
* Set the JPEG colorspace, and choose colorspace-dependent default values.
391
jpeg_set_colorspace (j_compress_ptr cinfo, J_COLOR_SPACE colorspace)
393
jpeg_component_info * compptr;
396
#define SET_COMP(index,id,hsamp,vsamp,quant,dctbl,actbl) \
397
(compptr = &cinfo->comp_info[index], \
398
compptr->component_id = (id), \
399
compptr->h_samp_factor = (hsamp), \
400
compptr->v_samp_factor = (vsamp), \
401
compptr->quant_tbl_no = (quant), \
402
compptr->dc_tbl_no = (dctbl), \
403
compptr->ac_tbl_no = (actbl) )
405
/* Safety check to ensure start_compress not called yet. */
406
if (cinfo->global_state != CSTATE_START)
407
ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
409
/* For all colorspaces, we use Q and Huff tables 0 for luminance components,
410
* tables 1 for chrominance components.
413
cinfo->jpeg_color_space = colorspace;
415
cinfo->write_JFIF_header = FALSE; /* No marker for non-JFIF colorspaces */
416
cinfo->write_Adobe_marker = FALSE; /* write no Adobe marker by default */
418
switch (colorspace) {
420
cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */
421
cinfo->num_components = 1;
422
/* JFIF specifies component ID 1 */
423
SET_COMP(0, 1, 1,1, 0, 0,0);
426
cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag RGB */
427
cinfo->num_components = 3;
428
SET_COMP(0, 0x52 /* 'R' */, 1,1, 0, 0,0);
429
SET_COMP(1, 0x47 /* 'G' */, 1,1, 0, 0,0);
430
SET_COMP(2, 0x42 /* 'B' */, 1,1, 0, 0,0);
433
cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */
434
cinfo->num_components = 3;
435
/* JFIF specifies component IDs 1,2,3 */
436
/* We default to 2x2 subsamples of chrominance */
437
SET_COMP(0, 1, 2,2, 0, 0,0);
438
SET_COMP(1, 2, 1,1, 1, 1,1);
439
SET_COMP(2, 3, 1,1, 1, 1,1);
442
cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag CMYK */
443
cinfo->num_components = 4;
444
SET_COMP(0, 0x43 /* 'C' */, 1,1, 0, 0,0);
445
SET_COMP(1, 0x4D /* 'M' */, 1,1, 0, 0,0);
446
SET_COMP(2, 0x59 /* 'Y' */, 1,1, 0, 0,0);
447
SET_COMP(3, 0x4B /* 'K' */, 1,1, 0, 0,0);
450
cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag YCCK */
451
cinfo->num_components = 4;
452
SET_COMP(0, 1, 2,2, 0, 0,0);
453
SET_COMP(1, 2, 1,1, 1, 1,1);
454
SET_COMP(2, 3, 1,1, 1, 1,1);
455
SET_COMP(3, 4, 2,2, 0, 0,0);
458
cinfo->num_components = cinfo->input_components;
459
if (cinfo->num_components < 1 || cinfo->num_components > MAX_COMPONENTS)
460
ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components,
462
for (ci = 0; ci < cinfo->num_components; ci++) {
463
SET_COMP(ci, ci, 1,1, 0, 0,0);
467
ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
472
#ifdef C_PROGRESSIVE_SUPPORTED
474
LOCAL(jpeg_scan_info *)
475
fill_a_scan (jpeg_scan_info * scanptr, int ci,
476
int Ss, int Se, int Ah, int Al)
477
/* Support routine: generate one scan for specified component */
479
scanptr->comps_in_scan = 1;
480
scanptr->component_index[0] = ci;
489
LOCAL(jpeg_scan_info *)
490
fill_scans (jpeg_scan_info * scanptr, int ncomps,
491
int Ss, int Se, int Ah, int Al)
492
/* Support routine: generate one scan for each component */
496
for (ci = 0; ci < ncomps; ci++) {
497
scanptr->comps_in_scan = 1;
498
scanptr->component_index[0] = ci;
508
LOCAL(jpeg_scan_info *)
509
fill_dc_scans (jpeg_scan_info * scanptr, int ncomps, int Ah, int Al)
510
/* Support routine: generate interleaved DC scan if possible, else N scans */
514
if (ncomps <= MAX_COMPS_IN_SCAN) {
515
/* Single interleaved DC scan */
516
scanptr->comps_in_scan = ncomps;
517
for (ci = 0; ci < ncomps; ci++)
518
scanptr->component_index[ci] = ci;
519
scanptr->Ss = scanptr->Se = 0;
524
/* Noninterleaved DC scan for each component */
525
scanptr = fill_scans(scanptr, ncomps, 0, 0, Ah, Al);
532
* Create a recommended progressive-JPEG script.
533
* cinfo->num_components and cinfo->jpeg_color_space must be correct.
537
jpeg_simple_progression (j_compress_ptr cinfo)
539
int ncomps = cinfo->num_components;
541
jpeg_scan_info * scanptr;
543
/* Safety check to ensure start_compress not called yet. */
544
if (cinfo->global_state != CSTATE_START)
545
ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
547
/* Figure space needed for script. Calculation must match code below! */
548
if (ncomps == 3 && cinfo->jpeg_color_space == JCS_YCbCr) {
549
/* Custom script for YCbCr color images. */
552
/* All-purpose script for other color spaces. */
553
if (ncomps > MAX_COMPS_IN_SCAN)
554
nscans = 6 * ncomps; /* 2 DC + 4 AC scans per component */
556
nscans = 2 + 4 * ncomps; /* 2 DC scans; 4 AC scans per component */
559
/* Allocate space for script.
560
* We need to put it in the permanent pool in case the application performs
561
* multiple compressions without changing the settings. To avoid a memory
562
* leak if jpeg_simple_progression is called repeatedly for the same JPEG
563
* object, we try to re-use previously allocated space, and we allocate
564
* enough space to handle YCbCr even if initially asked for grayscale.
566
if (cinfo->script_space == NULL || cinfo->script_space_size < nscans) {
567
cinfo->script_space_size = MAX(nscans, 10);
568
cinfo->script_space = (jpeg_scan_info *)
569
(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
570
cinfo->script_space_size * SIZEOF(jpeg_scan_info));
572
scanptr = cinfo->script_space;
573
cinfo->scan_info = scanptr;
574
cinfo->num_scans = nscans;
576
if (ncomps == 3 && cinfo->jpeg_color_space == JCS_YCbCr) {
577
/* Custom script for YCbCr color images. */
578
/* Initial DC scan */
579
scanptr = fill_dc_scans(scanptr, ncomps, 0, 1);
580
/* Initial AC scan: get some luma data out in a hurry */
581
scanptr = fill_a_scan(scanptr, 0, 1, 5, 0, 2);
582
/* Chroma data is too small to be worth expending many scans on */
583
scanptr = fill_a_scan(scanptr, 2, 1, 63, 0, 1);
584
scanptr = fill_a_scan(scanptr, 1, 1, 63, 0, 1);
585
/* Complete spectral selection for luma AC */
586
scanptr = fill_a_scan(scanptr, 0, 6, 63, 0, 2);
587
/* Refine next bit of luma AC */
588
scanptr = fill_a_scan(scanptr, 0, 1, 63, 2, 1);
589
/* Finish DC successive approximation */
590
scanptr = fill_dc_scans(scanptr, ncomps, 1, 0);
591
/* Finish AC successive approximation */
592
scanptr = fill_a_scan(scanptr, 2, 1, 63, 1, 0);
593
scanptr = fill_a_scan(scanptr, 1, 1, 63, 1, 0);
594
/* Luma bottom bit comes last since it's usually largest scan */
595
scanptr = fill_a_scan(scanptr, 0, 1, 63, 1, 0);
597
/* All-purpose script for other color spaces. */
598
/* Successive approximation first pass */
599
scanptr = fill_dc_scans(scanptr, ncomps, 0, 1);
600
scanptr = fill_scans(scanptr, ncomps, 1, 5, 0, 2);
601
scanptr = fill_scans(scanptr, ncomps, 6, 63, 0, 2);
602
/* Successive approximation second pass */
603
scanptr = fill_scans(scanptr, ncomps, 1, 63, 2, 1);
604
/* Successive approximation final pass */
605
scanptr = fill_dc_scans(scanptr, ncomps, 1, 0);
606
scanptr = fill_scans(scanptr, ncomps, 1, 63, 1, 0);
610
#endif /* C_PROGRESSIVE_SUPPORTED */