FFmpeg
sipr.c
Go to the documentation of this file.
1 /*
2  * SIPR / ACELP.NET decoder
3  *
4  * Copyright (c) 2008 Vladimir Voroshilov
5  * Copyright (c) 2009 Vitor Sessak
6  *
7  * This file is part of FFmpeg.
8  *
9  * FFmpeg is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * FFmpeg is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with FFmpeg; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  */
23 
24 #include <math.h>
25 #include <stdint.h>
26 #include <string.h>
27 
29 #include "libavutil/float_dsp.h"
30 #include "libavutil/mathematics.h"
31 
32 #define BITSTREAM_READER_LE
33 #include "avcodec.h"
34 #include "codec_internal.h"
35 #include "get_bits.h"
36 #include "internal.h"
37 #include "lsp.h"
38 #include "acelp_vectors.h"
39 #include "acelp_pitch_delay.h"
40 #include "acelp_filters.h"
41 #include "celp_filters.h"
42 
43 #define MAX_SUBFRAME_COUNT 5
44 
45 #include "sipr.h"
46 #include "siprdata.h"
47 
48 typedef struct SiprModeParam {
49  const char *mode_name;
50  uint16_t bits_per_frame;
51  uint8_t subframe_count;
54 
55  /* bitstream parameters */
57  uint8_t ma_predictor_bits; ///< size in bits of the switched MA predictor
58 
59  /** size in bits of the i-th stage vector of quantizer */
60  uint8_t vq_indexes_bits[5];
61 
62  /** size in bits of the adaptive-codebook index for every subframe */
63  uint8_t pitch_delay_bits[5];
64 
65  uint8_t gp_index_bits;
66  uint8_t fc_index_bits[10]; ///< size in bits of the fixed codebook indexes
67  uint8_t gc_index_bits; ///< size in bits of the gain codebook indexes
69 
70 static const SiprModeParam modes[MODE_COUNT] = {
71  [MODE_16k] = {
72  .mode_name = "16k",
73  .bits_per_frame = 160,
74  .subframe_count = SUBFRAME_COUNT_16k,
75  .frames_per_packet = 1,
76  .pitch_sharp_factor = 0.00,
77 
78  .number_of_fc_indexes = 10,
79  .ma_predictor_bits = 1,
80  .vq_indexes_bits = {7, 8, 7, 7, 7},
81  .pitch_delay_bits = {9, 6},
82  .gp_index_bits = 4,
83  .fc_index_bits = {4, 5, 4, 5, 4, 5, 4, 5, 4, 5},
84  .gc_index_bits = 5
85  },
86 
87  [MODE_8k5] = {
88  .mode_name = "8k5",
89  .bits_per_frame = 152,
90  .subframe_count = 3,
91  .frames_per_packet = 1,
92  .pitch_sharp_factor = 0.8,
93 
94  .number_of_fc_indexes = 3,
95  .ma_predictor_bits = 0,
96  .vq_indexes_bits = {6, 7, 7, 7, 5},
97  .pitch_delay_bits = {8, 5, 5},
98  .gp_index_bits = 0,
99  .fc_index_bits = {9, 9, 9},
100  .gc_index_bits = 7
101  },
102 
103  [MODE_6k5] = {
104  .mode_name = "6k5",
105  .bits_per_frame = 232,
106  .subframe_count = 3,
107  .frames_per_packet = 2,
108  .pitch_sharp_factor = 0.8,
109 
110  .number_of_fc_indexes = 3,
111  .ma_predictor_bits = 0,
112  .vq_indexes_bits = {6, 7, 7, 7, 5},
113  .pitch_delay_bits = {8, 5, 5},
114  .gp_index_bits = 0,
115  .fc_index_bits = {5, 5, 5},
116  .gc_index_bits = 7
117  },
118 
119  [MODE_5k0] = {
120  .mode_name = "5k0",
121  .bits_per_frame = 296,
122  .subframe_count = 5,
123  .frames_per_packet = 2,
124  .pitch_sharp_factor = 0.85,
125 
126  .number_of_fc_indexes = 1,
127  .ma_predictor_bits = 0,
128  .vq_indexes_bits = {6, 7, 7, 7, 5},
129  .pitch_delay_bits = {8, 5, 8, 5, 5},
130  .gp_index_bits = 0,
131  .fc_index_bits = {10},
132  .gc_index_bits = 7
133  }
134 };
135 
136 const float ff_pow_0_5[] = {
137  1.0/(1 << 1), 1.0/(1 << 2), 1.0/(1 << 3), 1.0/(1 << 4),
138  1.0/(1 << 5), 1.0/(1 << 6), 1.0/(1 << 7), 1.0/(1 << 8),
139  1.0/(1 << 9), 1.0/(1 << 10), 1.0/(1 << 11), 1.0/(1 << 12),
140  1.0/(1 << 13), 1.0/(1 << 14), 1.0/(1 << 15), 1.0/(1 << 16)
141 };
142 
143 static void dequant(float *out, const int *idx, const float * const cbs[])
144 {
145  int i;
146  int stride = 2;
147  int num_vec = 5;
148 
149  for (i = 0; i < num_vec; i++)
150  memcpy(out + stride*i, cbs[i] + stride*idx[i], stride*sizeof(float));
151 
152 }
153 
154 static void lsf_decode_fp(float *lsfnew, float *lsf_history,
155  const SiprParameters *parm)
156 {
157  int i;
158  float lsf_tmp[LP_FILTER_ORDER];
159 
160  dequant(lsf_tmp, parm->vq_indexes, lsf_codebooks);
161 
162  for (i = 0; i < LP_FILTER_ORDER; i++)
163  lsfnew[i] = lsf_history[i] * 0.33 + lsf_tmp[i] + mean_lsf[i];
164 
166 
167  /* Note that a minimum distance is not enforced between the last value and
168  the previous one, contrary to what is done in ff_acelp_reorder_lsf() */
170  lsfnew[9] = FFMIN(lsfnew[LP_FILTER_ORDER - 1], 1.3 * M_PI);
171 
172  memcpy(lsf_history, lsf_tmp, LP_FILTER_ORDER * sizeof(*lsf_history));
173 
174  for (i = 0; i < LP_FILTER_ORDER - 1; i++)
175  lsfnew[i] = cos(lsfnew[i]);
176  lsfnew[LP_FILTER_ORDER - 1] *= 6.153848 / M_PI;
177 }
178 
179 /** Apply pitch lag to the fixed vector (AMR section 6.1.2). */
180 static void pitch_sharpening(int pitch_lag_int, float beta,
181  float *fixed_vector)
182 {
183  int i;
184 
185  for (i = pitch_lag_int; i < SUBFR_SIZE; i++)
186  fixed_vector[i] += beta * fixed_vector[i - pitch_lag_int];
187 }
188 
189 /**
190  * Extract decoding parameters from the input bitstream.
191  * @param parms parameters structure
192  * @param pgb pointer to initialized GetBitContext structure
193  */
195  const SiprModeParam *p)
196 {
197  int i, j;
198 
199  if (p->ma_predictor_bits)
200  parms->ma_pred_switch = get_bits(pgb, p->ma_predictor_bits);
201 
202  for (i = 0; i < 5; i++)
203  parms->vq_indexes[i] = get_bits(pgb, p->vq_indexes_bits[i]);
204 
205  for (i = 0; i < p->subframe_count; i++) {
206  parms->pitch_delay[i] = get_bits(pgb, p->pitch_delay_bits[i]);
207  if (p->gp_index_bits)
208  parms->gp_index[i] = get_bits(pgb, p->gp_index_bits);
209 
210  for (j = 0; j < p->number_of_fc_indexes; j++)
211  parms->fc_indexes[i][j] = get_bits(pgb, p->fc_index_bits[j]);
212 
213  parms->gc_index[i] = get_bits(pgb, p->gc_index_bits);
214  }
215 }
216 
217 static void sipr_decode_lp(float *lsfnew, const float *lsfold, float *Az,
218  int num_subfr)
219 {
220  double lsfint[LP_FILTER_ORDER];
221  int i,j;
222  float t, t0 = 1.0 / num_subfr;
223 
224  t = t0 * 0.5;
225  for (i = 0; i < num_subfr; i++) {
226  for (j = 0; j < LP_FILTER_ORDER; j++)
227  lsfint[j] = lsfold[j] * (1 - t) + t * lsfnew[j];
228 
229  ff_amrwb_lsp2lpc(lsfint, Az, LP_FILTER_ORDER);
230  Az += LP_FILTER_ORDER;
231  t += t0;
232  }
233 }
234 
235 /**
236  * Evaluate the adaptive impulse response.
237  */
238 static void eval_ir(const float *Az, int pitch_lag, float *freq,
239  float pitch_sharp_factor)
240 {
241  float tmp1[SUBFR_SIZE+1], tmp2[LP_FILTER_ORDER+1];
242  int i;
243 
244  tmp1[0] = 1.0;
245  for (i = 0; i < LP_FILTER_ORDER; i++) {
246  tmp1[i+1] = Az[i] * ff_pow_0_55[i];
247  tmp2[i ] = Az[i] * ff_pow_0_7 [i];
248  }
249  memset(tmp1 + 11, 0, 37 * sizeof(float));
250 
251  ff_celp_lp_synthesis_filterf(freq, tmp2, tmp1, SUBFR_SIZE,
253 
254  pitch_sharpening(pitch_lag, pitch_sharp_factor, freq);
255 }
256 
257 /**
258  * Evaluate the convolution of a vector with a sparse vector.
259  */
260 static void convolute_with_sparse(float *out, const AMRFixed *pulses,
261  const float *shape, int length)
262 {
263  int i, j;
264 
265  memset(out, 0, length*sizeof(float));
266  for (i = 0; i < pulses->n; i++)
267  for (j = pulses->x[i]; j < length; j++)
268  out[j] += pulses->y[i] * shape[j - pulses->x[i]];
269 }
270 
271 /**
272  * Apply postfilter, very similar to AMR one.
273  */
274 static void postfilter_5k0(SiprContext *ctx, const float *lpc, float *samples)
275 {
276  float buf[SUBFR_SIZE + LP_FILTER_ORDER];
277  float *pole_out = buf + LP_FILTER_ORDER;
278  float lpc_n[LP_FILTER_ORDER];
279  float lpc_d[LP_FILTER_ORDER];
280  int i;
281 
282  for (i = 0; i < LP_FILTER_ORDER; i++) {
283  lpc_d[i] = lpc[i] * ff_pow_0_75[i];
284  lpc_n[i] = lpc[i] * ff_pow_0_5 [i];
285  };
286 
287  memcpy(pole_out - LP_FILTER_ORDER, ctx->postfilter_mem,
288  LP_FILTER_ORDER*sizeof(float));
289 
292 
293  memcpy(ctx->postfilter_mem, pole_out + SUBFR_SIZE - LP_FILTER_ORDER,
294  LP_FILTER_ORDER*sizeof(float));
295 
296  ff_tilt_compensation(&ctx->tilt_mem, 0.4, pole_out, SUBFR_SIZE);
297 
298  memcpy(pole_out - LP_FILTER_ORDER, ctx->postfilter_mem5k0,
299  LP_FILTER_ORDER*sizeof(*pole_out));
300 
301  memcpy(ctx->postfilter_mem5k0, pole_out + SUBFR_SIZE - LP_FILTER_ORDER,
302  LP_FILTER_ORDER*sizeof(*pole_out));
303 
306 
307 }
308 
309 static void decode_fixed_sparse(AMRFixed *fixed_sparse, const int16_t *pulses,
310  SiprMode mode, int low_gain)
311 {
312  int i;
313 
314  switch (mode) {
315  case MODE_6k5:
316  for (i = 0; i < 3; i++) {
317  fixed_sparse->x[i] = 3 * (pulses[i] & 0xf) + i;
318  fixed_sparse->y[i] = pulses[i] & 0x10 ? -1 : 1;
319  }
320  fixed_sparse->n = 3;
321  break;
322  case MODE_8k5:
323  for (i = 0; i < 3; i++) {
324  fixed_sparse->x[2*i ] = 3 * ((pulses[i] >> 4) & 0xf) + i;
325  fixed_sparse->x[2*i + 1] = 3 * ( pulses[i] & 0xf) + i;
326 
327  fixed_sparse->y[2*i ] = (pulses[i] & 0x100) ? -1.0: 1.0;
328 
329  fixed_sparse->y[2*i + 1] =
330  (fixed_sparse->x[2*i + 1] < fixed_sparse->x[2*i]) ?
331  -fixed_sparse->y[2*i ] : fixed_sparse->y[2*i];
332  }
333 
334  fixed_sparse->n = 6;
335  break;
336  case MODE_5k0:
337  default:
338  if (low_gain) {
339  int offset = (pulses[0] & 0x200) ? 2 : 0;
340  int val = pulses[0];
341 
342  for (i = 0; i < 3; i++) {
343  int index = (val & 0x7) * 6 + 4 - i*2;
344 
345  fixed_sparse->y[i] = (offset + index) & 0x3 ? -1 : 1;
346  fixed_sparse->x[i] = index;
347 
348  val >>= 3;
349  }
350  fixed_sparse->n = 3;
351  } else {
352  int pulse_subset = (pulses[0] >> 8) & 1;
353 
354  fixed_sparse->x[0] = ((pulses[0] >> 4) & 15) * 3 + pulse_subset;
355  fixed_sparse->x[1] = ( pulses[0] & 15) * 3 + pulse_subset + 1;
356 
357  fixed_sparse->y[0] = pulses[0] & 0x200 ? -1 : 1;
358  fixed_sparse->y[1] = -fixed_sparse->y[0];
359  fixed_sparse->n = 2;
360  }
361  break;
362  }
363 }
364 
366  float *out_data)
367 {
368  int i, j;
369  int subframe_count = modes[ctx->mode].subframe_count;
370  int frame_size = subframe_count * SUBFR_SIZE;
372  float *excitation;
373  float ir_buf[SUBFR_SIZE + LP_FILTER_ORDER];
374  float lsf_new[LP_FILTER_ORDER];
375  float *impulse_response = ir_buf + LP_FILTER_ORDER;
376  float *synth = ctx->synth_buf + 16; // 16 instead of LP_FILTER_ORDER for
377  // memory alignment
378  int t0_first = 0;
379  AMRFixed fixed_cb;
380 
381  memset(ir_buf, 0, LP_FILTER_ORDER * sizeof(float));
382  lsf_decode_fp(lsf_new, ctx->lsf_history, params);
383 
384  sipr_decode_lp(lsf_new, ctx->lsp_history, Az, subframe_count);
385 
386  memcpy(ctx->lsp_history, lsf_new, LP_FILTER_ORDER * sizeof(float));
387 
388  excitation = ctx->excitation + PITCH_DELAY_MAX + L_INTERPOL;
389 
390  for (i = 0; i < subframe_count; i++) {
391  float *pAz = Az + i*LP_FILTER_ORDER;
392  float fixed_vector[SUBFR_SIZE];
393  int T0,T0_frac;
394  float pitch_gain, gain_code, avg_energy;
395 
396  ff_decode_pitch_lag(&T0, &T0_frac, params->pitch_delay[i], t0_first, i,
397  ctx->mode == MODE_5k0, 6);
398 
399  if (i == 0 || (i == 2 && ctx->mode == MODE_5k0))
400  t0_first = T0;
401 
402  ff_acelp_interpolatef(excitation, excitation - T0 + (T0_frac <= 0),
403  ff_b60_sinc, 6,
404  2 * ((2 + T0_frac)%3 + 1), LP_FILTER_ORDER,
405  SUBFR_SIZE);
406 
407  decode_fixed_sparse(&fixed_cb, params->fc_indexes[i], ctx->mode,
408  ctx->past_pitch_gain < 0.8);
409 
410  eval_ir(pAz, T0, impulse_response, modes[ctx->mode].pitch_sharp_factor);
411 
412  convolute_with_sparse(fixed_vector, &fixed_cb, impulse_response,
413  SUBFR_SIZE);
414 
415  avg_energy = (0.01 + avpriv_scalarproduct_float_c(fixed_vector,
416  fixed_vector,
417  SUBFR_SIZE)) /
418  SUBFR_SIZE;
419 
420  ctx->past_pitch_gain = pitch_gain = gain_cb[params->gc_index[i]][0];
421 
422  gain_code = ff_amr_set_fixed_gain(gain_cb[params->gc_index[i]][1],
423  avg_energy, ctx->energy_history,
424  34 - 15.0/(0.05*M_LN10/M_LN2),
425  pred);
426 
427  ff_weighted_vector_sumf(excitation, excitation, fixed_vector,
428  pitch_gain, gain_code, SUBFR_SIZE);
429 
430  pitch_gain *= 0.5 * pitch_gain;
431  pitch_gain = FFMIN(pitch_gain, 0.4);
432 
433  ctx->gain_mem = 0.7 * ctx->gain_mem + 0.3 * pitch_gain;
434  ctx->gain_mem = FFMIN(ctx->gain_mem, pitch_gain);
435  gain_code *= ctx->gain_mem;
436 
437  for (j = 0; j < SUBFR_SIZE; j++)
438  fixed_vector[j] = excitation[j] - gain_code * fixed_vector[j];
439 
440  if (ctx->mode == MODE_5k0) {
441  postfilter_5k0(ctx, pAz, fixed_vector);
442 
444  pAz, excitation, SUBFR_SIZE,
446  }
447 
448  ff_celp_lp_synthesis_filterf(synth + i*SUBFR_SIZE, pAz, fixed_vector,
450 
451  excitation += SUBFR_SIZE;
452  }
453 
454  memcpy(synth - LP_FILTER_ORDER, synth + frame_size - LP_FILTER_ORDER,
455  LP_FILTER_ORDER * sizeof(float));
456 
457  if (ctx->mode == MODE_5k0) {
458  for (i = 0; i < subframe_count; i++) {
459  float energy = avpriv_scalarproduct_float_c(ctx->postfilter_syn5k0 + LP_FILTER_ORDER + i * SUBFR_SIZE,
460  ctx->postfilter_syn5k0 + LP_FILTER_ORDER + i * SUBFR_SIZE,
461  SUBFR_SIZE);
463  &synth[i * SUBFR_SIZE], energy,
464  SUBFR_SIZE, 0.9, &ctx->postfilter_agc);
465  }
466 
467  memcpy(ctx->postfilter_syn5k0, ctx->postfilter_syn5k0 + frame_size,
468  LP_FILTER_ORDER*sizeof(float));
469  }
470  memmove(ctx->excitation, excitation - PITCH_DELAY_MAX - L_INTERPOL,
471  (PITCH_DELAY_MAX + L_INTERPOL) * sizeof(float));
472 
474  (const float[2]) {-1.99997 , 1.000000000},
475  (const float[2]) {-1.93307352, 0.935891986},
476  0.939805806,
477  ctx->highpass_filt_mem,
478  frame_size);
479 }
480 
482 {
483  SiprContext *ctx = avctx->priv_data;
484  int i;
485 
486  switch (avctx->block_align) {
487  case 20: ctx->mode = MODE_16k; break;
488  case 19: ctx->mode = MODE_8k5; break;
489  case 29: ctx->mode = MODE_6k5; break;
490  case 37: ctx->mode = MODE_5k0; break;
491  default:
492  if (avctx->bit_rate > 12200) ctx->mode = MODE_16k;
493  else if (avctx->bit_rate > 7500 ) ctx->mode = MODE_8k5;
494  else if (avctx->bit_rate > 5750 ) ctx->mode = MODE_6k5;
495  else ctx->mode = MODE_5k0;
496  av_log(avctx, AV_LOG_WARNING,
497  "Invalid block_align: %d. Mode %s guessed based on bitrate: %"PRId64"\n",
498  avctx->block_align, modes[ctx->mode].mode_name, avctx->bit_rate);
499  }
500 
501  av_log(avctx, AV_LOG_DEBUG, "Mode: %s\n", modes[ctx->mode].mode_name);
502 
503  if (ctx->mode == MODE_16k) {
505  ctx->decode_frame = ff_sipr_decode_frame_16k;
506  } else {
507  ctx->decode_frame = decode_frame;
508  }
509 
510  for (i = 0; i < LP_FILTER_ORDER; i++)
511  ctx->lsp_history[i] = cos((i+1) * M_PI / (LP_FILTER_ORDER + 1));
512 
513  for (i = 0; i < 4; i++)
514  ctx->energy_history[i] = -14;
515 
518  avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
519 
520  return 0;
521 }
522 
524  int *got_frame_ptr, AVPacket *avpkt)
525 {
526  SiprContext *ctx = avctx->priv_data;
527  const uint8_t *buf=avpkt->data;
528  SiprParameters parm;
529  const SiprModeParam *mode_par = &modes[ctx->mode];
530  GetBitContext gb;
531  float *samples;
532  int subframe_size = ctx->mode == MODE_16k ? L_SUBFR_16k : SUBFR_SIZE;
533  int i, ret;
534 
535  ctx->avctx = avctx;
536  if (avpkt->size < (mode_par->bits_per_frame >> 3)) {
537  av_log(avctx, AV_LOG_ERROR,
538  "Error processing packet: packet size (%d) too small\n",
539  avpkt->size);
540  return AVERROR_INVALIDDATA;
541  }
542 
543  /* get output buffer */
544  frame->nb_samples = mode_par->frames_per_packet * subframe_size *
545  mode_par->subframe_count;
546  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
547  return ret;
548  samples = (float *)frame->data[0];
549 
550  init_get_bits(&gb, buf, mode_par->bits_per_frame);
551 
552  for (i = 0; i < mode_par->frames_per_packet; i++) {
553  decode_parameters(&parm, &gb, mode_par);
554 
555  ctx->decode_frame(ctx, &parm, samples);
556 
557  samples += subframe_size * mode_par->subframe_count;
558  }
559 
560  *got_frame_ptr = 1;
561 
562  return mode_par->bits_per_frame >> 3;
563 }
564 
566  .p.name = "sipr",
567  .p.long_name = NULL_IF_CONFIG_SMALL("RealAudio SIPR / ACELP.NET"),
568  .p.type = AVMEDIA_TYPE_AUDIO,
569  .p.id = AV_CODEC_ID_SIPR,
570  .priv_data_size = sizeof(SiprContext),
573  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
574  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
575 };
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AMRFixed::x
int x[10]
Definition: acelp_vectors.h:55
acelp_vectors.h
eval_ir
static void eval_ir(const float *Az, int pitch_lag, float *freq, float pitch_sharp_factor)
Evaluate the adaptive impulse response.
Definition: sipr.c:238
SiprModeParam::gp_index_bits
uint8_t gp_index_bits
Definition: sipr.c:65
ff_amr_set_fixed_gain
float ff_amr_set_fixed_gain(float fixed_gain_factor, float fixed_mean_energy, float *prediction_error, float energy_mean, const float *pred_table)
Calculate fixed gain (part of section 6.1.3 of AMR spec)
Definition: acelp_pitch_delay.c:86
SiprModeParam::mode_name
const char * mode_name
Definition: sipr.c:49
out
FILE * out
Definition: movenc.c:54
ff_decode_pitch_lag
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...
Definition: acelp_pitch_delay.c:107
postfilter_5k0
static void postfilter_5k0(SiprContext *ctx, const float *lpc, float *samples)
Apply postfilter, very similar to AMR one.
Definition: sipr.c:274
ff_amrwb_lsp2lpc
void ff_amrwb_lsp2lpc(const double *lsp, float *lp, int lp_order)
LSP to LP conversion (5.2.4 of AMR-WB)
Definition: lsp.c:145
ff_b60_sinc
const float ff_b60_sinc[61]
b60 hamming windowed sinc function coefficients
Definition: acelp_vectors.c:103
siprdata.h
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
MODE_5k0
@ MODE_5k0
Definition: sipr.h:52
ff_acelp_apply_order_2_transfer_function
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.
Definition: acelp_filters.c:121
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:374
ff_sipr_decode_frame_16k
void ff_sipr_decode_frame_16k(SiprContext *ctx, SiprParameters *params, float *out_data)
Definition: sipr16k.c:176
t0
#define t0
Definition: regdef.h:28
AV_CHANNEL_LAYOUT_MONO
#define AV_CHANNEL_LAYOUT_MONO
Definition: channel_layout.h:353
FFCodec
Definition: codec_internal.h:112
mathematics.h
ff_sort_nearly_sorted_floats
void ff_sort_nearly_sorted_floats(float *vals, int len)
Sort values in ascending order.
Definition: lsp.c:228
LP_FILTER_ORDER
#define LP_FILTER_ORDER
linear predictive coding filter order
Definition: amrnbdata.h:53
MAX_SUBFRAME_COUNT
#define MAX_SUBFRAME_COUNT
Definition: sipr.c:43
ff_celp_lp_synthesis_filterf
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:85
ff_sipr_decoder
const FFCodec ff_sipr_decoder
Definition: sipr.c:565
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:660
LSFQ_DIFF_MIN
#define LSFQ_DIFF_MIN
minimum LSF distance (3.2.4) 0.0391 in Q13
Definition: g729dec.c:59
MODE_8k5
@ MODE_8k5
Definition: sipr.h:50
init
static int init
Definition: av_tx.c:47
M_LN2
#define M_LN2
Definition: mathematics.h:40
SiprModeParam::frames_per_packet
uint8_t frames_per_packet
Definition: sipr.c:52
SUBFR_SIZE
#define SUBFR_SIZE
Subframe size for all modes except 16k.
Definition: sipr.h:44
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:380
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:116
PITCH_DELAY_MAX
#define PITCH_DELAY_MAX
Definition: acelp_pitch_delay.h:31
ff_pow_0_55
const float ff_pow_0_55[10]
Table of pow(0.55,n)
Definition: acelp_vectors.c:98
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:2057
lsf_decode_fp
static void lsf_decode_fp(float *lsfnew, float *lsf_history, const SiprParameters *parm)
Definition: sipr.c:154
convolute_with_sparse
static void convolute_with_sparse(float *out, const AMRFixed *pulses, const float *shape, int length)
Evaluate the convolution of a vector with a sparse vector.
Definition: sipr.c:260
SiprModeParam::number_of_fc_indexes
uint8_t number_of_fc_indexes
Definition: sipr.c:56
GetBitContext
Definition: get_bits.h:62
SiprParameters
Definition: sipr.h:56
val
static double val(void *priv, double ch)
Definition: aeval.c:77
SiprParameters::gc_index
int gc_index[5]
fixed-codebook gain indexes
Definition: sipr.h:62
SiprModeParam::pitch_sharp_factor
float pitch_sharp_factor
Definition: sipr.c:53
ff_adaptive_gain_control
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)
Definition: acelp_vectors.c:192
decode_parameters
static void decode_parameters(SiprParameters *parms, GetBitContext *pgb, const SiprModeParam *p)
Extract decoding parameters from the input bitstream.
Definition: sipr.c:194
AV_CODEC_ID_SIPR
@ AV_CODEC_ID_SIPR
Definition: codec_id.h:466
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:254
frame_size
int frame_size
Definition: mxfenc.c:2201
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
dequant
static void dequant(float *out, const int *idx, const float *const cbs[])
Definition: sipr.c:143
AMRFixed
Sparse representation for the algebraic codebook (fixed) vector.
Definition: acelp_vectors.h:53
sipr_decode_lp
static void sipr_decode_lp(float *lsfnew, const float *lsfold, float *Az, int num_subfr)
Definition: sipr.c:217
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
ctx
AVFormatContext * ctx
Definition: movenc.c:48
get_bits.h
AMRFixed::y
float y[10]
Definition: acelp_vectors.h:56
decode_fixed_sparse
static void decode_fixed_sparse(AMRFixed *fixed_sparse, const int16_t *pulses, SiprMode mode, int low_gain)
Definition: sipr.c:309
SiprMode
SiprMode
Definition: sipr.h:48
SiprParameters::ma_pred_switch
int ma_pred_switch
switched moving average predictor
Definition: sipr.h:57
L_INTERPOL
#define L_INTERPOL
Number of past samples needed for excitation interpolation.
Definition: sipr.h:41
SiprModeParam::vq_indexes_bits
uint8_t vq_indexes_bits[5]
size in bits of the i-th stage vector of quantizer
Definition: sipr.c:60
MODE_16k
@ MODE_16k
Definition: sipr.h:49
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:439
SiprParameters::fc_indexes
int16_t fc_indexes[5][10]
fixed-codebook indexes
Definition: sipr.h:61
SiprParameters::pitch_delay
int pitch_delay[5]
pitch delay
Definition: sipr.h:59
celp_filters.h
index
int index
Definition: gxfenc.c:89
float_dsp.h
av_channel_layout_uninit
void av_channel_layout_uninit(AVChannelLayout *channel_layout)
Free any allocated data in the channel layout and reset the channel count to 0.
Definition: channel_layout.c:630
AV_CODEC_CAP_CHANNEL_CONF
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:109
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1403
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:375
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:116
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:290
codec_internal.h
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1014
ff_pow_0_7
const float ff_pow_0_7[10]
Table of pow(0.7,n)
Definition: acelp_vectors.c:88
sipr_decode_frame
static int sipr_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)
Definition: sipr.c:523
SiprModeParam::bits_per_frame
uint16_t bits_per_frame
Definition: sipr.c:50
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
ff_pow_0_5
const float ff_pow_0_5[]
Definition: sipr.c:136
lsf_codebooks
static const float *const lsf_codebooks[]
Definition: siprdata.h:209
M_PI
#define M_PI
Definition: mathematics.h:52
ff_tilt_compensation
void ff_tilt_compensation(float *mem, float tilt, float *samples, int size)
Apply tilt compensation filter, 1 - tilt * z-1.
Definition: acelp_filters.c:138
pitch_sharpening
static void pitch_sharpening(int pitch_lag_int, float beta, float *fixed_vector)
Apply pitch lag to the fixed vector (AMR section 6.1.2).
Definition: sipr.c:180
sipr.h
SiprParameters::vq_indexes
int vq_indexes[5]
Definition: sipr.h:58
SiprContext
Definition: sipr.h:65
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
ff_sipr_init_16k
void ff_sipr_init_16k(SiprContext *ctx)
Definition: sipr16k.c:271
modes
static const SiprModeParam modes[MODE_COUNT]
Definition: sipr.c:70
decode_frame
static void decode_frame(SiprContext *ctx, SiprParameters *params, float *out_data)
Definition: sipr.c:365
xf
#define xf(width, name, var, range_min, range_max, subs,...)
Definition: cbs_av1.c:664
SiprModeParam::gc_index_bits
uint8_t gc_index_bits
size in bits of the gain codebook indexes
Definition: sipr.c:67
ff_pow_0_75
const float ff_pow_0_75[10]
Table of pow(0.75,n)
Definition: acelp_vectors.c:93
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
FF_CODEC_CAP_INIT_THREADSAFE
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: codec_internal.h:31
acelp_filters.h
ff_weighted_vector_sumf
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.
Definition: acelp_vectors.c:182
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:203
gain_cb
static const float gain_cb[128][2]
Definition: siprdata.h:213
MODE_6k5
@ MODE_6k5
Definition: sipr.h:51
avcodec.h
stride
#define stride
Definition: h264pred_template.c:537
ret
ret
Definition: filter_design.txt:187
pred
static const float pred[4]
Definition: siprdata.h:259
AVCodecContext::block_align
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs.
Definition: avcodec.h:1043
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
lsp.h
ff_celp_lp_zero_synthesis_filterf
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:200
AMRFixed::n
int n
Definition: acelp_vectors.h:54
SiprModeParam::pitch_delay_bits
uint8_t pitch_delay_bits[5]
size in bits of the adaptive-codebook index for every subframe
Definition: sipr.c:63
AVCodecContext
main external API structure.
Definition: avcodec.h:389
channel_layout.h
mode
mode
Definition: ebur128.h:83
SiprModeParam
Definition: sipr.c:48
L_SUBFR_16k
#define L_SUBFR_16k
Definition: sipr.h:32
mean_lsf
static const float mean_lsf[10]
Definition: siprdata.h:27
samples
Filter the word “frame” indicates either a video frame or a group of audio samples
Definition: filter_design.txt:8
SUBFRAME_COUNT_16k
#define SUBFRAME_COUNT_16k
Definition: sipr.h:46
SiprModeParam::subframe_count
uint8_t subframe_count
Definition: sipr.c:51
avpriv_scalarproduct_float_c
float avpriv_scalarproduct_float_c(const float *v1, const float *v2, int len)
Return the scalar product of two vectors.
Definition: float_dsp.c:124
M_LN10
#define M_LN10
Definition: mathematics.h:43
SiprModeParam::fc_index_bits
uint8_t fc_index_bits[10]
size in bits of the fixed codebook indexes
Definition: sipr.c:66
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:416
sipr_decoder_init
static av_cold int sipr_decoder_init(AVCodecContext *avctx)
Definition: sipr.c:481
SiprParameters::gp_index
int gp_index[5]
adaptive-codebook gain indexes
Definition: sipr.h:60
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
MODE_COUNT
@ MODE_COUNT
Definition: cinepakenc.c:77
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
pulses
static const int8_t pulses[4]
Number of non-zero pulses in the MP-MLQ excitation.
Definition: g723_1.h:260
ff_acelp_interpolatef
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:80
AV_SAMPLE_FMT_FLT
@ AV_SAMPLE_FMT_FLT
float
Definition: samplefmt.h:60
SiprModeParam::ma_predictor_bits
uint8_t ma_predictor_bits
size in bits of the switched MA predictor
Definition: sipr.c:57
ff_set_min_dist_lsf
void ff_set_min_dist_lsf(float *lsf, double min_spacing, int size)
Adjust the quantized LSFs so they are increasing and not too close.
Definition: lsp.c:51
acelp_pitch_delay.h