Doxygen Source Code Documentation
jcparam.c File Reference
#include "jinclude.h"
#include "jpeglib.h"
Go to the source code of this file.
Define Documentation
|
|
|
Value: (compptr = &cinfo->comp_info[index], \ compptr->component_id = (id), \ compptr->h_samp_factor = (hsamp), \ compptr->v_samp_factor = (vsamp), \ compptr->quant_tbl_no = (quant), \ compptr->dc_tbl_no = (dctbl), \ compptr->ac_tbl_no = (actbl) ) |
Function Documentation
|
Definition at line 152 of file jcparam.c. References ERREXIT, jpeg_alloc_huff_table(), MEMCOPY, SIZEOF, and UINT8. Referenced by std_huff_tables().
00155 { 00156 int nsymbols, len; 00157 00158 if (*htblptr == NULL) 00159 *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo); 00160 00161 /* Copy the number-of-symbols-of-each-code-length counts */ 00162 MEMCOPY((*htblptr)->bits, bits, SIZEOF((*htblptr)->bits)); 00163 00164 /* Validate the counts. We do this here mainly so we can copy the right 00165 * number of symbols from the val[] array, without risking marching off 00166 * the end of memory. jchuff.c will do a more thorough test later. 00167 */ 00168 nsymbols = 0; 00169 for (len = 1; len <= 16; len++) 00170 nsymbols += bits[len]; 00171 if (nsymbols < 1 || nsymbols > 256) 00172 ERREXIT(cinfo, JERR_BAD_HUFF_TABLE); 00173 00174 MEMCOPY((*htblptr)->huffval, val, nsymbols * SIZEOF(UINT8)); 00175 00176 /* Initialize sent_table FALSE so table will be written to JPEG file. */ 00177 (*htblptr)->sent_table = FALSE; 00178 } |
|
Definition at line 475 of file jcparam.c. References jpeg_scan_info::Ah, jpeg_scan_info::Al, jpeg_scan_info::component_index, jpeg_scan_info::comps_in_scan, jpeg_scan_info::Se, jpeg_scan_info::Ss, and Ss. Referenced by jpeg_simple_progression().
00477 : generate one scan for specified component */ 00478 { 00479 scanptr->comps_in_scan = 1; 00480 scanptr->component_index[0] = ci; 00481 scanptr->Ss = Ss; 00482 scanptr->Se = Se; 00483 scanptr->Ah = Ah; 00484 scanptr->Al = Al; 00485 scanptr++; 00486 return scanptr; 00487 } |
|
Definition at line 509 of file jcparam.c. References jpeg_scan_info::Ah, jpeg_scan_info::Al, jpeg_scan_info::component_index, jpeg_scan_info::comps_in_scan, fill_scans(), MAX_COMPS_IN_SCAN, jpeg_scan_info::Se, and jpeg_scan_info::Ss. Referenced by jpeg_simple_progression().
00510 : generate interleaved DC scan if possible, else N scans */ 00511 { 00512 int ci; 00513 00514 if (ncomps <= MAX_COMPS_IN_SCAN) { 00515 /* Single interleaved DC scan */ 00516 scanptr->comps_in_scan = ncomps; 00517 for (ci = 0; ci < ncomps; ci++) 00518 scanptr->component_index[ci] = ci; 00519 scanptr->Ss = scanptr->Se = 0; 00520 scanptr->Ah = Ah; 00521 scanptr->Al = Al; 00522 scanptr++; 00523 } else { 00524 /* Noninterleaved DC scan for each component */ 00525 scanptr = fill_scans(scanptr, ncomps, 0, 0, Ah, Al); 00526 } 00527 return scanptr; 00528 } |
|
Definition at line 490 of file jcparam.c. References jpeg_scan_info::Ah, jpeg_scan_info::Al, jpeg_scan_info::component_index, jpeg_scan_info::comps_in_scan, jpeg_scan_info::Se, jpeg_scan_info::Ss, and Ss. Referenced by fill_dc_scans(), and jpeg_simple_progression().
00492 : generate one scan for each component */ 00493 { 00494 int ci; 00495 00496 for (ci = 0; ci < ncomps; ci++) { 00497 scanptr->comps_in_scan = 1; 00498 scanptr->component_index[0] = ci; 00499 scanptr->Ss = Ss; 00500 scanptr->Se = Se; 00501 scanptr->Ah = Ah; 00502 scanptr->Al = Al; 00503 scanptr++; 00504 } 00505 return scanptr; 00506 } |
|
Definition at line 23 of file jcparam.c. References basic_table, CSTATE_START, ERREXIT1, i, jpeg_alloc_quant_table(), L, NUM_QUANT_TBLS, jpeg_compress_struct::quant_tbl_ptrs, and which_tbl. Referenced by jpeg_set_linear_quality(), and read_quant_tables().
00031 { 00032 JQUANT_TBL ** qtblptr; 00033 int i; 00034 long temp; 00035 00036 /* Safety check to ensure start_compress not called yet. */ 00037 if (cinfo->global_state != CSTATE_START) 00038 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); 00039 00040 if (which_tbl < 0 || which_tbl >= NUM_QUANT_TBLS) 00041 ERREXIT1(cinfo, JERR_DQT_INDEX, which_tbl); 00042 00043 qtblptr = & cinfo->quant_tbl_ptrs[which_tbl]; 00044 00045 if (*qtblptr == NULL) 00046 *qtblptr = jpeg_alloc_quant_table((j_common_ptr) cinfo); 00047 00048 for (i = 0; i < DCTSIZE2; i++) { 00049 temp = ((long) basic_table[i] * scale_factor + 50L) / 100L; 00050 /* limit the values to the valid range */ 00051 if (temp <= 0L) temp = 1L; 00052 if (temp > 32767L) temp = 32767L; /* max quantizer needed for 12 bits */ 00053 if (force_baseline && temp > 255L) 00054 temp = 255L; /* limit to baseline range if requested */ 00055 (*qtblptr)->quantval[i] = (UINT16) temp; 00056 } 00057 00058 /* Initialize sent_table FALSE so table will be written to JPEG file. */ 00059 (*qtblptr)->sent_table = FALSE; 00060 } |
|
Definition at line 359 of file jcparam.c. References ERREXIT, jpeg_compress_struct::in_color_space, JCS_CMYK, JCS_GRAYSCALE, JCS_RGB, JCS_UNKNOWN, JCS_YCbCr, JCS_YCCK, and jpeg_set_colorspace(). Referenced by jpeg_set_defaults().
00360 { 00361 switch (cinfo->in_color_space) { 00362 case JCS_GRAYSCALE: 00363 jpeg_set_colorspace(cinfo, JCS_GRAYSCALE); 00364 break; 00365 case JCS_RGB: 00366 jpeg_set_colorspace(cinfo, JCS_YCbCr); 00367 break; 00368 case JCS_YCbCr: 00369 jpeg_set_colorspace(cinfo, JCS_YCbCr); 00370 break; 00371 case JCS_CMYK: 00372 jpeg_set_colorspace(cinfo, JCS_CMYK); /* By default, no translation */ 00373 break; 00374 case JCS_YCCK: 00375 jpeg_set_colorspace(cinfo, JCS_YCCK); 00376 break; 00377 case JCS_UNKNOWN: 00378 jpeg_set_colorspace(cinfo, JCS_UNKNOWN); 00379 break; 00380 default: 00381 ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE); 00382 } 00383 } |
|
Definition at line 106 of file jcparam.c. References quality. Referenced by jpeg_set_quality().
00111 { 00112 /* Safety limit on quality factor. Convert 0 to 1 to avoid zero divide. */ 00113 if (quality <= 0) quality = 1; 00114 if (quality > 100) quality = 100; 00115 00116 /* The basic table is used as-is (scaling 100) for a quality of 50. 00117 * Qualities 50..100 are converted to scaling percentage 200 - 2*Q; 00118 * note that at Q=100 the scaling is 0, which will cause jpeg_add_quant_table 00119 * to make all the table entries 1 (hence, minimum quantization loss). 00120 * Qualities 1..50 are converted to scaling percentage 5000/Q. 00121 */ 00122 if (quality < 50) 00123 quality = 5000 / quality; 00124 else 00125 quality = 200 - quality*2; 00126 00127 return quality; 00128 } |
|
Definition at line 391 of file jcparam.c. References colorspace, compptr, CSTATE_START, ERREXIT, ERREXIT1, ERREXIT2, jpeg_compress_struct::input_components, J_COLOR_SPACE, JCS_CMYK, JCS_GRAYSCALE, JCS_RGB, JCS_UNKNOWN, JCS_YCbCr, JCS_YCCK, jpeg_compress_struct::jpeg_color_space, MAX_COMPONENTS, jpeg_compress_struct::num_components, jpeg_compress_struct::write_Adobe_marker, and jpeg_compress_struct::write_JFIF_header. Referenced by jpeg_copy_critical_parameters(), jpeg_default_colorspace(), and jtransform_adjust_parameters().
00392 { 00393 jpeg_component_info * compptr; 00394 int ci; 00395 00396 #define SET_COMP(index,id,hsamp,vsamp,quant,dctbl,actbl) \ 00397 (compptr = &cinfo->comp_info[index], \ 00398 compptr->component_id = (id), \ 00399 compptr->h_samp_factor = (hsamp), \ 00400 compptr->v_samp_factor = (vsamp), \ 00401 compptr->quant_tbl_no = (quant), \ 00402 compptr->dc_tbl_no = (dctbl), \ 00403 compptr->ac_tbl_no = (actbl) ) 00404 00405 /* Safety check to ensure start_compress not called yet. */ 00406 if (cinfo->global_state != CSTATE_START) 00407 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); 00408 00409 /* For all colorspaces, we use Q and Huff tables 0 for luminance components, 00410 * tables 1 for chrominance components. 00411 */ 00412 00413 cinfo->jpeg_color_space = colorspace; 00414 00415 cinfo->write_JFIF_header = FALSE; /* No marker for non-JFIF colorspaces */ 00416 cinfo->write_Adobe_marker = FALSE; /* write no Adobe marker by default */ 00417 00418 switch (colorspace) { 00419 case JCS_GRAYSCALE: 00420 cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */ 00421 cinfo->num_components = 1; 00422 /* JFIF specifies component ID 1 */ 00423 SET_COMP(0, 1, 1,1, 0, 0,0); 00424 break; 00425 case JCS_RGB: 00426 cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag RGB */ 00427 cinfo->num_components = 3; 00428 SET_COMP(0, 0x52 /* 'R' */, 1,1, 0, 0,0); 00429 SET_COMP(1, 0x47 /* 'G' */, 1,1, 0, 0,0); 00430 SET_COMP(2, 0x42 /* 'B' */, 1,1, 0, 0,0); 00431 break; 00432 case JCS_YCbCr: 00433 cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */ 00434 cinfo->num_components = 3; 00435 /* JFIF specifies component IDs 1,2,3 */ 00436 /* We default to 2x2 subsamples of chrominance */ 00437 SET_COMP(0, 1, 2,2, 0, 0,0); 00438 SET_COMP(1, 2, 1,1, 1, 1,1); 00439 SET_COMP(2, 3, 1,1, 1, 1,1); 00440 break; 00441 case JCS_CMYK: 00442 cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag CMYK */ 00443 cinfo->num_components = 4; 00444 SET_COMP(0, 0x43 /* 'C' */, 1,1, 0, 0,0); 00445 SET_COMP(1, 0x4D /* 'M' */, 1,1, 0, 0,0); 00446 SET_COMP(2, 0x59 /* 'Y' */, 1,1, 0, 0,0); 00447 SET_COMP(3, 0x4B /* 'K' */, 1,1, 0, 0,0); 00448 break; 00449 case JCS_YCCK: 00450 cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag YCCK */ 00451 cinfo->num_components = 4; 00452 SET_COMP(0, 1, 2,2, 0, 0,0); 00453 SET_COMP(1, 2, 1,1, 1, 1,1); 00454 SET_COMP(2, 3, 1,1, 1, 1,1); 00455 SET_COMP(3, 4, 2,2, 0, 0,0); 00456 break; 00457 case JCS_UNKNOWN: 00458 cinfo->num_components = cinfo->input_components; 00459 if (cinfo->num_components < 1 || cinfo->num_components > MAX_COMPONENTS) 00460 ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components, 00461 MAX_COMPONENTS); 00462 for (ci = 0; ci < cinfo->num_components; ci++) { 00463 SET_COMP(ci, ci, 1,1, 0, 0,0); 00464 } 00465 break; 00466 default: 00467 ERREXIT(cinfo, JERR_BAD_J_COLORSPACE); 00468 } 00469 } |
|
Definition at line 268 of file jcparam.c. References BITS_IN_JSAMPLE, jpeg_compress_struct::comp_info, CSTATE_START, ERREXIT1, i, JDCT_DEFAULT, jpeg_default_colorspace(), jpeg_set_quality(), JPOOL_PERMANENT, MAX_COMPONENTS, NUM_ARITH_TBLS, SIZEOF, and std_huff_tables(). Referenced by jpeg_copy_critical_parameters(), and write_JPEG_file().
00269 { 00270 int i; 00271 00272 /* Safety check to ensure start_compress not called yet. */ 00273 if (cinfo->global_state != CSTATE_START) 00274 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); 00275 00276 /* Allocate comp_info array large enough for maximum component count. 00277 * Array is made permanent in case application wants to compress 00278 * multiple images at same param settings. 00279 */ 00280 if (cinfo->comp_info == NULL) 00281 cinfo->comp_info = (jpeg_component_info *) 00282 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, 00283 MAX_COMPONENTS * SIZEOF(jpeg_component_info)); 00284 00285 /* Initialize everything not dependent on the color space */ 00286 00287 cinfo->data_precision = BITS_IN_JSAMPLE; 00288 /* Set up two quantization tables using default quality of 75 */ 00289 jpeg_set_quality(cinfo, 75, TRUE); 00290 /* Set up two Huffman tables */ 00291 std_huff_tables(cinfo); 00292 00293 /* Initialize default arithmetic coding conditioning */ 00294 for (i = 0; i < NUM_ARITH_TBLS; i++) { 00295 cinfo->arith_dc_L[i] = 0; 00296 cinfo->arith_dc_U[i] = 1; 00297 cinfo->arith_ac_K[i] = 5; 00298 } 00299 00300 /* Default is no multiple-scan output */ 00301 cinfo->scan_info = NULL; 00302 cinfo->num_scans = 0; 00303 00304 /* Expect normal source image, not raw downsampled data */ 00305 cinfo->raw_data_in = FALSE; 00306 00307 /* Use Huffman coding, not arithmetic coding, by default */ 00308 cinfo->arith_code = FALSE; 00309 00310 /* By default, don't do extra passes to optimize entropy coding */ 00311 cinfo->optimize_coding = FALSE; 00312 /* The standard Huffman tables are only valid for 8-bit data precision. 00313 * If the precision is higher, force optimization on so that usable 00314 * tables will be computed. This test can be removed if default tables 00315 * are supplied that are valid for the desired precision. 00316 */ 00317 if (cinfo->data_precision > 8) 00318 cinfo->optimize_coding = TRUE; 00319 00320 /* By default, use the simpler non-cosited sampling alignment */ 00321 cinfo->CCIR601_sampling = FALSE; 00322 00323 /* No input smoothing */ 00324 cinfo->smoothing_factor = 0; 00325 00326 /* DCT algorithm preference */ 00327 cinfo->dct_method = JDCT_DEFAULT; 00328 00329 /* No restart markers */ 00330 cinfo->restart_interval = 0; 00331 cinfo->restart_in_rows = 0; 00332 00333 /* Fill in default JFIF marker parameters. Note that whether the marker 00334 * will actually be written is determined by jpeg_set_colorspace. 00335 * 00336 * By default, the library emits JFIF version code 1.01. 00337 * An application that wants to emit JFIF 1.02 extension markers should set 00338 * JFIF_minor_version to 2. We could probably get away with just defaulting 00339 * to 1.02, but there may still be some decoders in use that will complain 00340 * about that; saying 1.01 should minimize compatibility problems. 00341 */ 00342 cinfo->JFIF_major_version = 1; /* Default JFIF version = 1.01 */ 00343 cinfo->JFIF_minor_version = 1; 00344 cinfo->density_unit = 0; /* Pixel size is unknown by default */ 00345 cinfo->X_density = 1; /* Pixel aspect ratio is square by default */ 00346 cinfo->Y_density = 1; 00347 00348 /* Choose JPEG colorspace based on input space, set defaults accordingly */ 00349 00350 jpeg_default_colorspace(cinfo); 00351 } |
|
Definition at line 64 of file jcparam.c. References jpeg_add_quant_table(). Referenced by jpeg_set_quality().
00071 { 00072 /* These are the sample quantization tables given in JPEG spec section K.1. 00073 * The spec says that the values given produce "good" quality, and 00074 * when divided by 2, "very good" quality. 00075 */ 00076 static const unsigned int std_luminance_quant_tbl[DCTSIZE2] = { 00077 16, 11, 10, 16, 24, 40, 51, 61, 00078 12, 12, 14, 19, 26, 58, 60, 55, 00079 14, 13, 16, 24, 40, 57, 69, 56, 00080 14, 17, 22, 29, 51, 87, 80, 62, 00081 18, 22, 37, 56, 68, 109, 103, 77, 00082 24, 35, 55, 64, 81, 104, 113, 92, 00083 49, 64, 78, 87, 103, 121, 120, 101, 00084 72, 92, 95, 98, 112, 100, 103, 99 00085 }; 00086 static const unsigned int std_chrominance_quant_tbl[DCTSIZE2] = { 00087 17, 18, 24, 47, 99, 99, 99, 99, 00088 18, 21, 26, 66, 99, 99, 99, 99, 00089 24, 26, 56, 99, 99, 99, 99, 99, 00090 47, 66, 99, 99, 99, 99, 99, 99, 00091 99, 99, 99, 99, 99, 99, 99, 99, 00092 99, 99, 99, 99, 99, 99, 99, 99, 00093 99, 99, 99, 99, 99, 99, 99, 99, 00094 99, 99, 99, 99, 99, 99, 99, 99 00095 }; 00096 00097 /* Set up two quantization tables using the specified scaling */ 00098 jpeg_add_quant_table(cinfo, 0, std_luminance_quant_tbl, 00099 scale_factor, force_baseline); 00100 jpeg_add_quant_table(cinfo, 1, std_chrominance_quant_tbl, 00101 scale_factor, force_baseline); 00102 } |
|
Definition at line 132 of file jcparam.c. References jpeg_quality_scaling(), jpeg_set_linear_quality(), and quality. Referenced by jpeg_set_defaults(), and write_JPEG_file().
00138 { 00139 /* Convert user 0-100 rating to percentage scaling */ 00140 quality = jpeg_quality_scaling(quality); 00141 00142 /* Set up standard quality tables */ 00143 jpeg_set_linear_quality(cinfo, quality, force_baseline); 00144 } |
|
Definition at line 537 of file jcparam.c. References CSTATE_START, ERREXIT1, fill_a_scan(), fill_dc_scans(), fill_scans(), JCS_YCbCr, jpeg_compress_struct::jpeg_color_space, JPOOL_PERMANENT, MAX, MAX_COMPS_IN_SCAN, jpeg_compress_struct::num_components, jpeg_compress_struct::num_scans, jpeg_compress_struct::scan_info, jpeg_compress_struct::script_space, jpeg_compress_struct::script_space_size, and SIZEOF. Referenced by parse_switches().
00538 { 00539 int ncomps = cinfo->num_components; 00540 int nscans; 00541 jpeg_scan_info * scanptr; 00542 00543 /* Safety check to ensure start_compress not called yet. */ 00544 if (cinfo->global_state != CSTATE_START) 00545 ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); 00546 00547 /* Figure space needed for script. Calculation must match code below! */ 00548 if (ncomps == 3 && cinfo->jpeg_color_space == JCS_YCbCr) { 00549 /* Custom script for YCbCr color images. */ 00550 nscans = 10; 00551 } else { 00552 /* All-purpose script for other color spaces. */ 00553 if (ncomps > MAX_COMPS_IN_SCAN) 00554 nscans = 6 * ncomps; /* 2 DC + 4 AC scans per component */ 00555 else 00556 nscans = 2 + 4 * ncomps; /* 2 DC scans; 4 AC scans per component */ 00557 } 00558 00559 /* Allocate space for script. 00560 * We need to put it in the permanent pool in case the application performs 00561 * multiple compressions without changing the settings. To avoid a memory 00562 * leak if jpeg_simple_progression is called repeatedly for the same JPEG 00563 * object, we try to re-use previously allocated space, and we allocate 00564 * enough space to handle YCbCr even if initially asked for grayscale. 00565 */ 00566 if (cinfo->script_space == NULL || cinfo->script_space_size < nscans) { 00567 cinfo->script_space_size = MAX(nscans, 10); 00568 cinfo->script_space = (jpeg_scan_info *) 00569 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, 00570 cinfo->script_space_size * SIZEOF(jpeg_scan_info)); 00571 } 00572 scanptr = cinfo->script_space; 00573 cinfo->scan_info = scanptr; 00574 cinfo->num_scans = nscans; 00575 00576 if (ncomps == 3 && cinfo->jpeg_color_space == JCS_YCbCr) { 00577 /* Custom script for YCbCr color images. */ 00578 /* Initial DC scan */ 00579 scanptr = fill_dc_scans(scanptr, ncomps, 0, 1); 00580 /* Initial AC scan: get some luma data out in a hurry */ 00581 scanptr = fill_a_scan(scanptr, 0, 1, 5, 0, 2); 00582 /* Chroma data is too small to be worth expending many scans on */ 00583 scanptr = fill_a_scan(scanptr, 2, 1, 63, 0, 1); 00584 scanptr = fill_a_scan(scanptr, 1, 1, 63, 0, 1); 00585 /* Complete spectral selection for luma AC */ 00586 scanptr = fill_a_scan(scanptr, 0, 6, 63, 0, 2); 00587 /* Refine next bit of luma AC */ 00588 scanptr = fill_a_scan(scanptr, 0, 1, 63, 2, 1); 00589 /* Finish DC successive approximation */ 00590 scanptr = fill_dc_scans(scanptr, ncomps, 1, 0); 00591 /* Finish AC successive approximation */ 00592 scanptr = fill_a_scan(scanptr, 2, 1, 63, 1, 0); 00593 scanptr = fill_a_scan(scanptr, 1, 1, 63, 1, 0); 00594 /* Luma bottom bit comes last since it's usually largest scan */ 00595 scanptr = fill_a_scan(scanptr, 0, 1, 63, 1, 0); 00596 } else { 00597 /* All-purpose script for other color spaces. */ 00598 /* Successive approximation first pass */ 00599 scanptr = fill_dc_scans(scanptr, ncomps, 0, 1); 00600 scanptr = fill_scans(scanptr, ncomps, 1, 5, 0, 2); 00601 scanptr = fill_scans(scanptr, ncomps, 6, 63, 0, 2); 00602 /* Successive approximation second pass */ 00603 scanptr = fill_scans(scanptr, ncomps, 1, 63, 2, 1); 00604 /* Successive approximation final pass */ 00605 scanptr = fill_dc_scans(scanptr, ncomps, 1, 0); 00606 scanptr = fill_scans(scanptr, ncomps, 1, 63, 1, 0); 00607 } 00608 } |
|
Definition at line 182 of file jcparam.c. References jpeg_compress_struct::ac_huff_tbl_ptrs, add_huff_table(), jpeg_compress_struct::dc_huff_tbl_ptrs, and UINT8. Referenced by jpeg_set_defaults().
00184 : these are only valid for 8-bit data precision! */ 00185 { 00186 static const UINT8 bits_dc_luminance[17] = 00187 { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 }; 00188 static const UINT8 val_dc_luminance[] = 00189 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 }; 00190 00191 static const UINT8 bits_dc_chrominance[17] = 00192 { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 }; 00193 static const UINT8 val_dc_chrominance[] = 00194 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 }; 00195 00196 static const UINT8 bits_ac_luminance[17] = 00197 { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d }; 00198 static const UINT8 val_ac_luminance[] = 00199 { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 00200 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07, 00201 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08, 00202 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0, 00203 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16, 00204 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28, 00205 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 00206 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 00207 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 00208 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 00209 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 00210 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 00211 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 00212 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 00213 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 00214 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5, 00215 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 00216 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2, 00217 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 00218 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 00219 0xf9, 0xfa }; 00220 00221 static const UINT8 bits_ac_chrominance[17] = 00222 { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 }; 00223 static const UINT8 val_ac_chrominance[] = 00224 { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21, 00225 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71, 00226 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 00227 0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0, 00228 0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34, 00229 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26, 00230 0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38, 00231 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 00232 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 00233 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 00234 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 00235 0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 00236 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 00237 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 00238 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 00239 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 00240 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 00241 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 00242 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 00243 0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 00244 0xf9, 0xfa }; 00245 00246 add_huff_table(cinfo, &cinfo->dc_huff_tbl_ptrs[0], 00247 bits_dc_luminance, val_dc_luminance); 00248 add_huff_table(cinfo, &cinfo->ac_huff_tbl_ptrs[0], 00249 bits_ac_luminance, val_ac_luminance); 00250 add_huff_table(cinfo, &cinfo->dc_huff_tbl_ptrs[1], 00251 bits_dc_chrominance, val_dc_chrominance); 00252 add_huff_table(cinfo, &cinfo->ac_huff_tbl_ptrs[1], 00253 bits_ac_chrominance, val_ac_chrominance); 00254 } |