1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204 |
- Unit JdHuff;
- { This file contains declarations for Huffman entropy decoding routines
- that are shared between the sequential decoder (jdhuff.c) and the
- progressive decoder (jdphuff.c). No other modules need to see these. }
- { This file contains Huffman entropy decoding routines.
- Much of the complexity here has to do with supporting input suspension.
- If the data source module demands suspension, we want to be able to back
- up to the start of the current MCU. To do this, we copy state variables
- into local working storage, and update them back to the permanent
- storage only upon successful completion of an MCU. }
- { Original: jdhuff.h+jdhuff.c; Copyright (C) 1991-1997, Thomas G. Lane. }
- interface
- {$I jconfig.inc}
- uses
- jmorecfg,
- jinclude,
- jdeferr,
- jerror,
- jutils,
- jpeglib;
- { Declarations shared with jdphuff.c }
- { Derived data constructed for each Huffman table }
- const
- HUFF_LOOKAHEAD = 8; { # of bits of lookahead }
- type
- d_derived_tbl_ptr = ^d_derived_tbl;
- d_derived_tbl = record
- { Basic tables: (element [0] of each array is unused) }
- maxcode : array[0..18-1] of INT32; { largest code of length k (-1 if none) }
- { (maxcode[17] is a sentinel to ensure jpeg_huff_decode terminates) }
- valoffset : array[0..17-1] of INT32; { huffval[] offset for codes of length k }
- { valoffset[k] = huffval[] index of 1st symbol of code length k, less
- the smallest code of length k; so given a code of length k, the
- corresponding symbol is huffval[code + valoffset[k]] }
- { Link to public Huffman table (needed only in jpeg_huff_decode) }
- pub : JHUFF_TBL_PTR;
- { Lookahead tables: indexed by the next HUFF_LOOKAHEAD bits of
- the input data stream. If the next Huffman code is no more
- than HUFF_LOOKAHEAD bits long, we can obtain its length and
- the corresponding symbol directly from these tables. }
- look_nbits : array[0..(1 shl HUFF_LOOKAHEAD)-1] of int;
- { # bits, or 0 if too long }
- look_sym : array[0..(1 shl HUFF_LOOKAHEAD)-1] of UINT8;
- { symbol, or unused }
- end;
- { Fetching the next N bits from the input stream is a time-critical operation
- for the Huffman decoders. We implement it with a combination of inline
- macros and out-of-line subroutines. Note that N (the number of bits
- demanded at one time) never exceeds 15 for JPEG use.
- We read source bytes into get_buffer and dole out bits as needed.
- If get_buffer already contains enough bits, they are fetched in-line
- by the macros CHECK_BIT_BUFFER and GET_BITS. When there aren't enough
- bits, jpeg_fill_bit_buffer is called; it will attempt to fill get_buffer
- as full as possible (not just to the number of bits needed; this
- prefetching reduces the overhead cost of calling jpeg_fill_bit_buffer).
- Note that jpeg_fill_bit_buffer may return FALSE to indicate suspension.
- On TRUE return, jpeg_fill_bit_buffer guarantees that get_buffer contains
- at least the requested number of bits --- dummy zeroes are inserted if
- necessary. }
- type
- bit_buf_type = INT32 ; { type of bit-extraction buffer }
- const
- BIT_BUF_SIZE = 32; { size of buffer in bits }
- { If long is > 32 bits on your machine, and shifting/masking longs is
- reasonably fast, making bit_buf_type be long and setting BIT_BUF_SIZE
- appropriately should be a win. Unfortunately we can't define the size
- with something like #define BIT_BUF_SIZE (sizeof(bit_buf_type)*8)
- because not all machines measure sizeof in 8-bit bytes. }
- type
- bitread_perm_state = record { Bitreading state saved across MCUs }
- get_buffer : bit_buf_type; { current bit-extraction buffer }
- bits_left : int; { # of unused bits in it }
- end;
- type
- bitread_working_state = record
- { Bitreading working state within an MCU }
- { current data source location }
- { We need a copy, rather than munging the original, in case of suspension }
- next_input_byte : JOCTETptr; { => next byte to read from source }
- bytes_in_buffer : size_t; { # of bytes remaining in source buffer }
- { Bit input buffer --- note these values are kept in register variables,
- not in this struct, inside the inner loops. }
- get_buffer : bit_buf_type; { current bit-extraction buffer }
- bits_left : int; { # of unused bits in it }
- { Pointer needed by jpeg_fill_bit_buffer }
- cinfo : j_decompress_ptr; { back link to decompress master record }
- end;
- { Module initialization routine for Huffman entropy decoding. }
- {GLOBAL}
- procedure jinit_huff_decoder (cinfo : j_decompress_ptr);
- {GLOBAL}
- function jpeg_huff_decode(var state : bitread_working_state;
- get_buffer : bit_buf_type; {register}
- bits_left : int; {register}
- htbl : d_derived_tbl_ptr;
- min_bits : int) : int;
- { Compute the derived values for a Huffman table.
- Note this is also used by jdphuff.c. }
- {GLOBAL}
- procedure jpeg_make_d_derived_tbl (cinfo : j_decompress_ptr;
- isDC : boolean;
- tblno : int;
- var pdtbl : d_derived_tbl_ptr);
- { Load up the bit buffer to a depth of at least nbits }
- function jpeg_fill_bit_buffer (var state : bitread_working_state;
- get_buffer : bit_buf_type; {register}
- bits_left : int; {register}
- nbits : int) : boolean;
- implementation
- {$IFDEF MACRO}
- { Macros to declare and load/save bitread local variables. }
- {$define BITREAD_STATE_VARS}
- get_buffer : bit_buf_type ; {register}
- bits_left : int; {register}
- br_state : bitread_working_state;
- {$define BITREAD_LOAD_STATE(cinfop,permstate)}
- br_state.cinfo := cinfop;
- br_state.next_input_byte := cinfop^.src^.next_input_byte;
- br_state.bytes_in_buffer := cinfop^.src^.bytes_in_buffer;
- get_buffer := permstate.get_buffer;
- bits_left := permstate.bits_left;
- {$define BITREAD_SAVE_STATE(cinfop,permstate) }
- cinfop^.src^.next_input_byte := br_state.next_input_byte;
- cinfop^.src^.bytes_in_buffer := br_state.bytes_in_buffer;
- permstate.get_buffer := get_buffer;
- permstate.bits_left := bits_left;
- { These macros provide the in-line portion of bit fetching.
- Use CHECK_BIT_BUFFER to ensure there are N bits in get_buffer
- before using GET_BITS, PEEK_BITS, or DROP_BITS.
- The variables get_buffer and bits_left are assumed to be locals,
- but the state struct might not be (jpeg_huff_decode needs this).
- CHECK_BIT_BUFFER(state,n,action);
- Ensure there are N bits in get_buffer; if suspend, take action.
- val = GET_BITS(n);
- Fetch next N bits.
- val = PEEK_BITS(n);
- Fetch next N bits without removing them from the buffer.
- DROP_BITS(n);
- Discard next N bits.
- The value N should be a simple variable, not an expression, because it
- is evaluated multiple times. }
- {$define CHECK_BIT_BUFFER(state,nbits,action)}
- if (bits_left < (nbits)) then
- begin
- if (not jpeg_fill_bit_buffer(&(state),get_buffer,bits_left,nbits)) then
- begin
- action;
- exit;
- end;
- get_buffer := state.get_buffer;
- bits_left := state.bits_left;
- end;
- {$define GET_BITS(nbits)}
- Dec(bits_left, (nbits));
- ( (int(get_buffer shr bits_left)) and ( pred(1 shl (nbits)) ) )
- {$define PEEK_BITS(nbits)}
- int(get_buffer shr (bits_left - (nbits))) and pred(1 shl (nbits))
- {$define DROP_BITS(nbits)}
- Dec(bits_left, nbits);
- { Code for extracting next Huffman-coded symbol from input bit stream.
- Again, this is time-critical and we make the main paths be macros.
- We use a lookahead table to process codes of up to HUFF_LOOKAHEAD bits
- without looping. Usually, more than 95% of the Huffman codes will be 8
- or fewer bits long. The few overlength codes are handled with a loop,
- which need not be inline code.
- Notes about the HUFF_DECODE macro:
- 1. Near the end of the data segment, we may fail to get enough bits
- for a lookahead. In that case, we do it the hard way.
- 2. If the lookahead table contains no entry, the next code must be
- more than HUFF_LOOKAHEAD bits long.
- 3. jpeg_huff_decode returns -1 if forced to suspend. }
- macro HUFF_DECODE(s,br_state,htbl,return FALSE,slowlabel);
- label showlabel;
- var
- nb, look : int; {register}
- begin
- if (bits_left < HUFF_LOOKAHEAD) then
- begin
- if (not jpeg_fill_bit_buffer(br_state,get_buffer,bits_left, 0)) then
- begin
- decode_mcu := FALSE;
- exit;
- end;
- get_buffer := br_state.get_buffer;
- bits_left := br_state.bits_left;
- if (bits_left < HUFF_LOOKAHEAD) then
- begin
- nb := 1;
- goto slowlabel;
- end;
- end;
- {look := PEEK_BITS(HUFF_LOOKAHEAD);}
- look := int(get_buffer shr (bits_left - HUFF_LOOKAHEAD)) and
- pred(1 shl HUFF_LOOKAHEAD);
- nb := htbl^.look_nbits[look];
- if (nb <> 0) then
- begin
- {DROP_BITS(nb);}
- Dec(bits_left, nb);
- s := htbl^.look_sym[look];
- end
- else
- begin
- nb := HUFF_LOOKAHEAD+1;
- slowlabel:
- s := jpeg_huff_decode(br_state,get_buffer,bits_left,htbl,nb));
- if (s < 0) then
- begin
- result := FALSE;
- exit;
- end;
- get_buffer := br_state.get_buffer;
- bits_left := br_state.bits_left;
- end;
- end;
- {$ENDIF} {MACRO}
- { Expanded entropy decoder object for Huffman decoding.
- The savable_state subrecord contains fields that change within an MCU,
- but must not be updated permanently until we complete the MCU. }
- type
- savable_state = record
- last_dc_val : array[0..MAX_COMPS_IN_SCAN-1] of int; { last DC coef for each component }
- end;
- type
- huff_entropy_ptr = ^huff_entropy_decoder;
- huff_entropy_decoder = record
- pub : jpeg_entropy_decoder; { public fields }
- { These fields are loaded into local variables at start of each MCU.
- In case of suspension, we exit WITHOUT updating them. }
- bitstate : bitread_perm_state; { Bit buffer at start of MCU }
- saved : savable_state; { Other state at start of MCU }
- { These fields are NOT loaded into local working state. }
- restarts_to_go : uInt; { MCUs left in this restart interval }
- { Pointers to derived tables (these workspaces have image lifespan) }
- dc_derived_tbls : array[0..NUM_HUFF_TBLS] of d_derived_tbl_ptr;
- ac_derived_tbls : array[0..NUM_HUFF_TBLS] of d_derived_tbl_ptr;
- { Precalculated info set up by start_pass for use in decode_mcu: }
- { Pointers to derived tables to be used for each block within an MCU }
- dc_cur_tbls : array[0..D_MAX_BLOCKS_IN_MCU-1] of d_derived_tbl_ptr;
- ac_cur_tbls : array[0..D_MAX_BLOCKS_IN_MCU-1] of d_derived_tbl_ptr;
- { Whether we care about the DC and AC coefficient values for each block }
- dc_needed : array[0..D_MAX_BLOCKS_IN_MCU-1] of boolean;
- ac_needed : array[0..D_MAX_BLOCKS_IN_MCU-1] of boolean;
- end;
- { Initialize for a Huffman-compressed scan. }
- {METHODDEF}
- procedure start_pass_huff_decoder (cinfo : j_decompress_ptr); far;
- var
- entropy : huff_entropy_ptr;
- ci, blkn, dctbl, actbl : int;
- compptr : jpeg_component_info_ptr;
- begin
- entropy := huff_entropy_ptr (cinfo^.entropy);
- { Check that the scan parameters Ss, Se, Ah/Al are OK for sequential JPEG.
- This ought to be an error condition, but we make it a warning because
- there are some baseline files out there with all zeroes in these bytes. }
- if (cinfo^.Ss <> 0) or (cinfo^.Se <> DCTSIZE2-1) or
- (cinfo^.Ah <> 0) or (cinfo^.Al <> 0) then
- WARNMS(j_common_ptr(cinfo), JWRN_NOT_SEQUENTIAL);
- for ci := 0 to pred(cinfo^.comps_in_scan) do
- begin
- compptr := cinfo^.cur_comp_info[ci];
- dctbl := compptr^.dc_tbl_no;
- actbl := compptr^.ac_tbl_no;
- { Compute derived values for Huffman tables }
- { We may do this more than once for a table, but it's not expensive }
- jpeg_make_d_derived_tbl(cinfo, TRUE, dctbl,
- entropy^.dc_derived_tbls[dctbl]);
- jpeg_make_d_derived_tbl(cinfo, FALSE, actbl,
- entropy^.ac_derived_tbls[actbl]);
- { Initialize DC predictions to 0 }
- entropy^.saved.last_dc_val[ci] := 0;
- end;
- { Precalculate decoding info for each block in an MCU of this scan }
- for blkn := 0 to pred(cinfo^.blocks_in_MCU) do
- begin
- ci := cinfo^.MCU_membership[blkn];
- compptr := cinfo^.cur_comp_info[ci];
- { Precalculate which table to use for each block }
- entropy^.dc_cur_tbls[blkn] := entropy^.dc_derived_tbls[compptr^.dc_tbl_no];
- entropy^.ac_cur_tbls[blkn] := entropy^.ac_derived_tbls[compptr^.ac_tbl_no];
- { Decide whether we really care about the coefficient values }
- if (compptr^.component_needed) then
- begin
- entropy^.dc_needed[blkn] := TRUE;
- { we don't need the ACs if producing a 1/8th-size image }
- entropy^.ac_needed[blkn] := (compptr^.DCT_scaled_size > 1);
- end
- else
- begin
- entropy^.ac_needed[blkn] := FALSE;
- entropy^.dc_needed[blkn] := FALSE;
- end;
- end;
- { Initialize bitread state variables }
- entropy^.bitstate.bits_left := 0;
- entropy^.bitstate.get_buffer := 0; { unnecessary, but keeps Purify quiet }
- entropy^.pub.insufficient_data := FALSE;
- { Initialize restart counter }
- entropy^.restarts_to_go := cinfo^.restart_interval;
- end;
- { Compute the derived values for a Huffman table.
- This routine also performs some validation checks on the table.
- Note this is also used by jdphuff.c. }
- {GLOBAL}
- procedure jpeg_make_d_derived_tbl (cinfo : j_decompress_ptr;
- isDC : boolean;
- tblno : int;
- var pdtbl : d_derived_tbl_ptr);
- var
- htbl : JHUFF_TBL_PTR;
- dtbl : d_derived_tbl_ptr;
- p, i, l, si, numsymbols : int;
- lookbits, ctr : int;
- huffsize : array[0..257-1] of byte;
- huffcode : array[0..257-1] of uInt;
- code : uInt;
- var
- sym : int;
- begin
- { Note that huffsize[] and huffcode[] are filled in code-length order,
- paralleling the order of the symbols themselves in htbl^.huffval[]. }
- { Find the input Huffman table }
- if (tblno < 0) or (tblno >= NUM_HUFF_TBLS) then
- ERREXIT1(j_common_ptr(cinfo), JERR_NO_HUFF_TABLE, tblno);
- if isDC then
- htbl := cinfo^.dc_huff_tbl_ptrs[tblno]
- else
- htbl := cinfo^.ac_huff_tbl_ptrs[tblno];
- if (htbl = NIL) then
- ERREXIT1(j_common_ptr(cinfo), JERR_NO_HUFF_TABLE, tblno);
- { Allocate a workspace if we haven't already done so. }
- if (pdtbl = NIL) then
- pdtbl := d_derived_tbl_ptr(
- cinfo^.mem^.alloc_small (j_common_ptr(cinfo), JPOOL_IMAGE,
- SIZEOF(d_derived_tbl)) );
- dtbl := pdtbl;
- dtbl^.pub := htbl; { fill in back link }
- { Figure C.1: make table of Huffman code length for each symbol }
- p := 0;
- for l := 1 to 16 do
- begin
- i := int(htbl^.bits[l]);
- if (i < 0) or (p + i > 256) then { protect against table overrun }
- ERREXIT(j_common_ptr(cinfo), JERR_BAD_HUFF_TABLE);
- while (i > 0) do
- begin
- huffsize[p] := byte(l);
- Inc(p);
- Dec(i);
- end;
- end;
- huffsize[p] := 0;
- numsymbols := p;
- { Figure C.2: generate the codes themselves }
- { We also validate that the counts represent a legal Huffman code tree. }
- code := 0;
- si := huffsize[0];
- p := 0;
- while (huffsize[p] <> 0) do
- begin
- while (( int (huffsize[p]) ) = si) do
- begin
- huffcode[p] := code;
- Inc(p);
- Inc(code);
- end;
- { code is now 1 more than the last code used for codelength si; but
- it must still fit in si bits, since no code is allowed to be all ones. }
- if (INT32(code) >= (INT32(1) shl si)) then
- ERREXIT(j_common_ptr(cinfo), JERR_BAD_HUFF_TABLE);
- code := code shl 1;
- Inc(si);
- end;
- { Figure F.15: generate decoding tables for bit-sequential decoding }
- p := 0;
- for l := 1 to 16 do
- begin
- if (htbl^.bits[l] <> 0) then
- begin
- { valoffset[l] = huffval[] index of 1st symbol of code length l,
- minus the minimum code of length l }
- dtbl^.valoffset[l] := INT32(p) - INT32(huffcode[p]);
- Inc(p, htbl^.bits[l]);
- dtbl^.maxcode[l] := huffcode[p-1]; { maximum code of length l }
- end
- else
- begin
- dtbl^.maxcode[l] := -1; { -1 if no codes of this length }
- end;
- end;
- dtbl^.maxcode[17] := long($FFFFF); { ensures jpeg_huff_decode terminates }
- { Compute lookahead tables to speed up decoding.
- First we set all the table entries to 0, indicating "too long";
- then we iterate through the Huffman codes that are short enough and
- fill in all the entries that correspond to bit sequences starting
- with that code. }
- MEMZERO(@dtbl^.look_nbits, SIZEOF(dtbl^.look_nbits));
- p := 0;
- for l := 1 to HUFF_LOOKAHEAD do
- begin
- for i := 1 to int (htbl^.bits[l]) do
- begin
- { l := current code's length, p := its index in huffcode[] & huffval[]. }
- { Generate left-justified code followed by all possible bit sequences }
- lookbits := huffcode[p] shl (HUFF_LOOKAHEAD-l);
- for ctr := pred(1 shl (HUFF_LOOKAHEAD-l)) downto 0 do
- begin
- dtbl^.look_nbits[lookbits] := l;
- dtbl^.look_sym[lookbits] := htbl^.huffval[p];
- Inc(lookbits);
- end;
- Inc(p);
- end;
- end;
- { Validate symbols as being reasonable.
- For AC tables, we make no check, but accept all byte values 0..255.
- For DC tables, we require the symbols to be in range 0..15.
- (Tighter bounds could be applied depending on the data depth and mode,
- but this is sufficient to ensure safe decoding.) }
- if (isDC) then
- begin
- for i := 0 to pred(numsymbols) do
- begin
- sym := htbl^.huffval[i];
- if (sym < 0) or (sym > 15) then
- ERREXIT(j_common_ptr(cinfo), JERR_BAD_HUFF_TABLE);
- end;
- end;
- end;
- { Out-of-line code for bit fetching (shared with jdphuff.c).
- See jdhuff.h for info about usage.
- Note: current values of get_buffer and bits_left are passed as parameters,
- but are returned in the corresponding fields of the state struct.
- On most machines MIN_GET_BITS should be 25 to allow the full 32-bit width
- of get_buffer to be used. (On machines with wider words, an even larger
- buffer could be used.) However, on some machines 32-bit shifts are
- quite slow and take time proportional to the number of places shifted.
- (This is true with most PC compilers, for instance.) In this case it may
- be a win to set MIN_GET_BITS to the minimum value of 15. This reduces the
- average shift distance at the cost of more calls to jpeg_fill_bit_buffer. }
- {$ifdef SLOW_SHIFT_32}
- const
- MIN_GET_BITS = 15; { minimum allowable value }
- {$else}
- const
- MIN_GET_BITS = (BIT_BUF_SIZE-7);
- {$endif}
- {GLOBAL}
- function jpeg_fill_bit_buffer (var state : bitread_working_state;
- {register} get_buffer : bit_buf_type;
- {register} bits_left : int;
- nbits : int) : boolean;
- label
- no_more_bytes;
- { Load up the bit buffer to a depth of at least nbits }
- var
- { Copy heavily used state fields into locals (hopefully registers) }
- {register} next_input_byte : {const} JOCTETptr;
- {register} bytes_in_buffer : size_t;
- var
- {register} c : int;
- var
- cinfo : j_decompress_ptr;
- begin
- next_input_byte := state.next_input_byte;
- bytes_in_buffer := state.bytes_in_buffer;
- cinfo := state.cinfo;
- { Attempt to load at least MIN_GET_BITS bits into get_buffer. }
- { (It is assumed that no request will be for more than that many bits.) }
- { We fail to do so only if we hit a marker or are forced to suspend. }
- if (cinfo^.unread_marker = 0) then { cannot advance past a marker }
- begin
- while (bits_left < MIN_GET_BITS) do
- begin
- { Attempt to read a byte }
- if (bytes_in_buffer = 0) then
- begin
- if not cinfo^.src^.fill_input_buffer(cinfo) then
- begin
- jpeg_fill_bit_buffer := FALSE;
- exit;
- end;
- next_input_byte := cinfo^.src^.next_input_byte;
- bytes_in_buffer := cinfo^.src^.bytes_in_buffer;
- end;
- Dec(bytes_in_buffer);
- c := GETJOCTET(next_input_byte^);
- Inc(next_input_byte);
- { If it's $FF, check and discard stuffed zero byte }
- if (c = $FF) then
- begin
- { Loop here to discard any padding FF's on terminating marker,
- so that we can save a valid unread_marker value. NOTE: we will
- accept multiple FF's followed by a 0 as meaning a single FF data
- byte. This data pattern is not valid according to the standard. }
- repeat
- if (bytes_in_buffer = 0) then
- begin
- if (not state.cinfo^.src^.fill_input_buffer (state.cinfo)) then
- begin
- jpeg_fill_bit_buffer := FALSE;
- exit;
- end;
- next_input_byte := state.cinfo^.src^.next_input_byte;
- bytes_in_buffer := state.cinfo^.src^.bytes_in_buffer;
- end;
- Dec(bytes_in_buffer);
- c := GETJOCTET(next_input_byte^);
- Inc(next_input_byte);
- Until (c <> $FF);
- if (c = 0) then
- begin
- { Found FF/00, which represents an FF data byte }
- c := $FF;
- end
- else
- begin
- { Oops, it's actually a marker indicating end of compressed data.
- Save the marker code for later use.
- Fine point: it might appear that we should save the marker into
- bitread working state, not straight into permanent state. But
- once we have hit a marker, we cannot need to suspend within the
- current MCU, because we will read no more bytes from the data
- source. So it is OK to update permanent state right away. }
- cinfo^.unread_marker := c;
- { See if we need to insert some fake zero bits. }
- goto no_more_bytes;
- end;
- end;
- { OK, load c into get_buffer }
- get_buffer := (get_buffer shl 8) or c;
- Inc(bits_left, 8);
- end { end while }
- end
- else
- begin
- no_more_bytes:
- { We get here if we've read the marker that terminates the compressed
- data segment. There should be enough bits in the buffer register
- to satisfy the request; if so, no problem. }
- if (nbits > bits_left) then
- begin
- { Uh-oh. Report corrupted data to user and stuff zeroes into
- the data stream, so that we can produce some kind of image.
- We use a nonvolatile flag to ensure that only one warning message
- appears per data segment. }
- if not cinfo^.entropy^.insufficient_data then
- begin
- WARNMS(j_common_ptr(cinfo), JWRN_HIT_MARKER);
- cinfo^.entropy^.insufficient_data := TRUE;
- end;
- { Fill the buffer with zero bits }
- get_buffer := get_buffer shl (MIN_GET_BITS - bits_left);
- bits_left := MIN_GET_BITS;
- end;
- end;
- { Unload the local registers }
- state.next_input_byte := next_input_byte;
- state.bytes_in_buffer := bytes_in_buffer;
- state.get_buffer := get_buffer;
- state.bits_left := bits_left;
- jpeg_fill_bit_buffer := TRUE;
- end;
- { Out-of-line code for Huffman code decoding.
- See jdhuff.h for info about usage. }
- {GLOBAL}
- function jpeg_huff_decode (var state : bitread_working_state;
- {register} get_buffer : bit_buf_type;
- {register} bits_left : int;
- htbl : d_derived_tbl_ptr;
- min_bits : int) : int;
- var
- {register} l : int;
- {register} code : INT32;
- begin
- l := min_bits;
- { HUFF_DECODE has determined that the code is at least min_bits }
- { bits long, so fetch that many bits in one swoop. }
- {CHECK_BIT_BUFFER(state, l, return -1);}
- if (bits_left < l) then
- begin
- if (not jpeg_fill_bit_buffer(state, get_buffer, bits_left, l)) then
- begin
- jpeg_huff_decode := -1;
- exit;
- end;
- get_buffer := state.get_buffer;
- bits_left := state.bits_left;
- end;
- {code := GET_BITS(l);}
- Dec(bits_left, l);
- code := (int(get_buffer shr bits_left)) and ( pred(1 shl l) );
- { Collect the rest of the Huffman code one bit at a time. }
- { This is per Figure F.16 in the JPEG spec. }
- while (code > htbl^.maxcode[l]) do
- begin
- code := code shl 1;
- {CHECK_BIT_BUFFER(state, 1, return -1);}
- if (bits_left < 1) then
- begin
- if (not jpeg_fill_bit_buffer(state, get_buffer, bits_left, 1)) then
- begin
- jpeg_huff_decode := -1;
- exit;
- end;
- get_buffer := state.get_buffer;
- bits_left := state.bits_left;
- end;
- {code := code or GET_BITS(1);}
- Dec(bits_left);
- code := code or ( (int(get_buffer shr bits_left)) and pred(1 shl 1) );
- Inc(l);
- end;
- { Unload the local registers }
- state.get_buffer := get_buffer;
- state.bits_left := bits_left;
- { With garbage input we may reach the sentinel value l := 17. }
- if (l > 16) then
- begin
- WARNMS(j_common_ptr(state.cinfo), JWRN_HUFF_BAD_CODE);
- jpeg_huff_decode := 0; { fake a zero as the safest result }
- exit;
- end;
- jpeg_huff_decode := htbl^.pub^.huffval[ int (code + htbl^.valoffset[l]) ];
- end;
- { Figure F.12: extend sign bit.
- On some machines, a shift and add will be faster than a table lookup. }
- {$ifdef AVOID_TABLES}
- #define HUFF_EXTEND(x,s) ((x) < (1<<((s)-1)) ? (x) + (((-1)<<(s)) + 1) : (x))
- {$else}
- {$define HUFF_EXTEND(x,s)
- if (x < extend_test[s]) then
- := x + extend_offset[s]
- else
- x;}
- const
- extend_test : array[0..16-1] of int = { entry n is 2**(n-1) }
- ($0000, $0001, $0002, $0004, $0008, $0010, $0020, $0040,
- $0080, $0100, $0200, $0400, $0800, $1000, $2000, $4000);
- const
- extend_offset : array[0..16-1] of int = { entry n is (-1 << n) + 1 }
- (0, ((-1) shl 1) + 1, ((-1) shl 2) + 1, ((-1) shl 3) + 1, ((-1) shl 4) + 1,
- ((-1) shl 5) + 1, ((-1) shl 6) + 1, ((-1) shl 7) + 1, ((-1) shl 8) + 1,
- ((-1) shl 9) + 1, ((-1) shl 10) + 1, ((-1) shl 11) + 1,((-1) shl 12) + 1,
- ((-1) shl 13) + 1, ((-1) shl 14) + 1, ((-1) shl 15) + 1);
- {$endif} { AVOID_TABLES }
- { Check for a restart marker & resynchronize decoder.
- Returns FALSE if must suspend. }
- {LOCAL}
- function process_restart (cinfo : j_decompress_ptr) : boolean;
- var
- entropy : huff_entropy_ptr;
- ci : int;
- begin
- entropy := huff_entropy_ptr (cinfo^.entropy);
- { Throw away any unused bits remaining in bit buffer; }
- { include any full bytes in next_marker's count of discarded bytes }
- Inc(cinfo^.marker^.discarded_bytes, entropy^.bitstate.bits_left div 8);
- entropy^.bitstate.bits_left := 0;
- { Advance past the RSTn marker }
- if (not cinfo^.marker^.read_restart_marker (cinfo)) then
- begin
- process_restart := FALSE;
- exit;
- end;
- { Re-initialize DC predictions to 0 }
- for ci := 0 to pred(cinfo^.comps_in_scan) do
- entropy^.saved.last_dc_val[ci] := 0;
- { Reset restart counter }
- entropy^.restarts_to_go := cinfo^.restart_interval;
- { Reset out-of-data flag, unless read_restart_marker left us smack up
- against a marker. In that case we will end up treating the next data
- segment as empty, and we can avoid producing bogus output pixels by
- leaving the flag set. }
- if (cinfo^.unread_marker = 0) then
- entropy^.pub.insufficient_data := FALSE;
- process_restart := TRUE;
- end;
- { Decode and return one MCU's worth of Huffman-compressed coefficients.
- The coefficients are reordered from zigzag order into natural array order,
- but are not dequantized.
- The i'th block of the MCU is stored into the block pointed to by
- MCU_data[i]. WE ASSUME THIS AREA HAS BEEN ZEROED BY THE CALLER.
- (Wholesale zeroing is usually a little faster than retail...)
- Returns FALSE if data source requested suspension. In that case no
- changes have been made to permanent state. (Exception: some output
- coefficients may already have been assigned. This is harmless for
- this module, since we'll just re-assign them on the next call.) }
- {METHODDEF}
- function decode_mcu (cinfo : j_decompress_ptr;
- var MCU_data : array of JBLOCKROW) : boolean; far;
- label
- label1, label2, label3;
- var
- entropy : huff_entropy_ptr;
- {register} s, k, r : int;
- blkn, ci : int;
- block : JBLOCK_PTR;
- {BITREAD_STATE_VARS}
- get_buffer : bit_buf_type ; {register}
- bits_left : int; {register}
- br_state : bitread_working_state;
- state : savable_state;
- dctbl : d_derived_tbl_ptr;
- actbl : d_derived_tbl_ptr;
- var
- nb, look : int; {register}
- begin
- entropy := huff_entropy_ptr (cinfo^.entropy);
- { Process restart marker if needed; may have to suspend }
- if (cinfo^.restart_interval <> 0) then
- begin
- if (entropy^.restarts_to_go = 0) then
- if (not process_restart(cinfo)) then
- begin
- decode_mcu := FALSE;
- exit;
- end;
- end;
- { If we've run out of data, just leave the MCU set to zeroes.
- This way, we return uniform gray for the remainder of the segment. }
- if not entropy^.pub.insufficient_data then
- begin
- { Load up working state }
- {BITREAD_LOAD_STATE(cinfo,entropy^.bitstate);}
- br_state.cinfo := cinfo;
- br_state.next_input_byte := cinfo^.src^.next_input_byte;
- br_state.bytes_in_buffer := cinfo^.src^.bytes_in_buffer;
- get_buffer := entropy^.bitstate.get_buffer;
- bits_left := entropy^.bitstate.bits_left;
- {ASSIGN_STATE(state, entropy^.saved);}
- state := entropy^.saved;
- { Outer loop handles each block in the MCU }
- for blkn := 0 to pred(cinfo^.blocks_in_MCU) do
- begin
- block := JBLOCK_PTR(MCU_data[blkn]);
- dctbl := entropy^.dc_cur_tbls[blkn];
- actbl := entropy^.ac_cur_tbls[blkn];
- { Decode a single block's worth of coefficients }
- { Section F.2.2.1: decode the DC coefficient difference }
- {HUFF_DECODE(s, br_state, dctbl, return FALSE, label1);}
- if (bits_left < HUFF_LOOKAHEAD) then
- begin
- if (not jpeg_fill_bit_buffer(br_state,get_buffer,bits_left, 0)) then
- begin
- decode_mcu := False;
- exit;
- end;
- get_buffer := br_state.get_buffer;
- bits_left := br_state.bits_left;
- if (bits_left < HUFF_LOOKAHEAD) then
- begin
- nb := 1;
- goto label1;
- end;
- end;
- {look := PEEK_BITS(HUFF_LOOKAHEAD);}
- look := int(get_buffer shr (bits_left - HUFF_LOOKAHEAD)) and
- pred(1 shl HUFF_LOOKAHEAD);
- nb := dctbl^.look_nbits[look];
- if (nb <> 0) then
- begin
- {DROP_BITS(nb);}
- Dec(bits_left, nb);
- s := dctbl^.look_sym[look];
- end
- else
- begin
- nb := HUFF_LOOKAHEAD+1;
- label1:
- s := jpeg_huff_decode(br_state,get_buffer,bits_left,dctbl,nb);
- if (s < 0) then
- begin
- decode_mcu := FALSE;
- exit;
- end;
- get_buffer := br_state.get_buffer;
- bits_left := br_state.bits_left;
- end;
- if (s <> 0) then
- begin
- {CHECK_BIT_BUFFER(br_state, s, return FALSE);}
- if (bits_left < s) then
- begin
- if (not jpeg_fill_bit_buffer(br_state,get_buffer,bits_left,s)) then
- begin
- decode_mcu := FALSE;
- exit;
- end;
- get_buffer := br_state.get_buffer;
- bits_left := br_state.bits_left;
- end;
- {r := GET_BITS(s);}
- Dec(bits_left, s);
- r := ( int(get_buffer shr bits_left)) and ( pred(1 shl s) );
- {s := HUFF_EXTEND(r, s);}
- if (r < extend_test[s]) then
- s := r + extend_offset[s]
- else
- s := r;
- end;
- if (entropy^.dc_needed[blkn]) then
- begin
- { Convert DC difference to actual value, update last_dc_val }
- ci := cinfo^.MCU_membership[blkn];
- Inc(s, state.last_dc_val[ci]);
- state.last_dc_val[ci] := s;
- { Output the DC coefficient (assumes jpeg_natural_order[0] := 0) }
- block^[0] := JCOEF (s);
- end;
- if (entropy^.ac_needed[blkn]) then
- begin
- { Section F.2.2.2: decode the AC coefficients }
- { Since zeroes are skipped, output area must be cleared beforehand }
- k := 1;
- while (k < DCTSIZE2) do { Nomssi: k is incr. in the loop }
- begin
- {HUFF_DECODE(s, br_state, actbl, return FALSE, label2);}
- if (bits_left < HUFF_LOOKAHEAD) then
- begin
- if (not jpeg_fill_bit_buffer(br_state,get_buffer,bits_left, 0)) then
- begin
- decode_mcu := False;
- exit;
- end;
- get_buffer := br_state.get_buffer;
- bits_left := br_state.bits_left;
- if (bits_left < HUFF_LOOKAHEAD) then
- begin
- nb := 1;
- goto label2;
- end;
- end;
- {look := PEEK_BITS(HUFF_LOOKAHEAD);}
- look := int(get_buffer shr (bits_left - HUFF_LOOKAHEAD)) and
- pred(1 shl HUFF_LOOKAHEAD);
- nb := actbl^.look_nbits[look];
- if (nb <> 0) then
- begin
- {DROP_BITS(nb);}
- Dec(bits_left, nb);
- s := actbl^.look_sym[look];
- end
- else
- begin
- nb := HUFF_LOOKAHEAD+1;
- label2:
- s := jpeg_huff_decode(br_state,get_buffer,bits_left,actbl,nb);
- if (s < 0) then
- begin
- decode_mcu := FALSE;
- exit;
- end;
- get_buffer := br_state.get_buffer;
- bits_left := br_state.bits_left;
- end;
- r := s shr 4;
- s := s and 15;
- if (s <> 0) then
- begin
- Inc(k, r);
- {CHECK_BIT_BUFFER(br_state, s, return FALSE);}
- if (bits_left < s) then
- begin
- if (not jpeg_fill_bit_buffer(br_state,get_buffer,bits_left,s)) then
- begin
- decode_mcu := FALSE;
- exit;
- end;
- get_buffer := br_state.get_buffer;
- bits_left := br_state.bits_left;
- end;
- {r := GET_BITS(s);}
- Dec(bits_left, s);
- r := (int(get_buffer shr bits_left)) and ( pred(1 shl s) );
- {s := HUFF_EXTEND(r, s);}
- if (r < extend_test[s]) then
- s := r + extend_offset[s]
- else
- s := r;
- { Output coefficient in natural (dezigzagged) order.
- Note: the extra entries in jpeg_natural_order[] will save us
- if k >= DCTSIZE2, which could happen if the data is corrupted. }
- block^[jpeg_natural_order[k]] := JCOEF (s);
- end
- else
- begin
- if (r <> 15) then
- break;
- Inc(k, 15);
- end;
- Inc(k);
- end;
- end
- else
- begin
- { Section F.2.2.2: decode the AC coefficients }
- { In this path we just discard the values }
- k := 1;
- while (k < DCTSIZE2) do
- begin
- {HUFF_DECODE(s, br_state, actbl, return FALSE, label3);}
- if (bits_left < HUFF_LOOKAHEAD) then
- begin
- if (not jpeg_fill_bit_buffer(br_state,get_buffer,bits_left, 0)) then
- begin
- decode_mcu := False;
- exit;
- end;
- get_buffer := br_state.get_buffer;
- bits_left := br_state.bits_left;
- if (bits_left < HUFF_LOOKAHEAD) then
- begin
- nb := 1;
- goto label3;
- end;
- end;
- {look := PEEK_BITS(HUFF_LOOKAHEAD);}
- look := int(get_buffer shr (bits_left - HUFF_LOOKAHEAD)) and
- pred(1 shl HUFF_LOOKAHEAD);
- nb := actbl^.look_nbits[look];
- if (nb <> 0) then
- begin
- {DROP_BITS(nb);}
- Dec(bits_left, nb);
- s := actbl^.look_sym[look];
- end
- else
- begin
- nb := HUFF_LOOKAHEAD+1;
- label3:
- s := jpeg_huff_decode(br_state,get_buffer,bits_left,actbl,nb);
- if (s < 0) then
- begin
- decode_mcu := FALSE;
- exit;
- end;
- get_buffer := br_state.get_buffer;
- bits_left := br_state.bits_left;
- end;
- r := s shr 4;
- s := s and 15;
- if (s <> 0) then
- begin
- Inc(k, r);
- {CHECK_BIT_BUFFER(br_state, s, return FALSE);}
- if (bits_left < s) then
- begin
- if (not jpeg_fill_bit_buffer(br_state,get_buffer,bits_left,s)) then
- begin
- decode_mcu := FALSE;
- exit;
- end;
- get_buffer := br_state.get_buffer;
- bits_left := br_state.bits_left;
- end;
- {DROP_BITS(s);}
- Dec(bits_left, s);
- end
- else
- begin
- if (r <> 15) then
- break;
- Inc(k, 15);
- end;
- Inc(k);
- end;
- end;
- end;
- { Completed MCU, so update state }
- {BITREAD_SAVE_STATE(cinfo,entropy^.bitstate);}
- cinfo^.src^.next_input_byte := br_state.next_input_byte;
- cinfo^.src^.bytes_in_buffer := br_state.bytes_in_buffer;
- entropy^.bitstate.get_buffer := get_buffer;
- entropy^.bitstate.bits_left := bits_left;
- {ASSIGN_STATE(entropy^.saved, state);}
- entropy^.saved := state;
- end;
- { Account for restart interval (no-op if not using restarts) }
- Dec(entropy^.restarts_to_go);
- decode_mcu := TRUE;
- end;
- { Module initialization routine for Huffman entropy decoding. }
- {GLOBAL}
- procedure jinit_huff_decoder (cinfo : j_decompress_ptr);
- var
- entropy : huff_entropy_ptr;
- i : int;
- begin
- entropy := huff_entropy_ptr(
- cinfo^.mem^.alloc_small (j_common_ptr(cinfo), JPOOL_IMAGE,
- SIZEOF(huff_entropy_decoder)) );
- cinfo^.entropy := jpeg_entropy_decoder_ptr (entropy);
- entropy^.pub.start_pass := start_pass_huff_decoder;
- entropy^.pub.decode_mcu := decode_mcu;
- { Mark tables unallocated }
- for i := 0 to pred(NUM_HUFF_TBLS) do
- begin
- entropy^.dc_derived_tbls[i] := NIL;
- entropy^.ac_derived_tbls[i] := NIL;
- end;
- end;
- end.
|