Various minor cleanups (removing dead arguments, macros) to libcelt/. Reinstate ...
[opus.git] / libcelt / modes.c
index 212102e..0c3e374 100644 (file)
@@ -1,23 +1,19 @@
 /* Copyright (c) 2007-2008 CSIRO
    Copyright (c) 2007-2009 Xiph.Org Foundation
-   Copyright (c) 2008 Gregory Maxwell 
+   Copyright (c) 2008 Gregory Maxwell
    Written by Jean-Marc Valin and Gregory Maxwell */
 /*
    Redistribution and use in source and binary forms, with or without
    modification, are permitted provided that the following conditions
    are met:
-   
+
    - Redistributions of source code must retain the above copyright
    notice, this list of conditions and the following disclaimer.
-   
+
    - Redistributions in binary form must reproduce the above copyright
    notice, this list of conditions and the following disclaimer in the
    documentation and/or other materials provided with the distribution.
-   
-   - Neither the name of the Xiph.org Foundation nor the names of its
-   contributors may be used to endorse or promote products derived from
-   this software without specific prior written permission.
-   
+
    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 #include "stack_alloc.h"
 #include "quant_bands.h"
 
-static const celt_int16 eband5ms[] = {
-  0,  1,  2,  3,  4,  5,  6,  7,  8, 10, 12, 14, 16, 20, 24, 28, 34, 40, 48, 60, 78, 100
-};
-
-#if 1
-
-#define BITALLOC_SIZE 9
-/* Bit allocation table in units of 1/32 bit/sample (0.1875 dB SNR) */
-static const unsigned char band_allocation[] = {
+static const opus_int16 eband5ms[] = {
 /*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 */
-  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
- 80, 80, 75, 70, 65, 60, 55, 50, 44, 40, 35, 30, 15,  1,  0,  0,  0,  0,  0,  0,  0,
- 90, 85, 85, 85, 85, 82, 78, 74, 70, 65, 60, 54, 45, 35, 25, 15,  1,  0,  0,  0,  0,
-120,110,110,110,100, 96, 90, 88, 84, 76, 70, 65, 60, 45, 35, 25, 20,  1,  1,  0,  0,
-135,125,125,125,115,112,104,104,100, 96, 83, 78, 70, 55, 46, 36, 32, 28, 20,  8,  0,
-170,165,157,155,149,145,143,138,138,138,129,124,108, 96, 88, 83, 72, 56, 44, 28,  2,
-192,192,160,160,160,160,160,160,160,160,150,140,120,110,100, 90, 80, 70, 60, 50, 20,
-224,224,192,192,192,192,192,192,192,160,160,160,160,160,160,160,160,120, 80, 64, 40,
-255,255,224,224,224,224,224,224,224,192,192,192,192,192,192,192,192,192,192,192,120,
-};
-
-#else
-
-#if 1
-/* Alternate tuning based on exp_tuning_knobs from 2010/10/21:
- 87 5 25 14 300
-120 5 25 16 400
-125 5 25 17 500
-130 5 24 18 600
-130 5 24 19 920
-140 7 24 20 1240
-170 7 20 21 2000
-120 5 20 21 4000
- */
-
-#define BITALLOC_SIZE 9
-/* Bit allocation table in units of 1/32 bit/sample (0.1875 dB SNR) */
-static const unsigned char band_allocation[] = {
-  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
- 99, 99, 90, 84, 78, 71, 65, 58, 51, 45, 39, 32, 26, 20,  1,  0,  0,  0,  0,  0,  0,
-124,124,109, 98, 88, 77, 71, 65, 59, 52, 46, 40, 34, 27, 21, 15,  1,  0,  0,  0,  0,
-132,132,117,107, 97, 87, 80, 74, 68, 62, 55, 49, 43, 37, 30, 23, 17,  1,  1,  0,  0,
-138,138,123,112,102, 91, 85, 79, 73, 67, 61, 55, 49, 43, 37, 31, 25, 19,  1,  0,  0,
-152,152,139,130,120,110,104, 98, 92, 86, 80, 74, 68, 62, 56, 50, 44, 38, 32,  8,  0,
-167,167,154,145,136,127,117,108,102, 96, 90, 84, 78, 72, 66, 60, 54, 48, 42, 36,  2,
-215,215,194,180,165,151,137,121,116,111,106,101, 96, 91, 86, 81, 76, 71, 66, 61, 56,
-240,240,239,233,225,218,211,203,198,193,188,183,178,173,168,163,158,153,148,143,138,
+  0,  1,  2,  3,  4,  5,  6,  7,  8, 10, 12, 14, 16, 20, 24, 28, 34, 40, 48, 60, 78, 100
 };
 
-#else
 /* Alternate tuning (partially derived from Vorbis) */
 #define BITALLOC_SIZE 11
 /* Bit allocation table in units of 1/32 bit/sample (0.1875 dB SNR) */
 static const unsigned char band_allocation[] = {
+/*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 */
   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
85, 85, 75, 70, 63, 55, 50, 45, 40, 35, 33, 28, 15,  1,  0,  0,  0,  0,  0,  0,  0,
-108,105, 96, 88, 83, 77, 72, 66, 59, 53, 49, 44, 41, 37, 30, 27,  1,  0,  0,  0,  0,
-120,117,108,100, 95, 89, 84, 78, 71, 65, 61, 56, 53, 49, 42, 34, 30, 25,  1,  0,  0,
-136,131,123,118,109, 99, 93, 87, 81, 75, 69, 66, 61, 56, 50, 45, 40, 35, 32,  1,  1,
-151,148,138,131,122,113,105,102, 96, 92, 85, 82, 76, 68, 63, 58, 51, 44, 38, 27,  8,
-171,168,158,147,139,130,123,119,111,108,103, 99, 91, 82, 78, 75, 66, 55, 48, 36, 12,
-187,184,174,163,155,146,139,135,127,124,119,115,107, 98, 94, 91, 82, 71, 64, 52, 28,
-203,200,191,181,174,166,159,156,149,147,143,139,132,124,121,119,110,100, 94, 83, 60,
-219,216,207,197,190,183,176,173,166,164,161,157,150,142,139,138,129,119,113,102, 80,
-229,229,224,222,223,224,224,225,222,221,221,220,220,219,218,200,178,154,146,130,102,
90, 80, 75, 69, 63, 56, 49, 40, 34, 29, 20, 18, 10,  0,  0,  0,  0,  0,  0,  0,  0,
+110,100, 90, 84, 78, 71, 65, 58, 51, 45, 39, 32, 26, 20, 12,  0,  0,  0,  0,  0,  0,
+118,110,103, 93, 86, 80, 75, 70, 65, 59, 53, 47, 40, 31, 23, 15,  4,  0,  0,  0,  0,
+126,119,112,104, 95, 89, 83, 78, 72, 66, 60, 54, 47, 39, 32, 25, 17, 12,  1,  0,  0,
+134,127,120,114,103, 97, 91, 85, 78, 72, 66, 60, 54, 47, 41, 35, 29, 23, 16, 10,  1,
+144,137,130,124,113,107,101, 95, 88, 82, 76, 70, 64, 57, 51, 45, 39, 33, 26, 15,  1,
+152,145,138,132,123,117,111,105, 98, 92, 86, 80, 74, 67, 61, 55, 49, 43, 36, 20,  1,
+162,155,148,142,133,127,121,115,108,102, 96, 90, 84, 77, 71, 65, 59, 53, 46, 30,  1,
+172,165,158,152,143,137,131,125,118,112,106,100, 94, 87, 81, 75, 69, 63, 56, 45, 20,
+200,200,200,200,200,200,200,200,198,193,188,183,178,173,168,163,158,153,148,129,104,
 };
-#endif
-#endif
 
-#ifdef STATIC_MODES
-#include "static_modes.c"
-#endif
+#ifndef CUSTOM_MODES_ONLY
+ #ifdef FIXED_POINT
+  #include "static_modes_fixed.h"
+ #else
+  #include "static_modes_float.h"
+ #endif
+#endif /* CUSTOM_MODES_ONLY */
 
 #ifndef M_PI
 #define M_PI 3.141592653
 #endif
 
-
-int celt_mode_info(const CELTMode *mode, int request, celt_int32 *value)
-{
-   switch (request)
-   {
-      case CELT_GET_LOOKAHEAD:
-         *value = mode->overlap;
-         break;
-      case CELT_GET_BITSTREAM_VERSION:
-         *value = CELT_BITSTREAM_VERSION;
-         break;
-      case CELT_GET_SAMPLE_RATE:
-         *value = mode->Fs;
-         break;
-      default:
-         return CELT_UNIMPLEMENTED;
-   }
-   return CELT_OK;
-}
-
-#ifndef STATIC_MODES
+#ifdef CUSTOM_MODES
 
 /* Defining 25 critical bands for the full 0-20 kHz audio bandwidth
    Taken from http://ccrma.stanford.edu/~jos/bbt/Bark_Frequency_Scale.html */
 #define BARK_BANDS 25
-static const celt_int16 bark_freq[BARK_BANDS+1] = {
+static const opus_int16 bark_freq[BARK_BANDS+1] = {
       0,   100,   200,   300,   400,
     510,   630,   770,   920,  1080,
    1270,  1480,  1720,  2000,  2320,
@@ -152,16 +86,16 @@ static const celt_int16 bark_freq[BARK_BANDS+1] = {
    6400,  7700,  9500, 12000, 15500,
   20000};
 
-static celt_int16 *compute_ebands(celt_int32 Fs, int frame_size, int res, int *nbEBands)
+static opus_int16 *compute_ebands(opus_int32 Fs, int frame_size, int res, int *nbEBands)
 {
-   celt_int16 *eBands;
-   int i, lin, low, high, nBark, offset=0;
+   opus_int16 *eBands;
+   int i, j, lin, low, high, nBark, offset=0;
 
    /* All modes that have 2.5 ms short blocks use the same definition */
-   if (Fs == 400*(celt_int32)frame_size)
+   if (Fs == 400*(opus_int32)frame_size)
    {
       *nbEBands = sizeof(eband5ms)/sizeof(eband5ms[0])-1;
-      eBands = celt_alloc(sizeof(celt_int16)*(*nbEBands+1));
+      eBands = opus_alloc(sizeof(opus_int16)*(*nbEBands+1));
       for (i=0;i<*nbEBands+1;i++)
          eBands[i] = eband5ms[i];
       return eBands;
@@ -179,11 +113,11 @@ static celt_int16 *compute_ebands(celt_int32 Fs, int frame_size, int res, int *n
    low = (bark_freq[lin]+res/2)/res;
    high = nBark-lin;
    *nbEBands = low+high;
-   eBands = celt_alloc(sizeof(celt_int16)*(*nbEBands+2));
-   
+   eBands = opus_alloc(sizeof(opus_int16)*(*nbEBands+2));
+
    if (eBands==NULL)
       return NULL;
-   
+
    /* Linear spacing (min_width) */
    for (i=0;i<low;i++)
       eBands[i] = i;
@@ -193,14 +127,16 @@ static celt_int16 *compute_ebands(celt_int32 Fs, int frame_size, int res, int *n
    for (i=0;i<high;i++)
    {
       int target = bark_freq[lin+i];
-      eBands[i+low] = (target+(offset+res)/2)/res;
+      /* Round to an even value */
+      eBands[i+low] = (target+offset/2+res)/(2*res)*2;
       offset = eBands[i+low]*res - target;
    }
    /* Enforce the minimum spacing at the boundary */
    for (i=0;i<*nbEBands;i++)
       if (eBands[i] < i)
          eBands[i] = i;
-   eBands[*nbEBands] = (bark_freq[nBark]+res/2)/res;
+   /* Round to an even value */
+   eBands[*nbEBands] = (bark_freq[nBark]+res)/(2*res)*2;
    if (eBands[*nbEBands] > frame_size)
       eBands[*nbEBands] = frame_size;
    for (i=1;i<*nbEBands-1;i++)
@@ -210,27 +146,36 @@ static celt_int16 *compute_ebands(celt_int32 Fs, int frame_size, int res, int *n
          eBands[i] -= (2*eBands[i]-eBands[i-1]-eBands[i+1])/2;
       }
    }
-   /*for (i=0;i<=*nbEBands+1;i++)
-      printf ("%d ", eBands[i]);
-   printf ("\n");
-   exit(1);*/
-   /* FIXME: Remove last band if too small */
+   /* Remove any empty bands. */
+   for (i=j=0;i<*nbEBands;i++)
+      if(eBands[i+1]>eBands[j])
+         eBands[++j]=eBands[i+1];
+   *nbEBands=j;
+
+   for (i=1;i<*nbEBands;i++)
+   {
+      /* Every band must be smaller than the last band. */
+      celt_assert(eBands[i]-eBands[i-1]<=eBands[*nbEBands]-eBands[*nbEBands-1]);
+      /* Each band must be no larger than twice the size of the previous one. */
+      celt_assert(eBands[i+1]-eBands[i]<=2*(eBands[i]-eBands[i-1]));
+   }
+
    return eBands;
 }
 
-static void compute_allocation_table(CELTMode *mode, int res)
+static void compute_allocation_table(CELTMode *mode)
 {
    int i, j;
    unsigned char *allocVectors;
    int maxBands = sizeof(eband5ms)/sizeof(eband5ms[0])-1;
 
    mode->nbAllocVectors = BITALLOC_SIZE;
-   allocVectors = celt_alloc(sizeof(unsigned char)*(BITALLOC_SIZE*mode->nbEBands));
+   allocVectors = opus_alloc(sizeof(unsigned char)*(BITALLOC_SIZE*mode->nbEBands));
    if (allocVectors==NULL)
       return;
 
    /* Check for standard mode */
-   if (mode->Fs == 400*(celt_int32)mode->shortMdctSize && mode->Fs >= 40000)
+   if (mode->Fs == 400*(opus_int32)mode->shortMdctSize)
    {
       for (i=0;i<BITALLOC_SIZE*mode->nbEBands;i++)
          allocVectors[i] = band_allocation[i];
@@ -238,50 +183,29 @@ static void compute_allocation_table(CELTMode *mode, int res)
       return;
    }
    /* If not the standard mode, interpolate */
-
    /* Compute per-codec-band allocation from per-critical-band matrix */
    for (i=0;i<BITALLOC_SIZE;i++)
    {
-      celt_int32 current = 0;
-      int eband = 0;
-      /* We may be looping over too many bands, but eband will stop being
-         incremented once we reach the last band */
-      for (j=0;j<maxBands;j++)
+      for (j=0;j<mode->nbEBands;j++)
       {
-         int edge, low, high;
-         celt_int32 alloc;
-         alloc = band_allocation[i*maxBands + j]*(mode->eBands[eband+1]-mode->eBands[eband])<<4;
-         low = eband5ms[j]*200;
-         high = eband5ms[j+1]*200;
-         edge = mode->eBands[eband+1]*res;
-         while (edge <= high && eband < mode->nbEBands)
+         int k;
+         for (k=0;k<maxBands;k++)
          {
-            celt_int32 num;
-            int den, bits;
-            int N = (mode->eBands[eband+1]-mode->eBands[eband]);
-            num = alloc * (edge-low);
-            den = high-low;
-            /* Divide with rounding */
-            bits = (2*num+den)/(2*den);
-            allocVectors[i*mode->nbEBands+eband] = (2*(current+bits)+(N<<4))/(2*N<<4);
-            /* Remove the part of the band we just allocated */
-            low = edge;
-            alloc -= bits;
-
-            /* Move to next eband */
-            current = 0;
-            eband++;
-            if (eband < mode->nbEBands)
-               edge = mode->eBands[eband+1]*res;
+            if (400*(opus_int32)eband5ms[k] > mode->eBands[j]*(opus_int32)mode->Fs/mode->shortMdctSize)
+               break;
+         }
+         if (k>maxBands-1)
+            allocVectors[i*mode->nbEBands+j] = band_allocation[i*maxBands + maxBands-1];
+         else {
+            opus_int32 a0, a1;
+            a1 = mode->eBands[j]*(opus_int32)mode->Fs/mode->shortMdctSize - 400*(opus_int32)eband5ms[k-1];
+            a0 = 400*(opus_int32)eband5ms[k] - mode->eBands[j]*(opus_int32)mode->Fs/mode->shortMdctSize;
+            allocVectors[i*mode->nbEBands+j] = (a0*band_allocation[i*maxBands+k-1]
+                                             + a1*band_allocation[i*maxBands+k])/(a0+a1);
          }
-         current += alloc;
-      }
-      if (eband < mode->nbEBands)
-      {
-         int N = (mode->eBands[eband+1]-mode->eBands[eband]);
-         allocVectors[i*mode->nbEBands+eband] = (2*current+(N<<4))/(2*N<<4);
       }
    }
+
    /*printf ("\n");
    for (i=0;i<BITALLOC_SIZE;i++)
    {
@@ -294,60 +218,92 @@ static void compute_allocation_table(CELTMode *mode, int res)
    mode->allocVectors = allocVectors;
 }
 
-#endif /* STATIC_MODES */
+#endif /* CUSTOM_MODES */
 
-CELTMode *celt_mode_create(celt_int32 Fs, int frame_size, int *error)
+CELTMode *opus_custom_mode_create(opus_int32 Fs, int frame_size, int *error)
 {
    int i;
-#ifdef STATIC_MODES
+#ifdef CUSTOM_MODES
+   CELTMode *mode=NULL;
+   int res;
+   opus_val16 *window;
+   opus_int16 *logN;
+   int LM;
+   ALLOC_STACK;
+#if !defined(VAR_ARRAYS) && !defined(USE_ALLOCA)
+   if (global_stack==NULL)
+      goto failure;
+#endif
+#endif
+
+#ifndef CUSTOM_MODES_ONLY
    for (i=0;i<TOTAL_MODES;i++)
    {
-      if (Fs == static_mode_list[i]->Fs &&
-          frame_size == static_mode_list[i]->shortMdctSize*static_mode_list[i]->nbShortMdcts)
+      int j;
+      for (j=0;j<4;j++)
       {
-         return (CELTMode*)static_mode_list[i];
+         if (Fs == static_mode_list[i]->Fs &&
+               (frame_size<<j) == static_mode_list[i]->shortMdctSize*static_mode_list[i]->nbShortMdcts)
+         {
+            if (error)
+               *error = OPUS_OK;
+            return (CELTMode*)static_mode_list[i];
+         }
       }
    }
+#endif /* CUSTOM_MODES_ONLY */
+
+#ifndef CUSTOM_MODES
    if (error)
-      *error = CELT_BAD_ARG;
+      *error = OPUS_BAD_ARG;
    return NULL;
 #else
-   int res;
-   CELTMode *mode=NULL;
-   celt_word16 *window;
-   celt_int16 *logN;
-   int LM;
-#ifdef STDIN_TUNING
-   scanf("%d ", &MIN_BINS);
-   scanf("%d ", &BITALLOC_SIZE);
-   band_allocation = celt_alloc(sizeof(int)*BARK_BANDS*BITALLOC_SIZE);
-   for (i=0;i<BARK_BANDS*BITALLOC_SIZE;i++)
-   {
-      scanf("%d ", band_allocation+i);
-   }
-#endif
-   ALLOC_STACK;
-#if !defined(VAR_ARRAYS) && !defined(USE_ALLOCA)
-   if (global_stack==NULL)
-      goto failure;
-#endif 
 
    /* The good thing here is that permutation of the arguments will automatically be invalid */
-   
+
    if (Fs < 8000 || Fs > 96000)
    {
       if (error)
-         *error = CELT_BAD_ARG;
+         *error = OPUS_BAD_ARG;
       return NULL;
    }
    if (frame_size < 40 || frame_size > 1024 || frame_size%2!=0)
    {
       if (error)
-         *error = CELT_BAD_ARG;
+         *error = OPUS_BAD_ARG;
       return NULL;
    }
-   
-   mode = celt_alloc(sizeof(CELTMode));
+   /* Frames of less than 1ms are not supported. */
+   if ((opus_int32)frame_size*1000 < Fs)
+   {
+      if (error)
+         *error = OPUS_BAD_ARG;
+      return NULL;
+   }
+
+   if ((opus_int32)frame_size*75 >= Fs && (frame_size%16)==0)
+   {
+     LM = 3;
+   } else if ((opus_int32)frame_size*150 >= Fs && (frame_size%8)==0)
+   {
+     LM = 2;
+   } else if ((opus_int32)frame_size*300 >= Fs && (frame_size%4)==0)
+   {
+     LM = 1;
+   } else
+   {
+     LM = 0;
+   }
+
+   /* Shorts longer than 3.3ms are not supported. */
+   if ((opus_int32)(frame_size>>LM)*300 > Fs)
+   {
+      if (error)
+         *error = OPUS_BAD_ARG;
+      return NULL;
+   }
+
+   mode = opus_alloc(sizeof(CELTMode));
    if (mode==NULL)
       goto failure;
    mode->Fs = Fs;
@@ -357,44 +313,30 @@ CELTMode *celt_mode_create(celt_int32 Fs, int frame_size, int *error)
       approximate that. */
    if(Fs < 12000) /* 8 kHz */
    {
-      mode->preemph[0] =  QCONST16(.35f, 15);
-      mode->preemph[1] = -QCONST16(.18f, 15);
-      mode->preemph[2] =  QCONST16(.272f, SIG_SHIFT);
-      mode->preemph[3] =  QCONST16(3.6765f, 13);
+      mode->preemph[0] =  QCONST16(0.3500061035f, 15);
+      mode->preemph[1] = -QCONST16(0.1799926758f, 15);
+      mode->preemph[2] =  QCONST16(0.2719968125f, SIG_SHIFT); /* exact 1/preemph[3] */
+      mode->preemph[3] =  QCONST16(3.6765136719f, 13);
    } else if(Fs < 24000) /* 16 kHz */
    {
-      mode->preemph[0] =  QCONST16(.6f, 15);
-      mode->preemph[1] = -QCONST16(.18f, 15);
-      mode->preemph[2] =  QCONST16(.4425f, SIG_SHIFT);
-      mode->preemph[3] =  QCONST16(2.259887f, 13);
+      mode->preemph[0] =  QCONST16(0.6000061035f, 15);
+      mode->preemph[1] = -QCONST16(0.1799926758f, 15);
+      mode->preemph[2] =  QCONST16(0.4424998650f, SIG_SHIFT); /* exact 1/preemph[3] */
+      mode->preemph[3] =  QCONST16(2.2598876953f, 13);
    } else if(Fs < 40000) /* 32 kHz */
    {
-      mode->preemph[0] =  QCONST16(.78f, 15);
-      mode->preemph[1] = -QCONST16(.1f, 15);
-      mode->preemph[2] =  QCONST16(.75f, SIG_SHIFT);
-      mode->preemph[3] =  QCONST16(1.33333333f, 13);
+      mode->preemph[0] =  QCONST16(0.7799987793f, 15);
+      mode->preemph[1] = -QCONST16(0.1000061035f, 15);
+      mode->preemph[2] =  QCONST16(0.7499771125f, SIG_SHIFT); /* exact 1/preemph[3] */
+      mode->preemph[3] =  QCONST16(1.3333740234f, 13);
    } else /* 48 kHz */
    {
-      mode->preemph[0] =  QCONST16(.85f, 15);
-      mode->preemph[1] =  QCONST16(.0f, 15);
+      mode->preemph[0] =  QCONST16(0.8500061035f, 15);
+      mode->preemph[1] =  QCONST16(0.0f, 15);
       mode->preemph[2] =  QCONST16(1.f, SIG_SHIFT);
       mode->preemph[3] =  QCONST16(1.f, 13);
    }
 
-   if ((celt_int32)frame_size*75 >= Fs && (frame_size%16)==0)
-   {
-     LM = 3;
-   } else if ((celt_int32)frame_size*150 >= Fs && (frame_size%8)==0)
-   {
-     LM = 2;
-   } else if ((celt_int32)frame_size*300 >= Fs && (frame_size%4)==0)
-   {
-     LM = 1;
-   } else
-   {
-     LM = 0;
-   }
-
    mode->maxLM = LM;
    mode->nbShortMdcts = 1<<LM;
    mode->shortMdctSize = frame_size/mode->nbShortMdcts;
@@ -407,19 +349,15 @@ CELTMode *celt_mode_create(celt_int32 Fs, int frame_size, int *error)
    mode->effEBands = mode->nbEBands;
    while (mode->eBands[mode->effEBands] > mode->shortMdctSize)
       mode->effEBands--;
-   
-   /* Overlap must be divisible by 4 */
-   if (mode->nbShortMdcts > 1)
-      mode->overlap = (mode->shortMdctSize>>2)<<2;
-   else
-      mode->overlap = (frame_size>>3)<<2;
 
+   /* Overlap must be divisible by 4 */
+   mode->overlap = ((mode->shortMdctSize>>2)<<2);
 
-   compute_allocation_table(mode, res);
+   compute_allocation_table(mode);
    if (mode->allocVectors==NULL)
       goto failure;
-   
-   window = (celt_word16*)celt_alloc(mode->overlap*sizeof(celt_word16));
+
+   window = (opus_val16*)opus_alloc(mode->overlap*sizeof(opus_val16));
    if (window==NULL)
       goto failure;
 
@@ -432,7 +370,7 @@ CELTMode *celt_mode_create(celt_int32 Fs, int frame_size, int *error)
 #endif
    mode->window = window;
 
-   logN = (celt_int16*)celt_alloc(mode->nbEBands*sizeof(celt_int16));
+   logN = (opus_int16*)opus_alloc(mode->nbEBands*sizeof(opus_int16));
    if (logN==NULL)
       goto failure;
 
@@ -442,48 +380,51 @@ CELTMode *celt_mode_create(celt_int32 Fs, int frame_size, int *error)
 
    compute_pulse_cache(mode, mode->maxLM);
 
-   clt_mdct_init(&mode->mdct, 2*mode->shortMdctSize*mode->nbShortMdcts, mode->maxLM);
-   if ((mode->mdct.trig==NULL)
-#ifndef ENABLE_TI_DSPLIB55
-         || (mode->mdct.kfft==NULL)
-#endif
-   )
+   if (clt_mdct_init(&mode->mdct, 2*mode->shortMdctSize*mode->nbShortMdcts,
+           mode->maxLM) == 0)
       goto failure;
 
-   mode->prob = quant_prob_alloc(mode);
-   if (mode->prob==NULL)
-     goto failure;
-
    if (error)
-      *error = CELT_OK;
+      *error = OPUS_OK;
 
    return mode;
-failure: 
+failure:
    if (error)
-      *error = CELT_INVALID_MODE;
+      *error = OPUS_ALLOC_FAIL;
    if (mode!=NULL)
-      celt_mode_destroy(mode);
+      opus_custom_mode_destroy(mode);
    return NULL;
-#endif /* !STATIC_MODES */
+#endif /* !CUSTOM_MODES */
 }
 
-void celt_mode_destroy(CELTMode *mode)
+void opus_custom_mode_destroy(CELTMode *mode)
 {
-#ifndef STATIC_MODES
    if (mode == NULL)
       return;
+#ifdef CUSTOM_MODES
+#ifndef CUSTOM_MODES_ONLY
+   {
+     int i;
+     for (i=0;i<TOTAL_MODES;i++)
+     {
+        if (mode == static_mode_list[i])
+        {
+           return;
+        }
+     }
+   }
+#endif /* CUSTOM_MODES_ONLY */
+   opus_free((opus_int16*)mode->eBands);
+   opus_free((opus_int16*)mode->allocVectors);
 
-   celt_free((celt_int16*)mode->eBands);
-   celt_free((celt_int16*)mode->allocVectors);
-   
-   celt_free((celt_word16*)mode->window);
-   celt_free((celt_int16*)mode->logN);
+   opus_free((opus_val16*)mode->window);
+   opus_free((opus_int16*)mode->logN);
 
-   celt_free((celt_int16*)mode->cache.index);
-   celt_free((unsigned char*)mode->cache.bits);
+   opus_free((opus_int16*)mode->cache.index);
+   opus_free((unsigned char*)mode->cache.bits);
+   opus_free((unsigned char*)mode->cache.caps);
    clt_mdct_clear(&mode->mdct);
-   quant_prob_free(mode->prob);
 
-   celt_free((CELTMode *)mode);
+   opus_free((CELTMode *)mode);
 #endif
 }