summaryrefslogtreecommitdiffstats
path: root/decoder.h
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2017-05-07 15:50:01 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2017-05-07 15:50:01 +0000
commitefe11df4b26426c3db4f96592e899b1f005a878e (patch)
tree4195bbbd046bc3e44a30202dc3284e45bad0f516 /decoder.h
parentReleasing debian version 1.8-5. (diff)
downloadclzip-efe11df4b26426c3db4f96592e899b1f005a878e.tar.xz
clzip-efe11df4b26426c3db4f96592e899b1f005a878e.zip
Merging upstream version 1.9.
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'decoder.h')
-rw-r--r--decoder.h209
1 files changed, 93 insertions, 116 deletions
diff --git a/decoder.h b/decoder.h
index 662aaf9..2f96575 100644
--- a/decoder.h
+++ b/decoder.h
@@ -1,5 +1,5 @@
/* Clzip - LZMA lossless data compressor
- Copyright (C) 2010-2016 Antonio Diaz Diaz.
+ Copyright (C) 2010-2017 Antonio Diaz Diaz.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@@ -56,7 +56,7 @@ Rd_member_position( const struct Range_decoder * const rdec )
{ return rdec->partial_member_pos + rdec->pos; }
static inline void Rd_reset_member_position( struct Range_decoder * const rdec )
- { rdec->partial_member_pos = -rdec->pos; }
+ { rdec->partial_member_pos = 0; rdec->partial_member_pos -= rdec->pos; }
static inline uint8_t Rd_get_byte( struct Range_decoder * const rdec )
{
@@ -68,23 +68,22 @@ static inline uint8_t Rd_get_byte( struct Range_decoder * const rdec )
static inline int Rd_read_data( struct Range_decoder * const rdec,
uint8_t * const outbuf, const int size )
{
- int rest = size;
- while( rest > 0 && !Rd_finished( rdec ) )
+ int sz = 0;
+ while( sz < size && !Rd_finished( rdec ) )
{
- const int rd = min( rest, rdec->stream_pos - rdec->pos );
- memcpy( outbuf + size - rest, rdec->buffer + rdec->pos, rd );
+ const int rd = min( size - sz, rdec->stream_pos - rdec->pos );
+ memcpy( outbuf + sz, rdec->buffer + rdec->pos, rd );
rdec->pos += rd;
- rest -= rd;
+ sz += rd;
}
- return size - rest;
+ return sz;
}
static inline void Rd_load( struct Range_decoder * const rdec )
{
int i;
rdec->code = 0;
- for( i = 0; i < 5; ++i )
- rdec->code = (rdec->code << 8) | Rd_get_byte( rdec );
+ for( i = 0; i < 5; ++i ) rdec->code = (rdec->code << 8) | Rd_get_byte( rdec );
rdec->range = 0xFFFFFFFFU;
rdec->code &= rdec->range; /* make sure that first byte is discarded */
}
@@ -92,34 +91,30 @@ static inline void Rd_load( struct Range_decoder * const rdec )
static inline void Rd_normalize( struct Range_decoder * const rdec )
{
if( rdec->range <= 0x00FFFFFFU )
- {
- rdec->range <<= 8;
- rdec->code = (rdec->code << 8) | Rd_get_byte( rdec );
- }
+ { rdec->range <<= 8; rdec->code = (rdec->code << 8) | Rd_get_byte( rdec ); }
}
-static inline int Rd_decode( struct Range_decoder * const rdec,
- const int num_bits )
+static inline unsigned Rd_decode( struct Range_decoder * const rdec,
+ const int num_bits )
{
- int symbol = 0;
+ unsigned symbol = 0;
int i;
for( i = num_bits; i > 0; --i )
{
- uint32_t mask;
+ bool bit;
Rd_normalize( rdec );
rdec->range >>= 1;
/* symbol <<= 1; */
/* if( rdec->code >= rdec->range ) { rdec->code -= rdec->range; symbol |= 1; } */
- mask = 0U - (rdec->code < rdec->range);
- rdec->code -= rdec->range;
- rdec->code += rdec->range & mask;
- symbol = (symbol << 1) + (mask + 1);
+ bit = ( rdec->code >= rdec->range );
+ symbol = ( symbol << 1 ) + bit;
+ rdec->code -= rdec->range & ( 0U - bit );
}
return symbol;
}
-static inline int Rd_decode_bit( struct Range_decoder * const rdec,
- Bit_model * const probability )
+static inline unsigned Rd_decode_bit( struct Range_decoder * const rdec,
+ Bit_model * const probability )
{
uint32_t bound;
Rd_normalize( rdec );
@@ -139,20 +134,20 @@ static inline int Rd_decode_bit( struct Range_decoder * const rdec,
}
}
-static inline int Rd_decode_tree( struct Range_decoder * const rdec,
- Bit_model bm[], const int num_bits )
+static inline unsigned Rd_decode_tree3( struct Range_decoder * const rdec,
+ Bit_model bm[] )
{
- int symbol = 1;
- int i;
- for( i = num_bits; i > 0; --i )
- symbol = ( symbol << 1 ) | Rd_decode_bit( rdec, &bm[symbol] );
- return symbol - (1 << num_bits);
+ unsigned symbol = 1;
+ symbol = ( symbol << 1 ) | Rd_decode_bit( rdec, &bm[symbol] );
+ symbol = ( symbol << 1 ) | Rd_decode_bit( rdec, &bm[symbol] );
+ symbol = ( symbol << 1 ) | Rd_decode_bit( rdec, &bm[symbol] );
+ return symbol & 7;
}
-static inline int Rd_decode_tree6( struct Range_decoder * const rdec,
- Bit_model bm[] )
+static inline unsigned Rd_decode_tree6( struct Range_decoder * const rdec,
+ Bit_model bm[] )
{
- int symbol = 1;
+ unsigned symbol = 1;
symbol = ( symbol << 1 ) | Rd_decode_bit( rdec, &bm[symbol] );
symbol = ( symbol << 1 ) | Rd_decode_bit( rdec, &bm[symbol] );
symbol = ( symbol << 1 ) | Rd_decode_bit( rdec, &bm[symbol] );
@@ -162,69 +157,69 @@ static inline int Rd_decode_tree6( struct Range_decoder * const rdec,
return symbol & 0x3F;
}
-static inline int Rd_decode_tree_reversed( struct Range_decoder * const rdec,
- Bit_model bm[], const int num_bits )
+static inline unsigned Rd_decode_tree8( struct Range_decoder * const rdec,
+ Bit_model bm[] )
{
- int model = 1;
- int symbol = 0;
+ unsigned symbol = 1;
+ int i;
+ for( i = 0; i < 8; ++i )
+ symbol = ( symbol << 1 ) | Rd_decode_bit( rdec, &bm[symbol] );
+ return symbol & 0xFF;
+ }
+
+static inline unsigned
+Rd_decode_tree_reversed( struct Range_decoder * const rdec,
+ Bit_model bm[], const int num_bits )
+ {
+ unsigned model = 1;
+ unsigned symbol = 0;
int i;
for( i = 0; i < num_bits; ++i )
{
- const bool bit = Rd_decode_bit( rdec, &bm[model] );
- model <<= 1;
- if( bit ) { ++model; symbol |= (1 << i); }
+ const unsigned bit = Rd_decode_bit( rdec, &bm[model] );
+ model = ( model << 1 ) + bit;
+ symbol |= ( bit << i );
}
return symbol;
}
-static inline int Rd_decode_tree_reversed4( struct Range_decoder * const rdec,
- Bit_model bm[] )
+static inline unsigned
+Rd_decode_tree_reversed4( struct Range_decoder * const rdec, Bit_model bm[] )
{
- int model = 1;
- int symbol = Rd_decode_bit( rdec, &bm[model] );
- int bit;
- model = (model << 1) + symbol;
- bit = Rd_decode_bit( rdec, &bm[model] );
- model = (model << 1) + bit; symbol |= (bit << 1);
+ unsigned symbol = Rd_decode_bit( rdec, &bm[1] );
+ unsigned model = 2 + symbol;
+ unsigned bit = Rd_decode_bit( rdec, &bm[model] );
+ model = ( model << 1 ) + bit; symbol |= ( bit << 1 );
bit = Rd_decode_bit( rdec, &bm[model] );
- model = (model << 1) + bit; symbol |= (bit << 2);
- if( Rd_decode_bit( rdec, &bm[model] ) ) symbol |= 8;
+ model = ( model << 1 ) + bit; symbol |= ( bit << 2 );
+ symbol |= ( Rd_decode_bit( rdec, &bm[model] ) << 3 );
return symbol;
}
-static inline int Rd_decode_matched( struct Range_decoder * const rdec,
- Bit_model bm[], int match_byte )
+static inline unsigned Rd_decode_matched( struct Range_decoder * const rdec,
+ Bit_model bm[], unsigned match_byte )
{
- Bit_model * const bm1 = bm + 0x100;
- int symbol = 1;
- while( symbol < 0x100 )
+ unsigned symbol = 1;
+ unsigned mask = 0x100;
+ while( true )
{
- int match_bit, bit;
- match_byte <<= 1;
- match_bit = match_byte & 0x100;
- bit = Rd_decode_bit( rdec, &bm1[match_bit+symbol] );
- symbol = ( symbol << 1 ) | bit;
- if( match_bit != bit << 8 )
- {
- while( symbol < 0x100 )
- symbol = ( symbol << 1 ) | Rd_decode_bit( rdec, &bm[symbol] );
- break;
- }
+ const unsigned match_bit = ( match_byte <<= 1 ) & mask;
+ const unsigned bit = Rd_decode_bit( rdec, &bm[symbol+match_bit+mask] );
+ symbol = ( symbol << 1 ) + bit;
+ if( symbol > 0xFF ) return symbol & 0xFF;
+ mask &= ~(match_bit ^ (bit << 8)); /* if( match_bit != bit ) mask = 0; */
}
- return symbol & 0xFF;
}
-static inline int Rd_decode_len( struct Range_decoder * const rdec,
- struct Len_model * const lm,
- const int pos_state )
+static inline unsigned Rd_decode_len( struct Range_decoder * const rdec,
+ struct Len_model * const lm,
+ const int pos_state )
{
if( Rd_decode_bit( rdec, &lm->choice1 ) == 0 )
- return Rd_decode_tree( rdec, lm->bm_low[pos_state], len_low_bits );
+ return Rd_decode_tree3( rdec, lm->bm_low[pos_state] );
if( Rd_decode_bit( rdec, &lm->choice2 ) == 0 )
- return len_low_symbols +
- Rd_decode_tree( rdec, lm->bm_mid[pos_state], len_mid_bits );
- return len_low_symbols + len_mid_symbols +
- Rd_decode_tree( rdec, lm->bm_high, len_high_bits );
+ return len_low_symbols + Rd_decode_tree3( rdec, lm->bm_mid[pos_state] );
+ return len_low_symbols + len_mid_symbols + Rd_decode_tree8( rdec, lm->bm_high );
}
@@ -239,35 +234,22 @@ struct LZ_decoder
uint32_t crc;
int outfd; /* output file descriptor */
bool pos_wrapped;
-
- Bit_model bm_literal[1<<literal_context_bits][0x300];
- 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[len_states][1<<dis_slot_bits];
- Bit_model bm_dis[modeled_distances-end_dis_model];
- Bit_model bm_align[dis_align_size];
-
- struct Len_model match_len_model;
- struct Len_model rep_len_model;
};
void LZd_flush_data( struct LZ_decoder * const d );
static inline uint8_t LZd_peek_prev( const struct LZ_decoder * const d )
{
- const unsigned i = ( ( d->pos > 0 ) ? d->pos : d->dictionary_size ) - 1;
- return d->buffer[i];
+ if( d->pos > 0 ) return d->buffer[d->pos-1];
+ if( d->pos_wrapped ) return d->buffer[d->dictionary_size-1];
+ return 0; /* prev_byte of first byte */
}
static inline uint8_t LZd_peek( const struct LZ_decoder * const d,
const unsigned distance )
{
- unsigned i = d->pos - distance - 1;
- if( d->pos <= distance ) i += d->dictionary_size;
+ const unsigned i = ( ( d->pos > distance ) ? 0 : d->dictionary_size ) +
+ d->pos - distance - 1;
return d->buffer[i];
}
@@ -280,17 +262,26 @@ static inline void LZd_put_byte( struct LZ_decoder * const d, const uint8_t b )
static inline void LZd_copy_block( struct LZ_decoder * const d,
const unsigned distance, unsigned len )
{
- unsigned i = d->pos - distance - 1;
- bool fast;
- if( d->pos <= distance )
- { i += d->dictionary_size;
- fast = ( len <= d->dictionary_size - i && len <= i - d->pos ); }
+ unsigned lpos = d->pos, i = lpos - distance - 1;
+ bool fast, fast2;
+ if( lpos > distance )
+ {
+ fast = ( len < d->dictionary_size - lpos );
+ fast2 = ( fast && len <= lpos - i );
+ }
else
- fast = ( len < d->dictionary_size - d->pos && len <= d->pos - i );
- if( fast ) /* no wrap, no overlap */
{
- memcpy( d->buffer + d->pos, d->buffer + i, len );
+ i += d->dictionary_size;
+ fast = ( len < d->dictionary_size - i ); /* (i == pos) may happen */
+ fast2 = ( fast && len <= i - lpos );
+ }
+ if( fast ) /* no wrap */
+ {
d->pos += len;
+ if( fast2 ) /* no wrap, no overlap */
+ memcpy( d->buffer + lpos, d->buffer + i, len );
+ else
+ for( ; len > 0; --len ) d->buffer[lpos++] = d->buffer[i++];
}
else for( ; len > 0; --len )
{
@@ -314,20 +305,6 @@ static inline bool LZd_init( struct LZ_decoder * const d,
d->crc = 0xFFFFFFFFU;
d->outfd = ofd;
d->pos_wrapped = false;
-
- Bm_array_init( d->bm_literal[0], (1 << literal_context_bits) * 0x300 );
- Bm_array_init( d->bm_match[0], states * pos_states );
- Bm_array_init( d->bm_rep, states );
- Bm_array_init( d->bm_rep0, states );
- Bm_array_init( d->bm_rep1, states );
- Bm_array_init( d->bm_rep2, states );
- Bm_array_init( d->bm_len[0], states * pos_states );
- Bm_array_init( d->bm_dis_slot[0], len_states * (1 << dis_slot_bits) );
- Bm_array_init( d->bm_dis, modeled_distances - end_dis_model );
- Bm_array_init( d->bm_align, dis_align_size );
- Lm_init( &d->match_len_model );
- Lm_init( &d->rep_len_model );
- d->buffer[d->dictionary_size-1] = 0; /* prev_byte of first byte */
return true;
}