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