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 = ^JBLOCKone 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@/// JHUFF_TBL = record
bits : Array[0..17-1] of UINT8;
huffval : Array[0..256-1] of UINT8;
sent_table : boolean;
end;
JHUFF_TBL_FIELD = Array[0..(MaxInt div SizeOf(JHUFF_TBL))-1] of JHUFF_TBL;@\\\
JHUFF_TBL_PTR = ^JHUFF_TBLHuffman 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@\\\*) { 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
err : jpeg_error_mgr_ptr;
mem : jpeg_memory_mgr_ptr;
progress : jpeg_progress_mgr_ptr;
is_decompressor : boolean;
global_state : int;
end;
jpeg_component_info = 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_array = array[jTCinfo] of jpeg_component_info;
jpeg_component_info_list_ptr = ^jpeg_component_info_array
jpeg_component_info_ptr = ^jpeg_component_infolooking for EOI in jpeg_finish_decompress } (*@\\\*) { Basic info about one component (color channel).
jpeg_compress_struct = record@\\\*) { Master record for a compression instance } (*@/// 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;
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_masterAM_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@/// 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_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 = recordfor TP FormatStr } (*@/// 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;
jpeg_error_mgr_ptr = ^jpeg_error_mgrUSE_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_readerMarker 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@\\\*) { 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
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;
jpeg_memory_mgr_ptr = ^jpeg_memory_mgr
jpeg_progress_mgr = record@\\\*) { Progress monitor object } (*@/// jpeg_progress_mgr = record
progress_monitor : procedure(cinfo : j_common_ptr);
pass_counter : long;
pass_limit : long;
completed_passes : int;
total_passes : int;
end;
jpeg_progress_mgr_ptr = ^jpeg_progress_mgr
jpeg_scan_info = record@/// 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_ptr = ^jpeg_scan_infoThe 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@/// JQUANT_TBL = record
quantval : Array[0..DCTSIZE2-1] of UINT16;
sent_table : boolean;
end;
JQUANT_TBL_FIELD = Array[0..(MaxInt div SizeOf(JQUANT_TBL))-1] of JQUANT_TBL;@\\\
JQUANT_TBL_PTR = ^JQUANT_TBLTypes 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 = ^JSAMPLEfor typecasting
JSAMPROW = ^JSAMPLE_ARRAYfar
JSAMPROW_ARRAY = Array[jTRow] of JSAMPROW;
JSAMPROW_PTR = ^JSAMPROW
JSAMP_ARRAY = Array[jTArray] of JSAMPARRAY;
jTArray = 0..(MaxInt div SIZEOF(JSAMPARRAY))-1ptr to some rows (a 2-D sample array)
jTBlockArray = 0..(MaxInt div SIZEOF(JBLOCKROW))-1far} { pointer to one row of coefficient blocks
jTBlockImage = 0..(MaxInt div SIZEOF(JBLOCKARRAY))-1a 2-D array of coefficient blocks
jTBlockRow = 0..(MaxInt div SIZEOF(JBLOCK))-1
jTByte = 0..(MaxInt div SIZEOF(byte))-1far} { useful in a couple of places
jTCinfo = 0..(MaxInt div SizeOf(jpeg_component_info))-1record jpeg_component_info } (*@\\\
jTCoef = 0..(MaxInt div SIZEOF(JCOEF))-1a 3-D array of coefficient blocks
jTRow = 0..(MaxInt div SIZEOF(JSAMPROW))-1ptr 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 |
Variables |