← Back to branch summary

~ubuntu-branches/ubuntu/trusty/sflphone/trusty

« back to all changes in this revision

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

  • Committer: Package Import Robot
  • Author(s): Mark Purcell
  • Date: 2013-06-30 11:40:56 UTC
  • mfrom: (4.1.18 saucy-proposed)
  • Revision ID: package-import@ubuntu.com-20130630114056-0np50jkyqo6vnmii
Tags: 1.2.3-2
* changeset_r92d62cfc54732bbbcfff2b1d36c096b120b981a5.diff 
  - fixes automatic endian detection 
* Update Vcs: fixes vcs-field-not-canonical

Show diffs side-by-side

added added

removed removed

Lines of Context:
daemon/libs/pjproject-2.0.1/third_party/ilbc/getCBvec.c
 
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
 
 
21
   void getCBvec(
 
22
 
 
23
 
 
24
 
 
25
 
 
26
 
 
27
       float *cbvec,   /* (o) Constructed codebook vector */
 
28
       float *mem,     /* (i) Codebook buffer */
 
29
       int index,      /* (i) Codebook index */
 
30
       int lMem,       /* (i) Length of codebook buffer */
 
31
       int cbveclen/* (i) Codebook vector length */
 
32
   ){
 
33
       int j, k, n, memInd, sFilt;
 
34
       float tmpbuf[CB_MEML];
 
35
       int base_size;
 
36
       int ilow, ihigh;
 
37
       float alfa, alfa1;
 
38
 
 
39
       /* Determine size of codebook sections */
 
40
 
 
41
       base_size=lMem-cbveclen+1;
 
42
 
 
43
       if (cbveclen==SUBL) {
 
44
           base_size+=cbveclen/2;
 
45
       }
 
46
 
 
47
       /* No filter -> First codebook section */
 
48
 
 
49
       if (index<lMem-cbveclen+1) {
 
50
 
 
51
           /* first non-interpolated vectors */
 
52
 
 
53
           k=index+cbveclen;
 
54
           /* get vector */
 
55
           memcpy(cbvec, mem+lMem-k, cbveclen*sizeof(float));
 
56
 
 
57
       } else if (index < base_size) {
 
58
 
 
59
           k=2*(index-(lMem-cbveclen+1))+cbveclen;
 
60
 
 
61
           ihigh=k/2;
 
62
           ilow=ihigh-5;
 
63
 
 
64
           /* Copy first noninterpolated part */
 
65
 
 
66
           memcpy(cbvec, mem+lMem-k/2, ilow*sizeof(float));
 
67
 
 
68
           /* interpolation */
 
69
 
 
70
           alfa1=(float)0.2;
 
71
           alfa=0.0;
 
72
           for (j=ilow; j<ihigh; j++) {
 
73
               cbvec[j]=((float)1.0-alfa)*mem[lMem-k/2+j]+
 
74
                   alfa*mem[lMem-k+j];
 
75
 
 
76
 
 
77
 
 
78
 
 
79
 
 
80
               alfa+=alfa1;
 
81
           }
 
82
 
 
83
           /* Copy second noninterpolated part */
 
84
 
 
85
           memcpy(cbvec+ihigh, mem+lMem-k+ihigh,
 
86
               (cbveclen-ihigh)*sizeof(float));
 
87
 
 
88
       }
 
89
 
 
90
       /* Higher codebook section based on filtering */
 
91
 
 
92
       else {
 
93
 
 
94
           /* first non-interpolated vectors */
 
95
 
 
96
           if (index-base_size<lMem-cbveclen+1) {
 
97
               float tempbuff2[CB_MEML+CB_FILTERLEN+1];
 
98
               float *pos;
 
99
               float *pp, *pp1;
 
100
 
 
101
               memset(tempbuff2, 0,
 
102
                   CB_HALFFILTERLEN*sizeof(float));
 
103
               memcpy(&tempbuff2[CB_HALFFILTERLEN], mem,
 
104
                   lMem*sizeof(float));
 
105
               memset(&tempbuff2[lMem+CB_HALFFILTERLEN], 0,
 
106
                   (CB_HALFFILTERLEN+1)*sizeof(float));
 
107
 
 
108
               k=index-base_size+cbveclen;
 
109
               sFilt=lMem-k;
 
110
               memInd=sFilt+1-CB_HALFFILTERLEN;
 
111
 
 
112
               /* do filtering */
 
113
               pos=cbvec;
 
114
               memset(pos, 0, cbveclen*sizeof(float));
 
115
               for (n=0; n<cbveclen; n++) {
 
116
                   pp=&tempbuff2[memInd+n+CB_HALFFILTERLEN];
 
117
                   pp1=&cbfiltersTbl[CB_FILTERLEN-1];
 
118
                   for (j=0; j<CB_FILTERLEN; j++) {
 
119
                       (*pos)+=(*pp++)*(*pp1--);
 
120
                   }
 
121
                   pos++;
 
122
               }
 
123
           }
 
124
 
 
125
           /* interpolated vectors */
 
126
 
 
127
           else {
 
128
 
 
129
 
 
130
 
 
131
 
 
132
 
 
133
               float tempbuff2[CB_MEML+CB_FILTERLEN+1];
 
134
 
 
135
               float *pos;
 
136
               float *pp, *pp1;
 
137
               int i;
 
138
 
 
139
               memset(tempbuff2, 0,
 
140
                   CB_HALFFILTERLEN*sizeof(float));
 
141
               memcpy(&tempbuff2[CB_HALFFILTERLEN], mem,
 
142
                   lMem*sizeof(float));
 
143
               memset(&tempbuff2[lMem+CB_HALFFILTERLEN], 0,
 
144
                   (CB_HALFFILTERLEN+1)*sizeof(float));
 
145
 
 
146
               k=2*(index-base_size-
 
147
                   (lMem-cbveclen+1))+cbveclen;
 
148
               sFilt=lMem-k;
 
149
               memInd=sFilt+1-CB_HALFFILTERLEN;
 
150
 
 
151
               /* do filtering */
 
152
               pos=&tmpbuf[sFilt];
 
153
               memset(pos, 0, k*sizeof(float));
 
154
               for (i=0; i<k; i++) {
 
155
                   pp=&tempbuff2[memInd+i+CB_HALFFILTERLEN];
 
156
                   pp1=&cbfiltersTbl[CB_FILTERLEN-1];
 
157
                   for (j=0; j<CB_FILTERLEN; j++) {
 
158
                       (*pos)+=(*pp++)*(*pp1--);
 
159
                   }
 
160
                   pos++;
 
161
               }
 
162
 
 
163
               ihigh=k/2;
 
164
               ilow=ihigh-5;
 
165
 
 
166
               /* Copy first noninterpolated part */
 
167
 
 
168
               memcpy(cbvec, tmpbuf+lMem-k/2,
 
169
                   ilow*sizeof(float));
 
170
 
 
171
               /* interpolation */
 
172
 
 
173
               alfa1=(float)0.2;
 
174
               alfa=0.0;
 
175
               for (j=ilow; j<ihigh; j++) {
 
176
                   cbvec[j]=((float)1.0-alfa)*
 
177
                       tmpbuf[lMem-k/2+j]+alfa*tmpbuf[lMem-k+j];
 
178
                   alfa+=alfa1;
 
179
               }
 
180
 
 
181
 
 
182
 
 
183
 
 
184
 
 
185
 
 
186
               /* Copy second noninterpolated part */
 
187
 
 
188
               memcpy(cbvec+ihigh, tmpbuf+lMem-k+ihigh,
 
189
                   (cbveclen-ihigh)*sizeof(float));
 
190
           }
 
191
       }
 
192
   }