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