Libav
amrnbdec.c
Go to the documentation of this file.
1 /*
2  * AMR narrowband decoder
3  * Copyright (c) 2006-2007 Robert Swain
4  * Copyright (c) 2009 Colin McQuillan
5  *
6  * This file is part of Libav.
7  *
8  * Libav is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * Libav is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with Libav; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 
43 #include <string.h>
44 #include <math.h>
45 
47 #include "libavutil/float_dsp.h"
48 #include "avcodec.h"
49 #include "libavutil/common.h"
50 #include "celp_filters.h"
51 #include "acelp_filters.h"
52 #include "acelp_vectors.h"
53 #include "acelp_pitch_delay.h"
54 #include "lsp.h"
55 #include "amr.h"
56 #include "internal.h"
57 
58 #include "amrnbdata.h"
59 
60 #define AMR_BLOCK_SIZE 160
61 #define AMR_SAMPLE_BOUND 32768.0
62 
63 
72 #define AMR_SAMPLE_SCALE (2.0 / 32768.0)
73 
75 #define PRED_FAC_MODE_12k2 0.65
76 
77 #define LSF_R_FAC (8000.0 / 32768.0)
78 #define MIN_LSF_SPACING (50.0488 / 8000.0)
79 #define PITCH_LAG_MIN_MODE_12k2 18
80 
81 
82 #define MIN_ENERGY -14.0
83 
89 #define SHARP_MAX 0.79449462890625
90 
92 #define AMR_TILT_RESPONSE 22
93 
94 #define AMR_TILT_GAMMA_T 0.8
95 
96 #define AMR_AGC_ALPHA 0.9
97 
98 typedef struct AMRContext {
102 
104  double lsp[4][LP_FILTER_ORDER];
106 
107  float lsf_q[4][LP_FILTER_ORDER];
109 
110  float lpc[4][LP_FILTER_ORDER];
111 
113 
115  float *excitation;
116 
119 
120  float prediction_error[4];
121  float pitch_gain[5];
122  float fixed_gain[5];
123 
124  float beta;
127 
131 
132  float postfilter_mem[10];
133  float tilt_mem;
135  float high_pass_mem[2];
136 
138 
139 } AMRContext;
140 
142 static void weighted_vector_sumd(double *out, const double *in_a,
143  const double *in_b, double weight_coeff_a,
144  double weight_coeff_b, int length)
145 {
146  int i;
147 
148  for (i = 0; i < length; i++)
149  out[i] = weight_coeff_a * in_a[i]
150  + weight_coeff_b * in_b[i];
151 }
152 
154 {
155  AMRContext *p = avctx->priv_data;
156  int i;
157 
158  if (avctx->channels > 1) {
159  avpriv_report_missing_feature(avctx, "multi-channel AMR");
160  return AVERROR_PATCHWELCOME;
161  }
162 
163  avctx->channels = 1;
165  avctx->sample_rate = 8000;
166  avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
167 
168  // p->excitation always points to the same position in p->excitation_buf
170 
171  for (i = 0; i < LP_FILTER_ORDER; i++) {
172  p->prev_lsp_sub4[i] = lsp_sub4_init[i] * 1000 / (float)(1 << 15);
173  p->lsf_avg[i] = p->lsf_q[3][i] = lsp_avg_init[i] / (float)(1 << 15);
174  }
175 
176  for (i = 0; i < 4; i++)
178 
179  return 0;
180 }
181 
182 
194 static enum Mode unpack_bitstream(AMRContext *p, const uint8_t *buf,
195  int buf_size)
196 {
197  enum Mode mode;
198 
199  // Decode the first octet.
200  mode = buf[0] >> 3 & 0x0F; // frame type
201  p->bad_frame_indicator = (buf[0] & 0x4) != 0x4; // quality bit
202 
203  if (mode >= N_MODES || buf_size < frame_sizes_nb[mode] + 1) {
204  return NO_DATA;
205  }
206 
207  if (mode < MODE_DTX)
208  ff_amr_bit_reorder((uint16_t *) &p->frame, sizeof(AMRNBFrame), buf + 1,
210 
211  return mode;
212 }
213 
214 
217 
225 static void interpolate_lsf(float lsf_q[4][LP_FILTER_ORDER], float *lsf_new)
226 {
227  int i;
228 
229  for (i = 0; i < 4; i++)
230  ff_weighted_vector_sumf(lsf_q[i], lsf_q[3], lsf_new,
231  0.25 * (3 - i), 0.25 * (i + 1),
232  LP_FILTER_ORDER);
233 }
234 
246 static void lsf2lsp_for_mode12k2(AMRContext *p, double lsp[LP_FILTER_ORDER],
247  const float lsf_no_r[LP_FILTER_ORDER],
248  const int16_t *lsf_quantizer[5],
249  const int quantizer_offset,
250  const int sign, const int update)
251 {
252  int16_t lsf_r[LP_FILTER_ORDER]; // residual LSF vector
253  float lsf_q[LP_FILTER_ORDER]; // quantified LSF vector
254  int i;
255 
256  for (i = 0; i < LP_FILTER_ORDER >> 1; i++)
257  memcpy(&lsf_r[i << 1], &lsf_quantizer[i][quantizer_offset],
258  2 * sizeof(*lsf_r));
259 
260  if (sign) {
261  lsf_r[4] *= -1;
262  lsf_r[5] *= -1;
263  }
264 
265  if (update)
266  memcpy(p->prev_lsf_r, lsf_r, LP_FILTER_ORDER * sizeof(*lsf_r));
267 
268  for (i = 0; i < LP_FILTER_ORDER; i++)
269  lsf_q[i] = lsf_r[i] * (LSF_R_FAC / 8000.0) + lsf_no_r[i] * (1.0 / 8000.0);
270 
271  ff_set_min_dist_lsf(lsf_q, MIN_LSF_SPACING, LP_FILTER_ORDER);
272 
273  if (update)
274  interpolate_lsf(p->lsf_q, lsf_q);
275 
276  ff_acelp_lsf2lspd(lsp, lsf_q, LP_FILTER_ORDER);
277 }
278 
284 static void lsf2lsp_5(AMRContext *p)
285 {
286  const uint16_t *lsf_param = p->frame.lsf;
287  float lsf_no_r[LP_FILTER_ORDER]; // LSFs without the residual vector
288  const int16_t *lsf_quantizer[5];
289  int i;
290 
291  lsf_quantizer[0] = lsf_5_1[lsf_param[0]];
292  lsf_quantizer[1] = lsf_5_2[lsf_param[1]];
293  lsf_quantizer[2] = lsf_5_3[lsf_param[2] >> 1];
294  lsf_quantizer[3] = lsf_5_4[lsf_param[3]];
295  lsf_quantizer[4] = lsf_5_5[lsf_param[4]];
296 
297  for (i = 0; i < LP_FILTER_ORDER; i++)
298  lsf_no_r[i] = p->prev_lsf_r[i] * LSF_R_FAC * PRED_FAC_MODE_12k2 + lsf_5_mean[i];
299 
300  lsf2lsp_for_mode12k2(p, p->lsp[1], lsf_no_r, lsf_quantizer, 0, lsf_param[2] & 1, 0);
301  lsf2lsp_for_mode12k2(p, p->lsp[3], lsf_no_r, lsf_quantizer, 2, lsf_param[2] & 1, 1);
302 
303  // interpolate LSP vectors at subframes 1 and 3
304  weighted_vector_sumd(p->lsp[0], p->prev_lsp_sub4, p->lsp[1], 0.5, 0.5, LP_FILTER_ORDER);
305  weighted_vector_sumd(p->lsp[2], p->lsp[1] , p->lsp[3], 0.5, 0.5, LP_FILTER_ORDER);
306 }
307 
313 static void lsf2lsp_3(AMRContext *p)
314 {
315  const uint16_t *lsf_param = p->frame.lsf;
316  int16_t lsf_r[LP_FILTER_ORDER]; // residual LSF vector
317  float lsf_q[LP_FILTER_ORDER]; // quantified LSF vector
318  const int16_t *lsf_quantizer;
319  int i, j;
320 
321  lsf_quantizer = (p->cur_frame_mode == MODE_7k95 ? lsf_3_1_MODE_7k95 : lsf_3_1)[lsf_param[0]];
322  memcpy(lsf_r, lsf_quantizer, 3 * sizeof(*lsf_r));
323 
324  lsf_quantizer = lsf_3_2[lsf_param[1] << (p->cur_frame_mode <= MODE_5k15)];
325  memcpy(lsf_r + 3, lsf_quantizer, 3 * sizeof(*lsf_r));
326 
327  lsf_quantizer = (p->cur_frame_mode <= MODE_5k15 ? lsf_3_3_MODE_5k15 : lsf_3_3)[lsf_param[2]];
328  memcpy(lsf_r + 6, lsf_quantizer, 4 * sizeof(*lsf_r));
329 
330  // calculate mean-removed LSF vector and add mean
331  for (i = 0; i < LP_FILTER_ORDER; i++)
332  lsf_q[i] = (lsf_r[i] + p->prev_lsf_r[i] * pred_fac[i]) * (LSF_R_FAC / 8000.0) + lsf_3_mean[i] * (1.0 / 8000.0);
333 
334  ff_set_min_dist_lsf(lsf_q, MIN_LSF_SPACING, LP_FILTER_ORDER);
335 
336  // store data for computing the next frame's LSFs
337  interpolate_lsf(p->lsf_q, lsf_q);
338  memcpy(p->prev_lsf_r, lsf_r, LP_FILTER_ORDER * sizeof(*lsf_r));
339 
340  ff_acelp_lsf2lspd(p->lsp[3], lsf_q, LP_FILTER_ORDER);
341 
342  // interpolate LSP vectors at subframes 1, 2 and 3
343  for (i = 1; i <= 3; i++)
344  for(j = 0; j < LP_FILTER_ORDER; j++)
345  p->lsp[i-1][j] = p->prev_lsp_sub4[j] +
346  (p->lsp[3][j] - p->prev_lsp_sub4[j]) * 0.25 * i;
347 }
348 
350 
351 
354 
358 static void decode_pitch_lag_1_6(int *lag_int, int *lag_frac, int pitch_index,
359  const int prev_lag_int, const int subframe)
360 {
361  if (subframe == 0 || subframe == 2) {
362  if (pitch_index < 463) {
363  *lag_int = (pitch_index + 107) * 10923 >> 16;
364  *lag_frac = pitch_index - *lag_int * 6 + 105;
365  } else {
366  *lag_int = pitch_index - 368;
367  *lag_frac = 0;
368  }
369  } else {
370  *lag_int = ((pitch_index + 5) * 10923 >> 16) - 1;
371  *lag_frac = pitch_index - *lag_int * 6 - 3;
372  *lag_int += av_clip(prev_lag_int - 5, PITCH_LAG_MIN_MODE_12k2,
373  PITCH_DELAY_MAX - 9);
374  }
375 }
376 
378  const AMRNBSubframe *amr_subframe,
379  const int subframe)
380 {
381  int pitch_lag_int, pitch_lag_frac;
382  enum Mode mode = p->cur_frame_mode;
383 
384  if (p->cur_frame_mode == MODE_12k2) {
385  decode_pitch_lag_1_6(&pitch_lag_int, &pitch_lag_frac,
386  amr_subframe->p_lag, p->pitch_lag_int,
387  subframe);
388  } else
389  ff_decode_pitch_lag(&pitch_lag_int, &pitch_lag_frac,
390  amr_subframe->p_lag,
391  p->pitch_lag_int, subframe,
392  mode != MODE_4k75 && mode != MODE_5k15,
393  mode <= MODE_6k7 ? 4 : (mode == MODE_7k95 ? 5 : 6));
394 
395  p->pitch_lag_int = pitch_lag_int; // store previous lag in a uint8_t
396 
397  pitch_lag_frac <<= (p->cur_frame_mode != MODE_12k2);
398 
399  pitch_lag_int += pitch_lag_frac > 0;
400 
401  /* Calculate the pitch vector by interpolating the past excitation at the
402  pitch lag using a b60 hamming windowed sinc function. */
403  ff_acelp_interpolatef(p->excitation, p->excitation + 1 - pitch_lag_int,
404  ff_b60_sinc, 6,
405  pitch_lag_frac + 6 - 6*(pitch_lag_frac > 0),
406  10, AMR_SUBFRAME_SIZE);
407 
408  memcpy(p->pitch_vector, p->excitation, AMR_SUBFRAME_SIZE * sizeof(float));
409 }
410 
412 
413 
416 
420 static void decode_10bit_pulse(int code, int pulse_position[8],
421  int i1, int i2, int i3)
422 {
423  // coded using 7+3 bits with the 3 LSBs being, individually, the LSB of 1 of
424  // the 3 pulses and the upper 7 bits being coded in base 5
425  const uint8_t *positions = base_five_table[code >> 3];
426  pulse_position[i1] = (positions[2] << 1) + ( code & 1);
427  pulse_position[i2] = (positions[1] << 1) + ((code >> 1) & 1);
428  pulse_position[i3] = (positions[0] << 1) + ((code >> 2) & 1);
429 }
430 
438 static void decode_8_pulses_31bits(const int16_t *fixed_index,
439  AMRFixed *fixed_sparse)
440 {
441  int pulse_position[8];
442  int i, temp;
443 
444  decode_10bit_pulse(fixed_index[4], pulse_position, 0, 4, 1);
445  decode_10bit_pulse(fixed_index[5], pulse_position, 2, 6, 5);
446 
447  // coded using 5+2 bits with the 2 LSBs being, individually, the LSB of 1 of
448  // the 2 pulses and the upper 5 bits being coded in base 5
449  temp = ((fixed_index[6] >> 2) * 25 + 12) >> 5;
450  pulse_position[3] = temp % 5;
451  pulse_position[7] = temp / 5;
452  if (pulse_position[7] & 1)
453  pulse_position[3] = 4 - pulse_position[3];
454  pulse_position[3] = (pulse_position[3] << 1) + ( fixed_index[6] & 1);
455  pulse_position[7] = (pulse_position[7] << 1) + ((fixed_index[6] >> 1) & 1);
456 
457  fixed_sparse->n = 8;
458  for (i = 0; i < 4; i++) {
459  const int pos1 = (pulse_position[i] << 2) + i;
460  const int pos2 = (pulse_position[i + 4] << 2) + i;
461  const float sign = fixed_index[i] ? -1.0 : 1.0;
462  fixed_sparse->x[i ] = pos1;
463  fixed_sparse->x[i + 4] = pos2;
464  fixed_sparse->y[i ] = sign;
465  fixed_sparse->y[i + 4] = pos2 < pos1 ? -sign : sign;
466  }
467 }
468 
484 static void decode_fixed_sparse(AMRFixed *fixed_sparse, const uint16_t *pulses,
485  const enum Mode mode, const int subframe)
486 {
487  assert(MODE_4k75 <= mode && mode <= MODE_12k2);
488 
489  if (mode == MODE_12k2) {
490  ff_decode_10_pulses_35bits(pulses, fixed_sparse, gray_decode, 5, 3);
491  } else if (mode == MODE_10k2) {
492  decode_8_pulses_31bits(pulses, fixed_sparse);
493  } else {
494  int *pulse_position = fixed_sparse->x;
495  int i, pulse_subset;
496  const int fixed_index = pulses[0];
497 
498  if (mode <= MODE_5k15) {
499  pulse_subset = ((fixed_index >> 3) & 8) + (subframe << 1);
500  pulse_position[0] = ( fixed_index & 7) * 5 + track_position[pulse_subset];
501  pulse_position[1] = ((fixed_index >> 3) & 7) * 5 + track_position[pulse_subset + 1];
502  fixed_sparse->n = 2;
503  } else if (mode == MODE_5k9) {
504  pulse_subset = ((fixed_index & 1) << 1) + 1;
505  pulse_position[0] = ((fixed_index >> 1) & 7) * 5 + pulse_subset;
506  pulse_subset = (fixed_index >> 4) & 3;
507  pulse_position[1] = ((fixed_index >> 6) & 7) * 5 + pulse_subset + (pulse_subset == 3 ? 1 : 0);
508  fixed_sparse->n = pulse_position[0] == pulse_position[1] ? 1 : 2;
509  } else if (mode == MODE_6k7) {
510  pulse_position[0] = (fixed_index & 7) * 5;
511  pulse_subset = (fixed_index >> 2) & 2;
512  pulse_position[1] = ((fixed_index >> 4) & 7) * 5 + pulse_subset + 1;
513  pulse_subset = (fixed_index >> 6) & 2;
514  pulse_position[2] = ((fixed_index >> 8) & 7) * 5 + pulse_subset + 2;
515  fixed_sparse->n = 3;
516  } else { // mode <= MODE_7k95
517  pulse_position[0] = gray_decode[ fixed_index & 7];
518  pulse_position[1] = gray_decode[(fixed_index >> 3) & 7] + 1;
519  pulse_position[2] = gray_decode[(fixed_index >> 6) & 7] + 2;
520  pulse_subset = (fixed_index >> 9) & 1;
521  pulse_position[3] = gray_decode[(fixed_index >> 10) & 7] + pulse_subset + 3;
522  fixed_sparse->n = 4;
523  }
524  for (i = 0; i < fixed_sparse->n; i++)
525  fixed_sparse->y[i] = (pulses[1] >> i) & 1 ? 1.0 : -1.0;
526  }
527 }
528 
537 static void pitch_sharpening(AMRContext *p, int subframe, enum Mode mode,
538  AMRFixed *fixed_sparse)
539 {
540  // The spec suggests the current pitch gain is always used, but in other
541  // modes the pitch and codebook gains are joinly quantized (sec 5.8.2)
542  // so the codebook gain cannot depend on the quantized pitch gain.
543  if (mode == MODE_12k2)
544  p->beta = FFMIN(p->pitch_gain[4], 1.0);
545 
546  fixed_sparse->pitch_lag = p->pitch_lag_int;
547  fixed_sparse->pitch_fac = p->beta;
548 
549  // Save pitch sharpening factor for the next subframe
550  // MODE_4k75 only updates on the 2nd and 4th subframes - this follows from
551  // the fact that the gains for two subframes are jointly quantized.
552  if (mode != MODE_4k75 || subframe & 1)
553  p->beta = av_clipf(p->pitch_gain[4], 0.0, SHARP_MAX);
554 }
556 
557 
560 
573 static float fixed_gain_smooth(AMRContext *p , const float *lsf,
574  const float *lsf_avg, const enum Mode mode)
575 {
576  float diff = 0.0;
577  int i;
578 
579  for (i = 0; i < LP_FILTER_ORDER; i++)
580  diff += fabs(lsf_avg[i] - lsf[i]) / lsf_avg[i];
581 
582  // If diff is large for ten subframes, disable smoothing for a 40-subframe
583  // hangover period.
584  p->diff_count++;
585  if (diff <= 0.65)
586  p->diff_count = 0;
587 
588  if (p->diff_count > 10) {
589  p->hang_count = 0;
590  p->diff_count--; // don't let diff_count overflow
591  }
592 
593  if (p->hang_count < 40) {
594  p->hang_count++;
595  } else if (mode < MODE_7k4 || mode == MODE_10k2) {
596  const float smoothing_factor = av_clipf(4.0 * diff - 1.6, 0.0, 1.0);
597  const float fixed_gain_mean = (p->fixed_gain[0] + p->fixed_gain[1] +
598  p->fixed_gain[2] + p->fixed_gain[3] +
599  p->fixed_gain[4]) * 0.2;
600  return smoothing_factor * p->fixed_gain[4] +
601  (1.0 - smoothing_factor) * fixed_gain_mean;
602  }
603  return p->fixed_gain[4];
604 }
605 
615 static void decode_gains(AMRContext *p, const AMRNBSubframe *amr_subframe,
616  const enum Mode mode, const int subframe,
617  float *fixed_gain_factor)
618 {
619  if (mode == MODE_12k2 || mode == MODE_7k95) {
620  p->pitch_gain[4] = qua_gain_pit [amr_subframe->p_gain ]
621  * (1.0 / 16384.0);
622  *fixed_gain_factor = qua_gain_code[amr_subframe->fixed_gain]
623  * (1.0 / 2048.0);
624  } else {
625  const uint16_t *gains;
626 
627  if (mode >= MODE_6k7) {
628  gains = gains_high[amr_subframe->p_gain];
629  } else if (mode >= MODE_5k15) {
630  gains = gains_low [amr_subframe->p_gain];
631  } else {
632  // gain index is only coded in subframes 0,2 for MODE_4k75
633  gains = gains_MODE_4k75[(p->frame.subframe[subframe & 2].p_gain << 1) + (subframe & 1)];
634  }
635 
636  p->pitch_gain[4] = gains[0] * (1.0 / 16384.0);
637  *fixed_gain_factor = gains[1] * (1.0 / 4096.0);
638  }
639 }
640 
642 
643 
646 
657 static void apply_ir_filter(float *out, const AMRFixed *in,
658  const float *filter)
659 {
660  float filter1[AMR_SUBFRAME_SIZE],
661  filter2[AMR_SUBFRAME_SIZE];
662  int lag = in->pitch_lag;
663  float fac = in->pitch_fac;
664  int i;
665 
666  if (lag < AMR_SUBFRAME_SIZE) {
667  ff_celp_circ_addf(filter1, filter, filter, lag, fac,
669 
670  if (lag < AMR_SUBFRAME_SIZE >> 1)
671  ff_celp_circ_addf(filter2, filter, filter1, lag, fac,
673  }
674 
675  memset(out, 0, sizeof(float) * AMR_SUBFRAME_SIZE);
676  for (i = 0; i < in->n; i++) {
677  int x = in->x[i];
678  float y = in->y[i];
679  const float *filterp;
680 
681  if (x >= AMR_SUBFRAME_SIZE - lag) {
682  filterp = filter;
683  } else if (x >= AMR_SUBFRAME_SIZE - (lag << 1)) {
684  filterp = filter1;
685  } else
686  filterp = filter2;
687 
688  ff_celp_circ_addf(out, out, filterp, x, y, AMR_SUBFRAME_SIZE);
689  }
690 }
691 
704 static const float *anti_sparseness(AMRContext *p, AMRFixed *fixed_sparse,
705  const float *fixed_vector,
706  float fixed_gain, float *out)
707 {
708  int ir_filter_nr;
709 
710  if (p->pitch_gain[4] < 0.6) {
711  ir_filter_nr = 0; // strong filtering
712  } else if (p->pitch_gain[4] < 0.9) {
713  ir_filter_nr = 1; // medium filtering
714  } else
715  ir_filter_nr = 2; // no filtering
716 
717  // detect 'onset'
718  if (fixed_gain > 2.0 * p->prev_sparse_fixed_gain) {
719  p->ir_filter_onset = 2;
720  } else if (p->ir_filter_onset)
721  p->ir_filter_onset--;
722 
723  if (!p->ir_filter_onset) {
724  int i, count = 0;
725 
726  for (i = 0; i < 5; i++)
727  if (p->pitch_gain[i] < 0.6)
728  count++;
729  if (count > 2)
730  ir_filter_nr = 0;
731 
732  if (ir_filter_nr > p->prev_ir_filter_nr + 1)
733  ir_filter_nr--;
734  } else if (ir_filter_nr < 2)
735  ir_filter_nr++;
736 
737  // Disable filtering for very low level of fixed_gain.
738  // Note this step is not specified in the technical description but is in
739  // the reference source in the function Ph_disp.
740  if (fixed_gain < 5.0)
741  ir_filter_nr = 2;
742 
744  && ir_filter_nr < 2) {
745  apply_ir_filter(out, fixed_sparse,
746  (p->cur_frame_mode == MODE_7k95 ?
748  ir_filters_lookup)[ir_filter_nr]);
749  fixed_vector = out;
750  }
751 
752  // update ir filter strength history
753  p->prev_ir_filter_nr = ir_filter_nr;
754  p->prev_sparse_fixed_gain = fixed_gain;
755 
756  return fixed_vector;
757 }
758 
760 
761 
764 
775 static int synthesis(AMRContext *p, float *lpc,
776  float fixed_gain, const float *fixed_vector,
777  float *samples, uint8_t overflow)
778 {
779  int i;
780  float excitation[AMR_SUBFRAME_SIZE];
781 
782  // if an overflow has been detected, the pitch vector is scaled down by a
783  // factor of 4
784  if (overflow)
785  for (i = 0; i < AMR_SUBFRAME_SIZE; i++)
786  p->pitch_vector[i] *= 0.25;
787 
788  ff_weighted_vector_sumf(excitation, p->pitch_vector, fixed_vector,
789  p->pitch_gain[4], fixed_gain, AMR_SUBFRAME_SIZE);
790 
791  // emphasize pitch vector contribution
792  if (p->pitch_gain[4] > 0.5 && !overflow) {
793  float energy = avpriv_scalarproduct_float_c(excitation, excitation,
794  AMR_SUBFRAME_SIZE);
795  float pitch_factor =
796  p->pitch_gain[4] *
797  (p->cur_frame_mode == MODE_12k2 ?
798  0.25 * FFMIN(p->pitch_gain[4], 1.0) :
799  0.5 * FFMIN(p->pitch_gain[4], SHARP_MAX));
800 
801  for (i = 0; i < AMR_SUBFRAME_SIZE; i++)
802  excitation[i] += pitch_factor * p->pitch_vector[i];
803 
804  ff_scale_vector_to_given_sum_of_squares(excitation, excitation, energy,
805  AMR_SUBFRAME_SIZE);
806  }
807 
808  ff_celp_lp_synthesis_filterf(samples, lpc, excitation, AMR_SUBFRAME_SIZE,
810 
811  // detect overflow
812  for (i = 0; i < AMR_SUBFRAME_SIZE; i++)
813  if (fabsf(samples[i]) > AMR_SAMPLE_BOUND) {
814  return 1;
815  }
816 
817  return 0;
818 }
819 
821 
822 
825 
831 static void update_state(AMRContext *p)
832 {
833  memcpy(p->prev_lsp_sub4, p->lsp[3], LP_FILTER_ORDER * sizeof(p->lsp[3][0]));
834 
835  memmove(&p->excitation_buf[0], &p->excitation_buf[AMR_SUBFRAME_SIZE],
836  (PITCH_DELAY_MAX + LP_FILTER_ORDER + 1) * sizeof(float));
837 
838  memmove(&p->pitch_gain[0], &p->pitch_gain[1], 4 * sizeof(float));
839  memmove(&p->fixed_gain[0], &p->fixed_gain[1], 4 * sizeof(float));
840 
841  memmove(&p->samples_in[0], &p->samples_in[AMR_SUBFRAME_SIZE],
842  LP_FILTER_ORDER * sizeof(float));
843 }
844 
846 
847 
850 
857 static float tilt_factor(float *lpc_n, float *lpc_d)
858 {
859  float rh0, rh1; // autocorrelation at lag 0 and 1
860 
861  // LP_FILTER_ORDER prior zeros are needed for ff_celp_lp_synthesis_filterf
862  float impulse_buffer[LP_FILTER_ORDER + AMR_TILT_RESPONSE] = { 0 };
863  float *hf = impulse_buffer + LP_FILTER_ORDER; // start of impulse response
864 
865  hf[0] = 1.0;
866  memcpy(hf + 1, lpc_n, sizeof(float) * LP_FILTER_ORDER);
868  LP_FILTER_ORDER);
869 
871  rh1 = avpriv_scalarproduct_float_c(hf, hf + 1, AMR_TILT_RESPONSE - 1);
872 
873  // The spec only specifies this check for 12.2 and 10.2 kbit/s
874  // modes. But in the ref source the tilt is always non-negative.
875  return rh1 >= 0.0 ? rh1 / rh0 * AMR_TILT_GAMMA_T : 0.0;
876 }
877 
886 static void postfilter(AMRContext *p, float *lpc, float *buf_out)
887 {
888  int i;
889  float *samples = p->samples_in + LP_FILTER_ORDER; // Start of input
890 
891  float speech_gain = avpriv_scalarproduct_float_c(samples, samples,
893 
894  float pole_out[AMR_SUBFRAME_SIZE + LP_FILTER_ORDER]; // Output of pole filter
895  const float *gamma_n, *gamma_d; // Formant filter factor table
896  float lpc_n[LP_FILTER_ORDER], lpc_d[LP_FILTER_ORDER]; // Transfer function coefficients
897 
898  if (p->cur_frame_mode == MODE_12k2 || p->cur_frame_mode == MODE_10k2) {
899  gamma_n = ff_pow_0_7;
900  gamma_d = ff_pow_0_75;
901  } else {
902  gamma_n = ff_pow_0_55;
903  gamma_d = ff_pow_0_7;
904  }
905 
906  for (i = 0; i < LP_FILTER_ORDER; i++) {
907  lpc_n[i] = lpc[i] * gamma_n[i];
908  lpc_d[i] = lpc[i] * gamma_d[i];
909  }
910 
911  memcpy(pole_out, p->postfilter_mem, sizeof(float) * LP_FILTER_ORDER);
912  ff_celp_lp_synthesis_filterf(pole_out + LP_FILTER_ORDER, lpc_d, samples,
913  AMR_SUBFRAME_SIZE, LP_FILTER_ORDER);
914  memcpy(p->postfilter_mem, pole_out + AMR_SUBFRAME_SIZE,
915  sizeof(float) * LP_FILTER_ORDER);
916 
917  ff_celp_lp_zero_synthesis_filterf(buf_out, lpc_n,
918  pole_out + LP_FILTER_ORDER,
919  AMR_SUBFRAME_SIZE, LP_FILTER_ORDER);
920 
921  ff_tilt_compensation(&p->tilt_mem, tilt_factor(lpc_n, lpc_d), buf_out,
923 
924  ff_adaptive_gain_control(buf_out, buf_out, speech_gain, AMR_SUBFRAME_SIZE,
926 }
927 
929 
930 static int amrnb_decode_frame(AVCodecContext *avctx, void *data,
931  int *got_frame_ptr, AVPacket *avpkt)
932 {
933 
934  AMRContext *p = avctx->priv_data; // pointer to private data
935  AVFrame *frame = data;
936  const uint8_t *buf = avpkt->data;
937  int buf_size = avpkt->size;
938  float *buf_out; // pointer to the output data buffer
939  int i, subframe, ret;
940  float fixed_gain_factor;
941  AMRFixed fixed_sparse = {0}; // fixed vector up to anti-sparseness processing
942  float spare_vector[AMR_SUBFRAME_SIZE]; // extra stack space to hold result from anti-sparseness processing
943  float synth_fixed_gain; // the fixed gain that synthesis should use
944  const float *synth_fixed_vector; // pointer to the fixed vector that synthesis should use
945 
946  /* get output buffer */
947  frame->nb_samples = AMR_BLOCK_SIZE;
948  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
949  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
950  return ret;
951  }
952  buf_out = (float *)frame->data[0];
953 
954  p->cur_frame_mode = unpack_bitstream(p, buf, buf_size);
955  if (p->cur_frame_mode == NO_DATA) {
956  av_log(avctx, AV_LOG_ERROR, "Corrupt bitstream\n");
957  return AVERROR_INVALIDDATA;
958  }
959  if (p->cur_frame_mode == MODE_DTX) {
960  avpriv_request_sample(avctx, "dtx mode");
961  return AVERROR_PATCHWELCOME;
962  }
963 
964  if (p->cur_frame_mode == MODE_12k2) {
965  lsf2lsp_5(p);
966  } else
967  lsf2lsp_3(p);
968 
969  for (i = 0; i < 4; i++)
970  ff_acelp_lspd2lpc(p->lsp[i], p->lpc[i], 5);
971 
972  for (subframe = 0; subframe < 4; subframe++) {
973  const AMRNBSubframe *amr_subframe = &p->frame.subframe[subframe];
974 
975  decode_pitch_vector(p, amr_subframe, subframe);
976 
977  decode_fixed_sparse(&fixed_sparse, amr_subframe->pulses,
978  p->cur_frame_mode, subframe);
979 
980  // The fixed gain (section 6.1.3) depends on the fixed vector
981  // (section 6.1.2), but the fixed vector calculation uses
982  // pitch sharpening based on the on the pitch gain (section 6.1.3).
983  // So the correct order is: pitch gain, pitch sharpening, fixed gain.
984  decode_gains(p, amr_subframe, p->cur_frame_mode, subframe,
985  &fixed_gain_factor);
986 
987  pitch_sharpening(p, subframe, p->cur_frame_mode, &fixed_sparse);
988 
989  if (fixed_sparse.pitch_lag == 0) {
990  av_log(avctx, AV_LOG_ERROR, "The file is corrupted, pitch_lag = 0 is not allowed\n");
991  return AVERROR_INVALIDDATA;
992  }
993  ff_set_fixed_vector(p->fixed_vector, &fixed_sparse, 1.0,
995 
996  p->fixed_gain[4] =
997  ff_amr_set_fixed_gain(fixed_gain_factor,
999  p->fixed_vector,
1002  p->prediction_error,
1004 
1005  // The excitation feedback is calculated without any processing such
1006  // as fixed gain smoothing. This isn't mentioned in the specification.
1007  for (i = 0; i < AMR_SUBFRAME_SIZE; i++)
1008  p->excitation[i] *= p->pitch_gain[4];
1009  ff_set_fixed_vector(p->excitation, &fixed_sparse, p->fixed_gain[4],
1010  AMR_SUBFRAME_SIZE);
1011 
1012  // In the ref decoder, excitation is stored with no fractional bits.
1013  // This step prevents buzz in silent periods. The ref encoder can
1014  // emit long sequences with pitch factor greater than one. This
1015  // creates unwanted feedback if the excitation vector is nonzero.
1016  // (e.g. test sequence T19_795.COD in 3GPP TS 26.074)
1017  for (i = 0; i < AMR_SUBFRAME_SIZE; i++)
1018  p->excitation[i] = truncf(p->excitation[i]);
1019 
1020  // Smooth fixed gain.
1021  // The specification is ambiguous, but in the reference source, the
1022  // smoothed value is NOT fed back into later fixed gain smoothing.
1023  synth_fixed_gain = fixed_gain_smooth(p, p->lsf_q[subframe],
1024  p->lsf_avg, p->cur_frame_mode);
1025 
1026  synth_fixed_vector = anti_sparseness(p, &fixed_sparse, p->fixed_vector,
1027  synth_fixed_gain, spare_vector);
1028 
1029  if (synthesis(p, p->lpc[subframe], synth_fixed_gain,
1030  synth_fixed_vector, &p->samples_in[LP_FILTER_ORDER], 0))
1031  // overflow detected -> rerun synthesis scaling pitch vector down
1032  // by a factor of 4, skipping pitch vector contribution emphasis
1033  // and adaptive gain control
1034  synthesis(p, p->lpc[subframe], synth_fixed_gain,
1035  synth_fixed_vector, &p->samples_in[LP_FILTER_ORDER], 1);
1036 
1037  postfilter(p, p->lpc[subframe], buf_out + subframe * AMR_SUBFRAME_SIZE);
1038 
1039  // update buffers and history
1040  ff_clear_fixed_vector(p->fixed_vector, &fixed_sparse, AMR_SUBFRAME_SIZE);
1041  update_state(p);
1042  }
1043 
1048 
1049  /* Update averaged lsf vector (used for fixed gain smoothing).
1050  *
1051  * Note that lsf_avg should not incorporate the current frame's LSFs
1052  * for fixed_gain_smooth.
1053  * The specification has an incorrect formula: the reference decoder uses
1054  * qbar(n-1) rather than qbar(n) in section 6.1(4) equation 71. */
1056  0.84, 0.16, LP_FILTER_ORDER);
1057 
1058  *got_frame_ptr = 1;
1059 
1060  /* return the amount of bytes consumed if everything was OK */
1061  return frame_sizes_nb[p->cur_frame_mode] + 1; // +7 for rounding and +8 for TOC
1062 }
1063 
1064 
1066  .name = "amrnb",
1067  .long_name = NULL_IF_CONFIG_SMALL("AMR-NB (Adaptive Multi-Rate NarrowBand)"),
1068  .type = AVMEDIA_TYPE_AUDIO,
1069  .id = AV_CODEC_ID_AMR_NB,
1070  .priv_data_size = sizeof(AMRContext),
1073  .capabilities = CODEC_CAP_DR1,
1074  .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLT,
1076 };
#define AMR_SAMPLE_SCALE
Scale from constructed speech to [-1,1].
Definition: amrnbdec.c:72
void ff_decode_pitch_lag(int *lag_int, int *lag_frac, int pitch_index, const int prev_lag_int, const int subframe, int third_as_first, int resolution)
Decode the adaptive codebook index to the integer and fractional parts of the pitch lag for one subfr...
#define AMR_BLOCK_SIZE
samples per frame
Definition: amrnbdec.c:60
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:54
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
This structure describes decoded (raw) audio or video data.
Definition: frame.h:135
float lsf_avg[LP_FILTER_ORDER]
vector of averaged lsf vector
Definition: amrnbdec.c:108
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.
void ff_decode_10_pulses_35bits(const int16_t *fixed_index, AMRFixed *fixed_sparse, const uint8_t *gray_decode, int half_pulse_count, int bits)
Decode the algebraic codebook index to pulse positions and signs and construct the algebraic codebook...
static int amrnb_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: amrnbdec.c:930
static void pitch_sharpening(AMRContext *p, int subframe, enum Mode mode, AMRFixed *fixed_sparse)
Apply pitch lag to obtain the sharpened fixed vector (section 6.1.2)
Definition: amrnbdec.c:537
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.
AMRNB unpacked data frame.
Definition: amrnbdata.h:68
void ff_clear_fixed_vector(float *out, const AMRFixed *in, int size)
Clear array values set by set_fixed_vector.
static const uint8_t base_five_table[128][3]
Base-5 representation for values 0-124.
Definition: amrnbdata.h:367
int x[10]
Definition: acelp_vectors.h:31
int size
Definition: avcodec.h:974
static const int16_t lsf_3_1[256][3]
Definition: amrnbdata.h:633
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt)>2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);returnNULL;}returnac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_dlog(ac->avr,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> in
static void decode_fixed_sparse(AMRFixed *fixed_sparse, const uint16_t *pulses, const enum Mode mode, const int subframe)
Decode the algebraic codebook index to pulse positions and signs, then construct the algebraic codebo...
Definition: amrnbdec.c:484
static float tilt_factor(float *lpc_n, float *lpc_d)
Get the tilt factor of a formant filter from its transfer function.
Definition: amrnbdec.c:857
static const uint8_t track_position[16]
track start positions for algebraic code book routines
Definition: amrnbdata.h:1433
uint8_t bad_frame_indicator
bad frame ? 1 : 0
Definition: amrnbdec.c:100
silent frame
Definition: amrnbdata.h:48
void ff_set_fixed_vector(float *out, const AMRFixed *in, float scale, int size)
Add fixed vector to an array from a sparse representation.
float pitch_fac
Definition: acelp_vectors.h:35
static float fixed_gain_smooth(AMRContext *p, const float *lsf, const float *lsf_avg, const enum Mode mode)
fixed gain smoothing Note that where the spec specifies the "spectrum in the q domain" in section 6...
Definition: amrnbdec.c:573
static const int16_t lsf_3_2[512][3]
Definition: amrnbdata.h:723
static int synthesis(AMRContext *p, float *lpc, float fixed_gain, const float *fixed_vector, float *samples, uint8_t overflow)
Conduct 10th order linear predictive coding synthesis.
Definition: amrnbdec.c:775
AVCodec.
Definition: avcodec.h:2812
static void weighted_vector_sumd(double *out, const double *in_a, const double *in_b, double weight_coeff_a, double weight_coeff_b, int length)
Double version of ff_weighted_vector_sumf()
Definition: amrnbdec.c:142
static const float * ir_filters_lookup_MODE_7k95[2]
Definition: amrnbdata.h:1661
static av_cold int amrnb_decode_init(AVCodecContext *avctx)
Definition: amrnbdec.c:153
double prev_lsp_sub4[LP_FILTER_ORDER]
lsp vector for the 4th subframe of the previous frame
Definition: amrnbdec.c:105
static void postfilter(AMRContext *p, float *lpc, float *buf_out)
Perform adaptive post-filtering to enhance the quality of the speech.
Definition: amrnbdec.c:886
static const int16_t lsf_5_1[128][4]
Definition: amrnbdata.h:1071
float postfilter_agc
previous factor used for adaptive gain control
Definition: amrnbdec.c:134
no transmission
Definition: amrnbdata.h:50
float avpriv_scalarproduct_float_c(const float *v1, const float *v2, int len)
Return the scalar product of two vectors.
Definition: float_dsp.c:104
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
Definition: mimic.c:275
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1815
uint8_t
#define av_cold
Definition: attributes.h:66
Sparse representation for the algebraic codebook (fixed) vector.
Definition: acelp_vectors.h:29
static const uint16_t qua_gain_code[32]
scalar quantized fixed gain table for 7.95 and 12.2 kbps modes
Definition: amrnbdata.h:1450
Mode
Frame type (Table 1a in 3GPP TS 26.101)
Definition: amrnbdata.h:39
static const uint16_t qua_gain_pit[16]
scalar quantized pitch gain table for 7.95 and 12.2 kbps modes
Definition: amrnbdata.h:1444
#define PITCH_DELAY_MAX
static void lsf2lsp_3(AMRContext *p)
Decode a set of 3 split-matrix quantized lsf indexes into an lsp vector.
Definition: amrnbdec.c:313
static const float energy_pred_fac[4]
4-tap moving average prediction coefficients in reverse order
Definition: amrnbdata.h:1463
uint16_t fixed_gain
index to decode the fixed gain factor, for MODE_12k2 and MODE_7k95
Definition: amrnbdata.h:61
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:684
const char data[16]
Definition: mxf.c:70
static const int8_t lsp_sub4_init[LP_FILTER_ORDER]
Values for the lsp vector from the 4th subframe of the previous subframe values.
Definition: amrnbdata.h:395
5.90 kbit/s
Definition: amrnbdata.h:42
double lsp[4][LP_FILTER_ORDER]
lsp vectors from current frame
Definition: amrnbdec.c:104
uint8_t * data
Definition: avcodec.h:973
static void apply_ir_filter(float *out, const AMRFixed *in, const float *filter)
Circularly convolve a sparse fixed vector with a phase dispersion impulse response filter (D...
Definition: amrnbdec.c:657
AMRNBFrame frame
decoded AMR parameters (lsf coefficients, codebook indexes, etc)
Definition: amrnbdec.c:99
static void interpolate_lsf(float lsf_q[4][LP_FILTER_ORDER], float *lsf_new)
Interpolate the LSF vector (used for fixed gain smoothing).
Definition: amrnbdec.c:225
void ff_adaptive_gain_control(float *out, const float *in, float speech_energ, int size, float alpha, float *gain_mem)
Adaptive gain control (as used in AMR postfiltering)
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
uint16_t lsf[5]
lsf parameters: 5 parameters for MODE_12k2, only 3 for other modes
Definition: amrnbdata.h:69
uint8_t prev_ir_filter_nr
previous impulse response filter "impNr": 0 - strong, 1 - medium, 2 - none
Definition: amrnbdec.c:129
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:123
static void decode_pitch_vector(AMRContext *p, const AMRNBSubframe *amr_subframe, const int subframe)
Definition: amrnbdec.c:377
static void update_state(AMRContext *p)
Update buffers and history at the end of decoding a subframe.
Definition: amrnbdec.c:831
float fixed_vector[AMR_SUBFRAME_SIZE]
algebraic codebook (fixed) vector (must be kept zero between frames)
Definition: amrnbdec.c:118
sample_fmts
Definition: avconv_filter.c:68
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:145
AMRNBSubframe subframe[4]
unpacked data for each subframe
Definition: amrnbdata.h:70
const float ff_pow_0_7[10]
Table of pow(0.7,n)
Definition: acelp_vectors.c:78
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:169
const char * name
Name of the codec implementation.
Definition: avcodec.h:2819
int16_t prev_lsf_r[LP_FILTER_ORDER]
residual LSF vector from previous subframe
Definition: amrnbdec.c:103
static const uint8_t frame_sizes_nb[N_MODES]
number of bytes for each mode
Definition: amrnbdata.h:357
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.
const float ff_pow_0_75[10]
Table of pow(0.75,n)
Definition: acelp_vectors.c:83
float pitch_gain[5]
quantified pitch gains for the current and previous four subframes
Definition: amrnbdec.c:121
#define LP_FILTER_ORDER
linear predictive coding filter order
Definition: amrnbdata.h:53
static const int16_t lsf_3_3_MODE_5k15[128][4]
Definition: amrnbdata.h:413
float * excitation
pointer to the current excitation vector in excitation_buf
Definition: amrnbdec.c:115
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1868
#define AMR_SAMPLE_BOUND
threshold for synthesis overflow
Definition: amrnbdec.c:61
uint8_t ir_filter_onset
flag for impulse response filter strength
Definition: amrnbdec.c:130
static void filter(MpegAudioContext *s, int ch, const short *samples, int incr)
Definition: mpegaudioenc.c:307
#define AMR_SUBFRAME_SIZE
samples per subframe
Definition: amrnbdata.h:36
AMRNB unpacked data subframe.
Definition: amrnbdata.h:58
audio channel layout utility functions
#define MIN_ENERGY
Initial energy in dB.
Definition: amrnbdec.c:82
static const float highpass_poles[2]
Definition: amrnbdata.h:1668
#define FFMIN(a, b)
Definition: common.h:57
AVCodec ff_amrnb_decoder
Definition: amrnbdec.c:1065
number of modes
Definition: amrnbdata.h:49
float samples_in[LP_FILTER_ORDER+AMR_SUBFRAME_SIZE]
floating point samples
Definition: amrnbdec.c:137
12.2 kbit/s
Definition: amrnbdata.h:47
static const int16_t lsf_3_1_MODE_7k95[512][3]
Definition: amrnbdata.h:459
float y[10]
Definition: acelp_vectors.h:32
static const int16_t lsf_5_5[64][4]
Definition: amrnbdata.h:1384
static const float * ir_filters_lookup[2]
Definition: amrnbdata.h:1658
uint16_t p_lag
index to decode the pitch lag
Definition: amrnbdata.h:59
static av_always_inline av_const float truncf(float x)
Definition: libm.h:172
static const float highpass_zeros[2]
Definition: amrnbdata.h:1667
static const uint16_t gains_MODE_4k75[512][2]
gain table for 4.75 kbps mode
Definition: amrnbdata.h:1469
float pitch_vector[AMR_SUBFRAME_SIZE]
adaptive code book (pitch) vector
Definition: amrnbdec.c:117
void ff_tilt_compensation(float *mem, float tilt, float *samples, int size)
Apply tilt compensation filter, 1 - tilt * z-1.
#define MIN_LSF_SPACING
Ensures stability of LPC filter.
Definition: amrnbdec.c:78
static const float lsf_3_mean[LP_FILTER_ORDER]
Definition: amrnbdata.h:1409
void ff_acelp_lspd2lpc(const double *lsp, float *lpc, int lp_half_order)
Reconstruct LPC coefficients from the line spectral pair frequencies.
Definition: lsp.c:201
#define AVERROR_PATCHWELCOME
Not yet implemented in Libav, patches welcome.
Definition: error.h:57
static const float * anti_sparseness(AMRContext *p, AMRFixed *fixed_sparse, const float *fixed_vector, float fixed_gain, float *out)
Reduce fixed vector sparseness by smoothing with one of three IR filters.
Definition: amrnbdec.c:704
uint8_t pitch_lag_int
integer part of pitch lag from current subframe
Definition: amrnbdec.c:112
float tilt_mem
previous input to tilt compensation filter
Definition: amrnbdec.c:133
float lsf_q[4][LP_FILTER_ORDER]
Interpolated LSF vector for fixed gain smoothing.
Definition: amrnbdec.c:107
Libavcodec external API header.
#define PRED_FAC_MODE_12k2
Prediction factor for 12.2kbit/s mode.
Definition: amrnbdec.c:75
AVSampleFormat
Audio Sample Formats.
Definition: samplefmt.h:61
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
AV_SAMPLE_FMT_NONE
Definition: avconv_filter.c:68
int sample_rate
samples per second
Definition: avcodec.h:1807
7.95 kbit/s
Definition: amrnbdata.h:45
float high_pass_mem[2]
previous intermediate values in the high-pass filter
Definition: amrnbdec.c:135
main external API structure.
Definition: avcodec.h:1050
static const float lsf_5_mean[LP_FILTER_ORDER]
Definition: amrnbdata.h:1414
10.2 kbit/s
Definition: amrnbdata.h:46
uint16_t p_gain
index to decode the pitch gain
Definition: amrnbdata.h:60
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: utils.c:612
uint8_t diff_count
the number of subframes for which diff has been above 0.65
Definition: amrnbdec.c:125
static const uint8_t *const amr_unpacking_bitmaps_per_mode[N_MODES]
position of the bitmapping data for each packet type in the AMRNBFrame
Definition: amrnbdata.h:345
float prediction_error[4]
quantified prediction errors {20log10(^gamma_gc)} for previous four subframes
Definition: amrnbdec.c:120
static const float highpass_gain
Definition: amrnbdata.h:1669
void ff_acelp_lsf2lspd(double *lsp, const float *lsf, int lp_order)
Floating point version of ff_acelp_lsf2lsp()
Definition: lsp.c:91
enum Mode cur_frame_mode
Definition: amrnbdec.c:101
float fixed_gain[5]
quantified fixed gains for the current and previous four subframes
Definition: amrnbdec.c:122
void ff_celp_lp_zero_synthesis_filterf(float *out, const float *filter_coeffs, const float *in, int buffer_length, int filter_length)
LP zero synthesis filter.
Definition: celp_filters.c:196
float lpc[4][LP_FILTER_ORDER]
lpc coefficient vectors for 4 subframes
Definition: amrnbdec.c:110
float beta
previous pitch_gain, bounded by [0.0,SHARP_MAX]
Definition: amrnbdec.c:124
#define SHARP_MAX
Maximum sharpening factor.
Definition: amrnbdec.c:89
#define AMR_TILT_RESPONSE
Number of impulse response coefficients used for tilt factor.
Definition: amrnbdec.c:92
static void decode_8_pulses_31bits(const int16_t *fixed_index, AMRFixed *fixed_sparse)
Decode the algebraic codebook index to pulse positions and signs and construct the algebraic codebook...
Definition: amrnbdec.c:438
static void decode_pitch_lag_1_6(int *lag_int, int *lag_frac, int pitch_index, const int prev_lag_int, const int subframe)
Like ff_decode_pitch_lag(), but with 1/6 resolution.
Definition: amrnbdec.c:358
static const int16_t lsf_5_4[256][4]
Definition: amrnbdata.h:1295
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
static void decode_10bit_pulse(int code, int pulse_position[8], int i1, int i2, int i3)
Decode a 10-bit algebraic codebook index from a 10.2 kbit/s frame.
Definition: amrnbdec.c:420
static const int16_t lsf_3_3[512][4]
Definition: amrnbdata.h:897
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:141
static const int16_t lsf_5_2[256][4]
Definition: amrnbdata.h:1117
static const uint8_t gray_decode[8]
3-bit Gray code to binary lookup table
Definition: amrnbdata.h:1438
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt)>2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);returnNULL;}returnac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_dlog(ac->avr,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> out
static const float pred_fac[LP_FILTER_ORDER]
Prediction factor table for modes other than 12.2kbit/s.
Definition: amrnbdata.h:1420
float prev_sparse_fixed_gain
previous fixed gain; used by anti-sparseness processing to determine "onset"
Definition: amrnbdec.c:128
float postfilter_mem[10]
previous intermediate values in the formant filter
Definition: amrnbdec.c:132
#define AMR_AGC_ALPHA
Adaptive gain control factor used in post-filter.
Definition: amrnbdec.c:96
common internal api header.
common internal and external API header
static void lsf2lsp_5(AMRContext *p)
Decode a set of 5 split-matrix quantized lsf indexes into 2 lsp vectors.
Definition: amrnbdec.c:284
static void lsf2lsp_for_mode12k2(AMRContext *p, double lsp[LP_FILTER_ORDER], const float lsf_no_r[LP_FILTER_ORDER], const int16_t *lsf_quantizer[5], const int quantizer_offset, const int sign, const int update)
Decode a set of 5 split-matrix quantized lsf indexes into an lsp vector.
Definition: amrnbdec.c:246
int pitch_lag
Definition: acelp_vectors.h:34
static const uint16_t gains_low[64][2]
gain table for 5.15 and 5.90 kbps modes
Definition: amrnbdata.h:1610
6.70 kbit/s
Definition: amrnbdata.h:43
static void decode_gains(AMRContext *p, const AMRNBSubframe *amr_subframe, const enum Mode mode, const int subframe, float *fixed_gain_factor)
Decode pitch gain and fixed gain factor (part of section 6.1.3).
Definition: amrnbdec.c:615
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
static av_cold int init(AVCodecParserContext *s)
Definition: h264_parser.c:499
#define LSF_R_FAC
LSF residual tables to Hertz.
Definition: amrnbdec.c:77
void * priv_data
Definition: avcodec.h:1092
const float ff_b60_sinc[61]
b60 hamming windowed sinc function coefficients
Definition: acelp_vectors.c:93
4.75 kbit/s
Definition: amrnbdata.h:40
static const uint16_t gains_high[128][2]
gain table for 6.70, 7.40 and 10.2 kbps modes
Definition: amrnbdata.h:1578
uint8_t hang_count
the number of subframes since a hangover period started
Definition: amrnbdec.c:126
int channels
number of audio channels
Definition: avcodec.h:1808
AMR narrowband data and definitions.
static const float energy_mean[8]
desired mean innovation energy, indexed by active mode
Definition: amrnbdata.h:1458
7.40 kbit/s
Definition: amrnbdata.h:44
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
#define PITCH_LAG_MIN_MODE_12k2
Lower bound on decoded lag search in 12.2kbit/s mode.
Definition: amrnbdec.c:79
static const int8_t pulses[4]
Definition: g723_1_data.h:531
uint16_t pulses[10]
pulses: 10 for MODE_12k2, 7 for MODE_10k2, and index and sign for others
Definition: amrnbdata.h:62
float excitation_buf[PITCH_DELAY_MAX+LP_FILTER_ORDER+1+AMR_SUBFRAME_SIZE]
current excitation and all necessary excitation history
Definition: amrnbdec.c:114
static enum Mode unpack_bitstream(AMRContext *p, const uint8_t *buf, int buf_size)
Unpack an RFC4867 speech frame into the AMR frame mode and parameters.
Definition: amrnbdec.c:194
#define AV_CH_LAYOUT_MONO
5.15 kbit/s
Definition: amrnbdata.h:41
This structure stores compressed data.
Definition: avcodec.h:950
const float ff_pow_0_55[10]
Table of pow(0.55,n)
Definition: acelp_vectors.c:88
static const int16_t lsf_5_3[256][4]
Definition: amrnbdata.h:1206
#define AMR_TILT_GAMMA_T
Tilt factor = 1st reflection coefficient * gamma_t.
Definition: amrnbdec.c:94
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:179
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)
static const int16_t lsp_avg_init[LP_FILTER_ORDER]
Mean lsp values.
Definition: amrnbdata.h:404