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