jctrans.pas

用pascal寫的jpeg codec, 測試過的

  cinfo^.marker^.write_file_header (cinfo);
end;


{ The rest of this file is a special implementation of the coefficient
  buffer controller.  This is similar to jccoefct.c, but it handles only
  output from presupplied virtual arrays.  Furthermore, we generate any
  dummy padding blocks on-the-fly rather than expecting them to be present
  in the arrays. }

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

    { Virtual block array for each component. }
    whole_image : jvirt_barray_tbl_ptr;

    { Workspace for constructing dummy blocks at right/bottom edges. }
    dummy_buffer : array[0..C_MAX_BLOCKS_IN_MCU-1] of JBLOCKROW;
  end; {my_coef_controller;}


{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);

  if (pass_mode <> JBUF_CRANK_DEST) then
    ERREXIT(j_common_ptr(cinfo), JERR_BAD_BUFFER_MODE);

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


{ Process some data.
  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 scan.
  The data is obtained from the virtual arrays and fed to the entropy coder.
  Returns TRUE if the iMCU row is completed, FALSE if suspended.

  NB: input_buf is ignored; it is likely to be a NIL pointer. }

{METHODDEF}
function compress_output (cinfo : j_compress_ptr;
                          input_buf : JSAMPIMAGE) : boolean; far;
var
  coef : my_coef_ptr;
  MCU_col_num : JDIMENSION;	{ index of current MCU within row }
  last_MCU_col : JDIMENSION;
  last_iMCU_row : JDIMENSION;
  blkn, ci, xindex, yindex, yoffset, blockcnt : int;
  start_col : JDIMENSION;
  buffer : array[0..MAX_COMPS_IN_SCAN-1] of JBLOCKARRAY;
  MCU_buffer : array[0..C_MAX_BLOCKS_IN_MCU-1] of JBLOCKROW;
  buffer_ptr : JBLOCKROW;
  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;

  { Align the virtual buffers for the components used in this scan. }
  for ci := 0 to pred(cinfo^.comps_in_scan) do
  begin
    compptr := cinfo^.cur_comp_info[ci];
    buffer[ci] := cinfo^.mem^.access_virt_barray
      (j_common_ptr(cinfo), coef^.whole_image^[compptr^.component_index],
       coef^.iMCU_row_num * compptr^.v_samp_factor,
       JDIMENSION(compptr^.v_samp_factor), FALSE);
  end;

  { Loop to process 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 pred(cinfo^.MCUs_per_row) do
    begin
      { Construct list of pointers to DCT blocks belonging to this MCU }
      blkn := 0;			{ index of current DCT block within MCU }
      for ci := 0 to pred(cinfo^.comps_in_scan) do
      begin
	compptr := cinfo^.cur_comp_info[ci];
	start_col := MCU_col_num * compptr^.MCU_width;
        if (MCU_col_num < last_MCU_col) then
          blockcnt := compptr^.MCU_width
        else
	  blockcnt := compptr^.last_col_width;
	for yindex := 0 to pred(compptr^.MCU_height) do
        begin
	  if (coef^.iMCU_row_num < last_iMCU_row) or
	     (yindex+yoffset < compptr^.last_row_height) then
          begin
	    { Fill in pointers to real blocks in this row }
	    buffer_ptr := JBLOCKROW(@ buffer[ci]^[yindex+yoffset]^[start_col]);
	    for xindex := 0 to pred(blockcnt) do
            begin
	      MCU_buffer[blkn] := buffer_ptr;
              Inc(blkn);
              Inc(JBLOCK_PTR(buffer_ptr));
            end;
	  end
          else
          begin
	    { At bottom of image, need a whole row of dummy blocks }
	    xindex := 0;
	  end;
	  { Fill in any dummy blocks needed in this row.
	    Dummy blocks are filled in the same way as in jccoefct.c:
	    all zeroes in the AC entries, DC entries equal to previous
	    block's DC value.  The init routine has already zeroed the
	    AC entries, so we need only set the DC entries correctly. }

	  while (xindex < compptr^.MCU_width) do
          begin
	    MCU_buffer[blkn] := coef^.dummy_buffer[blkn];
	    MCU_buffer[blkn]^[0][0] := MCU_buffer[blkn-1]^[0][0];
            Inc(xindex);
	    Inc(blkn);
	  end;
	end;
      end;
      { Try to write the MCU. }
      if (not cinfo^.entropy^.encode_mcu (cinfo, MCU_buffer)) then
      begin
	{ Suspension forced; update state counters and exit }
	coef^.MCU_vert_offset := yoffset;
	coef^.mcu_ctr := MCU_col_num;
	compress_output := 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_output := TRUE;
end;


{ Initialize coefficient buffer controller.

  Each passed coefficient array must be the right size for that
  coefficient: width_in_blocks wide and height_in_blocks high,
  with unitheight at least v_samp_factor. }

{LOCAL}
procedure transencode_coef_controller (cinfo : j_compress_ptr;
			               coef_arrays : jvirt_barray_tbl_ptr);
var
  coef : my_coef_ptr;
  buffer : JBLOCKROW;
  i : int;
begin
  coef := my_coef_ptr(
    cinfo^.mem^.alloc_small (j_common_ptr(cinfo), JPOOL_IMAGE,
				SIZEOF(my_coef_controller)));
  cinfo^.coef := jpeg_c_coef_controller_ptr (coef);
  coef^.pub.start_pass := start_pass_coef;
  coef^.pub.compress_data := compress_output;

  { Save pointer to virtual arrays }
  coef^.whole_image := coef_arrays;

  { Allocate and pre-zero space for dummy DCT blocks. }
  buffer := JBLOCKROW(
    cinfo^.mem^.alloc_large (j_common_ptr(cinfo), JPOOL_IMAGE,
				C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK)) );
  jzero_far({FAR} pointer(buffer), C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
  for i := 0 to pred(C_MAX_BLOCKS_IN_MCU) do
  begin
    coef^.dummy_buffer[i] := JBLOCKROW(@ buffer^[i]);
  end;
end;

end.