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 /** Double version of ff_weighted_vector_sumf() */
149 static void weighted_vector_sumd(double *out, const double *in_a,
150  const double *in_b, double weight_coeff_a,
151  double weight_coeff_b, int length)
152 {
153  int i;
154 
155  for (i = 0; i < length; i++)
156  out[i] = weight_coeff_a * in_a[i]
157  + weight_coeff_b * in_b[i];
158 }
159 
161 {
162  AMRContext *p = avctx->priv_data;
163  int i;
164 
165  if (avctx->channels > 1) {
166  avpriv_report_missing_feature(avctx, "multi-channel AMR");
167  return AVERROR_PATCHWELCOME;
168  }
169 
170  avctx->channels = 1;
172  if (!avctx->sample_rate)
173  avctx->sample_rate = 8000;
174  avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
175 
176  // p->excitation always points to the same position in p->excitation_buf
178 
179  for (i = 0; i < LP_FILTER_ORDER; i++) {
180  p->prev_lsp_sub4[i] = lsp_sub4_init[i] * 1000 / (float)(1 << 15);
181  p->lsf_avg[i] = p->lsf_q[3][i] = lsp_avg_init[i] / (float)(1 << 15);
182  }
183 
184  for (i = 0; i < 4; i++)
186 
191 
192  return 0;
193 }
194 
195 
196 /**
197  * Unpack an RFC4867 speech frame into the AMR frame mode and parameters.
198  *
199  * The order of speech bits is specified by 3GPP TS 26.101.
200  *
201  * @param p the context
202  * @param buf pointer to the input buffer
203  * @param buf_size size of the input buffer
204  *
205  * @return the frame mode
206  */
207 static enum Mode unpack_bitstream(AMRContext *p, const uint8_t *buf,
208  int buf_size)
209 {
210  enum Mode mode;
211 
212  // Decode the first octet.
213  mode = buf[0] >> 3 & 0x0F; // frame type
214  p->bad_frame_indicator = (buf[0] & 0x4) != 0x4; // quality bit
215 
216  if (mode >= N_MODES || buf_size < frame_sizes_nb[mode] + 1) {
217  return NO_DATA;
218  }
219 
220  if (mode < MODE_DTX)
221  ff_amr_bit_reorder((uint16_t *) &p->frame, sizeof(AMRNBFrame), buf + 1,
223 
224  return mode;
225 }
226 
227 
228 /// @name AMR pitch LPC coefficient decoding functions
229 /// @{
230 
231 /**
232  * Interpolate the LSF vector (used for fixed gain smoothing).
233  * The interpolation is done over all four subframes even in MODE_12k2.
234  *
235  * @param[in] ctx The Context
236  * @param[in,out] lsf_q LSFs in [0,1] for each subframe
237  * @param[in] lsf_new New LSFs in [0,1] for subframe 4
238  */
239 static void interpolate_lsf(ACELPVContext *ctx, float lsf_q[4][LP_FILTER_ORDER], float *lsf_new)
240 {
241  int i;
242 
243  for (i = 0; i < 4; i++)
244  ctx->weighted_vector_sumf(lsf_q[i], lsf_q[3], lsf_new,
245  0.25 * (3 - i), 0.25 * (i + 1),
246  LP_FILTER_ORDER);
247 }
248 
249 /**
250  * Decode a set of 5 split-matrix quantized lsf indexes into an lsp vector.
251  *
252  * @param p the context
253  * @param lsp output LSP vector
254  * @param lsf_no_r LSF vector without the residual vector added
255  * @param lsf_quantizer pointers to LSF dictionary tables
256  * @param quantizer_offset offset in tables
257  * @param sign for the 3 dictionary table
258  * @param update store data for computing the next frame's LSFs
259  */
261  const float lsf_no_r[LP_FILTER_ORDER],
262  const int16_t *lsf_quantizer[5],
263  const int quantizer_offset,
264  const int sign, const int update)
265 {
266  int16_t lsf_r[LP_FILTER_ORDER]; // residual LSF vector
267  float lsf_q[LP_FILTER_ORDER]; // quantified LSF vector
268  int i;
269 
270  for (i = 0; i < LP_FILTER_ORDER >> 1; i++)
271  memcpy(&lsf_r[i << 1], &lsf_quantizer[i][quantizer_offset],
272  2 * sizeof(*lsf_r));
273 
274  if (sign) {
275  lsf_r[4] *= -1;
276  lsf_r[5] *= -1;
277  }
278 
279  if (update)
280  memcpy(p->prev_lsf_r, lsf_r, LP_FILTER_ORDER * sizeof(*lsf_r));
281 
282  for (i = 0; i < LP_FILTER_ORDER; i++)
283  lsf_q[i] = lsf_r[i] * (LSF_R_FAC / 8000.0) + lsf_no_r[i] * (1.0 / 8000.0);
284 
285  ff_set_min_dist_lsf(lsf_q, MIN_LSF_SPACING, LP_FILTER_ORDER);
286 
287  if (update)
288  interpolate_lsf(&p->acelpv_ctx, p->lsf_q, lsf_q);
289 
290  ff_acelp_lsf2lspd(lsp, lsf_q, LP_FILTER_ORDER);
291 }
292 
293 /**
294  * Decode a set of 5 split-matrix quantized lsf indexes into 2 lsp vectors.
295  *
296  * @param p pointer to the AMRContext
297  */
298 static void lsf2lsp_5(AMRContext *p)
299 {
300  const uint16_t *lsf_param = p->frame.lsf;
301  float lsf_no_r[LP_FILTER_ORDER]; // LSFs without the residual vector
302  const int16_t *lsf_quantizer[5];
303  int i;
304 
305  lsf_quantizer[0] = lsf_5_1[lsf_param[0]];
306  lsf_quantizer[1] = lsf_5_2[lsf_param[1]];
307  lsf_quantizer[2] = lsf_5_3[lsf_param[2] >> 1];
308  lsf_quantizer[3] = lsf_5_4[lsf_param[3]];
309  lsf_quantizer[4] = lsf_5_5[lsf_param[4]];
310 
311  for (i = 0; i < LP_FILTER_ORDER; i++)
312  lsf_no_r[i] = p->prev_lsf_r[i] * LSF_R_FAC * PRED_FAC_MODE_12k2 + lsf_5_mean[i];
313 
314  lsf2lsp_for_mode12k2(p, p->lsp[1], lsf_no_r, lsf_quantizer, 0, lsf_param[2] & 1, 0);
315  lsf2lsp_for_mode12k2(p, p->lsp[3], lsf_no_r, lsf_quantizer, 2, lsf_param[2] & 1, 1);
316 
317  // interpolate LSP vectors at subframes 1 and 3
318  weighted_vector_sumd(p->lsp[0], p->prev_lsp_sub4, p->lsp[1], 0.5, 0.5, LP_FILTER_ORDER);
319  weighted_vector_sumd(p->lsp[2], p->lsp[1] , p->lsp[3], 0.5, 0.5, LP_FILTER_ORDER);
320 }
321 
322 /**
323  * Decode a set of 3 split-matrix quantized lsf indexes into an lsp vector.
324  *
325  * @param p pointer to the AMRContext
326  */
327 static void lsf2lsp_3(AMRContext *p)
328 {
329  const uint16_t *lsf_param = p->frame.lsf;
330  int16_t lsf_r[LP_FILTER_ORDER]; // residual LSF vector
331  float lsf_q[LP_FILTER_ORDER]; // quantified LSF vector
332  const int16_t *lsf_quantizer;
333  int i, j;
334 
335  lsf_quantizer = (p->cur_frame_mode == MODE_7k95 ? lsf_3_1_MODE_7k95 : lsf_3_1)[lsf_param[0]];
336  memcpy(lsf_r, lsf_quantizer, 3 * sizeof(*lsf_r));
337 
338  lsf_quantizer = lsf_3_2[lsf_param[1] << (p->cur_frame_mode <= MODE_5k15)];
339  memcpy(lsf_r + 3, lsf_quantizer, 3 * sizeof(*lsf_r));
340 
341  lsf_quantizer = (p->cur_frame_mode <= MODE_5k15 ? lsf_3_3_MODE_5k15 : lsf_3_3)[lsf_param[2]];
342  memcpy(lsf_r + 6, lsf_quantizer, 4 * sizeof(*lsf_r));
343 
344  // calculate mean-removed LSF vector and add mean
345  for (i = 0; i < LP_FILTER_ORDER; i++)
346  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);
347 
348  ff_set_min_dist_lsf(lsf_q, MIN_LSF_SPACING, LP_FILTER_ORDER);
349 
350  // store data for computing the next frame's LSFs
351  interpolate_lsf(&p->acelpv_ctx, p->lsf_q, lsf_q);
352  memcpy(p->prev_lsf_r, lsf_r, LP_FILTER_ORDER * sizeof(*lsf_r));
353 
354  ff_acelp_lsf2lspd(p->lsp[3], lsf_q, LP_FILTER_ORDER);
355 
356  // interpolate LSP vectors at subframes 1, 2 and 3
357  for (i = 1; i <= 3; i++)
358  for(j = 0; j < LP_FILTER_ORDER; j++)
359  p->lsp[i-1][j] = p->prev_lsp_sub4[j] +
360  (p->lsp[3][j] - p->prev_lsp_sub4[j]) * 0.25 * i;
361 }
362 
363 /// @}
364 
365 
366 /// @name AMR pitch vector decoding functions
367 /// @{
368 
369 /**
370  * Like ff_decode_pitch_lag(), but with 1/6 resolution
371  */
372 static void decode_pitch_lag_1_6(int *lag_int, int *lag_frac, int pitch_index,
373  const int prev_lag_int, const int subframe)
374 {
375  if (subframe == 0 || subframe == 2) {
376  if (pitch_index < 463) {
377  *lag_int = (pitch_index + 107) * 10923 >> 16;
378  *lag_frac = pitch_index - *lag_int * 6 + 105;
379  } else {
380  *lag_int = pitch_index - 368;
381  *lag_frac = 0;
382  }
383  } else {
384  *lag_int = ((pitch_index + 5) * 10923 >> 16) - 1;
385  *lag_frac = pitch_index - *lag_int * 6 - 3;
386  *lag_int += av_clip(prev_lag_int - 5, PITCH_LAG_MIN_MODE_12k2,
387  PITCH_DELAY_MAX - 9);
388  }
389 }
390 
392  const AMRNBSubframe *amr_subframe,
393  const int subframe)
394 {
395  int pitch_lag_int, pitch_lag_frac;
396  enum Mode mode = p->cur_frame_mode;
397 
398  if (p->cur_frame_mode == MODE_12k2) {
399  decode_pitch_lag_1_6(&pitch_lag_int, &pitch_lag_frac,
400  amr_subframe->p_lag, p->pitch_lag_int,
401  subframe);
402  } else
403  ff_decode_pitch_lag(&pitch_lag_int, &pitch_lag_frac,
404  amr_subframe->p_lag,
405  p->pitch_lag_int, subframe,
406  mode != MODE_4k75 && mode != MODE_5k15,
407  mode <= MODE_6k7 ? 4 : (mode == MODE_7k95 ? 5 : 6));
408 
409  p->pitch_lag_int = pitch_lag_int; // store previous lag in a uint8_t
410 
411  pitch_lag_frac <<= (p->cur_frame_mode != MODE_12k2);
412 
413  pitch_lag_int += pitch_lag_frac > 0;
414 
415  /* Calculate the pitch vector by interpolating the past excitation at the
416  pitch lag using a b60 hamming windowed sinc function. */
418  p->excitation + 1 - pitch_lag_int,
419  ff_b60_sinc, 6,
420  pitch_lag_frac + 6 - 6*(pitch_lag_frac > 0),
421  10, AMR_SUBFRAME_SIZE);
422 
423  memcpy(p->pitch_vector, p->excitation, AMR_SUBFRAME_SIZE * sizeof(float));
424 }
425 
426 /// @}
427 
428 
429 /// @name AMR algebraic code book (fixed) vector decoding functions
430 /// @{
431 
432 /**
433  * Decode a 10-bit algebraic codebook index from a 10.2 kbit/s frame.
434  */
435 static void decode_10bit_pulse(int code, int pulse_position[8],
436  int i1, int i2, int i3)
437 {
438  // coded using 7+3 bits with the 3 LSBs being, individually, the LSB of 1 of
439  // the 3 pulses and the upper 7 bits being coded in base 5
440  const uint8_t *positions = base_five_table[code >> 3];
441  pulse_position[i1] = (positions[2] << 1) + ( code & 1);
442  pulse_position[i2] = (positions[1] << 1) + ((code >> 1) & 1);
443  pulse_position[i3] = (positions[0] << 1) + ((code >> 2) & 1);
444 }
445 
446 /**
447  * Decode the algebraic codebook index to pulse positions and signs and
448  * construct the algebraic codebook vector for MODE_10k2.
449  *
450  * @param fixed_index positions of the eight pulses
451  * @param fixed_sparse pointer to the algebraic codebook vector
452  */
453 static void decode_8_pulses_31bits(const int16_t *fixed_index,
454  AMRFixed *fixed_sparse)
455 {
456  int pulse_position[8];
457  int i, temp;
458 
459  decode_10bit_pulse(fixed_index[4], pulse_position, 0, 4, 1);
460  decode_10bit_pulse(fixed_index[5], pulse_position, 2, 6, 5);
461 
462  // coded using 5+2 bits with the 2 LSBs being, individually, the LSB of 1 of
463  // the 2 pulses and the upper 5 bits being coded in base 5
464  temp = ((fixed_index[6] >> 2) * 25 + 12) >> 5;
465  pulse_position[3] = temp % 5;
466  pulse_position[7] = temp / 5;
467  if (pulse_position[7] & 1)
468  pulse_position[3] = 4 - pulse_position[3];
469  pulse_position[3] = (pulse_position[3] << 1) + ( fixed_index[6] & 1);
470  pulse_position[7] = (pulse_position[7] << 1) + ((fixed_index[6] >> 1) & 1);
471 
472  fixed_sparse->n = 8;
473  for (i = 0; i < 4; i++) {
474  const int pos1 = (pulse_position[i] << 2) + i;
475  const int pos2 = (pulse_position[i + 4] << 2) + i;
476  const float sign = fixed_index[i] ? -1.0 : 1.0;
477  fixed_sparse->x[i ] = pos1;
478  fixed_sparse->x[i + 4] = pos2;
479  fixed_sparse->y[i ] = sign;
480  fixed_sparse->y[i + 4] = pos2 < pos1 ? -sign : sign;
481  }
482 }
483 
484 /**
485  * Decode the algebraic codebook index to pulse positions and signs,
486  * then construct the algebraic codebook vector.
487  *
488  * nb of pulses | bits encoding pulses
489  * For MODE_4k75 or MODE_5k15, 2 | 1-3, 4-6, 7
490  * MODE_5k9, 2 | 1, 2-4, 5-6, 7-9
491  * MODE_6k7, 3 | 1-3, 4, 5-7, 8, 9-11
492  * MODE_7k4 or MODE_7k95, 4 | 1-3, 4-6, 7-9, 10, 11-13
493  *
494  * @param fixed_sparse pointer to the algebraic codebook vector
495  * @param pulses algebraic codebook indexes
496  * @param mode mode of the current frame
497  * @param subframe current subframe number
498  */
499 static void decode_fixed_sparse(AMRFixed *fixed_sparse, const uint16_t *pulses,
500  const enum Mode mode, const int subframe)
501 {
502  av_assert1(MODE_4k75 <= (signed)mode && mode <= MODE_12k2);
503 
504  if (mode == MODE_12k2) {
505  ff_decode_10_pulses_35bits(pulses, fixed_sparse, gray_decode, 5, 3);
506  } else if (mode == MODE_10k2) {
507  decode_8_pulses_31bits(pulses, fixed_sparse);
508  } else {
509  int *pulse_position = fixed_sparse->x;
510  int i, pulse_subset;
511  const int fixed_index = pulses[0];
512 
513  if (mode <= MODE_5k15) {
514  pulse_subset = ((fixed_index >> 3) & 8) + (subframe << 1);
515  pulse_position[0] = ( fixed_index & 7) * 5 + track_position[pulse_subset];
516  pulse_position[1] = ((fixed_index >> 3) & 7) * 5 + track_position[pulse_subset + 1];
517  fixed_sparse->n = 2;
518  } else if (mode == MODE_5k9) {
519  pulse_subset = ((fixed_index & 1) << 1) + 1;
520  pulse_position[0] = ((fixed_index >> 1) & 7) * 5 + pulse_subset;
521  pulse_subset = (fixed_index >> 4) & 3;
522  pulse_position[1] = ((fixed_index >> 6) & 7) * 5 + pulse_subset + (pulse_subset == 3 ? 1 : 0);
523  fixed_sparse->n = pulse_position[0] == pulse_position[1] ? 1 : 2;
524  } else if (mode == MODE_6k7) {
525  pulse_position[0] = (fixed_index & 7) * 5;
526  pulse_subset = (fixed_index >> 2) & 2;
527  pulse_position[1] = ((fixed_index >> 4) & 7) * 5 + pulse_subset + 1;
528  pulse_subset = (fixed_index >> 6) & 2;
529  pulse_position[2] = ((fixed_index >> 8) & 7) * 5 + pulse_subset + 2;
530  fixed_sparse->n = 3;
531  } else { // mode <= MODE_7k95
532  pulse_position[0] = gray_decode[ fixed_index & 7];
533  pulse_position[1] = gray_decode[(fixed_index >> 3) & 7] + 1;
534  pulse_position[2] = gray_decode[(fixed_index >> 6) & 7] + 2;
535  pulse_subset = (fixed_index >> 9) & 1;
536  pulse_position[3] = gray_decode[(fixed_index >> 10) & 7] + pulse_subset + 3;
537  fixed_sparse->n = 4;
538  }
539  for (i = 0; i < fixed_sparse->n; i++)
540  fixed_sparse->y[i] = (pulses[1] >> i) & 1 ? 1.0 : -1.0;
541  }
542 }
543 
544 /**
545  * Apply pitch lag to obtain the sharpened fixed vector (section 6.1.2)
546  *
547  * @param p the context
548  * @param subframe unpacked amr subframe
549  * @param mode mode of the current frame
550  * @param fixed_sparse sparse respresentation of the fixed vector
551  */
552 static void pitch_sharpening(AMRContext *p, int subframe, enum Mode mode,
553  AMRFixed *fixed_sparse)
554 {
555  // The spec suggests the current pitch gain is always used, but in other
556  // modes the pitch and codebook gains are joinly quantized (sec 5.8.2)
557  // so the codebook gain cannot depend on the quantized pitch gain.
558  if (mode == MODE_12k2)
559  p->beta = FFMIN(p->pitch_gain[4], 1.0);
560 
561  fixed_sparse->pitch_lag = p->pitch_lag_int;
562  fixed_sparse->pitch_fac = p->beta;
563 
564  // Save pitch sharpening factor for the next subframe
565  // MODE_4k75 only updates on the 2nd and 4th subframes - this follows from
566  // the fact that the gains for two subframes are jointly quantized.
567  if (mode != MODE_4k75 || subframe & 1)
568  p->beta = av_clipf(p->pitch_gain[4], 0.0, SHARP_MAX);
569 }
570 /// @}
571 
572 
573 /// @name AMR gain decoding functions
574 /// @{
575 
576 /**
577  * fixed gain smoothing
578  * Note that where the spec specifies the "spectrum in the q domain"
579  * in section 6.1.4, in fact frequencies should be used.
580  *
581  * @param p the context
582  * @param lsf LSFs for the current subframe, in the range [0,1]
583  * @param lsf_avg averaged LSFs
584  * @param mode mode of the current frame
585  *
586  * @return fixed gain smoothed
587  */
588 static float fixed_gain_smooth(AMRContext *p , const float *lsf,
589  const float *lsf_avg, const enum Mode mode)
590 {
591  float diff = 0.0;
592  int i;
593 
594  for (i = 0; i < LP_FILTER_ORDER; i++)
595  diff += fabs(lsf_avg[i] - lsf[i]) / lsf_avg[i];
596 
597  // If diff is large for ten subframes, disable smoothing for a 40-subframe
598  // hangover period.
599  p->diff_count++;
600  if (diff <= 0.65)
601  p->diff_count = 0;
602 
603  if (p->diff_count > 10) {
604  p->hang_count = 0;
605  p->diff_count--; // don't let diff_count overflow
606  }
607 
608  if (p->hang_count < 40) {
609  p->hang_count++;
610  } else if (mode < MODE_7k4 || mode == MODE_10k2) {
611  const float smoothing_factor = av_clipf(4.0 * diff - 1.6, 0.0, 1.0);
612  const float fixed_gain_mean = (p->fixed_gain[0] + p->fixed_gain[1] +
613  p->fixed_gain[2] + p->fixed_gain[3] +
614  p->fixed_gain[4]) * 0.2;
615  return smoothing_factor * p->fixed_gain[4] +
616  (1.0 - smoothing_factor) * fixed_gain_mean;
617  }
618  return p->fixed_gain[4];
619 }
620 
621 /**
622  * Decode pitch gain and fixed gain factor (part of section 6.1.3).
623  *
624  * @param p the context
625  * @param amr_subframe unpacked amr subframe
626  * @param mode mode of the current frame
627  * @param subframe current subframe number
628  * @param fixed_gain_factor decoded gain correction factor
629  */
630 static void decode_gains(AMRContext *p, const AMRNBSubframe *amr_subframe,
631  const enum Mode mode, const int subframe,
632  float *fixed_gain_factor)
633 {
634  if (mode == MODE_12k2 || mode == MODE_7k95) {
635  p->pitch_gain[4] = qua_gain_pit [amr_subframe->p_gain ]
636  * (1.0 / 16384.0);
637  *fixed_gain_factor = qua_gain_code[amr_subframe->fixed_gain]
638  * (1.0 / 2048.0);
639  } else {
640  const uint16_t *gains;
641 
642  if (mode >= MODE_6k7) {
643  gains = gains_high[amr_subframe->p_gain];
644  } else if (mode >= MODE_5k15) {
645  gains = gains_low [amr_subframe->p_gain];
646  } else {
647  // gain index is only coded in subframes 0,2 for MODE_4k75
648  gains = gains_MODE_4k75[(p->frame.subframe[subframe & 2].p_gain << 1) + (subframe & 1)];
649  }
650 
651  p->pitch_gain[4] = gains[0] * (1.0 / 16384.0);
652  *fixed_gain_factor = gains[1] * (1.0 / 4096.0);
653  }
654 }
655 
656 /// @}
657 
658 
659 /// @name AMR preprocessing functions
660 /// @{
661 
662 /**
663  * Circularly convolve a sparse fixed vector with a phase dispersion impulse
664  * response filter (D.6.2 of G.729 and 6.1.5 of AMR).
665  *
666  * @param out vector with filter applied
667  * @param in source vector
668  * @param filter phase filter coefficients
669  *
670  * out[n] = sum(i,0,len-1){ in[i] * filter[(len + n - i)%len] }
671  */
672 static void apply_ir_filter(float *out, const AMRFixed *in,
673  const float *filter)
674 {
675  float filter1[AMR_SUBFRAME_SIZE], ///< filters at pitch lag*1 and *2
676  filter2[AMR_SUBFRAME_SIZE];
677  int lag = in->pitch_lag;
678  float fac = in->pitch_fac;
679  int i;
680 
681  if (lag < AMR_SUBFRAME_SIZE) {
682  ff_celp_circ_addf(filter1, filter, filter, lag, fac,
684 
685  if (lag < AMR_SUBFRAME_SIZE >> 1)
686  ff_celp_circ_addf(filter2, filter, filter1, lag, fac,
688  }
689 
690  memset(out, 0, sizeof(float) * AMR_SUBFRAME_SIZE);
691  for (i = 0; i < in->n; i++) {
692  int x = in->x[i];
693  float y = in->y[i];
694  const float *filterp;
695 
696  if (x >= AMR_SUBFRAME_SIZE - lag) {
697  filterp = filter;
698  } else if (x >= AMR_SUBFRAME_SIZE - (lag << 1)) {
699  filterp = filter1;
700  } else
701  filterp = filter2;
702 
703  ff_celp_circ_addf(out, out, filterp, x, y, AMR_SUBFRAME_SIZE);
704  }
705 }
706 
707 /**
708  * Reduce fixed vector sparseness by smoothing with one of three IR filters.
709  * Also know as "adaptive phase dispersion".
710  *
711  * This implements 3GPP TS 26.090 section 6.1(5).
712  *
713  * @param p the context
714  * @param fixed_sparse algebraic codebook vector
715  * @param fixed_vector unfiltered fixed vector
716  * @param fixed_gain smoothed gain
717  * @param out space for modified vector if necessary
718  */
719 static const float *anti_sparseness(AMRContext *p, AMRFixed *fixed_sparse,
720  const float *fixed_vector,
721  float fixed_gain, float *out)
722 {
723  int ir_filter_nr;
724 
725  if (p->pitch_gain[4] < 0.6) {
726  ir_filter_nr = 0; // strong filtering
727  } else if (p->pitch_gain[4] < 0.9) {
728  ir_filter_nr = 1; // medium filtering
729  } else
730  ir_filter_nr = 2; // no filtering
731 
732  // detect 'onset'
733  if (fixed_gain > 2.0 * p->prev_sparse_fixed_gain) {
734  p->ir_filter_onset = 2;
735  } else if (p->ir_filter_onset)
736  p->ir_filter_onset--;
737 
738  if (!p->ir_filter_onset) {
739  int i, count = 0;
740 
741  for (i = 0; i < 5; i++)
742  if (p->pitch_gain[i] < 0.6)
743  count++;
744  if (count > 2)
745  ir_filter_nr = 0;
746 
747  if (ir_filter_nr > p->prev_ir_filter_nr + 1)
748  ir_filter_nr--;
749  } else if (ir_filter_nr < 2)
750  ir_filter_nr++;
751 
752  // Disable filtering for very low level of fixed_gain.
753  // Note this step is not specified in the technical description but is in
754  // the reference source in the function Ph_disp.
755  if (fixed_gain < 5.0)
756  ir_filter_nr = 2;
757 
759  && ir_filter_nr < 2) {
760  apply_ir_filter(out, fixed_sparse,
761  (p->cur_frame_mode == MODE_7k95 ?
763  ir_filters_lookup)[ir_filter_nr]);
764  fixed_vector = out;
765  }
766 
767  // update ir filter strength history
768  p->prev_ir_filter_nr = ir_filter_nr;
770 
771  return fixed_vector;
772 }
773 
774 /// @}
775 
776 
777 /// @name AMR synthesis functions
778 /// @{
779 
780 /**
781  * Conduct 10th order linear predictive coding synthesis.
782  *
783  * @param p pointer to the AMRContext
784  * @param lpc pointer to the LPC coefficients
785  * @param fixed_gain fixed codebook gain for synthesis
786  * @param fixed_vector algebraic codebook vector
787  * @param samples pointer to the output speech samples
788  * @param overflow 16-bit overflow flag
789  */
790 static int synthesis(AMRContext *p, float *lpc,
791  float fixed_gain, const float *fixed_vector,
792  float *samples, uint8_t overflow)
793 {
794  int i;
796 
797  // if an overflow has been detected, the pitch vector is scaled down by a
798  // factor of 4
799  if (overflow)
800  for (i = 0; i < AMR_SUBFRAME_SIZE; i++)
801  p->pitch_vector[i] *= 0.25;
802 
803  p->acelpv_ctx.weighted_vector_sumf(excitation, p->pitch_vector, fixed_vector,
804  p->pitch_gain[4], fixed_gain, AMR_SUBFRAME_SIZE);
805 
806  // emphasize pitch vector contribution
807  if (p->pitch_gain[4] > 0.5 && !overflow) {
808  float energy = p->celpm_ctx.dot_productf(excitation, excitation,
809  AMR_SUBFRAME_SIZE);
810  float pitch_factor =
811  p->pitch_gain[4] *
812  (p->cur_frame_mode == MODE_12k2 ?
813  0.25 * FFMIN(p->pitch_gain[4], 1.0) :
814  0.5 * FFMIN(p->pitch_gain[4], SHARP_MAX));
815 
816  for (i = 0; i < AMR_SUBFRAME_SIZE; i++)
817  excitation[i] += pitch_factor * p->pitch_vector[i];
818 
819  ff_scale_vector_to_given_sum_of_squares(excitation, excitation, energy,
820  AMR_SUBFRAME_SIZE);
821  }
822 
823  p->celpf_ctx.celp_lp_synthesis_filterf(samples, lpc, excitation,
824  AMR_SUBFRAME_SIZE,
826 
827  // detect overflow
828  for (i = 0; i < AMR_SUBFRAME_SIZE; i++)
829  if (fabsf(samples[i]) > AMR_SAMPLE_BOUND) {
830  return 1;
831  }
832 
833  return 0;
834 }
835 
836 /// @}
837 
838 
839 /// @name AMR update functions
840 /// @{
841 
842 /**
843  * Update buffers and history at the end of decoding a subframe.
844  *
845  * @param p pointer to the AMRContext
846  */
847 static void update_state(AMRContext *p)
848 {
849  memcpy(p->prev_lsp_sub4, p->lsp[3], LP_FILTER_ORDER * sizeof(p->lsp[3][0]));
850 
851  memmove(&p->excitation_buf[0], &p->excitation_buf[AMR_SUBFRAME_SIZE],
852  (PITCH_DELAY_MAX + LP_FILTER_ORDER + 1) * sizeof(float));
853 
854  memmove(&p->pitch_gain[0], &p->pitch_gain[1], 4 * sizeof(float));
855  memmove(&p->fixed_gain[0], &p->fixed_gain[1], 4 * sizeof(float));
856 
857  memmove(&p->samples_in[0], &p->samples_in[AMR_SUBFRAME_SIZE],
858  LP_FILTER_ORDER * sizeof(float));
859 }
860 
861 /// @}
862 
863 
864 /// @name AMR Postprocessing functions
865 /// @{
866 
867 /**
868  * Get the tilt factor of a formant filter from its transfer function
869  *
870  * @param p The Context
871  * @param lpc_n LP_FILTER_ORDER coefficients of the numerator
872  * @param lpc_d LP_FILTER_ORDER coefficients of the denominator
873  */
874 static float tilt_factor(AMRContext *p, float *lpc_n, float *lpc_d)
875 {
876  float rh0, rh1; // autocorrelation at lag 0 and 1
877 
878  // LP_FILTER_ORDER prior zeros are needed for ff_celp_lp_synthesis_filterf
879  float impulse_buffer[LP_FILTER_ORDER + AMR_TILT_RESPONSE] = { 0 };
880  float *hf = impulse_buffer + LP_FILTER_ORDER; // start of impulse response
881 
882  hf[0] = 1.0;
883  memcpy(hf + 1, lpc_n, sizeof(float) * LP_FILTER_ORDER);
884  p->celpf_ctx.celp_lp_synthesis_filterf(hf, lpc_d, hf,
886  LP_FILTER_ORDER);
887 
888  rh0 = p->celpm_ctx.dot_productf(hf, hf, AMR_TILT_RESPONSE);
889  rh1 = p->celpm_ctx.dot_productf(hf, hf + 1, AMR_TILT_RESPONSE - 1);
890 
891  // The spec only specifies this check for 12.2 and 10.2 kbit/s
892  // modes. But in the ref source the tilt is always non-negative.
893  return rh1 >= 0.0 ? rh1 / rh0 * AMR_TILT_GAMMA_T : 0.0;
894 }
895 
896 /**
897  * Perform adaptive post-filtering to enhance the quality of the speech.
898  * See section 6.2.1.
899  *
900  * @param p pointer to the AMRContext
901  * @param lpc interpolated LP coefficients for this subframe
902  * @param buf_out output of the filter
903  */
904 static void postfilter(AMRContext *p, float *lpc, float *buf_out)
905 {
906  int i;
907  float *samples = p->samples_in + LP_FILTER_ORDER; // Start of input
908 
909  float speech_gain = p->celpm_ctx.dot_productf(samples, samples,
911 
912  float pole_out[AMR_SUBFRAME_SIZE + LP_FILTER_ORDER]; // Output of pole filter
913  const float *gamma_n, *gamma_d; // Formant filter factor table
914  float lpc_n[LP_FILTER_ORDER], lpc_d[LP_FILTER_ORDER]; // Transfer function coefficients
915 
916  if (p->cur_frame_mode == MODE_12k2 || p->cur_frame_mode == MODE_10k2) {
917  gamma_n = ff_pow_0_7;
918  gamma_d = ff_pow_0_75;
919  } else {
920  gamma_n = ff_pow_0_55;
921  gamma_d = ff_pow_0_7;
922  }
923 
924  for (i = 0; i < LP_FILTER_ORDER; i++) {
925  lpc_n[i] = lpc[i] * gamma_n[i];
926  lpc_d[i] = lpc[i] * gamma_d[i];
927  }
928 
929  memcpy(pole_out, p->postfilter_mem, sizeof(float) * LP_FILTER_ORDER);
930  p->celpf_ctx.celp_lp_synthesis_filterf(pole_out + LP_FILTER_ORDER, lpc_d, samples,
931  AMR_SUBFRAME_SIZE, LP_FILTER_ORDER);
932  memcpy(p->postfilter_mem, pole_out + AMR_SUBFRAME_SIZE,
933  sizeof(float) * LP_FILTER_ORDER);
934 
935  p->celpf_ctx.celp_lp_zero_synthesis_filterf(buf_out, lpc_n,
936  pole_out + LP_FILTER_ORDER,
937  AMR_SUBFRAME_SIZE, LP_FILTER_ORDER);
938 
939  ff_tilt_compensation(&p->tilt_mem, tilt_factor(p, lpc_n, lpc_d), buf_out,
941 
942  ff_adaptive_gain_control(buf_out, buf_out, speech_gain, AMR_SUBFRAME_SIZE,
944 }
945 
946 /// @}
947 
948 static int amrnb_decode_frame(AVCodecContext *avctx, void *data,
949  int *got_frame_ptr, AVPacket *avpkt)
950 {
951 
952  AMRContext *p = avctx->priv_data; // pointer to private data
953  AVFrame *frame = data;
954  const uint8_t *buf = avpkt->data;
955  int buf_size = avpkt->size;
956  float *buf_out; // pointer to the output data buffer
957  int i, subframe, ret;
958  float fixed_gain_factor;
959  AMRFixed fixed_sparse = {0}; // fixed vector up to anti-sparseness processing
960  float spare_vector[AMR_SUBFRAME_SIZE]; // extra stack space to hold result from anti-sparseness processing
961  float synth_fixed_gain; // the fixed gain that synthesis should use
962  const float *synth_fixed_vector; // pointer to the fixed vector that synthesis should use
963 
964  /* get output buffer */
965  frame->nb_samples = AMR_BLOCK_SIZE;
966  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
967  return ret;
968  buf_out = (float *)frame->data[0];
969 
970  p->cur_frame_mode = unpack_bitstream(p, buf, buf_size);
971  if (p->cur_frame_mode == NO_DATA) {
972  av_log(avctx, AV_LOG_ERROR, "Corrupt bitstream\n");
973  return AVERROR_INVALIDDATA;
974  }
975  if (p->cur_frame_mode == MODE_DTX) {
976  avpriv_report_missing_feature(avctx, "dtx mode");
977  av_log(avctx, AV_LOG_INFO, "Note: libopencore_amrnb supports dtx\n");
978  return AVERROR_PATCHWELCOME;
979  }
980 
981  if (p->cur_frame_mode == MODE_12k2) {
982  lsf2lsp_5(p);
983  } else
984  lsf2lsp_3(p);
985 
986  for (i = 0; i < 4; i++)
987  ff_acelp_lspd2lpc(p->lsp[i], p->lpc[i], 5);
988 
989  for (subframe = 0; subframe < 4; subframe++) {
990  const AMRNBSubframe *amr_subframe = &p->frame.subframe[subframe];
991 
992  decode_pitch_vector(p, amr_subframe, subframe);
993 
994  decode_fixed_sparse(&fixed_sparse, amr_subframe->pulses,
995  p->cur_frame_mode, subframe);
996 
997  // The fixed gain (section 6.1.3) depends on the fixed vector
998  // (section 6.1.2), but the fixed vector calculation uses
999  // pitch sharpening based on the on the pitch gain (section 6.1.3).
1000  // So the correct order is: pitch gain, pitch sharpening, fixed gain.
1001  decode_gains(p, amr_subframe, p->cur_frame_mode, subframe,
1002  &fixed_gain_factor);
1003 
1004  pitch_sharpening(p, subframe, p->cur_frame_mode, &fixed_sparse);
1005 
1006  if (fixed_sparse.pitch_lag == 0) {
1007  av_log(avctx, AV_LOG_ERROR, "The file is corrupted, pitch_lag = 0 is not allowed\n");
1008  return AVERROR_INVALIDDATA;
1009  }
1010  ff_set_fixed_vector(p->fixed_vector, &fixed_sparse, 1.0,
1012 
1013  p->fixed_gain[4] =
1014  ff_amr_set_fixed_gain(fixed_gain_factor,
1016  p->fixed_vector,
1019  p->prediction_error,
1021 
1022  // The excitation feedback is calculated without any processing such
1023  // as fixed gain smoothing. This isn't mentioned in the specification.
1024  for (i = 0; i < AMR_SUBFRAME_SIZE; i++)
1025  p->excitation[i] *= p->pitch_gain[4];
1026  ff_set_fixed_vector(p->excitation, &fixed_sparse, p->fixed_gain[4],
1027  AMR_SUBFRAME_SIZE);
1028 
1029  // In the ref decoder, excitation is stored with no fractional bits.
1030  // This step prevents buzz in silent periods. The ref encoder can
1031  // emit long sequences with pitch factor greater than one. This
1032  // creates unwanted feedback if the excitation vector is nonzero.
1033  // (e.g. test sequence T19_795.COD in 3GPP TS 26.074)
1034  for (i = 0; i < AMR_SUBFRAME_SIZE; i++)
1035  p->excitation[i] = truncf(p->excitation[i]);
1036 
1037  // Smooth fixed gain.
1038  // The specification is ambiguous, but in the reference source, the
1039  // smoothed value is NOT fed back into later fixed gain smoothing.
1040  synth_fixed_gain = fixed_gain_smooth(p, p->lsf_q[subframe],
1041  p->lsf_avg, p->cur_frame_mode);
1042 
1043  synth_fixed_vector = anti_sparseness(p, &fixed_sparse, p->fixed_vector,
1044  synth_fixed_gain, spare_vector);
1045 
1046  if (synthesis(p, p->lpc[subframe], synth_fixed_gain,
1047  synth_fixed_vector, &p->samples_in[LP_FILTER_ORDER], 0))
1048  // overflow detected -> rerun synthesis scaling pitch vector down
1049  // by a factor of 4, skipping pitch vector contribution emphasis
1050  // and adaptive gain control
1051  synthesis(p, p->lpc[subframe], synth_fixed_gain,
1052  synth_fixed_vector, &p->samples_in[LP_FILTER_ORDER], 1);
1053 
1054  postfilter(p, p->lpc[subframe], buf_out + subframe * AMR_SUBFRAME_SIZE);
1055 
1056  // update buffers and history
1057  ff_clear_fixed_vector(p->fixed_vector, &fixed_sparse, AMR_SUBFRAME_SIZE);
1058  update_state(p);
1059  }
1060 
1062  buf_out, highpass_zeros,
1066 
1067  /* Update averaged lsf vector (used for fixed gain smoothing).
1068  *
1069  * Note that lsf_avg should not incorporate the current frame's LSFs
1070  * for fixed_gain_smooth.
1071  * The specification has an incorrect formula: the reference decoder uses
1072  * qbar(n-1) rather than qbar(n) in section 6.1(4) equation 71. */
1074  0.84, 0.16, LP_FILTER_ORDER);
1075 
1076  *got_frame_ptr = 1;
1077 
1078  /* return the amount of bytes consumed if everything was OK */
1079  return frame_sizes_nb[p->cur_frame_mode] + 1; // +7 for rounding and +8 for TOC
1080 }
1081 
1082 
1084  .name = "amrnb",
1085  .type = AVMEDIA_TYPE_AUDIO,
1086  .id = AV_CODEC_ID_AMR_NB,
1087  .priv_data_size = sizeof(AMRContext),
1090  .capabilities = CODEC_CAP_DR1,
1091  .long_name = NULL_IF_CONFIG_SMALL("AMR-NB (Adaptive Multi-Rate NarrowBand)"),
1092  .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLT,
1094 };
#define AMR_SAMPLE_SCALE
Scale from constructed speech to [-1,1].
Definition: amrnbdec.c:74
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...
#define AMR_BLOCK_SIZE
samples per frame
Definition: amrnbdec.c:62
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
This structure describes decoded (raw) audio or video data.
Definition: frame.h:76
float lsf_avg[LP_FILTER_ORDER]
vector of averaged lsf vector
Definition: amrnbdec.c:110
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...
static int amrnb_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: amrnbdec.c:948
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:552
else temp
Definition: vf_mcdeint.c:148
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
AMRNB unpacked data frame.
Definition: amrnbdata.h:68
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
float(* dot_productf)(const float *a, const float *b, int length)
Return the dot product.
Definition: celp_math.h:37
void ff_clear_fixed_vector(float *out, const AMRFixed *in, int size)
Clear array values set by set_fixed_vector.
static const uint8_t base_five_table[128][3]
Base-5 representation for values 0-124.
Definition: amrnbdata.h:367
int x[10]
Definition: acelp_vectors.h:55
static const int16_t lsf_3_1[256][3]
Definition: amrnbdata.h:633
About Git write you should know how to use GIT properly Luckily Git comes with excellent documentation git help man git shows you the available git< command > help man git< command > shows information about the subcommand< command > The most comprehensive manual is the website Git Reference visit they are quite exhaustive You do not need a special username or password All you need is to provide a ssh public key to the Git server admin What follows now is a basic introduction to Git and some FFmpeg specific guidelines Read it at least if you are granted commit privileges to the FFmpeg project you are expected to be familiar with these rules I if not You can get git from etc no matter how small Every one of them has been saved from looking like a fool by this many times It s very easy for stray debug output or cosmetic modifications to slip in
Definition: git-howto.txt:5
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:499
static const uint8_t track_position[16]
track start positions for algebraic code book routines
Definition: amrnbdata.h:1433
uint8_t bad_frame_indicator
bad frame ? 1 : 0
Definition: amrnbdec.c:102
silent frame
Definition: amrnbdata.h:48
void ff_set_fixed_vector(float *out, const AMRFixed *in, float scale, int size)
Add fixed vector to an array from a sparse representation.
float pitch_fac
Definition: acelp_vectors.h:59
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:588
static const int16_t lsf_3_2[512][3]
Definition: amrnbdata.h:723
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:790
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:149
static av_cold int amrnb_decode_init(AVCodecContext *avctx)
Definition: amrnbdec.c:160
double prev_lsp_sub4[LP_FILTER_ORDER]
lsp vector for the 4th subframe of the previous frame
Definition: amrnbdec.c:107
static void postfilter(AMRContext *p, float *lpc, float *buf_out)
Perform adaptive post-filtering to enhance the quality of the speech.
Definition: amrnbdec.c:904
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
static const int16_t lsf_5_1[128][4]
Definition: amrnbdata.h:1071
float postfilter_agc
previous factor used for adaptive gain control
Definition: amrnbdec.c:136
no transmission
Definition: amrnbdata.h:50
enum AVSampleFormat sample_fmt
audio sample format
uint8_t
#define av_cold
Definition: attributes.h:78
Sparse representation for the algebraic codebook (fixed) vector.
Definition: acelp_vectors.h:53
mode
Definition: f_perms.c:27
static const uint16_t qua_gain_code[32]
scalar quantized fixed gain table for 7.95 and 12.2 kbps modes
Definition: amrnbdata.h:1450
Mode
Frame type (Table 1a in 3GPP TS 26.101)
Definition: amrnbdata.h:39
static const uint16_t qua_gain_pit[16]
scalar quantized pitch gain table for 7.95 and 12.2 kbps modes
Definition: amrnbdata.h:1444
#define PITCH_DELAY_MAX
static void lsf2lsp_3(AMRContext *p)
Decode a set of 3 split-matrix quantized lsf indexes into an lsp vector.
Definition: amrnbdec.c:327
static const float energy_pred_fac[4]
4-tap moving average prediction coefficients in reverse order
Definition: amrnbdata.h:1463
uint16_t fixed_gain
index to decode the fixed gain factor, for MODE_12k2 and MODE_7k95
Definition: amrnbdata.h:61
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
the mask is usually to keep the same permissions Filters should remove permissions on reference they give to output whenever necessary It can be automatically done by setting the rej_perms field on the output pad Here are a few guidelines corresponding to common 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
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
5.90 kbit/s
Definition: amrnbdata.h:42
double lsp[4][LP_FILTER_ORDER]
lsp vectors from current frame
Definition: amrnbdec.c:106
uint8_t * data
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:672
AMRNBFrame frame
decoded AMR parameters (lsf coefficients, codebook indexes, etc)
Definition: amrnbdec.c:101
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)
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
uint16_t lsf[5]
lsf parameters: 5 parameters for MODE_12k2, only 3 for other modes
Definition: amrnbdata.h:69
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
uint8_t prev_ir_filter_nr
previous impulse response filter "impNr": 0 - strong, 1 - medium, 2 - none
Definition: amrnbdec.c:131
Discrete Time axis x
static void decode_pitch_vector(AMRContext *p, const AMRNBSubframe *amr_subframe, const int subframe)
Definition: amrnbdec.c:391
static void update_state(AMRContext *p)
Update buffers and history at the end of decoding a subframe.
Definition: amrnbdec.c:847
float fixed_vector[AMR_SUBFRAME_SIZE]
algebraic codebook (fixed) vector (must be kept zero between frames)
Definition: amrnbdec.c:120
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Spectrum Plot time data
AMRNBSubframe subframe[4]
unpacked data for each subframe
Definition: amrnbdata.h:70
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
const float ff_pow_0_7[10]
Table of pow(0.7,n)
Definition: acelp_vectors.c:98
simple assert() macros that are a bit more flexible than ISO C assert().
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:246
const char * name
Name of the codec implementation.
int16_t prev_lsf_r[LP_FILTER_ORDER]
residual LSF vector from previous subframe
Definition: amrnbdec.c:105
static const uint8_t frame_sizes_nb[N_MODES]
number of bytes for each mode
Definition: amrnbdata.h:357
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.
const float ff_pow_0_75[10]
Table of pow(0.75,n)
float pitch_gain[5]
quantified pitch gains for the current and previous four subframes
Definition: amrnbdec.c:123
#define LP_FILTER_ORDER
linear predictive coding filter order
Definition: amrnbdata.h:53
external API header
static const int16_t lsf_3_3_MODE_5k15[128][4]
Definition: amrnbdata.h:413
float * excitation
pointer to the current excitation vector in excitation_buf
Definition: amrnbdec.c:117
uint64_t channel_layout
Audio channel layout.
#define AMR_SAMPLE_BOUND
threshold for synthesis overflow
Definition: amrnbdec.c:63
uint8_t ir_filter_onset
flag for impulse response filter strength
Definition: amrnbdec.c:132
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:239
#define AMR_SUBFRAME_SIZE
samples per subframe
Definition: amrnbdata.h:36
static const float *const ir_filters_lookup_MODE_7k95[2]
Definition: amrnbdata.h:1661
AMRNB unpacked data subframe.
Definition: amrnbdata.h:58
audio channel layout utility functions
#define MIN_ENERGY
Initial energy in dB.
Definition: amrnbdec.c:84
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
static const float highpass_poles[2]
Definition: amrnbdata.h:1668
#define FFMIN(a, b)
Definition: common.h:58
AVCodec ff_amrnb_decoder
Definition: amrnbdec.c:1083
number of modes
Definition: amrnbdata.h:49
ret
Definition: avfilter.c:821
float samples_in[LP_FILTER_ORDER+AMR_SUBFRAME_SIZE]
floating point samples
Definition: amrnbdec.c:139
12.2 kbit/s
Definition: amrnbdata.h:47
static const int16_t lsf_3_1_MODE_7k95[512][3]
Definition: amrnbdata.h:459
float y[10]
Definition: acelp_vectors.h:56
static const int16_t lsf_5_5[64][4]
Definition: amrnbdata.h:1384
uint16_t p_lag
index to decode the pitch lag
Definition: amrnbdata.h:59
static av_always_inline av_const float truncf(float x)
Definition: libm.h:183
#define diff(a, as, b, bs)
Definition: vf_phase.c:80
static const float highpass_zeros[2]
Definition: amrnbdata.h:1667
static const uint16_t gains_MODE_4k75[512][2]
gain table for 4.75 kbps mode
Definition: amrnbdata.h:1469
float pitch_vector[AMR_SUBFRAME_SIZE]
adaptive code book (pitch) vector
Definition: amrnbdec.c:119
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
void ff_tilt_compensation(float *mem, float tilt, float *samples, int size)
Apply tilt compensation filter, 1 - tilt * z-1.
#define MIN_LSF_SPACING
Ensures stability of LPC filter.
Definition: amrnbdec.c:80
static const float lsf_3_mean[LP_FILTER_ORDER]
Definition: amrnbdata.h:1409
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
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
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:719
or the Software in violation of any applicable export control laws in any jurisdiction Except as provided by mandatorily applicable UPF has no obligation to provide you with source code to the Software In the event Software contains any source code
uint8_t pitch_lag_int
integer part of pitch lag from current subframe
Definition: amrnbdec.c:114
float tilt_mem
previous input to tilt compensation filter
Definition: amrnbdec.c:135
float lsf_q[4][LP_FILTER_ORDER]
Interpolated LSF vector for fixed gain smoothing.
Definition: amrnbdec.c:109
#define PRED_FAC_MODE_12k2
Prediction factor for 12.2kbit/s mode.
Definition: amrnbdec.c:77
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:50
int sample_rate
samples per second
7.95 kbit/s
Definition: amrnbdata.h:45
float high_pass_mem[2]
previous intermediate values in the high-pass filter
Definition: amrnbdec.c:137
main external API structure.
static const float lsf_5_mean[LP_FILTER_ORDER]
Definition: amrnbdata.h:1414
10.2 kbit/s
Definition: amrnbdata.h:46
uint16_t p_gain
index to decode the pitch gain
Definition: amrnbdata.h:60
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:148
void ff_celp_math_init(CELPMContext *c)
Initialize CELPMContext.
Definition: celp_math.c:120
void * buf
Definition: avisynth_c.h:594
uint8_t diff_count
the number of subframes for which diff has been above 0.65
Definition: amrnbdec.c:127
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
float prediction_error[4]
quantified prediction errors {20log10(^gamma_gc)} for previous four subframes
Definition: amrnbdec.c:122
for lag
void ff_celp_filter_init(CELPFContext *c)
Initialize CELPFContext.
Definition: celp_filters.c:212
synthesis window for stochastic i
static const float highpass_gain
Definition: amrnbdata.h:1669
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:874
void ff_acelp_lsf2lspd(double *lsp, const float *lsf, int lp_order)
Floating point version of ff_acelp_lsf2lsp()
Definition: lsp.c:93
enum Mode cur_frame_mode
Definition: amrnbdec.c:103
float fixed_gain[5]
quantified fixed gains for the current and previous four subframes
Definition: amrnbdec.c:124
float lpc[4][LP_FILTER_ORDER]
lpc coefficient vectors for 4 subframes
Definition: amrnbdec.c:112
float beta
previous pitch_gain, bounded by [0.0,SHARP_MAX]
Definition: amrnbdec.c:126
#define SHARP_MAX
Maximum sharpening factor.
Definition: amrnbdec.c:91
#define AMR_TILT_RESPONSE
Number of impulse response coefficients used for tilt factor.
Definition: amrnbdec.c:94
static const float *const ir_filters_lookup[2]
Definition: amrnbdata.h:1658
CELPFContext celpf_ctx
context for filters for CELP-based codecs
Definition: amrnbdec.c:143
void ff_acelp_vectors_init(ACELPVContext *c)
Initialize ACELPVContext.
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:453
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:372
static const int16_t lsf_5_4[256][4]
Definition: amrnbdata.h:1295
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
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:435
static const int16_t lsf_3_3[512][4]
Definition: amrnbdata.h:897
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:87
static const int16_t lsf_5_2[256][4]
Definition: amrnbdata.h:1117
static const uint8_t gray_decode[8]
3-bit Gray code to binary lookup table
Definition: amrnbdata.h:1438
static const float pred_fac[LP_FILTER_ORDER]
Prediction factor table for modes other than 12.2kbit/s.
Definition: amrnbdata.h:1420
float prev_sparse_fixed_gain
previous fixed gain; used by anti-sparseness processing to determine "onset"
Definition: amrnbdec.c:130
float postfilter_mem[10]
previous intermediate values in the formant filter
Definition: amrnbdec.c:134
#define AMR_AGC_ALPHA
Adaptive gain control factor used in post-filter.
Definition: amrnbdec.c:98
common internal api header.
common internal and external API header
static void lsf2lsp_5(AMRContext *p)
Decode a set of 5 split-matrix quantized lsf indexes into 2 lsp vectors.
Definition: amrnbdec.c:298
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:260
int pitch_lag
Definition: acelp_vectors.h:58
static const uint16_t gains_low[64][2]
gain table for 5.15 and 5.90 kbps modes
Definition: amrnbdata.h:1610
6.70 kbit/s
Definition: amrnbdata.h:43
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:630
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
AVSampleFormat
Audio Sample Formats.
Definition: samplefmt.h:49
void ff_acelp_filter_init(ACELPFContext *c)
Initialize ACELPFContext.
function y
Definition: D.m:1
#define LSF_R_FAC
LSF residual tables to Hertz.
Definition: amrnbdec.c:79
const float ff_b60_sinc[61]
b60 hamming windowed sinc function coefficients
4.75 kbit/s
Definition: amrnbdata.h:40
static const uint16_t gains_high[128][2]
gain table for 6.70, 7.40 and 10.2 kbps modes
Definition: amrnbdata.h:1578
uint8_t hang_count
the number of subframes since a hangover period started
Definition: amrnbdec.c:128
int channels
number of audio channels
AMR narrowband data and definitions.
static const float energy_mean[8]
desired mean innovation energy, indexed by active mode
Definition: amrnbdata.h:1458
7.40 kbit/s
Definition: amrnbdata.h:44
#define PITCH_LAG_MIN_MODE_12k2
Lower bound on decoded lag search in 12.2kbit/s mode.
Definition: amrnbdec.c:81
CELPMContext celpm_ctx
context for fixed point math operations
Definition: amrnbdec.c:144
#define AV_LOG_INFO
Definition: log.h:156
Filter the word “frame” indicates either a video frame or a group of audio samples
static const int8_t pulses[4]
Number of non-zero pulses in the MP-MLQ excitation.
Definition: g723_1_data.h:608
void INT64 INT64 count
Definition: avisynth_c.h:594
uint16_t pulses[10]
pulses: 10 for MODE_12k2, 7 for MODE_10k2, and index and sign for others
Definition: amrnbdata.h:62
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31))))#define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac){}void ff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map){AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);return NULL;}return ac;}in_planar=av_sample_fmt_is_planar(in_fmt);out_planar=av_sample_fmt_is_planar(out_fmt);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;}int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){int use_generic=1;int len=in->nb_samples;int p;if(ac->dc){av_dlog(ac->avr,"%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> out
static int decode(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: crystalhd.c:868
struct AMRContext AMRContext
x4
Definition: Lab2 1d.m:1
float excitation_buf[PITCH_DELAY_MAX+LP_FILTER_ORDER+1+AMR_SUBFRAME_SIZE]
current excitation and all necessary excitation history
Definition: amrnbdec.c:116
const char int length
Definition: avisynth_c.h:668
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:207
#define AV_CH_LAYOUT_MONO
5.15 kbit/s
Definition: amrnbdata.h:41
This structure stores compressed data.
const float ff_pow_0_55[10]
Table of pow(0.55,n)
ACELPFContext acelpf_ctx
context for filters for ACELP-based codecs
Definition: amrnbdec.c:141
static const int16_t lsf_5_3[256][4]
Definition: amrnbdata.h:1206
#define AMR_TILT_GAMMA_T
Tilt factor = 1st reflection coefficient * gamma_t.
Definition: amrnbdec.c:96
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:127
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)
ACELPVContext acelpv_ctx
context for vector operations for ACELP-based codecs
Definition: amrnbdec.c:142
static const int16_t lsp_avg_init[LP_FILTER_ORDER]
Mean lsp values.
Definition: amrnbdata.h:404