← Back to branch summary

~ubuntu-branches/ubuntu/vivid/unrar-nonfree/vivid

« back to all changes in this revision

Viewing changes to model.cpp

  • Committer: Package Import Robot
  • Author(s): Martin Meredith
  • Date: 2015-02-03 12:58:01 UTC
  • mfrom: (1.1.18) (5.1.18 sid)
  • Revision ID: package-import@ubuntu.com-20150203125801-od6ev8cqy1er51vz
Tags: 1:5.2.5-1
New upstream release

Show diffs side-by-side

added added

removed removed

Lines of Context:
model.cpp
5
5
 *  Contents: model description and encoding/decoding routines              *
6
6
 ****************************************************************************/
7
7
 
8
 
inline PPM_CONTEXT* PPM_CONTEXT::createChild(ModelPPM *Model,STATE* pStats,
9
 
                                             STATE& FirstState)
 
8
static const int MAX_O=64; /* maximum allowed model order */
 
9
const uint TOP=1 << 24, BOT=1 << 15;
 
10
 
 
11
template <class T>
 
12
inline void _PPMD_SWAP(T& t1,T& t2) { T tmp=t1; t1=t2; t2=tmp; }
 
13
 
 
14
 
 
15
inline RARPPM_CONTEXT* RARPPM_CONTEXT::createChild(ModelPPM *Model,RARPPM_STATE* pStats,
 
16
                                             RARPPM_STATE& FirstState)
10
17
{
11
 
  PPM_CONTEXT* pc = (PPM_CONTEXT*) Model->SubAlloc.AllocContext();
 
18
  RARPPM_CONTEXT* pc = (RARPPM_CONTEXT*) Model->SubAlloc.AllocContext();
12
19
  if ( pc ) 
13
20
  {
14
21
    pc->NumStats=1;                     
34
41
  memset(CharMask,0,sizeof(CharMask));
35
42
  SubAlloc.InitSubAllocator();
36
43
  InitRL=-(MaxOrder < 12 ? MaxOrder:12)-1;
37
 
  MinContext = MaxContext = (PPM_CONTEXT*) SubAlloc.AllocContext();
 
44
  MinContext = MaxContext = (RARPPM_CONTEXT*) SubAlloc.AllocContext();
38
45
  MinContext->Suffix=NULL;
39
46
  OrderFall=MaxOrder;
40
47
  MinContext->U.SummFreq=(MinContext->NumStats=256)+1;
41
 
  FoundState=MinContext->U.Stats=(STATE*)SubAlloc.AllocUnits(256/2);
 
48
  FoundState=MinContext->U.Stats=(RARPPM_STATE*)SubAlloc.AllocUnits(256/2);
42
49
  for (RunLength=InitRL, PrevSuccess=i=0;i < 256;i++) 
43
50
  {
44
51
    MinContext->U.Stats[i].Symbol=i;      
105
112
}
106
113
 
107
114
 
108
 
void PPM_CONTEXT::rescale(ModelPPM *Model)
 
115
void RARPPM_CONTEXT::rescale(ModelPPM *Model)
109
116
{
110
117
  int OldNS=NumStats, i=NumStats-1, Adder, EscFreq;
111
 
  STATE* p1, * p;
 
118
  RARPPM_STATE* p1, * p;
112
119
  for (p=Model->FoundState;p != U.Stats;p--)
113
120
    _PPMD_SWAP(p[0],p[-1]);
114
121
  U.Stats->Freq += 4;
122
129
    U.SummFreq += (p->Freq=(p->Freq+Adder) >> 1);
123
130
    if (p[0].Freq > p[-1].Freq) 
124
131
    {
125
 
      STATE tmp=*(p1=p);
 
132
      RARPPM_STATE tmp=*(p1=p);
126
133
      do 
127
134
      { 
128
135
        p1[0]=p1[-1]; 
139
146
    EscFreq += i;
140
147
    if ((NumStats -= i) == 1) 
141
148
    {
142
 
      STATE tmp=*U.Stats;
 
149
      RARPPM_STATE tmp=*U.Stats;
143
150
      do 
144
151
      { 
145
152
        tmp.Freq-=(tmp.Freq >> 1); 
152
159
  U.SummFreq += (EscFreq -= (EscFreq >> 1));
153
160
  int n0=(OldNS+1) >> 1, n1=(NumStats+1) >> 1;
154
161
  if (n0 != n1)
155
 
    U.Stats = (STATE*) Model->SubAlloc.ShrinkUnits(U.Stats,n0,n1);
 
162
    U.Stats = (RARPPM_STATE*) Model->SubAlloc.ShrinkUnits(U.Stats,n0,n1);
156
163
  Model->FoundState=U.Stats;
157
164
}
158
165
 
159
166
 
160
 
inline PPM_CONTEXT* ModelPPM::CreateSuccessors(bool Skip,STATE* p1)
 
167
inline RARPPM_CONTEXT* ModelPPM::CreateSuccessors(bool Skip,RARPPM_STATE* p1)
161
168
{
162
169
#ifdef __ICL
163
170
  static
164
171
#endif
165
 
  STATE UpState;
166
 
  PPM_CONTEXT* pc=MinContext, * UpBranch=FoundState->Successor;
167
 
  STATE * p, * ps[MAX_O], ** pps=ps;
 
172
  RARPPM_STATE UpState;
 
173
  RARPPM_CONTEXT* pc=MinContext, * UpBranch=FoundState->Successor;
 
174
  RARPPM_STATE * p, * ps[MAX_O], ** pps=ps;
168
175
  if ( !Skip ) 
169
176
  {
170
177
    *pps++ = FoundState;
202
209
  if (pps == ps)
203
210
    return pc;
204
211
  UpState.Symbol=*(byte*) UpBranch;
205
 
  UpState.Successor=(PPM_CONTEXT*) (((byte*) UpBranch)+1);
 
212
  UpState.Successor=(RARPPM_CONTEXT*) (((byte*) UpBranch)+1);
206
213
  if (pc->NumStats != 1) 
207
214
  {
208
215
    if ((byte*) pc <= SubAlloc.pText)
230
237
 
231
238
inline void ModelPPM::UpdateModel()
232
239
{
233
 
  STATE fs = *FoundState, *p = NULL;
234
 
  PPM_CONTEXT *pc, *Successor;
 
240
  RARPPM_STATE fs = *FoundState, *p = NULL;
 
241
  RARPPM_CONTEXT *pc, *Successor;
235
242
  uint ns1, ns, cf, sf, s0;
236
243
  if (fs.Freq < MAX_FREQ/4 && (pc=MinContext->Suffix) != NULL) 
237
244
  {
269
276
    return;
270
277
  }
271
278
  *SubAlloc.pText++ = fs.Symbol;                   
272
 
  Successor = (PPM_CONTEXT*) SubAlloc.pText;
 
279
  Successor = (RARPPM_CONTEXT*) SubAlloc.pText;
273
280
  if (SubAlloc.pText >= SubAlloc.FakeUnitsStart)                
274
281
    goto RESTART_MODEL;
275
282
  if ( fs.Successor ) 
295
302
    {
296
303
      if ((ns1 & 1) == 0) 
297
304
      {
298
 
        pc->U.Stats=(STATE*) SubAlloc.ExpandUnits(pc->U.Stats,ns1 >> 1);
 
305
        pc->U.Stats=(RARPPM_STATE*) SubAlloc.ExpandUnits(pc->U.Stats,ns1 >> 1);
299
306
        if ( !pc->U.Stats )           
300
307
          goto RESTART_MODEL;
301
308
      }
303
310
    } 
304
311
    else 
305
312
    {
306
 
      p=(STATE*) SubAlloc.AllocUnits(1);
 
313
      p=(RARPPM_STATE*) SubAlloc.AllocUnits(1);
307
314
      if ( !p )
308
315
        goto RESTART_MODEL;
309
316
      *p=pc->OneState;
346
353
 
347
354
 
348
355
 
349
 
inline void PPM_CONTEXT::decodeBinSymbol(ModelPPM *Model)
 
356
inline void RARPPM_CONTEXT::decodeBinSymbol(ModelPPM *Model)
350
357
{
351
 
  STATE& rs=OneState;
 
358
  RARPPM_STATE& rs=OneState;
352
359
  Model->HiBitsFlag=Model->HB2Flag[Model->FoundState->Symbol];
353
360
  ushort& bs=Model->BinSumm[rs.Freq-1][Model->PrevSuccess+
354
361
           Model->NS2BSIndx[Suffix->NumStats-1]+
378
385
}
379
386
 
380
387
 
381
 
inline void PPM_CONTEXT::update1(ModelPPM *Model,STATE* p)
 
388
inline void RARPPM_CONTEXT::update1(ModelPPM *Model,RARPPM_STATE* p)
382
389
{
383
390
  (Model->FoundState=p)->Freq += 4;              
384
391
  U.SummFreq += 4;
394
401
 
395
402
 
396
403
 
397
 
inline bool PPM_CONTEXT::decodeSymbol1(ModelPPM *Model)
 
404
inline bool RARPPM_CONTEXT::decodeSymbol1(ModelPPM *Model)
398
405
{
399
406
  Model->Coder.SubRange.scale=U.SummFreq;
400
 
  STATE* p=U.Stats;
 
407
  RARPPM_STATE* p=U.Stats;
401
408
  int i, HiCnt;
402
409
  int count=Model->Coder.GetCurrentCount();
403
410
  if (count>=(int)Model->Coder.SubRange.scale)
439
446
}
440
447
 
441
448
 
442
 
inline void PPM_CONTEXT::update2(ModelPPM *Model,STATE* p)
 
449
inline void RARPPM_CONTEXT::update2(ModelPPM *Model,RARPPM_STATE* p)
443
450
{
444
451
  (Model->FoundState=p)->Freq += 4;              
445
452
  U.SummFreq += 4;
450
457
}
451
458
 
452
459
 
453
 
inline SEE2_CONTEXT* PPM_CONTEXT::makeEscFreq2(ModelPPM *Model,int Diff)
 
460
inline RARPPM_SEE2_CONTEXT* RARPPM_CONTEXT::makeEscFreq2(ModelPPM *Model,int Diff)
454
461
{
455
 
  SEE2_CONTEXT* psee2c;
 
462
  RARPPM_SEE2_CONTEXT* psee2c;
456
463
  if (NumStats != 256) 
457
464
  {
458
465
    psee2c=Model->SEE2Cont[Model->NS2Indx[Diff-1]]+
472
479
 
473
480
 
474
481
 
475
 
inline bool PPM_CONTEXT::decodeSymbol2(ModelPPM *Model)
 
482
inline bool RARPPM_CONTEXT::decodeSymbol2(ModelPPM *Model)
476
483
{
477
484
  int count, HiCnt, i=NumStats-Model->NumMasked;
478
 
  SEE2_CONTEXT* psee2c=makeEscFreq2(Model,i);
479
 
  STATE* ps[256], ** pps=ps, * p=U.Stats-1;
 
485
  RARPPM_SEE2_CONTEXT* psee2c=makeEscFreq2(Model,i);
 
486
  RARPPM_STATE* ps[256], ** pps=ps, * p=U.Stats-1;
480
487
  HiCnt=0;
481
488
  do 
482
489
  {