40 blosc_set_nthreads(std::thread::hardware_concurrency());
45 blosc_set_compressor(BLOSC_LZ4HC_COMPNAME);
54 const uint8_t* buffer,
55 const size_t buffer_size,
56 uint8_t* compressed_buffer,
57 const size_t compressed_buffer_size,
59 if (buffer_size < min_compressor_bytes && min_compressor_bytes != 0) {
63 const auto compressed_len = blosc_compress(5,
65 sizeof(
unsigned char),
68 &compressed_buffer[0],
69 compressed_buffer_size);
71 if (compressed_len <= 0) {
82 return compressed_len;
86 const auto buffer_size = buffer.size();
89 const size_t compressed_len =
compress((uint8_t*)buffer.c_str(),
91 &compressed_buffer[0],
93 if (compressed_len > 0 && compressed_len < buffer_size) {
98 compressed_buffer.resize(compressed_len);
99 return {compressed_buffer.begin(), compressed_buffer.end()};
108 uint8_t* decompressed_buffer,
109 const size_t decompressed_size) {
110 size_t decompressed_buf_len, compressed_buf_len, block_size, decompressed_len = 0;
112 &compressed_buffer[0], &compressed_buf_len, &decompressed_buf_len, &block_size);
114 if (compressed_buf_len > 0 && decompressed_size == decompressed_buf_len) {
117 blosc_decompress(&compressed_buffer[0], decompressed_buffer, decompressed_size);
120 if (decompressed_len == 0) {
122 std::string(
"failed to decompress buffer for compressed size: ") +
125 if (decompressed_len != decompressed_size) {
127 std::string(
"decompression buffer size mismatch. Decompressed buffer length: ") +
130 return decompressed_len;
134 const size_t decompressed_size) {
135 std::vector<uint8_t> decompressed_buffer(decompressed_size);
136 if (buffer.size() == decompressed_size) {
141 (uint8_t*)&buffer[0], (uint8_t*)&decompressed_buffer[0], decompressed_size);
142 return {decompressed_buffer.begin(), decompressed_buffer.end()};
149 uint8_t* output_buffer,
150 size_t uncompressed_size,
151 const size_t min_compressor_bytes) {
153 const auto compressed_size =
compress(input_buffer,
157 min_compressor_bytes);
158 if (compressed_size > 0) {
159 return compressed_size;
164 if (uncompressed_size > min_compressor_bytes) {
165 LOG(
WARNING) <<
"Compressor failed for byte size of " << uncompressed_size;
168 memcpy(output_buffer, input_buffer, uncompressed_size);
169 return uncompressed_size;
173 const size_t compressed_size,
174 uint8_t* decompressed_buffer,
175 const size_t decompressed_size) {
177 decompress(compressed_buffer, decompressed_buffer, decompressed_size);
182 if (compressed_size > decompressed_size) {
183 throw std::runtime_error(
184 "compressed buffer size is greater than decompressed buffer size.");
187 memcpy(decompressed_buffer, compressed_buffer, decompressed_size);
192 size_t* num_bytes_compressed,
193 size_t* num_bytes_uncompressed,
194 size_t* block_size) {
195 blosc_cbuffer_sizes(data_ptr, num_bytes_uncompressed, num_bytes_compressed, block_size);
201 static std::mutex compressor_singleton_lock;
202 std::lock_guard<std::mutex> singleton_lock(compressor_singleton_lock);
213 return blosc_set_nthreads(num_threads);
221 return blosc_set_compressor(compressor_name.c_str());
int setThreads(size_t num_threads)
size_t decompress(const uint8_t *compressed_buffer, uint8_t *decompressed_buffer, const size_t decompressed_size)
size_t getScratchSpaceSize(const size_t len) const
int setCompressor(std::string &compressor)
size_t g_compression_limit_bytes
size_t compressOrMemcpy(const uint8_t *input_buffer, uint8_t *output_buffer, const size_t uncompressed_size, const size_t min_compressor_bytes)
singleton class to handle concurrancy and state for blosc library. A C++ wraper over a pure C library...
std::mutex compressor_lock
bool decompressOrMemcpy(const uint8_t *compressed_buffer, const size_t compressed_buffer_size, uint8_t *decompressed_buffer, const size_t decompressed_size)
void getBloscBufferSizes(const uint8_t *data_ptr, size_t *num_bytes_compressed, size_t *num_bytes_uncompressed, size_t *block_size)
static BloscCompressor * getCompressor()
int64_t compress(const uint8_t *buffer, const size_t buffer_size, uint8_t *compressed_buffer, const size_t compressed_buffer_size, const size_t min_compressor_bytes)
static BloscCompressor * instance