/* This program is part of the TACLeBench benchmark suite. Version V 2.0 Name: jpeglib Author: Thomas G. Lane Function: This file defines the application interface for the JPEG library. Most applications using the library need only include this file, and perhaps jerror.h if they want to know the exact error codes. Source: MediaBench II http://euler.slu.edu/~fritts/mediabench (mirror) Original name: cjpeg Changes: No major functional changes. License: See the accompanying README file. */ #ifndef JPEGLIB_H #define JPEGLIB_H /* Various constants determining the sizes of things. All of these are specified by the JPEG standard, so don't change them if you want to be compatible. */ /* The basic DCT block is 8x8 samples */ #define DCTSIZE 8 /* DCTSIZE squared; # of elements in a block */ #define DCTSIZE2 64 /* Data structures for images (arrays of samples and of DCT coefficients). On 80x86 machines, the image arrays are too big for near pointers, but the pointer arrays can fit in near memory. */ /* ptr to one image row of pixel samples. */ typedef unsigned char *JSAMPROW; /* ptr to some rows (a 2-D sample array) */ typedef JSAMPROW *JSAMPARRAY; /* one block of coefficients */ typedef signed char JBLOCK[DCTSIZE2]; /* pointer to one row of coefficient blocks */ typedef JBLOCK *JBLOCKROW; /* a 2-D array of coefficient blocks */ typedef JBLOCKROW *JBLOCKARRAY; /* useful in a couple of places */ typedef signed char *JCOEFPTR; /* DCT coefficient quantization tables. */ typedef struct { /* quantization step for each coefficient */ /* This array gives the coefficient quantizers in natural array order (not the zigzag order in which they are stored in a JPEG DQT marker). CAUTION: IJG versions prior to v6a kept this array in zigzag order. */ unsigned short quantval[ DCTSIZE2 ]; /* 1 when table has been output */ /* This field is used only during compression. It's initialized 0 when the table is created, and set 1 when it's been output to the file. You could suppress output of a table by setting this to 1. (See jpeg_suppress_tables for an example.) */ int sent_table; } JQUANT_TBL; /* Huffman coding tables. */ typedef struct { /* These two fields directly represent the contents of a JPEG DHT marker */ /* bits[k] = # of symbols with codes of */ /* length k bits; bits[0] is unused */ unsigned char bits[ 17 ]; /* The symbols, in order of incr code length */ /* This field is used only during compression. It's initialized 0 when the table is created, and set 1 when it's been output to the file. You could suppress output of a table by setting this to 1. (See jpeg_suppress_tables for an example.) */ unsigned char huffval[ 256 ]; /* 1 when table has been output */ int sent_table; } JHUFF_TBL; /* Basic info about one component (color channel). */ typedef struct { /* These values are fixed over the whole image. For compression, they must be supplied by parameter setup; for decompression, they are read from the SOF marker. */ /* identifier for this component (0..255) */ int component_id; /* its index in SOF or cinfo->comp_info[] */ int component_index; /* horizontal sampling factor (1..4) */ int h_samp_factor; /* vertical sampling factor (1..4) */ int v_samp_factor; /* quantization table selector (0..3) */ int quant_tbl_no; /* These values may vary between scans. For compression, they must be supplied by parameter setup; for decompression, they are read from the SOS marker. The decompressor output side may not use these variables. */ /* DC entropy table selector (0..3) */ int dc_tbl_no; /* AC entropy table selector (0..3) */ int ac_tbl_no; /* Remaining fields should be treated as private by applications. */ /* These values are computed during compression or decompression startup: Component's size in DCT blocks. Any dummy blocks added to complete an MCU are not counted; therefore these values do not depend on whether a scan is interleaved or not. */ unsigned int width_in_blocks; unsigned int height_in_blocks; /* Size of a DCT block in samples. Always DCTSIZE for compression. For decompression this is the size of the output from one DCT block, reflecting any scaling we choose to apply during the IDCT step. Values of 1,2,4,8 are likely to be supported. Note that different components may receive different IDCT scalings. */ int DCT_scaled_size; /* The downsampled dimensions are the component's actual, unpadded number of samples at the main buffer (preprocessing/compression interface), thus downsampled_width = ceil(image_width * Hi/Hmax) and similarly for height. For decompression, IDCT scaling is included, so downsampled_width = ceil(image_width * Hi/Hmax * DCT_scaled_size/DCTSIZE) */ /* actual width in samples */ unsigned int downsampled_width; /* actual height in samples */ unsigned int downsampled_height; /* This flag is used only for decompression. In cases where some of the components will be ignored (eg grayscale output from YCbCr image), we can skip most computations for the unused components. */ /* do we need the value of this component? */ int component_needed; /* These values are computed before starting a scan of the component. The decompressor output side may not use these variables. */ /* number of blocks per MCU, horizontally */ int MCU_width; /* number of blocks per MCU, vertically */ int MCU_height; /* MCU_width * MCU_height */ int MCU_blocks; /* MCU width in samples, MCU_width*DCT_scaled_size */ int MCU_sample_width; /* # of non-dummy blocks across in last MCU */ int last_col_width; /* # of non-dummy blocks down in last MCU */ int last_row_height; /* Saved quantization table for component; (void*)0 if none yet saved. See jdinput.c comments about the need for this information. This field is currently used only for decompression. */ JQUANT_TBL *quant_table; /* Private per-component storage for DCT or IDCT subsystem. */ void *dct_table; } jpeg_component_info; /* The script for encoding a multiple-scan file is an array of these: */ typedef struct { /* number of components encoded in this scan */ int comps_in_scan; /* their SOF/comp_info[] indexes */ int component_index[ 4 ]; /* progressive JPEG spectral selection parms */ int Ss, Se; /* progressive JPEG successive approx. parms */ int Ah, Al; } jpeg_scan_info; /* Known color spaces. */ typedef enum { /* error/unspecified */ JCS_UNKNOWN, /* monochrome */ JCS_GRAYSCALE, /* red/green/blue */ JCS_RGB, /* Y/Cb/Cr (also known as YUV) */ JCS_YCbCr, /* C/M/Y/K */ JCS_CMYK, /* Y/Cb/Cr/K */ JCS_YCCK } J_COLOR_SPACE; /* DCT/IDCT algorithm options. */ typedef enum { /* slow but accurate integer algorithm */ JDCT_ISLOW,
generated by cgit v1.2.2 (git 2.25.0) at 2026-10-12 21:40:45 -0400
/\ struct jpeg_error_mgr *err; \ /* Memory manager module */\ struct jpeg_memory_mgr *mem; \ /* Progress monitor, or (void*)0 if none */\ struct jpeg_progress_mgr *progress; \ /* Available for use by application */\ void *client_data; \ /* So common code can tell which is which */\ int is_decompressor; \ /* For checking call sequence validity */\ int global_state /* Routines that are to be used by both halves of the library are declared to receive a pointer to this structure. There are no actual instances of jpeg_common_struct, only of jpeg_compress_struct and jpeg_decompress_struct. */ struct jpeg_common_struct { /* Fields common to both master struct types */ jpeg_common_fields; /* Additional fields follow in an actual jpeg_compress_struct or jpeg_decompress_struct. All three structs must agree on these initial fields! (This would be a lot cleaner in C++.) */ }; typedef struct jpeg_common_struct *j_common_ptr; typedef struct jpeg_compress_struct *j_compress_ptr; typedef struct jpeg_decompress_struct *j_decompress_ptr; /* Master record for a compression instance */ struct jpeg_compress_struct { /* Fields shared with jpeg_decompress_struct */ jpeg_common_fields; /* Destination for compressed data */ struct jpeg_destination_mgr *dest; /* Description of source image --- these fields must be filled in by outer application before starting compression. in_color_space must be correct before you can even call jpeg_set_defaults(). */ /* input image width */ unsigned int image_width; /* input image height */ unsigned int image_height; /* # of color components in input image */ int input_components; /* colorspace of input image */ J_COLOR_SPACE in_color_space; /* image gamma of input image */ double input_gamma; /* Compression parameters --- these fields must be set before calling jpeg_start_compress(). We recommend calling jpeg_set_defaults() to initialize everything to reasonable defaults, then changing anything the application specifically wants to change. That way you won't get burnt when new parameters are added. Also note that there are several helper routines to simplify changing parameters. */ /* bits of precision in image data */ int data_precision; /* # of color components in JPEG image */ int num_components; /* colorspace of JPEG image */ J_COLOR_SPACE jpeg_color_space; /* comp_info[i] describes component that appears i'th in SOF */ jpeg_component_info *comp_info; /* ptrs to coefficient quantization tables, or (void*)0 if not defined */ JQUANT_TBL *quant_tbl_ptrs[ 4 ]; /* ptrs to Huffman coding tables, or (void*)0 if not defined */ JHUFF_TBL *dc_huff_tbl_ptrs[ 4 ]; JHUFF_TBL *ac_huff_tbl_ptrs[ 4 ]; /* L values for DC arith-coding tables */ unsigned char arith_dc_L[ 16 ]; /* U values for DC arith-coding tables */ unsigned char arith_dc_U[ 16 ]; /* Kx values for AC arith-coding tables */ unsigned char arith_ac_K[ 16 ]; /* # of entries in scan_info array */ int num_scans; /* script for multi-scan file, or (void*)0 The default value of scan_info is (void*)0, which causes a single-scan sequential JPEG file to be emitted. To create a multi-scan file, set num_scans and scan_info to point to an array of scan definitions. */ const jpeg_scan_info *scan_info; /* 1=caller supplies downsampled data */ int raw_data_in; /* 1=arithmetic coding, 0=Huffman */ int arith_code; /* 1=optimize entropy encoding parms */ int optimize_coding; /* 1=first samples are cosited */ int CCIR601_sampling; /* 1..100, or 0 for no input smoothing */ int smoothing_factor; /* DCT algorithm selector */ J_DCT_METHOD dct_method; /* The restart interval can be specified in absolute MCUs by setting restart_interval, or in MCU rows by setting restart_in_rows (in which case the correct restart_interval will be figured for each scan). */ /* MCUs per restart, or 0 for no restart */ unsigned int restart_interval; /* if > 0, MCU rows per restart interval */ int restart_in_rows; /* Parameters controlling emission of special markers. */ /* should a JFIF marker be written? */ int write_JFIF_header; /* What to write for the JFIF version number */ unsigned char JFIF_major_version; unsigned char JFIF_minor_version; /* These three values are not used by the JPEG code, merely copied into the JFIF APP0 marker. density_unit can be 0 for unknown, 1 for dots/inch, or 2 for dots/cm. Note that the pixel aspect ratio is defined by X_density/Y_density even when density_unit=0. */ /* JFIF code for pixel size units */ unsigned char density_unit; /* Horizontal pixel density */ unsigned short X_density; /* Vertical pixel density */ unsigned short Y_density; /* should an Adobe marker be written? */ int write_Adobe_marker; /* State variable: index of next scanline to be written to jpeg_write_scanlines(). Application may use this to control its processing loop, e.g., "while (next_scanline < image_height)". */ /* 0 .. image_height-1 */ unsigned int next_scanline; /* Remaining fields are known throughout compressor, but generally should not be touched by a surrounding application. */ /* These fields are computed during compression startup */ /* 1 if scan script uses progressive mode */ int progressive_mode; /* largest h_samp_factor */ int max_h_samp_factor; /* largest v_samp_factor */ int max_v_samp_factor; /* # of iMCU rows to be input to coef ctlr The coefficient controller receives data in units of MCU rows as defined for fully interleaved scans (whether the JPEG file is interleaved or not). There are v_samp_factor * DCTSIZE sample rows of each component in an "iMCU" (interleaved MCU) row. */ unsigned int total_iMCU_rows; /* These fields are valid during any one scan. They describe the components and MCUs actually appearing in the scan. */ /* # of JPEG components in this scan */ int comps_in_scan; /* *cur_comp_info[i] describes component that appears i'th in SOS */ jpeg_component_info *cur_comp_info[ 4 ]; /* # of MCUs across the image */ unsigned int MCUs_per_row; /* # of MCU rows in the image */ unsigned int MCU_rows_in_scan; /* # of DCT blocks per MCU */ int blocks_in_MCU; /* MCU_membership[i] is index in cur_comp_info of component owning i'th block in an MCU */ int MCU_membership[ 10 ]; /* progressive JPEG parameters for scan */ int Ss, Se, Ah, Al; /* Links to compression subobjects (methods and private variables of modules) */ struct jpeg_comp_master *master; struct jpeg_c_main_controller *main; struct jpeg_c_prep_controller *prep; struct jpeg_c_coef_controller *coef; struct jpeg_marker_writer *marker; struct jpeg_color_converter *cconvert; struct jpeg_downsampler *downsample; struct jpeg_forward_dct *fdct; struct jpeg_entropy_encoder *entropy; /* workspace for jpeg_simple_progression */ jpeg_scan_info *script_space; int script_space_size; }; /* "Object" declarations for JPEG modules that may be supplied or called directly by the surrounding application. As with all objects in the JPEG library, these structs only define the publicly visible methods and state variables of a module. Additional private fields may exist after the public ones. */ /* Error handler object */ struct jpeg_error_mgr { /* Error exit handler: does not return to caller */ void ( *error_exit ) ( j_common_ptr cinfo ); /* Conditionally emit a trace or warning message */ void ( *emit_message ) ( j_common_ptr cinfo, int msg_level ); /* Routine that actually outputs a trace or error message */ void ( *output_message ) ( j_common_ptr cinfo ); /* Format a message string for the most recent JPEG error or message */ void ( *format_message ) ( j_common_ptr cinfo, char *buffer ); /* Reset error state variables at start of a new image */ void ( *reset_error_mgr ) ( j_common_ptr cinfo ); /* The message ID code and any parameters are saved here. A message can have one string parameter or up to 8 int parameters. */ int msg_code; union { int i[ 8 ]; char s[ 80 ]; } msg_parm; /* Standard state variables for error facility */ /* max msg_level that will be displayed */ int trace_level; /* For recoverable corrupt-data errors, we emit a warning message, but keep going unless emit_message chooses to abort. emit_message should count warnings in num_warnings. The surrounding application can check for bad data by seeing if num_warnings is nonzero at the end of processing. */ /* number of corrupt-data warnings */ long num_warnings; /* These fields point to the table(s) of error message strings. An application can change the table pointer to switch to a different message list (typically, to change the language in which errors are reported). Some applications may wish to add additional error codes that will be handled by the JPEG library error mechanism; the second table pointer is used for this purpose. First table includes all errors generated by JPEG library itself. Error code 0 is reserved for a "no such error string" message. */ /* Library errors */ const char *const *jpeg_message_table; /* Table contains strings 0..last_jpeg_message */ int last_jpeg_message; /* Second table can be added by application (see cjpeg/djpeg for example). It contains strings numbered first_addon_message..last_addon_message. */ /* Non-library errors */ const char *const *addon_message_table; /* code for first string in addon table */ int first_addon_message; /* code for last string in addon table */ int last_addon_message; }; /* Progress monitor object */ struct jpeg_progress_mgr { void ( *progress_monitor ) ( j_common_ptr cinfo ); /* work units completed in this pass */ long pass_counter; /* total number of work units in this pass */ long pass_limit; /* passes completed so far */ int completed_passes; /* total number of passes expected */ int total_passes; }; /* Data destination object for compression */ struct jpeg_destination_mgr { /* => next byte to write in buffer */ unsigned char *next_output_byte; /* # of byte spaces remaining in buffer */ long unsigned int free_in_buffer; void ( *init_destination ) ( j_compress_ptr cinfo ); int ( *empty_output_buffer ) ( j_compress_ptr cinfo ); void ( *term_destination ) ( j_compress_ptr cinfo ); }; /* Memory manager object. Allocates "small" objects (a few K total), "large" objects (tens of K), and "really big" objects (virtual arrays with backing store if needed). The memory manager does not allow individual objects to be freed; rather, each created object is assigned to a pool, and whole pools can be freed at once. This is faster and more convenient than remembering exactly what to free, especially where malloc()/free() are not too speedy. NB: alloc routines never return (void*)0. They exit to error_exit if not successful. */ typedef struct jvirt_sarray_control *jvirt_sarray_ptr; typedef struct jvirt_barray_control *jvirt_barray_ptr; struct jpeg_memory_mgr { /* Method pointers */ void *( *alloc_small ) ( j_common_ptr cinfo, int pool_id, long unsigned int sizeofobject ); void *( *alloc_large ) ( j_common_ptr cinfo, int pool_id, long unsigned int sizeofobject ); JSAMPARRAY ( *alloc_sarray ) ( j_common_ptr cinfo, int pool_id, unsigned int samplesperrow, unsigned int numrows ); JBLOCKARRAY ( *alloc_barray )( j_common_ptr cinfo, int pool_id, unsigned int blocksperrow, unsigned int numrows ); jvirt_sarray_ptr ( *request_virt_sarray ) ( j_common_ptr cinfo, int pool_id, int pre_zero, unsigned int samplesperrow, unsigned int numrows, unsigned int maxaccess ); jvirt_barray_ptr ( *request_virt_barray ) ( j_common_ptr cinfo, int pool_id, int pre_zero, unsigned int blocksperrow, unsigned int numrows, unsigned int maxaccess ); void ( *realize_virt_arrays ) ( j_common_ptr cinfo ); JSAMPARRAY ( *access_virt_sarray ) ( j_common_ptr cinfo, jvirt_sarray_ptr ptr, unsigned int start_row, unsigned int num_rows, int writable ); JBLOCKARRAY ( *access_virt_barray ) ( j_common_ptr cinfo, jvirt_barray_ptr ptr, unsigned int start_row, unsigned int num_rows, int writable ); void ( *free_pool ) ( j_common_ptr cinfo, int pool_id ); void ( *self_destruct ) ( j_common_ptr cinfo ); /* Limit on memory allocation for this JPEG object. (Note that this is merely advisory, not a guaranteed maximum; it only affects the space used for virtual-array buffers.) May be changed by outer application after creating the JPEG object. */ long max_memory_to_use; /* Maximum allocation request accepted by alloc_large. */ long max_alloc_chunk; }; #endif /* JPEGLIB_H */