From a6fc7d7ec63719e4f8d58a019e33aefeaf9435b5 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 6 Nov 2015 12:25:37 +0100 Subject: Adding upstream version 1.0~rc3. Signed-off-by: Daniel Baumann --- decoder.h | 191 +++++++++++++++++++++++++++----------------------------------- 1 file changed, 84 insertions(+), 107 deletions(-) (limited to 'decoder.h') diff --git a/decoder.h b/decoder.h index 7df68b9..1bb773c 100644 --- a/decoder.h +++ b/decoder.h @@ -15,182 +15,159 @@ along with this program. If not, see . */ -enum { Ib_buffer_size = 65536 }; +enum { Rd_buffer_size = 16384 }; -struct Input_buffer +struct Range_decoder { - uint8_t * buffer; + long long partial_member_pos; + uint8_t * buffer; // input buffer int pos; int stream_pos; // when reached, a new block must be read + uint32_t code; + uint32_t range; int infd_; // input file descriptor bool at_stream_end; }; -bool Ib_read_block( struct Input_buffer * const ibuf ); +bool Rd_read_block( struct Range_decoder * const rdec ); -static inline void Ib_init( struct Input_buffer * const ibuf, const int infd ) +static inline void Rd_init( struct Range_decoder * const rdec, const int infd ) { - ibuf->buffer = (uint8_t *)malloc( Ib_buffer_size ); - if( !ibuf->buffer ) + rdec->partial_member_pos = 0; + rdec->buffer = (uint8_t *)malloc( Rd_buffer_size ); + if( !rdec->buffer ) { show_error( "not enough memory. Find a machine with more memory", 0, false ); cleanup_and_fail( 1 ); } - ibuf->pos = 0; - ibuf->stream_pos = 0; - ibuf->infd_ = infd; - ibuf->at_stream_end = false; + rdec->pos = 0; + rdec->stream_pos = 0; + rdec->code = 0; + rdec->range = 0xFFFFFFFF; + rdec->infd_ = infd; + rdec->at_stream_end = false; } -static inline void Ib_free( struct Input_buffer * const ibuf ) - { free( ibuf->buffer ); ibuf->buffer = 0; } +static inline void Rd_free( struct Range_decoder * const rdec ) + { free( rdec->buffer ); rdec->buffer = 0; } -static inline bool Ib_finished( struct Input_buffer * const ibuf ) - { return ibuf->at_stream_end && ibuf->pos >= ibuf->stream_pos; } +static inline bool Rd_code_is_zero( struct Range_decoder * const rdec ) + { return ( rdec->code == 0 ); } -static inline uint8_t Ib_get_byte( struct Input_buffer * const ibuf ) - { - if( ibuf->pos >= ibuf->stream_pos && !Ib_read_block( ibuf ) ) - return 0; - return ibuf->buffer[ibuf->pos++]; - } +static inline bool Rd_finished( struct Range_decoder * const rdec ) + { return rdec->at_stream_end && rdec->pos >= rdec->stream_pos; } +static inline long long Rd_member_position( struct Range_decoder * const rdec ) + { return rdec->partial_member_pos + rdec->pos; } -struct Range_decoder - { - long long member_pos; - uint32_t code; - uint32_t range; - struct Input_buffer * ibuf; - }; +static inline void Rd_reset_member_position( struct Range_decoder * const rdec ) + { rdec->partial_member_pos = -rdec->pos; } -static inline uint8_t Rd_get_byte( struct Range_decoder * const range_decoder ) +static inline uint8_t Rd_get_byte( struct Range_decoder * const rdec ) { - ++range_decoder->member_pos; - return Ib_get_byte( range_decoder->ibuf ); + if( rdec->pos >= rdec->stream_pos && !Rd_read_block( rdec ) ) return 0; + return rdec->buffer[rdec->pos++]; } -static inline void Rd_init( struct Range_decoder * const range_decoder, - struct Input_buffer * const buf ) +static inline void Rd_load( struct Range_decoder * const rdec ) { - range_decoder->member_pos = sizeof (File_header); - range_decoder->code = 0; - range_decoder->range = 0xFFFFFFFF; - range_decoder->ibuf = buf; + rdec->code = 0; + rdec->range = 0xFFFFFFFFU; for( int i = 0; i < 5; ++i ) - range_decoder->code = (range_decoder->code << 8) | - Rd_get_byte( range_decoder ); + rdec->code = (rdec->code << 8) | Rd_get_byte( rdec ); } -static inline bool Rd_code_is_zero( struct Range_decoder * const range_decoder ) - { return ( range_decoder->code == 0 ); } -static inline bool Rd_finished( struct Range_decoder * const range_decoder ) - { return Ib_finished( range_decoder->ibuf ); } -static inline long long Rd_member_position( struct Range_decoder * const range_decoder ) - { return range_decoder->member_pos; } - -static inline void Rd_reload( struct Range_decoder * const range_decoder ) +static inline void Rd_normalize( struct Range_decoder * const rdec ) { - range_decoder->code = 0; - range_decoder->range = 0xFFFFFFFF; - for( int i = 0; i < 5; ++i ) - range_decoder->code = (range_decoder->code << 8) | - Rd_get_byte( range_decoder ); - } - -static inline void Rd_normalize( struct Range_decoder * const range_decoder ) - { - if( range_decoder->range <= 0x00FFFFFF ) + if( rdec->range <= 0x00FFFFFFU ) { - range_decoder->range <<= 8; - range_decoder->code = (range_decoder->code << 8) | - Rd_get_byte( range_decoder ); + rdec->range <<= 8; + rdec->code = (rdec->code << 8) | Rd_get_byte( rdec ); } } -static inline int Rd_decode( struct Range_decoder * const range_decoder, +static inline int Rd_decode( struct Range_decoder * const rdec, const int num_bits ) { int symbol = 0; for( int i = num_bits; i > 0; --i ) { symbol <<= 1; - if( range_decoder->range <= 0x00FFFFFF ) + if( rdec->range <= 0x00FFFFFFU ) { - range_decoder->range <<= 7; - range_decoder->code = (range_decoder->code << 8) | - Rd_get_byte( range_decoder ); - if( range_decoder->code >= range_decoder->range ) - { range_decoder->code -= range_decoder->range; symbol |= 1; } + rdec->range <<= 7; + rdec->code = (rdec->code << 8) | Rd_get_byte( rdec ); + if( rdec->code >= rdec->range ) + { rdec->code -= rdec->range; symbol |= 1; } } else { - range_decoder->range >>= 1; - if( range_decoder->code >= range_decoder->range ) - { range_decoder->code -= range_decoder->range; symbol |= 1; } + rdec->range >>= 1; + if( rdec->code >= rdec->range ) + { rdec->code -= rdec->range; symbol |= 1; } } } return symbol; } -static inline int Rd_decode_bit( struct Range_decoder * const range_decoder, +static inline int Rd_decode_bit( struct Range_decoder * const rdec, Bit_model * const probability ) { - Rd_normalize( range_decoder ); - const uint32_t bound = ( range_decoder->range >> bit_model_total_bits ) * + Rd_normalize( rdec ); + const uint32_t bound = ( rdec->range >> bit_model_total_bits ) * *probability; - if( range_decoder->code < bound ) + if( rdec->code < bound ) { - range_decoder->range = bound; + rdec->range = bound; *probability += (bit_model_total - *probability) >> bit_model_move_bits; return 0; } else { - range_decoder->range -= bound; - range_decoder->code -= bound; + rdec->range -= bound; + rdec->code -= bound; *probability -= *probability >> bit_model_move_bits; return 1; } } -static inline int Rd_decode_tree( struct Range_decoder * const range_decoder, +static inline int Rd_decode_tree( struct Range_decoder * const rdec, Bit_model bm[], const int num_bits ) { int model = 1; for( int i = num_bits; i > 0; --i ) - model = ( model << 1 ) | Rd_decode_bit( range_decoder, &bm[model] ); + model = ( model << 1 ) | Rd_decode_bit( rdec, &bm[model] ); return model - (1 << num_bits); } -static inline int Rd_decode_tree_reversed( struct Range_decoder * const range_decoder, +static inline int Rd_decode_tree_reversed( struct Range_decoder * const rdec, Bit_model bm[], const int num_bits ) { int model = 1; int symbol = 0; for( int i = 0; i < num_bits; ++i ) { - const int bit = Rd_decode_bit( range_decoder, &bm[model] ); + const int bit = Rd_decode_bit( rdec, &bm[model] ); model <<= 1; if( bit ) { model |= 1; symbol |= (1 << i); } } return symbol; } -static inline int Rd_decode_matched( struct Range_decoder * const range_decoder, +static inline int Rd_decode_matched( struct Range_decoder * const rdec, Bit_model bm[], const int match_byte ) { - Bit_model *bm1 = bm + 0x100; + Bit_model * const bm1 = bm + 0x100; int symbol = 1; - for( int i = 1; i <= 8; ++i ) + for( int i = 7; i >= 0; --i ) { - const int match_bit = ( match_byte << i ) & 0x100; - const int bit = Rd_decode_bit( range_decoder, &bm1[match_bit+symbol] ); + const int match_bit = ( match_byte >> i ) & 1; + const int bit = Rd_decode_bit( rdec, &bm1[(match_bit<<8)+symbol] ); symbol = ( symbol << 1 ) | bit; - if( ( match_bit && !bit ) || ( !match_bit && bit ) ) + if( match_bit != bit ) { - while( ++i <= 8 ) - symbol = ( symbol << 1 ) | Rd_decode_bit( range_decoder, &bm[symbol] ); + while( --i >= 0 ) + symbol = ( symbol << 1 ) | Rd_decode_bit( rdec, &bm[symbol] ); break; } } @@ -222,18 +199,16 @@ static inline void Led_init( struct Len_decoder * const len_decoder ) } static inline int Led_decode( struct Len_decoder * const len_decoder, - struct Range_decoder * const range_decoder, + struct Range_decoder * const rdec, const int pos_state ) { - if( Rd_decode_bit( range_decoder, &len_decoder->choice1 ) == 0 ) - return Rd_decode_tree( range_decoder, len_decoder->bm_low[pos_state], - len_low_bits ); - if( Rd_decode_bit( range_decoder, &len_decoder->choice2 ) == 0 ) + if( Rd_decode_bit( rdec, &len_decoder->choice1 ) == 0 ) + return Rd_decode_tree( rdec, len_decoder->bm_low[pos_state], len_low_bits ); + if( Rd_decode_bit( rdec, &len_decoder->choice2 ) == 0 ) return len_low_symbols + - Rd_decode_tree( range_decoder, len_decoder->bm_mid[pos_state], - len_mid_bits ); + Rd_decode_tree( rdec, len_decoder->bm_mid[pos_state], len_mid_bits ); return len_low_symbols + len_mid_symbols + - Rd_decode_tree( range_decoder, len_decoder->bm_high, len_high_bits ); + Rd_decode_tree( rdec, len_decoder->bm_high, len_high_bits ); } @@ -253,15 +228,15 @@ static inline int Lid_state( const int prev_byte ) { return ( prev_byte >> ( 8 - literal_context_bits ) ); } static inline uint8_t Lid_decode( struct Literal_decoder * const literal_decoder, - struct Range_decoder * const range_decoder, + struct Range_decoder * const rdec, const uint8_t prev_byte ) - { return Rd_decode_tree( range_decoder, literal_decoder->bm_literal[Lid_state(prev_byte)], 8 ); } + { return Rd_decode_tree( rdec, literal_decoder->bm_literal[Lid_state(prev_byte)], 8 ); } static inline uint8_t Lid_decode_matched( struct Literal_decoder * const literal_decoder, - struct Range_decoder * const range_decoder, + struct Range_decoder * const rdec, const uint8_t prev_byte, const uint8_t match_byte ) - { return Rd_decode_matched( range_decoder, literal_decoder->bm_literal[Lid_state(prev_byte)], match_byte ); } + { return Rd_decode_matched( rdec, literal_decoder->bm_literal[Lid_state(prev_byte)], match_byte ); } struct LZ_decoder @@ -286,7 +261,7 @@ struct LZ_decoder Bit_model bm_dis[modeled_distances-end_dis_model]; Bit_model bm_align[dis_align_size]; - struct Range_decoder range_decoder; + struct Range_decoder * range_decoder; struct Len_decoder len_decoder; struct Len_decoder rep_match_len_decoder; struct Literal_decoder literal_decoder; @@ -335,7 +310,7 @@ bool LZd_verify_trailer( struct LZ_decoder * const decoder, static inline void LZd_init( struct LZ_decoder * const decoder, const File_header header, - struct Input_buffer * const ibuf, const int outfd ) + struct Range_decoder * const rdec, const int outfd ) { decoder->partial_data_pos = 0; decoder->format_version = Fh_version( header ); @@ -349,7 +324,7 @@ static inline void LZd_init( struct LZ_decoder * const decoder, } decoder->pos = 0; decoder->stream_pos = 0; - decoder->crc_ = 0xFFFFFFFF; + decoder->crc_ = 0xFFFFFFFFU; decoder->outfd_ = outfd; for( int i = 0; i < St_states; ++i ) @@ -372,7 +347,7 @@ static inline void LZd_init( struct LZ_decoder * const decoder, for( int i = 0; i < dis_align_size; ++i ) Bm_init( &decoder->bm_align[i] ); - Rd_init( &decoder->range_decoder, ibuf ); + decoder->range_decoder = rdec; Led_init( &decoder->len_decoder ); Led_init( &decoder->rep_match_len_decoder ); Lid_init( &decoder->literal_decoder ); @@ -383,11 +358,13 @@ static inline void LZd_free( struct LZ_decoder * const decoder ) { free( decoder->buffer ); decoder->buffer = 0; } static inline uint32_t LZd_crc( struct LZ_decoder * const decoder ) - { return decoder->crc_ ^ 0xFFFFFFFF; } + { return decoder->crc_ ^ 0xFFFFFFFFU; } + int LZd_decode_member( struct LZ_decoder * const decoder, struct Pretty_print * const pp ); static inline long long LZd_member_position( struct LZ_decoder * const decoder ) - { return Rd_member_position( &decoder->range_decoder ); } + { return Rd_member_position( decoder->range_decoder ); } + static inline long long LZd_data_position( struct LZ_decoder * const decoder ) { return decoder->partial_data_pos + decoder->pos; } -- cgit v1.2.3