AuroraRuntime/Source/Compression/Compressors/BZip2Compressor.hpp
2023-10-17 09:28:58 +01:00

209 lines
5.7 KiB
C++

/***
Copyright (C) 2022 J Reece Wilson (a/k/a "Reece"). All rights reserved.
File: BZip2Compressor.hpp
Date: 2022-2-15
Author: Reece
***/
#pragma once
#include "bzlib.h"
typedef struct
{
void * handle;
char buf[BZ_MAX_UNUSED];
AuInt32 bufN;
char writing;
bz_stream strm;
AuInt32 lastErr;
char initialisedOk;
} bz2_file;
static const char *BShitToString(int error)
{
int n {};
bz2_file B;
B.lastErr = error;
return BZ2_bzerror((BZFILE *)&B, &n);
}
namespace Aurora::Compression
{
struct BZIPDeflate : BaseStream
{
CompressInfo meta;
BZIPDeflate(const CompressInfo &meta) : meta(meta), BaseStream(meta.uInternalStreamSize)
{}
~BZIPDeflate()
{
if (this->bInit_)
{
BZ2_bzCompressEnd(&this->ctx_);
}
}
bool Init(const AuSPtr<IO::IStreamReader> &pReader) override
{
this->pReader_ = pReader;
if (!this->IsValid())
{
SysPushErrorMem();
return false;
}
auto ret = BZ2_bzCompressInit(&this->ctx_, meta.uCompressionLevel, 0, 0);
if (ret < BZ_OK)
{
this->SetLastError(ret, BShitToString(ret));
return false;
}
this->bInit_ = true;
this->SetArray(this->din_);
this->SetOutArray(this->dout_);
return true;
}
AuStreamReadWrittenPair_t Ingest_s(AuUInt32 input) override
{
AuUInt32 done {}, read {};
if (!this->pReader_)
{
return {};
}
while (read < input)
{
read += IngestForInPointer<char, uInt>(this->pReader_, this->ctx_.next_in, this->ctx_.avail_in, input - read, this);
if (!this->ctx_.avail_in)
{
return {read, done};
}
do
{
auto [pMainDOut, uMainDOutLength] = this->GetDOutPair();
this->ctx_.avail_out = uMainDOutLength;
this->ctx_.next_out = pMainDOut;
auto ret = BZ2_bzCompress(&this->ctx_, BZ_RUN);
if (ret < BZ_OK)
{
SysPushErrorIO("Error: {}", BShitToString(ret));
this->pReader_.reset();
return AuMakePair(read, 0);
}
auto have = uMainDOutLength - this->ctx_.avail_out;
done += have;
if (!Write2(reinterpret_cast<const AuUInt8 *>(pMainDOut),
have))
{
this->pReader_.reset();
SysPushErrorIO("Compression Out of Overhead");
return AuMakePair(read, 0);
}
}
while (this->ctx_.avail_out == 0);
}
return AuMakePair(read, done);
}
bool Flush() override
{
return RunFlush(BZ_FLUSH);
}
bool Finish() override
{
return RunFlush(BZ_FINISH);
}
bool RunFlush(int type)
{
if (!this->pReader_)
{
return {};
}
if (!this->ctx_.avail_in)
{
do
{
auto [pMainDOut, uMainDOutLength] = this->GetDOutPair();
this->ctx_.avail_out = uMainDOutLength;
this->ctx_.next_out = pMainDOut;
auto ret = BZ2_bzCompress(&this->ctx_, type);
if (ret < BZ_OK)
{
this->SetLastError(ret, BShitToString(ret));
this->pReader_.reset();
return false;
}
auto have = uMainDOutLength - this->ctx_.avail_out;
if (!Write2(pMainDOut,
have))
{
this->pReader_.reset();
SysPushErrorIO("Compression Out of Overhead");
return false;
}
} while (this->ctx_.avail_out == 0);
return true;
}
while (this->ctx_.avail_in)
{
do
{
auto [pMainDOut, uMainDOutLength] = this->GetDOutPair();
this->ctx_.avail_out = uMainDOutLength;
this->ctx_.next_out = pMainDOut;
auto ret = BZ2_bzCompress(&this->ctx_, type);
if (ret < BZ_OK)
{
this->SetLastError(ret, BShitToString(ret));
this->pReader_.reset();
return false;
}
auto have = uMainDOutLength - this->ctx_.avail_out;
if (!Write2(reinterpret_cast<const AuUInt8 *>(pMainDOut),
have))
{
this->pReader_.reset();
SysPushErrorIO("Compression Out of Overhead");
return false;
}
}
while (this->ctx_.avail_out == 0);
}
return true;
}
private:
AuSPtr<IO::IStreamReader> pReader_;
bz_stream ctx_ {};
bool bInit_ {};
char dout_[kChunkSize];
char din_[kChunkSize];
};
}