CentrED/Imaging/JpegLib/imjcphuff.pas

unit imjcphuff;

{ This file contains Huffman entropy encoding routines for progressive JPEG.

  We do not support output suspension in this module, since the library
  currently does not allow multiple-scan files to be written with output
  suspension. }

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

interface

{$I imjconfig.inc}

uses
  imjmorecfg,
  imjinclude,
  imjpeglib,
  imjdeferr,
  imjerror,
  imjutils,
  imjcomapi,
  imjchuff;       	{ Declarations shared with jchuff.c }

{ Module initialization routine for progressive Huffman entropy encoding. }

{GLOBAL}
procedure jinit_phuff_encoder (cinfo : j_compress_ptr);

implementation

{ Expanded entropy encoder object for progressive Huffman encoding. }
type
  phuff_entropy_ptr = ^phuff_entropy_encoder;
  phuff_entropy_encoder = record
    pub : jpeg_entropy_encoder; { public fields }

    { Mode flag: TRUE for optimization, FALSE for actual data output }
    gather_statistics : boolean;

    { Bit-level coding status.
      next_output_byte/free_in_buffer are local copies of cinfo^.dest fields.}

    next_output_byte : JOCTETptr; { => next byte to write in buffer }
    free_in_buffer : size_t;    { # of byte spaces remaining in buffer }
    put_buffer : INT32;		{ current bit-accumulation buffer }
    put_bits : int;             { # of bits now in it }
    cinfo : j_compress_ptr;     { link to cinfo (needed for dump_buffer) }

    { Coding status for DC components }
    last_dc_val : array[0..MAX_COMPS_IN_SCAN-1] of int;
                                { last DC coef for each component }

    { Coding status for AC components }
    ac_tbl_no : int;            { the table number of the single component }
    EOBRUN : uInt;              { run length of EOBs }
    BE : uInt;                  { # of buffered correction bits before MCU }
    bit_buffer : JBytePtr;      { buffer for correction bits (1 per char) }
    { packing correction bits tightly would save some space but cost time... }

    restarts_to_go : uInt;	{ MCUs left in this restart interval }
    next_restart_num : int;     { next restart number to write (0-7) }

    { Pointers to derived tables (these workspaces have image lifespan).
      Since any one scan codes only DC or only AC, we only need one set
      of tables, not one for DC and one for AC. }

    derived_tbls : array[0..NUM_HUFF_TBLS-1] of c_derived_tbl_ptr;

    { Statistics tables for optimization; again, one set is enough }
    count_ptrs : array[0..NUM_HUFF_TBLS-1] of TLongTablePtr;
  end;


{ MAX_CORR_BITS is the number of bits the AC refinement correction-bit
  buffer can hold.  Larger sizes may slightly improve compression, but
  1000 is already well into the realm of overkill.
  The minimum safe size is 64 bits. }

const
  MAX_CORR_BITS = 1000;         { Max # of correction bits I can buffer }


{ Forward declarations }
{METHODDEF}
function encode_mcu_DC_first (cinfo : j_compress_ptr;
                              const MCU_data: array of JBLOCKROW) : boolean;
                              forward;
{METHODDEF}
function encode_mcu_AC_first (cinfo : j_compress_ptr;
                              const MCU_data: array of JBLOCKROW) : boolean;
                              forward;
{METHODDEF}
function encode_mcu_DC_refine (cinfo : j_compress_ptr;
                              const MCU_data: array of JBLOCKROW) : boolean;
                              forward;
{METHODDEF}
function encode_mcu_AC_refine (cinfo : j_compress_ptr;
                              const MCU_data: array of JBLOCKROW) : boolean;
                              forward;

{METHODDEF}
procedure finish_pass_phuff (cinfo : j_compress_ptr); forward;

{METHODDEF}
procedure finish_pass_gather_phuff (cinfo : j_compress_ptr); forward;


{ Initialize for a Huffman-compressed scan using progressive JPEG. }

{METHODDEF}
procedure start_pass_phuff (cinfo : j_compress_ptr;
                            gather_statistics : boolean);  
var
  entropy : phuff_entropy_ptr;
  is_DC_band : boolean;
  ci, tbl : int;
  compptr : jpeg_component_info_ptr;
begin
  tbl := 0;
  entropy := phuff_entropy_ptr (cinfo^.entropy);

  entropy^.cinfo := cinfo;
  entropy^.gather_statistics := gather_statistics;

  is_DC_band := (cinfo^.Ss = 0);

  { We assume jcmaster.c already validated the scan parameters. }

  { Select execution routines }
  if (cinfo^.Ah = 0) then
  begin
    if (is_DC_band) then
      entropy^.pub.encode_mcu := encode_mcu_DC_first
    else
      entropy^.pub.encode_mcu := encode_mcu_AC_first;
  end
  else
  begin
    if (is_DC_band) then
      entropy^.pub.encode_mcu := encode_mcu_DC_refine
    else
    begin
      entropy^.pub.encode_mcu := encode_mcu_AC_refine;
      { AC refinement needs a correction bit buffer }
      if (entropy^.bit_buffer = NIL) then
	entropy^.bit_buffer := JBytePtr(
	  cinfo^.mem^.alloc_small (j_common_ptr(cinfo), JPOOL_IMAGE,
				      MAX_CORR_BITS * SIZEOF(byte)) );
    end;
  end;
  if (gather_statistics) then
    entropy^.pub.finish_pass := finish_pass_gather_phuff
  else
    entropy^.pub.finish_pass := finish_pass_phuff;

  { Only DC coefficients may be interleaved, so cinfo^.comps_in_scan = 1
    for AC coefficients. }

  for ci := 0 to pred(cinfo^.comps_in_scan) do
  begin
    compptr := cinfo^.cur_comp_info[ci];
    { Initialize DC predictions to 0 }
    entropy^.last_dc_val[ci] := 0;
    { Get table index }
    if (is_DC_band) then
    begin
      if (cinfo^.Ah <> 0) then  { DC refinement needs no table }
	continue;
      tbl := compptr^.dc_tbl_no;
    end
    else
    begin
      tbl := compptr^.ac_tbl_no;
      entropy^.ac_tbl_no := tbl;
    end;
    if (gather_statistics) then
    begin
      { Check for invalid table index }
      { (make_c_derived_tbl does this in the other path) }
      if (tbl < 0) or (tbl >= NUM_HUFF_TBLS) then
        ERREXIT1(j_common_ptr(cinfo), JERR_NO_HUFF_TABLE, tbl);
      { Allocate and zero the statistics tables }
      { Note that jpeg_gen_optimal_table expects 257 entries in each table! }
      if (entropy^.count_ptrs[tbl] = NIL) then
	entropy^.count_ptrs[tbl] := TLongTablePtr(
	  cinfo^.mem^.alloc_small (j_common_ptr(cinfo), JPOOL_IMAGE,
				      257 * SIZEOF(long)) );
      MEMZERO(entropy^.count_ptrs[tbl], 257 * SIZEOF(long));
    end else
    begin
      { Compute derived values for Huffman table }
      { We may do this more than once for a table, but it's not expensive }
      jpeg_make_c_derived_tbl(cinfo, is_DC_band, tbl,
			      entropy^.derived_tbls[tbl]);
    end;
  end;

  { Initialize AC stuff }
  entropy^.EOBRUN := 0;
  entropy^.BE := 0;

  { Initialize bit buffer to empty }
  entropy^.put_buffer := 0;
  entropy^.put_bits := 0;

  { Initialize restart stuff }
  entropy^.restarts_to_go := cinfo^.restart_interval;
  entropy^.next_restart_num := 0;
end;




{LOCAL}
procedure dump_buffer (entropy : phuff_entropy_ptr);
{ Empty the output buffer; we do not support suspension in this module. }
var
  dest : jpeg_destination_mgr_ptr;
begin
  dest := entropy^.cinfo^.dest;

  if (not dest^.empty_output_buffer (entropy^.cinfo)) then
    ERREXIT(j_common_ptr(entropy^.cinfo), JERR_CANT_SUSPEND);
  { After a successful buffer dump, must reset buffer pointers }
  entropy^.next_output_byte := dest^.next_output_byte;
  entropy^.free_in_buffer := dest^.free_in_buffer;
end;


{ Outputting bits to the file }

{ Only the right 24 bits of put_buffer are used; the valid bits are
  left-justified in this part.  At most 16 bits can be passed to emit_bits
  in one call, and we never retain more than 7 bits in put_buffer
  between calls, so 24 bits are sufficient. }


{LOCAL}
procedure emit_bits (entropy : phuff_entropy_ptr;
                     code : uInt;
                     size : int); {INLINE}
{ Emit some bits, unless we are in gather mode }
var
  {register} put_buffer : INT32;
  {register} put_bits : int;
var
  c : int;
begin
  { This routine is heavily used, so it's worth coding tightly. }
  put_buffer := INT32 (code);
  put_bits := entropy^.put_bits;

  { if size is 0, caller used an invalid Huffman table entry }
  if (size = 0) then
    ERREXIT(j_common_ptr(entropy^.cinfo), JERR_HUFF_MISSING_CODE);

  if (entropy^.gather_statistics) then
    exit;			{ do nothing if we're only getting stats }

  put_buffer := put_buffer and ((INT32(1) shl size) - 1);
                                { mask off any extra bits in code }

  Inc(put_bits, size);          { new number of bits in buffer }

  put_buffer := put_buffer shl (24 - put_bits); { align incoming bits }

  put_buffer := put_buffer or entropy^.put_buffer;
                                { and merge with old buffer contents }

  while (put_bits >= 8) do
  begin
    c := int ((put_buffer shr 16) and $FF);

    {emit_byte(entropy, c);}
    { Outputting bytes to the file.
      NB: these must be called only when actually outputting,
      that is, entropy^.gather_statistics = FALSE. }
    { Emit a byte }
    entropy^.next_output_byte^ := JOCTET(c);
    Inc(entropy^.next_output_byte);
    Dec(entropy^.free_in_buffer);
    if (entropy^.free_in_buffer = 0) then
      dump_buffer(entropy);

    if (c = $FF) then
    begin		{ need to stuff a zero byte? }
      {emit_byte(entropy, 0);}
      entropy^.next_output_byte^ := JOCTET(0);
      Inc(entropy^.next_output_byte);
      Dec(entropy^.free_in_buffer);
      if (entropy^.free_in_buffer = 0) then
        dump_buffer(entropy);
    end;
    put_buffer := put_buffer shl 8;
    Dec(put_bits, 8);
  end;

  entropy^.put_buffer := put_buffer; { update variables }
  entropy^.put_bits := put_bits;
end;


{LOCAL}
procedure flush_bits (entropy : phuff_entropy_ptr);
begin
  emit_bits(entropy, $7F, 7); { fill any partial byte with ones }
  entropy^.put_buffer := 0;     { and reset bit-buffer to empty }
  entropy^.put_bits := 0;
end;

{ Emit (or just count) a Huffman symbol. }


{LOCAL}
procedure emit_symbol (entropy : phuff_entropy_ptr;
                       tbl_no : int;
                       symbol : int); {INLINE}
var
  tbl : c_derived_tbl_ptr;
begin
  if (entropy^.gather_statistics) then
    Inc(entropy^.count_ptrs[tbl_no]^[symbol])
  else
  begin
    tbl := entropy^.derived_tbls[tbl_no];
    emit_bits(entropy, tbl^.ehufco[symbol], tbl^.ehufsi[symbol]);
  end;
end;


{ Emit bits from a correction bit buffer. }

{LOCAL}
procedure emit_buffered_bits (entropy : phuff_entropy_ptr;
                              bufstart : JBytePtr;
		              nbits : uInt);
var
  bufptr : byteptr;
begin
  if (entropy^.gather_statistics) then
    exit;			{ no real work }

  bufptr := byteptr(bufstart);
  while (nbits > 0) do
  begin
    emit_bits(entropy, uInt(bufptr^), 1);
    Inc(bufptr);
    Dec(nbits);
  end;
end;


{ Emit any pending EOBRUN symbol. }

{LOCAL}
procedure emit_eobrun (entropy : phuff_entropy_ptr);
var
  {register} temp, nbits : int;
begin
  if (entropy^.EOBRUN > 0) then
  begin	                       { if there is any pending EOBRUN }
    temp := entropy^.EOBRUN;
    nbits := 0;
    temp := temp shr 1;
    while (temp <> 0) do
    begin
      Inc(nbits);
      temp := temp shr 1;
    end;

    { safety check: shouldn't happen given limited correction-bit buffer }
    if (nbits > 14) then
      ERREXIT(j_common_ptr(entropy^.cinfo), JERR_HUFF_MISSING_CODE);

    emit_symbol(entropy, entropy^.ac_tbl_no, nbits shl 4);
    if (nbits <> 0) then
      emit_bits(entropy, entropy^.EOBRUN, nbits);

    entropy^.EOBRUN := 0;

    { Emit any buffered correction bits }
    emit_buffered_bits(entropy, entropy^.bit_buffer, entropy^.BE);
    entropy^.BE := 0;
  end;
end;


{ Emit a restart marker & resynchronize predictions. }

{LOCAL}
procedure emit_restart (entropy : phuff_entropy_ptr;
                        restart_num : int);
var
  ci : int;
begin
  emit_eobrun(entropy);

  if (not entropy^.gather_statistics) then
  begin
    flush_bits(entropy);
    {emit_byte(entropy, $FF);}
    { Outputting bytes to the file.
      NB: these must be called only when actually outputting,
      that is, entropy^.gather_statistics = FALSE. }

    entropy^.next_output_byte^ := JOCTET($FF);
    Inc(entropy^.next_output_byte);
    Dec(entropy^.free_in_buffer);
    if (entropy^.free_in_buffer = 0) then
      dump_buffer(entropy);

    {emit_byte(entropy, JPEG_RST0 + restart_num);}
    entropy^.next_output_byte^ := JOCTET(JPEG_RST0 + restart_num);
    Inc(entropy^.next_output_byte);
    Dec(entropy^.free_in_buffer);
    if (entropy^.free_in_buffer = 0) then
      dump_buffer(entropy);
  end;

  if (entropy^.cinfo^.Ss = 0) then
  begin
    { Re-initialize DC predictions to 0 }
    for ci := 0 to pred(entropy^.cinfo^.comps_in_scan) do
      entropy^.last_dc_val[ci] := 0;
  end
  else
  begin
    { Re-initialize all AC-related fields to 0 }
    entropy^.EOBRUN := 0;
    entropy^.BE := 0;
  end;
end;


{ MCU encoding for DC initial scan (either spectral selection,
  or first pass of successive approximation). }

{METHODDEF}
function encode_mcu_DC_first (cinfo : j_compress_ptr;
                              const MCU_data: array of JBLOCKROW) : boolean;
var
  entropy : phuff_entropy_ptr;
  {register} temp, temp2 : int;
  {register} nbits : int;
  blkn, ci : int;
  Al : int;
  block : JBLOCK_PTR;
  compptr : jpeg_component_info_ptr;
  ishift_temp : int;
begin
  entropy := phuff_entropy_ptr (cinfo^.entropy);
  Al := cinfo^.Al;

  entropy^.next_output_byte := cinfo^.dest^.next_output_byte;
  entropy^.free_in_buffer := cinfo^.dest^.free_in_buffer;

  { Emit restart marker if needed }
  if (cinfo^.restart_interval <> 0) then
    if (entropy^.restarts_to_go = 0) then
      emit_restart(entropy, entropy^.next_restart_num);

  { Encode the MCU data blocks }
  for blkn := 0 to pred(cinfo^.blocks_in_MCU) do
  begin
    block := JBLOCK_PTR(MCU_data[blkn]);
    ci := cinfo^.MCU_membership[blkn];
    compptr := cinfo^.cur_comp_info[ci];

    { Compute the DC value after the required point transform by Al.
      This is simply an arithmetic right shift. }

    {temp2 := IRIGHT_SHIFT( int(block^[0]), Al);}
    {IRIGHT_SHIFT_IS_UNSIGNED}
    ishift_temp := int(block^[0]);
    if ishift_temp < 0 then
      temp2 := (ishift_temp shr Al) or ((not 0) shl (16-Al))
    else
      temp2 := ishift_temp shr Al;


    { DC differences are figured on the point-transformed values. }
    temp := temp2 - entropy^.last_dc_val[ci];
    entropy^.last_dc_val[ci] := temp2;

    { Encode the DC coefficient difference per section G.1.2.1 }
    temp2 := temp;
    if (temp < 0) then
    begin
      temp := -temp;		{ temp is abs value of input }
      { For a negative input, want temp2 := bitwise complement of abs(input) }
      { This code assumes we are on a two's complement machine }
      Dec(temp2);
    end;

    { Find the number of bits needed for the magnitude of the coefficient }
    nbits := 0;
    while (temp <> 0) do
    begin
      Inc(nbits);
      temp := temp shr 1;
    end;

    { Check for out-of-range coefficient values.
      Since we're encoding a difference, the range limit is twice as much. }

    if (nbits > MAX_COEF_BITS+1) then
      ERREXIT(j_common_ptr(cinfo), JERR_BAD_DCT_COEF);

    { Count/emit the Huffman-coded symbol for the number of bits }
    emit_symbol(entropy, compptr^.dc_tbl_no, nbits);

    { Emit that number of bits of the value, if positive, }
    { or the complement of its magnitude, if negative. }
    if (nbits <> 0) then       { emit_bits rejects calls with size 0 }
      emit_bits(entropy, uInt(temp2), nbits);
  end;

  cinfo^.dest^.next_output_byte := entropy^.next_output_byte;
  cinfo^.dest^.free_in_buffer := entropy^.free_in_buffer;

  { Update restart-interval state too }
  if (cinfo^.restart_interval <> 0) then
  begin
    if (entropy^.restarts_to_go = 0) then
    begin
      entropy^.restarts_to_go := cinfo^.restart_interval;
      Inc(entropy^.next_restart_num);
      with entropy^ do
        next_restart_num := next_restart_num and 7;
    end;
    Dec(entropy^.restarts_to_go);
  end;

  encode_mcu_DC_first := TRUE;
end;


{ MCU encoding for AC initial scan (either spectral selection,
  or first pass of successive approximation). }

{METHODDEF}
function encode_mcu_AC_first (cinfo : j_compress_ptr;
                              const MCU_data: array of JBLOCKROW) : boolean;
var
  entropy : phuff_entropy_ptr;
  {register} temp, temp2 : int;
  {register} nbits : int;
  {register} r, k : int;
  Se : int;
  Al : int;
  block : JBLOCK_PTR;
begin
  entropy := phuff_entropy_ptr (cinfo^.entropy);
  Se := cinfo^.Se;
  Al := cinfo^.Al;

  entropy^.next_output_byte := cinfo^.dest^.next_output_byte;
  entropy^.free_in_buffer := cinfo^.dest^.free_in_buffer;

  { Emit restart marker if needed }
  if (cinfo^.restart_interval <> 0) then
    if (entropy^.restarts_to_go = 0) then
      emit_restart(entropy, entropy^.next_restart_num);

  { Encode the MCU data block }
  block := JBLOCK_PTR(MCU_data[0]);

  { Encode the AC coefficients per section G.1.2.2, fig. G.3 }

  r := 0;			{ r := run length of zeros }

  for k := cinfo^.Ss to Se do
  begin
    temp := (block^[jpeg_natural_order[k]]);
    if (temp = 0) then
    begin
      Inc(r);
      continue;
    end;
    { We must apply the point transform by Al.  For AC coefficients this
      is an integer division with rounding towards 0.  To do this portably
      in C, we shift after obtaining the absolute value; so the code is
      interwoven with finding the abs value (temp) and output bits (temp2). }

    if (temp < 0) then
    begin
      temp := -temp;		{ temp is abs value of input }
      temp := temp shr Al;	{ apply the point transform }
      { For a negative coef, want temp2 := bitwise complement of abs(coef) }
      temp2 := not temp;
    end
    else
    begin
      temp := temp shr Al;	{ apply the point transform }
      temp2 := temp;
    end;
    { Watch out for case that nonzero coef is zero after point transform }
    if (temp = 0) then
    begin
      Inc(r);
      continue;
    end;

    { Emit any pending EOBRUN }
    if (entropy^.EOBRUN > 0) then
      emit_eobrun(entropy);
    { if run length > 15, must emit special run-length-16 codes ($F0) }
    while (r > 15) do
    begin
      emit_symbol(entropy, entropy^.ac_tbl_no, $F0);
      Dec(r, 16);
    end;

    { Find the number of bits needed for the magnitude of the coefficient }
    nbits := 0;			{ there must be at least one 1 bit }
    repeat
      Inc(nbits);
      temp := temp shr 1;
    until (temp = 0);

    { Check for out-of-range coefficient values }
    if (nbits > MAX_COEF_BITS) then
      ERREXIT(j_common_ptr(cinfo), JERR_BAD_DCT_COEF);

    { Count/emit Huffman symbol for run length / number of bits }
    emit_symbol(entropy, entropy^.ac_tbl_no, (r shl 4) + nbits);

    { Emit that number of bits of the value, if positive, }
    { or the complement of its magnitude, if negative. }
    emit_bits(entropy, uInt(temp2), nbits);

    r := 0;			{ reset zero run length }
  end;

  if (r > 0) then
  begin			        { If there are trailing zeroes, }
    Inc(entropy^.EOBRUN);	{ count an EOB }
    if (entropy^.EOBRUN = $7FFF) then
      emit_eobrun(entropy);	{ force it out to avoid overflow }
  end;

  cinfo^.dest^.next_output_byte := entropy^.next_output_byte;
  cinfo^.dest^.free_in_buffer := entropy^.free_in_buffer;

  { Update restart-interval state too }
  if (cinfo^.restart_interval <> 0) then
  begin
    if (entropy^.restarts_to_go = 0) then
    begin
      entropy^.restarts_to_go := cinfo^.restart_interval;
      Inc(entropy^.next_restart_num);
      with entropy^ do
        next_restart_num := next_restart_num and 7;
    end;
    Dec(entropy^.restarts_to_go);
  end;

  encode_mcu_AC_first := TRUE;
end;


{ MCU encoding for DC successive approximation refinement scan.
  Note: we assume such scans can be multi-component, although the spec
  is not very clear on the point. }

{METHODDEF}
function encode_mcu_DC_refine (cinfo : j_compress_ptr;
                              const MCU_data: array of JBLOCKROW) : boolean;
var
  entropy : phuff_entropy_ptr;
  {register} temp : int;
  blkn : int;
  Al : int;
  block : JBLOCK_PTR;
begin
  entropy := phuff_entropy_ptr (cinfo^.entropy);
  Al := cinfo^.Al;

  entropy^.next_output_byte := cinfo^.dest^.next_output_byte;
  entropy^.free_in_buffer := cinfo^.dest^.free_in_buffer;

  { Emit restart marker if needed }
  if (cinfo^.restart_interval <> 0) then
    if (entropy^.restarts_to_go = 0) then
      emit_restart(entropy, entropy^.next_restart_num);

  { Encode the MCU data blocks }
  for blkn := 0 to pred(cinfo^.blocks_in_MCU) do
  begin
    block := JBLOCK_PTR(MCU_data[blkn]);

    { We simply emit the Al'th bit of the DC coefficient value. }
    temp := block^[0];
    emit_bits(entropy, uInt(temp shr Al), 1);
  end;

  cinfo^.dest^.next_output_byte := entropy^.next_output_byte;
  cinfo^.dest^.free_in_buffer := entropy^.free_in_buffer;

  { Update restart-interval state too }
  if (cinfo^.restart_interval <> 0) then
  begin
    if (entropy^.restarts_to_go = 0) then
    begin
      entropy^.restarts_to_go := cinfo^.restart_interval;
      Inc(entropy^.next_restart_num);
      with entropy^ do
        next_restart_num := next_restart_num and 7;
    end;
    Dec(entropy^.restarts_to_go);
  end;

  encode_mcu_DC_refine := TRUE;
end;


{ MCU encoding for AC successive approximation refinement scan. }

{METHODDEF}
function encode_mcu_AC_refine (cinfo : j_compress_ptr;
                               const MCU_data: array of JBLOCKROW) : boolean;

var
  entropy : phuff_entropy_ptr;
  {register} temp : int;
  {register} r, k : int;
  EOB : int;
  BR_buffer : JBytePtr;
  BR : uInt;
  Se : int;
  Al : int;
  block : JBLOCK_PTR;
  absvalues : array[0..DCTSIZE2-1] of int;
begin
  entropy := phuff_entropy_ptr(cinfo^.entropy);
  Se := cinfo^.Se;
  Al := cinfo^.Al;

  entropy^.next_output_byte := cinfo^.dest^.next_output_byte;
  entropy^.free_in_buffer := cinfo^.dest^.free_in_buffer;

  { Emit restart marker if needed }
  if (cinfo^.restart_interval <> 0) then
    if (entropy^.restarts_to_go = 0) then
      emit_restart(entropy, entropy^.next_restart_num);

  { Encode the MCU data block }
  block := JBLOCK_PTR(MCU_data[0]);

  { It is convenient to make a pre-pass to determine the transformed
    coefficients' absolute values and the EOB position. }

  EOB := 0;
  for k := cinfo^.Ss to Se do
  begin
    temp := block^[jpeg_natural_order[k]];
    { We must apply the point transform by Al.  For AC coefficients this
      is an integer division with rounding towards 0.  To do this portably
      in C, we shift after obtaining the absolute value. }

    if (temp < 0) then
      temp := -temp;		{ temp is abs value of input }
    temp := temp shr Al;		{ apply the point transform }
    absvalues[k] := temp;	{ save abs value for main pass }
    if (temp = 1) then
      EOB := k;			{ EOB := index of last newly-nonzero coef }
  end;

  { Encode the AC coefficients per section G.1.2.3, fig. G.7 }

  r := 0;			{ r := run length of zeros }
  BR := 0;			{ BR := count of buffered bits added now }
  BR_buffer := JBytePtr(@(entropy^.bit_buffer^[entropy^.BE]));
                                { Append bits to buffer }

  for k := cinfo^.Ss to Se do
  begin
    temp := absvalues[k];
    if (temp = 0) then
    begin
      Inc(r);
      continue;
    end;

    { Emit any required ZRLs, but not if they can be folded into EOB }
    while (r > 15) and (k <= EOB) do
    begin
      { emit any pending EOBRUN and the BE correction bits }
      emit_eobrun(entropy);
      { Emit ZRL }
      emit_symbol(entropy, entropy^.ac_tbl_no, $F0);
      Dec(r, 16);
      { Emit buffered correction bits that must be associated with ZRL }
      emit_buffered_bits(entropy, BR_buffer, BR);
      BR_buffer := entropy^.bit_buffer; { BE bits are gone now }
      BR := 0;
    end;

    { If the coef was previously nonzero, it only needs a correction bit.
      NOTE: a straight translation of the spec's figure G.7 would suggest
      that we also need to test r > 15.  But if r > 15, we can only get here
      if k > EOB, which implies that this coefficient is not 1. }
    if (temp > 1) then
    begin
      { The correction bit is the next bit of the absolute value. }
      BR_buffer^[BR] := byte (temp and 1);
      Inc(BR);
      continue;
    end;

    { Emit any pending EOBRUN and the BE correction bits }
    emit_eobrun(entropy);

    { Count/emit Huffman symbol for run length / number of bits }
    emit_symbol(entropy, entropy^.ac_tbl_no, (r shl 4) + 1);

    { Emit output bit for newly-nonzero coef }
    if (block^[jpeg_natural_order[k]] < 0) then
      temp := 0
    else
      temp := 1;
    emit_bits(entropy, uInt(temp), 1);

    { Emit buffered correction bits that must be associated with this code }
    emit_buffered_bits(entropy, BR_buffer, BR);
    BR_buffer := entropy^.bit_buffer; { BE bits are gone now }
    BR := 0;
    r := 0;			{ reset zero run length }
  end;

  if (r > 0) or (BR > 0) then
  begin	                        { If there are trailing zeroes, }
    Inc(entropy^.EOBRUN);       { count an EOB }
    Inc(entropy^.BE, BR);          { concat my correction bits to older ones }
    { We force out the EOB if we risk either:
      1. overflow of the EOB counter;
      2. overflow of the correction bit buffer during the next MCU. }

    if (entropy^.EOBRUN = $7FFF) or
       (entropy^.BE > (MAX_CORR_BITS-DCTSIZE2+1)) then
      emit_eobrun(entropy);
  end;

  cinfo^.dest^.next_output_byte := entropy^.next_output_byte;
  cinfo^.dest^.free_in_buffer := entropy^.free_in_buffer;

  { Update restart-interval state too }
  if (cinfo^.restart_interval <> 0) then
  begin
    if (entropy^.restarts_to_go = 0) then
    begin
      entropy^.restarts_to_go := cinfo^.restart_interval;
      Inc(entropy^.next_restart_num);
      with entropy^ do
        next_restart_num := next_restart_num and 7;
    end;
    Dec(entropy^.restarts_to_go);
  end;

  encode_mcu_AC_refine := TRUE;
end;


{ Finish up at the end of a Huffman-compressed progressive scan. }

{METHODDEF}
procedure finish_pass_phuff (cinfo : j_compress_ptr);
var
  entropy : phuff_entropy_ptr;
begin
  entropy := phuff_entropy_ptr (cinfo^.entropy);

  entropy^.next_output_byte := cinfo^.dest^.next_output_byte;
  entropy^.free_in_buffer := cinfo^.dest^.free_in_buffer;

  { Flush out any buffered data }
  emit_eobrun(entropy);
  flush_bits(entropy);

  cinfo^.dest^.next_output_byte := entropy^.next_output_byte;
  cinfo^.dest^.free_in_buffer := entropy^.free_in_buffer;
end;


{ Finish up a statistics-gathering pass and create the new Huffman tables. }

{METHODDEF}
procedure finish_pass_gather_phuff (cinfo : j_compress_ptr);
var
  entropy : phuff_entropy_ptr;
  is_DC_band : boolean;
  ci, tbl : int;
  compptr : jpeg_component_info_ptr;
  htblptr : ^JHUFF_TBL_PTR;
  did : array[0..NUM_HUFF_TBLS-1] of boolean;
begin
  tbl := 0;
  entropy := phuff_entropy_ptr (cinfo^.entropy);

  { Flush out buffered data (all we care about is counting the EOB symbol) }
  emit_eobrun(entropy);

  is_DC_band := (cinfo^.Ss = 0);

  { It's important not to apply jpeg_gen_optimal_table more than once
    per table, because it clobbers the input frequency counts! }

  MEMZERO(@did, SIZEOF(did));

  for ci := 0 to pred(cinfo^.comps_in_scan) do
  begin
    compptr := cinfo^.cur_comp_info[ci];
    if (is_DC_band) then
    begin
      if (cinfo^.Ah <> 0) then     { DC refinement needs no table }
	continue;
      tbl := compptr^.dc_tbl_no;
    end
    else
    begin
      tbl := compptr^.ac_tbl_no;
    end;
    if (not did[tbl]) then
    begin
      if (is_DC_band) then
        htblptr := @(cinfo^.dc_huff_tbl_ptrs[tbl])
      else
        htblptr := @(cinfo^.ac_huff_tbl_ptrs[tbl]);
      if (htblptr^ = NIL) then
        htblptr^ := jpeg_alloc_huff_table(j_common_ptr(cinfo));
      jpeg_gen_optimal_table(cinfo, htblptr^, entropy^.count_ptrs[tbl]^);
      did[tbl] := TRUE;
    end;
  end;
end;


{ Module initialization routine for progressive Huffman entropy encoding. }

{GLOBAL}
procedure jinit_phuff_encoder (cinfo : j_compress_ptr);
var
  entropy : phuff_entropy_ptr;
  i : int;
begin
  entropy := phuff_entropy_ptr(
    cinfo^.mem^.alloc_small (j_common_ptr(cinfo), JPOOL_IMAGE,
				SIZEOF(phuff_entropy_encoder)) );
  cinfo^.entropy := jpeg_entropy_encoder_ptr(entropy);
  entropy^.pub.start_pass := start_pass_phuff;

  { Mark tables unallocated }
  for i := 0 to pred(NUM_HUFF_TBLS) do
  begin
    entropy^.derived_tbls[i] := NIL;
    entropy^.count_ptrs[i] := NIL;
  end;
  entropy^.bit_buffer := NIL;	{ needed only in AC refinement scan }
end;

end.