static VALUE rubylz4_raw_compress(VALUE self, VALUE input, VALUE compression_level_value)
{
Check_Type(input, RUBY_T_STRING);
const char* input_data = RSTRING_PTR(input);
int input_size = RSTRING_LEN(input);
Check_Type(compression_level_value, RUBY_T_FIXNUM);
int compression_level = FIX2INT(compression_level_value);
// do compress
int max_compressed_size = LZ4_compressBound(input_size);
VALUE output = rb_str_new(NULL, max_compressed_size);
char* output_data = RSTRING_PTR(output);
int compressed_size = LZ4_compress_fast(input_data, output_data,
input_size, max_compressed_size,
compression_level);
if (compressed_size == 0) {
rb_raise(rb_eRuntimeError, "%s", "compress failed");
} else {
rb_str_resize(output, compressed_size);
return output;
}
}
int main() {
const char* source = "";
char* dest = 0;
int sourceSize = 0;
int maxDestSize = 0;
int acceleration = 0;
const int result = LZ4_compress_fast (source, dest, sourceSize, maxDestSize, acceleration);
return result;
}
static SquashStatus
squash_lz4_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) {
int level = squash_codec_get_option_int_index (codec, options, SQUASH_LZ4_OPT_LEVEL);
#if INT_MAX < SIZE_MAX
if (SQUASH_UNLIKELY(INT_MAX < uncompressed_size) ||
SQUASH_UNLIKELY(INT_MAX < *compressed_size))
return squash_error (SQUASH_RANGE);
#endif
int lz4_r;
if (level == 7) {
lz4_r = LZ4_compress_limitedOutput ((char*) uncompressed,
(char*) compressed,
(int) uncompressed_size,
(int) *compressed_size);
} else if (level < 7) {
lz4_r = LZ4_compress_fast ((const char*) uncompressed,
(char*) compressed,
(int) uncompressed_size,
(int) *compressed_size,
squash_lz4_level_to_fast_mode (level));
} else if (level < 17) {
lz4_r = LZ4_compressHC2_limitedOutput ((char*) uncompressed,
(char*) compressed,
(int) uncompressed_size,
(int) *compressed_size,
squash_lz4_level_to_hc_level (level));
} else {
squash_assert_unreachable();
}
#if SIZE_MAX < INT_MAX
if (SQUASH_UNLIKELY(SIZE_MAX < lz4_r))
return squash_error (SQUASH_RANGE);
#endif
*compressed_size = lz4_r;
return SQUASH_UNLIKELY(lz4_r == 0) ? squash_error (SQUASH_BUFFER_FULL) : SQUASH_OK;
}
void TestUnitCompression::testLz4()
{
int32_t size=LZ4_compress_fast(text.data(),buffer,text.size(),sizeof(buffer),6);
if(size<=0 || (uint32_t)size>(text.size()+text.size()/10))
{
std::cerr << "compress Lz4: Failed" << std::endl;
finalResult=false;
return;
}
else
std::cout << "compress Lz4: Ok, ratio: " << size << "/" << text.size() << "=" << ((float)text.size()/(float)size) << std::endl;
int32_t size2=LZ4_decompress_safe(buffer,buffer2,size,sizeof(buffer2));
if(size2!=(int32_t)text.size() || buffer2!=text)
{
std::cerr << "decompress Lz4: Failed" << std::endl;
finalResult=false;
return;
}
else
std::cout << "decompress Lz4: Ok" << std::endl;
}
void SaveLz4(const Image<unsigned char>& image, const pangolin::PixelFormat& fmt, std::ostream& out, int compression_level)
{
#ifdef HAVE_LZ4
const int64_t src_size = image.SizeBytes();
const int64_t max_dst_size = LZ4_compressBound(src_size);
std::unique_ptr<char[]> output_buffer(new char[max_dst_size]);
// Same as LZ4_compress_default(), but allows to select an "acceleration" factor.
// The larger the acceleration value, the faster the algorithm, but also the lesser the compression.
// It's a trade-off. It can be fine tuned, with each successive value providing roughly +~3% to speed.
// An acceleration value of "1" is the same as regular LZ4_compress_default()
// Values <= 0 will be replaced by ACCELERATION_DEFAULT (see lz4.c), which is 1.
const int64_t compressed_data_size = LZ4_compress_fast((char*)image.ptr, output_buffer.get(), src_size, max_dst_size, compression_level);
if (compressed_data_size < 0)
throw std::runtime_error("A negative result from LZ4_compress_default indicates a failure trying to compress the data.");
if (compressed_data_size == 0)
throw std::runtime_error("A result of 0 for LZ4 means compression worked, but was stopped because the destination buffer couldn't hold all the information.");
lz4_image_header header;
strncpy(header.magic,"LZ4",3);
strncpy(header.fmt, fmt.format.c_str(), sizeof(header.fmt));
header.w = image.w;
header.h = image.h;
header.compressed_size = compressed_data_size;
out.write((char*)&header, sizeof(header));
out.write(output_buffer.get(), compressed_data_size);
#else
PANGOLIN_UNUSED(image);
PANGOLIN_UNUSED(fmt);
PANGOLIN_UNUSED(out);
PANGOLIN_UNUSED(compression_level);
throw std::runtime_error("Rebuild Pangolin for LZ4 support.");
#endif // HAVE_LZ4
}
int64_t lzbench_lz4fast_compress(char *inbuf, size_t insize, char *outbuf, size_t outsize, size_t level, size_t, char*)
{
return LZ4_compress_fast(inbuf, outbuf, insize, outsize, level);
}
void Message::compress(Message::Compression type, int level) {
if (isCompressed())
return;
switch (type) {
#ifdef BUILD_WITH_COMPRESSION_MINIZ
case COMPRESS_MINIZ: {
mz_ulong compressedSize = mz_compressBound(_size);
int cmp_status;
uint8_t *pCmp;
pCmp = (mz_uint8 *)malloc((size_t)compressedSize);
level = (level >= 0 ? level : BUILD_WITH_COMPRESSION_LEVEL_MINIZ);
// last argument is speed size tradeoff: BEST_SPEED [0-9] BEST_COMPRESSION
cmp_status = mz_compress2(pCmp, &compressedSize, (const unsigned char *)_data.get(), _size, level);
if (cmp_status != Z_OK) {
// error
free(pCmp);
}
_data = SharedPtr<char>((char*)pCmp);
_meta["um.compressed"] = toStr(_size) + ":miniz";
_size = compressedSize;
}
return;
#endif
#ifdef BUILD_WITH_COMPRESSION_FASTLZ
case COMPRESS_FASTLZ: {
// The minimum input buffer size is 16.
if (_size < 16)
return;
// The output buffer must be at least 5% larger than the input buffer and can not be smaller than 66 bytes.
int compressedSize = _size + (double)_size * 0.06;
if (compressedSize < 66)
compressedSize = 66;
char* compressedData = (char*)malloc(compressedSize);
compressedSize = fastlz_compress(_data.get(), _size, compressedData);
// If the input is not compressible, the return value might be larger than length
if (compressedSize > _size) {
free(compressedData);
return;
}
// std::cout << _size << " -> " << compressedSize << " = " << ((float)compressedSize / (float)_size) << std::endl;
_data = SharedPtr<char>((char*)compressedData);
_meta["um.compressed"] = toStr(_size) + ":fastlz";
_size = compressedSize;
}
return;
#endif
#ifdef BUILD_WITH_COMPRESSION_LZ4
case COMPRESS_LZ4: {
level = (level >= 0 ? level : BUILD_WITH_COMPRESSION_LEVEL_LZ4);
#ifdef LZ4_FRAME
LZ4F_preferences_t lz4_preferences = {
{ LZ4F_max256KB, LZ4F_blockLinked, LZ4F_noContentChecksum, LZ4F_frame, 0, { 0, 0 } },
level, /* compression level */
0, /* autoflush */
{ 0, 0, 0, 0 }, /* reserved, must be set to 0 */
};
LZ4F_errorCode_t r;
LZ4F_compressionContext_t ctx;
r = LZ4F_createCompressionContext(&ctx, LZ4F_VERSION);
if (LZ4F_isError(r)) {
// printf("Failed to create context: error %zu", r);
return;
}
#define LZ4_HEADER_SIZE 19
#define LZ4_FOOTER_SIZE 4
size_t n, offset = 0;
size_t frameSize = LZ4F_compressBound(_size, &lz4_preferences);
size_t compressedSize = frameSize + LZ4_HEADER_SIZE + LZ4_FOOTER_SIZE;
char* compressedData = (char*)malloc(compressedSize);
n = LZ4F_compressBegin(ctx, compressedData, compressedSize, &lz4_preferences);
if (LZ4F_isError(n)) {
// printf("Failed to start compression: error %zu", n);
LZ4F_freeCompressionContext(ctx);
free(compressedData);
return;
}
offset += n;
n = LZ4F_compressUpdate(ctx, compressedData + offset, compressedSize - offset, _data.get(), _size, NULL);
if (LZ4F_isError(n)) {
// printf("Compression failed: error %zu", n);
LZ4F_freeCompressionContext(ctx);
free(compressedData);
return;
}
offset += n;
n = LZ4F_compressEnd(ctx, compressedData + offset, compressedSize - offset, NULL);
if (LZ4F_isError(n)) {
// printf("Failed to end compression: error %zu", n);
LZ4F_freeCompressionContext(ctx);
free(compressedData);
return;
}
offset += n;
_data = SharedPtr<char>((char*)compressedData);
_meta["um.compressed"] = toStr(_size) + ":lz4";
_size = offset;
LZ4F_freeCompressionContext(ctx);
#else
size_t compressedSize = LZ4_compressBound(_size);
char* compressedData = (char*)malloc(compressedSize);
int actualSize = 0;
actualSize = LZ4_compress_fast(_data.get(), compressedData, _size, compressedSize, level);
if (actualSize == 0) {
free(compressedData);
return;
}
_data = SharedPtr<char>((char*)compressedData);
_meta["um.compressed"] = toStr(_size) + ":lz4";
_size = actualSize;
#endif
}
return;
#endif
default:
break;
}
}
