← Back to branch summary

~ubuntu-branches/ubuntu/wily/sflphone/wily

« back to all changes in this revision

Viewing changes to daemon/libs/pjproject-2.0.1/third_party/ilbc/enhancer.c

  • Committer: Package Import Robot
  • Author(s): Mark Purcell
  • Date: 2014-01-28 18:23:36 UTC
  • mfrom: (1.1.11)
  • mto: This revision was merged to the branch mainline in revision 24.
  • Revision ID: package-import@ubuntu.com-20140128182336-3xenud1kbnwmf3mz
http://bugs.debian.org/735846
http://bugs.debian.org/727164
http://bugs.debian.org/718178
http://bugs.debian.org/736583
http://bugs.debian.org/722040
http://bugs.debian.org/736746
* New upstream release 
  - Fixes "New Upstream Release" (Closes: #735846)
  - Fixes "Ringtone does not stop" (Closes: #727164)
  - Fixes "[sflphone-kde] crash on startup" (Closes: #718178)
  - Fixes "sflphone GUI crashes when call is hung up" (Closes: #736583)
* Build-Depends: ensure GnuTLS 2.6
  - libucommon-dev (>= 6.0.7-1.1), libccrtp-dev (>= 2.0.6-3)
  - Fixes "FTBFS Build-Depends libgnutls{26,28}-dev" (Closes: #722040)
* Fix "boost 1.49 is going away" unversioned Build-Depends: (Closes: #736746)
* Add Build-Depends: libsndfile-dev, nepomuk-core-dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
daemon/libs/pjproject-2.0.1/third_party/ilbc/enhancer.c
1
 
 
2
 
   /******************************************************************
3
 
 
4
 
       iLBC Speech Coder ANSI-C Source Code
5
 
 
6
 
       enhancer.c
7
 
 
8
 
       Copyright (C) The Internet Society (2004).
9
 
       All Rights Reserved.
10
 
 
11
 
   ******************************************************************/
12
 
 
13
 
   #include <math.h>
14
 
   #include <string.h>
15
 
   #include "iLBC_define.h"
16
 
   #include "constants.h"
17
 
   #include "filter.h"
18
 
 
19
 
   /*----------------------------------------------------------------*
20
 
    * Find index in array such that the array element with said
21
 
    * index is the element of said array closest to "value"
22
 
    * according to the squared-error criterion
23
 
    *---------------------------------------------------------------*/
24
 
 
25
 
   void NearestNeighbor(
26
 
 
27
 
 
28
 
 
29
 
 
30
 
 
31
 
       int   *index,   /* (o) index of array element closest
32
 
                              to value */
33
 
       float *array,   /* (i) data array */
34
 
       float value,/* (i) value */
35
 
       int arlength/* (i) dimension of data array */
36
 
   ){
37
 
       int i;
38
 
       float bestcrit,crit;
39
 
 
40
 
       crit=array[0]-value;
41
 
       bestcrit=crit*crit;
42
 
       *index=0;
43
 
       for (i=1; i<arlength; i++) {
44
 
           crit=array[i]-value;
45
 
           crit=crit*crit;
46
 
 
47
 
           if (crit<bestcrit) {
48
 
               bestcrit=crit;
49
 
               *index=i;
50
 
           }
51
 
       }
52
 
   }
53
 
 
54
 
   /*----------------------------------------------------------------*
55
 
    * compute cross correlation between sequences
56
 
    *---------------------------------------------------------------*/
57
 
 
58
 
   void mycorr1(
59
 
       float* corr,    /* (o) correlation of seq1 and seq2 */
60
 
       float* seq1,    /* (i) first sequence */
61
 
       int dim1,           /* (i) dimension first seq1 */
62
 
       const float *seq2,  /* (i) second sequence */
63
 
       int dim2        /* (i) dimension seq2 */
64
 
   ){
65
 
       int i,j;
66
 
 
67
 
       for (i=0; i<=dim1-dim2; i++) {
68
 
           corr[i]=0.0;
69
 
           for (j=0; j<dim2; j++) {
70
 
               corr[i] += seq1[i+j] * seq2[j];
71
 
           }
72
 
       }
73
 
   }
74
 
 
75
 
   /*----------------------------------------------------------------*
76
 
    * upsample finite array assuming zeros outside bounds
77
 
    *---------------------------------------------------------------*/
78
 
 
79
 
 
80
 
 
81
 
 
82
 
 
83
 
 
84
 
   void enh_upsample(
85
 
       float* useq1,   /* (o) upsampled output sequence */
86
 
       float* seq1,/* (i) unupsampled sequence */
87
 
       int dim1,       /* (i) dimension seq1 */
88
 
       int hfl         /* (i) polyphase filter length=2*hfl+1 */
89
 
   ){
90
 
       float *pu,*ps;
91
 
       int i,j,k,q,filterlength,hfl2;
92
 
       const float *polyp[ENH_UPS0]; /* pointers to
93
 
                                        polyphase columns */
94
 
       const float *pp;
95
 
 
96
 
       /* define pointers for filter */
97
 
 
98
 
       filterlength=2*hfl+1;
99
 
 
100
 
       if ( filterlength > dim1 ) {
101
 
           hfl2=(int) (dim1/2);
102
 
           for (j=0; j<ENH_UPS0; j++) {
103
 
               polyp[j]=polyphaserTbl+j*filterlength+hfl-hfl2;
104
 
           }
105
 
           hfl=hfl2;
106
 
           filterlength=2*hfl+1;
107
 
       }
108
 
       else {
109
 
           for (j=0; j<ENH_UPS0; j++) {
110
 
               polyp[j]=polyphaserTbl+j*filterlength;
111
 
           }
112
 
       }
113
 
 
114
 
       /* filtering: filter overhangs left side of sequence */
115
 
 
116
 
       pu=useq1;
117
 
       for (i=hfl; i<filterlength; i++) {
118
 
           for (j=0; j<ENH_UPS0; j++) {
119
 
               *pu=0.0;
120
 
               pp = polyp[j];
121
 
               ps = seq1+i;
122
 
               for (k=0; k<=i; k++) {
123
 
                   *pu += *ps-- * *pp++;
124
 
               }
125
 
               pu++;
126
 
           }
127
 
       }
128
 
 
129
 
       /* filtering: simple convolution=inner products */
130
 
 
131
 
       for (i=filterlength; i<dim1; i++) {
132
 
 
133
 
 
134
 
 
135
 
 
136
 
 
137
 
           for (j=0;j<ENH_UPS0; j++){
138
 
               *pu=0.0;
139
 
               pp = polyp[j];
140
 
               ps = seq1+i;
141
 
               for (k=0; k<filterlength; k++) {
142
 
                   *pu += *ps-- * *pp++;
143
 
               }
144
 
               pu++;
145
 
           }
146
 
       }
147
 
 
148
 
       /* filtering: filter overhangs right side of sequence */
149
 
 
150
 
       for (q=1; q<=hfl; q++) {
151
 
           for (j=0; j<ENH_UPS0; j++) {
152
 
               *pu=0.0;
153
 
               pp = polyp[j]+q;
154
 
               ps = seq1+dim1-1;
155
 
               for (k=0; k<filterlength-q; k++) {
156
 
                   *pu += *ps-- * *pp++;
157
 
               }
158
 
               pu++;
159
 
           }
160
 
       }
161
 
   }
162
 
 
163
 
 
164
 
   /*----------------------------------------------------------------*
165
 
    * find segment starting near idata+estSegPos that has highest
166
 
    * correlation with idata+centerStartPos through
167
 
    * idata+centerStartPos+ENH_BLOCKL-1 segment is found at a
168
 
    * resolution of ENH_UPSO times the original of the original
169
 
    * sampling rate
170
 
    *---------------------------------------------------------------*/
171
 
 
172
 
   void refiner(
173
 
       float *seg,         /* (o) segment array */
174
 
       float *updStartPos, /* (o) updated start point */
175
 
       float* idata,       /* (i) original data buffer */
176
 
       int idatal,         /* (i) dimension of idata */
177
 
       int centerStartPos, /* (i) beginning center segment */
178
 
       float estSegPos,/* (i) estimated beginning other segment */
179
 
       float period    /* (i) estimated pitch period */
180
 
   ){
181
 
       int estSegPosRounded,searchSegStartPos,searchSegEndPos,corrdim;
182
 
       int tloc,tloc2,i,st,en,fraction;
183
 
       float vect[ENH_VECTL],corrVec[ENH_CORRDIM],maxv;
184
 
       float corrVecUps[ENH_CORRDIM*ENH_UPS0];
185
 
 
186
 
       (void)period;
187
 
 
188
 
 
189
 
 
190
 
       /* defining array bounds */
191
 
 
192
 
       estSegPosRounded=(int)(estSegPos - 0.5);
193
 
 
194
 
       searchSegStartPos=estSegPosRounded-ENH_SLOP;
195
 
 
196
 
       if (searchSegStartPos<0) {
197
 
           searchSegStartPos=0;
198
 
       }
199
 
       searchSegEndPos=estSegPosRounded+ENH_SLOP;
200
 
 
201
 
       if (searchSegEndPos+ENH_BLOCKL >= idatal) {
202
 
           searchSegEndPos=idatal-ENH_BLOCKL-1;
203
 
       }
204
 
       corrdim=searchSegEndPos-searchSegStartPos+1;
205
 
 
206
 
       /* compute upsampled correlation (corr33) and find
207
 
          location of max */
208
 
 
209
 
       mycorr1(corrVec,idata+searchSegStartPos,
210
 
           corrdim+ENH_BLOCKL-1,idata+centerStartPos,ENH_BLOCKL);
211
 
       enh_upsample(corrVecUps,corrVec,corrdim,ENH_FL0);
212
 
       tloc=0; maxv=corrVecUps[0];
213
 
       for (i=1; i<ENH_UPS0*corrdim; i++) {
214
 
 
215
 
           if (corrVecUps[i]>maxv) {
216
 
               tloc=i;
217
 
               maxv=corrVecUps[i];
218
 
           }
219
 
       }
220
 
 
221
 
       /* make vector can be upsampled without ever running outside
222
 
          bounds */
223
 
 
224
 
       *updStartPos= (float)searchSegStartPos +
225
 
           (float)tloc/(float)ENH_UPS0+(float)1.0;
226
 
       tloc2=(int)(tloc/ENH_UPS0);
227
 
 
228
 
       if (tloc>tloc2*ENH_UPS0) {
229
 
           tloc2++;
230
 
       }
231
 
       st=searchSegStartPos+tloc2-ENH_FL0;
232
 
 
233
 
       if (st<0) {
234
 
           memset(vect,0,-st*sizeof(float));
235
 
           memcpy(&vect[-st],idata, (ENH_VECTL+st)*sizeof(float));
236
 
       }
237
 
       else {
238
 
 
239
 
 
240
 
 
241
 
 
242
 
 
243
 
           en=st+ENH_VECTL;
244
 
 
245
 
           if (en>idatal) {
246
 
               memcpy(vect, &idata[st],
247
 
                   (ENH_VECTL-(en-idatal))*sizeof(float));
248
 
               memset(&vect[ENH_VECTL-(en-idatal)], 0,
249
 
                   (en-idatal)*sizeof(float));
250
 
           }
251
 
           else {
252
 
               memcpy(vect, &idata[st], ENH_VECTL*sizeof(float));
253
 
           }
254
 
       }
255
 
       fraction=tloc2*ENH_UPS0-tloc;
256
 
 
257
 
       /* compute the segment (this is actually a convolution) */
258
 
 
259
 
       mycorr1(seg,vect,ENH_VECTL,polyphaserTbl+(2*ENH_FL0+1)*fraction,
260
 
           2*ENH_FL0+1);
261
 
   }
262
 
 
263
 
   /*----------------------------------------------------------------*
264
 
    * find the smoothed output data
265
 
    *---------------------------------------------------------------*/
266
 
 
267
 
   void smath(
268
 
       float *odata,   /* (o) smoothed output */
269
 
       float *sseq,/* (i) said second sequence of waveforms */
270
 
       int hl,         /* (i) 2*hl+1 is sseq dimension */
271
 
       float alpha0/* (i) max smoothing energy fraction */
272
 
   ){
273
 
       int i,k;
274
 
       float w00,w10,w11,A,B,C,*psseq,err,errs;
275
 
       float surround[BLOCKL_MAX]; /* shape contributed by other than
276
 
                                      current */
277
 
       float wt[2*ENH_HL+1];       /* waveform weighting to get
278
 
                                      surround shape */
279
 
       float denom;
280
 
 
281
 
       /* create shape of contribution from all waveforms except the
282
 
          current one */
283
 
 
284
 
       for (i=1; i<=2*hl+1; i++) {
285
 
           wt[i-1] = (float)0.5*(1 - (float)cos(2*PI*i/(2*hl+2)));
286
 
       }
287
 
       wt[hl]=0.0; /* for clarity, not used */
288
 
       for (i=0; i<ENH_BLOCKL; i++) {
289
 
           surround[i]=sseq[i]*wt[0];
290
 
       }
291
 
 
292
 
 
293
 
 
294
 
 
295
 
 
296
 
       for (k=1; k<hl; k++) {
297
 
           psseq=sseq+k*ENH_BLOCKL;
298
 
           for(i=0;i<ENH_BLOCKL; i++) {
299
 
               surround[i]+=psseq[i]*wt[k];
300
 
           }
301
 
       }
302
 
       for (k=hl+1; k<=2*hl; k++) {
303
 
           psseq=sseq+k*ENH_BLOCKL;
304
 
           for(i=0;i<ENH_BLOCKL; i++) {
305
 
               surround[i]+=psseq[i]*wt[k];
306
 
           }
307
 
       }
308
 
 
309
 
       /* compute some inner products */
310
 
 
311
 
       w00 = w10 = w11 = 0.0;
312
 
       psseq=sseq+hl*ENH_BLOCKL; /* current block  */
313
 
       for (i=0; i<ENH_BLOCKL;i++) {
314
 
           w00+=psseq[i]*psseq[i];
315
 
           w11+=surround[i]*surround[i];
316
 
           w10+=surround[i]*psseq[i];
317
 
       }
318
 
 
319
 
       if (fabs(w11) < 1.0) {
320
 
           w11=1.0;
321
 
       }
322
 
       C = (float)sqrt( w00/w11);
323
 
 
324
 
       /* first try enhancement without power-constraint */
325
 
 
326
 
       errs=0.0;
327
 
       psseq=sseq+hl*ENH_BLOCKL;
328
 
       for (i=0; i<ENH_BLOCKL; i++) {
329
 
           odata[i]=C*surround[i];
330
 
           err=psseq[i]-odata[i];
331
 
           errs+=err*err;
332
 
       }
333
 
 
334
 
       /* if constraint violated by first try, add constraint */
335
 
 
336
 
       if (errs > alpha0 * w00) {
337
 
           if ( w00 < 1) {
338
 
               w00=1;
339
 
           }
340
 
           denom = (w11*w00-w10*w10)/(w00*w00);
341
 
 
342
 
           if (denom > 0.0001) { /* eliminates numerical problems
343
 
                                    for if smooth */
344
 
 
345
 
 
346
 
 
347
 
 
348
 
 
349
 
               A = (float)sqrt( (alpha0- alpha0*alpha0/4)/denom);
350
 
               B = -alpha0/2 - A * w10/w00;
351
 
               B = B+1;
352
 
           }
353
 
           else { /* essentially no difference between cycles;
354
 
                     smoothing not needed */
355
 
               A= 0.0;
356
 
               B= 1.0;
357
 
           }
358
 
 
359
 
           /* create smoothed sequence */
360
 
 
361
 
           psseq=sseq+hl*ENH_BLOCKL;
362
 
           for (i=0; i<ENH_BLOCKL; i++) {
363
 
               odata[i]=A*surround[i]+B*psseq[i];
364
 
           }
365
 
       }
366
 
   }
367
 
 
368
 
   /*----------------------------------------------------------------*
369
 
    * get the pitch-synchronous sample sequence
370
 
    *---------------------------------------------------------------*/
371
 
 
372
 
   void getsseq(
373
 
       float *sseq,    /* (o) the pitch-synchronous sequence */
374
 
       float *idata,       /* (i) original data */
375
 
       int idatal,         /* (i) dimension of data */
376
 
       int centerStartPos, /* (i) where current block starts */
377
 
       float *period,      /* (i) rough-pitch-period array */
378
 
       float *plocs,       /* (i) where periods of period array
379
 
                                  are taken */
380
 
       int periodl,    /* (i) dimension period array */
381
 
       int hl              /* (i) 2*hl+1 is the number of sequences */
382
 
   ){
383
 
       int i,centerEndPos,q;
384
 
       float blockStartPos[2*ENH_HL+1];
385
 
       int lagBlock[2*ENH_HL+1];
386
 
       float plocs2[ENH_PLOCSL];
387
 
       float *psseq;
388
 
 
389
 
       centerEndPos=centerStartPos+ENH_BLOCKL-1;
390
 
 
391
 
       /* present */
392
 
 
393
 
       NearestNeighbor(lagBlock+hl,plocs,
394
 
           (float)0.5*(centerStartPos+centerEndPos),periodl);
395
 
 
396
 
       blockStartPos[hl]=(float)centerStartPos;
397
 
 
398
 
 
399
 
 
400
 
 
401
 
 
402
 
       psseq=sseq+ENH_BLOCKL*hl;
403
 
       memcpy(psseq, idata+centerStartPos, ENH_BLOCKL*sizeof(float));
404
 
 
405
 
       /* past */
406
 
 
407
 
       for (q=hl-1; q>=0; q--) {
408
 
           blockStartPos[q]=blockStartPos[q+1]-period[lagBlock[q+1]];
409
 
           NearestNeighbor(lagBlock+q,plocs,
410
 
               blockStartPos[q]+
411
 
               ENH_BLOCKL_HALF-period[lagBlock[q+1]], periodl);
412
 
 
413
 
 
414
 
           if (blockStartPos[q]-ENH_OVERHANG>=0) {
415
 
               refiner(sseq+q*ENH_BLOCKL, blockStartPos+q, idata,
416
 
                   idatal, centerStartPos, blockStartPos[q],
417
 
                   period[lagBlock[q+1]]);
418
 
           } else {
419
 
               psseq=sseq+q*ENH_BLOCKL;
420
 
               memset(psseq, 0, ENH_BLOCKL*sizeof(float));
421
 
           }
422
 
       }
423
 
 
424
 
       /* future */
425
 
 
426
 
       for (i=0; i<periodl; i++) {
427
 
           plocs2[i]=plocs[i]-period[i];
428
 
       }
429
 
       for (q=hl+1; q<=2*hl; q++) {
430
 
           NearestNeighbor(lagBlock+q,plocs2,
431
 
               blockStartPos[q-1]+ENH_BLOCKL_HALF,periodl);
432
 
 
433
 
           blockStartPos[q]=blockStartPos[q-1]+period[lagBlock[q]];
434
 
           if (blockStartPos[q]+ENH_BLOCKL+ENH_OVERHANG<idatal) {
435
 
               refiner(sseq+ENH_BLOCKL*q, blockStartPos+q, idata,
436
 
                   idatal, centerStartPos, blockStartPos[q],
437
 
                   period[lagBlock[q]]);
438
 
           }
439
 
           else {
440
 
               psseq=sseq+q*ENH_BLOCKL;
441
 
               memset(psseq, 0, ENH_BLOCKL*sizeof(float));
442
 
           }
443
 
       }
444
 
   }
445
 
 
446
 
   /*----------------------------------------------------------------*
447
 
    * perform enhancement on idata+centerStartPos through
448
 
    * idata+centerStartPos+ENH_BLOCKL-1
449
 
    *---------------------------------------------------------------*/
450
 
 
451
 
 
452
 
 
453
 
 
454
 
 
455
 
   void enhancer(
456
 
       float *odata,       /* (o) smoothed block, dimension blockl */
457
 
       float *idata,       /* (i) data buffer used for enhancing */
458
 
       int idatal,         /* (i) dimension idata */
459
 
       int centerStartPos, /* (i) first sample current block
460
 
                                  within idata */
461
 
       float alpha0,       /* (i) max correction-energy-fraction
462
 
                                 (in [0,1]) */
463
 
       float *period,      /* (i) pitch period array */
464
 
       float *plocs,       /* (i) locations where period array
465
 
                                  values valid */
466
 
       int periodl         /* (i) dimension of period and plocs */
467
 
   ){
468
 
       float sseq[(2*ENH_HL+1)*ENH_BLOCKL];
469
 
 
470
 
       /* get said second sequence of segments */
471
 
 
472
 
       getsseq(sseq,idata,idatal,centerStartPos,period,
473
 
           plocs,periodl,ENH_HL);
474
 
 
475
 
       /* compute the smoothed output from said second sequence */
476
 
 
477
 
       smath(odata,sseq,ENH_HL,alpha0);
478
 
 
479
 
   }
480
 
 
481
 
   /*----------------------------------------------------------------*
482
 
    * cross correlation
483
 
    *---------------------------------------------------------------*/
484
 
 
485
 
   float xCorrCoef(
486
 
       float *target,      /* (i) first array */
487
 
       float *regressor,   /* (i) second array */
488
 
       int subl        /* (i) dimension arrays */
489
 
   ){
490
 
       int i;
491
 
       float ftmp1, ftmp2;
492
 
 
493
 
       ftmp1 = 0.0;
494
 
       ftmp2 = 0.0;
495
 
       for (i=0; i<subl; i++) {
496
 
           ftmp1 += target[i]*regressor[i];
497
 
           ftmp2 += regressor[i]*regressor[i];
498
 
       }
499
 
 
500
 
       if (ftmp1 > 0.0) {
501
 
           return (float)(ftmp1*ftmp1/ftmp2);
502
 
       }
503
 
 
504
 
 
505
 
 
506
 
 
507
 
 
508
 
       else {
509
 
           return (float)0.0;
510
 
       }
511
 
   }
512
 
 
513
 
   /*----------------------------------------------------------------*
514
 
    * interface for enhancer
515
 
    *---------------------------------------------------------------*/
516
 
 
517
 
   int enhancerInterface(
518
 
       float *out,                     /* (o) enhanced signal */
519
 
       float *in,                      /* (i) unenhanced signal */
520
 
       iLBC_Dec_Inst_t *iLBCdec_inst   /* (i) buffers etc */
521
 
   ){
522
 
       float *enh_buf, *enh_period;
523
 
       int iblock, isample;
524
 
       int lag=0, ilag, i, ioffset;
525
 
       float cc, maxcc;
526
 
       float ftmp1, ftmp2;
527
 
       float *inPtr, *enh_bufPtr1, *enh_bufPtr2;
528
 
       float plc_pred[ENH_BLOCKL];
529
 
 
530
 
       float lpState[6], downsampled[(ENH_NBLOCKS*ENH_BLOCKL+120)/2];
531
 
       int inLen=ENH_NBLOCKS*ENH_BLOCKL+120;
532
 
       int start, plc_blockl, inlag;
533
 
 
534
 
       enh_buf=iLBCdec_inst->enh_buf;
535
 
       enh_period=iLBCdec_inst->enh_period;
536
 
 
537
 
       memmove(enh_buf, &enh_buf[iLBCdec_inst->blockl],
538
 
           (ENH_BUFL-iLBCdec_inst->blockl)*sizeof(float));
539
 
 
540
 
       memcpy(&enh_buf[ENH_BUFL-iLBCdec_inst->blockl], in,
541
 
           iLBCdec_inst->blockl*sizeof(float));
542
 
 
543
 
       if (iLBCdec_inst->mode==30)
544
 
           plc_blockl=ENH_BLOCKL;
545
 
       else
546
 
           plc_blockl=40;
547
 
 
548
 
       /* when 20 ms frame, move processing one block */
549
 
       ioffset=0;
550
 
       if (iLBCdec_inst->mode==20) ioffset=1;
551
 
 
552
 
       i=3-ioffset;
553
 
       memmove(enh_period, &enh_period[i],
554
 
           (ENH_NBLOCKS_TOT-i)*sizeof(float));
555
 
 
556
 
 
557
 
 
558
 
 
559
 
 
560
 
 
561
 
       /* Set state information to the 6 samples right before
562
 
          the samples to be downsampled. */
563
 
 
564
 
       memcpy(lpState,
565
 
           enh_buf+(ENH_NBLOCKS_EXTRA+ioffset)*ENH_BLOCKL-126,
566
 
           6*sizeof(float));
567
 
 
568
 
       /* Down sample a factor 2 to save computations */
569
 
 
570
 
       DownSample(enh_buf+(ENH_NBLOCKS_EXTRA+ioffset)*ENH_BLOCKL-120,
571
 
                   lpFilt_coefsTbl, inLen-ioffset*ENH_BLOCKL,
572
 
                   lpState, downsampled);
573
 
 
574
 
       /* Estimate the pitch in the down sampled domain. */
575
 
       for (iblock = 0; iblock<ENH_NBLOCKS-ioffset; iblock++) {
576
 
 
577
 
           lag = 10;
578
 
           maxcc = xCorrCoef(downsampled+60+iblock*
579
 
               ENH_BLOCKL_HALF, downsampled+60+iblock*
580
 
               ENH_BLOCKL_HALF-lag, ENH_BLOCKL_HALF);
581
 
           for (ilag=11; ilag<60; ilag++) {
582
 
               cc = xCorrCoef(downsampled+60+iblock*
583
 
                   ENH_BLOCKL_HALF, downsampled+60+iblock*
584
 
                   ENH_BLOCKL_HALF-ilag, ENH_BLOCKL_HALF);
585
 
 
586
 
               if (cc > maxcc) {
587
 
                   maxcc = cc;
588
 
                   lag = ilag;
589
 
               }
590
 
           }
591
 
 
592
 
           /* Store the estimated lag in the non-downsampled domain */
593
 
           enh_period[iblock+ENH_NBLOCKS_EXTRA+ioffset] = (float)lag*2;
594
 
 
595
 
 
596
 
       }
597
 
 
598
 
 
599
 
       /* PLC was performed on the previous packet */
600
 
       if (iLBCdec_inst->prev_enh_pl==1) {
601
 
 
602
 
           inlag=(int)enh_period[ENH_NBLOCKS_EXTRA+ioffset];
603
 
 
604
 
           lag = inlag-1;
605
 
           maxcc = xCorrCoef(in, in+lag, plc_blockl);
606
 
           for (ilag=inlag; ilag<=inlag+1; ilag++) {
607
 
               cc = xCorrCoef(in, in+ilag, plc_blockl);
608
 
 
609
 
 
610
 
 
611
 
 
612
 
 
613
 
 
614
 
               if (cc > maxcc) {
615
 
                   maxcc = cc;
616
 
                   lag = ilag;
617
 
               }
618
 
           }
619
 
 
620
 
           enh_period[ENH_NBLOCKS_EXTRA+ioffset-1]=(float)lag;
621
 
 
622
 
           /* compute new concealed residual for the old lookahead,
623
 
              mix the forward PLC with a backward PLC from
624
 
              the new frame */
625
 
 
626
 
           inPtr=&in[lag-1];
627
 
 
628
 
           enh_bufPtr1=&plc_pred[plc_blockl-1];
629
 
 
630
 
           if (lag>plc_blockl) {
631
 
               start=plc_blockl;
632
 
           } else {
633
 
               start=lag;
634
 
           }
635
 
 
636
 
           for (isample = start; isample>0; isample--) {
637
 
               *enh_bufPtr1-- = *inPtr--;
638
 
           }
639
 
 
640
 
           enh_bufPtr2=&enh_buf[ENH_BUFL-1-iLBCdec_inst->blockl];
641
 
           for (isample = (plc_blockl-1-lag); isample>=0; isample--) {
642
 
               *enh_bufPtr1-- = *enh_bufPtr2--;
643
 
           }
644
 
 
645
 
           /* limit energy change */
646
 
           ftmp2=0.0;
647
 
           ftmp1=0.0;
648
 
           for (i=0;i<plc_blockl;i++) {
649
 
               ftmp2+=enh_buf[ENH_BUFL-1-iLBCdec_inst->blockl-i]*
650
 
                   enh_buf[ENH_BUFL-1-iLBCdec_inst->blockl-i];
651
 
               ftmp1+=plc_pred[i]*plc_pred[i];
652
 
           }
653
 
           ftmp1=(float)sqrt(ftmp1/(float)plc_blockl);
654
 
           ftmp2=(float)sqrt(ftmp2/(float)plc_blockl);
655
 
           if (ftmp1>(float)2.0*ftmp2 && ftmp1>0.0) {
656
 
               for (i=0;i<plc_blockl-10;i++) {
657
 
                   plc_pred[i]*=(float)2.0*ftmp2/ftmp1;
658
 
               }
659
 
               for (i=plc_blockl-10;i<plc_blockl;i++) {
660
 
                   plc_pred[i]*=(float)(i-plc_blockl+10)*
661
 
                       ((float)1.0-(float)2.0*ftmp2/ftmp1)/(float)(10)+
662
 
 
663
 
 
664
 
 
665
 
 
666
 
 
667
 
                       (float)2.0*ftmp2/ftmp1;
668
 
               }
669
 
           }
670
 
 
671
 
           enh_bufPtr1=&enh_buf[ENH_BUFL-1-iLBCdec_inst->blockl];
672
 
           for (i=0; i<plc_blockl; i++) {
673
 
               ftmp1 = (float) (i+1) / (float) (plc_blockl+1);
674
 
               *enh_bufPtr1 *= ftmp1;
675
 
               *enh_bufPtr1 += ((float)1.0-ftmp1)*
676
 
                                   plc_pred[plc_blockl-1-i];
677
 
               enh_bufPtr1--;
678
 
           }
679
 
       }
680
 
 
681
 
       if (iLBCdec_inst->mode==20) {
682
 
           /* Enhancer with 40 samples delay */
683
 
           for (iblock = 0; iblock<2; iblock++) {
684
 
               enhancer(out+iblock*ENH_BLOCKL, enh_buf,
685
 
                   ENH_BUFL, (5+iblock)*ENH_BLOCKL+40,
686
 
                   ENH_ALPHA0, enh_period, enh_plocsTbl,
687
 
                       ENH_NBLOCKS_TOT);
688
 
           }
689
 
       } else if (iLBCdec_inst->mode==30) {
690
 
           /* Enhancer with 80 samples delay */
691
 
           for (iblock = 0; iblock<3; iblock++) {
692
 
               enhancer(out+iblock*ENH_BLOCKL, enh_buf,
693
 
                   ENH_BUFL, (4+iblock)*ENH_BLOCKL,
694
 
                   ENH_ALPHA0, enh_period, enh_plocsTbl,
695
 
                       ENH_NBLOCKS_TOT);
696
 
           }
697
 
       }
698
 
 
699
 
       return (lag*2);
700
 
   }