1 /*
2 * jcparam.c
3 *
4 * Copyright (C) 1991-1998, Thomas G. Lane.
5 * Modified 2003-2008 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)
24 jpeg_add_quant_table (j_compress_ptr cinfo, int which_tbl,
25 const unsigned int *basic_table,
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)
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 three 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)
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;
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 /* Use Huffman coding, not arithmetic coding, by default */
327 cinfo->arith_code = FALSE;
328
329 /* By default, don't do extra passes to optimize entropy coding */
330 cinfo->optimize_coding = FALSE;
331 /* The standard Huffman tables are only valid for 8-bit data precision.
332 * If the precision is higher, force optimization on so that usable
333 * tables will be computed. This test can be removed if default tables
334 * are supplied that are valid for the desired precision.
335 */
336 if (cinfo->data_precision > 8)
337 cinfo->optimize_coding = TRUE;
338
339 /* By default, use the simpler non-cosited sampling alignment */
340 cinfo->CCIR601_sampling = FALSE;
341
342 /* By default, apply fancy downsampling */
343 cinfo->do_fancy_downsampling = TRUE;
344
345 /* No input smoothing */
346 cinfo->smoothing_factor = 0;
347
348 /* DCT algorithm preference */
349 cinfo->dct_method = JDCT_DEFAULT;
350
351 /* No restart markers */
352 cinfo->restart_interval = 0;
353 cinfo->restart_in_rows = 0;
354
355 /* Fill in default JFIF marker parameters. Note that whether the marker
356 * will actually be written is determined by jpeg_set_colorspace.
357 *
358 * By default, the library emits JFIF version code 1.01.
359 * An application that wants to emit JFIF 1.02 extension markers should set
360 * JFIF_minor_version to 2. We could probably get away with just defaulting
361 * to 1.02, but there may still be some decoders in use that will complain
362 * about that; saying 1.01 should minimize compatibility problems.
363 */
364 cinfo->JFIF_major_version = 1; /* Default JFIF version = 1.01 */
365 cinfo->JFIF_minor_version = 1;
366 cinfo->density_unit = 0; /* Pixel size is unknown by default */
367 cinfo->X_density = 1; /* Pixel aspect ratio is square by default */
368 cinfo->Y_density = 1;
369
370 /* Choose JPEG colorspace based on input space, set defaults accordingly */
371
372 jpeg_default_colorspace(cinfo);
373 }
374
375
376 /*
377 * Select an appropriate JPEG colorspace for in_color_space.
378 */
379
380 GLOBAL(void)
381 jpeg_default_colorspace (j_compress_ptr cinfo)
382 {
383 switch (cinfo->in_color_space) {
384 case JCS_GRAYSCALE:
385 jpeg_set_colorspace(cinfo, JCS_GRAYSCALE);
386 break;
387 case JCS_RGB:
388 jpeg_set_colorspace(cinfo, JCS_YCbCr);
389 break;
390 case JCS_YCbCr:
391 jpeg_set_colorspace(cinfo, JCS_YCbCr);
392 break;
393 case JCS_CMYK:
394 jpeg_set_colorspace(cinfo, JCS_CMYK); /* By default, no translation */
395 break;
396 case JCS_YCCK:
397 jpeg_set_colorspace(cinfo, JCS_YCCK);
398 break;
399 case JCS_UNKNOWN:
400 jpeg_set_colorspace(cinfo, JCS_UNKNOWN);
401 break;
402 default:
403 ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
404 }
405 }
406
407
408 /*
409 * Set the JPEG colorspace, and choose colorspace-dependent default values.
410 */
411
412 GLOBAL(void)
413 jpeg_set_colorspace (j_compress_ptr cinfo, J_COLOR_SPACE colorspace)
414 {
415 jpeg_component_info * compptr;
416 int ci;
417
418 #define SET_COMP(index,id,hsamp,vsamp,quant,dctbl,actbl) \
419 (compptr = &cinfo->comp_info[index], \
420 compptr->component_id = (id), \
421 compptr->h_samp_factor = (hsamp), \
422 compptr->v_samp_factor = (vsamp), \
423 compptr->quant_tbl_no = (quant), \
424 compptr->dc_tbl_no = (dctbl), \
425 compptr->ac_tbl_no = (actbl) )
426
427 /* Safety check to ensure start_compress not called yet. */
428 if (cinfo->global_state != CSTATE_START)
429 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
430
431 /* For all colorspaces, we use Q and Huff tables 0 for luminance components,
432 * tables 1 for chrominance components.
433 */
434
435 cinfo->jpeg_color_space = colorspace;
436
437 cinfo->write_JFIF_header = FALSE; /* No marker for non-JFIF colorspaces */
438 cinfo->write_Adobe_marker = FALSE; /* write no Adobe marker by default */
439
440 switch (colorspace) {
441 case JCS_GRAYSCALE:
442 cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */
443 cinfo->num_components = 1;
444 /* JFIF specifies component ID 1 */
445 SET_COMP(0, 1, 1,1, 0, 0,0);
446 break;
447 case JCS_RGB:
448 cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag RGB */
449 cinfo->num_components = 3;
450 SET_COMP(0, 0x52 /* 'R' */, 1,1, 0, 0,0);
451 SET_COMP(1, 0x47 /* 'G' */, 1,1, 0, 0,0);
452 SET_COMP(2, 0x42 /* 'B' */, 1,1, 0, 0,0);
453 break;
454 case JCS_YCbCr:
455 cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */
456 cinfo->num_components = 3;
457 /* JFIF specifies component IDs 1,2,3 */
458 /* We default to 2x2 subsamples of chrominance */
459 SET_COMP(0, 1, 2,2, 0, 0,0);
460 SET_COMP(1, 2, 1,1, 1, 1,1);
461 SET_COMP(2, 3, 1,1, 1, 1,1);
462 break;
463 case JCS_CMYK:
464 cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag CMYK */
465 cinfo->num_components = 4;
466 SET_COMP(0, 0x43 /* 'C' */, 1,1, 0, 0,0);
467 SET_COMP(1, 0x4D /* 'M' */, 1,1, 0, 0,0);
468 SET_COMP(2, 0x59 /* 'Y' */, 1,1, 0, 0,0);
469 SET_COMP(3, 0x4B /* 'K' */, 1,1, 0, 0,0);
470 break;
471 case JCS_YCCK:
472 cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag YCCK */
473 cinfo->num_components = 4;
474 SET_COMP(0, 1, 2,2, 0, 0,0);
475 SET_COMP(1, 2, 1,1, 1, 1,1);
476 SET_COMP(2, 3, 1,1, 1, 1,1);
477 SET_COMP(3, 4, 2,2, 0, 0,0);
478 break;
479 case JCS_UNKNOWN:
480 cinfo->num_components = cinfo->input_components;
481 if (cinfo->num_components < 1 || cinfo->num_components > MAX_COMPONENTS)
482 ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components,
483 MAX_COMPONENTS);
484 for (ci = 0; ci < cinfo->num_components; ci++) {
485 SET_COMP(ci, ci, 1,1, 0, 0,0);
486 }
487 break;
488 default:
489 ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
490 }
491 }
492
493
494 #ifdef C_PROGRESSIVE_SUPPORTED
495
496 LOCAL(jpeg_scan_info *)
497 fill_a_scan (jpeg_scan_info * scanptr, int ci,
498 int Ss, int Se, int Ah, int Al)
499 /* Support routine: generate one scan for specified component */
500 {
501 scanptr->comps_in_scan = 1;
502 scanptr->component_index[0] = ci;
503 scanptr->Ss = Ss;
504 scanptr->Se = Se;
505 scanptr->Ah = Ah;
506 scanptr->Al = Al;
550 }
551
552
553 /*
554 * Create a recommended progressive-JPEG script.
555 * cinfo->num_components and cinfo->jpeg_color_space must be correct.
556 */
557
558 GLOBAL(void)
559 jpeg_simple_progression (j_compress_ptr cinfo)
560 {
561 int ncomps = cinfo->num_components;
562 int nscans;
563 jpeg_scan_info * scanptr;
564
565 /* Safety check to ensure start_compress not called yet. */
566 if (cinfo->global_state != CSTATE_START)
567 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
568
569 /* Figure space needed for script. Calculation must match code below! */
570 if (ncomps == 3 && cinfo->jpeg_color_space == JCS_YCbCr) {
571 /* Custom script for YCbCr color images. */
572 nscans = 10;
573 } else {
574 /* All-purpose script for other color spaces. */
575 if (ncomps > MAX_COMPS_IN_SCAN)
576 nscans = 6 * ncomps; /* 2 DC + 4 AC scans per component */
577 else
578 nscans = 2 + 4 * ncomps; /* 2 DC scans; 4 AC scans per component */
579 }
580
581 /* Allocate space for script.
582 * We need to put it in the permanent pool in case the application performs
583 * multiple compressions without changing the settings. To avoid a memory
584 * leak if jpeg_simple_progression is called repeatedly for the same JPEG
585 * object, we try to re-use previously allocated space, and we allocate
586 * enough space to handle YCbCr even if initially asked for grayscale.
587 */
588 if (cinfo->script_space == NULL || cinfo->script_space_size < nscans) {
589 cinfo->script_space_size = MAX(nscans, 10);
590 cinfo->script_space = (jpeg_scan_info *)
591 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
592 cinfo->script_space_size * SIZEOF(jpeg_scan_info));
593 }
594 scanptr = cinfo->script_space;
595 cinfo->scan_info = scanptr;
596 cinfo->num_scans = nscans;
597
598 if (ncomps == 3 && cinfo->jpeg_color_space == JCS_YCbCr) {
599 /* Custom script for YCbCr color images. */
600 /* Initial DC scan */
601 scanptr = fill_dc_scans(scanptr, ncomps, 0, 1);
602 /* Initial AC scan: get some luma data out in a hurry */
603 scanptr = fill_a_scan(scanptr, 0, 1, 5, 0, 2);
604 /* Chroma data is too small to be worth expending many scans on */
605 scanptr = fill_a_scan(scanptr, 2, 1, 63, 0, 1);
606 scanptr = fill_a_scan(scanptr, 1, 1, 63, 0, 1);
607 /* Complete spectral selection for luma AC */
608 scanptr = fill_a_scan(scanptr, 0, 6, 63, 0, 2);
609 /* Refine next bit of luma AC */
610 scanptr = fill_a_scan(scanptr, 0, 1, 63, 2, 1);
611 /* Finish DC successive approximation */
612 scanptr = fill_dc_scans(scanptr, ncomps, 1, 0);
613 /* Finish AC successive approximation */
614 scanptr = fill_a_scan(scanptr, 2, 1, 63, 1, 0);
615 scanptr = fill_a_scan(scanptr, 1, 1, 63, 1, 0);
616 /* Luma bottom bit comes last since it's usually largest scan */
617 scanptr = fill_a_scan(scanptr, 0, 1, 63, 1, 0);
618 } else {
619 /* All-purpose script for other color spaces. */
|
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)
24 jpeg_add_quant_table (j_compress_ptr cinfo, int which_tbl,
25 const unsigned int *basic_table,
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)
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)
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;
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)
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)
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 *)
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;
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)
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. */
|