is a data compression library providing in-memory LZMA compression and decompression functions using the lzip format.
| encoder_base.h (lzlib-1.12.tar.lz) | : | encoder_base.h (lzlib-1.13.tar.lz) |
|---|
| /* Lzlib - Compression library for the lzip format | | /* Lzlib - Compression library for the lzip format |
|
| Copyright (C) 2009-2021 Antonio Diaz Diaz. | | Copyright (C) 2009-2022 Antonio Diaz Diaz. |
| | |
| This library is free software. Redistribution and use in source and | | This library is free software. Redistribution and use in source and |
| binary forms, with or without modification, are permitted provided | | binary forms, with or without modification, are permitted provided |
| that the following conditions are met: | | that the following conditions are met: |
| | |
| 1. Redistributions of source code must retain the above copyright | | 1. Redistributions of source code must retain the above copyright |
| notice, this list of conditions, and the following disclaimer. | | notice, this list of conditions, and the following disclaimer. |
| | |
| 2. Redistributions in binary form must reproduce the above copyright | | 2. Redistributions in binary form must reproduce the above copyright |
| notice, this list of conditions, and the following disclaimer in the | | notice, this list of conditions, and the following disclaimer in the |
| | |
| skipping to change at line 147 | | skipping to change at line 147 |
|---|
| { return get_price( probability ); } | | { return get_price( probability ); } |
| | |
| static inline int price1( const Bit_model probability ) | | static inline int price1( const Bit_model probability ) |
| { return get_price( bit_model_total - probability ); } | | { return get_price( bit_model_total - probability ); } |
| | |
| static inline int price_bit( const Bit_model bm, const bool bit ) | | static inline int price_bit( const Bit_model bm, const bool bit ) |
| { return ( bit ? price1( bm ) : price0( bm ) ); } | | { return ( bit ? price1( bm ) : price0( bm ) ); } |
| | |
| static inline int price_symbol3( const Bit_model bm[], int symbol ) | | static inline int price_symbol3( const Bit_model bm[], int symbol ) |
| { | | { |
|
| int price; | | |
| bool bit = symbol & 1; | | bool bit = symbol & 1; |
| symbol |= 8; symbol >>= 1; | | symbol |= 8; symbol >>= 1; |
|
| price = price_bit( bm[symbol], bit ); | | int price = price_bit( bm[symbol], bit ); |
| bit = symbol & 1; symbol >>= 1; price += price_bit( bm[symbol], bit ); | | bit = symbol & 1; symbol >>= 1; price += price_bit( bm[symbol], bit ); |
| return price + price_bit( bm[1], symbol & 1 ); | | return price + price_bit( bm[1], symbol & 1 ); |
| } | | } |
| | |
| static inline int price_symbol6( const Bit_model bm[], unsigned symbol ) | | static inline int price_symbol6( const Bit_model bm[], unsigned symbol ) |
| { | | { |
|
| int price; | | |
| bool bit = symbol & 1; | | bool bit = symbol & 1; |
| symbol |= 64; symbol >>= 1; | | symbol |= 64; symbol >>= 1; |
|
| price = price_bit( bm[symbol], bit ); | | int price = price_bit( bm[symbol], bit ); |
| bit = symbol & 1; symbol >>= 1; price += price_bit( bm[symbol], bit ); | | bit = symbol & 1; symbol >>= 1; price += price_bit( bm[symbol], bit ); |
| bit = symbol & 1; symbol >>= 1; price += price_bit( bm[symbol], bit ); | | bit = symbol & 1; symbol >>= 1; price += price_bit( bm[symbol], bit ); |
| bit = symbol & 1; symbol >>= 1; price += price_bit( bm[symbol], bit ); | | bit = symbol & 1; symbol >>= 1; price += price_bit( bm[symbol], bit ); |
| bit = symbol & 1; symbol >>= 1; price += price_bit( bm[symbol], bit ); | | bit = symbol & 1; symbol >>= 1; price += price_bit( bm[symbol], bit ); |
| return price + price_bit( bm[1], symbol & 1 ); | | return price + price_bit( bm[1], symbol & 1 ); |
| } | | } |
| | |
| static inline int price_symbol8( const Bit_model bm[], int symbol ) | | static inline int price_symbol8( const Bit_model bm[], int symbol ) |
| { | | { |
|
| int price; | | |
| bool bit = symbol & 1; | | bool bit = symbol & 1; |
| symbol |= 0x100; symbol >>= 1; | | symbol |= 0x100; symbol >>= 1; |
|
| price = price_bit( bm[symbol], bit ); | | int price = price_bit( bm[symbol], bit ); |
| bit = symbol & 1; symbol >>= 1; price += price_bit( bm[symbol], bit ); | | bit = symbol & 1; symbol >>= 1; price += price_bit( bm[symbol], bit ); |
| bit = symbol & 1; symbol >>= 1; price += price_bit( bm[symbol], bit ); | | bit = symbol & 1; symbol >>= 1; price += price_bit( bm[symbol], bit ); |
| bit = symbol & 1; symbol >>= 1; price += price_bit( bm[symbol], bit ); | | bit = symbol & 1; symbol >>= 1; price += price_bit( bm[symbol], bit ); |
| bit = symbol & 1; symbol >>= 1; price += price_bit( bm[symbol], bit ); | | bit = symbol & 1; symbol >>= 1; price += price_bit( bm[symbol], bit ); |
| bit = symbol & 1; symbol >>= 1; price += price_bit( bm[symbol], bit ); | | bit = symbol & 1; symbol >>= 1; price += price_bit( bm[symbol], bit ); |
| bit = symbol & 1; symbol >>= 1; price += price_bit( bm[symbol], bit ); | | bit = symbol & 1; symbol >>= 1; price += price_bit( bm[symbol], bit ); |
| return price + price_bit( bm[1], symbol & 1 ); | | return price + price_bit( bm[1], symbol & 1 ); |
| } | | } |
| | |
| static inline int price_symbol_reversed( const Bit_model bm[], int symbol, | | static inline int price_symbol_reversed( const Bit_model bm[], int symbol, |
| | |
| skipping to change at line 421 | | skipping to change at line 418 |
|---|
| renc->low += bound; | | renc->low += bound; |
| renc->range -= bound; | | renc->range -= bound; |
| *probability -= *probability >> bit_model_move_bits; | | *probability -= *probability >> bit_model_move_bits; |
| } | | } |
| if( renc->range <= 0x00FFFFFFU ) { renc->range <<= 8; Re_shift_low( renc ); } | | if( renc->range <= 0x00FFFFFFU ) { renc->range <<= 8; Re_shift_low( renc ); } |
| } | | } |
| | |
| static inline void Re_encode_tree3( struct Range_encoder * const renc, | | static inline void Re_encode_tree3( struct Range_encoder * const renc, |
| Bit_model bm[], const int symbol ) | | Bit_model bm[], const int symbol ) |
| { | | { |
|
| int model; | | |
| bool bit = ( symbol >> 2 ) & 1; | | bool bit = ( symbol >> 2 ) & 1; |
| Re_encode_bit( renc, &bm[1], bit ); | | Re_encode_bit( renc, &bm[1], bit ); |
|
| model = 2 | bit; | | int model = 2 | bit; |
| bit = ( symbol >> 1 ) & 1; | | bit = ( symbol >> 1 ) & 1; |
| Re_encode_bit( renc, &bm[model], bit ); model <<= 1; model |= bit; | | Re_encode_bit( renc, &bm[model], bit ); model <<= 1; model |= bit; |
| Re_encode_bit( renc, &bm[model], symbol & 1 ); | | Re_encode_bit( renc, &bm[model], symbol & 1 ); |
| } | | } |
| | |
| static inline void Re_encode_tree6( struct Range_encoder * const renc, | | static inline void Re_encode_tree6( struct Range_encoder * const renc, |
| Bit_model bm[], const unsigned symbol ) | | Bit_model bm[], const unsigned symbol ) |
| { | | { |
|
| int model; | | |
| bool bit = ( symbol >> 5 ) & 1; | | bool bit = ( symbol >> 5 ) & 1; |
| Re_encode_bit( renc, &bm[1], bit ); | | Re_encode_bit( renc, &bm[1], bit ); |
|
| model = 2 | bit; | | int model = 2 | bit; |
| bit = ( symbol >> 4 ) & 1; | | bit = ( symbol >> 4 ) & 1; |
| Re_encode_bit( renc, &bm[model], bit ); model <<= 1; model |= bit; | | Re_encode_bit( renc, &bm[model], bit ); model <<= 1; model |= bit; |
| bit = ( symbol >> 3 ) & 1; | | bit = ( symbol >> 3 ) & 1; |
| Re_encode_bit( renc, &bm[model], bit ); model <<= 1; model |= bit; | | Re_encode_bit( renc, &bm[model], bit ); model <<= 1; model |= bit; |
| bit = ( symbol >> 2 ) & 1; | | bit = ( symbol >> 2 ) & 1; |
| Re_encode_bit( renc, &bm[model], bit ); model <<= 1; model |= bit; | | Re_encode_bit( renc, &bm[model], bit ); model <<= 1; model |= bit; |
| bit = ( symbol >> 1 ) & 1; | | bit = ( symbol >> 1 ) & 1; |
| Re_encode_bit( renc, &bm[model], bit ); model <<= 1; model |= bit; | | Re_encode_bit( renc, &bm[model], bit ); model <<= 1; model |= bit; |
| Re_encode_bit( renc, &bm[model], symbol & 1 ); | | Re_encode_bit( renc, &bm[model], symbol & 1 ); |
| } | | } |
| | |
| skipping to change at line 576 | | skipping to change at line 571 |
|---|
| const uint8_t prev_byte, const uint8_t symbol ) | | const uint8_t prev_byte, const uint8_t symbol ) |
| { return price_symbol8( eb->bm_literal[get_lit_state(prev_byte)], symbol ); } | | { return price_symbol8( eb->bm_literal[get_lit_state(prev_byte)], symbol ); } |
| | |
| static inline int LZeb_price_matched( const struct LZ_encoder_base * const eb, | | static inline int LZeb_price_matched( const struct LZ_encoder_base * const eb, |
| const uint8_t prev_byte, const uint8_t symbol, const uint8_t match_byte ) | | const uint8_t prev_byte, const uint8_t symbol, const uint8_t match_byte ) |
| { return price_matched( eb->bm_literal[get_lit_state(prev_byte)], symbol, | | { return price_matched( eb->bm_literal[get_lit_state(prev_byte)], symbol, |
| match_byte ); } | | match_byte ); } |
| | |
| static inline void LZeb_encode_literal( struct LZ_encoder_base * const eb, | | static inline void LZeb_encode_literal( struct LZ_encoder_base * const eb, |
| const uint8_t prev_byte, const uint8_t symbol ) | | const uint8_t prev_byte, const uint8_t symbol ) |
|
| { Re_encode_tree8( &eb->renc, eb->bm_literal[get_lit_state(prev_byte)], | | { Re_encode_tree8( &eb->renc, eb->bm_literal[get_lit_state(prev_byte)], symbol |
| symbol ); } | | ); } |
| | |
| static inline void LZeb_encode_matched( struct LZ_encoder_base * const eb, | | static inline void LZeb_encode_matched( struct LZ_encoder_base * const eb, |
| const uint8_t prev_byte, const uint8_t symbol, const uint8_t match_byte ) | | const uint8_t prev_byte, const uint8_t symbol, const uint8_t match_byte ) |
| { Re_encode_matched( &eb->renc, eb->bm_literal[get_lit_state(prev_byte)], | | { Re_encode_matched( &eb->renc, eb->bm_literal[get_lit_state(prev_byte)], |
| symbol, match_byte ); } | | symbol, match_byte ); } |
| | |
| static inline void LZeb_encode_pair( struct LZ_encoder_base * const eb, | | static inline void LZeb_encode_pair( struct LZ_encoder_base * const eb, |
| const unsigned dis, const int len, | | const unsigned dis, const int len, |
| const int pos_state ) | | const int pos_state ) |
| { | | { |
|
| const unsigned dis_slot = get_slot( dis ); | | |
| Re_encode_len( &eb->renc, &eb->match_len_model, len, pos_state ); | | Re_encode_len( &eb->renc, &eb->match_len_model, len, pos_state ); |
|
| | const unsigned dis_slot = get_slot( dis ); |
| Re_encode_tree6( &eb->renc, eb->bm_dis_slot[get_len_state(len)], dis_slot ); | | Re_encode_tree6( &eb->renc, eb->bm_dis_slot[get_len_state(len)], dis_slot ); |
| | |
| if( dis_slot >= start_dis_model ) | | if( dis_slot >= start_dis_model ) |
| { | | { |
| const int direct_bits = ( dis_slot >> 1 ) - 1; | | const int direct_bits = ( dis_slot >> 1 ) - 1; |
| const unsigned base = ( 2 | ( dis_slot & 1 ) ) << direct_bits; | | const unsigned base = ( 2 | ( dis_slot & 1 ) ) << direct_bits; |
| const unsigned direct_dis = dis - base; | | const unsigned direct_dis = dis - base; |
| | |
| if( dis_slot < end_dis_model ) | | if( dis_slot < end_dis_model ) |
| Re_encode_tree_reversed( &eb->renc, eb->bm_dis + ( base - dis_slot ), | | Re_encode_tree_reversed( &eb->renc, eb->bm_dis + ( base - dis_slot ), |
| | | |
| End of changes. 14 change blocks. |
|---|
| 14 lines changed or deleted | | 9 lines changed or added |
|---|
"Fossies" - the Fresh Open Source Software Archive 