Real-time collaboration for Jupyter Notebooks, Linux Terminals, LaTeX, VS Code, R IDE, and more,
all in one place.

1
/*
2
 * jcparam.c
3
 *
4
 * Copyright (C) 1991-1998, Thomas G. Lane.
5
 * This file is part of the Independent JPEG Group's software.
6
 * For conditions of distribution and use, see the accompanying README file.
7
 *
8
 * This file contains optional default-setting code for the JPEG compressor.
9
 * Applications do not have to use this file, but those that don't use it
10
 * must know a lot more about the innards of the JPEG code.
11
 */
12

13
#define JPEG_INTERNALS
14
#include "jinclude.h"
15
#include "jpeglib.h"
16

17

18
/*
19
 * Quantization table setup routines
20
 */
21

22
GLOBAL(void)
23
jpeg_add_quant_table (j_compress_ptr cinfo, int which_tbl,
24
		      const unsigned int *basic_table,
25
		      int scale_factor, boolean force_baseline)
26
/* Define a quantization table equal to the basic_table times
27
 * a scale factor (given as a percentage).
28
 * If force_baseline is TRUE, the computed quantization table entries
29
 * are limited to 1..255 for JPEG baseline compatibility.
30
 */
31
{
32
  JQUANT_TBL ** qtblptr;
33
  int i;
34
  long temp;
35

36
  /* Safety check to ensure start_compress not called yet. */
37
  if (cinfo->global_state != CSTATE_START)
38
    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
39

40
  if (which_tbl < 0 || which_tbl >= NUM_QUANT_TBLS)
41
    ERREXIT1(cinfo, JERR_DQT_INDEX, which_tbl);
42

43
  qtblptr = & cinfo->quant_tbl_ptrs[which_tbl];
44

45
  if (*qtblptr == NULL)
46
    *qtblptr = jpeg_alloc_quant_table((j_common_ptr) cinfo);
47

48
  for (i = 0; i < DCTSIZE2; i++) {
49
    temp = ((long) basic_table[i] * scale_factor + 50L) / 100L;
50
    /* limit the values to the valid range */
51
    if (temp <= 0L) temp = 1L;
52
    if (temp > 32767L) temp = 32767L; /* max quantizer needed for 12 bits */
53
    if (force_baseline && temp > 255L)
54
      temp = 255L;		/* limit to baseline range if requested */
55
    (*qtblptr)->quantval[i] = (UINT16) temp;
56
  }
57

58
  /* Initialize sent_table FALSE so table will be written to JPEG file. */
59
  (*qtblptr)->sent_table = FALSE;
60
}
61

62

63
GLOBAL(void)
64
jpeg_set_linear_quality (j_compress_ptr cinfo, int scale_factor,
65
			 boolean force_baseline)
66
/* Set or change the 'quality' (quantization) setting, using default tables
67
 * and a straight percentage-scaling quality scale.  In most cases it's better
68
 * to use jpeg_set_quality (below); this entry point is provided for
69
 * applications that insist on a linear percentage scaling.
70
 */
71
{
72
  /* These are the sample quantization tables given in JPEG spec section K.1.
73
   * The spec says that the values given produce "good" quality, and
74
   * when divided by 2, "very good" quality.
75
   */
76
  static const unsigned int std_luminance_quant_tbl[DCTSIZE2] = {
77
    16,  11,  10,  16,  24,  40,  51,  61,
78
    12,  12,  14,  19,  26,  58,  60,  55,
79
    14,  13,  16,  24,  40,  57,  69,  56,
80
    14,  17,  22,  29,  51,  87,  80,  62,
81
    18,  22,  37,  56,  68, 109, 103,  77,
82
    24,  35,  55,  64,  81, 104, 113,  92,
83
    49,  64,  78,  87, 103, 121, 120, 101,
84
    72,  92,  95,  98, 112, 100, 103,  99
85
  };
86
  static const unsigned int std_chrominance_quant_tbl[DCTSIZE2] = {
87
    17,  18,  24,  47,  99,  99,  99,  99,
88
    18,  21,  26,  66,  99,  99,  99,  99,
89
    24,  26,  56,  99,  99,  99,  99,  99,
90
    47,  66,  99,  99,  99,  99,  99,  99,
91
    99,  99,  99,  99,  99,  99,  99,  99,
92
    99,  99,  99,  99,  99,  99,  99,  99,
93
    99,  99,  99,  99,  99,  99,  99,  99,
94
    99,  99,  99,  99,  99,  99,  99,  99
95
  };
96

97
  /* Set up two quantization tables using the specified scaling */
98
  jpeg_add_quant_table(cinfo, 0, std_luminance_quant_tbl,
99
		       scale_factor, force_baseline);
100
  jpeg_add_quant_table(cinfo, 1, std_chrominance_quant_tbl,
101
		       scale_factor, force_baseline);
102
}
103

104

105
GLOBAL(int)
106
jpeg_quality_scaling (int quality)
107
/* Convert a user-specified quality rating to a percentage scaling factor
108
 * for an underlying quantization table, using our recommended scaling curve.
109
 * The input 'quality' factor should be 0 (terrible) to 100 (very good).
110
 */
111
{
112
  /* Safety limit on quality factor.  Convert 0 to 1 to avoid zero divide. */
113
  if (quality <= 0) quality = 1;
114
  if (quality > 100) quality = 100;
115

116
  /* The basic table is used as-is (scaling 100) for a quality of 50.
117
   * Qualities 50..100 are converted to scaling percentage 200 - 2*Q;
118
   * note that at Q=100 the scaling is 0, which will cause jpeg_add_quant_table
119
   * to make all the table entries 1 (hence, minimum quantization loss).
120
   * Qualities 1..50 are converted to scaling percentage 5000/Q.
121
   */
122
  if (quality < 50)
123
    quality = 5000 / quality;
124
  else
125
    quality = 200 - quality*2;
126

127
  return quality;
128
}
129

130

131
GLOBAL(void)
132
jpeg_set_quality (j_compress_ptr cinfo, int quality, boolean force_baseline)
133
/* Set or change the 'quality' (quantization) setting, using default tables.
134
 * This is the standard quality-adjusting entry point for typical user
135
 * interfaces; only those who want detailed control over quantization tables
136
 * would use the preceding three routines directly.
137
 */
138
{
139
  /* Convert user 0-100 rating to percentage scaling */
140
  quality = jpeg_quality_scaling(quality);
141

142
  /* Set up standard quality tables */
143
  jpeg_set_linear_quality(cinfo, quality, force_baseline);
144
}
145

146

147
/*
148
 * Huffman table setup routines
149
 */
150

151
LOCAL(void)
152
add_huff_table (j_compress_ptr cinfo,
153
		JHUFF_TBL **htblptr, const UINT8 *bits, const UINT8 *val)
154
/* Define a Huffman table */
155
{
156
  int nsymbols, len;
157

158
  if (*htblptr == NULL)
159
    *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo);
160

161
  /* Copy the number-of-symbols-of-each-code-length counts */
162
  MEMCOPY((*htblptr)->bits, bits, SIZEOF((*htblptr)->bits));
163

164
  /* Validate the counts.  We do this here mainly so we can copy the right
165
   * number of symbols from the val[] array, without risking marching off
166
   * the end of memory.  jchuff.c will do a more thorough test later.
167
   */
168
  nsymbols = 0;
169
  for (len = 1; len <= 16; len++)
170
    nsymbols += bits[len];
171
  if (nsymbols < 1 || nsymbols > 256)
172
    ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
173

174
  MEMCOPY((*htblptr)->huffval, val, nsymbols * SIZEOF(UINT8));
175

176
  /* Initialize sent_table FALSE so table will be written to JPEG file. */
177
  (*htblptr)->sent_table = FALSE;
178
}
179

180

181
LOCAL(void)
182
std_huff_tables (j_compress_ptr cinfo)
183
/* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
184
/* IMPORTANT: these are only valid for 8-bit data precision! */
185
{
186
  static const UINT8 bits_dc_luminance[17] =
187
    { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
188
  static const UINT8 val_dc_luminance[] =
189
    { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
190
  
191
  static const UINT8 bits_dc_chrominance[17] =
192
    { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
193
  static const UINT8 val_dc_chrominance[] =
194
    { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
195
  
196
  static const UINT8 bits_ac_luminance[17] =
197
    { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
198
  static const UINT8 val_ac_luminance[] =
199
    { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
200
      0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
201
      0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
202
      0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
203
      0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
204
      0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
205
      0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
206
      0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
207
      0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
208
      0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
209
      0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
210
      0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
211
      0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
212
      0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
213
      0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
214
      0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
215
      0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
216
      0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
217
      0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
218
      0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
219
      0xf9, 0xfa };
220
  
221
  static const UINT8 bits_ac_chrominance[17] =
222
    { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
223
  static const UINT8 val_ac_chrominance[] =
224
    { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
225
      0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
226
      0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
227
      0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
228
      0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
229
      0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
230
      0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
231
      0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
232
      0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
233
      0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
234
      0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
235
      0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
236
      0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
237
      0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
238
      0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
239
      0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
240
      0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
241
      0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
242
      0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
243
      0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
244
      0xf9, 0xfa };
245
  
246
  add_huff_table(cinfo, &cinfo->dc_huff_tbl_ptrs[0],
247
		 bits_dc_luminance, val_dc_luminance);
248
  add_huff_table(cinfo, &cinfo->ac_huff_tbl_ptrs[0],
249
		 bits_ac_luminance, val_ac_luminance);
250
  add_huff_table(cinfo, &cinfo->dc_huff_tbl_ptrs[1],
251
		 bits_dc_chrominance, val_dc_chrominance);
252
  add_huff_table(cinfo, &cinfo->ac_huff_tbl_ptrs[1],
253
		 bits_ac_chrominance, val_ac_chrominance);
254
}
255

256

257
/*
258
 * Default parameter setup for compression.
259
 *
260
 * Applications that don't choose to use this routine must do their
261
 * own setup of all these parameters.  Alternately, you can call this
262
 * to establish defaults and then alter parameters selectively.  This
263
 * is the recommended approach since, if we add any new parameters,
264
 * your code will still work (they'll be set to reasonable defaults).
265
 */
266

267
GLOBAL(void)
268
jpeg_set_defaults (j_compress_ptr cinfo)
269
{
270
  int i;
271

272
  /* Safety check to ensure start_compress not called yet. */
273
  if (cinfo->global_state != CSTATE_START)
274
    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
275

276
  /* Allocate comp_info array large enough for maximum component count.
277
   * Array is made permanent in case application wants to compress
278
   * multiple images at same param settings.
279
   */
280
  if (cinfo->comp_info == NULL)
281
    cinfo->comp_info = (jpeg_component_info *)
282
      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
283
				  MAX_COMPONENTS * SIZEOF(jpeg_component_info));
284

285
  /* Initialize everything not dependent on the color space */
286

287
  cinfo->data_precision = BITS_IN_JSAMPLE;
288
  /* Set up two quantization tables using default quality of 75 */
289
  jpeg_set_quality(cinfo, 75, TRUE);
290
  /* Set up two Huffman tables */
291
  std_huff_tables(cinfo);
292

293
  /* Initialize default arithmetic coding conditioning */
294
  for (i = 0; i < NUM_ARITH_TBLS; i++) {
295
    cinfo->arith_dc_L[i] = 0;
296
    cinfo->arith_dc_U[i] = 1;
297
    cinfo->arith_ac_K[i] = 5;
298
  }
299

300
  /* Default is no multiple-scan output */
301
  cinfo->scan_info = NULL;
302
  cinfo->num_scans = 0;
303

304
  /* Expect normal source image, not raw downsampled data */
305
  cinfo->raw_data_in = FALSE;
306

307
  /* Use Huffman coding, not arithmetic coding, by default */
308
  cinfo->arith_code = FALSE;
309

310
  /* By default, don't do extra passes to optimize entropy coding */
311
  cinfo->optimize_coding = FALSE;
312
  /* The standard Huffman tables are only valid for 8-bit data precision.
313
   * If the precision is higher, force optimization on so that usable
314
   * tables will be computed.  This test can be removed if default tables
315
   * are supplied that are valid for the desired precision.
316
   */
317
  if (cinfo->data_precision > 8)
318
    cinfo->optimize_coding = TRUE;
319

320
  /* By default, use the simpler non-cosited sampling alignment */
321
  cinfo->CCIR601_sampling = FALSE;
322

323
  /* No input smoothing */
324
  cinfo->smoothing_factor = 0;
325

326
  /* DCT algorithm preference */
327
  cinfo->dct_method = JDCT_DEFAULT;
328

329
  /* No restart markers */
330
  cinfo->restart_interval = 0;
331
  cinfo->restart_in_rows = 0;
332

333
  /* Fill in default JFIF marker parameters.  Note that whether the marker
334
   * will actually be written is determined by jpeg_set_colorspace.
335
   *
336
   * By default, the library emits JFIF version code 1.01.
337
   * An application that wants to emit JFIF 1.02 extension markers should set
338
   * JFIF_minor_version to 2.  We could probably get away with just defaulting
339
   * to 1.02, but there may still be some decoders in use that will complain
340
   * about that; saying 1.01 should minimize compatibility problems.
341
   */
342
  cinfo->JFIF_major_version = 1; /* Default JFIF version = 1.01 */
343
  cinfo->JFIF_minor_version = 1;
344
  cinfo->density_unit = 0;	/* Pixel size is unknown by default */
345
  cinfo->X_density = 1;		/* Pixel aspect ratio is square by default */
346
  cinfo->Y_density = 1;
347

348
  /* Choose JPEG colorspace based on input space, set defaults accordingly */
349

350
  jpeg_default_colorspace(cinfo);
351
}
352

353

354
/*
355
 * Select an appropriate JPEG colorspace for in_color_space.
356
 */
357

358
GLOBAL(void)
359
jpeg_default_colorspace (j_compress_ptr cinfo)
360
{
361
  switch (cinfo->in_color_space) {
362
  case JCS_GRAYSCALE:
363
    jpeg_set_colorspace(cinfo, JCS_GRAYSCALE);
364
    break;
365
  case JCS_RGB:
366
    jpeg_set_colorspace(cinfo, JCS_YCbCr);
367
    break;
368
  case JCS_YCbCr:
369
    jpeg_set_colorspace(cinfo, JCS_YCbCr);
370
    break;
371
  case JCS_CMYK:
372
    jpeg_set_colorspace(cinfo, JCS_CMYK); /* By default, no translation */
373
    break;
374
  case JCS_YCCK:
375
    jpeg_set_colorspace(cinfo, JCS_YCCK);
376
    break;
377
  case JCS_UNKNOWN:
378
    jpeg_set_colorspace(cinfo, JCS_UNKNOWN);
379
    break;
380
  default:
381
    ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
382
  }
383
}
384

385

386
/*
387
 * Set the JPEG colorspace, and choose colorspace-dependent default values.
388
 */
389

390
GLOBAL(void)
391
jpeg_set_colorspace (j_compress_ptr cinfo, J_COLOR_SPACE colorspace)
392
{
393
  jpeg_component_info * compptr;
394
  int ci;
395

396
#define SET_COMP(index,id,hsamp,vsamp,quant,dctbl,actbl)  \
397
  (compptr = &cinfo->comp_info[index], \
398
   compptr->component_id = (id), \
399
   compptr->h_samp_factor = (hsamp), \
400
   compptr->v_samp_factor = (vsamp), \
401
   compptr->quant_tbl_no = (quant), \
402
   compptr->dc_tbl_no = (dctbl), \
403
   compptr->ac_tbl_no = (actbl) )
404

405
  /* Safety check to ensure start_compress not called yet. */
406
  if (cinfo->global_state != CSTATE_START)
407
    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
408

409
  /* For all colorspaces, we use Q and Huff tables 0 for luminance components,
410
   * tables 1 for chrominance components.
411
   */
412

413
  cinfo->jpeg_color_space = colorspace;
414

415
  cinfo->write_JFIF_header = FALSE; /* No marker for non-JFIF colorspaces */
416
  cinfo->write_Adobe_marker = FALSE; /* write no Adobe marker by default */
417

418
  switch (colorspace) {
419
  case JCS_GRAYSCALE:
420
    cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */
421
    cinfo->num_components = 1;
422
    /* JFIF specifies component ID 1 */
423
    SET_COMP(0, 1, 1,1, 0, 0,0);
424
    break;
425
  case JCS_RGB:
426
    cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag RGB */
427
    cinfo->num_components = 3;
428
    SET_COMP(0, 0x52 /* 'R' */, 1,1, 0, 0,0);
429
    SET_COMP(1, 0x47 /* 'G' */, 1,1, 0, 0,0);
430
    SET_COMP(2, 0x42 /* 'B' */, 1,1, 0, 0,0);
431
    break;
432
  case JCS_YCbCr:
433
    cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */
434
    cinfo->num_components = 3;
435
    /* JFIF specifies component IDs 1,2,3 */
436
    /* We default to 2x2 subsamples of chrominance */
437
    SET_COMP(0, 1, 2,2, 0, 0,0);
438
    SET_COMP(1, 2, 1,1, 1, 1,1);
439
    SET_COMP(2, 3, 1,1, 1, 1,1);
440
    break;
441
  case JCS_CMYK:
442
    cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag CMYK */
443
    cinfo->num_components = 4;
444
    SET_COMP(0, 0x43 /* 'C' */, 1,1, 0, 0,0);
445
    SET_COMP(1, 0x4D /* 'M' */, 1,1, 0, 0,0);
446
    SET_COMP(2, 0x59 /* 'Y' */, 1,1, 0, 0,0);
447
    SET_COMP(3, 0x4B /* 'K' */, 1,1, 0, 0,0);
448
    break;
449
  case JCS_YCCK:
450
    cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag YCCK */
451
    cinfo->num_components = 4;
452
    SET_COMP(0, 1, 2,2, 0, 0,0);
453
    SET_COMP(1, 2, 1,1, 1, 1,1);
454
    SET_COMP(2, 3, 1,1, 1, 1,1);
455
    SET_COMP(3, 4, 2,2, 0, 0,0);
456
    break;
457
  case JCS_UNKNOWN:
458
    cinfo->num_components = cinfo->input_components;
459
    if (cinfo->num_components < 1 || cinfo->num_components > MAX_COMPONENTS)
460
      ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components,
461
	       MAX_COMPONENTS);
462
    for (ci = 0; ci < cinfo->num_components; ci++) {
463
      SET_COMP(ci, ci, 1,1, 0, 0,0);
464
    }
465
    break;
466
  default:
467
    ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
468
  }
469
}
470

471

472
#ifdef C_PROGRESSIVE_SUPPORTED
473

474
LOCAL(jpeg_scan_info *)
475
fill_a_scan (jpeg_scan_info * scanptr, int ci,
476
	     int Ss, int Se, int Ah, int Al)
477
/* Support routine: generate one scan for specified component */
478
{
479
  scanptr->comps_in_scan = 1;
480
  scanptr->component_index[0] = ci;
481
  scanptr->Ss = Ss;
482
  scanptr->Se = Se;
483
  scanptr->Ah = Ah;
484
  scanptr->Al = Al;
485
  scanptr++;
486
  return scanptr;
487
}
488

489
LOCAL(jpeg_scan_info *)
490
fill_scans (jpeg_scan_info * scanptr, int ncomps,
491
	    int Ss, int Se, int Ah, int Al)
492
/* Support routine: generate one scan for each component */
493
{
494
  int ci;
495

496
  for (ci = 0; ci < ncomps; ci++) {
497
    scanptr->comps_in_scan = 1;
498
    scanptr->component_index[0] = ci;
499
    scanptr->Ss = Ss;
500
    scanptr->Se = Se;
501
    scanptr->Ah = Ah;
502
    scanptr->Al = Al;
503
    scanptr++;
504
  }
505
  return scanptr;
506
}
507

508
LOCAL(jpeg_scan_info *)
509
fill_dc_scans (jpeg_scan_info * scanptr, int ncomps, int Ah, int Al)
510
/* Support routine: generate interleaved DC scan if possible, else N scans */
511
{
512
  int ci;
513

514
  if (ncomps <= MAX_COMPS_IN_SCAN) {
515
    /* Single interleaved DC scan */
516
    scanptr->comps_in_scan = ncomps;
517
    for (ci = 0; ci < ncomps; ci++)
518
      scanptr->component_index[ci] = ci;
519
    scanptr->Ss = scanptr->Se = 0;
520
    scanptr->Ah = Ah;
521
    scanptr->Al = Al;
522
    scanptr++;
523
  } else {
524
    /* Noninterleaved DC scan for each component */
525
    scanptr = fill_scans(scanptr, ncomps, 0, 0, Ah, Al);
526
  }
527
  return scanptr;
528
}
529

530

531
/*
532
 * Create a recommended progressive-JPEG script.
533
 * cinfo->num_components and cinfo->jpeg_color_space must be correct.
534
 */
535

536
GLOBAL(void)
537
jpeg_simple_progression (j_compress_ptr cinfo)
538
{
539
  int ncomps = cinfo->num_components;
540
  int nscans;
541
  jpeg_scan_info * scanptr;
542

543
  /* Safety check to ensure start_compress not called yet. */
544
  if (cinfo->global_state != CSTATE_START)
545
    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
546

547
  /* Figure space needed for script.  Calculation must match code below! */
548
  if (ncomps == 3 && cinfo->jpeg_color_space == JCS_YCbCr) {
549
    /* Custom script for YCbCr color images. */
550
    nscans = 10;
551
  } else {
552
    /* All-purpose script for other color spaces. */
553
    if (ncomps > MAX_COMPS_IN_SCAN)
554
      nscans = 6 * ncomps;	/* 2 DC + 4 AC scans per component */
555
    else
556
      nscans = 2 + 4 * ncomps;	/* 2 DC scans; 4 AC scans per component */
557
  }
558

559
  /* Allocate space for script.
560
   * We need to put it in the permanent pool in case the application performs
561
   * multiple compressions without changing the settings.  To avoid a memory
562
   * leak if jpeg_simple_progression is called repeatedly for the same JPEG
563
   * object, we try to re-use previously allocated space, and we allocate
564
   * enough space to handle YCbCr even if initially asked for grayscale.
565
   */
566
  if (cinfo->script_space == NULL || cinfo->script_space_size < nscans) {
567
    cinfo->script_space_size = MAX(nscans, 10);
568
    cinfo->script_space = (jpeg_scan_info *)
569
      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
570
			cinfo->script_space_size * SIZEOF(jpeg_scan_info));
571
  }
572
  scanptr = cinfo->script_space;
573
  cinfo->scan_info = scanptr;
574
  cinfo->num_scans = nscans;
575

576
  if (ncomps == 3 && cinfo->jpeg_color_space == JCS_YCbCr) {
577
    /* Custom script for YCbCr color images. */
578
    /* Initial DC scan */
579
    scanptr = fill_dc_scans(scanptr, ncomps, 0, 1);
580
    /* Initial AC scan: get some luma data out in a hurry */
581
    scanptr = fill_a_scan(scanptr, 0, 1, 5, 0, 2);
582
    /* Chroma data is too small to be worth expending many scans on */
583
    scanptr = fill_a_scan(scanptr, 2, 1, 63, 0, 1);
584
    scanptr = fill_a_scan(scanptr, 1, 1, 63, 0, 1);
585
    /* Complete spectral selection for luma AC */
586
    scanptr = fill_a_scan(scanptr, 0, 6, 63, 0, 2);
587
    /* Refine next bit of luma AC */
588
    scanptr = fill_a_scan(scanptr, 0, 1, 63, 2, 1);
589
    /* Finish DC successive approximation */
590
    scanptr = fill_dc_scans(scanptr, ncomps, 1, 0);
591
    /* Finish AC successive approximation */
592
    scanptr = fill_a_scan(scanptr, 2, 1, 63, 1, 0);
593
    scanptr = fill_a_scan(scanptr, 1, 1, 63, 1, 0);
594
    /* Luma bottom bit comes last since it's usually largest scan */
595
    scanptr = fill_a_scan(scanptr, 0, 1, 63, 1, 0);
596
  } else {
597
    /* All-purpose script for other color spaces. */
598
    /* Successive approximation first pass */
599
    scanptr = fill_dc_scans(scanptr, ncomps, 0, 1);
600
    scanptr = fill_scans(scanptr, ncomps, 1, 5, 0, 2);
601
    scanptr = fill_scans(scanptr, ncomps, 6, 63, 0, 2);
602
    /* Successive approximation second pass */
603
    scanptr = fill_scans(scanptr, ncomps, 1, 63, 2, 1);
604
    /* Successive approximation final pass */
605
    scanptr = fill_dc_scans(scanptr, ncomps, 1, 0);
606
    scanptr = fill_scans(scanptr, ncomps, 1, 63, 1, 0);
607
  }
608
}
609

610
#endif /* C_PROGRESSIVE_SUPPORTED */
611

612