void BZ2Decompress(Stream& out, Stream& in, Gate2<int, int> progress)
{
enum { BUF_SIZE = 65536 };
Buffer<char> input(BUF_SIZE), output(BUF_SIZE);
int avail = in.Get(input, BUF_SIZE);
if(avail == 0)
return;
bz_stream z;
Zero(z);
z.bzalloc = bzalloc_new;
z.bzfree = bzfree_new;
z.opaque = 0;
if(BZ2_bzDecompressInit(&z, 0, 0) != BZ_OK)
{
out.SetError();
return;
}
z.next_in = input;
z.avail_in = avail;
z.next_out = output;
z.avail_out = BUF_SIZE;
int code;
bool running = true;
int64 total = in.GetLeft();
int done = 0;
do
{
if(z.avail_in == 0 && running)
{
if((z.avail_in = in.Get(z.next_in = input, BUF_SIZE)) == 0)
running = false;
done += z.avail_in;
if(progress(done, (int)total) || in.IsError())
{
BZ2_bzDecompressEnd(&z);
out.SetError();
return;
}
}
code = BZ2_bzDecompress(&z);
if(z.avail_out == 0)
{
out.Put(z.next_out = output, z.avail_out = BUF_SIZE);
if(out.IsError())
{
BZ2_bzDecompressEnd(&z);
return;
}
}
}
while(code == BZ_OK);
if(z.avail_out < BUF_SIZE)
out.Put(output, BUF_SIZE - z.avail_out);
BZ2_bzDecompressEnd(&z);
}
static int sZpress(Stream& out, Stream& in, int size, Gate2<int, int> progress, bool nohdr, dword *crc,
bool compress)
{
const int BUF_SIZE = 65536;
Buffer<Bytef> input(BUF_SIZE), output(BUF_SIZE);
z_stream z;
z.zalloc = zalloc_new;
z.zfree = zfree_new;
z.opaque = 0;
if(compress ? deflateInit2(&z, Z_DEFAULT_COMPRESSION, Z_DEFLATED,
nohdr ? -MAX_WBITS : MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY)
: inflateInit2(&z, nohdr ? -MAX_WBITS : +MAX_WBITS) != Z_OK) {
out.SetError();
return -1;
}
int code;
int flush;
int done = 0;
int outsz = 0;
if(crc)
*crc = crc32(0, NULL, 0);
do {
z.avail_in = in.Get(z.next_in = input, min(size - done, BUF_SIZE));
if(progress(done += z.avail_in, size) || in.IsError())
goto error;
if(!compress && z.avail_in == 0)
break;
flush = z.avail_in > 0 ? Z_NO_FLUSH : Z_FINISH;
if(crc && compress)
*crc = crc32(*crc, input, z.avail_in);
do {
z.avail_out = BUF_SIZE;
z.next_out = output;
code = (compress ? deflate : inflate)(&z, flush);
if(code == Z_STREAM_ERROR)
goto error;
int count = BUF_SIZE - z.avail_out;
if(crc && !compress)
*crc = crc32(*crc, output, count);
out.Put(output, count);
if(out.IsError())
goto error;
outsz += count;
}
while(z.avail_out == 0);
}
while(compress ? flush != Z_FINISH : code != Z_STREAM_END);
if(!compress || code == Z_STREAM_END) {
(compress ? deflateEnd : inflateEnd)(&z);
return outsz;
}
error:
(compress ? deflateEnd : inflateEnd)(&z);
return -1;
}
void BZ2Compress(Stream& out, Stream& in, Gate2<int, int> progress)
{
enum { BUF_SIZE = 65536 };
Buffer<char> input(BUF_SIZE), output(BUF_SIZE);
bz_stream z;
z.bzalloc = bzalloc_new;
z.bzfree = bzfree_new;
z.opaque = 0;
if(BZ2_bzCompressInit(&z, 9, 0, 30) != BZ_OK)
{
out.SetError();
return;
}
z.avail_in = 0;
z.avail_out = BUF_SIZE;
z.next_out = output;
int code;
int flush = BZ_RUN;
int64 total = in.GetLeft();
int done = 0;
do
{
if(z.avail_in == 0 && flush == BZ_RUN)
{
z.next_in = input;
if((z.avail_in = in.Get(z.next_in = input, BUF_SIZE)) == 0)
flush = BZ_FINISH;
done += z.avail_in;
if(progress(done, (int)total) || in.IsError())
{
BZ2_bzCompressEnd(&z);
out.SetError();
return;
}
}
code = BZ2_bzCompress(&z, flush);
if(z.avail_out == 0)
{
out.Put(z.next_out = output, z.avail_out = BUF_SIZE);
if(out.IsError())
{
BZ2_bzCompressEnd(&z);
return;
}
}
}
while(code == BZ_RUN_OK || code == BZ_FINISH_OK);
if(z.avail_out < BUF_SIZE)
out.Put(output, BUF_SIZE - z.avail_out);
BZ2_bzCompressEnd(&z);
if(code != BZ_STREAM_END)
out.SetError();
}
bool SaveStreamBOM(Stream& out, const WString& data) {
if(!out.IsOpen() || out.IsError())
return false;
word w = 0xfeff;
out.Put(&w, 2);
out.Put(~data, 2 * data.GetLength());
out.Close();
return out.IsOK();
}
bool SaveStreamBOMUtf8(Stream& out, const String& data) {
if(!out.IsOpen() || out.IsError())
return false;
static unsigned char bom[] = {0xEF, 0xBB, 0xBF};
out.Put(bom, 3);
out.Put(ToCharset(CHARSET_UTF8, data));
out.Close();
return out.IsOK();
}
static int64 sLZ4Compress(Stream& out, Stream& in, int64 size, Gate<int64, int64> progress, bool co)
{
LZ4CompressStream outs(out);
#ifdef _MULTITHREADED
if(co)
outs.Co();
#endif
sCompressStreamCopy_(outs, in, progress, in, size);
outs.Close();
if(!out.IsError() && !outs.IsError())
return out.GetSize();
return -1;
}
static int64 sZstdDecompress(Stream& out, Stream& in, int64 size, Gate<int64, int64> progress, bool co)
{
ZstdDecompressStream ins(in);
#ifdef _MULTITHREADED
if(co)
ins.Co();
#endif
sCompressStreamCopy_(out, ins, progress, in, size);
ins.Close();
if(!out.IsError() && !ins.IsError())
return out.GetSize();
return -1;
}
