Annotation of elwix/tools/oldlzma/SRC/7zip/Compress/LZMA/LZMAEncoder.cpp, revision 1.1.1.1
1.1 misho 1: // LZMA/Encoder.cpp
2:
3: #include "StdAfx.h"
4:
5: #include "../../../Common/Defs.h"
6:
7: #include "LZMAEncoder.h"
8:
9: // for minimal compressing code size define these:
10: // #define COMPRESS_MF_BT
11: // #define COMPRESS_MF_BT4
12:
13: #if !defined(COMPRESS_MF_BT) && !defined(COMPRESS_MF_PAT) && !defined(COMPRESS_MF_HC)
14: #define COMPRESS_MF_BT
15: #define COMPRESS_MF_PAT
16: #define COMPRESS_MF_HC
17: #endif
18:
19: #ifdef COMPRESS_MF_BT
20: #if !defined(COMPRESS_MF_BT2) && !defined(COMPRESS_MF_BT3) && !defined(COMPRESS_MF_BT4) && !defined(COMPRESS_MF_BT4B)
21: #define COMPRESS_MF_BT2
22: #define COMPRESS_MF_BT3
23: #define COMPRESS_MF_BT4
24: #define COMPRESS_MF_BT4B
25: #endif
26: #ifdef COMPRESS_MF_BT2
27: #include "../LZ/BinTree/BinTree2.h"
28: #endif
29: #ifdef COMPRESS_MF_BT3
30: #include "../LZ/BinTree/BinTree3.h"
31: #endif
32: #ifdef COMPRESS_MF_BT4
33: #include "../LZ/BinTree/BinTree4.h"
34: #endif
35: #ifdef COMPRESS_MF_BT4B
36: #include "../LZ/BinTree/BinTree4b.h"
37: #endif
38: #endif
39:
40: #ifdef COMPRESS_MF_PAT
41: #include "../LZ/Patricia/Pat2.h"
42: #include "../LZ/Patricia/Pat2H.h"
43: #include "../LZ/Patricia/Pat3H.h"
44: #include "../LZ/Patricia/Pat4H.h"
45: #include "../LZ/Patricia/Pat2R.h"
46: #endif
47:
48: #ifdef COMPRESS_MF_HC
49: #include "../LZ/HashChain/HC3.h"
50: #include "../LZ/HashChain/HC4.h"
51: #endif
52:
53: #ifdef COMPRESS_MF_MT
54: #include "../LZ/MT/MT.h"
55: #endif
56:
57: namespace NCompress {
58: namespace NLZMA {
59:
60: const int kDefaultDictionaryLogSize = 20;
61: const UInt32 kNumFastBytesDefault = 0x20;
62:
63: enum
64: {
65: kBT2,
66: kBT3,
67: kBT4,
68: kBT4B,
69: kPat2,
70: kPat2H,
71: kPat3H,
72: kPat4H,
73: kPat2R,
74: kHC3,
75: kHC4
76: };
77:
78: static const wchar_t *kMatchFinderIDs[] =
79: {
80: L"BT2",
81: L"BT3",
82: L"BT4",
83: L"BT4B",
84: L"PAT2",
85: L"PAT2H",
86: L"PAT3H",
87: L"PAT4H",
88: L"PAT2R",
89: L"HC3",
90: L"HC4"
91: };
92:
93: Byte g_FastPos[1024];
94:
95: class CFastPosInit
96: {
97: public:
98: CFastPosInit() { Init(); }
99: void Init()
100: {
101: const Byte kFastSlots = 20;
102: int c = 2;
103: g_FastPos[0] = 0;
104: g_FastPos[1] = 1;
105:
106: for (Byte slotFast = 2; slotFast < kFastSlots; slotFast++)
107: {
108: UInt32 k = (1 << ((slotFast >> 1) - 1));
109: for (UInt32 j = 0; j < k; j++, c++)
110: g_FastPos[c] = slotFast;
111: }
112: }
113: } g_FastPosInit;
114:
115:
116: void CLiteralEncoder2::Encode(NRangeCoder::CEncoder *rangeEncoder, Byte symbol)
117: {
118: UInt32 context = 1;
119: int i = 8;
120: do
121: {
122: i--;
123: UInt32 bit = (symbol >> i) & 1;
124: _encoders[context].Encode(rangeEncoder, bit);
125: context = (context << 1) | bit;
126: }
127: while(i != 0);
128: }
129:
130: void CLiteralEncoder2::EncodeMatched(NRangeCoder::CEncoder *rangeEncoder,
131: Byte matchByte, Byte symbol)
132: {
133: UInt32 context = 1;
134: int i = 8;
135: do
136: {
137: i--;
138: UInt32 bit = (symbol >> i) & 1;
139: UInt32 matchBit = (matchByte >> i) & 1;
140: _encoders[0x100 + (matchBit << 8) + context].Encode(rangeEncoder, bit);
141: context = (context << 1) | bit;
142: if (matchBit != bit)
143: {
144: while(i != 0)
145: {
146: i--;
147: UInt32 bit = (symbol >> i) & 1;
148: _encoders[context].Encode(rangeEncoder, bit);
149: context = (context << 1) | bit;
150: }
151: break;
152: }
153: }
154: while(i != 0);
155: }
156:
157: UInt32 CLiteralEncoder2::GetPrice(bool matchMode, Byte matchByte, Byte symbol) const
158: {
159: UInt32 price = 0;
160: UInt32 context = 1;
161: int i = 8;
162: if (matchMode)
163: {
164: do
165: {
166: i--;
167: UInt32 matchBit = (matchByte >> i) & 1;
168: UInt32 bit = (symbol >> i) & 1;
169: price += _encoders[0x100 + (matchBit << 8) + context].GetPrice(bit);
170: context = (context << 1) | bit;
171: if (matchBit != bit)
172: break;
173: }
174: while (i != 0);
175: }
176: while(i != 0)
177: {
178: i--;
179: UInt32 bit = (symbol >> i) & 1;
180: price += _encoders[context].GetPrice(bit);
181: context = (context << 1) | bit;
182: }
183: return price;
184: };
185:
186:
187: namespace NLength {
188:
189: void CEncoder::Init(UInt32 numPosStates)
190: {
191: _choice.Init();
192: _choice2.Init();
193: for (UInt32 posState = 0; posState < numPosStates; posState++)
194: {
195: _lowCoder[posState].Init();
196: _midCoder[posState].Init();
197: }
198: _highCoder.Init();
199: }
200:
201: void CEncoder::Encode(NRangeCoder::CEncoder *rangeEncoder, UInt32 symbol, UInt32 posState)
202: {
203: if(symbol < kNumLowSymbols)
204: {
205: _choice.Encode(rangeEncoder, 0);
206: _lowCoder[posState].Encode(rangeEncoder, symbol);
207: }
208: else
209: {
210: _choice.Encode(rangeEncoder, 1);
211: if(symbol < kNumLowSymbols + kNumMidSymbols)
212: {
213: _choice2.Encode(rangeEncoder, 0);
214: _midCoder[posState].Encode(rangeEncoder, symbol - kNumLowSymbols);
215: }
216: else
217: {
218: _choice2.Encode(rangeEncoder, 1);
219: _highCoder.Encode(rangeEncoder, symbol - kNumLowSymbols - kNumMidSymbols);
220: }
221: }
222: }
223:
224: UInt32 CEncoder::GetPrice(UInt32 symbol, UInt32 posState) const
225: {
226: if(symbol < kNumLowSymbols)
227: return _choice.GetPrice0() + _lowCoder[posState].GetPrice(symbol);
228: UInt32 price = _choice.GetPrice1();
229: if(symbol < kNumLowSymbols + kNumMidSymbols)
230: {
231: price += _choice2.GetPrice0();
232: price += _midCoder[posState].GetPrice(symbol - kNumLowSymbols);
233: }
234: else
235: {
236: price += _choice2.GetPrice1();
237: price += _highCoder.GetPrice(symbol - kNumLowSymbols - kNumMidSymbols);
238: }
239: return price;
240: }
241:
242: }
243: CEncoder::CEncoder():
244: _numFastBytes(kNumFastBytesDefault),
245: _distTableSize(kDefaultDictionaryLogSize * 2),
246: _posStateBits(2),
247: _posStateMask(4 - 1),
248: _numLiteralPosStateBits(0),
249: _numLiteralContextBits(3),
250: _dictionarySize(1 << kDefaultDictionaryLogSize),
251: _dictionarySizePrev(UInt32(-1)),
252: _numFastBytesPrev(UInt32(-1)),
253: _matchFinderIndex(kBT4),
254: #ifdef COMPRESS_MF_MT
255: _multiThread(false),
256: #endif
257: _writeEndMark(false)
258: {
259: _maxMode = false;
260: _fastMode = false;
261: }
262:
263: HRESULT CEncoder::Create()
264: {
265: if (!_rangeEncoder.Create(1 << 20))
266: return E_OUTOFMEMORY;
267: if (!_matchFinder)
268: {
269: switch(_matchFinderIndex)
270: {
271: #ifdef COMPRESS_MF_BT
272: #ifdef COMPRESS_MF_BT2
273: case kBT2:
274: _matchFinder = new NBT2::CMatchFinderBinTree;
275: break;
276: #endif
277: #ifdef COMPRESS_MF_BT3
278: case kBT3:
279: _matchFinder = new NBT3::CMatchFinderBinTree;
280: break;
281: #endif
282: #ifdef COMPRESS_MF_BT4
283: case kBT4:
284: _matchFinder = new NBT4::CMatchFinderBinTree;
285: break;
286: #endif
287: #ifdef COMPRESS_MF_BT4B
288: case kBT4B:
289: _matchFinder = new NBT4B::CMatchFinderBinTree;
290: break;
291: #endif
292: #endif
293:
294: #ifdef COMPRESS_MF_PAT
295: case kPat2:
296: _matchFinder = new NPat2::CPatricia;
297: break;
298: case kPat2H:
299: _matchFinder = new NPat2H::CPatricia;
300: break;
301: case kPat3H:
302: _matchFinder = new NPat3H::CPatricia;
303: break;
304: case kPat4H:
305: _matchFinder = new NPat4H::CPatricia;
306: break;
307: case kPat2R:
308: _matchFinder = new NPat2R::CPatricia;
309: break;
310: #endif
311:
312: #ifdef COMPRESS_MF_HC
313: case kHC3:
314: _matchFinder = new NHC3::CMatchFinderHC;
315: break;
316: case kHC4:
317: _matchFinder = new NHC4::CMatchFinderHC;
318: break;
319: #endif
320: }
321: if (_matchFinder == 0)
322: return E_OUTOFMEMORY;
323:
324: #ifdef COMPRESS_MF_MT
325: if (_multiThread && !(_fastMode && (_matchFinderIndex == kHC3 || _matchFinderIndex == kHC4)))
326: {
327: CMatchFinderMT *mfSpec = new CMatchFinderMT;
328: if (mfSpec == 0)
329: return E_OUTOFMEMORY;
330: CMyComPtr<IMatchFinder> mf = mfSpec;
331: RINOK(mfSpec->SetMatchFinder(_matchFinder));
332: _matchFinder.Release();
333: _matchFinder = mf;
334: }
335: #endif
336: }
337:
338: if (!_literalEncoder.Create(_numLiteralPosStateBits, _numLiteralContextBits))
339: return E_OUTOFMEMORY;
340:
341: if (_dictionarySize == _dictionarySizePrev && _numFastBytesPrev == _numFastBytes)
342: return S_OK;
343: RINOK(_matchFinder->Create(_dictionarySize, kNumOpts, _numFastBytes,
344: kMatchMaxLen - _numFastBytes));
345: _dictionarySizePrev = _dictionarySize;
346: _numFastBytesPrev = _numFastBytes;
347: return S_OK;
348: }
349:
350: static bool AreStringsEqual(const wchar_t *base, const wchar_t *testString)
351: {
352: while (true)
353: {
354: wchar_t c = *testString;
355: if (c >= 'a' && c <= 'z')
356: c -= 0x20;
357: if (*base != c)
358: return false;
359: if (c == 0)
360: return true;
361: base++;
362: testString++;
363: }
364: }
365:
366: static int FindMatchFinder(const wchar_t *s)
367: {
368: for (int m = 0; m < (int)(sizeof(kMatchFinderIDs) / sizeof(kMatchFinderIDs[0])); m++)
369: if (AreStringsEqual(kMatchFinderIDs[m], s))
370: return m;
371: return -1;
372: }
373:
374: STDMETHODIMP CEncoder::SetCoderProperties(const PROPID *propIDs,
375: const PROPVARIANT *properties, UInt32 numProperties)
376: {
377: for (UInt32 i = 0; i < numProperties; i++)
378: {
379: const PROPVARIANT &prop = properties[i];
380: switch(propIDs[i])
381: {
382: case NCoderPropID::kNumFastBytes:
383: {
384: if (prop.vt != VT_UI4)
385: return E_INVALIDARG;
386: UInt32 numFastBytes = prop.ulVal;
387: if(numFastBytes < 2 || numFastBytes > kMatchMaxLen)
388: return E_INVALIDARG;
389: _numFastBytes = numFastBytes;
390: break;
391: }
392: case NCoderPropID::kAlgorithm:
393: {
394: if (prop.vt != VT_UI4)
395: return E_INVALIDARG;
396: UInt32 maximize = prop.ulVal;
397: _fastMode = (maximize == 0);
398: _maxMode = (maximize >= 2);
399: break;
400: }
401: case NCoderPropID::kMatchFinder:
402: {
403: if (prop.vt != VT_BSTR)
404: return E_INVALIDARG;
405: int matchFinderIndexPrev = _matchFinderIndex;
406: int m = FindMatchFinder(prop.bstrVal);
407: if (m < 0)
408: return E_INVALIDARG;
409: _matchFinderIndex = m;
410: if (_matchFinder && matchFinderIndexPrev != _matchFinderIndex)
411: {
412: _dictionarySizePrev = UInt32(-1);
413: _matchFinder.Release();
414: }
415: break;
416: }
417: #ifdef COMPRESS_MF_MT
418: case NCoderPropID::kMultiThread:
419: {
420: if (prop.vt != VT_BOOL)
421: return E_INVALIDARG;
422: bool newMultiThread = (prop.boolVal == VARIANT_TRUE);
423: if (newMultiThread != _multiThread)
424: {
425: _dictionarySizePrev = UInt32(-1);
426: _matchFinder.Release();
427: }
428: _multiThread = newMultiThread;
429: break;
430: }
431: #endif
432: case NCoderPropID::kDictionarySize:
433: {
434: const int kDicLogSizeMaxCompress = 28;
435: if (prop.vt != VT_UI4)
436: return E_INVALIDARG;
437: UInt32 dictionarySize = prop.ulVal;
438: if (dictionarySize < UInt32(1 << kDicLogSizeMin) ||
439: dictionarySize > UInt32(1 << kDicLogSizeMaxCompress))
440: return E_INVALIDARG;
441: _dictionarySize = dictionarySize;
442: UInt32 dicLogSize;
443: for(dicLogSize = 0; dicLogSize < (UInt32)kDicLogSizeMaxCompress; dicLogSize++)
444: if (dictionarySize <= (UInt32(1) << dicLogSize))
445: break;
446: _distTableSize = dicLogSize * 2;
447: break;
448: }
449: case NCoderPropID::kPosStateBits:
450: {
451: if (prop.vt != VT_UI4)
452: return E_INVALIDARG;
453: UInt32 value = prop.ulVal;
454: if (value > (UInt32)NLength::kNumPosStatesBitsEncodingMax)
455: return E_INVALIDARG;
456: _posStateBits = value;
457: _posStateMask = (1 << _posStateBits) - 1;
458: break;
459: }
460: case NCoderPropID::kLitPosBits:
461: {
462: if (prop.vt != VT_UI4)
463: return E_INVALIDARG;
464: UInt32 value = prop.ulVal;
465: if (value > (UInt32)kNumLitPosStatesBitsEncodingMax)
466: return E_INVALIDARG;
467: _numLiteralPosStateBits = value;
468: break;
469: }
470: case NCoderPropID::kLitContextBits:
471: {
472: if (prop.vt != VT_UI4)
473: return E_INVALIDARG;
474: UInt32 value = prop.ulVal;
475: if (value > (UInt32)kNumLitContextBitsMax)
476: return E_INVALIDARG;
477: _numLiteralContextBits = value;
478: break;
479: }
480: case NCoderPropID::kEndMarker:
481: {
482: if (prop.vt != VT_BOOL)
483: return E_INVALIDARG;
484: SetWriteEndMarkerMode(prop.boolVal == VARIANT_TRUE);
485: break;
486: }
487: default:
488: return E_INVALIDARG;
489: }
490: }
491: return S_OK;
492: }
493:
494: STDMETHODIMP CEncoder::WriteCoderProperties(ISequentialOutStream *outStream)
495: {
496: const UInt32 kPropSize = 5;
497: Byte properties[kPropSize];
498: properties[0] = (_posStateBits * 5 + _numLiteralPosStateBits) * 9 + _numLiteralContextBits;
499: for (int i = 0; i < 4; i++)
500: properties[1 + i] = Byte(_dictionarySize >> (8 * i));
501: return outStream->Write(properties, kPropSize, NULL);
502: }
503:
504: STDMETHODIMP CEncoder::SetOutStream(ISequentialOutStream *outStream)
505: {
506: _rangeEncoder.SetStream(outStream);
507: return S_OK;
508: }
509:
510: STDMETHODIMP CEncoder::ReleaseOutStream()
511: {
512: _rangeEncoder.ReleaseStream();
513: return S_OK;
514: }
515:
516: HRESULT CEncoder::Init()
517: {
518: CBaseState::Init();
519:
520: // RINOK(_matchFinder->Init(inStream));
521: _rangeEncoder.Init();
522:
523: for(int i = 0; i < kNumStates; i++)
524: {
525: for (UInt32 j = 0; j <= _posStateMask; j++)
526: {
527: _isMatch[i][j].Init();
528: _isRep0Long[i][j].Init();
529: }
530: _isRep[i].Init();
531: _isRepG0[i].Init();
532: _isRepG1[i].Init();
533: _isRepG2[i].Init();
534: }
535:
536: _literalEncoder.Init();
537:
538: // _repMatchLenEncoder.Init();
539:
540: {
541: for(UInt32 i = 0; i < kNumLenToPosStates; i++)
542: _posSlotEncoder[i].Init();
543: }
544: {
545: for(UInt32 i = 0; i < kNumFullDistances - kEndPosModelIndex; i++)
546: _posEncoders[i].Init();
547: }
548:
549: _lenEncoder.Init(1 << _posStateBits);
550: _repMatchLenEncoder.Init(1 << _posStateBits);
551:
552: _posAlignEncoder.Init();
553:
554: _longestMatchWasFound = false;
555: _optimumEndIndex = 0;
556: _optimumCurrentIndex = 0;
557: _additionalOffset = 0;
558:
559: return S_OK;
560: }
561:
562: HRESULT CEncoder::MovePos(UInt32 num)
563: {
564: for (;num != 0; num--)
565: {
566: _matchFinder->DummyLongestMatch();
567: RINOK(_matchFinder->MovePos());
568: _additionalOffset++;
569: }
570: return S_OK;
571: }
572:
573: UInt32 CEncoder::Backward(UInt32 &backRes, UInt32 cur)
574: {
575: _optimumEndIndex = cur;
576: UInt32 posMem = _optimum[cur].PosPrev;
577: UInt32 backMem = _optimum[cur].BackPrev;
578: do
579: {
580: if (_optimum[cur].Prev1IsChar)
581: {
582: _optimum[posMem].MakeAsChar();
583: _optimum[posMem].PosPrev = posMem - 1;
584: if (_optimum[cur].Prev2)
585: {
586: _optimum[posMem - 1].Prev1IsChar = false;
587: _optimum[posMem - 1].PosPrev = _optimum[cur].PosPrev2;
588: _optimum[posMem - 1].BackPrev = _optimum[cur].BackPrev2;
589: }
590: }
591: UInt32 posPrev = posMem;
592: UInt32 backCur = backMem;
593:
594: backMem = _optimum[posPrev].BackPrev;
595: posMem = _optimum[posPrev].PosPrev;
596:
597: _optimum[posPrev].BackPrev = backCur;
598: _optimum[posPrev].PosPrev = cur;
599: cur = posPrev;
600: }
601: while(cur != 0);
602: backRes = _optimum[0].BackPrev;
603: _optimumCurrentIndex = _optimum[0].PosPrev;
604: return _optimumCurrentIndex;
605: }
606:
607: /*
608: inline UInt32 GetMatchLen(const Byte *data, UInt32 back, UInt32 limit)
609: {
610: back++;
611: for(UInt32 i = 0; i < limit && data[i] == data[i - back]; i++);
612: return i;
613: }
614: */
615:
616: HRESULT CEncoder::GetOptimum(UInt32 position, UInt32 &backRes, UInt32 &lenRes)
617: {
618: if(_optimumEndIndex != _optimumCurrentIndex)
619: {
620: lenRes = _optimum[_optimumCurrentIndex].PosPrev - _optimumCurrentIndex;
621: backRes = _optimum[_optimumCurrentIndex].BackPrev;
622: _optimumCurrentIndex = _optimum[_optimumCurrentIndex].PosPrev;
623: return S_OK;
624: }
625: _optimumCurrentIndex = 0;
626: _optimumEndIndex = 0; // test it;
627:
628: UInt32 lenMain;
629: if (!_longestMatchWasFound)
630: {
631: RINOK(ReadMatchDistances(lenMain));
632: }
633: else
634: {
635: lenMain = _longestMatchLength;
636: _longestMatchWasFound = false;
637: }
638:
639:
640: UInt32 reps[kNumRepDistances];
641: UInt32 repLens[kNumRepDistances];
642: UInt32 repMaxIndex = 0;
643: UInt32 i;
644: for(i = 0; i < kNumRepDistances; i++)
645: {
646: reps[i] = _repDistances[i];
647: repLens[i] = _matchFinder->GetMatchLen(0 - 1, reps[i], kMatchMaxLen);
648: if (i == 0 || repLens[i] > repLens[repMaxIndex])
649: repMaxIndex = i;
650: }
651: if(repLens[repMaxIndex] > _numFastBytes)
652: {
653: backRes = repMaxIndex;
654: lenRes = repLens[repMaxIndex];
655: MovePos(lenRes - 1);
656: return S_OK;
657: }
658:
659: if(lenMain > _numFastBytes)
660: {
661: UInt32 backMain = (lenMain < _numFastBytes) ? _matchDistances[lenMain] :
662: _matchDistances[_numFastBytes];
663: backRes = backMain + kNumRepDistances;
664: MovePos(lenMain - 1);
665: lenRes = lenMain;
666: return S_OK;
667: }
668: Byte currentByte = _matchFinder->GetIndexByte(0 - 1);
669:
670: _optimum[0].State = _state;
671:
672: Byte matchByte;
673:
674: matchByte = _matchFinder->GetIndexByte(0 - _repDistances[0] - 1 - 1);
675:
676: UInt32 posState = (position & _posStateMask);
677:
678: _optimum[1].Price = _isMatch[_state.Index][posState].GetPrice0() +
679: _literalEncoder.GetPrice(position, _previousByte, !_state.IsCharState(), matchByte, currentByte);
680: _optimum[1].MakeAsChar();
681:
682: _optimum[1].PosPrev = 0;
683:
684: for (i = 0; i < kNumRepDistances; i++)
685: _optimum[0].Backs[i] = reps[i];
686:
687: UInt32 matchPrice = _isMatch[_state.Index][posState].GetPrice1();
688: UInt32 repMatchPrice = matchPrice + _isRep[_state.Index].GetPrice1();
689:
690: if(matchByte == currentByte)
691: {
692: UInt32 shortRepPrice = repMatchPrice + GetRepLen1Price(_state, posState);
693: if(shortRepPrice < _optimum[1].Price)
694: {
695: _optimum[1].Price = shortRepPrice;
696: _optimum[1].MakeAsShortRep();
697: }
698: }
699: if(lenMain < 2)
700: {
701: backRes = _optimum[1].BackPrev;
702: lenRes = 1;
703: return S_OK;
704: }
705:
706:
707: UInt32 normalMatchPrice = matchPrice +
708: _isRep[_state.Index].GetPrice0();
709:
710: if (lenMain <= repLens[repMaxIndex])
711: lenMain = 0;
712:
713: UInt32 len;
714: for(len = 2; len <= lenMain; len++)
715: {
716: _optimum[len].PosPrev = 0;
717: _optimum[len].BackPrev = _matchDistances[len] + kNumRepDistances;
718: _optimum[len].Price = normalMatchPrice +
719: GetPosLenPrice(_matchDistances[len], len, posState);
720: _optimum[len].Prev1IsChar = false;
721: }
722:
723: if (lenMain < repLens[repMaxIndex])
724: lenMain = repLens[repMaxIndex];
725:
726: for (; len <= lenMain; len++)
727: _optimum[len].Price = kIfinityPrice;
728:
729: for(i = 0; i < kNumRepDistances; i++)
730: {
731: UInt32 repLen = repLens[i];
732: for(UInt32 lenTest = 2; lenTest <= repLen; lenTest++)
733: {
734: UInt32 curAndLenPrice = repMatchPrice + GetRepPrice(i, lenTest, _state, posState);
735: COptimal &optimum = _optimum[lenTest];
736: if (curAndLenPrice < optimum.Price)
737: {
738: optimum.Price = curAndLenPrice;
739: optimum.PosPrev = 0;
740: optimum.BackPrev = i;
741: optimum.Prev1IsChar = false;
742: }
743: }
744: }
745:
746: UInt32 cur = 0;
747: UInt32 lenEnd = lenMain;
748:
749: while(true)
750: {
751: cur++;
752: if(cur == lenEnd)
753: {
754: lenRes = Backward(backRes, cur);
755: return S_OK;
756: }
757: position++;
758: UInt32 posPrev = _optimum[cur].PosPrev;
759: CState state;
760: if (_optimum[cur].Prev1IsChar)
761: {
762: posPrev--;
763: if (_optimum[cur].Prev2)
764: {
765: state = _optimum[_optimum[cur].PosPrev2].State;
766: if (_optimum[cur].BackPrev2 < kNumRepDistances)
767: state.UpdateRep();
768: else
769: state.UpdateMatch();
770: }
771: else
772: state = _optimum[posPrev].State;
773: state.UpdateChar();
774: }
775: else
776: state = _optimum[posPrev].State;
777: if (posPrev == cur - 1)
778: {
779: if (_optimum[cur].IsShortRep())
780: state.UpdateShortRep();
781: else
782: state.UpdateChar();
783: /*
784: if (_optimum[cur].Prev1IsChar)
785: for(int i = 0; i < kNumRepDistances; i++)
786: reps[i] = _optimum[posPrev].Backs[i];
787: */
788: }
789: else
790: {
791: UInt32 pos;
792: if (_optimum[cur].Prev1IsChar && _optimum[cur].Prev2)
793: {
794: posPrev = _optimum[cur].PosPrev2;
795: pos = _optimum[cur].BackPrev2;
796: state.UpdateRep();
797: }
798: else
799: {
800: pos = _optimum[cur].BackPrev;
801: if (pos < kNumRepDistances)
802: state.UpdateRep();
803: else
804: state.UpdateMatch();
805: }
806: if (pos < kNumRepDistances)
807: {
808: reps[0] = _optimum[posPrev].Backs[pos];
809: UInt32 i;
810: for(i = 1; i <= pos; i++)
811: reps[i] = _optimum[posPrev].Backs[i - 1];
812: for(; i < kNumRepDistances; i++)
813: reps[i] = _optimum[posPrev].Backs[i];
814: }
815: else
816: {
817: reps[0] = (pos - kNumRepDistances);
818: for(UInt32 i = 1; i < kNumRepDistances; i++)
819: reps[i] = _optimum[posPrev].Backs[i - 1];
820: }
821: }
822: _optimum[cur].State = state;
823: for(UInt32 i = 0; i < kNumRepDistances; i++)
824: _optimum[cur].Backs[i] = reps[i];
825: UInt32 newLen;
826: RINOK(ReadMatchDistances(newLen));
827: if(newLen > _numFastBytes)
828: {
829: _longestMatchLength = newLen;
830: _longestMatchWasFound = true;
831: lenRes = Backward(backRes, cur);
832: return S_OK;
833: }
834: UInt32 curPrice = _optimum[cur].Price;
835: // Byte currentByte = _matchFinder->GetIndexByte(0 - 1);
836: // Byte matchByte = _matchFinder->GetIndexByte(0 - reps[0] - 1 - 1);
837: const Byte *data = _matchFinder->GetPointerToCurrentPos() - 1;
838: Byte currentByte = *data;
839: Byte matchByte = data[(size_t)0 - reps[0] - 1];
840:
841: UInt32 posState = (position & _posStateMask);
842:
843: UInt32 curAnd1Price = curPrice +
844: _isMatch[state.Index][posState].GetPrice0() +
845: _literalEncoder.GetPrice(position, data[(size_t)0 - 1], !state.IsCharState(), matchByte, currentByte);
846:
847: COptimal &nextOptimum = _optimum[cur + 1];
848:
849: bool nextIsChar = false;
850: if (curAnd1Price < nextOptimum.Price)
851: {
852: nextOptimum.Price = curAnd1Price;
853: nextOptimum.PosPrev = cur;
854: nextOptimum.MakeAsChar();
855: nextIsChar = true;
856: }
857:
858: UInt32 matchPrice = curPrice + _isMatch[state.Index][posState].GetPrice1();
859: UInt32 repMatchPrice = matchPrice + _isRep[state.Index].GetPrice1();
860:
861: if(matchByte == currentByte &&
862: !(nextOptimum.PosPrev < cur && nextOptimum.BackPrev == 0))
863: {
864: UInt32 shortRepPrice = repMatchPrice + GetRepLen1Price(state, posState);
865: if(shortRepPrice <= nextOptimum.Price)
866: {
867: nextOptimum.Price = shortRepPrice;
868: nextOptimum.PosPrev = cur;
869: nextOptimum.MakeAsShortRep();
870: // nextIsChar = false;
871: }
872: }
873: /*
874: if(newLen == 2 && _matchDistances[2] >= kDistLimit2) // test it maybe set 2000 ?
875: continue;
876: */
877:
878: UInt32 numAvailableBytes = _matchFinder->GetNumAvailableBytes() + 1;
879: numAvailableBytes = MyMin(kNumOpts - 1 - cur, numAvailableBytes);
880:
881: if (numAvailableBytes < 2)
882: continue;
883: if (numAvailableBytes > _numFastBytes)
884: numAvailableBytes = _numFastBytes;
885: if (numAvailableBytes >= 3 && !nextIsChar)
886: {
887: UInt32 backOffset = reps[0] + 1;
888: UInt32 temp;
889: for (temp = 1; temp < numAvailableBytes; temp++)
890: if (data[temp] != data[(size_t)temp - backOffset])
891: break;
892: UInt32 lenTest2 = temp - 1;
893: if (lenTest2 >= 2)
894: {
895: CState state2 = state;
896: state2.UpdateChar();
897: UInt32 posStateNext = (position + 1) & _posStateMask;
898: UInt32 nextRepMatchPrice = curAnd1Price +
899: _isMatch[state2.Index][posStateNext].GetPrice1() +
900: _isRep[state2.Index].GetPrice1();
901: // for (; lenTest2 >= 2; lenTest2--)
902: {
903: while(lenEnd < cur + 1 + lenTest2)
904: _optimum[++lenEnd].Price = kIfinityPrice;
905: UInt32 curAndLenPrice = nextRepMatchPrice + GetRepPrice(
906: 0, lenTest2, state2, posStateNext);
907: COptimal &optimum = _optimum[cur + 1 + lenTest2];
908: if (curAndLenPrice < optimum.Price)
909: {
910: optimum.Price = curAndLenPrice;
911: optimum.PosPrev = cur + 1;
912: optimum.BackPrev = 0;
913: optimum.Prev1IsChar = true;
914: optimum.Prev2 = false;
915: }
916: }
917: }
918: }
919: for(UInt32 repIndex = 0; repIndex < kNumRepDistances; repIndex++)
920: {
921: // UInt32 repLen = _matchFinder->GetMatchLen(0 - 1, reps[repIndex], newLen); // test it;
922: UInt32 backOffset = reps[repIndex] + 1;
923: UInt32 lenTest;
924: for (lenTest = 0; lenTest < numAvailableBytes; lenTest++)
925: if (data[lenTest] != data[(size_t)lenTest - backOffset])
926: break;
927: for(; lenTest >= 2; lenTest--)
928: {
929: while(lenEnd < cur + lenTest)
930: _optimum[++lenEnd].Price = kIfinityPrice;
931: UInt32 curAndLenPrice = repMatchPrice + GetRepPrice(repIndex, lenTest, state, posState);
932: COptimal &optimum = _optimum[cur + lenTest];
933: if (curAndLenPrice < optimum.Price)
934: {
935: optimum.Price = curAndLenPrice;
936: optimum.PosPrev = cur;
937: optimum.BackPrev = repIndex;
938: optimum.Prev1IsChar = false;
939: }
940:
941: /*
942: if (_maxMode)
943: {
944: UInt32 temp;
945: for (temp = lenTest + 1; temp < numAvailableBytes; temp++)
946: if (data[temp] != data[(size_t)temp - backOffset])
947: break;
948: UInt32 lenTest2 = temp - (lenTest + 1);
949: if (lenTest2 >= 2)
950: {
951: CState state2 = state;
952: state2.UpdateRep();
953: UInt32 posStateNext = (position + lenTest) & _posStateMask;
954: UInt32 curAndLenCharPrice = curAndLenPrice +
955: _isMatch[state2.Index][posStateNext].GetPrice0() +
956: _literalEncoder.GetPrice(position + lenTest, data[(size_t)lenTest - 1],
957: true, data[(size_t)lenTest - backOffset], data[lenTest]);
958: state2.UpdateChar();
959: posStateNext = (position + lenTest + 1) & _posStateMask;
960: UInt32 nextMatchPrice = curAndLenCharPrice + _isMatch[state2.Index][posStateNext].GetPrice1();
961: UInt32 nextRepMatchPrice = nextMatchPrice + _isRep[state2.Index].GetPrice1();
962:
963: // for(; lenTest2 >= 2; lenTest2--)
964: {
965: UInt32 offset = lenTest + 1 + lenTest2;
966: while(lenEnd < cur + offset)
967: _optimum[++lenEnd].Price = kIfinityPrice;
968: UInt32 curAndLenPrice = nextRepMatchPrice + GetRepPrice(
969: 0, lenTest2, state2, posStateNext);
970: COptimal &optimum = _optimum[cur + offset];
971: if (curAndLenPrice < optimum.Price)
972: {
973: optimum.Price = curAndLenPrice;
974: optimum.PosPrev = cur + lenTest + 1;
975: optimum.BackPrev = 0;
976: optimum.Prev1IsChar = true;
977: optimum.Prev2 = true;
978: optimum.PosPrev2 = cur;
979: optimum.BackPrev2 = repIndex;
980: }
981: }
982: }
983: }
984: */
985: }
986: }
987:
988: // for(UInt32 lenTest = 2; lenTest <= newLen; lenTest++)
989: if (newLen > numAvailableBytes)
990: newLen = numAvailableBytes;
991: if (newLen >= 2)
992: {
993: if (newLen == 2 && _matchDistances[2] >= 0x80)
994: continue;
995: UInt32 normalMatchPrice = matchPrice +
996: _isRep[state.Index].GetPrice0();
997: while(lenEnd < cur + newLen)
998: _optimum[++lenEnd].Price = kIfinityPrice;
999:
1000: for(UInt32 lenTest = newLen; lenTest >= 2; lenTest--)
1001: {
1002: UInt32 curBack = _matchDistances[lenTest];
1003: UInt32 curAndLenPrice = normalMatchPrice + GetPosLenPrice(curBack, lenTest, posState);
1004: COptimal &optimum = _optimum[cur + lenTest];
1005: if (curAndLenPrice < optimum.Price)
1006: {
1007: optimum.Price = curAndLenPrice;
1008: optimum.PosPrev = cur;
1009: optimum.BackPrev = curBack + kNumRepDistances;
1010: optimum.Prev1IsChar = false;
1011: }
1012:
1013: if (_maxMode)
1014: {
1015: UInt32 backOffset = curBack + 1;
1016: UInt32 temp;
1017: for (temp = lenTest + 1; temp < numAvailableBytes; temp++)
1018: if (data[temp] != data[(size_t)temp - backOffset])
1019: break;
1020: UInt32 lenTest2 = temp - (lenTest + 1);
1021: if (lenTest2 >= 2)
1022: {
1023: CState state2 = state;
1024: state2.UpdateMatch();
1025: UInt32 posStateNext = (position + lenTest) & _posStateMask;
1026: UInt32 curAndLenCharPrice = curAndLenPrice +
1027: _isMatch[state2.Index][posStateNext].GetPrice0() +
1028: _literalEncoder.GetPrice(position + lenTest, data[(size_t)lenTest - 1],
1029: true, data[(size_t)lenTest - backOffset], data[lenTest]);
1030: state2.UpdateChar();
1031: posStateNext = (position + lenTest + 1) & _posStateMask;
1032: UInt32 nextMatchPrice = curAndLenCharPrice + _isMatch[state2.Index][posStateNext].GetPrice1();
1033: UInt32 nextRepMatchPrice = nextMatchPrice + _isRep[state2.Index].GetPrice1();
1034:
1035: // for(; lenTest2 >= 2; lenTest2--)
1036: {
1037: UInt32 offset = lenTest + 1 + lenTest2;
1038: while(lenEnd < cur + offset)
1039: _optimum[++lenEnd].Price = kIfinityPrice;
1040: UInt32 curAndLenPrice = nextRepMatchPrice + GetRepPrice(
1041: 0, lenTest2, state2, posStateNext);
1042: COptimal &optimum = _optimum[cur + offset];
1043: if (curAndLenPrice < optimum.Price)
1044: {
1045: optimum.Price = curAndLenPrice;
1046: optimum.PosPrev = cur + lenTest + 1;
1047: optimum.BackPrev = 0;
1048: optimum.Prev1IsChar = true;
1049: optimum.Prev2 = true;
1050: optimum.PosPrev2 = cur;
1051: optimum.BackPrev2 = curBack + kNumRepDistances;
1052: }
1053: }
1054: }
1055: }
1056: }
1057: }
1058: }
1059: }
1060:
1061: static inline bool ChangePair(UInt32 smallDist, UInt32 bigDist)
1062: {
1063: const int kDif = 7;
1064: return (smallDist < (UInt32(1) << (32-kDif)) && bigDist >= (smallDist << kDif));
1065: }
1066:
1067:
1068: HRESULT CEncoder::ReadMatchDistances(UInt32 &lenRes)
1069: {
1070: lenRes = _matchFinder->GetLongestMatch(_matchDistances);
1071: if (lenRes == _numFastBytes)
1072: lenRes += _matchFinder->GetMatchLen(lenRes, _matchDistances[lenRes],
1073: kMatchMaxLen - lenRes);
1074: _additionalOffset++;
1075: return _matchFinder->MovePos();
1076: }
1077:
1078: HRESULT CEncoder::GetOptimumFast(UInt32 position, UInt32 &backRes, UInt32 &lenRes)
1079: {
1080: UInt32 lenMain;
1081: if (!_longestMatchWasFound)
1082: {
1083: RINOK(ReadMatchDistances(lenMain));
1084: }
1085: else
1086: {
1087: lenMain = _longestMatchLength;
1088: _longestMatchWasFound = false;
1089: }
1090: UInt32 repLens[kNumRepDistances];
1091: UInt32 repMaxIndex = 0;
1092: for(UInt32 i = 0; i < kNumRepDistances; i++)
1093: {
1094: repLens[i] = _matchFinder->GetMatchLen(0 - 1, _repDistances[i], kMatchMaxLen);
1095: if (i == 0 || repLens[i] > repLens[repMaxIndex])
1096: repMaxIndex = i;
1097: }
1098: if(repLens[repMaxIndex] >= _numFastBytes)
1099: {
1100: backRes = repMaxIndex;
1101: lenRes = repLens[repMaxIndex];
1102: MovePos(lenRes - 1);
1103: return S_OK;
1104: }
1105: if(lenMain >= _numFastBytes)
1106: {
1107: backRes = _matchDistances[_numFastBytes] + kNumRepDistances;
1108: MovePos(lenMain - 1);
1109: lenRes = lenMain;
1110: return S_OK;
1111: }
1112: while (lenMain > 2)
1113: {
1114: if (!ChangePair(_matchDistances[lenMain - 1], _matchDistances[lenMain]))
1115: break;
1116: lenMain--;
1117: }
1118: if (lenMain == 2 && _matchDistances[2] >= 0x80)
1119: lenMain = 1;
1120:
1121: UInt32 backMain = _matchDistances[lenMain];
1122: if (repLens[repMaxIndex] >= 2)
1123: {
1124: if (repLens[repMaxIndex] + 1 >= lenMain ||
1125: repLens[repMaxIndex] + 2 >= lenMain && (backMain > (1<<12)))
1126: {
1127: backRes = repMaxIndex;
1128: lenRes = repLens[repMaxIndex];
1129: MovePos(lenRes - 1);
1130: return S_OK;
1131: }
1132: }
1133:
1134:
1135: if (lenMain >= 2)
1136: {
1137: RINOK(ReadMatchDistances(_longestMatchLength));
1138: if (_longestMatchLength >= 2 &&
1139: (
1140: (_longestMatchLength >= lenMain && _matchDistances[lenMain] < backMain) ||
1141: _longestMatchLength == lenMain + 1 &&
1142: !ChangePair(backMain, _matchDistances[_longestMatchLength]) ||
1143: _longestMatchLength > lenMain + 1 ||
1144: _longestMatchLength + 1 >= lenMain && lenMain >= 3 &&
1145: ChangePair(_matchDistances[lenMain - 1], backMain)
1146: )
1147: )
1148: {
1149: _longestMatchWasFound = true;
1150: backRes = UInt32(-1);
1151: lenRes = 1;
1152: return S_OK;
1153: }
1154: for(UInt32 i = 0; i < kNumRepDistances; i++)
1155: {
1156: UInt32 repLen = _matchFinder->GetMatchLen(0 - 1, _repDistances[i], kMatchMaxLen);
1157: if (repLen >= 2 && repLen + 1 >= lenMain)
1158: {
1159: _longestMatchWasFound = true;
1160: backRes = UInt32(-1);
1161: lenRes = 1;
1162: return S_OK;
1163: }
1164: }
1165: backRes = backMain + kNumRepDistances;
1166: MovePos(lenMain - 2);
1167: lenRes = lenMain;
1168: return S_OK;
1169: }
1170: backRes = UInt32(-1);
1171: lenRes = 1;
1172: return S_OK;
1173: }
1174:
1175: STDMETHODIMP CEncoder::InitMatchFinder(IMatchFinder *matchFinder)
1176: {
1177: _matchFinder = matchFinder;
1178: return S_OK;
1179: }
1180:
1181: HRESULT CEncoder::Flush(UInt32 nowPos)
1182: {
1183: ReleaseMFStream();
1184: WriteEndMarker(nowPos & _posStateMask);
1185: _rangeEncoder.FlushData();
1186: return _rangeEncoder.FlushStream();
1187: }
1188:
1189: void CEncoder::WriteEndMarker(UInt32 posState)
1190: {
1191: // This function for writing End Mark for stream version of LZMA.
1192: // In current version this feature is not used.
1193: if (!_writeEndMark)
1194: return;
1195:
1196: _isMatch[_state.Index][posState].Encode(&_rangeEncoder, 1);
1197: _isRep[_state.Index].Encode(&_rangeEncoder, 0);
1198: _state.UpdateMatch();
1199: UInt32 len = kMatchMinLen; // kMatchMaxLen;
1200: _lenEncoder.Encode(&_rangeEncoder, len - kMatchMinLen, posState);
1201: UInt32 posSlot = (1 << kNumPosSlotBits) - 1;
1202: UInt32 lenToPosState = GetLenToPosState(len);
1203: _posSlotEncoder[lenToPosState].Encode(&_rangeEncoder, posSlot);
1204: UInt32 footerBits = 30;
1205: UInt32 posReduced = (UInt32(1) << footerBits) - 1;
1206: _rangeEncoder.EncodeDirectBits(posReduced >> kNumAlignBits, footerBits - kNumAlignBits);
1207: _posAlignEncoder.ReverseEncode(&_rangeEncoder, posReduced & kAlignMask);
1208: }
1209:
1210: HRESULT CEncoder::CodeReal(ISequentialInStream *inStream,
1211: ISequentialOutStream *outStream,
1212: const UInt64 *inSize, const UInt64 *outSize,
1213: ICompressProgressInfo *progress)
1214: {
1215: _needReleaseMFStream = false;
1216: CCoderReleaser coderReleaser(this);
1217: RINOK(SetStreams(inStream, outStream, inSize, outSize));
1218: while(true)
1219: {
1220: UInt64 processedInSize;
1221: UInt64 processedOutSize;
1222: Int32 finished;
1223: RINOK(CodeOneBlock(&processedInSize, &processedOutSize, &finished));
1224: if (finished != 0)
1225: return S_OK;
1226: if (progress != 0)
1227: {
1228: RINOK(progress->SetRatioInfo(&processedInSize, &processedOutSize));
1229: }
1230: }
1231: }
1232:
1233: HRESULT CEncoder::SetStreams(ISequentialInStream *inStream,
1234: ISequentialOutStream *outStream,
1235: const UInt64 *inSize, const UInt64 *outSize)
1236: {
1237: _inStream = inStream;
1238: _finished = false;
1239: RINOK(Create());
1240: RINOK(SetOutStream(outStream));
1241: RINOK(Init());
1242:
1243: // CCoderReleaser releaser(this);
1244:
1245: /*
1246: if (_matchFinder->GetNumAvailableBytes() == 0)
1247: return Flush();
1248: */
1249:
1250: if (!_fastMode)
1251: {
1252: FillPosSlotPrices();
1253: FillDistancesPrices();
1254: FillAlignPrices();
1255: }
1256:
1257: _lenEncoder.SetTableSize(_numFastBytes);
1258: _lenEncoder.UpdateTables(1 << _posStateBits);
1259: _repMatchLenEncoder.SetTableSize(_numFastBytes);
1260: _repMatchLenEncoder.UpdateTables(1 << _posStateBits);
1261:
1262: lastPosSlotFillingPos = 0;
1263: nowPos64 = 0;
1264: return S_OK;
1265: }
1266:
1267: HRESULT CEncoder::CodeOneBlock(UInt64 *inSize, UInt64 *outSize, Int32 *finished)
1268: {
1269: if (_inStream != 0)
1270: {
1271: RINOK(_matchFinder->Init(_inStream));
1272: _needReleaseMFStream = true;
1273: _inStream = 0;
1274: }
1275:
1276:
1277: *finished = 1;
1278: if (_finished)
1279: return S_OK;
1280: _finished = true;
1281:
1282:
1283: UInt64 progressPosValuePrev = nowPos64;
1284: if (nowPos64 == 0)
1285: {
1286: if (_matchFinder->GetNumAvailableBytes() == 0)
1287: return Flush(UInt32(nowPos64));
1288: UInt32 len; // it's not used
1289: RINOK(ReadMatchDistances(len));
1290: UInt32 posState = UInt32(nowPos64) & _posStateMask;
1291: _isMatch[_state.Index][posState].Encode(&_rangeEncoder, 0);
1292: _state.UpdateChar();
1293: Byte curByte = _matchFinder->GetIndexByte(0 - _additionalOffset);
1294: _literalEncoder.GetSubCoder(UInt32(nowPos64), _previousByte)->Encode(&_rangeEncoder, curByte);
1295: _previousByte = curByte;
1296: _additionalOffset--;
1297: nowPos64++;
1298: }
1299: if (_matchFinder->GetNumAvailableBytes() == 0)
1300: return Flush(UInt32(nowPos64));
1301: while(true)
1302: {
1303: #ifdef _NO_EXCEPTIONS
1304: if (_rangeEncoder.Stream.ErrorCode != S_OK)
1305: return _rangeEncoder.Stream.ErrorCode;
1306: #endif
1307: UInt32 pos;
1308: UInt32 posState = UInt32(nowPos64) & _posStateMask;
1309:
1310: UInt32 len;
1311: HRESULT result;
1312: if (_fastMode)
1313: result = GetOptimumFast(UInt32(nowPos64), pos, len);
1314: else
1315: result = GetOptimum(UInt32(nowPos64), pos, len);
1316: RINOK(result);
1317:
1318: if(len == 1 && pos == 0xFFFFFFFF)
1319: {
1320: _isMatch[_state.Index][posState].Encode(&_rangeEncoder, 0);
1321: Byte curByte = _matchFinder->GetIndexByte(0 - _additionalOffset);
1322: CLiteralEncoder2 *subCoder = _literalEncoder.GetSubCoder(UInt32(nowPos64), _previousByte);
1323: if(!_state.IsCharState())
1324: {
1325: Byte matchByte = _matchFinder->GetIndexByte(0 - _repDistances[0] - 1 - _additionalOffset);
1326: subCoder->EncodeMatched(&_rangeEncoder, matchByte, curByte);
1327: }
1328: else
1329: subCoder->Encode(&_rangeEncoder, curByte);
1330: _state.UpdateChar();
1331: _previousByte = curByte;
1332: }
1333: else
1334: {
1335: _isMatch[_state.Index][posState].Encode(&_rangeEncoder, 1);
1336: if(pos < kNumRepDistances)
1337: {
1338: _isRep[_state.Index].Encode(&_rangeEncoder, 1);
1339: if(pos == 0)
1340: {
1341: _isRepG0[_state.Index].Encode(&_rangeEncoder, 0);
1342: if(len == 1)
1343: _isRep0Long[_state.Index][posState].Encode(&_rangeEncoder, 0);
1344: else
1345: _isRep0Long[_state.Index][posState].Encode(&_rangeEncoder, 1);
1346: }
1347: else
1348: {
1349: _isRepG0[_state.Index].Encode(&_rangeEncoder, 1);
1350: if (pos == 1)
1351: _isRepG1[_state.Index].Encode(&_rangeEncoder, 0);
1352: else
1353: {
1354: _isRepG1[_state.Index].Encode(&_rangeEncoder, 1);
1355: _isRepG2[_state.Index].Encode(&_rangeEncoder, pos - 2);
1356: }
1357: }
1358: if (len == 1)
1359: _state.UpdateShortRep();
1360: else
1361: {
1362: _repMatchLenEncoder.Encode(&_rangeEncoder, len - kMatchMinLen, posState);
1363: _state.UpdateRep();
1364: }
1365:
1366:
1367: UInt32 distance = _repDistances[pos];
1368: if (pos != 0)
1369: {
1370: for(UInt32 i = pos; i >= 1; i--)
1371: _repDistances[i] = _repDistances[i - 1];
1372: _repDistances[0] = distance;
1373: }
1374: }
1375: else
1376: {
1377: _isRep[_state.Index].Encode(&_rangeEncoder, 0);
1378: _state.UpdateMatch();
1379: _lenEncoder.Encode(&_rangeEncoder, len - kMatchMinLen, posState);
1380: pos -= kNumRepDistances;
1381: UInt32 posSlot = GetPosSlot(pos);
1382: UInt32 lenToPosState = GetLenToPosState(len);
1383: _posSlotEncoder[lenToPosState].Encode(&_rangeEncoder, posSlot);
1384:
1385: if (posSlot >= kStartPosModelIndex)
1386: {
1387: UInt32 footerBits = ((posSlot >> 1) - 1);
1388: UInt32 base = ((2 | (posSlot & 1)) << footerBits);
1389: UInt32 posReduced = pos - base;
1390:
1391: if (posSlot < kEndPosModelIndex)
1392: NRangeCoder::ReverseBitTreeEncode(_posEncoders + base - posSlot - 1,
1393: &_rangeEncoder, footerBits, posReduced);
1394: else
1395: {
1396: _rangeEncoder.EncodeDirectBits(posReduced >> kNumAlignBits, footerBits - kNumAlignBits);
1397: _posAlignEncoder.ReverseEncode(&_rangeEncoder, posReduced & kAlignMask);
1398: if (!_fastMode)
1399: if (--_alignPriceCount == 0)
1400: FillAlignPrices();
1401: }
1402: }
1403: UInt32 distance = pos;
1404: for(UInt32 i = kNumRepDistances - 1; i >= 1; i--)
1405: _repDistances[i] = _repDistances[i - 1];
1406: _repDistances[0] = distance;
1407: }
1408: _previousByte = _matchFinder->GetIndexByte(len - 1 - _additionalOffset);
1409: }
1410: _additionalOffset -= len;
1411: nowPos64 += len;
1412: if (!_fastMode)
1413: if (nowPos64 - lastPosSlotFillingPos >= (1 << 9))
1414: {
1415: FillPosSlotPrices();
1416: FillDistancesPrices();
1417: lastPosSlotFillingPos = nowPos64;
1418: }
1419: if (_additionalOffset == 0)
1420: {
1421: *inSize = nowPos64;
1422: *outSize = _rangeEncoder.GetProcessedSize();
1423: if (_matchFinder->GetNumAvailableBytes() == 0)
1424: return Flush(UInt32(nowPos64));
1425: if (nowPos64 - progressPosValuePrev >= (1 << 12))
1426: {
1427: _finished = false;
1428: *finished = 0;
1429: return S_OK;
1430: }
1431: }
1432: }
1433: }
1434:
1435: STDMETHODIMP CEncoder::Code(ISequentialInStream *inStream,
1436: ISequentialOutStream *outStream, const UInt64 *inSize, const UInt64 *outSize,
1437: ICompressProgressInfo *progress)
1438: {
1439: #ifndef _NO_EXCEPTIONS
1440: try
1441: {
1442: #endif
1443: return CodeReal(inStream, outStream, inSize, outSize, progress);
1444: #ifndef _NO_EXCEPTIONS
1445: }
1446: catch(const COutBufferException &e) { return e.ErrorCode; }
1447: catch(...) { return E_FAIL; }
1448: #endif
1449: }
1450:
1451: void CEncoder::FillPosSlotPrices()
1452: {
1453: for (UInt32 lenToPosState = 0; lenToPosState < kNumLenToPosStates; lenToPosState++)
1454: {
1455: UInt32 posSlot;
1456: for (posSlot = 0; posSlot < kEndPosModelIndex && posSlot < _distTableSize; posSlot++)
1457: _posSlotPrices[lenToPosState][posSlot] = _posSlotEncoder[lenToPosState].GetPrice(posSlot);
1458: for (; posSlot < _distTableSize; posSlot++)
1459: _posSlotPrices[lenToPosState][posSlot] = _posSlotEncoder[lenToPosState].GetPrice(posSlot) +
1460: ((((posSlot >> 1) - 1) - kNumAlignBits) << NRangeCoder::kNumBitPriceShiftBits);
1461: }
1462: }
1463:
1464: void CEncoder::FillDistancesPrices()
1465: {
1466: for (UInt32 lenToPosState = 0; lenToPosState < kNumLenToPosStates; lenToPosState++)
1467: {
1468: UInt32 i;
1469: for (i = 0; i < kStartPosModelIndex; i++)
1470: _distancesPrices[lenToPosState][i] = _posSlotPrices[lenToPosState][i];
1471: for (; i < kNumFullDistances; i++)
1472: {
1473: UInt32 posSlot = GetPosSlot(i);
1474: UInt32 footerBits = ((posSlot >> 1) - 1);
1475: UInt32 base = ((2 | (posSlot & 1)) << footerBits);
1476:
1477: _distancesPrices[lenToPosState][i] = _posSlotPrices[lenToPosState][posSlot] +
1478: NRangeCoder::ReverseBitTreeGetPrice(_posEncoders +
1479: base - posSlot - 1, footerBits, i - base);
1480:
1481: }
1482: }
1483: }
1484:
1485: void CEncoder::FillAlignPrices()
1486: {
1487: for (UInt32 i = 0; i < kAlignTableSize; i++)
1488: _alignPrices[i] = _posAlignEncoder.ReverseGetPrice(i);
1489: _alignPriceCount = kAlignTableSize;
1490: }
1491:
1492: }}
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to LZMAEncoder.cpp 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