PageRenderTime 74ms CodeModel.GetById 12ms app.highlight 56ms RepoModel.GetById 1ms app.codeStats 0ms

/media/libjpeg/jcparam.c

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