jpeglib.pas

用pascal寫的jpeg codec, 測試過的

type
  J_DITHER_MODE = (
    JDITHER_NONE,               { no dithering }
    JDITHER_ORDERED,            { simple ordered dither }
    JDITHER_FS                  { Floyd-Steinberg error diffusion dither }
                  );


const
  JPOOL_PERMANENT  = 0; { lasts until master record is destroyed }
  JPOOL_IMAGE      = 1; { lasts until done with image/datastream }
  JPOOL_NUMPOOLS   = 2;


{ "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 }

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 }
    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_any_marker is exported for use by applications }
    { Probably only COM and APPn markers should be written }
    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;

{ 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