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