44 blosc_set_nthreads(std::thread::hardware_concurrency());
49 blosc_set_compressor(BLOSC_LZ4HC_COMPNAME);
58 const uint8_t* buffer,
59 const size_t buffer_size,
60 uint8_t* compressed_buffer,
61 const size_t compressed_buffer_size,
63 if (compressed_buffer_size < BLOSC_MIN_HEADER_LENGTH) {
74 if (buffer_size < min_compressor_bytes && min_compressor_bytes != 0) {
78 const auto compressed_len = blosc_compress(5,
80 sizeof(
unsigned char),
83 &compressed_buffer[0],
84 compressed_buffer_size);
86 if (compressed_len <= 0) {
96 return compressed_len;
100 const auto buffer_size = buffer.size();
103 const size_t compressed_len =
compress((uint8_t*)buffer.c_str(),
105 &compressed_buffer[0],
107 if (compressed_len > 0 && compressed_len < buffer_size) {
112 compressed_buffer.resize(compressed_len);
113 return {compressed_buffer.begin(), compressed_buffer.end()};
121 uint8_t* decompressed_buffer,
122 const size_t decompressed_size) {
123 size_t decompressed_buf_len, compressed_buf_len, block_size, decompressed_len = 0;
125 &compressed_buffer[0], &compressed_buf_len, &decompressed_buf_len, &block_size);
127 if (compressed_buf_len > 0 && decompressed_size == decompressed_buf_len) {
130 blosc_decompress(&compressed_buffer[0], decompressed_buffer, decompressed_size);
133 if (decompressed_len == 0) {
135 std::string(
"failed to decompress buffer for compressed size: ") +
138 if (decompressed_len != decompressed_size) {
140 std::string(
"decompression buffer size mismatch. Decompressed buffer length: ") +
143 return decompressed_len;
147 const size_t decompressed_size) {
148 std::vector<uint8_t> decompressed_buffer(decompressed_size);
149 if (buffer.size() == decompressed_size) {
154 (uint8_t*)&buffer[0], (uint8_t*)&decompressed_buffer[0], decompressed_size);
155 return {decompressed_buffer.begin(), decompressed_buffer.end()};
162 uint8_t* output_buffer,
163 size_t uncompressed_size,
164 const size_t min_compressor_bytes) {
166 const auto compressed_size =
compress(input_buffer,
170 min_compressor_bytes);
171 if (compressed_size > 0) {
172 return compressed_size;
177 if (uncompressed_size > min_compressor_bytes) {
178 LOG(
WARNING) <<
"Compressor failed for byte size of " << uncompressed_size;
181 memcpy(output_buffer, input_buffer, uncompressed_size);
182 return uncompressed_size;
186 const size_t compressed_size,
187 uint8_t* decompressed_buffer,
188 const size_t decompressed_size) {
190 decompress(compressed_buffer, decompressed_buffer, decompressed_size);
195 if (compressed_size > decompressed_size) {
196 throw std::runtime_error(
197 "compressed buffer size is greater than decompressed buffer size.");
200 memcpy(decompressed_buffer, compressed_buffer, decompressed_size);
205 size_t* num_bytes_compressed,
206 size_t* num_bytes_uncompressed,
207 size_t* block_size) {
208 blosc_cbuffer_sizes(data_ptr, num_bytes_uncompressed, num_bytes_compressed, block_size);
214 static std::mutex compressor_singleton_lock;
215 std::lock_guard<std::mutex> singleton_lock(compressor_singleton_lock);
225 return blosc_set_nthreads(static_cast<int>(num_threads));
233 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++ wrapper over a pure C librar...
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