static modes simplifications for std mode
[opus.git] / libcelt / modes.c
index be2e081..30d7a3e 100644 (file)
@@ -1,5 +1,7 @@
-/* (C) 2007-2009 Jean-Marc Valin, CSIRO
-   (C) 2008 Gregory Maxwell */
+/* Copyright (c) 2007-2008 CSIRO
+   Copyright (c) 2007-2009 Xiph.Org Foundation
+   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
 #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
+};
+
+#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  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,
+175,170,167,155,149,145,143,138,138,138,129,124,108, 96, 88, 83, 72, 56, 44, 28,  2,
+224,192,192,192,192,192,192,192,192,192,192,192,156,128,108, 96, 88, 76, 68, 44, 20,
+255,224,224,224,224,224,224,224,224,224,224,224,224,188,164,148,124, 96, 80, 64, 40,
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,252,220,188,144,104, 84, 60,
+};
+
 #ifdef STATIC_MODES
 #include "static_modes.c"
 #endif
 
-#define MODEVALID   0xa110ca7e
-#define MODEPARTIAL 0x7eca10a1
-#define MODEFREED   0xb10cf8ee
-
 #ifndef M_PI
 #define M_PI 3.141592653
 #endif
 
 
-int celt_mode_info(const CELTMode *mode, int request, celt_int32_t *value)
+int celt_mode_info(const CELTMode *mode, int request, celt_int32 *value)
 {
-   if (check_mode(mode) != CELT_OK)
-      return CELT_INVALID_MODE;
    switch (request)
    {
-      case CELT_GET_FRAME_SIZE:
-         *value = mode->mdctSize;
-         break;
       case CELT_GET_LOOKAHEAD:
          *value = mode->overlap;
          break;
-      case CELT_GET_NB_CHANNELS:
-         *value = mode->nbChannels;
-         break;
       case CELT_GET_BITSTREAM_VERSION:
          *value = CELT_BITSTREAM_VERSION;
          break;
@@ -82,18 +91,10 @@ int celt_mode_info(const CELTMode *mode, int request, celt_int32_t *value)
 
 #ifndef STATIC_MODES
 
-#define PBANDS 8
-
-#ifdef STDIN_TUNING
-int MIN_BINS;
-#else
-#define MIN_BINS 3
-#endif
-
 /* 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_t bark_freq[BARK_BANDS+1] = {
+static const celt_int16 bark_freq[BARK_BANDS+1] = {
       0,   100,   200,   300,   400,
     510,   630,   770,   920,  1080,
    1270,  1480,  1720,  2000,  2320,
@@ -101,40 +102,20 @@ static const celt_int16_t bark_freq[BARK_BANDS+1] = {
    6400,  7700,  9500, 12000, 15500,
   20000};
 
-static const celt_int16_t pitch_freq[PBANDS+1] ={0, 345, 689, 1034, 1378, 2067, 3273, 5340, 6374};
-
-/* This allocation table is per critical band. When creating a mode, the bits get added together 
-   into the codec bands, which are sometimes larger than one critical band at low frequency */
-
-#ifdef STDIN_TUNING
-int BITALLOC_SIZE;
-int *band_allocation;
-#else
-#define BITALLOC_SIZE 12
-static const int band_allocation[BARK_BANDS*BITALLOC_SIZE] = 
-   {  4,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-      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,
-      2,  2,  2,  1,  2,  2,  2,  2,  2,  1,  2,  2,  4,  5,  7,  7,  7,  5,  4,  0,  0,  0,  0,  0,  0,
-      2,  2,  2,  2,  3,  2,  2,  2,  2,  2,  3,  3,  5,  6,  8,  8,  8,  6,  5,  4,  0,  0,  0,  0,  0,
-      3,  2,  2,  2,  3,  3,  2,  3,  2,  3,  4,  4,  6,  7,  9,  9,  9,  7,  6,  5,  5,  5,  0,  0,  0,
-      3,  3,  2,  2,  3,  3,  3,  3,  3,  4,  4,  5,  7,  9, 10, 10, 10,  9,  6,  5,  5,  5,  5,  1,  0,
-      4,  3,  3,  3,  3,  3,  3,  3,  4,  4,  6,  7,  7,  9, 11, 10, 10,  9,  9,  8, 11, 10, 10,  1,  1,
-      5,  5,  5,  5,  5,  5,  5,  6,  6,  6,  8,  8, 10, 12, 12, 11, 11, 17, 12, 15, 15, 20, 18, 10,  1,
-      8,  7,  7,  7,  7,  7,  8,  8,  9, 10, 11, 12, 14, 17, 18, 21, 22, 27, 29, 39, 37, 38, 40, 35,  1,
-      7,  7,  7,  7,  7,  7, 10, 10, 10, 13, 14, 18, 20, 24, 28, 32, 32, 35, 38, 38, 42, 50, 59, 54, 31,
-      8,  8,  8,  8,  8,  9, 10, 12, 14, 20, 22, 25, 28, 30, 35, 42, 46, 50, 55, 60, 62, 62, 72, 82, 62,
-      9,  9,  9, 10, 12, 13, 15, 18, 22, 30, 32, 35, 40, 45, 55, 62, 66, 70, 85, 90, 92, 92, 92,102, 92,
-   };
-#endif
-
-static celt_int16_t *compute_ebands(celt_int32_t Fs, int frame_size, int *nbEBands)
+static celt_int16 *compute_ebands(celt_int32 Fs, int frame_size, int res, int *nbEBands)
 {
-   celt_int16_t *eBands;
-   int i, res, min_width, lin, low, high, nBark;
-   res = (Fs+frame_size)/(2*frame_size);
-   min_width = MIN_BINS*res;
-   /*printf ("min_width = %d\n", min_width);*/
+   celt_int16 *eBands;
+   int i, 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)
+   {
+      *nbEBands = sizeof(eband5ms)/sizeof(eband5ms[0])-1;
+      eBands = celt_alloc(sizeof(celt_int16)*(*nbEBands+1));
+      for (i=0;i<*nbEBands+1;i++)
+         eBands[i] = eband5ms[i];
+      return eBands;
+   }
    /* Find the number of critical bands supported by our sampling rate */
    for (nBark=1;nBark<BARK_BANDS;nBark++)
     if (bark_freq[nBark+1]*2 >= Fs)
@@ -142,260 +123,253 @@ static celt_int16_t *compute_ebands(celt_int32_t Fs, int frame_size, int *nbEBan
 
    /* Find where the linear part ends (i.e. where the spacing is more than min_width */
    for (lin=0;lin<nBark;lin++)
-      if (bark_freq[lin+1]-bark_freq[lin] >= min_width)
+      if (bark_freq[lin+1]-bark_freq[lin] >= res)
          break;
-   
-   /*printf ("lin = %d (%d Hz)\n", lin, bark_freq[lin]);*/
-   low = ((bark_freq[lin]/res)+(MIN_BINS-1))/MIN_BINS;
+
+   low = (bark_freq[lin]+res/2)/res;
    high = nBark-lin;
    *nbEBands = low+high;
-   eBands = celt_alloc(sizeof(celt_int16_t)*(*nbEBands+2));
+   eBands = celt_alloc(sizeof(celt_int16)*(*nbEBands+2));
    
    if (eBands==NULL)
       return NULL;
    
    /* Linear spacing (min_width) */
    for (i=0;i<low;i++)
-      eBands[i] = MIN_BINS*i;
+      eBands[i] = i;
+   if (low>0)
+      offset = eBands[low-1]*res - bark_freq[lin-1];
    /* Spacing follows critical bands */
    for (i=0;i<high;i++)
-      eBands[i+low] = (bark_freq[lin+i]+res/2)/res;
+   {
+      int target = bark_freq[lin+i];
+      eBands[i+low] = (target+(offset+res)/2)/res;
+      offset = eBands[i+low]*res - target;
+   }
    /* Enforce the minimum spacing at the boundary */
    for (i=0;i<*nbEBands;i++)
-      if (eBands[i] < MIN_BINS*i)
-         eBands[i] = MIN_BINS*i;
+      if (eBands[i] < i)
+         eBands[i] = i;
    eBands[*nbEBands] = (bark_freq[nBark]+res/2)/res;
-   eBands[*nbEBands+1] = frame_size;
-   if (eBands[*nbEBands] > eBands[*nbEBands+1])
-      eBands[*nbEBands] = eBands[*nbEBands+1];
-   
-   /* FIXME: Remove last band if too small */
-   /*for (i=0;i<*nbEBands+2;i++)
-      printf("%d ", eBands[i]);
-   printf ("\n");
-   exit(1);*/
-   return eBands;
-}
-
-static void compute_pbands(CELTMode *mode, int res)
-{
-   int i;
-   celt_int16_t *pBands;
-   pBands=celt_alloc(sizeof(celt_int16_t)*(PBANDS+2));
-   mode->pBands = pBands;
-   if (pBands==NULL)
-     return;
-   mode->nbPBands = PBANDS;
-   for (i=0;i<PBANDS+1;i++)
+   if (eBands[*nbEBands] > frame_size)
+      eBands[*nbEBands] = frame_size;
+   for (i=1;i<*nbEBands-1;i++)
    {
-      pBands[i] = (pitch_freq[i]+res/2)/res;
-      if (pBands[i] < mode->eBands[i])
-         pBands[i] = mode->eBands[i];
-   }
-   pBands[PBANDS+1] = mode->eBands[mode->nbEBands+1];
-   for (i=1;i<mode->nbPBands+1;i++)
-   {
-      int j;
-      for (j=0;j<mode->nbEBands;j++)
-         if (mode->eBands[j] <= pBands[i] && mode->eBands[j+1] > pBands[i])
-            break;
-      /*printf ("%d %d\n", i, j);*/
-      if (mode->eBands[j] != pBands[i])
+      if (eBands[i+1]-eBands[i] < eBands[i]-eBands[i-1])
       {
-         if (pBands[i]-mode->eBands[j] < mode->eBands[j+1]-pBands[i] && 
-             mode->eBands[j] != pBands[i-1])
-            pBands[i] = mode->eBands[j];
-         else
-            pBands[i] = mode->eBands[j+1];
+         eBands[i] -= (2*eBands[i]-eBands[i-1]-eBands[i+1])/2;
       }
    }
-   /*for (i=0;i<mode->nbPBands+2;i++)
-      printf("%d ", pBands[i]);
-   printf ("\n");*/
-   mode->pitchEnd = pBands[PBANDS];
+   /*for (i=0;i<=*nbEBands+1;i++)
+      printf ("%d ", eBands[i]);
+   printf ("\n");
+   exit(1);*/
+   /* FIXME: Remove last band if too small */
+   return eBands;
 }
 
 static void compute_allocation_table(CELTMode *mode, int res)
 {
-   int i, j, nBark;
-   celt_int16_t *allocVectors;
-   const int C = CHANNELS(mode);
-
-   /* Find the number of critical bands supported by our sampling rate */
-   for (nBark=1;nBark<BARK_BANDS;nBark++)
-    if (bark_freq[nBark+1]*2 >= mode->Fs)
-       break;
+   int i, j;
+   unsigned char *allocVectors;
+   int maxBands = sizeof(eband5ms)/sizeof(eband5ms[0])-1;
 
    mode->nbAllocVectors = BITALLOC_SIZE;
-   allocVectors = celt_alloc(sizeof(celt_int16_t)*(BITALLOC_SIZE*mode->nbEBands));
+   allocVectors = celt_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)
+   {
+      for (i=0;i<BITALLOC_SIZE*mode->nbEBands;i++)
+         allocVectors[i] = band_allocation[i];
+      mode->allocVectors = allocVectors;
+      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_t current = 0;
+      celt_int32 current = 0;
       int eband = 0;
-      for (j=0;j<nBark;j++)
+      /* 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++)
       {
-         int edge, low;
-         celt_int32_t alloc;
+         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;
-         alloc = band_allocation[i*BARK_BANDS+j];
-         alloc = alloc*C*mode->mdctSize;
-         if (edge < bark_freq[j+1])
+         while (edge <= high && eband < mode->nbEBands)
          {
-            int num, den;
-            num = alloc * (edge-bark_freq[j]);
-            den = bark_freq[j+1]-bark_freq[j];
-            low = (num+den/2)/den;
-            allocVectors[i*mode->nbEBands+eband] = (current+low+128)/256;
-            current=0;
+            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++;
-            current += alloc-low;
-         } else {
-            current += alloc;
-         }   
+            if (eband < mode->nbEBands)
+               edge = mode->eBands[eband+1]*res;
+         }
+         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);
       }
-      allocVectors[i*mode->nbEBands+eband] = (current+128)/256;
    }
+   /*printf ("\n");
+   for (i=0;i<BITALLOC_SIZE;i++)
+   {
+      for (j=0;j<mode->nbEBands;j++)
+         printf ("%d ", allocVectors[i*mode->nbEBands+j]);
+      printf ("\n");
+   }
+   exit(0);*/
+
    mode->allocVectors = allocVectors;
 }
 
 #endif /* STATIC_MODES */
 
-CELTMode *celt_mode_create(celt_int32_t Fs, int channels, int frame_size, int *error)
+CELTMode *celt_mode_create(celt_int32 Fs, int frame_size, int *error)
 {
    int i;
-#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
 #ifdef STATIC_MODES
-   const CELTMode *m = NULL;
-   CELTMode *mode=NULL;
-   ALLOC_STACK;
-#if !defined(VAR_ARRAYS) && !defined(USE_ALLOCA)
-   if (global_stack==NULL)
-   {
-      celt_free(global_stack);
-      goto failure;
-   }
-#endif 
    for (i=0;i<TOTAL_MODES;i++)
    {
       if (Fs == static_mode_list[i]->Fs &&
-          channels == static_mode_list[i]->nbChannels &&
-          frame_size == static_mode_list[i]->mdctSize)
+          frame_size == static_mode_list[i]->shortMdctSize*static_mode_list[i]->nbShortMdcts)
       {
-         m = static_mode_list[i];
-         break;
+         return (CELTMode*)static_mode_list[i];
       }
    }
-   if (m == NULL)
-   {
-      celt_warning("Mode not included as part of the static modes");
-      if (error)
-         *error = CELT_BAD_ARG;
-      return NULL;
-   }
-   mode = (CELTMode*)celt_alloc(sizeof(CELTMode));
-   if (mode==NULL)
-      goto failure;
-   CELT_COPY(mode, m, 1);
-   mode->marker_start = MODEPARTIAL;
+   if (error)
+      *error = CELT_BAD_ARG;
+   return NULL;
 #else
    int res;
    CELTMode *mode=NULL;
-   celt_word16_t *window;
+   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)
-   {
-      celt_free(global_stack);
       goto failure;
-   }
 #endif 
 
    /* The good thing here is that permutation of the arguments will automatically be invalid */
    
-   if (Fs < 32000 || Fs > 96000)
+   if (Fs < 8000 || Fs > 96000)
    {
-      celt_warning("Sampling rate must be between 32 kHz and 96 kHz");
       if (error)
          *error = CELT_BAD_ARG;
       return NULL;
    }
-   if (channels < 0 || channels > 2)
+   if (frame_size < 40 || frame_size > 1024 || frame_size%2!=0)
    {
-      celt_warning("Only mono and stereo supported");
       if (error)
          *error = CELT_BAD_ARG;
       return NULL;
    }
-   if (frame_size < 64 || frame_size > 512 || frame_size%2!=0)
-   {
-      celt_warning("Only even frame sizes from 64 to 512 are supported");
-      if (error)
-         *error = CELT_BAD_ARG;
-      return NULL;
-   }
-   res = (Fs+frame_size)/(2*frame_size);
    
    mode = celt_alloc(sizeof(CELTMode));
    if (mode==NULL)
       goto failure;
-   mode->marker_start = MODEPARTIAL;
    mode->Fs = Fs;
-   mode->mdctSize = frame_size;
-   mode->nbChannels = channels;
-   mode->eBands = compute_ebands(Fs, frame_size, &mode->nbEBands);
-   if (mode->eBands==NULL)
-      goto failure;
-   compute_pbands(mode, res);
-   if (mode->pBands==NULL)
-      goto failure;
-   mode->ePredCoef = QCONST16(.8f,15);
 
-   if (frame_size > 384 && (frame_size%8)==0)
+   /* Pre/de-emphasis depends on sampling rate. The "standard" pre-emphasis
+      is defined as A(z) = 1 - 0.85*z^-1 at 48 kHz. Other rates should
+      approximate that. */
+   if(Fs < 12000) /* 8 kHz */
    {
-     mode->nbShortMdcts = 4;
-   } else if (frame_size > 384 && (frame_size%10)==0)
+      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);
+   } else if(Fs < 24000) /* 16 kHz */
    {
-     mode->nbShortMdcts = 5;
-   } else if (frame_size > 256 && (frame_size%6)==0)
+      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);
+   } else if(Fs < 40000) /* 32 kHz */
    {
-     mode->nbShortMdcts = 3;
-   } else if (frame_size > 256 && (frame_size%8)==0)
+      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);
+   } else /* 48 kHz */
+   {
+      mode->preemph[0] =  QCONST16(.85f, 15);
+      mode->preemph[1] =  QCONST16(.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)
    {
-     mode->nbShortMdcts = 4;
-   } else if (frame_size > 64 && (frame_size%4)==0)
+     LM = 3;
+   } else if ((celt_int32)frame_size*150 >= Fs && (frame_size%8)==0)
    {
-     mode->nbShortMdcts = 2;
-   } else if (frame_size > 128 && (frame_size%6)==0)
+     LM = 2;
+   } else if ((celt_int32)frame_size*300 >= Fs && (frame_size%4)==0)
    {
-     mode->nbShortMdcts = 3;
+     LM = 1;
    } else
    {
-     mode->nbShortMdcts = 1;
+     LM = 0;
    }
 
+   mode->maxLM = LM;
+   mode->nbShortMdcts = 1<<LM;
+   mode->shortMdctSize = frame_size/mode->nbShortMdcts;
+   res = (mode->Fs+mode->shortMdctSize)/(2*mode->shortMdctSize);
+
+   mode->eBands = compute_ebands(Fs, mode->shortMdctSize, res, &mode->nbEBands);
+   if (mode->eBands==NULL)
+      goto failure;
+
+   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 = ((frame_size/mode->nbShortMdcts)>>2)<<2; 
+      mode->overlap = (mode->shortMdctSize>>2)<<2;
    else
       mode->overlap = (frame_size>>3)<<2;
 
+
    compute_allocation_table(mode, res);
    if (mode->allocVectors==NULL)
       goto failure;
-   /*printf ("%d bands\n", mode->nbEBands);*/
    
-   window = (celt_word16_t*)celt_alloc(mode->overlap*sizeof(celt_word16_t));
+   window = (celt_word16*)celt_alloc(mode->overlap*sizeof(celt_word16));
    if (window==NULL)
       goto failure;
 
@@ -404,47 +378,35 @@ CELTMode *celt_mode_create(celt_int32_t Fs, int channels, int frame_size, int *e
       window[i] = Q15ONE*sin(.5*M_PI* sin(.5*M_PI*(i+.5)/mode->overlap) * sin(.5*M_PI*(i+.5)/mode->overlap));
 #else
    for (i=0;i<mode->overlap;i++)
-      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)));
+      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))));
 #endif
    mode->window = window;
 
-   mode->bits = (const celt_int16_t **)compute_alloc_cache(mode, 1);
-   if (mode->bits==NULL)
+   logN = (celt_int16*)celt_alloc(mode->nbEBands*sizeof(celt_int16));
+   if (logN==NULL)
       goto failure;
 
-#ifndef SHORTCUTS
-   psydecay_init(&mode->psy, MAX_PERIOD/2, mode->Fs);
-   if (mode->psy.decayR==NULL)
-      goto failure;
-#endif
-   
-#endif /* !STATIC_MODES */
+   for (i=0;i<mode->nbEBands;i++)
+      logN[i] = log2_frac(mode->eBands[i+1]-mode->eBands[i], BITRES);
+   mode->logN = logN;
 
-#ifdef DISABLE_STEREO
-   if (channels > 1)
-   {
-      celt_warning("Stereo support was disable from this build");
-      if (error)
-         *error = CELT_BAD_ARG;
-      return NULL;
-   }
-#endif
+   compute_pulse_cache(mode, mode->maxLM);
 
-   mdct_init(&mode->mdct, 2*mode->mdctSize);
-   mode->fft = pitch_state_alloc(MAX_PERIOD);
+   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
+   )
+      goto failure;
 
-   mode->shortMdctSize = mode->mdctSize/mode->nbShortMdcts;
-   mdct_init(&mode->shortMdct, 2*mode->shortMdctSize);
-   mode->shortWindow = mode->window;
    mode->prob = quant_prob_alloc(mode);
-   if ((mode->mdct.trig==NULL) || (mode->mdct.kfft==NULL) || (mode->fft==NULL) ||
-       (mode->shortMdct.trig==NULL) || (mode->shortMdct.kfft==NULL) || (mode->prob==NULL))
+   if (mode->prob==NULL)
      goto failure;
 
-   mode->marker_start = MODEVALID;
-   mode->marker_end   = MODEVALID;
    if (error)
       *error = CELT_OK;
+
    return mode;
 failure: 
    if (error)
@@ -452,70 +414,26 @@ failure:
    if (mode!=NULL)
       celt_mode_destroy(mode);
    return NULL;
+#endif /* !STATIC_MODES */
 }
 
 void celt_mode_destroy(CELTMode *mode)
 {
-   int i;
-   const celt_int16_t *prevPtr = NULL;
+#ifndef STATIC_MODES
    if (mode == NULL)
-   {
-      celt_warning("NULL passed to celt_mode_destroy");
-      return;
-   }
-
-   if (mode->marker_start == MODEFREED || mode->marker_end == MODEFREED)
-   {
-      celt_warning("Freeing a mode which has already been freed"); 
       return;
-   }
 
-   if (mode->marker_start != MODEVALID && mode->marker_start != MODEPARTIAL)
-   {
-      celt_warning("This is not a valid CELT mode structure");
-      return;  
-   }
-   mode->marker_start = MODEFREED;
-#ifndef STATIC_MODES
-   if (mode->bits!=NULL)
-   {
-      for (i=0;i<mode->nbEBands;i++)
-      {
-         if (mode->bits[i] != prevPtr)
-         {
-            prevPtr = mode->bits[i];
-            celt_free((int*)mode->bits[i]);
-          }
-      }
-   }   
-   celt_free((int**)mode->bits);
-   celt_free((int*)mode->eBands);
-   celt_free((int*)mode->pBands);
-   celt_free((int*)mode->allocVectors);
+   celt_free((celt_int16*)mode->eBands);
+   celt_free((celt_int16*)mode->allocVectors);
    
-   celt_free((celt_word16_t*)mode->window);
+   celt_free((celt_word16*)mode->window);
+   celt_free((celt_int16*)mode->logN);
 
-#ifndef SHORTCUTS
-   psydecay_clear(&mode->psy);
-#endif
-#endif
-   mdct_clear(&mode->mdct);
-   mdct_clear(&mode->shortMdct);
-   pitch_state_free(mode->fft);
+   celt_free((celt_int16*)mode->cache.index);
+   celt_free((unsigned char*)mode->cache.bits);
+   clt_mdct_clear(&mode->mdct);
    quant_prob_free(mode->prob);
-   mode->marker_end = MODEFREED;
-   celt_free((CELTMode *)mode);
-}
 
-int check_mode(const CELTMode *mode)
-{
-   if (mode==NULL)
-      return CELT_INVALID_MODE;
-   if (mode->marker_start == MODEVALID && mode->marker_end == MODEVALID)
-      return CELT_OK;
-   if (mode->marker_start == MODEFREED || mode->marker_end == MODEFREED)
-      celt_warning("Using a mode that has already been freed");
-   else
-      celt_warning("This is not a valid CELT mode");
-   return CELT_INVALID_MODE;
+   celt_free((CELTMode *)mode);
+#endif
 }