LzmaEnc.c - OpenGrok cross reference for /third

Lines Matching defs:probs
789 static void LitEnc_Encode(CRangeEnc *p, CLzmaProb *probs, UInt32 sym)

796     // RangeEnc_EncodeBit(p, probs + (sym >> 8), (sym >> 7) & 1);

797     CLzmaProb *prob = probs + (sym >> 8);

806 static void LitEnc_EncodeMatched(CRangeEnc *p, CLzmaProb *probs, UInt32 sym, UInt32 matchByte)

817     // RangeEnc_EncodeBit(p, probs + (offs + (matchByte & offs) + (sym >> 8)), (sym >> 7) & 1);

818     prob = probs + (offs + (matchByte & offs) + (sym >> 8));

868 static UInt32 LitEnc_GetPrice(const CLzmaProb *probs, UInt32 sym, const CProbPrice *ProbPrices)

876     price += GET_PRICEa(probs[sym], bit);

883 static UInt32 LitEnc_Matched_GetPrice(const CLzmaProb *probs, UInt32 sym, UInt32 matchByte, const CProbPrice *ProbPrices)

891     price += GET_PRICEa(probs[offs + (matchByte & offs) + (sym >> 8)], (sym >> 7) & 1);

900 static void RcTree_ReverseEncode(CRangeEnc *rc, CLzmaProb *probs, unsigned numBits, unsigned sym)

908     // RangeEnc_EncodeBit(rc, probs + m, bit);

910     RC_BIT(rc, probs + m, bit)

931   CLzmaProb *probs = p->low;

933   RC_BIT_PRE(rc, probs)

936     RC_BIT_1(rc, probs)

937     probs += kLenNumLowSymbols;

938     RC_BIT_PRE(rc, probs)

941       RC_BIT_1(rc, probs)

950   // RcTree_Encode(rc, probs + (posState << kLenNumLowBits), kLenNumLowBits, sym);

954     RC_BIT_0(rc, probs)

955     probs += (posState << (1 + kLenNumLowBits));

956     bit = (sym >> 2)    ; RC_BIT(rc, probs + 1, bit)  m = (1 << 1) + bit;

957     bit = (sym >> 1) & 1; RC_BIT(rc, probs + m, bit)  m = (m << 1) + bit;

958     bit =  sym       & 1; RC_BIT(rc, probs + m, bit)

963 static void SetPrices_3(const CLzmaProb *probs, UInt32 startPrice, UInt32 *prices, const CProbPrice *ProbPrices)

970     price += GET_PRICEa(probs[1           ], (i >> 2));

971     price += GET_PRICEa(probs[2 + (i >> 2)], (i >> 1) & 1);

972     prob = probs[4 + (i >> 1)];

997       const CLzmaProb *probs = enc->low + (posState << (1 + kLenNumLowBits));

998       SetPrices_3(probs, a, prices, ProbPrices);

999       SetPrices_3(probs + kLenNumLowSymbols, c, prices + kLenNumLowSymbols, ProbPrices);

1026       const CLzmaProb *probs = enc->high;

1036         LitEnc_GetPrice(probs, i - kLenNumLowSymbols * 2, ProbPrices);

1038         // UInt32 price = a + RcTree_GetPrice(probs, kLenNumHighBits - 1, sym, ProbPrices);

1045           price += GET_PRICEa(probs[sym], bit);

1050           unsigned prob = probs[(size_t)i + (1 << (kLenNumHighBits - 1))];

1313       const CLzmaProb *probs = LIT_PROBS(position, *(data - 1));

1316           LitEnc_Matched_GetPrice(probs, curByte, matchByte, p->ProbPrices) :

1317           LitEnc_GetPrice(probs, curByte, p->ProbPrices));

1613       const CLzmaProb *probs = LIT_PROBS(position, *(data - 1));

1615           LitEnc_Matched_GetPrice(probs, curByte, matchByte, p->ProbPrices) :

1616           LitEnc_GetPrice(probs, curByte, p->ProbPrices));

2121     CLzmaProb *probs = p->posSlotEncoder[0];

2126       RC_BIT_PRE(p, probs + m)

2127       RC_BIT_1(&p->rc, probs + m)

2146     CLzmaProb *probs = p->posAlignEncoder;

2151       RC_BIT_PRE(p, probs + m)

2152       RC_BIT_1(&p->rc, probs + m)

2206   const CLzmaProb *probs = p->posAlignEncoder;

2215     bit = sym & 1; sym >>= 1; price += GET_PRICEa(probs[m], bit); m = (m << 1) + bit;

2216     bit = sym & 1; sym >>= 1; price += GET_PRICEa(probs[m], bit); m = (m << 1) + bit;

2217     bit = sym & 1; sym >>= 1; price += GET_PRICEa(probs[m], bit); m = (m << 1) + bit;

2218     prob = probs[m];

2241     const CLzmaProb *probs = p->posEncoders + (size_t)base * 2;

2254       price += GET_PRICEa(probs[m], bit);

2260       unsigned prob = probs[m];

2271     const CLzmaProb *probs = p->posSlotEncoder[lps];

2280       bit = sym & 1; sym >>= 1; price  = GET_PRICEa(probs[sym], bit);

2281       bit = sym & 1; sym >>= 1; price += GET_PRICEa(probs[sym], bit);

2282       bit = sym & 1; sym >>= 1; price += GET_PRICEa(probs[sym], bit);

2283       bit = sym & 1; sym >>= 1; price += GET_PRICEa(probs[sym], bit);

2284       bit = sym & 1; sym >>= 1; price += GET_PRICEa(probs[sym], bit);

2285       prob = probs[(size_t)slot + (1 << (kNumPosSlotBits - 1))];

2427     CLzmaProb *probs;

2447     probs = &p->isMatch[p->state][posState];

2449     RC_BIT_PRE(&p->rc, probs)

2463       RC_BIT_0(&p->rc, probs)

2466       probs = LIT_PROBS(nowPos32, *(data - 1));

2471         LitEnc_Encode(&p->rc, probs, curByte);

2473         LitEnc_EncodeMatched(&p->rc, probs, curByte, *(data - p->reps[0]));

2477       RC_BIT_1(&p->rc, probs)

2478       probs = &p->isRep[p->state];

2479       RC_BIT_PRE(&p->rc, probs)

2483         RC_BIT_1(&p->rc, probs)

2484         probs = &p->isRepG0[p->state];

2485         RC_BIT_PRE(&p->rc, probs)

2488           RC_BIT_0(&p->rc, probs)

2489           probs = &p->isRep0Long[p->state][posState];

2490           RC_BIT_PRE(&p->rc, probs)

2493             RC_BIT_1_BASE(&p->rc, probs)

2497             RC_BIT_0_BASE(&p->rc, probs)

2503           RC_BIT_1(&p->rc, probs)

2504           probs = &p->isRepG1[p->state];

2505           RC_BIT_PRE(&p->rc, probs)

2508             RC_BIT_0_BASE(&p->rc, probs)

2513             RC_BIT_1(&p->rc, probs)

2514             probs = &p->isRepG2[p->state];

2515             RC_BIT_PRE(&p->rc, probs)

2518               RC_BIT_0_BASE(&p->rc, probs)

2523               RC_BIT_1_BASE(&p->rc, probs)

2547         RC_BIT_0(&p->rc, probs)

2566           probs = p->posSlotEncoder[GetLenToPosState(len)];

2569             CLzmaProb *prob = probs + (sym >> kNumPosSlotBits);

2793       CLzmaProb *probs = p->posSlotEncoder[i];

2796         probs[j] = kProbInitValue;

2807     CLzmaProb *probs = p->litProbs;

2809       probs[k] = kProbInitValue;