src/jpeg/libijg12/jcparam12.c

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