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