source: golgotha/src/i4/loaders/jpg/jcparam.cc @ 80

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