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