Fix compiler warnings
[opus.git] / celt / modes.c
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 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
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