private void DecodeBinarySymbol(PpmContext context)
{
PpmState state = context.FirstState;
int index1 = probabilities[state.Frequency - 1];
int index2 = numberStatisticsToBinarySummaryIndex[context.Suffix.NumberStatistics] + previousSuccess +
context.Flags + ((runLength >> 26) & 0x20);
if (Coder.RangeGetCurrentShiftCount(TotalBitCount) < binarySummary[index1, index2])
{
foundState = state;
state.Frequency += (byte)((state.Frequency < 196) ? 1 : 0);
Coder.LowCount = 0;
Coder.HighCount = binarySummary[index1, index2];
binarySummary[index1, index2] +=
(ushort)(Interval - Mean(binarySummary[index1, index2], PeriodBitCount, 2));
previousSuccess = 1;
runLength++;
}
else
{
Coder.LowCount = binarySummary[index1, index2];
binarySummary[index1, index2] -= (ushort)Mean(binarySummary[index1, index2], PeriodBitCount, 2);
Coder.HighCount = BinaryScale;
initialEscape = ExponentialEscapes[binarySummary[index1, index2] >> 10];
characterMask[state.Symbol] = escapeCount;
previousSuccess = 0;
numberMasked = 0;
foundState = PpmState.Zero;
}
}
private void DecodeBinarySymbol(PpmContext context)
{
PpmState state = context.FirstState;
int index1 = _probabilities[state.Frequency - 1];
int index2 = _numberStatisticsToBinarySummaryIndex[context.Suffix.NumberStatistics] + _previousSuccess +
context.Flags + ((_runLength >> 26) & 0x20);
if (_coder.RangeGetCurrentShiftCount(TOTAL_BIT_COUNT) < _binarySummary[index1, index2])
{
_foundState = state;
state.Frequency += (byte)((state.Frequency < 196) ? 1 : 0);
_coder._lowCount = 0;
_coder._highCount = _binarySummary[index1, index2];
_binarySummary[index1, index2] +=
(ushort)(INTERVAL - Mean(_binarySummary[index1, index2], PERIOD_BIT_COUNT, 2));
_previousSuccess = 1;
_runLength++;
}
else
{
_coder._lowCount = _binarySummary[index1, index2];
_binarySummary[index1, index2] -= (ushort)Mean(_binarySummary[index1, index2], PERIOD_BIT_COUNT, 2);
_coder._highCount = BINARY_SCALE;
_initialEscape = EXPONENTIAL_ESCAPES[_binarySummary[index1, index2] >> 10];
_characterMask[state.Symbol] = _escapeCount;
_previousSuccess = 0;
_numberMasked = 0;
_foundState = PpmState.ZERO;
}
}
private void Refresh(uint oldUnitCount, bool scale, PpmContext context)
{
int index = context.NumberStatistics;
int escapeFrequency;
int scaleValue = (scale ? 1 : 0);
context.Statistics = _allocator.ShrinkUnits(context.Statistics, oldUnitCount, (uint)((index + 2) >> 1));
PpmState statistics = context.Statistics;
context.Flags =
(byte)((context.Flags & (0x10 + (scale ? 0x04 : 0x00))) + ((statistics.Symbol >= 0x40) ? 0x08 : 0x00));
escapeFrequency = context.SummaryFrequency - statistics.Frequency;
statistics.Frequency = (byte)((statistics.Frequency + scaleValue) >> scaleValue);
context.SummaryFrequency = statistics.Frequency;
do
{
escapeFrequency -= (++statistics).Frequency;
statistics.Frequency = (byte)((statistics.Frequency + scaleValue) >> scaleValue);
context.SummaryFrequency += statistics.Frequency;
context.Flags |= (byte)((statistics.Symbol >= 0x40) ? 0x08 : 0x00);
}while (--index != 0);
escapeFrequency = (escapeFrequency + scaleValue) >> scaleValue;
context.SummaryFrequency += (ushort)escapeFrequency;
}
/// <summary>
/// Indicates whether this instance and a specified object are equal.
/// </summary>
/// <returns>true if obj and this instance are the same type and represent the same value; otherwise, false.</returns>
/// <param name="obj">Another object to compare to.</param>
public override bool Equals(object obj)
{
if (obj is PpmState)
{
PpmState state = (PpmState)obj;
return(state.Address == Address);
}
return(base.Equals(obj));
}
private void Update2(PpmState state, PpmContext context)
{
_foundState = state;
_foundState.Frequency += 4;
context.SummaryFrequency += 4;
if (state.Frequency > MAXIMUM_FREQUENCY)
{
Rescale(context);
}
_escapeCount++;
_runLength = _initialRunLength;
}
private void DecodeSymbol2(PpmContext context)
{
See2Context see2Context = MakeEscapeFrequency(context);
uint currentSymbol;
uint count;
uint highCount = 0;
uint index = (uint)(context.NumberStatistics - _numberMasked);
uint stateIndex = 0;
PpmState state = context.Statistics - 1;
do
{
do
{
currentSymbol = state[1].Symbol;
state++;
}while (_characterMask[currentSymbol] == _escapeCount);
highCount += state.Frequency;
_decodeStates[stateIndex++] = state;
// note that decodeStates is a static array that is re-used on each call to this method (for performance reasons)
}while (--index != 0);
_coder._scale += highCount;
count = _coder.RangeGetCurrentCount();
stateIndex = 0;
state = _decodeStates[stateIndex];
if (count < highCount)
{
highCount = 0;
while ((highCount += state.Frequency) <= count)
{
state = _decodeStates[++stateIndex];
}
_coder._highCount = highCount;
_coder._lowCount = _coder._highCount - state.Frequency;
see2Context.Update();
Update2(state, context);
}
else
{
_coder._lowCount = highCount;
_coder._highCount = _coder._scale;
index = (uint)(context.NumberStatistics - _numberMasked);
_numberMasked = context.NumberStatistics;
do
{
_characterMask[_decodeStates[stateIndex].Symbol] = _escapeCount;
stateIndex++;
}while (--index != 0);
see2Context._summary += (ushort)_coder._scale;
}
}
private void Update2(PpmState state, PpmContext context)
{
foundState = state;
foundState.Frequency += 4;
context.SummaryFrequency += 4;
if (state.Frequency > MaximumFrequency)
{
Rescale(context);
}
escapeCount++;
runLength = initialRunLength;
}
private void DecodeSymbol1(PpmContext context)
{
uint index;
uint count;
uint highCount = context.Statistics.Frequency;
PpmState state = context.Statistics;
_coder._scale = context.SummaryFrequency;
count = _coder.RangeGetCurrentCount();
if (count < highCount)
{
_coder._highCount = highCount;
_previousSuccess = (byte)((2 * _coder._highCount >= _coder._scale) ? 1 : 0);
_foundState = state;
highCount += 4;
_foundState.Frequency = (byte)highCount;
context.SummaryFrequency += 4;
_runLength += _previousSuccess;
if (highCount > MAXIMUM_FREQUENCY)
{
Rescale(context);
}
_coder._lowCount = 0;
return;
}
index = context.NumberStatistics;
_previousSuccess = 0;
while ((highCount += (++state).Frequency) <= count)
{
if (--index == 0)
{
_coder._lowCount = highCount;
_characterMask[state.Symbol] = _escapeCount;
_numberMasked = context.NumberStatistics;
index = context.NumberStatistics;
_foundState = PpmState.ZERO;
do
{
_characterMask[(--state).Symbol] = _escapeCount;
}while (--index != 0);
_coder._highCount = _coder._scale;
return;
}
}
_coder._highCount = highCount;
_coder._lowCount = _coder._highCount - state.Frequency;
Update1(state, context);
}
private void DecodeSymbol1(PpmContext context)
{
uint index;
uint count;
uint highCount = context.Statistics.Frequency;
PpmState state = context.Statistics;
Coder.Scale = context.SummaryFrequency;
count = Coder.RangeGetCurrentCount();
if (count < highCount)
{
Coder.HighCount = highCount;
previousSuccess = (byte)((2 * Coder.HighCount >= Coder.Scale) ? 1 : 0);
foundState = state;
highCount += 4;
foundState.Frequency = (byte)highCount;
context.SummaryFrequency += 4;
runLength += previousSuccess;
if (highCount > MaximumFrequency)
{
Rescale(context);
}
Coder.LowCount = 0;
return;
}
index = context.NumberStatistics;
previousSuccess = 0;
while ((highCount += (++state).Frequency) <= count)
{
if (--index == 0)
{
Coder.LowCount = highCount;
characterMask[state.Symbol] = escapeCount;
numberMasked = context.NumberStatistics;
index = context.NumberStatistics;
foundState = PpmState.Zero;
do
{
characterMask[(--state).Symbol] = escapeCount;
}while (--index != 0);
Coder.HighCount = Coder.Scale;
return;
}
}
Coder.HighCount = highCount;
Coder.LowCount = Coder.HighCount - state.Frequency;
Update1(state, context);
}
private void Update1(PpmState state, PpmContext context)
{
_foundState = state;
_foundState.Frequency += 4;
context.SummaryFrequency += 4;
if (state[0].Frequency > state[-1].Frequency)
{
Swap(state[0], state[-1]);
_foundState = --state;
if (state.Frequency > MAXIMUM_FREQUENCY)
{
Rescale(context);
}
}
}
private void Update1(PpmState state, PpmContext context)
{
foundState = state;
foundState.Frequency += 4;
context.SummaryFrequency += 4;
if (state[0].Frequency > state[-1].Frequency)
{
Swap(state[0], state[-1]);
foundState = --state;
if (state.Frequency > MaximumFrequency)
{
Rescale(context);
}
}
}
private void EncodeSymbol2(int symbol, PpmContext context)
{
See2Context see2Context = MakeEscapeFrequency(context);
uint currentSymbol;
uint lowCount = 0;
uint index = (uint)(context.NumberStatistics - _numberMasked);
PpmState state = context.Statistics - 1;
do
{
do
{
currentSymbol = state[1].Symbol;
state++;
}while (_characterMask[currentSymbol] == _escapeCount);
_characterMask[currentSymbol] = _escapeCount;
if (currentSymbol == symbol)
{
goto SymbolFound;
}
lowCount += state.Frequency;
}while (--index != 0);
_coder._lowCount = lowCount;
_coder._scale += _coder._lowCount;
_coder._highCount = _coder._scale;
see2Context._summary += (ushort)_coder._scale;
_numberMasked = context.NumberStatistics;
return;
SymbolFound:
_coder._lowCount = lowCount;
lowCount += state.Frequency;
_coder._highCount = lowCount;
for (PpmState p1 = state; --index != 0;)
{
do
{
currentSymbol = p1[1].Symbol;
p1++;
}while (_characterMask[currentSymbol] == _escapeCount);
lowCount += p1.Frequency;
}
_coder._scale += lowCount;
see2Context.Update();
Update2(state, context);
}
private void EncodeSymbol1(int symbol, PpmContext context)
{
uint lowCount;
uint index = context.Statistics.Symbol;
PpmState state = context.Statistics;
_coder._scale = context.SummaryFrequency;
if (index == symbol)
{
_coder._highCount = state.Frequency;
_previousSuccess = (byte)((2 * _coder._highCount >= _coder._scale) ? 1 : 0);
_foundState = state;
_foundState.Frequency += 4;
context.SummaryFrequency += 4;
_runLength += _previousSuccess;
if (state.Frequency > MAXIMUM_FREQUENCY)
{
Rescale(context);
}
_coder._lowCount = 0;
return;
}
lowCount = state.Frequency;
index = context.NumberStatistics;
_previousSuccess = 0;
while ((++state).Symbol != symbol)
{
lowCount += state.Frequency;
if (--index == 0)
{
_coder._lowCount = lowCount;
_characterMask[state.Symbol] = _escapeCount;
_numberMasked = context.NumberStatistics;
index = context.NumberStatistics;
_foundState = PpmState.ZERO;
do
{
_characterMask[(--state).Symbol] = _escapeCount;
}while (--index != 0);
_coder._highCount = _coder._scale;
return;
}
}
_coder._highCount = (_coder._lowCount = lowCount) + state.Frequency;
Update1(state, context);
}
private void EncodeSymbol1(int symbol, PpmContext context)
{
uint lowCount;
uint index = context.Statistics.Symbol;
PpmState state = context.Statistics;
Coder.Scale = context.SummaryFrequency;
if (index == symbol)
{
Coder.HighCount = state.Frequency;
previousSuccess = (byte)((2 * Coder.HighCount >= Coder.Scale) ? 1 : 0);
foundState = state;
foundState.Frequency += 4;
context.SummaryFrequency += 4;
runLength += previousSuccess;
if (state.Frequency > MaximumFrequency)
{
Rescale(context);
}
Coder.LowCount = 0;
return;
}
lowCount = state.Frequency;
index = context.NumberStatistics;
previousSuccess = 0;
while ((++state).Symbol != symbol)
{
lowCount += state.Frequency;
if (--index == 0)
{
Coder.LowCount = lowCount;
characterMask[state.Symbol] = escapeCount;
numberMasked = context.NumberStatistics;
index = context.NumberStatistics;
foundState = PpmState.Zero;
do
{
characterMask[(--state).Symbol] = escapeCount;
}while (--index != 0);
Coder.HighCount = Coder.Scale;
return;
}
}
Coder.HighCount = (Coder.LowCount = lowCount) + state.Frequency;
Update1(state, context);
}
private PpmContext RemoveBinaryContexts(int order, PpmContext context)
{
if (context.NumberStatistics == 0)
{
PpmState state = context.FirstState;
if ((Pointer)state.Successor >= Allocator.BaseUnit && order < modelOrder)
{
state.Successor = RemoveBinaryContexts(order + 1, state.Successor);
}
else
{
state.Successor = PpmContext.Zero;
}
if ((state.Successor == PpmContext.Zero) &&
(context.Suffix.NumberStatistics == 0 || context.Suffix.Flags == 0xff))
{
Allocator.FreeUnits(context, 1);
return(PpmContext.Zero);
}
else
{
return(context);
}
}
for (PpmState state = context.Statistics + context.NumberStatistics; state >= context.Statistics; state--)
{
if ((Pointer)state.Successor >= Allocator.BaseUnit && order < modelOrder)
{
state.Successor = RemoveBinaryContexts(order + 1, state.Successor);
}
else
{
state.Successor = PpmContext.Zero;
}
}
return(context);
}
private void Update2(PpmState state, PpmContext context)
{
foundState = state;
foundState.Frequency += 4;
context.SummaryFrequency += 4;
if (state.Frequency > MaximumFrequency)
Rescale(context);
escapeCount++;
runLength = initialRunLength;
}
private void Update1(PpmState state, PpmContext context)
{
foundState = state;
foundState.Frequency += 4;
context.SummaryFrequency += 4;
if (state[0].Frequency > state[-1].Frequency)
{
Swap(state[0], state[-1]);
foundState = --state;
if (state.Frequency > MaximumFrequency)
Rescale(context);
}
}
