1 
2    /******************************************************************
3 
4        iLBC Speech Coder ANSI-C Source Code
5 
6        getCBvec.c
7 
8        Copyright (C) The Internet Society (2004).
9        All Rights Reserved.
10 
11    ******************************************************************/
12 
13    #include "iLBC_define.h"
14    #include "constants.h"
15    #include <string.h>
16 
17    /*----------------------------------------------------------------*
18     *  Construct codebook vector for given index.
19     *---------------------------------------------------------------*/
20 
getCBvec(float * cbvec,float * mem,int index,int lMem,int cbveclen)21    void getCBvec(
22        float *cbvec,   /* (o) Constructed codebook vector */
23        float *mem,     /* (i) Codebook buffer */
24        int index,      /* (i) Codebook index */
25        int lMem,       /* (i) Length of codebook buffer */
26        int cbveclen/* (i) Codebook vector length */
27    ){
28        int j, k, n, memInd, sFilt;
29        float tmpbuf[CB_MEML];
30        int base_size;
31        int ilow, ihigh;
32        float alfa, alfa1;
33 
34        /* Determine size of codebook sections */
35 
36        base_size=lMem-cbveclen+1;
37 
38        if (cbveclen==SUBL) {
39            base_size+=cbveclen/2;
40        }
41 
42        /* No filter -> First codebook section */
43 
44 
45 
46        if (index<lMem-cbveclen+1) {
47 
48            /* first non-interpolated vectors */
49 
50            k=index+cbveclen;
51            /* get vector */
52            memcpy(cbvec, mem+lMem-k, cbveclen*sizeof(float));
53 
54        } else if (index < base_size) {
55 
56            k=2*(index-(lMem-cbveclen+1))+cbveclen;
57 
58            ihigh=k/2;
59            ilow=ihigh-5;
60 
61            /* Copy first noninterpolated part */
62 
63            memcpy(cbvec, mem+lMem-k/2, ilow*sizeof(float));
64 
65            /* interpolation */
66 
67            alfa1=(float)0.2;
68            alfa=0.0;
69            for (j=ilow; j<ihigh; j++) {
70                cbvec[j]=((float)1.0-alfa)*mem[lMem-k/2+j]+
71                    alfa*mem[lMem-k+j];
72                alfa+=alfa1;
73            }
74 
75            /* Copy second noninterpolated part */
76 
77            memcpy(cbvec+ihigh, mem+lMem-k+ihigh,
78                (cbveclen-ihigh)*sizeof(float));
79 
80        }
81 
82        /* Higher codebbok section based on filtering */
83 
84        else {
85 
86            /* first non-interpolated vectors */
87 
88            if (index-base_size<lMem-cbveclen+1) {
89                float tempbuff2[CB_MEML+CB_FILTERLEN+1];
90                float *pos;
91                float *pp, *pp1;
92 
93                memset(tempbuff2, 0,
94                    CB_HALFFILTERLEN*sizeof(float));
95                memcpy(&tempbuff2[CB_HALFFILTERLEN], mem,
96                    lMem*sizeof(float));
97                memset(&tempbuff2[lMem+CB_HALFFILTERLEN], 0,
98                    (CB_HALFFILTERLEN+1)*sizeof(float));
99 
100 
101 
102                k=index-base_size+cbveclen;
103                sFilt=lMem-k;
104                memInd=sFilt+1-CB_HALFFILTERLEN;
105 
106                /* do filtering */
107                pos=cbvec;
108                memset(pos, 0, cbveclen*sizeof(float));
109                for (n=0; n<cbveclen; n++) {
110                    pp=&tempbuff2[memInd+n+CB_HALFFILTERLEN];
111                    pp1=&cbfiltersTbl[CB_FILTERLEN-1];
112                    for (j=0; j<CB_FILTERLEN; j++) {
113                        (*pos)+=(*pp++)*(*pp1--);
114                    }
115                    pos++;
116                }
117            }
118 
119            /* interpolated vectors */
120 
121            else {
122                float tempbuff2[CB_MEML+CB_FILTERLEN+1];
123 
124                float *pos;
125                float *pp, *pp1;
126                int i;
127 
128                memset(tempbuff2, 0,
129                    CB_HALFFILTERLEN*sizeof(float));
130                memcpy(&tempbuff2[CB_HALFFILTERLEN], mem,
131                    lMem*sizeof(float));
132                memset(&tempbuff2[lMem+CB_HALFFILTERLEN], 0,
133                    (CB_HALFFILTERLEN+1)*sizeof(float));
134 
135                k=2*(index-base_size-
136                    (lMem-cbveclen+1))+cbveclen;
137                sFilt=lMem-k;
138                memInd=sFilt+1-CB_HALFFILTERLEN;
139 
140                /* do filtering */
141                pos=&tmpbuf[sFilt];
142                memset(pos, 0, k*sizeof(float));
143                for (i=0; i<k; i++) {
144                    pp=&tempbuff2[memInd+i+CB_HALFFILTERLEN];
145                    pp1=&cbfiltersTbl[CB_FILTERLEN-1];
146                    for (j=0; j<CB_FILTERLEN; j++) {
147                        (*pos)+=(*pp++)*(*pp1--);
148                    }
149                    pos++;
150                }
151 
152                ihigh=k/2;
153                ilow=ihigh-5;
154 
155 
156 
157                /* Copy first noninterpolated part */
158 
159                memcpy(cbvec, tmpbuf+lMem-k/2,
160                    ilow*sizeof(float));
161 
162                /* interpolation */
163 
164                alfa1=(float)0.2;
165                alfa=0.0;
166                for (j=ilow; j<ihigh; j++) {
167                    cbvec[j]=((float)1.0-alfa)*
168                        tmpbuf[lMem-k/2+j]+alfa*tmpbuf[lMem-k+j];
169                    alfa+=alfa1;
170                }
171 
172                /* Copy second noninterpolated part */
173 
174                memcpy(cbvec+ihigh, tmpbuf+lMem-k+ihigh,
175                    (cbveclen-ihigh)*sizeof(float));
176            }
177        }
178    }
179 
180 
181