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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
|
// Rar3Decoder.h
// According to unRAR license, this code may not be used to develop
// a program that creates RAR archives
/* This code uses Carryless rangecoder (1999): Dmitry Subbotin : Public domain */
#ifndef __COMPRESS_RAR3_DECODER_H
#define __COMPRESS_RAR3_DECODER_H
#include "../../../C/Ppmd7.h"
#include "../../Common/MyCom.h"
#include "../ICoder.h"
#include "../Common/InBuffer.h"
#include "BitmDecoder.h"
#include "HuffmanDecoder.h"
#include "Rar3Vm.h"
namespace NCompress {
namespace NRar3 {
const UInt32 kWindowSize = 1 << 22;
const UInt32 kWindowMask = (kWindowSize - 1);
const UInt32 kNumReps = 4;
const UInt32 kNumLen2Symbols = 8;
const UInt32 kLenTableSize = 28;
const UInt32 kMainTableSize = 256 + 1 + 1 + 1 + kNumReps + kNumLen2Symbols + kLenTableSize;
const UInt32 kDistTableSize = 60;
const int kNumAlignBits = 4;
const UInt32 kAlignTableSize = (1 << kNumAlignBits) + 1;
const UInt32 kLevelTableSize = 20;
const UInt32 kTablesSizesSum = kMainTableSize + kDistTableSize + kAlignTableSize + kLenTableSize;
class CBitDecoder
{
UInt32 m_Value;
unsigned m_BitPos;
public:
CInBuffer m_Stream;
bool Create(UInt32 bufferSize) { return m_Stream.Create(bufferSize); }
void SetStream(ISequentialInStream *inStream) { m_Stream.SetStream(inStream);}
void ReleaseStream() { m_Stream.ReleaseStream();}
void Init()
{
m_Stream.Init();
m_BitPos = 0;
m_Value = 0;
}
UInt64 GetProcessedSize() const { return m_Stream.GetProcessedSize() - (m_BitPos) / 8; }
UInt32 GetBitPosition() const { return ((8 - m_BitPos) & 7); }
UInt32 GetValue(unsigned numBits)
{
if (m_BitPos < numBits)
{
m_BitPos += 8;
m_Value = (m_Value << 8) | m_Stream.ReadByte();
if (m_BitPos < numBits)
{
m_BitPos += 8;
m_Value = (m_Value << 8) | m_Stream.ReadByte();
}
}
return m_Value >> (m_BitPos - numBits);
}
void MovePos(unsigned numBits)
{
m_BitPos -= numBits;
m_Value = m_Value & ((1 << m_BitPos) - 1);
}
UInt32 ReadBits(unsigned numBits)
{
UInt32 res = GetValue(numBits);
MovePos(numBits);
return res;
}
};
const UInt32 kTopValue = (1 << 24);
const UInt32 kBot = (1 << 15);
struct CRangeDecoder
{
IPpmd7_RangeDec s;
UInt32 Range;
UInt32 Code;
UInt32 Low;
CBitDecoder bitDecoder;
SRes Res;
public:
void InitRangeCoder()
{
Code = 0;
Low = 0;
Range = 0xFFFFFFFF;
for (int i = 0; i < 4; i++)
Code = (Code << 8) | bitDecoder.ReadBits(8);
}
void Normalize()
{
while ((Low ^ (Low + Range)) < kTopValue ||
Range < kBot && ((Range = (0 - Low) & (kBot - 1)), 1))
{
Code = (Code << 8) | bitDecoder.m_Stream.ReadByte();
Range <<= 8;
Low <<= 8;
}
}
CRangeDecoder();
};
struct CFilter: public NVm::CProgram
{
CRecordVector<Byte> GlobalData;
UInt32 BlockStart;
UInt32 BlockSize;
UInt32 ExecCount;
CFilter(): BlockStart(0), BlockSize(0), ExecCount(0) {}
};
struct CTempFilter: public NVm::CProgramInitState
{
UInt32 BlockStart;
UInt32 BlockSize;
UInt32 ExecCount;
bool NextWindow;
UInt32 FilterIndex;
};
const int kNumHuffmanBits = 15;
class CDecoder:
public ICompressCoder,
public ICompressSetDecoderProperties2,
public CMyUnknownImp
{
CRangeDecoder m_InBitStream;
Byte *_window;
UInt32 _winPos;
UInt32 _wrPtr;
UInt64 _lzSize;
UInt64 _unpackSize;
UInt64 _writtenFileSize; // if it's > _unpackSize, then _unpackSize only written
CMyComPtr<ISequentialOutStream> _outStream;
NHuffman::CDecoder<kNumHuffmanBits, kMainTableSize> m_MainDecoder;
NHuffman::CDecoder<kNumHuffmanBits, kDistTableSize> m_DistDecoder;
NHuffman::CDecoder<kNumHuffmanBits, kAlignTableSize> m_AlignDecoder;
NHuffman::CDecoder<kNumHuffmanBits, kLenTableSize> m_LenDecoder;
NHuffman::CDecoder<kNumHuffmanBits, kLevelTableSize> m_LevelDecoder;
UInt32 _reps[kNumReps];
UInt32 _lastLength;
Byte m_LastLevels[kTablesSizesSum];
Byte *_vmData;
Byte *_vmCode;
NVm::CVm _vm;
CRecordVector<CFilter *> _filters;
CRecordVector<CTempFilter *> _tempFilters;
UInt32 _lastFilter;
bool m_IsSolid;
bool _lzMode;
UInt32 PrevAlignBits;
UInt32 PrevAlignCount;
bool TablesRead;
CPpmd7 _ppmd;
int PpmEscChar;
bool PpmError;
HRESULT WriteDataToStream(const Byte *data, UInt32 size);
HRESULT WriteData(const Byte *data, UInt32 size);
HRESULT WriteArea(UInt32 startPtr, UInt32 endPtr);
void ExecuteFilter(int tempFilterIndex, NVm::CBlockRef &outBlockRef);
HRESULT WriteBuf();
void InitFilters();
bool AddVmCode(UInt32 firstByte, UInt32 codeSize);
bool ReadVmCodeLZ();
bool ReadVmCodePPM();
UInt32 ReadBits(int numBits);
HRESULT InitPPM();
int DecodePpmSymbol();
HRESULT DecodePPM(Int32 num, bool &keepDecompressing);
HRESULT ReadTables(bool &keepDecompressing);
HRESULT ReadEndOfBlock(bool &keepDecompressing);
HRESULT DecodeLZ(bool &keepDecompressing);
HRESULT CodeReal(ICompressProgressInfo *progress);
public:
CDecoder();
~CDecoder();
MY_UNKNOWN_IMP1(ICompressSetDecoderProperties2)
void ReleaseStreams()
{
_outStream.Release();
m_InBitStream.bitDecoder.ReleaseStream();
}
STDMETHOD(Code)(ISequentialInStream *inStream, ISequentialOutStream *outStream,
const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
STDMETHOD(SetDecoderProperties2)(const Byte *data, UInt32 size);
void CopyBlock(UInt32 distance, UInt32 len)
{
_lzSize += len;
UInt32 pos = (_winPos - distance - 1) & kWindowMask;
Byte *window = _window;
UInt32 winPos = _winPos;
if (kWindowSize - winPos > len && kWindowSize - pos > len)
{
const Byte *src = window + pos;
Byte *dest = window + winPos;
_winPos += len;
do
*dest++ = *src++;
while(--len != 0);
return;
}
do
{
window[winPos] = window[pos];
winPos = (winPos + 1) & kWindowMask;
pos = (pos + 1) & kWindowMask;
}
while(--len != 0);
_winPos = winPos;
}
void PutByte(Byte b)
{
_window[_winPos] = b;
_winPos = (_winPos + 1) & kWindowMask;
_lzSize++;
}
};
}}
#endif
|
