FFmpeg: libavcodec/amrnbdec.c Source File

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 
46 #include "libavutil/channel_layout.h"
47 #include "avcodec.h"
48 #include "libavutil/common.h"
49 #include "libavutil/avassert.h"
50 #include "celp_math.h"
51 #include "celp_filters.h"
52 #include "acelp_filters.h"
53 #include "acelp_vectors.h"
54 #include "acelp_pitch_delay.h"
55 #include "lsp.h"
56 #include "amr.h"
57 #include "codec_internal.h"
58 #include "decode.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
103   enum Mode cur_frame_mode;
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 {
149   AMRContext ch[2];
150 } 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 
164  static av_cold int amrnb_decode_init(AVCodecContext *avctx)
165 {
166  AMRChannelsContext *s = avctx->priv_data;
167  int i;
168 
169  if (avctx->ch_layout.nb_channels > 2) {
170  avpriv_report_missing_feature(avctx, ">2 channel AMR");
171  return AVERROR_PATCHWELCOME;
172  }
173 
174  if (!avctx->ch_layout.nb_channels) {
175  av_channel_layout_uninit(&avctx->ch_layout);
176  avctx->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_MONO;
177  }
178  if (!avctx->sample_rate)
179  avctx->sample_rate = 8000;
180  avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
181 
182  for (int ch = 0; ch < avctx->ch_layout.nb_channels; ch++) {
183  AMRContext *p = &s->ch[ch];
184  // p->excitation always points to the same position in p->excitation_buf
185  p->excitation = &p->excitation_buf[PITCH_DELAY_MAX + LP_FILTER_ORDER + 1];
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++)
193  p->prediction_error[i] = MIN_ENERGY;
194 
195  ff_acelp_filter_init(&p->acelpf_ctx);
196  ff_acelp_vectors_init(&p->acelpv_ctx);
197  ff_celp_filter_init(&p->celpf_ctx);
198  ff_celp_math_init(&p->celpm_ctx);
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,
231  amr_unpacking_bitmaps_per_mode[mode]);
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),
255  LP_FILTER_ORDER);
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 
294  ff_set_min_dist_lsf(lsf_q, MIN_LSF_SPACING, LP_FILTER_ORDER);
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 
357  ff_set_min_dist_lsf(lsf_q, MIN_LSF_SPACING, LP_FILTER_ORDER);
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 
400  static void decode_pitch_vector(AMRContext *p,
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. */
426  p->acelpf_ctx.acelp_interpolatef(p->excitation,
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) {
691  ff_celp_circ_addf(filter1, filter, filter, lag, fac,
692  AMR_SUBFRAME_SIZE);
693 
694  if (lag < AMR_SUBFRAME_SIZE >> 1)
695  ff_celp_circ_addf(filter2, filter, filter1, lag, fac,
696  AMR_SUBFRAME_SIZE);
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 
767  if (p->cur_frame_mode != MODE_7k4 && p->cur_frame_mode < MODE_10k2
768  && ir_filter_nr < 2) {
769  apply_ir_filter(out, fixed_sparse,
770  (p->cur_frame_mode == MODE_7k95 ?
771  ir_filters_lookup_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,
818  AMR_SUBFRAME_SIZE);
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,
829  AMR_SUBFRAME_SIZE);
830  }
831 
832  p->celpf_ctx.celp_lp_synthesis_filterf(samples, lpc, excitation,
833  AMR_SUBFRAME_SIZE,
834  LP_FILTER_ORDER);
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,
894  AMR_TILT_RESPONSE,
895  LP_FILTER_ORDER);
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,
919  AMR_SUBFRAME_SIZE);
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);
939  p->celpf_ctx.celp_lp_synthesis_filterf(pole_out + LP_FILTER_ORDER, lpc_d, samples,
940  AMR_SUBFRAME_SIZE, 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,
946  AMR_SUBFRAME_SIZE, LP_FILTER_ORDER);
947 
948  ff_tilt_compensation(&p->tilt_mem, tilt_factor(p, lpc_n, lpc_d), buf_out,
949  AMR_SUBFRAME_SIZE);
950 
951  ff_adaptive_gain_control(buf_out, buf_out, speech_gain, AMR_SUBFRAME_SIZE,
952  AMR_AGC_ALPHA, &p->postfilter_agc);
953 }
954 
955 /// @}
956 
957  static int amrnb_decode_frame(AVCodecContext *avctx, AVFrame *frame,
958  int *got_frame_ptr, AVPacket *avpkt)
959 {
960 
961  AMRChannelsContext *s = avctx->priv_data; // pointer to private data
962  const uint8_t *buf = avpkt->data;
963  int buf_size = avpkt->size;
964  int ret;
965 
966  /* get output buffer */
967  frame->nb_samples = AMR_BLOCK_SIZE;
968  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
969  return ret;
970 
971  for (int ch = 0; ch < avctx->ch_layout.nb_channels; ch++) {
972  AMRContext *p = &s->ch[ch];
973  float fixed_gain_factor;
974  AMRFixed fixed_sparse = {0}; // fixed vector up to anti-sparseness processing
975  float spare_vector[AMR_SUBFRAME_SIZE]; // extra stack space to hold result from anti-sparseness processing
976  float synth_fixed_gain; // the fixed gain that synthesis should use
977  const float *synth_fixed_vector; // pointer to the fixed vector that synthesis should use
978  float *buf_out = (float *)frame->extended_data[ch];
979  int channel_size;
980  int i, subframe;
981 
982  p->cur_frame_mode = unpack_bitstream(p, buf, buf_size);
983  if (p->cur_frame_mode == NO_DATA) {
984  av_log(avctx, AV_LOG_ERROR, "Corrupt bitstream\n");
985  return AVERROR_INVALIDDATA;
986  }
987  if (p->cur_frame_mode == MODE_DTX) {
988  avpriv_report_missing_feature(avctx, "dtx mode");
989  av_log(avctx, AV_LOG_INFO, "Note: libopencore_amrnb supports dtx\n");
990  return AVERROR_PATCHWELCOME;
991  }
992 
993  channel_size = frame_sizes_nb[p->cur_frame_mode] + 1; // +7 for rounding and +8 for TOC
994  if (p->cur_frame_mode == MODE_12k2) {
995  lsf2lsp_5(p);
996  } else
997  lsf2lsp_3(p);
998 
999  for (i = 0; i < 4; i++)
1000  ff_acelp_lspd2lpc(p->lsp[i], p->lpc[i], 5);
1001 
1002  for (subframe = 0; subframe < 4; subframe++) {
1003  const AMRNBSubframe *amr_subframe = &p->frame.subframe[subframe];
1004 
1005  decode_pitch_vector(p, amr_subframe, subframe);
1006 
1007  decode_fixed_sparse(&fixed_sparse, amr_subframe->pulses,
1008  p->cur_frame_mode, subframe);
1009 
1010  // The fixed gain (section 6.1.3) depends on the fixed vector
1011  // (section 6.1.2), but the fixed vector calculation uses
1012  // pitch sharpening based on the on the pitch gain (section 6.1.3).
1013  // So the correct order is: pitch gain, pitch sharpening, fixed gain.
1014  decode_gains(p, amr_subframe, p->cur_frame_mode, subframe,
1015  &fixed_gain_factor);
1016 
1017  pitch_sharpening(p, subframe, p->cur_frame_mode, &fixed_sparse);
1018 
1019  if (fixed_sparse.pitch_lag == 0) {
1020  av_log(avctx, AV_LOG_ERROR, "The file is corrupted, pitch_lag = 0 is not allowed\n");
1021  return AVERROR_INVALIDDATA;
1022  }
1023  ff_set_fixed_vector(p->fixed_vector, &fixed_sparse, 1.0,
1024  AMR_SUBFRAME_SIZE);
1025 
1026  p->fixed_gain[4] =
1027  ff_amr_set_fixed_gain(fixed_gain_factor,
1028  p->celpm_ctx.dot_productf(p->fixed_vector,
1029  p->fixed_vector,
1030  AMR_SUBFRAME_SIZE) /
1031  AMR_SUBFRAME_SIZE,
1032  p->prediction_error,
1033  energy_mean[p->cur_frame_mode], energy_pred_fac);
1034 
1035  // The excitation feedback is calculated without any processing such
1036  // as fixed gain smoothing. This isn't mentioned in the specification.
1037  for (i = 0; i < AMR_SUBFRAME_SIZE; i++)
1038  p->excitation[i] *= p->pitch_gain[4];
1039  ff_set_fixed_vector(p->excitation, &fixed_sparse, p->fixed_gain[4],
1040  AMR_SUBFRAME_SIZE);
1041 
1042  // In the ref decoder, excitation is stored with no fractional bits.
1043  // This step prevents buzz in silent periods. The ref encoder can
1044  // emit long sequences with pitch factor greater than one. This
1045  // creates unwanted feedback if the excitation vector is nonzero.
1046  // (e.g. test sequence T19_795.COD in 3GPP TS 26.074)
1047  for (i = 0; i < AMR_SUBFRAME_SIZE; i++)
1048  p->excitation[i] = truncf(p->excitation[i]);
1049 
1050  // Smooth fixed gain.
1051  // The specification is ambiguous, but in the reference source, the
1052  // smoothed value is NOT fed back into later fixed gain smoothing.
1053  synth_fixed_gain = fixed_gain_smooth(p, p->lsf_q[subframe],
1054  p->lsf_avg, p->cur_frame_mode);
1055 
1056  synth_fixed_vector = anti_sparseness(p, &fixed_sparse, p->fixed_vector,
1057  synth_fixed_gain, spare_vector);
1058 
1059  if (synthesis(p, p->lpc[subframe], synth_fixed_gain,
1060  synth_fixed_vector, &p->samples_in[LP_FILTER_ORDER], 0))
1061  // overflow detected -> rerun synthesis scaling pitch vector down
1062  // by a factor of 4, skipping pitch vector contribution emphasis
1063  // and adaptive gain control
1064  synthesis(p, p->lpc[subframe], synth_fixed_gain,
1065  synth_fixed_vector, &p->samples_in[LP_FILTER_ORDER], 1);
1066 
1067  postfilter(p, p->lpc[subframe], buf_out + subframe * AMR_SUBFRAME_SIZE);
1068 
1069  // update buffers and history
1070  ff_clear_fixed_vector(p->fixed_vector, &fixed_sparse, AMR_SUBFRAME_SIZE);
1071  update_state(p);
1072  }
1073 
1074  p->acelpf_ctx.acelp_apply_order_2_transfer_function(buf_out,
1075  buf_out, highpass_zeros,
1076  highpass_poles,
1077  highpass_gain * AMR_SAMPLE_SCALE,
1078  p->high_pass_mem, AMR_BLOCK_SIZE);
1079 
1080  /* Update averaged lsf vector (used for fixed gain smoothing).
1081  *
1082  * Note that lsf_avg should not incorporate the current frame's LSFs
1083  * for fixed_gain_smooth.
1084  * The specification has an incorrect formula: the reference decoder uses
1085  * qbar(n-1) rather than qbar(n) in section 6.1(4) equation 71. */
1086  p->acelpv_ctx.weighted_vector_sumf(p->lsf_avg, p->lsf_avg, p->lsf_q[3],
1087  0.84, 0.16, LP_FILTER_ORDER);
1088  buf += channel_size;
1089  buf_size -= channel_size;
1090  }
1091 
1092  *got_frame_ptr = 1;
1093 
1094  return buf - avpkt->data;
1095 }
1096 
1097 
1098  const FFCodec ff_amrnb_decoder = {
1099  .p.name = "amrnb",
1100  CODEC_LONG_NAME("AMR-NB (Adaptive Multi-Rate NarrowBand)"),
1101  .p.type = AVMEDIA_TYPE_AUDIO,
1102  .p.id = AV_CODEC_ID_AMR_NB,
1103  .priv_data_size = sizeof(AMRChannelsContext),
1104  .init = amrnb_decode_init,
1105  FF_CODEC_DECODE_CB(amrnb_decode_frame),
1106  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
1107  .p.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLTP,
1108  AV_SAMPLE_FMT_NONE },
1109 };
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: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:100
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
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:107
out
FILE * out
Definition: movenc.c:55
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:1056
filter1
static void filter1(SUINT32 *dst, const int32_t *src, int32_t coeff, ptrdiff_t len)
Definition: dcadsp.c:360
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:389
AMRChannelsContext::ch
AMRContext ch[2]
Definition: amrnbdec.c:149
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:539
AV_CODEC_ID_AMR_NB
@ AV_CODEC_ID_AMR_NB
Definition: codec_id.h:421
FFCodec
Definition: codec_internal.h:127
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
filter
void(* filter)(uint8_t *src, int stride, int qscale)
Definition: h263dsp.c:29
AMR_SAMPLE_SCALE
#define AMR_SAMPLE_SCALE
Scale from constructed speech to [-1,1].
Definition: amrnbdec.c:74
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:321
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:1098
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
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
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:1071
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: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
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:311
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:198
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:97
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:49
decode.h
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
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:296
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
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: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
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:106
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:121
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1719
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:368
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:540
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:311
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:137
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1063
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: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
diff
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
Definition: vf_paletteuse.c:164
amrnb_decode_frame
static int amrnb_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)
Definition: amrnbdec.c:957
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
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:256
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:56
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
hf
uint8_t ptrdiff_t const uint8_t ptrdiff_t int const int8_t * hf
Definition: dsp.h:249
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
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:451
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
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:437
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:263
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
AV_CHANNEL_LAYOUT_MONO
#define AV_CHANNEL_LAYOUT_MONO
Definition: channel_layout.h:386
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:516
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:478
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: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: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:220
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:55
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
Generated on Fri Aug 22 2025 13:58:09 for FFmpeg by   doxygen 1.8.17

AltStyle によって変換されたページ (->オリジナル) /