Annotation of elwix/tools/oldlzma/SRC/7zip/Compress/LZMA/LZMAEncoder.h, revision 1.1.1.1
1.1 misho 1: // LZMA/Encoder.h
2:
3: #ifndef __LZMA_ENCODER_H
4: #define __LZMA_ENCODER_H
5:
6: #include "../../../Common/MyCom.h"
7: #include "../../../Common/Alloc.h"
8: #include "../../ICoder.h"
9: #include "../LZ/IMatchFinder.h"
10: #include "../RangeCoder/RangeCoderBitTree.h"
11:
12: #include "LZMA.h"
13:
14: namespace NCompress {
15: namespace NLZMA {
16:
17: typedef NRangeCoder::CBitEncoder<kNumMoveBits> CMyBitEncoder;
18:
19: class CBaseState
20: {
21: protected:
22: CState _state;
23: Byte _previousByte;
24: UInt32 _repDistances[kNumRepDistances];
25: void Init()
26: {
27: _state.Init();
28: _previousByte = 0;
29: for(UInt32 i = 0 ; i < kNumRepDistances; i++)
30: _repDistances[i] = 0;
31: }
32: };
33:
34: struct COptimal
35: {
36: CState State;
37:
38: bool Prev1IsChar;
39: bool Prev2;
40:
41: UInt32 PosPrev2;
42: UInt32 BackPrev2;
43:
44: UInt32 Price;
45: UInt32 PosPrev; // posNext;
46: UInt32 BackPrev;
47: UInt32 Backs[kNumRepDistances];
48: void MakeAsChar() { BackPrev = UInt32(-1); Prev1IsChar = false; }
49: void MakeAsShortRep() { BackPrev = 0; ; Prev1IsChar = false; }
50: bool IsShortRep() { return (BackPrev == 0); }
51: };
52:
53:
54: extern Byte g_FastPos[1024];
55: inline UInt32 GetPosSlot(UInt32 pos)
56: {
57: if (pos < (1 << 10))
58: return g_FastPos[pos];
59: if (pos < (1 << 19))
60: return g_FastPos[pos >> 9] + 18;
61: return g_FastPos[pos >> 18] + 36;
62: }
63:
64: inline UInt32 GetPosSlot2(UInt32 pos)
65: {
66: if (pos < (1 << 16))
67: return g_FastPos[pos >> 6] + 12;
68: if (pos < (1 << 25))
69: return g_FastPos[pos >> 15] + 30;
70: return g_FastPos[pos >> 24] + 48;
71: }
72:
73: const UInt32 kIfinityPrice = 0xFFFFFFF;
74:
75: const UInt32 kNumOpts = 1 << 12;
76:
77:
78: class CLiteralEncoder2
79: {
80: CMyBitEncoder _encoders[0x300];
81: public:
82: void Init()
83: {
84: for (int i = 0; i < 0x300; i++)
85: _encoders[i].Init();
86: }
87: void Encode(NRangeCoder::CEncoder *rangeEncoder, Byte symbol);
88: void EncodeMatched(NRangeCoder::CEncoder *rangeEncoder, Byte matchByte, Byte symbol);
89: UInt32 GetPrice(bool matchMode, Byte matchByte, Byte symbol) const;
90: };
91:
92: class CLiteralEncoder
93: {
94: CLiteralEncoder2 *_coders;
95: int _numPrevBits;
96: int _numPosBits;
97: UInt32 _posMask;
98: public:
99: CLiteralEncoder(): _coders(0) {}
100: ~CLiteralEncoder() { Free(); }
101: void Free()
102: {
103: MyFree(_coders);
104: _coders = 0;
105: }
106: bool Create(int numPosBits, int numPrevBits)
107: {
108: if (_coders == 0 || (numPosBits + numPrevBits) !=
109: (_numPrevBits + _numPosBits) )
110: {
111: Free();
112: UInt32 numStates = 1 << (numPosBits + numPrevBits);
113: _coders = (CLiteralEncoder2 *)MyAlloc(numStates * sizeof(CLiteralEncoder2));
114: }
115: _numPosBits = numPosBits;
116: _posMask = (1 << numPosBits) - 1;
117: _numPrevBits = numPrevBits;
118: return (_coders != 0);
119: }
120: void Init()
121: {
122: UInt32 numStates = 1 << (_numPrevBits + _numPosBits);
123: for (UInt32 i = 0; i < numStates; i++)
124: _coders[i].Init();
125: }
126: UInt32 GetState(UInt32 pos, Byte prevByte) const
127: { return ((pos & _posMask) << _numPrevBits) + (prevByte >> (8 - _numPrevBits)); }
128: CLiteralEncoder2 *GetSubCoder(UInt32 pos, Byte prevByte)
129: { return &_coders[GetState(pos, prevByte)]; }
130: /*
131: void Encode(NRangeCoder::CEncoder *rangeEncoder, UInt32 pos, Byte prevByte,
132: Byte symbol)
133: { _coders[GetState(pos, prevByte)].Encode(rangeEncoder, symbol); }
134: void EncodeMatched(NRangeCoder::CEncoder *rangeEncoder, UInt32 pos, Byte prevByte,
135: Byte matchByte, Byte symbol)
136: { _coders[GetState(pos, prevByte)].Encode(rangeEncoder,
137: matchByte, symbol); }
138: */
139: UInt32 GetPrice(UInt32 pos, Byte prevByte, bool matchMode, Byte matchByte, Byte symbol) const
140: { return _coders[GetState(pos, prevByte)].GetPrice(matchMode, matchByte, symbol); }
141: };
142:
143: namespace NLength {
144:
145: class CEncoder
146: {
147: CMyBitEncoder _choice;
148: CMyBitEncoder _choice2;
149: NRangeCoder::CBitTreeEncoder<kNumMoveBits, kNumLowBits> _lowCoder[kNumPosStatesEncodingMax];
150: NRangeCoder::CBitTreeEncoder<kNumMoveBits, kNumMidBits> _midCoder[kNumPosStatesEncodingMax];
151: NRangeCoder::CBitTreeEncoder<kNumMoveBits, kNumHighBits> _highCoder;
152: public:
153: void Init(UInt32 numPosStates);
154: void Encode(NRangeCoder::CEncoder *rangeEncoder, UInt32 symbol, UInt32 posState);
155: UInt32 GetPrice(UInt32 symbol, UInt32 posState) const;
156: };
157:
158: const UInt32 kNumSpecSymbols = kNumLowSymbols + kNumMidSymbols;
159:
160: class CPriceTableEncoder: public CEncoder
161: {
162: UInt32 _prices[kNumSymbolsTotal][kNumPosStatesEncodingMax];
163: UInt32 _tableSize;
164: UInt32 _counters[kNumPosStatesEncodingMax];
165: public:
166: void SetTableSize(UInt32 tableSize) { _tableSize = tableSize; }
167: UInt32 GetPrice(UInt32 symbol, UInt32 posState) const
168: { return _prices[symbol][posState]; }
169: void UpdateTable(UInt32 posState)
170: {
171: for (UInt32 len = 0; len < _tableSize; len++)
172: _prices[len][posState] = CEncoder::GetPrice(len, posState);
173: _counters[posState] = _tableSize;
174: }
175: void UpdateTables(UInt32 numPosStates)
176: {
177: for (UInt32 posState = 0; posState < numPosStates; posState++)
178: UpdateTable(posState);
179: }
180: void Encode(NRangeCoder::CEncoder *rangeEncoder, UInt32 symbol, UInt32 posState)
181: {
182: CEncoder::Encode(rangeEncoder, symbol, posState);
183: if (--_counters[posState] == 0)
184: UpdateTable(posState);
185: }
186: };
187:
188: }
189:
190: class CEncoder :
191: public ICompressCoder,
192: public ICompressSetOutStream,
193: public ICompressSetCoderProperties,
194: public ICompressWriteCoderProperties,
195: public CBaseState,
196: public CMyUnknownImp
197: {
198: COptimal _optimum[kNumOpts];
199: CMyComPtr<IMatchFinder> _matchFinder; // test it
200: NRangeCoder::CEncoder _rangeEncoder;
201:
202: CMyBitEncoder _isMatch[kNumStates][NLength::kNumPosStatesEncodingMax];
203: CMyBitEncoder _isRep[kNumStates];
204: CMyBitEncoder _isRepG0[kNumStates];
205: CMyBitEncoder _isRepG1[kNumStates];
206: CMyBitEncoder _isRepG2[kNumStates];
207: CMyBitEncoder _isRep0Long[kNumStates][NLength::kNumPosStatesEncodingMax];
208:
209: NRangeCoder::CBitTreeEncoder<kNumMoveBits, kNumPosSlotBits> _posSlotEncoder[kNumLenToPosStates];
210:
211: CMyBitEncoder _posEncoders[kNumFullDistances - kEndPosModelIndex];
212: NRangeCoder::CBitTreeEncoder<kNumMoveBits, kNumAlignBits> _posAlignEncoder;
213:
214: NLength::CPriceTableEncoder _lenEncoder;
215: NLength::CPriceTableEncoder _repMatchLenEncoder;
216:
217: CLiteralEncoder _literalEncoder;
218:
219: UInt32 _matchDistances[kMatchMaxLen + 1];
220:
221: bool _fastMode;
222: bool _maxMode;
223: UInt32 _numFastBytes;
224: UInt32 _longestMatchLength;
225:
226: UInt32 _additionalOffset;
227:
228: UInt32 _optimumEndIndex;
229: UInt32 _optimumCurrentIndex;
230:
231: bool _longestMatchWasFound;
232:
233: UInt32 _posSlotPrices[kNumLenToPosStates][kDistTableSizeMax];
234:
235: UInt32 _distancesPrices[kNumLenToPosStates][kNumFullDistances];
236:
237: UInt32 _alignPrices[kAlignTableSize];
238: UInt32 _alignPriceCount;
239:
240: UInt32 _distTableSize;
241:
242: UInt32 _posStateBits;
243: UInt32 _posStateMask;
244: UInt32 _numLiteralPosStateBits;
245: UInt32 _numLiteralContextBits;
246:
247: UInt32 _dictionarySize;
248:
249: UInt32 _dictionarySizePrev;
250: UInt32 _numFastBytesPrev;
251:
252: UInt64 lastPosSlotFillingPos;
253: UInt64 nowPos64;
254: bool _finished;
255: ISequentialInStream *_inStream;
256:
257: int _matchFinderIndex;
258: #ifdef COMPRESS_MF_MT
259: bool _multiThread;
260: #endif
261:
262: bool _writeEndMark;
263:
264: bool _needReleaseMFStream;
265:
266: HRESULT ReadMatchDistances(UInt32 &len);
267:
268: HRESULT MovePos(UInt32 num);
269: UInt32 GetRepLen1Price(CState state, UInt32 posState) const
270: {
271: return _isRepG0[state.Index].GetPrice0() +
272: _isRep0Long[state.Index][posState].GetPrice0();
273: }
274: UInt32 GetRepPrice(UInt32 repIndex, UInt32 len, CState state, UInt32 posState) const
275: {
276: UInt32 price = _repMatchLenEncoder.GetPrice(len - kMatchMinLen, posState);
277: if(repIndex == 0)
278: {
279: price += _isRepG0[state.Index].GetPrice0();
280: price += _isRep0Long[state.Index][posState].GetPrice1();
281: }
282: else
283: {
284: price += _isRepG0[state.Index].GetPrice1();
285: if (repIndex == 1)
286: price += _isRepG1[state.Index].GetPrice0();
287: else
288: {
289: price += _isRepG1[state.Index].GetPrice1();
290: price += _isRepG2[state.Index].GetPrice(repIndex - 2);
291: }
292: }
293: return price;
294: }
295: /*
296: UInt32 GetPosLen2Price(UInt32 pos, UInt32 posState) const
297: {
298: if (pos >= kNumFullDistances)
299: return kIfinityPrice;
300: return _distancesPrices[0][pos] + _lenEncoder.GetPrice(0, posState);
301: }
302: UInt32 GetPosLen3Price(UInt32 pos, UInt32 len, UInt32 posState) const
303: {
304: UInt32 price;
305: UInt32 lenToPosState = GetLenToPosState(len);
306: if (pos < kNumFullDistances)
307: price = _distancesPrices[lenToPosState][pos];
308: else
309: price = _posSlotPrices[lenToPosState][GetPosSlot2(pos)] +
310: _alignPrices[pos & kAlignMask];
311: return price + _lenEncoder.GetPrice(len - kMatchMinLen, posState);
312: }
313: */
314: UInt32 GetPosLenPrice(UInt32 pos, UInt32 len, UInt32 posState) const
315: {
316: if (len == 2 && pos >= 0x80)
317: return kIfinityPrice;
318: UInt32 price;
319: UInt32 lenToPosState = GetLenToPosState(len);
320: if (pos < kNumFullDistances)
321: price = _distancesPrices[lenToPosState][pos];
322: else
323: price = _posSlotPrices[lenToPosState][GetPosSlot2(pos)] +
324: _alignPrices[pos & kAlignMask];
325: return price + _lenEncoder.GetPrice(len - kMatchMinLen, posState);
326: }
327:
328: UInt32 Backward(UInt32 &backRes, UInt32 cur);
329: HRESULT GetOptimum(UInt32 position, UInt32 &backRes, UInt32 &lenRes);
330: HRESULT GetOptimumFast(UInt32 position, UInt32 &backRes, UInt32 &lenRes);
331:
332: void FillPosSlotPrices();
333: void FillDistancesPrices();
334: void FillAlignPrices();
335:
336: void ReleaseMFStream()
337: {
338: if (_matchFinder && _needReleaseMFStream)
339: {
340: _matchFinder->ReleaseStream();
341: _needReleaseMFStream = false;
342: }
343: }
344:
345: void ReleaseStreams()
346: {
347: ReleaseMFStream();
348: ReleaseOutStream();
349: }
350:
351: HRESULT Flush(UInt32 nowPos);
352: class CCoderReleaser
353: {
354: CEncoder *_coder;
355: public:
356: CCoderReleaser(CEncoder *coder): _coder(coder) {}
357: ~CCoderReleaser()
358: {
359: _coder->ReleaseStreams();
360: }
361: };
362: friend class CCoderReleaser;
363:
364: void WriteEndMarker(UInt32 posState);
365:
366: public:
367: CEncoder();
368: void SetWriteEndMarkerMode(bool writeEndMarker)
369: { _writeEndMark= writeEndMarker; }
370:
371: HRESULT Create();
372:
373: MY_UNKNOWN_IMP3(
374: ICompressSetOutStream,
375: ICompressSetCoderProperties,
376: ICompressWriteCoderProperties
377: )
378:
379: HRESULT Init();
380:
381: // ICompressCoder interface
382: HRESULT SetStreams(ISequentialInStream *inStream,
383: ISequentialOutStream *outStream,
384: const UInt64 *inSize, const UInt64 *outSize);
385: HRESULT CodeOneBlock(UInt64 *inSize, UInt64 *outSize, Int32 *finished);
386:
387: HRESULT CodeReal(ISequentialInStream *inStream,
388: ISequentialOutStream *outStream,
389: const UInt64 *inSize, const UInt64 *outSize,
390: ICompressProgressInfo *progress);
391:
392: // ICompressCoder interface
393: STDMETHOD(Code)(ISequentialInStream *inStream,
394: ISequentialOutStream *outStream,
395: const UInt64 *inSize, const UInt64 *outSize,
396: ICompressProgressInfo *progress);
397:
398: // IInitMatchFinder interface
399: STDMETHOD(InitMatchFinder)(IMatchFinder *matchFinder);
400:
401: // ICompressSetCoderProperties2
402: STDMETHOD(SetCoderProperties)(const PROPID *propIDs,
403: const PROPVARIANT *properties, UInt32 numProperties);
404:
405: // ICompressWriteCoderProperties
406: STDMETHOD(WriteCoderProperties)(ISequentialOutStream *outStream);
407:
408: STDMETHOD(SetOutStream)(ISequentialOutStream *outStream);
409: STDMETHOD(ReleaseOutStream)();
410:
411: virtual ~CEncoder() {}
412: };
413:
414: }}
415:
416: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to LZMAEncoder.h CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / elwix / tools / oldlzma / SRC / 7zip / Compress / LZMA