FFmpeg
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
speexdec.c
Go to the documentation of this file.
1 /*
2  * Copyright 2002-2008 Xiph.org Foundation
3  * Copyright 2002-2008 Jean-Marc Valin
4  * Copyright 2005-2007 Analog Devices Inc.
5  * Copyright 2005-2008 Commonwealth Scientific and Industrial Research Organisation (CSIRO)
6  * Copyright 1993, 2002, 2006 David Rowe
7  * Copyright 2003 EpicGames
8  * Copyright 1992-1994 Jutta Degener, Carsten Bormann
9 
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13 
14  * - Redistributions of source code must retain the above copyright
15  * notice, this list of conditions and the following disclaimer.
16 
17  * - Redistributions in binary form must reproduce the above copyright
18  * notice, this list of conditions and the following disclaimer in the
19  * documentation and/or other materials provided with the distribution.
20 
21  * - Neither the name of the Xiph.org Foundation nor the names of its
22  * contributors may be used to endorse or promote products derived from
23  * this software without specific prior written permission.
24 
25  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
26  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
27  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
28  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR
29  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
30  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
31  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
32  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
33  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
34  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
35  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36  *
37  * This file is part of FFmpeg.
38  *
39  * FFmpeg is free software; you can redistribute it and/or
40  * modify it under the terms of the GNU Lesser General Public
41  * License as published by the Free Software Foundation; either
42  * version 2.1 of the License, or (at your option) any later version.
43  *
44  * FFmpeg is distributed in the hope that it will be useful,
45  * but WITHOUT ANY WARRANTY; without even the implied warranty of
46  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
47  * Lesser General Public License for more details.
48  *
49  * You should have received a copy of the GNU Lesser General Public
50  * License along with FFmpeg; if not, write to the Free Software
51  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
52  */
53 
54 #include "libavutil/avassert.h"
55 #include "libavutil/avstring.h"
56 #include "libavutil/float_dsp.h"
57 #include "libavutil/intfloat.h"
58 #include "libavutil/mem.h"
59 #include "avcodec.h"
60 #include "bytestream.h"
61 #include "codec_internal.h"
62 #include "decode.h"
63 #include "get_bits.h"
64 #include "speexdata.h"
65 
66 #define SPEEX_NB_MODES 3
67 #define SPEEX_INBAND_STEREO 9
68 
69 #define QMF_ORDER 64
70 #define NB_ORDER 10
71 #define NB_FRAME_SIZE 160
72 #define NB_SUBMODES 9
73 #define NB_SUBMODE_BITS 4
74 #define SB_SUBMODE_BITS 3
75 
76 #define NB_SUBFRAME_SIZE 40
77 #define NB_NB_SUBFRAMES 4
78 #define NB_PITCH_START 17
79 #define NB_PITCH_END 144
80 
81 #define NB_DEC_BUFFER (NB_FRAME_SIZE + 2 * NB_PITCH_END + NB_SUBFRAME_SIZE + 12)
82 
83 #define SPEEX_MEMSET(dst, c, n) (memset((dst), (c), (n) * sizeof(*(dst))))
84 #define SPEEX_COPY(dst, src, n) (memcpy((dst), (src), (n) * sizeof(*(dst))))
85 
86 #define LSP_LINEAR(i) (.25f * (i) + .25f)
87 #define LSP_LINEAR_HIGH(i) (.3125f * (i) + .75f)
88 #define LSP_DIV_256(x) (0.00390625f * (x))
89 #define LSP_DIV_512(x) (0.001953125f * (x))
90 #define LSP_DIV_1024(x) (0.0009765625f * (x))
91 
92 typedef struct LtpParams {
93  const int8_t *gain_cdbk;
94  int gain_bits;
96 } LtpParam;
97 
98 static const LtpParam ltp_params_vlbr = { gain_cdbk_lbr, 5, 0 };
99 static const LtpParam ltp_params_lbr = { gain_cdbk_lbr, 5, 7 };
100 static const LtpParam ltp_params_med = { gain_cdbk_lbr, 5, 7 };
101 static const LtpParam ltp_params_nb = { gain_cdbk_nb, 7, 7 };
102 
103 typedef struct SplitCodebookParams {
106  const signed char *shape_cb;
110 
111 static const SplitCodebookParams split_cb_nb_ulbr = { 20, 2, exc_20_32_table, 5, 0 };
112 static const SplitCodebookParams split_cb_nb_vlbr = { 10, 4, exc_10_16_table, 4, 0 };
113 static const SplitCodebookParams split_cb_nb_lbr = { 10, 4, exc_10_32_table, 5, 0 };
114 static const SplitCodebookParams split_cb_nb_med = { 8, 5, exc_8_128_table, 7, 0 };
115 static const SplitCodebookParams split_cb_nb = { 5, 8, exc_5_64_table, 6, 0 };
116 static const SplitCodebookParams split_cb_sb = { 5, 8, exc_5_256_table, 8, 0 };
117 static const SplitCodebookParams split_cb_high = { 8, 5, hexc_table, 7, 1 };
119 
120 /** Quantizes LSPs */
121 typedef void (*lsp_quant_func)(float *, float *, int, GetBitContext *);
122 
123 /** Decodes quantized LSPs */
124 typedef void (*lsp_unquant_func)(float *, int, GetBitContext *);
125 
126 /** Long-term predictor quantization */
127 typedef int (*ltp_quant_func)(float *, float *, float *,
128  float *, float *, float *,
129  const void *, int, int, float, int, int,
130  GetBitContext *, char *, float *,
131  float *, int, int, int, float *);
132 
133 /** Long-term un-quantize */
134 typedef void (*ltp_unquant_func)(float *, float *, int, int,
135  float, const void *, int, int *,
136  float *, GetBitContext *, int, int,
137  float, int);
138 
139 /** Innovation quantization function */
140 typedef void (*innovation_quant_func)(float *, float *,
141  float *, float *, const void *,
142  int, int, float *, float *,
143  GetBitContext *, char *, int, int);
144 
145 /** Innovation unquantization function */
146 typedef void (*innovation_unquant_func)(float *, const void *, int,
147  GetBitContext *, uint32_t *);
148 
149 typedef struct SpeexSubmode {
150  int lbr_pitch; /**< Set to -1 for "normal" modes, otherwise encode pitch using
151  a global pitch and allowing a +- lbr_pitch variation (for
152  low not-rates)*/
153  int forced_pitch_gain; /**< Use the same (forced) pitch gain for all
154  sub-frames */
155  int have_subframe_gain; /**< Number of bits to use as sub-frame innovation
156  gain */
157  int double_codebook; /**< Apply innovation quantization twice for higher
158  quality (and higher bit-rate)*/
159  lsp_unquant_func lsp_unquant; /**< LSP unquantization function */
160 
161  ltp_unquant_func ltp_unquant; /**< Long-term predictor (pitch) un-quantizer */
162  const void *LtpParam; /**< Pitch parameters (options) */
163 
164  innovation_unquant_func innovation_unquant; /**< Innovation un-quantization */
165  const void *innovation_params; /**< Innovation quantization parameters*/
166 
167  float comb_gain; /**< Gain of enhancer comb filter */
168 } SpeexSubmode;
169 
170 typedef struct SpeexMode {
171  int modeID; /**< ID of the mode */
172  int (*decode)(AVCodecContext *avctx, void *dec, GetBitContext *gb, float *out);
173  int frame_size; /**< Size of frames used for decoding */
174  int subframe_size; /**< Size of sub-frames used for decoding */
175  int lpc_size; /**< Order of LPC filter */
176  float folding_gain; /**< Folding gain */
177  const SpeexSubmode *submodes[NB_SUBMODES]; /**< Sub-mode data for the mode */
178  int default_submode; /**< Default sub-mode to use when decoding */
179 } SpeexMode;
180 
181 typedef struct DecoderState {
182  const SpeexMode *mode;
183  int modeID; /**< ID of the decoder mode */
184  int first; /**< Is first frame */
185  int full_frame_size; /**< Length of full-band frames */
186  int is_wideband; /**< If wideband is present */
187  int count_lost; /**< Was the last frame lost? */
188  int frame_size; /**< Length of high-band frames */
189  int subframe_size; /**< Length of high-band sub-frames */
190  int nb_subframes; /**< Number of high-band sub-frames */
191  int lpc_size; /**< Order of high-band LPC analysis */
192  float last_ol_gain; /**< Open-loop gain for previous frame */
193  float *innov_save; /**< If non-NULL, innovation is copied here */
194 
195  /* This is used in packet loss concealment */
196  int last_pitch; /**< Pitch of last correctly decoded frame */
197  float last_pitch_gain; /**< Pitch gain of last correctly decoded frame */
198  uint32_t seed; /**< Seed used for random number generation */
199 
201  const SpeexSubmode *const *submodes; /**< Sub-mode data */
202  int submodeID; /**< Activated sub-mode */
203  int lpc_enh_enabled; /**< 1 when LPC enhancer is on, 0 otherwise */
204 
205  /* Vocoder data */
206  float voc_m1;
207  float voc_m2;
208  float voc_mean;
210 
212  int highpass_enabled; /**< Is the input filter enabled */
213 
214  float *exc; /**< Start of excitation frame */
215  float mem_hp[2]; /**< High-pass filter memory */
216  float exc_buf[NB_DEC_BUFFER]; /**< Excitation buffer */
217  float old_qlsp[NB_ORDER]; /**< Quantized LSPs for previous frame */
218  float interp_qlpc[NB_ORDER]; /**< Interpolated quantized LPCs */
219  float mem_sp[NB_ORDER]; /**< Filter memory for synthesis signal */
222  float pi_gain[NB_NB_SUBFRAMES]; /**< Gain of LPC filter at theta=pi (fe/2) */
223  float exc_rms[NB_NB_SUBFRAMES]; /**< RMS of excitation per subframe */
224 } DecoderState;
225 
226 /* Default handler for user callbacks: skip it */
227 static int speex_default_user_handler(GetBitContext *gb, void *state, void *data)
228 {
229  const int req_size = get_bits(gb, 4);
230  skip_bits_long(gb, 5 + 8 * req_size);
231  return 0;
232 }
233 
234 typedef struct StereoState {
235  float balance; /**< Left/right balance info */
236  float e_ratio; /**< Ratio of energies: E(left+right)/[E(left)+E(right)] */
237  float smooth_left; /**< Smoothed left channel gain */
238  float smooth_right; /**< Smoothed right channel gain */
239 } StereoState;
240 
241 typedef struct SpeexContext {
242  AVClass *class;
244 
245  int32_t version_id; /**< Version for Speex (for checking compatibility) */
246  int32_t rate; /**< Sampling rate used */
247  int32_t mode; /**< Mode used (0 for narrowband, 1 for wideband) */
248  int32_t bitstream_version; /**< Version ID of the bit-stream */
249  int32_t nb_channels; /**< Number of channels decoded */
250  int32_t bitrate; /**< Bit-rate used */
251  int32_t frame_size; /**< Size of frames */
252  int32_t vbr; /**< 1 for a VBR decoding, 0 otherwise */
253  int32_t frames_per_packet; /**< Number of frames stored per Ogg packet */
254  int32_t extra_headers; /**< Number of additional headers after the comments */
255 
256  int pkt_size;
257 
260 
262 } SpeexContext;
263 
264 static void lsp_unquant_lbr(float *lsp, int order, GetBitContext *gb)
265 {
266  int id;
267 
268  for (int i = 0; i < order; i++)
269  lsp[i] = LSP_LINEAR(i);
270 
271  id = get_bits(gb, 6);
272  for (int i = 0; i < 10; i++)
273  lsp[i] += LSP_DIV_256(cdbk_nb[id * 10 + i]);
274 
275  id = get_bits(gb, 6);
276  for (int i = 0; i < 5; i++)
277  lsp[i] += LSP_DIV_512(cdbk_nb_low1[id * 5 + i]);
278 
279  id = get_bits(gb, 6);
280  for (int i = 0; i < 5; i++)
281  lsp[i + 5] += LSP_DIV_512(cdbk_nb_high1[id * 5 + i]);
282 }
283 
284 static void forced_pitch_unquant(float *exc, float *exc_out, int start, int end,
285  float pitch_coef, const void *par, int nsf,
286  int *pitch_val, float *gain_val, GetBitContext *gb, int count_lost,
287  int subframe_offset, float last_pitch_gain, int cdbk_offset)
288 {
289  av_assert0(!isnan(pitch_coef));
290  pitch_coef = fminf(pitch_coef, .99f);
291  for (int i = 0; i < nsf; i++) {
292  exc_out[i] = exc[i - start] * pitch_coef;
293  exc[i] = exc_out[i];
294  }
295  pitch_val[0] = start;
296  gain_val[0] = gain_val[2] = 0.f;
297  gain_val[1] = pitch_coef;
298 }
299 
300 static inline float speex_rand(float std, uint32_t *seed)
301 {
302  const uint32_t jflone = 0x3f800000;
303  const uint32_t jflmsk = 0x007fffff;
304  float fran;
305  uint32_t ran;
306  seed[0] = 1664525 * seed[0] + 1013904223;
307  ran = jflone | (jflmsk & seed[0]);
308  fran = av_int2float(ran);
309  fran -= 1.5f;
310  fran *= std;
311  return fran;
312 }
313 
314 static void noise_codebook_unquant(float *exc, const void *par, int nsf,
315  GetBitContext *gb, uint32_t *seed)
316 {
317  for (int i = 0; i < nsf; i++)
318  exc[i] = speex_rand(1.f, seed);
319 }
320 
321 static void split_cb_shape_sign_unquant(float *exc, const void *par, int nsf,
322  GetBitContext *gb, uint32_t *seed)
323 {
324  int subvect_size, nb_subvect, have_sign, shape_bits;
325  const SplitCodebookParams *params;
326  const signed char *shape_cb;
327  int signs[10], ind[10];
328 
329  params = par;
330  subvect_size = params->subvect_size;
331  nb_subvect = params->nb_subvect;
332 
333  shape_cb = params->shape_cb;
334  have_sign = params->have_sign;
335  shape_bits = params->shape_bits;
336 
337  /* Decode codewords and gains */
338  for (int i = 0; i < nb_subvect; i++) {
339  signs[i] = have_sign ? get_bits1(gb) : 0;
340  ind[i] = get_bitsz(gb, shape_bits);
341  }
342  /* Compute decoded excitation */
343  for (int i = 0; i < nb_subvect; i++) {
344  const float s = signs[i] ? -1.f : 1.f;
345 
346  for (int j = 0; j < subvect_size; j++)
347  exc[subvect_size * i + j] += s * 0.03125f * shape_cb[ind[i] * subvect_size + j];
348  }
349 }
350 
351 #define SUBMODE(x) st->submodes[st->submodeID]->x
352 
353 #define gain_3tap_to_1tap(g) (FFABS(g[1]) + (g[0] > 0.f ? g[0] : -.5f * g[0]) + (g[2] > 0.f ? g[2] : -.5f * g[2]))
354 
355 static void
356 pitch_unquant_3tap(float *exc, float *exc_out, int start, int end, float pitch_coef,
357  const void *par, int nsf, int *pitch_val, float *gain_val, GetBitContext *gb,
358  int count_lost, int subframe_offset, float last_pitch_gain, int cdbk_offset)
359 {
360  int pitch, gain_index, gain_cdbk_size;
361  const int8_t *gain_cdbk;
362  const LtpParam *params;
363  float gain[3];
364 
365  params = (const LtpParam *)par;
366  gain_cdbk_size = 1 << params->gain_bits;
367  gain_cdbk = params->gain_cdbk + 4 * gain_cdbk_size * cdbk_offset;
368 
369  pitch = get_bitsz(gb, params->pitch_bits);
370  pitch += start;
371  gain_index = get_bitsz(gb, params->gain_bits);
372  gain[0] = 0.015625f * gain_cdbk[gain_index * 4] + .5f;
373  gain[1] = 0.015625f * gain_cdbk[gain_index * 4 + 1] + .5f;
374  gain[2] = 0.015625f * gain_cdbk[gain_index * 4 + 2] + .5f;
375 
376  if (count_lost && pitch > subframe_offset) {
377  float tmp = count_lost < 4 ? last_pitch_gain : 0.5f * last_pitch_gain;
378  float gain_sum;
379 
380  tmp = fminf(tmp, .95f);
381  gain_sum = gain_3tap_to_1tap(gain);
382 
383  if (gain_sum > tmp && gain_sum > 0.f) {
384  float fact = tmp / gain_sum;
385  for (int i = 0; i < 3; i++)
386  gain[i] *= fact;
387  }
388  }
389 
390  pitch_val[0] = pitch;
391  gain_val[0] = gain[0];
392  gain_val[1] = gain[1];
393  gain_val[2] = gain[2];
394  SPEEX_MEMSET(exc_out, 0, nsf);
395 
396  for (int i = 0; i < 3; i++) {
397  int tmp1, tmp3;
398  int pp = pitch + 1 - i;
399  tmp1 = nsf;
400  if (tmp1 > pp)
401  tmp1 = pp;
402  for (int j = 0; j < tmp1; j++)
403  exc_out[j] += gain[2 - i] * exc[j - pp];
404  tmp3 = nsf;
405  if (tmp3 > pp + pitch)
406  tmp3 = pp + pitch;
407  for (int j = tmp1; j < tmp3; j++)
408  exc_out[j] += gain[2 - i] * exc[j - pp - pitch];
409  }
410 }
411 
412 static void lsp_unquant_nb(float *lsp, int order, GetBitContext *gb)
413 {
414  int id;
415 
416  for (int i = 0; i < order; i++)
417  lsp[i] = LSP_LINEAR(i);
418 
419  id = get_bits(gb, 6);
420  for (int i = 0; i < 10; i++)
421  lsp[i] += LSP_DIV_256(cdbk_nb[id * 10 + i]);
422 
423  id = get_bits(gb, 6);
424  for (int i = 0; i < 5; i++)
425  lsp[i] += LSP_DIV_512(cdbk_nb_low1[id * 5 + i]);
426 
427  id = get_bits(gb, 6);
428  for (int i = 0; i < 5; i++)
429  lsp[i] += LSP_DIV_1024(cdbk_nb_low2[id * 5 + i]);
430 
431  id = get_bits(gb, 6);
432  for (int i = 0; i < 5; i++)
433  lsp[i + 5] += LSP_DIV_512(cdbk_nb_high1[id * 5 + i]);
434 
435  id = get_bits(gb, 6);
436  for (int i = 0; i < 5; i++)
437  lsp[i + 5] += LSP_DIV_1024(cdbk_nb_high2[id * 5 + i]);
438 }
439 
440 static void lsp_unquant_high(float *lsp, int order, GetBitContext *gb)
441 {
442  int id;
443 
444  for (int i = 0; i < order; i++)
445  lsp[i] = LSP_LINEAR_HIGH(i);
446 
447  id = get_bits(gb, 6);
448  for (int i = 0; i < order; i++)
449  lsp[i] += LSP_DIV_256(high_lsp_cdbk[id * order + i]);
450 
451  id = get_bits(gb, 6);
452  for (int i = 0; i < order; i++)
453  lsp[i] += LSP_DIV_512(high_lsp_cdbk2[id * order + i]);
454 }
455 
456 /* 2150 bps "vocoder-like" mode for comfort noise */
457 static const SpeexSubmode nb_submode1 = {
460 };
461 
462 /* 5.95 kbps very low bit-rate mode */
463 static const SpeexSubmode nb_submode2 = {
466 };
467 
468 /* 8 kbps low bit-rate mode */
469 static const SpeexSubmode nb_submode3 = {
472 };
473 
474 /* 11 kbps medium bit-rate mode */
475 static const SpeexSubmode nb_submode4 = {
478 };
479 
480 /* 15 kbps high bit-rate mode */
481 static const SpeexSubmode nb_submode5 = {
484 };
485 
486 /* 18.2 high bit-rate mode */
487 static const SpeexSubmode nb_submode6 = {
490 };
491 
492 /* 24.6 kbps high bit-rate mode */
493 static const SpeexSubmode nb_submode7 = {
496 };
497 
498 /* 3.95 kbps very low bit-rate mode */
499 static const SpeexSubmode nb_submode8 = {
502 };
503 
504 static const SpeexSubmode wb_submode1 = {
505  0, 0, 1, 0, lsp_unquant_high, NULL, NULL,
506  NULL, NULL, -1.f
507 };
508 
509 static const SpeexSubmode wb_submode2 = {
510  0, 0, 1, 0, lsp_unquant_high, NULL, NULL,
512 };
513 
514 static const SpeexSubmode wb_submode3 = {
515  0, 0, 1, 0, lsp_unquant_high, NULL, NULL,
517 };
518 
519 static const SpeexSubmode wb_submode4 = {
520  0, 0, 1, 1, lsp_unquant_high, NULL, NULL,
522 };
523 
524 static int nb_decode(AVCodecContext *, void *, GetBitContext *, float *);
525 static int sb_decode(AVCodecContext *, void *, GetBitContext *, float *);
526 
528  {
529  .modeID = 0,
530  .decode = nb_decode,
531  .frame_size = NB_FRAME_SIZE,
532  .subframe_size = NB_SUBFRAME_SIZE,
533  .lpc_size = NB_ORDER,
534  .submodes = {
537  },
538  .default_submode = 5,
539  },
540  {
541  .modeID = 1,
542  .decode = sb_decode,
543  .frame_size = NB_FRAME_SIZE,
544  .subframe_size = NB_SUBFRAME_SIZE,
545  .lpc_size = 8,
546  .folding_gain = 0.9f,
547  .submodes = {
549  },
550  .default_submode = 3,
551  },
552  {
553  .modeID = 2,
554  .decode = sb_decode,
555  .frame_size = 320,
556  .subframe_size = 80,
557  .lpc_size = 8,
558  .folding_gain = 0.7f,
559  .submodes = {
560  NULL, &wb_submode1
561  },
562  .default_submode = 1,
563  },
564 };
565 
566 static float compute_rms(const float *x, int len)
567 {
568  float sum = 0.f;
569 
570  for (int i = 0; i < len; i++)
571  sum += x[i] * x[i];
572 
573  av_assert0(len > 0);
574  return sqrtf(.1f + sum / len);
575 }
576 
577 static void bw_lpc(float gamma, const float *lpc_in,
578  float *lpc_out, int order)
579 {
580  float tmp = gamma;
581 
582  for (int i = 0; i < order; i++) {
583  lpc_out[i] = tmp * lpc_in[i];
584  tmp *= gamma;
585  }
586 }
587 
588 static void iir_mem(const float *x, const float *den,
589  float *y, int N, int ord, float *mem)
590 {
591  for (int i = 0; i < N; i++) {
592  float yi = x[i] + mem[0];
593  float nyi = -yi;
594  for (int j = 0; j < ord - 1; j++)
595  mem[j] = mem[j + 1] + den[j] * nyi;
596  mem[ord - 1] = den[ord - 1] * nyi;
597  y[i] = yi;
598  }
599 }
600 
601 static void highpass(const float *x, float *y, int len, float *mem, int wide)
602 {
603  static const float Pcoef[2][3] = {{ 1.00000f, -1.92683f, 0.93071f }, { 1.00000f, -1.97226f, 0.97332f } };
604  static const float Zcoef[2][3] = {{ 0.96446f, -1.92879f, 0.96446f }, { 0.98645f, -1.97277f, 0.98645f } };
605  const float *den, *num;
606 
607  den = Pcoef[wide];
608  num = Zcoef[wide];
609  for (int i = 0; i < len; i++) {
610  float yi = num[0] * x[i] + mem[0];
611  mem[0] = mem[1] + num[1] * x[i] + -den[1] * yi;
612  mem[1] = num[2] * x[i] + -den[2] * yi;
613  y[i] = yi;
614  }
615 }
616 
617 #define median3(a, b, c) \
618  ((a) < (b) ? ((b) < (c) ? (b) : ((a) < (c) ? (c) : (a))) \
619  : ((c) < (b) ? (b) : ((c) < (a) ? (c) : (a))))
620 
621 static int speex_std_stereo(GetBitContext *gb, void *state, void *data)
622 {
623  StereoState *stereo = data;
624  float sign = get_bits1(gb) ? -1.f : 1.f;
625 
626  stereo->balance = exp(sign * .25f * get_bits(gb, 5));
627  stereo->e_ratio = e_ratio_quant[get_bits(gb, 2)];
628 
629  return 0;
630 }
631 
632 static int speex_inband_handler(GetBitContext *gb, void *state, StereoState *stereo)
633 {
634  int id = get_bits(gb, 4);
635 
636  if (id == SPEEX_INBAND_STEREO) {
637  return speex_std_stereo(gb, state, stereo);
638  } else {
639  int adv;
640 
641  if (id < 2)
642  adv = 1;
643  else if (id < 8)
644  adv = 4;
645  else if (id < 10)
646  adv = 8;
647  else if (id < 12)
648  adv = 16;
649  else if (id < 14)
650  adv = 32;
651  else
652  adv = 64;
653  skip_bits_long(gb, adv);
654  }
655  return 0;
656 }
657 
658 static void sanitize_values(float *vec, float min_val, float max_val, int len)
659 {
660  for (int i = 0; i < len; i++) {
661  if (!isnormal(vec[i]) || fabsf(vec[i]) < 1e-8f)
662  vec[i] = 0.f;
663  else
664  vec[i] = av_clipf(vec[i], min_val, max_val);
665  }
666 }
667 
668 static void signal_mul(const float *x, float *y, float scale, int len)
669 {
670  for (int i = 0; i < len; i++)
671  y[i] = scale * x[i];
672 }
673 
674 static float inner_prod(const float *x, const float *y, int len)
675 {
676  float sum = 0.f;
677 
678  for (int i = 0; i < len; i += 8) {
679  float part = 0.f;
680  part += x[i + 0] * y[i + 0];
681  part += x[i + 1] * y[i + 1];
682  part += x[i + 2] * y[i + 2];
683  part += x[i + 3] * y[i + 3];
684  part += x[i + 4] * y[i + 4];
685  part += x[i + 5] * y[i + 5];
686  part += x[i + 6] * y[i + 6];
687  part += x[i + 7] * y[i + 7];
688  sum += part;
689  }
690 
691  return sum;
692 }
693 
694 static int interp_pitch(const float *exc, float *interp, int pitch, int len)
695 {
696  float corr[4][7], maxcorr;
697  int maxi, maxj;
698 
699  for (int i = 0; i < 7; i++)
700  corr[0][i] = inner_prod(exc, exc - pitch - 3 + i, len);
701  for (int i = 0; i < 3; i++) {
702  for (int j = 0; j < 7; j++) {
703  int i1, i2;
704  float tmp = 0.f;
705 
706  i1 = 3 - j;
707  if (i1 < 0)
708  i1 = 0;
709  i2 = 10 - j;
710  if (i2 > 7)
711  i2 = 7;
712  for (int k = i1; k < i2; k++)
713  tmp += shift_filt[i][k] * corr[0][j + k - 3];
714  corr[i + 1][j] = tmp;
715  }
716  }
717  maxi = maxj = 0;
718  maxcorr = corr[0][0];
719  for (int i = 0; i < 4; i++) {
720  for (int j = 0; j < 7; j++) {
721  if (corr[i][j] > maxcorr) {
722  maxcorr = corr[i][j];
723  maxi = i;
724  maxj = j;
725  }
726  }
727  }
728  for (int i = 0; i < len; i++) {
729  float tmp = 0.f;
730  if (maxi > 0.f) {
731  for (int k = 0; k < 7; k++)
732  tmp += exc[i - (pitch - maxj + 3) + k - 3] * shift_filt[maxi - 1][k];
733  } else {
734  tmp = exc[i - (pitch - maxj + 3)];
735  }
736  interp[i] = tmp;
737  }
738  return pitch - maxj + 3;
739 }
740 
741 static void multicomb(const float *exc, float *new_exc, float *ak, int p, int nsf,
742  int pitch, int max_pitch, float comb_gain)
743 {
744  float old_ener, new_ener;
745  float iexc0_mag, iexc1_mag, exc_mag;
746  float iexc[4 * NB_SUBFRAME_SIZE];
747  float corr0, corr1, gain0, gain1;
748  float pgain1, pgain2;
749  float c1, c2, g1, g2;
750  float ngain, gg1, gg2;
751  int corr_pitch = pitch;
752 
753  interp_pitch(exc, iexc, corr_pitch, 80);
754  if (corr_pitch > max_pitch)
755  interp_pitch(exc, iexc + nsf, 2 * corr_pitch, 80);
756  else
757  interp_pitch(exc, iexc + nsf, -corr_pitch, 80);
758 
759  iexc0_mag = sqrtf(1000.f + inner_prod(iexc, iexc, nsf));
760  iexc1_mag = sqrtf(1000.f + inner_prod(iexc + nsf, iexc + nsf, nsf));
761  exc_mag = sqrtf(1.f + inner_prod(exc, exc, nsf));
762  corr0 = inner_prod(iexc, exc, nsf);
763  corr1 = inner_prod(iexc + nsf, exc, nsf);
764  if (corr0 > iexc0_mag * exc_mag)
765  pgain1 = 1.f;
766  else
767  pgain1 = (corr0 / exc_mag) / iexc0_mag;
768  if (corr1 > iexc1_mag * exc_mag)
769  pgain2 = 1.f;
770  else
771  pgain2 = (corr1 / exc_mag) / iexc1_mag;
772  gg1 = exc_mag / iexc0_mag;
773  gg2 = exc_mag / iexc1_mag;
774  if (comb_gain > 0.f) {
775  c1 = .4f * comb_gain + .07f;
776  c2 = .5f + 1.72f * (c1 - .07f);
777  } else {
778  c1 = c2 = 0.f;
779  }
780  g1 = 1.f - c2 * pgain1 * pgain1;
781  g2 = 1.f - c2 * pgain2 * pgain2;
782  g1 = fmaxf(g1, c1);
783  g2 = fmaxf(g2, c1);
784  g1 = c1 / g1;
785  g2 = c1 / g2;
786 
787  if (corr_pitch > max_pitch) {
788  gain0 = .7f * g1 * gg1;
789  gain1 = .3f * g2 * gg2;
790  } else {
791  gain0 = .6f * g1 * gg1;
792  gain1 = .6f * g2 * gg2;
793  }
794  for (int i = 0; i < nsf; i++)
795  new_exc[i] = exc[i] + (gain0 * iexc[i]) + (gain1 * iexc[i + nsf]);
796  new_ener = compute_rms(new_exc, nsf);
797  old_ener = compute_rms(exc, nsf);
798 
799  old_ener = fmaxf(old_ener, 1.f);
800  new_ener = fmaxf(new_ener, 1.f);
801  old_ener = fminf(old_ener, new_ener);
802  ngain = old_ener / new_ener;
803 
804  for (int i = 0; i < nsf; i++)
805  new_exc[i] *= ngain;
806 }
807 
808 static void lsp_interpolate(const float *old_lsp, const float *new_lsp,
809  float *lsp, int len, int subframe,
810  int nb_subframes, float margin)
811 {
812  const float tmp = (1.f + subframe) / nb_subframes;
813 
814  for (int i = 0; i < len; i++) {
815  lsp[i] = (1.f - tmp) * old_lsp[i] + tmp * new_lsp[i];
816  lsp[i] = av_clipf(lsp[i], margin, M_PI - margin);
817  }
818  for (int i = 1; i < len - 1; i++) {
819  lsp[i] = fmaxf(lsp[i], lsp[i - 1] + margin);
820  if (lsp[i] > lsp[i + 1] - margin)
821  lsp[i] = .5f * (lsp[i] + lsp[i + 1] - margin);
822  }
823 }
824 
825 static void lsp_to_lpc(const float *freq, float *ak, int lpcrdr)
826 {
827  float xout1, xout2, xin1, xin2;
828  float *pw, *n0;
829  float Wp[4 * NB_ORDER + 2] = { 0 };
830  float x_freq[NB_ORDER];
831  const int m = lpcrdr >> 1;
832 
833  pw = Wp;
834 
835  xin1 = xin2 = 1.f;
836 
837  for (int i = 0; i < lpcrdr; i++)
838  x_freq[i] = -cosf(freq[i]);
839 
840  /* reconstruct P(z) and Q(z) by cascading second order
841  * polynomials in form 1 - 2xz(-1) +z(-2), where x is the
842  * LSP coefficient
843  */
844  for (int j = 0; j <= lpcrdr; j++) {
845  int i2 = 0;
846  for (int i = 0; i < m; i++, i2 += 2) {
847  n0 = pw + (i * 4);
848  xout1 = xin1 + 2.f * x_freq[i2 ] * n0[0] + n0[1];
849  xout2 = xin2 + 2.f * x_freq[i2 + 1] * n0[2] + n0[3];
850  n0[1] = n0[0];
851  n0[3] = n0[2];
852  n0[0] = xin1;
853  n0[2] = xin2;
854  xin1 = xout1;
855  xin2 = xout2;
856  }
857  xout1 = xin1 + n0[4];
858  xout2 = xin2 - n0[5];
859  if (j > 0)
860  ak[j - 1] = (xout1 + xout2) * 0.5f;
861  n0[4] = xin1;
862  n0[5] = xin2;
863 
864  xin1 = 0.f;
865  xin2 = 0.f;
866  }
867 }
868 
869 static int nb_decode(AVCodecContext *avctx, void *ptr_st,
870  GetBitContext *gb, float *out)
871 {
872  DecoderState *st = ptr_st;
873  float ol_gain = 0, ol_pitch_coef = 0, best_pitch_gain = 0, pitch_average = 0;
874  int m, pitch, wideband, ol_pitch = 0, best_pitch = 40;
875  SpeexContext *s = avctx->priv_data;
876  float innov[NB_SUBFRAME_SIZE];
877  float exc32[NB_SUBFRAME_SIZE];
878  float interp_qlsp[NB_ORDER];
879  float qlsp[NB_ORDER];
880  float ak[NB_ORDER];
881  float pitch_gain[3] = { 0 };
882 
883  st->exc = st->exc_buf + 2 * NB_PITCH_END + NB_SUBFRAME_SIZE + 6;
884 
885  if (st->encode_submode) {
886  do { /* Search for next narrowband block (handle requests, skip wideband blocks) */
887  if (get_bits_left(gb) < 5)
888  return AVERROR_INVALIDDATA;
889  wideband = get_bits1(gb);
890  if (wideband) /* Skip wideband block (for compatibility) */ {
891  int submode, advance;
892 
893  submode = get_bits(gb, SB_SUBMODE_BITS);
894  advance = wb_skip_table[submode];
895  advance -= SB_SUBMODE_BITS + 1;
896  if (advance < 0)
897  return AVERROR_INVALIDDATA;
898  skip_bits_long(gb, advance);
899 
900  if (get_bits_left(gb) < 5)
901  return AVERROR_INVALIDDATA;
902  wideband = get_bits1(gb);
903  if (wideband) {
904  submode = get_bits(gb, SB_SUBMODE_BITS);
905  advance = wb_skip_table[submode];
906  advance -= SB_SUBMODE_BITS + 1;
907  if (advance < 0)
908  return AVERROR_INVALIDDATA;
909  skip_bits_long(gb, advance);
910  wideband = get_bits1(gb);
911  if (wideband) {
912  av_log(avctx, AV_LOG_ERROR, "more than two wideband layers found\n");
913  return AVERROR_INVALIDDATA;
914  }
915  }
916  }
917  if (get_bits_left(gb) < 4)
918  return AVERROR_INVALIDDATA;
919  m = get_bits(gb, 4);
920  if (m == 15) /* We found a terminator */ {
921  return AVERROR_INVALIDDATA;
922  } else if (m == 14) /* Speex in-band request */ {
923  int ret = speex_inband_handler(gb, st, &s->stereo);
924  if (ret)
925  return ret;
926  } else if (m == 13) /* User in-band request */ {
927  int ret = speex_default_user_handler(gb, st, NULL);
928  if (ret)
929  return ret;
930  } else if (m > 8) /* Invalid mode */ {
931  return AVERROR_INVALIDDATA;
932  }
933  } while (m > 8);
934 
935  st->submodeID = m; /* Get the sub-mode that was used */
936  }
937 
938  /* Shift all buffers by one frame */
939  memmove(st->exc_buf, st->exc_buf + NB_FRAME_SIZE, (2 * NB_PITCH_END + NB_SUBFRAME_SIZE + 12) * sizeof(float));
940 
941  /* If null mode (no transmission), just set a couple things to zero */
942  if (st->submodes[st->submodeID] == NULL) {
943  float lpc[NB_ORDER];
944  float innov_gain = 0.f;
945 
946  bw_lpc(0.93f, st->interp_qlpc, lpc, NB_ORDER);
947  innov_gain = compute_rms(st->exc, NB_FRAME_SIZE);
948  for (int i = 0; i < NB_FRAME_SIZE; i++)
949  st->exc[i] = speex_rand(innov_gain, &st->seed);
950 
951  /* Final signal synthesis from excitation */
952  iir_mem(st->exc, lpc, out, NB_FRAME_SIZE, NB_ORDER, st->mem_sp);
953  st->count_lost = 0;
954 
955  return 0;
956  }
957 
958  /* Unquantize LSPs */
959  SUBMODE(lsp_unquant)(qlsp, NB_ORDER, gb);
960 
961  /* Damp memory if a frame was lost and the LSP changed too much */
962  if (st->count_lost) {
963  float fact, lsp_dist = 0;
964 
965  for (int i = 0; i < NB_ORDER; i++)
966  lsp_dist = lsp_dist + FFABS(st->old_qlsp[i] - qlsp[i]);
967  fact = .6f * exp(-.2f * lsp_dist);
968  for (int i = 0; i < NB_ORDER; i++)
969  st->mem_sp[i] = fact * st->mem_sp[i];
970  }
971 
972  /* Handle first frame and lost-packet case */
973  if (st->first || st->count_lost)
974  memcpy(st->old_qlsp, qlsp, sizeof(st->old_qlsp));
975 
976  /* Get open-loop pitch estimation for low bit-rate pitch coding */
977  if (SUBMODE(lbr_pitch) != -1)
978  ol_pitch = NB_PITCH_START + get_bits(gb, 7);
979 
980  if (SUBMODE(forced_pitch_gain))
981  ol_pitch_coef = 0.066667f * get_bits(gb, 4);
982 
983  /* Get global excitation gain */
984  ol_gain = expf(get_bits(gb, 5) / 3.5f);
985 
986  if (st->submodeID == 1)
987  st->dtx_enabled = get_bits(gb, 4) == 15;
988 
989  if (st->submodeID > 1)
990  st->dtx_enabled = 0;
991 
992  for (int sub = 0; sub < NB_NB_SUBFRAMES; sub++) { /* Loop on subframes */
993  float *exc, *innov_save = NULL, tmp, ener;
994  int pit_min, pit_max, offset, q_energy;
995 
996  offset = NB_SUBFRAME_SIZE * sub; /* Offset relative to start of frame */
997  exc = st->exc + offset; /* Excitation */
998  if (st->innov_save) /* Original signal */
999  innov_save = st->innov_save + offset;
1000 
1001  SPEEX_MEMSET(exc, 0, NB_SUBFRAME_SIZE); /* Reset excitation */
1002 
1003  /* Adaptive codebook contribution */
1004  av_assert0(SUBMODE(ltp_unquant));
1005  /* Handle pitch constraints if any */
1006  if (SUBMODE(lbr_pitch) != -1) {
1007  int margin = SUBMODE(lbr_pitch);
1008 
1009  if (margin) {
1010  pit_min = ol_pitch - margin + 1;
1011  pit_min = FFMAX(pit_min, NB_PITCH_START);
1012  pit_max = ol_pitch + margin;
1013  pit_max = FFMIN(pit_max, NB_PITCH_START);
1014  } else {
1015  pit_min = pit_max = ol_pitch;
1016  }
1017  } else {
1018  pit_min = NB_PITCH_START;
1019  pit_max = NB_PITCH_END;
1020  }
1021 
1022  SUBMODE(ltp_unquant)(exc, exc32, pit_min, pit_max, ol_pitch_coef, SUBMODE(LtpParam),
1023  NB_SUBFRAME_SIZE, &pitch, pitch_gain, gb, st->count_lost, offset,
1024  st->last_pitch_gain, 0);
1025 
1026  sanitize_values(exc32, -32000, 32000, NB_SUBFRAME_SIZE);
1027 
1028  tmp = gain_3tap_to_1tap(pitch_gain);
1029 
1030  pitch_average += tmp;
1031  if ((tmp > best_pitch_gain &&
1032  FFABS(2 * best_pitch - pitch) >= 3 &&
1033  FFABS(3 * best_pitch - pitch) >= 4 &&
1034  FFABS(4 * best_pitch - pitch) >= 5) ||
1035  (tmp > .6f * best_pitch_gain &&
1036  (FFABS(best_pitch - 2 * pitch) < 3 ||
1037  FFABS(best_pitch - 3 * pitch) < 4 ||
1038  FFABS(best_pitch - 4 * pitch) < 5)) ||
1039  ((.67f * tmp) > best_pitch_gain &&
1040  (FFABS(2 * best_pitch - pitch) < 3 ||
1041  FFABS(3 * best_pitch - pitch) < 4 ||
1042  FFABS(4 * best_pitch - pitch) < 5))) {
1043  best_pitch = pitch;
1044  if (tmp > best_pitch_gain)
1045  best_pitch_gain = tmp;
1046  }
1047 
1048  memset(innov, 0, sizeof(innov));
1049 
1050  /* Decode sub-frame gain correction */
1051  if (SUBMODE(have_subframe_gain) == 3) {
1052  q_energy = get_bits(gb, 3);
1053  ener = exc_gain_quant_scal3[q_energy] * ol_gain;
1054  } else if (SUBMODE(have_subframe_gain) == 1) {
1055  q_energy = get_bits1(gb);
1056  ener = exc_gain_quant_scal1[q_energy] * ol_gain;
1057  } else {
1058  ener = ol_gain;
1059  }
1060 
1061  av_assert0(SUBMODE(innovation_unquant));
1062  /* Fixed codebook contribution */
1063  SUBMODE(innovation_unquant)(innov, SUBMODE(innovation_params), NB_SUBFRAME_SIZE, gb, &st->seed);
1064  /* De-normalize innovation and update excitation */
1065 
1066  signal_mul(innov, innov, ener, NB_SUBFRAME_SIZE);
1067 
1068  /* Decode second codebook (only for some modes) */
1069  if (SUBMODE(double_codebook)) {
1070  float innov2[NB_SUBFRAME_SIZE] = { 0 };
1071 
1072  SUBMODE(innovation_unquant)(innov2, SUBMODE(innovation_params), NB_SUBFRAME_SIZE, gb, &st->seed);
1073  signal_mul(innov2, innov2, 0.454545f * ener, NB_SUBFRAME_SIZE);
1074  for (int i = 0; i < NB_SUBFRAME_SIZE; i++)
1075  innov[i] += innov2[i];
1076  }
1077  for (int i = 0; i < NB_SUBFRAME_SIZE; i++)
1078  exc[i] = exc32[i] + innov[i];
1079  if (innov_save)
1080  memcpy(innov_save, innov, sizeof(innov));
1081 
1082  /* Vocoder mode */
1083  if (st->submodeID == 1) {
1084  float g = ol_pitch_coef;
1085 
1086  g = av_clipf(1.5f * (g - .2f), 0.f, 1.f);
1087 
1088  SPEEX_MEMSET(exc, 0, NB_SUBFRAME_SIZE);
1089  while (st->voc_offset < NB_SUBFRAME_SIZE) {
1090  if (st->voc_offset >= 0)
1091  exc[st->voc_offset] = sqrtf(2.f * ol_pitch) * (g * ol_gain);
1092  st->voc_offset += ol_pitch;
1093  }
1095 
1096  for (int i = 0; i < NB_SUBFRAME_SIZE; i++) {
1097  float exci = exc[i];
1098  exc[i] = (.7f * exc[i] + .3f * st->voc_m1) + ((1.f - .85f * g) * innov[i]) - .15f * g * st->voc_m2;
1099  st->voc_m1 = exci;
1100  st->voc_m2 = innov[i];
1101  st->voc_mean = .8f * st->voc_mean + .2f * exc[i];
1102  exc[i] -= st->voc_mean;
1103  }
1104  }
1105  }
1106 
1107  if (st->lpc_enh_enabled && SUBMODE(comb_gain) > 0 && !st->count_lost) {
1109  2 * NB_SUBFRAME_SIZE, best_pitch, 40, SUBMODE(comb_gain));
1111  st->interp_qlpc, NB_ORDER, 2 * NB_SUBFRAME_SIZE, best_pitch, 40,
1112  SUBMODE(comb_gain));
1113  } else {
1115  }
1116 
1117  /* If the last packet was lost, re-scale the excitation to obtain the same
1118  * energy as encoded in ol_gain */
1119  if (st->count_lost) {
1120  float exc_ener, gain;
1121 
1122  exc_ener = compute_rms(st->exc, NB_FRAME_SIZE);
1123  av_assert0(exc_ener + 1.f > 0.f);
1124  gain = fminf(ol_gain / (exc_ener + 1.f), 2.f);
1125  for (int i = 0; i < NB_FRAME_SIZE; i++) {
1126  st->exc[i] *= gain;
1127  out[i] = st->exc[i - NB_SUBFRAME_SIZE];
1128  }
1129  }
1130 
1131  for (int sub = 0; sub < NB_NB_SUBFRAMES; sub++) { /* Loop on subframes */
1132  const int offset = NB_SUBFRAME_SIZE * sub; /* Offset relative to start of frame */
1133  float pi_g = 1.f, *sp = out + offset; /* Original signal */
1134 
1135  lsp_interpolate(st->old_qlsp, qlsp, interp_qlsp, NB_ORDER, sub, NB_NB_SUBFRAMES, 0.002f);
1136  lsp_to_lpc(interp_qlsp, ak, NB_ORDER); /* Compute interpolated LPCs (unquantized) */
1137 
1138  for (int i = 0; i < NB_ORDER; i += 2) /* Compute analysis filter at w=pi */
1139  pi_g += ak[i + 1] - ak[i];
1140  st->pi_gain[sub] = pi_g;
1141  st->exc_rms[sub] = compute_rms(st->exc + offset, NB_SUBFRAME_SIZE);
1142 
1143  iir_mem(sp, st->interp_qlpc, sp, NB_SUBFRAME_SIZE, NB_ORDER, st->mem_sp);
1144 
1145  memcpy(st->interp_qlpc, ak, sizeof(st->interp_qlpc));
1146  }
1147 
1148  if (st->highpass_enabled)
1150 
1151  /* Store the LSPs for interpolation in the next frame */
1152  memcpy(st->old_qlsp, qlsp, sizeof(st->old_qlsp));
1153 
1154  st->count_lost = 0;
1155  st->last_pitch = best_pitch;
1156  st->last_pitch_gain = .25f * pitch_average;
1157  st->last_ol_gain = ol_gain;
1158  st->first = 0;
1159 
1160  return 0;
1161 }
1162 
1163 static void qmf_synth(const float *x1, const float *x2, const float *a, float *y, int N, int M, float *mem1, float *mem2)
1164 {
1165  const int M2 = M >> 1, N2 = N >> 1;
1166  float xx1[352], xx2[352];
1167 
1168  for (int i = 0; i < N2; i++)
1169  xx1[i] = x1[N2-1-i];
1170  for (int i = 0; i < M2; i++)
1171  xx1[N2+i] = mem1[2*i+1];
1172  for (int i = 0; i < N2; i++)
1173  xx2[i] = x2[N2-1-i];
1174  for (int i = 0; i < M2; i++)
1175  xx2[N2+i] = mem2[2*i+1];
1176 
1177  for (int i = 0; i < N2; i += 2) {
1178  float y0, y1, y2, y3;
1179  float x10, x20;
1180 
1181  y0 = y1 = y2 = y3 = 0.f;
1182  x10 = xx1[N2-2-i];
1183  x20 = xx2[N2-2-i];
1184 
1185  for (int j = 0; j < M2; j += 2) {
1186  float x11, x21;
1187  float a0, a1;
1188 
1189  a0 = a[2*j];
1190  a1 = a[2*j+1];
1191  x11 = xx1[N2-1+j-i];
1192  x21 = xx2[N2-1+j-i];
1193 
1194  y0 += a0 * (x11-x21);
1195  y1 += a1 * (x11+x21);
1196  y2 += a0 * (x10-x20);
1197  y3 += a1 * (x10+x20);
1198  a0 = a[2*j+2];
1199  a1 = a[2*j+3];
1200  x10 = xx1[N2+j-i];
1201  x20 = xx2[N2+j-i];
1202 
1203  y0 += a0 * (x10-x20);
1204  y1 += a1 * (x10+x20);
1205  y2 += a0 * (x11-x21);
1206  y3 += a1 * (x11+x21);
1207  }
1208  y[2 * i ] = 2.f * y0;
1209  y[2 * i+1] = 2.f * y1;
1210  y[2 * i+2] = 2.f * y2;
1211  y[2 * i+3] = 2.f * y3;
1212  }
1213 
1214  for (int i = 0; i < M2; i++)
1215  mem1[2*i+1] = xx1[i];
1216  for (int i = 0; i < M2; i++)
1217  mem2[2*i+1] = xx2[i];
1218 }
1219 
1220 static int sb_decode(AVCodecContext *avctx, void *ptr_st,
1221  GetBitContext *gb, float *out)
1222 {
1223  SpeexContext *s = avctx->priv_data;
1224  DecoderState *st = ptr_st;
1225  float low_pi_gain[NB_NB_SUBFRAMES];
1226  float low_exc_rms[NB_NB_SUBFRAMES];
1227  float interp_qlsp[NB_ORDER];
1228  int ret, wideband;
1229  float *low_innov_alias;
1230  float qlsp[NB_ORDER];
1231  float ak[NB_ORDER];
1232  const SpeexMode *mode;
1233 
1234  mode = st->mode;
1235 
1236  if (st->modeID > 0) {
1237  low_innov_alias = out + st->frame_size;
1238  s->st[st->modeID - 1].innov_save = low_innov_alias;
1239  ret = speex_modes[st->modeID - 1].decode(avctx, &s->st[st->modeID - 1], gb, out);
1240  if (ret < 0)
1241  return ret;
1242  }
1243 
1244  if (st->encode_submode) { /* Check "wideband bit" */
1245  if (get_bits_left(gb) > 0)
1246  wideband = show_bits1(gb);
1247  else
1248  wideband = 0;
1249  if (wideband) { /* Regular wideband frame, read the submode */
1250  wideband = get_bits1(gb);
1251  st->submodeID = get_bits(gb, SB_SUBMODE_BITS);
1252  } else { /* Was a narrowband frame, set "null submode" */
1253  st->submodeID = 0;
1254  }
1255  if (st->submodeID != 0 && st->submodes[st->submodeID] == NULL)
1256  return AVERROR_INVALIDDATA;
1257  }
1258 
1259  /* If null mode (no transmission), just set a couple things to zero */
1260  if (st->submodes[st->submodeID] == NULL) {
1261  for (int i = 0; i < st->frame_size; i++)
1262  out[st->frame_size + i] = 1e-15f;
1263 
1264  st->first = 1;
1265 
1266  /* Final signal synthesis from excitation */
1267  iir_mem(out + st->frame_size, st->interp_qlpc, out + st->frame_size, st->frame_size, st->lpc_size, st->mem_sp);
1268 
1269  qmf_synth(out, out + st->frame_size, h0, out, st->full_frame_size, QMF_ORDER, st->g0_mem, st->g1_mem);
1270 
1271  return 0;
1272  }
1273 
1274  memcpy(low_pi_gain, s->st[st->modeID - 1].pi_gain, sizeof(low_pi_gain));
1275  memcpy(low_exc_rms, s->st[st->modeID - 1].exc_rms, sizeof(low_exc_rms));
1276 
1277  SUBMODE(lsp_unquant)(qlsp, st->lpc_size, gb);
1278 
1279  if (st->first)
1280  memcpy(st->old_qlsp, qlsp, sizeof(st->old_qlsp));
1281 
1282  for (int sub = 0; sub < st->nb_subframes; sub++) {
1283  float filter_ratio, el, rl, rh;
1284  float *innov_save = NULL, *sp;
1285  float exc[80];
1286  int offset;
1287 
1288  offset = st->subframe_size * sub;
1289  sp = out + st->frame_size + offset;
1290  /* Pointer for saving innovation */
1291  if (st->innov_save) {
1292  innov_save = st->innov_save + 2 * offset;
1293  SPEEX_MEMSET(innov_save, 0, 2 * st->subframe_size);
1294  }
1295 
1296  av_assert0(st->nb_subframes > 0);
1297  lsp_interpolate(st->old_qlsp, qlsp, interp_qlsp, st->lpc_size, sub, st->nb_subframes, 0.05f);
1298  lsp_to_lpc(interp_qlsp, ak, st->lpc_size);
1299 
1300  /* Calculate reponse ratio between the low and high filter in the middle
1301  of the band (4000 Hz) */
1302  st->pi_gain[sub] = 1.f;
1303  rh = 1.f;
1304  for (int i = 0; i < st->lpc_size; i += 2) {
1305  rh += ak[i + 1] - ak[i];
1306  st->pi_gain[sub] += ak[i] + ak[i + 1];
1307  }
1308 
1309  rl = low_pi_gain[sub];
1310  filter_ratio = (rl + .01f) / (rh + .01f);
1311 
1312  SPEEX_MEMSET(exc, 0, st->subframe_size);
1313  if (!SUBMODE(innovation_unquant)) {
1314  const int x = get_bits(gb, 5);
1315  const float g = expf(.125f * (x - 10)) / filter_ratio;
1316 
1317  for (int i = 0; i < st->subframe_size; i += 2) {
1318  exc[i ] = mode->folding_gain * low_innov_alias[offset + i ] * g;
1319  exc[i + 1] = -mode->folding_gain * low_innov_alias[offset + i + 1] * g;
1320  }
1321  } else {
1322  float gc, scale;
1323 
1324  el = low_exc_rms[sub];
1325  gc = 0.87360f * gc_quant_bound[get_bits(gb, 4)];
1326 
1327  if (st->subframe_size == 80)
1328  gc *= M_SQRT2;
1329 
1330  scale = (gc * el) / filter_ratio;
1331  SUBMODE(innovation_unquant)
1332  (exc, SUBMODE(innovation_params), st->subframe_size,
1333  gb, &st->seed);
1334 
1335  signal_mul(exc, exc, scale, st->subframe_size);
1336  if (SUBMODE(double_codebook)) {
1337  float innov2[80];
1338 
1339  SPEEX_MEMSET(innov2, 0, st->subframe_size);
1340  SUBMODE(innovation_unquant)(innov2, SUBMODE(innovation_params), st->subframe_size, gb, &st->seed);
1341  signal_mul(innov2, innov2, 0.4f * scale, st->subframe_size);
1342  for (int i = 0; i < st->subframe_size; i++)
1343  exc[i] += innov2[i];
1344  }
1345  }
1346 
1347  if (st->innov_save) {
1348  for (int i = 0; i < st->subframe_size; i++)
1349  innov_save[2 * i] = exc[i];
1350  }
1351 
1352  iir_mem(st->exc_buf, st->interp_qlpc, sp, st->subframe_size, st->lpc_size, st->mem_sp);
1353  memcpy(st->exc_buf, exc, sizeof(exc));
1354  memcpy(st->interp_qlpc, ak, sizeof(st->interp_qlpc));
1355  st->exc_rms[sub] = compute_rms(st->exc_buf, st->subframe_size);
1356  }
1357 
1358  qmf_synth(out, out + st->frame_size, h0, out, st->full_frame_size, QMF_ORDER, st->g0_mem, st->g1_mem);
1359  memcpy(st->old_qlsp, qlsp, sizeof(st->old_qlsp));
1360 
1361  st->first = 0;
1362 
1363  return 0;
1364 }
1365 
1367 {
1368  st->mode = mode;
1369  st->modeID = mode->modeID;
1370 
1371  st->first = 1;
1372  st->encode_submode = 1;
1373  st->is_wideband = st->modeID > 0;
1374  st->innov_save = NULL;
1375 
1376  st->submodes = mode->submodes;
1377  st->submodeID = mode->default_submode;
1378  st->subframe_size = mode->subframe_size;
1379  st->lpc_size = mode->lpc_size;
1380  st->full_frame_size = (1 + (st->modeID > 0)) * mode->frame_size;
1381  st->nb_subframes = mode->frame_size / mode->subframe_size;
1382  st->frame_size = mode->frame_size;
1383 
1384  st->lpc_enh_enabled = 1;
1385 
1386  st->last_pitch = 40;
1387  st->count_lost = 0;
1388  st->seed = 1000;
1389  st->last_ol_gain = 0;
1390 
1391  st->voc_m1 = st->voc_m2 = st->voc_mean = 0;
1392  st->voc_offset = 0;
1393  st->dtx_enabled = 0;
1394  st->highpass_enabled = mode->modeID == 0;
1395 
1396  return 0;
1397 }
1398 
1400  const uint8_t *extradata, int extradata_size)
1401 {
1402  SpeexContext *s = avctx->priv_data;
1403  const uint8_t *buf = av_strnstr(extradata, "Speex ", extradata_size);
1404 
1405  if (!buf)
1406  return AVERROR_INVALIDDATA;
1407 
1408  buf += 28;
1409 
1410  s->version_id = bytestream_get_le32(&buf);
1411  buf += 4;
1412  s->rate = bytestream_get_le32(&buf);
1413  if (s->rate <= 0)
1414  return AVERROR_INVALIDDATA;
1415  s->mode = bytestream_get_le32(&buf);
1416  if (s->mode < 0 || s->mode >= SPEEX_NB_MODES)
1417  return AVERROR_INVALIDDATA;
1418  s->bitstream_version = bytestream_get_le32(&buf);
1419  if (s->bitstream_version != 4)
1420  return AVERROR_INVALIDDATA;
1421  s->nb_channels = bytestream_get_le32(&buf);
1422  if (s->nb_channels <= 0 || s->nb_channels > 2)
1423  return AVERROR_INVALIDDATA;
1424  s->bitrate = bytestream_get_le32(&buf);
1425  s->frame_size = bytestream_get_le32(&buf);
1426  if (s->frame_size < NB_FRAME_SIZE << (s->mode > 1) ||
1427  s->frame_size > INT32_MAX >> (s->mode > 1))
1428  return AVERROR_INVALIDDATA;
1429  s->frame_size = FFMIN(s->frame_size << (s->mode > 1), NB_FRAME_SIZE << s->mode);
1430  s->vbr = bytestream_get_le32(&buf);
1431  s->frames_per_packet = bytestream_get_le32(&buf);
1432  if (s->frames_per_packet <= 0 ||
1433  s->frames_per_packet > 64 ||
1434  s->frames_per_packet >= INT32_MAX / s->nb_channels / s->frame_size)
1435  return AVERROR_INVALIDDATA;
1436  s->extra_headers = bytestream_get_le32(&buf);
1437 
1438  return 0;
1439 }
1440 
1442 {
1443  SpeexContext *s = avctx->priv_data;
1444  int ret;
1445 
1446  s->fdsp = avpriv_float_dsp_alloc(0);
1447  if (!s->fdsp)
1448  return AVERROR(ENOMEM);
1449 
1450  if (avctx->extradata && avctx->extradata_size >= 80) {
1451  ret = parse_speex_extradata(avctx, avctx->extradata, avctx->extradata_size);
1452  if (ret < 0)
1453  return ret;
1454  } else {
1455  s->rate = avctx->sample_rate;
1456  if (s->rate <= 0)
1457  return AVERROR_INVALIDDATA;
1458 
1459  s->nb_channels = avctx->ch_layout.nb_channels;
1460  if (s->nb_channels <= 0 || s->nb_channels > 2)
1461  return AVERROR_INVALIDDATA;
1462 
1463  switch (s->rate) {
1464  case 8000: s->mode = 0; break;
1465  case 16000: s->mode = 1; break;
1466  case 32000: s->mode = 2; break;
1467  default: s->mode = 2;
1468  }
1469 
1470  s->frames_per_packet = 64;
1471  s->frame_size = NB_FRAME_SIZE << s->mode;
1472  }
1473 
1474  if (avctx->codec_tag == MKTAG('S', 'P', 'X', 'N')) {
1475  int quality;
1476 
1477  if (!avctx->extradata || avctx->extradata && avctx->extradata_size < 47) {
1478  av_log(avctx, AV_LOG_ERROR, "Missing or invalid extradata.\n");
1479  return AVERROR_INVALIDDATA;
1480  }
1481 
1482  quality = avctx->extradata[37];
1483  if (quality > 10) {
1484  av_log(avctx, AV_LOG_ERROR, "Unsupported quality mode %d.\n", quality);
1485  return AVERROR_PATCHWELCOME;
1486  }
1487 
1488  s->pkt_size = ((const uint8_t[]){ 5, 10, 15, 20, 20, 28, 28, 38, 38, 46, 62 })[quality];
1489 
1490  s->mode = 0;
1491  s->nb_channels = 1;
1492  s->rate = avctx->sample_rate;
1493  if (s->rate <= 0)
1494  return AVERROR_INVALIDDATA;
1495  s->frames_per_packet = 1;
1496  s->frame_size = NB_FRAME_SIZE;
1497  }
1498 
1499  if (s->bitrate > 0)
1500  avctx->bit_rate = s->bitrate;
1503  avctx->ch_layout.nb_channels = s->nb_channels;
1504  avctx->sample_rate = s->rate;
1505  avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
1506 
1507  for (int m = 0; m <= s->mode; m++) {
1508  ret = decoder_init(s, &s->st[m], &speex_modes[m]);
1509  if (ret < 0)
1510  return ret;
1511  }
1512 
1513  s->stereo.balance = 1.f;
1514  s->stereo.e_ratio = .5f;
1515  s->stereo.smooth_left = 1.f;
1516  s->stereo.smooth_right = 1.f;
1517 
1518  return 0;
1519 }
1520 
1521 static void speex_decode_stereo(float *data, int frame_size, StereoState *stereo)
1522 {
1523  float balance, e_left, e_right, e_ratio;
1524 
1525  balance = stereo->balance;
1526  e_ratio = stereo->e_ratio;
1527 
1528  /* These two are Q14, with max value just below 2. */
1529  e_right = 1.f / sqrtf(e_ratio * (1.f + balance));
1530  e_left = sqrtf(balance) * e_right;
1531 
1532  for (int i = frame_size - 1; i >= 0; i--) {
1533  float tmp = data[i];
1534  stereo->smooth_left = stereo->smooth_left * 0.98f + e_left * 0.02f;
1535  stereo->smooth_right = stereo->smooth_right * 0.98f + e_right * 0.02f;
1536  data[2 * i ] = stereo->smooth_left * tmp;
1537  data[2 * i + 1] = stereo->smooth_right * tmp;
1538  }
1539 }
1540 
1542  int *got_frame_ptr, AVPacket *avpkt)
1543 {
1544  SpeexContext *s = avctx->priv_data;
1545  int frames_per_packet = s->frames_per_packet;
1546  const float scale = 1.f / 32768.f;
1547  int buf_size = avpkt->size;
1548  float *dst;
1549  int ret;
1550 
1551  if (s->pkt_size && avpkt->size == 62)
1552  buf_size = s->pkt_size;
1553  if ((ret = init_get_bits8(&s->gb, avpkt->data, buf_size)) < 0)
1554  return ret;
1555 
1556  frame->nb_samples = FFALIGN(s->frame_size * frames_per_packet, 4);
1557  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1558  return ret;
1559 
1560  dst = (float *)frame->extended_data[0];
1561  for (int i = 0; i < frames_per_packet; i++) {
1562  ret = speex_modes[s->mode].decode(avctx, &s->st[s->mode], &s->gb, dst + i * s->frame_size);
1563  if (ret < 0)
1564  return ret;
1565  if (avctx->ch_layout.nb_channels == 2)
1566  speex_decode_stereo(dst + i * s->frame_size, s->frame_size, &s->stereo);
1567  if (get_bits_left(&s->gb) < 5 ||
1568  show_bits(&s->gb, 5) == 15) {
1569  frames_per_packet = i + 1;
1570  break;
1571  }
1572  }
1573 
1574  dst = (float *)frame->extended_data[0];
1575  s->fdsp->vector_fmul_scalar(dst, dst, scale, frame->nb_samples * frame->ch_layout.nb_channels);
1576  frame->nb_samples = s->frame_size * frames_per_packet;
1577 
1578  *got_frame_ptr = 1;
1579 
1580  return (get_bits_count(&s->gb) + 7) >> 3;
1581 }
1582 
1584 {
1585  SpeexContext *s = avctx->priv_data;
1586  av_freep(&s->fdsp);
1587  return 0;
1588 }
1589 
1591  .p.name = "speex",
1592  CODEC_LONG_NAME("Speex"),
1593  .p.type = AVMEDIA_TYPE_AUDIO,
1594  .p.id = AV_CODEC_ID_SPEEX,
1595  .init = speex_decode_init,
1597  .close = speex_decode_close,
1598  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
1599  .priv_data_size = sizeof(SpeexContext),
1600  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1601 };
M
#define M(a, b)
Definition: vp3dsp.c:48
LtpParams::pitch_bits
int pitch_bits
Definition: speexdec.c:95
DecoderState::submodeID
int submodeID
Activated sub-mode.
Definition: speexdec.c:202
split_cb_high
static const SplitCodebookParams split_cb_high
Definition: speexdec.c:117
SB_SUBMODE_BITS
#define SB_SUBMODE_BITS
Definition: speexdec.c:74
nb_submode4
static const SpeexSubmode nb_submode4
Definition: speexdec.c:475
skip_bits_long
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:261
DecoderState::seed
uint32_t seed
Seed used for random number generation.
Definition: speexdec.c:198
h0
static const float h0[64]
Definition: speexdata.h:741
SpeexSubmode::have_subframe_gain
int have_subframe_gain
Number of bits to use as sub-frame innovation gain.
Definition: speexdec.c:155
SplitCodebookParams::shape_bits
int shape_bits
Definition: speexdec.c:107
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:42
show_bits1
static unsigned int show_bits1(GetBitContext *s)
Definition: get_bits.h:391
QMF_ORDER
#define QMF_ORDER
Definition: speexdec.c:69
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:678
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
wb_submode2
static const SpeexSubmode wb_submode2
Definition: speexdec.c:509
hexc_10_32_table
static const int8_t hexc_10_32_table[320]
Definition: speexdata.h:694
nb_submode3
static const SpeexSubmode nb_submode3
Definition: speexdec.c:469
DecoderState::count_lost
int count_lost
Was the last frame lost?
Definition: speexdec.c:187
exc_gain_quant_scal1
static const float exc_gain_quant_scal1[2]
Definition: speexdata.h:778
out
FILE * out
Definition: movenc.c:55
speexdata.h
SpeexContext::vbr
int32_t vbr
1 for a VBR decoding, 0 otherwise
Definition: speexdec.c:252
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1024
DecoderState::exc_buf
float exc_buf[NB_DEC_BUFFER]
Excitation buffer.
Definition: speexdec.c:216
DecoderState::highpass_enabled
int highpass_enabled
Is the input filter enabled.
Definition: speexdec.c:212
DecoderState::dtx_enabled
int dtx_enabled
Definition: speexdec.c:211
DecoderState::mode
const SpeexMode * mode
Definition: speexdec.c:182
hexc_table
static const int8_t hexc_table[1024]
Definition: speexdata.h:612
ltp_quant_func
int(* ltp_quant_func)(float *, float *, float *, float *, float *, float *, const void *, int, int, float, int, int, GetBitContext *, char *, float *, float *, int, int, int, float *)
Long-term predictor quantization.
Definition: speexdec.c:127
DecoderState::mem_hp
float mem_hp[2]
High-pass filter memory.
Definition: speexdec.c:215
DecoderState::voc_m1
float voc_m1
Definition: speexdec.c:206
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:249
exc_8_128_table
static const int8_t exc_8_128_table[1024]
Definition: speexdata.h:295
LSP_DIV_1024
#define LSP_DIV_1024(x)
Definition: speexdec.c:90
SpeexContext::version_id
int32_t version_id
Version for Speex (for checking compatibility)
Definition: speexdec.c:245
cdbk_nb_high1
static const int8_t cdbk_nb_high1[320]
Definition: speexdata.h:562
SpeexMode::modeID
int modeID
ID of the mode.
Definition: speexdec.c:171
DecoderState::lpc_enh_enabled
int lpc_enh_enabled
1 when LPC enhancer is on, 0 otherwise
Definition: speexdec.c:203
mode
Definition: swscale.c:56
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:410
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
AVPacket::data
uint8_t * data
Definition: packet.h:535
LtpParams
Definition: speexdec.c:92
data
const char data[16]
Definition: mxf.c:149
DecoderState::exc
float * exc
Start of excitation frame.
Definition: speexdec.c:214
expf
#define expf(x)
Definition: libm.h:285
FFCodec
Definition: codec_internal.h:127
LSP_DIV_512
#define LSP_DIV_512(x)
Definition: speexdec.c:89
AVChannelLayout::order
enum AVChannelOrder order
Channel order used in this layout.
Definition: channel_layout.h:324
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
N2
#define N2
Definition: vf_pp7.c:74
SpeexMode::lpc_size
int lpc_size
Order of LPC filter.
Definition: speexdec.c:175
c1
static const uint64_t c1
Definition: murmur3.c:52
nb_submode8
static const SpeexSubmode nb_submode8
Definition: speexdec.c:499
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:329
intfloat.h
SpeexSubmode::double_codebook
int double_codebook
Apply innovation quantization twice for higher quality (and higher bit-rate)
Definition: speexdec.c:157
speex_inband_handler
static int speex_inband_handler(GetBitContext *gb, void *state, StereoState *stereo)
Definition: speexdec.c:632
DecoderState::first
int first
Is first frame
Definition: speexdec.c:184
gain_3tap_to_1tap
#define gain_3tap_to_1tap(g)
Definition: speexdec.c:353
quality
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about quality
Definition: rate_distortion.txt:12
wb_submode4
static const SpeexSubmode wb_submode4
Definition: speexdec.c:519
SpeexSubmode
Definition: speexdec.c:149
SpeexMode::subframe_size
int subframe_size
Size of sub-frames used for decoding.
Definition: speexdec.c:174
SpeexSubmode::LtpParam
const void * LtpParam
Pitch parameters (options)
Definition: speexdec.c:162
LSP_DIV_256
#define LSP_DIV_256(x)
Definition: speexdec.c:88
SpeexContext::pkt_size
int pkt_size
Definition: speexdec.c:256
SpeexContext::nb_channels
int32_t nb_channels
Number of channels decoded.
Definition: speexdec.c:249
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:318
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
exc_5_256_table
static const int8_t exc_5_256_table[1280]
Definition: speexdata.h:137
AV_CODEC_ID_SPEEX
@ AV_CODEC_ID_SPEEX
Definition: codec_id.h:483
LSP_LINEAR_HIGH
#define LSP_LINEAR_HIGH(i)
Definition: speexdec.c:87
cosf
#define cosf(x)
Definition: libm.h:80
interp
interp
Definition: vf_curves.c:62
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:1039
speex_default_user_handler
static int speex_default_user_handler(GetBitContext *gb, void *state, void *data)
Definition: speexdec.c:227
av_int2float
static av_always_inline float av_int2float(uint32_t i)
Reinterpret a 32-bit integer as a float.
Definition: intfloat.h:40
SpeexSubmode::ltp_unquant
ltp_unquant_func ltp_unquant
Long-term predictor (pitch) un-quantizer.
Definition: speexdec.c:161
GetBitContext
Definition: get_bits.h:108
innovation_quant_func
void(* innovation_quant_func)(float *, float *, float *, float *, const void *, int, int, float *, float *, GetBitContext *, char *, int, int)
Innovation quantization function.
Definition: speexdec.c:140
DecoderState
Definition: speexdec.c:181
split_cb_nb_lbr
static const SplitCodebookParams split_cb_nb_lbr
Definition: speexdec.c:113
DecoderState::nb_subframes
int nb_subframes
Number of high-band sub-frames.
Definition: speexdec.c:190
fabsf
static __device__ float fabsf(float a)
Definition: cuda_runtime.h:181
wb_submode3
static const SpeexSubmode wb_submode3
Definition: speexdec.c:514
SpeexContext::bitrate
int32_t bitrate
Bit-rate used.
Definition: speexdec.c:250
e_ratio_quant
static const float e_ratio_quant[4]
Definition: speexdata.h:766
ff_speex_decoder
const FFCodec ff_speex_decoder
Definition: speexdec.c:1590
split_cb_nb_ulbr
static const SplitCodebookParams split_cb_nb_ulbr
Definition: speexdec.c:111
NB_PITCH_START
#define NB_PITCH_START
Definition: speexdec.c:78
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
av_cold
#define av_cold
Definition: attributes.h:90
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:528
StereoState::balance
float balance
Left/right balance info.
Definition: speexdec.c:235
lsp_interpolate
static void lsp_interpolate(const float *old_lsp, const float *new_lsp, float *lsp, int len, int subframe, int nb_subframes, float margin)
Definition: speexdec.c:808
state
static struct @486 state
float
float
Definition: af_crystalizer.c:122
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:515
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:341
s
#define s(width, name)
Definition: cbs_vp9.c:198
split_cb_sb
static const SplitCodebookParams split_cb_sb
Definition: speexdec.c:116
nb_decode
static int nb_decode(AVCodecContext *, void *, GetBitContext *, float *)
Definition: speexdec.c:869
g
const char * g
Definition: vf_curves.c:128
frame_size
int frame_size
Definition: mxfenc.c:2446
speex_std_stereo
static int speex_std_stereo(GetBitContext *gb, void *state, void *data)
Definition: speexdec.c:621
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AV_CHANNEL_ORDER_UNSPEC
@ AV_CHANNEL_ORDER_UNSPEC
Only the channel count is specified, without any further information about the channel order.
Definition: channel_layout.h:119
gain_cdbk_lbr
static const int8_t gain_cdbk_lbr[128]
Definition: speexdata.h:406
fminf
float fminf(float, float)
NB_SUBFRAME_SIZE
#define NB_SUBFRAME_SIZE
Definition: speexdec.c:76
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
nb_submode7
static const SpeexSubmode nb_submode7
Definition: speexdec.c:493
decode.h
speex_rand
static float speex_rand(float std, uint32_t *seed)
Definition: speexdec.c:300
get_bits.h
cdbk_nb_low2
static const int8_t cdbk_nb_low2[320]
Definition: speexdata.h:537
speex_modes
static const SpeexMode speex_modes[SPEEX_NB_MODES]
Definition: speexdec.c:527
DecoderState::encode_submode
int encode_submode
Definition: speexdec.c:200
NB_FRAME_SIZE
#define NB_FRAME_SIZE
Definition: speexdec.c:71
StereoState
Definition: speexdec.c:234
DecoderState::modeID
int modeID
ID of the decoder mode.
Definition: speexdec.c:183
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:326
SUBMODE
#define SUBMODE(x)
Definition: speexdec.c:351
nb_submode6
static const SpeexSubmode nb_submode6
Definition: speexdec.c:487
SpeexSubmode::innovation_unquant
innovation_unquant_func innovation_unquant
Innovation un-quantization.
Definition: speexdec.c:164
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:74
DecoderState::mem_sp
float mem_sp[NB_ORDER]
Filter memory for synthesis signal.
Definition: speexdec.c:219
SPEEX_MEMSET
#define SPEEX_MEMSET(dst, c, n)
Definition: speexdec.c:83
lsp_to_lpc
static void lsp_to_lpc(const float *freq, float *ak, int lpcrdr)
Definition: speexdec.c:825
speex_decode_frame
static int speex_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)
Definition: speexdec.c:1541
nb_submode1
static const SpeexSubmode nb_submode1
Definition: speexdec.c:457
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:75
NULL
#define NULL
Definition: coverity.c:32
SpeexContext::frames_per_packet
int32_t frames_per_packet
Number of frames stored per Ogg packet.
Definition: speexdec.c:253
NB_SUBMODES
#define NB_SUBMODES
Definition: speexdec.c:72
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
DecoderState::lpc_size
int lpc_size
Order of high-band LPC analysis.
Definition: speexdec.c:191
isnan
#define isnan(x)
Definition: libm.h:342
SpeexMode::default_submode
int default_submode
Default sub-mode to use when decoding.
Definition: speexdec.c:178
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:481
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:371
DecoderState::exc_rms
float exc_rms[NB_NB_SUBFRAMES]
RMS of excitation per subframe.
Definition: speexdec.c:223
split_cb_nb
static const SplitCodebookParams split_cb_nb
Definition: speexdec.c:115
sqrtf
static __device__ float sqrtf(float a)
Definition: cuda_runtime.h:184
SpeexContext::bitstream_version
int32_t bitstream_version
Version ID of the bit-stream.
Definition: speexdec.c:248
LtpParams::gain_bits
int gain_bits
Definition: speexdec.c:94
exc_10_32_table
static const int8_t exc_10_32_table[320]
Definition: speexdata.h:367
av_clipf
av_clipf
Definition: af_crystalizer.c:122
SpeexContext::extra_headers
int32_t extra_headers
Number of additional headers after the comments.
Definition: speexdec.c:254
ltp_params_nb
static const LtpParam ltp_params_nb
Definition: speexdec.c:101
exp
int8_t exp
Definition: eval.c:73
seed
static unsigned int seed
Definition: videogen.c:78
wb_skip_table
static const uint16_t wb_skip_table[8]
Definition: speexdata.h:765
DecoderState::voc_offset
int voc_offset
Definition: speexdec.c:209
float_dsp.h
SpeexSubmode::comb_gain
float comb_gain
Gain of enhancer comb filter.
Definition: speexdec.c:167
AV_CODEC_CAP_CHANNEL_CONF
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:91
f
f
Definition: af_crystalizer.c:122
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1611
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:536
LtpParams::gain_cdbk
const int8_t * gain_cdbk
Definition: speexdec.c:93
lsp_unquant_nb
static void lsp_unquant_nb(float *lsp, int order, GetBitContext *gb)
Definition: speexdec.c:412
exc_5_64_table
static const int8_t exc_5_64_table[320]
Definition: speexdata.h:232
codec_internal.h
SpeexContext::fdsp
AVFloatDSPContext * fdsp
Definition: speexdec.c:261
ltp_params_lbr
static const LtpParam ltp_params_lbr
Definition: speexdec.c:99
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:83
ltp_params_med
static const LtpParam ltp_params_med
Definition: speexdec.c:100
sanitize_values
static void sanitize_values(float *vec, float min_val, float max_val, int len)
Definition: speexdec.c:658
SpeexMode::folding_gain
float folding_gain
Folding gain.
Definition: speexdec.c:176
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:424
ltp_unquant_func
void(* ltp_unquant_func)(float *, float *, int, int, float, const void *, int, int *, float *, GetBitContext *, int, int, float, int)
Long-term un-quantize.
Definition: speexdec.c:134
NB_PITCH_END
#define NB_PITCH_END
Definition: speexdec.c:79
fmaxf
float fmaxf(float, float)
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1031
DecoderState::submodes
const SpeexSubmode *const * submodes
Sub-mode data.
Definition: speexdec.c:201
LSP_LINEAR
#define LSP_LINEAR(i)
Definition: speexdec.c:86
signal_mul
static void signal_mul(const float *x, float *y, float scale, int len)
Definition: speexdec.c:668
DecoderState::old_qlsp
float old_qlsp[NB_ORDER]
Quantized LSPs for previous frame.
Definition: speexdec.c:217
DecoderState::frame_size
int frame_size
Length of high-band frames.
Definition: speexdec.c:188
SpeexContext
Definition: speexdec.c:241
AVFloatDSPContext
Definition: float_dsp.h:24
noise_codebook_unquant
static void noise_codebook_unquant(float *exc, const void *par, int nsf, GetBitContext *gb, uint32_t *seed)
Definition: speexdec.c:314
pitch_unquant_3tap
static void pitch_unquant_3tap(float *exc, float *exc_out, int start, int end, float pitch_coef, const void *par, int nsf, int *pitch_val, float *gain_val, GetBitContext *gb, int count_lost, int subframe_offset, float last_pitch_gain, int cdbk_offset)
Definition: speexdec.c:356
gain_cdbk_nb
static const int8_t gain_cdbk_nb[512]
Definition: speexdata.h:257
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
a0
static double a0(void *priv, double x, double y)
Definition: vf_xfade.c:2028
SpeexMode::frame_size
int frame_size
Size of frames used for decoding.
Definition: speexdec.c:173
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
cdbk_nb_high2
static const int8_t cdbk_nb_high2[320]
Definition: speexdata.h:587
N
#define N
Definition: af_mcompand.c:54
fact
static double fact(double i)
Definition: af_aiir.c:935
SPEEX_COPY
#define SPEEX_COPY(dst, src, n)
Definition: speexdec.c:84
M_PI
#define M_PI
Definition: mathematics.h:67
DecoderState::subframe_size
int subframe_size
Length of high-band sub-frames.
Definition: speexdec.c:189
SpeexSubmode::innovation_params
const void * innovation_params
Innovation quantization parameters.
Definition: speexdec.c:165
ran
static uint32_t ran(void)
Definition: trasher.c:28
exc_20_32_table
static const int8_t exc_20_32_table[640]
Definition: speexdata.h:417
shift_filt
static const float shift_filt[3][7]
Definition: speexdata.h:719
multicomb
static void multicomb(const float *exc, float *new_exc, float *ak, int p, int nsf, int pitch, int max_pitch, float comb_gain)
Definition: speexdec.c:741
SplitCodebookParams::shape_cb
const signed char * shape_cb
Definition: speexdec.c:106
lsp_quant_func
void(* lsp_quant_func)(float *, float *, int, GetBitContext *)
Quantizes LSPs.
Definition: speexdec.c:121
lsp_unquant_lbr
static void lsp_unquant_lbr(float *lsp, int order, GetBitContext *gb)
Definition: speexdec.c:264
split_cb_nb_med
static const SplitCodebookParams split_cb_nb_med
Definition: speexdec.c:114
forced_pitch_unquant
static void forced_pitch_unquant(float *exc, float *exc_out, int start, int end, float pitch_coef, const void *par, int nsf, int *pitch_val, float *gain_val, GetBitContext *gb, int count_lost, int subframe_offset, float last_pitch_gain, int cdbk_offset)
Definition: speexdec.c:284
nb_submode5
static const SpeexSubmode nb_submode5
Definition: speexdec.c:481
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVCodecContext::extradata
uint8_t * extradata
Out-of-band global headers that may be used by some codecs.
Definition: avcodec.h:514
show_bits
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:354
DecoderState::interp_qlpc
float interp_qlpc[NB_ORDER]
Interpolated quantized LPCs.
Definition: speexdec.c:218
lsp_unquant_func
void(* lsp_unquant_func)(float *, int, GetBitContext *)
Decodes quantized LSPs.
Definition: speexdec.c:124
iir_mem
static void iir_mem(const float *x, const float *den, float *y, int N, int ord, float *mem)
Definition: speexdec.c:588
DecoderState::full_frame_size
int full_frame_size
Length of full-band frames.
Definition: speexdec.c:185
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:179
DecoderState::voc_m2
float voc_m2
Definition: speexdec.c:207
len
int len
Definition: vorbis_enc_data.h:426
inner_prod
static float inner_prod(const float *x, const float *y, int len)
Definition: speexdec.c:674
cdbk_nb
static const int8_t cdbk_nb[640]
Definition: speexdata.h:463
avcodec.h
decoder_init
static int decoder_init(SpeexContext *s, DecoderState *st, const SpeexMode *mode)
Definition: speexdec.c:1366
SPEEX_INBAND_STEREO
#define SPEEX_INBAND_STEREO
Definition: speexdec.c:67
SpeexContext::gb
GetBitContext gb
Definition: speexdec.c:243
parse_speex_extradata
static int parse_speex_extradata(AVCodecContext *avctx, const uint8_t *extradata, int extradata_size)
Definition: speexdec.c:1399
ret
ret
Definition: filter_design.txt:187
SplitCodebookParams::subvect_size
int subvect_size
Definition: speexdec.c:104
SpeexSubmode::lsp_unquant
lsp_unquant_func lsp_unquant
LSP unquantization function.
Definition: speexdec.c:159
split_cb_nb_vlbr
static const SplitCodebookParams split_cb_nb_vlbr
Definition: speexdec.c:112
SpeexMode::decode
int(* decode)(AVCodecContext *avctx, void *dec, GetBitContext *gb, float *out)
Definition: speexdec.c:172
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
av_strnstr
char * av_strnstr(const char *haystack, const char *needle, size_t hay_length)
Locate the first occurrence of the string needle in the string haystack where not more than hay_lengt...
Definition: avstring.c:71
StereoState::smooth_right
float smooth_right
Smoothed right channel gain.
Definition: speexdec.c:238
id
enum AVCodecID id
Definition: dts2pts.c:367
gc_quant_bound
static const float gc_quant_bound[16]
Definition: speexdata.h:760
DecoderState::last_pitch
int last_pitch
Pitch of last correctly decoded frame.
Definition: speexdec.c:196
StereoState::smooth_left
float smooth_left
Smoothed left channel gain.
Definition: speexdec.c:237
AVCodecContext
main external API structure.
Definition: avcodec.h:431
c2
static const uint64_t c2
Definition: murmur3.c:53
SpeexMode::submodes
const SpeexSubmode * submodes[NB_SUBMODES]
Sub-mode data for the mode.
Definition: speexdec.c:177
DecoderState::last_ol_gain
float last_ol_gain
Open-loop gain for previous frame.
Definition: speexdec.c:192
cdbk_nb_low1
static const int8_t cdbk_nb_low1[320]
Definition: speexdata.h:512
mode
mode
Definition: ebur128.h:83
DecoderState::voc_mean
float voc_mean
Definition: speexdec.c:208
av_channel_layout_uninit
void av_channel_layout_uninit(AVChannelLayout *channel_layout)
Free any allocated data in the channel layout and reset the channel count to 0.
Definition: channel_layout.c:442
NB_NB_SUBFRAMES
#define NB_NB_SUBFRAMES
Definition: speexdec.c:77
DecoderState::is_wideband
int is_wideband
If wideband is present.
Definition: speexdec.c:186
speex_decode_close
static av_cold int speex_decode_close(AVCodecContext *avctx)
Definition: speexdec.c:1583
SpeexContext::stereo
StereoState stereo
Definition: speexdec.c:258
DecoderState::g0_mem
float g0_mem[QMF_ORDER]
Definition: speexdec.c:220
mem.h
get_bitsz
static av_always_inline int get_bitsz(GetBitContext *s, int n)
Read 0-25 bits.
Definition: get_bits.h:334
high_lsp_cdbk2
static const int8_t high_lsp_cdbk2[512]
Definition: speexdata.h:99
SpeexContext::mode
int32_t mode
Mode used (0 for narrowband, 1 for wideband)
Definition: speexdec.c:247
M_SQRT2
#define M_SQRT2
Definition: mathematics.h:109
SpeexContext::st
DecoderState st[SPEEX_NB_MODES]
Definition: speexdec.c:259
nb_submode2
static const SpeexSubmode nb_submode2
Definition: speexdec.c:463
ltp_params_vlbr
static const LtpParam ltp_params_vlbr
Definition: speexdec.c:98
SpeexSubmode::forced_pitch_gain
int forced_pitch_gain
Use the same (forced) pitch gain for all sub-frames.
Definition: speexdec.c:153
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:456
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: intra.c:291
wb_submode1
static const SpeexSubmode wb_submode1
Definition: speexdec.c:504
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
highpass
static void highpass(const float *x, float *y, int len, float *mem, int wide)
Definition: speexdec.c:601
NB_ORDER
#define NB_ORDER
Definition: speexdec.c:70
AVPacket
This structure stores compressed data.
Definition: packet.h:512
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:458
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
avpriv_float_dsp_alloc
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:135
DecoderState::g1_mem
float g1_mem[QMF_ORDER]
Definition: speexdec.c:221
speex_decode_stereo
static void speex_decode_stereo(float *data, int frame_size, StereoState *stereo)
Definition: speexdec.c:1521
int32_t
int32_t
Definition: audioconvert.c:56
bytestream.h
innovation_unquant_func
void(* innovation_unquant_func)(float *, const void *, int, GetBitContext *, uint32_t *)
Innovation unquantization function.
Definition: speexdec.c:146
SpeexSubmode::lbr_pitch
int lbr_pitch
Set to -1 for "normal" modes, otherwise encode pitch using a global pitch and allowing a +- lbr_pitch...
Definition: speexdec.c:150
speex_decode_init
static av_cold int speex_decode_init(AVCodecContext *avctx)
Definition: speexdec.c:1441
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
SpeexContext::frame_size
int32_t frame_size
Size of frames.
Definition: speexdec.c:251
lsp_unquant_high
static void lsp_unquant_high(float *lsp, int order, GetBitContext *gb)
Definition: speexdec.c:440
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
exc_10_16_table
static const int8_t exc_10_16_table[160]
Definition: speexdata.h:392
qmf_synth
static void qmf_synth(const float *x1, const float *x2, const float *a, float *y, int N, int M, float *mem1, float *mem2)
Definition: speexdec.c:1163
exc_gain_quant_scal3
static const float exc_gain_quant_scal3[8]
Definition: speexdata.h:774
a1
static double a1(void *priv, double x, double y)
Definition: vf_xfade.c:2029
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
DecoderState::last_pitch_gain
float last_pitch_gain
Pitch gain of last correctly decoded frame.
Definition: speexdec.c:197
avstring.h
split_cb_high_lbr
static const SplitCodebookParams split_cb_high_lbr
Definition: speexdec.c:118
SplitCodebookParams
Definition: speexdec.c:103
SplitCodebookParams::have_sign
int have_sign
Definition: speexdec.c:108
DecoderState::pi_gain
float pi_gain[NB_NB_SUBFRAMES]
Gain of LPC filter at theta=pi (fe/2)
Definition: speexdec.c:222
SpeexContext::rate
int32_t rate
Sampling rate used.
Definition: speexdec.c:246
bw_lpc
static void bw_lpc(float gamma, const float *lpc_in, float *lpc_out, int order)
Definition: speexdec.c:577
interp_pitch
static int interp_pitch(const float *exc, float *interp, int pitch, int len)
Definition: speexdec.c:694
AV_SAMPLE_FMT_FLT
@ AV_SAMPLE_FMT_FLT
float
Definition: samplefmt.h:60
compute_rms
static float compute_rms(const float *x, int len)
Definition: speexdec.c:566
NB_DEC_BUFFER
#define NB_DEC_BUFFER
Definition: speexdec.c:81
sb_decode
static int sb_decode(AVCodecContext *, void *, GetBitContext *, float *)
Definition: speexdec.c:1220
DecoderState::innov_save
float * innov_save
If non-NULL, innovation is copied here.
Definition: speexdec.c:193
SplitCodebookParams::nb_subvect
int nb_subvect
Definition: speexdec.c:105
StereoState::e_ratio
float e_ratio
Ratio of energies: E(left+right)/[E(left)+E(right)]
Definition: speexdec.c:236
SpeexMode
Definition: speexdec.c:170
split_cb_shape_sign_unquant
static void split_cb_shape_sign_unquant(float *exc, const void *par, int nsf, GetBitContext *gb, uint32_t *seed)
Definition: speexdec.c:321
high_lsp_cdbk
static const int8_t high_lsp_cdbk[512]
Definition: speexdata.h:59
SPEEX_NB_MODES
#define SPEEX_NB_MODES
Definition: speexdec.c:66