void ZlibCompressor::Compress(std::string& compressed,
const void* uncompressed,
size_t uncompressedSize)
{
if (uncompressedSize == 0)
{
compressed.clear();
return;
}
uLongf compressedSize = compressBound(uncompressedSize) + 1024 /* security margin */;
if (compressedSize == 0)
{
compressedSize = 1;
}
uint8_t* target;
if (HasPrefixWithUncompressedSize())
{
compressed.resize(compressedSize + sizeof(uint64_t));
target = reinterpret_cast<uint8_t*>(&compressed[0]) + sizeof(uint64_t);
}
else
{
compressed.resize(compressedSize);
target = reinterpret_cast<uint8_t*>(&compressed[0]);
}
int error = compress2(target,
&compressedSize,
const_cast<Bytef *>(static_cast<const Bytef *>(uncompressed)),
uncompressedSize,
GetCompressionLevel());
if (error != Z_OK)
{
compressed.clear();
switch (error)
{
case Z_MEM_ERROR:
throw OrthancException(ErrorCode_NotEnoughMemory);
default:
throw OrthancException(ErrorCode_InternalError);
}
}
// The compression was successful
if (HasPrefixWithUncompressedSize())
{
uint64_t s = static_cast<uint64_t>(uncompressedSize);
memcpy(&compressed[0], &s, sizeof(uint64_t));
compressed.resize(compressedSize + sizeof(uint64_t));
}
else
{
compressed.resize(compressedSize);
}
}
std::unique_ptr<reflectionzeug::PropertyGroup> CanvasExporterPNG::createPropertyGroup()
{
auto group = CanvasExporterImages::createPropertyGroup();
auto pngWriter = static_cast<vtkPNGWriter *>(m_writer.Get());
group->addProperty<int>("CompressionLevel",
[pngWriter] () { return pngWriter->GetCompressionLevel(); },
[pngWriter] (int level) { pngWriter->SetCompressionLevel(level); })
->setOptions({
{ "title", "Compression Level" },
{ "minimum", pngWriter->GetCompressionLevelMinValue() },
{ "maximum", pngWriter->GetCompressionLevelMaxValue() }
});
return group;
}
void GzipCompressor::Compress(std::string& compressed,
const void* uncompressed,
size_t uncompressedSize)
{
uLongf compressedSize = compressBound(uncompressedSize) + 1024 /* security margin */;
if (compressedSize == 0)
{
compressedSize = 1;
}
uint8_t* target;
if (HasPrefixWithUncompressedSize())
{
compressed.resize(compressedSize + sizeof(uint64_t));
target = reinterpret_cast<uint8_t*>(&compressed[0]) + sizeof(uint64_t);
}
else
{
compressed.resize(compressedSize);
target = reinterpret_cast<uint8_t*>(&compressed[0]);
}
z_stream stream;
memset(&stream, 0, sizeof(stream));
stream.next_in = const_cast<Bytef*>(reinterpret_cast<const Bytef*>(uncompressed));
stream.next_out = reinterpret_cast<Bytef*>(target);
stream.avail_in = static_cast<uInt>(uncompressedSize);
stream.avail_out = static_cast<uInt>(compressedSize);
// Ensure no overflow (if the buffer is too large for the current archicture)
if (static_cast<size_t>(stream.avail_in) != uncompressedSize ||
static_cast<size_t>(stream.avail_out) != compressedSize)
{
throw OrthancException(ErrorCode_NotEnoughMemory);
}
// Initialize the compression engine
int error = deflateInit2(&stream,
GetCompressionLevel(),
Z_DEFLATED,
MAX_WBITS + 16, // ask for gzip output
8, // default memory level
Z_DEFAULT_STRATEGY);
if (error != Z_OK)
{
// Cannot initialize zlib
compressed.clear();
throw OrthancException(ErrorCode_InternalError);
}
// Compress the input buffer
error = deflate(&stream, Z_FINISH);
if (error != Z_STREAM_END)
{
deflateEnd(&stream);
compressed.clear();
switch (error)
{
case Z_MEM_ERROR:
throw OrthancException(ErrorCode_NotEnoughMemory);
default:
throw OrthancException(ErrorCode_InternalError);
}
}
size_t size = stream.total_out;
if (deflateEnd(&stream) != Z_OK)
{
throw OrthancException(ErrorCode_InternalError);
}
// The compression was successful
if (HasPrefixWithUncompressedSize())
{
uint64_t s = static_cast<uint64_t>(uncompressedSize);
memcpy(&compressed[0], &s, sizeof(uint64_t));
compressed.resize(size + sizeof(uint64_t));
}
else
{
compressed.resize(size);
}
}
