libjpeg.pas

很好的源代码

     * restart_interval, or in MCU rows by setting restart_in_rows
     * (in which case the correct restart_interval will be figured
     * for each scan).
     *)
    restart_interval: uint; (* MCUs per restart, or 0 for no restart *)
    restart_in_rows: int;		(* if > 0, MCU rows per restart interval *)

    (* Parameters controlling emission of special markers. *)

    write_JFIF_header: boolean;	(* should a JFIF marker be written? *)
    JFIF_major_version: UINT8;	(* What to write for the JFIF version number *)
    JFIF_minor_version: UINT8;
    (* 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. *)
    density_unit: UINT8;		(* JFIF code for pixel size units *)
    X_density: UINT16;		(* Horizontal pixel density *)
    Y_density: UINT16;		(* Vertical pixel density *)
    write_Adobe_marker: boolean;	(* should an Adobe marker be written? *)

    (* 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)".
     *)

    next_scanline: JDIMENSION;	(* 0 .. image_height-1  *)

    (* Remaining fields are known throughout compressor, but generally
     * should not be touched by a surrounding application.
     *)

    (*
     * These fields are computed during compression startup
     *)
    progressive_mode: boolean;	(* TRUE if scan script uses progressive mode *)
    max_h_samp_factor: int;	(* largest h_samp_factor *)
    max_v_samp_factor: int;	(* largest v_samp_factor *)

    total_iMCU_rows: JDIMENSION;	(* # 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.
     *)

    (*
     * These fields are valid during any one scan.
     * They describe the components and MCUs actually appearing in the scan.
     *)
    comps_in_scan: int;		(* # of JPEG components in this scan *)
    cur_comp_info: array [0..MAX_COMPS_IN_SCAN-1] of pjpeg_component_info;
    (* *cur_comp_info[i] describes component that appears i'th in SOS *)

    MCUs_per_row: JDIMENSION;	(* # of MCUs across the image *)
    MCU_rows_in_scan: JDIMENSION;	(* # of MCU rows in the image *)

    blocks_in_MCU: int;		(* # of DCT blocks per MCU *)
    MCU_membership: array [0..C_MAX_BLOCKS_IN_MCU-1] of int;
    (* MCU_membership[i] is index in cur_comp_info of component owning *)
    (* i'th block in an MCU *)

    Ss, Se, Ah, Al: int;		(* progressive JPEG parameters for scan *)

    (*
     * Links to compression subobjects (methods and private variables of modules)
     *)
    master: pjpeg_comp_master;
    main: pjpeg_c_main_controller;
    prep: pjpeg_c_prep_controller;
    coef: pjpeg_c_coef_controller;
    marker: pjpeg_marker_writer;
    cconvert: pjpeg_color_converter;
    downsample: pjpeg_downsampler;
    fdct: pjpeg_forward_dct;
    entropy: pjpeg_entropy_encoder;
    script_space: pjpeg_scan_info; (* workspace for jpeg_simple_progression *)
    script_space_size: int;
  end;

  jpeg_error_mgr = record
    (* Error exit handler: does not return to caller *)
    error_exit: procedure (CInfo: j_common_ptr); cdecl;
    (* Conditionally emit a trace or warning message *)
    emit_message:  procedure (CInfo: j_common_ptr; msg_level: int); cdecl;
    (* Routine that actually outputs a trace or error message *)
    output_message: procedure (CInfo: j_common_ptr); cdecl;
    (* Format a message string for the most recent JPEG error or message *)
    format_message:  procedure (CInfo: j_common_ptr; Buffer: PChar); cdecl;
    (* Reset error state variables at start of a new image *)
    reset_error_mgr: JMETHOD;

    (* The message ID code and any parameters are saved here.
     * A message can have one string parameter or up to 8 int parameters.
     *)
    msg_code: int;
    msg_param: record
      case Integer of
        0: (i: array [0..7] of int);
        1: (s: array [0..JMSG_STR_PARM_MAX-1] of Char);
    end;
    (* Standard state variables for error facility *)

    trace_level: int ;		(* max msg_level that will be displayed *)

    (* 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.
     *)
    num_warnings: long ;		(* number of corrupt-data 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.
     *)
    jpeg_message_table: PPChar; (* Library errors *)
    last_jpeg_message: int ;    (* Table contains strings 0..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.
     *)
    addon_message_table: PPChar; (* Non-library errors *)
    first_addon_message: int ;	(* code for first string in addon table *)
    last_addon_message: int ;	(* code for last string in addon table *)
  end;

  jpeg_source_mgr = record
    next_input_byte: PJOCTET; // => next byte to read from buffer
    bytes_in_buffer: size_t;	// # of bytes remaining in buffer

    init_source: procedure (var cinfo: jpeg_decompress_struct); cdecl;
    fill_input_buffer: function (var cinfo: jpeg_decompress_struct ): Boolean; cdecl;
    skip_input_data: procedure (var cinfo: jpeg_decompress_struct; num_bytes: long); cdecl;
    resync_to_restart: function (var cinfo: jpeg_decompress_struct; desired: int): Boolean; cdecl;
    term_source: procedure (var cinfo: jpeg_decompress_struct); cdecl;
  end;

  jpeg_destination_mgr = record
    next_output_byte: PJOCTET;	(* => next byte to write in buffer *)
    free_in_buffer: size_t;	(* # of byte spaces remaining in buffer *)

    init_destination: procedure (var cinfo: jpeg_compress_struct); cdecl;
    empty_output_buffer: function (var cinfo: jpeg_compress_struct): Boolean; cdecl;
    term_destination: procedure (var cinfo: jpeg_compress_struct); cdecl;
  end;

  jpeg_scan_info = record
    comps_in_scan: int;		(* number of components encoded in this scan *)
    component_index: array [0..MAX_COMPS_IN_SCAN-1] of int; (* their SOF/comp_info[] indexes *)
    Ss, Se: int;			(* progressive JPEG spectral selection parms *)
    Ah, Al: int;			(* progressive JPEG successive approx. parms *)
  end;

  jpeg_memory_mgr = record
    (* Method pointers *)
    alloc_small: function(cinfo: j_common_ptr; pool_id: int; sizeofobject: size_t): Pointer; cdecl;
    alloc_large: JMETHOD;
    alloc_sarry: JMETHOD;
    alloc_barray: JMETHOD;
    request_virt_sarray: JMETHOD;
    request_virt_barray: JMETHOD;
    realize_virt_arrays: JMETHOD;
    access_virt_sarray: JMETHOD;
    access_virt_barray: JMETHOD;
    free_pool: JMETHOD;
    self_destruct: JMETHOD;
{    JMETHOD(void FAR *, alloc_large, (j_common_ptr cinfo, int pool_id,
               size_t sizeofobject));
    JMETHOD(JSAMPARRAY, alloc_sarray, (j_common_ptr cinfo, int pool_id,
               JDIMENSION samplesperrow,
               JDIMENSION numrows));
    JMETHOD(JBLOCKARRAY, alloc_barray, (j_common_ptr cinfo, int pool_id,
                JDIMENSION blocksperrow,
                JDIMENSION numrows));
    JMETHOD(jvirt_sarray_ptr, request_virt_sarray, (j_common_ptr cinfo,
                int pool_id,
                boolean pre_zero,
                JDIMENSION samplesperrow,
                JDIMENSION numrows,
                JDIMENSION maxaccess));
    JMETHOD(jvirt_barray_ptr, request_virt_barray, (j_common_ptr cinfo,
                int pool_id,
                boolean pre_zero,
                JDIMENSION blocksperrow,
                JDIMENSION numrows,
                JDIMENSION maxaccess));
    JMETHOD(void, realize_virt_arrays, (j_common_ptr cinfo));
    JMETHOD(JSAMPARRAY, access_virt_sarray, (j_common_ptr cinfo,
               jvirt_sarray_ptr ptr,
               JDIMENSION start_row,
               JDIMENSION num_rows,
               boolean writable));
    JMETHOD(JBLOCKARRAY, access_virt_barray, (j_common_ptr cinfo,
                jvirt_barray_ptr ptr,
                JDIMENSION start_row,
                JDIMENSION num_rows,
                boolean writable));
    JMETHOD(void, free_pool, (j_common_ptr cinfo, int pool_id));
    JMETHOD(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.
     *)
    max_memory_to_use: long;

    (* Maximum allocation request accepted by alloc_large. *)
    max_alloc_chunk: long;
  end;

const
  jpeglib = 'libjpeg.dll';

function jpeg_std_error(err: pjpeg_error_mgr): pjpeg_error_mgr; cdecl; external jpeglib;
procedure jpeg_CreateDecompress(var cinfo: jpeg_decompress_struct; version: int; structsize: size_t); cdecl; external jpeglib;
function jpeg_read_header(var cinfo: jpeg_decompress_struct; require_image: Boolean): int; cdecl; external jpeglib;
function jpeg_resync_to_restart(var cinfo: jpeg_decompress_struct; desired: int): Boolean; cdecl; external jpeglib;
function jpeg_start_decompress(var cinfo: jpeg_decompress_struct): Boolean; cdecl; external jpeglib;
function jpeg_read_scanlines(var cinfo: jpeg_decompress_struct; scanlines: JSAMPARRAY;
	max_lines: JDIMENSION): JDIMENSION; cdecl; external jpeglib;
function jpeg_finish_decompress(var cinfo: jpeg_decompress_struct): Boolean; cdecl; external jpeglib;
procedure jpeg_destroy_decompress(var cinfo: jpeg_decompress_struct); cdecl; external jpeglib;
procedure jpeg_CreateCompress(var cinfo: jpeg_compress_struct; version: int; structsize: size_t); cdecl; external jpeglib;
procedure jpeg_set_defaults(var cinfo: jpeg_compress_struct); cdecl; external jpeglib;
procedure jpeg_set_quality(var cinfo: jpeg_compress_struct; quality: int; force_baseline: boolean); cdecl; external jpeglib;
procedure jpeg_start_compress(var cinfo: jpeg_compress_struct; write_all_tables: boolean); cdecl; external jpeglib;
function jpeg_write_scanlines(var cinfo: jpeg_compress_struct; scanlines: JSAMPARRAY;
	num_lines: JDIMENSION): JDIMENSION; cdecl; external jpeglib;
function jpeg_finish_compress(var cinfo: jpeg_compress_struct): Boolean; cdecl; external jpeglib;
procedure jpeg_destroy_compress(var cinfo: jpeg_compress_struct); cdecl; external jpeglib;

procedure jpeg_create_decompress(var cinfo: jpeg_decompress_struct);
procedure jpeg_create_compress(var cinfo: jpeg_compress_struct);

procedure ERREXIT(CInfo: j_common_ptr; Code: J_MESSAGE_CODE);
procedure WARNMS(CInfo: j_common_ptr; Code: J_MESSAGE_CODE);

implementation

procedure jpeg_create_decompress(var cinfo: jpeg_decompress_struct);
begin
  jpeg_CreateDecompress(cinfo,JPEG_LIB_VERSION,SizeOf(jpeg_decompress_struct));
end;

procedure jpeg_create_compress(var cinfo: jpeg_compress_struct);
begin
  jpeg_CreateCompress(cinfo,JPEG_LIB_VERSION,SizeOf(jpeg_compress_struct));
end;

procedure ERREXIT(CInfo: j_common_ptr; Code: J_MESSAGE_CODE);
begin
  CInfo.err.msg_code := Ord(Code);
  CInfo.err.error_exit(CInfo);
end;

procedure WARNMS(CInfo: j_common_ptr; Code: J_MESSAGE_CODE);
begin
  CInfo.err.msg_code := Ord(Code);
  CInfo.err.emit_message(CInfo,-1);
end;

end.