jccoefct.pas

DELPHI版的JPEG文件解码源程序

Unit JcCoefCt;

{ This file contains the coefficient buffer controller for compression.
  This controller is the top level of the JPEG compressor proper.
  The coefficient buffer lies between forward-DCT and entropy encoding steps.}

{ Original: jccoefct.c; Copyright (C) 1994-1997, Thomas G. Lane. }

interface

uses
  jmorecfg,
  jinclude,
  jerror,
  jdeferr,
  jutils,
  jpeglib;

{$I jconfig.inc}

{ We use a full-image coefficient buffer when doing Huffman optimization,
  and also for writing multiple-scan JPEG files.  In all cases, the DCT
  step is run during the first pass, and subsequent passes need only read
  the buffered coefficients. }
{$ifdef ENTROPY_OPT_SUPPORTED}
  {$define FULL_COEF_BUFFER_SUPPORTED}
{$else}
  {$ifdef C_MULTISCAN_FILES_SUPPORTED}
    {$define FULL_COEF_BUFFER_SUPPORTED}
  {$endif}
{$endif}

{ Initialize coefficient buffer controller. }

{GLOBAL}
procedure jinit_c_coef_controller (cinfo : j_compress_ptr;
                                   need_full_buffer : boolean);

implementation

{ Private buffer controller object }

type
  my_coef_ptr = ^my_coef_controller;
  my_coef_controller = record
    pub : jpeg_c_coef_controller; { public fields }

    iMCU_row_num : JDIMENSION;	{ iMCU row # within image }
    mcu_ctr : JDIMENSION;	{ counts MCUs processed in current row }
    MCU_vert_offset : int;	{ counts MCU rows within iMCU row }
    MCU_rows_per_iMCU_row : int;  { number of such rows needed }

    { For single-pass compression, it's sufficient to buffer just one MCU
      (although this may prove a bit slow in practice).  We allocate a
      workspace of C_MAX_BLOCKS_IN_MCU coefficient blocks, and reuse it for each
      MCU constructed and sent.  (On 80x86, the workspace is FAR even though
      it's not really very big; this is to keep the module interfaces unchanged
      when a large coefficient buffer is necessary.)
      In multi-pass modes, this array points to the current MCU's blocks
      within the virtual arrays. }

    MCU_buffer : array[0..C_MAX_BLOCKS_IN_MCU-1] of JBLOCKROW;

    { In multi-pass modes, we need a virtual block array for each component. }
    whole_image : array[0..MAX_COMPONENTS-1] of jvirt_barray_ptr;
  end;


{ Forward declarations }
{METHODDEF}
function compress_data(cinfo : j_compress_ptr;
                       input_buf : JSAMPIMAGE) : boolean; far; forward;
{$ifdef FULL_COEF_BUFFER_SUPPORTED
{METHODDEF}
function compress_first_pass(cinfo : j_compress_ptr;
                             input_buf : JSAMPIMAGE) : boolean;  far; forward;
{METHODDEF}
function compress_output(cinfo : j_compress_ptr;
                         input_buf : JSAMPIMAGE) : boolean;  far; forward;
{$endif}


{LOCAL}
procedure start_iMCU_row (cinfo : j_compress_ptr);
{ Reset within-iMCU-row counters for a new row }
var
  coef : my_coef_ptr;
begin
  coef := my_coef_ptr (cinfo^.coef);

  { In an interleaved scan, an MCU row is the same as an iMCU row.
    In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows.
    But at the bottom of the image, process only what's left. }
  if (cinfo^.comps_in_scan > 1) then
  begin
    coef^.MCU_rows_per_iMCU_row := 1;
  end
  else
  begin
    if (coef^.iMCU_row_num < (cinfo^.total_iMCU_rows-1)) then
      coef^.MCU_rows_per_iMCU_row := cinfo^.cur_comp_info[0]^.v_samp_factor
    else
      coef^.MCU_rows_per_iMCU_row := cinfo^.cur_comp_info[0]^.last_row_height;
  end;

  coef^.mcu_ctr := 0;
  coef^.MCU_vert_offset := 0;
end;


{ Initialize for a processing pass. }

{METHODDEF}
procedure start_pass_coef (cinfo : j_compress_ptr;
                           pass_mode : J_BUF_MODE); far;
var
  coef : my_coef_ptr;
begin
  coef := my_coef_ptr (cinfo^.coef);

  coef^.iMCU_row_num := 0;
  start_iMCU_row(cinfo);

  case (pass_mode) of
  JBUF_PASS_THRU:
    begin
      if (coef^.whole_image[0] <> NIL) then
        ERREXIT(j_common_ptr(cinfo), JERR_BAD_BUFFER_MODE);
      coef^.pub.compress_data := compress_data;
    end;
{$ifdef FULL_COEF_BUFFER_SUPPORTED}
  JBUF_SAVE_AND_PASS:
    begin
      if (coef^.whole_image[0] = NIL) then
        ERREXIT(j_common_ptr(cinfo), JERR_BAD_BUFFER_MODE);
      coef^.pub.compress_data := compress_first_pass;
    end;
  JBUF_CRANK_DEST:
    begin
      if (coef^.whole_image[0] = NIL) then
        ERREXIT(j_common_ptr(cinfo), JERR_BAD_BUFFER_MODE);
      coef^.pub.compress_data := compress_output;
    end;
{$endif}
  else
    ERREXIT(j_common_ptr(cinfo), JERR_BAD_BUFFER_MODE);
  end;
end;


{ Process some data in the single-pass case.
  We process the equivalent of one fully interleaved MCU row ("iMCU" row)
  per call, ie, v_samp_factor block rows for each component in the image.
  Returns TRUE if the iMCU row is completed, FALSE if suspended.

  NB: input_buf contains a plane for each component in image,
  which we index according to the component's SOF position. }


{METHODDEF}
function compress_data (cinfo : j_compress_ptr;
                        input_buf : JSAMPIMAGE) : boolean;
var
  coef : my_coef_ptr;
  MCU_col_num : JDIMENSION;	{ index of current MCU within row }
  last_MCU_col : JDIMENSION;
  last_iMCU_row : JDIMENSION;
  blkn, bi, ci, yindex, yoffset, blockcnt : int;
  ypos, xpos : JDIMENSION;
  compptr : jpeg_component_info_ptr;
begin
  coef := my_coef_ptr (cinfo^.coef);
  last_MCU_col := cinfo^.MCUs_per_row - 1;
  last_iMCU_row := cinfo^.total_iMCU_rows - 1;

  { Loop to write as much as one whole iMCU row }
  for yoffset := coef^.MCU_vert_offset to pred(coef^.MCU_rows_per_iMCU_row) do
  begin
    for MCU_col_num := coef^.mcu_ctr to last_MCU_col do
    begin
      { Determine where data comes from in input_buf and do the DCT thing.
        Each call on forward_DCT processes a horizontal row of DCT blocks
        as wide as an MCU; we rely on having allocated the MCU_buffer[] blocks
        sequentially.  Dummy blocks at the right or bottom edge are filled in
        specially.  The data in them does not matter for image reconstruction,
        so we fill them with values that will encode to the smallest amount of
        data, viz: all zeroes in the AC entries, DC entries equal to previous
        block's DC value.  (Thanks to Thomas Kinsman for this idea.) }

      blkn := 0;
      for ci := 0 to pred(cinfo^.comps_in_scan) do
      begin
	compptr := cinfo^.cur_comp_info[ci];
        if (MCU_col_num < last_MCU_col)  then
          blockcnt := compptr^.MCU_width
        else
          blockcnt := compptr^.last_col_width;
	xpos := MCU_col_num * compptr^.MCU_sample_width;
	ypos := yoffset * DCTSIZE;      { ypos = (yoffset+yindex) * DCTSIZE }
	for yindex := 0 to pred(compptr^.MCU_height) do
        begin
	  if (coef^.iMCU_row_num < last_iMCU_row) or
	     (yoffset+yindex < compptr^.last_row_height) then
          begin
	    cinfo^.fdct^.forward_DCT (cinfo, compptr,
				      input_buf^[compptr^.component_index],
				      coef^.MCU_buffer[blkn],
				      ypos, xpos, JDIMENSION (blockcnt));

	    if (blockcnt < compptr^.MCU_width) then
            begin
	      { Create some dummy blocks at the right edge of the image. }
	      jzero_far({FAR}pointer(coef^.MCU_buffer[blkn + blockcnt]),
			(compptr^.MCU_width - blockcnt) * SIZEOF(JBLOCK));
	      for bi := blockcnt to pred(compptr^.MCU_width) do
              begin
		coef^.MCU_buffer[blkn+bi]^[0][0] := coef^.MCU_buffer[blkn+bi-1]^[0][0];
	      end;
	    end;
	  end
          else
          begin
	    { Create a row of dummy blocks at the bottom of the image. }
	    jzero_far({FAR}pointer(coef^.MCU_buffer[blkn]),
		      compptr^.MCU_width * SIZEOF(JBLOCK));
	    for bi := 0 to pred(compptr^.MCU_width) do
            begin
	      coef^.MCU_buffer[blkn+bi]^[0][0] := coef^.MCU_buffer[blkn-1]^[0][0];
	    end;
	  end;
	  Inc(blkn, compptr^.MCU_width);
	  Inc(ypos, DCTSIZE);
	end;
      end;
      { Try to write the MCU.  In event of a suspension failure, we will
        re-DCT the MCU on restart (a bit inefficient, could be fixed...) }

      if (not cinfo^.entropy^.encode_mcu (cinfo, JBLOCKARRAY(@coef^.MCU_buffer)^)) then
      begin
	{ Suspension forced; update state counters and exit }
	coef^.MCU_vert_offset := yoffset;
	coef^.mcu_ctr := MCU_col_num;
	compress_data := FALSE;
        exit;
      end;
    end;
    { Completed an MCU row, but perhaps not an iMCU row }
    coef^.mcu_ctr := 0;
  end;
  { Completed the iMCU row, advance counters for next one }
  Inc(coef^.iMCU_row_num);
  start_iMCU_row(cinfo);
  compress_data := TRUE;
end;


{$ifdef FULL_COEF_BUFFER_SUPPORTED}

{ Process some data in the first pass of a multi-pass case.
  We process the equivalent of one fully interleaved MCU row ("iMCU" row)
  per call, ie, v_samp_factor block rows for each component in the image.