jcparam.c
Go to the documentation of this file.
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 
22 GLOBAL(void)
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 
63 GLOBAL(void)
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,
100  jpeg_add_quant_table(cinfo, 1, std_chrominance_quant_tbl,
102 }
103 
104 
105 GLOBAL(int)
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 
131 GLOBAL(void)
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 */
141 
142  /* Set up standard quality tables */
144 }
145 
146 
147 /*
148  * Huffman table setup routines
149  */
150 
151 LOCAL(void)
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 
181 LOCAL(void)
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 
267 GLOBAL(void)
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,
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 
351 }
352 
353 
354 /*
355  * Select an appropriate JPEG colorspace for in_color_space.
356  */
357 
358 GLOBAL(void)
360 {
361  switch (cinfo->in_color_space) {
362  case JCS_GRAYSCALE:
364  break;
365  case JCS_RGB:
367  break;
368  case 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:
376  break;
377  case 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 
390 GLOBAL(void)
392 {
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,
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 
475 fill_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 
490 fill_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 
509 fill_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 
536 GLOBAL(void)
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 */
char int boolean force_baseline
Definition: cdjpeg.h:133
jpeg_default_colorspace(j_compress_ptr cinfo)
Definition: jcparam.c:359
#define BITS_IN_JSAMPLE
Definition: jmorecfg.h:23
#define MAX(a, b)
Returns the max value between a and b.
Definition: IceTypes.h:147
#define CSTATE_START
Definition: jpegint.h:25
#define NUM_QUANT_TBLS
Definition: jpeglib.h:43
#define FALSE
Definition: OPC_IceHook.h:9
char int scale_factor
Definition: cdjpeg.h:133
struct jpeg_common_struct * j_common_ptr
Definition: jpeglib.h:261
#define MAX_COMPONENTS
Definition: jmorecfg.h:35
#define JDCT_DEFAULT
Definition: jpeglib.h:224
#define ERREXIT(cinfo, code)
Definition: jerror.h:205
jpeg_alloc_huff_table(j_common_ptr cinfo)
Definition: jcomapi.c:98
#define TRUE
Definition: OPC_IceHook.h:13
#define SIZEOF(object)
Definition: jinclude.h:80
png_uint_32 i
Definition: png.h:2735
jpeg_component_info * compptr
Definition: jdct.h:102
fill_dc_scans(jpeg_scan_info *scanptr, int ncomps, int Ah, int Al)
Definition: jcparam.c:509
std_huff_tables(j_compress_ptr cinfo)
Definition: jcparam.c:182
fill_scans(jpeg_scan_info *scanptr, int ncomps, int Ss, int Se, int Ah, int Al)
Definition: jcparam.c:490
int const unsigned int * basic_table
Definition: jpeglib.h:924
jpeg_set_linear_quality(j_compress_ptr cinfo, int scale_factor, boolean force_baseline)
Definition: jcparam.c:64
#define MEMCOPY(dest, src, size)
Definition: jinclude.h:68
short UINT8
Definition: jmorecfg.h:140
#define DCTSIZE2
Definition: jpeglib.h:42
#define LOCAL(type)
Definition: jmorecfg.h:186
int which_tbl
Definition: jpeglib.h:924
int val
Definition: jpeglib.h:956
int quality
Definition: jpeglib.h:919
unsigned int UINT16
Definition: jmorecfg.h:149
jpeg_simple_progression(j_compress_ptr cinfo)
Definition: jcparam.c:537
#define ERREXIT1(cinfo, code, p1)
Definition: jerror.h:208
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:23
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:152
#define GLOBAL(type)
Definition: jmorecfg.h:188
jpeg_set_colorspace(j_compress_ptr cinfo, J_COLOR_SPACE colorspace)
Definition: jcparam.c:391
J_COLOR_SPACE colorspace
Definition: jpeglib.h:917
jpeg_set_defaults(j_compress_ptr cinfo)
Definition: jcparam.c:268
#define NUM_ARITH_TBLS
Definition: jpeglib.h:45
#define JPOOL_PERMANENT
Definition: jpeglib.h:748
#define const
Definition: zconf.h:124
fill_a_scan(jpeg_scan_info *scanptr, int ci, int Ss, int Se, int Ah, int Al)
Definition: jcparam.c:475
#define ERREXIT2(cinfo, code, p1, p2)
Definition: jerror.h:212
#define SET_COMP(index, id, hsamp, vsamp, quant, dctbl, actbl)
J_COLOR_SPACE
Definition: jpeglib.h:206
jpeg_quality_scaling(int quality)
Definition: jcparam.c:106
jpeg_set_quality(j_compress_ptr cinfo, int quality, boolean force_baseline)
Definition: jcparam.c:132
#define MAX_COMPS_IN_SCAN
Definition: jpeglib.h:46


openhrp3
Author(s): AIST, General Robotix Inc., Nakamura Lab of Dept. of Mechano Informatics at University of Tokyo
autogenerated on Sat May 8 2021 02:42:39