/* 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; }