source: trunk/libjpeg/jcparam.c @ 15

Last change on this file since 15 was 15, checked in by Eugene Romanenko, 15 years ago

needed libs update

File size: 21.4 KB
Line 
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
22GLOBAL(void)
23jpeg_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
63GLOBAL(void)
64jpeg_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
105GLOBAL(int)
106jpeg_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
131GLOBAL(void)
132jpeg_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
151LOCAL(void)
152add_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
181LOCAL(void)
182std_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
267GLOBAL(void)
268jpeg_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
358GLOBAL(void)
359jpeg_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
390GLOBAL(void)
391jpeg_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
474LOCAL(jpeg_scan_info *)
475fill_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
489LOCAL(jpeg_scan_info *)
490fill_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
508LOCAL(jpeg_scan_info *)
509fill_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
536GLOBAL(void)
537jpeg_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 */
Note: See TracBrowser for help on using the repository browser.