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