Implemented new "global" search for the whole sub-frame, slight improvement
[speexdsp.git] / libspeex / cb_search.c
1 /* Copyright (C) 2002 Jean-Marc Valin 
2    File: cb_search.c
3
4    This library is free software; you can redistribute it and/or
5    modify it under the terms of the GNU Lesser General Public
6    License as published by the Free Software Foundation; either
7    version 2.1 of the License, or (at your option) any later version.
8    
9    This library is distributed in the hope that it will be useful,
10    but WITHOUT ANY WARRANTY; without even the implied warranty of
11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12    Lesser General Public License for more details.
13    
14    You should have received a copy of the GNU Lesser General Public
15    License along with this library; if not, write to the Free Software
16    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17 */
18
19
20
21 #include <stdlib.h>
22 #include <cb_search.h>
23 #include "filters.h"
24 #include <math.h>
25 #include <stdio.h>
26 #include "stack_alloc.h"
27 #include "vq.h"
28
29 #define min(a,b) ((a) < (b) ? (a) : (b))
30 #define max(a,b) ((a) > (b) ? (a) : (b))
31
32 void split_cb_search_nogain(
33 float target[],                 /* target vector */
34 float ak[],                     /* LPCs for this subframe */
35 float awk1[],                   /* Weighted LPCs for this subframe */
36 float awk2[],                   /* Weighted LPCs for this subframe */
37 void *par,                      /* Codebook/search parameters*/
38 int   p,                        /* number of LPC coeffs */
39 int   nsf,                      /* number of samples in subframe */
40 float *exc,
41 SpeexBits *bits,
42 float *stack
43 )
44 {
45    int i,j;
46    float *resp;
47    float *t, *r, *e;
48    int *ind;
49    float *shape_cb;
50    int shape_cb_size, subvect_size, nb_subvect;
51    split_cb_params *params;
52
53    params = (split_cb_params *) par;
54    subvect_size = params->subvect_size;
55    nb_subvect = params->nb_subvect;
56    shape_cb_size = 1<<params->shape_bits;
57    shape_cb = params->shape_cb;
58    resp = PUSH(stack, shape_cb_size*subvect_size);
59    t = PUSH(stack, nsf);
60    r = PUSH(stack, nsf);
61    e = PUSH(stack, nsf);
62    ind = (int*)PUSH(stack, nb_subvect);
63
64    for (i=0;i<nsf;i++)
65       t[i]=target[i];
66
67    e[0]=1;
68    for (i=1;i<nsf;i++)
69       e[i]=0;
70    residue_zero(e, awk1, r, nsf, p);
71    syn_filt_zero(r, ak, r, nsf, p);
72    syn_filt_zero(r, awk2, r, nsf,p);
73    
74    /* Pre-compute codewords response and energy */
75    for (i=0;i<shape_cb_size;i++)
76    {
77       float *res = resp+i*subvect_size;
78
79       /* Compute codeword response */
80       int k;
81       for(j=0;j<subvect_size;j++)
82          res[j]=0;
83       for(j=0;j<subvect_size;j++)
84       {
85          for (k=j;k<subvect_size;k++)
86             res[k]+=shape_cb[i*subvect_size+j]*r[k-j];
87       }
88    }
89
90    for (i=0;i<nb_subvect;i++)
91    {
92       int best_index=0, k, m;
93       float g, dist, best_dist=-1;
94       float *a, *b;
95
96       /* Find best codeword for current sub-vector */
97       for (j=0;j<shape_cb_size;j++)
98       {
99          dist=0;
100          a=resp+j*subvect_size;
101          b=t+subvect_size*i;
102          for (k=0;k<subvect_size;k++)
103             dist += (a[k]-b[k])*(a[k]-b[k]);
104          if (dist<best_dist || j==0)
105          {
106             best_dist=dist;
107             best_index=j;
108          }
109       }
110       /*printf ("best index: %d/%d\n", best_index, shape_cb_size);*/
111       speex_bits_pack(bits,best_index,params->shape_bits);
112
113       ind[i]=best_index;
114       /* Update target for next subvector */
115       for (j=0;j<subvect_size;j++)
116       {
117          g=shape_cb[best_index*subvect_size+j];
118          for (k=subvect_size*i+j,m=0;k<nsf;k++,m++)
119             t[k] -= g*r[m];
120       }
121
122    }
123    
124    /* Put everything back together */
125    for (i=0;i<nb_subvect;i++)
126       for (j=0;j<subvect_size;j++)
127          e[subvect_size*i+j]=shape_cb[ind[i]*subvect_size+j];
128
129    /* Update excitation */
130    for (j=0;j<nsf;j++)
131       exc[j]+=e[j];
132    
133    /* Update target */
134    residue_zero(e, awk1, r, nsf, p);
135    syn_filt_zero(r, ak, r, nsf, p);
136    syn_filt_zero(r, awk2, r, nsf,p);
137    for (j=0;j<nsf;j++)
138       target[j]-=r[j];
139
140    
141
142    POP(stack);
143    POP(stack);
144    POP(stack);
145    POP(stack);
146    POP(stack);
147 }
148
149
150 void split_cb_search_nogain2(
151 float target[],                 /* target vector */
152 float ak[],                     /* LPCs for this subframe */
153 float awk1[],                   /* Weighted LPCs for this subframe */
154 float awk2[],                   /* Weighted LPCs for this subframe */
155 void *par,                      /* Codebook/search parameters*/
156 int   p,                        /* number of LPC coeffs */
157 int   nsf,                      /* number of samples in subframe */
158 float *exc,
159 SpeexBits *bits,
160 float *stack
161 )
162 {
163    int i,j;
164    float *resp;
165    float *t, *r, *e, *E;
166    int *ind;
167    float *shape_cb;
168    int shape_cb_size, subvect_size, nb_subvect;
169    split_cb_params *params;
170    int best_index_mem[2][2];
171    float best_dist_mem[2];
172    int last_best=0;
173
174    params = (split_cb_params *) par;
175    subvect_size = params->subvect_size;
176    nb_subvect = params->nb_subvect;
177    shape_cb_size = 1<<params->shape_bits;
178    shape_cb = params->shape_cb;
179    resp = PUSH(stack, shape_cb_size*subvect_size);
180    t = PUSH(stack, nsf);
181    r = PUSH(stack, nsf);
182    e = PUSH(stack, nsf);
183    E = PUSH(stack, shape_cb_size);
184    ind = (int*)PUSH(stack, nb_subvect);
185
186    for (i=0;i<nsf;i++)
187       t[i]=target[i];
188
189    e[0]=1;
190    for (i=1;i<nsf;i++)
191       e[i]=0;
192    residue_zero(e, awk1, r, nsf, p);
193    syn_filt_zero(r, ak, r, nsf, p);
194    syn_filt_zero(r, awk2, r, nsf,p);
195    
196    /* Pre-compute codewords response and energy */
197    for (i=0;i<shape_cb_size;i++)
198    {
199       float *res = resp+i*subvect_size;
200
201       /* Compute codeword response */
202       int k;
203       for(j=0;j<subvect_size;j++)
204          res[j]=0;
205       for(j=0;j<subvect_size;j++)
206       {
207          for (k=j;k<subvect_size;k++)
208             res[k]+=shape_cb[i*subvect_size+j]*r[k-j];
209       }
210       E[i]=0;
211       for(j=0;j<subvect_size;j++)
212          E[i]+=res[j]*res[j];
213    }
214
215    for (i=0;i<nb_subvect;i++)
216    {
217       int best_index[2]={0,0}, k, m;
218       float g, best_dist[2]={-1,-1};
219       float *x;
220       float energy=0;
221       x=t+subvect_size*i;
222
223       for (k=0;k<subvect_size;k++)
224          energy+=x[k]*x[k];
225       /* Find best codewords for current sub-vector */
226       if (i==0)
227          vq_nbest(x, resp, subvect_size, shape_cb_size, E, 2, best_index, best_dist);
228       else
229       {
230          best_index[0]=best_index_mem[last_best][0];
231          best_index[1]=best_index_mem[last_best][1];
232       }
233       if (i<nb_subvect-1)
234       {
235          int nbest;
236          float *tt, err[2];
237          float best_score[2];
238          tt=PUSH(stack,nsf);
239          for (nbest=0;nbest<2;nbest++)
240          {
241             for (j=0;j<nsf;j++)
242                tt[j]=t[j];
243             for (j=0;j<subvect_size;j++)
244             {
245                g=shape_cb[best_index[nbest]*subvect_size+j];
246                for (k=subvect_size*i+j,m=0;k<nsf;k++,m++)
247                   tt[k] -= g*r[m];
248             }
249             
250             {
251                vq_nbest(&tt[subvect_size*(i+1)], resp, subvect_size, shape_cb_size, E, 2, best_index_mem[nbest], best_dist_mem);
252                for (j=0;j<subvect_size;j++)
253                {
254                   g=shape_cb[best_index_mem[nbest][0]*subvect_size+j];
255                   for (k=subvect_size*(i+1)+j,m=0;k<nsf;k++,m++)
256                      tt[k] -= g*r[m];
257                }
258             }
259
260             err[nbest]=0;
261             for (j=subvect_size*i;j<subvect_size*(i+2);j++)
262                err[nbest]-=tt[j]*tt[j];
263             
264             best_score[nbest]=err[nbest];
265          }
266
267          if (best_score[1]>best_score[0])
268          {
269             last_best=1;
270             best_index[0]=best_index[1];
271             best_score[0]=best_score[1];
272          } else
273             last_best=0;
274          POP(stack);
275
276       }
277
278       ind[i]=best_index[0];
279
280       /*printf ("best index: %d/%d\n", best_index, shape_cb_size);*/
281       speex_bits_pack(bits,ind[i],params->shape_bits);
282
283       /* Update target for next subvector */
284       for (j=0;j<subvect_size;j++)
285       {
286          g=shape_cb[ind[i]*subvect_size+j];
287          for (k=subvect_size*i+j,m=0;k<nsf;k++,m++)
288             t[k] -= g*r[m];
289       }
290    }
291    
292    /* Put everything back together */
293    for (i=0;i<nb_subvect;i++)
294       for (j=0;j<subvect_size;j++)
295          e[subvect_size*i+j]=shape_cb[ind[i]*subvect_size+j];
296
297    /* Update excitation */
298    for (j=0;j<nsf;j++)
299       exc[j]+=e[j];
300    
301    /* Update target */
302    residue_zero(e, awk1, r, nsf, p);
303    syn_filt_zero(r, ak, r, nsf, p);
304    syn_filt_zero(r, awk2, r, nsf,p);
305    for (j=0;j<nsf;j++)
306       target[j]-=r[j];
307
308    
309    POP(stack);
310    POP(stack);
311    POP(stack);
312    POP(stack);
313    POP(stack);
314    POP(stack);
315 }
316
317
318
319
320 void split_cb_search_nogain3(
321 float target[],                 /* target vector */
322 float ak[],                     /* LPCs for this subframe */
323 float awk1[],                   /* Weighted LPCs for this subframe */
324 float awk2[],                   /* Weighted LPCs for this subframe */
325 void *par,                      /* Codebook/search parameters*/
326 int   p,                        /* number of LPC coeffs */
327 int   nsf,                      /* number of samples in subframe */
328 float *exc,
329 SpeexBits *bits,
330 float *stack
331 )
332 {
333    int i,j,k,m,n,q;
334    float *resp;
335    float *t, *r, *e, *E;
336    /*FIXME: Should make this dynamic*/
337    float *tmp, *ot[20], *nt[20];
338    float *ndist;
339    int *itmp, *nind[20], *oind[20];
340
341    int *ind;
342    float *shape_cb;
343    int shape_cb_size, subvect_size, nb_subvect;
344    split_cb_params *params;
345    int N=4;
346    int *best_index;
347    float *best_dist;
348
349    params = (split_cb_params *) par;
350    subvect_size = params->subvect_size;
351    nb_subvect = params->nb_subvect;
352    shape_cb_size = 1<<params->shape_bits;
353    shape_cb = params->shape_cb;
354    resp = PUSH(stack, shape_cb_size*subvect_size);
355    t = PUSH(stack, nsf);
356    r = PUSH(stack, nsf);
357    e = PUSH(stack, nsf);
358    E = PUSH(stack, shape_cb_size);
359    ind = (int*)PUSH(stack, nb_subvect);
360
361    tmp = PUSH(stack, 2*N*nsf);
362    for (i=0;i<N;i++)
363    {
364       ot[i]=tmp;
365       tmp += nsf;
366       nt[i]=tmp;
367       tmp += nsf;
368    }
369
370    best_index = (int*)PUSH(stack, N);
371    best_dist = PUSH(stack, N);
372    ndist = PUSH(stack, N);
373    
374    itmp = (int*)PUSH(stack, 2*N*nb_subvect);
375    for (i=0;i<N;i++)
376    {
377       nind[i]=itmp;
378       itmp+=nb_subvect;
379       oind[i]=itmp;
380       itmp+=nb_subvect;
381       for (j=0;j<nb_subvect;j++)
382          nind[i][j]=oind[i][j]=-1;
383    }
384
385    for (j=0;j<N;j++)
386       for (i=0;i<nsf;i++)
387          ot[j][i]=target[i];
388
389    for (i=0;i<nsf;i++)
390       t[i]=target[i];
391
392    e[0]=1;
393    for (i=1;i<nsf;i++)
394       e[i]=0;
395    residue_zero(e, awk1, r, nsf, p);
396    syn_filt_zero(r, ak, r, nsf, p);
397    syn_filt_zero(r, awk2, r, nsf,p);
398    
399    /* Pre-compute codewords response and energy */
400    for (i=0;i<shape_cb_size;i++)
401    {
402       float *res = resp+i*subvect_size;
403
404       /* Compute codeword response */
405       int k;
406       for(j=0;j<subvect_size;j++)
407          res[j]=0;
408       for(j=0;j<subvect_size;j++)
409       {
410          for (k=j;k<subvect_size;k++)
411             res[k]+=shape_cb[i*subvect_size+j]*r[k-j];
412       }
413       E[i]=0;
414       for(j=0;j<subvect_size;j++)
415          E[i]+=res[j]*res[j];
416    }
417
418    /*For all subvectors*/
419    for (i=0;i<nb_subvect;i++)
420    {
421       /*"erase" nbest list*/
422       for (j=0;j<N;j++)
423          ndist[j]=-1;
424
425       /*For all n-bests of previous subvector*/
426       for (j=0;j<N;j++)
427       {
428          float *x=ot[j]+subvect_size*i;
429          /*Find new n-best based on previous n-best j*/
430          vq_nbest(x, resp, subvect_size, shape_cb_size, E, N, best_index, best_dist);
431
432          /*For all new n-bests*/
433          for (k=0;k<N;k++)
434          {
435             float err=0;
436             for (m=0;m<nsf;m++)
437                t[m]=ot[j][m];
438             for (m=0;m<subvect_size;m++)
439             {
440                float g=shape_cb[best_index[k]*subvect_size+m];
441                for (n=subvect_size*i+m,q=0;n<nsf;n++,q++)
442                   t[n] -= g*r[q];
443             }
444             
445             for (m=0;m<(i+1)*subvect_size;m++)
446                err += t[m]*t[m];
447             if (err<ndist[N-1] || ndist[N-1]<-.5)
448             {
449                for (m=0;m<N;m++)
450                {
451                   if (err < ndist[m] || ndist[m]<-.5)
452                   {
453                      for (n=N-1;n>m;n--)
454                      {
455                         for (q=0;q<nsf;q++)
456                            nt[n][q]=nt[n-1][q];
457                         for (q=0;q<nb_subvect;q++)
458                            nind[n][q]=nind[n-1][q];
459                         ndist[n]=ndist[n-1];
460                      }
461                      for (q=0;q<nsf;q++)
462                         nt[m][q]=t[q];
463                      for (q=0;q<nb_subvect;q++)
464                         nind[m][q]=oind[j][q];
465                      nind[m][i]=best_index[k];
466                      ndist[m]=err;
467                      break;
468                   }
469                }
470             }
471          }
472          if (i==0)
473            break;
474       }
475
476       for (j=0;j<N;j++)
477          for (m=0;m<nsf;m++)
478             ot[j][m]=nt[j][m];
479       for (j=0;j<N;j++)
480          for (m=0;m<nb_subvect;m++)
481             oind[j][m]=nind[j][m];
482
483    }
484
485    for (i=0;i<nb_subvect;i++)
486    {
487       ind[i]=nind[0][i];
488       speex_bits_pack(bits,ind[i],params->shape_bits);
489    }
490    
491    /* Put everything back together */
492    for (i=0;i<nb_subvect;i++)
493       for (j=0;j<subvect_size;j++)
494          e[subvect_size*i+j]=shape_cb[ind[i]*subvect_size+j];
495
496    /* Update excitation */
497    for (j=0;j<nsf;j++)
498       exc[j]+=e[j];
499    
500    /* Update target */
501    residue_zero(e, awk1, r, nsf, p);
502    syn_filt_zero(r, ak, r, nsf, p);
503    syn_filt_zero(r, awk2, r, nsf,p);
504    for (j=0;j<nsf;j++)
505       target[j]-=r[j];
506
507    POP(stack);
508    POP(stack);
509    POP(stack);
510    POP(stack);
511    POP(stack);
512    POP(stack);
513    POP(stack);
514    POP(stack);
515    POP(stack);
516    POP(stack);
517    POP(stack);
518 }
519
520
521
522
523
524 void split_cb_search_shape_sign(
525 float target[],                 /* target vector */
526 float ak[],                     /* LPCs for this subframe */
527 float awk1[],                   /* Weighted LPCs for this subframe */
528 float awk2[],                   /* Weighted LPCs for this subframe */
529 void *par,                      /* Codebook/search parameters*/
530 int   p,                        /* number of LPC coeffs */
531 int   nsf,                      /* number of samples in subframe */
532 float *exc,
533 SpeexBits *bits,
534 float *stack
535 )
536 {
537    int i,j;
538    float *resp;
539    float *t, *r, *e, *E;
540    int *ind, *signs;
541    float *shape_cb;
542    int shape_cb_size, subvect_size, nb_subvect;
543    split_cb_params *params;
544
545    params = (split_cb_params *) par;
546    subvect_size = params->subvect_size;
547    nb_subvect = params->nb_subvect;
548    shape_cb_size = 1<<params->shape_bits;
549    shape_cb = params->shape_cb;
550    resp = PUSH(stack, shape_cb_size*subvect_size);
551    t = PUSH(stack, nsf);
552    r = PUSH(stack, nsf);
553    e = PUSH(stack, nsf);
554    E = PUSH(stack, shape_cb_size);
555    ind = (int*)PUSH(stack, nb_subvect);
556    signs = (int*)PUSH(stack, nb_subvect);
557
558    for (i=0;i<nsf;i++)
559       t[i]=target[i];
560
561    e[0]=1;
562    for (i=1;i<nsf;i++)
563       e[i]=0;
564    residue_zero(e, awk1, r, nsf, p);
565    syn_filt_zero(r, ak, r, nsf, p);
566    syn_filt_zero(r, awk2, r, nsf,p);
567    
568    /* Pre-compute codewords response and energy */
569    for (i=0;i<shape_cb_size;i++)
570    {
571       float *res = resp+i*subvect_size;
572
573       /* Compute codeword response */
574       int k;
575       for(j=0;j<subvect_size;j++)
576          res[j]=0;
577       for(j=0;j<subvect_size;j++)
578       {
579          for (k=j;k<subvect_size;k++)
580             res[k]+=shape_cb[i*subvect_size+j]*r[k-j];
581       }
582       E[i]=0;
583       for(j=0;j<subvect_size;j++)
584          E[i]+=res[j]*res[j];
585    }
586
587    for (i=0;i<nb_subvect;i++)
588    {
589       int best_index[2]={0,0}, k, m;
590       float g, dist, best_dist[2]={-1,-1}, best_sign[2]={0,0};
591       float *a, *x;
592       float energy=0;
593       x=t+subvect_size*i;
594
595       for (k=0;k<subvect_size;k++)
596          energy+=x[k]*x[k];
597       /* Find best codeword for current sub-vector */
598       for (j=0;j<shape_cb_size;j++)
599       {
600          int sign;
601          dist=0;
602          a=resp+j*subvect_size;
603          dist=0;
604          for (k=0;k<subvect_size;k++)
605             dist -= 2*a[k]*x[k];
606          if (dist > 0)
607          {
608             sign=1;
609             dist =- dist;
610          } else
611             sign=0;
612          dist += energy+E[j];
613          if (dist<best_dist[0] || best_dist[0]<0)
614          {
615             best_dist[1]=best_dist[0];
616             best_index[1]=best_index[0];
617             best_sign[1]=best_sign[0];
618             best_dist[0]=dist;
619             best_index[0]=j;
620             best_sign[0]=sign;
621          } else if (dist<best_dist[1] || best_dist[1]<0)
622          {
623             best_dist[1]=dist;
624             best_index[1]=j;
625             best_sign[1]=sign;
626          }
627       }
628       if (i<nb_subvect-1)
629       {
630          int nbest;
631          float *tt, err[2];
632          float best_score[2];
633          tt=PUSH(stack,nsf);
634          for (nbest=0;nbest<2;nbest++)
635          {
636             float s=1;
637             if (best_sign[nbest])
638                s=-1;
639             for (j=0;j<nsf;j++)
640                tt[j]=t[j];
641             for (j=0;j<subvect_size;j++)
642             {
643                g=s*shape_cb[best_index[nbest]*subvect_size+j];
644                for (k=subvect_size*i+j,m=0;k<nsf;k++,m++)
645                   tt[k] -= g*r[m];
646             }
647             
648             {
649                int best_index2=0, best_sign2=0, sign2;
650                float  best_dist2=0;
651                x=t+subvect_size*(i+1);
652                for (j=0;j<shape_cb_size;j++)
653                {
654                   a=resp+j*subvect_size;
655                   dist = 0;
656                   for (k=0;k<subvect_size;k++)
657                      dist -= 2*a[k]*x[k];
658                   if (dist > 0)
659                   {
660                      sign2=1;
661                      dist =- dist;
662                   } else
663                      sign2=0;
664                   dist += energy+E[j];
665                   if (dist<best_dist2 || j==0)
666                   {
667                      best_dist2=dist;
668                      best_index2=j;
669                      best_sign2=sign2;
670                   }
671                }
672                s=1;
673                if (best_sign2)
674                   s=-1;
675                /*int i2=vq_index(&tt[subvect_size*(i+1)], resp, subvect_size, shape_cb_size);*/
676                
677                for (j=0;j<subvect_size;j++)
678                {
679                   g=s*shape_cb[best_index2*subvect_size+j];
680                   for (k=subvect_size*(i+1)+j,m=0;k<nsf;k++,m++)
681                      tt[k] -= g*r[m];
682                }
683             }
684
685             err[nbest]=0;
686             for (j=subvect_size*i;j<subvect_size*(i+2);j++)
687                err[nbest]-=tt[j]*tt[j];
688             
689             best_score[nbest]=err[nbest];
690          }
691
692          if (best_score[1]>best_score[0])
693          {
694             best_sign[0]=best_sign[1];
695             best_index[0]=best_index[1];
696             best_score[0]=best_score[1];
697          }
698          POP(stack);
699
700       }
701
702       ind[i]=best_index[0];
703       signs[i] = best_sign[0];
704
705       /*printf ("best index: %d/%d\n", best_index, shape_cb_size);*/
706       speex_bits_pack(bits,signs[i],1);
707       speex_bits_pack(bits,ind[i],params->shape_bits);
708
709       /* Update target for next subvector */
710       for (j=0;j<subvect_size;j++)
711       {
712          g=shape_cb[ind[i]*subvect_size+j];
713          if (signs[i])
714             g=-g;
715          for (k=subvect_size*i+j,m=0;k<nsf;k++,m++)
716             t[k] -= g*r[m];
717       }
718    }
719    
720    /* Put everything back together */
721    for (i=0;i<nb_subvect;i++)
722    {
723       float s=1;
724       if (signs[i])
725          s=-1;
726       for (j=0;j<subvect_size;j++)
727          e[subvect_size*i+j]=s*shape_cb[ind[i]*subvect_size+j];
728    }
729    /* Update excitation */
730    for (j=0;j<nsf;j++)
731       exc[j]+=e[j];
732    
733    /* Update target */
734    residue_zero(e, awk1, r, nsf, p);
735    syn_filt_zero(r, ak, r, nsf, p);
736    syn_filt_zero(r, awk2, r, nsf,p);
737    for (j=0;j<nsf;j++)
738       target[j]-=r[j];
739
740    
741    POP(stack);
742    POP(stack);
743    POP(stack);
744    POP(stack);
745    POP(stack);
746    POP(stack);
747    POP(stack);
748 }
749
750
751 void split_cb_nogain_unquant(
752 float *exc,
753 void *par,                      /* non-overlapping codebook */
754 int   nsf,                      /* number of samples in subframe */
755 SpeexBits *bits,
756 float *stack
757 )
758 {
759    int i,j;
760    int *ind;
761    float *shape_cb;
762    int shape_cb_size, subvect_size, nb_subvect;
763    split_cb_params *params;
764
765    params = (split_cb_params *) par;
766    subvect_size = params->subvect_size;
767    nb_subvect = params->nb_subvect;
768    shape_cb_size = 1<<params->shape_bits;
769    shape_cb = params->shape_cb;
770    
771    ind = (int*)PUSH(stack, nb_subvect);
772
773    /* Decode codewords and gains */
774    for (i=0;i<nb_subvect;i++)
775       ind[i] = speex_bits_unpack_unsigned(bits, params->shape_bits);
776
777    /* Compute decoded excitation */
778    for (i=0;i<nb_subvect;i++)
779       for (j=0;j<subvect_size;j++)
780          exc[subvect_size*i+j]+=shape_cb[ind[i]*subvect_size+j];
781
782    POP(stack);
783 }
784
785 void split_cb_shape_sign_unquant(
786 float *exc,
787 void *par,                      /* non-overlapping codebook */
788 int   nsf,                      /* number of samples in subframe */
789 SpeexBits *bits,
790 float *stack
791 )
792 {
793    int i,j;
794    int *ind, *signs;
795    float *shape_cb;
796    int shape_cb_size, subvect_size, nb_subvect;
797    split_cb_params *params;
798
799    params = (split_cb_params *) par;
800    subvect_size = params->subvect_size;
801    nb_subvect = params->nb_subvect;
802    shape_cb_size = 1<<params->shape_bits;
803    shape_cb = params->shape_cb;
804    
805    ind = (int*)PUSH(stack, nb_subvect);
806    signs = (int*)PUSH(stack, nb_subvect);
807
808    /* Decode codewords and gains */
809    for (i=0;i<nb_subvect;i++)
810    {
811       signs[i] = speex_bits_unpack_unsigned(bits, 1);
812       ind[i] = speex_bits_unpack_unsigned(bits, params->shape_bits);
813    }
814    /* Compute decoded excitation */
815    for (i=0;i<nb_subvect;i++)
816    {
817       float s=1;
818       if (signs[i])
819          s=-1;
820       for (j=0;j<subvect_size;j++)
821          exc[subvect_size*i+j]+=s*shape_cb[ind[i]*subvect_size+j];
822    }
823    POP(stack);
824    POP(stack);
825 }