lzip/lzlib
1
0
Fork 0
Code Issues Activity

Adding upstream version 0.8.

Browse source 
Signed-off-by: Daniel Baumann <daniel@debian.org>
This commit is contained in:
Daniel Baumann 2025-02-20 16:18:54 +01:00
parent 37258e3901
commit f78fedc24f
Signed by: daniel
GPG key ID: FBB4F0E80A80222F
23 changed files with 1833 additions and 1235 deletions
Download patch file Download diff file Expand all files Collapse all files

98
lzcheck.cc
View file

@ -1,5 +1,5 @@
/* Lzcheck - A test program for the lzlib library
Copyright (C) 2009 Antonio Diaz Diaz.
Copyright (C) 2009, 2010 Antonio Diaz Diaz.
This program is free software: you have unlimited permission
to copy, distribute and modify it.
@ -8,9 +8,13 @@
lzcheck filename.txt
This program reads the specified text file and then compresses it,
line by line, to test the flushing mechanism.
line by line, to test the flushing mechanism and the member
restart/reset/sync functions.
*/
#define _FILE_OFFSET_BITS 64
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
@ -29,7 +33,7 @@
#define ULLONG_MAX 0xFFFFFFFFFFFFFFFFULL
#endif
const int buffer_size = 65536;
const int buffer_size = 32768;
uint8_t in_buffer[buffer_size];
uint8_t mid_buffer[buffer_size];
uint8_t out_buffer[buffer_size];
@ -54,8 +58,8 @@ int main( const int argc, const char * argv[] )
const int dictionary_size = 1 << 20;
const int match_len_limit = 80;
const long long member_size = LLONG_MAX;
void * encoder = LZ_compress_open( dictionary_size, match_len_limit,
member_size );
LZ_Encoder * encoder = LZ_compress_open( dictionary_size, match_len_limit,
member_size );
if( !encoder || LZ_compress_errno( encoder ) != LZ_ok )
{
const bool mem_error = ( LZ_compress_errno( encoder ) == LZ_mem_error );
@ -69,7 +73,7 @@ int main( const int argc, const char * argv[] )
return 3;
}
void * decoder = LZ_decompress_open();
LZ_Decoder * decoder = LZ_decompress_open();
if( !decoder || LZ_decompress_errno( decoder ) != LZ_ok )
{
LZ_decompress_close( decoder );
@ -77,35 +81,91 @@ int main( const int argc, const char * argv[] )
return 1;
}
while( true )
int retval = 0;
while( retval <= 2 )
{
const int read_size = std::fread( in_buffer, 1, buffer_size, file );
if( read_size <= 0 ) break;
const int read_size = std::fread( in_buffer, 1, buffer_size / 2, file );
if( read_size <= 0 ) break; // end of file
for( int l = 0, r = 1; r <= read_size; l = r, ++r )
{
while( r < read_size && in_buffer[r-1] != '\n' ) ++r;
const int leading_garbage = (l == 0) ? std::min( r, read_size / 2 ) : 0;
const int in_size = LZ_compress_write( encoder, in_buffer + l, r - l );
if( in_size < r - l ) r = l + in_size;
LZ_compress_sync_flush( encoder );
const int mid_size = LZ_compress_read( encoder, mid_buffer, buffer_size );
LZ_decompress_write( decoder, mid_buffer, mid_size );
const int out_size = LZ_decompress_read( decoder, out_buffer, buffer_size );
if( leading_garbage )
std::memset( mid_buffer, in_buffer[0], leading_garbage );
const int mid_size = LZ_compress_read( encoder,
mid_buffer + leading_garbage,
buffer_size - leading_garbage );
if( mid_size < 0 )
{
std::fprintf( stderr, "LZ_compress_read error: %s.\n",
LZ_strerror( LZ_compress_errno( encoder ) ) );
retval = 3; break;
}
LZ_decompress_write( decoder, mid_buffer, mid_size + leading_garbage );
int out_size = LZ_decompress_read( decoder, out_buffer, buffer_size );
if( out_size < 0 )
{
if( LZ_decompress_errno( decoder ) == LZ_header_error ||
LZ_decompress_errno( decoder ) == LZ_data_error )
{
LZ_decompress_sync_to_member( decoder ); // remove leading garbage
out_size = LZ_decompress_read( decoder, out_buffer, buffer_size );
}
if( out_size < 0 )
{
std::fprintf( stderr, "LZ_decompress_read error: %s.\n",
LZ_strerror( LZ_decompress_errno( decoder ) ) );
retval = 3; break;
}
}
if( out_size != in_size || std::memcmp( in_buffer + l, out_buffer, out_size ) )
{
std::printf( "sync error at pos %d. in_size = %d, out_size = %d\n",
l, in_size, out_size );
for( int i = 0; i < in_size; ++i ) std::putchar( in_buffer[l+i] );
if( in_buffer[l+in_size-1] != '\n' ) std::putchar( '\n' );
for( int i = 0; i < out_size; ++i ) std::putchar( out_buffer[i] );
std::putchar( '\n' );
std::fprintf( stderr, "sync error at pos %d. in_size = %d, out_size = %d\n",
l, in_size, out_size );
for( int i = 0; i < in_size; ++i )
std::fputc( in_buffer[l+i], stderr );
if( in_buffer[l+in_size-1] != '\n' )
std::fputc( '\n', stderr );
for( int i = 0; i < out_size; ++i )
std::fputc( out_buffer[i], stderr );
std::fputc( '\n', stderr );
retval = 1;
}
}
if( retval >= 3 ) break;
if( LZ_compress_finish( encoder ) < 0 ||
LZ_decompress_write( decoder, mid_buffer, LZ_compress_read( encoder, mid_buffer, buffer_size ) ) < 0 ||
LZ_decompress_read( decoder, out_buffer, buffer_size ) != 0 ||
LZ_decompress_reset( decoder ) < 0 ||
LZ_compress_restart_member( encoder, member_size ) < 0 )
{
std::fprintf( stderr, "can't restart member: %s.\n",
LZ_strerror( LZ_decompress_errno( decoder ) ) );
retval = 3; break;
}
const int size = std::min( 100, read_size );
if( LZ_compress_write( encoder, in_buffer, size ) != size ||
LZ_compress_finish( encoder ) < 0 ||
LZ_decompress_write( decoder, mid_buffer, LZ_compress_read( encoder, mid_buffer, buffer_size ) ) < 0 ||
LZ_decompress_read( decoder, out_buffer, 0 ) != 0 ||
LZ_decompress_sync_to_member( decoder ) < 0 ||
LZ_compress_restart_member( encoder, member_size ) < 0 )
{
std::fprintf( stderr, "can't seek to next member: %s.\n",
LZ_strerror( LZ_decompress_errno( decoder ) ) );
retval = 3; break;
}
}
LZ_decompress_close( decoder );
LZ_compress_close( encoder );
std::fclose( file );
return 0;
return retval;
}