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



Page generated by Doxygen 1.8.6 for MRPT 1.5.6 Git: 4c65e84 Tue Apr 24 08:18:17 2018 +0200 at mar abr 24 08:26:17 CEST 2018