LzmaEnc.c - OpenGrok cross reference for /third

Lines Matching defs:price
264   UInt32 price;

870   UInt32 price = 0;

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

879   return price;

885   UInt32 price = 0;

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

896   return price;

968     UInt32 price = startPrice;

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

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

973     prices[i    ] = price + GET_PRICEa_0(prob);

974     prices[i + 1] = price + GET_PRICEa_1(prob);

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

1040         UInt32 price = b;

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

1051           prices[(size_t)i * 2    ] = price + GET_PRICEa_0(prob);

1052           prices[(size_t)i * 2 + 1] = price + GET_PRICEa_1(prob);

1144   UInt32 price;

1148     price = GET_PRICE_0(prob);

1149     price += GET_PRICE_1(p->isRep0Long[state][posState]);

1153     price = GET_PRICE_1(prob);

1156       price += GET_PRICE_0(prob);

1159       price += GET_PRICE_1(prob);

1160       price += GET_PRICE(p->isRepG2[state], repIndex - 2);

1163   return price;

1314       p->opt[1].price = GET_PRICE_0(p->isMatch[p->state][posState]) +

1329       if (shortRepPrice < p->opt[1].price)

1331         p->opt[1].price = shortRepPrice;

1353       UInt32 price;

1356       price = repMatchPrice + GetPrice_PureRep(p, i, p->state, posState);

1359         UInt32 price2 = price + GET_PRICE_LEN(&p->repLenEnc, posState, repLen);

1361         if (price2 < opt->price)

1363           opt->price = price2;

1391           UInt32 price = normalMatchPrice + GET_PRICE_LEN(&p->lenEnc, posState, len);

1395             price += p->distancesPrices[lenToPosState][dist & (kNumFullDistances - 1)];

1400             price += p->alignPrices[dist & kAlignMask];

1401             price += p->posSlotPrices[lenToPosState][slot];

1406           if (price < opt->price)

1408             opt->price = price;

1433       printf("\nprice[%4X] = %u", position - cur + i, p->opt[i].price);

1460       UInt32 price = p->opt[cur].price;

1464         UInt32 price2 = p->opt[j].price;

1465         if (price >= price2)

1467           price = price2;

1497     if (curOpt->price >= kInfinityPrice)

1594       UInt32 curPrice = curOpt->price;

1603     // here we can allow skip_items in p->opt, if we don't check (nextOpt->price < kInfinityPrice)

1605     if ((nextOpt->price < kInfinityPrice

1608         || litPrice > nextOpt->price

1618       if (litPrice < nextOpt->price)

1620         nextOpt->price = litPrice;

1640     if (repMatchPrice < nextOpt->price) // 18.new

1643         // nextOpt->price >= kInfinityPrice ||

1651       // if (shortRepPrice <= nextOpt->price) // 17.old

1652       if (shortRepPrice < nextOpt->price)  // 18.new

1654         nextOpt->price = shortRepPrice;

1687           UInt32 price = litPrice + GetPrice_Rep_0(p, state2, posState2);

1699               // price2 = price + GetPrice_Len_Rep_0(p, len, state2, posState2);

1700               price2 = price + GET_PRICE_LEN(&p->repLenEnc, posState2, len);

1704               if (price2 < opt->price)

1706                 opt->price = price2;

1727         UInt32 price;

1744           price = repMatchPrice + GetPrice_PureRep(p, repIndex, state, posState);

1747             UInt32 price2 = price + GET_PRICE_LEN(&p->repLenEnc, posState, len2);

1749             if (price2 < opt->price)

1751               opt->price = price2;

1780             price += GET_PRICE_LEN(&p->repLenEnc, posState, len)

1790             price += GetPrice_Rep_0(p, state2, posState2);

1808                 // price2 = price + GetPrice_Len_Rep_0(p, len2, state2, posState2);

1809                 price2 = price + GET_PRICE_LEN(&p->repLenEnc, posState2, len2);

1813                 if (price2 < opt->price)

1815                   opt->price = price2;

1864         UInt32 price = normalMatchPrice + GET_PRICE_LEN(&p->lenEnc, posState, len);

1870             price += p->distancesPrices[lenNorm][dist & (kNumFullDistances - 1)];

1872             price += p->posSlotPrices[lenNorm][posSlot] + p->alignPrices[dist & kAlignMask];

1875           if (price < opt->price)

1877             opt->price = price;

1910             price += GET_PRICE_0(p->isMatch[state2][posState2]);

1911             price += LitEnc_Matched_GetPrice(LIT_PROBS(position + len, data[(size_t)len - 1]),

1918             price += GetPrice_Rep_0(p, state2, posState2);

1929               // price2 = price + GetPrice_Len_Rep_0(p, len2, state2, posState2);

1930               price2 = price + GET_PRICE_LEN(&p->repLenEnc, posState2, len2);

1933               if (price2 < opt->price)

1935                 opt->price = price2;

1958     p->opt[last].price = kInfinityPrice;

2210     UInt32 price = 0;

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;

2219     p->alignPrices[i    ] = price + GET_PRICEa_0(prob);

2220     p->alignPrices[i + 8] = price + GET_PRICEa_1(prob);

2243     UInt32 price = 0;

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

2261       tempPrices[base         ] = price + GET_PRICEa_0(prob);

2262       tempPrices[base + offset] = price + GET_PRICEa_1(prob);

2276       UInt32 price;

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);

2286       posSlotPrices[(size_t)slot * 2    ] = price + GET_PRICEa_0(prob);

2287       posSlotPrices[(size_t)slot * 2 + 1] = price + GET_PRICEa_1(prob);

2821       p->opt[i].price = kInfinityPrice;