f332191c6076427a432527c16ac75275b52cb48e
[opus.git] / celt / celt.c
1 /* Copyright (c) 2007-2008 CSIRO
2    Copyright (c) 2007-2010 Xiph.Org Foundation
3    Copyright (c) 2008 Gregory Maxwell
4    Written by Jean-Marc Valin and Gregory Maxwell */
5 /*
6    Redistribution and use in source and binary forms, with or without
7    modification, are permitted provided that the following conditions
8    are met:
9
10    - Redistributions of source code must retain the above copyright
11    notice, this list of conditions and the following disclaimer.
12
13    - Redistributions in binary form must reproduce the above copyright
14    notice, this list of conditions and the following disclaimer in the
15    documentation and/or other materials provided with the distribution.
16
17    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
21    OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
22    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
23    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
24    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
25    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
26    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
27    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30 #ifdef HAVE_CONFIG_H
31 #include "config.h"
32 #endif
33
34 #define CELT_C
35
36 #include "os_support.h"
37 #include "mdct.h"
38 #include <math.h>
39 #include "celt.h"
40 #include "pitch.h"
41 #include "bands.h"
42 #include "modes.h"
43 #include "entcode.h"
44 #include "quant_bands.h"
45 #include "rate.h"
46 #include "stack_alloc.h"
47 #include "mathops.h"
48 #include "float_cast.h"
49 #include <stdarg.h>
50 #include "celt_lpc.h"
51 #include "vq.h"
52
53 #ifndef PACKAGE_VERSION
54 #define PACKAGE_VERSION "unknown"
55 #endif
56
57 #if defined(MIPSr1_ASM)
58 #include "mips/celt_mipsr1.h"
59 #endif
60
61
62 int resampling_factor(opus_int32 rate)
63 {
64    int ret;
65    switch (rate)
66    {
67    case 48000:
68       ret = 1;
69       break;
70    case 24000:
71       ret = 2;
72       break;
73    case 16000:
74       ret = 3;
75       break;
76    case 12000:
77       ret = 4;
78       break;
79    case 8000:
80       ret = 6;
81       break;
82    default:
83 #ifndef CUSTOM_MODES
84       celt_assert(0);
85 #endif
86       ret = 0;
87       break;
88    }
89    return ret;
90 }
91
92 #if !defined(OVERRIDE_COMB_FILTER_CONST) || defined(NON_STATIC_COMB_FILTER_CONST_C)
93 /* This version should be faster on ARM */
94 #ifdef OPUS_ARM_ASM
95 #ifndef NON_STATIC_COMB_FILTER_CONST_C
96 static
97 #endif
98 void comb_filter_const_c(opus_val32 *y, opus_val32 *x, int T, int N,
99       opus_val16 g10, opus_val16 g11, opus_val16 g12)
100 {
101    opus_val32 x0, x1, x2, x3, x4;
102    int i;
103    x4 = SHL32(x[-T-2], 1);
104    x3 = SHL32(x[-T-1], 1);
105    x2 = SHL32(x[-T], 1);
106    x1 = SHL32(x[-T+1], 1);
107    for (i=0;i<N-4;i+=5)
108    {
109       opus_val32 t;
110       x0=SHL32(x[i-T+2],1);
111       t = MAC16_32_Q16(x[i], g10, x2);
112       t = MAC16_32_Q16(t, g11, ADD32(x1,x3));
113       t = MAC16_32_Q16(t, g12, ADD32(x0,x4));
114       t = SATURATE(t, SIG_SAT);
115       y[i] = t;
116       x4=SHL32(x[i-T+3],1);
117       t = MAC16_32_Q16(x[i+1], g10, x1);
118       t = MAC16_32_Q16(t, g11, ADD32(x0,x2));
119       t = MAC16_32_Q16(t, g12, ADD32(x4,x3));
120       t = SATURATE(t, SIG_SAT);
121       y[i+1] = t;
122       x3=SHL32(x[i-T+4],1);
123       t = MAC16_32_Q16(x[i+2], g10, x0);
124       t = MAC16_32_Q16(t, g11, ADD32(x4,x1));
125       t = MAC16_32_Q16(t, g12, ADD32(x3,x2));
126       t = SATURATE(t, SIG_SAT);
127       y[i+2] = t;
128       x2=SHL32(x[i-T+5],1);
129       t = MAC16_32_Q16(x[i+3], g10, x4);
130       t = MAC16_32_Q16(t, g11, ADD32(x3,x0));
131       t = MAC16_32_Q16(t, g12, ADD32(x2,x1));
132       t = SATURATE(t, SIG_SAT);
133       y[i+3] = t;
134       x1=SHL32(x[i-T+6],1);
135       t = MAC16_32_Q16(x[i+4], g10, x3);
136       t = MAC16_32_Q16(t, g11, ADD32(x2,x4));
137       t = MAC16_32_Q16(t, g12, ADD32(x1,x0));
138       t = SATURATE(t, SIG_SAT);
139       y[i+4] = t;
140    }
141 #ifdef CUSTOM_MODES
142    for (;i<N;i++)
143    {
144       opus_val32 t;
145       x0=SHL32(x[i-T+2],1);
146       t = MAC16_32_Q16(x[i], g10, x2);
147       t = MAC16_32_Q16(t, g11, ADD32(x1,x3));
148       t = MAC16_32_Q16(t, g12, ADD32(x0,x4));
149       t = SATURATE(t, SIG_SAT);
150       y[i] = t;
151       x4=x3;
152       x3=x2;
153       x2=x1;
154       x1=x0;
155    }
156 #endif
157 }
158 #else
159 #ifndef NON_STATIC_COMB_FILTER_CONST_C
160 static
161 #endif
162 void comb_filter_const_c(opus_val32 *y, opus_val32 *x, int T, int N,
163       opus_val16 g10, opus_val16 g11, opus_val16 g12)
164 {
165    opus_val32 x0, x1, x2, x3, x4;
166    int i;
167    x4 = x[-T-2];
168    x3 = x[-T-1];
169    x2 = x[-T];
170    x1 = x[-T+1];
171    for (i=0;i<N;i++)
172    {
173       x0=x[i-T+2];
174       y[i] = x[i]
175                + MULT16_32_Q15(g10,x2)
176                + MULT16_32_Q15(g11,ADD32(x1,x3))
177                + MULT16_32_Q15(g12,ADD32(x0,x4));
178       y[i] = SATURATE(y[i], SIG_SAT);
179       x4=x3;
180       x3=x2;
181       x2=x1;
182       x1=x0;
183    }
184
185 }
186 #endif
187 #endif
188
189 #ifndef OVERRIDE_comb_filter
190 void comb_filter(opus_val32 *y, opus_val32 *x, int T0, int T1, int N,
191       opus_val16 g0, opus_val16 g1, int tapset0, int tapset1,
192       const opus_val16 *window, int overlap, int arch)
193 {
194    int i;
195    /* printf ("%d %d %f %f\n", T0, T1, g0, g1); */
196    opus_val16 g00, g01, g02, g10, g11, g12;
197    opus_val32 x0, x1, x2, x3, x4;
198    static const opus_val16 gains[3][3] = {
199          {QCONST16(0.3066406250f, 15), QCONST16(0.2170410156f, 15), QCONST16(0.1296386719f, 15)},
200          {QCONST16(0.4638671875f, 15), QCONST16(0.2680664062f, 15), QCONST16(0.f, 15)},
201          {QCONST16(0.7998046875f, 15), QCONST16(0.1000976562f, 15), QCONST16(0.f, 15)}};
202
203    if (g0==0 && g1==0)
204    {
205       /* OPT: Happens to work without the OPUS_MOVE(), but only because the current encoder already copies x to y */
206       if (x!=y)
207          OPUS_MOVE(y, x, N);
208       return;
209    }
210    g00 = MULT16_16_P15(g0, gains[tapset0][0]);
211    g01 = MULT16_16_P15(g0, gains[tapset0][1]);
212    g02 = MULT16_16_P15(g0, gains[tapset0][2]);
213    g10 = MULT16_16_P15(g1, gains[tapset1][0]);
214    g11 = MULT16_16_P15(g1, gains[tapset1][1]);
215    g12 = MULT16_16_P15(g1, gains[tapset1][2]);
216    x1 = x[-T1+1];
217    x2 = x[-T1  ];
218    x3 = x[-T1-1];
219    x4 = x[-T1-2];
220    /* If the filter didn't change, we don't need the overlap */
221    if (g0==g1 && T0==T1 && tapset0==tapset1)
222       overlap=0;
223    for (i=0;i<overlap;i++)
224    {
225       opus_val16 f;
226       x0=x[i-T1+2];
227       f = MULT16_16_Q15(window[i],window[i]);
228       y[i] = x[i]
229                + MULT16_32_Q15(MULT16_16_Q15((Q15ONE-f),g00),x[i-T0])
230                + MULT16_32_Q15(MULT16_16_Q15((Q15ONE-f),g01),ADD32(x[i-T0+1],x[i-T0-1]))
231                + MULT16_32_Q15(MULT16_16_Q15((Q15ONE-f),g02),ADD32(x[i-T0+2],x[i-T0-2]))
232                + MULT16_32_Q15(MULT16_16_Q15(f,g10),x2)
233                + MULT16_32_Q15(MULT16_16_Q15(f,g11),ADD32(x1,x3))
234                + MULT16_32_Q15(MULT16_16_Q15(f,g12),ADD32(x0,x4));
235       y[i] = SATURATE(y[i], SIG_SAT);
236       x4=x3;
237       x3=x2;
238       x2=x1;
239       x1=x0;
240
241    }
242    if (g1==0)
243    {
244       /* OPT: Happens to work without the OPUS_MOVE(), but only because the current encoder already copies x to y */
245       if (x!=y)
246          OPUS_MOVE(y+overlap, x+overlap, N-overlap);
247       return;
248    }
249
250    /* Compute the part with the constant filter. */
251    comb_filter_const(y+i, x+i, T1, N-i, g10, g11, g12, arch);
252 }
253 #endif /* OVERRIDE_comb_filter */
254
255 /* TF change table. Positive values mean better frequency resolution (longer
256    effective window), whereas negative values mean better time resolution
257    (shorter effective window). The second index is computed as:
258    4*isTransient + 2*tf_select + per_band_flag */
259 const signed char tf_select_table[4][8] = {
260     /*isTransient=0     isTransient=1 */
261       {0, -1, 0, -1,    0,-1, 0,-1}, /* 2.5 ms */
262       {0, -1, 0, -2,    1, 0, 1,-1}, /* 5 ms */
263       {0, -2, 0, -3,    2, 0, 1,-1}, /* 10 ms */
264       {0, -2, 0, -3,    3, 0, 1,-1}, /* 20 ms */
265 };
266
267
268 void init_caps(const CELTMode *m,int *cap,int LM,int C)
269 {
270    int i;
271    for (i=0;i<m->nbEBands;i++)
272    {
273       int N;
274       N=(m->eBands[i+1]-m->eBands[i])<<LM;
275       cap[i] = (m->cache.caps[m->nbEBands*(2*LM+C-1)+i]+64)*C*N>>2;
276    }
277 }
278
279
280
281 const char *opus_strerror(int error)
282 {
283    static const char * const error_strings[8] = {
284       "success",
285       "invalid argument",
286       "buffer too small",
287       "internal error",
288       "corrupted stream",
289       "request not implemented",
290       "invalid state",
291       "memory allocation failed"
292    };
293    if (error > 0 || error < -7)
294       return "unknown error";
295    else
296       return error_strings[-error];
297 }
298
299 const char *opus_get_version_string(void)
300 {
301     return "libopus " PACKAGE_VERSION
302     /* Applications may rely on the presence of this substring in the version
303        string to determine if they have a fixed-point or floating-point build
304        at runtime. */
305 #ifdef FIXED_POINT
306           "-fixed"
307 #endif
308 #ifdef FUZZING
309           "-fuzzing"
310 #endif
311           ;
312 }