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