static inline void UpdateModel()
{
static PPM_CONTEXT::STATE fs;
PPM_CONTEXT::STATE* p = NULL; fs = *FoundState;
PPM_CONTEXT* pc, * Successor;
UINT ns1;
if ( !OrderFall ) {
MinContext=MaxContext=FoundState->Successor=CreateSuccessors(TRUE,p);
if ( !MinContext ) goto RESTART_MODEL;
return;
}
*pText++ = fs.Symbol; Successor = (PPM_CONTEXT*) pText;
if (pText >= UnitsStart) goto RESTART_MODEL;
if ( fs.Successor ) {
if ((BYTE*) fs.Successor <= pText &&
(fs.Successor=CreateSuccessors(FALSE,p)) == NULL)
goto RESTART_MODEL;
if ( !--OrderFall ) {
Successor=fs.Successor; pText -= (MaxContext != MinContext);
}
} else {
FoundState->Successor=Successor; fs.Successor=MinContext;
}
for (pc=MaxContext;pc != MinContext;pc=pc->Suffix) {
if ((ns1=pc->NumStats) != 0) {
if ((ns1 & 1) != 0) {
pc->Stats=(PPM_CONTEXT::STATE*) ExpandUnits(pc->Stats,(ns1+1) >> 1);
if ( !pc->Stats ) goto RESTART_MODEL;
}
} else {
static void UpdateModel(PPMdModelVariantI *self,PPMdContext *mincontext)
{
PPMdState fs=*self->core.FoundState;
PPMdState *state=NULL;
PPMdContext *currcontext=self->MaxContext;
if(fs.Freq<MAX_FREQ/4&&mincontext->Suffix)
{
PPMdContext *context=PPMdContextSuffix(mincontext,&self->core);
if(context->LastStateIndex!=0)
{
state=PPMdContextStates(context,&self->core);
if(state->Symbol!=fs.Symbol)
{
do state++;
while(state->Symbol!=fs.Symbol);
if(state[0].Freq>=state[-1].Freq)
{
SWAP(state[0],state[-1]);
state--;
}
}
if(state->Freq<MAX_FREQ-9)
{
state->Freq+=2;
context->SummFreq+=2;
}
}
else
{
state=PPMdContextOneState(context);
if(state->Freq<32) state->Freq++;
}
}
if(self->core.OrderFall==0&&fs.Successor)
{
PPMdContext *newsuccessor=CreateSuccessors(self,true,state,mincontext);
SetPPMdStateSuccessorPointer(self->core.FoundState,newsuccessor,&self->core);
if(!newsuccessor) goto RESTART_MODEL;
self->MaxContext=newsuccessor;
return;
}
*self->alloc->pText++=fs.Symbol;
PPMdContext *Successor=(PPMdContext *)self->alloc->pText;
if(self->alloc->pText>=self->alloc->UnitsStart) goto RESTART_MODEL;
if(fs.Successor)
{
if((uint8_t *)PPMdStateSuccessor(&fs,&self->core)<self->alloc->UnitsStart)
{
SetPPMdStateSuccessorPointer(&fs,CreateSuccessors(self,false,state,mincontext),&self->core);
}
}
else
{
SetPPMdStateSuccessorPointer(&fs,ReduceOrder(self,state,mincontext),&self->core);
}
if(!fs.Successor) goto RESTART_MODEL;
if(--self->core.OrderFall==0)
{
Successor=PPMdStateSuccessor(&fs,&self->core);
if(self->MaxContext!=mincontext) self->alloc->pText--;
}
else if(self->MRMethod>MRM_FREEZE)
{
Successor=PPMdStateSuccessor(&fs,&self->core);
self->alloc->pText=self->alloc->HeapStart;
self->core.OrderFall=0;
}
int minnum=mincontext->LastStateIndex+1;
int s0=mincontext->SummFreq-minnum-(fs.Freq-1);
uint8_t flag=fs.Symbol>=0x40?8:0;
for(;currcontext!=mincontext;currcontext=PPMdContextSuffix(currcontext,&self->core))
{
int currnum=currcontext->LastStateIndex+1;
if(currnum!=1)
{
if((currnum&1)==0)
{
uint32_t states=ExpandUnits(self->core.alloc,currcontext->States,currnum>>1);
if(!states) goto RESTART_MODEL;
currcontext->States=states;
}
if(3*currnum-1<minnum) currcontext->SummFreq++;
}
else
{
