Moved mdct state and window to the mode so it can be shared between multiple
[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 #define MODEVALID 0xa110ca7e
42 #define MODEFREED 0xb10cf8ee
43
44
45 int celt_mode_info(const CELTMode *mode, int request, celt_int32_t *value)
46 {
47    switch (request)
48    {
49       case CELT_GET_FRAME_SIZE:
50          *value = mode->mdctSize;
51          break;
52       case CELT_GET_LOOKAHEAD:
53          *value = mode->overlap;
54          break;
55       case CELT_GET_NB_CHANNELS:
56          *value = mode->nbChannels;
57          break;
58       default:
59          return CELT_BAD_ARG;
60    }
61    return CELT_OK;
62 }
63
64 #define PBANDS 8
65 #define MIN_BINS 4
66 /* Defining 25 critical bands for the full 0-20 kHz audio bandwidth
67    Taken from http://ccrma.stanford.edu/~jos/bbt/Bark_Frequency_Scale.html */
68 #define BARK_BANDS 25
69 static const celt_int16_t bark_freq[BARK_BANDS+1] = {
70       0,   100,   200,   300,   400,
71     510,   630,   770,   920,  1080,
72    1270,  1480,  1720,  2000,  2320,
73    2700,  3150,  3700,  4400,  5300,
74    6400,  7700,  9500, 12000, 15500,
75   20000};
76
77 static const celt_int16_t pitch_freq[PBANDS+1] ={0, 345, 689, 1034, 1378, 2067, 3273, 5340, 6374};
78
79 /* This allocation table is per critical band. When creating a mode, the bits get added together 
80    into the codec bands, which are sometimes larger than one critical band at low frequency */
81 #define BITALLOC_SIZE 10
82 static const int band_allocation[BARK_BANDS*BITALLOC_SIZE] = 
83    {  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,
84       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,
85       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,
86       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,
87       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,
88       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,
89       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,
90       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,
91       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,
92      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,
93    };
94
95
96 static int *compute_ebands(int Fs, int frame_size, int *nbEBands)
97 {
98    int *eBands;
99    int i, res, min_width, lin, low, high;
100    res = (Fs+frame_size)/(2*frame_size);
101    min_width = MIN_BINS*res;
102    /*printf ("min_width = %d\n", min_width);*/
103
104    /* Find where the linear part ends (i.e. where the spacing is more than min_width */
105    for (lin=0;lin<BARK_BANDS;lin++)
106       if (bark_freq[lin+1]-bark_freq[lin] >= min_width)
107          break;
108    
109    /*printf ("lin = %d (%d Hz)\n", lin, bark_freq[lin]);*/
110    low = ((bark_freq[lin]/res)+(MIN_BINS-1))/MIN_BINS;
111    high = BARK_BANDS-lin;
112    *nbEBands = low+high;
113    eBands = celt_alloc(sizeof(int)*(*nbEBands+2));
114    
115    /* Linear spacing (min_width) */
116    for (i=0;i<low;i++)
117       eBands[i] = MIN_BINS*i;
118    /* Spacing follows critical bands */
119    for (i=0;i<high;i++)
120       eBands[i+low] = (bark_freq[lin+i]+res/2)/res;
121    /* Enforce the minimum spacing at the boundary */
122    for (i=0;i<*nbEBands;i++)
123       if (eBands[i] < MIN_BINS*i)
124          eBands[i] = MIN_BINS*i;
125    eBands[*nbEBands] = (bark_freq[BARK_BANDS]+res/2)/res;
126    eBands[*nbEBands+1] = frame_size;
127    if (eBands[*nbEBands] > eBands[*nbEBands+1])
128       eBands[*nbEBands] = eBands[*nbEBands+1];
129    
130    /* FIXME: Remove last band if too small */
131    /*for (i=0;i<*nbEBands+2;i++)
132       printf("%d ", eBands[i]);
133    printf ("\n");*/
134    return eBands;
135 }
136
137 static void compute_pbands(CELTMode *mode, int res)
138 {
139    int i;
140    int *pBands;
141    pBands=celt_alloc(sizeof(int)*(PBANDS+2));
142    mode->nbPBands = PBANDS;
143    for (i=0;i<PBANDS+1;i++)
144    {
145       pBands[i] = (pitch_freq[i]+res/2)/res;
146       if (pBands[i] < mode->eBands[i])
147          pBands[i] = mode->eBands[i];
148    }
149    pBands[PBANDS+1] = mode->eBands[mode->nbEBands+1];
150    for (i=1;i<mode->nbPBands+1;i++)
151    {
152       int j;
153       for (j=0;j<mode->nbEBands;j++)
154          if (mode->eBands[j] <= pBands[i] && mode->eBands[j+1] > pBands[i])
155             break;
156       /*printf ("%d %d\n", i, j);*/
157       if (mode->eBands[j] != pBands[i])
158       {
159          if (pBands[i]-mode->eBands[j] < mode->eBands[j+1]-pBands[i] && 
160              mode->eBands[j] != pBands[i-1])
161             pBands[i] = mode->eBands[j];
162          else
163             pBands[i] = mode->eBands[j+1];
164       }
165    }
166    /*for (i=0;i<mode->nbPBands+2;i++)
167       printf("%d ", pBands[i]);
168    printf ("\n");*/
169    mode->pBands = pBands;
170    mode->pitchEnd = pBands[PBANDS];
171 }
172
173 static void compute_allocation_table(CELTMode *mode, int res)
174 {
175    int i, j, eband;
176    int *allocVectors;
177    
178    mode->nbAllocVectors = BITALLOC_SIZE;
179    allocVectors = celt_alloc(sizeof(int)*(BITALLOC_SIZE*mode->nbEBands));
180    for (i=0;i<BITALLOC_SIZE;i++)
181    {
182       eband = 0;
183       for (j=0;j<BARK_BANDS;j++)
184       {
185          int edge, low;
186          edge = mode->eBands[eband+1]*res;
187          if (edge < bark_freq[j+1])
188          {
189             int num, den;
190             num = band_allocation[i*BARK_BANDS+j] * (edge-bark_freq[j]);
191             den = bark_freq[j+1]-bark_freq[j];
192             low = (num+den/2)/den;
193             allocVectors[i*mode->nbEBands+eband] += low;
194             eband++;
195             allocVectors[i*mode->nbEBands+eband] += band_allocation[i*BARK_BANDS+j]-low;
196          } else {
197             allocVectors[i*mode->nbEBands+eband] += band_allocation[i*BARK_BANDS+j];
198          }
199       }
200    }
201    /*for (i=0;i<BITALLOC_SIZE;i++)
202    {
203       for (j=0;j<mode->nbEBands;j++)
204          printf ("%2d ", allocVectors[i*mode->nbEBands+j]);
205       printf ("\n");
206    }*/
207    mode->allocVectors = allocVectors;
208 }
209
210
211
212 CELTMode *celt_mode_create(int Fs, int channels, int frame_size, int lookahead, int *error)
213 {
214    int res;
215    int N, N2, N4, i;
216    CELTMode *mode;
217    
218    /* The good thing here is that permutation of the arguments will automatically be invalid */
219    
220    if (Fs < 32000 || Fs > 64000)
221    {
222       celt_warning("Sampling rate must be between 32 kHz and 64 kHz");
223       if (error)
224          *error = CELT_BAD_ARG;
225       return NULL;
226    }
227    if (channels < 0 || channels > 2)
228    {
229       celt_warning("Only mono and stereo supported");
230       if (error)
231          *error = CELT_BAD_ARG;
232       return NULL;
233    }
234    if (frame_size < 64 || frame_size > 256 || frame_size%2!=0)
235    {
236       celt_warning("Only even frame sizes between 64 and 256 are supported");
237       if (error)
238          *error = CELT_BAD_ARG;
239       return NULL;
240    }
241    if (lookahead < 32 || lookahead > frame_size)
242    {
243       celt_warning("The overlap must be between 32 and the frame size");
244       if (error)
245          *error = CELT_BAD_ARG;
246       return NULL;
247    }
248    res = (Fs+frame_size)/(2*frame_size);
249    
250    mode = celt_alloc(sizeof(CELTMode));
251    mode->Fs = Fs;
252    mode->overlap = lookahead;
253    mode->mdctSize = frame_size;
254    mode->nbMdctBlocks = 1;
255    mode->nbChannels = channels;
256    mode->eBands = compute_ebands(Fs, frame_size, &mode->nbEBands);
257    compute_pbands(mode, res);
258    mode->ePredCoef = QCONST16(.8f,15);
259    
260    compute_allocation_table(mode, res);
261    compute_alloc_cache(mode);
262    /*printf ("%d bands\n", mode->nbEBands);*/
263    
264    N = mode->mdctSize;
265    N2 = N/2;
266    N4 = N/4;
267    mdct_init(&mode->mdct, 2*N);
268
269    mode->window = (celt_word16_t*)celt_alloc(2*N*sizeof(celt_word16_t));
270
271    for (i=0;i<2*N;i++)
272       mode->window[i] = 0;
273    for (i=0;i<mode->overlap;i++)
274       mode->window[N4+i] = mode->window[2*N-N4-i-1] 
275             = Q15ONE*sin(.5*M_PI* sin(.5*M_PI*(i+.5)/mode->overlap) * sin(.5*M_PI*(i+.5)/mode->overlap));
276    for (i=0;i<2*N4;i++)
277       mode->window[N-N4+i] = Q15ONE;
278
279    mode->marker_start = MODEVALID;
280    mode->marker_end = MODEVALID;
281    return mode;
282 }
283
284 void celt_mode_destroy(CELTMode *mode)
285 {
286    int i;
287    const int *prevPtr = NULL;
288    if (check_mode(mode) != CELT_OK)
289       return;
290    celt_free((int*)mode->eBands);
291    celt_free((int*)mode->pBands);
292    celt_free((int*)mode->allocVectors);
293    
294    for (i=0;i<mode->nbEBands;i++)
295    {
296       if (mode->bits[i] != prevPtr)
297       {
298          prevPtr = mode->bits[i];
299          celt_free((int*)mode->bits[i]);
300       }
301    }
302    celt_free((int**)mode->bits);
303    mdct_clear(&mode->mdct);
304    celt_free(mode->window);
305
306    mode->marker_start = MODEFREED;
307    mode->marker_end = MODEFREED;
308    celt_free((CELTMode *)mode);
309
310 }
311
312 int check_mode(const CELTMode *mode)
313 {
314    if (mode->marker_start == MODEVALID && mode->marker_end == MODEVALID)
315       return CELT_OK;
316    if (mode->marker_start == MODEFREED || mode->marker_end == MODEFREED)
317       celt_warning("Using a mode that has already been freed");
318    else
319       celt_warning("This is not a valid CELT mode");
320    return CELT_INVALID_MODE;
321 }