jpeglib.pas

DELPHI版的JPEG文件解码源程序

  private fields may exist after the public ones. }


{ Error handler object }

const
  JMSG_LENGTH_MAX  = 200;  { recommended size of format_message buffer }
  JMSG_STR_PARM_MAX = 80;

const
  TEMP_NAME_LENGTH = 64;   { max length of a temporary file's name }
type
  TEMP_STRING = string[TEMP_NAME_LENGTH];

{$ifdef USE_MSDOS_MEMMGR}  { DOS-specific junk }
type
  XMSH = ushort;           { type of extended-memory handles }
  EMSH = ushort;           { type of expanded-memory handles }

  handle_union = record
    case byte of
    0:(file_handle : short);    { DOS file handle if it's a temp file }
    1:(xms_handle : XMSH);      { handle if it's a chunk of XMS }
    2:(ems_handle : EMSH);      { handle if it's a chunk of EMS }
  end;
{$endif} { USE_MSDOS_MEMMGR }

type
  jpeg_error_mgr_ptr = ^jpeg_error_mgr;
  jpeg_memory_mgr_ptr = ^jpeg_memory_mgr;
  jpeg_progress_mgr_ptr = ^jpeg_progress_mgr;


{$ifdef common}
{ Common fields between JPEG compression and decompression master structs. }
    err : jpeg_error_mgr_ptr;            { Error handler module }
    mem : jpeg_memory_mgr_ptr;           { Memory manager module }
    progress : jpeg_progress_mgr_ptr;    { Progress monitor, or NIL if none }
    client_data : voidp;                 { Available for use by application }
    is_decompressor : boolean;     { so common code can tell which is which }
    global_state : int;            { for checking call sequence validity }
{$endif}

  j_common_ptr = ^jpeg_common_struct;
  j_compress_ptr = ^jpeg_compress_struct;
  j_decompress_ptr = ^jpeg_decompress_struct;

  {$ifdef AM_MEMORY_MANAGER}	{ only jmemmgr.c defines these }

{ This structure holds whatever state is needed to access a single
  backing-store object.  The read/write/close method pointers are called
  by jmemmgr.c to manipulate the backing-store object; all other fields
  are private to the system-dependent backing store routines. }


  backing_store_ptr = ^backing_store_info;
  backing_store_info = record
  { Methods for reading/writing/closing this backing-store object }
    read_backing_store : procedure (cinfo : j_common_ptr;
				    info : backing_store_ptr;
				    buffer_address : pointer; {far}
				    file_offset : long;
                                    byte_count : long);
    write_backing_store : procedure (cinfo : j_common_ptr;
				     info : backing_store_ptr;
				     buffer_address : pointer;  {far}
				     file_offset : long;
                                     byte_count : long);

    close_backing_store : procedure (cinfo : j_common_ptr;
				     info : backing_store_ptr);

  { Private fields for system-dependent backing-store management }
  {$ifdef USE_MSDOS_MEMMGR}
    { For the MS-DOS manager (jmemdos.c), we need: }
    handle : handle_union;            { reference to backing-store storage object }
    temp_name : TEMP_STRING;  { name if it's a file }
  {$else}
    { For a typical implementation with temp files, we need: }
    temp_file : file;                 { stdio reference to temp file }
    temp_name : TEMP_STRING;  { name of temp file }
  {$endif}
 end;


{ The control blocks for virtual arrays.
  Note that these blocks are allocated in the "small" pool area.
  System-dependent info for the associated backing store (if any) is hidden
  inside the backing_store_info struct. }

  jvirt_sarray_ptr = ^jvirt_sarray_control;
  jvirt_sarray_control = record
    mem_buffer : JSAMPARRAY;    { => the in-memory buffer }
    rows_in_array : JDIMENSION; { total virtual array height }
    samplesperrow : JDIMENSION; { width of array (and of memory buffer) }
    maxaccess : JDIMENSION;     { max rows accessed by access_virt_sarray }
    rows_in_mem : JDIMENSION;   { height of memory buffer }
    rowsperchunk : JDIMENSION;  { allocation chunk size in mem_buffer }
    cur_start_row : JDIMENSION; { first logical row # in the buffer }
    first_undef_row : JDIMENSION; { row # of first uninitialized row }
    pre_zero : boolean;         { pre-zero mode requested? }
    dirty : boolean;            { do current buffer contents need written? }
    b_s_open : boolean;         { is backing-store data valid? }
    next : jvirt_sarray_ptr;    { link to next virtual sarray control block }
    b_s_info : backing_store_info; { System-dependent control info }
  end;

  jvirt_barray_ptr = ^jvirt_barray_control;
  jvirt_barray_control = record
    mem_buffer : JBLOCKARRAY;   { => the in-memory buffer }
    rows_in_array : JDIMENSION; { total virtual array height }
    blocksperrow : JDIMENSION;	{ width of array (and of memory buffer) }
    maxaccess : JDIMENSION;     { max rows accessed by access_virt_barray }
    rows_in_mem : JDIMENSION;   { height of memory buffer }
    rowsperchunk : JDIMENSION;  { allocation chunk size in mem_buffer }
    cur_start_row : JDIMENSION; { first logical row # in the buffer }
    first_undef_row : JDIMENSION; { row # of first uninitialized row }
    pre_zero : boolean;         { pre-zero mode requested? }
    dirty : boolean;            { do current buffer contents need written? }
    b_s_open : boolean;         { is backing-store data valid? }
    next : jvirt_barray_ptr;    { link to next virtual barray control block }
    b_s_info : backing_store_info;  { System-dependent control info }
  end;

  {$endif} { AM_MEMORY_MANAGER }

{ Declarations for compression modules }

{ Master control module }
  jpeg_comp_master_ptr = ^jpeg_comp_master;
  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);

    { State variables made visible to other modules }
    call_pass_startup : Boolean;   { True if pass_startup must be called }
    is_last_pass : Boolean;        { True during last pass }
  end;

{ Main buffer control (downsampled-data buffer) }
  jpeg_c_main_controller_ptr = ^jpeg_c_main_controller;
  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;
                             var in_row_ctr : JDIMENSION;
			     in_rows_avail : JDIMENSION);
  end;

{ Compression preprocessing (downsampling input buffer control) }
  jpeg_c_prep_controller_ptr = ^jpeg_c_prep_controller;
  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;
				 var in_row_ctr : JDIMENSION;
				 in_rows_avail : JDIMENSION;
				 output_buf : JSAMPIMAGE;
				 var out_row_group_ctr : JDIMENSION;
				 out_row_groups_avail : JDIMENSION);
  end;

{ Coefficient buffer control }
  jpeg_c_coef_controller_ptr = ^jpeg_c_coef_controller;
  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;

{ Colorspace conversion }
  jpeg_color_converter_ptr = ^jpeg_color_converter;
  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;

{ Downsampling }
  jpeg_downsampler_ptr = ^jpeg_downsampler;
  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;  { TRUE if need rows above & below }
  end;

{ Forward DCT (also controls coefficient quantization) }
  jpeg_forward_dct_ptr = ^jpeg_forward_dct;
  jpeg_forward_dct = record
    start_pass : procedure(cinfo : j_compress_ptr);
    { perhaps this should be an array??? }
    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;

{ Entropy encoding }

  jpeg_entropy_encoder_ptr = ^jpeg_entropy_encoder;
  jpeg_entropy_encoder = record
    start_pass : procedure(cinfo : j_compress_ptr; gather_statistics : boolean);
    encode_mcu : function(cinfo : j_compress_ptr;
                          const MCU_data: array of JBLOCKROW) : boolean;
    finish_pass : procedure(cinfo : j_compress_ptr);
  end;

{ Marker writing }
  jpeg_marker_writer_ptr = ^jpeg_marker_writer;
  jpeg_marker_writer = record
    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);
   { These routines are exported to allow insertion of extra markers }
   { Probably only COM and APPn markers should be written this way }
    write_marker_header : procedure (cinfo : j_compress_ptr;
                                     marker : int;
				     datalen : uint);
    write_marker_byte : procedure (cinfo : j_compress_ptr; val : int);
  end;

{ Declarations for decompression modules }

{ Master control module }
  jpeg_decomp_master_ptr = ^jpeg_decomp_master;
  jpeg_decomp_master = record
    prepare_for_output_pass : procedure( cinfo : j_decompress_ptr);
    finish_output_pass : procedure(cinfo : j_decompress_ptr);

    { State variables made visible to other modules }
    is_dummy_pass : Boolean;	{ True during 1st pass for 2-pass quant }
  end;

{ Input control module }
  jpeg_input_controller_ptr = ^jpeg_input_controller;
  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);

    { State variables made visible to other modules }
    has_multiple_scans : Boolean;  { True if file has multiple scans }
    eoi_reached : Boolean;         { True when EOI has been consumed }
  end;

{ Main buffer control (downsampled-data buffer) }

  jpeg_d_main_controller_ptr = ^jpeg_d_main_controller;
  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;
                             var out_row_ctr : JDIMENSION;
	                     out_rows_avail : JDIMENSION);
  end;

{ Coefficient buffer control }
  jvirt_barray_tbl = array[0..MAX_COMPONENTS-1] of jvirt_barray_ptr;
  jvirt_barray_tbl_ptr = ^jvirt_barray_tbl;
  jpeg_d_coef_controller_ptr = ^jpeg_d_coef_controller;
  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;
  { Pointer to array of coefficient virtual arrays, or NIL if none }
    coef_arrays : jvirt_barray_tbl_ptr;
  end;

{ Decompression postprocessing (color quantization buffer control) }
  jpeg_d_post_controller_ptr = ^jpeg_d_post_controller;
  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;
				  var in_row_group_ctr : JDIMENSION;
				  in_row_groups_avail : JDIMENSION;
				  output_buf : JSAMPARRAY;
				  var out_row_ctr : JDIMENSION;
				  out_rows_avail : JDIMENSION);
  end;


{ Routine signature for application-supplied marker processing methods.
  Need not pass marker code since it is stored in cinfo^.unread_marker. }

  jpeg_marker_parser_method = function(cinfo : j_decompress_ptr) : boolean;

{ Marker reading & parsing }
  jpeg_marker_reader_ptr = ^jpeg_marker_reader;
  jpeg_marker_reader = record
    reset_marker_reader : procedure(cinfo : j_decompress_ptr);
    { Read markers until SOS or EOI.
      Returns same codes as are defined for jpeg_consume_input:
      JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI. }

    read_markers : function (cinfo : j_decompress_ptr) : int;
    { Read a restart marker --- exported for use by entropy decoder only }
    read_restart_marker : jpeg_marker_parser_method;

    { State of marker reader --- nominally internal, but applications
      supplying COM or APPn handlers might like to know the state. }

    saw_SOI : boolean;            { found SOI? }
    saw_SOF : boolean;            { found SOF? }
    next_restart_num : int;       { next restart number expected (0-7) }
    discarded_bytes : uint;       { # of bytes skipped looking for a marker }
  end;