sb_celp.c 44.5 KB
Newer Older
Tristan Matthews's avatar
Tristan Matthews committed
1
/* Copyright (C) 2002-2006 Jean-Marc Valin
jmvalin's avatar
...  
jmvalin committed
2
   File: sb_celp.c
3

jm's avatar
jm committed
4 5 6
   Redistribution and use in source and binary forms, with or without
   modification, are permitted provided that the following conditions
   are met:
Tristan Matthews's avatar
Tristan Matthews committed
7

jm's avatar
jm committed
8 9
   - Redistributions of source code must retain the above copyright
   notice, this list of conditions and the following disclaimer.
Tristan Matthews's avatar
Tristan Matthews committed
10

jm's avatar
jm committed
11 12 13
   - 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.
Tristan Matthews's avatar
Tristan Matthews committed
14

jm's avatar
jm committed
15 16 17
   - 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.
Tristan Matthews's avatar
Tristan Matthews committed
18

jm's avatar
jm committed
19 20 21 22 23 24 25 26 27 28 29
   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 FOUNDATION 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.
30 31
*/

32 33 34
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
35

jmvalin's avatar
jmvalin committed
36
#include <math.h>
37 38
#include "sb_celp.h"
#include "filters.h"
jmvalin's avatar
jmvalin committed
39 40
#include "lpc.h"
#include "lsp.h"
41
#include "stack_alloc.h"
jmvalin's avatar
jmvalin committed
42
#include "cb_search.h"
jmvalin's avatar
jmvalin committed
43
#include "quant_lsp.h"
44
#include "vq.h"
45
#include "ltp.h"
jm's avatar
jm committed
46
#include "arch.h"
47
#include "math_approx.h"
48
#include "os_support.h"
jmvalin's avatar
jmvalin committed
49

jm's avatar
jm committed
50 51 52 53
#ifndef NULL
#define NULL 0
#endif

54 55 56
/* Default size for the encoder and decoder stack (can be changed at compile time).
   This does not apply when using variable-size arrays or alloca. */
#ifndef SB_ENC_STACK
57
#define SB_ENC_STACK (10000*sizeof(spx_sig_t))
58 59 60 61 62 63 64
#endif

#ifndef SB_DEC_STACK
#define SB_DEC_STACK (6000*sizeof(spx_sig_t))
#endif


65
#ifndef DISABLE_WIDEBAND
66 67


jmvalin's avatar
jmvalin committed
68
#define sqr(x) ((x)*(x))
69

70 71
#define SUBMODE(x) st->submodes[st->submodeID]->x

72
#ifdef FIXED_POINT
jm's avatar
jm committed
73
static const spx_word16_t gc_quant_bound[16] = {125, 164, 215, 282, 370, 484, 635, 832, 1090, 1428, 1871, 2452, 3213, 4210, 5516, 7228};
74 75 76 77 78
static const spx_word16_t fold_quant_bound[32] = {
   39, 44, 50, 57, 64, 73, 83, 94,
   106, 120, 136, 154, 175, 198, 225, 255,
   288, 327, 370, 420, 476, 539, 611, 692,
   784, 889, 1007, 1141, 1293, 1465, 1660, 1881};
79
#define LSP_MARGIN 410
80 81
#define LSP_DELTA1 6553
#define LSP_DELTA2 1638
82 83

#else
84

85
static const spx_word16_t gc_quant_bound[16] = {
Tristan Matthews's avatar
Tristan Matthews committed
86
      0.97979, 1.28384, 1.68223, 2.20426, 2.88829, 3.78458, 4.95900, 6.49787,
87 88 89 90 91 92
      8.51428, 11.15642, 14.61846, 19.15484, 25.09895, 32.88761, 43.09325, 56.46588};
static const spx_word16_t fold_quant_bound[32] = {
   0.30498, 0.34559, 0.39161, 0.44375, 0.50283, 0.56979, 0.64565, 0.73162,
   0.82903, 0.93942, 1.06450, 1.20624, 1.36685, 1.54884, 1.75506, 1.98875,
   2.25355, 2.55360, 2.89361, 3.27889, 3.71547, 4.21018, 4.77076, 5.40598,
   6.12577, 6.94141, 7.86565, 8.91295, 10.09969, 11.44445, 12.96826, 14.69497};
93

94
#define LSP_MARGIN .05
95 96
#define LSP_DELTA1 .2
#define LSP_DELTA2 .05
97

98 99
#endif

100
#define QMF_ORDER 64
101 102

#ifdef FIXED_POINT
jm's avatar
jm committed
103
static const spx_word16_t h0[64] = {2, -7, -7, 18, 15, -39, -25, 75, 35, -130, -41, 212, 38, -327, -17, 483, -32, -689, 124, 956, -283, -1307, 543, 1780, -973, -2467, 1733, 3633, -3339, -6409, 9059, 30153, 30153, 9059, -6409, -3339, 3633, 1733, -2467, -973, 1780, 543, -1307, -283, 956, 124, -689, -32, 483, -17, -327, 38, 212, -41, -130, 35, 75, -25, -39, 15, 18, -7, -7, 2};
104 105

#else
jm's avatar
jm committed
106
static const float h0[64] = {
107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138
   3.596189e-05f, -0.0001123515f,
   -0.0001104587f, 0.0002790277f,
   0.0002298438f, -0.0005953563f,
   -0.0003823631f, 0.00113826f,
   0.0005308539f, -0.001986177f,
   -0.0006243724f, 0.003235877f,
   0.0005743159f, -0.004989147f,
   -0.0002584767f, 0.007367171f,
   -0.0004857935f, -0.01050689f,
   0.001894714f, 0.01459396f,
   -0.004313674f, -0.01994365f,
   0.00828756f, 0.02716055f,
   -0.01485397f, -0.03764973f,
   0.026447f, 0.05543245f,
   -0.05095487f, -0.09779096f,
   0.1382363f, 0.4600981f,
   0.4600981f, 0.1382363f,
   -0.09779096f, -0.05095487f,
   0.05543245f, 0.026447f,
   -0.03764973f, -0.01485397f,
   0.02716055f, 0.00828756f,
   -0.01994365f, -0.004313674f,
   0.01459396f, 0.001894714f,
   -0.01050689f, -0.0004857935f,
   0.007367171f, -0.0002584767f,
   -0.004989147f, 0.0005743159f,
   0.003235877f, -0.0006243724f,
   -0.001986177f, 0.0005308539f,
   0.00113826f, -0.0003823631f,
   -0.0005953563f, 0.0002298438f,
   0.0002790277f, -0.0001104587f,
   -0.0001123515f, 3.596189e-05f
139 140
};

141
#endif
142

143
extern const spx_word16_t lag_window[];
144 145
extern const spx_word16_t lpc_window[];

146
#ifndef DISABLE_ENCODER
jm's avatar
jm committed
147
void *sb_encoder_init(const SpeexMode *m)
148
{
jmvalin's avatar
jmvalin committed
149
   int i;
150
   spx_int32_t tmp;
151
   SBEncState *st;
jm's avatar
jm committed
152
   const SpeexSBMode *mode;
153

jm's avatar
jm committed
154
   st = (SBEncState*)speex_alloc(sizeof(SBEncState));
155 156
   if (!st)
      return NULL;
157
   st->mode = m;
158
   mode = (const SpeexSBMode*)m->mode;
159

160

161
   st->st_low = speex_encoder_init(mode->nb_mode);
162 163 164 165 166 167 168
#if defined(VAR_ARRAYS) || defined (USE_ALLOCA)
   st->stack = NULL;
#else
   /*st->stack = (char*)speex_alloc_scratch(SB_ENC_STACK);*/
   speex_encoder_ctl(st->st_low, SPEEX_GET_STACK, &st->stack);
#endif

169 170 171 172
   st->full_frame_size = 2*mode->frameSize;
   st->frame_size = mode->frameSize;
   st->subframeSize = mode->subframeSize;
   st->nbSubframes = mode->frameSize/mode->subframeSize;
173
   st->windowSize = st->frame_size+st->subframeSize;
174
   st->lpcSize=mode->lpcSize;
jmvalin's avatar
jmvalin committed
175

176
   st->encode_submode = 1;
177
   st->submodes=mode->submodes;
jm's avatar
jm committed
178
   st->submodeSelect = st->submodeID=mode->defaultSubmode;
Tristan Matthews's avatar
Tristan Matthews committed
179

180 181 182 183
   tmp=9;
   speex_encoder_ctl(st->st_low, SPEEX_SET_QUALITY, &tmp);
   tmp=1;
   speex_encoder_ctl(st->st_low, SPEEX_SET_WIDEBAND, &tmp);
184

185
   st->lpc_floor = mode->lpc_floor;
186 187
   st->gamma1=mode->gamma1;
   st->gamma2=mode->gamma2;
jmvalin's avatar
jmvalin committed
188
   st->first=1;
189

190
   st->high=(spx_word16_t*)speex_alloc((st->windowSize-st->frame_size)*sizeof(spx_word16_t));
jm's avatar
jm committed
191 192 193

   st->h0_mem=(spx_word16_t*)speex_alloc((QMF_ORDER)*sizeof(spx_word16_t));

194
   st->window= lpc_window;
jmvalin's avatar
jmvalin committed
195

196
   st->lagWindow = lag_window;
jmvalin's avatar
jmvalin committed
197

jm's avatar
jm committed
198 199 200 201
   st->old_lsp = (spx_lsp_t*)speex_alloc(st->lpcSize*sizeof(spx_lsp_t));
   st->old_qlsp = (spx_lsp_t*)speex_alloc(st->lpcSize*sizeof(spx_lsp_t));
   st->interp_qlpc = (spx_coef_t*)speex_alloc(st->lpcSize*sizeof(spx_coef_t));
   st->pi_gain = (spx_word32_t*)speex_alloc((st->nbSubframes)*sizeof(spx_word32_t));
202
   st->exc_rms = (spx_word16_t*)speex_alloc((st->nbSubframes)*sizeof(spx_word16_t));
203
   st->innov_rms_save = NULL;
Tristan Matthews's avatar
Tristan Matthews committed
204

jm's avatar
jm committed
205 206 207
   st->mem_sp = (spx_mem_t*)speex_alloc((st->lpcSize)*sizeof(spx_mem_t));
   st->mem_sp2 = (spx_mem_t*)speex_alloc((st->lpcSize)*sizeof(spx_mem_t));
   st->mem_sw = (spx_mem_t*)speex_alloc((st->lpcSize)*sizeof(spx_mem_t));
208

jm's avatar
jm committed
209
   for (i=0;i<st->lpcSize;i++)
210
      st->old_lsp[i]= DIV32(MULT16_16(QCONST16(3.1415927f, LSP_SHIFT), i+1), st->lpcSize+1);
jm's avatar
jm committed
211

212
#ifndef DISABLE_VBR
213 214
   st->vbr_quality = 8;
   st->vbr_enabled = 0;
215
   st->vbr_max = 0;
216
   st->vbr_max_high = 20000;  /* We just need a big value here */
jm's avatar
jm committed
217
   st->vad_enabled = 0;
jm's avatar
jm committed
218
   st->abr_enabled = 0;
219
   st->relative_quality=0;
220
#endif /* #ifndef DISABLE_VBR */
221

jmvalin's avatar
jmvalin committed
222
   st->complexity=2;
jm's avatar
jm committed
223
   speex_encoder_ctl(st->st_low, SPEEX_GET_SAMPLING_RATE, &st->sampling_rate);
224
   st->sampling_rate*=2;
jm's avatar
jm committed
225 226 227
#ifdef ENABLE_VALGRIND
   VALGRIND_MAKE_READABLE(st, (st->stack-(char*)st));
#endif
228
   return st;
229 230
}

231
void sb_encoder_destroy(void *state)
232
{
233
   SBEncState *st=(SBEncState*)state;
234

235
   speex_encoder_destroy(st->st_low);
236
#if !(defined(VAR_ARRAYS) || defined (USE_ALLOCA))
237
   /*speex_free_scratch(st->stack);*/
238
#endif
239

240 241 242 243 244 245 246 247
   speex_free(st->high);

   speex_free(st->h0_mem);

   speex_free(st->old_lsp);
   speex_free(st->old_qlsp);
   speex_free(st->interp_qlpc);
   speex_free(st->pi_gain);
248
   speex_free(st->exc_rms);
249 250 251 252 253

   speex_free(st->mem_sp);
   speex_free(st->mem_sp2);
   speex_free(st->mem_sw);

Tristan Matthews's avatar
Tristan Matthews committed
254

255
   speex_free(st);
256 257
}

258
int sb_encoder_ctl(void *state, int request, void *ptr)
259
{
260
   SBEncState *st;
261 262
   st=(SBEncState*)state;
   switch(request)
263
   {
264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299
   case SPEEX_GET_FRAME_SIZE:
      (*(spx_int32_t*)ptr) = st->full_frame_size;
      break;
   case SPEEX_SET_HIGH_MODE:
      st->submodeSelect = st->submodeID = (*(spx_int32_t*)ptr);
      break;
   case SPEEX_SET_LOW_MODE:
      speex_encoder_ctl(st->st_low, SPEEX_SET_LOW_MODE, ptr);
      break;
   case SPEEX_SET_DTX:
      speex_encoder_ctl(st->st_low, SPEEX_SET_DTX, ptr);
      break;
   case SPEEX_GET_DTX:
      speex_encoder_ctl(st->st_low, SPEEX_GET_DTX, ptr);
      break;
   case SPEEX_GET_LOW_MODE:
      speex_encoder_ctl(st->st_low, SPEEX_GET_LOW_MODE, ptr);
      break;
   case SPEEX_SET_MODE:
      speex_encoder_ctl(st, SPEEX_SET_QUALITY, ptr);
      break;
#ifndef DISABLE_VBR
   case SPEEX_SET_VBR:
      st->vbr_enabled = (*(spx_int32_t*)ptr);
      speex_encoder_ctl(st->st_low, SPEEX_SET_VBR, ptr);
      break;
   case SPEEX_GET_VBR:
      (*(spx_int32_t*)ptr) = st->vbr_enabled;
      break;
   case SPEEX_SET_VAD:
      st->vad_enabled = (*(spx_int32_t*)ptr);
      speex_encoder_ctl(st->st_low, SPEEX_SET_VAD, ptr);
      break;
   case SPEEX_GET_VAD:
      (*(spx_int32_t*)ptr) = st->vad_enabled;
      break;
300
#endif /* #ifndef DISABLE_VBR */
301 302
#if !defined(DISABLE_VBR) && !defined(DISABLE_FLOAT_API)
   case SPEEX_SET_VBR_QUALITY:
303
      {
304 305 306 307 308 309 310 311 312 313 314
         spx_int32_t q;
         float qual = (*(float*)ptr)+.6;
         st->vbr_quality = (*(float*)ptr);
         if (qual>10)
            qual=10;
         q=(int)floor(.5+*(float*)ptr);
         if (q>10)
            q=10;
         speex_encoder_ctl(st->st_low, SPEEX_SET_VBR_QUALITY, &qual);
         speex_encoder_ctl(state, SPEEX_SET_QUALITY, &q);
         break;
315
      }
316 317 318 319
   case SPEEX_GET_VBR_QUALITY:
      (*(float*)ptr) = st->vbr_quality;
      break;
#endif /* #if !defined(DISABLE_VBR) && !defined(DISABLE_FLOAT_API) */
320
#ifndef DISABLE_VBR
321 322 323 324
   case SPEEX_SET_ABR:
      st->abr_enabled = (*(spx_int32_t*)ptr);
      st->vbr_enabled = st->abr_enabled!=0;
      speex_encoder_ctl(st->st_low, SPEEX_SET_VBR, &st->vbr_enabled);
Tristan Matthews's avatar
Tristan Matthews committed
325
      if (st->vbr_enabled)
jm's avatar
jm committed
326
      {
327 328 329 330
         spx_int32_t i=10, rate, target;
         float vbr_qual;
         target = (*(spx_int32_t*)ptr);
         while (i>=0)
jm's avatar
jm committed
331
         {
332 333 334 335 336
            speex_encoder_ctl(st, SPEEX_SET_QUALITY, &i);
            speex_encoder_ctl(st, SPEEX_GET_BITRATE, &rate);
            if (rate <= target)
               break;
            i--;
jm's avatar
jm committed
337
         }
338 339 340 341 342 343 344
         vbr_qual=i;
         if (vbr_qual<0)
            vbr_qual=0;
         speex_encoder_ctl(st, SPEEX_SET_VBR_QUALITY, &vbr_qual);
         st->abr_count=0;
         st->abr_drift=0;
         st->abr_drift2=0;
jm's avatar
jm committed
345
      }
Tristan Matthews's avatar
Tristan Matthews committed
346

347 348 349 350 351 352 353
      break;
   case SPEEX_GET_ABR:
      (*(spx_int32_t*)ptr) = st->abr_enabled;
      break;
#endif /* #ifndef DISABLE_VBR */

   case SPEEX_SET_QUALITY:
jm's avatar
...  
jm committed
354
      {
355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380
         spx_int32_t nb_qual;
         int quality = (*(spx_int32_t*)ptr);
         if (quality < 0)
            quality = 0;
         if (quality > 10)
            quality = 10;
         st->submodeSelect = st->submodeID = ((const SpeexSBMode*)(st->mode->mode))->quality_map[quality];
         nb_qual = ((const SpeexSBMode*)(st->mode->mode))->low_quality_map[quality];
         speex_encoder_ctl(st->st_low, SPEEX_SET_MODE, &nb_qual);
      }
      break;
   case SPEEX_SET_COMPLEXITY:
      speex_encoder_ctl(st->st_low, SPEEX_SET_COMPLEXITY, ptr);
      st->complexity = (*(spx_int32_t*)ptr);
      if (st->complexity<1)
         st->complexity=1;
      break;
   case SPEEX_GET_COMPLEXITY:
      (*(spx_int32_t*)ptr) = st->complexity;
      break;
   case SPEEX_SET_BITRATE:
      {
         spx_int32_t i=10;
         spx_int32_t rate, target;
         target = (*(spx_int32_t*)ptr);
         while (i>=0)
jm's avatar
...  
jm committed
381
         {
382 383 384
            speex_encoder_ctl(st, SPEEX_SET_QUALITY, &i);
            speex_encoder_ctl(st, SPEEX_GET_BITRATE, &rate);
            if (rate <= target)
jm's avatar
...  
jm committed
385
               break;
386
            i--;
jm's avatar
...  
jm committed
387
         }
388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418
      }
      break;
   case SPEEX_GET_BITRATE:
      speex_encoder_ctl(st->st_low, request, ptr);
      /*fprintf (stderr, "before: %d\n", (*(int*)ptr));*/
      if (st->submodes[st->submodeID])
         (*(spx_int32_t*)ptr) += st->sampling_rate*SUBMODE(bits_per_frame)/st->full_frame_size;
      else
         (*(spx_int32_t*)ptr) += st->sampling_rate*(SB_SUBMODE_BITS+1)/st->full_frame_size;
      /*fprintf (stderr, "after: %d\n", (*(int*)ptr));*/
      break;
   case SPEEX_SET_SAMPLING_RATE:
      {
         spx_int32_t tmp=(*(spx_int32_t*)ptr);
         st->sampling_rate = tmp;
         tmp>>=1;
         speex_encoder_ctl(st->st_low, SPEEX_SET_SAMPLING_RATE, &tmp);
      }
      break;
   case SPEEX_GET_SAMPLING_RATE:
      (*(spx_int32_t*)ptr)=st->sampling_rate;
      break;
   case SPEEX_RESET_STATE:
      {
         int i;
         st->first = 1;
         for (i=0;i<st->lpcSize;i++)
            st->old_lsp[i]= DIV32(MULT16_16(QCONST16(3.1415927f, LSP_SHIFT), i+1), st->lpcSize+1);
         for (i=0;i<st->lpcSize;i++)
            st->mem_sw[i]=st->mem_sp[i]=st->mem_sp2[i]=0;
         for (i=0;i<QMF_ORDER;i++)
419
            st->h0_mem[i]=0;
420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443
      }
      break;
   case SPEEX_SET_SUBMODE_ENCODING:
      st->encode_submode = (*(spx_int32_t*)ptr);
      speex_encoder_ctl(st->st_low, SPEEX_SET_SUBMODE_ENCODING, ptr);
      break;
   case SPEEX_GET_SUBMODE_ENCODING:
      (*(spx_int32_t*)ptr) = st->encode_submode;
      break;
   case SPEEX_GET_LOOKAHEAD:
      speex_encoder_ctl(st->st_low, SPEEX_GET_LOOKAHEAD, ptr);
      (*(spx_int32_t*)ptr) = 2*(*(spx_int32_t*)ptr) + QMF_ORDER - 1;
      break;
   case SPEEX_SET_PLC_TUNING:
      speex_encoder_ctl(st->st_low, SPEEX_SET_PLC_TUNING, ptr);
      break;
   case SPEEX_GET_PLC_TUNING:
      speex_encoder_ctl(st->st_low, SPEEX_GET_PLC_TUNING, ptr);
      break;
#ifndef DISABLE_VBR
   case SPEEX_SET_VBR_MAX_BITRATE:
      {
         st->vbr_max = (*(spx_int32_t*)ptr);
         if (SPEEX_SET_VBR_MAX_BITRATE<1)
jm's avatar
jm committed
444
         {
445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464
            speex_encoder_ctl(st->st_low, SPEEX_SET_VBR_MAX_BITRATE, &st->vbr_max);
            st->vbr_max_high = 17600;
         } else {
            spx_int32_t low_rate;
            if (st->vbr_max >= 42200)
            {
               st->vbr_max_high = 17600;
            } else if (st->vbr_max >= 27800)
            {
               st->vbr_max_high = 9600;
            } else if (st->vbr_max > 20600)
            {
               st->vbr_max_high = 5600;
            } else {
               st->vbr_max_high = 1800;
            }
            if (st->subframeSize==80)
               st->vbr_max_high = 1800;
            low_rate = st->vbr_max - st->vbr_max_high;
            speex_encoder_ctl(st->st_low, SPEEX_SET_VBR_MAX_BITRATE, &low_rate);
jm's avatar
jm committed
465
         }
466 467 468 469 470 471 472 473 474 475 476 477
      }
      break;
   case SPEEX_GET_VBR_MAX_BITRATE:
      (*(spx_int32_t*)ptr) = st->vbr_max;
      break;
#endif /* #ifndef DISABLE_VBR */
   case SPEEX_SET_HIGHPASS:
      speex_encoder_ctl(st->st_low, SPEEX_SET_HIGHPASS, ptr);
      break;
   case SPEEX_GET_HIGHPASS:
      speex_encoder_ctl(st->st_low, SPEEX_GET_HIGHPASS, ptr);
      break;
jm's avatar
jm committed
478

jm's avatar
jm committed
479

480 481 482 483 484 485 486
   /* This is all internal stuff past this point */
   case SPEEX_GET_PI_GAIN:
      {
         int i;
         spx_word32_t *g = (spx_word32_t*)ptr;
         for (i=0;i<st->nbSubframes;i++)
            g[i]=st->pi_gain[i];
487
      }
488 489 490 491 492 493 494 495 496 497 498 499
      break;
   case SPEEX_GET_EXC:
      {
         int i;
         for (i=0;i<st->nbSubframes;i++)
            ((spx_word16_t*)ptr)[i] = st->exc_rms[i];
      }
      break;
#ifndef DISABLE_VBR
   case SPEEX_GET_RELATIVE_QUALITY:
      (*(float*)ptr)=st->relative_quality;
      break;
500
#endif /* #ifndef DISABLE_VBR */
501 502 503 504 505 506 507 508 509 510 511 512
   case SPEEX_SET_INNOVATION_SAVE:
      st->innov_rms_save = (spx_word16_t*)ptr;
      break;
   case SPEEX_SET_WIDEBAND:
      speex_encoder_ctl(st->st_low, SPEEX_SET_WIDEBAND, ptr);
      break;
   case SPEEX_GET_STACK:
      *((char**)ptr) = st->stack;
      break;
   default:
      speex_warning_int("Unknown nb_ctl request: ", request);
      return -1;
513
   }
514 515
   return 0;
}
516

517

518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543
int sb_encode(void *state, void *vin, SpeexBits *bits)
{
   SBEncState *st;
   int i, roots, sub;
   char *stack;
   VARDECL(spx_mem_t *mem);
   VARDECL(spx_sig_t *innov);
   VARDECL(spx_word16_t *target);
   VARDECL(spx_word16_t *syn_resp);
   VARDECL(spx_word32_t *low_pi_gain);
   spx_word16_t *low;
   spx_word16_t *high;
   VARDECL(spx_word16_t *low_exc_rms);
   VARDECL(spx_word16_t *low_innov_rms);
   const SpeexSBMode *mode;
   spx_int32_t dtx;
   spx_word16_t *in = (spx_word16_t*)vin;
   spx_word16_t e_low=0, e_high=0;
   VARDECL(spx_coef_t *lpc);
   VARDECL(spx_coef_t *interp_lpc);
   VARDECL(spx_coef_t *bw_lpc1);
   VARDECL(spx_coef_t *bw_lpc2);
   VARDECL(spx_lsp_t *lsp);
   VARDECL(spx_lsp_t *qlsp);
   VARDECL(spx_lsp_t *interp_lsp);
   VARDECL(spx_lsp_t *interp_qlsp);
Tristan Matthews's avatar
Tristan Matthews committed
544

545 546 547 548 549
   st = (SBEncState*)state;
   stack=st->stack;
   mode = (const SpeexSBMode*)(st->mode->mode);
   low = in;
   high = in+st->frame_size;
Tristan Matthews's avatar
Tristan Matthews committed
550

551 552 553
   /* High-band buffering / sync with low band */
   /* Compute the two sub-bands by filtering with QMF h0*/
   qmf_decomp(in, h0, low, high, st->full_frame_size, QMF_ORDER, st->h0_mem, stack);
Tristan Matthews's avatar
Tristan Matthews committed
554

555 556 557 558 559 560 561
#ifndef DISABLE_VBR
   if (st->vbr_enabled || st->vad_enabled)
   {
      /* Need to compute things here before the signal is trashed by the encoder */
      /*FIXME: Are the two signals (low, high) in sync? */
      e_low = compute_rms16(low, st->frame_size);
      e_high = compute_rms16(high, st->frame_size);
562
   }
563
#endif /* #ifndef DISABLE_VBR */
564

565 566 567 568
   ALLOC(low_innov_rms, st->nbSubframes, spx_word16_t);
   speex_encoder_ctl(st->st_low, SPEEX_SET_INNOVATION_SAVE, low_innov_rms);
   /* Encode the narrowband part*/
   speex_encode_native(st->st_low, low, bits);
569

570 571 572
   high = high - (st->windowSize-st->frame_size);
   SPEEX_COPY(high, st->high, st->windowSize-st->frame_size);
   SPEEX_COPY(st->high, &high[st->frame_size], st->windowSize-st->frame_size);
Tristan Matthews's avatar
Tristan Matthews committed
573

574 575 576 577 578

   ALLOC(low_pi_gain, st->nbSubframes, spx_word32_t);
   ALLOC(low_exc_rms, st->nbSubframes, spx_word16_t);
   speex_encoder_ctl(st->st_low, SPEEX_GET_PI_GAIN, low_pi_gain);
   speex_encoder_ctl(st->st_low, SPEEX_GET_EXC, low_exc_rms);
Tristan Matthews's avatar
Tristan Matthews committed
579

580 581 582 583 584 585 586 587 588 589 590
   speex_encoder_ctl(st->st_low, SPEEX_GET_LOW_MODE, &dtx);

   if (dtx==0)
      dtx=1;
   else
      dtx=0;

   ALLOC(lpc, st->lpcSize, spx_coef_t);
   ALLOC(interp_lpc, st->lpcSize, spx_coef_t);
   ALLOC(bw_lpc1, st->lpcSize, spx_coef_t);
   ALLOC(bw_lpc2, st->lpcSize, spx_coef_t);
Tristan Matthews's avatar
Tristan Matthews committed
591

592 593 594 595
   ALLOC(lsp, st->lpcSize, spx_lsp_t);
   ALLOC(qlsp, st->lpcSize, spx_lsp_t);
   ALLOC(interp_lsp, st->lpcSize, spx_lsp_t);
   ALLOC(interp_qlsp, st->lpcSize, spx_lsp_t);
Tristan Matthews's avatar
Tristan Matthews committed
596

597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663
   {
      VARDECL(spx_word16_t *autocorr);
      VARDECL(spx_word16_t *w_sig);
      ALLOC(autocorr, st->lpcSize+1, spx_word16_t);
      ALLOC(w_sig, st->windowSize, spx_word16_t);
      /* Window for analysis */
      /* FIXME: This is a kludge */
      if (st->subframeSize==80)
      {
         for (i=0;i<st->windowSize;i++)
            w_sig[i] = EXTRACT16(SHR32(MULT16_16(high[i],st->window[i>>1]),SIG_SHIFT));
      } else {
         for (i=0;i<st->windowSize;i++)
            w_sig[i] = EXTRACT16(SHR32(MULT16_16(high[i],st->window[i]),SIG_SHIFT));
      }
      /* Compute auto-correlation */
      _spx_autocorr(w_sig, autocorr, st->lpcSize+1, st->windowSize);
      autocorr[0] = ADD16(autocorr[0],MULT16_16_Q15(autocorr[0],st->lpc_floor)); /* Noise floor in auto-correlation domain */

      /* Lag windowing: equivalent to filtering in the power-spectrum domain */
      for (i=0;i<st->lpcSize+1;i++)
         autocorr[i] = MULT16_16_Q14(autocorr[i],st->lagWindow[i]);

      /* Levinson-Durbin */
      _spx_lpc(lpc, autocorr, st->lpcSize);
   }

   /* LPC to LSPs (x-domain) transform */
   roots=lpc_to_lsp (lpc, st->lpcSize, lsp, 10, LSP_DELTA1, stack);
   if (roots!=st->lpcSize)
   {
      roots = lpc_to_lsp (lpc, st->lpcSize, lsp, 10, LSP_DELTA2, stack);
      if (roots!=st->lpcSize) {
         /*If we can't find all LSP's, do some damage control and use a flat filter*/
         for (i=0;i<st->lpcSize;i++)
         {
            lsp[i]=st->old_lsp[i];
         }
      }
   }

#ifndef DISABLE_VBR
   /* VBR code */
   if ((st->vbr_enabled || st->vad_enabled) && !dtx)
   {
      float ratio;
      if (st->abr_enabled)
      {
         float qual_change=0;
         if (st->abr_drift2 * st->abr_drift > 0)
         {
            /* Only adapt if long-term and short-term drift are the same sign */
            qual_change = -.00001*st->abr_drift/(1+st->abr_count);
            if (qual_change>.1)
               qual_change=.1;
            if (qual_change<-.1)
               qual_change=-.1;
         }
         st->vbr_quality += qual_change;
         if (st->vbr_quality>10)
            st->vbr_quality=10;
         if (st->vbr_quality<0)
            st->vbr_quality=0;
      }


      ratio = 2*log((1.f+e_high)/(1.f+e_low));
Tristan Matthews's avatar
Tristan Matthews committed
664

665 666 667 668 669 670
      speex_encoder_ctl(st->st_low, SPEEX_GET_RELATIVE_QUALITY, &st->relative_quality);
      if (ratio<-4)
         ratio=-4;
      if (ratio>2)
         ratio=2;
      /*if (ratio>-2)*/
Tristan Matthews's avatar
Tristan Matthews committed
671
      if (st->vbr_enabled)
672 673 674 675 676 677 678 679 680 681 682 683 684 685
      {
         spx_int32_t modeid;
         modeid = mode->nb_modes-1;
         st->relative_quality+=1.0*(ratio+2);
	 if (st->relative_quality<-1)
            st->relative_quality=-1;
         while (modeid)
         {
            int v1;
            float thresh;
            v1=(int)floor(st->vbr_quality);
            if (v1==10)
               thresh = mode->vbr_thresh[modeid][v1];
            else
Tristan Matthews's avatar
Tristan Matthews committed
686
               thresh = (st->vbr_quality-v1)   * mode->vbr_thresh[modeid][v1+1] +
687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746
                        (1+v1-st->vbr_quality) * mode->vbr_thresh[modeid][v1];
            if (st->relative_quality >= thresh && st->sampling_rate*st->submodes[modeid]->bits_per_frame/st->full_frame_size <= st->vbr_max_high)
               break;
            modeid--;
         }
         speex_encoder_ctl(state, SPEEX_SET_HIGH_MODE, &modeid);
         if (st->abr_enabled)
         {
            spx_int32_t bitrate;
            speex_encoder_ctl(state, SPEEX_GET_BITRATE, &bitrate);
            st->abr_drift+=(bitrate-st->abr_enabled);
            st->abr_drift2 = .95*st->abr_drift2 + .05*(bitrate-st->abr_enabled);
            st->abr_count += 1.0;
         }

      } else {
         /* VAD only */
         int modeid;
         if (st->relative_quality<2.0)
            modeid=1;
         else
            modeid=st->submodeSelect;
         /*speex_encoder_ctl(state, SPEEX_SET_MODE, &mode);*/
         st->submodeID=modeid;

      }
      /*fprintf (stderr, "%f %f\n", ratio, low_qual);*/
   }
#endif /* #ifndef DISABLE_VBR */

   if (st->encode_submode)
   {
      speex_bits_pack(bits, 1, 1);
      if (dtx)
         speex_bits_pack(bits, 0, SB_SUBMODE_BITS);
      else
         speex_bits_pack(bits, st->submodeID, SB_SUBMODE_BITS);
   }

   /* If null mode (no transmission), just set a couple things to zero*/
   if (dtx || st->submodes[st->submodeID] == NULL)
   {
      for (i=0;i<st->frame_size;i++)
         high[i]=VERY_SMALL;

      for (i=0;i<st->lpcSize;i++)
         st->mem_sw[i]=0;
      st->first=1;

      /* Final signal synthesis from excitation */
      iir_mem16(high, st->interp_qlpc, high, st->frame_size, st->lpcSize, st->mem_sp, stack);

      if (dtx)
         return 0;
      else
         return 1;
   }


   /* LSP quantization */
Tristan Matthews's avatar
Tristan Matthews committed
747
   SUBMODE(lsp_quant)(lsp, qlsp, st->lpcSize, bits);
jmvalin's avatar
jmvalin committed
748

jmvalin's avatar
jmvalin committed
749 750 751
   if (st->first)
   {
      for (i=0;i<st->lpcSize;i++)
752
         st->old_lsp[i] = lsp[i];
jmvalin's avatar
jmvalin committed
753
      for (i=0;i<st->lpcSize;i++)
754
         st->old_qlsp[i] = qlsp[i];
jmvalin's avatar
jmvalin committed
755
   }
Tristan Matthews's avatar
Tristan Matthews committed
756

757
   ALLOC(mem, st->lpcSize, spx_mem_t);
758
   ALLOC(syn_resp, st->subframeSize, spx_word16_t);
759
   ALLOC(innov, st->subframeSize, spx_sig_t);
760
   ALLOC(target, st->subframeSize, spx_word16_t);
761

jmvalin's avatar
jmvalin committed
762 763
   for (sub=0;sub<st->nbSubframes;sub++)
   {
764
      VARDECL(spx_word16_t *exc);
765
      VARDECL(spx_word16_t *res);
766 767
      VARDECL(spx_word16_t *sw);
      spx_word16_t *sp;
jm's avatar
jm committed
768
      spx_word16_t filter_ratio;     /*Q7*/
jmvalin's avatar
jmvalin committed
769
      int offset;
jm's avatar
jm committed
770
      spx_word32_t rl, rh;           /*Q13*/
771
      spx_word16_t eh=0;
772

jmvalin's avatar
jmvalin committed
773
      offset = st->subframeSize*sub;
774
      sp=high+offset;
775
      ALLOC(exc, st->subframeSize, spx_word16_t);
776
      ALLOC(res, st->subframeSize, spx_word16_t);
777
      ALLOC(sw, st->subframeSize, spx_word16_t);
Tristan Matthews's avatar
Tristan Matthews committed
778

jmvalin's avatar
jmvalin committed
779
      /* LSP interpolation (quantized and unquantized) */
780 781
      lsp_interpolate(st->old_lsp, lsp, interp_lsp, st->lpcSize, sub, st->nbSubframes, LSP_MARGIN);
      lsp_interpolate(st->old_qlsp, qlsp, interp_qlsp, st->lpcSize, sub, st->nbSubframes, LSP_MARGIN);
782

783 784
      lsp_to_lpc(interp_lsp, interp_lpc, st->lpcSize,stack);
      lsp_to_lpc(interp_qlsp, st->interp_qlpc, st->lpcSize, stack);
785

786 787
      bw_lpc(st->gamma1, interp_lpc, bw_lpc1, st->lpcSize);
      bw_lpc(st->gamma2, interp_lpc, bw_lpc2, st->lpcSize);
788

789
      /* Compute mid-band (4000 Hz for wideband) response of low-band and high-band
790
         filters */
jm's avatar
jm committed
791 792
      st->pi_gain[sub]=LPC_SCALING;
      rh = LPC_SCALING;
793
      for (i=0;i<st->lpcSize;i+=2)
794
      {
jm's avatar
jm committed
795 796
         rh += st->interp_qlpc[i+1] - st->interp_qlpc[i];
         st->pi_gain[sub] += st->interp_qlpc[i] + st->interp_qlpc[i+1];
797
      }
Tristan Matthews's avatar
Tristan Matthews committed
798

799
      rl = low_pi_gain[sub];
800
#ifdef FIXED_POINT
jm's avatar
jm committed
801
      filter_ratio=EXTRACT16(SATURATE(PDIV32(SHL32(ADD32(rl,82),7),ADD32(82,rh)),32767));
802
#else
803
      filter_ratio=(rl+.01)/(rh+.01);
804
#endif
Tristan Matthews's avatar
Tristan Matthews committed
805

806
      /* Compute "real excitation" */
807
      fir_mem16(sp, st->interp_qlpc, exc, st->subframeSize, st->lpcSize, st->mem_sp2, stack);
808
      /* Compute energy of low-band and high-band excitation */
809

810
      eh = compute_rms16(exc, st->subframeSize);
811

812
      if (!SUBMODE(innovation_quant)) {/* 1 for spectral folding excitation, 0 for stochastic */
jm's avatar
jm committed
813 814
         spx_word32_t g;   /*Q7*/
         spx_word16_t el;  /*Q0*/
815
         el = low_innov_rms[sub];
816

817
         /* Gain to use if we want to use the low-band excitation for high-band */
jm's avatar
jm committed
818
         g=PDIV32(MULT16_16(filter_ratio,eh),EXTEND32(ADD16(1,el)));
Tristan Matthews's avatar
Tristan Matthews committed
819

jm's avatar
jm committed
820 821 822 823 824
#if 0
         {
            char *tmp_stack=stack;
            float *tmp_sig;
            float g2;
825
            ALLOC(tmp_sig, st->subframeSize, spx_sig_t);
jm's avatar
jm committed
826 827
            for (i=0;i<st->lpcSize;i++)
               mem[i]=st->mem_sp[i];
828
            iir_mem2(st->low_innov+offset, st->interp_qlpc, tmp_sig, st->subframeSize, st->lpcSize, mem);
jm's avatar
jm committed
829 830 831
            g2 = compute_rms(sp, st->subframeSize)/(.01+compute_rms(tmp_sig, st->subframeSize));
            /*fprintf (stderr, "gains: %f %f\n", g, g2);*/
            g = g2;
jm's avatar
jm committed
832
            stack = tmp_stack;
jm's avatar
jm committed
833 834
         }
#endif
jmvalin's avatar
jmvalin committed
835

jm's avatar
jm committed
836
         /*print_vec(&g, 1, "gain factor");*/
jmvalin's avatar
jmvalin committed
837
         /* Gain quantization */
838
         {
839
            int quant = scal_quant(g, fold_quant_bound, 32);
jm's avatar
jm committed
840
            /*speex_warning_int("tata", quant);*/
841 842 843 844
            if (quant<0)
               quant=0;
            if (quant>31)
               quant=31;
845
            speex_bits_pack(bits, quant, 5);
846
         }
847 848 849 850 851
         if (st->innov_rms_save)
         {
            st->innov_rms_save[sub] = eh;
         }
         st->exc_rms[sub] = eh;
852
      } else {
jm's avatar
jm committed
853 854 855 856
         spx_word16_t gc;       /*Q7*/
         spx_word32_t scale;    /*Q14*/
         spx_word16_t el;       /*Q0*/
         el = low_exc_rms[sub]; /*Q0*/
857

858
         gc = PDIV32_16(MULT16_16(filter_ratio,1+eh),1+el);
859 860 861

         /* This is a kludge that cleans up a historical bug */
         if (st->subframeSize==80)
862
            gc = MULT16_16_P15(QCONST16(0.70711f,15),gc);
863
         /*printf ("%f %f %f %f\n", el, eh, filter_ratio, gc);*/
864
         {
865
            int qgc = scal_quant(gc, gc_quant_bound, 16);
866
            speex_bits_pack(bits, qgc, 4);
867
            gc = MULT16_16_Q15(QCONST16(0.87360,15),gc_quant_bound[qgc]);
868
         }
869
         if (st->subframeSize==80)
870
            gc = MULT16_16_P14(QCONST16(1.4142f,14), gc);
871

872
         scale = SHL32(MULT16_16(PDIV32_16(SHL32(EXTEND32(gc),SIG_SHIFT-6),filter_ratio),(1+el)),6);
jm's avatar
jm committed
873

874
         compute_impulse_response(st->interp_qlpc, bw_lpc1, bw_lpc2, syn_resp, st->subframeSize, st->lpcSize, stack);
875

Tristan Matthews's avatar
Tristan Matthews committed
876

877 878
         /* Reset excitation */
         for (i=0;i<st->subframeSize;i++)
879
            res[i]=VERY_SMALL;
Tristan Matthews's avatar
Tristan Matthews committed
880

881 882 883
         /* Compute zero response (ringing) of A(z/g1) / ( A(z/g2) * Aq(z) ) */
         for (i=0;i<st->lpcSize;i++)
            mem[i]=st->mem_sp[i];
884
         iir_mem16(res, st->interp_qlpc, res, st->subframeSize, st->lpcSize, mem, stack);
885 886 887

         for (i=0;i<st->lpcSize;i++)
            mem[i]=st->mem_sw[i];
888
         filter_mem16(res, bw_lpc1, bw_lpc2, res, st->subframeSize, st->lpcSize, mem, stack);
889 890

         /* Compute weighted signal */
891
         for (i=0;i<st->lpcSize;i++)
892
            mem[i]=st->mem_sw[i];
893
         filter_mem16(sp, bw_lpc1, bw_lpc2, sw, st->subframeSize, st->lpcSize, mem, stack);
894

895 896
         /* Compute target signal */
         for (i=0;i<st->subframeSize;i++)
897
            target[i]=SUB16(sw[i],res[i]);
898

899
         signal_div(target, target, scale, st->subframeSize);
900

901
         /* Reset excitation */
902
         SPEEX_MEMSET(innov, 0, st->subframeSize);
903

jmvalin's avatar
jmvalin committed
904
         /*print_vec(target, st->subframeSize, "\ntarget");*/
Tristan Matthews's avatar
Tristan Matthews committed
905 906
         SUBMODE(innovation_quant)(target, st->interp_qlpc, bw_lpc1, bw_lpc2,
                                   SUBMODE(innovation_params), st->lpcSize, st->subframeSize,
907
                                   innov, syn_resp, bits, stack, st->complexity, SUBMODE(double_codebook));
jmvalin's avatar
jmvalin committed
908
         /*print_vec(target, st->subframeSize, "after");*/
909

910
         signal_mul(innov, innov, scale, st->subframeSize);
911

912
         if (SUBMODE(double_codebook)) {