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