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 Libav.
6  *
7  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
28 #include "libavutil/common.h"
29 #include "libavutil/lfg.h"
30 
31 #include "avcodec.h"
32 #include "dsputil.h"
33 #include "lsp.h"
34 #include "celp_filters.h"
35 #include "acelp_filters.h"
36 #include "acelp_vectors.h"
37 #include "acelp_pitch_delay.h"
38 #include "internal.h"
39 
40 #define AMR_USE_16BIT_TABLES
41 #include "amr.h"
42 
43 #include "amrwbdata.h"
44 
45 typedef struct {
48  enum Mode fr_cur_mode;
50  float isf_cur[LP_ORDER];
51  float isf_q_past[LP_ORDER];
52  float isf_past_final[LP_ORDER];
53  double isp[4][LP_ORDER];
54  double isp_sub4_past[LP_ORDER];
55 
56  float lp_coef[4][LP_ORDER];
57 
60 
61  float excitation_buf[AMRWB_P_DELAY_MAX + LP_ORDER + 2 + AMRWB_SFR_SIZE];
62  float *excitation;
63 
64  float pitch_vector[AMRWB_SFR_SIZE];
65  float fixed_vector[AMRWB_SFR_SIZE];
66 
67  float prediction_error[4];
68  float pitch_gain[6];
69  float fixed_gain[2];
70 
71  float tilt_coef;
72 
75  float prev_tr_gain;
76 
77  float samples_az[LP_ORDER + AMRWB_SFR_SIZE];
78  float samples_up[UPS_MEM_SIZE + AMRWB_SFR_SIZE];
79  float samples_hb[LP_ORDER_16k + AMRWB_SFR_SIZE_16k];
80 
81  float hpf_31_mem[2], hpf_400_mem[2];
82  float demph_mem[1];
83  float bpf_6_7_mem[HB_FIR_SIZE];
84  float lpf_7_mem[HB_FIR_SIZE];
85 
88 } AMRWBContext;
89 
91 {
92  AMRWBContext *ctx = avctx->priv_data;
93  int i;
94 
95  if (avctx->channels > 1) {
96  av_log_missing_feature(avctx, "multi-channel AMR", 0);
97  return AVERROR_PATCHWELCOME;
98  }
99 
100  avctx->channels = 1;
102  avctx->sample_rate = 16000;
103  avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
104 
105  av_lfg_init(&ctx->prng, 1);
106 
108  ctx->first_frame = 1;
109 
110  for (i = 0; i < LP_ORDER; i++)
111  ctx->isf_past_final[i] = isf_init[i] * (1.0f / (1 << 15));
112 
113  for (i = 0; i < 4; i++)
114  ctx->prediction_error[i] = MIN_ENERGY;
115 
117  avctx->coded_frame = &ctx->avframe;
118 
119  return 0;
120 }
121 
131 static int decode_mime_header(AMRWBContext *ctx, const uint8_t *buf)
132 {
133  /* Decode frame header (1st octet) */
134  ctx->fr_cur_mode = buf[0] >> 3 & 0x0F;
135  ctx->fr_quality = (buf[0] & 0x4) == 0x4;
136 
137  return 1;
138 }
139 
147 static void decode_isf_indices_36b(uint16_t *ind, float *isf_q)
148 {
149  int i;
150 
151  for (i = 0; i < 9; i++)
152  isf_q[i] = dico1_isf[ind[0]][i] * (1.0f / (1 << 15));
153 
154  for (i = 0; i < 7; i++)
155  isf_q[i + 9] = dico2_isf[ind[1]][i] * (1.0f / (1 << 15));
156 
157  for (i = 0; i < 5; i++)
158  isf_q[i] += dico21_isf_36b[ind[2]][i] * (1.0f / (1 << 15));
159 
160  for (i = 0; i < 4; i++)
161  isf_q[i + 5] += dico22_isf_36b[ind[3]][i] * (1.0f / (1 << 15));
162 
163  for (i = 0; i < 7; i++)
164  isf_q[i + 9] += dico23_isf_36b[ind[4]][i] * (1.0f / (1 << 15));
165 }
166 
174 static void decode_isf_indices_46b(uint16_t *ind, float *isf_q)
175 {
176  int i;
177 
178  for (i = 0; i < 9; i++)
179  isf_q[i] = dico1_isf[ind[0]][i] * (1.0f / (1 << 15));
180 
181  for (i = 0; i < 7; i++)
182  isf_q[i + 9] = dico2_isf[ind[1]][i] * (1.0f / (1 << 15));
183 
184  for (i = 0; i < 3; i++)
185  isf_q[i] += dico21_isf[ind[2]][i] * (1.0f / (1 << 15));
186 
187  for (i = 0; i < 3; i++)
188  isf_q[i + 3] += dico22_isf[ind[3]][i] * (1.0f / (1 << 15));
189 
190  for (i = 0; i < 3; i++)
191  isf_q[i + 6] += dico23_isf[ind[4]][i] * (1.0f / (1 << 15));
192 
193  for (i = 0; i < 3; i++)
194  isf_q[i + 9] += dico24_isf[ind[5]][i] * (1.0f / (1 << 15));
195 
196  for (i = 0; i < 4; i++)
197  isf_q[i + 12] += dico25_isf[ind[6]][i] * (1.0f / (1 << 15));
198 }
199 
208 static void isf_add_mean_and_past(float *isf_q, float *isf_past)
209 {
210  int i;
211  float tmp;
212 
213  for (i = 0; i < LP_ORDER; i++) {
214  tmp = isf_q[i];
215  isf_q[i] += isf_mean[i] * (1.0f / (1 << 15));
216  isf_q[i] += PRED_FACTOR * isf_past[i];
217  isf_past[i] = tmp;
218  }
219 }
220 
228 static void interpolate_isp(double isp_q[4][LP_ORDER], const double *isp4_past)
229 {
230  int i, k;
231 
232  for (k = 0; k < 3; k++) {
233  float c = isfp_inter[k];
234  for (i = 0; i < LP_ORDER; i++)
235  isp_q[k][i] = (1.0 - c) * isp4_past[i] + c * isp_q[3][i];
236  }
237 }
238 
250 static void decode_pitch_lag_high(int *lag_int, int *lag_frac, int pitch_index,
251  uint8_t *base_lag_int, int subframe)
252 {
253  if (subframe == 0 || subframe == 2) {
254  if (pitch_index < 376) {
255  *lag_int = (pitch_index + 137) >> 2;
256  *lag_frac = pitch_index - (*lag_int << 2) + 136;
257  } else if (pitch_index < 440) {
258  *lag_int = (pitch_index + 257 - 376) >> 1;
259  *lag_frac = (pitch_index - (*lag_int << 1) + 256 - 376) << 1;
260  /* the actual resolution is 1/2 but expressed as 1/4 */
261  } else {
262  *lag_int = pitch_index - 280;
263  *lag_frac = 0;
264  }
265  /* minimum lag for next subframe */
266  *base_lag_int = av_clip(*lag_int - 8 - (*lag_frac < 0),
268  // XXX: the spec states clearly that *base_lag_int should be
269  // the nearest integer to *lag_int (minus 8), but the ref code
270  // actually always uses its floor, I'm following the latter
271  } else {
272  *lag_int = (pitch_index + 1) >> 2;
273  *lag_frac = pitch_index - (*lag_int << 2);
274  *lag_int += *base_lag_int;
275  }
276 }
277 
283 static void decode_pitch_lag_low(int *lag_int, int *lag_frac, int pitch_index,
284  uint8_t *base_lag_int, int subframe, enum Mode mode)
285 {
286  if (subframe == 0 || (subframe == 2 && mode != MODE_6k60)) {
287  if (pitch_index < 116) {
288  *lag_int = (pitch_index + 69) >> 1;
289  *lag_frac = (pitch_index - (*lag_int << 1) + 68) << 1;
290  } else {
291  *lag_int = pitch_index - 24;
292  *lag_frac = 0;
293  }
294  // XXX: same problem as before
295  *base_lag_int = av_clip(*lag_int - 8 - (*lag_frac < 0),
297  } else {
298  *lag_int = (pitch_index + 1) >> 1;
299  *lag_frac = (pitch_index - (*lag_int << 1)) << 1;
300  *lag_int += *base_lag_int;
301  }
302 }
303 
313  const AMRWBSubFrame *amr_subframe,
314  const int subframe)
315 {
316  int pitch_lag_int, pitch_lag_frac;
317  int i;
318  float *exc = ctx->excitation;
319  enum Mode mode = ctx->fr_cur_mode;
320 
321  if (mode <= MODE_8k85) {
322  decode_pitch_lag_low(&pitch_lag_int, &pitch_lag_frac, amr_subframe->adap,
323  &ctx->base_pitch_lag, subframe, mode);
324  } else
325  decode_pitch_lag_high(&pitch_lag_int, &pitch_lag_frac, amr_subframe->adap,
326  &ctx->base_pitch_lag, subframe);
327 
328  ctx->pitch_lag_int = pitch_lag_int;
329  pitch_lag_int += pitch_lag_frac > 0;
330 
331  /* Calculate the pitch vector by interpolating the past excitation at the
332  pitch lag using a hamming windowed sinc function */
333  ff_acelp_interpolatef(exc, exc + 1 - pitch_lag_int,
334  ac_inter, 4,
335  pitch_lag_frac + (pitch_lag_frac > 0 ? 0 : 4),
336  LP_ORDER, AMRWB_SFR_SIZE + 1);
337 
338  /* Check which pitch signal path should be used
339  * 6k60 and 8k85 modes have the ltp flag set to 0 */
340  if (amr_subframe->ltp) {
341  memcpy(ctx->pitch_vector, exc, AMRWB_SFR_SIZE * sizeof(float));
342  } else {
343  for (i = 0; i < AMRWB_SFR_SIZE; i++)
344  ctx->pitch_vector[i] = 0.18 * exc[i - 1] + 0.64 * exc[i] +
345  0.18 * exc[i + 1];
346  memcpy(exc, ctx->pitch_vector, AMRWB_SFR_SIZE * sizeof(float));
347  }
348 }
349 
351 #define BIT_STR(x,lsb,len) (((x) >> (lsb)) & ((1 << (len)) - 1))
352 
354 #define BIT_POS(x, p) (((x) >> (p)) & 1)
355 
369 static inline void decode_1p_track(int *out, int code, int m, int off)
370 {
371  int pos = BIT_STR(code, 0, m) + off;
372 
373  out[0] = BIT_POS(code, m) ? -pos : pos;
374 }
375 
376 static inline void decode_2p_track(int *out, int code, int m, int off)
377 {
378  int pos0 = BIT_STR(code, m, m) + off;
379  int pos1 = BIT_STR(code, 0, m) + off;
380 
381  out[0] = BIT_POS(code, 2*m) ? -pos0 : pos0;
382  out[1] = BIT_POS(code, 2*m) ? -pos1 : pos1;
383  out[1] = pos0 > pos1 ? -out[1] : out[1];
384 }
385 
386 static void decode_3p_track(int *out, int code, int m, int off)
387 {
388  int half_2p = BIT_POS(code, 2*m - 1) << (m - 1);
389 
390  decode_2p_track(out, BIT_STR(code, 0, 2*m - 1),
391  m - 1, off + half_2p);
392  decode_1p_track(out + 2, BIT_STR(code, 2*m, m + 1), m, off);
393 }
394 
395 static void decode_4p_track(int *out, int code, int m, int off)
396 {
397  int half_4p, subhalf_2p;
398  int b_offset = 1 << (m - 1);
399 
400  switch (BIT_STR(code, 4*m - 2, 2)) { /* case ID (2 bits) */
401  case 0: /* 0 pulses in A, 4 pulses in B or vice versa */
402  half_4p = BIT_POS(code, 4*m - 3) << (m - 1); // which has 4 pulses
403  subhalf_2p = BIT_POS(code, 2*m - 3) << (m - 2);
404 
405  decode_2p_track(out, BIT_STR(code, 0, 2*m - 3),
406  m - 2, off + half_4p + subhalf_2p);
407  decode_2p_track(out + 2, BIT_STR(code, 2*m - 2, 2*m - 1),
408  m - 1, off + half_4p);
409  break;
410  case 1: /* 1 pulse in A, 3 pulses in B */
411  decode_1p_track(out, BIT_STR(code, 3*m - 2, m),
412  m - 1, off);
413  decode_3p_track(out + 1, BIT_STR(code, 0, 3*m - 2),
414  m - 1, off + b_offset);
415  break;
416  case 2: /* 2 pulses in each half */
417  decode_2p_track(out, BIT_STR(code, 2*m - 1, 2*m - 1),
418  m - 1, off);
419  decode_2p_track(out + 2, BIT_STR(code, 0, 2*m - 1),
420  m - 1, off + b_offset);
421  break;
422  case 3: /* 3 pulses in A, 1 pulse in B */
423  decode_3p_track(out, BIT_STR(code, m, 3*m - 2),
424  m - 1, off);
425  decode_1p_track(out + 3, BIT_STR(code, 0, m),
426  m - 1, off + b_offset);
427  break;
428  }
429 }
430 
431 static void decode_5p_track(int *out, int code, int m, int off)
432 {
433  int half_3p = BIT_POS(code, 5*m - 1) << (m - 1);
434 
435  decode_3p_track(out, BIT_STR(code, 2*m + 1, 3*m - 2),
436  m - 1, off + half_3p);
437 
438  decode_2p_track(out + 3, BIT_STR(code, 0, 2*m + 1), m, off);
439 }
440 
441 static void decode_6p_track(int *out, int code, int m, int off)
442 {
443  int b_offset = 1 << (m - 1);
444  /* which half has more pulses in cases 0 to 2 */
445  int half_more = BIT_POS(code, 6*m - 5) << (m - 1);
446  int half_other = b_offset - half_more;
447 
448  switch (BIT_STR(code, 6*m - 4, 2)) { /* case ID (2 bits) */
449  case 0: /* 0 pulses in A, 6 pulses in B or vice versa */
450  decode_1p_track(out, BIT_STR(code, 0, m),
451  m - 1, off + half_more);
452  decode_5p_track(out + 1, BIT_STR(code, m, 5*m - 5),
453  m - 1, off + half_more);
454  break;
455  case 1: /* 1 pulse in A, 5 pulses in B or vice versa */
456  decode_1p_track(out, BIT_STR(code, 0, m),
457  m - 1, off + half_other);
458  decode_5p_track(out + 1, BIT_STR(code, m, 5*m - 5),
459  m - 1, off + half_more);
460  break;
461  case 2: /* 2 pulses in A, 4 pulses in B or vice versa */
462  decode_2p_track(out, BIT_STR(code, 0, 2*m - 1),
463  m - 1, off + half_other);
464  decode_4p_track(out + 2, BIT_STR(code, 2*m - 1, 4*m - 4),
465  m - 1, off + half_more);
466  break;
467  case 3: /* 3 pulses in A, 3 pulses in B */
468  decode_3p_track(out, BIT_STR(code, 3*m - 2, 3*m - 2),
469  m - 1, off);
470  decode_3p_track(out + 3, BIT_STR(code, 0, 3*m - 2),
471  m - 1, off + b_offset);
472  break;
473  }
474 }
475 
485 static void decode_fixed_vector(float *fixed_vector, const uint16_t *pulse_hi,
486  const uint16_t *pulse_lo, const enum Mode mode)
487 {
488  /* sig_pos stores for each track the decoded pulse position indexes
489  * (1-based) multiplied by its corresponding amplitude (+1 or -1) */
490  int sig_pos[4][6];
491  int spacing = (mode == MODE_6k60) ? 2 : 4;
492  int i, j;
493 
494  switch (mode) {
495  case MODE_6k60:
496  for (i = 0; i < 2; i++)
497  decode_1p_track(sig_pos[i], pulse_lo[i], 5, 1);
498  break;
499  case MODE_8k85:
500  for (i = 0; i < 4; i++)
501  decode_1p_track(sig_pos[i], pulse_lo[i], 4, 1);
502  break;
503  case MODE_12k65:
504  for (i = 0; i < 4; i++)
505  decode_2p_track(sig_pos[i], pulse_lo[i], 4, 1);
506  break;
507  case MODE_14k25:
508  for (i = 0; i < 2; i++)
509  decode_3p_track(sig_pos[i], pulse_lo[i], 4, 1);
510  for (i = 2; i < 4; i++)
511  decode_2p_track(sig_pos[i], pulse_lo[i], 4, 1);
512  break;
513  case MODE_15k85:
514  for (i = 0; i < 4; i++)
515  decode_3p_track(sig_pos[i], pulse_lo[i], 4, 1);
516  break;
517  case MODE_18k25:
518  for (i = 0; i < 4; i++)
519  decode_4p_track(sig_pos[i], (int) pulse_lo[i] +
520  ((int) pulse_hi[i] << 14), 4, 1);
521  break;
522  case MODE_19k85:
523  for (i = 0; i < 2; i++)
524  decode_5p_track(sig_pos[i], (int) pulse_lo[i] +
525  ((int) pulse_hi[i] << 10), 4, 1);
526  for (i = 2; i < 4; i++)
527  decode_4p_track(sig_pos[i], (int) pulse_lo[i] +
528  ((int) pulse_hi[i] << 14), 4, 1);
529  break;
530  case MODE_23k05:
531  case MODE_23k85:
532  for (i = 0; i < 4; i++)
533  decode_6p_track(sig_pos[i], (int) pulse_lo[i] +
534  ((int) pulse_hi[i] << 11), 4, 1);
535  break;
536  }
537 
538  memset(fixed_vector, 0, sizeof(float) * AMRWB_SFR_SIZE);
539 
540  for (i = 0; i < 4; i++)
541  for (j = 0; j < pulses_nb_per_mode_tr[mode][i]; j++) {
542  int pos = (FFABS(sig_pos[i][j]) - 1) * spacing + i;
543 
544  fixed_vector[pos] += sig_pos[i][j] < 0 ? -1.0 : 1.0;
545  }
546 }
547 
556 static void decode_gains(const uint8_t vq_gain, const enum Mode mode,
557  float *fixed_gain_factor, float *pitch_gain)
558 {
559  const int16_t *gains = (mode <= MODE_8k85 ? qua_gain_6b[vq_gain] :
560  qua_gain_7b[vq_gain]);
561 
562  *pitch_gain = gains[0] * (1.0f / (1 << 14));
563  *fixed_gain_factor = gains[1] * (1.0f / (1 << 11));
564 }
565 
572 // XXX: Spec states this procedure should be applied when the pitch
573 // lag is less than 64, but this checking seems absent in reference and AMR-NB
574 static void pitch_sharpening(AMRWBContext *ctx, float *fixed_vector)
575 {
576  int i;
577 
578  /* Tilt part */
579  for (i = AMRWB_SFR_SIZE - 1; i != 0; i--)
580  fixed_vector[i] -= fixed_vector[i - 1] * ctx->tilt_coef;
581 
582  /* Periodicity enhancement part */
583  for (i = ctx->pitch_lag_int; i < AMRWB_SFR_SIZE; i++)
584  fixed_vector[i] += fixed_vector[i - ctx->pitch_lag_int] * 0.85;
585 }
586 
593 // XXX: There is something wrong with the precision here! The magnitudes
594 // of the energies are not correct. Please check the reference code carefully
595 static float voice_factor(float *p_vector, float p_gain,
596  float *f_vector, float f_gain)
597 {
598  double p_ener = (double) ff_scalarproduct_float_c(p_vector, p_vector,
599  AMRWB_SFR_SIZE) *
600  p_gain * p_gain;
601  double f_ener = (double) ff_scalarproduct_float_c(f_vector, f_vector,
602  AMRWB_SFR_SIZE) *
603  f_gain * f_gain;
604 
605  return (p_ener - f_ener) / (p_ener + f_ener);
606 }
607 
618 static float *anti_sparseness(AMRWBContext *ctx,
619  float *fixed_vector, float *buf)
620 {
621  int ir_filter_nr;
622 
623  if (ctx->fr_cur_mode > MODE_8k85) // no filtering in higher modes
624  return fixed_vector;
625 
626  if (ctx->pitch_gain[0] < 0.6) {
627  ir_filter_nr = 0; // strong filtering
628  } else if (ctx->pitch_gain[0] < 0.9) {
629  ir_filter_nr = 1; // medium filtering
630  } else
631  ir_filter_nr = 2; // no filtering
632 
633  /* detect 'onset' */
634  if (ctx->fixed_gain[0] > 3.0 * ctx->fixed_gain[1]) {
635  if (ir_filter_nr < 2)
636  ir_filter_nr++;
637  } else {
638  int i, count = 0;
639 
640  for (i = 0; i < 6; i++)
641  if (ctx->pitch_gain[i] < 0.6)
642  count++;
643 
644  if (count > 2)
645  ir_filter_nr = 0;
646 
647  if (ir_filter_nr > ctx->prev_ir_filter_nr + 1)
648  ir_filter_nr--;
649  }
650 
651  /* update ir filter strength history */
652  ctx->prev_ir_filter_nr = ir_filter_nr;
653 
654  ir_filter_nr += (ctx->fr_cur_mode == MODE_8k85);
655 
656  if (ir_filter_nr < 2) {
657  int i;
658  const float *coef = ir_filters_lookup[ir_filter_nr];
659 
660  /* Circular convolution code in the reference
661  * decoder was modified to avoid using one
662  * extra array. The filtered vector is given by:
663  *
664  * c2(n) = sum(i,0,len-1){ c(i) * coef( (n - i + len) % len ) }
665  */
666 
667  memset(buf, 0, sizeof(float) * AMRWB_SFR_SIZE);
668  for (i = 0; i < AMRWB_SFR_SIZE; i++)
669  if (fixed_vector[i])
670  ff_celp_circ_addf(buf, buf, coef, i, fixed_vector[i],
671  AMRWB_SFR_SIZE);
672  fixed_vector = buf;
673  }
674 
675  return fixed_vector;
676 }
677 
682 static float stability_factor(const float *isf, const float *isf_past)
683 {
684  int i;
685  float acc = 0.0;
686 
687  for (i = 0; i < LP_ORDER - 1; i++)
688  acc += (isf[i] - isf_past[i]) * (isf[i] - isf_past[i]);
689 
690  // XXX: This part is not so clear from the reference code
691  // the result is more accurate changing the "/ 256" to "* 512"
692  return FFMAX(0.0, 1.25 - acc * 0.8 * 512);
693 }
694 
706 static float noise_enhancer(float fixed_gain, float *prev_tr_gain,
707  float voice_fac, float stab_fac)
708 {
709  float sm_fac = 0.5 * (1 - voice_fac) * stab_fac;
710  float g0;
711 
712  // XXX: the following fixed-point constants used to in(de)crement
713  // gain by 1.5dB were taken from the reference code, maybe it could
714  // be simpler
715  if (fixed_gain < *prev_tr_gain) {
716  g0 = FFMIN(*prev_tr_gain, fixed_gain + fixed_gain *
717  (6226 * (1.0f / (1 << 15)))); // +1.5 dB
718  } else
719  g0 = FFMAX(*prev_tr_gain, fixed_gain *
720  (27536 * (1.0f / (1 << 15)))); // -1.5 dB
721 
722  *prev_tr_gain = g0; // update next frame threshold
723 
724  return sm_fac * g0 + (1 - sm_fac) * fixed_gain;
725 }
726 
733 static void pitch_enhancer(float *fixed_vector, float voice_fac)
734 {
735  int i;
736  float cpe = 0.125 * (1 + voice_fac);
737  float last = fixed_vector[0]; // holds c(i - 1)
738 
739  fixed_vector[0] -= cpe * fixed_vector[1];
740 
741  for (i = 1; i < AMRWB_SFR_SIZE - 1; i++) {
742  float cur = fixed_vector[i];
743 
744  fixed_vector[i] -= cpe * (last + fixed_vector[i + 1]);
745  last = cur;
746  }
747 
748  fixed_vector[AMRWB_SFR_SIZE - 1] -= cpe * last;
749 }
750 
761 static void synthesis(AMRWBContext *ctx, float *lpc, float *excitation,
762  float fixed_gain, const float *fixed_vector,
763  float *samples)
764 {
765  ff_weighted_vector_sumf(excitation, ctx->pitch_vector, fixed_vector,
766  ctx->pitch_gain[0], fixed_gain, AMRWB_SFR_SIZE);
767 
768  /* emphasize pitch vector contribution in low bitrate modes */
769  if (ctx->pitch_gain[0] > 0.5 && ctx->fr_cur_mode <= MODE_8k85) {
770  int i;
771  float energy = ff_scalarproduct_float_c(excitation, excitation,
773 
774  // XXX: Weird part in both ref code and spec. A unknown parameter
775  // {beta} seems to be identical to the current pitch gain
776  float pitch_factor = 0.25 * ctx->pitch_gain[0] * ctx->pitch_gain[0];
777 
778  for (i = 0; i < AMRWB_SFR_SIZE; i++)
779  excitation[i] += pitch_factor * ctx->pitch_vector[i];
780 
781  ff_scale_vector_to_given_sum_of_squares(excitation, excitation,
782  energy, AMRWB_SFR_SIZE);
783  }
784 
785  ff_celp_lp_synthesis_filterf(samples, lpc, excitation,
787 }
788 
798 static void de_emphasis(float *out, float *in, float m, float mem[1])
799 {
800  int i;
801 
802  out[0] = in[0] + m * mem[0];
803 
804  for (i = 1; i < AMRWB_SFR_SIZE; i++)
805  out[i] = in[i] + out[i - 1] * m;
806 
807  mem[0] = out[AMRWB_SFR_SIZE - 1];
808 }
809 
818 static void upsample_5_4(float *out, const float *in, int o_size)
819 {
820  const float *in0 = in - UPS_FIR_SIZE + 1;
821  int i, j, k;
822  int int_part = 0, frac_part;
823 
824  i = 0;
825  for (j = 0; j < o_size / 5; j++) {
826  out[i] = in[int_part];
827  frac_part = 4;
828  i++;
829 
830  for (k = 1; k < 5; k++) {
831  out[i] = ff_scalarproduct_float_c(in0 + int_part,
832  upsample_fir[4 - frac_part],
833  UPS_MEM_SIZE);
834  int_part++;
835  frac_part--;
836  i++;
837  }
838  }
839 }
840 
850 static float find_hb_gain(AMRWBContext *ctx, const float *synth,
851  uint16_t hb_idx, uint8_t vad)
852 {
853  int wsp = (vad > 0);
854  float tilt;
855 
856  if (ctx->fr_cur_mode == MODE_23k85)
857  return qua_hb_gain[hb_idx] * (1.0f / (1 << 14));
858 
859  tilt = ff_scalarproduct_float_c(synth, synth + 1, AMRWB_SFR_SIZE - 1) /
861 
862  /* return gain bounded by [0.1, 1.0] */
863  return av_clipf((1.0 - FFMAX(0.0, tilt)) * (1.25 - 0.25 * wsp), 0.1, 1.0);
864 }
865 
875 static void scaled_hb_excitation(AMRWBContext *ctx, float *hb_exc,
876  const float *synth_exc, float hb_gain)
877 {
878  int i;
879  float energy = ff_scalarproduct_float_c(synth_exc, synth_exc, AMRWB_SFR_SIZE);
880 
881  /* Generate a white-noise excitation */
882  for (i = 0; i < AMRWB_SFR_SIZE_16k; i++)
883  hb_exc[i] = 32768.0 - (uint16_t) av_lfg_get(&ctx->prng);
884 
886  energy * hb_gain * hb_gain,
887  AMRWB_SFR_SIZE_16k);
888 }
889 
893 static float auto_correlation(float *diff_isf, float mean, int lag)
894 {
895  int i;
896  float sum = 0.0;
897 
898  for (i = 7; i < LP_ORDER - 2; i++) {
899  float prod = (diff_isf[i] - mean) * (diff_isf[i - lag] - mean);
900  sum += prod * prod;
901  }
902  return sum;
903 }
904 
912 static void extrapolate_isf(float isf[LP_ORDER_16k])
913 {
914  float diff_isf[LP_ORDER - 2], diff_mean;
915  float corr_lag[3];
916  float est, scale;
917  int i, j, i_max_corr;
918 
919  isf[LP_ORDER_16k - 1] = isf[LP_ORDER - 1];
920 
921  /* Calculate the difference vector */
922  for (i = 0; i < LP_ORDER - 2; i++)
923  diff_isf[i] = isf[i + 1] - isf[i];
924 
925  diff_mean = 0.0;
926  for (i = 2; i < LP_ORDER - 2; i++)
927  diff_mean += diff_isf[i] * (1.0f / (LP_ORDER - 4));
928 
929  /* Find which is the maximum autocorrelation */
930  i_max_corr = 0;
931  for (i = 0; i < 3; i++) {
932  corr_lag[i] = auto_correlation(diff_isf, diff_mean, i + 2);
933 
934  if (corr_lag[i] > corr_lag[i_max_corr])
935  i_max_corr = i;
936  }
937  i_max_corr++;
938 
939  for (i = LP_ORDER - 1; i < LP_ORDER_16k - 1; i++)
940  isf[i] = isf[i - 1] + isf[i - 1 - i_max_corr]
941  - isf[i - 2 - i_max_corr];
942 
943  /* Calculate an estimate for ISF(18) and scale ISF based on the error */
944  est = 7965 + (isf[2] - isf[3] - isf[4]) / 6.0;
945  scale = 0.5 * (FFMIN(est, 7600) - isf[LP_ORDER - 2]) /
946  (isf[LP_ORDER_16k - 2] - isf[LP_ORDER - 2]);
947 
948  for (i = LP_ORDER - 1, j = 0; i < LP_ORDER_16k - 1; i++, j++)
949  diff_isf[j] = scale * (isf[i] - isf[i - 1]);
950 
951  /* Stability insurance */
952  for (i = 1; i < LP_ORDER_16k - LP_ORDER; i++)
953  if (diff_isf[i] + diff_isf[i - 1] < 5.0) {
954  if (diff_isf[i] > diff_isf[i - 1]) {
955  diff_isf[i - 1] = 5.0 - diff_isf[i];
956  } else
957  diff_isf[i] = 5.0 - diff_isf[i - 1];
958  }
959 
960  for (i = LP_ORDER - 1, j = 0; i < LP_ORDER_16k - 1; i++, j++)
961  isf[i] = isf[i - 1] + diff_isf[j] * (1.0f / (1 << 15));
962 
963  /* Scale the ISF vector for 16000 Hz */
964  for (i = 0; i < LP_ORDER_16k - 1; i++)
965  isf[i] *= 0.8;
966 }
967 
977 static void lpc_weighting(float *out, const float *lpc, float gamma, int size)
978 {
979  int i;
980  float fac = gamma;
981 
982  for (i = 0; i < size; i++) {
983  out[i] = lpc[i] * fac;
984  fac *= gamma;
985  }
986 }
987 
999 static void hb_synthesis(AMRWBContext *ctx, int subframe, float *samples,
1000  const float *exc, const float *isf, const float *isf_past)
1001 {
1002  float hb_lpc[LP_ORDER_16k];
1003  enum Mode mode = ctx->fr_cur_mode;
1004 
1005  if (mode == MODE_6k60) {
1006  float e_isf[LP_ORDER_16k]; // ISF vector for extrapolation
1007  double e_isp[LP_ORDER_16k];
1008 
1009  ff_weighted_vector_sumf(e_isf, isf_past, isf, isfp_inter[subframe],
1010  1.0 - isfp_inter[subframe], LP_ORDER);
1011 
1012  extrapolate_isf(e_isf);
1013 
1014  e_isf[LP_ORDER_16k - 1] *= 2.0;
1015  ff_acelp_lsf2lspd(e_isp, e_isf, LP_ORDER_16k);
1016  ff_amrwb_lsp2lpc(e_isp, hb_lpc, LP_ORDER_16k);
1017 
1018  lpc_weighting(hb_lpc, hb_lpc, 0.9, LP_ORDER_16k);
1019  } else {
1020  lpc_weighting(hb_lpc, ctx->lp_coef[subframe], 0.6, LP_ORDER);
1021  }
1022 
1023  ff_celp_lp_synthesis_filterf(samples, hb_lpc, exc, AMRWB_SFR_SIZE_16k,
1024  (mode == MODE_6k60) ? LP_ORDER_16k : LP_ORDER);
1025 }
1026 
1038 static void hb_fir_filter(float *out, const float fir_coef[HB_FIR_SIZE + 1],
1039  float mem[HB_FIR_SIZE], const float *in)
1040 {
1041  int i, j;
1042  float data[AMRWB_SFR_SIZE_16k + HB_FIR_SIZE]; // past and current samples
1043 
1044  memcpy(data, mem, HB_FIR_SIZE * sizeof(float));
1045  memcpy(data + HB_FIR_SIZE, in, AMRWB_SFR_SIZE_16k * sizeof(float));
1046 
1047  for (i = 0; i < AMRWB_SFR_SIZE_16k; i++) {
1048  out[i] = 0.0;
1049  for (j = 0; j <= HB_FIR_SIZE; j++)
1050  out[i] += data[i + j] * fir_coef[j];
1051  }
1052 
1053  memcpy(mem, data + AMRWB_SFR_SIZE_16k, HB_FIR_SIZE * sizeof(float));
1054 }
1055 
1060 {
1061  memmove(&ctx->excitation_buf[0], &ctx->excitation_buf[AMRWB_SFR_SIZE],
1062  (AMRWB_P_DELAY_MAX + LP_ORDER + 1) * sizeof(float));
1063 
1064  memmove(&ctx->pitch_gain[1], &ctx->pitch_gain[0], 5 * sizeof(float));
1065  memmove(&ctx->fixed_gain[1], &ctx->fixed_gain[0], 1 * sizeof(float));
1066 
1067  memmove(&ctx->samples_az[0], &ctx->samples_az[AMRWB_SFR_SIZE],
1068  LP_ORDER * sizeof(float));
1069  memmove(&ctx->samples_up[0], &ctx->samples_up[AMRWB_SFR_SIZE],
1070  UPS_MEM_SIZE * sizeof(float));
1071  memmove(&ctx->samples_hb[0], &ctx->samples_hb[AMRWB_SFR_SIZE_16k],
1072  LP_ORDER_16k * sizeof(float));
1073 }
1074 
1075 static int amrwb_decode_frame(AVCodecContext *avctx, void *data,
1076  int *got_frame_ptr, AVPacket *avpkt)
1077 {
1078  AMRWBContext *ctx = avctx->priv_data;
1079  AMRWBFrame *cf = &ctx->frame;
1080  const uint8_t *buf = avpkt->data;
1081  int buf_size = avpkt->size;
1082  int expected_fr_size, header_size;
1083  float *buf_out;
1084  float spare_vector[AMRWB_SFR_SIZE]; // extra stack space to hold result from anti-sparseness processing
1085  float fixed_gain_factor; // fixed gain correction factor (gamma)
1086  float *synth_fixed_vector; // pointer to the fixed vector that synthesis should use
1087  float synth_fixed_gain; // the fixed gain that synthesis should use
1088  float voice_fac, stab_fac; // parameters used for gain smoothing
1089  float synth_exc[AMRWB_SFR_SIZE]; // post-processed excitation for synthesis
1090  float hb_exc[AMRWB_SFR_SIZE_16k]; // excitation for the high frequency band
1091  float hb_samples[AMRWB_SFR_SIZE_16k]; // filtered high-band samples from synthesis
1092  float hb_gain;
1093  int sub, i, ret;
1094 
1095  /* get output buffer */
1097  if ((ret = ff_get_buffer(avctx, &ctx->avframe)) < 0) {
1098  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1099  return ret;
1100  }
1101  buf_out = (float *)ctx->avframe.data[0];
1102 
1103  header_size = decode_mime_header(ctx, buf);
1104  if (ctx->fr_cur_mode > MODE_SID) {
1105  av_log(avctx, AV_LOG_ERROR,
1106  "Invalid mode %d\n", ctx->fr_cur_mode);
1107  return AVERROR_INVALIDDATA;
1108  }
1109  expected_fr_size = ((cf_sizes_wb[ctx->fr_cur_mode] + 7) >> 3) + 1;
1110 
1111  if (buf_size < expected_fr_size) {
1112  av_log(avctx, AV_LOG_ERROR,
1113  "Frame too small (%d bytes). Truncated file?\n", buf_size);
1114  *got_frame_ptr = 0;
1115  return AVERROR_INVALIDDATA;
1116  }
1117 
1118  if (!ctx->fr_quality || ctx->fr_cur_mode > MODE_SID)
1119  av_log(avctx, AV_LOG_ERROR, "Encountered a bad or corrupted frame\n");
1120 
1121  if (ctx->fr_cur_mode == MODE_SID) { /* Comfort noise frame */
1122  av_log_missing_feature(avctx, "SID mode", 1);
1123  return AVERROR_PATCHWELCOME;
1124  }
1125 
1126  ff_amr_bit_reorder((uint16_t *) &ctx->frame, sizeof(AMRWBFrame),
1127  buf + header_size, amr_bit_orderings_by_mode[ctx->fr_cur_mode]);
1128 
1129  /* Decode the quantized ISF vector */
1130  if (ctx->fr_cur_mode == MODE_6k60) {
1132  } else {
1134  }
1135 
1138 
1139  stab_fac = stability_factor(ctx->isf_cur, ctx->isf_past_final);
1140 
1141  ctx->isf_cur[LP_ORDER - 1] *= 2.0;
1142  ff_acelp_lsf2lspd(ctx->isp[3], ctx->isf_cur, LP_ORDER);
1143 
1144  /* Generate a ISP vector for each subframe */
1145  if (ctx->first_frame) {
1146  ctx->first_frame = 0;
1147  memcpy(ctx->isp_sub4_past, ctx->isp[3], LP_ORDER * sizeof(double));
1148  }
1149  interpolate_isp(ctx->isp, ctx->isp_sub4_past);
1150 
1151  for (sub = 0; sub < 4; sub++)
1152  ff_amrwb_lsp2lpc(ctx->isp[sub], ctx->lp_coef[sub], LP_ORDER);
1153 
1154  for (sub = 0; sub < 4; sub++) {
1155  const AMRWBSubFrame *cur_subframe = &cf->subframe[sub];
1156  float *sub_buf = buf_out + sub * AMRWB_SFR_SIZE_16k;
1157 
1158  /* Decode adaptive codebook (pitch vector) */
1159  decode_pitch_vector(ctx, cur_subframe, sub);
1160  /* Decode innovative codebook (fixed vector) */
1161  decode_fixed_vector(ctx->fixed_vector, cur_subframe->pul_ih,
1162  cur_subframe->pul_il, ctx->fr_cur_mode);
1163 
1164  pitch_sharpening(ctx, ctx->fixed_vector);
1165 
1166  decode_gains(cur_subframe->vq_gain, ctx->fr_cur_mode,
1167  &fixed_gain_factor, &ctx->pitch_gain[0]);
1168 
1169  ctx->fixed_gain[0] =
1170  ff_amr_set_fixed_gain(fixed_gain_factor,
1172  ctx->fixed_vector,
1173  AMRWB_SFR_SIZE) /
1175  ctx->prediction_error,
1177 
1178  /* Calculate voice factor and store tilt for next subframe */
1179  voice_fac = voice_factor(ctx->pitch_vector, ctx->pitch_gain[0],
1180  ctx->fixed_vector, ctx->fixed_gain[0]);
1181  ctx->tilt_coef = voice_fac * 0.25 + 0.25;
1182 
1183  /* Construct current excitation */
1184  for (i = 0; i < AMRWB_SFR_SIZE; i++) {
1185  ctx->excitation[i] *= ctx->pitch_gain[0];
1186  ctx->excitation[i] += ctx->fixed_gain[0] * ctx->fixed_vector[i];
1187  ctx->excitation[i] = truncf(ctx->excitation[i]);
1188  }
1189 
1190  /* Post-processing of excitation elements */
1191  synth_fixed_gain = noise_enhancer(ctx->fixed_gain[0], &ctx->prev_tr_gain,
1192  voice_fac, stab_fac);
1193 
1194  synth_fixed_vector = anti_sparseness(ctx, ctx->fixed_vector,
1195  spare_vector);
1196 
1197  pitch_enhancer(synth_fixed_vector, voice_fac);
1198 
1199  synthesis(ctx, ctx->lp_coef[sub], synth_exc, synth_fixed_gain,
1200  synth_fixed_vector, &ctx->samples_az[LP_ORDER]);
1201 
1202  /* Synthesis speech post-processing */
1204  &ctx->samples_az[LP_ORDER], PREEMPH_FAC, ctx->demph_mem);
1205 
1208  hpf_31_gain, ctx->hpf_31_mem, AMRWB_SFR_SIZE);
1209 
1210  upsample_5_4(sub_buf, &ctx->samples_up[UPS_FIR_SIZE],
1211  AMRWB_SFR_SIZE_16k);
1212 
1213  /* High frequency band (6.4 - 7.0 kHz) generation part */
1216  hpf_400_gain, ctx->hpf_400_mem, AMRWB_SFR_SIZE);
1217 
1218  hb_gain = find_hb_gain(ctx, hb_samples,
1219  cur_subframe->hb_gain, cf->vad);
1220 
1221  scaled_hb_excitation(ctx, hb_exc, synth_exc, hb_gain);
1222 
1223  hb_synthesis(ctx, sub, &ctx->samples_hb[LP_ORDER_16k],
1224  hb_exc, ctx->isf_cur, ctx->isf_past_final);
1225 
1226  /* High-band post-processing filters */
1227  hb_fir_filter(hb_samples, bpf_6_7_coef, ctx->bpf_6_7_mem,
1228  &ctx->samples_hb[LP_ORDER_16k]);
1229 
1230  if (ctx->fr_cur_mode == MODE_23k85)
1231  hb_fir_filter(hb_samples, lpf_7_coef, ctx->lpf_7_mem,
1232  hb_samples);
1233 
1234  /* Add the low and high frequency bands */
1235  for (i = 0; i < AMRWB_SFR_SIZE_16k; i++)
1236  sub_buf[i] = (sub_buf[i] + hb_samples[i]) * (1.0f / (1 << 15));
1237 
1238  /* Update buffers and history */
1239  update_sub_state(ctx);
1240  }
1241 
1242  /* update state for next frame */
1243  memcpy(ctx->isp_sub4_past, ctx->isp[3], LP_ORDER * sizeof(ctx->isp[3][0]));
1244  memcpy(ctx->isf_past_final, ctx->isf_cur, LP_ORDER * sizeof(float));
1245 
1246  *got_frame_ptr = 1;
1247  *(AVFrame *)data = ctx->avframe;
1248 
1249  return expected_fr_size;
1250 }
1251 
1253  .name = "amrwb",
1254  .type = AVMEDIA_TYPE_AUDIO,
1255  .id = AV_CODEC_ID_AMR_WB,
1256  .priv_data_size = sizeof(AMRWBContext),
1259  .capabilities = CODEC_CAP_DR1,
1260  .long_name = NULL_IF_CONFIG_SMALL("AMR-WB (Adaptive Multi-Rate WideBand)"),
1261  .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLT,
1263 };
AMRWBSubFrame subframe[4]
data for subframes
Definition: amrwbdata.h:81
Definition: lfg.h:25
AMRWBFrame frame
AMRWB parameters decoded from bitstream.
Definition: amrwbdec.c:47
static const int16_t dico2_isf[256][7]
Definition: amrwbdata.h:951
float samples_up[UPS_MEM_SIZE+AMRWB_SFR_SIZE]
low-band samples and memory processed for upsampling
Definition: amrwbdec.c:78
float hpf_31_mem[2]
Definition: amrwbdec.c:81
void ff_celp_lp_synthesis_filterf(float *out, const float *filter_coeffs, const float *in, int buffer_length, int filter_length)
LP synthesis filter.
Definition: celp_filters.c:83
static int16_t * samples
AVLFG prng
random number generator for white noise excitation
Definition: amrwbdec.c:86
int size
static const uint8_t pulses_nb_per_mode_tr[][4]
[i][j] is the number of pulses present in track j at mode i
Definition: amrwbdata.h:1656
This structure describes decoded (raw) audio or video data.
Definition: avcodec.h:989
static const int16_t qua_gain_6b[64][2]
Tables for decoding quantized gains { pitch (Q14), fixed factor (Q11) }.
Definition: amrwbdata.h:1663
static const float lpf_7_coef[31]
Definition: amrwbdata.h:1870
float * excitation
points to current excitation in excitation_buf[]
Definition: amrwbdec.c:62
23.05 kbit/s
Definition: amrwbdata.h:59
void ff_acelp_apply_order_2_transfer_function(float *out, const float *in, const float zero_coeffs[2], const float pole_coeffs[2], float gain, float mem[2], int n)
Apply an order 2 rational transfer function in-place.
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:1038
float fixed_gain[2]
quantified fixed gains for the current and previous subframes
Definition: amrwbdec.c:69
void ff_weighted_vector_sumf(float *out, const float *in_a, const float *in_b, float weight_coeff_a, float weight_coeff_b, int length)
float implementation of weighted sum of two vectors.
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:283
AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:2725
float pitch_vector[AMRWB_SFR_SIZE]
adaptive codebook (pitch) vector for current subframe
Definition: amrwbdec.c:64
int acc
Definition: yuv2rgb.c:476
float prev_tr_gain
previous initial gain used by noise enhancer for threshold
Definition: amrwbdec.c:75
#define UPS_FIR_SIZE
upsampling filter size
Definition: amrwbdata.h:36
static void decode_5p_track(int *out, int code, int m, int off)
code: 5m bits
Definition: amrwbdec.c:431
#define AMRWB_P_DELAY_MAX
maximum pitch delay value
Definition: amrwbdata.h:47
int size
Definition: avcodec.h:916
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:912
static void decode_6p_track(int *out, int code, int m, int off)
code: 6m-2 bits
Definition: amrwbdec.c:441
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:682
static const int16_t dico24_isf[32][3]
Definition: amrwbdata.h:1379
static const int16_t dico23_isf[128][3]
Definition: amrwbdata.h:1312
static void isf_add_mean_and_past(float *isf_q, float *isf_past)
Apply mean and past ISF values using the prediction factor.
Definition: amrwbdec.c:208
float isf_past_final[LP_ORDER]
final processed ISF vector of the previous frame
Definition: amrwbdec.c:52
static const int16_t dico22_isf[128][3]
Definition: amrwbdata.h:1245
enum Mode fr_cur_mode
mode index of current frame
Definition: amrwbdec.c:48
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:977
uint8_t first_frame
flag active during decoding of the first frame
Definition: amrwbdec.c:87
static void pitch_enhancer(float *fixed_vector, float voice_fac)
Filter the fixed_vector to emphasize the higher frequencies.
Definition: amrwbdec.c:733
AVCodec.
Definition: avcodec.h:2960
float tilt_coef
{beta_1} related to the voicing of the previous subframe
Definition: amrwbdec.c:71
static const int16_t dico23_isf_36b[64][7]
Definition: amrwbdata.h:1551
static void scaled_hb_excitation(AMRWBContext *ctx, float *hb_exc, const float *synth_exc, float hb_gain)
Generate the high-band excitation with the same energy from the lower one and scaled by the given gai...
Definition: amrwbdec.c:875
uint16_t vq_gain
VQ adaptive and innovative gains.
Definition: amrwbdata.h:72
struct AMRWBContext AMRWBContext
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
Definition: mimic.c:228
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2112
float lpf_7_mem[HB_FIR_SIZE]
previous values in the high-band low pass filter
Definition: amrwbdec.c:84
uint8_t
static int amrwb_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: amrwbdec.c:1075
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:143
static const int16_t isf_mean[LP_ORDER]
Means of ISF vectors in Q15.
Definition: amrwbdata.h:1619
Mode
Frame type (Table 1a in 3GPP TS 26.101)
Definition: amrnbdata.h:39
18.25 kbit/s
Definition: amrwbdata.h:57
14.25 kbit/s
Definition: amrwbdata.h:55
static const float energy_pred_fac[4]
4-tap moving average prediction coefficients in reverse order
Definition: amrnbdata.h:1463
uint16_t isp_id[7]
index of ISP subvectors
Definition: amrwbdata.h:80
const char data[16]
Definition: mxf.c:66
#define MIN_ISF_SPACING
minimum isf gap
Definition: amrwbdata.h:39
static const float hpf_31_gain
Definition: amrwbdata.h:1815
uint8_t * data
Definition: avcodec.h:915
#define UPS_MEM_SIZE
Definition: amrwbdata.h:37
static const float hpf_zeros[2]
High-pass filters coefficients for 31 Hz and 400 Hz cutoff.
Definition: amrwbdata.h:1813
static const float ac_inter[65]
Coefficients for FIR interpolation of excitation vector at pitch lag resulting the adaptive codebook ...
Definition: amrwbdata.h:1635
float bpf_6_7_mem[HB_FIR_SIZE]
previous values in the high-band band pass filter
Definition: amrwbdec.c:83
static const float bpf_6_7_coef[31]
High-band post-processing FIR filters coefficients from Q15.
Definition: amrwbdata.h:1856
static void ff_amr_bit_reorder(uint16_t *out, int size, const uint8_t *data, const R_TABLE_TYPE *ord_table)
Fill the frame structure variables from bitstream by parsing the given reordering table that uses the...
Definition: amr.h:51
float isf_cur[LP_ORDER]
working ISF vector from current frame
Definition: amrwbdec.c:50
static int init(AVCodecParserContext *s)
Definition: h264_parser.c:335
static void decode_3p_track(int *out, int code, int m, int off)
code: 3m+1 bits
Definition: amrwbdec.c:386
static const float hpf_31_poles[2]
Definition: amrwbdata.h:1814
uint8_t prev_ir_filter_nr
previous impulse response filter "impNr": 0 - strong, 1 - medium, 2 - none
Definition: amrwbdec.c:74
static const float isfp_inter[4]
ISF/ISP interpolation coefficients for each subframe.
Definition: amrwbdata.h:1631
static void synthesis(AMRWBContext *ctx, float *lpc, float *excitation, float fixed_gain, const float *fixed_vector, float *samples)
Conduct 16th order linear predictive coding synthesis from excitation.
Definition: amrwbdec.c:761
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:798
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:618
6.60 kbit/s
Definition: amrwbdata.h:52
#define AMRWB_SFR_SIZE
samples per subframe at 12.8 kHz
Definition: amrwbdata.h:45
static void decode_1p_track(int *out, int code, int m, int off)
The next six functions decode_[i]p_track decode exactly i pulses positions and amplitudes (-1 or 1) i...
Definition: amrwbdec.c:369
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:88
static float voice_factor(float *p_vector, float p_gain, float *f_vector, float f_gain)
Calculate the voicing factor (-1.0 = unvoiced to 1.0 = voiced).
Definition: amrwbdec.c:595
float prev_sparse_fixed_gain
previous fixed gain; used by anti-sparseness to determine "onset"
Definition: amrwbdec.c:73
float isf_q_past[LP_ORDER]
quantized ISF vector of the previous frame
Definition: amrwbdec.c:51
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:146
float ff_scalarproduct_float_c(const float *v1, const float *v2, int len)
Return the scalar product of two vectors.
Definition: dsputil.c:2418
const char * name
Name of the codec implementation.
Definition: avcodec.h:2967
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.
static const int16_t dico21_isf_36b[128][5]
Definition: amrwbdata.h:1417
int off
Definition: dsputil_bfin.c:28
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2165
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:228
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:312
audio channel layout utility functions
#define MIN_ENERGY
Initial energy in dB.
Definition: amrnbdec.c:82
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame)
Get a buffer for a frame.
Definition: utils.c:464
float demph_mem[1]
previous value in the de-emphasis filter
Definition: amrwbdec.c:82
double isp_sub4_past[LP_ORDER]
ISP vector for the 4th subframe of the previous frame.
Definition: amrwbdec.c:54
static const int16_t dico21_isf[64][3]
Definition: amrwbdata.h:1210
static const float * ir_filters_lookup[2]
Definition: amrnbdata.h:1658
uint16_t pul_il[4]
LSBs part of codebook index.
Definition: amrwbdata.h:75
static av_always_inline av_const float truncf(float x)
Definition: libm.h:172
static const int16_t dico25_isf[32][4]
Definition: amrwbdata.h:1398
float samples_az[LP_ORDER+AMRWB_SFR_SIZE]
low-band samples and memory from synthesis at 12.8kHz
Definition: amrwbdec.c:77
float prediction_error[4]
quantified prediction errors {20log10(^gamma_gc)} for previous four subframes
Definition: amrwbdec.c:67
static void upsample_5_4(float *out, const float *in, int o_size)
Upsample a signal by 5/4 ratio (from 12.8kHz to 16kHz) using a FIR interpolation filter.
Definition: amrwbdec.c:818
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:999
static void decode_2p_track(int *out, int code, int m, int off)
code: 2m+1 bits
Definition: amrwbdec.c:376
float lp_coef[4][LP_ORDER]
Linear Prediction Coefficients from ISP vector.
Definition: amrwbdec.c:56
float pitch_gain[6]
quantified pitch gains for the current and previous five subframes
Definition: amrwbdec.c:68
#define LP_ORDER
linear predictive coding filter order
Definition: amrwbdata.h:33
static const uint16_t * amr_bit_orderings_by_mode[]
Reordering array addresses for each mode.
Definition: amrwbdata.h:676
uint16_t pul_ih[4]
MSBs part of codebook index (high modes only)
Definition: amrwbdata.h:74
static void decode_isf_indices_46b(uint16_t *ind, float *isf_q)
Decode quantized ISF vectors using 46-bit indexes (except 6K60 mode).
Definition: amrwbdec.c:174
uint16_t vad
voice activity detection flag
Definition: amrwbdata.h:79
external API header
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:49
#define LP_ORDER_16k
lpc filter order at 16kHz
Definition: amrwbdata.h:34
AVCodec ff_amrwb_decoder
Definition: amrwbdec.c:1252
uint16_t adap
adaptive codebook index
Definition: amrwbdata.h:70
AV_SAMPLE_FMT_NONE
Definition: avconv_filter.c:63
int sample_rate
samples per second
Definition: avcodec.h:2104
main external API structure.
Definition: avcodec.h:1339
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:485
#define PRED_FACTOR
Definition: amrwbdata.h:40
static unsigned int av_lfg_get(AVLFG *c)
Get the next random unsigned 32-bit number using an ALFG.
Definition: lfg.h:38
float excitation_buf[AMRWB_P_DELAY_MAX+LP_ORDER+2+AMRWB_SFR_SIZE]
current excitation and all necessary excitation history
Definition: amrwbdec.c:61
static const float hpf_400_poles[2]
Definition: amrwbdata.h:1817
void avcodec_get_frame_defaults(AVFrame *frame)
Set the fields of the given AVFrame to default values.
Definition: utils.c:602
static av_cold int amrwb_decode_init(AVCodecContext *avctx)
Definition: amrwbdec.c:90
static const int16_t qua_gain_7b[128][2]
Definition: amrwbdata.h:1698
void av_log_missing_feature(void *avc, const char *feature, int want_sample)
Log a generic warning message about a missing feature.
Definition: utils.c:2005
static const float hpf_400_gain
Definition: amrwbdata.h:1818
void ff_acelp_lsf2lspd(double *lsp, const float *lsf, int lp_order)
Floating point version of ff_acelp_lsf2lsp()
Definition: lsp.c:91
uint8_t pitch_lag_int
integer part of pitch lag of the previous subframe
Definition: amrwbdec.c:59
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:706
av_cold void av_lfg_init(AVLFG *c, unsigned int seed)
Definition: lfg.c:30
static float auto_correlation(float *diff_isf, float mean, int lag)
Calculate the auto-correlation for the ISF difference vector.
Definition: amrwbdec.c:893
AVFrame avframe
AVFrame for decoded samples.
Definition: amrwbdec.c:46
static void update_sub_state(AMRWBContext *ctx)
Update context state before the next subframe.
Definition: amrwbdec.c:1059
15.85 kbit/s
Definition: amrwbdata.h:56
#define AMRWB_SFR_SIZE_16k
samples per subframe at 16 kHz
Definition: amrwbdata.h:46
static const uint16_t cf_sizes_wb[]
Core frame sizes in each mode.
Definition: amrwbdata.h:1885
uint8_t fr_quality
frame quality index (FQI)
Definition: amrwbdec.c:49
static const uint16_t scale[4]
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: avcodec.h:997
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:250
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:850
float samples_hb[LP_ORDER_16k+AMRWB_SFR_SIZE_16k]
high-band samples and memory from synthesis at 16kHz
Definition: amrwbdec.c:79
static const float upsample_fir[4][24]
Interpolation coefficients for 5/4 signal upsampling Table from the reference source was reordered fo...
Definition: amrwbdata.h:1822
uint8_t base_pitch_lag
integer part of pitch lag for the next relative subframe
Definition: amrwbdec.c:58
comfort noise frame
Definition: amrwbdata.h:61
static int decode_mime_header(AMRWBContext *ctx, const uint8_t *buf)
Decode the frame header in the "MIME/storage" format.
Definition: amrwbdec.c:131
23.85 kbit/s
Definition: amrwbdata.h:60
common internal api header.
common internal and external API header
#define HB_FIR_SIZE
amount of past data needed by HB filters
Definition: amrwbdata.h:35
uint16_t hb_gain
high-band energy index (mode 23k85 only)
Definition: amrwbdata.h:73
void ff_set_min_dist_lsf(float *lsf, double min_spacing, int size)
Adjust the quantized LSFs so they are increasing and not too close.
Definition: lsp.c:49
#define BIT_STR(x, lsb, len)
Get x bits in the index interval [lsb,lsb+len-1] inclusive.
Definition: amrwbdec.c:351
AVSampleFormat
Audio Sample Formats.
Definition: samplefmt.h:49
8.85 kbit/s
Definition: amrwbdata.h:53
static const int16_t dico1_isf[256][9]
Indexed tables for retrieval of quantized ISF vectors in Q15.
Definition: amrwbdata.h:692
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:556
float fixed_vector[AMRWB_SFR_SIZE]
algebraic codebook (fixed) vector for current subframe
Definition: amrwbdec.c:65
DSP utils.
void * priv_data
Definition: avcodec.h:1382
#define ENERGY_MEAN
mean innovation energy (dB) in all modes
Definition: amrwbdata.h:42
#define PREEMPH_FAC
factor used to de-emphasize synthesis
Definition: amrwbdata.h:43
static const int16_t dico22_isf_36b[128][4]
Definition: amrwbdata.h:1484
int channels
number of audio channels
Definition: avcodec.h:2105
AMR wideband data and definitions.
19.85 kbit/s
Definition: amrwbdata.h:58
void ff_acelp_interpolatef(float *out, const float *in, const float *filter_coeffs, int precision, int frac_pos, int filter_length, int length)
Floating point version of ff_acelp_interpolate()
Definition: acelp_filters.c:77
float hpf_400_mem[2]
previous values in the high pass filters
Definition: amrwbdec.c:81
static void pitch_sharpening(AMRWBContext *ctx, float *fixed_vector)
Apply pitch sharpening filters to the fixed codebook vector.
Definition: amrwbdec.c:574
static const int16_t isf_init[LP_ORDER]
Initialization tables for the processed ISF vector in Q15.
Definition: amrwbdata.h:1625
#define BIT_POS(x, p)
Get the bit at specified position.
Definition: amrwbdec.c:354
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:147
static const uint16_t qua_hb_gain[16]
High band quantized gains for 23k85 in Q14.
Definition: amrwbdata.h:1850
#define AV_CH_LAYOUT_MONO
static void decode_4p_track(int *out, int code, int m, int off)
code: 4m bits
Definition: amrwbdec.c:395
This structure stores compressed data.
Definition: avcodec.h:898
uint16_t ltp
ltp-filtering flag
Definition: amrwbdata.h:71
int nb_samples
number of audio samples (per channel) described by this frame
Definition: avcodec.h:1042
double isp[4][LP_ORDER]
ISP vectors from current frame.
Definition: amrwbdec.c:53
for(j=16;j >0;--j)
float ff_amr_set_fixed_gain(float fixed_gain_factor, float fixed_mean_energy, float *prediction_error, float energy_mean, const float *pred_table)
Calculate fixed gain (part of section 6.1.3 of AMR spec)
12.65 kbit/s
Definition: amrwbdata.h:54
#define AMRWB_P_DELAY_MIN
Definition: amrwbdata.h:48