PageRenderTime 50ms CodeModel.GetById 3ms app.highlight 41ms RepoModel.GetById 1ms app.codeStats 0ms

/src/FreeImage/Source/LibJPEG/jcparam.c

https://bitbucket.org/cabalistic/ogredeps/
C | 632 lines | 392 code | 84 blank | 156 comment | 52 complexity | a58c56830b9ad17508109fe99f667533 MD5 | raw file
  1/*
  2 * jcparam.c
  3 *
  4 * Copyright (C) 1991-1998, Thomas G. Lane.
  5 * Modified 2003-2008 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
 23GLOBAL(void)
 24jpeg_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 */
 68static 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};
 78static 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
 90GLOBAL(void)
 91jpeg_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
105GLOBAL(void)
106jpeg_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
122GLOBAL(int)
123jpeg_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
148GLOBAL(void)
149jpeg_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 three 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
168LOCAL(void)
169add_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
198LOCAL(void)
199std_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
284GLOBAL(void)
285jpeg_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  /* Choose JPEG colorspace based on input space, set defaults accordingly */
371
372  jpeg_default_colorspace(cinfo);
373}
374
375
376/*
377 * Select an appropriate JPEG colorspace for in_color_space.
378 */
379
380GLOBAL(void)
381jpeg_default_colorspace (j_compress_ptr cinfo)
382{
383  switch (cinfo->in_color_space) {
384  case JCS_GRAYSCALE:
385    jpeg_set_colorspace(cinfo, JCS_GRAYSCALE);
386    break;
387  case JCS_RGB:
388    jpeg_set_colorspace(cinfo, JCS_YCbCr);
389    break;
390  case JCS_YCbCr:
391    jpeg_set_colorspace(cinfo, JCS_YCbCr);
392    break;
393  case JCS_CMYK:
394    jpeg_set_colorspace(cinfo, JCS_CMYK); /* By default, no translation */
395    break;
396  case JCS_YCCK:
397    jpeg_set_colorspace(cinfo, JCS_YCCK);
398    break;
399  case JCS_UNKNOWN:
400    jpeg_set_colorspace(cinfo, JCS_UNKNOWN);
401    break;
402  default:
403    ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
404  }
405}
406
407
408/*
409 * Set the JPEG colorspace, and choose colorspace-dependent default values.
410 */
411
412GLOBAL(void)
413jpeg_set_colorspace (j_compress_ptr cinfo, J_COLOR_SPACE colorspace)
414{
415  jpeg_component_info * compptr;
416  int ci;
417
418#define SET_COMP(index,id,hsamp,vsamp,quant,dctbl,actbl)  \
419  (compptr = &cinfo->comp_info[index], \
420   compptr->component_id = (id), \
421   compptr->h_samp_factor = (hsamp), \
422   compptr->v_samp_factor = (vsamp), \
423   compptr->quant_tbl_no = (quant), \
424   compptr->dc_tbl_no = (dctbl), \
425   compptr->ac_tbl_no = (actbl) )
426
427  /* Safety check to ensure start_compress not called yet. */
428  if (cinfo->global_state != CSTATE_START)
429    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
430
431  /* For all colorspaces, we use Q and Huff tables 0 for luminance components,
432   * tables 1 for chrominance components.
433   */
434
435  cinfo->jpeg_color_space = colorspace;
436
437  cinfo->write_JFIF_header = FALSE; /* No marker for non-JFIF colorspaces */
438  cinfo->write_Adobe_marker = FALSE; /* write no Adobe marker by default */
439
440  switch (colorspace) {
441  case JCS_GRAYSCALE:
442    cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */
443    cinfo->num_components = 1;
444    /* JFIF specifies component ID 1 */
445    SET_COMP(0, 1, 1,1, 0, 0,0);
446    break;
447  case JCS_RGB:
448    cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag RGB */
449    cinfo->num_components = 3;
450    SET_COMP(0, 0x52 /* 'R' */, 1,1, 0, 0,0);
451    SET_COMP(1, 0x47 /* 'G' */, 1,1, 0, 0,0);
452    SET_COMP(2, 0x42 /* 'B' */, 1,1, 0, 0,0);
453    break;
454  case JCS_YCbCr:
455    cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */
456    cinfo->num_components = 3;
457    /* JFIF specifies component IDs 1,2,3 */
458    /* We default to 2x2 subsamples of chrominance */
459    SET_COMP(0, 1, 2,2, 0, 0,0);
460    SET_COMP(1, 2, 1,1, 1, 1,1);
461    SET_COMP(2, 3, 1,1, 1, 1,1);
462    break;
463  case JCS_CMYK:
464    cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag CMYK */
465    cinfo->num_components = 4;
466    SET_COMP(0, 0x43 /* 'C' */, 1,1, 0, 0,0);
467    SET_COMP(1, 0x4D /* 'M' */, 1,1, 0, 0,0);
468    SET_COMP(2, 0x59 /* 'Y' */, 1,1, 0, 0,0);
469    SET_COMP(3, 0x4B /* 'K' */, 1,1, 0, 0,0);
470    break;
471  case JCS_YCCK:
472    cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag YCCK */
473    cinfo->num_components = 4;
474    SET_COMP(0, 1, 2,2, 0, 0,0);
475    SET_COMP(1, 2, 1,1, 1, 1,1);
476    SET_COMP(2, 3, 1,1, 1, 1,1);
477    SET_COMP(3, 4, 2,2, 0, 0,0);
478    break;
479  case JCS_UNKNOWN:
480    cinfo->num_components = cinfo->input_components;
481    if (cinfo->num_components < 1 || cinfo->num_components > MAX_COMPONENTS)
482      ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components,
483	       MAX_COMPONENTS);
484    for (ci = 0; ci < cinfo->num_components; ci++) {
485      SET_COMP(ci, ci, 1,1, 0, 0,0);
486    }
487    break;
488  default:
489    ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
490  }
491}
492
493
494#ifdef C_PROGRESSIVE_SUPPORTED
495
496LOCAL(jpeg_scan_info *)
497fill_a_scan (jpeg_scan_info * scanptr, int ci,
498	     int Ss, int Se, int Ah, int Al)
499/* Support routine: generate one scan for specified component */
500{
501  scanptr->comps_in_scan = 1;
502  scanptr->component_index[0] = ci;
503  scanptr->Ss = Ss;
504  scanptr->Se = Se;
505  scanptr->Ah = Ah;
506  scanptr->Al = Al;
507  scanptr++;
508  return scanptr;
509}
510
511LOCAL(jpeg_scan_info *)
512fill_scans (jpeg_scan_info * scanptr, int ncomps,
513	    int Ss, int Se, int Ah, int Al)
514/* Support routine: generate one scan for each component */
515{
516  int ci;
517
518  for (ci = 0; ci < ncomps; ci++) {
519    scanptr->comps_in_scan = 1;
520    scanptr->component_index[0] = ci;
521    scanptr->Ss = Ss;
522    scanptr->Se = Se;
523    scanptr->Ah = Ah;
524    scanptr->Al = Al;
525    scanptr++;
526  }
527  return scanptr;
528}
529
530LOCAL(jpeg_scan_info *)
531fill_dc_scans (jpeg_scan_info * scanptr, int ncomps, int Ah, int Al)
532/* Support routine: generate interleaved DC scan if possible, else N scans */
533{
534  int ci;
535
536  if (ncomps <= MAX_COMPS_IN_SCAN) {
537    /* Single interleaved DC scan */
538    scanptr->comps_in_scan = ncomps;
539    for (ci = 0; ci < ncomps; ci++)
540      scanptr->component_index[ci] = ci;
541    scanptr->Ss = scanptr->Se = 0;
542    scanptr->Ah = Ah;
543    scanptr->Al = Al;
544    scanptr++;
545  } else {
546    /* Noninterleaved DC scan for each component */
547    scanptr = fill_scans(scanptr, ncomps, 0, 0, Ah, Al);
548  }
549  return scanptr;
550}
551
552
553/*
554 * Create a recommended progressive-JPEG script.
555 * cinfo->num_components and cinfo->jpeg_color_space must be correct.
556 */
557
558GLOBAL(void)
559jpeg_simple_progression (j_compress_ptr cinfo)
560{
561  int ncomps = cinfo->num_components;
562  int nscans;
563  jpeg_scan_info * scanptr;
564
565  /* Safety check to ensure start_compress not called yet. */
566  if (cinfo->global_state != CSTATE_START)
567    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
568
569  /* Figure space needed for script.  Calculation must match code below! */
570  if (ncomps == 3 && cinfo->jpeg_color_space == JCS_YCbCr) {
571    /* Custom script for YCbCr color images. */
572    nscans = 10;
573  } else {
574    /* All-purpose script for other color spaces. */
575    if (ncomps > MAX_COMPS_IN_SCAN)
576      nscans = 6 * ncomps;	/* 2 DC + 4 AC scans per component */
577    else
578      nscans = 2 + 4 * ncomps;	/* 2 DC scans; 4 AC scans per component */
579  }
580
581  /* Allocate space for script.
582   * We need to put it in the permanent pool in case the application performs
583   * multiple compressions without changing the settings.  To avoid a memory
584   * leak if jpeg_simple_progression is called repeatedly for the same JPEG
585   * object, we try to re-use previously allocated space, and we allocate
586   * enough space to handle YCbCr even if initially asked for grayscale.
587   */
588  if (cinfo->script_space == NULL || cinfo->script_space_size < nscans) {
589    cinfo->script_space_size = MAX(nscans, 10);
590    cinfo->script_space = (jpeg_scan_info *)
591      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
592			cinfo->script_space_size * SIZEOF(jpeg_scan_info));
593  }
594  scanptr = cinfo->script_space;
595  cinfo->scan_info = scanptr;
596  cinfo->num_scans = nscans;
597
598  if (ncomps == 3 && cinfo->jpeg_color_space == JCS_YCbCr) {
599    /* Custom script for YCbCr color images. */
600    /* Initial DC scan */
601    scanptr = fill_dc_scans(scanptr, ncomps, 0, 1);
602    /* Initial AC scan: get some luma data out in a hurry */
603    scanptr = fill_a_scan(scanptr, 0, 1, 5, 0, 2);
604    /* Chroma data is too small to be worth expending many scans on */
605    scanptr = fill_a_scan(scanptr, 2, 1, 63, 0, 1);
606    scanptr = fill_a_scan(scanptr, 1, 1, 63, 0, 1);
607    /* Complete spectral selection for luma AC */
608    scanptr = fill_a_scan(scanptr, 0, 6, 63, 0, 2);
609    /* Refine next bit of luma AC */
610    scanptr = fill_a_scan(scanptr, 0, 1, 63, 2, 1);
611    /* Finish DC successive approximation */
612    scanptr = fill_dc_scans(scanptr, ncomps, 1, 0);
613    /* Finish AC successive approximation */
614    scanptr = fill_a_scan(scanptr, 2, 1, 63, 1, 0);
615    scanptr = fill_a_scan(scanptr, 1, 1, 63, 1, 0);
616    /* Luma bottom bit comes last since it's usually largest scan */
617    scanptr = fill_a_scan(scanptr, 0, 1, 63, 1, 0);
618  } else {
619    /* All-purpose script for other color spaces. */
620    /* Successive approximation first pass */
621    scanptr = fill_dc_scans(scanptr, ncomps, 0, 1);
622    scanptr = fill_scans(scanptr, ncomps, 1, 5, 0, 2);
623    scanptr = fill_scans(scanptr, ncomps, 6, 63, 0, 2);
624    /* Successive approximation second pass */
625    scanptr = fill_scans(scanptr, ncomps, 1, 63, 2, 1);
626    /* Successive approximation final pass */
627    scanptr = fill_dc_scans(scanptr, ncomps, 1, 0);
628    scanptr = fill_scans(scanptr, ncomps, 1, 63, 1, 0);
629  }
630}
631
632#endif /* C_PROGRESSIVE_SUPPORTED */