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 "internal.h"
59 
60 #include "amrnbdata.h"
61 
62 #define AMR_BLOCK_SIZE 160 ///< samples per frame
63 #define AMR_SAMPLE_BOUND 32768.0 ///< threshold for synthesis overflow
64 
65 /**
66  * Scale from constructed speech to [-1,1]
67  *
68  * AMR is designed to produce 16-bit PCM samples (3GPP TS 26.090 4.2) but
69  * upscales by two (section 6.2.2).
70  *
71  * Fundamentally, this scale is determined by energy_mean through
72  * the fixed vector contribution to the excitation vector.
73  */
74 #define AMR_SAMPLE_SCALE (2.0 / 32768.0)
75 
76 /** Prediction factor for 12.2kbit/s mode */
77 #define PRED_FAC_MODE_12k2 0.65
78 
79 #define LSF_R_FAC (8000.0 / 32768.0) ///< LSF residual tables to Hertz
80 #define MIN_LSF_SPACING (50.0488 / 8000.0) ///< Ensures stability of LPC filter
81 #define PITCH_LAG_MIN_MODE_12k2 18 ///< Lower bound on decoded lag search in 12.2kbit/s mode
82 
83 /** Initial energy in dB. Also used for bad frames (unimplemented). */
84 #define MIN_ENERGY -14.0
85 
86 /** Maximum sharpening factor
87  *
88  * The specification says 0.8, which should be 13107, but the reference C code
89  * uses 13017 instead. (Amusingly the same applies to SHARP_MAX in g729dec.c.)
90  */
91 #define SHARP_MAX 0.79449462890625
92 
93 /** Number of impulse response coefficients used for tilt factor */
94 #define AMR_TILT_RESPONSE 22
95 /** Tilt factor = 1st reflection coefficient * gamma_t */
96 #define AMR_TILT_GAMMA_T 0.8
97 /** Adaptive gain control factor used in post-filter */
98 #define AMR_AGC_ALPHA 0.9
99 
100 typedef struct AMRContext {
101  AMRNBFrame frame; ///< decoded AMR parameters (lsf coefficients, codebook indexes, etc)
102  uint8_t bad_frame_indicator; ///< bad frame ? 1 : 0
104 
105  int16_t prev_lsf_r[LP_FILTER_ORDER]; ///< residual LSF vector from previous subframe
106  double lsp[4][LP_FILTER_ORDER]; ///< lsp vectors from current frame
107  double prev_lsp_sub4[LP_FILTER_ORDER]; ///< lsp vector for the 4th subframe of the previous frame
108 
109  float lsf_q[4][LP_FILTER_ORDER]; ///< Interpolated LSF vector for fixed gain smoothing
110  float lsf_avg[LP_FILTER_ORDER]; ///< vector of averaged lsf vector
111 
112  float lpc[4][LP_FILTER_ORDER]; ///< lpc coefficient vectors for 4 subframes
113 
114  uint8_t pitch_lag_int; ///< integer part of pitch lag from current subframe
115 
116  float excitation_buf[PITCH_DELAY_MAX + LP_FILTER_ORDER + 1 + AMR_SUBFRAME_SIZE]; ///< current excitation and all necessary excitation history
117  float *excitation; ///< pointer to the current excitation vector in excitation_buf
118 
119  float pitch_vector[AMR_SUBFRAME_SIZE]; ///< adaptive code book (pitch) vector
120  float fixed_vector[AMR_SUBFRAME_SIZE]; ///< algebraic codebook (fixed) vector (must be kept zero between frames)
121 
122  float prediction_error[4]; ///< quantified prediction errors {20log10(^gamma_gc)} for previous four subframes
123  float pitch_gain[5]; ///< quantified pitch gains for the current and previous four subframes
124  float fixed_gain[5]; ///< quantified fixed gains for the current and previous four subframes
125 
126  float beta; ///< previous pitch_gain, bounded by [0.0,SHARP_MAX]
127  uint8_t diff_count; ///< the number of subframes for which diff has been above 0.65
128  uint8_t hang_count; ///< the number of subframes since a hangover period started
129 
130  float prev_sparse_fixed_gain; ///< previous fixed gain; used by anti-sparseness processing to determine "onset"
131  uint8_t prev_ir_filter_nr; ///< previous impulse response filter "impNr": 0 - strong, 1 - medium, 2 - none
132  uint8_t ir_filter_onset; ///< flag for impulse response filter strength
133 
134  float postfilter_mem[10]; ///< previous intermediate values in the formant filter
135  float tilt_mem; ///< previous input to tilt compensation filter
136  float postfilter_agc; ///< previous factor used for adaptive gain control
137  float high_pass_mem[2]; ///< previous intermediate values in the high-pass filter
138 
139  float samples_in[LP_FILTER_ORDER + AMR_SUBFRAME_SIZE]; ///< floating point samples
140 
141  ACELPFContext acelpf_ctx; ///< context for filters for ACELP-based codecs
142  ACELPVContext acelpv_ctx; ///< context for vector operations for ACELP-based codecs
143  CELPFContext celpf_ctx; ///< context for filters for CELP-based codecs
144  CELPMContext celpm_ctx; ///< context for fixed point math operations
145 
146 } AMRContext;
147 
148 typedef struct AMRChannelsContext {
151 
152 /** Double version of ff_weighted_vector_sumf() */
153 static void weighted_vector_sumd(double *out, const double *in_a,
154  const double *in_b, double weight_coeff_a,
155  double weight_coeff_b, int length)
156 {
157  int i;
158 
159  for (i = 0; i < length; i++)
160  out[i] = weight_coeff_a * in_a[i]
161  + weight_coeff_b * in_b[i];
162 }
163 
165 {
166  AMRChannelsContext *s = avctx->priv_data;
167  int i;
168 
169  if (avctx->channels > 2) {
170  avpriv_report_missing_feature(avctx, ">2 channel AMR");
171  return AVERROR_PATCHWELCOME;
172  }
173 
174  if (!avctx->channels) {
175  avctx->channels = 1;
177  }
178  if (!avctx->sample_rate)
179  avctx->sample_rate = 8000;
181 
182  for (int ch = 0; ch < avctx->channels; ch++) {
183  AMRContext *p = &s->ch[ch];
184  // p->excitation always points to the same position in p->excitation_buf
186 
187  for (i = 0; i < LP_FILTER_ORDER; i++) {
188  p->prev_lsp_sub4[i] = lsp_sub4_init[i] * 1000 / (float)(1 << 15);
189  p->lsf_avg[i] = p->lsf_q[3][i] = lsp_avg_init[i] / (float)(1 << 15);
190  }
191 
192  for (i = 0; i < 4; i++)
194 
199  }
200 
201  return 0;
202 }
203 
204 
205 /**
206  * Unpack an RFC4867 speech frame into the AMR frame mode and parameters.
207  *
208  * The order of speech bits is specified by 3GPP TS 26.101.
209  *
210  * @param p the context
211  * @param buf pointer to the input buffer
212  * @param buf_size size of the input buffer
213  *
214  * @return the frame mode
215  */
216 static enum Mode unpack_bitstream(AMRContext *p, const uint8_t *buf,
217  int buf_size)
218 {
219  enum Mode mode;
220 
221  // Decode the first octet.
222  mode = buf[0] >> 3 & 0x0F; // frame type
223  p->bad_frame_indicator = (buf[0] & 0x4) != 0x4; // quality bit
224 
225  if (mode >= N_MODES || buf_size < frame_sizes_nb[mode] + 1) {
226  return NO_DATA;
227  }
228 
229  if (mode < MODE_DTX)
230  ff_amr_bit_reorder((uint16_t *) &p->frame, sizeof(AMRNBFrame), buf + 1,
232 
233  return mode;
234 }
235 
236 
237 /// @name AMR pitch LPC coefficient decoding functions
238 /// @{
239 
240 /**
241  * Interpolate the LSF vector (used for fixed gain smoothing).
242  * The interpolation is done over all four subframes even in MODE_12k2.
243  *
244  * @param[in] ctx The Context
245  * @param[in,out] lsf_q LSFs in [0,1] for each subframe
246  * @param[in] lsf_new New LSFs in [0,1] for subframe 4
247  */
248 static void interpolate_lsf(ACELPVContext *ctx, float lsf_q[4][LP_FILTER_ORDER], float *lsf_new)
249 {
250  int i;
251 
252  for (i = 0; i < 4; i++)
253  ctx->weighted_vector_sumf(lsf_q[i], lsf_q[3], lsf_new,
254  0.25 * (3 - i), 0.25 * (i + 1),
256 }
257 
258 /**
259  * Decode a set of 5 split-matrix quantized lsf indexes into an lsp vector.
260  *
261  * @param p the context
262  * @param lsp output LSP vector
263  * @param lsf_no_r LSF vector without the residual vector added
264  * @param lsf_quantizer pointers to LSF dictionary tables
265  * @param quantizer_offset offset in tables
266  * @param sign for the 3 dictionary table
267  * @param update store data for computing the next frame's LSFs
268  */
269 static void lsf2lsp_for_mode12k2(AMRContext *p, double lsp[LP_FILTER_ORDER],
270  const float lsf_no_r[LP_FILTER_ORDER],
271  const int16_t *lsf_quantizer[5],
272  const int quantizer_offset,
273  const int sign, const int update)
274 {
275  int16_t lsf_r[LP_FILTER_ORDER]; // residual LSF vector
276  float lsf_q[LP_FILTER_ORDER]; // quantified LSF vector
277  int i;
278 
279  for (i = 0; i < LP_FILTER_ORDER >> 1; i++)
280  memcpy(&lsf_r[i << 1], &lsf_quantizer[i][quantizer_offset],
281  2 * sizeof(*lsf_r));
282 
283  if (sign) {
284  lsf_r[4] *= -1;
285  lsf_r[5] *= -1;
286  }
287 
288  if (update)
289  memcpy(p->prev_lsf_r, lsf_r, LP_FILTER_ORDER * sizeof(*lsf_r));
290 
291  for (i = 0; i < LP_FILTER_ORDER; i++)
292  lsf_q[i] = lsf_r[i] * (LSF_R_FAC / 8000.0) + lsf_no_r[i] * (1.0 / 8000.0);
293 
295 
296  if (update)
297  interpolate_lsf(&p->acelpv_ctx, p->lsf_q, lsf_q);
298 
299  ff_acelp_lsf2lspd(lsp, lsf_q, LP_FILTER_ORDER);
300 }
301 
302 /**
303  * Decode a set of 5 split-matrix quantized lsf indexes into 2 lsp vectors.
304  *
305  * @param p pointer to the AMRContext
306  */
307 static void lsf2lsp_5(AMRContext *p)
308 {
309  const uint16_t *lsf_param = p->frame.lsf;
310  float lsf_no_r[LP_FILTER_ORDER]; // LSFs without the residual vector
311  const int16_t *lsf_quantizer[5];
312  int i;
313 
314  lsf_quantizer[0] = lsf_5_1[lsf_param[0]];
315  lsf_quantizer[1] = lsf_5_2[lsf_param[1]];
316  lsf_quantizer[2] = lsf_5_3[lsf_param[2] >> 1];
317  lsf_quantizer[3] = lsf_5_4[lsf_param[3]];
318  lsf_quantizer[4] = lsf_5_5[lsf_param[4]];
319 
320  for (i = 0; i < LP_FILTER_ORDER; i++)
321  lsf_no_r[i] = p->prev_lsf_r[i] * LSF_R_FAC * PRED_FAC_MODE_12k2 + lsf_5_mean[i];
322 
323  lsf2lsp_for_mode12k2(p, p->lsp[1], lsf_no_r, lsf_quantizer, 0, lsf_param[2] & 1, 0);
324  lsf2lsp_for_mode12k2(p, p->lsp[3], lsf_no_r, lsf_quantizer, 2, lsf_param[2] & 1, 1);
325 
326  // interpolate LSP vectors at subframes 1 and 3
327  weighted_vector_sumd(p->lsp[0], p->prev_lsp_sub4, p->lsp[1], 0.5, 0.5, LP_FILTER_ORDER);
328  weighted_vector_sumd(p->lsp[2], p->lsp[1] , p->lsp[3], 0.5, 0.5, LP_FILTER_ORDER);
329 }
330 
331 /**
332  * Decode a set of 3 split-matrix quantized lsf indexes into an lsp vector.
333  *
334  * @param p pointer to the AMRContext
335  */
336 static void lsf2lsp_3(AMRContext *p)
337 {
338  const uint16_t *lsf_param = p->frame.lsf;
339  int16_t lsf_r[LP_FILTER_ORDER]; // residual LSF vector
340  float lsf_q[LP_FILTER_ORDER]; // quantified LSF vector
341  const int16_t *lsf_quantizer;
342  int i, j;
343 
344  lsf_quantizer = (p->cur_frame_mode == MODE_7k95 ? lsf_3_1_MODE_7k95 : lsf_3_1)[lsf_param[0]];
345  memcpy(lsf_r, lsf_quantizer, 3 * sizeof(*lsf_r));
346 
347  lsf_quantizer = lsf_3_2[lsf_param[1] << (p->cur_frame_mode <= MODE_5k15)];
348  memcpy(lsf_r + 3, lsf_quantizer, 3 * sizeof(*lsf_r));
349 
350  lsf_quantizer = (p->cur_frame_mode <= MODE_5k15 ? lsf_3_3_MODE_5k15 : lsf_3_3)[lsf_param[2]];
351  memcpy(lsf_r + 6, lsf_quantizer, 4 * sizeof(*lsf_r));
352 
353  // calculate mean-removed LSF vector and add mean
354  for (i = 0; i < LP_FILTER_ORDER; i++)
355  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);
356 
358 
359  // store data for computing the next frame's LSFs
360  interpolate_lsf(&p->acelpv_ctx, p->lsf_q, lsf_q);
361  memcpy(p->prev_lsf_r, lsf_r, LP_FILTER_ORDER * sizeof(*lsf_r));
362 
363  ff_acelp_lsf2lspd(p->lsp[3], lsf_q, LP_FILTER_ORDER);
364 
365  // interpolate LSP vectors at subframes 1, 2 and 3
366  for (i = 1; i <= 3; i++)
367  for(j = 0; j < LP_FILTER_ORDER; j++)
368  p->lsp[i-1][j] = p->prev_lsp_sub4[j] +
369  (p->lsp[3][j] - p->prev_lsp_sub4[j]) * 0.25 * i;
370 }
371 
372 /// @}
373 
374 
375 /// @name AMR pitch vector decoding functions
376 /// @{
377 
378 /**
379  * Like ff_decode_pitch_lag(), but with 1/6 resolution
380  */
381 static void decode_pitch_lag_1_6(int *lag_int, int *lag_frac, int pitch_index,
382  const int prev_lag_int, const int subframe)
383 {
384  if (subframe == 0 || subframe == 2) {
385  if (pitch_index < 463) {
386  *lag_int = (pitch_index + 107) * 10923 >> 16;
387  *lag_frac = pitch_index - *lag_int * 6 + 105;
388  } else {
389  *lag_int = pitch_index - 368;
390  *lag_frac = 0;
391  }
392  } else {
393  *lag_int = ((pitch_index + 5) * 10923 >> 16) - 1;
394  *lag_frac = pitch_index - *lag_int * 6 - 3;
395  *lag_int += av_clip(prev_lag_int - 5, PITCH_LAG_MIN_MODE_12k2,
396  PITCH_DELAY_MAX - 9);
397  }
398 }
399 
401  const AMRNBSubframe *amr_subframe,
402  const int subframe)
403 {
404  int pitch_lag_int, pitch_lag_frac;
405  enum Mode mode = p->cur_frame_mode;
406 
407  if (p->cur_frame_mode == MODE_12k2) {
408  decode_pitch_lag_1_6(&pitch_lag_int, &pitch_lag_frac,
409  amr_subframe->p_lag, p->pitch_lag_int,
410  subframe);
411  } else {
412  ff_decode_pitch_lag(&pitch_lag_int, &pitch_lag_frac,
413  amr_subframe->p_lag,
414  p->pitch_lag_int, subframe,
415  mode != MODE_4k75 && mode != MODE_5k15,
416  mode <= MODE_6k7 ? 4 : (mode == MODE_7k95 ? 5 : 6));
417  pitch_lag_frac *= 2;
418  }
419 
420  p->pitch_lag_int = pitch_lag_int; // store previous lag in a uint8_t
421 
422  pitch_lag_int += pitch_lag_frac > 0;
423 
424  /* Calculate the pitch vector by interpolating the past excitation at the
425  pitch lag using a b60 hamming windowed sinc function. */
427  p->excitation + 1 - pitch_lag_int,
428  ff_b60_sinc, 6,
429  pitch_lag_frac + 6 - 6*(pitch_lag_frac > 0),
430  10, AMR_SUBFRAME_SIZE);
431 
432  memcpy(p->pitch_vector, p->excitation, AMR_SUBFRAME_SIZE * sizeof(float));
433 }
434 
435 /// @}
436 
437 
438 /// @name AMR algebraic code book (fixed) vector decoding functions
439 /// @{
440 
441 /**
442  * Decode a 10-bit algebraic codebook index from a 10.2 kbit/s frame.
443  */
444 static void decode_10bit_pulse(int code, int pulse_position[8],
445  int i1, int i2, int i3)
446 {
447  // coded using 7+3 bits with the 3 LSBs being, individually, the LSB of 1 of
448  // the 3 pulses and the upper 7 bits being coded in base 5
449  const uint8_t *positions = base_five_table[code >> 3];
450  pulse_position[i1] = (positions[2] << 1) + ( code & 1);
451  pulse_position[i2] = (positions[1] << 1) + ((code >> 1) & 1);
452  pulse_position[i3] = (positions[0] << 1) + ((code >> 2) & 1);
453 }
454 
455 /**
456  * Decode the algebraic codebook index to pulse positions and signs and
457  * construct the algebraic codebook vector for MODE_10k2.
458  *
459  * @param fixed_index positions of the eight pulses
460  * @param fixed_sparse pointer to the algebraic codebook vector
461  */
462 static void decode_8_pulses_31bits(const int16_t *fixed_index,
463  AMRFixed *fixed_sparse)
464 {
465  int pulse_position[8];
466  int i, temp;
467 
468  decode_10bit_pulse(fixed_index[4], pulse_position, 0, 4, 1);
469  decode_10bit_pulse(fixed_index[5], pulse_position, 2, 6, 5);
470 
471  // coded using 5+2 bits with the 2 LSBs being, individually, the LSB of 1 of
472  // the 2 pulses and the upper 5 bits being coded in base 5
473  temp = ((fixed_index[6] >> 2) * 25 + 12) >> 5;
474  pulse_position[3] = temp % 5;
475  pulse_position[7] = temp / 5;
476  if (pulse_position[7] & 1)
477  pulse_position[3] = 4 - pulse_position[3];
478  pulse_position[3] = (pulse_position[3] << 1) + ( fixed_index[6] & 1);
479  pulse_position[7] = (pulse_position[7] << 1) + ((fixed_index[6] >> 1) & 1);
480 
481  fixed_sparse->n = 8;
482  for (i = 0; i < 4; i++) {
483  const int pos1 = (pulse_position[i] << 2) + i;
484  const int pos2 = (pulse_position[i + 4] << 2) + i;
485  const float sign = fixed_index[i] ? -1.0 : 1.0;
486  fixed_sparse->x[i ] = pos1;
487  fixed_sparse->x[i + 4] = pos2;
488  fixed_sparse->y[i ] = sign;
489  fixed_sparse->y[i + 4] = pos2 < pos1 ? -sign : sign;
490  }
491 }
492 
493 /**
494  * Decode the algebraic codebook index to pulse positions and signs,
495  * then construct the algebraic codebook vector.
496  *
497  * nb of pulses | bits encoding pulses
498  * For MODE_4k75 or MODE_5k15, 2 | 1-3, 4-6, 7
499  * MODE_5k9, 2 | 1, 2-4, 5-6, 7-9
500  * MODE_6k7, 3 | 1-3, 4, 5-7, 8, 9-11
501  * MODE_7k4 or MODE_7k95, 4 | 1-3, 4-6, 7-9, 10, 11-13
502  *
503  * @param fixed_sparse pointer to the algebraic codebook vector
504  * @param pulses algebraic codebook indexes
505  * @param mode mode of the current frame
506  * @param subframe current subframe number
507  */
508 static void decode_fixed_sparse(AMRFixed *fixed_sparse, const uint16_t *pulses,
509  const enum Mode mode, const int subframe)
510 {
511  av_assert1(MODE_4k75 <= (signed)mode && mode <= MODE_12k2);
512 
513  if (mode == MODE_12k2) {
514  ff_decode_10_pulses_35bits(pulses, fixed_sparse, gray_decode, 5, 3);
515  } else if (mode == MODE_10k2) {
516  decode_8_pulses_31bits(pulses, fixed_sparse);
517  } else {
518  int *pulse_position = fixed_sparse->x;
519  int i, pulse_subset;
520  const int fixed_index = pulses[0];
521 
522  if (mode <= MODE_5k15) {
523  pulse_subset = ((fixed_index >> 3) & 8) + (subframe << 1);
524  pulse_position[0] = ( fixed_index & 7) * 5 + track_position[pulse_subset];
525  pulse_position[1] = ((fixed_index >> 3) & 7) * 5 + track_position[pulse_subset + 1];
526  fixed_sparse->n = 2;
527  } else if (mode == MODE_5k9) {
528  pulse_subset = ((fixed_index & 1) << 1) + 1;
529  pulse_position[0] = ((fixed_index >> 1) & 7) * 5 + pulse_subset;
530  pulse_subset = (fixed_index >> 4) & 3;
531  pulse_position[1] = ((fixed_index >> 6) & 7) * 5 + pulse_subset + (pulse_subset == 3 ? 1 : 0);
532  fixed_sparse->n = pulse_position[0] == pulse_position[1] ? 1 : 2;
533  } else if (mode == MODE_6k7) {
534  pulse_position[0] = (fixed_index & 7) * 5;
535  pulse_subset = (fixed_index >> 2) & 2;
536  pulse_position[1] = ((fixed_index >> 4) & 7) * 5 + pulse_subset + 1;
537  pulse_subset = (fixed_index >> 6) & 2;
538  pulse_position[2] = ((fixed_index >> 8) & 7) * 5 + pulse_subset + 2;
539  fixed_sparse->n = 3;
540  } else { // mode <= MODE_7k95
541  pulse_position[0] = gray_decode[ fixed_index & 7];
542  pulse_position[1] = gray_decode[(fixed_index >> 3) & 7] + 1;
543  pulse_position[2] = gray_decode[(fixed_index >> 6) & 7] + 2;
544  pulse_subset = (fixed_index >> 9) & 1;
545  pulse_position[3] = gray_decode[(fixed_index >> 10) & 7] + pulse_subset + 3;
546  fixed_sparse->n = 4;
547  }
548  for (i = 0; i < fixed_sparse->n; i++)
549  fixed_sparse->y[i] = (pulses[1] >> i) & 1 ? 1.0 : -1.0;
550  }
551 }
552 
553 /**
554  * Apply pitch lag to obtain the sharpened fixed vector (section 6.1.2)
555  *
556  * @param p the context
557  * @param subframe unpacked amr subframe
558  * @param mode mode of the current frame
559  * @param fixed_sparse sparse representation of the fixed vector
560  */
561 static void pitch_sharpening(AMRContext *p, int subframe, enum Mode mode,
562  AMRFixed *fixed_sparse)
563 {
564  // The spec suggests the current pitch gain is always used, but in other
565  // modes the pitch and codebook gains are jointly quantized (sec 5.8.2)
566  // so the codebook gain cannot depend on the quantized pitch gain.
567  if (mode == MODE_12k2)
568  p->beta = FFMIN(p->pitch_gain[4], 1.0);
569 
570  fixed_sparse->pitch_lag = p->pitch_lag_int;
571  fixed_sparse->pitch_fac = p->beta;
572 
573  // Save pitch sharpening factor for the next subframe
574  // MODE_4k75 only updates on the 2nd and 4th subframes - this follows from
575  // the fact that the gains for two subframes are jointly quantized.
576  if (mode != MODE_4k75 || subframe & 1)
577  p->beta = av_clipf(p->pitch_gain[4], 0.0, SHARP_MAX);
578 }
579 /// @}
580 
581 
582 /// @name AMR gain decoding functions
583 /// @{
584 
585 /**
586  * fixed gain smoothing
587  * Note that where the spec specifies the "spectrum in the q domain"
588  * in section 6.1.4, in fact frequencies should be used.
589  *
590  * @param p the context
591  * @param lsf LSFs for the current subframe, in the range [0,1]
592  * @param lsf_avg averaged LSFs
593  * @param mode mode of the current frame
594  *
595  * @return fixed gain smoothed
596  */
597 static float fixed_gain_smooth(AMRContext *p , const float *lsf,
598  const float *lsf_avg, const enum Mode mode)
599 {
600  float diff = 0.0;
601  int i;
602 
603  for (i = 0; i < LP_FILTER_ORDER; i++)
604  diff += fabs(lsf_avg[i] - lsf[i]) / lsf_avg[i];
605 
606  // If diff is large for ten subframes, disable smoothing for a 40-subframe
607  // hangover period.
608  p->diff_count++;
609  if (diff <= 0.65)
610  p->diff_count = 0;
611 
612  if (p->diff_count > 10) {
613  p->hang_count = 0;
614  p->diff_count--; // don't let diff_count overflow
615  }
616 
617  if (p->hang_count < 40) {
618  p->hang_count++;
619  } else if (mode < MODE_7k4 || mode == MODE_10k2) {
620  const float smoothing_factor = av_clipf(4.0 * diff - 1.6, 0.0, 1.0);
621  const float fixed_gain_mean = (p->fixed_gain[0] + p->fixed_gain[1] +
622  p->fixed_gain[2] + p->fixed_gain[3] +
623  p->fixed_gain[4]) * 0.2;
624  return smoothing_factor * p->fixed_gain[4] +
625  (1.0 - smoothing_factor) * fixed_gain_mean;
626  }
627  return p->fixed_gain[4];
628 }
629 
630 /**
631  * Decode pitch gain and fixed gain factor (part of section 6.1.3).
632  *
633  * @param p the context
634  * @param amr_subframe unpacked amr subframe
635  * @param mode mode of the current frame
636  * @param subframe current subframe number
637  * @param fixed_gain_factor decoded gain correction factor
638  */
639 static void decode_gains(AMRContext *p, const AMRNBSubframe *amr_subframe,
640  const enum Mode mode, const int subframe,
641  float *fixed_gain_factor)
642 {
643  if (mode == MODE_12k2 || mode == MODE_7k95) {
644  p->pitch_gain[4] = qua_gain_pit [amr_subframe->p_gain ]
645  * (1.0 / 16384.0);
646  *fixed_gain_factor = qua_gain_code[amr_subframe->fixed_gain]
647  * (1.0 / 2048.0);
648  } else {
649  const uint16_t *gains;
650 
651  if (mode >= MODE_6k7) {
652  gains = gains_high[amr_subframe->p_gain];
653  } else if (mode >= MODE_5k15) {
654  gains = gains_low [amr_subframe->p_gain];
655  } else {
656  // gain index is only coded in subframes 0,2 for MODE_4k75
657  gains = gains_MODE_4k75[(p->frame.subframe[subframe & 2].p_gain << 1) + (subframe & 1)];
658  }
659 
660  p->pitch_gain[4] = gains[0] * (1.0 / 16384.0);
661  *fixed_gain_factor = gains[1] * (1.0 / 4096.0);
662  }
663 }
664 
665 /// @}
666 
667 
668 /// @name AMR preprocessing functions
669 /// @{
670 
671 /**
672  * Circularly convolve a sparse fixed vector with a phase dispersion impulse
673  * response filter (D.6.2 of G.729 and 6.1.5 of AMR).
674  *
675  * @param out vector with filter applied
676  * @param in source vector
677  * @param filter phase filter coefficients
678  *
679  * out[n] = sum(i,0,len-1){ in[i] * filter[(len + n - i)%len] }
680  */
681 static void apply_ir_filter(float *out, const AMRFixed *in,
682  const float *filter)
683 {
684  float filter1[AMR_SUBFRAME_SIZE], ///< filters at pitch lag*1 and *2
685  filter2[AMR_SUBFRAME_SIZE];
686  int lag = in->pitch_lag;
687  float fac = in->pitch_fac;
688  int i;
689 
690  if (lag < AMR_SUBFRAME_SIZE) {
693 
694  if (lag < AMR_SUBFRAME_SIZE >> 1)
695  ff_celp_circ_addf(filter2, filter, filter1, lag, fac,
697  }
698 
699  memset(out, 0, sizeof(float) * AMR_SUBFRAME_SIZE);
700  for (i = 0; i < in->n; i++) {
701  int x = in->x[i];
702  float y = in->y[i];
703  const float *filterp;
704 
705  if (x >= AMR_SUBFRAME_SIZE - lag) {
706  filterp = filter;
707  } else if (x >= AMR_SUBFRAME_SIZE - (lag << 1)) {
708  filterp = filter1;
709  } else
710  filterp = filter2;
711 
712  ff_celp_circ_addf(out, out, filterp, x, y, AMR_SUBFRAME_SIZE);
713  }
714 }
715 
716 /**
717  * Reduce fixed vector sparseness by smoothing with one of three IR filters.
718  * Also know as "adaptive phase dispersion".
719  *
720  * This implements 3GPP TS 26.090 section 6.1(5).
721  *
722  * @param p the context
723  * @param fixed_sparse algebraic codebook vector
724  * @param fixed_vector unfiltered fixed vector
725  * @param fixed_gain smoothed gain
726  * @param out space for modified vector if necessary
727  */
728 static const float *anti_sparseness(AMRContext *p, AMRFixed *fixed_sparse,
729  const float *fixed_vector,
730  float fixed_gain, float *out)
731 {
732  int ir_filter_nr;
733 
734  if (p->pitch_gain[4] < 0.6) {
735  ir_filter_nr = 0; // strong filtering
736  } else if (p->pitch_gain[4] < 0.9) {
737  ir_filter_nr = 1; // medium filtering
738  } else
739  ir_filter_nr = 2; // no filtering
740 
741  // detect 'onset'
742  if (fixed_gain > 2.0 * p->prev_sparse_fixed_gain) {
743  p->ir_filter_onset = 2;
744  } else if (p->ir_filter_onset)
745  p->ir_filter_onset--;
746 
747  if (!p->ir_filter_onset) {
748  int i, count = 0;
749 
750  for (i = 0; i < 5; i++)
751  if (p->pitch_gain[i] < 0.6)
752  count++;
753  if (count > 2)
754  ir_filter_nr = 0;
755 
756  if (ir_filter_nr > p->prev_ir_filter_nr + 1)
757  ir_filter_nr--;
758  } else if (ir_filter_nr < 2)
759  ir_filter_nr++;
760 
761  // Disable filtering for very low level of fixed_gain.
762  // Note this step is not specified in the technical description but is in
763  // the reference source in the function Ph_disp.
764  if (fixed_gain < 5.0)
765  ir_filter_nr = 2;
766 
768  && ir_filter_nr < 2) {
769  apply_ir_filter(out, fixed_sparse,
770  (p->cur_frame_mode == MODE_7k95 ?
772  ir_filters_lookup)[ir_filter_nr]);
773  fixed_vector = out;
774  }
775 
776  // update ir filter strength history
777  p->prev_ir_filter_nr = ir_filter_nr;
778  p->prev_sparse_fixed_gain = fixed_gain;
779 
780  return fixed_vector;
781 }
782 
783 /// @}
784 
785 
786 /// @name AMR synthesis functions
787 /// @{
788 
789 /**
790  * Conduct 10th order linear predictive coding synthesis.
791  *
792  * @param p pointer to the AMRContext
793  * @param lpc pointer to the LPC coefficients
794  * @param fixed_gain fixed codebook gain for synthesis
795  * @param fixed_vector algebraic codebook vector
796  * @param samples pointer to the output speech samples
797  * @param overflow 16-bit overflow flag
798  */
799 static int synthesis(AMRContext *p, float *lpc,
800  float fixed_gain, const float *fixed_vector,
801  float *samples, uint8_t overflow)
802 {
803  int i;
804  float excitation[AMR_SUBFRAME_SIZE];
805 
806  // if an overflow has been detected, the pitch vector is scaled down by a
807  // factor of 4
808  if (overflow)
809  for (i = 0; i < AMR_SUBFRAME_SIZE; i++)
810  p->pitch_vector[i] *= 0.25;
811 
812  p->acelpv_ctx.weighted_vector_sumf(excitation, p->pitch_vector, fixed_vector,
813  p->pitch_gain[4], fixed_gain, AMR_SUBFRAME_SIZE);
814 
815  // emphasize pitch vector contribution
816  if (p->pitch_gain[4] > 0.5 && !overflow) {
817  float energy = p->celpm_ctx.dot_productf(excitation, excitation,
819  float pitch_factor =
820  p->pitch_gain[4] *
821  (p->cur_frame_mode == MODE_12k2 ?
822  0.25 * FFMIN(p->pitch_gain[4], 1.0) :
823  0.5 * FFMIN(p->pitch_gain[4], SHARP_MAX));
824 
825  for (i = 0; i < AMR_SUBFRAME_SIZE; i++)
826  excitation[i] += pitch_factor * p->pitch_vector[i];
827 
828  ff_scale_vector_to_given_sum_of_squares(excitation, excitation, energy,
830  }
831 
832  p->celpf_ctx.celp_lp_synthesis_filterf(samples, lpc, excitation,
835 
836  // detect overflow
837  for (i = 0; i < AMR_SUBFRAME_SIZE; i++)
838  if (fabsf(samples[i]) > AMR_SAMPLE_BOUND) {
839  return 1;
840  }
841 
842  return 0;
843 }
844 
845 /// @}
846 
847 
848 /// @name AMR update functions
849 /// @{
850 
851 /**
852  * Update buffers and history at the end of decoding a subframe.
853  *
854  * @param p pointer to the AMRContext
855  */
856 static void update_state(AMRContext *p)
857 {
858  memcpy(p->prev_lsp_sub4, p->lsp[3], LP_FILTER_ORDER * sizeof(p->lsp[3][0]));
859 
860  memmove(&p->excitation_buf[0], &p->excitation_buf[AMR_SUBFRAME_SIZE],
861  (PITCH_DELAY_MAX + LP_FILTER_ORDER + 1) * sizeof(float));
862 
863  memmove(&p->pitch_gain[0], &p->pitch_gain[1], 4 * sizeof(float));
864  memmove(&p->fixed_gain[0], &p->fixed_gain[1], 4 * sizeof(float));
865 
866  memmove(&p->samples_in[0], &p->samples_in[AMR_SUBFRAME_SIZE],
867  LP_FILTER_ORDER * sizeof(float));
868 }
869 
870 /// @}
871 
872 
873 /// @name AMR Postprocessing functions
874 /// @{
875 
876 /**
877  * Get the tilt factor of a formant filter from its transfer function
878  *
879  * @param p The Context
880  * @param lpc_n LP_FILTER_ORDER coefficients of the numerator
881  * @param lpc_d LP_FILTER_ORDER coefficients of the denominator
882  */
883 static float tilt_factor(AMRContext *p, float *lpc_n, float *lpc_d)
884 {
885  float rh0, rh1; // autocorrelation at lag 0 and 1
886 
887  // LP_FILTER_ORDER prior zeros are needed for ff_celp_lp_synthesis_filterf
888  float impulse_buffer[LP_FILTER_ORDER + AMR_TILT_RESPONSE] = { 0 };
889  float *hf = impulse_buffer + LP_FILTER_ORDER; // start of impulse response
890 
891  hf[0] = 1.0;
892  memcpy(hf + 1, lpc_n, sizeof(float) * LP_FILTER_ORDER);
893  p->celpf_ctx.celp_lp_synthesis_filterf(hf, lpc_d, hf,
896 
897  rh0 = p->celpm_ctx.dot_productf(hf, hf, AMR_TILT_RESPONSE);
898  rh1 = p->celpm_ctx.dot_productf(hf, hf + 1, AMR_TILT_RESPONSE - 1);
899 
900  // The spec only specifies this check for 12.2 and 10.2 kbit/s
901  // modes. But in the ref source the tilt is always non-negative.
902  return rh1 >= 0.0 ? rh1 / rh0 * AMR_TILT_GAMMA_T : 0.0;
903 }
904 
905 /**
906  * Perform adaptive post-filtering to enhance the quality of the speech.
907  * See section 6.2.1.
908  *
909  * @param p pointer to the AMRContext
910  * @param lpc interpolated LP coefficients for this subframe
911  * @param buf_out output of the filter
912  */
913 static void postfilter(AMRContext *p, float *lpc, float *buf_out)
914 {
915  int i;
916  float *samples = p->samples_in + LP_FILTER_ORDER; // Start of input
917 
918  float speech_gain = p->celpm_ctx.dot_productf(samples, samples,
920 
921  float pole_out[AMR_SUBFRAME_SIZE + LP_FILTER_ORDER]; // Output of pole filter
922  const float *gamma_n, *gamma_d; // Formant filter factor table
923  float lpc_n[LP_FILTER_ORDER], lpc_d[LP_FILTER_ORDER]; // Transfer function coefficients
924 
925  if (p->cur_frame_mode == MODE_12k2 || p->cur_frame_mode == MODE_10k2) {
926  gamma_n = ff_pow_0_7;
927  gamma_d = ff_pow_0_75;
928  } else {
929  gamma_n = ff_pow_0_55;
930  gamma_d = ff_pow_0_7;
931  }
932 
933  for (i = 0; i < LP_FILTER_ORDER; i++) {
934  lpc_n[i] = lpc[i] * gamma_n[i];
935  lpc_d[i] = lpc[i] * gamma_d[i];
936  }
937 
938  memcpy(pole_out, p->postfilter_mem, sizeof(float) * LP_FILTER_ORDER);
941  memcpy(p->postfilter_mem, pole_out + AMR_SUBFRAME_SIZE,
942  sizeof(float) * LP_FILTER_ORDER);
943 
944  p->celpf_ctx.celp_lp_zero_synthesis_filterf(buf_out, lpc_n,
945  pole_out + LP_FILTER_ORDER,
947 
948  ff_tilt_compensation(&p->tilt_mem, tilt_factor(p, lpc_n, lpc_d), buf_out,
950 
951  ff_adaptive_gain_control(buf_out, buf_out, speech_gain, AMR_SUBFRAME_SIZE,
953 }
954 
955 /// @}
956 
957 static int amrnb_decode_frame(AVCodecContext *avctx, void *data,
958  int *got_frame_ptr, AVPacket *avpkt)
959 {
960 
961  AMRChannelsContext *s = avctx->priv_data; // pointer to private data
962  AVFrame *frame = 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->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  .name = "amrnb",
1101  .long_name = NULL_IF_CONFIG_SMALL("AMR-NB (Adaptive Multi-Rate NarrowBand)"),
1102  .type = AVMEDIA_TYPE_AUDIO,
1103  .id = AV_CODEC_ID_AMR_NB,
1104  .priv_data_size = sizeof(AMRChannelsContext),
1107  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
1108  .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
AVCodec
AVCodec.
Definition: codec.h:202
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:69
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:116
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:96
ff_amrnb_decoder
const AVCodec ff_amrnb_decoder
Definition: amrnbdec.c:1099
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
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:728
AVCodecContext::channel_layout
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1043
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:86
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:107
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:107
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:992
filter1
static void filter1(SUINT32 *dst, const int32_t *src, int32_t coeff, ptrdiff_t len)
Definition: dcadsp.c:358
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:948
AV_CH_LAYOUT_MONO
#define AV_CH_LAYOUT_MONO
Definition: channel_layout.h:90
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:141
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:303
AMRChannelsContext::ch
AMRContext ch[2]
Definition: amrnbdec.c:149
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:81
AVPacket::data
uint8_t * data
Definition: packet.h:373
data
const char data[16]
Definition: mxf.c:143
AV_CODEC_ID_AMR_NB
@ AV_CODEC_ID_AMR_NB
Definition: codec_id.h:406
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:74
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
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
SHARP_MAX
#define SHARP_MAX
Maximum sharpening factor.
Definition: amrnbdec.c:91
AMRChannelsContext
Definition: amrnbdec.c:148
AMRContext::bad_frame_indicator
uint8_t bad_frame_indicator
bad frame ? 1 : 0
Definition: amrnbdec.c:102
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:131
positions
const static uint16_t positions[][14][3]
Definition: vf_vectorscope.c:817
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
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
amrnb_decode_frame
static int amrnb_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: amrnbdec.c:957
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:307
avassert.h
AMRContext::prev_lsf_r
int16_t prev_lsf_r[LP_FILTER_ORDER]
residual LSF vector from previous subframe
Definition: amrnbdec.c:105
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:381
AMRContext::postfilter_agc
float postfilter_agc
previous factor used for adaptive gain control
Definition: amrnbdec.c:136
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:269
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
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
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:132
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:913
s
#define s(width, name)
Definition: cbs_vp9.c:257
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:106
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:98
AMRContext::excitation
float * excitation
pointer to the current excitation vector in excitation_buf
Definition: amrnbdec.c:117
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:153
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:80
AMRFixed::y
float y[10]
Definition: acelp_vectors.h:56
AMRContext
Definition: amrnbdec.c:100
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:77
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:101
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:96
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:681
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:120
av_clipf
#define av_clipf
Definition: common.h:144
celp_filters.h
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:216
AMRContext::pitch_gain
float pitch_gain[5]
quantified pitch gains for the current and previous four subframes
Definition: amrnbdec.c:123
AMR_TILT_RESPONSE
#define AMR_TILT_RESPONSE
Number of impulse response coefficients used for tilt factor.
Definition: amrnbdec.c:94
float_dsp.h
decode_pitch_vector
static void decode_pitch_vector(AMRContext *p, const AMRNBSubframe *amr_subframe, const int subframe)
Definition: amrnbdec.c:400
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:856
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:109
AMRContext::tilt_mem
float tilt_mem
previous input to tilt compensation filter
Definition: amrnbdec.c:135
ff_celp_math_init
void ff_celp_math_init(CELPMContext *c)
Initialize CELPMContext.
Definition: celp_math.c:122
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1652
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:374
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
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:137
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1000
highpass_poles
static const float highpass_poles[2]
Definition: amrnbdata.h:1663
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
AMRContext::cur_frame_mode
enum Mode cur_frame_mode
Definition: amrnbdec.c:103
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:112
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:561
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
AMRContext::fixed_gain
float fixed_gain[5]
quantified fixed gains for the current and previous four subframes
Definition: amrnbdec.c:124
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:126
AMRContext::samples_in
float samples_in[LP_FILTER_ORDER+AMR_SUBFRAME_SIZE]
floating point samples
Definition: amrnbdec.c:139
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
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:993
AMRContext::pitch_vector
float pitch_vector[AMR_SUBFRAME_SIZE]
adaptive code book (pitch) vector
Definition: amrnbdec.c:119
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:248
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:597
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
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:799
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:508
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:79
AMRContext::pitch_lag_int
uint8_t pitch_lag_int
integer part of pitch lag from current subframe
Definition: amrnbdec.c:114
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:58
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:209
amr.h
AMRContext::hang_count
uint8_t hang_count
the number of subframes since a hangover period started
Definition: amrnbdec.c:128
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:336
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:122
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:383
channel_layout.h
AMR_BLOCK_SIZE
#define AMR_BLOCK_SIZE
samples per frame
Definition: amrnbdec.c:62
AMRContext::diff_count
uint8_t diff_count
the number of subframes for which diff has been above 0.65
Definition: amrnbdec.c:127
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:142
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:143
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:130
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:350
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:410
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:462
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:883
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:444
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:110
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
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:84
AMRContext::postfilter_mem
float postfilter_mem[10]
previous intermediate values in the formant filter
Definition: amrnbdec.c:134
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:63
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:164
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:639
acelp_pitch_delay.h
AMRContext::celpm_ctx
CELPMContext celpm_ctx
context for fixed point math operations
Definition: amrnbdec.c:144
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