FFmpeg
amrnbdec.c
Go to the documentation of this file.
1 /*
2  * AMR narrowband decoder
3  * Copyright (c) 2006-2007 Robert Swain
4  * Copyright (c) 2009 Colin McQuillan
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 
24 /**
25  * @file
26  * AMR narrowband decoder
27  *
28  * This decoder uses floats for simplicity and so is not bit-exact. One
29  * difference is that differences in phase can accumulate. The test sequences
30  * in 3GPP TS 26.074 can still be useful.
31  *
32  * - Comparing this file's output to the output of the ref decoder gives a
33  * PSNR of 30 to 80. Plotting the output samples shows a difference in
34  * phase in some areas.
35  *
36  * - Comparing both decoders against their input, this decoder gives a similar
37  * PSNR. If the test sequence homing frames are removed (this decoder does
38  * not detect them), the PSNR is at least as good as the reference on 140
39  * out of 169 tests.
40  */
41 
42 
43 #include <string.h>
44 #include <math.h>
45 
47 #include "libavutil/float_dsp.h"
48 #include "avcodec.h"
49 #include "libavutil/common.h"
50 #include "libavutil/avassert.h"
51 #include "celp_math.h"
52 #include "celp_filters.h"
53 #include "acelp_filters.h"
54 #include "acelp_vectors.h"
55 #include "acelp_pitch_delay.h"
56 #include "lsp.h"
57 #include "amr.h"
58 #include "codec_internal.h"
59 #include "internal.h"
60 
61 #include "amrnbdata.h"
62 
63 #define AMR_BLOCK_SIZE 160 ///< samples per frame
64 #define AMR_SAMPLE_BOUND 32768.0 ///< threshold for synthesis overflow
65 
66 /**
67  * Scale from constructed speech to [-1,1]
68  *
69  * AMR is designed to produce 16-bit PCM samples (3GPP TS 26.090 4.2) but
70  * upscales by two (section 6.2.2).
71  *
72  * Fundamentally, this scale is determined by energy_mean through
73  * the fixed vector contribution to the excitation vector.
74  */
75 #define AMR_SAMPLE_SCALE (2.0 / 32768.0)
76 
77 /** Prediction factor for 12.2kbit/s mode */
78 #define PRED_FAC_MODE_12k2 0.65
79 
80 #define LSF_R_FAC (8000.0 / 32768.0) ///< LSF residual tables to Hertz
81 #define MIN_LSF_SPACING (50.0488 / 8000.0) ///< Ensures stability of LPC filter
82 #define PITCH_LAG_MIN_MODE_12k2 18 ///< Lower bound on decoded lag search in 12.2kbit/s mode
83 
84 /** Initial energy in dB. Also used for bad frames (unimplemented). */
85 #define MIN_ENERGY -14.0
86 
87 /** Maximum sharpening factor
88  *
89  * The specification says 0.8, which should be 13107, but the reference C code
90  * uses 13017 instead. (Amusingly the same applies to SHARP_MAX in g729dec.c.)
91  */
92 #define SHARP_MAX 0.79449462890625
93 
94 /** Number of impulse response coefficients used for tilt factor */
95 #define AMR_TILT_RESPONSE 22
96 /** Tilt factor = 1st reflection coefficient * gamma_t */
97 #define AMR_TILT_GAMMA_T 0.8
98 /** Adaptive gain control factor used in post-filter */
99 #define AMR_AGC_ALPHA 0.9
100 
101 typedef struct AMRContext {
102  AMRNBFrame frame; ///< decoded AMR parameters (lsf coefficients, codebook indexes, etc)
103  uint8_t bad_frame_indicator; ///< bad frame ? 1 : 0
105 
106  int16_t prev_lsf_r[LP_FILTER_ORDER]; ///< residual LSF vector from previous subframe
107  double lsp[4][LP_FILTER_ORDER]; ///< lsp vectors from current frame
108  double prev_lsp_sub4[LP_FILTER_ORDER]; ///< lsp vector for the 4th subframe of the previous frame
109 
110  float lsf_q[4][LP_FILTER_ORDER]; ///< Interpolated LSF vector for fixed gain smoothing
111  float lsf_avg[LP_FILTER_ORDER]; ///< vector of averaged lsf vector
112 
113  float lpc[4][LP_FILTER_ORDER]; ///< lpc coefficient vectors for 4 subframes
114 
115  uint8_t pitch_lag_int; ///< integer part of pitch lag from current subframe
116 
117  float excitation_buf[PITCH_DELAY_MAX + LP_FILTER_ORDER + 1 + AMR_SUBFRAME_SIZE]; ///< current excitation and all necessary excitation history
118  float *excitation; ///< pointer to the current excitation vector in excitation_buf
119 
120  float pitch_vector[AMR_SUBFRAME_SIZE]; ///< adaptive code book (pitch) vector
121  float fixed_vector[AMR_SUBFRAME_SIZE]; ///< algebraic codebook (fixed) vector (must be kept zero between frames)
122 
123  float prediction_error[4]; ///< quantified prediction errors {20log10(^gamma_gc)} for previous four subframes
124  float pitch_gain[5]; ///< quantified pitch gains for the current and previous four subframes
125  float fixed_gain[5]; ///< quantified fixed gains for the current and previous four subframes
126 
127  float beta; ///< previous pitch_gain, bounded by [0.0,SHARP_MAX]
128  uint8_t diff_count; ///< the number of subframes for which diff has been above 0.65
129  uint8_t hang_count; ///< the number of subframes since a hangover period started
130 
131  float prev_sparse_fixed_gain; ///< previous fixed gain; used by anti-sparseness processing to determine "onset"
132  uint8_t prev_ir_filter_nr; ///< previous impulse response filter "impNr": 0 - strong, 1 - medium, 2 - none
133  uint8_t ir_filter_onset; ///< flag for impulse response filter strength
134 
135  float postfilter_mem[10]; ///< previous intermediate values in the formant filter
136  float tilt_mem; ///< previous input to tilt compensation filter
137  float postfilter_agc; ///< previous factor used for adaptive gain control
138  float high_pass_mem[2]; ///< previous intermediate values in the high-pass filter
139 
140  float samples_in[LP_FILTER_ORDER + AMR_SUBFRAME_SIZE]; ///< floating point samples
141 
142  ACELPFContext acelpf_ctx; ///< context for filters for ACELP-based codecs
143  ACELPVContext acelpv_ctx; ///< context for vector operations for ACELP-based codecs
144  CELPFContext celpf_ctx; ///< context for filters for CELP-based codecs
145  CELPMContext celpm_ctx; ///< context for fixed point math operations
146 
147 } AMRContext;
148 
149 typedef struct AMRChannelsContext {
152 
153 /** Double version of ff_weighted_vector_sumf() */
154 static void weighted_vector_sumd(double *out, const double *in_a,
155  const double *in_b, double weight_coeff_a,
156  double weight_coeff_b, int length)
157 {
158  int i;
159 
160  for (i = 0; i < length; i++)
161  out[i] = weight_coeff_a * in_a[i]
162  + weight_coeff_b * in_b[i];
163 }
164 
166 {
167  AMRChannelsContext *s = avctx->priv_data;
168  int i;
169 
170  if (avctx->ch_layout.nb_channels > 2) {
171  avpriv_report_missing_feature(avctx, ">2 channel AMR");
172  return AVERROR_PATCHWELCOME;
173  }
174 
175  if (!avctx->ch_layout.nb_channels) {
178  }
179  if (!avctx->sample_rate)
180  avctx->sample_rate = 8000;
182 
183  for (int ch = 0; ch < avctx->ch_layout.nb_channels; ch++) {
184  AMRContext *p = &s->ch[ch];
185  // p->excitation always points to the same position in p->excitation_buf
187 
188  for (i = 0; i < LP_FILTER_ORDER; i++) {
189  p->prev_lsp_sub4[i] = lsp_sub4_init[i] * 1000 / (float)(1 << 15);
190  p->lsf_avg[i] = p->lsf_q[3][i] = lsp_avg_init[i] / (float)(1 << 15);
191  }
192 
193  for (i = 0; i < 4; i++)
195 
200  }
201 
202  return 0;
203 }
204 
205 
206 /**
207  * Unpack an RFC4867 speech frame into the AMR frame mode and parameters.
208  *
209  * The order of speech bits is specified by 3GPP TS 26.101.
210  *
211  * @param p the context
212  * @param buf pointer to the input buffer
213  * @param buf_size size of the input buffer
214  *
215  * @return the frame mode
216  */
217 static enum Mode unpack_bitstream(AMRContext *p, const uint8_t *buf,
218  int buf_size)
219 {
220  enum Mode mode;
221 
222  // Decode the first octet.
223  mode = buf[0] >> 3 & 0x0F; // frame type
224  p->bad_frame_indicator = (buf[0] & 0x4) != 0x4; // quality bit
225 
226  if (mode >= N_MODES || buf_size < frame_sizes_nb[mode] + 1) {
227  return NO_DATA;
228  }
229 
230  if (mode < MODE_DTX)
231  ff_amr_bit_reorder((uint16_t *) &p->frame, sizeof(AMRNBFrame), buf + 1,
233 
234  return mode;
235 }
236 
237 
238 /// @name AMR pitch LPC coefficient decoding functions
239 /// @{
240 
241 /**
242  * Interpolate the LSF vector (used for fixed gain smoothing).
243  * The interpolation is done over all four subframes even in MODE_12k2.
244  *
245  * @param[in] ctx The Context
246  * @param[in,out] lsf_q LSFs in [0,1] for each subframe
247  * @param[in] lsf_new New LSFs in [0,1] for subframe 4
248  */
249 static void interpolate_lsf(ACELPVContext *ctx, float lsf_q[4][LP_FILTER_ORDER], float *lsf_new)
250 {
251  int i;
252 
253  for (i = 0; i < 4; i++)
254  ctx->weighted_vector_sumf(lsf_q[i], lsf_q[3], lsf_new,
255  0.25 * (3 - i), 0.25 * (i + 1),
257 }
258 
259 /**
260  * Decode a set of 5 split-matrix quantized lsf indexes into an lsp vector.
261  *
262  * @param p the context
263  * @param lsp output LSP vector
264  * @param lsf_no_r LSF vector without the residual vector added
265  * @param lsf_quantizer pointers to LSF dictionary tables
266  * @param quantizer_offset offset in tables
267  * @param sign for the 3 dictionary table
268  * @param update store data for computing the next frame's LSFs
269  */
270 static void lsf2lsp_for_mode12k2(AMRContext *p, double lsp[LP_FILTER_ORDER],
271  const float lsf_no_r[LP_FILTER_ORDER],
272  const int16_t *lsf_quantizer[5],
273  const int quantizer_offset,
274  const int sign, const int update)
275 {
276  int16_t lsf_r[LP_FILTER_ORDER]; // residual LSF vector
277  float lsf_q[LP_FILTER_ORDER]; // quantified LSF vector
278  int i;
279 
280  for (i = 0; i < LP_FILTER_ORDER >> 1; i++)
281  memcpy(&lsf_r[i << 1], &lsf_quantizer[i][quantizer_offset],
282  2 * sizeof(*lsf_r));
283 
284  if (sign) {
285  lsf_r[4] *= -1;
286  lsf_r[5] *= -1;
287  }
288 
289  if (update)
290  memcpy(p->prev_lsf_r, lsf_r, LP_FILTER_ORDER * sizeof(*lsf_r));
291 
292  for (i = 0; i < LP_FILTER_ORDER; i++)
293  lsf_q[i] = lsf_r[i] * (LSF_R_FAC / 8000.0) + lsf_no_r[i] * (1.0 / 8000.0);
294 
296 
297  if (update)
298  interpolate_lsf(&p->acelpv_ctx, p->lsf_q, lsf_q);
299 
300  ff_acelp_lsf2lspd(lsp, lsf_q, LP_FILTER_ORDER);
301 }
302 
303 /**
304  * Decode a set of 5 split-matrix quantized lsf indexes into 2 lsp vectors.
305  *
306  * @param p pointer to the AMRContext
307  */
308 static void lsf2lsp_5(AMRContext *p)
309 {
310  const uint16_t *lsf_param = p->frame.lsf;
311  float lsf_no_r[LP_FILTER_ORDER]; // LSFs without the residual vector
312  const int16_t *lsf_quantizer[5];
313  int i;
314 
315  lsf_quantizer[0] = lsf_5_1[lsf_param[0]];
316  lsf_quantizer[1] = lsf_5_2[lsf_param[1]];
317  lsf_quantizer[2] = lsf_5_3[lsf_param[2] >> 1];
318  lsf_quantizer[3] = lsf_5_4[lsf_param[3]];
319  lsf_quantizer[4] = lsf_5_5[lsf_param[4]];
320 
321  for (i = 0; i < LP_FILTER_ORDER; i++)
322  lsf_no_r[i] = p->prev_lsf_r[i] * LSF_R_FAC * PRED_FAC_MODE_12k2 + lsf_5_mean[i];
323 
324  lsf2lsp_for_mode12k2(p, p->lsp[1], lsf_no_r, lsf_quantizer, 0, lsf_param[2] & 1, 0);
325  lsf2lsp_for_mode12k2(p, p->lsp[3], lsf_no_r, lsf_quantizer, 2, lsf_param[2] & 1, 1);
326 
327  // interpolate LSP vectors at subframes 1 and 3
328  weighted_vector_sumd(p->lsp[0], p->prev_lsp_sub4, p->lsp[1], 0.5, 0.5, LP_FILTER_ORDER);
329  weighted_vector_sumd(p->lsp[2], p->lsp[1] , p->lsp[3], 0.5, 0.5, LP_FILTER_ORDER);
330 }
331 
332 /**
333  * Decode a set of 3 split-matrix quantized lsf indexes into an lsp vector.
334  *
335  * @param p pointer to the AMRContext
336  */
337 static void lsf2lsp_3(AMRContext *p)
338 {
339  const uint16_t *lsf_param = p->frame.lsf;
340  int16_t lsf_r[LP_FILTER_ORDER]; // residual LSF vector
341  float lsf_q[LP_FILTER_ORDER]; // quantified LSF vector
342  const int16_t *lsf_quantizer;
343  int i, j;
344 
345  lsf_quantizer = (p->cur_frame_mode == MODE_7k95 ? lsf_3_1_MODE_7k95 : lsf_3_1)[lsf_param[0]];
346  memcpy(lsf_r, lsf_quantizer, 3 * sizeof(*lsf_r));
347 
348  lsf_quantizer = lsf_3_2[lsf_param[1] << (p->cur_frame_mode <= MODE_5k15)];
349  memcpy(lsf_r + 3, lsf_quantizer, 3 * sizeof(*lsf_r));
350 
351  lsf_quantizer = (p->cur_frame_mode <= MODE_5k15 ? lsf_3_3_MODE_5k15 : lsf_3_3)[lsf_param[2]];
352  memcpy(lsf_r + 6, lsf_quantizer, 4 * sizeof(*lsf_r));
353 
354  // calculate mean-removed LSF vector and add mean
355  for (i = 0; i < LP_FILTER_ORDER; i++)
356  lsf_q[i] = (lsf_r[i] + p->prev_lsf_r[i] * pred_fac[i]) * (LSF_R_FAC / 8000.0) + lsf_3_mean[i] * (1.0 / 8000.0);
357 
359 
360  // store data for computing the next frame's LSFs
361  interpolate_lsf(&p->acelpv_ctx, p->lsf_q, lsf_q);
362  memcpy(p->prev_lsf_r, lsf_r, LP_FILTER_ORDER * sizeof(*lsf_r));
363 
364  ff_acelp_lsf2lspd(p->lsp[3], lsf_q, LP_FILTER_ORDER);
365 
366  // interpolate LSP vectors at subframes 1, 2 and 3
367  for (i = 1; i <= 3; i++)
368  for(j = 0; j < LP_FILTER_ORDER; j++)
369  p->lsp[i-1][j] = p->prev_lsp_sub4[j] +
370  (p->lsp[3][j] - p->prev_lsp_sub4[j]) * 0.25 * i;
371 }
372 
373 /// @}
374 
375 
376 /// @name AMR pitch vector decoding functions
377 /// @{
378 
379 /**
380  * Like ff_decode_pitch_lag(), but with 1/6 resolution
381  */
382 static void decode_pitch_lag_1_6(int *lag_int, int *lag_frac, int pitch_index,
383  const int prev_lag_int, const int subframe)
384 {
385  if (subframe == 0 || subframe == 2) {
386  if (pitch_index < 463) {
387  *lag_int = (pitch_index + 107) * 10923 >> 16;
388  *lag_frac = pitch_index - *lag_int * 6 + 105;
389  } else {
390  *lag_int = pitch_index - 368;
391  *lag_frac = 0;
392  }
393  } else {
394  *lag_int = ((pitch_index + 5) * 10923 >> 16) - 1;
395  *lag_frac = pitch_index - *lag_int * 6 - 3;
396  *lag_int += av_clip(prev_lag_int - 5, PITCH_LAG_MIN_MODE_12k2,
397  PITCH_DELAY_MAX - 9);
398  }
399 }
400 
402  const AMRNBSubframe *amr_subframe,
403  const int subframe)
404 {
405  int pitch_lag_int, pitch_lag_frac;
406  enum Mode mode = p->cur_frame_mode;
407 
408  if (p->cur_frame_mode == MODE_12k2) {
409  decode_pitch_lag_1_6(&pitch_lag_int, &pitch_lag_frac,
410  amr_subframe->p_lag, p->pitch_lag_int,
411  subframe);
412  } else {
413  ff_decode_pitch_lag(&pitch_lag_int, &pitch_lag_frac,
414  amr_subframe->p_lag,
415  p->pitch_lag_int, subframe,
416  mode != MODE_4k75 && mode != MODE_5k15,
417  mode <= MODE_6k7 ? 4 : (mode == MODE_7k95 ? 5 : 6));
418  pitch_lag_frac *= 2;
419  }
420 
421  p->pitch_lag_int = pitch_lag_int; // store previous lag in a uint8_t
422 
423  pitch_lag_int += pitch_lag_frac > 0;
424 
425  /* Calculate the pitch vector by interpolating the past excitation at the
426  pitch lag using a b60 hamming windowed sinc function. */
428  p->excitation + 1 - pitch_lag_int,
429  ff_b60_sinc, 6,
430  pitch_lag_frac + 6 - 6*(pitch_lag_frac > 0),
431  10, AMR_SUBFRAME_SIZE);
432 
433  memcpy(p->pitch_vector, p->excitation, AMR_SUBFRAME_SIZE * sizeof(float));
434 }
435 
436 /// @}
437 
438 
439 /// @name AMR algebraic code book (fixed) vector decoding functions
440 /// @{
441 
442 /**
443  * Decode a 10-bit algebraic codebook index from a 10.2 kbit/s frame.
444  */
445 static void decode_10bit_pulse(int code, int pulse_position[8],
446  int i1, int i2, int i3)
447 {
448  // coded using 7+3 bits with the 3 LSBs being, individually, the LSB of 1 of
449  // the 3 pulses and the upper 7 bits being coded in base 5
450  const uint8_t *positions = base_five_table[code >> 3];
451  pulse_position[i1] = (positions[2] << 1) + ( code & 1);
452  pulse_position[i2] = (positions[1] << 1) + ((code >> 1) & 1);
453  pulse_position[i3] = (positions[0] << 1) + ((code >> 2) & 1);
454 }
455 
456 /**
457  * Decode the algebraic codebook index to pulse positions and signs and
458  * construct the algebraic codebook vector for MODE_10k2.
459  *
460  * @param fixed_index positions of the eight pulses
461  * @param fixed_sparse pointer to the algebraic codebook vector
462  */
463 static void decode_8_pulses_31bits(const int16_t *fixed_index,
464  AMRFixed *fixed_sparse)
465 {
466  int pulse_position[8];
467  int i, temp;
468 
469  decode_10bit_pulse(fixed_index[4], pulse_position, 0, 4, 1);
470  decode_10bit_pulse(fixed_index[5], pulse_position, 2, 6, 5);
471 
472  // coded using 5+2 bits with the 2 LSBs being, individually, the LSB of 1 of
473  // the 2 pulses and the upper 5 bits being coded in base 5
474  temp = ((fixed_index[6] >> 2) * 25 + 12) >> 5;
475  pulse_position[3] = temp % 5;
476  pulse_position[7] = temp / 5;
477  if (pulse_position[7] & 1)
478  pulse_position[3] = 4 - pulse_position[3];
479  pulse_position[3] = (pulse_position[3] << 1) + ( fixed_index[6] & 1);
480  pulse_position[7] = (pulse_position[7] << 1) + ((fixed_index[6] >> 1) & 1);
481 
482  fixed_sparse->n = 8;
483  for (i = 0; i < 4; i++) {
484  const int pos1 = (pulse_position[i] << 2) + i;
485  const int pos2 = (pulse_position[i + 4] << 2) + i;
486  const float sign = fixed_index[i] ? -1.0 : 1.0;
487  fixed_sparse->x[i ] = pos1;
488  fixed_sparse->x[i + 4] = pos2;
489  fixed_sparse->y[i ] = sign;
490  fixed_sparse->y[i + 4] = pos2 < pos1 ? -sign : sign;
491  }
492 }
493 
494 /**
495  * Decode the algebraic codebook index to pulse positions and signs,
496  * then construct the algebraic codebook vector.
497  *
498  * nb of pulses | bits encoding pulses
499  * For MODE_4k75 or MODE_5k15, 2 | 1-3, 4-6, 7
500  * MODE_5k9, 2 | 1, 2-4, 5-6, 7-9
501  * MODE_6k7, 3 | 1-3, 4, 5-7, 8, 9-11
502  * MODE_7k4 or MODE_7k95, 4 | 1-3, 4-6, 7-9, 10, 11-13
503  *
504  * @param fixed_sparse pointer to the algebraic codebook vector
505  * @param pulses algebraic codebook indexes
506  * @param mode mode of the current frame
507  * @param subframe current subframe number
508  */
509 static void decode_fixed_sparse(AMRFixed *fixed_sparse, const uint16_t *pulses,
510  const enum Mode mode, const int subframe)
511 {
512  av_assert1(MODE_4k75 <= (signed)mode && mode <= MODE_12k2);
513 
514  if (mode == MODE_12k2) {
515  ff_decode_10_pulses_35bits(pulses, fixed_sparse, gray_decode, 5, 3);
516  } else if (mode == MODE_10k2) {
517  decode_8_pulses_31bits(pulses, fixed_sparse);
518  } else {
519  int *pulse_position = fixed_sparse->x;
520  int i, pulse_subset;
521  const int fixed_index = pulses[0];
522 
523  if (mode <= MODE_5k15) {
524  pulse_subset = ((fixed_index >> 3) & 8) + (subframe << 1);
525  pulse_position[0] = ( fixed_index & 7) * 5 + track_position[pulse_subset];
526  pulse_position[1] = ((fixed_index >> 3) & 7) * 5 + track_position[pulse_subset + 1];
527  fixed_sparse->n = 2;
528  } else if (mode == MODE_5k9) {
529  pulse_subset = ((fixed_index & 1) << 1) + 1;
530  pulse_position[0] = ((fixed_index >> 1) & 7) * 5 + pulse_subset;
531  pulse_subset = (fixed_index >> 4) & 3;
532  pulse_position[1] = ((fixed_index >> 6) & 7) * 5 + pulse_subset + (pulse_subset == 3 ? 1 : 0);
533  fixed_sparse->n = pulse_position[0] == pulse_position[1] ? 1 : 2;
534  } else if (mode == MODE_6k7) {
535  pulse_position[0] = (fixed_index & 7) * 5;
536  pulse_subset = (fixed_index >> 2) & 2;
537  pulse_position[1] = ((fixed_index >> 4) & 7) * 5 + pulse_subset + 1;
538  pulse_subset = (fixed_index >> 6) & 2;
539  pulse_position[2] = ((fixed_index >> 8) & 7) * 5 + pulse_subset + 2;
540  fixed_sparse->n = 3;
541  } else { // mode <= MODE_7k95
542  pulse_position[0] = gray_decode[ fixed_index & 7];
543  pulse_position[1] = gray_decode[(fixed_index >> 3) & 7] + 1;
544  pulse_position[2] = gray_decode[(fixed_index >> 6) & 7] + 2;
545  pulse_subset = (fixed_index >> 9) & 1;
546  pulse_position[3] = gray_decode[(fixed_index >> 10) & 7] + pulse_subset + 3;
547  fixed_sparse->n = 4;
548  }
549  for (i = 0; i < fixed_sparse->n; i++)
550  fixed_sparse->y[i] = (pulses[1] >> i) & 1 ? 1.0 : -1.0;
551  }
552 }
553 
554 /**
555  * Apply pitch lag to obtain the sharpened fixed vector (section 6.1.2)
556  *
557  * @param p the context
558  * @param subframe unpacked amr subframe
559  * @param mode mode of the current frame
560  * @param fixed_sparse sparse representation of the fixed vector
561  */
562 static void pitch_sharpening(AMRContext *p, int subframe, enum Mode mode,
563  AMRFixed *fixed_sparse)
564 {
565  // The spec suggests the current pitch gain is always used, but in other
566  // modes the pitch and codebook gains are jointly quantized (sec 5.8.2)
567  // so the codebook gain cannot depend on the quantized pitch gain.
568  if (mode == MODE_12k2)
569  p->beta = FFMIN(p->pitch_gain[4], 1.0);
570 
571  fixed_sparse->pitch_lag = p->pitch_lag_int;
572  fixed_sparse->pitch_fac = p->beta;
573 
574  // Save pitch sharpening factor for the next subframe
575  // MODE_4k75 only updates on the 2nd and 4th subframes - this follows from
576  // the fact that the gains for two subframes are jointly quantized.
577  if (mode != MODE_4k75 || subframe & 1)
578  p->beta = av_clipf(p->pitch_gain[4], 0.0, SHARP_MAX);
579 }
580 /// @}
581 
582 
583 /// @name AMR gain decoding functions
584 /// @{
585 
586 /**
587  * fixed gain smoothing
588  * Note that where the spec specifies the "spectrum in the q domain"
589  * in section 6.1.4, in fact frequencies should be used.
590  *
591  * @param p the context
592  * @param lsf LSFs for the current subframe, in the range [0,1]
593  * @param lsf_avg averaged LSFs
594  * @param mode mode of the current frame
595  *
596  * @return fixed gain smoothed
597  */
598 static float fixed_gain_smooth(AMRContext *p , const float *lsf,
599  const float *lsf_avg, const enum Mode mode)
600 {
601  float diff = 0.0;
602  int i;
603 
604  for (i = 0; i < LP_FILTER_ORDER; i++)
605  diff += fabs(lsf_avg[i] - lsf[i]) / lsf_avg[i];
606 
607  // If diff is large for ten subframes, disable smoothing for a 40-subframe
608  // hangover period.
609  p->diff_count++;
610  if (diff <= 0.65)
611  p->diff_count = 0;
612 
613  if (p->diff_count > 10) {
614  p->hang_count = 0;
615  p->diff_count--; // don't let diff_count overflow
616  }
617 
618  if (p->hang_count < 40) {
619  p->hang_count++;
620  } else if (mode < MODE_7k4 || mode == MODE_10k2) {
621  const float smoothing_factor = av_clipf(4.0 * diff - 1.6, 0.0, 1.0);
622  const float fixed_gain_mean = (p->fixed_gain[0] + p->fixed_gain[1] +
623  p->fixed_gain[2] + p->fixed_gain[3] +
624  p->fixed_gain[4]) * 0.2;
625  return smoothing_factor * p->fixed_gain[4] +
626  (1.0 - smoothing_factor) * fixed_gain_mean;
627  }
628  return p->fixed_gain[4];
629 }
630 
631 /**
632  * Decode pitch gain and fixed gain factor (part of section 6.1.3).
633  *
634  * @param p the context
635  * @param amr_subframe unpacked amr subframe
636  * @param mode mode of the current frame
637  * @param subframe current subframe number
638  * @param fixed_gain_factor decoded gain correction factor
639  */
640 static void decode_gains(AMRContext *p, const AMRNBSubframe *amr_subframe,
641  const enum Mode mode, const int subframe,
642  float *fixed_gain_factor)
643 {
644  if (mode == MODE_12k2 || mode == MODE_7k95) {
645  p->pitch_gain[4] = qua_gain_pit [amr_subframe->p_gain ]
646  * (1.0 / 16384.0);
647  *fixed_gain_factor = qua_gain_code[amr_subframe->fixed_gain]
648  * (1.0 / 2048.0);
649  } else {
650  const uint16_t *gains;
651 
652  if (mode >= MODE_6k7) {
653  gains = gains_high[amr_subframe->p_gain];
654  } else if (mode >= MODE_5k15) {
655  gains = gains_low [amr_subframe->p_gain];
656  } else {
657  // gain index is only coded in subframes 0,2 for MODE_4k75
658  gains = gains_MODE_4k75[(p->frame.subframe[subframe & 2].p_gain << 1) + (subframe & 1)];
659  }
660 
661  p->pitch_gain[4] = gains[0] * (1.0 / 16384.0);
662  *fixed_gain_factor = gains[1] * (1.0 / 4096.0);
663  }
664 }
665 
666 /// @}
667 
668 
669 /// @name AMR preprocessing functions
670 /// @{
671 
672 /**
673  * Circularly convolve a sparse fixed vector with a phase dispersion impulse
674  * response filter (D.6.2 of G.729 and 6.1.5 of AMR).
675  *
676  * @param out vector with filter applied
677  * @param in source vector
678  * @param filter phase filter coefficients
679  *
680  * out[n] = sum(i,0,len-1){ in[i] * filter[(len + n - i)%len] }
681  */
682 static void apply_ir_filter(float *out, const AMRFixed *in,
683  const float *filter)
684 {
685  float filter1[AMR_SUBFRAME_SIZE], ///< filters at pitch lag*1 and *2
686  filter2[AMR_SUBFRAME_SIZE];
687  int lag = in->pitch_lag;
688  float fac = in->pitch_fac;
689  int i;
690 
691  if (lag < AMR_SUBFRAME_SIZE) {
694 
695  if (lag < AMR_SUBFRAME_SIZE >> 1)
696  ff_celp_circ_addf(filter2, filter, filter1, lag, fac,
698  }
699 
700  memset(out, 0, sizeof(float) * AMR_SUBFRAME_SIZE);
701  for (i = 0; i < in->n; i++) {
702  int x = in->x[i];
703  float y = in->y[i];
704  const float *filterp;
705 
706  if (x >= AMR_SUBFRAME_SIZE - lag) {
707  filterp = filter;
708  } else if (x >= AMR_SUBFRAME_SIZE - (lag << 1)) {
709  filterp = filter1;
710  } else
711  filterp = filter2;
712 
713  ff_celp_circ_addf(out, out, filterp, x, y, AMR_SUBFRAME_SIZE);
714  }
715 }
716 
717 /**
718  * Reduce fixed vector sparseness by smoothing with one of three IR filters.
719  * Also know as "adaptive phase dispersion".
720  *
721  * This implements 3GPP TS 26.090 section 6.1(5).
722  *
723  * @param p the context
724  * @param fixed_sparse algebraic codebook vector
725  * @param fixed_vector unfiltered fixed vector
726  * @param fixed_gain smoothed gain
727  * @param out space for modified vector if necessary
728  */
729 static const float *anti_sparseness(AMRContext *p, AMRFixed *fixed_sparse,
730  const float *fixed_vector,
731  float fixed_gain, float *out)
732 {
733  int ir_filter_nr;
734 
735  if (p->pitch_gain[4] < 0.6) {
736  ir_filter_nr = 0; // strong filtering
737  } else if (p->pitch_gain[4] < 0.9) {
738  ir_filter_nr = 1; // medium filtering
739  } else
740  ir_filter_nr = 2; // no filtering
741 
742  // detect 'onset'
743  if (fixed_gain > 2.0 * p->prev_sparse_fixed_gain) {
744  p->ir_filter_onset = 2;
745  } else if (p->ir_filter_onset)
746  p->ir_filter_onset--;
747 
748  if (!p->ir_filter_onset) {
749  int i, count = 0;
750 
751  for (i = 0; i < 5; i++)
752  if (p->pitch_gain[i] < 0.6)
753  count++;
754  if (count > 2)
755  ir_filter_nr = 0;
756 
757  if (ir_filter_nr > p->prev_ir_filter_nr + 1)
758  ir_filter_nr--;
759  } else if (ir_filter_nr < 2)
760  ir_filter_nr++;
761 
762  // Disable filtering for very low level of fixed_gain.
763  // Note this step is not specified in the technical description but is in
764  // the reference source in the function Ph_disp.
765  if (fixed_gain < 5.0)
766  ir_filter_nr = 2;
767 
769  && ir_filter_nr < 2) {
770  apply_ir_filter(out, fixed_sparse,
771  (p->cur_frame_mode == MODE_7k95 ?
773  ir_filters_lookup)[ir_filter_nr]);
774  fixed_vector = out;
775  }
776 
777  // update ir filter strength history
778  p->prev_ir_filter_nr = ir_filter_nr;
779  p->prev_sparse_fixed_gain = fixed_gain;
780 
781  return fixed_vector;
782 }
783 
784 /// @}
785 
786 
787 /// @name AMR synthesis functions
788 /// @{
789 
790 /**
791  * Conduct 10th order linear predictive coding synthesis.
792  *
793  * @param p pointer to the AMRContext
794  * @param lpc pointer to the LPC coefficients
795  * @param fixed_gain fixed codebook gain for synthesis
796  * @param fixed_vector algebraic codebook vector
797  * @param samples pointer to the output speech samples
798  * @param overflow 16-bit overflow flag
799  */
800 static int synthesis(AMRContext *p, float *lpc,
801  float fixed_gain, const float *fixed_vector,
802  float *samples, uint8_t overflow)
803 {
804  int i;
805  float excitation[AMR_SUBFRAME_SIZE];
806 
807  // if an overflow has been detected, the pitch vector is scaled down by a
808  // factor of 4
809  if (overflow)
810  for (i = 0; i < AMR_SUBFRAME_SIZE; i++)
811  p->pitch_vector[i] *= 0.25;
812 
813  p->acelpv_ctx.weighted_vector_sumf(excitation, p->pitch_vector, fixed_vector,
814  p->pitch_gain[4], fixed_gain, AMR_SUBFRAME_SIZE);
815 
816  // emphasize pitch vector contribution
817  if (p->pitch_gain[4] > 0.5 && !overflow) {
818  float energy = p->celpm_ctx.dot_productf(excitation, excitation,
820  float pitch_factor =
821  p->pitch_gain[4] *
822  (p->cur_frame_mode == MODE_12k2 ?
823  0.25 * FFMIN(p->pitch_gain[4], 1.0) :
824  0.5 * FFMIN(p->pitch_gain[4], SHARP_MAX));
825 
826  for (i = 0; i < AMR_SUBFRAME_SIZE; i++)
827  excitation[i] += pitch_factor * p->pitch_vector[i];
828 
829  ff_scale_vector_to_given_sum_of_squares(excitation, excitation, energy,
831  }
832 
833  p->celpf_ctx.celp_lp_synthesis_filterf(samples, lpc, excitation,
836 
837  // detect overflow
838  for (i = 0; i < AMR_SUBFRAME_SIZE; i++)
839  if (fabsf(samples[i]) > AMR_SAMPLE_BOUND) {
840  return 1;
841  }
842 
843  return 0;
844 }
845 
846 /// @}
847 
848 
849 /// @name AMR update functions
850 /// @{
851 
852 /**
853  * Update buffers and history at the end of decoding a subframe.
854  *
855  * @param p pointer to the AMRContext
856  */
857 static void update_state(AMRContext *p)
858 {
859  memcpy(p->prev_lsp_sub4, p->lsp[3], LP_FILTER_ORDER * sizeof(p->lsp[3][0]));
860 
861  memmove(&p->excitation_buf[0], &p->excitation_buf[AMR_SUBFRAME_SIZE],
862  (PITCH_DELAY_MAX + LP_FILTER_ORDER + 1) * sizeof(float));
863 
864  memmove(&p->pitch_gain[0], &p->pitch_gain[1], 4 * sizeof(float));
865  memmove(&p->fixed_gain[0], &p->fixed_gain[1], 4 * sizeof(float));
866 
867  memmove(&p->samples_in[0], &p->samples_in[AMR_SUBFRAME_SIZE],
868  LP_FILTER_ORDER * sizeof(float));
869 }
870 
871 /// @}
872 
873 
874 /// @name AMR Postprocessing functions
875 /// @{
876 
877 /**
878  * Get the tilt factor of a formant filter from its transfer function
879  *
880  * @param p The Context
881  * @param lpc_n LP_FILTER_ORDER coefficients of the numerator
882  * @param lpc_d LP_FILTER_ORDER coefficients of the denominator
883  */
884 static float tilt_factor(AMRContext *p, float *lpc_n, float *lpc_d)
885 {
886  float rh0, rh1; // autocorrelation at lag 0 and 1
887 
888  // LP_FILTER_ORDER prior zeros are needed for ff_celp_lp_synthesis_filterf
889  float impulse_buffer[LP_FILTER_ORDER + AMR_TILT_RESPONSE] = { 0 };
890  float *hf = impulse_buffer + LP_FILTER_ORDER; // start of impulse response
891 
892  hf[0] = 1.0;
893  memcpy(hf + 1, lpc_n, sizeof(float) * LP_FILTER_ORDER);
894  p->celpf_ctx.celp_lp_synthesis_filterf(hf, lpc_d, hf,
897 
898  rh0 = p->celpm_ctx.dot_productf(hf, hf, AMR_TILT_RESPONSE);
899  rh1 = p->celpm_ctx.dot_productf(hf, hf + 1, AMR_TILT_RESPONSE - 1);
900 
901  // The spec only specifies this check for 12.2 and 10.2 kbit/s
902  // modes. But in the ref source the tilt is always non-negative.
903  return rh1 >= 0.0 ? rh1 / rh0 * AMR_TILT_GAMMA_T : 0.0;
904 }
905 
906 /**
907  * Perform adaptive post-filtering to enhance the quality of the speech.
908  * See section 6.2.1.
909  *
910  * @param p pointer to the AMRContext
911  * @param lpc interpolated LP coefficients for this subframe
912  * @param buf_out output of the filter
913  */
914 static void postfilter(AMRContext *p, float *lpc, float *buf_out)
915 {
916  int i;
917  float *samples = p->samples_in + LP_FILTER_ORDER; // Start of input
918 
919  float speech_gain = p->celpm_ctx.dot_productf(samples, samples,
921 
922  float pole_out[AMR_SUBFRAME_SIZE + LP_FILTER_ORDER]; // Output of pole filter
923  const float *gamma_n, *gamma_d; // Formant filter factor table
924  float lpc_n[LP_FILTER_ORDER], lpc_d[LP_FILTER_ORDER]; // Transfer function coefficients
925 
926  if (p->cur_frame_mode == MODE_12k2 || p->cur_frame_mode == MODE_10k2) {
927  gamma_n = ff_pow_0_7;
928  gamma_d = ff_pow_0_75;
929  } else {
930  gamma_n = ff_pow_0_55;
931  gamma_d = ff_pow_0_7;
932  }
933 
934  for (i = 0; i < LP_FILTER_ORDER; i++) {
935  lpc_n[i] = lpc[i] * gamma_n[i];
936  lpc_d[i] = lpc[i] * gamma_d[i];
937  }
938 
939  memcpy(pole_out, p->postfilter_mem, sizeof(float) * LP_FILTER_ORDER);
942  memcpy(p->postfilter_mem, pole_out + AMR_SUBFRAME_SIZE,
943  sizeof(float) * LP_FILTER_ORDER);
944 
945  p->celpf_ctx.celp_lp_zero_synthesis_filterf(buf_out, lpc_n,
946  pole_out + LP_FILTER_ORDER,
948 
949  ff_tilt_compensation(&p->tilt_mem, tilt_factor(p, lpc_n, lpc_d), buf_out,
951 
952  ff_adaptive_gain_control(buf_out, buf_out, speech_gain, AMR_SUBFRAME_SIZE,
954 }
955 
956 /// @}
957 
959  int *got_frame_ptr, AVPacket *avpkt)
960 {
961 
962  AMRChannelsContext *s = avctx->priv_data; // pointer to private data
963  const uint8_t *buf = avpkt->data;
964  int buf_size = avpkt->size;
965  int ret;
966 
967  /* get output buffer */
968  frame->nb_samples = AMR_BLOCK_SIZE;
969  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
970  return ret;
971 
972  for (int ch = 0; ch < avctx->ch_layout.nb_channels; ch++) {
973  AMRContext *p = &s->ch[ch];
974  float fixed_gain_factor;
975  AMRFixed fixed_sparse = {0}; // fixed vector up to anti-sparseness processing
976  float spare_vector[AMR_SUBFRAME_SIZE]; // extra stack space to hold result from anti-sparseness processing
977  float synth_fixed_gain; // the fixed gain that synthesis should use
978  const float *synth_fixed_vector; // pointer to the fixed vector that synthesis should use
979  float *buf_out = (float *)frame->extended_data[ch];
980  int channel_size;
981  int i, subframe;
982 
983  p->cur_frame_mode = unpack_bitstream(p, buf, buf_size);
984  if (p->cur_frame_mode == NO_DATA) {
985  av_log(avctx, AV_LOG_ERROR, "Corrupt bitstream\n");
986  return AVERROR_INVALIDDATA;
987  }
988  if (p->cur_frame_mode == MODE_DTX) {
989  avpriv_report_missing_feature(avctx, "dtx mode");
990  av_log(avctx, AV_LOG_INFO, "Note: libopencore_amrnb supports dtx\n");
991  return AVERROR_PATCHWELCOME;
992  }
993 
994  channel_size = frame_sizes_nb[p->cur_frame_mode] + 1; // +7 for rounding and +8 for TOC
995  if (p->cur_frame_mode == MODE_12k2) {
996  lsf2lsp_5(p);
997  } else
998  lsf2lsp_3(p);
999 
1000  for (i = 0; i < 4; i++)
1001  ff_acelp_lspd2lpc(p->lsp[i], p->lpc[i], 5);
1002 
1003  for (subframe = 0; subframe < 4; subframe++) {
1004  const AMRNBSubframe *amr_subframe = &p->frame.subframe[subframe];
1005 
1006  decode_pitch_vector(p, amr_subframe, subframe);
1007 
1008  decode_fixed_sparse(&fixed_sparse, amr_subframe->pulses,
1009  p->cur_frame_mode, subframe);
1010 
1011  // The fixed gain (section 6.1.3) depends on the fixed vector
1012  // (section 6.1.2), but the fixed vector calculation uses
1013  // pitch sharpening based on the on the pitch gain (section 6.1.3).
1014  // So the correct order is: pitch gain, pitch sharpening, fixed gain.
1015  decode_gains(p, amr_subframe, p->cur_frame_mode, subframe,
1016  &fixed_gain_factor);
1017 
1018  pitch_sharpening(p, subframe, p->cur_frame_mode, &fixed_sparse);
1019 
1020  if (fixed_sparse.pitch_lag == 0) {
1021  av_log(avctx, AV_LOG_ERROR, "The file is corrupted, pitch_lag = 0 is not allowed\n");
1022  return AVERROR_INVALIDDATA;
1023  }
1024  ff_set_fixed_vector(p->fixed_vector, &fixed_sparse, 1.0,
1026 
1027  p->fixed_gain[4] =
1028  ff_amr_set_fixed_gain(fixed_gain_factor,
1030  p->fixed_vector,
1033  p->prediction_error,
1035 
1036  // The excitation feedback is calculated without any processing such
1037  // as fixed gain smoothing. This isn't mentioned in the specification.
1038  for (i = 0; i < AMR_SUBFRAME_SIZE; i++)
1039  p->excitation[i] *= p->pitch_gain[4];
1040  ff_set_fixed_vector(p->excitation, &fixed_sparse, p->fixed_gain[4],
1042 
1043  // In the ref decoder, excitation is stored with no fractional bits.
1044  // This step prevents buzz in silent periods. The ref encoder can
1045  // emit long sequences with pitch factor greater than one. This
1046  // creates unwanted feedback if the excitation vector is nonzero.
1047  // (e.g. test sequence T19_795.COD in 3GPP TS 26.074)
1048  for (i = 0; i < AMR_SUBFRAME_SIZE; i++)
1049  p->excitation[i] = truncf(p->excitation[i]);
1050 
1051  // Smooth fixed gain.
1052  // The specification is ambiguous, but in the reference source, the
1053  // smoothed value is NOT fed back into later fixed gain smoothing.
1054  synth_fixed_gain = fixed_gain_smooth(p, p->lsf_q[subframe],
1055  p->lsf_avg, p->cur_frame_mode);
1056 
1057  synth_fixed_vector = anti_sparseness(p, &fixed_sparse, p->fixed_vector,
1058  synth_fixed_gain, spare_vector);
1059 
1060  if (synthesis(p, p->lpc[subframe], synth_fixed_gain,
1061  synth_fixed_vector, &p->samples_in[LP_FILTER_ORDER], 0))
1062  // overflow detected -> rerun synthesis scaling pitch vector down
1063  // by a factor of 4, skipping pitch vector contribution emphasis
1064  // and adaptive gain control
1065  synthesis(p, p->lpc[subframe], synth_fixed_gain,
1066  synth_fixed_vector, &p->samples_in[LP_FILTER_ORDER], 1);
1067 
1068  postfilter(p, p->lpc[subframe], buf_out + subframe * AMR_SUBFRAME_SIZE);
1069 
1070  // update buffers and history
1072  update_state(p);
1073  }
1074 
1076  buf_out, highpass_zeros,
1080 
1081  /* Update averaged lsf vector (used for fixed gain smoothing).
1082  *
1083  * Note that lsf_avg should not incorporate the current frame's LSFs
1084  * for fixed_gain_smooth.
1085  * The specification has an incorrect formula: the reference decoder uses
1086  * qbar(n-1) rather than qbar(n) in section 6.1(4) equation 71. */
1088  0.84, 0.16, LP_FILTER_ORDER);
1089  buf += channel_size;
1090  buf_size -= channel_size;
1091  }
1092 
1093  *got_frame_ptr = 1;
1094 
1095  return avpkt->size;
1096 }
1097 
1098 
1100  .p.name = "amrnb",
1101  .p.long_name = NULL_IF_CONFIG_SMALL("AMR-NB (Adaptive Multi-Rate NarrowBand)"),
1102  .p.type = AVMEDIA_TYPE_AUDIO,
1103  .p.id = AV_CODEC_ID_AMR_NB,
1104  .priv_data_size = sizeof(AMRChannelsContext),
1107  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
1108  .p.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLTP,
1110 };
AMRNBSubframe::p_gain
uint16_t p_gain
index to decode the pitch gain
Definition: amrnbdata.h:60
lsf_3_1_MODE_7k95
static const int16_t lsf_3_1_MODE_7k95[512][3]
Definition: amrnbdata.h:459
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:66
AMRContext::excitation_buf
float excitation_buf[PITCH_DELAY_MAX+LP_FILTER_ORDER+1+AMR_SUBFRAME_SIZE]
current excitation and all necessary excitation history
Definition: amrnbdec.c:117
AMRFixed::x
int x[10]
Definition: acelp_vectors.h:55
AMRNBSubframe::pulses
uint16_t pulses[10]
pulses: 10 for MODE_12k2, 7 for MODE_10k2, and index and sign for others
Definition: amrnbdata.h:62
av_clip
#define av_clip
Definition: common.h:95
track_position
static const uint8_t track_position[16]
track start positions for algebraic code book routines
Definition: amrnbdata.h:1428
acelp_vectors.h
anti_sparseness
static const float * anti_sparseness(AMRContext *p, AMRFixed *fixed_sparse, const float *fixed_vector, float fixed_gain, float *out)
Reduce fixed vector sparseness by smoothing with one of three IR filters.
Definition: amrnbdec.c:729
ff_amr_set_fixed_gain
float ff_amr_set_fixed_gain(float fixed_gain_factor, float fixed_mean_energy, float *prediction_error, float energy_mean, const float *pred_table)
Calculate fixed gain (part of section 6.1.3 of AMR spec)
Definition: acelp_pitch_delay.c:84
gray_decode
static const uint8_t gray_decode[8]
3-bit Gray code to binary lookup table
Definition: amrnbdata.h:1433
lsf_5_3
static const int16_t lsf_5_3[256][4]
Definition: amrnbdata.h:1206
AMRContext::prev_lsp_sub4
double prev_lsp_sub4[LP_FILTER_ORDER]
lsp vector for the 4th subframe of the previous frame
Definition: amrnbdec.c:108
out
FILE * out
Definition: movenc.c:54
ff_decode_pitch_lag
void ff_decode_pitch_lag(int *lag_int, int *lag_frac, int pitch_index, const int prev_lag_int, const int subframe, int third_as_first, int resolution)
Decode the adaptive codebook index to the integer and fractional parts of the pitch lag for one subfr...
Definition: acelp_pitch_delay.c:105
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1007
filter1
static void filter1(SUINT32 *dst, const int32_t *src, int32_t coeff, ptrdiff_t len)
Definition: dcadsp.c:358
MODE_7k95
@ MODE_7k95
7.95 kbit/s
Definition: amrnbdata.h:45
MODE_10k2
@ MODE_10k2
10.2 kbit/s
Definition: amrnbdata.h:46
AMRContext::acelpf_ctx
ACELPFContext acelpf_ctx
context for filters for ACELP-based codecs
Definition: amrnbdec.c:142
lsf_3_2
static const int16_t lsf_3_2[512][3]
Definition: amrnbdata.h:723
ff_b60_sinc
const float ff_b60_sinc[61]
b60 hamming windowed sinc function coefficients
Definition: acelp_vectors.c:103
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
AMRChannelsContext::ch
AMRContext ch[2]
Definition: amrnbdec.c:150
internal.h
PITCH_LAG_MIN_MODE_12k2
#define PITCH_LAG_MIN_MODE_12k2
Lower bound on decoded lag search in 12.2kbit/s mode.
Definition: amrnbdec.c:82
AVPacket::data
uint8_t * data
Definition: packet.h:374
AV_CHANNEL_LAYOUT_MONO
#define AV_CHANNEL_LAYOUT_MONO
Definition: channel_layout.h:353
AV_CODEC_ID_AMR_NB
@ AV_CODEC_ID_AMR_NB
Definition: codec_id.h:412
FFCodec
Definition: codec_internal.h:118
ff_acelp_filter_init
void ff_acelp_filter_init(ACELPFContext *c)
Initialize ACELPFContext.
Definition: acelp_filters.c:150
frame_sizes_nb
static const uint8_t frame_sizes_nb[N_MODES]
number of bytes for each mode
Definition: amrnbdata.h:357
AMR_SAMPLE_SCALE
#define AMR_SAMPLE_SCALE
Scale from constructed speech to [-1,1].
Definition: amrnbdec.c:75
filter
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce then the filter should push the output frames on the output link immediately As an exception to the previous rule if the input frame is enough to produce several output frames then the filter needs output only at least one per link The additional frames can be left buffered in the filter
Definition: filter_design.txt:228
qua_gain_code
static const uint16_t qua_gain_code[32]
scalar quantized fixed gain table for 7.95 and 12.2 kbps modes
Definition: amrnbdata.h:1445
CELPFContext::celp_lp_synthesis_filterf
void(* celp_lp_synthesis_filterf)(float *out, const float *filter_coeffs, const float *in, int buffer_length, int filter_length)
LP synthesis filter.
Definition: celp_filters.h:45
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:300
LP_FILTER_ORDER
#define LP_FILTER_ORDER
linear predictive coding filter order
Definition: amrnbdata.h:53
MODE_12k2
@ MODE_12k2
12.2 kbit/s
Definition: amrnbdata.h:47
ff_amrnb_decoder
const FFCodec ff_amrnb_decoder
Definition: amrnbdec.c:1099
SHARP_MAX
#define SHARP_MAX
Maximum sharpening factor.
Definition: amrnbdec.c:92
AMRChannelsContext
Definition: amrnbdec.c:149
init
static int init
Definition: av_tx.c:47
AMRContext::bad_frame_indicator
uint8_t bad_frame_indicator
bad frame ? 1 : 0
Definition: amrnbdec.c:103
AMRContext::prev_ir_filter_nr
uint8_t prev_ir_filter_nr
previous impulse response filter "impNr": 0 - strong, 1 - medium, 2 - none
Definition: amrnbdec.c:132
positions
const static uint16_t positions[][14][3]
Definition: vf_vectorscope.c:817
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:122
PITCH_DELAY_MAX
#define PITCH_DELAY_MAX
Definition: acelp_pitch_delay.h:31
ff_pow_0_55
const float ff_pow_0_55[10]
Table of pow(0.55,n)
Definition: acelp_vectors.c:98
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:2065
AMRFixed::pitch_fac
float pitch_fac
Definition: acelp_vectors.h:59
ff_clear_fixed_vector
void ff_clear_fixed_vector(float *out, const AMRFixed *in, int size)
Clear array values set by set_fixed_vector.
Definition: acelp_vectors.c:243
update
static av_always_inline void update(SilenceDetectContext *s, AVFrame *insamples, int is_silence, int current_sample, int64_t nb_samples_notify, AVRational time_base)
Definition: af_silencedetect.c:78
fabsf
static __device__ float fabsf(float a)
Definition: cuda_runtime.h:181
ff_adaptive_gain_control
void ff_adaptive_gain_control(float *out, const float *in, float speech_energ, int size, float alpha, float *gain_mem)
Adaptive gain control (as used in AMR postfiltering)
Definition: acelp_vectors.c:192
lsf2lsp_5
static void lsf2lsp_5(AMRContext *p)
Decode a set of 5 split-matrix quantized lsf indexes into 2 lsp vectors.
Definition: amrnbdec.c:308
avassert.h
AMRContext::prev_lsf_r
int16_t prev_lsf_r[LP_FILTER_ORDER]
residual LSF vector from previous subframe
Definition: amrnbdec.c:106
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
decode_pitch_lag_1_6
static void decode_pitch_lag_1_6(int *lag_int, int *lag_frac, int pitch_index, const int prev_lag_int, const int subframe)
Like ff_decode_pitch_lag(), but with 1/6 resolution.
Definition: amrnbdec.c:382
AMRContext::postfilter_agc
float postfilter_agc
previous factor used for adaptive gain control
Definition: amrnbdec.c:137
Mode
Mode
Frame type (Table 1a in 3GPP TS 26.101)
Definition: amrnbdata.h:39
ACELPFContext::acelp_interpolatef
void(* acelp_interpolatef)(float *out, const float *in, const float *filter_coeffs, int precision, int frac_pos, int filter_length, int length)
Floating point version of ff_acelp_interpolate()
Definition: acelp_filters.h:32
lsf2lsp_for_mode12k2
static void lsf2lsp_for_mode12k2(AMRContext *p, double lsp[LP_FILTER_ORDER], const float lsf_no_r[LP_FILTER_ORDER], const int16_t *lsf_quantizer[5], const int quantizer_offset, const int sign, const int update)
Decode a set of 5 split-matrix quantized lsf indexes into an lsp vector.
Definition: amrnbdec.c:270
float
float
Definition: af_crystalizer.c:122
MODE_4k75
@ MODE_4k75
4.75 kbit/s
Definition: amrnbdata.h:40
lsf_3_3_MODE_5k15
static const int16_t lsf_3_3_MODE_5k15[128][4]
Definition: amrnbdata.h:413
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:260
AMRNBFrame
AMRNB unpacked data frame.
Definition: amrnbdata.h:68
AMRContext::ir_filter_onset
uint8_t ir_filter_onset
flag for impulse response filter strength
Definition: amrnbdec.c:133
postfilter
static void postfilter(AMRContext *p, float *lpc, float *buf_out)
Perform adaptive post-filtering to enhance the quality of the speech.
Definition: amrnbdec.c:914
s
#define s(width, name)
Definition: cbs_vp9.c:256
energy_pred_fac
static const float energy_pred_fac[4]
4-tap moving average prediction coefficients in reverse order
Definition: amrnbdata.h:1458
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AMRFixed
Sparse representation for the algebraic codebook (fixed) vector.
Definition: acelp_vectors.h:53
MODE_6k7
@ MODE_6k7
6.70 kbit/s
Definition: amrnbdata.h:43
AMRContext::lsp
double lsp[4][LP_FILTER_ORDER]
lsp vectors from current frame
Definition: amrnbdec.c:107
ff_acelp_lsf2lspd
void ff_acelp_lsf2lspd(double *lsp, const float *lsf, int lp_order)
Floating point version of ff_acelp_lsf2lsp()
Definition: lsp.c:93
AMR_AGC_ALPHA
#define AMR_AGC_ALPHA
Adaptive gain control factor used in post-filter.
Definition: amrnbdec.c:99
AMRContext::excitation
float * excitation
pointer to the current excitation vector in excitation_buf
Definition: amrnbdec.c:118
weighted_vector_sumd
static void weighted_vector_sumd(double *out, const double *in_a, const double *in_b, double weight_coeff_a, double weight_coeff_b, int length)
Double version of ff_weighted_vector_sumf()
Definition: amrnbdec.c:154
ctx
AVFormatContext * ctx
Definition: movenc.c:48
AMRNBFrame::subframe
AMRNBSubframe subframe[4]
unpacked data for each subframe
Definition: amrnbdata.h:70
MIN_LSF_SPACING
#define MIN_LSF_SPACING
Ensures stability of LPC filter.
Definition: amrnbdec.c:81
AMRFixed::y
float y[10]
Definition: acelp_vectors.h:56
AMRContext
Definition: amrnbdec.c:101
MODE_5k15
@ MODE_5k15
5.15 kbit/s
Definition: amrnbdata.h:41
AMR_SUBFRAME_SIZE
#define AMR_SUBFRAME_SIZE
samples per subframe
Definition: amrnbdata.h:36
PRED_FAC_MODE_12k2
#define PRED_FAC_MODE_12k2
Prediction factor for 12.2kbit/s mode.
Definition: amrnbdec.c:78
MODE_7k4
@ MODE_7k4
7.40 kbit/s
Definition: amrnbdata.h:44
lsf_5_5
static const int16_t lsf_5_5[64][4]
Definition: amrnbdata.h:1384
AMRContext::frame
AMRNBFrame frame
decoded AMR parameters (lsf coefficients, codebook indexes, etc)
Definition: amrnbdec.c:102
fabs
static __device__ float fabs(float a)
Definition: cuda_runtime.h:182
CELPFContext::celp_lp_zero_synthesis_filterf
void(* celp_lp_zero_synthesis_filterf)(float *out, const float *filter_coeffs, const float *in, int buffer_length, int filter_length)
LP zero synthesis filter.
Definition: celp_filters.h:65
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
AMR_TILT_GAMMA_T
#define AMR_TILT_GAMMA_T
Tilt factor = 1st reflection coefficient * gamma_t.
Definition: amrnbdec.c:97
ir_filters_lookup
static const float *const ir_filters_lookup[2]
Definition: amrnbdata.h:1653
apply_ir_filter
static void apply_ir_filter(float *out, const AMRFixed *in, const float *filter)
Circularly convolve a sparse fixed vector with a phase dispersion impulse response filter (D....
Definition: amrnbdec.c:682
AMRNBFrame::lsf
uint16_t lsf[5]
lsf parameters: 5 parameters for MODE_12k2, only 3 for other modes
Definition: amrnbdata.h:69
ff_decode_10_pulses_35bits
void ff_decode_10_pulses_35bits(const int16_t *fixed_index, AMRFixed *fixed_sparse, const uint8_t *gray_decode, int half_pulse_count, int bits)
Decode the algebraic codebook index to pulse positions and signs and construct the algebraic codebook...
Definition: acelp_vectors.c:141
highpass_zeros
static const float highpass_zeros[2]
Definition: amrnbdata.h:1662
AMRContext::fixed_vector
float fixed_vector[AMR_SUBFRAME_SIZE]
algebraic codebook (fixed) vector (must be kept zero between frames)
Definition: amrnbdec.c:121
celp_filters.h
av_clipf
av_clipf
Definition: af_crystalizer.c:122
unpack_bitstream
static enum Mode unpack_bitstream(AMRContext *p, const uint8_t *buf, int buf_size)
Unpack an RFC4867 speech frame into the AMR frame mode and parameters.
Definition: amrnbdec.c:217
AMRContext::pitch_gain
float pitch_gain[5]
quantified pitch gains for the current and previous four subframes
Definition: amrnbdec.c:124
AMR_TILT_RESPONSE
#define AMR_TILT_RESPONSE
Number of impulse response coefficients used for tilt factor.
Definition: amrnbdec.c:95
float_dsp.h
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:630
decode_pitch_vector
static void decode_pitch_vector(AMRContext *p, const AMRNBSubframe *amr_subframe, const int subframe)
Definition: amrnbdec.c:401
qua_gain_pit
static const uint16_t qua_gain_pit[16]
scalar quantized pitch gain table for 7.95 and 12.2 kbps modes
Definition: amrnbdata.h:1439
update_state
static void update_state(AMRContext *p)
Update buffers and history at the end of decoding a subframe.
Definition: amrnbdec.c:857
ACELPVContext
Definition: acelp_vectors.h:28
ACELPFContext
Definition: acelp_filters.h:28
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:109
AMRNBSubframe::p_lag
uint16_t p_lag
index to decode the pitch lag
Definition: amrnbdata.h:59
ff_acelp_vectors_init
void ff_acelp_vectors_init(ACELPVContext *c)
Initialize ACELPVContext.
Definition: acelp_vectors.c:258
AMRContext::lsf_q
float lsf_q[4][LP_FILTER_ORDER]
Interpolated LSF vector for fixed gain smoothing.
Definition: amrnbdec.c:110
AMRContext::tilt_mem
float tilt_mem
previous input to tilt compensation filter
Definition: amrnbdec.c:136
ff_celp_math_init
void ff_celp_math_init(CELPMContext *c)
Initialize CELPMContext.
Definition: celp_math.c:121
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1462
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:375
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:290
codec_internal.h
gains_high
static const uint16_t gains_high[128][2]
gain table for 6.70, 7.40 and 10.2 kbps modes
Definition: amrnbdata.h:1573
CELPFContext
Definition: celp_filters.h:28
AMRContext::high_pass_mem
float high_pass_mem[2]
previous intermediate values in the high-pass filter
Definition: amrnbdec.c:138
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1023
highpass_poles
static const float highpass_poles[2]
Definition: amrnbdata.h:1663
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
AMRContext::cur_frame_mode
enum Mode cur_frame_mode
Definition: amrnbdec.c:104
celp_math.h
ACELPFContext::acelp_apply_order_2_transfer_function
void(* acelp_apply_order_2_transfer_function)(float *out, const float *in, const float zero_coeffs[2], const float pole_coeffs[2], float gain, float mem[2], int n)
Apply an order 2 rational transfer function in-place.
Definition: acelp_filters.h:47
AMRContext::lpc
float lpc[4][LP_FILTER_ORDER]
lpc coefficient vectors for 4 subframes
Definition: amrnbdec.c:113
pitch_sharpening
static void pitch_sharpening(AMRContext *p, int subframe, enum Mode mode, AMRFixed *fixed_sparse)
Apply pitch lag to obtain the sharpened fixed vector (section 6.1.2)
Definition: amrnbdec.c:562
ff_pow_0_7
const float ff_pow_0_7[10]
Table of pow(0.7,n)
Definition: acelp_vectors.c:88
avpriv_report_missing_feature
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
highpass_gain
static const float highpass_gain
Definition: amrnbdata.h:1664
amrnb_decode_frame
static int amrnb_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)
Definition: amrnbdec.c:958
AMRContext::fixed_gain
float fixed_gain[5]
quantified fixed gains for the current and previous four subframes
Definition: amrnbdec.c:125
gains_MODE_4k75
static const uint16_t gains_MODE_4k75[512][2]
gain table for 4.75 kbps mode
Definition: amrnbdata.h:1464
AMRContext::beta
float beta
previous pitch_gain, bounded by [0.0,SHARP_MAX]
Definition: amrnbdec.c:127
AMRContext::samples_in
float samples_in[LP_FILTER_ORDER+AMR_SUBFRAME_SIZE]
floating point samples
Definition: amrnbdec.c:140
ff_celp_filter_init
void ff_celp_filter_init(CELPFContext *c)
Initialize CELPFContext.
Definition: celp_filters.c:213
ff_tilt_compensation
void ff_tilt_compensation(float *mem, float tilt, float *samples, int size)
Apply tilt compensation filter, 1 - tilt * z-1.
Definition: acelp_filters.c:138
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
lsf_3_3
static const int16_t lsf_3_3[512][4]
Definition: amrnbdata.h:897
AMRNBSubframe::fixed_gain
uint16_t fixed_gain
index to decode the fixed gain factor, for MODE_12k2 and MODE_7k95
Definition: amrnbdata.h:61
AMRContext::pitch_vector
float pitch_vector[AMR_SUBFRAME_SIZE]
adaptive code book (pitch) vector
Definition: amrnbdec.c:120
lsf_5_4
static const int16_t lsf_5_4[256][4]
Definition: amrnbdata.h:1295
interpolate_lsf
static void interpolate_lsf(ACELPVContext *ctx, float lsf_q[4][LP_FILTER_ORDER], float *lsf_new)
Interpolate the LSF vector (used for fixed gain smoothing).
Definition: amrnbdec.c:249
lsf_3_mean
static const float lsf_3_mean[LP_FILTER_ORDER]
Definition: amrnbdata.h:1409
fixed_gain_smooth
static float fixed_gain_smooth(AMRContext *p, const float *lsf, const float *lsf_avg, const enum Mode mode)
fixed gain smoothing Note that where the spec specifies the "spectrum in the q domain" in section 6....
Definition: amrnbdec.c:598
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
synthesis
static int synthesis(AMRContext *p, float *lpc, float fixed_gain, const float *fixed_vector, float *samples, uint8_t overflow)
Conduct 10th order linear predictive coding synthesis.
Definition: amrnbdec.c:800
NO_DATA
@ NO_DATA
no transmission
Definition: amrnbdata.h:50
decode_fixed_sparse
static void decode_fixed_sparse(AMRFixed *fixed_sparse, const uint16_t *pulses, const enum Mode mode, const int subframe)
Decode the algebraic codebook index to pulse positions and signs, then construct the algebraic codebo...
Definition: amrnbdec.c:509
lsf_5_2
static const int16_t lsf_5_2[256][4]
Definition: amrnbdata.h:1117
LSF_R_FAC
#define LSF_R_FAC
LSF residual tables to Hertz.
Definition: amrnbdec.c:80
AMRContext::pitch_lag_int
uint8_t pitch_lag_int
integer part of pitch lag from current subframe
Definition: amrnbdec.c:115
lsp_avg_init
static const int16_t lsp_avg_init[LP_FILTER_ORDER]
Mean lsp values.
Definition: amrnbdata.h:404
common.h
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:55
pred_fac
static const float pred_fac[LP_FILTER_ORDER]
Prediction factor table for modes other than 12.2kbit/s.
Definition: amrnbdata.h:1420
ff_pow_0_75
const float ff_pow_0_75[10]
Table of pow(0.75,n)
Definition: acelp_vectors.c:93
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
lsf_5_1
static const int16_t lsf_5_1[128][4]
Definition: amrnbdata.h:1071
acelp_filters.h
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:211
amr.h
AMRContext::hang_count
uint8_t hang_count
the number of subframes since a hangover period started
Definition: amrnbdec.c:129
avcodec.h
ret
ret
Definition: filter_design.txt:187
lsf2lsp_3
static void lsf2lsp_3(AMRContext *p)
Decode a set of 3 split-matrix quantized lsf indexes into an lsp vector.
Definition: amrnbdec.c:337
lsf_5_mean
static const float lsf_5_mean[LP_FILTER_ORDER]
Definition: amrnbdata.h:1414
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
lsp.h
AMRContext::prediction_error
float prediction_error[4]
quantified prediction errors {20log10(^gamma_gc)} for previous four subframes
Definition: amrnbdec.c:123
AMRFixed::n
int n
Definition: acelp_vectors.h:54
CELPMContext
Definition: celp_math.h:28
ir_filters_lookup_MODE_7k95
static const float *const ir_filters_lookup_MODE_7k95[2]
Definition: amrnbdata.h:1656
ff_celp_circ_addf
void ff_celp_circ_addf(float *out, const float *in, const float *lagged, int lag, float fac, int n)
Add an array to a rotated array.
Definition: celp_filters.c:51
energy_mean
static const float energy_mean[8]
desired mean innovation energy, indexed by active mode
Definition: amrnbdata.h:1453
MODE_DTX
@ MODE_DTX
silent frame
Definition: amrnbdata.h:48
AVCodecContext
main external API structure.
Definition: avcodec.h:398
channel_layout.h
AMR_BLOCK_SIZE
#define AMR_BLOCK_SIZE
samples per frame
Definition: amrnbdec.c:63
AMRContext::diff_count
uint8_t diff_count
the number of subframes for which diff has been above 0.65
Definition: amrnbdec.c:128
mode
mode
Definition: ebur128.h:83
amrnbdata.h
lsf_3_1
static const int16_t lsf_3_1[256][3]
Definition: amrnbdata.h:633
MODE_5k9
@ MODE_5k9
5.90 kbit/s
Definition: amrnbdata.h:42
temp
else temp
Definition: vf_mcdeint.c:248
ff_set_fixed_vector
void ff_set_fixed_vector(float *out, const AMRFixed *in, float scale, int size)
Add fixed vector to an array from a sparse representation.
Definition: acelp_vectors.c:224
samples
Filter the word “frame” indicates either a video frame or a group of audio samples
Definition: filter_design.txt:8
ff_amr_bit_reorder
static void ff_amr_bit_reorder(uint16_t *out, int size, const uint8_t *data, const R_TABLE_TYPE *ord_table)
Fill the frame structure variables from bitstream by parsing the given reordering table that uses the...
Definition: amr.h:51
base_five_table
static const uint8_t base_five_table[128][3]
Base-5 representation for values 0-124.
Definition: amrnbdata.h:367
N_MODES
@ N_MODES
number of modes
Definition: amrnbdata.h:49
AMRContext::acelpv_ctx
ACELPVContext acelpv_ctx
context for vector operations for ACELP-based codecs
Definition: amrnbdec.c:143
CELPMContext::dot_productf
float(* dot_productf)(const float *a, const float *b, int length)
Return the dot product.
Definition: celp_math.h:37
AMRContext::celpf_ctx
CELPFContext celpf_ctx
context for filters for CELP-based codecs
Definition: amrnbdec.c:144
overflow
Undefined Behavior In the C some operations are like signed integer overflow
Definition: undefined.txt:3
AMRContext::prev_sparse_fixed_gain
float prev_sparse_fixed_gain
previous fixed gain; used by anti-sparseness processing to determine "onset"
Definition: amrnbdec.c:131
diff
static av_always_inline int diff(const uint32_t a, const uint32_t b)
Definition: vf_palettegen.c:139
gains_low
static const uint16_t gains_low[64][2]
gain table for 5.15 and 5.90 kbps modes
Definition: amrnbdata.h:1605
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:425
decode_8_pulses_31bits
static void decode_8_pulses_31bits(const int16_t *fixed_index, AMRFixed *fixed_sparse)
Decode the algebraic codebook index to pulse positions and signs and construct the algebraic codebook...
Definition: amrnbdec.c:463
tilt_factor
static float tilt_factor(AMRContext *p, float *lpc_n, float *lpc_d)
Get the tilt factor of a formant filter from its transfer function.
Definition: amrnbdec.c:884
AMRFixed::pitch_lag
int pitch_lag
Definition: acelp_vectors.h:58
decode_10bit_pulse
static void decode_10bit_pulse(int code, int pulse_position[8], int i1, int i2, int i3)
Decode a 10-bit algebraic codebook index from a 10.2 kbit/s frame.
Definition: amrnbdec.c:445
ff_scale_vector_to_given_sum_of_squares
void ff_scale_vector_to_given_sum_of_squares(float *out, const float *in, float sum_of_squares, const int n)
Set the sum of squares of a signal by scaling.
Definition: acelp_vectors.c:213
AMRContext::lsf_avg
float lsf_avg[LP_FILTER_ORDER]
vector of averaged lsf vector
Definition: amrnbdec.c:111
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
MIN_ENERGY
#define MIN_ENERGY
Initial energy in dB.
Definition: amrnbdec.c:85
AMRContext::postfilter_mem
float postfilter_mem[10]
previous intermediate values in the formant filter
Definition: amrnbdec.c:135
ff_acelp_lspd2lpc
void ff_acelp_lspd2lpc(const double *lsp, float *lpc, int lp_half_order)
Reconstruct LPC coefficients from the line spectral pair frequencies.
Definition: lsp.c:209
ACELPVContext::weighted_vector_sumf
void(* weighted_vector_sumf)(float *out, const float *in_a, const float *in_b, float weight_coeff_a, float weight_coeff_b, int length)
float implementation of weighted sum of two vectors.
Definition: acelp_vectors.h:40
AMRNBSubframe
AMRNB unpacked data subframe.
Definition: amrnbdata.h:58
truncf
static __device__ float truncf(float a)
Definition: cuda_runtime.h:178
AMR_SAMPLE_BOUND
#define AMR_SAMPLE_BOUND
threshold for synthesis overflow
Definition: amrnbdec.c:64
amr_unpacking_bitmaps_per_mode
static const uint8_t *const amr_unpacking_bitmaps_per_mode[N_MODES]
position of the bitmapping data for each packet type in the AMRNBFrame
Definition: amrnbdata.h:345
pulses
static const int8_t pulses[4]
Number of non-zero pulses in the MP-MLQ excitation.
Definition: g723_1.h:260
amrnb_decode_init
static av_cold int amrnb_decode_init(AVCodecContext *avctx)
Definition: amrnbdec.c:165
ff_set_min_dist_lsf
void ff_set_min_dist_lsf(float *lsf, double min_spacing, int size)
Adjust the quantized LSFs so they are increasing and not too close.
Definition: lsp.c:51
decode_gains
static void decode_gains(AMRContext *p, const AMRNBSubframe *amr_subframe, const enum Mode mode, const int subframe, float *fixed_gain_factor)
Decode pitch gain and fixed gain factor (part of section 6.1.3).
Definition: amrnbdec.c:640
acelp_pitch_delay.h
AMRContext::celpm_ctx
CELPMContext celpm_ctx
context for fixed point math operations
Definition: amrnbdec.c:145
lsp_sub4_init
static const int8_t lsp_sub4_init[LP_FILTER_ORDER]
Values for the lsp vector from the 4th subframe of the previous subframe values.
Definition: amrnbdata.h:395