1 /* Copyright (c) 2007-2008 CSIRO
2 Copyright (c) 2007-2009 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 #include "celt.h"
35 #include "modes.h"
36 #include "rate.h"
37 #include "os_support.h"
38 #include "stack_alloc.h"
39 #include "quant_bands.h"
40 #include "cpu_support.h"
41
42 static const opus_int16 eband5ms[] = {
43 /*0 200 400 600 800 1k 1.2 1.4 1.6 2k 2.4 2.8 3.2 4k 4.8 5.6 6.8 8k 9.6 12k 15.6 */
44 0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 34, 40, 48, 60, 78, 100
45 };
46
47 /* Alternate tuning (partially derived from Vorbis) */
48 #define BITALLOC_SIZE 11
49 /* Bit allocation table in units of 1/32 bit/sample (0.1875 dB SNR) */
50 static const unsigned char band_allocation[] = {
51 /*0 200 400 600 800 1k 1.2 1.4 1.6 2k 2.4 2.8 3.2 4k 4.8 5.6 6.8 8k 9.6 12k 15.6 */
52 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
53 90, 80, 75, 69, 63, 56, 49, 40, 34, 29, 20, 18, 10, 0, 0, 0, 0, 0, 0, 0, 0,
54 110,100, 90, 84, 78, 71, 65, 58, 51, 45, 39, 32, 26, 20, 12, 0, 0, 0, 0, 0, 0,
55 118,110,103, 93, 86, 80, 75, 70, 65, 59, 53, 47, 40, 31, 23, 15, 4, 0, 0, 0, 0,
56 126,119,112,104, 95, 89, 83, 78, 72, 66, 60, 54, 47, 39, 32, 25, 17, 12, 1, 0, 0,
57 134,127,120,114,103, 97, 91, 85, 78, 72, 66, 60, 54, 47, 41, 35, 29, 23, 16, 10, 1,
58 144,137,130,124,113,107,101, 95, 88, 82, 76, 70, 64, 57, 51, 45, 39, 33, 26, 15, 1,
59 152,145,138,132,123,117,111,105, 98, 92, 86, 80, 74, 67, 61, 55, 49, 43, 36, 20, 1,
60 162,155,148,142,133,127,121,115,108,102, 96, 90, 84, 77, 71, 65, 59, 53, 46, 30, 1,
61 172,165,158,152,143,137,131,125,118,112,106,100, 94, 87, 81, 75, 69, 63, 56, 45, 20,
62 200,200,200,200,200,200,200,200,198,193,188,183,178,173,168,163,158,153,148,129,104,
63 };
64
65 #ifndef CUSTOM_MODES_ONLY
66 #ifdef FIXED_POINT
67 #include "static_modes_fixed.h"
68 #else
69 #include "static_modes_float.h"
70 #endif
71 #endif /* CUSTOM_MODES_ONLY */
72
73 #ifndef M_PI
74 #define M_PI 3.141592653
75 #endif
76
77 #ifdef CUSTOM_MODES
78
79 /* Defining 25 critical bands for the full 0-20 kHz audio bandwidth
80 Taken from http://ccrma.stanford.edu/~jos/bbt/Bark_Frequency_Scale.html */
81 #define BARK_BANDS 25
82 static const opus_int16 bark_freq[BARK_BANDS+1] = {
83 0, 100, 200, 300, 400,
84 510, 630, 770, 920, 1080,
85 1270, 1480, 1720, 2000, 2320,
86 2700, 3150, 3700, 4400, 5300,
87 6400, 7700, 9500, 12000, 15500,
88 20000};
89
compute_ebands(opus_int32 Fs,int frame_size,int res,int * nbEBands)90 static opus_int16 *compute_ebands(opus_int32 Fs, int frame_size, int res, int *nbEBands)
91 {
92 opus_int16 *eBands;
93 int i, j, lin, low, high, nBark, offset=0;
94
95 /* All modes that have 2.5 ms short blocks use the same definition */
96 if (Fs == 400*(opus_int32)frame_size)
97 {
98 *nbEBands = sizeof(eband5ms)/sizeof(eband5ms[0])-1;
99 eBands = opus_alloc(sizeof(opus_int16)*(*nbEBands+1));
100 for (i=0;i<*nbEBands+1;i++)
101 eBands[i] = eband5ms[i];
102 return eBands;
103 }
104 /* Find the number of critical bands supported by our sampling rate */
105 for (nBark=1;nBark<BARK_BANDS;nBark++)
106 if (bark_freq[nBark+1]*2 >= Fs)
107 break;
108
109 /* Find where the linear part ends (i.e. where the spacing is more than min_width */
110 for (lin=0;lin<nBark;lin++)
111 if (bark_freq[lin+1]-bark_freq[lin] >= res)
112 break;
113
114 low = (bark_freq[lin]+res/2)/res;
115 high = nBark-lin;
116 *nbEBands = low+high;
117 eBands = opus_alloc(sizeof(opus_int16)*(*nbEBands+2));
118
119 if (eBands==NULL)
120 return NULL;
121
122 /* Linear spacing (min_width) */
123 for (i=0;i<low;i++)
124 eBands[i] = i;
125 if (low>0)
126 offset = eBands[low-1]*res - bark_freq[lin-1];
127 /* Spacing follows critical bands */
128 for (i=0;i<high;i++)
129 {
130 int target = bark_freq[lin+i];
131 /* Round to an even value */
132 eBands[i+low] = (target+offset/2+res)/(2*res)*2;
133 offset = eBands[i+low]*res - target;
134 }
135 /* Enforce the minimum spacing at the boundary */
136 for (i=0;i<*nbEBands;i++)
137 if (eBands[i] < i)
138 eBands[i] = i;
139 /* Round to an even value */
140 eBands[*nbEBands] = (bark_freq[nBark]+res)/(2*res)*2;
141 if (eBands[*nbEBands] > frame_size)
142 eBands[*nbEBands] = frame_size;
143 for (i=1;i<*nbEBands-1;i++)
144 {
145 if (eBands[i+1]-eBands[i] < eBands[i]-eBands[i-1])
146 {
147 eBands[i] -= (2*eBands[i]-eBands[i-1]-eBands[i+1])/2;
148 }
149 }
150 /* Remove any empty bands. */
151 for (i=j=0;i<*nbEBands;i++)
152 if(eBands[i+1]>eBands[j])
153 eBands[++j]=eBands[i+1];
154 *nbEBands=j;
155
156 for (i=1;i<*nbEBands;i++)
157 {
158 /* Every band must be smaller than the last band. */
159 celt_assert(eBands[i]-eBands[i-1]<=eBands[*nbEBands]-eBands[*nbEBands-1]);
160 /* Each band must be no larger than twice the size of the previous one. */
161 celt_assert(eBands[i+1]-eBands[i]<=2*(eBands[i]-eBands[i-1]));
162 }
163
164 return eBands;
165 }
166
compute_allocation_table(CELTMode * mode)167 static void compute_allocation_table(CELTMode *mode)
168 {
169 int i, j;
170 unsigned char *allocVectors;
171 int maxBands = sizeof(eband5ms)/sizeof(eband5ms[0])-1;
172
173 mode->nbAllocVectors = BITALLOC_SIZE;
174 allocVectors = opus_alloc(sizeof(unsigned char)*(BITALLOC_SIZE*mode->nbEBands));
175 if (allocVectors==NULL)
176 return;
177
178 /* Check for standard mode */
179 if (mode->Fs == 400*(opus_int32)mode->shortMdctSize)
180 {
181 for (i=0;i<BITALLOC_SIZE*mode->nbEBands;i++)
182 allocVectors[i] = band_allocation[i];
183 mode->allocVectors = allocVectors;
184 return;
185 }
186 /* If not the standard mode, interpolate */
187 /* Compute per-codec-band allocation from per-critical-band matrix */
188 for (i=0;i<BITALLOC_SIZE;i++)
189 {
190 for (j=0;j<mode->nbEBands;j++)
191 {
192 int k;
193 for (k=0;k<maxBands;k++)
194 {
195 if (400*(opus_int32)eband5ms[k] > mode->eBands[j]*(opus_int32)mode->Fs/mode->shortMdctSize)
196 break;
197 }
198 if (k>maxBands-1)
199 allocVectors[i*mode->nbEBands+j] = band_allocation[i*maxBands + maxBands-1];
200 else {
201 opus_int32 a0, a1;
202 a1 = mode->eBands[j]*(opus_int32)mode->Fs/mode->shortMdctSize - 400*(opus_int32)eband5ms[k-1];
203 a0 = 400*(opus_int32)eband5ms[k] - mode->eBands[j]*(opus_int32)mode->Fs/mode->shortMdctSize;
204 allocVectors[i*mode->nbEBands+j] = (a0*band_allocation[i*maxBands+k-1]
205 + a1*band_allocation[i*maxBands+k])/(a0+a1);
206 }
207 }
208 }
209
210 /*printf ("\n");
211 for (i=0;i<BITALLOC_SIZE;i++)
212 {
213 for (j=0;j<mode->nbEBands;j++)
214 printf ("%d ", allocVectors[i*mode->nbEBands+j]);
215 printf ("\n");
216 }
217 exit(0);*/
218
219 mode->allocVectors = allocVectors;
220 }
221
222 #endif /* CUSTOM_MODES */
223
opus_custom_mode_create(opus_int32 Fs,int frame_size,int * error)224 CELTMode *opus_custom_mode_create(opus_int32 Fs, int frame_size, int *error)
225 {
226 int i;
227 #ifdef CUSTOM_MODES
228 CELTMode *mode=NULL;
229 int res;
230 opus_val16 *window;
231 opus_int16 *logN;
232 int LM;
233 int arch = opus_select_arch();
234 ALLOC_STACK;
235 #if !defined(VAR_ARRAYS) && !defined(USE_ALLOCA)
236 if (global_stack==NULL)
237 goto failure;
238 #endif
239 #endif
240
241 #ifndef CUSTOM_MODES_ONLY
242 for (i=0;i<TOTAL_MODES;i++)
243 {
244 int j;
245 for (j=0;j<4;j++)
246 {
247 if (Fs == static_mode_list[i]->Fs &&
248 (frame_size<<j) == static_mode_list[i]->shortMdctSize*static_mode_list[i]->nbShortMdcts)
249 {
250 if (error)
251 *error = OPUS_OK;
252 return (CELTMode*)static_mode_list[i];
253 }
254 }
255 }
256 #endif /* CUSTOM_MODES_ONLY */
257
258 #ifndef CUSTOM_MODES
259 if (error)
260 *error = OPUS_BAD_ARG;
261 return NULL;
262 #else
263
264 /* The good thing here is that permutation of the arguments will automatically be invalid */
265
266 if (Fs < 8000 || Fs > 96000)
267 {
268 if (error)
269 *error = OPUS_BAD_ARG;
270 return NULL;
271 }
272 if (frame_size < 40 || frame_size > 1024 || frame_size%2!=0)
273 {
274 if (error)
275 *error = OPUS_BAD_ARG;
276 return NULL;
277 }
278 /* Frames of less than 1ms are not supported. */
279 if ((opus_int32)frame_size*1000 < Fs)
280 {
281 if (error)
282 *error = OPUS_BAD_ARG;
283 return NULL;
284 }
285
286 if ((opus_int32)frame_size*75 >= Fs && (frame_size%16)==0)
287 {
288 LM = 3;
289 } else if ((opus_int32)frame_size*150 >= Fs && (frame_size%8)==0)
290 {
291 LM = 2;
292 } else if ((opus_int32)frame_size*300 >= Fs && (frame_size%4)==0)
293 {
294 LM = 1;
295 } else
296 {
297 LM = 0;
298 }
299
300 /* Shorts longer than 3.3ms are not supported. */
301 if ((opus_int32)(frame_size>>LM)*300 > Fs)
302 {
303 if (error)
304 *error = OPUS_BAD_ARG;
305 return NULL;
306 }
307
308 mode = opus_alloc(sizeof(CELTMode));
309 if (mode==NULL)
310 goto failure;
311 mode->Fs = Fs;
312
313 /* Pre/de-emphasis depends on sampling rate. The "standard" pre-emphasis
314 is defined as A(z) = 1 - 0.85*z^-1 at 48 kHz. Other rates should
315 approximate that. */
316 if(Fs < 12000) /* 8 kHz */
317 {
318 mode->preemph[0] = QCONST16(0.3500061035f, 15);
319 mode->preemph[1] = -QCONST16(0.1799926758f, 15);
320 mode->preemph[2] = QCONST16(0.2719968125f, SIG_SHIFT); /* exact 1/preemph[3] */
321 mode->preemph[3] = QCONST16(3.6765136719f, 13);
322 } else if(Fs < 24000) /* 16 kHz */
323 {
324 mode->preemph[0] = QCONST16(0.6000061035f, 15);
325 mode->preemph[1] = -QCONST16(0.1799926758f, 15);
326 mode->preemph[2] = QCONST16(0.4424998650f, SIG_SHIFT); /* exact 1/preemph[3] */
327 mode->preemph[3] = QCONST16(2.2598876953f, 13);
328 } else if(Fs < 40000) /* 32 kHz */
329 {
330 mode->preemph[0] = QCONST16(0.7799987793f, 15);
331 mode->preemph[1] = -QCONST16(0.1000061035f, 15);
332 mode->preemph[2] = QCONST16(0.7499771125f, SIG_SHIFT); /* exact 1/preemph[3] */
333 mode->preemph[3] = QCONST16(1.3333740234f, 13);
334 } else /* 48 kHz */
335 {
336 mode->preemph[0] = QCONST16(0.8500061035f, 15);
337 mode->preemph[1] = QCONST16(0.0f, 15);
338 mode->preemph[2] = QCONST16(1.f, SIG_SHIFT);
339 mode->preemph[3] = QCONST16(1.f, 13);
340 }
341
342 mode->maxLM = LM;
343 mode->nbShortMdcts = 1<<LM;
344 mode->shortMdctSize = frame_size/mode->nbShortMdcts;
345 res = (mode->Fs+mode->shortMdctSize)/(2*mode->shortMdctSize);
346
347 mode->eBands = compute_ebands(Fs, mode->shortMdctSize, res, &mode->nbEBands);
348 if (mode->eBands==NULL)
349 goto failure;
350 #if !defined(SMALL_FOOTPRINT)
351 /* Make sure we don't allocate a band larger than our PVQ table.
352 208 should be enough, but let's be paranoid. */
353 if ((mode->eBands[mode->nbEBands] - mode->eBands[mode->nbEBands-1])<<LM >
354 208) {
355 goto failure;
356 }
357 #endif
358
359 mode->effEBands = mode->nbEBands;
360 while (mode->eBands[mode->effEBands] > mode->shortMdctSize)
361 mode->effEBands--;
362
363 /* Overlap must be divisible by 4 */
364 mode->overlap = ((mode->shortMdctSize>>2)<<2);
365
366 compute_allocation_table(mode);
367 if (mode->allocVectors==NULL)
368 goto failure;
369
370 window = (opus_val16*)opus_alloc(mode->overlap*sizeof(opus_val16));
371 if (window==NULL)
372 goto failure;
373
374 #ifndef FIXED_POINT
375 for (i=0;i<mode->overlap;i++)
376 window[i] = Q15ONE*sin(.5*M_PI* sin(.5*M_PI*(i+.5)/mode->overlap) * sin(.5*M_PI*(i+.5)/mode->overlap));
377 #else
378 for (i=0;i<mode->overlap;i++)
379 window[i] = MIN32(32767,floor(.5+32768.*sin(.5*M_PI* sin(.5*M_PI*(i+.5)/mode->overlap) * sin(.5*M_PI*(i+.5)/mode->overlap))));
380 #endif
381 mode->window = window;
382
383 logN = (opus_int16*)opus_alloc(mode->nbEBands*sizeof(opus_int16));
384 if (logN==NULL)
385 goto failure;
386
387 for (i=0;i<mode->nbEBands;i++)
388 logN[i] = log2_frac(mode->eBands[i+1]-mode->eBands[i], BITRES);
389 mode->logN = logN;
390
391 compute_pulse_cache(mode, mode->maxLM);
392
393 if (clt_mdct_init(&mode->mdct, 2*mode->shortMdctSize*mode->nbShortMdcts,
394 mode->maxLM, arch) == 0)
395 goto failure;
396
397 if (error)
398 *error = OPUS_OK;
399
400 return mode;
401 failure:
402 if (error)
403 *error = OPUS_ALLOC_FAIL;
404 if (mode!=NULL)
405 opus_custom_mode_destroy(mode);
406 return NULL;
407 #endif /* !CUSTOM_MODES */
408 }
409
410 #ifdef CUSTOM_MODES
opus_custom_mode_destroy(CELTMode * mode)411 void opus_custom_mode_destroy(CELTMode *mode)
412 {
413 int arch = opus_select_arch();
414
415 if (mode == NULL)
416 return;
417 #ifndef CUSTOM_MODES_ONLY
418 {
419 int i;
420 for (i=0;i<TOTAL_MODES;i++)
421 {
422 if (mode == static_mode_list[i])
423 {
424 return;
425 }
426 }
427 }
428 #endif /* CUSTOM_MODES_ONLY */
429 opus_free((opus_int16*)mode->eBands);
430 opus_free((unsigned char*)mode->allocVectors);
431
432 opus_free((opus_val16*)mode->window);
433 opus_free((opus_int16*)mode->logN);
434
435 opus_free((opus_int16*)mode->cache.index);
436 opus_free((unsigned char*)mode->cache.bits);
437 opus_free((unsigned char*)mode->cache.caps);
438 clt_mdct_clear(&mode->mdct, arch);
439
440 opus_free((CELTMode *)mode);
441 }
442 #endif
443