/src/opus/celt/modes.c

Source (jump to first uncovered line)
/* 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
   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.

   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
   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
   OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "celt.h"
#include "modes.h"
#include "rate.h"
#include "os_support.h"
#include "stack_alloc.h"
#include "quant_bands.h"
#include "cpu_support.h"

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,  1,  2,  3,  4,  5,  6,  7,  8, 10, 12, 14, 16, 20, 24, 28, 34, 40, 48, 60, 78, 100
};

/* 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,
 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,
};

#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

#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 opus_int16 bark_freq[BARK_BANDS+1] = {
      0,   100,   200,   300,   400,
    510,   630,   770,   920,  1080,
   1270,  1480,  1720,  2000,  2320,
   2700,  3150,  3700,  4400,  5300,
   6400,  7700,  9500, 12000, 15500,
  20000};

static opus_int16 *compute_ebands(opus_int32 Fs, int frame_size, int res, int *nbEBands)
{
   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*(opus_int32)frame_size)
   {
      *nbEBands = sizeof(eband5ms)/sizeof(eband5ms[0])-1;
      eBands = opus_alloc(sizeof(opus_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)
       break;

   /* 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] >= res)
         break;

   low = (bark_freq[lin]+res/2)/res;
   high = nBark-lin;
   *nbEBands = low+high;
   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;
   if (low>0)
      offset = eBands[low-1]*res - bark_freq[lin-1];
   /* Spacing follows critical bands */
   for (i=0;i<high;i++)
   {
      int target = bark_freq[lin+i];
      /* 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;
   /* 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++)
   {
      if (eBands[i+1]-eBands[i] < eBands[i]-eBands[i-1])
      {
         eBands[i] -= (2*eBands[i]-eBands[i-1]-eBands[i+1])/2;
      }
   }
   /* 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 i, j;
   unsigned char *allocVectors;
   int maxBands = sizeof(eband5ms)/sizeof(eband5ms[0])-1;

   mode->nbAllocVectors = BITALLOC_SIZE;
   allocVectors = opus_alloc(sizeof(unsigned char)*(BITALLOC_SIZE*mode->nbEBands));
   if (allocVectors==NULL)
   {
      mode->allocVectors = NULL;
      return;
   }

   /* Check for standard mode */
   if (mode->Fs == 400*(opus_int32)mode->shortMdctSize)
   {
      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++)
   {
      for (j=0;j<mode->nbEBands;j++)
      {
         int k;
         for (k=0;k<maxBands;k++)
         {
            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);
         }
      }
   }

   /*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 /* CUSTOM_MODES */

CELTMode *opus_custom_mode_create(opus_int32 Fs, int frame_size, int *error)
{
   int i;
#ifdef CUSTOM_MODES
   CELTMode *mode=NULL;
   int res;
   opus_val16 *window;
   opus_int16 *logN;
   int LM;
   int arch = opus_select_arch();
   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++)
   {
      int j;
      for (j=0;j<4;j++)
      {
         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 = OPUS_BAD_ARG;
   return NULL;
#else

   /* The good thing here is that permutation of the arguments will automatically be invalid */

   if (Fs < 8000 || Fs > 96000)
   {
      if (error)
         *error = OPUS_BAD_ARG;
      return NULL;
   }
   if (frame_size < 40 || frame_size > 1024 || frame_size%2!=0)
   {
      if (error)
         *error = OPUS_BAD_ARG;
      return NULL;
   }
   /* 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;

   /* 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->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(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(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(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);
   }

   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;
#if !defined(SMALL_FOOTPRINT)
   /* Make sure we don't allocate a band larger than our PVQ table.
      208 should be enough, but let's be paranoid. */
   if ((mode->eBands[mode->nbEBands] - mode->eBands[mode->nbEBands-1])<<LM >
    208) {
       goto failure;
   }
#endif

   mode->effEBands = mode->nbEBands;
   while (mode->eBands[mode->effEBands] > mode->shortMdctSize)
      mode->effEBands--;

   /* Overlap must be divisible by 4 */
   mode->overlap = ((mode->shortMdctSize>>2)<<2);

   compute_allocation_table(mode);
   if (mode->allocVectors==NULL)
      goto failure;

   window = (opus_val16*)opus_alloc(mode->overlap*sizeof(opus_val16));
   if (window==NULL)
      goto failure;

#ifndef FIXED_POINT
   for (i=0;i<mode->overlap;i++)
      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,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;

   logN = (opus_int16*)opus_alloc(mode->nbEBands*sizeof(opus_int16));
   if (logN==NULL)
      goto failure;

   for (i=0;i<mode->nbEBands;i++)
      logN[i] = log2_frac(mode->eBands[i+1]-mode->eBands[i], BITRES);
   mode->logN = logN;

   compute_pulse_cache(mode, mode->maxLM);

   if (clt_mdct_init(&mode->mdct, 2*mode->shortMdctSize*mode->nbShortMdcts,
           mode->maxLM, arch) == 0)
      goto failure;

   if (error)
      *error = OPUS_OK;

   return mode;
failure:
   if (error)
      *error = OPUS_ALLOC_FAIL;
   if (mode!=NULL)
      opus_custom_mode_destroy(mode);
   return NULL;
#endif /* !CUSTOM_MODES */
}

#ifdef CUSTOM_MODES
void opus_custom_mode_destroy(CELTMode *mode)
{
   int arch = opus_select_arch();

   if (mode == NULL)
      return;
#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((unsigned char*)mode->allocVectors);

   opus_free((opus_val16*)mode->window);
   opus_free((opus_int16*)mode->logN);

   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, arch);

   opus_free((CELTMode *)mode);
}
#endif

Coverage Report

Created: 2024-09-06 07:53

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