summaryrefslogtreecommitdiffstats
path: root/bbexample.c
diff options
context:
space:
mode:
Diffstat (limited to 'bbexample.c')
-rw-r--r--bbexample.c199
1 files changed, 129 insertions, 70 deletions
diff --git a/bbexample.c b/bbexample.c
index 3737f97..6b1352b 100644
--- a/bbexample.c
+++ b/bbexample.c
@@ -1,5 +1,5 @@
-/* Buff to buff example - Test program for the lzlib library
- Copyright (C) 2010-2015 Antonio Diaz Diaz.
+/* Buffer to buffer example - Test program for the lzlib library
+ Copyright (C) 2010-2016 Antonio Diaz Diaz.
This program is free software: you have unlimited permission
to copy, distribute and modify it.
@@ -11,6 +11,8 @@
compression/decompression can be implemented using lzlib.
*/
+#include <errno.h>
+#include <limits.h>
#ifndef __cplusplus
#include <stdbool.h>
#endif
@@ -23,33 +25,102 @@
#include "lzlib.h"
+/* Returns the address of a malloc'd buffer containing the file data and
+ its size in '*size'.
+ In case of error, returns 0 and does not modify '*size'.
+*/
+uint8_t * read_file( const char * const name, long * const size )
+ {
+ long buffer_size = 1 << 20, file_size;
+ uint8_t * buffer, * tmp;
+ FILE * const f = fopen( name, "rb" );
+ if( !f )
+ {
+ fprintf( stderr, "bbexample: Can't open input file '%s': %s\n",
+ name, strerror( errno ) );
+ return 0;
+ }
+
+ buffer = (uint8_t *)malloc( buffer_size );
+ if( !buffer )
+ { fputs( "bbexample: Not enough memory.\n", stderr ); return 0; }
+ file_size = fread( buffer, 1, buffer_size, f );
+ while( file_size >= buffer_size )
+ {
+ if( buffer_size >= LONG_MAX )
+ {
+ fprintf( stderr, "bbexample: Input file '%s' is too large.\n", name );
+ free( buffer ); return 0;
+ }
+ buffer_size = ( buffer_size <= LONG_MAX / 2 ) ? 2 * buffer_size : LONG_MAX;
+ tmp = (uint8_t *)realloc( buffer, buffer_size );
+ if( !tmp )
+ { fputs( "bbexample: Not enough memory.\n", stderr );
+ free( buffer ); return 0; }
+ buffer = tmp;
+ file_size += fread( buffer + file_size, 1, buffer_size - file_size, f );
+ }
+ if( ferror( f ) || !feof( f ) )
+ {
+ fprintf( stderr, "bbexample: Error reading file '%s': %s\n",
+ name, strerror( errno ) );
+ free( buffer ); return 0;
+ }
+ fclose( f );
+ *size = file_size;
+ return buffer;
+ }
+
+
/* Compresses 'size' bytes from 'data'. Returns the address of a
malloc'd buffer containing the compressed data and its size in
'*out_sizep'.
In case of error, returns 0 and does not modify '*out_sizep'.
*/
-uint8_t * bbcompress( const uint8_t * const data, const int size,
- int * const out_sizep )
+uint8_t * bbcompress( const uint8_t * const data, const long size,
+ const int level, long * const out_sizep )
{
+ struct Lzma_options
+ {
+ int dictionary_size; /* 4 KiB .. 512 MiB */
+ int match_len_limit; /* 5 .. 273 */
+ };
+ /* Mapping from gzip/bzip2 style 1..9 compression modes
+ to the corresponding LZMA compression modes. */
+ const struct Lzma_options option_mapping[] =
+ {
+ { 65535, 16 }, /* -0 (65535,16 chooses fast encoder) */
+ { 1 << 20, 5 }, /* -1 */
+ { 3 << 19, 6 }, /* -2 */
+ { 1 << 21, 8 }, /* -3 */
+ { 3 << 20, 12 }, /* -4 */
+ { 1 << 22, 20 }, /* -5 */
+ { 1 << 23, 36 }, /* -6 */
+ { 1 << 24, 68 }, /* -7 */
+ { 3 << 23, 132 }, /* -8 */
+ { 1 << 25, 273 } }; /* -9 */
+ struct Lzma_options encoder_options;
+ const unsigned long long member_size = 0x7FFFFFFFFFFFFFFFULL; /* INT64_MAX */
struct LZ_Encoder * encoder;
uint8_t * new_data;
- const int match_len_limit = 36;
- const unsigned long long member_size = 0x7FFFFFFFFFFFFFFFULL; /* INT64_MAX */
- int delta_size, new_data_size;
- int new_pos = 0;
- int written = 0;
+ const long delta_size = ( size / 4 ) + 64; /* size may be zero */
+ long new_data_size = delta_size; /* initial size */
+ long new_pos = 0;
+ long written = 0;
bool error = false;
- int dict_size = 8 << 20; /* 8 MiB */
- if( dict_size > size ) dict_size = size; /* saves memory */
- if( dict_size < LZ_min_dictionary_size() )
- dict_size = LZ_min_dictionary_size();
- encoder = LZ_compress_open( dict_size, match_len_limit, member_size );
+ if( level < 0 || level > 9 ) return 0;
+ encoder_options = option_mapping[level];
+
+ if( encoder_options.dictionary_size > size && level != 0 )
+ encoder_options.dictionary_size = size; /* saves memory */
+ if( encoder_options.dictionary_size < LZ_min_dictionary_size() )
+ encoder_options.dictionary_size = LZ_min_dictionary_size();
+ encoder = LZ_compress_open( encoder_options.dictionary_size,
+ encoder_options.match_len_limit, member_size );
if( !encoder || LZ_compress_errno( encoder ) != LZ_ok )
{ LZ_compress_close( encoder ); return 0; }
- delta_size = (size < 256) ? 64 : size / 4; /* size may be zero */
- new_data_size = delta_size; /* initial size */
new_data = (uint8_t *)malloc( new_data_size );
if( !new_data )
{ LZ_compress_close( encoder ); return 0; }
@@ -75,11 +146,12 @@ uint8_t * bbcompress( const uint8_t * const data, const int size,
if( LZ_compress_finished( encoder ) == 1 ) break;
if( new_pos >= new_data_size )
{
- uint8_t * const tmp =
- (uint8_t *)realloc( new_data, new_data_size + delta_size );
+ uint8_t * tmp;
+ if( new_data_size > LONG_MAX - delta_size ) { error = true; break; }
+ new_data_size += delta_size;
+ tmp = (uint8_t *)realloc( new_data, new_data_size );
if( !tmp ) { error = true; break; }
new_data = tmp;
- new_data_size += delta_size;
}
}
@@ -95,15 +167,15 @@ uint8_t * bbcompress( const uint8_t * const data, const int size,
'*out_sizep'.
In case of error, returns 0 and does not modify '*out_sizep'.
*/
-uint8_t * bbdecompress( const uint8_t * const data, const int size,
- int * const out_sizep )
+uint8_t * bbdecompress( const uint8_t * const data, const long size,
+ long * const out_sizep )
{
struct LZ_Decoder * const decoder = LZ_decompress_open();
uint8_t * new_data;
- const int delta_size = size; /* size must be > zero */
- int new_data_size = delta_size; /* initial size */
- int new_pos = 0;
- int written = 0;
+ const long delta_size = size; /* size must be > zero */
+ long new_data_size = delta_size; /* initial size */
+ long new_pos = 0;
+ long written = 0;
bool error = false;
if( !decoder || LZ_decompress_errno( decoder ) != LZ_ok )
{ LZ_decompress_close( decoder ); return 0; }
@@ -133,11 +205,12 @@ uint8_t * bbdecompress( const uint8_t * const data, const int size,
if( LZ_decompress_finished( decoder ) == 1 ) break;
if( new_pos >= new_data_size )
{
- uint8_t * const tmp =
- (uint8_t *)realloc( new_data, new_data_size + delta_size );
+ uint8_t * tmp;
+ if( new_data_size > LONG_MAX - delta_size ) { error = true; break; }
+ new_data_size += delta_size;
+ tmp = (uint8_t *)realloc( new_data, new_data_size );
if( !tmp ) { error = true; break; }
new_data = tmp;
- new_data_size += delta_size;
}
}
@@ -150,10 +223,9 @@ uint8_t * bbdecompress( const uint8_t * const data, const int size,
int main( const int argc, const char * const argv[] )
{
- FILE * file;
- uint8_t * in_buffer, * mid_buffer, * out_buffer;
- const int in_buffer_size = 1 << 20;
- int in_size, mid_size = 0, out_size = 0;
+ uint8_t * in_buffer;
+ long in_size = 0;
+ int level;
if( argc < 2 )
{
@@ -161,51 +233,38 @@ int main( const int argc, const char * const argv[] )
return 1;
}
- file = fopen( argv[1], "rb" );
- if( !file )
- {
- fprintf( stderr, "bbexample: Can't open file '%s' for reading.\n", argv[1] );
- return 1;
- }
+ in_buffer = read_file( argv[1], &in_size );
+ if( !in_buffer ) return 1;
- in_buffer = (uint8_t *)malloc( in_buffer_size );
- if( !in_buffer )
+ for( level = 0; level <= 9; ++level )
{
- fputs( "bbexample: Not enough memory.\n", stderr );
- return 1;
- }
+ uint8_t * mid_buffer, * out_buffer;
+ long mid_size = 0, out_size = 0;
- in_size = fread( in_buffer, 1, in_buffer_size, file );
- if( in_size >= in_buffer_size )
- {
- fprintf( stderr, "bbexample: Input file '%s' is too big.\n", argv[1] );
- return 1;
- }
- fclose( file );
+ mid_buffer = bbcompress( in_buffer, in_size, level, &mid_size );
+ if( !mid_buffer )
+ {
+ fputs( "bbexample: Not enough memory or compress error.\n", stderr );
+ return 1;
+ }
- mid_buffer = bbcompress( in_buffer, in_size, &mid_size );
- if( !mid_buffer )
- {
- fputs( "bbexample: Not enough memory or compress error.\n", stderr );
- return 1;
- }
+ out_buffer = bbdecompress( mid_buffer, mid_size, &out_size );
+ if( !out_buffer )
+ {
+ fputs( "bbexample: Not enough memory or decompress error.\n", stderr );
+ return 1;
+ }
- out_buffer = bbdecompress( mid_buffer, mid_size, &out_size );
- if( !out_buffer )
- {
- fputs( "bbexample: Not enough memory or decompress error.\n", stderr );
- return 1;
- }
+ if( in_size != out_size ||
+ ( in_size > 0 && memcmp( in_buffer, out_buffer, in_size ) != 0 ) )
+ {
+ fputs( "bbexample: Decompressed data differs from original.\n", stderr );
+ return 1;
+ }
- if( in_size != out_size ||
- ( in_size > 0 && memcmp( in_buffer, out_buffer, in_size ) != 0 ) )
- {
- fputs( "bbexample: Decompressed data differs from original.\n", stderr );
- return 1;
+ free( out_buffer );
+ free( mid_buffer );
}
-
- free( out_buffer );
- free( mid_buffer );
free( in_buffer );
return 0;
}