?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Port Android relocation packer to chromium build
[chromium-blink-merge.git] / third_party / speex / libspeex / sb_celp.c
blob6c19ff8bb751a3350516ba6f029ddb8faa285dfc
1 /* Copyright (C) 2002-2006 Jean-Marc Valin
2 File: sb_celp.c
3
4 Redistribution and use in source and binary forms, with or without
5 modification, are permitted provided that the following conditions
6 are met:
7
8 - Redistributions of source code must retain the above copyright
9 notice, this list of conditions and the following disclaimer.
10
11 - Redistributions in binary form must reproduce the above copyright
12 notice, this list of conditions and the following disclaimer in the
13 documentation and/or other materials provided with the distribution.
14
15 - Neither the name of the Xiph.org Foundation nor the names of its
16 contributors may be used to endorse or promote products derived from
17 this software without specific prior written permission.
18
19 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20 ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR
23 CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
24 EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
25 PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
26 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
27 LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
28 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
29 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 #ifdef HAVE_CONFIG_H
33 #include "config.h"
34 #endif
35
36 #include <math.h>
37 #include "sb_celp.h"
38 #include "filters.h"
39 #include "lpc.h"
40 #include "lsp.h"
41 #include "stack_alloc.h"
42 #include "cb_search.h"
43 #include "quant_lsp.h"
44 #include "vq.h"
45 #include "ltp.h"
46 #include "arch.h"
47 #include "math_approx.h"
48 #include "os_support.h"
49
50 #ifndef NULL
51 #define NULL 0
52 #endif
53
54 /* Default size for the encoder and decoder stack (can be changed at compile time).
55 This does not apply when using variable-size arrays or alloca. */
56 #ifndef SB_ENC_STACK
57 #define SB_ENC_STACK (10000*sizeof(spx_sig_t))
58 #endif
59
60 #ifndef SB_DEC_STACK
61 #define SB_DEC_STACK (6000*sizeof(spx_sig_t))
62 #endif
63
64
65 #ifdef DISABLE_WIDEBAND
66 void *sb_encoder_init(const SpeexMode *m)
67 {
68 speex_fatal("Wideband and Ultra-wideband are disabled");
69 return NULL;
70 }
71 void sb_encoder_destroy(void *state)
72 {
73 speex_fatal("Wideband and Ultra-wideband are disabled");
74 }
75 int sb_encode(void *state, void *vin, SpeexBits *bits)
76 {
77 speex_fatal("Wideband and Ultra-wideband are disabled");
78 return -2;
79 }
80 void *sb_decoder_init(const SpeexMode *m)
81 {
82 speex_fatal("Wideband and Ultra-wideband are disabled");
83 return NULL;
84 }
85 void sb_decoder_destroy(void *state)
86 {
87 speex_fatal("Wideband and Ultra-wideband are disabled");
88 }
89 int sb_decode(void *state, SpeexBits *bits, void *vout)
90 {
91 speex_fatal("Wideband and Ultra-wideband are disabled");
92 return -2;
93 }
94 int sb_encoder_ctl(void *state, int request, void *ptr)
95 {
96 speex_fatal("Wideband and Ultra-wideband are disabled");
97 return -2;
98 }
99 int sb_decoder_ctl(void *state, int request, void *ptr)
100 {
101 speex_fatal("Wideband and Ultra-wideband are disabled");
102 return -2;
103 }
104 #else
105
106
107 #ifndef M_PI
108 #define M_PI 3.14159265358979323846 /* pi */
109 #endif
110
111 #define sqr(x) ((x)*(x))
112
113 #define SUBMODE(x) st->submodes[st->submodeID]->x
114
115 #ifdef FIXED_POINT
116 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};
117 static const spx_word16_t fold_quant_bound[32] = {
118 39, 44, 50, 57, 64, 73, 83, 94,
119 106, 120, 136, 154, 175, 198, 225, 255,
120 288, 327, 370, 420, 476, 539, 611, 692,
121 784, 889, 1007, 1141, 1293, 1465, 1660, 1881};
122 #define LSP_MARGIN 410
123 #define LSP_DELTA1 6553
124 #define LSP_DELTA2 1638
125
126 #else
127
128 static const spx_word16_t gc_quant_bound[16] = {
129 0.97979, 1.28384, 1.68223, 2.20426, 2.88829, 3.78458, 4.95900, 6.49787,
130 8.51428, 11.15642, 14.61846, 19.15484, 25.09895, 32.88761, 43.09325, 56.46588};
131 static const spx_word16_t fold_quant_bound[32] = {
132 0.30498, 0.34559, 0.39161, 0.44375, 0.50283, 0.56979, 0.64565, 0.73162,
133 0.82903, 0.93942, 1.06450, 1.20624, 1.36685, 1.54884, 1.75506, 1.98875,
134 2.25355, 2.55360, 2.89361, 3.27889, 3.71547, 4.21018, 4.77076, 5.40598,
135 6.12577, 6.94141, 7.86565, 8.91295, 10.09969, 11.44445, 12.96826, 14.69497};
136
137 #define LSP_MARGIN .05
138 #define LSP_DELTA1 .2
139 #define LSP_DELTA2 .05
140
141 #endif
142
143 #define QMF_ORDER 64
144
145 #ifdef FIXED_POINT
146 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};
147
148 #else
149 static const float h0[64] = {
150 3.596189e-05f, -0.0001123515f,
151 -0.0001104587f, 0.0002790277f,
152 0.0002298438f, -0.0005953563f,
153 -0.0003823631f, 0.00113826f,
154 0.0005308539f, -0.001986177f,
155 -0.0006243724f, 0.003235877f,
156 0.0005743159f, -0.004989147f,
157 -0.0002584767f, 0.007367171f,
158 -0.0004857935f, -0.01050689f,
159 0.001894714f, 0.01459396f,
160 -0.004313674f, -0.01994365f,
161 0.00828756f, 0.02716055f,
162 -0.01485397f, -0.03764973f,
163 0.026447f, 0.05543245f,
164 -0.05095487f, -0.09779096f,
165 0.1382363f, 0.4600981f,
166 0.4600981f, 0.1382363f,
167 -0.09779096f, -0.05095487f,
168 0.05543245f, 0.026447f,
169 -0.03764973f, -0.01485397f,
170 0.02716055f, 0.00828756f,
171 -0.01994365f, -0.004313674f,
172 0.01459396f, 0.001894714f,
173 -0.01050689f, -0.0004857935f,
174 0.007367171f, -0.0002584767f,
175 -0.004989147f, 0.0005743159f,
176 0.003235877f, -0.0006243724f,
177 -0.001986177f, 0.0005308539f,
178 0.00113826f, -0.0003823631f,
179 -0.0005953563f, 0.0002298438f,
180 0.0002790277f, -0.0001104587f,
181 -0.0001123515f, 3.596189e-05f
182 };
183
184 #endif
185
186 extern const spx_word16_t lag_window[];
187 extern const spx_word16_t lpc_window[];
188
189
190 void *sb_encoder_init(const SpeexMode *m)
191 {
192 int i;
193 spx_int32_t tmp;
194 SBEncState *st;
195 const SpeexSBMode *mode;
196
197 st = (SBEncState*)speex_alloc(sizeof(SBEncState));
198 if (!st)
199 return NULL;
200 st->mode = m;
201 mode = (const SpeexSBMode*)m->mode;
202
203
204 st->st_low = speex_encoder_init(mode->nb_mode);
205 #if defined(VAR_ARRAYS) || defined (USE_ALLOCA)
206 st->stack = NULL;
207 #else
208 /*st->stack = (char*)speex_alloc_scratch(SB_ENC_STACK);*/
209 speex_encoder_ctl(st->st_low, SPEEX_GET_STACK, &st->stack);
210 #endif
211
212 st->full_frame_size = 2*mode->frameSize;
213 st->frame_size = mode->frameSize;
214 st->subframeSize = mode->subframeSize;
215 st->nbSubframes = mode->frameSize/mode->subframeSize;
216 st->windowSize = st->frame_size+st->subframeSize;
217 st->lpcSize=mode->lpcSize;
218
219 st->encode_submode = 1;
220 st->submodes=mode->submodes;
221 st->submodeSelect = st->submodeID=mode->defaultSubmode;
222
223 tmp=9;
224 speex_encoder_ctl(st->st_low, SPEEX_SET_QUALITY, &tmp);
225 tmp=1;
226 speex_encoder_ctl(st->st_low, SPEEX_SET_WIDEBAND, &tmp);
227
228 st->lpc_floor = mode->lpc_floor;
229 st->gamma1=mode->gamma1;
230 st->gamma2=mode->gamma2;
231 st->first=1;
232
233 st->high=(spx_word16_t*)speex_alloc((st->windowSize-st->frame_size)*sizeof(spx_word16_t));
234
235 st->h0_mem=(spx_word16_t*)speex_alloc((QMF_ORDER)*sizeof(spx_word16_t));
236 st->h1_mem=(spx_word16_t*)speex_alloc((QMF_ORDER)*sizeof(spx_word16_t));
237
238 st->window= lpc_window;
239
240 st->lagWindow = lag_window;
241
242 st->old_lsp = (spx_lsp_t*)speex_alloc(st->lpcSize*sizeof(spx_lsp_t));
243 st->old_qlsp = (spx_lsp_t*)speex_alloc(st->lpcSize*sizeof(spx_lsp_t));
244 st->interp_qlpc = (spx_coef_t*)speex_alloc(st->lpcSize*sizeof(spx_coef_t));
245 st->pi_gain = (spx_word32_t*)speex_alloc((st->nbSubframes)*sizeof(spx_word32_t));
246 st->exc_rms = (spx_word16_t*)speex_alloc((st->nbSubframes)*sizeof(spx_word16_t));
247 st->innov_rms_save = NULL;
248
249 st->mem_sp = (spx_mem_t*)speex_alloc((st->lpcSize)*sizeof(spx_mem_t));
250 st->mem_sp2 = (spx_mem_t*)speex_alloc((st->lpcSize)*sizeof(spx_mem_t));
251 st->mem_sw = (spx_mem_t*)speex_alloc((st->lpcSize)*sizeof(spx_mem_t));
252
253 for (i=0;i<st->lpcSize;i++)
254 st->old_lsp[i]= DIV32(MULT16_16(QCONST16(3.1415927f, LSP_SHIFT), i+1), st->lpcSize+1);
255
256 #ifndef DISABLE_VBR
257 st->vbr_quality = 8;
258 st->vbr_enabled = 0;
259 st->vbr_max = 0;
260 st->vbr_max_high = 20000; /* We just need a big value here */
261 st->vad_enabled = 0;
262 st->abr_enabled = 0;
263 st->relative_quality=0;
264 #endif /* #ifndef DISABLE_VBR */
265
266 st->complexity=2;
267 speex_encoder_ctl(st->st_low, SPEEX_GET_SAMPLING_RATE, &st->sampling_rate);
268 st->sampling_rate*=2;
269 #ifdef ENABLE_VALGRIND
270 VALGRIND_MAKE_READABLE(st, (st->stack-(char*)st));
271 #endif
272 return st;
273 }
274
275 void sb_encoder_destroy(void *state)
276 {
277 SBEncState *st=(SBEncState*)state;
278
279 speex_encoder_destroy(st->st_low);
280 #if !(defined(VAR_ARRAYS) || defined (USE_ALLOCA))
281 /*speex_free_scratch(st->stack);*/
282 #endif
283
284 speex_free(st->high);
285
286 speex_free(st->h0_mem);
287 speex_free(st->h1_mem);
288
289 speex_free(st->old_lsp);
290 speex_free(st->old_qlsp);
291 speex_free(st->interp_qlpc);
292 speex_free(st->pi_gain);
293 speex_free(st->exc_rms);
294
295 speex_free(st->mem_sp);
296 speex_free(st->mem_sp2);
297 speex_free(st->mem_sw);
298
299
300 speex_free(st);
301 }
302
303
304 int sb_encode(void *state, void *vin, SpeexBits *bits)
305 {
306 SBEncState *st;
307 int i, roots, sub;
308 char *stack;
309 VARDECL(spx_mem_t *mem);
310 VARDECL(spx_sig_t *innov);
311 VARDECL(spx_word16_t *target);
312 VARDECL(spx_word16_t *syn_resp);
313 VARDECL(spx_word32_t *low_pi_gain);
314 spx_word16_t *low;
315 spx_word16_t *high;
316 VARDECL(spx_word16_t *low_exc_rms);
317 VARDECL(spx_word16_t *low_innov_rms);
318 const SpeexSBMode *mode;
319 spx_int32_t dtx;
320 spx_word16_t *in = (spx_word16_t*)vin;
321 spx_word16_t e_low=0, e_high=0;
322 VARDECL(spx_coef_t *lpc);
323 VARDECL(spx_coef_t *interp_lpc);
324 VARDECL(spx_coef_t *bw_lpc1);
325 VARDECL(spx_coef_t *bw_lpc2);
326 VARDECL(spx_lsp_t *lsp);
327 VARDECL(spx_lsp_t *qlsp);
328 VARDECL(spx_lsp_t *interp_lsp);
329 VARDECL(spx_lsp_t *interp_qlsp);
330
331 st = (SBEncState*)state;
332 stack=st->stack;
333 mode = (const SpeexSBMode*)(st->mode->mode);
334 low = in;
335 high = in+st->frame_size;
336
337 /* High-band buffering / sync with low band */
338 /* Compute the two sub-bands by filtering with QMF h0*/
339 qmf_decomp(in, h0, low, high, st->full_frame_size, QMF_ORDER, st->h0_mem, stack);
340
341 #ifndef DISABLE_VBR
342 if (st->vbr_enabled || st->vad_enabled)
343 {
344 /* Need to compute things here before the signal is trashed by the encoder */
345 /*FIXME: Are the two signals (low, high) in sync? */
346 e_low = compute_rms16(low, st->frame_size);
347 e_high = compute_rms16(high, st->frame_size);
348 }
349 #endif /* #ifndef DISABLE_VBR */
350
351 ALLOC(low_innov_rms, st->nbSubframes, spx_word16_t);
352 speex_encoder_ctl(st->st_low, SPEEX_SET_INNOVATION_SAVE, low_innov_rms);
353 /* Encode the narrowband part*/
354 speex_encode_native(st->st_low, low, bits);
355
356 high = high - (st->windowSize-st->frame_size);
357 SPEEX_COPY(high, st->high, st->windowSize-st->frame_size);
358 SPEEX_COPY(st->high, &high[st->frame_size], st->windowSize-st->frame_size);
359
360
361 ALLOC(low_pi_gain, st->nbSubframes, spx_word32_t);
362 ALLOC(low_exc_rms, st->nbSubframes, spx_word16_t);
363 speex_encoder_ctl(st->st_low, SPEEX_GET_PI_GAIN, low_pi_gain);
364 speex_encoder_ctl(st->st_low, SPEEX_GET_EXC, low_exc_rms);
365
366 speex_encoder_ctl(st->st_low, SPEEX_GET_LOW_MODE, &dtx);
367
368 if (dtx==0)
369 dtx=1;
370 else
371 dtx=0;
372
373 ALLOC(lpc, st->lpcSize, spx_coef_t);
374 ALLOC(interp_lpc, st->lpcSize, spx_coef_t);
375 ALLOC(bw_lpc1, st->lpcSize, spx_coef_t);
376 ALLOC(bw_lpc2, st->lpcSize, spx_coef_t);
377
378 ALLOC(lsp, st->lpcSize, spx_lsp_t);
379 ALLOC(qlsp, st->lpcSize, spx_lsp_t);
380 ALLOC(interp_lsp, st->lpcSize, spx_lsp_t);
381 ALLOC(interp_qlsp, st->lpcSize, spx_lsp_t);
382
383 {
384 VARDECL(spx_word16_t *autocorr);
385 VARDECL(spx_word16_t *w_sig);
386 ALLOC(autocorr, st->lpcSize+1, spx_word16_t);
387 ALLOC(w_sig, st->windowSize, spx_word16_t);
388 /* Window for analysis */
389 /* FIXME: This is a kludge */
390 if (st->subframeSize==80)
391 {
392 for (i=0;i<st->windowSize;i++)
393 w_sig[i] = EXTRACT16(SHR32(MULT16_16(high[i],st->window[i>>1]),SIG_SHIFT));
394 } else {
395 for (i=0;i<st->windowSize;i++)
396 w_sig[i] = EXTRACT16(SHR32(MULT16_16(high[i],st->window[i]),SIG_SHIFT));
397 }
398 /* Compute auto-correlation */
399 _spx_autocorr(w_sig, autocorr, st->lpcSize+1, st->windowSize);
400 autocorr[0] = ADD16(autocorr[0],MULT16_16_Q15(autocorr[0],st->lpc_floor)); /* Noise floor in auto-correlation domain */
401
402 /* Lag windowing: equivalent to filtering in the power-spectrum domain */
403 for (i=0;i<st->lpcSize+1;i++)
404 autocorr[i] = MULT16_16_Q14(autocorr[i],st->lagWindow[i]);
405
406 /* Levinson-Durbin */
407 _spx_lpc(lpc, autocorr, st->lpcSize);
408 }
409
410 /* LPC to LSPs (x-domain) transform */
411 roots=lpc_to_lsp (lpc, st->lpcSize, lsp, 10, LSP_DELTA1, stack);
412 if (roots!=st->lpcSize)
413 {
414 roots = lpc_to_lsp (lpc, st->lpcSize, lsp, 10, LSP_DELTA2, stack);
415 if (roots!=st->lpcSize) {
416 /*If we can't find all LSP's, do some damage control and use a flat filter*/
417 for (i=0;i<st->lpcSize;i++)
418 {
419 lsp[i]=st->old_lsp[i];
420 }
421 }
422 }
423
424 #ifndef DISABLE_VBR
425 /* VBR code */
426 if ((st->vbr_enabled || st->vad_enabled) && !dtx)
427 {
428 float ratio;
429 if (st->abr_enabled)
430 {
431 float qual_change=0;
432 if (st->abr_drift2 * st->abr_drift > 0)
433 {
434 /* Only adapt if long-term and short-term drift are the same sign */
435 qual_change = -.00001*st->abr_drift/(1+st->abr_count);
436 if (qual_change>.1)
437 qual_change=.1;
438 if (qual_change<-.1)
439 qual_change=-.1;
440 }
441 st->vbr_quality += qual_change;
442 if (st->vbr_quality>10)
443 st->vbr_quality=10;
444 if (st->vbr_quality<0)
445 st->vbr_quality=0;
446 }
447
448
449 ratio = 2*log((1.f+e_high)/(1.f+e_low));
450
451 speex_encoder_ctl(st->st_low, SPEEX_GET_RELATIVE_QUALITY, &st->relative_quality);
452 if (ratio<-4)
453 ratio=-4;
454 if (ratio>2)
455 ratio=2;
456 /*if (ratio>-2)*/
457 if (st->vbr_enabled)
458 {
459 spx_int32_t modeid;
460 modeid = mode->nb_modes-1;
461 st->relative_quality+=1.0*(ratio+2);
462 if (st->relative_quality<-1)
463 st->relative_quality=-1;
464 while (modeid)
465 {
466 int v1;
467 float thresh;
468 v1=(int)floor(st->vbr_quality);
469 if (v1==10)
470 thresh = mode->vbr_thresh[modeid][v1];
471 else
472 thresh = (st->vbr_quality-v1) * mode->vbr_thresh[modeid][v1+1] +
473 (1+v1-st->vbr_quality) * mode->vbr_thresh[modeid][v1];
474 if (st->relative_quality >= thresh && st->sampling_rate*st->submodes[modeid]->bits_per_frame/st->full_frame_size <= st->vbr_max_high)
475 break;
476 modeid--;
477 }
478 speex_encoder_ctl(state, SPEEX_SET_HIGH_MODE, &modeid);
479 if (st->abr_enabled)
480 {
481 spx_int32_t bitrate;
482 speex_encoder_ctl(state, SPEEX_GET_BITRATE, &bitrate);
483 st->abr_drift+=(bitrate-st->abr_enabled);
484 st->abr_drift2 = .95*st->abr_drift2 + .05*(bitrate-st->abr_enabled);
485 st->abr_count += 1.0;
486 }
487
488 } else {
489 /* VAD only */
490 int modeid;
491 if (st->relative_quality<2.0)
492 modeid=1;
493 else
494 modeid=st->submodeSelect;
495 /*speex_encoder_ctl(state, SPEEX_SET_MODE, &mode);*/
496 st->submodeID=modeid;
497
498 }
499 /*fprintf (stderr, "%f %f\n", ratio, low_qual);*/
500 }
501 #endif /* #ifndef DISABLE_VBR */
502
503 if (st->encode_submode)
504 {
505 speex_bits_pack(bits, 1, 1);
506 if (dtx)
507 speex_bits_pack(bits, 0, SB_SUBMODE_BITS);
508 else
509 speex_bits_pack(bits, st->submodeID, SB_SUBMODE_BITS);
510 }
511
512 /* If null mode (no transmission), just set a couple things to zero*/
513 if (dtx || st->submodes[st->submodeID] == NULL)
514 {
515 for (i=0;i<st->frame_size;i++)
516 high[i]=VERY_SMALL;
517
518 for (i=0;i<st->lpcSize;i++)
519 st->mem_sw[i]=0;
520 st->first=1;
521
522 /* Final signal synthesis from excitation */
523 iir_mem16(high, st->interp_qlpc, high, st->frame_size, st->lpcSize, st->mem_sp, stack);
524
525 if (dtx)
526 return 0;
527 else
528 return 1;
529 }
530
531
532 /* LSP quantization */
533 SUBMODE(lsp_quant)(lsp, qlsp, st->lpcSize, bits);
534
535 if (st->first)
536 {
537 for (i=0;i<st->lpcSize;i++)
538 st->old_lsp[i] = lsp[i];
539 for (i=0;i<st->lpcSize;i++)
540 st->old_qlsp[i] = qlsp[i];
541 }
542
543 ALLOC(mem, st->lpcSize, spx_mem_t);
544 ALLOC(syn_resp, st->subframeSize, spx_word16_t);
545 ALLOC(innov, st->subframeSize, spx_sig_t);
546 ALLOC(target, st->subframeSize, spx_word16_t);
547
548 for (sub=0;sub<st->nbSubframes;sub++)
549 {
550 VARDECL(spx_word16_t *exc);
551 VARDECL(spx_word16_t *res);
552 VARDECL(spx_word16_t *sw);
553 spx_word16_t *sp;
554 spx_word16_t filter_ratio; /*Q7*/
555 int offset;
556 spx_word32_t rl, rh; /*Q13*/
557 spx_word16_t eh=0;
558
559 offset = st->subframeSize*sub;
560 sp=high+offset;
561 ALLOC(exc, st->subframeSize, spx_word16_t);
562 ALLOC(res, st->subframeSize, spx_word16_t);
563 ALLOC(sw, st->subframeSize, spx_word16_t);
564
565 /* LSP interpolation (quantized and unquantized) */
566 lsp_interpolate(st->old_lsp, lsp, interp_lsp, st->lpcSize, sub, st->nbSubframes);
567 lsp_interpolate(st->old_qlsp, qlsp, interp_qlsp, st->lpcSize, sub, st->nbSubframes);
568
569 lsp_enforce_margin(interp_lsp, st->lpcSize, LSP_MARGIN);
570 lsp_enforce_margin(interp_qlsp, st->lpcSize, LSP_MARGIN);
571
572 lsp_to_lpc(interp_lsp, interp_lpc, st->lpcSize,stack);
573 lsp_to_lpc(interp_qlsp, st->interp_qlpc, st->lpcSize, stack);
574
575 bw_lpc(st->gamma1, interp_lpc, bw_lpc1, st->lpcSize);
576 bw_lpc(st->gamma2, interp_lpc, bw_lpc2, st->lpcSize);
577
578 /* Compute mid-band (4000 Hz for wideband) response of low-band and high-band
579 filters */
580 st->pi_gain[sub]=LPC_SCALING;
581 rh = LPC_SCALING;
582 for (i=0;i<st->lpcSize;i+=2)
583 {
584 rh += st->interp_qlpc[i+1] - st->interp_qlpc[i];
585 st->pi_gain[sub] += st->interp_qlpc[i] + st->interp_qlpc[i+1];
586 }
587
588 rl = low_pi_gain[sub];
589 #ifdef FIXED_POINT
590 filter_ratio=EXTRACT16(SATURATE(PDIV32(SHL32(ADD32(rl,82),7),ADD32(82,rh)),32767));
591 #else
592 filter_ratio=(rl+.01)/(rh+.01);
593 #endif
594
595 /* Compute "real excitation" */
596 fir_mem16(sp, st->interp_qlpc, exc, st->subframeSize, st->lpcSize, st->mem_sp2, stack);
597 /* Compute energy of low-band and high-band excitation */
598
599 eh = compute_rms16(exc, st->subframeSize);
600
601 if (!SUBMODE(innovation_quant)) {/* 1 for spectral folding excitation, 0 for stochastic */
602 spx_word32_t g; /*Q7*/
603 spx_word16_t el; /*Q0*/
604 el = low_innov_rms[sub];
605
606 /* Gain to use if we want to use the low-band excitation for high-band */
607 g=PDIV32(MULT16_16(filter_ratio,eh),EXTEND32(ADD16(1,el)));
608
609 #if 0
610 {
611 char *tmp_stack=stack;
612 float *tmp_sig;
613 float g2;
614 ALLOC(tmp_sig, st->subframeSize, spx_sig_t);
615 for (i=0;i<st->lpcSize;i++)
616 mem[i]=st->mem_sp[i];
617 iir_mem2(st->low_innov+offset, st->interp_qlpc, tmp_sig, st->subframeSize, st->lpcSize, mem);
618 g2 = compute_rms(sp, st->subframeSize)/(.01+compute_rms(tmp_sig, st->subframeSize));
619 /*fprintf (stderr, "gains: %f %f\n", g, g2);*/
620 g = g2;
621 stack = tmp_stack;
622 }
623 #endif
624
625 /*print_vec(&g, 1, "gain factor");*/
626 /* Gain quantization */
627 {
628 int quant = scal_quant(g, fold_quant_bound, 32);
629 /*speex_warning_int("tata", quant);*/
630 if (quant<0)
631 quant=0;
632 if (quant>31)
633 quant=31;
634 speex_bits_pack(bits, quant, 5);
635 }
636 if (st->innov_rms_save)
637 {
638 st->innov_rms_save[sub] = eh;
639 }
640 st->exc_rms[sub] = eh;
641 } else {
642 spx_word16_t gc; /*Q7*/
643 spx_word32_t scale; /*Q14*/
644 spx_word16_t el; /*Q0*/
645 el = low_exc_rms[sub]; /*Q0*/
646
647 gc = PDIV32_16(MULT16_16(filter_ratio,1+eh),1+el);
648
649 /* This is a kludge that cleans up a historical bug */
650 if (st->subframeSize==80)
651 gc = MULT16_16_P15(QCONST16(0.70711f,15),gc);
652 /*printf ("%f %f %f %f\n", el, eh, filter_ratio, gc);*/
653 {
654 int qgc = scal_quant(gc, gc_quant_bound, 16);
655 speex_bits_pack(bits, qgc, 4);
656 gc = MULT16_16_Q15(QCONST16(0.87360,15),gc_quant_bound[qgc]);
657 }
658 if (st->subframeSize==80)
659 gc = MULT16_16_P14(QCONST16(1.4142f,14), gc);
660
661 scale = SHL32(MULT16_16(PDIV32_16(SHL32(EXTEND32(gc),SIG_SHIFT-6),filter_ratio),(1+el)),6);
662
663 compute_impulse_response(st->interp_qlpc, bw_lpc1, bw_lpc2, syn_resp, st->subframeSize, st->lpcSize, stack);
664
665
666 /* Reset excitation */
667 for (i=0;i<st->subframeSize;i++)
668 res[i]=VERY_SMALL;
669
670 /* Compute zero response (ringing) of A(z/g1) / ( A(z/g2) * Aq(z) ) */
671 for (i=0;i<st->lpcSize;i++)
672 mem[i]=st->mem_sp[i];
673 iir_mem16(res, st->interp_qlpc, res, st->subframeSize, st->lpcSize, mem, stack);
674
675 for (i=0;i<st->lpcSize;i++)
676 mem[i]=st->mem_sw[i];
677 filter_mem16(res, bw_lpc1, bw_lpc2, res, st->subframeSize, st->lpcSize, mem, stack);
678
679 /* Compute weighted signal */
680 for (i=0;i<st->lpcSize;i++)
681 mem[i]=st->mem_sw[i];
682 filter_mem16(sp, bw_lpc1, bw_lpc2, sw, st->subframeSize, st->lpcSize, mem, stack);
683
684 /* Compute target signal */
685 for (i=0;i<st->subframeSize;i++)
686 target[i]=SUB16(sw[i],res[i]);
687
688 signal_div(target, target, scale, st->subframeSize);
689
690 /* Reset excitation */
691 SPEEX_MEMSET(innov, 0, st->subframeSize);
692
693 /*print_vec(target, st->subframeSize, "\ntarget");*/
694 SUBMODE(innovation_quant)(target, st->interp_qlpc, bw_lpc1, bw_lpc2,
695 SUBMODE(innovation_params), st->lpcSize, st->subframeSize,
696 innov, syn_resp, bits, stack, st->complexity, SUBMODE(double_codebook));
697 /*print_vec(target, st->subframeSize, "after");*/
698
699 signal_mul(innov, innov, scale, st->subframeSize);
700
701 if (SUBMODE(double_codebook)) {
702 char *tmp_stack=stack;
703 VARDECL(spx_sig_t *innov2);
704 ALLOC(innov2, st->subframeSize, spx_sig_t);
705 SPEEX_MEMSET(innov2, 0, st->subframeSize);
706 for (i=0;i<st->subframeSize;i++)
707 target[i]=MULT16_16_P13(QCONST16(2.5f,13), target[i]);
708
709 SUBMODE(innovation_quant)(target, st->interp_qlpc, bw_lpc1, bw_lpc2,
710 SUBMODE(innovation_params), st->lpcSize, st->subframeSize,
711 innov2, syn_resp, bits, stack, st->complexity, 0);
712 signal_mul(innov2, innov2, MULT16_32_P15(QCONST16(0.4f,15),scale), st->subframeSize);
713
714 for (i=0;i<st->subframeSize;i++)
715 innov[i] = ADD32(innov[i],innov2[i]);
716 stack = tmp_stack;
717 }
718 for (i=0;i<st->subframeSize;i++)
719 exc[i] = PSHR32(innov[i],SIG_SHIFT);
720
721 if (st->innov_rms_save)
722 {
723 st->innov_rms_save[sub] = MULT16_16_Q15(QCONST16(.70711f, 15), compute_rms(innov, st->subframeSize));
724 }
725 st->exc_rms[sub] = compute_rms16(exc, st->subframeSize);
726
727
728 }
729
730
731 /*Keep the previous memory*/
732 for (i=0;i<st->lpcSize;i++)
733 mem[i]=st->mem_sp[i];
734 /* Final signal synthesis from excitation */
735 iir_mem16(exc, st->interp_qlpc, sp, st->subframeSize, st->lpcSize, st->mem_sp, stack);
736
737 /* Compute weighted signal again, from synthesized speech (not sure it's the right thing) */
738 filter_mem16(sp, bw_lpc1, bw_lpc2, sw, st->subframeSize, st->lpcSize, st->mem_sw, stack);
739 }
740
741 for (i=0;i<st->lpcSize;i++)
742 st->old_lsp[i] = lsp[i];
743 for (i=0;i<st->lpcSize;i++)
744 st->old_qlsp[i] = qlsp[i];
745
746 st->first=0;
747
748 return 1;
749 }
750
751
752
753
754
755 void *sb_decoder_init(const SpeexMode *m)
756 {
757 spx_int32_t tmp;
758 SBDecState *st;
759 const SpeexSBMode *mode;
760 st = (SBDecState*)speex_alloc(sizeof(SBDecState));
761 if (!st)
762 return NULL;
763 st->mode = m;
764 mode=(const SpeexSBMode*)m->mode;
765 st->encode_submode = 1;
766
767 st->st_low = speex_decoder_init(mode->nb_mode);
768 #if defined(VAR_ARRAYS) || defined (USE_ALLOCA)
769 st->stack = NULL;
770 #else
771 /*st->stack = (char*)speex_alloc_scratch(SB_DEC_STACK);*/
772 speex_decoder_ctl(st->st_low, SPEEX_GET_STACK, &st->stack);
773 #endif
774
775 st->full_frame_size = 2*mode->frameSize;
776 st->frame_size = mode->frameSize;
777 st->subframeSize = mode->subframeSize;
778 st->nbSubframes = mode->frameSize/mode->subframeSize;
779 st->lpcSize=mode->lpcSize;
780 speex_decoder_ctl(st->st_low, SPEEX_GET_SAMPLING_RATE, &st->sampling_rate);
781 st->sampling_rate*=2;
782 tmp=1;
783 speex_decoder_ctl(st->st_low, SPEEX_SET_WIDEBAND, &tmp);
784
785 st->submodes=mode->submodes;
786 st->submodeID=mode->defaultSubmode;
787
788 st->first=1;
789
790 st->g0_mem = (spx_word16_t*)speex_alloc((QMF_ORDER)*sizeof(spx_word16_t));
791 st->g1_mem = (spx_word16_t*)speex_alloc((QMF_ORDER)*sizeof(spx_word16_t));
792
793 st->excBuf = (spx_word16_t*)speex_alloc((st->subframeSize)*sizeof(spx_word16_t));
794
795 st->old_qlsp = (spx_lsp_t*)speex_alloc((st->lpcSize)*sizeof(spx_lsp_t));
796 st->interp_qlpc = (spx_coef_t*)speex_alloc(st->lpcSize*sizeof(spx_coef_t));
797
798 st->pi_gain = (spx_word32_t*)speex_alloc((st->nbSubframes)*sizeof(spx_word32_t));
799 st->exc_rms = (spx_word16_t*)speex_alloc((st->nbSubframes)*sizeof(spx_word16_t));
800 st->mem_sp = (spx_mem_t*)speex_alloc((2*st->lpcSize)*sizeof(spx_mem_t));
801
802 st->innov_save = NULL;
803
804
805 st->lpc_enh_enabled=0;
806 st->seed = 1000;
807
808 #ifdef ENABLE_VALGRIND
809 VALGRIND_MAKE_READABLE(st, (st->stack-(char*)st));
810 #endif
811 return st;
812 }
813
814 void sb_decoder_destroy(void *state)
815 {
816 SBDecState *st;
817 st = (SBDecState*)state;
818 speex_decoder_destroy(st->st_low);
819 #if !(defined(VAR_ARRAYS) || defined (USE_ALLOCA))
820 /*speex_free_scratch(st->stack);*/
821 #endif
822
823 speex_free(st->g0_mem);
824 speex_free(st->g1_mem);
825 speex_free(st->excBuf);
826 speex_free(st->old_qlsp);
827 speex_free(st->interp_qlpc);
828 speex_free(st->pi_gain);
829 speex_free(st->exc_rms);
830 speex_free(st->mem_sp);
831
832 speex_free(state);
833 }
834
835 static void sb_decode_lost(SBDecState *st, spx_word16_t *out, int dtx, char *stack)
836 {
837 int i;
838 int saved_modeid=0;
839
840 if (dtx)
841 {
842 saved_modeid=st->submodeID;
843 st->submodeID=1;
844 } else {
845 bw_lpc(QCONST16(0.99f,15), st->interp_qlpc, st->interp_qlpc, st->lpcSize);
846 }
847
848 st->first=1;
849
850
851 /* Final signal synthesis from excitation */
852 if (!dtx)
853 {
854 st->last_ener = MULT16_16_Q15(QCONST16(.9f,15),st->last_ener);
855 }
856 for (i=0;i<st->frame_size;i++)
857 out[i+st->frame_size] = speex_rand(st->last_ener, &st->seed);
858
859 iir_mem16(out+st->frame_size, st->interp_qlpc, out+st->frame_size, st->frame_size, st->lpcSize,
860 st->mem_sp, stack);
861
862
863 /* Reconstruct the original */
864 qmf_synth(out, out+st->frame_size, h0, out, st->full_frame_size, QMF_ORDER, st->g0_mem, st->g1_mem, stack);
865 if (dtx)
866 {
867 st->submodeID=saved_modeid;
868 }
869
870 return;
871 }
872
873 int sb_decode(void *state, SpeexBits *bits, void *vout)
874 {
875 int i, sub;
876 SBDecState *st;
877 int wideband;
878 int ret;
879 char *stack;
880 VARDECL(spx_word32_t *low_pi_gain);
881 VARDECL(spx_word16_t *low_exc_rms);
882 VARDECL(spx_coef_t *ak);
883 VARDECL(spx_lsp_t *qlsp);
884 VARDECL(spx_lsp_t *interp_qlsp);
885 spx_int32_t dtx;
886 const SpeexSBMode *mode;
887 spx_word16_t *out = (spx_word16_t*)vout;
888 spx_word16_t *low_innov_alias;
889 spx_word32_t exc_ener_sum = 0;
890
891 st = (SBDecState*)state;
892 stack=st->stack;
893 mode = (const SpeexSBMode*)(st->mode->mode);
894
895 low_innov_alias = out+st->frame_size;
896 speex_decoder_ctl(st->st_low, SPEEX_SET_INNOVATION_SAVE, low_innov_alias);
897 /* Decode the low-band */
898 ret = speex_decode_native(st->st_low, bits, out);
899
900 speex_decoder_ctl(st->st_low, SPEEX_GET_DTX_STATUS, &dtx);
901
902 /* If error decoding the narrowband part, propagate error */
903 if (ret!=0)
904 {
905 return ret;
906 }
907
908 if (!bits)
909 {
910 sb_decode_lost(st, out, dtx, stack);
911 return 0;
912 }
913
914 if (st->encode_submode)
915 {
916
917 /*Check "wideband bit"*/
918 if (speex_bits_remaining(bits)>0)
919 wideband = speex_bits_peek(bits);
920 else
921 wideband = 0;
922 if (wideband)
923 {
924 /*Regular wideband frame, read the submode*/
925 wideband = speex_bits_unpack_unsigned(bits, 1);
926 st->submodeID = speex_bits_unpack_unsigned(bits, SB_SUBMODE_BITS);
927 } else
928 {
929 /*Was a narrowband frame, set "null submode"*/
930 st->submodeID = 0;
931 }
932 if (st->submodeID != 0 && st->submodes[st->submodeID] == NULL)
933 {
934 speex_notify("Invalid mode encountered. The stream is corrupted.");
935 return -2;
936 }
937 }
938
939 /* If null mode (no transmission), just set a couple things to zero*/
940 if (st->submodes[st->submodeID] == NULL)
941 {
942 if (dtx)
943 {
944 sb_decode_lost(st, out, 1, stack);
945 return 0;
946 }
947
948 for (i=0;i<st->frame_size;i++)
949 out[st->frame_size+i]=VERY_SMALL;
950
951 st->first=1;
952
953 /* Final signal synthesis from excitation */
954 iir_mem16(out+st->frame_size, st->interp_qlpc, out+st->frame_size, st->frame_size, st->lpcSize, st->mem_sp, stack);
955
956 qmf_synth(out, out+st->frame_size, h0, out, st->full_frame_size, QMF_ORDER, st->g0_mem, st->g1_mem, stack);
957
958 return 0;
959
960 }
961
962 ALLOC(low_pi_gain, st->nbSubframes, spx_word32_t);
963 ALLOC(low_exc_rms, st->nbSubframes, spx_word16_t);
964 speex_decoder_ctl(st->st_low, SPEEX_GET_PI_GAIN, low_pi_gain);
965 speex_decoder_ctl(st->st_low, SPEEX_GET_EXC, low_exc_rms);
966
967 ALLOC(qlsp, st->lpcSize, spx_lsp_t);
968 ALLOC(interp_qlsp, st->lpcSize, spx_lsp_t);
969 SUBMODE(lsp_unquant)(qlsp, st->lpcSize, bits);
970
971 if (st->first)
972 {
973 for (i=0;i<st->lpcSize;i++)
974 st->old_qlsp[i] = qlsp[i];
975 }
976
977 ALLOC(ak, st->lpcSize, spx_coef_t);
978
979 for (sub=0;sub<st->nbSubframes;sub++)
980 {
981 VARDECL(spx_word32_t *exc);
982 spx_word16_t *innov_save=NULL;
983 spx_word16_t *sp;
984 spx_word16_t filter_ratio;
985 spx_word16_t el=0;
986 int offset;
987 spx_word32_t rl=0,rh=0;
988
989 offset = st->subframeSize*sub;
990 sp=out+st->frame_size+offset;
991 ALLOC(exc, st->subframeSize, spx_word32_t);
992 /* Pointer for saving innovation */
993 if (st->innov_save)
994 {
995 innov_save = st->innov_save+2*offset;
996 SPEEX_MEMSET(innov_save, 0, 2*st->subframeSize);
997 }
998
999 /* LSP interpolation */
1000 lsp_interpolate(st->old_qlsp, qlsp, interp_qlsp, st->lpcSize, sub, st->nbSubframes);
1001
1002 lsp_enforce_margin(interp_qlsp, st->lpcSize, LSP_MARGIN);
1003
1004 /* LSP to LPC */
1005 lsp_to_lpc(interp_qlsp, ak, st->lpcSize, stack);
1006
1007 /* Calculate reponse ratio between the low and high filter in the middle
1008 of the band (4000 Hz) */
1009
1010 st->pi_gain[sub]=LPC_SCALING;
1011 rh = LPC_SCALING;
1012 for (i=0;i<st->lpcSize;i+=2)
1013 {
1014 rh += ak[i+1] - ak[i];
1015 st->pi_gain[sub] += ak[i] + ak[i+1];
1016 }
1017
1018 rl = low_pi_gain[sub];
1019 #ifdef FIXED_POINT
1020 filter_ratio=EXTRACT16(SATURATE(PDIV32(SHL32(ADD32(rl,82),7),ADD32(82,rh)),32767));
1021 #else
1022 filter_ratio=(rl+.01)/(rh+.01);
1023 #endif
1024
1025 SPEEX_MEMSET(exc, 0, st->subframeSize);
1026 if (!SUBMODE(innovation_unquant))
1027 {
1028 spx_word32_t g;
1029 int quant;
1030
1031 quant = speex_bits_unpack_unsigned(bits, 5);
1032 g= spx_exp(MULT16_16(QCONST16(.125f,11),(quant-10)));
1033
1034 g = PDIV32(g, filter_ratio);
1035
1036 for (i=0;i<st->subframeSize;i+=2)
1037 {
1038 exc[i]=SHL32(MULT16_32_P15(MULT16_16_Q15(mode->folding_gain,low_innov_alias[offset+i]),SHL32(g,6)),SIG_SHIFT);
1039 exc[i+1]=NEG32(SHL32(MULT16_32_P15(MULT16_16_Q15(mode->folding_gain,low_innov_alias[offset+i+1]),SHL32(g,6)),SIG_SHIFT));
1040 }
1041
1042 } else {
1043 spx_word16_t gc;
1044 spx_word32_t scale;
1045 int qgc = speex_bits_unpack_unsigned(bits, 4);
1046
1047 el = low_exc_rms[sub];
1048 gc = MULT16_16_Q15(QCONST16(0.87360,15),gc_quant_bound[qgc]);
1049
1050 if (st->subframeSize==80)
1051 gc = MULT16_16_P14(QCONST16(1.4142f,14),gc);
1052
1053 scale = SHL32(PDIV32(SHL32(MULT16_16(gc, el),3), filter_ratio),SIG_SHIFT-3);
1054 SUBMODE(innovation_unquant)(exc, SUBMODE(innovation_params), st->subframeSize,
1055 bits, stack, &st->seed);
1056
1057 signal_mul(exc,exc,scale,st->subframeSize);
1058
1059 if (SUBMODE(double_codebook)) {
1060 char *tmp_stack=stack;
1061 VARDECL(spx_sig_t *innov2);
1062 ALLOC(innov2, st->subframeSize, spx_sig_t);
1063 SPEEX_MEMSET(innov2, 0, st->subframeSize);
1064 SUBMODE(innovation_unquant)(innov2, SUBMODE(innovation_params), st->subframeSize,
1065 bits, stack, &st->seed);
1066 signal_mul(innov2, innov2, MULT16_32_P15(QCONST16(0.4f,15),scale), st->subframeSize);
1067 for (i=0;i<st->subframeSize;i++)
1068 exc[i] = ADD32(exc[i],innov2[i]);
1069 stack = tmp_stack;
1070 }
1071
1072 }
1073
1074 if (st->innov_save)
1075 {
1076 for (i=0;i<st->subframeSize;i++)
1077 innov_save[2*i]=EXTRACT16(PSHR32(exc[i],SIG_SHIFT));
1078 }
1079
1080 iir_mem16(st->excBuf, st->interp_qlpc, sp, st->subframeSize, st->lpcSize,
1081 st->mem_sp, stack);
1082 for (i=0;i<st->subframeSize;i++)
1083 st->excBuf[i]=EXTRACT16(PSHR32(exc[i],SIG_SHIFT));
1084 for (i=0;i<st->lpcSize;i++)
1085 st->interp_qlpc[i] = ak[i];
1086 st->exc_rms[sub] = compute_rms16(st->excBuf, st->subframeSize);
1087 exc_ener_sum = ADD32(exc_ener_sum, DIV32(MULT16_16(st->exc_rms[sub],st->exc_rms[sub]), st->nbSubframes));
1088 }
1089 st->last_ener = spx_sqrt(exc_ener_sum);
1090
1091 qmf_synth(out, out+st->frame_size, h0, out, st->full_frame_size, QMF_ORDER, st->g0_mem, st->g1_mem, stack);
1092 for (i=0;i<st->lpcSize;i++)
1093 st->old_qlsp[i] = qlsp[i];
1094
1095 st->first=0;
1096
1097 return 0;
1098 }
1099
1100
1101 int sb_encoder_ctl(void *state, int request, void *ptr)
1102 {
1103 SBEncState *st;
1104 st=(SBEncState*)state;
1105 switch(request)
1106 {
1107 case SPEEX_GET_FRAME_SIZE:
1108 (*(spx_int32_t*)ptr) = st->full_frame_size;
1109 break;
1110 case SPEEX_SET_HIGH_MODE:
1111 st->submodeSelect = st->submodeID = (*(spx_int32_t*)ptr);
1112 break;
1113 case SPEEX_SET_LOW_MODE:
1114 speex_encoder_ctl(st->st_low, SPEEX_SET_LOW_MODE, ptr);
1115 break;
1116 case SPEEX_SET_DTX:
1117 speex_encoder_ctl(st->st_low, SPEEX_SET_DTX, ptr);
1118 break;
1119 case SPEEX_GET_DTX:
1120 speex_encoder_ctl(st->st_low, SPEEX_GET_DTX, ptr);
1121 break;
1122 case SPEEX_GET_LOW_MODE:
1123 speex_encoder_ctl(st->st_low, SPEEX_GET_LOW_MODE, ptr);
1124 break;
1125 case SPEEX_SET_MODE:
1126 speex_encoder_ctl(st, SPEEX_SET_QUALITY, ptr);
1127 break;
1128 #ifndef DISABLE_VBR
1129 case SPEEX_SET_VBR:
1130 st->vbr_enabled = (*(spx_int32_t*)ptr);
1131 speex_encoder_ctl(st->st_low, SPEEX_SET_VBR, ptr);
1132 break;
1133 case SPEEX_GET_VBR:
1134 (*(spx_int32_t*)ptr) = st->vbr_enabled;
1135 break;
1136 case SPEEX_SET_VAD:
1137 st->vad_enabled = (*(spx_int32_t*)ptr);
1138 speex_encoder_ctl(st->st_low, SPEEX_SET_VAD, ptr);
1139 break;
1140 case SPEEX_GET_VAD:
1141 (*(spx_int32_t*)ptr) = st->vad_enabled;
1142 break;
1143 #endif /* #ifndef DISABLE_VBR */
1144 #if !defined(DISABLE_VBR) && !defined(DISABLE_FLOAT_API)
1145 case SPEEX_SET_VBR_QUALITY:
1146 {
1147 spx_int32_t q;
1148 float qual = (*(float*)ptr)+.6;
1149 st->vbr_quality = (*(float*)ptr);
1150 if (qual>10)
1151 qual=10;
1152 q=(int)floor(.5+*(float*)ptr);
1153 if (q>10)
1154 q=10;
1155 speex_encoder_ctl(st->st_low, SPEEX_SET_VBR_QUALITY, &qual);
1156 speex_encoder_ctl(state, SPEEX_SET_QUALITY, &q);
1157 break;
1158 }
1159 case SPEEX_GET_VBR_QUALITY:
1160 (*(float*)ptr) = st->vbr_quality;
1161 break;
1162 #endif /* #if !defined(DISABLE_VBR) && !defined(DISABLE_FLOAT_API) */
1163 #ifndef DISABLE_VBR
1164 case SPEEX_SET_ABR:
1165 st->abr_enabled = (*(spx_int32_t*)ptr);
1166 st->vbr_enabled = st->abr_enabled!=0;
1167 speex_encoder_ctl(st->st_low, SPEEX_SET_VBR, &st->vbr_enabled);
1168 if (st->vbr_enabled)
1169 {
1170 spx_int32_t i=10, rate, target;
1171 float vbr_qual;
1172 target = (*(spx_int32_t*)ptr);
1173 while (i>=0)
1174 {
1175 speex_encoder_ctl(st, SPEEX_SET_QUALITY, &i);
1176 speex_encoder_ctl(st, SPEEX_GET_BITRATE, &rate);
1177 if (rate <= target)
1178 break;
1179 i--;
1180 }
1181 vbr_qual=i;
1182 if (vbr_qual<0)
1183 vbr_qual=0;
1184 speex_encoder_ctl(st, SPEEX_SET_VBR_QUALITY, &vbr_qual);
1185 st->abr_count=0;
1186 st->abr_drift=0;
1187 st->abr_drift2=0;
1188 }
1189
1190 break;
1191 case SPEEX_GET_ABR:
1192 (*(spx_int32_t*)ptr) = st->abr_enabled;
1193 break;
1194 #endif /* #ifndef DISABLE_VBR */
1195
1196 case SPEEX_SET_QUALITY:
1197 {
1198 spx_int32_t nb_qual;
1199 int quality = (*(spx_int32_t*)ptr);
1200 if (quality < 0)
1201 quality = 0;
1202 if (quality > 10)
1203 quality = 10;
1204 st->submodeSelect = st->submodeID = ((const SpeexSBMode*)(st->mode->mode))->quality_map[quality];
1205 nb_qual = ((const SpeexSBMode*)(st->mode->mode))->low_quality_map[quality];
1206 speex_encoder_ctl(st->st_low, SPEEX_SET_MODE, &nb_qual);
1207 }
1208 break;
1209 case SPEEX_SET_COMPLEXITY:
1210 speex_encoder_ctl(st->st_low, SPEEX_SET_COMPLEXITY, ptr);
1211 st->complexity = (*(spx_int32_t*)ptr);
1212 if (st->complexity<1)
1213 st->complexity=1;
1214 break;
1215 case SPEEX_GET_COMPLEXITY:
1216 (*(spx_int32_t*)ptr) = st->complexity;
1217 break;
1218 case SPEEX_SET_BITRATE:
1219 {
1220 spx_int32_t i=10;
1221 spx_int32_t rate, target;
1222 target = (*(spx_int32_t*)ptr);
1223 while (i>=0)
1224 {
1225 speex_encoder_ctl(st, SPEEX_SET_QUALITY, &i);
1226 speex_encoder_ctl(st, SPEEX_GET_BITRATE, &rate);
1227 if (rate <= target)
1228 break;
1229 i--;
1230 }
1231 }
1232 break;
1233 case SPEEX_GET_BITRATE:
1234 speex_encoder_ctl(st->st_low, request, ptr);
1235 /*fprintf (stderr, "before: %d\n", (*(int*)ptr));*/
1236 if (st->submodes[st->submodeID])
1237 (*(spx_int32_t*)ptr) += st->sampling_rate*SUBMODE(bits_per_frame)/st->full_frame_size;
1238 else
1239 (*(spx_int32_t*)ptr) += st->sampling_rate*(SB_SUBMODE_BITS+1)/st->full_frame_size;
1240 /*fprintf (stderr, "after: %d\n", (*(int*)ptr));*/
1241 break;
1242 case SPEEX_SET_SAMPLING_RATE:
1243 {
1244 spx_int32_t tmp=(*(spx_int32_t*)ptr);
1245 st->sampling_rate = tmp;
1246 tmp>>=1;
1247 speex_encoder_ctl(st->st_low, SPEEX_SET_SAMPLING_RATE, &tmp);
1248 }
1249 break;
1250 case SPEEX_GET_SAMPLING_RATE:
1251 (*(spx_int32_t*)ptr)=st->sampling_rate;
1252 break;
1253 case SPEEX_RESET_STATE:
1254 {
1255 int i;
1256 st->first = 1;
1257 for (i=0;i<st->lpcSize;i++)
1258 st->old_lsp[i]= DIV32(MULT16_16(QCONST16(3.1415927f, LSP_SHIFT), i+1), st->lpcSize+1);
1259 for (i=0;i<st->lpcSize;i++)
1260 st->mem_sw[i]=st->mem_sp[i]=st->mem_sp2[i]=0;
1261 for (i=0;i<QMF_ORDER;i++)
1262 st->h0_mem[i]=st->h1_mem[i]=0;
1263 }
1264 break;
1265 case SPEEX_SET_SUBMODE_ENCODING:
1266 st->encode_submode = (*(spx_int32_t*)ptr);
1267 speex_encoder_ctl(st->st_low, SPEEX_SET_SUBMODE_ENCODING, ptr);
1268 break;
1269 case SPEEX_GET_SUBMODE_ENCODING:
1270 (*(spx_int32_t*)ptr) = st->encode_submode;
1271 break;
1272 case SPEEX_GET_LOOKAHEAD:
1273 speex_encoder_ctl(st->st_low, SPEEX_GET_LOOKAHEAD, ptr);
1274 (*(spx_int32_t*)ptr) = 2*(*(spx_int32_t*)ptr) + QMF_ORDER - 1;
1275 break;
1276 case SPEEX_SET_PLC_TUNING:
1277 speex_encoder_ctl(st->st_low, SPEEX_SET_PLC_TUNING, ptr);
1278 break;
1279 case SPEEX_GET_PLC_TUNING:
1280 speex_encoder_ctl(st->st_low, SPEEX_GET_PLC_TUNING, ptr);
1281 break;
1282 #ifndef DISABLE_VBR
1283 case SPEEX_SET_VBR_MAX_BITRATE:
1284 {
1285 st->vbr_max = (*(spx_int32_t*)ptr);
1286 if (SPEEX_SET_VBR_MAX_BITRATE<1)
1287 {
1288 speex_encoder_ctl(st->st_low, SPEEX_SET_VBR_MAX_BITRATE, &st->vbr_max);
1289 st->vbr_max_high = 17600;
1290 } else {
1291 spx_int32_t low_rate;
1292 if (st->vbr_max >= 42200)
1293 {
1294 st->vbr_max_high = 17600;
1295 } else if (st->vbr_max >= 27800)
1296 {
1297 st->vbr_max_high = 9600;
1298 } else if (st->vbr_max > 20600)
1299 {
1300 st->vbr_max_high = 5600;
1301 } else {
1302 st->vbr_max_high = 1800;
1303 }
1304 if (st->subframeSize==80)
1305 st->vbr_max_high = 1800;
1306 low_rate = st->vbr_max - st->vbr_max_high;
1307 speex_encoder_ctl(st->st_low, SPEEX_SET_VBR_MAX_BITRATE, &low_rate);
1308 }
1309 }
1310 break;
1311 case SPEEX_GET_VBR_MAX_BITRATE:
1312 (*(spx_int32_t*)ptr) = st->vbr_max;
1313 break;
1314 #endif /* #ifndef DISABLE_VBR */
1315 case SPEEX_SET_HIGHPASS:
1316 speex_encoder_ctl(st->st_low, SPEEX_SET_HIGHPASS, ptr);
1317 break;
1318 case SPEEX_GET_HIGHPASS:
1319 speex_encoder_ctl(st->st_low, SPEEX_GET_HIGHPASS, ptr);
1320 break;
1321
1322
1323 /* This is all internal stuff past this point */
1324 case SPEEX_GET_PI_GAIN:
1325 {
1326 int i;
1327 spx_word32_t *g = (spx_word32_t*)ptr;
1328 for (i=0;i<st->nbSubframes;i++)
1329 g[i]=st->pi_gain[i];
1330 }
1331 break;
1332 case SPEEX_GET_EXC:
1333 {
1334 int i;
1335 for (i=0;i<st->nbSubframes;i++)
1336 ((spx_word16_t*)ptr)[i] = st->exc_rms[i];
1337 }
1338 break;
1339 #ifndef DISABLE_VBR
1340 case SPEEX_GET_RELATIVE_QUALITY:
1341 (*(float*)ptr)=st->relative_quality;
1342 break;
1343 #endif /* #ifndef DISABLE_VBR */
1344 case SPEEX_SET_INNOVATION_SAVE:
1345 st->innov_rms_save = (spx_word16_t*)ptr;
1346 break;
1347 case SPEEX_SET_WIDEBAND:
1348 speex_encoder_ctl(st->st_low, SPEEX_SET_WIDEBAND, ptr);
1349 break;
1350 case SPEEX_GET_STACK:
1351 *((char**)ptr) = st->stack;
1352 break;
1353 default:
1354 speex_warning_int("Unknown nb_ctl request: ", request);
1355 return -1;
1356 }
1357 return 0;
1358 }
1359
1360 int sb_decoder_ctl(void *state, int request, void *ptr)
1361 {
1362 SBDecState *st;
1363 st=(SBDecState*)state;
1364 switch(request)
1365 {
1366 case SPEEX_SET_HIGH_MODE:
1367 st->submodeID = (*(spx_int32_t*)ptr);
1368 break;
1369 case SPEEX_SET_LOW_MODE:
1370 speex_decoder_ctl(st->st_low, SPEEX_SET_LOW_MODE, ptr);
1371 break;
1372 case SPEEX_GET_LOW_MODE:
1373 speex_decoder_ctl(st->st_low, SPEEX_GET_LOW_MODE, ptr);
1374 break;
1375 case SPEEX_GET_FRAME_SIZE:
1376 (*(spx_int32_t*)ptr) = st->full_frame_size;
1377 break;
1378 case SPEEX_SET_ENH:
1379 speex_decoder_ctl(st->st_low, request, ptr);
1380 st->lpc_enh_enabled = *((spx_int32_t*)ptr);
1381 break;
1382 case SPEEX_GET_ENH:
1383 *((spx_int32_t*)ptr) = st->lpc_enh_enabled;
1384 break;
1385 case SPEEX_SET_MODE:
1386 case SPEEX_SET_QUALITY:
1387 {
1388 spx_int32_t nb_qual;
1389 int quality = (*(spx_int32_t*)ptr);
1390 if (quality < 0)
1391 quality = 0;
1392 if (quality > 10)
1393 quality = 10;
1394 st->submodeID = ((const SpeexSBMode*)(st->mode->mode))->quality_map[quality];
1395 nb_qual = ((const SpeexSBMode*)(st->mode->mode))->low_quality_map[quality];
1396 speex_decoder_ctl(st->st_low, SPEEX_SET_MODE, &nb_qual);
1397 }
1398 break;
1399 case SPEEX_GET_BITRATE:
1400 speex_decoder_ctl(st->st_low, request, ptr);
1401 if (st->submodes[st->submodeID])
1402 (*(spx_int32_t*)ptr) += st->sampling_rate*SUBMODE(bits_per_frame)/st->full_frame_size;
1403 else
1404 (*(spx_int32_t*)ptr) += st->sampling_rate*(SB_SUBMODE_BITS+1)/st->full_frame_size;
1405 break;
1406 case SPEEX_SET_SAMPLING_RATE:
1407 {
1408 spx_int32_t tmp=(*(spx_int32_t*)ptr);
1409 st->sampling_rate = tmp;
1410 tmp>>=1;
1411 speex_decoder_ctl(st->st_low, SPEEX_SET_SAMPLING_RATE, &tmp);
1412 }
1413 break;
1414 case SPEEX_GET_SAMPLING_RATE:
1415 (*(spx_int32_t*)ptr)=st->sampling_rate;
1416 break;
1417 case SPEEX_SET_HANDLER:
1418 speex_decoder_ctl(st->st_low, SPEEX_SET_HANDLER, ptr);
1419 break;
1420 case SPEEX_SET_USER_HANDLER:
1421 speex_decoder_ctl(st->st_low, SPEEX_SET_USER_HANDLER, ptr);
1422 break;
1423 case SPEEX_RESET_STATE:
1424 {
1425 int i;
1426 for (i=0;i<2*st->lpcSize;i++)
1427 st->mem_sp[i]=0;
1428 for (i=0;i<QMF_ORDER;i++)
1429 st->g0_mem[i]=st->g1_mem[i]=0;
1430 st->last_ener=0;
1431 }
1432 break;
1433 case SPEEX_SET_SUBMODE_ENCODING:
1434 st->encode_submode = (*(spx_int32_t*)ptr);
1435 speex_decoder_ctl(st->st_low, SPEEX_SET_SUBMODE_ENCODING, ptr);
1436 break;
1437 case SPEEX_GET_SUBMODE_ENCODING:
1438 (*(spx_int32_t*)ptr) = st->encode_submode;
1439 break;
1440 case SPEEX_GET_LOOKAHEAD:
1441 speex_decoder_ctl(st->st_low, SPEEX_GET_LOOKAHEAD, ptr);
1442 (*(spx_int32_t*)ptr) = 2*(*(spx_int32_t*)ptr);
1443 break;
1444 case SPEEX_SET_HIGHPASS:
1445 speex_decoder_ctl(st->st_low, SPEEX_SET_HIGHPASS, ptr);
1446 break;
1447 case SPEEX_GET_HIGHPASS:
1448 speex_decoder_ctl(st->st_low, SPEEX_GET_HIGHPASS, ptr);
1449 break;
1450 case SPEEX_GET_ACTIVITY:
1451 speex_decoder_ctl(st->st_low, SPEEX_GET_ACTIVITY, ptr);
1452 break;
1453 case SPEEX_GET_PI_GAIN:
1454 {
1455 int i;
1456 spx_word32_t *g = (spx_word32_t*)ptr;
1457 for (i=0;i<st->nbSubframes;i++)
1458 g[i]=st->pi_gain[i];
1459 }
1460 break;
1461 case SPEEX_GET_EXC:
1462 {
1463 int i;
1464 for (i=0;i<st->nbSubframes;i++)
1465 ((spx_word16_t*)ptr)[i] = st->exc_rms[i];
1466 }
1467 break;
1468 case SPEEX_GET_DTX_STATUS:
1469 speex_decoder_ctl(st->st_low, SPEEX_GET_DTX_STATUS, ptr);
1470 break;
1471 case SPEEX_SET_INNOVATION_SAVE:
1472 st->innov_save = (spx_word16_t*)ptr;
1473 break;
1474 case SPEEX_SET_WIDEBAND:
1475 speex_decoder_ctl(st->st_low, SPEEX_SET_WIDEBAND, ptr);
1476 break;
1477 case SPEEX_GET_STACK:
1478 *((char**)ptr) = st->stack;
1479 break;
1480 default:
1481 speex_warning_int("Unknown nb_ctl request: ", request);
1482 return -1;
1483 }
1484 return 0;
1485 }
1486
1487 #endif
1488