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 
114  ctx->excitation = &ctx->excitation_buf[AMRWB_P_DELAY_MAX + LP_ORDER + 1];
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 
123  ff_acelp_filter_init(&ctx->acelpf_ctx);
124  ff_acelp_vectors_init(&ctx->acelpv_ctx);
125  ff_celp_filter_init(&ctx->celpf_ctx);
126  ff_celp_math_init(&ctx->celpm_ctx);
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 
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 */
339  ctx->acelpf_ctx.acelp_interpolatef(exc,
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 */
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 */
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 + 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],
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,
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) {
1149  decode_isf_indices_36b(cf->isp_id, ctx->isf_cur);
1150  } else {
1151  decode_isf_indices_46b(cf->isp_id, ctx->isf_cur);
1152  }
1153 
1154  isf_add_mean_and_past(ctx->isf_cur, ctx->isf_q_past);
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,
1189  ctx->celpm_ctx.dot_productf(ctx->fixed_vector,
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 */
1222  de_emphasis(&ctx->samples_up[UPS_MEM_SIZE],
1223  &ctx->samples_az[LP_ORDER], PREEMPH_FAC, ctx->demph_mem);
1224 
1225  ctx->acelpf_ctx.acelp_apply_order_2_transfer_function(&ctx->samples_up[UPS_MEM_SIZE],
1226  &ctx->samples_up[UPS_MEM_SIZE], hpf_zeros, hpf_31_poles,
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 */
1233  ctx->acelpf_ctx.acelp_apply_order_2_transfer_function(hb_samples,
1234  &ctx->samples_up[UPS_MEM_SIZE], hpf_zeros, hpf_400_poles,
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 */
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 };
lpc_weighting
static void lpc_weighting(float *out, const float *lpc, float gamma, int size)
Spectral expand the LP coefficients using the equation: y[i] = x[i] * (gamma ** i)
Definition: amrwbdec.c:993
AVCodec
AVCodec.
Definition: avcodec.h:3481
pitch_enhancer
static void pitch_enhancer(float *fixed_vector, float voice_fac)
Filter the fixed_vector to emphasize the higher frequencies.
Definition: amrwbdec.c:742
AMRWBContext::base_pitch_lag
uint8_t base_pitch_lag
integer part of pitch lag for the next relative subframe
Definition: amrwbdec.c:59
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
UPS_FIR_SIZE
#define UPS_FIR_SIZE
upsampling filter size
Definition: amrwbdata.h:36
acelp_vectors.h
acc
int acc
Definition: yuv2rgb.c:555
AMRWBContext::demph_mem
float demph_mem[1]
previous value in the de-emphasis filter
Definition: amrwbdec.c:83
AMRWBContext::prev_ir_filter_nr
uint8_t prev_ir_filter_nr
previous impulse response filter "impNr": 0 - strong, 1 - medium, 2 - none
Definition: amrwbdec.c:75
AMRWBContext::isp_sub4_past
double isp_sub4_past[LP_ORDER]
ISP vector for the 4th subframe of the previous frame.
Definition: amrwbdec.c:55
MODE_6k60
@ MODE_6k60
6.60 kbit/s
Definition: amrwbdata.h:52
AVCodecContext::channel_layout
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2276
ff_amr_set_fixed_gain
float ff_amr_set_fixed_gain(float fixed_gain_factor, float fixed_mean_energy, float *prediction_error, float energy_mean, const float *pred_table)
Calculate fixed gain (part of section 6.1.3 of AMR spec)
Definition: acelp_pitch_delay.c:127
decode_2p_track
static void decode_2p_track(int *out, int code, int m, int off)
code: 2m+1 bits
Definition: amrwbdec.c:383
dico22_isf
static const int16_t dico22_isf[128][3]
Definition: amrwbdata.h:1245
upsample_fir
static const float upsample_fir[4][24]
Interpolation coefficients for 5/4 signal upsampling Table from the reference source was reordered fo...
Definition: amrwbdata.h:1822
qua_hb_gain
static const uint16_t qua_hb_gain[16]
High band quantized gains for 23k85 in Q14.
Definition: amrwbdata.h:1850
out
FILE * out
Definition: movenc.c:54
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:2225
av_lfg_init
av_cold void av_lfg_init(AVLFG *c, unsigned int seed)
Definition: lfg.c:32
AMRWBContext::samples_az
float samples_az[LP_ORDER+AMRWB_SFR_SIZE]
low-band samples and memory from synthesis at 12.8kHz
Definition: amrwbdec.c:78
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:686
amrwb_decode_frame
static int amrwb_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: amrwbdec.c:1094
AV_CH_LAYOUT_MONO
#define AV_CH_LAYOUT_MONO
Definition: channel_layout.h:85
AMRWBContext::prev_sparse_fixed_gain
float prev_sparse_fixed_gain
previous fixed gain; used by anti-sparseness to determine "onset"
Definition: amrwbdec.c:74
ff_amrwb_lsp2lpc
void ff_amrwb_lsp2lpc(const double *lsp, float *lp, int lp_order)
LSP to LP conversion (5.2.4 of AMR-WB)
Definition: lsp.c:145
dico2_isf
static const int16_t dico2_isf[256][7]
Definition: amrwbdata.h:951
AMRWBSubFrame::hb_gain
uint16_t hb_gain
high-band energy index (mode 23k85 only)
Definition: amrwbdata.h:73
decode_isf_indices_36b
static void decode_isf_indices_36b(uint16_t *ind, float *isf_q)
Decode quantized ISF vectors using 36-bit indexes (6K60 mode only).
Definition: amrwbdec.c:155
count
void INT64 INT64 count
Definition: avisynth_c.h:767
truncf
static av_always_inline av_const float truncf(float x)
Definition: libm.h:465
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:26
internal.h
AVPacket::data
uint8_t * data
Definition: avcodec.h:1477
data
const char data[16]
Definition: mxf.c:91
AMRWBSubFrame::adap
uint16_t adap
adaptive codebook index
Definition: amrwbdata.h:70
ff_acelp_filter_init
void ff_acelp_filter_init(ACELPFContext *c)
Initialize ACELPFContext.
Definition: acelp_filters.c:148
voice_factor
static float voice_factor(float *p_vector, float p_gain, float *f_vector, float f_gain, CELPMContext *ctx)
Calculate the voicing factor (-1.0 = unvoiced to 1.0 = voiced).
Definition: amrwbdec.c:603
MODE_23k85
@ MODE_23k85
23.85 kbit/s
Definition: amrwbdata.h:60
AMRWBContext::pitch_gain
float pitch_gain[6]
quantified pitch gains for the current and previous five subframes
Definition: amrwbdec.c:69
AMRWBContext::celpm_ctx
CELPMContext celpm_ctx
context for fixed point math operations
Definition: amrwbdec.c:92
UPS_MEM_SIZE
#define UPS_MEM_SIZE
Definition: amrwbdata.h:37
MODE_15k85
@ MODE_15k85
15.85 kbit/s
Definition: amrwbdata.h:56
AV_CODEC_ID_AMR_WB
@ AV_CODEC_ID_AMR_WB
Definition: avcodec.h:548
ff_amrwb_decoder
AVCodec ff_amrwb_decoder
Definition: amrwbdec.c:1270
AMRWB_P_DELAY_MAX
#define AMRWB_P_DELAY_MAX
maximum pitch delay value
Definition: amrwbdata.h:47
AMRWBContext::pitch_lag_int
uint8_t pitch_lag_int
integer part of pitch lag of the previous subframe
Definition: amrwbdec.c:60
mem
int mem
Definition: avisynth_c.h:916
bpf_6_7_coef
static const float bpf_6_7_coef[31]
High-band post-processing FIR filters coefficients from Q15.
Definition: amrwbdata.h:1856
amrwbdec_mips.h
dico23_isf
static const int16_t dico23_isf[128][3]
Definition: amrwbdata.h:1312
AMRWBFrame::isp_id
uint16_t isp_id[7]
index of ISP subvectors
Definition: amrwbdata.h:80
AMRWBContext::fr_quality
uint8_t fr_quality
frame quality index (FQI)
Definition: amrwbdec.c:50
MODE_19k85
@ MODE_19k85
19.85 kbit/s
Definition: amrwbdata.h:58
AMRWBContext::excitation
float * excitation
points to current excitation in excitation_buf[]
Definition: amrwbdec.c:63
AMRWBContext::samples_hb
float samples_hb[LP_ORDER_16k+AMRWB_SFR_SIZE_16k]
high-band samples and memory from synthesis at 16kHz
Definition: amrwbdec.c:80
decode_pitch_lag_low
static void decode_pitch_lag_low(int *lag_int, int *lag_frac, int pitch_index, uint8_t *base_lag_int, int subframe, enum Mode mode)
Decode an adaptive codebook index into pitch lag for 8k85 and 6k60 modes.
Definition: amrwbdec.c:289
update_sub_state
static void update_sub_state(AMRWBContext *ctx)
Update context state before the next subframe.
Definition: amrwbdec.c:1078
AMRWBFrame
Definition: amrwbdata.h:78
BIT_STR
#define BIT_STR(x, lsb, len)
Get x bits in the index interval [lsb,lsb+len-1] inclusive.
Definition: amrwbdec.c:358
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
buf
void * buf
Definition: avisynth_c.h:766
av_cold
#define av_cold
Definition: attributes.h:84
interpolate_isp
static void interpolate_isp(double isp_q[4][LP_ORDER], const double *isp4_past)
Interpolate the fourth ISP vector from current and past frames to obtain an ISP vector for each subfr...
Definition: amrwbdec.c:234
extrapolate_isf
static void extrapolate_isf(float isf[LP_ORDER_16k])
Extrapolate a ISF vector to the 16kHz range (20th order LP) used at mode 6k60 LP filter for the high ...
Definition: amrwbdec.c:928
decode_mime_header
static int decode_mime_header(AMRWBContext *ctx, const uint8_t *buf)
Decode the frame header in the "MIME/storage" format.
Definition: amrwbdec.c:140
Mode
Mode
Frame type (Table 1a in 3GPP TS 26.101)
Definition: amrnbdata.h:39
AMRWBContext::frame
AMRWBFrame frame
AMRWB parameters decoded from bitstream.
Definition: amrwbdec.c:48
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:42
dico21_isf_36b
static const int16_t dico21_isf_36b[128][5]
Definition: amrwbdata.h:1417
AMRWBContext::fixed_vector
float fixed_vector[AMRWB_SFR_SIZE]
algebraic codebook (fixed) vector for current subframe
Definition: amrwbdec.c:66
AMRWBContext::hpf_31_mem
float hpf_31_mem[2]
Definition: amrwbdec.c:82
BIT_POS
#define BIT_POS(x, p)
Get the bit at specified position.
Definition: amrwbdec.c:361
av_lfg_get
static unsigned int av_lfg_get(AVLFG *c)
Get the next random unsigned 32-bit number using an ALFG.
Definition: lfg.h:53
AMRWBContext::lp_coef
float lp_coef[4][LP_ORDER]
Linear Prediction Coefficients from ISP vector.
Definition: amrwbdec.c:57
isf_mean
static const int16_t isf_mean[LP_ORDER]
Means of ISF vectors in Q15.
Definition: amrwbdata.h:1619
energy_pred_fac
static const float energy_pred_fac[4]
4-tap moving average prediction coefficients in reverse order
Definition: amrnbdata.h:1463
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
decode_gains
static void decode_gains(const uint8_t vq_gain, const enum Mode mode, float *fixed_gain_factor, float *pitch_gain)
Decode pitch gain and fixed gain correction factor.
Definition: amrwbdec.c:563
lfg.h
hpf_zeros
static const float hpf_zeros[2]
High-pass filters coefficients for 31 Hz and 400 Hz cutoff.
Definition: amrwbdata.h:1813
MIN_ISF_SPACING
#define MIN_ISF_SPACING
minimum isf gap
Definition: amrwbdata.h:39
ff_acelp_lsf2lspd
void ff_acelp_lsf2lspd(double *lsp, const float *lsf, int lp_order)
Floating point version of ff_acelp_lsf2lsp()
Definition: lsp.c:93
AMRWBSubFrame::ltp
uint16_t ltp
ltp-filtering flag
Definition: amrwbdata.h:71
AMRWBContext::fr_cur_mode
enum Mode fr_cur_mode
mode index of current frame
Definition: amrwbdec.c:49
ctx
AVFormatContext * ctx
Definition: movenc.c:48
amr_bit_orderings_by_mode
static const uint16_t *const amr_bit_orderings_by_mode[]
Reordering array addresses for each mode.
Definition: amrwbdata.h:676
pitch_sharpening
static void pitch_sharpening(AMRWBContext *ctx, float *fixed_vector)
Apply pitch sharpening filters to the fixed codebook vector.
Definition: amrwbdec.c:581
MODE_8k85
@ MODE_8k85
8.85 kbit/s
Definition: amrwbdata.h:53
f
#define f(width, name)
Definition: cbs_vp9.c:255
scaled_hb_excitation
static void scaled_hb_excitation(AMRWBContext *ctx, float *hb_exc, const float *synth_exc, float hb_gain)
Generate the high-band excitation with the same energy from the lower one and scaled by the given gai...
Definition: amrwbdec.c:890
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
AMRWBContext::samples_up
float samples_up[UPS_MEM_SIZE+AMRWB_SFR_SIZE]
low-band samples and memory processed for upsampling
Definition: amrwbdec.c:79
MODE_SID
@ MODE_SID
comfort noise frame
Definition: amrwbdata.h:61
AMRWBSubFrame::vq_gain
uint16_t vq_gain
VQ adaptive and innovative gains.
Definition: amrwbdata.h:72
qua_gain_7b
static const int16_t qua_gain_7b[128][2]
Definition: amrwbdata.h:1698
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
MODE_12k65
@ MODE_12k65
12.65 kbit/s
Definition: amrwbdata.h:54
cf_sizes_wb
static const uint16_t cf_sizes_wb[]
Core frame sizes in each mode.
Definition: amrwbdata.h:1885
AMRWBSubFrame
Definition: amrwbdata.h:69
ir_filters_lookup
static const float *const ir_filters_lookup[2]
Definition: amrnbdata.h:1658
AMRWBContext::lpf_7_mem
float lpf_7_mem[HB_FIR_SIZE]
previous values in the high-band low pass filter
Definition: amrwbdec.c:85
hpf_31_poles
static const float hpf_31_poles[2]
Definition: amrwbdata.h:1814
AMRWB_SFR_SIZE
#define AMRWB_SFR_SIZE
samples per subframe at 12.8 kHz
Definition: amrwbdata.h:45
dico21_isf
static const int16_t dico21_isf[64][3]
Definition: amrwbdata.h:1210
AMRWB_SFR_SIZE_16k
#define AMRWB_SFR_SIZE_16k
samples per subframe at 16 kHz
Definition: amrwbdata.h:46
dico25_isf
static const int16_t dico25_isf[32][4]
Definition: amrwbdata.h:1398
dico23_isf_36b
static const int16_t dico23_isf_36b[64][7]
Definition: amrwbdata.h:1551
celp_filters.h
noise_enhancer
static float noise_enhancer(float fixed_gain, float *prev_tr_gain, float voice_fac, float stab_fac)
Apply a non-linear fixed gain smoothing in order to reduce fluctuation in the energy of excitation.
Definition: amrwbdec.c:715
pulses_nb_per_mode_tr
static const uint8_t pulses_nb_per_mode_tr[][4]
[i][j] is the number of pulses present in track j at mode i
Definition: amrwbdata.h:1656
auto_correlation
static float auto_correlation(float *diff_isf, float mean, int lag)
Calculate the auto-correlation for the ISF difference vector.
Definition: amrwbdec.c:909
AMRWB_P_DELAY_MIN
#define AMRWB_P_DELAY_MIN
Definition: amrwbdata.h:48
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
float_dsp.h
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
ACELPVContext
Definition: acelp_vectors.h:28
AMRWBContext::prng
AVLFG prng
random number generator for white noise excitation
Definition: amrwbdec.c:87
ACELPFContext
Definition: acelp_filters.h:28
ff_acelp_vectors_init
void ff_acelp_vectors_init(ACELPVContext *c)
Initialize ACELPVContext.
Definition: acelp_vectors.c:268
AVLFG
Context structure for the Lagged Fibonacci PRNG.
Definition: lfg.h:33
ff_celp_math_init
void ff_celp_math_init(CELPMContext *c)
Initialize CELPMContext.
Definition: celp_math.c:120
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1965
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:981
AVPacket::size
int size
Definition: avcodec.h:1478
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:188
AMRWBContext::first_frame
uint8_t first_frame
flag active during decoding of the first frame
Definition: amrwbdec.c:88
find_hb_gain
static float find_hb_gain(AMRWBContext *ctx, const float *synth, uint16_t hb_idx, uint8_t vad)
Calculate the high-band gain based on encoded index (23k85 mode) or on the low-band speech signal and...
Definition: amrwbdec.c:860
ENERGY_MEAN
#define ENERGY_MEAN
mean innovation energy (dB) in all modes
Definition: amrwbdata.h:42
CELPFContext
Definition: celp_filters.h:28
LP_ORDER_16k
#define LP_ORDER_16k
lpc filter order at 16kHz
Definition: amrwbdata.h:34
hpf_31_gain
static const float hpf_31_gain
Definition: amrwbdata.h:1815
de_emphasis
static void de_emphasis(float *out, float *in, float m, float mem[1])
Apply to synthesis a de-emphasis filter of the form: H(z) = 1 / (1 - m * z^-1)
Definition: amrwbdec.c:807
FFMAX
#define FFMAX(a, b)
Definition: common.h:94
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2233
decode_5p_track
static void decode_5p_track(int *out, int code, int m, int off)
code: 5m bits
Definition: amrwbdec.c:438
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
hb_fir_filter
static void hb_fir_filter(float *out, const float fir_coef[HB_FIR_SIZE+1], float mem[HB_FIR_SIZE], const float *in)
Apply a 15th order filter to high-band samples.
Definition: amrwbdec.c:1056
AMRWBContext::pitch_vector
float pitch_vector[AMRWB_SFR_SIZE]
adaptive codebook (pitch) vector for current subframe
Definition: amrwbdec.c:65
celp_math.h
AMRWBContext::hpf_400_mem
float hpf_400_mem[2]
previous values in the high pass filters
Definition: amrwbdec.c:82
size
int size
Definition: twinvq_data.h:11134
dico22_isf_36b
static const int16_t dico22_isf_36b[128][4]
Definition: amrwbdata.h:1484
avpriv_report_missing_feature
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
AMRWBContext::acelpf_ctx
ACELPFContext acelpf_ctx
context for filters for ACELP-based codecs
Definition: amrwbdec.c:89
dico24_isf
static const int16_t dico24_isf[32][3]
Definition: amrwbdata.h:1379
decode_pitch_lag_high
static void decode_pitch_lag_high(int *lag_int, int *lag_frac, int pitch_index, uint8_t *base_lag_int, int subframe)
Decode an adaptive codebook index into pitch lag (except 6k60, 8k85 modes).
Definition: amrwbdec.c:256
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
isf_init
static const int16_t isf_init[LP_ORDER]
Initialization tables for the processed ISF vector in Q15.
Definition: amrwbdata.h:1625
stability_factor
static float stability_factor(const float *isf, const float *isf_past)
Calculate a stability factor {teta} based on distance between current and past isf.
Definition: amrwbdec.c:691
AMRWBFrame::vad
uint16_t vad
voice activity detection flag
Definition: amrwbdata.h:79
ff_celp_filter_init
void ff_celp_filter_init(CELPFContext *c)
Initialize CELPFContext.
Definition: celp_filters.c:212
AMRWBContext::isf_past_final
float isf_past_final[LP_ORDER]
final processed ISF vector of the previous frame
Definition: amrwbdec.c:53
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:2226
AMRWBContext::fixed_gain
float fixed_gain[2]
quantified fixed gains for the current and previous subframes
Definition: amrwbdec.c:70
isf_add_mean_and_past
static void isf_add_mean_and_past(float *isf_q, float *isf_past)
Apply mean and past ISF values using the prediction factor.
Definition: amrwbdec.c:214
in
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
Definition: audio_convert.c:326
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
common.h
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
AMRWBContext::bpf_6_7_mem
float bpf_6_7_mem[HB_FIR_SIZE]
previous values in the high-band band pass filter
Definition: amrwbdec.c:84
uint8_t
uint8_t
Definition: audio_convert.c:194
acelp_filters.h
MODE_23k05
@ MODE_23k05
23.05 kbit/s
Definition: amrwbdata.h:59
AVCodec::name
const char * name
Name of the codec implementation.
Definition: avcodec.h:3488
amr.h
avcodec.h
decode_4p_track
static void decode_4p_track(int *out, int code, int m, int off)
code: 4m bits
Definition: amrwbdec.c:402
AMRWBContext::isp
double isp[4][LP_ORDER]
ISP vectors from current frame.
Definition: amrwbdec.c:54
lpf_7_coef
static const float lpf_7_coef[31]
Definition: amrwbdata.h:1870
ret
ret
Definition: filter_design.txt:187
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
lsp.h
hb_synthesis
static void hb_synthesis(AMRWBContext *ctx, int subframe, float *samples, const float *exc, const float *isf, const float *isf_past)
Conduct 20th order linear predictive coding synthesis for the high frequency band excitation at 16kHz...
Definition: amrwbdec.c:1015
ac_inter
static const float ac_inter[65]
Coefficients for FIR interpolation of excitation vector at pitch lag resulting the adaptive codebook ...
Definition: amrwbdata.h:1635
CELPMContext
Definition: celp_math.h:28
AMRWBSubFrame::pul_ih
uint16_t pul_ih[4]
MSBs part of codebook index (high modes only)
Definition: amrwbdata.h:74
ff_celp_circ_addf
void ff_celp_circ_addf(float *out, const float *in, const float *lagged, int lag, float fac, int n)
Add an array to a rotated array.
Definition: celp_filters.c:50
AVCodecContext
main external API structure.
Definition: avcodec.h:1565
channel_layout.h
AMRWBContext
Definition: amrwbdec.c:47
anti_sparseness
static float * anti_sparseness(AMRWBContext *ctx, float *fixed_vector, float *buf)
Reduce fixed vector sparseness by smoothing with one of three IR filters, also known as "adaptive pha...
Definition: amrwbdec.c:627
hpf_400_gain
static const float hpf_400_gain
Definition: amrwbdata.h:1818
mode
mode
Definition: ebur128.h:83
decode_isf_indices_46b
static void decode_isf_indices_46b(uint16_t *ind, float *isf_q)
Decode quantized ISF vectors using 46-bit indexes (except 6K60 mode).
Definition: amrwbdec.c:181
AMRWBContext::isf_cur
float isf_cur[LP_ORDER]
working ISF vector from current frame
Definition: amrwbdec.c:51
amrwbdata.h
samples
Filter the word “frame” indicates either a video frame or a group of audio samples
Definition: filter_design.txt:8
isfp_inter
static const float isfp_inter[4]
ISF/ISP interpolation coefficients for each subframe.
Definition: amrwbdata.h:1631
ff_amr_bit_reorder
static void ff_amr_bit_reorder(uint16_t *out, int size, const uint8_t *data, const R_TABLE_TYPE *ord_table)
Fill the frame structure variables from bitstream by parsing the given reordering table that uses the...
Definition: amr.h:51
LP_ORDER
#define LP_ORDER
linear predictive coding filter order
Definition: amrwbdata.h:33
decode_3p_track
static void decode_3p_track(int *out, int code, int m, int off)
code: 3m+1 bits
Definition: amrwbdec.c:393
AMRWBContext::prev_tr_gain
float prev_tr_gain
previous initial gain used by noise enhancer for threshold
Definition: amrwbdec.c:76
decode_fixed_vector
static void decode_fixed_vector(float *fixed_vector, const uint16_t *pulse_hi, const uint16_t *pulse_lo, const enum Mode mode)
Decode the algebraic codebook index to pulse positions and signs, then construct the algebraic codebo...
Definition: amrwbdec.c:492
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:39
AMRWBContext::prediction_error
float prediction_error[4]
quantified prediction errors {20log10(^gamma_gc)} for previous four subframes
Definition: amrwbdec.c:68
decode_1p_track
static void decode_1p_track(int *out, int code, int m, int off)
The next six functions decode_[i]p_track decode exactly i pulses positions and amplitudes (-1 or 1) i...
Definition: amrwbdec.c:376
synthesis
static void synthesis(AMRWBContext *ctx, float *lpc, float *excitation, float fixed_gain, const float *fixed_vector, float *samples)
Conduct 16th order linear predictive coding synthesis from excitation.
Definition: amrwbdec.c:770
AVPacket
This structure stores compressed data.
Definition: avcodec.h:1454
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:1592
AMRWBContext::excitation_buf
float excitation_buf[AMRWB_P_DELAY_MAX+LP_ORDER+2+AMRWB_SFR_SIZE]
current excitation and all necessary excitation history
Definition: amrwbdec.c:62
HB_FIR_SIZE
#define HB_FIR_SIZE
amount of past data needed by HB filters
Definition: amrwbdata.h:35
MODE_18k25
@ MODE_18k25
18.25 kbit/s
Definition: amrwbdata.h:57
amrwb_decode_init
static av_cold int amrwb_decode_init(AVCodecContext *avctx)
Definition: amrwbdec.c:96
dico1_isf
static const int16_t dico1_isf[256][9]
Indexed tables for retrieval of quantized ISF vectors in Q15.
Definition: amrwbdata.h:692
decode_6p_track
static void decode_6p_track(int *out, int code, int m, int off)
code: 6m-2 bits
Definition: amrwbdec.c:448
ff_scale_vector_to_given_sum_of_squares
void ff_scale_vector_to_given_sum_of_squares(float *out, const float *in, float sum_of_squares, const int n)
Set the sum of squares of a signal by scaling.
Definition: acelp_vectors.c:224
AMRWBFrame::subframe
AMRWBSubFrame subframe[4]
data for subframes
Definition: amrwbdata.h:81
AMRWBContext::isf_q_past
float isf_q_past[LP_ORDER]
quantized ISF vector of the previous frame
Definition: amrwbdec.c:52
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
MIN_ENERGY
#define MIN_ENERGY
Initial energy in dB.
Definition: amrnbdec.c:84
MODE_14k25
@ MODE_14k25
14.25 kbit/s
Definition: amrwbdata.h:55
qua_gain_6b
static const int16_t qua_gain_6b[64][2]
Tables for decoding quantized gains { pitch (Q14), fixed factor (Q11) }.
Definition: amrwbdata.h:1663
AMRWBSubFrame::pul_il
uint16_t pul_il[4]
LSBs part of codebook index.
Definition: amrwbdata.h:75
upsample_5_4
static void upsample_5_4(float *out, const float *in, int o_size, CELPMContext *ctx)
Upsample a signal by 5/4 ratio (from 12.8kHz to 16kHz) using a FIR interpolation filter.
Definition: amrwbdec.c:828
AMRWBContext::acelpv_ctx
ACELPVContext acelpv_ctx
context for vector operations for ACELP-based codecs
Definition: amrwbdec.c:90
PRED_FACTOR
#define PRED_FACTOR
Definition: amrwbdata.h:40
int
int
Definition: ffmpeg_filter.c:191
AMRWBContext::tilt_coef
float tilt_coef
{beta_1} related to the voicing of the previous subframe
Definition: amrwbdec.c:72
decode_pitch_vector
static void decode_pitch_vector(AMRWBContext *ctx, const AMRWBSubFrame *amr_subframe, const int subframe)
Find the pitch vector by interpolating the past excitation at the pitch delay, which is obtained in t...
Definition: amrwbdec.c:318
AV_SAMPLE_FMT_FLT
@ AV_SAMPLE_FMT_FLT
float
Definition: samplefmt.h:63
AMRWBContext::celpf_ctx
CELPFContext celpf_ctx
context for filters for CELP-based codecs
Definition: amrwbdec.c:91
hpf_400_poles
static const float hpf_400_poles[2]
Definition: amrwbdata.h:1817
ff_set_min_dist_lsf
void ff_set_min_dist_lsf(float *lsf, double min_spacing, int size)
Adjust the quantized LSFs so they are increasing and not too close.
Definition: lsp.c:51
PREEMPH_FAC
#define PREEMPH_FAC
factor used to de-emphasize synthesis
Definition: amrwbdata.h:43
acelp_pitch_delay.h