Line data Source code
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 :
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 :
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 :
224 0 : 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 0 : for (i=0;i<TOTAL_MODES;i++)
243 : {
244 : int j;
245 0 : for (j=0;j<4;j++)
246 : {
247 0 : if (Fs == static_mode_list[i]->Fs &&
248 0 : (frame_size<<j) == static_mode_list[i]->shortMdctSize*static_mode_list[i]->nbShortMdcts)
249 : {
250 0 : if (error)
251 0 : *error = OPUS_OK;
252 0 : return (CELTMode*)static_mode_list[i];
253 : }
254 : }
255 : }
256 : #endif /* CUSTOM_MODES_ONLY */
257 :
258 : #ifndef CUSTOM_MODES
259 0 : if (error)
260 0 : *error = OPUS_BAD_ARG;
261 0 : 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
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
|
