Unit JPEGLib

Classes

Functions

Types

byteptr
coef_bits_field
coef_bits_ptr
coef_bits_ptrfield
coef_bits_ptrrow
int8array
inverse_DCT_method_ptr
JBLOCK
JBLOCKARRAY
JBLOCKIMAGE
JBLOCKROW
JBLOCKROW_PTR
JBLOCK_ARRAY
JBLOCK_IMAGE
JBLOCK_PTR
JBLOCK_ROWS
JByteArray
JBytePtr
JCOEFPTR
JCOEF_ROW
JHUFF_TBL
JHUFF_TBL_FIELD
JHUFF_TBL_PTR
jpeg_color_converter
jpeg_color_converter_ptr
jpeg_color_deconverter
jpeg_color_deconverter_ptr
jpeg_color_quantizer
jpeg_color_quantizer_ptr
jpeg_common_struct
jpeg_component_info
jpeg_component_info_array
jpeg_component_info_list_ptr
jpeg_component_info_ptr
jpeg_compress_struct
jpeg_comp_master
jpeg_comp_master_ptr
jpeg_c_coef_controller
jpeg_c_coef_controller_ptr
jpeg_c_main_controller
jpeg_c_main_controller_ptr
jpeg_c_prep_controller
jpeg_c_prep_controller_ptr
jpeg_decompress_struct
jpeg_decomp_master
jpeg_decomp_master_ptr
jpeg_destination_mgr
jpeg_destination_mgr_ptr
jpeg_downsampler
jpeg_downsampler_ptr
jpeg_d_coef_controller
jpeg_d_coef_controller_ptr
jpeg_d_main_controller
jpeg_d_main_controller_ptr
jpeg_d_post_controller
jpeg_d_post_controller_ptr
jpeg_entropy_decoder
jpeg_entropy_decoder_ptr
jpeg_entropy_encoder
jpeg_entropy_encoder_ptr
jpeg_error_mgr
jpeg_error_mgr_ptr
jpeg_forward_dct
jpeg_forward_dct_ptr
jpeg_input_controller
jpeg_input_controller_ptr
jpeg_inverse_dct
jpeg_inverse_dct_ptr
jpeg_marker_parser_method
jpeg_marker_reader
jpeg_marker_reader_ptr
jpeg_marker_writer
jpeg_marker_writer_ptr
jpeg_memory_mgr
jpeg_memory_mgr_ptr
jpeg_progress_mgr
jpeg_progress_mgr_ptr
jpeg_scan_info
jpeg_scan_info_ptr
jpeg_source_mgr
jpeg_source_mgr_ptr
jpeg_upsampler
jpeg_upsampler_ptr
JQUANT_TBL
JQUANT_TBL_FIELD
JQUANT_TBL_PTR
JSAMPARRAY
JSAMPIMAGE
JSAMPLE_ARRAY
JSAMPLE_PTR
JSAMPROW
JSAMPROW_ARRAY
JSAMPROW_PTR
JSAMP_ARRAY
jTArray
jTBlockArray
jTBlockImage
jTBlockRow
jTByte
jTCinfo
jTCoef
jTRow
jTSample
jvirt_barray_tbl
jvirt_barray_tbl_ptr
J_BUF_MODE
J_COLOR_SPACE
j_common_ptr
j_compress_ptr
J_DCT_METHOD
j_decompress_ptr
J_DITHER_MODE
range_limit_table
range_limit_table_ptr
TEMP_STRING

Constants

CSTATE_RAW_OK
CSTATE_SCANNING
CSTATE_START
CSTATE_WRCOEFS
C_MAX_BLOCKS_IN_MCU
DCTSIZE
DCTSIZE2
DSTATE_BUFIMAGE
DSTATE_BUFPOST
DSTATE_INHEADER
DSTATE_PRELOAD
DSTATE_PRESCAN
DSTATE_RAW_OK
DSTATE_RDCOEFS
DSTATE_READY
DSTATE_SCANNING
DSTATE_START
DSTATE_STOPPING
D_MAX_BLOCKS_IN_MCU
JDCT_DEFAULT
JDCT_FASTEST
JMSG_LENGTH_MAX
JMSG_STR_PARM_MAX
JPEG_APP0
JPEG_COM
JPEG_EOI
JPEG_HEADER_OK
JPEG_HEADER_TABLES_ONLY
JPEG_LIB_VERSION
JPEG_REACHED_EOI
JPEG_REACHED_SOS
JPEG_ROW_COMPLETED
JPEG_RST0
JPEG_SCAN_COMPLETED
JPEG_SUSPENDED
JPOOL_IMAGE
JPOOL_NUMPOOLS
JPOOL_PERMANENT
MAX_COMPS_IN_SCAN
MAX_SAMP_FACTOR
NUM_ARITH_TBLS
NUM_HUFF_TBLS
NUM_QUANT_TBLS
TEMP_NAME_LENGTH

Variables


Functions


Types


byteptr = ^byte

coef_bits_field = Array[0..DCTSIZE2-1] of int;
@\\\*) { Master record for a decompression instance
coef_bits_ptr = ^coef_bits_field

coef_bits_ptrfield =  Array[0..MAX_COMPS_IN_SCAN-1] of coef_bits_field;

coef_bits_ptrrow = ^coef_bits_ptrfield

int8array = Array[0..8-1] of longint;
@\\\*) {int8array = Array[0..8-1] of int;
inverse_DCT_method_ptr = procedure(cinfo : j_decompress_ptr;
                 compptr : jpeg_component_info_ptr;
                 coef_block : JCOEFPTR;
                 output_buf : JSAMPARRAY; output_col : JDIMENSION)
@\\\*) { Inverse DCT (also performs dequantization)
JBLOCK = Array[0..DCTSIZE2-1] of JCOEF;
a 3-D sample array: top index is color } {
JBLOCKARRAY = ^JBLOCK_ARRAY

JBLOCKIMAGE = ^JBLOCK_IMAGE

JBLOCKROW = ^JBLOCK_ROWS

JBLOCKROW_PTR = ^JBLOCKROW

JBLOCK_ARRAY = Array[jTBlockArray] of JBLOCKROW;

JBLOCK_IMAGE = Array[jTBlockImage] of JBLOCKARRAY;

JBLOCK_PTR = ^JBLOCK
one block of coefficients
JBLOCK_ROWS = Array[jTBlockRow] of JBLOCK;

JByteArray = Array[jTByte] of byte;

JBytePtr = ^JByteArray

JCOEFPTR = ^JCOEF_ROW

JCOEF_ROW = Array[jTCoef] of JCOEF;

JHUFF_TBL = record
bits : Array[0..17-1] of UINT8;
huffval : Array[0..256-1] of UINT8;
sent_table : boolean;
end;
@/// JHUFF_TBL = record
JHUFF_TBL_FIELD = Array[0..(MaxInt div SizeOf(JHUFF_TBL))-1] of JHUFF_TBL;
@\\\
JHUFF_TBL_PTR = ^JHUFF_TBL
Huffman coding tables.
jpeg_color_converter = record
start_pass : procedure(cinfo : j_compress_ptr);
color_convert : procedure(cinfo : j_compress_ptr;
input_buf : JSAMPARRAY;
output_buf : JSAMPIMAGE;
output_row : JDIMENSION;
num_rows : int);
end;

jpeg_color_converter_ptr = ^jpeg_color_converter
@\\\*) { Colorspace conversion } (*@/// jpeg_color_converter = record
jpeg_color_deconverter = record
start_pass : procedure(cinfo: j_decompress_ptr);
color_convert : procedure(cinfo : j_decompress_ptr;
input_buf : JSAMPIMAGE;
input_row : JDIMENSION;
output_buf : JSAMPARRAY;
num_rows : int);
end;

jpeg_color_deconverter_ptr = ^jpeg_color_deconverter
@\\\*) { Colorspace conversion } (*@/// jpeg_color_deconverter = record
jpeg_color_quantizer = record
start_pass : procedure(cinfo : j_decompress_ptr;
is_pre_scan : boolean);
color_quantize : procedure(cinfo : j_decompress_ptr;
input_buf : JSAMPARRAY;
output_buf : JSAMPARRAY;
num_rows : int);
finish_pass : procedure(cinfo : j_decompress_ptr);
new_color_map : procedure(cinfo : j_decompress_ptr);
end;

jpeg_color_quantizer_ptr = ^jpeg_color_quantizer
@\\\*) { Color quantization or color precision reduction } (*@/// jpeg_color_quantizer = record
jpeg_common_struct = record
err : jpeg_error_mgr_ptr;
mem : jpeg_memory_mgr_ptr;
progress : jpeg_progress_mgr_ptr;
is_decompressor : boolean;
global_state : int;
end;
@\\\*) { 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.} (*@/// jpeg_common_struct = record
jpeg_component_info = record
component_id : int;
component_index : int;
h_samp_factor : int;
v_samp_factor : int;
quant_tbl_no : int;
dc_tbl_no : int;
ac_tbl_no : int;
width_in_blocks : JDIMENSION;
height_in_blocks : JDIMENSION;
DCT_scaled_size : int;
downsampled_width : JDIMENSION;
downsampled_height : JDIMENSION;
component_needed : boolean;
MCU_width : int;
MCU_height : int;
MCU_blocks : int;
MCU_sample_width : int;
last_col_width : int;
last_row_height : int;
quant_table : JQUANT_TBL_PTR;
dct_table : pointer;
end;
@/// jpeg_component_info = record
jpeg_component_info_array = array[jTCinfo] of jpeg_component_info;

jpeg_component_info_list_ptr = ^jpeg_component_info_array

jpeg_component_info_ptr = ^jpeg_component_info
looking for EOI in jpeg_finish_decompress } (*@\\\*) { Basic info about one component (color channel).
jpeg_compress_struct = record
err : jpeg_error_mgr_ptr;
mem : jpeg_memory_mgr_ptr;
progress : ^jpeg_progress_mgr;
is_decompressor : boolean;
global_state : int;
dest : jpeg_destination_mgr_ptr;
image_width : JDIMENSION;
image_height : JDIMENSION;
input_components : int;
in_color_space : J_COLOR_SPACE;
input_gamma : double;
data_precision : int;
num_components : int;
jpeg_color_space : J_COLOR_SPACE;
comp_info : jpeg_component_info_ptr;
quant_tbl_ptrs : Array[0..NUM_QUANT_TBLS-1] of JQUANT_TBL_PTR;
dc_huff_tbl_ptrs : Array[0..NUM_HUFF_TBLS-1] of JHUFF_TBL_PTR;
ac_huff_tbl_ptrs : Array[0..NUM_HUFF_TBLS-1] of JHUFF_TBL_PTR;
arith_dc_L : Array[0..NUM_ARITH_TBLS-1] of UINT8;
arith_dc_U : Array[0..NUM_ARITH_TBLS-1] of UINT8;
arith_ac_K : Array[0..NUM_ARITH_TBLS-1] of UINT8;
num_scans : int;
scan_info : jpeg_scan_info_ptr;
raw_data_in : boolean;
arith_code : boolean;
optimize_coding : boolean;
CCIR601_sampling : boolean;
smoothing_factor : int;
dct_method : J_DCT_METHOD;
restart_interval : uint;
restart_in_rows : int;
write_JFIF_header : boolean;
density_unit : UINT8;
X_density : UINT16;
Y_density : UINT16;
write_Adobe_marker : boolean;
next_scanline : JDIMENSION;
progressive_mode : boolean;
max_h_samp_factor : int;
max_v_samp_factor : int;
total_iMCU_rows : JDIMENSION;
comps_in_scan : int;
cur_comp_info : Array[0..MAX_COMPS_IN_SCAN-1] of jpeg_component_info_ptr;
MCUs_per_row : JDIMENSION;
MCU_rows_in_scan : JDIMENSION;
blocks_in_MCU : int;
MCU_membership : Array[0..C_MAX_BLOCKS_IN_MCU-1] of int;
Ss : int;
Se : int;
Ah : int;
Al : int;
master : jpeg_comp_master_ptr;
main : jpeg_c_main_controller_ptr;
prep : jpeg_c_prep_controller_ptr;
coef : jpeg_c_coef_controller_ptr;
marker : jpeg_marker_writer_ptr;
cconvert : jpeg_color_converter_ptr;
downsample : jpeg_downsampler_ptr;
fdct : jpeg_forward_dct_ptr;
entropy : jpeg_entropy_encoder_ptr;
end;
@\\\*) { Master record for a compression instance } (*@/// jpeg_compress_struct = record
jpeg_comp_master = record
prepare_for_pass : procedure(cinfo : j_compress_ptr);
pass_startup : procedure(cinfo : j_compress_ptr);
finish_pass : procedure(cinfo : j_compress_ptr);
call_pass_startup : Boolean;
is_last_pass : Boolean;
end;

jpeg_comp_master_ptr = ^jpeg_comp_master
AM_MEMORY_MANAGER } { Declarations for compression modules } { Master control module } (*@/// jpeg_comp_master = record
jpeg_c_coef_controller = record
start_pass : procedure(cinfo : j_compress_ptr;
pass_mode : J_BUF_MODE);
compress_data : function(cinfo : j_compress_ptr;
input_buf : JSAMPIMAGE) : boolean;
end;

jpeg_c_coef_controller_ptr = ^jpeg_c_coef_controller
@\\\*) { Coefficient buffer control } (*@/// jpeg_c_coef_controller = record
jpeg_c_main_controller = record
start_pass : procedure(cinfo : j_compress_ptr;
pass_mode : J_BUF_MODE);
process_data : procedure(cinfo : j_compress_ptr;
input_buf : JSAMPARRAY;
in_row_ctr : JDIMENSION;
in_rows_avail : JDIMENSION);
end;

jpeg_c_main_controller_ptr = ^jpeg_c_main_controller
@\\\*) { Main buffer control (downsampled-data buffer) } (*@/// jpeg_c_main_controller = record
jpeg_c_prep_controller = record
start_pass : procedure(cinfo : j_compress_ptr;
pass_mode : J_BUF_MODE);
pre_process_data : procedure(cinfo : j_compress_ptr;
input_buf : JSAMPARRAY;
in_row_ctr : JDIMENSION;
in_rows_avail : JDIMENSION;
output_buf : JSAMPIMAGE;
out_row_group_ctr : JDIMENSION;
out_row_groups_avail : JDIMENSION);
end;

jpeg_c_prep_controller_ptr = ^jpeg_c_prep_controller
@\\\*) { Compression preprocessing (downsampling input buffer control) } (*@/// jpeg_c_prep_controller = record
jpeg_decompress_struct = record
err : jpeg_error_mgr_ptr;
mem : jpeg_memory_mgr_ptr;
progress : jpeg_progress_mgr_ptr;
is_decompressor : boolean;
global_state : int;
src : jpeg_source_mgr_ptr;
image_width : JDIMENSION;
image_height : JDIMENSION;
num_components : int;
jpeg_color_space : J_COLOR_SPACE;
out_color_space : J_COLOR_SPACE;
scale_num : uint ;
scale_denom : uint ;
output_gamma : double;
buffered_image : boolean;
raw_data_out : boolean;
dct_method : J_DCT_METHOD;
do_fancy_upsampling : boolean;
do_block_smoothing : boolean;
quantize_colors : boolean;
dither_mode : J_DITHER_MODE;
two_pass_quantize : boolean;
desired_number_of_colors : int;
enable_1pass_quant : boolean;
enable_external_quant : boolean;
enable_2pass_quant : boolean;
output_width : JDIMENSION;
output_height : JDIMENSION;
out_color_components : int;
output_components : int;
rec_outbuf_height : int;
actual_number_of_colors : int;
colormap : JSAMPARRAY;
output_scanline : JDIMENSION;
input_scan_number : int;
input_iMCU_row : JDIMENSION;
output_scan_number : int;
output_iMCU_row : int;
coef_bits : coef_bits_ptrrow;
quant_tbl_ptrs : Array[0..NUM_QUANT_TBLS-1] of JQUANT_TBL_PTR;
dc_huff_tbl_ptrs : Array[0..NUM_HUFF_TBLS-1] of JHUFF_TBL_PTR;
ac_huff_tbl_ptrs : Array[0..NUM_HUFF_TBLS-1] of JHUFF_TBL_PTR;
data_precision : int;
comp_info : jpeg_component_info_ptr;
progressive_mode : boolean;
arith_code : boolean;
arith_dc_L : Array[0..NUM_ARITH_TBLS-1] of UINT8;
arith_dc_U : Array[0..NUM_ARITH_TBLS-1] of UINT8;
arith_ac_K : Array[0..NUM_ARITH_TBLS-1] of UINT8;
restart_interval : uint;
saw_JFIF_marker : boolean;
density_unit : UINT8;
X_density : UINT16;
Y_density : UINT16;
saw_Adobe_marker : boolean;
Adobe_transform : UINT8;
CCIR601_sampling : boolean;
max_h_samp_factor : int;
max_v_samp_factor : int;
min_DCT_scaled_size : int;
total_iMCU_rows : JDIMENSION;
sample_range_limit : range_limit_table_ptr;
comps_in_scan : int;
cur_comp_info : Array[0..MAX_COMPS_IN_SCAN-1] of jpeg_component_info_ptr;
MCUs_per_row : JDIMENSION;
MCU_rows_in_scan : JDIMENSION;
blocks_in_MCU : JDIMENSION;
MCU_membership : Array[0..D_MAX_BLOCKS_IN_MCU-1] of int;
Ss : int;
Se : int;
Ah : int;
Al : int;
unread_marker : int;
master : jpeg_decomp_master_ptr;
main : jpeg_d_main_controller_ptr;
coef : jpeg_d_coef_controller_ptr;
post : jpeg_d_post_controller_ptr;
inputctl : jpeg_input_controller_ptr;
marker : jpeg_marker_reader_ptr;
entropy : jpeg_entropy_decoder_ptr;
idct : jpeg_inverse_dct_ptr;
upsample : jpeg_upsampler_ptr;
cconvert : jpeg_color_deconverter_ptr;
cquantize : jpeg_color_quantizer_ptr;
end;
@/// jpeg_decompress_struct = record
jpeg_decomp_master = record
prepare_for_output_pass : procedure( cinfo : j_decompress_ptr);
finish_output_pass : procedure(cinfo : j_decompress_ptr);
is_dummy_pass : Boolean;
end;

jpeg_decomp_master_ptr = ^jpeg_decomp_master
@\\\*) { Declarations for decompression modules } { Master control module } (*@/// jpeg_decomp_master = record
jpeg_destination_mgr = record
next_output_byte : JOCTETptr;
free_in_buffer : size_t;
init_destination : procedure (cinfo : j_compress_ptr);
empty_output_buffer : function (cinfo : j_compress_ptr) : boolean;
term_destination : procedure (cinfo : j_compress_ptr);
end;

jpeg_destination_mgr_ptr = ^jpeg_destination_mgr
@\\\*) { Data destination object for compression } (*@/// jpeg_destination_mgr = record
jpeg_downsampler = record
start_pass : procedure(cinfo : j_compress_ptr);
downsample : procedure(cinfo : j_compress_ptr;
input_buf : JSAMPIMAGE;
in_row_index : JDIMENSION;
output_buf : JSAMPIMAGE;
out_row_group_index : JDIMENSION);
need_context_rows : Boolean;
end;

jpeg_downsampler_ptr = ^jpeg_downsampler
@\\\*) { Downsampling } (*@/// jpeg_downsampler = record
jpeg_d_coef_controller = record
start_input_pass : procedure(cinfo : j_decompress_ptr);
consume_data : function (cinfo : j_decompress_ptr) : int;
start_output_pass : procedure(cinfo : j_decompress_ptr);
decompress_data : function (cinfo : j_decompress_ptr;
output_buf : JSAMPIMAGE) : int;
coef_arrays : jvirt_barray_tbl_ptr;
end;

jpeg_d_coef_controller_ptr = ^jpeg_d_coef_controller
@/// jpeg_d_coef_controller = record
jpeg_d_main_controller = record
start_pass : procedure(cinfo : j_decompress_ptr;
pass_mode : J_BUF_MODE);
process_data : procedure(cinfo : j_decompress_ptr;
output_buf : JSAMPARRAY;
out_row_ctr : JDIMENSION;
out_rows_avail : JDIMENSION);
end;

jpeg_d_main_controller_ptr = ^jpeg_d_main_controller
@\\\*) { Main buffer control (downsampled-data buffer) } (*@/// jpeg_d_main_controller = record
jpeg_d_post_controller = record
start_pass : procedure(cinfo : j_decompress_ptr;
pass_mode : J_BUF_MODE);
post_process_data : procedure(cinfo : j_decompress_ptr;
input_buf : JSAMPIMAGE;
in_row_group_ctr : JDIMENSION;
in_row_groups_avail : JDIMENSION;
output_buf : JSAMPARRAY;
out_row_ctr : JDIMENSION;
out_rows_avail : JDIMENSION);
end;

jpeg_d_post_controller_ptr = ^jpeg_d_post_controller
@\\\*) { Decompression postprocessing (color quantization buffer control) } (*@/// jpeg_d_post_controller = record
jpeg_entropy_decoder = record
start_pass : procedure(cinfo : j_decompress_ptr);
decode_mcu : function(cinfo : j_decompress_ptr;
MCU_data : array of JBLOCKROW) : boolean;
end;

jpeg_entropy_decoder_ptr = ^jpeg_entropy_decoder
@\\\*) { Entropy decoding } (*@/// jpeg_entropy_decoder = record
jpeg_entropy_encoder = record
start_pass : procedure(cinfo : j_compress_ptr;
gather_statistics : boolean);
encode_mcu : function(cinfo : j_compress_ptr;
MCU_data : array of JBLOCKROW) : boolean;
finish_pass : procedure(cinfo : j_compress_ptr);
end;

jpeg_entropy_encoder_ptr = ^jpeg_entropy_encoder
@\\\*) { Entropy encoding } (*@/// jpeg_entropy_encoder = record
jpeg_error_mgr = record
error_exit : procedure (cinfo : j_common_ptr);
emit_message : procedure (cinfo : j_common_ptr;
msg_level : int);
output_message : procedure (cinfo : j_common_ptr);
format_message : procedure (cinfo : j_common_ptr;
buffer : string);
reset_error_mgr : procedure (cinfo : j_common_ptr);
msg_code : int;
trace_level : int;
num_warnings : long;
jpeg_message_table : ^msg_table;
last_jpeg_message : J_MESSAGE_CODE;
addon_message_table : ^msg_table;
first_addon_message : J_MESSAGE_CODE;
last_addon_message : J_MESSAGE_CODE;
end;
for TP FormatStr } (*@/// jpeg_error_mgr = record
jpeg_error_mgr_ptr = ^jpeg_error_mgr
USE_MSDOS_MEMMGR
jpeg_forward_dct = record
start_pass : procedure(cinfo : j_compress_ptr);
forward_DCT : procedure(cinfo : j_compress_ptr;
compptr : jpeg_component_info_ptr;
sample_data : JSAMPARRAY;
coef_blocks : JBLOCKROW;
start_row : JDIMENSION;
start_col : JDIMENSION;
num_blocks : JDIMENSION);
end;

jpeg_forward_dct_ptr = ^jpeg_forward_dct
@\\\*) { Forward DCT (also controls coefficient quantization) } (*@/// jpeg_forward_dct = record
jpeg_input_controller = record
consume_input : function (cinfo : j_decompress_ptr) : int;
reset_input_controller : procedure(cinfo : j_decompress_ptr);
start_input_pass : procedure(cinfo : j_decompress_ptr);
finish_input_pass : procedure(cinfo : j_decompress_ptr);
has_multiple_scans : Boolean;
eoi_reached : Boolean;
end;

jpeg_input_controller_ptr = ^jpeg_input_controller
@\\\*) { Input control module } (*@/// jpeg_input_controller = record
jpeg_inverse_dct = record
start_pass : procedure(cinfo : j_decompress_ptr);
inverse_DCT : Array[0..MAX_COMPONENTS-1] of inverse_DCT_method_ptr;
end;

jpeg_inverse_dct_ptr = ^jpeg_inverse_dct
@/// jpeg_inverse_dct = record
jpeg_marker_parser_method = function(cinfo : j_decompress_ptr) : boolean
@\\\*) { Routine signature for application-supplied marker processing methods. Need not pass marker code since it is stored in cinfo^.unread_marker.
jpeg_marker_reader = record
reset_marker_reader : procedure(cinfo : j_decompress_ptr);
read_markers : function (cinfo : j_decompress_ptr) : int;
read_restart_marker : jpeg_marker_parser_method;
process_COM : jpeg_marker_parser_method;
process_APPn : Array[0..16-1] of jpeg_marker_parser_method;
saw_SOI : boolean;
saw_SOF : boolean;
next_restart_num : int;
discarded_bytes : uint;
end;

jpeg_marker_reader_ptr = ^jpeg_marker_reader
Marker reading & parsing } (*@/// jpeg_marker_reader = record
jpeg_marker_writer = record
write_any_marker : procedure(cinfo : j_compress_ptr;
marker : int;
dataptr : JOCTETptr;
datalen : uint);
write_file_header : procedure(cinfo : j_compress_ptr);
write_frame_header : procedure(cinfo : j_compress_ptr);
write_scan_header : procedure(cinfo : j_compress_ptr);
write_file_trailer : procedure(cinfo : j_compress_ptr);
write_tables_only : procedure(cinfo : j_compress_ptr);
end;

jpeg_marker_writer_ptr = ^jpeg_marker_writer
@\\\*) { Marker writing } (*@/// jpeg_marker_writer = record
jpeg_memory_mgr = record
alloc_small : function (cinfo : j_common_ptr;
pool_id : int;
sizeofobject : size_t) : pointer;
alloc_large : function (cinfo : j_common_ptr;
pool_id : int;
sizeofobject : size_t) : pointer;
alloc_sarray : function (cinfo : j_common_ptr;
pool_id : int;
samplesperrow : JDIMENSION;
numrows : JDIMENSION) : JSAMPARRAY;
alloc_barray : function (cinfo : j_common_ptr;
pool_id : int;
blocksperrow : JDIMENSION;
numrows : JDIMENSION) : JBLOCKARRAY;
request_virt_sarray : function(cinfo : j_common_ptr;
pool_id : int;
pre_zero : boolean;
samplesperrow : JDIMENSION;
numrows : JDIMENSION;
maxaccess : JDIMENSION) : jvirt_sarray_ptr;
request_virt_barray : function(cinfo : j_common_ptr;
pool_id : int;
pre_zero : boolean;
blocksperrow : JDIMENSION;
numrows : JDIMENSION;
maxaccess : JDIMENSION) : jvirt_barray_ptr;
realize_virt_arrays : procedure (cinfo : j_common_ptr);
access_virt_sarray : function (cinfo : j_common_ptr;
ptr : jvirt_sarray_ptr;
start_row : JDIMENSION;
num_rows : JDIMENSION;
writable : boolean) : JSAMPARRAY;
access_virt_barray : function (cinfo : j_common_ptr;
ptr : jvirt_barray_ptr;
start_row : JDIMENSION;
num_rows : JDIMENSION;
writable : boolean) : JBLOCKARRAY;
free_pool : procedure (cinfo : j_common_ptr;
pool_id : int);
self_destruct : procedure (cinfo : j_common_ptr);
max_memory_to_use : long;
end;
@\\\*) { 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 NIL. They exit to error_exit if not successful. } (*@/// jpeg_memory_mgr = record
jpeg_memory_mgr_ptr = ^jpeg_memory_mgr

jpeg_progress_mgr = record
progress_monitor : procedure(cinfo : j_common_ptr);
pass_counter : long;
pass_limit : long;
completed_passes : int;
total_passes : int;
end;
@\\\*) { Progress monitor object } (*@/// jpeg_progress_mgr = record
jpeg_progress_mgr_ptr = ^jpeg_progress_mgr

jpeg_scan_info = record
comps_in_scan : int;
component_index : Array[0..MAX_COMPS_IN_SCAN-1] of int;
Ss : int;
Se : int;
Ah : int;
Al : int;
end;
@/// jpeg_scan_info = record
jpeg_scan_info_ptr = ^jpeg_scan_info
The script for encoding a multiple-scan file is an array of these:
jpeg_source_mgr = record
next_input_byte : JOCTETptr;
bytes_in_buffer : size_t;
init_source : procedure (cinfo : j_decompress_ptr);
fill_input_buffer : function (cinfo : j_decompress_ptr) : boolean;
skip_input_data : procedure (cinfo : j_decompress_ptr;
num_bytes : long);
resync_to_restart : function (cinfo : j_decompress_ptr;
desired : int) : boolean;
term_source : procedure (cinfo : j_decompress_ptr);
end;

jpeg_source_mgr_ptr = ^jpeg_source_mgr
@\\\*) { Data source object for decompression } (*@/// jpeg_source_mgr = record
jpeg_upsampler = record
start_pass : procedure(cinfo : j_decompress_ptr);
upsample : procedure(cinfo : j_decompress_ptr;
input_buf : JSAMPIMAGE;
in_row_group_ctr : JDIMENSION;
in_row_groups_avail : JDIMENSION;
output_buf : JSAMPARRAY;
out_row_ctr : JDIMENSION;
out_rows_avail : JDIMENSION);
need_context_rows : boolean;
end;

jpeg_upsampler_ptr = ^jpeg_upsampler
@\\\*) { Upsampling (note that upsampler must also call color converter) } (*@/// jpeg_upsampler = record
JQUANT_TBL = record
quantval : Array[0..DCTSIZE2-1] of UINT16;
sent_table : boolean;
end;
@/// JQUANT_TBL = record
JQUANT_TBL_FIELD = Array[0..(MaxInt div SizeOf(JQUANT_TBL))-1] of JQUANT_TBL;
@\\\
JQUANT_TBL_PTR = ^JQUANT_TBL
Types for JPEG compression parameters and working tables. } { DCT coefficient quantization tables.
JSAMPARRAY = ^JSAMPROW_ARRAY

JSAMPIMAGE = ^JSAMP_ARRAY

JSAMPLE_ARRAY = Array[jTSample] of JSAMPLE;

JSAMPLE_PTR = ^JSAMPLE
for typecasting
JSAMPROW = ^JSAMPLE_ARRAY
far
JSAMPROW_ARRAY = Array[jTRow] of JSAMPROW;

JSAMPROW_PTR = ^JSAMPROW

JSAMP_ARRAY = Array[jTArray] of JSAMPARRAY;

jTArray = 0..(MaxInt div SIZEOF(JSAMPARRAY))-1
ptr to some rows (a 2-D sample array)
jTBlockArray = 0..(MaxInt div SIZEOF(JBLOCKROW))-1
far} { pointer to one row of coefficient blocks
jTBlockImage = 0..(MaxInt div SIZEOF(JBLOCKARRAY))-1
a 2-D array of coefficient blocks
jTBlockRow = 0..(MaxInt div SIZEOF(JBLOCK))-1

jTByte = 0..(MaxInt div SIZEOF(byte))-1
far} { useful in a couple of places
jTCinfo = 0..(MaxInt div SizeOf(jpeg_component_info))-1
record jpeg_component_info } (*@\\\
jTCoef = 0..(MaxInt div SIZEOF(JCOEF))-1
a 3-D array of coefficient blocks
jTRow = 0..(MaxInt div SIZEOF(JSAMPROW))-1
ptr to one image row of pixel samples.
jTSample = 0..(MaxInt div SIZEOF(JSAMPLE))-1

jvirt_barray_tbl = array[0..MAX_COMPONENTS-1] of jvirt_barray_ptr;
@\\\*) { Coefficient buffer control
jvirt_barray_tbl_ptr = ^jvirt_barray_tbl

J_BUF_MODE = (                { Operating modes for buffer controllers }
      JBUF_PASS_THRU,         { Plain stripwise operation }
      { Remaining modes require a full-image buffer to have been created }
      JBUF_SAVE_SOURCE,       { Run source subobject only, save output }
      JBUF_CRANK_DEST,        { Run dest subobject only, using saved data }
      JBUF_SAVE_AND_PASS      { Run both subobjects, save output }
             );
@/// J_BUF_MODE = (..) { Operating modes for buffer controllers }
J_COLOR_SPACE = (
      JCS_UNKNOWN,            { error/unspecified }
      JCS_GRAYSCALE,          { monochrome }
      JCS_RGB,                { red/green/blue }
      JCS_YCbCr,              { Y/Cb/Cr (also known as YUV) }
      JCS_CMYK,               { C/M/Y/K }
      JCS_YCCK                { Y/Cb/Cr/K }
                );
@/// J_COLOR_SPACE = ( ... );
j_common_ptr = ^jpeg_common_struct

j_compress_ptr = ^jpeg_compress_struct

J_DCT_METHOD = (
      JDCT_ISLOW,             { slow but accurate integer algorithm }
      JDCT_IFAST,             { faster, less accurate integer method }
      JDCT_FLOAT              { floating-point: accurate, fast on fast HW }
               );
@/// J_DCT_METHOD = ( ... );
j_decompress_ptr = ^jpeg_decompress_struct

J_DITHER_MODE = (
  JDITHER_NONE,               { no dithering }
  JDITHER_ORDERED,            { simple ordered dither }
  JDITHER_FS                  { Floyd-Steinberg error diffusion dither }
                );
@/// J_DITHER_MODE = ( .. );
range_limit_table = array[-(MAXJSAMPLE+1)..4*(MAXJSAMPLE+1)
                            + CENTERJSAMPLE -1] of JSAMPLE;

range_limit_table_ptr = ^range_limit_table

TEMP_STRING = string[TEMP_NAME_LENGTH]
max length of a temporary file's name

Constants

CSTATE_RAW_OK = 102

start_compress done, write_scanlines OK

CSTATE_SCANNING = 101

after create_compress

CSTATE_START = 100

@\\\*) (*@/// const { Values of global_state field (jdapi.c has some dependencies on ordering!) }

CSTATE_WRCOEFS = 103

start_compress done, write_raw_data OK

C_MAX_BLOCKS_IN_MCU = 10

JPEG limit on sampling factors } { Unfortunately, some bozo at Adobe saw no reason to be bound by the standard; the PostScript DCT filter can emit files with many more than 10 blocks/MCU. If you happen to run across such a file, you can up D_MAX_BLOCKS_IN_MCU to handle it. We even let you do this from the jconfig.h file. However, we strongly discourage changing C_MAX_BLOCKS_IN_MCU; just because Adobe sometimes emits noncompliant files doesn't mean you should too.

DCTSIZE = 8

COM marker code } { 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.

DCTSIZE2 = 64

The basic DCT block is 8x8 samples

DSTATE_BUFIMAGE = 207

start_decompress done, read_raw_data OK

DSTATE_BUFPOST = 208

expecting jpeg_start_output

DSTATE_INHEADER = 201

after create_decompress

DSTATE_PRELOAD = 203

found SOS, ready for start_decompress

DSTATE_PRESCAN = 204

reading multiscan file in start_decompress

DSTATE_RAW_OK = 206

start_decompress done, read_scanlines OK

DSTATE_RDCOEFS = 209

looking for SOS/EOI in jpeg_finish_output

DSTATE_READY = 202

reading header markers, no SOS yet

DSTATE_SCANNING = 205

performing dummy pass for 2-pass quant

DSTATE_START = 200

jpeg_write_coefficients done

DSTATE_STOPPING = 210

reading file in jpeg_read_coefficients

D_MAX_BLOCKS_IN_MCU = 10

compressor's limit on blocks per MCU

JDCT_DEFAULT = JDCT_ISLOW

@\\\

JDCT_FASTEST = JDCT_IFAST

JMSG_LENGTH_MAX = 200

"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

JMSG_STR_PARM_MAX = 80

recommended size of format_message buffer

JPEG_APP0 = $E0

EOI marker code

JPEG_COM = $FE

APP0 marker code

JPEG_EOI = $D9

RST0 marker code

JPEG_HEADER_OK = 1

Suspended due to lack of input data

JPEG_HEADER_TABLES_ONLY = 2

Found valid image datastream

JPEG_LIB_VERSION = 61

seldom changed options } (*@\\\*) { Version ID for the JPEG library. Might be useful for tests like "#if JPEG_LIB_VERSION >= 60".

JPEG_REACHED_EOI = 2

Reached start of new scan

JPEG_REACHED_SOS = 1

Found valid table-specs-only datastream } { If you pass require_image = TRUE (normal case), you need not check for a TABLES_ONLY return code; an abbreviated file will cause an error exit. JPEG_SUSPENDED is only possible if you use a data source module that can give a suspension return (the stdio source module doesn't). } { function jpeg_consume_input (cinfo : j_decompress_ptr) : int; Return value is one of:

JPEG_ROW_COMPLETED = 3

Reached end of image

JPEG_RST0 = $D0

Version 6a } { These marker codes are exported since applications and data source modules are likely to want to use them.

JPEG_SCAN_COMPLETED = 4

Completed one iMCU row

JPEG_SUSPENDED = 0

@\\\*) { Decompression startup: read start of JPEG datastream to see what's there function jpeg_read_header (cinfo : j_decompress_ptr; require_image : boolean) : int; Return value is one of:

JPOOL_IMAGE = 1

lasts until master record is destroyed

JPOOL_NUMPOOLS = 2

lasts until done with image/datastream

JPOOL_PERMANENT = 0

@\\\

MAX_COMPS_IN_SCAN = 4

Arith-coding tables are numbered 0..15

MAX_SAMP_FACTOR = 4

JPEG limit on # of components in one scan

NUM_ARITH_TBLS = 16

Huffman tables are numbered 0..3

NUM_HUFF_TBLS = 4

Quantization tables are numbered 0..3

NUM_QUANT_TBLS = 4

DCTSIZE squared; # of elements in a block

TEMP_NAME_LENGTH = 64


Variables