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)
jpeg_add_quant_table(j_compress_ptr cinfo,int which_tbl,const unsigned int * basic_table,int scale_factor,boolean force_baseline)24 jpeg_add_quant_table (j_compress_ptr cinfo, int which_tbl,
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)
jpeg_default_qtables(j_compress_ptr cinfo,boolean force_baseline)91 jpeg_default_qtables (j_compress_ptr cinfo, boolean force_baseline)
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 */
98   jpeg_add_quant_table(cinfo, 0, std_luminance_quant_tbl,
99 		       cinfo->q_scale_factor[0], force_baseline);
100   jpeg_add_quant_table(cinfo, 1, std_chrominance_quant_tbl,
101 		       cinfo->q_scale_factor[1], force_baseline);
102 }
103 
104 
105 GLOBAL(void)
jpeg_set_linear_quality(j_compress_ptr cinfo,int scale_factor,boolean force_baseline)106 jpeg_set_linear_quality (j_compress_ptr cinfo, int scale_factor,
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 */
115   jpeg_add_quant_table(cinfo, 0, std_luminance_quant_tbl,
116 		       scale_factor, force_baseline);
117   jpeg_add_quant_table(cinfo, 1, std_chrominance_quant_tbl,
118 		       scale_factor, force_baseline);
119 }
120 
121 
122 GLOBAL(int)
jpeg_quality_scaling(int quality)123 jpeg_quality_scaling (int quality)
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)
jpeg_set_quality(j_compress_ptr cinfo,int quality,boolean force_baseline)149 jpeg_set_quality (j_compress_ptr cinfo, int quality, boolean force_baseline)
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 */
157   quality = jpeg_quality_scaling(quality);
158 
159   /* Set up standard quality tables */
160   jpeg_set_linear_quality(cinfo, quality, force_baseline);
161 }
162 
163 
164 /*
165  * Huffman table setup routines
166  */
167 
168 LOCAL(void)
add_huff_table(j_compress_ptr cinfo,JHUFF_TBL ** htblptr,const UINT8 * bits,const UINT8 * val)169 add_huff_table (j_compress_ptr cinfo,
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)
std_huff_tables(j_compress_ptr cinfo)199 std_huff_tables (j_compress_ptr cinfo)
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)
jpeg_set_defaults(j_compress_ptr cinfo)285 jpeg_set_defaults (j_compress_ptr cinfo)
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,
300 				  MAX_COMPONENTS * SIZEOF(jpeg_component_info));
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 
377   jpeg_default_colorspace(cinfo);
378 }
379 
380 
381 /*
382  * Select an appropriate JPEG colorspace for in_color_space.
383  */
384 
385 GLOBAL(void)
jpeg_default_colorspace(j_compress_ptr cinfo)386 jpeg_default_colorspace (j_compress_ptr cinfo)
387 {
388   switch (cinfo->in_color_space) {
389   case JCS_UNKNOWN:
390     jpeg_set_colorspace(cinfo, JCS_UNKNOWN);
391     break;
392   case JCS_GRAYSCALE:
393     jpeg_set_colorspace(cinfo, JCS_GRAYSCALE);
394     break;
395   case JCS_RGB:
396     jpeg_set_colorspace(cinfo, JCS_YCbCr);
397     break;
398   case JCS_YCbCr:
399     jpeg_set_colorspace(cinfo, 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:
405     jpeg_set_colorspace(cinfo, JCS_YCCK);
406     break;
407   case JCS_BG_RGB:
408     /* No translation for now -- conversion to BG_YCC not yet supportet */
409     jpeg_set_colorspace(cinfo, JCS_BG_RGB);
410     break;
411   case JCS_BG_YCC:
412     jpeg_set_colorspace(cinfo, 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)
jpeg_set_colorspace(j_compress_ptr cinfo,J_COLOR_SPACE colorspace)425 jpeg_set_colorspace (j_compress_ptr cinfo, J_COLOR_SPACE colorspace)
426 {
427   jpeg_component_info * compptr;
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,
457 	       MAX_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 
535 LOCAL(jpeg_scan_info *)
fill_a_scan(jpeg_scan_info * scanptr,int ci,int Ss,int Se,int Ah,int Al)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 
550 LOCAL(jpeg_scan_info *)
fill_scans(jpeg_scan_info * scanptr,int ncomps,int Ss,int Se,int Ah,int Al)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 
569 LOCAL(jpeg_scan_info *)
fill_dc_scans(jpeg_scan_info * scanptr,int ncomps,int Ah,int Al)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)
jpeg_simple_progression(j_compress_ptr cinfo)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,
633 			cinfo->script_space_size * SIZEOF(jpeg_scan_info));
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 */
676