/* Ppmd7.c -- PPMdH codec | |
2010-03-12 : Igor Pavlov : Public domain | |
This code is based on PPMd var.H (2001): Dmitry Shkarin : Public domain */ | |
#include "Precomp.h" | |
#include <memory.h> | |
#include "Ppmd7.h" | |
const Byte PPMD7_kExpEscape[16] = { 25, 14, 9, 7, 5, 5, 4, 4, 4, 3, 3, 3, 2, 2, 2, 2 }; | |
static const UInt16 kInitBinEsc[] = { 0x3CDD, 0x1F3F, 0x59BF, 0x48F3, 0x64A1, 0x5ABC, 0x6632, 0x6051}; | |
#define MAX_FREQ 124 | |
#define UNIT_SIZE 12 | |
#define U2B(nu) ((UInt32)(nu) * UNIT_SIZE) | |
#define U2I(nu) (p->Units2Indx[(nu) - 1]) | |
#define I2U(indx) (p->Indx2Units[indx]) | |
#ifdef PPMD_32BIT | |
#define REF(ptr) (ptr) | |
#else | |
#define REF(ptr) ((UInt32)((Byte *)(ptr) - (p)->Base)) | |
#endif | |
#define STATS_REF(ptr) ((CPpmd_State_Ref)REF(ptr)) | |
#define CTX(ref) ((CPpmd7_Context *)Ppmd7_GetContext(p, ref)) | |
#define STATS(ctx) Ppmd7_GetStats(p, ctx) | |
#define ONE_STATE(ctx) Ppmd7Context_OneState(ctx) | |
#define SUFFIX(ctx) CTX((ctx)->Suffix) | |
typedef CPpmd7_Context * CTX_PTR; | |
struct CPpmd7_Node_; | |
typedef | |
#ifdef PPMD_32BIT | |
struct CPpmd7_Node_ * | |
#else | |
UInt32 | |
#endif | |
CPpmd7_Node_Ref; | |
typedef struct CPpmd7_Node_ | |
{ | |
UInt16 Stamp; /* must be at offset 0 as CPpmd7_Context::NumStats. Stamp=0 means free */ | |
UInt16 NU; | |
CPpmd7_Node_Ref Next; /* must be at offset >= 4 */ | |
CPpmd7_Node_Ref Prev; | |
} CPpmd7_Node; | |
#ifdef PPMD_32BIT | |
#define NODE(ptr) (ptr) | |
#else | |
#define NODE(offs) ((CPpmd7_Node *)(p->Base + (offs))) | |
#endif | |
void Ppmd7_Construct(CPpmd7 *p) | |
{ | |
unsigned i, k, m; | |
p->Base = 0; | |
for (i = 0, k = 0; i < PPMD_NUM_INDEXES; i++) | |
{ | |
unsigned step = (i >= 12 ? 4 : (i >> 2) + 1); | |
do { p->Units2Indx[k++] = (Byte)i; } while(--step); | |
p->Indx2Units[i] = (Byte)k; | |
} | |
p->NS2BSIndx[0] = (0 << 1); | |
p->NS2BSIndx[1] = (1 << 1); | |
memset(p->NS2BSIndx + 2, (2 << 1), 9); | |
memset(p->NS2BSIndx + 11, (3 << 1), 256 - 11); | |
for (i = 0; i < 3; i++) | |
p->NS2Indx[i] = (Byte)i; | |
for (m = i, k = 1; i < 256; i++) | |
{ | |
p->NS2Indx[i] = (Byte)m; | |
if (--k == 0) | |
k = (++m) - 2; | |
} | |
memset(p->HB2Flag, 0, 0x40); | |
memset(p->HB2Flag + 0x40, 8, 0x100 - 0x40); | |
} | |
void Ppmd7_Free(CPpmd7 *p, ISzAlloc *alloc) | |
{ | |
alloc->Free(alloc, p->Base); | |
p->Size = 0; | |
p->Base = 0; | |
} | |
Bool Ppmd7_Alloc(CPpmd7 *p, UInt32 size, ISzAlloc *alloc) | |
{ | |
if (p->Base == 0 || p->Size != size) | |
{ | |
Ppmd7_Free(p, alloc); | |
p->AlignOffset = | |
#ifdef PPMD_32BIT | |
(4 - size) & 3; | |
#else | |
4 - (size & 3); | |
#endif | |
if ((p->Base = (Byte *)alloc->Alloc(alloc, p->AlignOffset + size | |
#ifndef PPMD_32BIT | |
+ UNIT_SIZE | |
#endif | |
)) == 0) | |
return False; | |
p->Size = size; | |
} | |
return True; | |
} | |
static void InsertNode(CPpmd7 *p, void *node, unsigned indx) | |
{ | |
*((CPpmd_Void_Ref *)node) = p->FreeList[indx]; | |
p->FreeList[indx] = REF(node); | |
} | |
static void *RemoveNode(CPpmd7 *p, unsigned indx) | |
{ | |
CPpmd_Void_Ref *node = (CPpmd_Void_Ref *)Ppmd7_GetPtr(p, p->FreeList[indx]); | |
p->FreeList[indx] = *node; | |
return node; | |
} | |
static void SplitBlock(CPpmd7 *p, void *ptr, unsigned oldIndx, unsigned newIndx) | |
{ | |
unsigned i, nu = I2U(oldIndx) - I2U(newIndx); | |
ptr = (Byte *)ptr + U2B(I2U(newIndx)); | |
if (I2U(i = U2I(nu)) != nu) | |
{ | |
unsigned k = I2U(--i); | |
InsertNode(p, ((Byte *)ptr) + U2B(k), nu - k - 1); | |
} | |
InsertNode(p, ptr, i); | |
} | |
static void GlueFreeBlocks(CPpmd7 *p) | |
{ | |
#ifdef PPMD_32BIT | |
CPpmd7_Node headItem; | |
CPpmd7_Node_Ref head = &headItem; | |
#else | |
CPpmd7_Node_Ref head = p->AlignOffset + p->Size; | |
#endif | |
CPpmd7_Node_Ref n = head; | |
unsigned i; | |
p->GlueCount = 255; | |
/* create doubly-linked list of free blocks */ | |
for (i = 0; i < PPMD_NUM_INDEXES; i++) | |
{ | |
UInt16 nu = I2U(i); | |
CPpmd7_Node_Ref next = (CPpmd7_Node_Ref)p->FreeList[i]; | |
p->FreeList[i] = 0; | |
while (next != 0) | |
{ | |
CPpmd7_Node *node = NODE(next); | |
node->Next = n; | |
n = NODE(n)->Prev = next; | |
next = *(const CPpmd7_Node_Ref *)node; | |
node->Stamp = 0; | |
node->NU = (UInt16)nu; | |
} | |
} | |
NODE(head)->Stamp = 1; | |
NODE(head)->Next = n; | |
NODE(n)->Prev = head; | |
if (p->LoUnit != p->HiUnit) | |
((CPpmd7_Node *)p->LoUnit)->Stamp = 1; | |
/* Glue free blocks */ | |
while (n != head) | |
{ | |
CPpmd7_Node *node = NODE(n); | |
UInt32 nu = (UInt32)node->NU; | |
for (;;) | |
{ | |
CPpmd7_Node *node2 = NODE(n) + nu; | |
nu += node2->NU; | |
if (node2->Stamp != 0 || nu >= 0x10000) | |
break; | |
NODE(node2->Prev)->Next = node2->Next; | |
NODE(node2->Next)->Prev = node2->Prev; | |
node->NU = (UInt16)nu; | |
} | |
n = node->Next; | |
} | |
/* Fill lists of free blocks */ | |
for (n = NODE(head)->Next; n != head;) | |
{ | |
CPpmd7_Node *node = NODE(n); | |
unsigned nu; | |
CPpmd7_Node_Ref next = node->Next; | |
for (nu = node->NU; nu > 128; nu -= 128, node += 128) | |
InsertNode(p, node, PPMD_NUM_INDEXES - 1); | |
if (I2U(i = U2I(nu)) != nu) | |
{ | |
unsigned k = I2U(--i); | |
InsertNode(p, node + k, nu - k - 1); | |
} | |
InsertNode(p, node, i); | |
n = next; | |
} | |
} | |
static void *AllocUnitsRare(CPpmd7 *p, unsigned indx) | |
{ | |
unsigned i; | |
void *retVal; | |
if (p->GlueCount == 0) | |
{ | |
GlueFreeBlocks(p); | |
if (p->FreeList[indx] != 0) | |
return RemoveNode(p, indx); | |
} | |
i = indx; | |
do | |
{ | |
if (++i == PPMD_NUM_INDEXES) | |
{ | |
UInt32 numBytes = U2B(I2U(indx)); | |
p->GlueCount--; | |
return ((UInt32)(p->UnitsStart - p->Text) > numBytes) ? (p->UnitsStart -= numBytes) : (NULL); | |
} | |
} | |
while (p->FreeList[i] == 0); | |
retVal = RemoveNode(p, i); | |
SplitBlock(p, retVal, i, indx); | |
return retVal; | |
} | |
static void *AllocUnits(CPpmd7 *p, unsigned indx) | |
{ | |
UInt32 numBytes; | |
if (p->FreeList[indx] != 0) | |
return RemoveNode(p, indx); | |
numBytes = U2B(I2U(indx)); | |
if (numBytes <= (UInt32)(p->HiUnit - p->LoUnit)) | |
{ | |
void *retVal = p->LoUnit; | |
p->LoUnit += numBytes; | |
return retVal; | |
} | |
return AllocUnitsRare(p, indx); | |
} | |
#define MyMem12Cpy(dest, src, num) \ | |
{ UInt32 *d = (UInt32 *)dest; const UInt32 *s = (const UInt32 *)src; UInt32 n = num; \ | |
do { d[0] = s[0]; d[1] = s[1]; d[2] = s[2]; s += 3; d += 3; } while(--n); } | |
static void *ShrinkUnits(CPpmd7 *p, void *oldPtr, unsigned oldNU, unsigned newNU) | |
{ | |
unsigned i0 = U2I(oldNU); | |
unsigned i1 = U2I(newNU); | |
if (i0 == i1) | |
return oldPtr; | |
if (p->FreeList[i1] != 0) | |
{ | |
void *ptr = RemoveNode(p, i1); | |
MyMem12Cpy(ptr, oldPtr, newNU); | |
InsertNode(p, oldPtr, i0); | |
return ptr; | |
} | |
SplitBlock(p, oldPtr, i0, i1); | |
return oldPtr; | |
} | |
#define SUCCESSOR(p) ((CPpmd_Void_Ref)((p)->SuccessorLow | ((UInt32)(p)->SuccessorHigh << 16))) | |
static void SetSuccessor(CPpmd_State *p, CPpmd_Void_Ref v) | |
{ | |
(p)->SuccessorLow = (UInt16)((UInt32)(v) & 0xFFFF); | |
(p)->SuccessorHigh = (UInt16)(((UInt32)(v) >> 16) & 0xFFFF); | |
} | |
static void RestartModel(CPpmd7 *p) | |
{ | |
unsigned i, k, m; | |
memset(p->FreeList, 0, sizeof(p->FreeList)); | |
p->Text = p->Base + p->AlignOffset; | |
p->HiUnit = p->Text + p->Size; | |
p->LoUnit = p->UnitsStart = p->HiUnit - p->Size / 8 / UNIT_SIZE * 7 * UNIT_SIZE; | |
p->GlueCount = 0; | |
p->OrderFall = p->MaxOrder; | |
p->RunLength = p->InitRL = -(Int32)((p->MaxOrder < 12) ? p->MaxOrder : 12) - 1; | |
p->PrevSuccess = 0; | |
p->MinContext = p->MaxContext = (CTX_PTR)(p->HiUnit -= UNIT_SIZE); /* AllocContext(p); */ | |
p->MinContext->Suffix = 0; | |
p->MinContext->NumStats = 256; | |
p->MinContext->SummFreq = 256 + 1; | |
p->FoundState = (CPpmd_State *)p->LoUnit; /* AllocUnits(p, PPMD_NUM_INDEXES - 1); */ | |
p->LoUnit += U2B(256 / 2); | |
p->MinContext->Stats = REF(p->FoundState); | |
for (i = 0; i < 256; i++) | |
{ | |
CPpmd_State *s = &p->FoundState[i]; | |
s->Symbol = (Byte)i; | |
s->Freq = 1; | |
SetSuccessor(s, 0); | |
} | |
for (i = 0; i < 128; i++) | |
for (k = 0; k < 8; k++) | |
{ | |
UInt16 *dest = p->BinSumm[i] + k; | |
UInt16 val = (UInt16)(PPMD_BIN_SCALE - kInitBinEsc[k] / (i + 2)); | |
for (m = 0; m < 64; m += 8) | |
dest[m] = val; | |
} | |
for (i = 0; i < 25; i++) | |
for (k = 0; k < 16; k++) | |
{ | |
CPpmd_See *s = &p->See[i][k]; | |
s->Summ = (UInt16)((5 * i + 10) << (s->Shift = PPMD_PERIOD_BITS - 4)); | |
s->Count = 4; | |
} | |
} | |
void Ppmd7_Init(CPpmd7 *p, unsigned maxOrder) | |
{ | |
p->MaxOrder = maxOrder; | |
RestartModel(p); | |
p->DummySee.Shift = PPMD_PERIOD_BITS; | |
p->DummySee.Summ = 0; /* unused */ | |
p->DummySee.Count = 64; /* unused */ | |
} | |
static CTX_PTR CreateSuccessors(CPpmd7 *p, Bool skip) | |
{ | |
CPpmd_State upState; | |
CTX_PTR c = p->MinContext; | |
CPpmd_Byte_Ref upBranch = (CPpmd_Byte_Ref)SUCCESSOR(p->FoundState); | |
CPpmd_State *ps[PPMD7_MAX_ORDER]; | |
unsigned numPs = 0; | |
if (!skip) | |
ps[numPs++] = p->FoundState; | |
while (c->Suffix) | |
{ | |
CPpmd_Void_Ref successor; | |
CPpmd_State *s; | |
c = SUFFIX(c); | |
if (c->NumStats != 1) | |
{ | |
for (s = STATS(c); s->Symbol != p->FoundState->Symbol; s++); | |
} | |
else | |
s = ONE_STATE(c); | |
successor = SUCCESSOR(s); | |
if (successor != upBranch) | |
{ | |
c = CTX(successor); | |
if (numPs == 0) | |
return c; | |
break; | |
} | |
ps[numPs++] = s; | |
} | |
upState.Symbol = *(const Byte *)Ppmd7_GetPtr(p, upBranch); | |
SetSuccessor(&upState, upBranch + 1); | |
if (c->NumStats == 1) | |
upState.Freq = ONE_STATE(c)->Freq; | |
else | |
{ | |
UInt32 cf, s0; | |
CPpmd_State *s; | |
for (s = STATS(c); s->Symbol != upState.Symbol; s++); | |
cf = s->Freq - 1; | |
s0 = c->SummFreq - c->NumStats - cf; | |
upState.Freq = (Byte)(1 + ((2 * cf <= s0) ? (5 * cf > s0) : ((2 * cf + 3 * s0 - 1) / (2 * s0)))); | |
} | |
do | |
{ | |
/* Create Child */ | |
CTX_PTR c1; /* = AllocContext(p); */ | |
if (p->HiUnit != p->LoUnit) | |
c1 = (CTX_PTR)(p->HiUnit -= UNIT_SIZE); | |
else if (p->FreeList[0] != 0) | |
c1 = (CTX_PTR)RemoveNode(p, 0); | |
else | |
{ | |
c1 = (CTX_PTR)AllocUnitsRare(p, 0); | |
if (!c1) | |
return NULL; | |
} | |
c1->NumStats = 1; | |
*ONE_STATE(c1) = upState; | |
c1->Suffix = REF(c); | |
SetSuccessor(ps[--numPs], REF(c1)); | |
c = c1; | |
} | |
while (numPs != 0); | |
return c; | |
} | |
static void SwapStates(CPpmd_State *t1, CPpmd_State *t2) | |
{ | |
CPpmd_State tmp = *t1; | |
*t1 = *t2; | |
*t2 = tmp; | |
} | |
static void UpdateModel(CPpmd7 *p) | |
{ | |
CPpmd_Void_Ref successor, fSuccessor = SUCCESSOR(p->FoundState); | |
CTX_PTR c; | |
unsigned s0, ns; | |
if (p->FoundState->Freq < MAX_FREQ / 4 && p->MinContext->Suffix != 0) | |
{ | |
c = SUFFIX(p->MinContext); | |
if (c->NumStats == 1) | |
{ | |
CPpmd_State *s = ONE_STATE(c); | |
if (s->Freq < 32) | |
s->Freq++; | |
} | |
else | |
{ | |
CPpmd_State *s = STATS(c); | |
if (s->Symbol != p->FoundState->Symbol) | |
{ | |
do { s++; } while (s->Symbol != p->FoundState->Symbol); | |
if (s[0].Freq >= s[-1].Freq) | |
{ | |
SwapStates(&s[0], &s[-1]); | |
s--; | |
} | |
} | |
if (s->Freq < MAX_FREQ - 9) | |
{ | |
s->Freq += 2; | |
c->SummFreq += 2; | |
} | |
} | |
} | |
if (p->OrderFall == 0) | |
{ | |
p->MinContext = p->MaxContext = CreateSuccessors(p, True); | |
if (p->MinContext == 0) | |
{ | |
RestartModel(p); | |
return; | |
} | |
SetSuccessor(p->FoundState, REF(p->MinContext)); | |
return; | |
} | |
*p->Text++ = p->FoundState->Symbol; | |
successor = REF(p->Text); | |
if (p->Text >= p->UnitsStart) | |
{ | |
RestartModel(p); | |
return; | |
} | |
if (fSuccessor) | |
{ | |
if (fSuccessor <= successor) | |
{ | |
CTX_PTR cs = CreateSuccessors(p, False); | |
if (cs == NULL) | |
{ | |
RestartModel(p); | |
return; | |
} | |
fSuccessor = REF(cs); | |
} | |
if (--p->OrderFall == 0) | |
{ | |
successor = fSuccessor; | |
p->Text -= (p->MaxContext != p->MinContext); | |
} | |
} | |
else | |
{ | |
SetSuccessor(p->FoundState, successor); | |
fSuccessor = REF(p->MinContext); | |
} | |
s0 = p->MinContext->SummFreq - (ns = p->MinContext->NumStats) - (p->FoundState->Freq - 1); | |
for (c = p->MaxContext; c != p->MinContext; c = SUFFIX(c)) | |
{ | |
unsigned ns1; | |
UInt32 cf, sf; | |
if ((ns1 = c->NumStats) != 1) | |
{ | |
if ((ns1 & 1) == 0) | |
{ | |
/* Expand for one UNIT */ | |
unsigned oldNU = ns1 >> 1; | |
unsigned i = U2I(oldNU); | |
if (i != U2I(oldNU + 1)) | |
{ | |
void *ptr = AllocUnits(p, i + 1); | |
void *oldPtr; | |
if (!ptr) | |
{ | |
RestartModel(p); | |
return; | |
} | |
oldPtr = STATS(c); | |
MyMem12Cpy(ptr, oldPtr, oldNU); | |
InsertNode(p, oldPtr, i); | |
c->Stats = STATS_REF(ptr); | |
} | |
} | |
c->SummFreq = (UInt16)(c->SummFreq + (2 * ns1 < ns) + 2 * ((4 * ns1 <= ns) & (c->SummFreq <= 8 * ns1))); | |
} | |
else | |
{ | |
CPpmd_State *s = (CPpmd_State*)AllocUnits(p, 0); | |
if (!s) | |
{ | |
RestartModel(p); | |
return; | |
} | |
*s = *ONE_STATE(c); | |
c->Stats = REF(s); | |
if (s->Freq < MAX_FREQ / 4 - 1) | |
s->Freq <<= 1; | |
else | |
s->Freq = MAX_FREQ - 4; | |
c->SummFreq = (UInt16)(s->Freq + p->InitEsc + (ns > 3)); | |
} | |
cf = 2 * (UInt32)p->FoundState->Freq * (c->SummFreq + 6); | |
sf = (UInt32)s0 + c->SummFreq; | |
if (cf < 6 * sf) | |
{ | |
cf = 1 + (cf > sf) + (cf >= 4 * sf); | |
c->SummFreq += 3; | |
} | |
else | |
{ | |
cf = 4 + (cf >= 9 * sf) + (cf >= 12 * sf) + (cf >= 15 * sf); | |
c->SummFreq = (UInt16)(c->SummFreq + cf); | |
} | |
{ | |
CPpmd_State *s = STATS(c) + ns1; | |
SetSuccessor(s, successor); | |
s->Symbol = p->FoundState->Symbol; | |
s->Freq = (Byte)cf; | |
c->NumStats = (UInt16)(ns1 + 1); | |
} | |
} | |
p->MaxContext = p->MinContext = CTX(fSuccessor); | |
} | |
static void Rescale(CPpmd7 *p) | |
{ | |
unsigned i, adder, sumFreq, escFreq; | |
CPpmd_State *stats = STATS(p->MinContext); | |
CPpmd_State *s = p->FoundState; | |
{ | |
CPpmd_State tmp = *s; | |
for (; s != stats; s--) | |
s[0] = s[-1]; | |
*s = tmp; | |
} | |
escFreq = p->MinContext->SummFreq - s->Freq; | |
s->Freq += 4; | |
adder = (p->OrderFall != 0); | |
s->Freq = (Byte)((s->Freq + adder) >> 1); | |
sumFreq = s->Freq; | |
i = p->MinContext->NumStats - 1; | |
do | |
{ | |
escFreq -= (++s)->Freq; | |
s->Freq = (Byte)((s->Freq + adder) >> 1); | |
sumFreq += s->Freq; | |
if (s[0].Freq > s[-1].Freq) | |
{ | |
CPpmd_State *s1 = s; | |
CPpmd_State tmp = *s1; | |
do | |
s1[0] = s1[-1]; | |
while (--s1 != stats && tmp.Freq > s1[-1].Freq); | |
*s1 = tmp; | |
} | |
} | |
while (--i); | |
if (s->Freq == 0) | |
{ | |
unsigned numStats = p->MinContext->NumStats; | |
unsigned n0, n1; | |
do { i++; } while ((--s)->Freq == 0); | |
escFreq += i; | |
p->MinContext->NumStats = (UInt16)(p->MinContext->NumStats - i); | |
if (p->MinContext->NumStats == 1) | |
{ | |
CPpmd_State tmp = *stats; | |
do | |
{ | |
tmp.Freq = (Byte)(tmp.Freq - (tmp.Freq >> 1)); | |
escFreq >>= 1; | |
} | |
while (escFreq > 1); | |
InsertNode(p, stats, U2I(((numStats + 1) >> 1))); | |
*(p->FoundState = ONE_STATE(p->MinContext)) = tmp; | |
return; | |
} | |
n0 = (numStats + 1) >> 1; | |
n1 = (p->MinContext->NumStats + 1) >> 1; | |
if (n0 != n1) | |
p->MinContext->Stats = STATS_REF(ShrinkUnits(p, stats, n0, n1)); | |
} | |
p->MinContext->SummFreq = (UInt16)(sumFreq + escFreq - (escFreq >> 1)); | |
p->FoundState = STATS(p->MinContext); | |
} | |
CPpmd_See *Ppmd7_MakeEscFreq(CPpmd7 *p, unsigned numMasked, UInt32 *escFreq) | |
{ | |
CPpmd_See *see; | |
unsigned nonMasked = p->MinContext->NumStats - numMasked; | |
if (p->MinContext->NumStats != 256) | |
{ | |
see = p->See[p->NS2Indx[nonMasked - 1]] + | |
(nonMasked < (unsigned)SUFFIX(p->MinContext)->NumStats - p->MinContext->NumStats) + | |
2 * (p->MinContext->SummFreq < 11 * p->MinContext->NumStats) + | |
4 * (numMasked > nonMasked) + | |
p->HiBitsFlag; | |
{ | |
unsigned r = (see->Summ >> see->Shift); | |
see->Summ = (UInt16)(see->Summ - r); | |
*escFreq = r + (r == 0); | |
} | |
} | |
else | |
{ | |
see = &p->DummySee; | |
*escFreq = 1; | |
} | |
return see; | |
} | |
static void NextContext(CPpmd7 *p) | |
{ | |
CTX_PTR c = CTX(SUCCESSOR(p->FoundState)); | |
if (p->OrderFall == 0 && (Byte *)c > p->Text) | |
p->MinContext = p->MaxContext = c; | |
else | |
UpdateModel(p); | |
} | |
void Ppmd7_Update1(CPpmd7 *p) | |
{ | |
CPpmd_State *s = p->FoundState; | |
s->Freq += 4; | |
p->MinContext->SummFreq += 4; | |
if (s[0].Freq > s[-1].Freq) | |
{ | |
SwapStates(&s[0], &s[-1]); | |
p->FoundState = --s; | |
if (s->Freq > MAX_FREQ) | |
Rescale(p); | |
} | |
NextContext(p); | |
} | |
void Ppmd7_Update1_0(CPpmd7 *p) | |
{ | |
p->PrevSuccess = (2 * p->FoundState->Freq > p->MinContext->SummFreq); | |
p->RunLength += p->PrevSuccess; | |
p->MinContext->SummFreq += 4; | |
if ((p->FoundState->Freq += 4) > MAX_FREQ) | |
Rescale(p); | |
NextContext(p); | |
} | |
void Ppmd7_UpdateBin(CPpmd7 *p) | |
{ | |
p->FoundState->Freq = (Byte)(p->FoundState->Freq + (p->FoundState->Freq < 128 ? 1: 0)); | |
p->PrevSuccess = 1; | |
p->RunLength++; | |
NextContext(p); | |
} | |
void Ppmd7_Update2(CPpmd7 *p) | |
{ | |
p->MinContext->SummFreq += 4; | |
if ((p->FoundState->Freq += 4) > MAX_FREQ) | |
Rescale(p); | |
p->RunLength = p->InitRL; | |
UpdateModel(p); | |
} |