Lines Matching defs:p
26 #define IF_BIT_0(p) ttt = *(p); NORMALIZE; bound = (range >> kNumBitModelTotalBits) * ttt; if (code < bound)
27 #define UPDATE_0(p) range = bound; *(p) = (CLzmaProb)(ttt + ((kBitModelTotal - ttt) >> kNumMoveBits));
28 #define UPDATE_1(p) range -= bound; code -= bound; *(p) = (CLzmaProb)(ttt - (ttt >> kNumMoveBits));
29 #define GET_BIT2(p, i, A0, A1) IF_BIT_0(p) \
30 { UPDATE_0(p); i = (i + i); A0; } else \
31 { UPDATE_1(p); i = (i + i) + 1; A1; }
32 #define GET_BIT(p, i) GET_BIT2(p, i, ; , ;)
56 #define IF_BIT_0_CHECK(p) ttt = *(p); NORMALIZE_CHECK; bound = (range >> kNumBitModelTotalBits) * ttt; if (code < bound)
59 #define GET_BIT2_CHECK(p, i, A0, A1) IF_BIT_0_CHECK(p) \
62 #define GET_BIT_CHECK(p, i) GET_BIT2_CHECK(p, i, ; , ;)
117 #define LzmaProps_GetNumProbs(p) ((UInt32)LZMA_BASE_SIZE + (LZMA_LIT_SIZE << ((p)->lc + (p)->lp)))
141 p->remainLen:
148 static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, SizeT limit, const Byte *bufLimit)
150 CLzmaProb *probs = p->probs;
152 unsigned state = p->state;
153 UInt32 rep0 = p->reps[0], rep1 = p->reps[1], rep2 = p->reps[2], rep3 = p->reps[3];
154 unsigned pbMask = ((unsigned)1 << (p->prop.pb)) - 1;
155 unsigned lpMask = ((unsigned)1 << (p->prop.lp)) - 1;
156 unsigned lc = p->prop.lc;
158 Byte *dic = p->dic;
159 SizeT dicBufSize = p->dicBufSize;
160 SizeT dicPos = p->dicPos;
162 UInt32 processedPos = p->processedPos;
163 UInt32 checkDicSize = p->checkDicSize;
166 const Byte *buf = p->buf;
167 UInt32 range = p->range;
168 UInt32 code = p->code;
194 unsigned matchByte = p->dic[(dicPos - rep0) + ((dicPos < rep0) ? dicBufSize : 0)];
432 p->buf = buf;
433 p->range = range;
434 p->code = code;
435 p->remainLen = len;
436 p->dicPos = dicPos;
437 p->processedPos = processedPos;
438 p->reps[0] = rep0;
439 p->reps[1] = rep1;
440 p->reps[2] = rep2;
441 p->reps[3] = rep3;
442 p->state = state;
447 static void MY_FAST_CALL LzmaDec_WriteRem(CLzmaDec *p, SizeT limit)
449 if (p->remainLen != 0 && p->remainLen < kMatchSpecLenStart)
451 Byte *dic = p->dic;
452 SizeT dicPos = p->dicPos;
453 SizeT dicBufSize = p->dicBufSize;
454 unsigned len = p->remainLen;
455 UInt32 rep0 = p->reps[0];
459 if (p->checkDicSize == 0 && p->prop.dicSize - p->processedPos <= len)
460 p->checkDicSize = p->prop.dicSize;
462 p->processedPos += len;
463 p->remainLen -= len;
469 p->dicPos = dicPos;
473 static int MY_FAST_CALL LzmaDec_DecodeReal2(CLzmaDec *p, SizeT limit, const Byte *bufLimit)
478 if (p->checkDicSize == 0)
480 UInt32 rem = p->prop.dicSize - p->processedPos;
481 if (limit - p->dicPos > rem)
482 limit2 = p->dicPos + rem;
484 RINOK(LzmaDec_DecodeReal(p, limit2, bufLimit));
485 if (p->processedPos >= p->prop.dicSize)
486 p->checkDicSize = p->prop.dicSize;
487 LzmaDec_WriteRem(p, limit);
489 while (p->dicPos < limit && p->buf < bufLimit && p->remainLen < kMatchSpecLenStart);
491 if (p->remainLen > kMatchSpecLenStart)
493 p->remainLen = kMatchSpecLenStart;
506 static ELzmaDummy LzmaDec_TryDummy(const CLzmaDec *p, const Byte *buf, SizeT inSize)
508 UInt32 range = p->range;
509 UInt32 code = p->code;
511 CLzmaProb *probs = p->probs;
512 unsigned state = p->state;
519 unsigned posState = (p->processedPos) & ((1 << p->prop.pb) - 1);
529 if (p->checkDicSize != 0 || p->processedPos != 0)
531 ((((p->processedPos) & ((1 << (p->prop.lp)) - 1)) << p->prop.lc) +
532 (p->dic[(p->dicPos == 0 ? p->dicBufSize : p->dicPos) - 1] >> (8 - p->prop.lc))));
541 unsigned matchByte = p->dic[p->dicPos - p->reps[0] +
542 ((p->dicPos < p->reps[0]) ? p->dicBufSize : 0)];
697 static void LzmaDec_InitRc(CLzmaDec *p, const Byte *data)
699 p->code = ((UInt32)data[1] << 24) | ((UInt32)data[2] << 16) | ((UInt32)data[3] << 8) | ((UInt32)data[4]);
700 p->range = 0xFFFFFFFF;
701 p->needFlush = 0;
704 void LzmaDec_InitDicAndState(CLzmaDec *p, Bool initDic, Bool initState)
706 p->needFlush = 1;
707 p->remainLen = 0;
708 p->tempBufSize = 0;
712 p->processedPos = 0;
713 p->checkDicSize = 0;
714 p->needInitState = 1;
717 p->needInitState = 1;
720 void LzmaDec_Init(CLzmaDec *p)
722 p->dicPos = 0;
723 LzmaDec_InitDicAndState(p, True, True);
726 static void LzmaDec_InitStateReal(CLzmaDec *p)
728 UInt32 numProbs = Literal + ((UInt32)LZMA_LIT_SIZE << (p->prop.lc + p->prop.lp));
730 CLzmaProb *probs = p->probs;
733 p->reps[0] = p->reps[1] = p->reps[2] = p->reps[3] = 1;
734 p->state = 0;
735 p->needInitState = 0;
738 SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit, const Byte *src, SizeT *srcLen,
743 LzmaDec_WriteRem(p, dicLimit);
747 while (p->remainLen != kMatchSpecLenStart)
751 if (p->needFlush != 0)
753 for (; inSize > 0 && p->tempBufSize < RC_INIT_SIZE; (*srcLen)++, inSize--)
754 p->tempBuf[p->tempBufSize++] = *src++;
755 if (p->tempBufSize < RC_INIT_SIZE)
760 if (p->tempBuf[0] != 0)
763 LzmaDec_InitRc(p, p->tempBuf);
764 p->tempBufSize = 0;
768 if (p->dicPos >= dicLimit)
770 if (p->remainLen == 0 && p->code == 0)
780 if (p->remainLen != 0)
788 if (p->needInitState)
789 LzmaDec_InitStateReal(p);
791 if (p->tempBufSize == 0)
797 int dummyRes = LzmaDec_TryDummy(p, src, inSize);
800 (void) memcpy(p->tempBuf, src, inSize);
801 p->tempBufSize = (unsigned)inSize;
815 p->buf = src;
816 if (LzmaDec_DecodeReal2(p, dicLimit, bufLimit) != 0)
819 processed = (SizeT)(p->buf - src);
826 unsigned rem = p->tempBufSize, lookAhead = 0;
828 p->tempBuf[rem++] = src[lookAhead++];
829 p->tempBufSize = rem;
832 int dummyRes = LzmaDec_TryDummy(p, p->tempBuf, rem);
845 p->buf = p->tempBuf;
846 if (LzmaDec_DecodeReal2(p, dicLimit, p->buf) != 0)
849 lookAhead -= (rem - (unsigned)(p->buf - p->tempBuf));
853 p->tempBufSize = 0;
856 if (p->code == 0)
858 return (p->code == 0) ? SZ_OK : SZ_ERROR_DATA;
861 SRes LzmaDec_DecodeToBuf(CLzmaDec *p, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status)
871 if (p->dicPos == p->dicBufSize)
872 p->dicPos = 0;
873 dicPos = p->dicPos;
874 if (outSize > p->dicBufSize - dicPos)
876 outSizeCur = p->dicBufSize;
885 res = LzmaDec_DecodeToDic(p, outSizeCur, src, &inSizeCur, curFinishMode, status);
889 outSizeCur = p->dicPos - dicPos;
890 (void) memcpy(dest, p->dic + dicPos, outSizeCur);
901 void LzmaDec_FreeProbs(CLzmaDec *p, ISzAlloc *alloc)
903 if (p->probs != 0)
904 alloc->Free(alloc, p->probs, (p->numProbs * sizeof (*p->probs)));
905 p->probs = 0;
908 static void LzmaDec_FreeDict(CLzmaDec *p, ISzAlloc *alloc)
910 if (p->dic != 0)
911 alloc->Free(alloc, p->dic, ((p->prop).dicSize * sizeof (*p->dic)));
912 p->dic = 0;
915 void LzmaDec_Free(CLzmaDec *p, ISzAlloc *alloc)
917 LzmaDec_FreeProbs(p, alloc);
918 LzmaDec_FreeDict(p, alloc);
921 SRes LzmaProps_Decode(CLzmaProps *p, const Byte *data, unsigned size)
933 p->dicSize = dicSize;
939 p->lc = d % 9;
941 p->pb = d / 5;
942 p->lp = d % 5;
947 static SRes LzmaDec_AllocateProbs2(CLzmaDec *p, const CLzmaProps *propNew, ISzAlloc *alloc)
950 if (p->probs == 0 || numProbs != p->numProbs)
952 LzmaDec_FreeProbs(p, alloc);
953 p->probs = (CLzmaProb *)alloc->Alloc(alloc, numProbs * sizeof(CLzmaProb));
954 p->numProbs = numProbs;
955 if (p->probs == 0)
961 SRes LzmaDec_AllocateProbs(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAlloc *alloc)
965 RINOK(LzmaDec_AllocateProbs2(p, &propNew, alloc));
966 p->prop = propNew;
970 SRes LzmaDec_Allocate(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAlloc *alloc)
975 RINOK(LzmaDec_AllocateProbs2(p, &propNew, alloc));
977 if (p->dic == 0 || dicBufSize != p->dicBufSize)
979 LzmaDec_FreeDict(p, alloc);
980 p->dic = (Byte *)alloc->Alloc(alloc, dicBufSize);
981 if (p->dic == 0)
983 LzmaDec_FreeProbs(p, alloc);
987 p->dicBufSize = dicBufSize;
988 p->prop = propNew;
996 CLzmaDec p;
1004 LzmaDec_Construct(&p);
1005 res = LzmaDec_AllocateProbs(&p, propData, propSize, alloc);
1008 p.dic = dest;
1009 p.dicBufSize = outSize;
1011 LzmaDec_Init(&p);
1014 res = LzmaDec_DecodeToDic(&p, outSize, src, srcLen, finishMode, status);
1019 (*destLen) = p.dicPos;
1020 LzmaDec_FreeProbs(&p, alloc);