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