QRScanner/mobile/jni/thirdparty/jpeg/jcparam.c

   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 */