int64_t lzbench_wflz_compress(char *inbuf, size_t insize, char *outbuf, size_t outsize, size_t level, size_t workmem, size_t)
{
if (level == 1)
return wfLZ_CompressFast((const uint8_t*)inbuf, insize, (uint8_t*)outbuf, (uint8_t*)workmem, 0);
return wfLZ_Compress((const uint8_t*)inbuf, insize, (uint8_t*)outbuf, (uint8_t*)workmem, 0);
}
int64_t lzbench_wflz_compress(char *inbuf, size_t insize, char *outbuf, size_t outsize, size_t level, size_t, char* workmem)
{
int64_t res;
if (!workmem)
return 0;
if (level == 0)
res = wfLZ_CompressFast((const uint8_t*)inbuf, insize, (uint8_t*)outbuf, (uint8_t*)workmem, 0);
else
res = wfLZ_Compress((const uint8_t*)inbuf, insize, (uint8_t*)outbuf, (uint8_t*)workmem, 0);
return res;
}
static SquashStatus
squash_wflz_compress_buffer (SquashCodec* codec,
size_t* compressed_size,
uint8_t compressed[SQUASH_ARRAY_PARAM(*compressed_size)],
size_t uncompressed_size,
const uint8_t uncompressed[SQUASH_ARRAY_PARAM(uncompressed_size)],
SquashOptions* options) {
const char* codec_name = squash_codec_get_name (codec);
const uint32_t swap = ((uint32_t) squash_options_get_int_at (options, codec, SQUASH_WFLZ_OPT_ENDIANNESS) != SQUASH_WFLZ_HOST_ORDER);
const int level = squash_options_get_int_at (options, codec, SQUASH_WFLZ_OPT_LEVEL);
#if UINT32_MAX < SIZE_MAX
if (SQUASH_UNLIKELY(UINT32_MAX < uncompressed_size))
return squash_error (SQUASH_RANGE);
#endif
if (*compressed_size < wfLZ_GetMaxCompressedSize ((uint32_t) uncompressed_size)) {
return squash_error (SQUASH_BUFFER_FULL);
}
uint8_t* work_mem = (uint8_t*) malloc (wfLZ_GetWorkMemSize ());
uint32_t wres;
if (codec_name[4] == '\0') {
if (level == 1) {
wres = wfLZ_CompressFast (uncompressed, (uint32_t) uncompressed_size,
compressed, work_mem, swap);
} else {
wres = wfLZ_Compress (uncompressed, (uint32_t) uncompressed_size,
compressed, work_mem, swap);
}
} else {
wres =
wfLZ_ChunkCompress ((uint8_t*) uncompressed, (uint32_t) uncompressed_size,
squash_options_get_size_at (options, codec, SQUASH_WFLZ_OPT_CHUNK_SIZE),
compressed, work_mem, swap, level == 1 ? 1 : 0);
}
#if SIZE_MAX < UINT32_MAX
if (SQUASH_UNLIKELY(SIZE_MAX < wres)) {
free (work_mem);
return squash_error (SQUASH_RANGE);
}
#endif
*compressed_size = (size_t) wres;
free (work_mem);
return SQUASH_LIKELY(*compressed_size > 0) ? SQUASH_OK : squash_error (SQUASH_FAILED);
}
//--
static
ERL_NIF_TERM
nif_compress(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
ErlNifBinary input;
if(!enif_inspect_iolist_as_binary(env, argv[0], &input))
{
return(enif_make_badarg(env));
}
ErlNifBinary bin;
// [rad] Figure out maximum compression buffer size.
uint32_t compressed_bytes = wfLZ_GetMaxCompressedSize(input.size);
// [rad] Get size of recommended scratchpad.
uint32_t scratchpad_bytes = wfLZ_GetWorkMemSize();
if(!enif_alloc_binary(compressed_bytes, &bin))
{
return(erlang_produce_error(env, "not_enough_memory"));
}
// [rad] Allocate scratchpad buffer.
uint8_t* scratchpad = malloc(scratchpad_bytes);
// [rad] Perform compression.
uint32_t data_comp_size = wfLZ_Compress((const uint8_t* const) input.data, input.size, (uint8_t* const) bin.data, (const uint8_t*) scratchpad, 0);
// [rad] We no longer need scratchpad.
free(scratchpad);
if(!data_comp_size)
{
return(erlang_produce_error(env, "compression_error"));
}
if(!enif_realloc_binary(&bin, data_comp_size))
{
return(erlang_produce_error(env, "not_enough_memory"));
}
return(enif_make_binary(env, &bin));
}
