fixed three declaration-after-statement issues
[opus.git] / libcelt / modes.c
1 /* (C) 2007-2008 Jean-Marc Valin, CSIRO
2 */
3 /*
4    Redistribution and use in source and binary forms, with or without
5    modification, are permitted provided that the following conditions
6    are met:
7    
8    - Redistributions of source code must retain the above copyright
9    notice, this list of conditions and the following disclaimer.
10    
11    - Redistributions in binary form must reproduce the above copyright
12    notice, this list of conditions and the following disclaimer in the
13    documentation and/or other materials provided with the distribution.
14    
15    - Neither the name of the Xiph.org Foundation nor the names of its
16    contributors may be used to endorse or promote products derived from
17    this software without specific prior written permission.
18    
19    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22    A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
23    CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
24    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
25    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
26    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
27    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
28    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
29    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 #ifdef HAVE_CONFIG_H
33 #include "config.h"
34 #endif
35
36 #include "celt.h"
37 #include "modes.h"
38 #include "rate.h"
39 #include "os_support.h"
40
41 #ifdef STATIC_MODES
42 #include "static_modes.c"
43 #endif
44
45 #define MODEVALID 0xa110ca7e
46 #define MODEFREED 0xb10cf8ee
47
48 #ifndef M_PI
49 #define M_PI 3.141592653
50 #endif
51
52
53 int EXPORT celt_mode_info(const CELTMode *mode, int request, celt_int32_t *value)
54 {
55    switch (request)
56    {
57       case CELT_GET_FRAME_SIZE:
58          *value = mode->mdctSize;
59          break;
60       case CELT_GET_LOOKAHEAD:
61          *value = mode->overlap;
62          break;
63       case CELT_GET_NB_CHANNELS:
64          *value = mode->nbChannels;
65          break;
66       default:
67          return CELT_BAD_ARG;
68    }
69    return CELT_OK;
70 }
71
72 #ifndef STATIC_MODES
73
74 #define PBANDS 8
75 #define MIN_BINS 4
76 /* Defining 25 critical bands for the full 0-20 kHz audio bandwidth
77    Taken from http://ccrma.stanford.edu/~jos/bbt/Bark_Frequency_Scale.html */
78 #define BARK_BANDS 25
79 static const celt_int16_t bark_freq[BARK_BANDS+1] = {
80       0,   100,   200,   300,   400,
81     510,   630,   770,   920,  1080,
82    1270,  1480,  1720,  2000,  2320,
83    2700,  3150,  3700,  4400,  5300,
84    6400,  7700,  9500, 12000, 15500,
85   20000};
86
87 static const celt_int16_t pitch_freq[PBANDS+1] ={0, 345, 689, 1034, 1378, 2067, 3273, 5340, 6374};
88
89 /* This allocation table is per critical band. When creating a mode, the bits get added together 
90    into the codec bands, which are sometimes larger than one critical band at low frequency */
91 #define BITALLOC_SIZE 10
92 static const int band_allocation[BARK_BANDS*BITALLOC_SIZE] = 
93    {  2,  2,  1,  1,  2,  2,  1,  1,  1,  1,  1,  1,  1,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
94       2,  2,  2,  1,  2,  2,  2,  2,  2,  1,  2,  2,  5,  5,  7,  7,  7,  5,  4,  0,  0,  0,  0,  0,  0,
95       2,  2,  2,  2,  3,  2,  2,  2,  2,  2,  3,  2,  6,  6,  8,  8,  8,  6,  5,  4,  0,  0,  0,  0,  0,
96       3,  2,  2,  2,  3,  3,  2,  3,  2,  2,  4,  3,  7,  7,  9,  9,  9,  7,  6,  5,  5,  5,  0,  0,  0,
97       3,  3,  2,  2,  3,  3,  3,  3,  3,  2,  4,  4,  9,  9, 10, 10, 10,  9,  6,  5,  5,  5,  5,  0,  0,
98       3,  3,  2,  2,  3,  3,  3,  3,  3,  3,  4,  4, 10, 10, 12, 12, 12, 10, 10, 10, 11, 10, 10,  5,  5,
99       4,  4,  4,  4,  5,  5,  5,  5,  5,  4,  7,  7, 14, 13, 13, 13, 13, 13, 15, 16, 17, 18, 20, 18, 11,
100       7,  7,  6,  6,  9,  8,  8,  8,  8,  8, 11, 11, 20, 18, 19, 19, 25, 22, 25, 30, 30, 35, 35, 35, 35,
101       8,  8,  8,  8, 10, 10, 10, 10,  9,  9, 19, 18, 25, 24, 23, 21, 29, 27, 35, 40, 42, 50, 59, 54, 51,
102      11, 11, 10, 10, 14, 13, 13, 13, 13, 12, 19, 18, 35, 34, 33, 31, 39, 37, 45, 50, 52, 60, 60, 60, 60,
103    };
104
105
106 static celt_int16_t *compute_ebands(celt_int32_t Fs, int frame_size, int *nbEBands)
107 {
108    celt_int16_t *eBands;
109    int i, res, min_width, lin, low, high;
110    res = (Fs+frame_size)/(2*frame_size);
111    min_width = MIN_BINS*res;
112    /*printf ("min_width = %d\n", min_width);*/
113
114    /* Find where the linear part ends (i.e. where the spacing is more than min_width */
115    for (lin=0;lin<BARK_BANDS;lin++)
116       if (bark_freq[lin+1]-bark_freq[lin] >= min_width)
117          break;
118    
119    /*printf ("lin = %d (%d Hz)\n", lin, bark_freq[lin]);*/
120    low = ((bark_freq[lin]/res)+(MIN_BINS-1))/MIN_BINS;
121    high = BARK_BANDS-lin;
122    *nbEBands = low+high;
123    eBands = celt_alloc(sizeof(celt_int16_t)*(*nbEBands+2));
124    
125    /* Linear spacing (min_width) */
126    for (i=0;i<low;i++)
127       eBands[i] = MIN_BINS*i;
128    /* Spacing follows critical bands */
129    for (i=0;i<high;i++)
130       eBands[i+low] = (bark_freq[lin+i]+res/2)/res;
131    /* Enforce the minimum spacing at the boundary */
132    for (i=0;i<*nbEBands;i++)
133       if (eBands[i] < MIN_BINS*i)
134          eBands[i] = MIN_BINS*i;
135    eBands[*nbEBands] = (bark_freq[BARK_BANDS]+res/2)/res;
136    eBands[*nbEBands+1] = frame_size;
137    if (eBands[*nbEBands] > eBands[*nbEBands+1])
138       eBands[*nbEBands] = eBands[*nbEBands+1];
139    
140    /* FIXME: Remove last band if too small */
141    /*for (i=0;i<*nbEBands+2;i++)
142       printf("%d ", eBands[i]);
143    printf ("\n");*/
144    return eBands;
145 }
146
147 static void compute_pbands(CELTMode *mode, int res)
148 {
149    int i;
150    celt_int16_t *pBands;
151    pBands=celt_alloc(sizeof(celt_int16_t)*(PBANDS+2));
152    mode->nbPBands = PBANDS;
153    for (i=0;i<PBANDS+1;i++)
154    {
155       pBands[i] = (pitch_freq[i]+res/2)/res;
156       if (pBands[i] < mode->eBands[i])
157          pBands[i] = mode->eBands[i];
158    }
159    pBands[PBANDS+1] = mode->eBands[mode->nbEBands+1];
160    for (i=1;i<mode->nbPBands+1;i++)
161    {
162       int j;
163       for (j=0;j<mode->nbEBands;j++)
164          if (mode->eBands[j] <= pBands[i] && mode->eBands[j+1] > pBands[i])
165             break;
166       /*printf ("%d %d\n", i, j);*/
167       if (mode->eBands[j] != pBands[i])
168       {
169          if (pBands[i]-mode->eBands[j] < mode->eBands[j+1]-pBands[i] && 
170              mode->eBands[j] != pBands[i-1])
171             pBands[i] = mode->eBands[j];
172          else
173             pBands[i] = mode->eBands[j+1];
174       }
175    }
176    /*for (i=0;i<mode->nbPBands+2;i++)
177       printf("%d ", pBands[i]);
178    printf ("\n");*/
179    mode->pBands = pBands;
180    mode->pitchEnd = pBands[PBANDS];
181 }
182
183 static void compute_allocation_table(CELTMode *mode, int res)
184 {
185    int i, j, eband;
186    celt_int16_t *allocVectors;
187    
188    mode->nbAllocVectors = BITALLOC_SIZE;
189    allocVectors = celt_alloc(sizeof(celt_int16_t)*(BITALLOC_SIZE*mode->nbEBands));
190    for (i=0;i<BITALLOC_SIZE;i++)
191    {
192       eband = 0;
193       for (j=0;j<BARK_BANDS;j++)
194       {
195          int edge, low;
196          edge = mode->eBands[eband+1]*res;
197          if (edge < bark_freq[j+1])
198          {
199             int num, den;
200             num = band_allocation[i*BARK_BANDS+j] * (edge-bark_freq[j]);
201             den = bark_freq[j+1]-bark_freq[j];
202             low = (num+den/2)/den;
203             allocVectors[i*mode->nbEBands+eband] += low;
204             eband++;
205             allocVectors[i*mode->nbEBands+eband] += band_allocation[i*BARK_BANDS+j]-low;
206          } else {
207             allocVectors[i*mode->nbEBands+eband] += band_allocation[i*BARK_BANDS+j];
208          }
209       }
210    }
211    /*for (i=0;i<BITALLOC_SIZE;i++)
212    {
213       for (j=0;j<mode->nbEBands;j++)
214          printf ("%2d ", allocVectors[i*mode->nbEBands+j]);
215       printf ("\n");
216    }*/
217    mode->allocVectors = allocVectors;
218 }
219
220 #endif /* STATIC_MODES */
221
222 CELTMode EXPORT *celt_mode_create(celt_int32_t Fs, int channels, int frame_size, int lookahead, int *error)
223 {
224 #ifdef STATIC_MODES
225    const CELTMode *m = NULL;
226    CELTMode *mode=NULL;
227    int i;
228    for (i=0;i<TOTAL_MODES;i++)
229    {
230       if (Fs == static_mode_list[i]->Fs &&
231           channels == static_mode_list[i]->nbChannels &&
232           frame_size == static_mode_list[i]->mdctSize &&
233           lookahead == static_mode_list[i]->overlap)
234       {
235          m = static_mode_list[i];
236          break;
237       }
238    }
239    if (m == NULL)
240    {
241       celt_warning("Mode not included as part of the static modes");
242       if (error)
243          *error = CELT_BAD_ARG;
244       return NULL;
245    }
246    mode = (CELTMode*)celt_alloc(sizeof(CELTMode));
247    CELT_COPY(mode, m, 1);
248 #else
249    int res;
250    int i;
251    CELTMode *mode;
252    celt_word16_t *window;
253
254    /* The good thing here is that permutation of the arguments will automatically be invalid */
255    
256    if (Fs < 32000 || Fs > 64000)
257    {
258       celt_warning("Sampling rate must be between 32 kHz and 64 kHz");
259       if (error)
260          *error = CELT_BAD_ARG;
261       return NULL;
262    }
263    if (channels < 0 || channels > 2)
264    {
265       celt_warning("Only mono and stereo supported");
266       if (error)
267          *error = CELT_BAD_ARG;
268       return NULL;
269    }
270    if (frame_size < 64 || frame_size > 256 || frame_size%2!=0)
271    {
272       celt_warning("Only even frame sizes between 64 and 256 are supported");
273       if (error)
274          *error = CELT_BAD_ARG;
275       return NULL;
276    }
277    if (lookahead < 32 || lookahead > frame_size)
278    {
279       celt_warning("The overlap must be between 32 and the frame size");
280       if (error)
281          *error = CELT_BAD_ARG;
282       return NULL;
283    }
284    res = (Fs+frame_size)/(2*frame_size);
285    
286    mode = celt_alloc(sizeof(CELTMode));
287    mode->Fs = Fs;
288    mode->overlap = lookahead;
289    mode->mdctSize = frame_size;
290    mode->nbChannels = channels;
291    mode->eBands = compute_ebands(Fs, frame_size, &mode->nbEBands);
292    compute_pbands(mode, res);
293    mode->ePredCoef = QCONST16(.8f,15);
294    
295    compute_allocation_table(mode, res);
296    /*printf ("%d bands\n", mode->nbEBands);*/
297    
298    window = (celt_word16_t*)celt_alloc(mode->overlap*sizeof(celt_word16_t));
299
300 #ifndef FIXED_POINT
301    for (i=0;i<mode->overlap;i++)
302       window[i] = Q15ONE*sin(.5*M_PI* sin(.5*M_PI*(i+.5)/mode->overlap) * sin(.5*M_PI*(i+.5)/mode->overlap));
303 #else
304    for (i=0;i<mode->overlap;i++)
305       window[i] = MIN32(32767,32768.*sin(.5*M_PI* sin(.5*M_PI*(i+.5)/mode->overlap) * sin(.5*M_PI*(i+.5)/mode->overlap)));
306 #endif
307    mode->window = window;
308
309    compute_alloc_cache(mode);
310
311    psydecay_init(&mode->psy, MAX_PERIOD/2, mode->Fs);
312
313    mode->marker_start = MODEVALID;
314    mode->marker_end = MODEVALID;
315 #endif /* !STATIC_MODES */
316    mdct_init(&mode->mdct, 2*mode->mdctSize);
317    if (error)
318       *error = CELT_OK;
319    return mode;
320 }
321
322 void EXPORT celt_mode_destroy(CELTMode *mode)
323 {
324 #ifndef STATIC_MODES
325    int i;
326    const celt_int16_t *prevPtr = NULL;
327    for (i=0;i<mode->nbEBands;i++)
328    {
329       if (mode->bits[i] != prevPtr)
330       {
331          prevPtr = mode->bits[i];
332          celt_free((int*)mode->bits[i]);
333       }
334    }
335    celt_free((int**)mode->bits);
336    if (check_mode(mode) != CELT_OK)
337       return;
338    celt_free((int*)mode->eBands);
339    celt_free((int*)mode->pBands);
340    celt_free((int*)mode->allocVectors);
341    
342    celt_free((celt_word16_t*)mode->window);
343
344    mode->marker_start = MODEFREED;
345    mode->marker_end = MODEFREED;
346    psydecay_clear(&mode->psy);
347 #endif
348    mdct_clear(&mode->mdct);
349    celt_free((CELTMode *)mode);
350 }
351
352 int check_mode(const CELTMode *mode)
353 {
354    if (mode->marker_start == MODEVALID && mode->marker_end == MODEVALID)
355       return CELT_OK;
356    if (mode->marker_start == MODEFREED || mode->marker_end == MODEFREED)
357       celt_warning("Using a mode that has already been freed");
358    else
359       celt_warning("This is not a valid CELT mode");
360    return CELT_INVALID_MODE;
361 }