/* 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, uint8_t * new_data,
int * const out_sizep, int dicsize, int max_len )
{
const int match_len_limit = max_len;
const long long member_size = LLONG_MAX;
int dict_size = 1<<dicsize;
if( dict_size > size ) dict_size = size; /* saves memory */
if( dict_size < LZ_min_dictionary_size() )
dict_size = LZ_min_dictionary_size();
struct LZ_Encoder * const encoder =
LZ_compress_open( dict_size, match_len_limit, member_size );
if( !encoder || LZ_compress_errno( encoder ) != LZ_ok )
{ LZ_compress_close( encoder ); return 0; }
//const int delta_size = (size < 256) ? 64 : size / 4; /* size may be zero */
int new_data_size = size; //delta_size; /* initial size */
//uint8_t * new_data = (uint8_t *)malloc( new_data_size );
//if( !new_data ) { LZ_compress_close( encoder ); return 0; }
int new_pos = 0;
int written = 0;
bool error = false;
while( true )
{
if( LZ_compress_write_size( encoder ) > 0 )
{
if( written < size )
{
const int wr = LZ_compress_write( encoder, data + written,
size - written );
if( wr < 0 ) { error = true; break; }
written += wr;
}
if( written >= size ) LZ_compress_finish( encoder );
}
const int rd = LZ_compress_read( encoder, new_data + new_pos,
new_data_size - new_pos );
if( rd < 0 ) { error = true; break; }
new_pos += rd;
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 );
if( !tmp ) { error = true; break; }
new_data = tmp;
new_data_size += delta_size;
}*/
}
if( LZ_compress_close( encoder ) < 0 ) error = true;
if( error ) { /*free( new_data );*/ return 0; }
*out_sizep = new_pos;
return new_data;
}
int64_t lzbench_lzlib_compress(char *inbuf, size_t insize, char *outbuf, size_t outsize, size_t level, size_t, char*)
{
struct Lzma_options
{
int dictionary_size; /* 4 KiB .. 512 MiB */
int match_len_limit; /* 5 .. 273 */
};
const struct Lzma_options option_mapping[10] = {
{ 65535, 16 }, /* -0 */
{ 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 LZ_Encoder * encoder;
const int match_len_limit = option_mapping[level].match_len_limit;
const unsigned long long member_size = 0x7FFFFFFFFFFFFFFFULL; /* INT64_MAX */
int new_pos = 0;
int written = 0;
bool error = false;
int dict_size = option_mapping[level].dictionary_size;
uint8_t *buf = (uint8_t*)inbuf;
uint8_t *obuf = (uint8_t*)outbuf;
if( dict_size > insize ) dict_size = insize; /* 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( !encoder || LZ_compress_errno( encoder ) != LZ_ok )
{ LZ_compress_close( encoder ); return 0; }
while( true )
{
int rd;
if( LZ_compress_write_size( encoder ) > 0 )
{
if( written < insize )
{
const int wr = LZ_compress_write( encoder, buf + written, insize - written );
if( wr < 0 ) { error = true; break; }
written += wr;
}
if( written >= insize ) LZ_compress_finish( encoder );
}
rd = LZ_compress_read( encoder, obuf + new_pos, outsize - new_pos );
if( rd < 0 ) { error = true; break; }
new_pos += rd;
if( LZ_compress_finished( encoder ) == 1 ) break;
}
if( LZ_compress_close( encoder ) < 0 ) error = true;
if (error) return 0;
return new_pos;
}
