neo/renderer/jpeg-6/jcparam.c

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