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