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


Page generated by Doxygen 1.8.14 for MRPT 1.9.9 Git: ae4571287 Thu Nov 23 00:06:53 2017 +0100 at dom oct 27 23:51:55 CET 2019