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