764 lines
20 KiB
C++
764 lines
20 KiB
C++
/***
|
|
Copyright (C) 2021 J Reece Wilson (a/k/a "Reece"). All rights reserved.
|
|
|
|
File: StreamCompression.cpp
|
|
Date: 2021-6-17
|
|
Author: Reece
|
|
***/
|
|
#include <Source/RuntimeInternal.hpp>
|
|
#include "Compression.hpp"
|
|
#include "StreamCompression.hpp"
|
|
|
|
#if defined(_AUHAS_BZIP2)
|
|
#include "bzlib.h"
|
|
#endif
|
|
#include "zstd.h"
|
|
#include "zlib.h"
|
|
#if defined(_AUHAS_LZ4)
|
|
#include "lz4.h"
|
|
#include "lz4frame.h"
|
|
#endif
|
|
|
|
namespace Aurora::Compression
|
|
{
|
|
static bool DecompressZSTD(const CompressionPipe &info)
|
|
{
|
|
Memory::ByteBuffer buffer;
|
|
Memory::ByteBuffer inflatedBuffer;
|
|
|
|
if (!info.writePipe)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!info.inPipe)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
auto length = ZSTD_DStreamInSize();
|
|
|
|
auto ok = AuTryResize(buffer, length);
|
|
if (!ok)
|
|
{
|
|
SysPushErrorMem("Couldn't reserve inflation buffers");
|
|
return false;
|
|
}
|
|
|
|
auto outFrameLength = ZSTD_DStreamOutSize();
|
|
ok = AuTryResize(inflatedBuffer, outFrameLength);
|
|
if (!ok)
|
|
{
|
|
SysPushErrorMem("Couldn't reserve inflation buffers");
|
|
return false;
|
|
}
|
|
|
|
auto dctx = ZSTD_createDCtx();
|
|
if (!dctx)
|
|
{
|
|
|
|
SysPushErrorGeneric("Couldn't create decompressor");
|
|
return false;
|
|
}
|
|
|
|
AuUInt read = buffer.size();
|
|
while (read = (info.inPipe(buffer.data(), length)))
|
|
{
|
|
ZSTD_inBuffer input = { buffer.data(), read, 0 };
|
|
while (input.pos < input.size)
|
|
{
|
|
ZSTD_outBuffer output = { inflatedBuffer.data(), outFrameLength, 0 };
|
|
auto ret = ZSTD_decompressStream(dctx, &output, &input);
|
|
if (ZSTD_isError(ret))
|
|
{
|
|
SysPushErrorIO("Compression error: {}", ret);
|
|
ZSTD_freeDCtx(dctx);
|
|
return false;
|
|
}
|
|
|
|
info.writePipe(output.dst, output.pos);
|
|
if (info.reportProgress)
|
|
{
|
|
if (!info.reportProgress(input.pos, output.pos))
|
|
{
|
|
ZSTD_freeDCtx(dctx);
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
ZSTD_freeDCtx(dctx);
|
|
return true;
|
|
}
|
|
|
|
static bool CompressZSTD(const CompressionPipe &stream, const CompressionInfo &info)
|
|
{
|
|
Memory::ByteBuffer inflatedBuffer;
|
|
Memory::ByteBuffer deflatedBuffer;
|
|
size_t ret;
|
|
const auto buffInSize = ZSTD_CStreamInSize();
|
|
const auto buffOutSize = ZSTD_CStreamOutSize();
|
|
|
|
if (!stream.writePipe)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!stream.inPipe)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
auto ok = AuTryResize(inflatedBuffer, buffInSize);
|
|
if (!ok)
|
|
{
|
|
SysPushErrorMem("Couldn't reserve deflation buffers");
|
|
return false;
|
|
}
|
|
|
|
ok = AuTryResize(deflatedBuffer, buffOutSize);
|
|
if (!ok)
|
|
{
|
|
SysPushErrorMem("Couldn't reserve deflation buffers. Out of memory");
|
|
return false;
|
|
}
|
|
|
|
auto cctx = ZSTD_createCCtx();
|
|
if (!cctx)
|
|
{
|
|
SysPushErrorGeneric("Couldn't create decompressor");
|
|
return false;
|
|
}
|
|
|
|
ret = ZSTD_CCtx_setParameter(cctx, ZSTD_c_compressionLevel, info.compressionLevel);
|
|
if (ZSTD_isError(ret))
|
|
{
|
|
SysPushErrorGen("Invalid compression level");
|
|
ZSTD_freeCCtx(cctx);
|
|
return false;
|
|
}
|
|
|
|
ret = ZSTD_CCtx_setParameter(cctx, ZSTD_c_checksumFlag, 1);
|
|
if (ZSTD_isError(ret))
|
|
{
|
|
SysPushErrorGen("Invalid option");
|
|
ZSTD_freeCCtx(cctx);
|
|
return false;
|
|
}
|
|
|
|
ret = ZSTD_CCtx_setParameter(cctx, ZSTD_c_nbWorkers, AuMax(stream.threads, 1u));
|
|
if (ZSTD_isError(ret))
|
|
{
|
|
SysPushErrorGen();
|
|
ZSTD_freeCCtx(cctx);
|
|
return false;
|
|
}
|
|
|
|
bool status = true;
|
|
|
|
size_t const toRead = buffInSize;
|
|
|
|
while (true)
|
|
{
|
|
size_t read = stream.inPipe(inflatedBuffer.data(), buffInSize);
|
|
/* Select the flush mode.
|
|
* If the read may not be finished (read == toRead) we use
|
|
* ZSTD_e_continue. If this is the last chunk, we use ZSTD_e_end.
|
|
* Zstd optimizes the case where the first flush mode is ZSTD_e_end,
|
|
* since it knows it is compressing the entire source in one pass.
|
|
*/
|
|
int const lastChunk = (read < toRead);
|
|
ZSTD_EndDirective const mode = lastChunk ? ZSTD_e_end : ZSTD_e_continue;
|
|
/* Set the input buffer to what we just read.
|
|
* We compress until the input buffer is empty, each time flushing the
|
|
* output.
|
|
*/
|
|
ZSTD_inBuffer input = { inflatedBuffer.data(), read, 0 };
|
|
int finished;
|
|
do
|
|
{
|
|
/* Compress into the output buffer and write all of the output to
|
|
* the file so we can reuse the buffer next iteration.
|
|
*/
|
|
ZSTD_outBuffer output = { deflatedBuffer.data(), buffOutSize, 0 };
|
|
size_t const remaining = ZSTD_compressStream2(cctx, &output, &input, mode);
|
|
if (ZSTD_isError(remaining))
|
|
{
|
|
SysPushErrorGen(": {}", ZSTD_getErrorName(remaining));
|
|
ZSTD_freeCCtx(cctx);
|
|
return false;
|
|
}
|
|
|
|
stream.writePipe(output.dst, output.pos);
|
|
|
|
if (stream.reportProgress)
|
|
{
|
|
if (!stream.reportProgress(input.pos, output.pos))
|
|
{
|
|
ZSTD_freeCCtx(cctx);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/* If we're on the last chunk we're finished when zstd returns 0,
|
|
* which means its consumed all the input AND finished the frame.
|
|
* Otherwise, we're finished when we've consumed all the input.
|
|
*/
|
|
finished = lastChunk ? (remaining == 0) : (input.pos == input.size);
|
|
} while (!finished);
|
|
|
|
SysAssertExp(input.pos == input.size);
|
|
|
|
if (lastChunk) break;
|
|
}
|
|
|
|
ZSTD_freeCCtx(cctx);
|
|
return true;
|
|
}
|
|
|
|
static bool CompressZLib(const CompressionPipe &stream, AuUInt8 level, AuInt8 bits)
|
|
{
|
|
int ret, flush;
|
|
z_stream strm {};
|
|
unsigned char in[kChunkSize];
|
|
unsigned char out[kChunkSize];
|
|
|
|
if (!stream.writePipe)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!stream.inPipe)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
ret = deflateInit2(&strm, level, Z_DEFLATED, bits, 8, Z_DEFAULT_STRATEGY);
|
|
if (ret < Z_OK)
|
|
{
|
|
SysPushErrorIO("Error: {}", ret);
|
|
return false;
|
|
}
|
|
|
|
AuUInt32 inputStat = 0, outputStat = 0;
|
|
|
|
do
|
|
{
|
|
auto read = stream.inPipe(in, AuArraySize(in));
|
|
strm.avail_in = read;
|
|
|
|
inputStat += read;
|
|
|
|
flush = !strm.avail_in ? Z_FINISH : Z_NO_FLUSH;
|
|
strm.next_in = in;
|
|
|
|
do
|
|
{
|
|
strm.avail_out = AuArraySize(out);
|
|
strm.next_out = out;
|
|
|
|
ret = deflate(&strm, flush);
|
|
if (ret < Z_OK)
|
|
{
|
|
SysPushErrorIO("Error: {}", ret);
|
|
return false;
|
|
}
|
|
|
|
auto have = AuArraySize(out) - strm.avail_out;
|
|
|
|
stream.writePipe(out, have);
|
|
|
|
outputStat += have;
|
|
if (stream.reportProgress)
|
|
{
|
|
if (!stream.reportProgress(inputStat, outputStat))
|
|
{
|
|
deflateEnd(&strm);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
} while (strm.avail_out == 0);
|
|
SysAssert(strm.avail_in == 0);
|
|
|
|
} while (flush != Z_FINISH);
|
|
|
|
deflateEnd(&strm);
|
|
return true;
|
|
}
|
|
|
|
static bool DecompressZLib(const CompressionPipe &stream, int bits)
|
|
{
|
|
int ret;
|
|
z_stream strm {};
|
|
unsigned char in[kChunkSize];
|
|
unsigned char out[kChunkSize];
|
|
|
|
if (!stream.writePipe)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!stream.inPipe)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
ret = inflateInit2(&strm, bits);
|
|
if (ret < Z_OK)
|
|
{
|
|
SysPushErrorIO("Error: {}", ret);
|
|
return false;
|
|
}
|
|
|
|
AuUInt32 inputStat = 0, outputStat = 0;
|
|
|
|
do
|
|
{
|
|
auto read = stream.inPipe(in, AuArraySize(in));
|
|
inputStat += read;
|
|
if (!read)
|
|
{
|
|
break;
|
|
}
|
|
|
|
strm.avail_in = read;
|
|
strm.next_in = in;
|
|
|
|
do
|
|
{
|
|
strm.avail_out = AuArraySize(out);
|
|
strm.next_out = out;
|
|
|
|
ret = inflate(&strm, Z_NO_FLUSH);
|
|
if (ret < Z_OK)
|
|
{
|
|
SysPushErrorIO("Error: {}", ret);
|
|
inflateEnd(&strm);
|
|
return false;
|
|
}
|
|
|
|
auto have = AuArraySize(out) - strm.avail_out;
|
|
|
|
stream.writePipe(out, have);
|
|
|
|
outputStat += have;
|
|
if (stream.reportProgress)
|
|
{
|
|
if (!stream.reportProgress(inputStat, outputStat))
|
|
{
|
|
inflateEnd(&strm);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
} while (strm.avail_out == 0);
|
|
SysAssert(strm.avail_in == 0);
|
|
|
|
} while (ret != Z_STREAM_END);
|
|
|
|
inflateEnd(&strm);
|
|
return true;
|
|
}
|
|
|
|
static bool CompressBZip2(const CompressionPipe &stream, const CompressionInfo &info)
|
|
{
|
|
#if defined(_AUHAS_BZIP2)
|
|
int ret, flush;
|
|
bz_stream strm {};
|
|
char in[kChunkSize];
|
|
char out[kChunkSize];
|
|
|
|
if (!stream.writePipe)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!stream.inPipe)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
ret = BZ2_bzCompressInit(&strm, info.compressionLevel, 0, 0);
|
|
if (ret < BZ_OK)
|
|
{
|
|
SysPushErrorIO("Error: {}", ret);
|
|
return false;
|
|
}
|
|
|
|
AuUInt32 inputStat = 0, outputStat = 0;
|
|
|
|
do
|
|
{
|
|
auto read = stream.inPipe(in, AuArraySize(in));
|
|
strm.avail_in = read;
|
|
|
|
inputStat += read;
|
|
|
|
flush = !strm.avail_in ? BZ_FINISH : BZ_RUN;
|
|
strm.next_in = in;
|
|
|
|
do
|
|
{
|
|
strm.avail_out = AuArraySize(out);
|
|
strm.next_out = out;
|
|
|
|
ret = BZ2_bzCompress(&strm, flush);
|
|
if (ret < BZ_OK)
|
|
{
|
|
SysPushErrorIO("Error: {}", ret);
|
|
BZ2_bzCompressEnd(&strm);
|
|
return false;
|
|
}
|
|
|
|
auto have = AuArraySize(out) - strm.avail_out;
|
|
|
|
stream.writePipe(out, have);
|
|
|
|
outputStat += have;
|
|
|
|
if (stream.reportProgress)
|
|
{
|
|
if (!stream.reportProgress(inputStat, outputStat))
|
|
{
|
|
BZ2_bzCompressEnd(&strm);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
} while (strm.avail_out == 0);
|
|
SysAssert(strm.avail_in == 0);
|
|
|
|
} while (flush != BZ_FINISH);
|
|
|
|
BZ2_bzCompressEnd(&strm);
|
|
return true;
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
|
|
static bool DecompressBZip2(const CompressionPipe &stream)
|
|
{
|
|
#if defined(_AUHAS_BZIP2)
|
|
int ret;
|
|
bz_stream strm {};
|
|
char in[kChunkSize];
|
|
char out[kChunkSize];
|
|
|
|
if (!stream.writePipe)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!stream.inPipe)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
ret = BZ2_bzDecompressInit(&strm, 0, 0);
|
|
if (ret < Z_OK)
|
|
{
|
|
SysPushErrorIO("Error: {}", ret);
|
|
return false;
|
|
}
|
|
|
|
AuUInt32 inputStat = 0, outputStat = 0;
|
|
|
|
do
|
|
{
|
|
auto read = stream.inPipe(in, AuArraySize(in));
|
|
inputStat += read;
|
|
if (!read)
|
|
{
|
|
break;
|
|
}
|
|
|
|
strm.avail_in = read;
|
|
strm.next_in = in;
|
|
|
|
do
|
|
{
|
|
strm.avail_out = AuArraySize(out);
|
|
strm.next_out = out;
|
|
|
|
ret = BZ2_bzDecompress(&strm);
|
|
if (ret < Z_OK)
|
|
{
|
|
SysPushErrorIO("Error: {}", ret);
|
|
BZ2_bzDecompressEnd(&strm);
|
|
return false;
|
|
}
|
|
|
|
auto have = AuArraySize(out) - strm.avail_out;
|
|
|
|
stream.writePipe(out, have);
|
|
|
|
outputStat += have;
|
|
if (stream.reportProgress)
|
|
{
|
|
if (!stream.reportProgress(inputStat, outputStat))
|
|
{
|
|
BZ2_bzDecompressEnd(&strm);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
} while (strm.avail_out == 0);
|
|
SysAssert(strm.avail_in == 0);
|
|
|
|
} while (ret != BZ_FINISH);
|
|
|
|
BZ2_bzDecompressEnd(&strm);
|
|
return true;
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
|
|
static bool CompressLZ4(const CompressionPipe &stream, const CompressionInfo &info)
|
|
{
|
|
#if defined(_AUHAS_LZ4)
|
|
bool ret;
|
|
LZ4F_cctx *cctxPtr;
|
|
LZ4F_preferences_t pref {};
|
|
AuUInt32 inputStat = 0, outputStat = 0;
|
|
LZ4F_compressOptions_t options {};
|
|
char header[512];
|
|
|
|
ret = true;
|
|
pref.compressionLevel = info.compressionLevel;
|
|
|
|
auto maxFrameSize = info.lz4BlockSize ? info.lz4BlockSize : 64 * 1024;
|
|
auto buffer = AuSPtr<char>(new char[maxFrameSize], AuDefaultDeleter<char[]>());
|
|
auto maxOut = LZ4F_compressBound(maxFrameSize, &pref);
|
|
auto outBuffer = AuSPtr<char>(new char[maxOut], AuDefaultDeleter<char[]>());;
|
|
|
|
auto err = LZ4F_createCompressionContext(&cctxPtr, LZ4F_getVersion());
|
|
if (LZ4F_isError(err))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Write header
|
|
{
|
|
auto written = LZ4F_compressBegin(cctxPtr, header, AuArraySize(header), &pref);
|
|
stream.writePipe(header, written);
|
|
}
|
|
|
|
while (true)
|
|
{
|
|
auto read = stream.inPipe(buffer.get(), maxFrameSize);
|
|
inputStat += read;
|
|
|
|
if (read)
|
|
{
|
|
AuUInt32 bufferedBytes = LZ4F_compressUpdate(cctxPtr, outBuffer.get(), maxOut, buffer.get(), read, &options);
|
|
|
|
if (LZ4F_isError(bufferedBytes))
|
|
{
|
|
ret = false;
|
|
break;
|
|
}
|
|
|
|
stream.writePipe(outBuffer.get(), bufferedBytes);
|
|
|
|
outputStat += bufferedBytes;
|
|
}
|
|
else
|
|
{
|
|
AuUInt32 bufferedBytes = LZ4F_compressEnd(cctxPtr, outBuffer.get(), maxOut, &options);
|
|
stream.writePipe(outBuffer.get(), bufferedBytes);
|
|
break;
|
|
}
|
|
|
|
if (stream.reportProgress)
|
|
{
|
|
if (!stream.reportProgress(inputStat, outputStat))
|
|
{
|
|
ret = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
LZ4F_freeCompressionContext(cctxPtr);
|
|
return ret;
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
|
|
static bool DecompressLZ4(const CompressionPipe &pipe, AuUInt32 frameMaxSize)
|
|
{
|
|
#if defined(_AUHAS_LZ4)
|
|
bool ret = true;
|
|
LZ4F_dctx *dctxPtr;
|
|
AuUInt32 inputStat = 0, outputStat = 0;
|
|
size_t bytesRemInFrame {};
|
|
LZ4F_decompressOptions_t opts {};
|
|
AuSPtr<char> bufferIn, bufferOut;
|
|
|
|
if (!pipe.writePipe)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!pipe.inPipe)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
auto err = LZ4F_createDecompressionContext(&dctxPtr, LZ4F_getVersion());
|
|
if (LZ4F_isError(err))
|
|
{
|
|
return false;
|
|
}
|
|
bufferIn = AuMakeSharedArray<char>(frameMaxSize);
|
|
bufferOut = AuMakeSharedArray<char>(frameMaxSize);
|
|
|
|
while (true)
|
|
{
|
|
auto frameSize = bytesRemInFrame ? bytesRemInFrame : LZ4F_MIN_SIZE_TO_KNOW_HEADER_LENGTH;
|
|
auto min = frameSize;
|
|
|
|
if (min > frameMaxSize)
|
|
{
|
|
ret = false;
|
|
break;
|
|
}
|
|
|
|
if (frameSize)
|
|
{
|
|
auto read = pipe.inPipe(bufferIn.get(), frameSize);
|
|
if (read != frameSize)
|
|
{
|
|
ret = read == 0 && outputStat;
|
|
break;
|
|
}
|
|
inputStat += frameSize;
|
|
}
|
|
|
|
if (frameSize)
|
|
{
|
|
auto mustConsume = frameSize;
|
|
size_t frameSPtr = mustConsume;
|
|
size_t frameS2Ptr = frameMaxSize;
|
|
|
|
bytesRemInFrame = LZ4F_decompress(dctxPtr, bufferOut.get(), &frameS2Ptr, bufferIn.get(), &frameSPtr, &opts);
|
|
if (LZ4F_isError(bytesRemInFrame))
|
|
{
|
|
SysPushErrorIO("{}", LZ4F_getErrorName(bytesRemInFrame));
|
|
ret = false;
|
|
break;
|
|
}
|
|
|
|
if (frameS2Ptr)
|
|
{
|
|
pipe.writePipe(bufferOut.get(), frameS2Ptr);
|
|
}
|
|
|
|
outputStat += frameS2Ptr;
|
|
|
|
|
|
if (pipe.reportProgress)
|
|
{
|
|
if (!pipe.reportProgress(inputStat, outputStat))
|
|
{
|
|
ret = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
LZ4F_freeDecompressionContext(dctxPtr);
|
|
return ret;
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
|
|
AUKN_SYM bool Compress(const CompressionPipe &stream, const CompressionInfo &info)
|
|
{
|
|
CompressionInfo meta = info;
|
|
AuInt8 bits;
|
|
|
|
if (!stream.inPipe)
|
|
{
|
|
return {};
|
|
}
|
|
|
|
if (!stream.writePipe)
|
|
{
|
|
return {};
|
|
}
|
|
|
|
switch (info.type)
|
|
{
|
|
case ECompresionType::eDeflate:
|
|
case ECompresionType::eZip:
|
|
case ECompresionType::eGZip:
|
|
{
|
|
if (!CompressionLevelFromExternalApi(meta, bits))
|
|
{
|
|
return {};
|
|
}
|
|
|
|
return CompressZLib(stream, info.compressionLevel, bits);
|
|
}
|
|
case ECompresionType::eZSTD:
|
|
return CompressZSTD(stream, info);
|
|
case ECompresionType::eBZIP2:
|
|
return CompressBZip2(stream, info);
|
|
case ECompresionType::eLZ4:
|
|
return CompressLZ4(stream, info);
|
|
//case ECompresionType::eLZMA:
|
|
// return CompressLZMA(stream, info);
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
AUKN_SYM bool Decompress(const CompressionPipe &pipe, const DecompressInfo &meta2)
|
|
{
|
|
DecompressInfo meta = meta2;
|
|
AuInt8 bits;
|
|
|
|
if (!pipe.inPipe)
|
|
{
|
|
return {};
|
|
}
|
|
|
|
if (!pipe.writePipe)
|
|
{
|
|
return {};
|
|
}
|
|
|
|
switch (meta.alg)
|
|
{
|
|
case ECompresionType::eDeflate:
|
|
case ECompresionType::eZip:
|
|
case ECompresionType::eGZip:
|
|
{
|
|
if (!CompressionLevelFromExternalApi(meta, bits))
|
|
{
|
|
return {};
|
|
}
|
|
|
|
return DecompressZLib(pipe, bits);
|
|
}
|
|
case ECompresionType::eZSTD:
|
|
return DecompressZSTD(pipe);
|
|
case ECompresionType::eBZIP2:
|
|
return DecompressBZip2(pipe);
|
|
case ECompresionType::eLZ4:
|
|
return DecompressLZ4(pipe, meta.internalStreamSize / 2);
|
|
//case ECompresionType::eLZMA:
|
|
// return DecompressLZMA(pipe);
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
} |