1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
|
#include "coding/zlib.hpp"
#include "std/target_os.hpp"
namespace coding
{
namespace
{
int constexpr kGzipBits = 16;
int constexpr kBothBits = 32;
int ToInt(ZLib::Deflate::Level level)
{
using Level = ZLib::Deflate::Level;
switch (level)
{
case Level::NoCompression: return Z_NO_COMPRESSION;
case Level::BestSpeed: return Z_BEST_SPEED;
case Level::BestCompression: return Z_BEST_COMPRESSION;
case Level::DefaultCompression: return Z_DEFAULT_COMPRESSION;
}
UNREACHABLE();
}
} // namespace
// ZLib::Processor ---------------------------------------------------------------------------------
ZLib::Processor::Processor(void const * data, size_t size) noexcept : m_init(false)
{
// next_in is defined as z_const (see
// http://www.zlib.net/manual.html). Sometimes it's a const (when
// ZLIB_CONST is defined), sometimes not, it depends on the local
// zconf.h. So, for portability, const_cast<...> is used here, but
// in any case, zlib does not modify |data|.
m_stream.next_in = static_cast<unsigned char *>(const_cast<void *>(data));
m_stream.avail_in = static_cast<unsigned int>(size);
m_stream.next_out = m_buffer;
m_stream.avail_out = kBufferSize;
m_stream.zalloc = Z_NULL;
m_stream.zfree = Z_NULL;
m_stream.opaque = Z_NULL;
}
bool ZLib::Processor::ConsumedAll() const
{
ASSERT(IsInit(), ());
return m_stream.avail_in == 0;
}
bool ZLib::Processor::BufferIsFull() const
{
ASSERT(IsInit(), ());
return m_stream.avail_out == 0;
}
// ZLib::Deflate -----------------------------------------------------------------------------------
ZLib::DeflateProcessor::DeflateProcessor(Deflate::Format format, Deflate::Level level,
void const * data, size_t size) noexcept
: Processor(data, size)
{
auto bits = MAX_WBITS;
switch (format)
{
case Deflate::Format::ZLib: break;
case Deflate::Format::GZip: bits = bits | kGzipBits; break;
}
int const ret =
deflateInit2(&m_stream, ToInt(level) /* level */, Z_DEFLATED /* method */,
bits /* windowBits */, 8 /* memLevel */, Z_DEFAULT_STRATEGY /* strategy */);
m_init = (ret == Z_OK);
}
ZLib::DeflateProcessor::~DeflateProcessor() noexcept
{
if (m_init)
deflateEnd(&m_stream);
}
int ZLib::DeflateProcessor::Process(int flush)
{
ASSERT(IsInit(), ());
return deflate(&m_stream, flush);
}
// ZLib::Inflate -----------------------------------------------------------------------------------
ZLib::InflateProcessor::InflateProcessor(Inflate::Format format, void const * data,
size_t size) noexcept
: Processor(data, size)
{
auto bits = MAX_WBITS;
switch (format)
{
case Inflate::Format::ZLib: break;
case Inflate::Format::GZip: bits = bits | kGzipBits; break;
case Inflate::Format::Both: bits = bits | kBothBits; break;
}
int const ret = inflateInit2(&m_stream, bits);
m_init = (ret == Z_OK);
}
ZLib::InflateProcessor::~InflateProcessor() noexcept
{
if (m_init)
inflateEnd(&m_stream);
}
int ZLib::InflateProcessor::Process(int flush)
{
ASSERT(IsInit(), ());
return inflate(&m_stream, flush);
}
} // namespace coding
|
