ReactOS  0.4.14-dev-833-g5f692ed
jcparam.c
Go to the documentation of this file.
1 /*
2  * jcparam.c
3  *
4  * Copyright (C) 1991-1998, Thomas G. Lane.
5  * Modified 2003-2013 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 
23 GLOBAL(void)
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  */
68 static 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 };
78 static 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 
90 GLOBAL(void)
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 */
99  cinfo->q_scale_factor[0], force_baseline);
101  cinfo->q_scale_factor[1], force_baseline);
102 }
103 
104 
105 GLOBAL(void)
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 */
119 }
120 
121 
122 GLOBAL(int)
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 
148 GLOBAL(void)
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 routines directly.
154  */
155 {
156  /* Convert user 0-100 rating to percentage scaling */
158 
159  /* Set up standard quality tables */
161 }
162 
163 
164 /*
165  * Huffman table setup routines
166  */
167 
168 LOCAL(void)
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 
198 LOCAL(void)
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 
284 GLOBAL(void)
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,
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  /* The standard Huffman tables are only valid for 8-bit data precision.
327  * If the precision is higher, use arithmetic coding.
328  * (Alternatively, using Huffman coding would be possible with forcing
329  * optimization on so that usable tables will be computed, or by
330  * supplying default tables that are valid for the desired precision.)
331  * Otherwise, use Huffman coding by default.
332  */
333  cinfo->arith_code = cinfo->data_precision > 8 ? TRUE : FALSE;
334 
335  /* By default, don't do extra passes to optimize entropy coding */
336  cinfo->optimize_coding = FALSE;
337 
338  /* By default, use the simpler non-cosited sampling alignment */
339  cinfo->CCIR601_sampling = FALSE;
340 
341  /* By default, apply fancy downsampling */
342  cinfo->do_fancy_downsampling = TRUE;
343 
344  /* No input smoothing */
345  cinfo->smoothing_factor = 0;
346 
347  /* DCT algorithm preference */
348  cinfo->dct_method = JDCT_DEFAULT;
349 
350  /* No restart markers */
351  cinfo->restart_interval = 0;
352  cinfo->restart_in_rows = 0;
353 
354  /* Fill in default JFIF marker parameters. Note that whether the marker
355  * will actually be written is determined by jpeg_set_colorspace.
356  *
357  * By default, the library emits JFIF version code 1.01.
358  * An application that wants to emit JFIF 1.02 extension markers should set
359  * JFIF_minor_version to 2. We could probably get away with just defaulting
360  * to 1.02, but there may still be some decoders in use that will complain
361  * about that; saying 1.01 should minimize compatibility problems.
362  *
363  * For wide gamut colorspaces (BG_RGB and BG_YCC), the major version will be
364  * overridden by jpeg_set_colorspace and set to 2.
365  */
366  cinfo->JFIF_major_version = 1; /* Default JFIF version = 1.01 */
367  cinfo->JFIF_minor_version = 1;
368  cinfo->density_unit = 0; /* Pixel size is unknown by default */
369  cinfo->X_density = 1; /* Pixel aspect ratio is square by default */
370  cinfo->Y_density = 1;
371 
372  /* No color transform */
373  cinfo->color_transform = JCT_NONE;
374 
375  /* Choose JPEG colorspace based on input space, set defaults accordingly */
376 
378 }
379 
380 
381 /*
382  * Select an appropriate JPEG colorspace for in_color_space.
383  */
384 
385 GLOBAL(void)
387 {
388  switch (cinfo->in_color_space) {
389  case JCS_UNKNOWN:
391  break;
392  case JCS_GRAYSCALE:
394  break;
395  case JCS_RGB:
397  break;
398  case JCS_YCbCr:
400  break;
401  case JCS_CMYK:
402  jpeg_set_colorspace(cinfo, JCS_CMYK); /* By default, no translation */
403  break;
404  case JCS_YCCK:
406  break;
407  case JCS_BG_RGB:
408  /* No translation for now -- conversion to BG_YCC not yet supportet */
410  break;
411  case JCS_BG_YCC:
413  break;
414  default:
415  ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
416  }
417 }
418 
419 
420 /*
421  * Set the JPEG colorspace, and choose colorspace-dependent default values.
422  */
423 
424 GLOBAL(void)
426 {
428  int ci;
429 
430 #define SET_COMP(index,id,hsamp,vsamp,quant,dctbl,actbl) \
431  (compptr = &cinfo->comp_info[index], \
432  compptr->component_id = (id), \
433  compptr->h_samp_factor = (hsamp), \
434  compptr->v_samp_factor = (vsamp), \
435  compptr->quant_tbl_no = (quant), \
436  compptr->dc_tbl_no = (dctbl), \
437  compptr->ac_tbl_no = (actbl) )
438 
439  /* Safety check to ensure start_compress not called yet. */
440  if (cinfo->global_state != CSTATE_START)
441  ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
442 
443  /* For all colorspaces, we use Q and Huff tables 0 for luminance components,
444  * tables 1 for chrominance components.
445  */
446 
447  cinfo->jpeg_color_space = colorspace;
448 
449  cinfo->write_JFIF_header = FALSE; /* No marker for non-JFIF colorspaces */
450  cinfo->write_Adobe_marker = FALSE; /* write no Adobe marker by default */
451 
452  switch (colorspace) {
453  case JCS_UNKNOWN:
454  cinfo->num_components = cinfo->input_components;
455  if (cinfo->num_components < 1 || cinfo->num_components > MAX_COMPONENTS)
456  ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components,
458  for (ci = 0; ci < cinfo->num_components; ci++) {
459  SET_COMP(ci, ci, 1,1, 0, 0,0);
460  }
461  break;
462  case JCS_GRAYSCALE:
463  cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */
464  cinfo->num_components = 1;
465  /* JFIF specifies component ID 1 */
466  SET_COMP(0, 0x01, 1,1, 0, 0,0);
467  break;
468  case JCS_RGB:
469  cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag RGB */
470  cinfo->num_components = 3;
471  SET_COMP(0, 0x52 /* 'R' */, 1,1, 0,
472  cinfo->color_transform == JCT_SUBTRACT_GREEN ? 1 : 0,
473  cinfo->color_transform == JCT_SUBTRACT_GREEN ? 1 : 0);
474  SET_COMP(1, 0x47 /* 'G' */, 1,1, 0, 0,0);
475  SET_COMP(2, 0x42 /* 'B' */, 1,1, 0,
476  cinfo->color_transform == JCT_SUBTRACT_GREEN ? 1 : 0,
477  cinfo->color_transform == JCT_SUBTRACT_GREEN ? 1 : 0);
478  break;
479  case JCS_YCbCr:
480  cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */
481  cinfo->num_components = 3;
482  /* JFIF specifies component IDs 1,2,3 */
483  /* We default to 2x2 subsamples of chrominance */
484  SET_COMP(0, 0x01, 2,2, 0, 0,0);
485  SET_COMP(1, 0x02, 1,1, 1, 1,1);
486  SET_COMP(2, 0x03, 1,1, 1, 1,1);
487  break;
488  case JCS_CMYK:
489  cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag CMYK */
490  cinfo->num_components = 4;
491  SET_COMP(0, 0x43 /* 'C' */, 1,1, 0, 0,0);
492  SET_COMP(1, 0x4D /* 'M' */, 1,1, 0, 0,0);
493  SET_COMP(2, 0x59 /* 'Y' */, 1,1, 0, 0,0);
494  SET_COMP(3, 0x4B /* 'K' */, 1,1, 0, 0,0);
495  break;
496  case JCS_YCCK:
497  cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag YCCK */
498  cinfo->num_components = 4;
499  SET_COMP(0, 0x01, 2,2, 0, 0,0);
500  SET_COMP(1, 0x02, 1,1, 1, 1,1);
501  SET_COMP(2, 0x03, 1,1, 1, 1,1);
502  SET_COMP(3, 0x04, 2,2, 0, 0,0);
503  break;
504  case JCS_BG_RGB:
505  cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */
506  cinfo->JFIF_major_version = 2; /* Set JFIF major version = 2 */
507  cinfo->num_components = 3;
508  /* Add offset 0x20 to the normal R/G/B component IDs */
509  SET_COMP(0, 0x72 /* 'r' */, 1,1, 0,
510  cinfo->color_transform == JCT_SUBTRACT_GREEN ? 1 : 0,
511  cinfo->color_transform == JCT_SUBTRACT_GREEN ? 1 : 0);
512  SET_COMP(1, 0x67 /* 'g' */, 1,1, 0, 0,0);
513  SET_COMP(2, 0x62 /* 'b' */, 1,1, 0,
514  cinfo->color_transform == JCT_SUBTRACT_GREEN ? 1 : 0,
515  cinfo->color_transform == JCT_SUBTRACT_GREEN ? 1 : 0);
516  break;
517  case JCS_BG_YCC:
518  cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */
519  cinfo->JFIF_major_version = 2; /* Set JFIF major version = 2 */
520  cinfo->num_components = 3;
521  /* Add offset 0x20 to the normal Cb/Cr component IDs */
522  /* We default to 2x2 subsamples of chrominance */
523  SET_COMP(0, 0x01, 2,2, 0, 0,0);
524  SET_COMP(1, 0x22, 1,1, 1, 1,1);
525  SET_COMP(2, 0x23, 1,1, 1, 1,1);
526  break;
527  default:
528  ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
529  }
530 }
531 
532 
533 #ifdef C_PROGRESSIVE_SUPPORTED
534 
536 fill_a_scan (jpeg_scan_info * scanptr, int ci,
537  int Ss, int Se, int Ah, int Al)
538 /* Support routine: generate one scan for specified component */
539 {
540  scanptr->comps_in_scan = 1;
541  scanptr->component_index[0] = ci;
542  scanptr->Ss = Ss;
543  scanptr->Se = Se;
544  scanptr->Ah = Ah;
545  scanptr->Al = Al;
546  scanptr++;
547  return scanptr;
548 }
549 
551 fill_scans (jpeg_scan_info * scanptr, int ncomps,
552  int Ss, int Se, int Ah, int Al)
553 /* Support routine: generate one scan for each component */
554 {
555  int ci;
556 
557  for (ci = 0; ci < ncomps; ci++) {
558  scanptr->comps_in_scan = 1;
559  scanptr->component_index[0] = ci;
560  scanptr->Ss = Ss;
561  scanptr->Se = Se;
562  scanptr->Ah = Ah;
563  scanptr->Al = Al;
564  scanptr++;
565  }
566  return scanptr;
567 }
568 
570 fill_dc_scans (jpeg_scan_info * scanptr, int ncomps, int Ah, int Al)
571 /* Support routine: generate interleaved DC scan if possible, else N scans */
572 {
573  int ci;
574 
575  if (ncomps <= MAX_COMPS_IN_SCAN) {
576  /* Single interleaved DC scan */
577  scanptr->comps_in_scan = ncomps;
578  for (ci = 0; ci < ncomps; ci++)
579  scanptr->component_index[ci] = ci;
580  scanptr->Ss = scanptr->Se = 0;
581  scanptr->Ah = Ah;
582  scanptr->Al = Al;
583  scanptr++;
584  } else {
585  /* Noninterleaved DC scan for each component */
586  scanptr = fill_scans(scanptr, ncomps, 0, 0, Ah, Al);
587  }
588  return scanptr;
589 }
590 
591 
592 /*
593  * Create a recommended progressive-JPEG script.
594  * cinfo->num_components and cinfo->jpeg_color_space must be correct.
595  */
596 
597 GLOBAL(void)
598 jpeg_simple_progression (j_compress_ptr cinfo)
599 {
600  int ncomps = cinfo->num_components;
601  int nscans;
602  jpeg_scan_info * scanptr;
603 
604  /* Safety check to ensure start_compress not called yet. */
605  if (cinfo->global_state != CSTATE_START)
606  ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
607 
608  /* Figure space needed for script. Calculation must match code below! */
609  if (ncomps == 3 &&
610  (cinfo->jpeg_color_space == JCS_YCbCr ||
611  cinfo->jpeg_color_space == JCS_BG_YCC)) {
612  /* Custom script for YCC color images. */
613  nscans = 10;
614  } else {
615  /* All-purpose script for other color spaces. */
616  if (ncomps > MAX_COMPS_IN_SCAN)
617  nscans = 6 * ncomps; /* 2 DC + 4 AC scans per component */
618  else
619  nscans = 2 + 4 * ncomps; /* 2 DC scans; 4 AC scans per component */
620  }
621 
622  /* Allocate space for script.
623  * We need to put it in the permanent pool in case the application performs
624  * multiple compressions without changing the settings. To avoid a memory
625  * leak if jpeg_simple_progression is called repeatedly for the same JPEG
626  * object, we try to re-use previously allocated space, and we allocate
627  * enough space to handle YCC even if initially asked for grayscale.
628  */
629  if (cinfo->script_space == NULL || cinfo->script_space_size < nscans) {
630  cinfo->script_space_size = MAX(nscans, 10);
631  cinfo->script_space = (jpeg_scan_info *)
632  (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
634  }
635  scanptr = cinfo->script_space;
636  cinfo->scan_info = scanptr;
637  cinfo->num_scans = nscans;
638 
639  if (ncomps == 3 &&
640  (cinfo->jpeg_color_space == JCS_YCbCr ||
641  cinfo->jpeg_color_space == JCS_BG_YCC)) {
642  /* Custom script for YCC color images. */
643  /* Initial DC scan */
644  scanptr = fill_dc_scans(scanptr, ncomps, 0, 1);
645  /* Initial AC scan: get some luma data out in a hurry */
646  scanptr = fill_a_scan(scanptr, 0, 1, 5, 0, 2);
647  /* Chroma data is too small to be worth expending many scans on */
648  scanptr = fill_a_scan(scanptr, 2, 1, 63, 0, 1);
649  scanptr = fill_a_scan(scanptr, 1, 1, 63, 0, 1);
650  /* Complete spectral selection for luma AC */
651  scanptr = fill_a_scan(scanptr, 0, 6, 63, 0, 2);
652  /* Refine next bit of luma AC */
653  scanptr = fill_a_scan(scanptr, 0, 1, 63, 2, 1);
654  /* Finish DC successive approximation */
655  scanptr = fill_dc_scans(scanptr, ncomps, 1, 0);
656  /* Finish AC successive approximation */
657  scanptr = fill_a_scan(scanptr, 2, 1, 63, 1, 0);
658  scanptr = fill_a_scan(scanptr, 1, 1, 63, 1, 0);
659  /* Luma bottom bit comes last since it's usually largest scan */
660  scanptr = fill_a_scan(scanptr, 0, 1, 63, 1, 0);
661  } else {
662  /* All-purpose script for other color spaces. */
663  /* Successive approximation first pass */
664  scanptr = fill_dc_scans(scanptr, ncomps, 0, 1);
665  scanptr = fill_scans(scanptr, ncomps, 1, 5, 0, 2);
666  scanptr = fill_scans(scanptr, ncomps, 6, 63, 0, 2);
667  /* Successive approximation second pass */
668  scanptr = fill_scans(scanptr, ncomps, 1, 63, 2, 1);
669  /* Successive approximation final pass */
670  scanptr = fill_dc_scans(scanptr, ncomps, 1, 0);
671  scanptr = fill_scans(scanptr, ncomps, 1, 63, 1, 0);
672  }
673 }
674 
675 #endif /* C_PROGRESSIVE_SUPPORTED */
char boolean force_baseline
Definition: cdjpeg.h:134
jpeg_default_colorspace(j_compress_ptr cinfo)
Definition: jcparam.c:386
#define BITS_IN_JSAMPLE
Definition: jmorecfg.h:33
#define TRUE
Definition: types.h:120
#define CSTATE_START
Definition: jpegint.h:26
#define ERREXIT(msg)
Definition: rdjpgcom.c:72
#define NUM_QUANT_TBLS
Definition: jpeglib.h:52
J_COLOR_SPACE jpeg_color_space
Definition: jpeglib.h:331
struct jpeg_common_struct * j_common_ptr
Definition: jpeglib.h:284
const jpeg_scan_info * scan_info
Definition: jpeglib.h:351
#define MAX_COMPONENTS
Definition: jmorecfg.h:45
#define JDCT_DEFAULT
Definition: jpeglib.h:247
jpeg_alloc_huff_table(j_common_ptr cinfo)
Definition: jcomapi.c:98
GLenum GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * bits
Definition: glext.h:10929
int comps_in_scan
Definition: jpeglib.h:199
jpeg_default_qtables(j_compress_ptr cinfo, boolean force_baseline)
Definition: jcparam.c:91
jpeg_component_info * compptr
Definition: jdct.h:238
int component_index[MAX_COMPS_IN_SCAN]
Definition: jpeglib.h:200
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define SIZEOF(_ar)
Definition: calc.h:97
std_huff_tables(j_compress_ptr cinfo)
Definition: jcparam.c:199
int const unsigned int * basic_table
Definition: jpeglib.h:998
jpeg_set_linear_quality(j_compress_ptr cinfo, int scale_factor, boolean force_baseline)
Definition: jcparam.c:106
smooth NULL
Definition: ftsmooth.c:416
#define MEMCOPY(dest, src, size)
Definition: jinclude.h:69
#define DCTSIZE2
Definition: jpeglib.h:51
#define LOCAL(type)
Definition: jmorecfg.h:289
GLuint GLfloat * val
Definition: glext.h:7180
int which_tbl
Definition: jpeglib.h:998
int quality
Definition: jpeglib.h:991
static const WCHAR L[]
Definition: oid.c:1250
#define ERREXIT1(cinfo, code, p1)
Definition: jerror.h:212
GLenum GLsizei len
Definition: glext.h:6722
jpeg_add_quant_table(j_compress_ptr cinfo, int which_tbl, const unsigned int *basic_table, int scale_factor, boolean force_baseline)
Definition: jcparam.c:24
static const unsigned int std_chrominance_quant_tbl[DCTSIZE2]
Definition: jcparam.c:78
jpeg_alloc_quant_table(j_common_ptr cinfo)
Definition: jcomapi.c:86
add_huff_table(j_compress_ptr cinfo, JHUFF_TBL **htblptr, const UINT8 *bits, const UINT8 *val)
Definition: jcparam.c:169
T MAX(T a, T b)
Definition: polytest.cpp:85
#define GLOBAL(type)
Definition: jmorecfg.h:291
jpeg_set_colorspace(j_compress_ptr cinfo, J_COLOR_SPACE colorspace)
Definition: jcparam.c:425
static calc_node_t temp
Definition: rpn_ieee.c:38
J_COLOR_SPACE colorspace
Definition: jpeglib.h:989
#define long
Definition: qsort.c:33
unsigned short UINT16
jpeg_set_defaults(j_compress_ptr cinfo)
Definition: jcparam.c:285
#define NUM_ARITH_TBLS
Definition: jpeglib.h:54
#define JPOOL_PERMANENT
Definition: jpeglib.h:807
jpeg_scan_info * script_space
Definition: jpeglib.h:452
#define const
Definition: zconf.h:230
#define ERREXIT2(cinfo, code, p1, p2)
Definition: jerror.h:216
#define SET_COMP(index, id, hsamp, vsamp, quant, dctbl, actbl)
static const unsigned int std_luminance_quant_tbl[DCTSIZE2]
Definition: jcparam.c:68
J_COLOR_SPACE
Definition: jpeglib.h:220
jpeg_quality_scaling(int quality)
Definition: jcparam.c:123
unsigned char UINT8
jpeg_set_quality(j_compress_ptr cinfo, int quality, boolean force_baseline)
Definition: jcparam.c:149
int scale_factor
Definition: jpeglib.h:994
#define MAX_COMPS_IN_SCAN
Definition: jpeglib.h:55