CentrED

unit imjccoefct;

{ 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

{$I imjconfig.inc}

uses

  imjmorecfg,

  imjinclude,

  imjerror,

  imjdeferr,

  imjutils,

  imjpeglib;

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

{$ifdef FULL_COEF_BUFFER_SUPPORTED}

{METHODDEF}

function compress_first_pass(cinfo : j_compress_ptr;

                             input_buf : JSAMPIMAGE) : boolean;  forward;

{METHODDEF}

function compress_output(cinfo : j_compress_ptr;

                         input_buf : JSAMPIMAGE) : boolean;  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);  

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 * JDIMENSION(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.

  This amount of data is read from the source buffer, DCT'd and quantized,

  and saved into the virtual arrays.  We also generate suitable dummy blocks

  as needed at the right and lower edges.  (The dummy blocks are constructed

  in the virtual arrays, which have been padded appropriately.)  This makes

  it possible for subsequent passes not to worry about real vs. dummy blocks.

  We must also emit the data to the entropy encoder.  This is conveniently

  done by calling compress_output() after we've loaded the current strip

  of the virtual arrays.

  NB: input_buf contains a plane for each component in image.  All

  components are DCT'd and loaded into the virtual arrays in this pass.

  However, it may be that only a subset of the components are emitted to

  the entropy encoder during this first pass; be careful about looking

  at the scan-dependent variables (MCU dimensions, etc). }

{METHODDEF}

function compress_first_pass (cinfo : j_compress_ptr;

                              input_buf : JSAMPIMAGE) : boolean;

var

  coef : my_coef_ptr;

  last_iMCU_row : JDIMENSION;

  blocks_across, MCUs_across, MCUindex : JDIMENSION;

  bi, ci, h_samp_factor, block_row, block_rows, ndummy : int;

  lastDC : JCOEF;

  compptr : jpeg_component_info_ptr;

  buffer : JBLOCKARRAY;

  thisblockrow, lastblockrow : JBLOCKROW;

begin

  coef := my_coef_ptr (cinfo^.coef);

  last_iMCU_row := cinfo^.total_iMCU_rows - 1;

  compptr := jpeg_component_info_ptr(cinfo^.comp_info);

  for ci := 0 to pred(cinfo^.num_components) do

  begin

    { Align the virtual buffer for this component. }

    buffer := cinfo^.mem^.access_virt_barray

      (j_common_ptr(cinfo), coef^.whole_image[ci],

       coef^.iMCU_row_num * JDIMENSION(compptr^.v_samp_factor),

       JDIMENSION (compptr^.v_samp_factor), TRUE);

    { Count non-dummy DCT block rows in this iMCU row. }

    if (coef^.iMCU_row_num < last_iMCU_row) then

      block_rows := compptr^.v_samp_factor

    else

    begin

      { NB: can't use last_row_height here, since may not be set! }

      block_rows := int (compptr^.height_in_blocks) mod compptr^.v_samp_factor;

      if (block_rows = 0) then

        block_rows := compptr^.v_samp_factor;

    end;

    blocks_across := compptr^.width_in_blocks;

    h_samp_factor := compptr^.h_samp_factor;

    { Count number of dummy blocks to be added at the right margin. }

    ndummy := int (blocks_across) mod h_samp_factor;

    if (ndummy > 0) then

      ndummy := h_samp_factor - ndummy;

    { Perform DCT for all non-dummy blocks in this iMCU row.  Each call

      on forward_DCT processes a complete horizontal row of DCT blocks. }

    for block_row := 0 to pred(block_rows) do

    begin

      thisblockrow := buffer^[block_row];

      cinfo^.fdct^.forward_DCT (cinfo, compptr,

                                input_buf^[ci],

                                thisblockrow,

                                JDIMENSION (block_row * DCTSIZE),

                                JDIMENSION (0),

                                blocks_across);

      if (ndummy > 0) then

      begin

        { Create dummy blocks at the right edge of the image. }

        Inc(JBLOCK_PTR(thisblockrow), blocks_across); { => first dummy block }

        jzero_far({FAR}pointer(thisblockrow), ndummy * SIZEOF(JBLOCK));

        {lastDC := thisblockrow^[-1][0];}

        { work around Range Checking }

        Dec(JBLOCK_PTR(thisblockrow));

        lastDC := thisblockrow^[0][0];

        Inc(JBLOCK_PTR(thisblockrow));

        for bi := 0 to pred(ndummy) do

        begin

          thisblockrow^[bi][0] := lastDC;

        end;

      end;

    end;

    { If at end of image, create dummy block rows as needed.

      The tricky part here is that within each MCU, we want the DC values

      of the dummy blocks to match the last real block's DC value.

      This squeezes a few more bytes out of the resulting file... }

    if (coef^.iMCU_row_num = last_iMCU_row) then

    begin

      Inc(blocks_across, ndummy);       { include lower right corner }

      MCUs_across := blocks_across div JDIMENSION(h_samp_factor);

      for block_row := block_rows to pred(compptr^.v_samp_factor) do

      begin

        thisblockrow := buffer^[block_row];

        lastblockrow := buffer^[block_row-1];

        jzero_far({FAR} pointer(thisblockrow),

                  size_t(blocks_across * SIZEOF(JBLOCK)));

        for MCUindex := 0 to pred(MCUs_across) do

        begin

          lastDC := lastblockrow^[h_samp_factor-1][0];

          for bi := 0 to pred(h_samp_factor) do

          begin

            thisblockrow^[bi][0] := lastDC;

          end;

          Inc(JBLOCK_PTR(thisblockrow), h_samp_factor); { advance to next MCU in row }

          Inc(JBLOCK_PTR(lastblockrow), h_samp_factor);

        end;

      end;

    end;

    Inc(compptr);

  end;

  { NB: compress_output will increment iMCU_row_num if successful.

    A suspension return will result in redoing all the work above next time.}

  { Emit data to the entropy encoder, sharing code with subsequent passes }

  compress_first_pass := compress_output(cinfo, input_buf);

end;

{ Process some data in subsequent passes 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 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;

var

  coef : my_coef_ptr;

  MCU_col_num : JDIMENSION;        { index of current MCU within row }

  blkn, ci, xindex, yindex, yoffset : int;

  start_col : JDIMENSION;

  buffer : array[0..MAX_COMPS_IN_SCAN-1] of JBLOCKARRAY;

  buffer_ptr : JBLOCKROW;

  compptr : jpeg_component_info_ptr;

begin

  coef := my_coef_ptr (cinfo^.coef);

  { Align the virtual buffers for the components used in this scan.

    NB: during first pass, this is safe only because the buffers will

    already be aligned properly, so jmemmgr.c won't need to do any I/O. }

  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 * JDIMENSION(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 * JDIMENSION(compptr^.MCU_width);

        for yindex := 0 to pred(compptr^.MCU_height) do

        begin

          buffer_ptr := JBLOCKROW(@ buffer[ci]^[yindex+yoffset]^[start_col]);

          for xindex := 0 to pred(compptr^.MCU_width) do

          begin

            coef^.MCU_buffer[blkn] := buffer_ptr;

            Inc(blkn);

            Inc(JBLOCK_PTR(buffer_ptr));

          end;

        end;

      end;

      { Try to write the MCU. }

      if (not cinfo^.entropy^.encode_mcu (cinfo, coef^.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;

{$endif} { FULL_COEF_BUFFER_SUPPORTED }

{ Initialize coefficient buffer controller. }

{GLOBAL}

procedure jinit_c_coef_controller (cinfo : j_compress_ptr;

                                   need_full_buffer : boolean);

var

  coef : my_coef_ptr;

var

  buffer : JBLOCKROW;

  i : int;

var

  ci : int;

  compptr : jpeg_component_info_ptr;

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;

  { Create the coefficient buffer. }

  if (need_full_buffer) then

  begin

{$ifdef FULL_COEF_BUFFER_SUPPORTED}

    { Allocate a full-image virtual array for each component, }

    { padded to a multiple of samp_factor DCT blocks in each direction. }

    compptr := jpeg_component_info_ptr(cinfo^.comp_info);

    for ci := 0 to pred(cinfo^.num_components) do

    begin

      coef^.whole_image[ci] := cinfo^.mem^.request_virt_barray

        (j_common_ptr(cinfo), JPOOL_IMAGE, FALSE,

         JDIMENSION (jround_up( long (compptr^.width_in_blocks),

                                long (compptr^.h_samp_factor) )),

         JDIMENSION (jround_up(long (compptr^.height_in_blocks),

                                long (compptr^.v_samp_factor))),

         JDIMENSION (compptr^.v_samp_factor));

      Inc(compptr);

    end;

{$else}

    ERREXIT(j_common_ptr(cinfo), JERR_BAD_BUFFER_MODE);

{$endif}

  end

  else

  begin

    { We only need a single-MCU buffer. }

    buffer := JBLOCKROW (

      cinfo^.mem^.alloc_large (j_common_ptr(cinfo), JPOOL_IMAGE,

                                  C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK)) );

    for i := 0 to pred(C_MAX_BLOCKS_IN_MCU) do

    begin

      coef^.MCU_buffer[i] := JBLOCKROW(@ buffer^[i]);

    end;

    coef^.whole_image[0] := NIL; { flag for no virtual arrays }

  end;

end;

end.