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