FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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) << 1;
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) << 1;
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)) << 1;
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 
334  ctx->pitch_lag_int = pitch_lag_int;
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
581 static void pitch_sharpening(AMRWBContext *ctx, float *fixed_vector)
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);
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 
866  if (ctx->fr_cur_mode == MODE_23k85)
867  return qua_hb_gain[hb_idx] * (1.0f / (1 << 14));
868 
869  tilt = ctx->celpm_ctx.dot_productf(synth, synth + 1, AMRWB_SFR_SIZE - 1) /
870  ctx->celpm_ctx.dot_productf(synth, synth, AMRWB_SFR_SIZE);
871 
872  /* return gain bounded by [0.1, 1.0] */
873  return av_clipf((1.0 - FFMAX(0.0, tilt)) * (1.25 - 0.25 * wsp), 0.1, 1.0);
874 }
875 
876 /**
877  * Generate the high-band excitation with the same energy from the lower
878  * one and scaled by the given gain.
879  *
880  * @param[in] ctx The context
881  * @param[out] hb_exc Buffer for the excitation
882  * @param[in] synth_exc Low-band excitation used for synthesis
883  * @param[in] hb_gain Wanted excitation gain
884  */
885 static void scaled_hb_excitation(AMRWBContext *ctx, float *hb_exc,
886  const float *synth_exc, float hb_gain)
887 {
888  int i;
889  float energy = ctx->celpm_ctx.dot_productf(synth_exc, synth_exc,
891 
892  /* Generate a white-noise excitation */
893  for (i = 0; i < AMRWB_SFR_SIZE_16k; i++)
894  hb_exc[i] = 32768.0 - (uint16_t) av_lfg_get(&ctx->prng);
895 
897  energy * hb_gain * hb_gain,
898  AMRWB_SFR_SIZE_16k);
899 }
900 
901 /**
902  * Calculate the auto-correlation for the ISF difference vector.
903  */
904 static float auto_correlation(float *diff_isf, float mean, int lag)
905 {
906  int i;
907  float sum = 0.0;
908 
909  for (i = 7; i < LP_ORDER - 2; i++) {
910  float prod = (diff_isf[i] - mean) * (diff_isf[i - lag] - mean);
911  sum += prod * prod;
912  }
913  return sum;
914 }
915 
916 /**
917  * Extrapolate a ISF vector to the 16kHz range (20th order LP)
918  * used at mode 6k60 LP filter for the high frequency band.
919  *
920  * @param[out] isf Buffer for extrapolated isf; contains LP_ORDER
921  * values on input
922  */
923 static void extrapolate_isf(float isf[LP_ORDER_16k])
924 {
925  float diff_isf[LP_ORDER - 2], diff_mean;
926  float corr_lag[3];
927  float est, scale;
928  int i, j, i_max_corr;
929 
930  isf[LP_ORDER_16k - 1] = isf[LP_ORDER - 1];
931 
932  /* Calculate the difference vector */
933  for (i = 0; i < LP_ORDER - 2; i++)
934  diff_isf[i] = isf[i + 1] - isf[i];
935 
936  diff_mean = 0.0;
937  for (i = 2; i < LP_ORDER - 2; i++)
938  diff_mean += diff_isf[i] * (1.0f / (LP_ORDER - 4));
939 
940  /* Find which is the maximum autocorrelation */
941  i_max_corr = 0;
942  for (i = 0; i < 3; i++) {
943  corr_lag[i] = auto_correlation(diff_isf, diff_mean, i + 2);
944 
945  if (corr_lag[i] > corr_lag[i_max_corr])
946  i_max_corr = i;
947  }
948  i_max_corr++;
949 
950  for (i = LP_ORDER - 1; i < LP_ORDER_16k - 1; i++)
951  isf[i] = isf[i - 1] + isf[i - 1 - i_max_corr]
952  - isf[i - 2 - i_max_corr];
953 
954  /* Calculate an estimate for ISF(18) and scale ISF based on the error */
955  est = 7965 + (isf[2] - isf[3] - isf[4]) / 6.0;
956  scale = 0.5 * (FFMIN(est, 7600) - isf[LP_ORDER - 2]) /
957  (isf[LP_ORDER_16k - 2] - isf[LP_ORDER - 2]);
958 
959  for (i = LP_ORDER - 1, j = 0; i < LP_ORDER_16k - 1; i++, j++)
960  diff_isf[j] = scale * (isf[i] - isf[i - 1]);
961 
962  /* Stability insurance */
963  for (i = 1; i < LP_ORDER_16k - LP_ORDER; i++)
964  if (diff_isf[i] + diff_isf[i - 1] < 5.0) {
965  if (diff_isf[i] > diff_isf[i - 1]) {
966  diff_isf[i - 1] = 5.0 - diff_isf[i];
967  } else
968  diff_isf[i] = 5.0 - diff_isf[i - 1];
969  }
970 
971  for (i = LP_ORDER - 1, j = 0; i < LP_ORDER_16k - 1; i++, j++)
972  isf[i] = isf[i - 1] + diff_isf[j] * (1.0f / (1 << 15));
973 
974  /* Scale the ISF vector for 16000 Hz */
975  for (i = 0; i < LP_ORDER_16k - 1; i++)
976  isf[i] *= 0.8;
977 }
978 
979 /**
980  * Spectral expand the LP coefficients using the equation:
981  * y[i] = x[i] * (gamma ** i)
982  *
983  * @param[out] out Output buffer (may use input array)
984  * @param[in] lpc LP coefficients array
985  * @param[in] gamma Weighting factor
986  * @param[in] size LP array size
987  */
988 static void lpc_weighting(float *out, const float *lpc, float gamma, int size)
989 {
990  int i;
991  float fac = gamma;
992 
993  for (i = 0; i < size; i++) {
994  out[i] = lpc[i] * fac;
995  fac *= gamma;
996  }
997 }
998 
999 /**
1000  * Conduct 20th order linear predictive coding synthesis for the high
1001  * frequency band excitation at 16kHz.
1002  *
1003  * @param[in] ctx The context
1004  * @param[in] subframe Current subframe index (0 to 3)
1005  * @param[in,out] samples Pointer to the output speech samples
1006  * @param[in] exc Generated white-noise scaled excitation
1007  * @param[in] isf Current frame isf vector
1008  * @param[in] isf_past Past frame final isf vector
1009  */
1010 static void hb_synthesis(AMRWBContext *ctx, int subframe, float *samples,
1011  const float *exc, const float *isf, const float *isf_past)
1012 {
1013  float hb_lpc[LP_ORDER_16k];
1014  enum Mode mode = ctx->fr_cur_mode;
1015 
1016  if (mode == MODE_6k60) {
1017  float e_isf[LP_ORDER_16k]; // ISF vector for extrapolation
1018  double e_isp[LP_ORDER_16k];
1019 
1020  ctx->acelpv_ctx.weighted_vector_sumf(e_isf, isf_past, isf, isfp_inter[subframe],
1021  1.0 - isfp_inter[subframe], LP_ORDER);
1022 
1023  extrapolate_isf(e_isf);
1024 
1025  e_isf[LP_ORDER_16k - 1] *= 2.0;
1026  ff_acelp_lsf2lspd(e_isp, e_isf, LP_ORDER_16k);
1027  ff_amrwb_lsp2lpc(e_isp, hb_lpc, LP_ORDER_16k);
1028 
1029  lpc_weighting(hb_lpc, hb_lpc, 0.9, LP_ORDER_16k);
1030  } else {
1031  lpc_weighting(hb_lpc, ctx->lp_coef[subframe], 0.6, LP_ORDER);
1032  }
1033 
1034  ctx->celpf_ctx.celp_lp_synthesis_filterf(samples, hb_lpc, exc, AMRWB_SFR_SIZE_16k,
1035  (mode == MODE_6k60) ? LP_ORDER_16k : LP_ORDER);
1036 }
1037 
1038 /**
1039  * Apply a 15th order filter to high-band samples.
1040  * The filter characteristic depends on the given coefficients.
1041  *
1042  * @param[out] out Buffer for filtered output
1043  * @param[in] fir_coef Filter coefficients
1044  * @param[in,out] mem State from last filtering (updated)
1045  * @param[in] in Input speech data (high-band)
1046  *
1047  * @remark It is safe to pass the same array in in and out parameters
1048  */
1049 
1050 #ifndef hb_fir_filter
1051 static void hb_fir_filter(float *out, const float fir_coef[HB_FIR_SIZE + 1],
1052  float mem[HB_FIR_SIZE], const float *in)
1053 {
1054  int i, j;
1055  float data[AMRWB_SFR_SIZE_16k + HB_FIR_SIZE]; // past and current samples
1056 
1057  memcpy(data, mem, HB_FIR_SIZE * sizeof(float));
1058  memcpy(data + HB_FIR_SIZE, in, AMRWB_SFR_SIZE_16k * sizeof(float));
1059 
1060  for (i = 0; i < AMRWB_SFR_SIZE_16k; i++) {
1061  out[i] = 0.0;
1062  for (j = 0; j <= HB_FIR_SIZE; j++)
1063  out[i] += data[i + j] * fir_coef[j];
1064  }
1065 
1066  memcpy(mem, data + AMRWB_SFR_SIZE_16k, HB_FIR_SIZE * sizeof(float));
1067 }
1068 #endif /* hb_fir_filter */
1069 
1070 /**
1071  * Update context state before the next subframe.
1072  */
1074 {
1075  memmove(&ctx->excitation_buf[0], &ctx->excitation_buf[AMRWB_SFR_SIZE],
1076  (AMRWB_P_DELAY_MAX + LP_ORDER + 1) * sizeof(float));
1077 
1078  memmove(&ctx->pitch_gain[1], &ctx->pitch_gain[0], 5 * sizeof(float));
1079  memmove(&ctx->fixed_gain[1], &ctx->fixed_gain[0], 1 * sizeof(float));
1080 
1081  memmove(&ctx->samples_az[0], &ctx->samples_az[AMRWB_SFR_SIZE],
1082  LP_ORDER * sizeof(float));
1083  memmove(&ctx->samples_up[0], &ctx->samples_up[AMRWB_SFR_SIZE],
1084  UPS_MEM_SIZE * sizeof(float));
1085  memmove(&ctx->samples_hb[0], &ctx->samples_hb[AMRWB_SFR_SIZE_16k],
1086  LP_ORDER_16k * sizeof(float));
1087 }
1088 
1089 static int amrwb_decode_frame(AVCodecContext *avctx, void *data,
1090  int *got_frame_ptr, AVPacket *avpkt)
1091 {
1092  AMRWBContext *ctx = avctx->priv_data;
1093  AVFrame *frame = data;
1094  AMRWBFrame *cf = &ctx->frame;
1095  const uint8_t *buf = avpkt->data;
1096  int buf_size = avpkt->size;
1097  int expected_fr_size, header_size;
1098  float *buf_out;
1099  float spare_vector[AMRWB_SFR_SIZE]; // extra stack space to hold result from anti-sparseness processing
1100  float fixed_gain_factor; // fixed gain correction factor (gamma)
1101  float *synth_fixed_vector; // pointer to the fixed vector that synthesis should use
1102  float synth_fixed_gain; // the fixed gain that synthesis should use
1103  float voice_fac, stab_fac; // parameters used for gain smoothing
1104  float synth_exc[AMRWB_SFR_SIZE]; // post-processed excitation for synthesis
1105  float hb_exc[AMRWB_SFR_SIZE_16k]; // excitation for the high frequency band
1106  float hb_samples[AMRWB_SFR_SIZE_16k]; // filtered high-band samples from synthesis
1107  float hb_gain;
1108  int sub, i, ret;
1109 
1110  /* get output buffer */
1111  frame->nb_samples = 4 * AMRWB_SFR_SIZE_16k;
1112  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1113  return ret;
1114  buf_out = (float *)frame->data[0];
1115 
1116  header_size = decode_mime_header(ctx, buf);
1117  if (ctx->fr_cur_mode > MODE_SID) {
1118  av_log(avctx, AV_LOG_ERROR,
1119  "Invalid mode %d\n", ctx->fr_cur_mode);
1120  return AVERROR_INVALIDDATA;
1121  }
1122  expected_fr_size = ((cf_sizes_wb[ctx->fr_cur_mode] + 7) >> 3) + 1;
1123 
1124  if (buf_size < expected_fr_size) {
1125  av_log(avctx, AV_LOG_ERROR,
1126  "Frame too small (%d bytes). Truncated file?\n", buf_size);
1127  *got_frame_ptr = 0;
1128  return AVERROR_INVALIDDATA;
1129  }
1130 
1131  if (!ctx->fr_quality || ctx->fr_cur_mode > MODE_SID)
1132  av_log(avctx, AV_LOG_ERROR, "Encountered a bad or corrupted frame\n");
1133 
1134  if (ctx->fr_cur_mode == MODE_SID) { /* Comfort noise frame */
1135  avpriv_request_sample(avctx, "SID mode");
1136  return AVERROR_PATCHWELCOME;
1137  }
1138 
1139  ff_amr_bit_reorder((uint16_t *) &ctx->frame, sizeof(AMRWBFrame),
1140  buf + header_size, amr_bit_orderings_by_mode[ctx->fr_cur_mode]);
1141 
1142  /* Decode the quantized ISF vector */
1143  if (ctx->fr_cur_mode == MODE_6k60) {
1145  } else {
1147  }
1148 
1151 
1152  stab_fac = stability_factor(ctx->isf_cur, ctx->isf_past_final);
1153 
1154  ctx->isf_cur[LP_ORDER - 1] *= 2.0;
1155  ff_acelp_lsf2lspd(ctx->isp[3], ctx->isf_cur, LP_ORDER);
1156 
1157  /* Generate a ISP vector for each subframe */
1158  if (ctx->first_frame) {
1159  ctx->first_frame = 0;
1160  memcpy(ctx->isp_sub4_past, ctx->isp[3], LP_ORDER * sizeof(double));
1161  }
1162  interpolate_isp(ctx->isp, ctx->isp_sub4_past);
1163 
1164  for (sub = 0; sub < 4; sub++)
1165  ff_amrwb_lsp2lpc(ctx->isp[sub], ctx->lp_coef[sub], LP_ORDER);
1166 
1167  for (sub = 0; sub < 4; sub++) {
1168  const AMRWBSubFrame *cur_subframe = &cf->subframe[sub];
1169  float *sub_buf = buf_out + sub * AMRWB_SFR_SIZE_16k;
1170 
1171  /* Decode adaptive codebook (pitch vector) */
1172  decode_pitch_vector(ctx, cur_subframe, sub);
1173  /* Decode innovative codebook (fixed vector) */
1174  decode_fixed_vector(ctx->fixed_vector, cur_subframe->pul_ih,
1175  cur_subframe->pul_il, ctx->fr_cur_mode);
1176 
1177  pitch_sharpening(ctx, ctx->fixed_vector);
1178 
1179  decode_gains(cur_subframe->vq_gain, ctx->fr_cur_mode,
1180  &fixed_gain_factor, &ctx->pitch_gain[0]);
1181 
1182  ctx->fixed_gain[0] =
1183  ff_amr_set_fixed_gain(fixed_gain_factor,
1185  ctx->fixed_vector,
1186  AMRWB_SFR_SIZE) /
1188  ctx->prediction_error,
1190 
1191  /* Calculate voice factor and store tilt for next subframe */
1192  voice_fac = voice_factor(ctx->pitch_vector, ctx->pitch_gain[0],
1193  ctx->fixed_vector, ctx->fixed_gain[0],
1194  &ctx->celpm_ctx);
1195  ctx->tilt_coef = voice_fac * 0.25 + 0.25;
1196 
1197  /* Construct current excitation */
1198  for (i = 0; i < AMRWB_SFR_SIZE; i++) {
1199  ctx->excitation[i] *= ctx->pitch_gain[0];
1200  ctx->excitation[i] += ctx->fixed_gain[0] * ctx->fixed_vector[i];
1201  ctx->excitation[i] = truncf(ctx->excitation[i]);
1202  }
1203 
1204  /* Post-processing of excitation elements */
1205  synth_fixed_gain = noise_enhancer(ctx->fixed_gain[0], &ctx->prev_tr_gain,
1206  voice_fac, stab_fac);
1207 
1208  synth_fixed_vector = anti_sparseness(ctx, ctx->fixed_vector,
1209  spare_vector);
1210 
1211  pitch_enhancer(synth_fixed_vector, voice_fac);
1212 
1213  synthesis(ctx, ctx->lp_coef[sub], synth_exc, synth_fixed_gain,
1214  synth_fixed_vector, &ctx->samples_az[LP_ORDER]);
1215 
1216  /* Synthesis speech post-processing */
1218  &ctx->samples_az[LP_ORDER], PREEMPH_FAC, ctx->demph_mem);
1219 
1222  hpf_31_gain, ctx->hpf_31_mem, AMRWB_SFR_SIZE);
1223 
1224  upsample_5_4(sub_buf, &ctx->samples_up[UPS_FIR_SIZE],
1225  AMRWB_SFR_SIZE_16k, &ctx->celpm_ctx);
1226 
1227  /* High frequency band (6.4 - 7.0 kHz) generation part */
1230  hpf_400_gain, ctx->hpf_400_mem, AMRWB_SFR_SIZE);
1231 
1232  hb_gain = find_hb_gain(ctx, hb_samples,
1233  cur_subframe->hb_gain, cf->vad);
1234 
1235  scaled_hb_excitation(ctx, hb_exc, synth_exc, hb_gain);
1236 
1237  hb_synthesis(ctx, sub, &ctx->samples_hb[LP_ORDER_16k],
1238  hb_exc, ctx->isf_cur, ctx->isf_past_final);
1239 
1240  /* High-band post-processing filters */
1241  hb_fir_filter(hb_samples, bpf_6_7_coef, ctx->bpf_6_7_mem,
1242  &ctx->samples_hb[LP_ORDER_16k]);
1243 
1244  if (ctx->fr_cur_mode == MODE_23k85)
1245  hb_fir_filter(hb_samples, lpf_7_coef, ctx->lpf_7_mem,
1246  hb_samples);
1247 
1248  /* Add the low and high frequency bands */
1249  for (i = 0; i < AMRWB_SFR_SIZE_16k; i++)
1250  sub_buf[i] = (sub_buf[i] + hb_samples[i]) * (1.0f / (1 << 15));
1251 
1252  /* Update buffers and history */
1253  update_sub_state(ctx);
1254  }
1255 
1256  /* update state for next frame */
1257  memcpy(ctx->isp_sub4_past, ctx->isp[3], LP_ORDER * sizeof(ctx->isp[3][0]));
1258  memcpy(ctx->isf_past_final, ctx->isf_cur, LP_ORDER * sizeof(float));
1259 
1260  *got_frame_ptr = 1;
1261 
1262  return expected_fr_size;
1263 }
1264 
1266  .name = "amrwb",
1267  .long_name = NULL_IF_CONFIG_SMALL("AMR-WB (Adaptive Multi-Rate WideBand)"),
1268  .type = AVMEDIA_TYPE_AUDIO,
1269  .id = AV_CODEC_ID_AMR_WB,
1270  .priv_data_size = sizeof(AMRWBContext),
1273  .capabilities = AV_CODEC_CAP_DR1,
1274  .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLT,
1276 };
AMRWBSubFrame subframe[4]
data for subframes
Definition: amrwbdata.h:81
Definition: lfg.h:25
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:184
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:101
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:1051
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:546
float prev_tr_gain
previous initial gain used by noise enhancer for threshold
Definition: amrwbdec.c:76
#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:1602
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
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:923
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:988
uint8_t first_frame
flag active during decoding of the first frame
Definition: amrwbdec.c:88
float(* dot_productf)(const float *a, const float *b, int length)
Return the dot product.
Definition: celp_math.h:37
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:3601
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:885
uint16_t vq_gain
VQ adaptive and innovative gains.
Definition: amrwbdata.h:72
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2446
int mem
Definition: avisynth_c.h:821
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:1089
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
static const int16_t isf_mean[LP_ORDER]
Means of ISF vectors in Q15.
Definition: amrwbdata.h:1619
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
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
static AVFrame * frame
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:1601
#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:101
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
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 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:176
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
const char * name
Name of the codec implementation.
Definition: avcodec.h:3608
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:109
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
#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:2489
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:1010
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
#define LP_ORDER
linear predictive coding filter order
Definition: amrwbdata.h:33
static const uint16_t * amr_bit_orderings_by_mode[]
Reordering array addresses for each mode.
Definition: amrwbdata.h:676
#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:1265
uint16_t adap
adaptive codebook index
Definition: amrwbdata.h:70
int sample_rate
samples per second
Definition: avcodec.h:2438
main external API structure.
Definition: avcodec.h:1676
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
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: utils.c:947
#define PRED_FACTOR
Definition: amrwbdata.h:40
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;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);returnNULL;}returnac;}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;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->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);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> in
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:38
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:690
static const float hpf_400_poles[2]
Definition: amrwbdata.h:1817
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:30
static float auto_correlation(float *diff_isf, float mean, int lag)
Calculate the auto-correlation for the ISF difference vector.
Definition: amrwbdec.c:904
static void update_sub_state(AMRWBContext *ctx)
Update context state before the next subframe.
Definition: amrwbdec.c:1073
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.
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:198
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:1718
#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 int16_t dico22_isf_36b[128][4]
Definition: amrwbdata.h:1484
int channels
number of audio channels
Definition: avcodec.h:2439
static uint8_t tmp[8]
Definition: des.c:38
static AVCodec * c
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
#define BIT_POS(x, p)
Get the bit at specified position.
Definition: amrwbdec.c:361
static int decode(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *pkt)
Definition: ffmpeg.c:2045
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:1578
uint16_t ltp
ltp-filtering flag
Definition: amrwbdata.h:71
mode
Use these values in ebur128_init (or'ed).
Definition: ebur128.h:83
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:241
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:959
double isp[4][LP_ORDER]
ISP vectors from current frame.
Definition: amrwbdec.c:54
for(j=16;j >0;--j)
void(* acelp_interpolatef)(float *out, const float *in, const float *filter_coeffs, int precision, int frac_pos, int filter_length, int length)
Floating point version of ff_acelp_interpolate()
Definition: acelp_filters.h:32
float 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