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