FFmpeg
amrwbdec.c
Go to the documentation of this file.
1 /*
2  * AMR wideband decoder
3  * Copyright (c) 2010 Marcelo Galvao Povoa
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A particular PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * AMR wideband decoder
25  */
26 
28 #include "libavutil/common.h"
29 #include "libavutil/float_dsp.h"
30 #include "libavutil/lfg.h"
31 
32 #include "avcodec.h"
33 #include "lsp.h"
34 #include "celp_filters.h"
35 #include "celp_math.h"
36 #include "acelp_filters.h"
37 #include "acelp_vectors.h"
38 #include "acelp_pitch_delay.h"
39 #include "codec_internal.h"
40 #include "internal.h"
41 
42 #define AMR_USE_16BIT_TABLES
43 #include "amr.h"
44 
45 #include "amrwbdata.h"
46 #include "mips/amrwbdec_mips.h"
47 
48 typedef struct AMRWBContext {
49  AMRWBFrame frame; ///< AMRWB parameters decoded from bitstream
50  enum Mode fr_cur_mode; ///< mode index of current frame
51  uint8_t fr_quality; ///< frame quality index (FQI)
52  float isf_cur[LP_ORDER]; ///< working ISF vector from current frame
53  float isf_q_past[LP_ORDER]; ///< quantized ISF vector of the previous frame
54  float isf_past_final[LP_ORDER]; ///< final processed ISF vector of the previous frame
55  double isp[4][LP_ORDER]; ///< ISP vectors from current frame
56  double isp_sub4_past[LP_ORDER]; ///< ISP vector for the 4th subframe of the previous frame
57 
58  float lp_coef[4][LP_ORDER]; ///< Linear Prediction Coefficients from ISP vector
59 
60  uint8_t base_pitch_lag; ///< integer part of pitch lag for the next relative subframe
61  uint8_t pitch_lag_int; ///< integer part of pitch lag of the previous subframe
62 
63  float excitation_buf[AMRWB_P_DELAY_MAX + LP_ORDER + 2 + AMRWB_SFR_SIZE]; ///< current excitation and all necessary excitation history
64  float *excitation; ///< points to current excitation in excitation_buf[]
65 
66  float pitch_vector[AMRWB_SFR_SIZE]; ///< adaptive codebook (pitch) vector for current subframe
67  float fixed_vector[AMRWB_SFR_SIZE]; ///< algebraic codebook (fixed) vector for current subframe
68 
69  float prediction_error[4]; ///< quantified prediction errors {20log10(^gamma_gc)} for previous four subframes
70  float pitch_gain[6]; ///< quantified pitch gains for the current and previous five subframes
71  float fixed_gain[2]; ///< quantified fixed gains for the current and previous subframes
72 
73  float tilt_coef; ///< {beta_1} related to the voicing of the previous subframe
74 
75  float prev_sparse_fixed_gain; ///< previous fixed gain; used by anti-sparseness to determine "onset"
76  uint8_t prev_ir_filter_nr; ///< previous impulse response filter "impNr": 0 - strong, 1 - medium, 2 - none
77  float prev_tr_gain; ///< previous initial gain used by noise enhancer for threshold
78 
79  float samples_az[LP_ORDER + AMRWB_SFR_SIZE]; ///< low-band samples and memory from synthesis at 12.8kHz
80  float samples_up[UPS_MEM_SIZE + AMRWB_SFR_SIZE]; ///< low-band samples and memory processed for upsampling
81  float samples_hb[LP_ORDER_16k + AMRWB_SFR_SIZE_16k]; ///< high-band samples and memory from synthesis at 16kHz
82 
83  float hpf_31_mem[2], hpf_400_mem[2]; ///< previous values in the high pass filters
84  float demph_mem[1]; ///< previous value in the de-emphasis filter
85  float bpf_6_7_mem[HB_FIR_SIZE]; ///< previous values in the high-band band pass filter
86  float lpf_7_mem[HB_FIR_SIZE]; ///< previous values in the high-band low pass filter
87 
88  AVLFG prng; ///< random number generator for white noise excitation
89  uint8_t first_frame; ///< flag active during decoding of the first frame
90  ACELPFContext acelpf_ctx; ///< context for filters for ACELP-based codecs
91  ACELPVContext acelpv_ctx; ///< context for vector operations for ACELP-based codecs
92  CELPFContext celpf_ctx; ///< context for filters for CELP-based codecs
93  CELPMContext celpm_ctx; ///< context for fixed point math operations
94 
95 } AMRWBContext;
96 
97 typedef struct AMRWBChannelsContext {
100 
102 {
103  AMRWBChannelsContext *s = avctx->priv_data;
104  int i;
105 
106  if (avctx->ch_layout.nb_channels > 2) {
107  avpriv_report_missing_feature(avctx, ">2 channel AMR");
108  return AVERROR_PATCHWELCOME;
109  }
110 
111  if (!avctx->ch_layout.nb_channels) {
114  }
115  if (!avctx->sample_rate)
116  avctx->sample_rate = 16000;
118 
119  for (int ch = 0; ch < avctx->ch_layout.nb_channels; ch++) {
120  AMRWBContext *ctx = &s->ch[ch];
121 
122  av_lfg_init(&ctx->prng, 1);
123 
124  ctx->excitation = &ctx->excitation_buf[AMRWB_P_DELAY_MAX + LP_ORDER + 1];
125  ctx->first_frame = 1;
126 
127  for (i = 0; i < LP_ORDER; i++)
128  ctx->isf_past_final[i] = isf_init[i] * (1.0f / (1 << 15));
129 
130  for (i = 0; i < 4; i++)
131  ctx->prediction_error[i] = MIN_ENERGY;
132 
133  ff_acelp_filter_init(&ctx->acelpf_ctx);
134  ff_acelp_vectors_init(&ctx->acelpv_ctx);
135  ff_celp_filter_init(&ctx->celpf_ctx);
136  ff_celp_math_init(&ctx->celpm_ctx);
137  }
138 
139  return 0;
140 }
141 
142 /**
143  * Decode the frame header in the "MIME/storage" format. This format
144  * is simpler and does not carry the auxiliary frame information.
145  *
146  * @param[in] ctx The Context
147  * @param[in] buf Pointer to the input buffer
148  *
149  * @return The decoded header length in bytes
150  */
151 static int decode_mime_header(AMRWBContext *ctx, const uint8_t *buf)
152 {
153  /* Decode frame header (1st octet) */
154  ctx->fr_cur_mode = buf[0] >> 3 & 0x0F;
155  ctx->fr_quality = (buf[0] & 0x4) == 0x4;
156 
157  return 1;
158 }
159 
160 /**
161  * Decode quantized ISF vectors using 36-bit indexes (6K60 mode only).
162  *
163  * @param[in] ind Array of 5 indexes
164  * @param[out] isf_q Buffer for isf_q[LP_ORDER]
165  */
166 static void decode_isf_indices_36b(uint16_t *ind, float *isf_q)
167 {
168  int i;
169 
170  for (i = 0; i < 9; i++)
171  isf_q[i] = dico1_isf[ind[0]][i] * (1.0f / (1 << 15));
172 
173  for (i = 0; i < 7; i++)
174  isf_q[i + 9] = dico2_isf[ind[1]][i] * (1.0f / (1 << 15));
175 
176  for (i = 0; i < 5; i++)
177  isf_q[i] += dico21_isf_36b[ind[2]][i] * (1.0f / (1 << 15));
178 
179  for (i = 0; i < 4; i++)
180  isf_q[i + 5] += dico22_isf_36b[ind[3]][i] * (1.0f / (1 << 15));
181 
182  for (i = 0; i < 7; i++)
183  isf_q[i + 9] += dico23_isf_36b[ind[4]][i] * (1.0f / (1 << 15));
184 }
185 
186 /**
187  * Decode quantized ISF vectors using 46-bit indexes (except 6K60 mode).
188  *
189  * @param[in] ind Array of 7 indexes
190  * @param[out] isf_q Buffer for isf_q[LP_ORDER]
191  */
192 static void decode_isf_indices_46b(uint16_t *ind, float *isf_q)
193 {
194  int i;
195 
196  for (i = 0; i < 9; i++)
197  isf_q[i] = dico1_isf[ind[0]][i] * (1.0f / (1 << 15));
198 
199  for (i = 0; i < 7; i++)
200  isf_q[i + 9] = dico2_isf[ind[1]][i] * (1.0f / (1 << 15));
201 
202  for (i = 0; i < 3; i++)
203  isf_q[i] += dico21_isf[ind[2]][i] * (1.0f / (1 << 15));
204 
205  for (i = 0; i < 3; i++)
206  isf_q[i + 3] += dico22_isf[ind[3]][i] * (1.0f / (1 << 15));
207 
208  for (i = 0; i < 3; i++)
209  isf_q[i + 6] += dico23_isf[ind[4]][i] * (1.0f / (1 << 15));
210 
211  for (i = 0; i < 3; i++)
212  isf_q[i + 9] += dico24_isf[ind[5]][i] * (1.0f / (1 << 15));
213 
214  for (i = 0; i < 4; i++)
215  isf_q[i + 12] += dico25_isf[ind[6]][i] * (1.0f / (1 << 15));
216 }
217 
218 /**
219  * Apply mean and past ISF values using the prediction factor.
220  * Updates past ISF vector.
221  *
222  * @param[in,out] isf_q Current quantized ISF
223  * @param[in,out] isf_past Past quantized ISF
224  */
225 static void isf_add_mean_and_past(float *isf_q, float *isf_past)
226 {
227  int i;
228  float tmp;
229 
230  for (i = 0; i < LP_ORDER; i++) {
231  tmp = isf_q[i];
232  isf_q[i] += isf_mean[i] * (1.0f / (1 << 15));
233  isf_q[i] += PRED_FACTOR * isf_past[i];
234  isf_past[i] = tmp;
235  }
236 }
237 
238 /**
239  * Interpolate the fourth ISP vector from current and past frames
240  * to obtain an ISP vector for each subframe.
241  *
242  * @param[in,out] isp_q ISPs for each subframe
243  * @param[in] isp4_past Past ISP for subframe 4
244  */
245 static void interpolate_isp(double isp_q[4][LP_ORDER], const double *isp4_past)
246 {
247  int i, k;
248 
249  for (k = 0; k < 3; k++) {
250  float c = isfp_inter[k];
251  for (i = 0; i < LP_ORDER; i++)
252  isp_q[k][i] = (1.0 - c) * isp4_past[i] + c * isp_q[3][i];
253  }
254 }
255 
256 /**
257  * Decode an adaptive codebook index into pitch lag (except 6k60, 8k85 modes).
258  * Calculate integer lag and fractional lag always using 1/4 resolution.
259  * In 1st and 3rd subframes the index is relative to last subframe integer lag.
260  *
261  * @param[out] lag_int Decoded integer pitch lag
262  * @param[out] lag_frac Decoded fractional pitch lag
263  * @param[in] pitch_index Adaptive codebook pitch index
264  * @param[in,out] base_lag_int Base integer lag used in relative subframes
265  * @param[in] subframe Current subframe index (0 to 3)
266  */
267 static void decode_pitch_lag_high(int *lag_int, int *lag_frac, int pitch_index,
268  uint8_t *base_lag_int, int subframe)
269 {
270  if (subframe == 0 || subframe == 2) {
271  if (pitch_index < 376) {
272  *lag_int = (pitch_index + 137) >> 2;
273  *lag_frac = pitch_index - (*lag_int << 2) + 136;
274  } else if (pitch_index < 440) {
275  *lag_int = (pitch_index + 257 - 376) >> 1;
276  *lag_frac = (pitch_index - (*lag_int << 1) + 256 - 376) * 2;
277  /* the actual resolution is 1/2 but expressed as 1/4 */
278  } else {
279  *lag_int = pitch_index - 280;
280  *lag_frac = 0;
281  }
282  /* minimum lag for next subframe */
283  *base_lag_int = av_clip(*lag_int - 8 - (*lag_frac < 0),
285  // XXX: the spec states clearly that *base_lag_int should be
286  // the nearest integer to *lag_int (minus 8), but the ref code
287  // actually always uses its floor, I'm following the latter
288  } else {
289  *lag_int = (pitch_index + 1) >> 2;
290  *lag_frac = pitch_index - (*lag_int << 2);
291  *lag_int += *base_lag_int;
292  }
293 }
294 
295 /**
296  * Decode an adaptive codebook index into pitch lag for 8k85 and 6k60 modes.
297  * The description is analogous to decode_pitch_lag_high, but in 6k60 the
298  * relative index is used for all subframes except the first.
299  */
300 static void decode_pitch_lag_low(int *lag_int, int *lag_frac, int pitch_index,
301  uint8_t *base_lag_int, int subframe, enum Mode mode)
302 {
303  if (subframe == 0 || (subframe == 2 && mode != MODE_6k60)) {
304  if (pitch_index < 116) {
305  *lag_int = (pitch_index + 69) >> 1;
306  *lag_frac = (pitch_index - (*lag_int << 1) + 68) * 2;
307  } else {
308  *lag_int = pitch_index - 24;
309  *lag_frac = 0;
310  }
311  // XXX: same problem as before
312  *base_lag_int = av_clip(*lag_int - 8 - (*lag_frac < 0),
314  } else {
315  *lag_int = (pitch_index + 1) >> 1;
316  *lag_frac = (pitch_index - (*lag_int << 1)) * 2;
317  *lag_int += *base_lag_int;
318  }
319 }
320 
321 /**
322  * Find the pitch vector by interpolating the past excitation at the
323  * pitch delay, which is obtained in this function.
324  *
325  * @param[in,out] ctx The context
326  * @param[in] amr_subframe Current subframe data
327  * @param[in] subframe Current subframe index (0 to 3)
328  */
330  const AMRWBSubFrame *amr_subframe,
331  const int subframe)
332 {
333  int pitch_lag_int, pitch_lag_frac;
334  int i;
335  float *exc = ctx->excitation;
336  enum Mode mode = ctx->fr_cur_mode;
337 
338  if (mode <= MODE_8k85) {
339  decode_pitch_lag_low(&pitch_lag_int, &pitch_lag_frac, amr_subframe->adap,
340  &ctx->base_pitch_lag, subframe, mode);
341  } else
342  decode_pitch_lag_high(&pitch_lag_int, &pitch_lag_frac, amr_subframe->adap,
343  &ctx->base_pitch_lag, subframe);
344 
345  ctx->pitch_lag_int = pitch_lag_int;
346  pitch_lag_int += pitch_lag_frac > 0;
347 
348  /* Calculate the pitch vector by interpolating the past excitation at the
349  pitch lag using a hamming windowed sinc function */
350  ctx->acelpf_ctx.acelp_interpolatef(exc,
351  exc + 1 - pitch_lag_int,
352  ac_inter, 4,
353  pitch_lag_frac + (pitch_lag_frac > 0 ? 0 : 4),
354  LP_ORDER, AMRWB_SFR_SIZE + 1);
355 
356  /* Check which pitch signal path should be used
357  * 6k60 and 8k85 modes have the ltp flag set to 0 */
358  if (amr_subframe->ltp) {
359  memcpy(ctx->pitch_vector, exc, AMRWB_SFR_SIZE * sizeof(float));
360  } else {
361  for (i = 0; i < AMRWB_SFR_SIZE; i++)
362  ctx->pitch_vector[i] = 0.18 * exc[i - 1] + 0.64 * exc[i] +
363  0.18 * exc[i + 1];
364  memcpy(exc, ctx->pitch_vector, AMRWB_SFR_SIZE * sizeof(float));
365  }
366 }
367 
368 /** Get x bits in the index interval [lsb,lsb+len-1] inclusive */
369 #define BIT_STR(x,lsb,len) av_mod_uintp2((x) >> (lsb), (len))
370 
371 /** Get the bit at specified position */
372 #define BIT_POS(x, p) (((x) >> (p)) & 1)
373 
374 /**
375  * The next six functions decode_[i]p_track decode exactly i pulses
376  * positions and amplitudes (-1 or 1) in a subframe track using
377  * an encoded pulse indexing (TS 26.190 section 5.8.2).
378  *
379  * The results are given in out[], in which a negative number means
380  * amplitude -1 and vice versa (i.e., ampl(x) = x / abs(x) ).
381  *
382  * @param[out] out Output buffer (writes i elements)
383  * @param[in] code Pulse index (no. of bits varies, see below)
384  * @param[in] m (log2) Number of potential positions
385  * @param[in] off Offset for decoded positions
386  */
387 static inline void decode_1p_track(int *out, int code, int m, int off)
388 {
389  int pos = BIT_STR(code, 0, m) + off; ///code: m+1 bits
390 
391  out[0] = BIT_POS(code, m) ? -pos : pos;
392 }
393 
394 static inline void decode_2p_track(int *out, int code, int m, int off) ///code: 2m+1 bits
395 {
396  int pos0 = BIT_STR(code, m, m) + off;
397  int pos1 = BIT_STR(code, 0, m) + off;
398 
399  out[0] = BIT_POS(code, 2*m) ? -pos0 : pos0;
400  out[1] = BIT_POS(code, 2*m) ? -pos1 : pos1;
401  out[1] = pos0 > pos1 ? -out[1] : out[1];
402 }
403 
404 static void decode_3p_track(int *out, int code, int m, int off) ///code: 3m+1 bits
405 {
406  int half_2p = BIT_POS(code, 2*m - 1) << (m - 1);
407 
408  decode_2p_track(out, BIT_STR(code, 0, 2*m - 1),
409  m - 1, off + half_2p);
410  decode_1p_track(out + 2, BIT_STR(code, 2*m, m + 1), m, off);
411 }
412 
413 static void decode_4p_track(int *out, int code, int m, int off) ///code: 4m bits
414 {
415  int half_4p, subhalf_2p;
416  int b_offset = 1 << (m - 1);
417 
418  switch (BIT_STR(code, 4*m - 2, 2)) { /* case ID (2 bits) */
419  case 0: /* 0 pulses in A, 4 pulses in B or vice versa */
420  half_4p = BIT_POS(code, 4*m - 3) << (m - 1); // which has 4 pulses
421  subhalf_2p = BIT_POS(code, 2*m - 3) << (m - 2);
422 
423  decode_2p_track(out, BIT_STR(code, 0, 2*m - 3),
424  m - 2, off + half_4p + subhalf_2p);
425  decode_2p_track(out + 2, BIT_STR(code, 2*m - 2, 2*m - 1),
426  m - 1, off + half_4p);
427  break;
428  case 1: /* 1 pulse in A, 3 pulses in B */
429  decode_1p_track(out, BIT_STR(code, 3*m - 2, m),
430  m - 1, off);
431  decode_3p_track(out + 1, BIT_STR(code, 0, 3*m - 2),
432  m - 1, off + b_offset);
433  break;
434  case 2: /* 2 pulses in each half */
435  decode_2p_track(out, BIT_STR(code, 2*m - 1, 2*m - 1),
436  m - 1, off);
437  decode_2p_track(out + 2, BIT_STR(code, 0, 2*m - 1),
438  m - 1, off + b_offset);
439  break;
440  case 3: /* 3 pulses in A, 1 pulse in B */
441  decode_3p_track(out, BIT_STR(code, m, 3*m - 2),
442  m - 1, off);
443  decode_1p_track(out + 3, BIT_STR(code, 0, m),
444  m - 1, off + b_offset);
445  break;
446  }
447 }
448 
449 static void decode_5p_track(int *out, int code, int m, int off) ///code: 5m bits
450 {
451  int half_3p = BIT_POS(code, 5*m - 1) << (m - 1);
452 
453  decode_3p_track(out, BIT_STR(code, 2*m + 1, 3*m - 2),
454  m - 1, off + half_3p);
455 
456  decode_2p_track(out + 3, BIT_STR(code, 0, 2*m + 1), m, off);
457 }
458 
459 static void decode_6p_track(int *out, int code, int m, int off) ///code: 6m-2 bits
460 {
461  int b_offset = 1 << (m - 1);
462  /* which half has more pulses in cases 0 to 2 */
463  int half_more = BIT_POS(code, 6*m - 5) << (m - 1);
464  int half_other = b_offset - half_more;
465 
466  switch (BIT_STR(code, 6*m - 4, 2)) { /* case ID (2 bits) */
467  case 0: /* 0 pulses in A, 6 pulses in B or vice versa */
469  m - 1, off + half_more);
470  decode_5p_track(out + 1, BIT_STR(code, m, 5*m - 5),
471  m - 1, off + half_more);
472  break;
473  case 1: /* 1 pulse in A, 5 pulses in B or vice versa */
475  m - 1, off + half_other);
476  decode_5p_track(out + 1, BIT_STR(code, m, 5*m - 5),
477  m - 1, off + half_more);
478  break;
479  case 2: /* 2 pulses in A, 4 pulses in B or vice versa */
480  decode_2p_track(out, BIT_STR(code, 0, 2*m - 1),
481  m - 1, off + half_other);
482  decode_4p_track(out + 2, BIT_STR(code, 2*m - 1, 4*m - 4),
483  m - 1, off + half_more);
484  break;
485  case 3: /* 3 pulses in A, 3 pulses in B */
486  decode_3p_track(out, BIT_STR(code, 3*m - 2, 3*m - 2),
487  m - 1, off);
488  decode_3p_track(out + 3, BIT_STR(code, 0, 3*m - 2),
489  m - 1, off + b_offset);
490  break;
491  }
492 }
493 
494 /**
495  * Decode the algebraic codebook index to pulse positions and signs,
496  * then construct the algebraic codebook vector.
497  *
498  * @param[out] fixed_vector Buffer for the fixed codebook excitation
499  * @param[in] pulse_hi MSBs part of the pulse index array (higher modes only)
500  * @param[in] pulse_lo LSBs part of the pulse index array
501  * @param[in] mode Mode of the current frame
502  */
503 static void decode_fixed_vector(float *fixed_vector, const uint16_t *pulse_hi,
504  const uint16_t *pulse_lo, const enum Mode mode)
505 {
506  /* sig_pos stores for each track the decoded pulse position indexes
507  * (1-based) multiplied by its corresponding amplitude (+1 or -1) */
508  int sig_pos[4][6];
509  int spacing = (mode == MODE_6k60) ? 2 : 4;
510  int i, j;
511 
512  switch (mode) {
513  case MODE_6k60:
514  for (i = 0; i < 2; i++)
515  decode_1p_track(sig_pos[i], pulse_lo[i], 5, 1);
516  break;
517  case MODE_8k85:
518  for (i = 0; i < 4; i++)
519  decode_1p_track(sig_pos[i], pulse_lo[i], 4, 1);
520  break;
521  case MODE_12k65:
522  for (i = 0; i < 4; i++)
523  decode_2p_track(sig_pos[i], pulse_lo[i], 4, 1);
524  break;
525  case MODE_14k25:
526  for (i = 0; i < 2; i++)
527  decode_3p_track(sig_pos[i], pulse_lo[i], 4, 1);
528  for (i = 2; i < 4; i++)
529  decode_2p_track(sig_pos[i], pulse_lo[i], 4, 1);
530  break;
531  case MODE_15k85:
532  for (i = 0; i < 4; i++)
533  decode_3p_track(sig_pos[i], pulse_lo[i], 4, 1);
534  break;
535  case MODE_18k25:
536  for (i = 0; i < 4; i++)
537  decode_4p_track(sig_pos[i], (int) pulse_lo[i] +
538  ((int) pulse_hi[i] << 14), 4, 1);
539  break;
540  case MODE_19k85:
541  for (i = 0; i < 2; i++)
542  decode_5p_track(sig_pos[i], (int) pulse_lo[i] +
543  ((int) pulse_hi[i] << 10), 4, 1);
544  for (i = 2; i < 4; i++)
545  decode_4p_track(sig_pos[i], (int) pulse_lo[i] +
546  ((int) pulse_hi[i] << 14), 4, 1);
547  break;
548  case MODE_23k05:
549  case MODE_23k85:
550  for (i = 0; i < 4; i++)
551  decode_6p_track(sig_pos[i], (int) pulse_lo[i] +
552  ((int) pulse_hi[i] << 11), 4, 1);
553  break;
554  }
555 
556  memset(fixed_vector, 0, sizeof(float) * AMRWB_SFR_SIZE);
557 
558  for (i = 0; i < 4; i++)
559  for (j = 0; j < pulses_nb_per_mode_tr[mode][i]; j++) {
560  int pos = (FFABS(sig_pos[i][j]) - 1) * spacing + i;
561 
562  fixed_vector[pos] += sig_pos[i][j] < 0 ? -1.0 : 1.0;
563  }
564 }
565 
566 /**
567  * Decode pitch gain and fixed gain correction factor.
568  *
569  * @param[in] vq_gain Vector-quantized index for gains
570  * @param[in] mode Mode of the current frame
571  * @param[out] fixed_gain_factor Decoded fixed gain correction factor
572  * @param[out] pitch_gain Decoded pitch gain
573  */
574 static void decode_gains(const uint8_t vq_gain, const enum Mode mode,
575  float *fixed_gain_factor, float *pitch_gain)
576 {
577  const int16_t *gains = (mode <= MODE_8k85 ? qua_gain_6b[vq_gain] :
578  qua_gain_7b[vq_gain]);
579 
580  *pitch_gain = gains[0] * (1.0f / (1 << 14));
581  *fixed_gain_factor = gains[1] * (1.0f / (1 << 11));
582 }
583 
584 /**
585  * Apply pitch sharpening filters to the fixed codebook vector.
586  *
587  * @param[in] ctx The context
588  * @param[in,out] fixed_vector Fixed codebook excitation
589  */
590 // XXX: Spec states this procedure should be applied when the pitch
591 // lag is less than 64, but this checking seems absent in reference and AMR-NB
592 static void pitch_sharpening(AMRWBContext *ctx, float *fixed_vector)
593 {
594  int i;
595 
596  /* Tilt part */
597  for (i = AMRWB_SFR_SIZE - 1; i != 0; i--)
598  fixed_vector[i] -= fixed_vector[i - 1] * ctx->tilt_coef;
599 
600  /* Periodicity enhancement part */
601  for (i = ctx->pitch_lag_int; i < AMRWB_SFR_SIZE; i++)
602  fixed_vector[i] += fixed_vector[i - ctx->pitch_lag_int] * 0.85;
603 }
604 
605 /**
606  * Calculate the voicing factor (-1.0 = unvoiced to 1.0 = voiced).
607  *
608  * @param[in] p_vector, f_vector Pitch and fixed excitation vectors
609  * @param[in] p_gain, f_gain Pitch and fixed gains
610  * @param[in] ctx The context
611  */
612 // XXX: There is something wrong with the precision here! The magnitudes
613 // of the energies are not correct. Please check the reference code carefully
614 static float voice_factor(float *p_vector, float p_gain,
615  float *f_vector, float f_gain,
616  CELPMContext *ctx)
617 {
618  double p_ener = (double) ctx->dot_productf(p_vector, p_vector,
619  AMRWB_SFR_SIZE) *
620  p_gain * p_gain;
621  double f_ener = (double) ctx->dot_productf(f_vector, f_vector,
622  AMRWB_SFR_SIZE) *
623  f_gain * f_gain;
624 
625  return (p_ener - f_ener) / (p_ener + f_ener + 0.01);
626 }
627 
628 /**
629  * Reduce fixed vector sparseness by smoothing with one of three IR filters,
630  * also known as "adaptive phase dispersion".
631  *
632  * @param[in] ctx The context
633  * @param[in,out] fixed_vector Unfiltered fixed vector
634  * @param[out] buf Space for modified vector if necessary
635  *
636  * @return The potentially overwritten filtered fixed vector address
637  */
639  float *fixed_vector, float *buf)
640 {
641  int ir_filter_nr;
642 
643  if (ctx->fr_cur_mode > MODE_8k85) // no filtering in higher modes
644  return fixed_vector;
645 
646  if (ctx->pitch_gain[0] < 0.6) {
647  ir_filter_nr = 0; // strong filtering
648  } else if (ctx->pitch_gain[0] < 0.9) {
649  ir_filter_nr = 1; // medium filtering
650  } else
651  ir_filter_nr = 2; // no filtering
652 
653  /* detect 'onset' */
654  if (ctx->fixed_gain[0] > 3.0 * ctx->fixed_gain[1]) {
655  if (ir_filter_nr < 2)
656  ir_filter_nr++;
657  } else {
658  int i, count = 0;
659 
660  for (i = 0; i < 6; i++)
661  if (ctx->pitch_gain[i] < 0.6)
662  count++;
663 
664  if (count > 2)
665  ir_filter_nr = 0;
666 
667  if (ir_filter_nr > ctx->prev_ir_filter_nr + 1)
668  ir_filter_nr--;
669  }
670 
671  /* update ir filter strength history */
672  ctx->prev_ir_filter_nr = ir_filter_nr;
673 
674  ir_filter_nr += (ctx->fr_cur_mode == MODE_8k85);
675 
676  if (ir_filter_nr < 2) {
677  int i;
678  const float *coef = ir_filters_lookup[ir_filter_nr];
679 
680  /* Circular convolution code in the reference
681  * decoder was modified to avoid using one
682  * extra array. The filtered vector is given by:
683  *
684  * c2(n) = sum(i,0,len-1){ c(i) * coef( (n - i + len) % len ) }
685  */
686 
687  memset(buf, 0, sizeof(float) * AMRWB_SFR_SIZE);
688  for (i = 0; i < AMRWB_SFR_SIZE; i++)
689  if (fixed_vector[i])
690  ff_celp_circ_addf(buf, buf, coef, i, fixed_vector[i],
692  fixed_vector = buf;
693  }
694 
695  return fixed_vector;
696 }
697 
698 /**
699  * Calculate a stability factor {teta} based on distance between
700  * current and past isf. A value of 1 shows maximum signal stability.
701  */
702 static float stability_factor(const float *isf, const float *isf_past)
703 {
704  int i;
705  float acc = 0.0;
706 
707  for (i = 0; i < LP_ORDER - 1; i++)
708  acc += (isf[i] - isf_past[i]) * (isf[i] - isf_past[i]);
709 
710  // XXX: This part is not so clear from the reference code
711  // the result is more accurate changing the "/ 256" to "* 512"
712  return FFMAX(0.0, 1.25 - acc * 0.8 * 512);
713 }
714 
715 /**
716  * Apply a non-linear fixed gain smoothing in order to reduce
717  * fluctuation in the energy of excitation.
718  *
719  * @param[in] fixed_gain Unsmoothed fixed gain
720  * @param[in,out] prev_tr_gain Previous threshold gain (updated)
721  * @param[in] voice_fac Frame voicing factor
722  * @param[in] stab_fac Frame stability factor
723  *
724  * @return The smoothed gain
725  */
726 static float noise_enhancer(float fixed_gain, float *prev_tr_gain,
727  float voice_fac, float stab_fac)
728 {
729  float sm_fac = 0.5 * (1 - voice_fac) * stab_fac;
730  float g0;
731 
732  // XXX: the following fixed-point constants used to in(de)crement
733  // gain by 1.5dB were taken from the reference code, maybe it could
734  // be simpler
735  if (fixed_gain < *prev_tr_gain) {
736  g0 = FFMIN(*prev_tr_gain, fixed_gain + fixed_gain *
737  (6226 * (1.0f / (1 << 15)))); // +1.5 dB
738  } else
739  g0 = FFMAX(*prev_tr_gain, fixed_gain *
740  (27536 * (1.0f / (1 << 15)))); // -1.5 dB
741 
742  *prev_tr_gain = g0; // update next frame threshold
743 
744  return sm_fac * g0 + (1 - sm_fac) * fixed_gain;
745 }
746 
747 /**
748  * Filter the fixed_vector to emphasize the higher frequencies.
749  *
750  * @param[in,out] fixed_vector Fixed codebook vector
751  * @param[in] voice_fac Frame voicing factor
752  */
753 static void pitch_enhancer(float *fixed_vector, float voice_fac)
754 {
755  int i;
756  float cpe = 0.125 * (1 + voice_fac);
757  float last = fixed_vector[0]; // holds c(i - 1)
758 
759  fixed_vector[0] -= cpe * fixed_vector[1];
760 
761  for (i = 1; i < AMRWB_SFR_SIZE - 1; i++) {
762  float cur = fixed_vector[i];
763 
764  fixed_vector[i] -= cpe * (last + fixed_vector[i + 1]);
765  last = cur;
766  }
767 
768  fixed_vector[AMRWB_SFR_SIZE - 1] -= cpe * last;
769 }
770 
771 /**
772  * Conduct 16th order linear predictive coding synthesis from excitation.
773  *
774  * @param[in] ctx Pointer to the AMRWBContext
775  * @param[in] lpc Pointer to the LPC coefficients
776  * @param[out] excitation Buffer for synthesis final excitation
777  * @param[in] fixed_gain Fixed codebook gain for synthesis
778  * @param[in] fixed_vector Algebraic codebook vector
779  * @param[in,out] samples Pointer to the output samples and memory
780  */
781 static void synthesis(AMRWBContext *ctx, float *lpc, float *excitation,
782  float fixed_gain, const float *fixed_vector,
783  float *samples)
784 {
785  ctx->acelpv_ctx.weighted_vector_sumf(excitation, ctx->pitch_vector, fixed_vector,
786  ctx->pitch_gain[0], fixed_gain, AMRWB_SFR_SIZE);
787 
788  /* emphasize pitch vector contribution in low bitrate modes */
789  if (ctx->pitch_gain[0] > 0.5 && ctx->fr_cur_mode <= MODE_8k85) {
790  int i;
791  float energy = ctx->celpm_ctx.dot_productf(excitation, excitation,
793 
794  // XXX: Weird part in both ref code and spec. A unknown parameter
795  // {beta} seems to be identical to the current pitch gain
796  float pitch_factor = 0.25 * ctx->pitch_gain[0] * ctx->pitch_gain[0];
797 
798  for (i = 0; i < AMRWB_SFR_SIZE; i++)
799  excitation[i] += pitch_factor * ctx->pitch_vector[i];
800 
801  ff_scale_vector_to_given_sum_of_squares(excitation, excitation,
802  energy, AMRWB_SFR_SIZE);
803  }
804 
805  ctx->celpf_ctx.celp_lp_synthesis_filterf(samples, lpc, excitation,
807 }
808 
809 /**
810  * Apply to synthesis a de-emphasis filter of the form:
811  * H(z) = 1 / (1 - m * z^-1)
812  *
813  * @param[out] out Output buffer
814  * @param[in] in Input samples array with in[-1]
815  * @param[in] m Filter coefficient
816  * @param[in,out] mem State from last filtering
817  */
818 static void de_emphasis(float *out, float *in, float m, float mem[1])
819 {
820  int i;
821 
822  out[0] = in[0] + m * mem[0];
823 
824  for (i = 1; i < AMRWB_SFR_SIZE; i++)
825  out[i] = in[i] + out[i - 1] * m;
826 
827  mem[0] = out[AMRWB_SFR_SIZE - 1];
828 }
829 
830 /**
831  * Upsample a signal by 5/4 ratio (from 12.8kHz to 16kHz) using
832  * a FIR interpolation filter. Uses past data from before *in address.
833  *
834  * @param[out] out Buffer for interpolated signal
835  * @param[in] in Current signal data (length 0.8*o_size)
836  * @param[in] o_size Output signal length
837  * @param[in] ctx The context
838  */
839 static void upsample_5_4(float *out, const float *in, int o_size, CELPMContext *ctx)
840 {
841  const float *in0 = in - UPS_FIR_SIZE + 1;
842  int i, j, k;
843  int int_part = 0, frac_part;
844 
845  i = 0;
846  for (j = 0; j < o_size / 5; j++) {
847  out[i] = in[int_part];
848  frac_part = 4;
849  i++;
850 
851  for (k = 1; k < 5; k++) {
852  out[i] = ctx->dot_productf(in0 + int_part,
853  upsample_fir[4 - frac_part],
854  UPS_MEM_SIZE);
855  int_part++;
856  frac_part--;
857  i++;
858  }
859  }
860 }
861 
862 /**
863  * Calculate the high-band gain based on encoded index (23k85 mode) or
864  * on the low-band speech signal and the Voice Activity Detection flag.
865  *
866  * @param[in] ctx The context
867  * @param[in] synth LB speech synthesis at 12.8k
868  * @param[in] hb_idx Gain index for mode 23k85 only
869  * @param[in] vad VAD flag for the frame
870  */
871 static float find_hb_gain(AMRWBContext *ctx, const float *synth,
872  uint16_t hb_idx, uint8_t vad)
873 {
874  int wsp = (vad > 0);
875  float tilt;
876  float tmp;
877 
878  if (ctx->fr_cur_mode == MODE_23k85)
879  return qua_hb_gain[hb_idx] * (1.0f / (1 << 14));
880 
881  tmp = ctx->celpm_ctx.dot_productf(synth, synth + 1, AMRWB_SFR_SIZE - 1);
882 
883  if (tmp > 0) {
884  tilt = tmp / ctx->celpm_ctx.dot_productf(synth, synth, AMRWB_SFR_SIZE);
885  } else
886  tilt = 0;
887 
888  /* return gain bounded by [0.1, 1.0] */
889  return av_clipf((1.0 - tilt) * (1.25 - 0.25 * wsp), 0.1, 1.0);
890 }
891 
892 /**
893  * Generate the high-band excitation with the same energy from the lower
894  * one and scaled by the given gain.
895  *
896  * @param[in] ctx The context
897  * @param[out] hb_exc Buffer for the excitation
898  * @param[in] synth_exc Low-band excitation used for synthesis
899  * @param[in] hb_gain Wanted excitation gain
900  */
901 static void scaled_hb_excitation(AMRWBContext *ctx, float *hb_exc,
902  const float *synth_exc, float hb_gain)
903 {
904  int i;
905  float energy = ctx->celpm_ctx.dot_productf(synth_exc, synth_exc,
907 
908  /* Generate a white-noise excitation */
909  for (i = 0; i < AMRWB_SFR_SIZE_16k; i++)
910  hb_exc[i] = 32768.0 - (uint16_t) av_lfg_get(&ctx->prng);
911 
913  energy * hb_gain * hb_gain,
915 }
916 
917 /**
918  * Calculate the auto-correlation for the ISF difference vector.
919  */
920 static float auto_correlation(float *diff_isf, float mean, int lag)
921 {
922  int i;
923  float sum = 0.0;
924 
925  for (i = 7; i < LP_ORDER - 2; i++) {
926  float prod = (diff_isf[i] - mean) * (diff_isf[i - lag] - mean);
927  sum += prod * prod;
928  }
929  return sum;
930 }
931 
932 /**
933  * Extrapolate a ISF vector to the 16kHz range (20th order LP)
934  * used at mode 6k60 LP filter for the high frequency band.
935  *
936  * @param[out] isf Buffer for extrapolated isf; contains LP_ORDER
937  * values on input
938  */
939 static void extrapolate_isf(float isf[LP_ORDER_16k])
940 {
941  float diff_isf[LP_ORDER - 2], diff_mean;
942  float corr_lag[3];
943  float est, scale;
944  int i, j, i_max_corr;
945 
946  isf[LP_ORDER_16k - 1] = isf[LP_ORDER - 1];
947 
948  /* Calculate the difference vector */
949  for (i = 0; i < LP_ORDER - 2; i++)
950  diff_isf[i] = isf[i + 1] - isf[i];
951 
952  diff_mean = 0.0;
953  for (i = 2; i < LP_ORDER - 2; i++)
954  diff_mean += diff_isf[i] * (1.0f / (LP_ORDER - 4));
955 
956  /* Find which is the maximum autocorrelation */
957  i_max_corr = 0;
958  for (i = 0; i < 3; i++) {
959  corr_lag[i] = auto_correlation(diff_isf, diff_mean, i + 2);
960 
961  if (corr_lag[i] > corr_lag[i_max_corr])
962  i_max_corr = i;
963  }
964  i_max_corr++;
965 
966  for (i = LP_ORDER - 1; i < LP_ORDER_16k - 1; i++)
967  isf[i] = isf[i - 1] + isf[i - 1 - i_max_corr]
968  - isf[i - 2 - i_max_corr];
969 
970  /* Calculate an estimate for ISF(18) and scale ISF based on the error */
971  est = 7965 + (isf[2] - isf[3] - isf[4]) / 6.0;
972  scale = 0.5 * (FFMIN(est, 7600) - isf[LP_ORDER - 2]) /
973  (isf[LP_ORDER_16k - 2] - isf[LP_ORDER - 2]);
974 
975  for (i = LP_ORDER - 1, j = 0; i < LP_ORDER_16k - 1; i++, j++)
976  diff_isf[j] = scale * (isf[i] - isf[i - 1]);
977 
978  /* Stability insurance */
979  for (i = 1; i < LP_ORDER_16k - LP_ORDER; i++)
980  if (diff_isf[i] + diff_isf[i - 1] < 5.0) {
981  if (diff_isf[i] > diff_isf[i - 1]) {
982  diff_isf[i - 1] = 5.0 - diff_isf[i];
983  } else
984  diff_isf[i] = 5.0 - diff_isf[i - 1];
985  }
986 
987  for (i = LP_ORDER - 1, j = 0; i < LP_ORDER_16k - 1; i++, j++)
988  isf[i] = isf[i - 1] + diff_isf[j] * (1.0f / (1 << 15));
989 
990  /* Scale the ISF vector for 16000 Hz */
991  for (i = 0; i < LP_ORDER_16k - 1; i++)
992  isf[i] *= 0.8;
993 }
994 
995 /**
996  * Spectral expand the LP coefficients using the equation:
997  * y[i] = x[i] * (gamma ** i)
998  *
999  * @param[out] out Output buffer (may use input array)
1000  * @param[in] lpc LP coefficients array
1001  * @param[in] gamma Weighting factor
1002  * @param[in] size LP array size
1003  */
1004 static void lpc_weighting(float *out, const float *lpc, float gamma, int size)
1005 {
1006  int i;
1007  float fac = gamma;
1008 
1009  for (i = 0; i < size; i++) {
1010  out[i] = lpc[i] * fac;
1011  fac *= gamma;
1012  }
1013 }
1014 
1015 /**
1016  * Conduct 20th order linear predictive coding synthesis for the high
1017  * frequency band excitation at 16kHz.
1018  *
1019  * @param[in] ctx The context
1020  * @param[in] subframe Current subframe index (0 to 3)
1021  * @param[in,out] samples Pointer to the output speech samples
1022  * @param[in] exc Generated white-noise scaled excitation
1023  * @param[in] isf Current frame isf vector
1024  * @param[in] isf_past Past frame final isf vector
1025  */
1026 static void hb_synthesis(AMRWBContext *ctx, int subframe, float *samples,
1027  const float *exc, const float *isf, const float *isf_past)
1028 {
1029  float hb_lpc[LP_ORDER_16k];
1030  enum Mode mode = ctx->fr_cur_mode;
1031 
1032  if (mode == MODE_6k60) {
1033  float e_isf[LP_ORDER_16k]; // ISF vector for extrapolation
1034  double e_isp[LP_ORDER_16k];
1035 
1036  ctx->acelpv_ctx.weighted_vector_sumf(e_isf, isf_past, isf, isfp_inter[subframe],
1037  1.0 - isfp_inter[subframe], LP_ORDER);
1038 
1039  extrapolate_isf(e_isf);
1040 
1041  e_isf[LP_ORDER_16k - 1] *= 2.0;
1042  ff_acelp_lsf2lspd(e_isp, e_isf, LP_ORDER_16k);
1043  ff_amrwb_lsp2lpc(e_isp, hb_lpc, LP_ORDER_16k);
1044 
1045  lpc_weighting(hb_lpc, hb_lpc, 0.9, LP_ORDER_16k);
1046  } else {
1047  lpc_weighting(hb_lpc, ctx->lp_coef[subframe], 0.6, LP_ORDER);
1048  }
1049 
1050  ctx->celpf_ctx.celp_lp_synthesis_filterf(samples, hb_lpc, exc, AMRWB_SFR_SIZE_16k,
1051  (mode == MODE_6k60) ? LP_ORDER_16k : LP_ORDER);
1052 }
1053 
1054 /**
1055  * Apply a 15th order filter to high-band samples.
1056  * The filter characteristic depends on the given coefficients.
1057  *
1058  * @param[out] out Buffer for filtered output
1059  * @param[in] fir_coef Filter coefficients
1060  * @param[in,out] mem State from last filtering (updated)
1061  * @param[in] in Input speech data (high-band)
1062  *
1063  * @remark It is safe to pass the same array in in and out parameters
1064  */
1065 
1066 #ifndef hb_fir_filter
1067 static void hb_fir_filter(float *out, const float fir_coef[HB_FIR_SIZE + 1],
1068  float mem[HB_FIR_SIZE], const float *in)
1069 {
1070  int i, j;
1071  float data[AMRWB_SFR_SIZE_16k + HB_FIR_SIZE]; // past and current samples
1072 
1073  memcpy(data, mem, HB_FIR_SIZE * sizeof(float));
1074  memcpy(data + HB_FIR_SIZE, in, AMRWB_SFR_SIZE_16k * sizeof(float));
1075 
1076  for (i = 0; i < AMRWB_SFR_SIZE_16k; i++) {
1077  out[i] = 0.0;
1078  for (j = 0; j <= HB_FIR_SIZE; j++)
1079  out[i] += data[i + j] * fir_coef[j];
1080  }
1081 
1082  memcpy(mem, data + AMRWB_SFR_SIZE_16k, HB_FIR_SIZE * sizeof(float));
1083 }
1084 #endif /* hb_fir_filter */
1085 
1086 /**
1087  * Update context state before the next subframe.
1088  */
1090 {
1091  memmove(&ctx->excitation_buf[0], &ctx->excitation_buf[AMRWB_SFR_SIZE],
1092  (AMRWB_P_DELAY_MAX + LP_ORDER + 1) * sizeof(float));
1093 
1094  memmove(&ctx->pitch_gain[1], &ctx->pitch_gain[0], 5 * sizeof(float));
1095  memmove(&ctx->fixed_gain[1], &ctx->fixed_gain[0], 1 * sizeof(float));
1096 
1097  memmove(&ctx->samples_az[0], &ctx->samples_az[AMRWB_SFR_SIZE],
1098  LP_ORDER * sizeof(float));
1099  memmove(&ctx->samples_up[0], &ctx->samples_up[AMRWB_SFR_SIZE],
1100  UPS_MEM_SIZE * sizeof(float));
1101  memmove(&ctx->samples_hb[0], &ctx->samples_hb[AMRWB_SFR_SIZE_16k],
1102  LP_ORDER_16k * sizeof(float));
1103 }
1104 
1106  int *got_frame_ptr, AVPacket *avpkt)
1107 {
1108  AMRWBChannelsContext *s = avctx->priv_data;
1109  const uint8_t *buf = avpkt->data;
1110  int buf_size = avpkt->size;
1111  int sub, i, ret;
1112 
1113  /* get output buffer */
1114  frame->nb_samples = 4 * AMRWB_SFR_SIZE_16k;
1115  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1116  return ret;
1117 
1118  for (int ch = 0; ch < avctx->ch_layout.nb_channels; ch++) {
1119  AMRWBContext *ctx = &s->ch[ch];
1120  AMRWBFrame *cf = &ctx->frame;
1121  int expected_fr_size, header_size;
1122  float spare_vector[AMRWB_SFR_SIZE]; // extra stack space to hold result from anti-sparseness processing
1123  float fixed_gain_factor; // fixed gain correction factor (gamma)
1124  float *synth_fixed_vector; // pointer to the fixed vector that synthesis should use
1125  float synth_fixed_gain; // the fixed gain that synthesis should use
1126  float voice_fac, stab_fac; // parameters used for gain smoothing
1127  float synth_exc[AMRWB_SFR_SIZE]; // post-processed excitation for synthesis
1128  float hb_exc[AMRWB_SFR_SIZE_16k]; // excitation for the high frequency band
1129  float hb_samples[AMRWB_SFR_SIZE_16k]; // filtered high-band samples from synthesis
1130  float hb_gain;
1131  float *buf_out = (float *)frame->extended_data[ch];
1132 
1133  header_size = decode_mime_header(ctx, buf);
1134  expected_fr_size = ((cf_sizes_wb[ctx->fr_cur_mode] + 7) >> 3) + 1;
1135 
1136  if (!ctx->fr_quality)
1137  av_log(avctx, AV_LOG_ERROR, "Encountered a bad or corrupted frame\n");
1138 
1139  if (ctx->fr_cur_mode == NO_DATA || !ctx->fr_quality) {
1140  /* The specification suggests a "random signal" and
1141  "a muting technique" to "gradually decrease the output level". */
1142  av_samples_set_silence(&frame->extended_data[ch], 0, frame->nb_samples, 1, AV_SAMPLE_FMT_FLT);
1143  buf += expected_fr_size;
1144  buf_size -= expected_fr_size;
1145  continue;
1146  }
1147  if (ctx->fr_cur_mode > MODE_SID) {
1148  av_log(avctx, AV_LOG_ERROR,
1149  "Invalid mode %d\n", ctx->fr_cur_mode);
1150  return AVERROR_INVALIDDATA;
1151  }
1152 
1153  if (buf_size < expected_fr_size) {
1154  av_log(avctx, AV_LOG_ERROR,
1155  "Frame too small (%d bytes). Truncated file?\n", buf_size);
1156  *got_frame_ptr = 0;
1157  return AVERROR_INVALIDDATA;
1158  }
1159 
1160  if (ctx->fr_cur_mode == MODE_SID) { /* Comfort noise frame */
1161  avpriv_request_sample(avctx, "SID mode");
1162  return AVERROR_PATCHWELCOME;
1163  }
1164 
1165  ff_amr_bit_reorder((uint16_t *) &ctx->frame, sizeof(AMRWBFrame),
1166  buf + header_size, amr_bit_orderings_by_mode[ctx->fr_cur_mode]);
1167 
1168  /* Decode the quantized ISF vector */
1169  if (ctx->fr_cur_mode == MODE_6k60) {
1170  decode_isf_indices_36b(cf->isp_id, ctx->isf_cur);
1171  } else {
1172  decode_isf_indices_46b(cf->isp_id, ctx->isf_cur);
1173  }
1174 
1175  isf_add_mean_and_past(ctx->isf_cur, ctx->isf_q_past);
1177 
1178  stab_fac = stability_factor(ctx->isf_cur, ctx->isf_past_final);
1179 
1180  ctx->isf_cur[LP_ORDER - 1] *= 2.0;
1181  ff_acelp_lsf2lspd(ctx->isp[3], ctx->isf_cur, LP_ORDER);
1182 
1183  /* Generate a ISP vector for each subframe */
1184  if (ctx->first_frame) {
1185  ctx->first_frame = 0;
1186  memcpy(ctx->isp_sub4_past, ctx->isp[3], LP_ORDER * sizeof(double));
1187  }
1188  interpolate_isp(ctx->isp, ctx->isp_sub4_past);
1189 
1190  for (sub = 0; sub < 4; sub++)
1191  ff_amrwb_lsp2lpc(ctx->isp[sub], ctx->lp_coef[sub], LP_ORDER);
1192 
1193  for (sub = 0; sub < 4; sub++) {
1194  const AMRWBSubFrame *cur_subframe = &cf->subframe[sub];
1195  float *sub_buf = buf_out + sub * AMRWB_SFR_SIZE_16k;
1196 
1197  /* Decode adaptive codebook (pitch vector) */
1198  decode_pitch_vector(ctx, cur_subframe, sub);
1199  /* Decode innovative codebook (fixed vector) */
1200  decode_fixed_vector(ctx->fixed_vector, cur_subframe->pul_ih,
1201  cur_subframe->pul_il, ctx->fr_cur_mode);
1202 
1203  pitch_sharpening(ctx, ctx->fixed_vector);
1204 
1205  decode_gains(cur_subframe->vq_gain, ctx->fr_cur_mode,
1206  &fixed_gain_factor, &ctx->pitch_gain[0]);
1207 
1208  ctx->fixed_gain[0] =
1209  ff_amr_set_fixed_gain(fixed_gain_factor,
1210  ctx->celpm_ctx.dot_productf(ctx->fixed_vector,
1211  ctx->fixed_vector,
1212  AMRWB_SFR_SIZE) /
1214  ctx->prediction_error,
1216 
1217  /* Calculate voice factor and store tilt for next subframe */
1218  voice_fac = voice_factor(ctx->pitch_vector, ctx->pitch_gain[0],
1219  ctx->fixed_vector, ctx->fixed_gain[0],
1220  &ctx->celpm_ctx);
1221  ctx->tilt_coef = voice_fac * 0.25 + 0.25;
1222 
1223  /* Construct current excitation */
1224  for (i = 0; i < AMRWB_SFR_SIZE; i++) {
1225  ctx->excitation[i] *= ctx->pitch_gain[0];
1226  ctx->excitation[i] += ctx->fixed_gain[0] * ctx->fixed_vector[i];
1227  ctx->excitation[i] = truncf(ctx->excitation[i]);
1228  }
1229 
1230  /* Post-processing of excitation elements */
1231  synth_fixed_gain = noise_enhancer(ctx->fixed_gain[0], &ctx->prev_tr_gain,
1232  voice_fac, stab_fac);
1233 
1234  synth_fixed_vector = anti_sparseness(ctx, ctx->fixed_vector,
1235  spare_vector);
1236 
1237  pitch_enhancer(synth_fixed_vector, voice_fac);
1238 
1239  synthesis(ctx, ctx->lp_coef[sub], synth_exc, synth_fixed_gain,
1240  synth_fixed_vector, &ctx->samples_az[LP_ORDER]);
1241 
1242  /* Synthesis speech post-processing */
1243  de_emphasis(&ctx->samples_up[UPS_MEM_SIZE],
1244  &ctx->samples_az[LP_ORDER], PREEMPH_FAC, ctx->demph_mem);
1245 
1246  ctx->acelpf_ctx.acelp_apply_order_2_transfer_function(&ctx->samples_up[UPS_MEM_SIZE],
1247  &ctx->samples_up[UPS_MEM_SIZE], hpf_zeros, hpf_31_poles,
1248  hpf_31_gain, ctx->hpf_31_mem, AMRWB_SFR_SIZE);
1249 
1250  upsample_5_4(sub_buf, &ctx->samples_up[UPS_FIR_SIZE],
1251  AMRWB_SFR_SIZE_16k, &ctx->celpm_ctx);
1252 
1253  /* High frequency band (6.4 - 7.0 kHz) generation part */
1254  ctx->acelpf_ctx.acelp_apply_order_2_transfer_function(hb_samples,
1255  &ctx->samples_up[UPS_MEM_SIZE], hpf_zeros, hpf_400_poles,
1256  hpf_400_gain, ctx->hpf_400_mem, AMRWB_SFR_SIZE);
1257 
1258  hb_gain = find_hb_gain(ctx, hb_samples,
1259  cur_subframe->hb_gain, cf->vad);
1260 
1261  scaled_hb_excitation(ctx, hb_exc, synth_exc, hb_gain);
1262 
1263  hb_synthesis(ctx, sub, &ctx->samples_hb[LP_ORDER_16k],
1264  hb_exc, ctx->isf_cur, ctx->isf_past_final);
1265 
1266  /* High-band post-processing filters */
1267  hb_fir_filter(hb_samples, bpf_6_7_coef, ctx->bpf_6_7_mem,
1268  &ctx->samples_hb[LP_ORDER_16k]);
1269 
1270  if (ctx->fr_cur_mode == MODE_23k85)
1271  hb_fir_filter(hb_samples, lpf_7_coef, ctx->lpf_7_mem,
1272  hb_samples);
1273 
1274  /* Add the low and high frequency bands */
1275  for (i = 0; i < AMRWB_SFR_SIZE_16k; i++)
1276  sub_buf[i] = (sub_buf[i] + hb_samples[i]) * (1.0f / (1 << 15));
1277 
1278  /* Update buffers and history */
1280  }
1281 
1282  /* update state for next frame */
1283  memcpy(ctx->isp_sub4_past, ctx->isp[3], LP_ORDER * sizeof(ctx->isp[3][0]));
1284  memcpy(ctx->isf_past_final, ctx->isf_cur, LP_ORDER * sizeof(float));
1285 
1286  buf += expected_fr_size;
1287  buf_size -= expected_fr_size;
1288  }
1289 
1290  *got_frame_ptr = 1;
1291 
1292  return avpkt->size;
1293 }
1294 
1296  .p.name = "amrwb",
1297  .p.long_name = NULL_IF_CONFIG_SMALL("AMR-WB (Adaptive Multi-Rate WideBand)"),
1298  .p.type = AVMEDIA_TYPE_AUDIO,
1299  .p.id = AV_CODEC_ID_AMR_WB,
1300  .priv_data_size = sizeof(AMRWBChannelsContext),
1303  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
1304  .p.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLT,
1306 };
lpc_weighting
static void lpc_weighting(float *out, const float *lpc, float gamma, int size)
Spectral expand the LP coefficients using the equation: y[i] = x[i] * (gamma ** i)
Definition: amrwbdec.c:1004
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:66
pitch_enhancer
static void pitch_enhancer(float *fixed_vector, float voice_fac)
Filter the fixed_vector to emphasize the higher frequencies.
Definition: amrwbdec.c:753
AMRWBContext::base_pitch_lag
uint8_t base_pitch_lag
integer part of pitch lag for the next relative subframe
Definition: amrwbdec.c:60
av_clip
#define av_clip
Definition: common.h:95
UPS_FIR_SIZE
#define UPS_FIR_SIZE
upsampling filter size
Definition: amrwbdata.h:36
acelp_vectors.h
acc
int acc
Definition: yuv2rgb.c:554
AMRWBContext::demph_mem
float demph_mem[1]
previous value in the de-emphasis filter
Definition: amrwbdec.c:84
AMRWBContext::prev_ir_filter_nr
uint8_t prev_ir_filter_nr
previous impulse response filter "impNr": 0 - strong, 1 - medium, 2 - none
Definition: amrwbdec.c:76
AMRWBContext::isp_sub4_past
double isp_sub4_past[LP_ORDER]
ISP vector for the 4th subframe of the previous frame.
Definition: amrwbdec.c:56
MODE_6k60
@ MODE_6k60
6.60 kbit/s
Definition: amrwbdata.h:52
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
decode_2p_track
static void decode_2p_track(int *out, int code, int m, int off)
code: 2m+1 bits
Definition: amrwbdec.c:394
dico22_isf
static const int16_t dico22_isf[128][3]
Definition: amrwbdata.h:1245
upsample_fir
static const float upsample_fir[4][24]
Interpolation coefficients for 5/4 signal upsampling Table from the reference source was reordered fo...
Definition: amrwbdata.h:1822
qua_hb_gain
static const uint16_t qua_hb_gain[16]
High band quantized gains for 23k85 in Q14.
Definition: amrwbdata.h:1850
out
FILE * out
Definition: movenc.c:54
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1007
av_lfg_init
av_cold void av_lfg_init(AVLFG *c, unsigned int seed)
Definition: lfg.c:32
AMRWBContext::samples_az
float samples_az[LP_ORDER+AMRWB_SFR_SIZE]
low-band samples and memory from synthesis at 12.8kHz
Definition: amrwbdec.c:79
sub
static float sub(float src0, float src1)
Definition: dnn_backend_native_layer_mathbinary.c:31
AMRWBChannelsContext::ch
AMRWBContext ch[2]
Definition: amrwbdec.c:98
AMRWBContext::prev_sparse_fixed_gain
float prev_sparse_fixed_gain
previous fixed gain; used by anti-sparseness to determine "onset"
Definition: amrwbdec.c:75
ff_amrwb_lsp2lpc
void ff_amrwb_lsp2lpc(const double *lsp, float *lp, int lp_order)
LSP to LP conversion (5.2.4 of AMR-WB)
Definition: lsp.c:145
dico2_isf
static const int16_t dico2_isf[256][7]
Definition: amrwbdata.h:951
AMRWBSubFrame::hb_gain
uint16_t hb_gain
high-band energy index (mode 23k85 only)
Definition: amrwbdata.h:73
decode_isf_indices_36b
static void decode_isf_indices_36b(uint16_t *ind, float *isf_q)
Decode quantized ISF vectors using 36-bit indexes (6K60 mode only).
Definition: amrwbdec.c:166
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:374
data
const char data[16]
Definition: mxf.c:146
AV_CHANNEL_LAYOUT_MONO
#define AV_CHANNEL_LAYOUT_MONO
Definition: channel_layout.h:353
FFCodec
Definition: codec_internal.h:118
AMRWBSubFrame::adap
uint16_t adap
adaptive codebook index
Definition: amrwbdata.h:70
ff_acelp_filter_init
void ff_acelp_filter_init(ACELPFContext *c)
Initialize ACELPFContext.
Definition: acelp_filters.c:150
voice_factor
static float voice_factor(float *p_vector, float p_gain, float *f_vector, float f_gain, CELPMContext *ctx)
Calculate the voicing factor (-1.0 = unvoiced to 1.0 = voiced).
Definition: amrwbdec.c:614
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
MODE_23k85
@ MODE_23k85
23.85 kbit/s
Definition: amrwbdata.h:60
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:300
AMRWBContext::pitch_gain
float pitch_gain[6]
quantified pitch gains for the current and previous five subframes
Definition: amrwbdec.c:70
amrwb_decode_frame
static int amrwb_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)
Definition: amrwbdec.c:1105
AMRWBContext::celpm_ctx
CELPMContext celpm_ctx
context for fixed point math operations
Definition: amrwbdec.c:93
UPS_MEM_SIZE
#define UPS_MEM_SIZE
Definition: amrwbdata.h:37
MODE_15k85
@ MODE_15k85
15.85 kbit/s
Definition: amrwbdata.h:56
AV_CODEC_ID_AMR_WB
@ AV_CODEC_ID_AMR_WB
Definition: codec_id.h:413
AMRWB_P_DELAY_MAX
#define AMRWB_P_DELAY_MAX
maximum pitch delay value
Definition: amrwbdata.h:47
init
static int init
Definition: av_tx.c:47
AMRWBContext::pitch_lag_int
uint8_t pitch_lag_int
integer part of pitch lag of the previous subframe
Definition: amrwbdec.c:61
bpf_6_7_coef
static const float bpf_6_7_coef[31]
High-band post-processing FIR filters coefficients from Q15.
Definition: amrwbdata.h:1856
amrwbdec_mips.h
dico23_isf
static const int16_t dico23_isf[128][3]
Definition: amrwbdata.h:1312
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:122
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:2065
AMRWBFrame::isp_id
uint16_t isp_id[7]
index of ISP subvectors
Definition: amrwbdata.h:80
AMRWBContext::fr_quality
uint8_t fr_quality
frame quality index (FQI)
Definition: amrwbdec.c:51
MODE_19k85
@ MODE_19k85
19.85 kbit/s
Definition: amrwbdata.h:58
scale
static av_always_inline float scale(float x, float s)
Definition: vf_v360.c:1389
AMRWBContext::excitation
float * excitation
points to current excitation in excitation_buf[]
Definition: amrwbdec.c:64
AMRWBContext::samples_hb
float samples_hb[LP_ORDER_16k+AMRWB_SFR_SIZE_16k]
high-band samples and memory from synthesis at 16kHz
Definition: amrwbdec.c:81
decode_pitch_lag_low
static void decode_pitch_lag_low(int *lag_int, int *lag_frac, int pitch_index, uint8_t *base_lag_int, int subframe, enum Mode mode)
Decode an adaptive codebook index into pitch lag for 8k85 and 6k60 modes.
Definition: amrwbdec.c:300
update_sub_state
static void update_sub_state(AMRWBContext *ctx)
Update context state before the next subframe.
Definition: amrwbdec.c:1089
AMRWBFrame
Definition: amrwbdata.h:78
BIT_STR
#define BIT_STR(x, lsb, len)
Get x bits in the index interval [lsb,lsb+len-1] inclusive.
Definition: amrwbdec.c:369
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
interpolate_isp
static void interpolate_isp(double isp_q[4][LP_ORDER], const double *isp4_past)
Interpolate the fourth ISP vector from current and past frames to obtain an ISP vector for each subfr...
Definition: amrwbdec.c:245
extrapolate_isf
static void extrapolate_isf(float isf[LP_ORDER_16k])
Extrapolate a ISF vector to the 16kHz range (20th order LP) used at mode 6k60 LP filter for the high ...
Definition: amrwbdec.c:939
decode_mime_header
static int decode_mime_header(AMRWBContext *ctx, const uint8_t *buf)
Decode the frame header in the "MIME/storage" format.
Definition: amrwbdec.c:151
Mode
Mode
Frame type (Table 1a in 3GPP TS 26.101)
Definition: amrnbdata.h:39
AMRWBContext::frame
AMRWBFrame frame
AMRWB parameters decoded from bitstream.
Definition: amrwbdec.c:49
dico21_isf_36b
static const int16_t dico21_isf_36b[128][5]
Definition: amrwbdata.h:1417
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:260
AMRWBContext::fixed_vector
float fixed_vector[AMRWB_SFR_SIZE]
algebraic codebook (fixed) vector for current subframe
Definition: amrwbdec.c:67
s
#define s(width, name)
Definition: cbs_vp9.c:256
AMRWBContext::hpf_31_mem
float hpf_31_mem[2]
Definition: amrwbdec.c:83
BIT_POS
#define BIT_POS(x, p)
Get the bit at specified position.
Definition: amrwbdec.c:372
av_lfg_get
static unsigned int av_lfg_get(AVLFG *c)
Get the next random unsigned 32-bit number using an ALFG.
Definition: lfg.h:53
AMRWBContext::lp_coef
float lp_coef[4][LP_ORDER]
Linear Prediction Coefficients from ISP vector.
Definition: amrwbdec.c:58
AMRWBChannelsContext
Definition: amrwbdec.c:97
isf_mean
static const int16_t isf_mean[LP_ORDER]
Means of ISF vectors in Q15.
Definition: amrwbdata.h:1619
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
decode_gains
static void decode_gains(const uint8_t vq_gain, const enum Mode mode, float *fixed_gain_factor, float *pitch_gain)
Decode pitch gain and fixed gain correction factor.
Definition: amrwbdec.c:574
lfg.h
hpf_zeros
static const float hpf_zeros[2]
High-pass filters coefficients for 31 Hz and 400 Hz cutoff.
Definition: amrwbdata.h:1813
MIN_ISF_SPACING
#define MIN_ISF_SPACING
minimum isf gap
Definition: amrwbdata.h:39
ff_acelp_lsf2lspd
void ff_acelp_lsf2lspd(double *lsp, const float *lsf, int lp_order)
Floating point version of ff_acelp_lsf2lsp()
Definition: lsp.c:93
AMRWBSubFrame::ltp
uint16_t ltp
ltp-filtering flag
Definition: amrwbdata.h:71
AMRWBContext::fr_cur_mode
enum Mode fr_cur_mode
mode index of current frame
Definition: amrwbdec.c:50
ctx
AVFormatContext * ctx
Definition: movenc.c:48
amr_bit_orderings_by_mode
static const uint16_t *const amr_bit_orderings_by_mode[]
Reordering array addresses for each mode.
Definition: amrwbdata.h:676
pitch_sharpening
static void pitch_sharpening(AMRWBContext *ctx, float *fixed_vector)
Apply pitch sharpening filters to the fixed codebook vector.
Definition: amrwbdec.c:592
MODE_8k85
@ MODE_8k85
8.85 kbit/s
Definition: amrwbdata.h:53
scaled_hb_excitation
static void scaled_hb_excitation(AMRWBContext *ctx, float *hb_exc, const float *synth_exc, float hb_gain)
Generate the high-band excitation with the same energy from the lower one and scaled by the given gai...
Definition: amrwbdec.c:901
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:64
AMRWBContext::samples_up
float samples_up[UPS_MEM_SIZE+AMRWB_SFR_SIZE]
low-band samples and memory processed for upsampling
Definition: amrwbdec.c:80
MODE_SID
@ MODE_SID
comfort noise frame
Definition: amrwbdata.h:61
AMRWBSubFrame::vq_gain
uint16_t vq_gain
VQ adaptive and innovative gains.
Definition: amrwbdata.h:72
qua_gain_7b
static const int16_t qua_gain_7b[128][2]
Definition: amrwbdata.h:1698
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
MODE_12k65
@ MODE_12k65
12.65 kbit/s
Definition: amrwbdata.h:54
cf_sizes_wb
static const uint16_t cf_sizes_wb[]
Core frame sizes in each mode.
Definition: amrwbdata.h:1885
AMRWBSubFrame
Definition: amrwbdata.h:69
ir_filters_lookup
static const float *const ir_filters_lookup[2]
Definition: amrnbdata.h:1653
AMRWBContext::lpf_7_mem
float lpf_7_mem[HB_FIR_SIZE]
previous values in the high-band low pass filter
Definition: amrwbdec.c:86
hpf_31_poles
static const float hpf_31_poles[2]
Definition: amrwbdata.h:1814
AMRWB_SFR_SIZE
#define AMRWB_SFR_SIZE
samples per subframe at 12.8 kHz
Definition: amrwbdata.h:45
dico21_isf
static const int16_t dico21_isf[64][3]
Definition: amrwbdata.h:1210
AMRWB_SFR_SIZE_16k
#define AMRWB_SFR_SIZE_16k
samples per subframe at 16 kHz
Definition: amrwbdata.h:46
dico25_isf
static const int16_t dico25_isf[32][4]
Definition: amrwbdata.h:1398
double
double
Definition: af_crystalizer.c:132
dico23_isf_36b
static const int16_t dico23_isf_36b[64][7]
Definition: amrwbdata.h:1551
celp_filters.h
av_clipf
av_clipf
Definition: af_crystalizer.c:122
noise_enhancer
static float noise_enhancer(float fixed_gain, float *prev_tr_gain, float voice_fac, float stab_fac)
Apply a non-linear fixed gain smoothing in order to reduce fluctuation in the energy of excitation.
Definition: amrwbdec.c:726
pulses_nb_per_mode_tr
static const uint8_t pulses_nb_per_mode_tr[][4]
[i][j] is the number of pulses present in track j at mode i
Definition: amrwbdata.h:1656
auto_correlation
static float auto_correlation(float *diff_isf, float mean, int lag)
Calculate the auto-correlation for the ISF difference vector.
Definition: amrwbdec.c:920
AMRWB_P_DELAY_MIN
#define AMRWB_P_DELAY_MIN
Definition: amrwbdata.h:48
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
float_dsp.h
av_channel_layout_uninit
void av_channel_layout_uninit(AVChannelLayout *channel_layout)
Free any allocated data in the channel layout and reset the channel count to 0.
Definition: channel_layout.c:630
ACELPVContext
Definition: acelp_vectors.h:28
AMRWBContext::prng
AVLFG prng
random number generator for white noise excitation
Definition: amrwbdec.c:88
ACELPFContext
Definition: acelp_filters.h:28
AV_CODEC_CAP_CHANNEL_CONF
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:109
ff_acelp_vectors_init
void ff_acelp_vectors_init(ACELPVContext *c)
Initialize ACELPVContext.
Definition: acelp_vectors.c:258
AVLFG
Context structure for the Lagged Fibonacci PRNG.
Definition: lfg.h:33
f
f
Definition: af_crystalizer.c:122
ff_celp_math_init
void ff_celp_math_init(CELPMContext *c)
Initialize CELPMContext.
Definition: celp_math.c:121
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1462
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:375
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
AMRWBContext::first_frame
uint8_t first_frame
flag active during decoding of the first frame
Definition: amrwbdec.c:89
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:290
codec_internal.h
find_hb_gain
static float find_hb_gain(AMRWBContext *ctx, const float *synth, uint16_t hb_idx, uint8_t vad)
Calculate the high-band gain based on encoded index (23k85 mode) or on the low-band speech signal and...
Definition: amrwbdec.c:871
ENERGY_MEAN
#define ENERGY_MEAN
mean innovation energy (dB) in all modes
Definition: amrwbdata.h:42
CELPFContext
Definition: celp_filters.h:28
LP_ORDER_16k
#define LP_ORDER_16k
lpc filter order at 16kHz
Definition: amrwbdata.h:34
hpf_31_gain
static const float hpf_31_gain
Definition: amrwbdata.h:1815
de_emphasis
static void de_emphasis(float *out, float *in, float m, float mem[1])
Apply to synthesis a de-emphasis filter of the form: H(z) = 1 / (1 - m * z^-1)
Definition: amrwbdec.c:818
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1023
decode_5p_track
static void decode_5p_track(int *out, int code, int m, int off)
code: 5m bits
Definition: amrwbdec.c:449
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
hb_fir_filter
static void hb_fir_filter(float *out, const float fir_coef[HB_FIR_SIZE+1], float mem[HB_FIR_SIZE], const float *in)
Apply a 15th order filter to high-band samples.
Definition: amrwbdec.c:1067
AMRWBContext::pitch_vector
float pitch_vector[AMRWB_SFR_SIZE]
adaptive codebook (pitch) vector for current subframe
Definition: amrwbdec.c:66
celp_math.h
AMRWBContext::hpf_400_mem
float hpf_400_mem[2]
previous values in the high pass filters
Definition: amrwbdec.c:83
size
int size
Definition: twinvq_data.h:10344
dico22_isf_36b
static const int16_t dico22_isf_36b[128][4]
Definition: amrwbdata.h:1484
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.
AMRWBContext::acelpf_ctx
ACELPFContext acelpf_ctx
context for filters for ACELP-based codecs
Definition: amrwbdec.c:90
dico24_isf
static const int16_t dico24_isf[32][3]
Definition: amrwbdata.h:1379
decode_pitch_lag_high
static void decode_pitch_lag_high(int *lag_int, int *lag_frac, int pitch_index, uint8_t *base_lag_int, int subframe)
Decode an adaptive codebook index into pitch lag (except 6k60, 8k85 modes).
Definition: amrwbdec.c:267
isf_init
static const int16_t isf_init[LP_ORDER]
Initialization tables for the processed ISF vector in Q15.
Definition: amrwbdata.h:1625
stability_factor
static float stability_factor(const float *isf, const float *isf_past)
Calculate a stability factor {teta} based on distance between current and past isf.
Definition: amrwbdec.c:702
AMRWBFrame::vad
uint16_t vad
voice activity detection flag
Definition: amrwbdata.h:79
ff_celp_filter_init
void ff_celp_filter_init(CELPFContext *c)
Initialize CELPFContext.
Definition: celp_filters.c:213
AMRWBContext::isf_past_final
float isf_past_final[LP_ORDER]
final processed ISF vector of the previous frame
Definition: amrwbdec.c:54
AMRWBContext::fixed_gain
float fixed_gain[2]
quantified fixed gains for the current and previous subframes
Definition: amrwbdec.c:71
isf_add_mean_and_past
static void isf_add_mean_and_past(float *isf_q, float *isf_past)
Apply mean and past ISF values using the prediction factor.
Definition: amrwbdec.c:225
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
NO_DATA
@ NO_DATA
no transmission
Definition: amrnbdata.h:50
common.h
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:55
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AMRWBContext::bpf_6_7_mem
float bpf_6_7_mem[HB_FIR_SIZE]
previous values in the high-band band pass filter
Definition: amrwbdec.c:85
acelp_filters.h
MODE_23k05
@ MODE_23k05
23.05 kbit/s
Definition: amrwbdata.h:59
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:211
amr.h
av_samples_set_silence
int av_samples_set_silence(uint8_t **audio_data, int offset, int nb_samples, int nb_channels, enum AVSampleFormat sample_fmt)
Fill an audio buffer with silence.
Definition: samplefmt.c:246
avcodec.h
decode_4p_track
static void decode_4p_track(int *out, int code, int m, int off)
code: 4m bits
Definition: amrwbdec.c:413
AMRWBContext::isp
double isp[4][LP_ORDER]
ISP vectors from current frame.
Definition: amrwbdec.c:55
lpf_7_coef
static const float lpf_7_coef[31]
Definition: amrwbdata.h:1870
ret
ret
Definition: filter_design.txt:187
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
hb_synthesis
static void hb_synthesis(AMRWBContext *ctx, int subframe, float *samples, const float *exc, const float *isf, const float *isf_past)
Conduct 20th order linear predictive coding synthesis for the high frequency band excitation at 16kHz...
Definition: amrwbdec.c:1026
pos
unsigned int pos
Definition: spdifenc.c:412
ac_inter
static const float ac_inter[65]
Coefficients for FIR interpolation of excitation vector at pitch lag resulting the adaptive codebook ...
Definition: amrwbdata.h:1635
CELPMContext
Definition: celp_math.h:28
AMRWBSubFrame::pul_ih
uint16_t pul_ih[4]
MSBs part of codebook index (high modes only)
Definition: amrwbdata.h:74
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
AVCodecContext
main external API structure.
Definition: avcodec.h:398
channel_layout.h
AMRWBContext
Definition: amrwbdec.c:48
anti_sparseness
static float * anti_sparseness(AMRWBContext *ctx, float *fixed_vector, float *buf)
Reduce fixed vector sparseness by smoothing with one of three IR filters, also known as "adaptive pha...
Definition: amrwbdec.c:638
hpf_400_gain
static const float hpf_400_gain
Definition: amrwbdata.h:1818
mode
mode
Definition: ebur128.h:83
decode_isf_indices_46b
static void decode_isf_indices_46b(uint16_t *ind, float *isf_q)
Decode quantized ISF vectors using 46-bit indexes (except 6K60 mode).
Definition: amrwbdec.c:192
AMRWBContext::isf_cur
float isf_cur[LP_ORDER]
working ISF vector from current frame
Definition: amrwbdec.c:52
amrwbdata.h
samples
Filter the word “frame” indicates either a video frame or a group of audio samples
Definition: filter_design.txt:8
mean
static float mean(const float *input, int size)
Definition: vf_nnedi.c:857
isfp_inter
static const float isfp_inter[4]
ISF/ISP interpolation coefficients for each subframe.
Definition: amrwbdata.h:1631
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
LP_ORDER
#define LP_ORDER
linear predictive coding filter order
Definition: amrwbdata.h:33
decode_3p_track
static void decode_3p_track(int *out, int code, int m, int off)
code: 3m+1 bits
Definition: amrwbdec.c:404
AMRWBContext::prev_tr_gain
float prev_tr_gain
previous initial gain used by noise enhancer for threshold
Definition: amrwbdec.c:77
decode_fixed_vector
static void decode_fixed_vector(float *fixed_vector, const uint16_t *pulse_hi, const uint16_t *pulse_lo, const enum Mode mode)
Decode the algebraic codebook index to pulse positions and signs, then construct the algebraic codebo...
Definition: amrwbdec.c:503
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
AMRWBContext::prediction_error
float prediction_error[4]
quantified prediction errors {20log10(^gamma_gc)} for previous four subframes
Definition: amrwbdec.c:69
decode_1p_track
static void decode_1p_track(int *out, int code, int m, int off)
The next six functions decode_[i]p_track decode exactly i pulses positions and amplitudes (-1 or 1) i...
Definition: amrwbdec.c:387
synthesis
static void synthesis(AMRWBContext *ctx, float *lpc, float *excitation, float fixed_gain, const float *fixed_vector, float *samples)
Conduct 16th order linear predictive coding synthesis from excitation.
Definition: amrwbdec.c:781
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:425
AMRWBContext::excitation_buf
float excitation_buf[AMRWB_P_DELAY_MAX+LP_ORDER+2+AMRWB_SFR_SIZE]
current excitation and all necessary excitation history
Definition: amrwbdec.c:63
HB_FIR_SIZE
#define HB_FIR_SIZE
amount of past data needed by HB filters
Definition: amrwbdata.h:35
MODE_18k25
@ MODE_18k25
18.25 kbit/s
Definition: amrwbdata.h:57
amrwb_decode_init
static av_cold int amrwb_decode_init(AVCodecContext *avctx)
Definition: amrwbdec.c:101
dico1_isf
static const int16_t dico1_isf[256][9]
Indexed tables for retrieval of quantized ISF vectors in Q15.
Definition: amrwbdata.h:692
decode_6p_track
static void decode_6p_track(int *out, int code, int m, int off)
code: 6m-2 bits
Definition: amrwbdec.c:459
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
AMRWBFrame::subframe
AMRWBSubFrame subframe[4]
data for subframes
Definition: amrwbdata.h:81
AMRWBContext::isf_q_past
float isf_q_past[LP_ORDER]
quantized ISF vector of the previous frame
Definition: amrwbdec.c:53
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
ff_amrwb_decoder
const FFCodec ff_amrwb_decoder
Definition: amrwbdec.c:1295
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
MIN_ENERGY
#define MIN_ENERGY
Initial energy in dB.
Definition: amrnbdec.c:85
MODE_14k25
@ MODE_14k25
14.25 kbit/s
Definition: amrwbdata.h:55
qua_gain_6b
static const int16_t qua_gain_6b[64][2]
Tables for decoding quantized gains { pitch (Q14), fixed factor (Q11) }.
Definition: amrwbdata.h:1663
AMRWBSubFrame::pul_il
uint16_t pul_il[4]
LSBs part of codebook index.
Definition: amrwbdata.h:75
truncf
static __device__ float truncf(float a)
Definition: cuda_runtime.h:178
upsample_5_4
static void upsample_5_4(float *out, const float *in, int o_size, CELPMContext *ctx)
Upsample a signal by 5/4 ratio (from 12.8kHz to 16kHz) using a FIR interpolation filter.
Definition: amrwbdec.c:839
AMRWBContext::acelpv_ctx
ACELPVContext acelpv_ctx
context for vector operations for ACELP-based codecs
Definition: amrwbdec.c:91
PRED_FACTOR
#define PRED_FACTOR
Definition: amrwbdata.h:40
int
int
Definition: ffmpeg_filter.c:155
AMRWBContext::tilt_coef
float tilt_coef
{beta_1} related to the voicing of the previous subframe
Definition: amrwbdec.c:73
decode_pitch_vector
static void decode_pitch_vector(AMRWBContext *ctx, const AMRWBSubFrame *amr_subframe, const int subframe)
Find the pitch vector by interpolating the past excitation at the pitch delay, which is obtained in t...
Definition: amrwbdec.c:329
AV_SAMPLE_FMT_FLT
@ AV_SAMPLE_FMT_FLT
float
Definition: samplefmt.h:60
AMRWBContext::celpf_ctx
CELPFContext celpf_ctx
context for filters for CELP-based codecs
Definition: amrwbdec.c:92
hpf_400_poles
static const float hpf_400_poles[2]
Definition: amrwbdata.h:1817
ff_set_min_dist_lsf
void ff_set_min_dist_lsf(float *lsf, double min_spacing, int size)
Adjust the quantized LSFs so they are increasing and not too close.
Definition: lsp.c:51
PREEMPH_FAC
#define PREEMPH_FAC
factor used to de-emphasize synthesis
Definition: amrwbdata.h:43
acelp_pitch_delay.h