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