diff options
Diffstat (limited to '')
| -rw-r--r-- | encoder.h | 288 |
1 files changed, 146 insertions, 142 deletions
@@ -1,4 +1,4 @@ -/* Clzip - A data compressor based on the LZMA algorithm +/* Clzip - Data compressor based on the LZMA algorithm Copyright (C) 2010 Antonio Diaz Diaz. This program is free software: you can redistribute it and/or modify @@ -24,8 +24,9 @@ extern Dis_slots dis_slots; static inline void Dis_slots_init() { - for( int slot = 0; slot < 4; ++slot ) dis_slots[slot] = slot; - for( int i = 4, size = 2, slot = 4; slot < 24; slot += 2 ) + int i, size, slot; + for( slot = 0; slot < 4; ++slot ) dis_slots[slot] = slot; + for( i = 4, size = 2, slot = 4; slot < 24; slot += 2 ) { memset( &dis_slots[i], slot, size ); memset( &dis_slots[i+size], slot + 1, size ); @@ -49,13 +50,13 @@ extern Prob_prices prob_prices; static inline void Prob_prices_init() { const int num_bits = ( bit_model_total_bits - 2 ); - for( int i = num_bits - 1; i >= 0; --i ) + int i, j = 1, end = 2; + prob_prices[0] = bit_model_total_bits << price_shift; + for( i = num_bits - 1; i >= 0; --i, end <<= 1 ) { - int start = 1 << ( num_bits - i - 1 ); - int end = 1 << ( num_bits - i); - for( int j = start; j < end; ++j ) - prob_prices[j] = (i << price_shift) + - ( ((end - j) << price_shift) >> (num_bits - i - 1) ); + for( ; j < end; ++j ) + prob_prices[j] = ( i << price_shift ) + + ( ((end - j) << price_shift) >> (num_bits - i - 1) ); } } @@ -73,10 +74,11 @@ static inline int price_bit( const Bit_model bm, const int bit ) { if( bit ) return price1( bm ); else return price0( bm ); } -static inline int price_symbol( const Bit_model bm[], int symbol, const int num_bits ) +static inline int price_symbol( const Bit_model bm[], int symbol, + const int num_bits ) { - symbol |= ( 1 << num_bits ); int price = 0; + symbol |= ( 1 << num_bits ); while( symbol > 1 ) { const int bit = symbol & 1; @@ -92,7 +94,8 @@ static inline int price_symbol_reversed( const Bit_model bm[], int symbol, { int price = 0; int model = 1; - for( int i = num_bits; i > 0; --i ) + int i; + for( i = num_bits; i > 0; --i ) { const int bit = symbol & 1; symbol >>= 1; @@ -108,8 +111,9 @@ static inline int price_matched( const Bit_model bm[], const int symbol, { int price = 0; int model = 1; + int i; - for( int i = 7; i >= 0; --i ) + for( i = 7; i >= 0; --i ) { const int match_bit = ( match_byte >> i ) & 1; int bit = ( symbol >> i ) & 1; @@ -130,86 +134,87 @@ static inline int price_matched( const Bit_model bm[], const int symbol, } -enum { // bytes to keep in buffer before dictionary - mf_before_size = max_num_trials + 1, - // bytes to keep in buffer after pos - mf_after_size = max_match_len, - mf_num_prev_positions4 = 1 << 20, - mf_num_prev_positions3 = 1 << 18, - mf_num_prev_positions2 = 1 << 16, - mf_num_prev_positions = mf_num_prev_positions4 + mf_num_prev_positions3 + - mf_num_prev_positions2 }; +enum { /* bytes to keep in buffer before dictionary */ + before_size = max_num_trials + 1, + /* bytes to keep in buffer after pos */ + after_size = max_match_len, + num_prev_positions4 = 1 << 20, + num_prev_positions3 = 1 << 18, + num_prev_positions2 = 1 << 16, + num_prev_positions = num_prev_positions4 + num_prev_positions3 + + num_prev_positions2 }; struct Matchfinder { long long partial_data_pos; - int dictionary_size_; // bytes to keep in buffer before pos + uint8_t * buffer; /* input buffer */ + int32_t * prev_positions; /* last seen position of key */ + int32_t * prev_pos_tree; + int dictionary_size_; /* bytes to keep in buffer before pos */ int buffer_size; - uint8_t * buffer; - int pos; - int cyclic_pos; - int stream_pos; // first byte not yet read from file - int pos_limit; // when reached, a new block must be read - int infd_; // input file descriptor + int pos; /* current pos in buffer */ + int cyclic_pos; /* current pos in dictionary */ + int stream_pos; /* first byte not yet read from file */ + int pos_limit; /* when reached, a new block must be read */ int match_len_limit_; - int32_t * prev_positions; // last seen position of key - int32_t * prev_pos_tree; - bool at_stream_end; // stream_pos shows real end of file + int cycles; + int infd; /* input file descriptor */ + bool at_stream_end; /* stream_pos shows real end of file */ }; -bool Mf_read_block( struct Matchfinder * const matchfinder ); +bool Mf_read_block( struct Matchfinder * const mf ); -void Mf_init( struct Matchfinder * const matchfinder, - const int dict_size, const int len_limit, const int infd ); +void Mf_init( struct Matchfinder * const mf, + const int dict_size, const int len_limit, const int ifd ); -static inline void Mf_free( struct Matchfinder * const matchfinder ) +static inline void Mf_free( struct Matchfinder * const mf ) { - free( matchfinder->prev_pos_tree ); matchfinder->prev_pos_tree = 0; - free( matchfinder->prev_positions ); matchfinder->prev_positions = 0; - free( matchfinder->buffer ); matchfinder->buffer = 0; + free( mf->prev_pos_tree ); mf->prev_pos_tree = 0; + free( mf->prev_positions ); mf->prev_positions = 0; + free( mf->buffer ); mf->buffer = 0; } -static inline uint8_t Mf_peek( struct Matchfinder * const matchfinder, const int i ) - { return matchfinder->buffer[matchfinder->pos+i]; } -static inline int Mf_available_bytes( struct Matchfinder * const matchfinder ) - { return matchfinder->stream_pos - matchfinder->pos; } -static inline long long Mf_data_position( struct Matchfinder * const matchfinder ) - { return matchfinder->partial_data_pos + matchfinder->pos; } -static inline int Mf_dictionary_size( struct Matchfinder * const matchfinder ) - { return matchfinder->dictionary_size_; } -static inline bool Mf_finished( struct Matchfinder * const matchfinder ) - { return matchfinder->at_stream_end && matchfinder->pos >= matchfinder->stream_pos; } -static inline int Mf_match_len_limit( struct Matchfinder * const matchfinder ) - { return matchfinder->match_len_limit_; } -static inline const uint8_t * Mf_ptr_to_current_pos( struct Matchfinder * const matchfinder ) - { return matchfinder->buffer + matchfinder->pos; } - -static inline bool Mf_dec_pos( struct Matchfinder * const matchfinder, +static inline uint8_t Mf_peek( struct Matchfinder * const mf, const int i ) + { return mf->buffer[mf->pos+i]; } +static inline int Mf_available_bytes( struct Matchfinder * const mf ) + { return mf->stream_pos - mf->pos; } +static inline long long Mf_data_position( struct Matchfinder * const mf ) + { return mf->partial_data_pos + mf->pos; } +static inline int Mf_dictionary_size( struct Matchfinder * const mf ) + { return mf->dictionary_size_; } +static inline bool Mf_finished( struct Matchfinder * const mf ) + { return mf->at_stream_end && mf->pos >= mf->stream_pos; } +static inline int Mf_match_len_limit( struct Matchfinder * const mf ) + { return mf->match_len_limit_; } +static inline const uint8_t * Mf_ptr_to_current_pos( struct Matchfinder * const mf ) + { return mf->buffer + mf->pos; } + +static inline bool Mf_dec_pos( struct Matchfinder * const mf, const int ahead ) { - if( ahead < 0 || matchfinder->pos < ahead ) return false; - matchfinder->pos -= ahead; - matchfinder->cyclic_pos -= ahead; - if( matchfinder->cyclic_pos < 0 ) - matchfinder->cyclic_pos += matchfinder->dictionary_size_; + if( ahead < 0 || mf->pos < ahead ) return false; + mf->pos -= ahead; + mf->cyclic_pos -= ahead; + if( mf->cyclic_pos < 0 ) mf->cyclic_pos += mf->dictionary_size_; return true; } -static inline int Mf_true_match_len( struct Matchfinder * const matchfinder, - const int index, const int distance, int len_limit ) +static inline int Mf_true_match_len( struct Matchfinder * const mf, + const int index, const int distance, + int len_limit ) { - if( index + len_limit > Mf_available_bytes( matchfinder ) ) - len_limit = Mf_available_bytes( matchfinder ) - index; - const uint8_t * const data = matchfinder->buffer + matchfinder->pos + index - distance; + const uint8_t * const data = mf->buffer + mf->pos + index - distance; int i = 0; + + if( index + len_limit > Mf_available_bytes( mf ) ) + len_limit = Mf_available_bytes( mf ) - index; while( i < len_limit && data[i] == data[i+distance] ) ++i; return i; } -bool Mf_reset( struct Matchfinder * const matchfinder ); -bool Mf_move_pos( struct Matchfinder * const matchfinder ); -int Mf_longest_match_len( struct Matchfinder * const matchfinder, - int * const distances ); +void Mf_reset( struct Matchfinder * const mf ); +void Mf_move_pos( struct Matchfinder * const mf ); +int Mf_longest_match_len( struct Matchfinder * const mf, int * const distances ); enum { re_buffer_size = 65536 }; @@ -218,28 +223,15 @@ struct Range_encoder { uint64_t low; long long partial_member_pos; - uint8_t * buffer; - int pos; + uint8_t * buffer; /* output buffer */ + int pos; /* current pos in buffer */ uint32_t range; int ff_count; - int outfd_; // output file descriptor + int outfd; /* output file descriptor */ uint8_t cache; }; -static inline void Re_flush_data( struct Range_encoder * const range_encoder ) - { - if( range_encoder->pos > 0 ) - { - if( range_encoder->outfd_ >= 0 ) - { - const int wr = writeblock( range_encoder->outfd_, range_encoder->buffer, range_encoder->pos ); - if( wr != range_encoder->pos ) - { show_error( "write error", errno, false ); cleanup_and_fail( 1 ); } - } - range_encoder->partial_member_pos += range_encoder->pos; - range_encoder->pos = 0; - } - } +void Re_flush_data( struct Range_encoder * const range_encoder ); static inline void Re_put_byte( struct Range_encoder * const range_encoder, const uint8_t b ) @@ -263,36 +255,37 @@ static inline void Re_shift_low( struct Range_encoder * const range_encoder ) } static inline void Re_init( struct Range_encoder * const range_encoder, - const int outfd ) + const int ofd ) { range_encoder->low = 0; range_encoder->partial_member_pos = 0; range_encoder->buffer = (uint8_t *)malloc( re_buffer_size ); if( !range_encoder->buffer ) { - show_error( "not enough memory. Try a smaller dictionary size", 0, false ); + show_error( "Not enough memory. Try a smaller dictionary size.", 0, false ); cleanup_and_fail( 1 ); } range_encoder->pos = 0; range_encoder->range = 0xFFFFFFFFU; range_encoder->ff_count = 0; - range_encoder->outfd_ = outfd; + range_encoder->outfd = ofd; range_encoder->cache = 0; } static inline void Re_free( struct Range_encoder * const range_encoder ) { free( range_encoder->buffer ); range_encoder->buffer = 0; } -static inline void Re_flush( struct Range_encoder * const range_encoder ) - { for( int i = 0; i < 5; ++i ) Re_shift_low( range_encoder ); } - static inline long long Re_member_position( struct Range_encoder * const range_encoder ) { return range_encoder->partial_member_pos + range_encoder->pos + range_encoder->ff_count; } +static inline void Re_flush( struct Range_encoder * const range_encoder ) + { int i; for( i = 0; i < 5; ++i ) Re_shift_low( range_encoder ); } + static inline void Re_encode( struct Range_encoder * const range_encoder, const int symbol, const int num_bits ) { - for( int i = num_bits - 1; i >= 0; --i ) + int i; + for( i = num_bits - 1; i >= 0; --i ) { range_encoder->range >>= 1; if( (symbol >> i) & 1 ) range_encoder->low += range_encoder->range; @@ -325,7 +318,8 @@ static inline void Re_encode_tree( struct Range_encoder * const range_encoder, { int mask = ( 1 << ( num_bits - 1 ) ); int model = 1; - for( int i = num_bits; i > 0; --i, mask >>= 1 ) + int i; + for( i = num_bits; i > 0; --i, mask >>= 1 ) { const int bit = ( symbol & mask ); Re_encode_bit( range_encoder, &bm[model], bit ); @@ -338,7 +332,8 @@ static inline void Re_encode_tree_reversed( struct Range_encoder * const range_e Bit_model bm[], int symbol, const int num_bits ) { int model = 1; - for( int i = num_bits; i > 0; --i ) + int i; + for( i = num_bits; i > 0; --i ) { const int bit = symbol & 1; Re_encode_bit( range_encoder, &bm[model], bit ); @@ -351,7 +346,8 @@ static inline void Re_encode_matched( struct Range_encoder * const range_encoder Bit_model bm[], int symbol, int match_byte ) { int model = 1; - for( int i = 7; i >= 0; --i ) + int i; + for( i = 7; i >= 0; --i ) { const int match_bit = ( match_byte >> i ) & 1; int bit = ( symbol >> i ) & 1; @@ -405,18 +401,19 @@ static inline void Lee_update_prices( struct Len_encoder * const len_encoder, static inline void Lee_init( struct Len_encoder * const len_encoder, const int len_limit ) { + int i, j; Bm_init( &len_encoder->choice1 ); Bm_init( &len_encoder->choice2 ); - for( int i = 0; i < pos_states; ++i ) - for( int j = 0; j < len_low_symbols; ++j ) + for( i = 0; i < pos_states; ++i ) + for( j = 0; j < len_low_symbols; ++j ) Bm_init( &len_encoder->bm_low[i][j] ); - for( int i = 0; i < pos_states; ++i ) - for( int j = 0; j < len_mid_symbols; ++j ) + for( i = 0; i < pos_states; ++i ) + for( j = 0; j < len_mid_symbols; ++j ) Bm_init( &len_encoder->bm_mid[i][j] ); - for( int i = 0; i < len_high_symbols; ++i ) + for( i = 0; i < len_high_symbols; ++i ) Bm_init( &len_encoder->bm_high[i] ); len_encoder->len_symbols = len_limit + 1 - min_match_len; - for( int i = 0; i < pos_states; ++i ) Lee_update_prices( len_encoder, i ); + for( i = 0; i < pos_states; ++i ) Lee_update_prices( len_encoder, i ); } void Lee_encode( struct Len_encoder * const len_encoder, @@ -433,16 +430,17 @@ struct Literal_encoder Bit_model bm_literal[1<<literal_context_bits][0x300]; }; +static inline int Lie_state( const int prev_byte ) + { return ( prev_byte >> ( 8 - literal_context_bits ) ); } + static inline void Lie_init( struct Literal_encoder * const literal_encoder ) { - for( int i = 0; i < 1<<literal_context_bits; ++i ) - for( int j = 0; j < 0x300; ++j ) + int i, j; + for( i = 0; i < 1<<literal_context_bits; ++i ) + for( j = 0; j < 0x300; ++j ) Bm_init( &literal_encoder->bm_literal[i][j] ); } -static inline int Lie_state( const int prev_byte ) - { return ( prev_byte >> ( 8 - literal_context_bits ) ); } - static inline void Lie_encode( struct Literal_encoder * const literal_encoder, struct Range_encoder * const range_encoder, uint8_t prev_byte, uint8_t symbol ) @@ -450,29 +448,28 @@ static inline void Lie_encode( struct Literal_encoder * const literal_encoder, static inline void Lie_encode_matched( struct Literal_encoder * const literal_encoder, struct Range_encoder * const range_encoder, - uint8_t prev_byte, uint8_t match_byte, uint8_t symbol ) + uint8_t prev_byte, uint8_t symbol, uint8_t match_byte ) { Re_encode_matched( range_encoder, literal_encoder->bm_literal[Lie_state(prev_byte)], symbol, match_byte ); } -static inline int Lie_price_matched( struct Literal_encoder * const literal_encoder, - uint8_t prev_byte, uint8_t symbol, uint8_t match_byte ) - { return price_matched( literal_encoder->bm_literal[Lie_state(prev_byte)], symbol, match_byte ); } - static inline int Lie_price_symbol( struct Literal_encoder * const literal_encoder, uint8_t prev_byte, uint8_t symbol ) { return price_symbol( literal_encoder->bm_literal[Lie_state(prev_byte)], symbol, 8 ); } +static inline int Lie_price_matched( struct Literal_encoder * const literal_encoder, + uint8_t prev_byte, uint8_t symbol, uint8_t match_byte ) + { return price_matched( literal_encoder->bm_literal[Lie_state(prev_byte)], symbol, match_byte ); } + -enum { lze_dis_align_mask = dis_align_size - 1, - lze_infinite_price = 0x0FFFFFFF, - lze_max_marker_size = 16, - num_rep_distances = 4 }; // must be 4 +enum { infinite_price = 0x0FFFFFFF, + max_marker_size = 16, + num_rep_distances = 4 }; /* must be 4 */ struct Trial { State state; int dis; - int prev_index; // index of prev trial in trials[] - int price; // dual use var; cumulative price, match length + int prev_index; /* index of prev trial in trials[] */ + int price; /* dual use var; cumulative price, match length */ int reps[num_rep_distances]; }; @@ -489,14 +486,14 @@ struct LZ_encoder int longest_match_found; uint32_t crc_; - Bit_model bm_match[St_states][pos_states]; - Bit_model bm_rep[St_states]; - Bit_model bm_rep0[St_states]; - Bit_model bm_rep1[St_states]; - Bit_model bm_rep2[St_states]; - Bit_model bm_len[St_states][pos_states]; + Bit_model bm_match[states][pos_states]; + Bit_model bm_rep[states]; + Bit_model bm_rep0[states]; + Bit_model bm_rep1[states]; + Bit_model bm_rep2[states]; + Bit_model bm_len[states][pos_states]; Bit_model bm_dis_slot[max_dis_states][1<<dis_slot_bits]; - Bit_model bm_dis[modeled_distances-end_dis_model]; + Bit_model bm_dis[modeled_distances-end_dis_model+1]; Bit_model bm_align[dis_align_size]; struct Matchfinder * matchfinder; @@ -521,18 +518,19 @@ void LZe_fill_distance_prices( struct LZ_encoder * const encoder ); static inline uint32_t LZe_crc( struct LZ_encoder * const encoder ) { return encoder->crc_ ^ 0xFFFFFFFFU; } - // move-to-front dis in/into reps + /* move-to-front dis in/into reps */ static inline void LZe_mtf_reps( const int dis, int reps[num_rep_distances] ) { + int i; if( dis >= num_rep_distances ) { - for( int i = num_rep_distances - 1; i > 0; --i ) reps[i] = reps[i-1]; + for( i = num_rep_distances - 1; i > 0; --i ) reps[i] = reps[i-1]; reps[0] = dis - num_rep_distances; } else if( dis > 0 ) { const int distance = reps[dis]; - for( int i = dis; i > 0; --i ) reps[i] = reps[i-1]; + for( i = dis; i > 0; --i ) reps[i] = reps[i-1]; reps[0] = distance; } } @@ -546,9 +544,10 @@ static inline int LZe_price_rep_len1( struct LZ_encoder * const encoder, static inline int LZe_price_rep( struct LZ_encoder * const encoder, const int rep, const State state, const int pos_state ) { + int price; if( rep == 0 ) return price0( encoder->bm_rep0[state] ) + price1( encoder->bm_len[state][pos_state] ); - int price = price1( encoder->bm_rep0[state] ); + price = price1( encoder->bm_rep0[state] ); if( rep == 1 ) price += price0( encoder->bm_rep1[state] ); else @@ -559,27 +558,33 @@ static inline int LZe_price_rep( struct LZ_encoder * const encoder, const int re return price; } -static inline int LZe_price_pair( struct LZ_encoder * const encoder, const int dis, - const int len, const int pos_state ) +static inline int LZe_price_pair( struct LZ_encoder * const encoder, + const int dis, const int len, + const int pos_state ) { - if( len <= min_match_len && dis >= modeled_distances ) - return lze_infinite_price; - int price = Lee_price( &encoder->len_encoder, len, pos_state ); const int dis_state = get_dis_state( len ); + int price; + + if( len <= min_match_len && dis >= modeled_distances ) + return infinite_price; + price = Lee_price( &encoder->len_encoder, len, pos_state ); if( dis < modeled_distances ) price += encoder->dis_prices[dis_state][dis]; else price += encoder->dis_slot_prices[dis_state][get_slot( dis )] + - encoder->align_prices[dis & lze_dis_align_mask]; + encoder->align_prices[dis & (dis_align_size - 1)]; return price; } static inline void LZe_encode_pair( struct LZ_encoder * const encoder, - const uint32_t dis, const int len, const int pos_state ) + const uint32_t dis, const int len, + const int pos_state ) { - Lee_encode( &encoder->len_encoder, &encoder->range_encoder, len, pos_state ); const int dis_slot = get_slot( dis ); - Re_encode_tree( &encoder->range_encoder, encoder->bm_dis_slot[get_dis_state(len)], dis_slot, dis_slot_bits ); + Lee_encode( &encoder->len_encoder, &encoder->range_encoder, len, pos_state ); + Re_encode_tree( &encoder->range_encoder, + encoder->bm_dis_slot[get_dis_state(len)], + dis_slot, dis_slot_bits ); if( dis_slot >= start_dis_model ) { @@ -607,16 +612,15 @@ static inline int LZe_read_match_distances( struct LZ_encoder * const encoder ) return len; } -static inline bool LZe_move_pos( struct LZ_encoder * const encoder, +static inline void LZe_move_pos( struct LZ_encoder * const encoder, int n, bool skip ) { while( --n >= 0 ) { if( skip ) skip = false; else Mf_longest_match_len( encoder->matchfinder, 0 ); - if( !Mf_move_pos( encoder->matchfinder ) ) return false; + Mf_move_pos( encoder->matchfinder ); } - return true; } static inline void LZe_backward( struct LZ_encoder * const encoder, int cur ) @@ -626,7 +630,7 @@ static inline void LZe_backward( struct LZ_encoder * const encoder, int cur ) { const int prev_index = encoder->trials[cur].prev_index; struct Trial * const prev_trial = &encoder->trials[prev_index]; - prev_trial->price = cur - prev_index; // len + prev_trial->price = cur - prev_index; /* len */ cur = *dis; *dis = prev_trial->dis; prev_trial->dis = cur; cur = prev_index; } |