FFmpeg
evrcdec.c
Go to the documentation of this file.
1 /*
2  * Enhanced Variable Rate Codec, Service Option 3 decoder
3  * Copyright (c) 2013 Paul B Mahol
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * Enhanced Variable Rate Codec, Service Option 3 decoder
25  * @author Paul B Mahol
26  */
27 
29 #include "libavutil/mathematics.h"
30 #include "libavutil/opt.h"
31 #include "avcodec.h"
32 #include "codec_internal.h"
33 #include "internal.h"
34 #include "get_bits.h"
35 #include "evrcdata.h"
36 #include "acelp_vectors.h"
37 #include "lsp.h"
38 
39 #define MIN_LSP_SEP (0.05 / (2.0 * M_PI))
40 #define MIN_DELAY 20
41 #define MAX_DELAY 120
42 #define NB_SUBFRAMES 3
43 #define SUBFRAME_SIZE 54
44 #define FILTER_ORDER 10
45 #define ACB_SIZE 128
46 
47 typedef enum {
48  RATE_ERRS = -1,
55 
56 /**
57  * EVRC-A unpacked data frame
58  */
59 typedef struct EVRCAFrame {
60  uint8_t lpc_flag; ///< spectral change indicator
61  uint16_t lsp[4]; ///< index into LSP codebook
62  uint8_t pitch_delay; ///< pitch delay for entire frame
63  uint8_t delay_diff; ///< delay difference for entire frame
64  uint8_t acb_gain[3]; ///< adaptive codebook gain
65  uint16_t fcb_shape[3][4]; ///< fixed codebook shape
66  uint8_t fcb_gain[3]; ///< fixed codebook gain index
67  uint8_t energy_gain; ///< frame energy gain index
68  uint8_t tty; ///< tty baud rate bit
69 } EVRCAFrame;
70 
71 typedef struct EVRCContext {
72  AVClass *class;
73 
75 
80 
87  float pitch_delay;
89  float avg_acb_gain; ///< average adaptive codebook gain
90  float avg_fcb_gain; ///< average fixed codebook gain
95  float fade_scale;
96  float last;
97 
99  uint8_t prev_error_flag;
101 } EVRCContext;
102 
103 /**
104  * Frame unpacking for RATE_FULL, RATE_HALF and RATE_QUANT
105  *
106  * @param e the context
107  *
108  * TIA/IS-127 Table 4.21-1
109  */
110 static void unpack_frame(EVRCContext *e)
111 {
112  EVRCAFrame *frame = &e->frame;
113  GetBitContext *gb = &e->gb;
114 
115  switch (e->bitrate) {
116  case RATE_FULL:
117  frame->lpc_flag = get_bits1(gb);
118  frame->lsp[0] = get_bits(gb, 6);
119  frame->lsp[1] = get_bits(gb, 6);
120  frame->lsp[2] = get_bits(gb, 9);
121  frame->lsp[3] = get_bits(gb, 7);
122  frame->pitch_delay = get_bits(gb, 7);
123  frame->delay_diff = get_bits(gb, 5);
124  frame->acb_gain[0] = get_bits(gb, 3);
125  frame->fcb_shape[0][0] = get_bits(gb, 8);
126  frame->fcb_shape[0][1] = get_bits(gb, 8);
127  frame->fcb_shape[0][2] = get_bits(gb, 8);
128  frame->fcb_shape[0][3] = get_bits(gb, 11);
129  frame->fcb_gain[0] = get_bits(gb, 5);
130  frame->acb_gain[1] = get_bits(gb, 3);
131  frame->fcb_shape[1][0] = get_bits(gb, 8);
132  frame->fcb_shape[1][1] = get_bits(gb, 8);
133  frame->fcb_shape[1][2] = get_bits(gb, 8);
134  frame->fcb_shape[1][3] = get_bits(gb, 11);
135  frame->fcb_gain [1] = get_bits(gb, 5);
136  frame->acb_gain [2] = get_bits(gb, 3);
137  frame->fcb_shape[2][0] = get_bits(gb, 8);
138  frame->fcb_shape[2][1] = get_bits(gb, 8);
139  frame->fcb_shape[2][2] = get_bits(gb, 8);
140  frame->fcb_shape[2][3] = get_bits(gb, 11);
141  frame->fcb_gain [2] = get_bits(gb, 5);
142  frame->tty = get_bits1(gb);
143  break;
144  case RATE_HALF:
145  frame->lsp [0] = get_bits(gb, 7);
146  frame->lsp [1] = get_bits(gb, 7);
147  frame->lsp [2] = get_bits(gb, 8);
148  frame->pitch_delay = get_bits(gb, 7);
149  frame->acb_gain [0] = get_bits(gb, 3);
150  frame->fcb_shape[0][0] = get_bits(gb, 10);
151  frame->fcb_gain [0] = get_bits(gb, 4);
152  frame->acb_gain [1] = get_bits(gb, 3);
153  frame->fcb_shape[1][0] = get_bits(gb, 10);
154  frame->fcb_gain [1] = get_bits(gb, 4);
155  frame->acb_gain [2] = get_bits(gb, 3);
156  frame->fcb_shape[2][0] = get_bits(gb, 10);
157  frame->fcb_gain [2] = get_bits(gb, 4);
158  break;
159  case RATE_QUANT:
160  frame->lsp [0] = get_bits(gb, 4);
161  frame->lsp [1] = get_bits(gb, 4);
162  frame->energy_gain = get_bits(gb, 8);
163  break;
164  }
165 }
166 
167 static evrc_packet_rate buf_size2bitrate(const int buf_size)
168 {
169  switch (buf_size) {
170  case 23: return RATE_FULL;
171  case 11: return RATE_HALF;
172  case 6: return RATE_QUARTER;
173  case 3: return RATE_QUANT;
174  case 1: return SILENCE;
175  }
176 
177  return RATE_ERRS;
178 }
179 
180 /**
181  * Determine the bitrate from the frame size and/or the first byte of the frame.
182  *
183  * @param avctx the AV codec context
184  * @param buf_size length of the buffer
185  * @param buf the bufffer
186  *
187  * @return the bitrate on success,
188  * RATE_ERRS if the bitrate cannot be satisfactorily determined
189  */
191  int *buf_size,
192  const uint8_t **buf)
193 {
195 
196  if ((bitrate = buf_size2bitrate(*buf_size)) >= 0) {
197  if (bitrate > **buf) {
198  EVRCContext *e = avctx->priv_data;
199  if (!e->warned_buf_mismatch_bitrate) {
200  av_log(avctx, AV_LOG_WARNING,
201  "Claimed bitrate and buffer size mismatch.\n");
203  }
204  bitrate = **buf;
205  } else if (bitrate < **buf) {
206  av_log(avctx, AV_LOG_ERROR,
207  "Buffer is too small for the claimed bitrate.\n");
208  return RATE_ERRS;
209  }
210  (*buf)++;
211  *buf_size -= 1;
212  } else if ((bitrate = buf_size2bitrate(*buf_size + 1)) >= 0) {
213  av_log(avctx, AV_LOG_DEBUG,
214  "Bitrate byte is missing, guessing the bitrate from packet size.\n");
215  } else
216  return RATE_ERRS;
217 
218  return bitrate;
219 }
220 
222  const char *message)
223 {
224  av_log(avctx, AV_LOG_WARNING, "Frame #%d, %s\n",
225  avctx->frame_number, message);
226 }
227 
228 /**
229  * Initialize the speech codec according to the specification.
230  *
231  * TIA/IS-127 5.2
232  */
234 {
235  EVRCContext *e = avctx->priv_data;
236  int i, n, idx = 0;
237  float denom = 2.0 / (2.0 * 8.0 + 1.0);
238 
241  avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
242 
243  for (i = 0; i < FILTER_ORDER; i++) {
244  e->prev_lspf[i] = (i + 1) * 0.048;
245  e->synthesis[i] = 0.0;
246  }
247 
248  for (i = 0; i < ACB_SIZE; i++)
249  e->pitch[i] = e->pitch_back[i] = 0.0;
250 
252  e->prev_pitch_delay = 40.0;
253  e->fade_scale = 1.0;
254  e->prev_error_flag = 0;
255  e->avg_acb_gain = e->avg_fcb_gain = 0.0;
256 
257  for (i = 0; i < 8; i++) {
258  float tt = ((float)i - 8.0 / 2.0) / 8.0;
259 
260  for (n = -8; n <= 8; n++, idx++) {
261  float arg1 = M_PI * 0.9 * (tt - n);
262  float arg2 = M_PI * (tt - n);
263 
264  e->interpolation_coeffs[idx] = 0.9;
265  if (arg1)
266  e->interpolation_coeffs[idx] *= (0.54 + 0.46 * cos(arg2 * denom)) *
267  sin(arg1) / arg1;
268  }
269  }
270 
271  return 0;
272 }
273 
274 /**
275  * Decode the 10 vector quantized line spectral pair frequencies from the LSP
276  * transmission codes of any bitrate and check for badly received packets.
277  *
278  * @param e the context
279  *
280  * @return 0 on success, -1 if the packet is badly received
281  *
282  * TIA/IS-127 5.2.1, 5.7.1
283  */
284 static int decode_lspf(EVRCContext *e)
285 {
286  const float * const *codebooks = evrc_lspq_codebooks[e->bitrate];
287  int i, j, k = 0;
288 
289  for (i = 0; i < evrc_lspq_nb_codebooks[e->bitrate]; i++) {
290  int row_size = evrc_lspq_codebooks_row_sizes[e->bitrate][i];
291  const float *codebook = codebooks[i];
292 
293  for (j = 0; j < row_size; j++)
294  e->lspf[k++] = codebook[e->frame.lsp[i] * row_size + j];
295  }
296 
297  // check for monotonic LSPs
298  for (i = 1; i < FILTER_ORDER; i++)
299  if (e->lspf[i] <= e->lspf[i - 1])
300  return -1;
301 
302  // check for minimum separation of LSPs at the splits
303  for (i = 0, k = 0; i < evrc_lspq_nb_codebooks[e->bitrate] - 1; i++) {
305  if (e->lspf[k] - e->lspf[k - 1] <= MIN_LSP_SEP)
306  return -1;
307  }
308 
309  return 0;
310 }
311 
312 /*
313  * Interpolation of LSP parameters.
314  *
315  * TIA/IS-127 5.2.3.1, 5.7.3.2
316  */
317 static void interpolate_lsp(float *ilsp, const float *lsp,
318  const float *prev, int index)
319 {
320  static const float lsp_interpolation_factors[] = { 0.1667, 0.5, 0.8333 };
321  ff_weighted_vector_sumf(ilsp, prev, lsp,
322  1.0 - lsp_interpolation_factors[index],
323  lsp_interpolation_factors[index], FILTER_ORDER);
324 }
325 
326 /*
327  * Reconstruction of the delay contour.
328  *
329  * TIA/IS-127 5.2.2.3.2
330  */
331 static void interpolate_delay(float *dst, float current, float prev, int index)
332 {
333  static const float d_interpolation_factors[] = { 0, 0.3313, 0.6625, 1, 1 };
334  dst[0] = (1.0 - d_interpolation_factors[index ]) * prev
335  + d_interpolation_factors[index ] * current;
336  dst[1] = (1.0 - d_interpolation_factors[index + 1]) * prev
337  + d_interpolation_factors[index + 1] * current;
338  dst[2] = (1.0 - d_interpolation_factors[index + 2]) * prev
339  + d_interpolation_factors[index + 2] * current;
340 }
341 
342 /*
343  * Convert the quantized, interpolated line spectral frequencies,
344  * to prediction coefficients.
345  *
346  * TIA/IS-127 5.2.3.2, 4.7.2.2
347  */
348 static void decode_predictor_coeffs(const float *ilspf, float *ilpc)
349 {
350  double lsp[FILTER_ORDER];
351  float a[FILTER_ORDER / 2 + 1], b[FILTER_ORDER / 2 + 1];
352  float a1[FILTER_ORDER / 2] = { 0 };
353  float a2[FILTER_ORDER / 2] = { 0 };
354  float b1[FILTER_ORDER / 2] = { 0 };
355  float b2[FILTER_ORDER / 2] = { 0 };
356  int i, k;
357 
358  ff_acelp_lsf2lspd(lsp, ilspf, FILTER_ORDER);
359 
360  for (k = 0; k <= FILTER_ORDER; k++) {
361  a[0] = k < 2 ? 0.25 : 0;
362  b[0] = k < 2 ? k < 1 ? 0.25 : -0.25 : 0;
363 
364  for (i = 0; i < FILTER_ORDER / 2; i++) {
365  a[i + 1] = a[i] - 2 * lsp[i * 2 ] * a1[i] + a2[i];
366  b[i + 1] = b[i] - 2 * lsp[i * 2 + 1] * b1[i] + b2[i];
367  a2[i] = a1[i];
368  a1[i] = a[i];
369  b2[i] = b1[i];
370  b1[i] = b[i];
371  }
372 
373  if (k)
374  ilpc[k - 1] = 2.0 * (a[FILTER_ORDER / 2] + b[FILTER_ORDER / 2]);
375  }
376 }
377 
378 static void bl_intrp(EVRCContext *e, float *ex, float delay)
379 {
380  float *f;
381  int offset, i, coef_idx;
382  int16_t t;
383 
384  offset = lrintf(delay);
385 
386  t = (offset - delay + 0.5) * 8.0 + 0.5;
387  if (t == 8) {
388  t = 0;
389  offset--;
390  }
391 
392  f = ex - offset - 8;
393 
394  coef_idx = t * (2 * 8 + 1);
395 
396  ex[0] = 0.0;
397  for (i = 0; i < 2 * 8 + 1; i++)
398  ex[0] += e->interpolation_coeffs[coef_idx + i] * f[i];
399 }
400 
401 /*
402  * Adaptive codebook excitation.
403  *
404  * TIA/IS-127 5.2.2.3.3, 4.12.5.2
405  */
406 static void acb_excitation(EVRCContext *e, float *excitation, float gain,
407  const float delay[3], int length)
408 {
409  float denom, locdelay, dpr, invl;
410  int i;
411 
412  invl = 1.0 / ((float) length);
413  dpr = length;
414 
415  /* first at-most extra samples */
416  denom = (delay[1] - delay[0]) * invl;
417  for (i = 0; i < dpr; i++) {
418  locdelay = delay[0] + i * denom;
419  bl_intrp(e, excitation + i, locdelay);
420  }
421 
422  denom = (delay[2] - delay[1]) * invl;
423  /* interpolation */
424  for (i = dpr; i < dpr + 10; i++) {
425  locdelay = delay[1] + (i - dpr) * denom;
426  bl_intrp(e, excitation + i, locdelay);
427  }
428 
429  for (i = 0; i < length; i++)
430  excitation[i] *= gain;
431 }
432 
433 static void decode_8_pulses_35bits(const uint16_t *fixed_index, float *cod)
434 {
435  int i, pos1, pos2, offset;
436 
437  offset = (fixed_index[3] >> 9) & 3;
438 
439  for (i = 0; i < 3; i++) {
440  pos1 = ((fixed_index[i] & 0x7f) / 11) * 5 + ((i + offset) % 5);
441  pos2 = ((fixed_index[i] & 0x7f) % 11) * 5 + ((i + offset) % 5);
442 
443  cod[pos1] = (fixed_index[i] & 0x80) ? -1.0 : 1.0;
444 
445  if (pos2 < pos1)
446  cod[pos2] = -cod[pos1];
447  else
448  cod[pos2] += cod[pos1];
449  }
450 
451  pos1 = ((fixed_index[3] & 0x7f) / 11) * 5 + ((3 + offset) % 5);
452  pos2 = ((fixed_index[3] & 0x7f) % 11) * 5 + ((4 + offset) % 5);
453 
454  cod[pos1] = (fixed_index[3] & 0x100) ? -1.0 : 1.0;
455  cod[pos2] = (fixed_index[3] & 0x80 ) ? -1.0 : 1.0;
456 }
457 
458 static void decode_3_pulses_10bits(uint16_t fixed_index, float *cod)
459 {
460  float sign;
461  int pos;
462 
463  sign = (fixed_index & 0x200) ? -1.0 : 1.0;
464 
465  pos = ((fixed_index & 0x7) * 7) + 4;
466  cod[pos] += sign;
467  pos = (((fixed_index >> 3) & 0x7) * 7) + 2;
468  cod[pos] -= sign;
469  pos = (((fixed_index >> 6) & 0x7) * 7);
470  cod[pos] += sign;
471 }
472 
473 /*
474  * Reconstruction of ACELP fixed codebook excitation for full and half rate.
475  *
476  * TIA/IS-127 5.2.3.7
477  */
478 static void fcb_excitation(EVRCContext *e, const uint16_t *codebook,
479  float *excitation, float pitch_gain,
480  int pitch_lag, int subframe_size)
481 {
482  int i;
483 
484  if (e->bitrate == RATE_FULL)
485  decode_8_pulses_35bits(codebook, excitation);
486  else
487  decode_3_pulses_10bits(*codebook, excitation);
488 
489  pitch_gain = av_clipf(pitch_gain, 0.2, 0.9);
490 
491  for (i = pitch_lag; i < subframe_size; i++)
492  excitation[i] += pitch_gain * excitation[i - pitch_lag];
493 }
494 
495 /**
496  * Synthesis of the decoder output signal.
497  *
498  * param[in] in input signal
499  * param[in] filter_coeffs LPC coefficients
500  * param[in/out] memory synthesis filter memory
501  * param buffer_length amount of data to process
502  * param[out] samples output samples
503  *
504  * TIA/IS-127 5.2.3.15, 5.7.3.4
505  */
506 static void synthesis_filter(const float *in, const float *filter_coeffs,
507  float *memory, int buffer_length, float *samples)
508 {
509  int i, j;
510 
511  for (i = 0; i < buffer_length; i++) {
512  samples[i] = in[i];
513  for (j = FILTER_ORDER - 1; j > 0; j--) {
514  samples[i] -= filter_coeffs[j] * memory[j];
515  memory[j] = memory[j - 1];
516  }
517  samples[i] -= filter_coeffs[0] * memory[0];
518  memory[0] = samples[i];
519  }
520 }
521 
522 static void bandwidth_expansion(float *coeff, const float *inbuf, float gamma)
523 {
524  double fac = gamma;
525  int i;
526 
527  for (i = 0; i < FILTER_ORDER; i++) {
528  coeff[i] = inbuf[i] * fac;
529  fac *= gamma;
530  }
531 }
532 
533 static void residual_filter(float *output, const float *input,
534  const float *coef, float *memory, int length)
535 {
536  float sum;
537  int i, j;
538 
539  for (i = 0; i < length; i++) {
540  sum = input[i];
541 
542  for (j = FILTER_ORDER - 1; j > 0; j--) {
543  sum += coef[j] * memory[j];
544  memory[j] = memory[j - 1];
545  }
546  sum += coef[0] * memory[0];
547  memory[0] = input[i];
548  output[i] = sum;
549  }
550 }
551 
552 /*
553  * TIA/IS-127 Table 5.9.1-1.
554  */
555 static const struct PfCoeff {
556  float tilt;
557  float ltgain;
558  float p1;
559  float p2;
560 } postfilter_coeffs[5] = {
561  { 0.0 , 0.0 , 0.0 , 0.0 },
562  { 0.0 , 0.0 , 0.57, 0.57 },
563  { 0.0 , 0.0 , 0.0 , 0.0 },
564  { 0.35, 0.50, 0.50, 0.75 },
565  { 0.20, 0.50, 0.57, 0.75 },
566 };
567 
568 /*
569  * Adaptive postfilter.
570  *
571  * TIA/IS-127 5.9
572  */
573 static void postfilter(EVRCContext *e, float *in, const float *coeff,
574  float *out, int idx, const struct PfCoeff *pfc,
575  int length)
576 {
577  float wcoef1[FILTER_ORDER], wcoef2[FILTER_ORDER],
578  scratch[SUBFRAME_SIZE], temp[SUBFRAME_SIZE],
579  mem[SUBFRAME_SIZE];
580  float sum1 = 0.0, sum2 = 0.0, gamma, gain;
581  float tilt = pfc->tilt;
582  int i, n, best;
583 
584  bandwidth_expansion(wcoef1, coeff, pfc->p1);
585  bandwidth_expansion(wcoef2, coeff, pfc->p2);
586 
587  /* Tilt compensation filter, TIA/IS-127 5.9.1 */
588  for (i = 0; i < length - 1; i++)
589  sum2 += in[i] * in[i + 1];
590  if (sum2 < 0.0)
591  tilt = 0.0;
592 
593  for (i = 0; i < length; i++) {
594  scratch[i] = in[i] - tilt * e->last;
595  e->last = in[i];
596  }
597 
598  /* Short term residual filter, TIA/IS-127 5.9.2 */
599  residual_filter(&e->postfilter_residual[ACB_SIZE], scratch, wcoef1, e->postfilter_fir, length);
600 
601  /* Long term postfilter */
602  best = idx;
603  for (i = FFMIN(MIN_DELAY, idx - 3); i <= FFMAX(MAX_DELAY, idx + 3); i++) {
604  for (n = ACB_SIZE, sum2 = 0; n < ACB_SIZE + length; n++)
605  sum2 += e->postfilter_residual[n] * e->postfilter_residual[n - i];
606  if (sum2 > sum1) {
607  sum1 = sum2;
608  best = i;
609  }
610  }
611 
612  for (i = ACB_SIZE, sum1 = 0; i < ACB_SIZE + length; i++)
613  sum1 += e->postfilter_residual[i - best] * e->postfilter_residual[i - best];
614  for (i = ACB_SIZE, sum2 = 0; i < ACB_SIZE + length; i++)
615  sum2 += e->postfilter_residual[i] * e->postfilter_residual[i - best];
616 
617  if (sum2 * sum1 == 0 || e->bitrate == RATE_QUANT) {
618  memcpy(temp, e->postfilter_residual + ACB_SIZE, length * sizeof(float));
619  } else {
620  gamma = sum2 / sum1;
621  if (gamma < 0.5)
622  memcpy(temp, e->postfilter_residual + ACB_SIZE, length * sizeof(float));
623  else {
624  gamma = FFMIN(gamma, 1.0);
625 
626  for (i = 0; i < length; i++) {
627  temp[i] = e->postfilter_residual[ACB_SIZE + i] + gamma *
628  pfc->ltgain * e->postfilter_residual[ACB_SIZE + i - best];
629  }
630  }
631  }
632 
633  memcpy(scratch, temp, length * sizeof(float));
634  memcpy(mem, e->postfilter_iir, FILTER_ORDER * sizeof(float));
635  synthesis_filter(scratch, wcoef2, mem, length, scratch);
636 
637  /* Gain computation, TIA/IS-127 5.9.4-2 */
638  for (i = 0, sum1 = 0, sum2 = 0; i < length; i++) {
639  sum1 += in[i] * in[i];
640  sum2 += scratch[i] * scratch[i];
641  }
642  gain = sum2 ? sqrt(sum1 / sum2) : 1.0;
643 
644  for (i = 0; i < length; i++)
645  temp[i] *= gain;
646 
647  /* Short term postfilter */
648  synthesis_filter(temp, wcoef2, e->postfilter_iir, length, out);
649 
650  memmove(e->postfilter_residual,
651  e->postfilter_residual + length, ACB_SIZE * sizeof(float));
652 }
653 
654 static void frame_erasure(EVRCContext *e, float *samples)
655 {
656  float ilspf[FILTER_ORDER], ilpc[FILTER_ORDER], idelay[NB_SUBFRAMES],
657  tmp[SUBFRAME_SIZE + 6], f;
658  int i, j;
659 
660  for (i = 0; i < FILTER_ORDER; i++) {
661  if (e->bitrate != RATE_QUANT)
662  e->lspf[i] = e->prev_lspf[i] * 0.875 + 0.125 * (i + 1) * 0.048;
663  else
664  e->lspf[i] = e->prev_lspf[i];
665  }
666 
667  if (e->prev_error_flag)
668  e->avg_acb_gain *= 0.75;
669  if (e->bitrate == RATE_FULL)
670  memcpy(e->pitch_back, e->pitch, ACB_SIZE * sizeof(float));
671  if (e->last_valid_bitrate == RATE_QUANT)
672  e->bitrate = RATE_QUANT;
673  else
674  e->bitrate = RATE_FULL;
675 
676  if (e->bitrate == RATE_FULL || e->bitrate == RATE_HALF) {
678  } else {
679  float sum = 0;
680 
681  idelay[0] = idelay[1] = idelay[2] = MIN_DELAY;
682 
683  for (i = 0; i < NB_SUBFRAMES; i++)
685  sum /= (float) NB_SUBFRAMES;
686  sum = pow(10, sum);
687  for (i = 0; i < NB_SUBFRAMES; i++)
688  e->energy_vector[i] = sum;
689  }
690 
691  if (fabs(e->pitch_delay - e->prev_pitch_delay) > 15)
693 
694  for (i = 0; i < NB_SUBFRAMES; i++) {
695  int subframe_size = subframe_sizes[i];
696  int pitch_lag;
697 
698  interpolate_lsp(ilspf, e->lspf, e->prev_lspf, i);
699 
700  if (e->bitrate != RATE_QUANT) {
701  if (e->avg_acb_gain < 0.3) {
702  idelay[0] = estimation_delay[i];
703  idelay[1] = estimation_delay[i + 1];
704  idelay[2] = estimation_delay[i + 2];
705  } else {
707  }
708  }
709 
710  pitch_lag = lrintf((idelay[1] + idelay[0]) / 2.0);
711  decode_predictor_coeffs(ilspf, ilpc);
712 
713  if (e->bitrate != RATE_QUANT) {
714  acb_excitation(e, e->pitch + ACB_SIZE,
715  e->avg_acb_gain, idelay, subframe_size);
716  for (j = 0; j < subframe_size; j++)
717  e->pitch[ACB_SIZE + j] *= e->fade_scale;
718  e->fade_scale = FFMAX(e->fade_scale - 0.05, 0.0);
719  } else {
720  for (j = 0; j < subframe_size; j++)
721  e->pitch[ACB_SIZE + j] = e->energy_vector[i];
722  }
723 
724  memmove(e->pitch, e->pitch + subframe_size, ACB_SIZE * sizeof(float));
725 
726  if (e->bitrate != RATE_QUANT && e->avg_acb_gain < 0.4) {
727  f = 0.1 * e->avg_fcb_gain;
728  for (j = 0; j < subframe_size; j++)
729  e->pitch[ACB_SIZE + j] += f;
730  } else if (e->bitrate == RATE_QUANT) {
731  for (j = 0; j < subframe_size; j++)
732  e->pitch[ACB_SIZE + j] = e->energy_vector[i];
733  }
734 
735  synthesis_filter(e->pitch + ACB_SIZE, ilpc,
736  e->synthesis, subframe_size, tmp);
737  postfilter(e, tmp, ilpc, samples, pitch_lag,
738  &postfilter_coeffs[e->bitrate], subframe_size);
739 
740  samples += subframe_size;
741  }
742 }
743 
745  int *got_frame_ptr, AVPacket *avpkt)
746 {
747  const uint8_t *buf = avpkt->data;
748  EVRCContext *e = avctx->priv_data;
749  int buf_size = avpkt->size;
750  float ilspf[FILTER_ORDER], ilpc[FILTER_ORDER], idelay[NB_SUBFRAMES];
751  float *samples;
752  int i, j, ret, error_flag = 0;
753 
754  frame->nb_samples = 160;
755  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
756  return ret;
757  samples = (float *)frame->data[0];
758 
759  if ((e->bitrate = determine_bitrate(avctx, &buf_size, &buf)) == RATE_ERRS) {
760  warn_insufficient_frame_quality(avctx, "bitrate cannot be determined.");
761  goto erasure;
762  }
763  if (e->bitrate <= SILENCE || e->bitrate == RATE_QUARTER)
764  goto erasure;
766  && !e->prev_error_flag)
767  goto erasure;
768 
769  if ((ret = init_get_bits8(&e->gb, buf, buf_size)) < 0)
770  return ret;
771  memset(&e->frame, 0, sizeof(EVRCAFrame));
772 
773  unpack_frame(e);
774 
775  if (e->bitrate != RATE_QUANT) {
776  uint8_t *p = (uint8_t *) &e->frame;
777  for (i = 0; i < sizeof(EVRCAFrame); i++) {
778  if (p[i])
779  break;
780  }
781  if (i == sizeof(EVRCAFrame))
782  goto erasure;
783  } else if (e->frame.lsp[0] == 0xf &&
784  e->frame.lsp[1] == 0xf &&
785  e->frame.energy_gain == 0xff) {
786  goto erasure;
787  }
788 
789  if (decode_lspf(e) < 0)
790  goto erasure;
791 
792  if (e->bitrate == RATE_FULL || e->bitrate == RATE_HALF) {
793  /* Pitch delay parameter checking as per TIA/IS-127 5.1.5.1 */
795  goto erasure;
796 
798 
799  /* Delay diff parameter checking as per TIA/IS-127 5.1.5.2 */
800  if (e->frame.delay_diff) {
801  int p = e->pitch_delay - e->frame.delay_diff + 16;
802  if (p < MIN_DELAY || p > MAX_DELAY)
803  goto erasure;
804  }
805 
806  /* Delay contour reconstruction as per TIA/IS-127 5.2.2.2 */
807  if (e->frame.delay_diff &&
808  e->bitrate == RATE_FULL && e->prev_error_flag) {
809  float delay;
810 
811  memcpy(e->pitch, e->pitch_back, ACB_SIZE * sizeof(float));
812 
813  delay = e->prev_pitch_delay;
814  e->prev_pitch_delay = delay - e->frame.delay_diff + 16.0;
815 
816  if (fabs(e->pitch_delay - delay) > 15)
817  delay = e->pitch_delay;
818 
819  for (i = 0; i < NB_SUBFRAMES; i++) {
820  int subframe_size = subframe_sizes[i];
821 
822  interpolate_delay(idelay, delay, e->prev_pitch_delay, i);
823  acb_excitation(e, e->pitch + ACB_SIZE, e->avg_acb_gain, idelay, subframe_size);
824  memmove(e->pitch, e->pitch + subframe_size, ACB_SIZE * sizeof(float));
825  }
826  }
827 
828  /* Smoothing of the decoded delay as per TIA/IS-127 5.2.2.5 */
829  if (fabs(e->pitch_delay - e->prev_pitch_delay) > 15)
831 
832  e->avg_acb_gain = e->avg_fcb_gain = 0.0;
833  } else {
834  idelay[0] = idelay[1] = idelay[2] = MIN_DELAY;
835 
836  /* Decode frame energy vectors as per TIA/IS-127 5.7.2 */
837  for (i = 0; i < NB_SUBFRAMES; i++)
838  e->energy_vector[i] = pow(10, evrc_energy_quant[e->frame.energy_gain][i]);
840  }
841 
842  for (i = 0; i < NB_SUBFRAMES; i++) {
843  float tmp[SUBFRAME_SIZE + 6] = { 0 };
844  int subframe_size = subframe_sizes[i];
845  int pitch_lag;
846 
847  interpolate_lsp(ilspf, e->lspf, e->prev_lspf, i);
848 
849  if (e->bitrate != RATE_QUANT)
851 
852  pitch_lag = lrintf((idelay[1] + idelay[0]) / 2.0);
853  decode_predictor_coeffs(ilspf, ilpc);
854 
855  /* Bandwidth expansion as per TIA/IS-127 5.2.3.3 */
856  if (e->frame.lpc_flag && e->prev_error_flag)
857  bandwidth_expansion(ilpc, ilpc, 0.75);
858 
859  if (e->bitrate != RATE_QUANT) {
860  float acb_sum, f;
861 
862  f = exp((e->bitrate == RATE_HALF ? 0.5 : 0.25)
863  * (e->frame.fcb_gain[i] + 1));
864  acb_sum = pitch_gain_vq[e->frame.acb_gain[i]];
865  e->avg_acb_gain += acb_sum / NB_SUBFRAMES;
866  e->avg_fcb_gain += f / NB_SUBFRAMES;
867 
868  acb_excitation(e, e->pitch + ACB_SIZE,
869  acb_sum, idelay, subframe_size);
871  acb_sum, pitch_lag, subframe_size);
872 
873  /* Total excitation generation as per TIA/IS-127 5.2.3.9 */
874  for (j = 0; j < subframe_size; j++)
875  e->pitch[ACB_SIZE + j] += f * tmp[j];
876  e->fade_scale = FFMIN(e->fade_scale + 0.2, 1.0);
877  } else {
878  for (j = 0; j < subframe_size; j++)
879  e->pitch[ACB_SIZE + j] = e->energy_vector[i];
880  }
881 
882  memmove(e->pitch, e->pitch + subframe_size, ACB_SIZE * sizeof(float));
883 
884  synthesis_filter(e->pitch + ACB_SIZE, ilpc,
885  e->synthesis, subframe_size,
886  e->postfilter ? tmp : samples);
887  if (e->postfilter)
888  postfilter(e, tmp, ilpc, samples, pitch_lag,
889  &postfilter_coeffs[e->bitrate], subframe_size);
890 
891  samples += subframe_size;
892  }
893 
894  if (error_flag) {
895 erasure:
896  error_flag = 1;
897  av_log(avctx, AV_LOG_WARNING, "frame erasure\n");
899  }
900 
901  memcpy(e->prev_lspf, e->lspf, sizeof(e->prev_lspf));
902  e->prev_error_flag = error_flag;
903  e->last_valid_bitrate = e->bitrate;
904 
905  if (e->bitrate != RATE_QUANT)
907 
908  samples = (float *)frame->data[0];
909  for (i = 0; i < 160; i++)
910  samples[i] /= 32768;
911 
912  *got_frame_ptr = 1;
913 
914  return avpkt->size;
915 }
916 
917 #define OFFSET(x) offsetof(EVRCContext, x)
918 #define AD AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM
919 
920 static const AVOption options[] = {
921  { "postfilter", "enable postfilter", OFFSET(postfilter), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, AD },
922  { NULL }
923 };
924 
925 static const AVClass evrcdec_class = {
926  .class_name = "evrc",
927  .item_name = av_default_item_name,
928  .option = options,
929  .version = LIBAVUTIL_VERSION_INT,
930 };
931 
933  .p.name = "evrc",
934  .p.long_name = NULL_IF_CONFIG_SMALL("EVRC (Enhanced Variable Rate Codec)"),
935  .p.type = AVMEDIA_TYPE_AUDIO,
936  .p.id = AV_CODEC_ID_EVRC,
937  .init = evrc_decode_init,
939  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
940  .priv_data_size = sizeof(EVRCContext),
941  .p.priv_class = &evrcdec_class,
942  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
943 };
EVRCAFrame::lsp
uint16_t lsp[4]
index into LSP codebook
Definition: evrcdec.c:61
PfCoeff::p2
float p2
Definition: evrcdec.c:559
determine_bitrate
static evrc_packet_rate determine_bitrate(AVCodecContext *avctx, int *buf_size, const uint8_t **buf)
Determine the bitrate from the frame size and/or the first byte of the frame.
Definition: evrcdec.c:190
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
FILTER_ORDER
#define FILTER_ORDER
Definition: evrcdec.c:44
EVRCContext::gb
GetBitContext gb
Definition: evrcdec.c:76
RATE_ERRS
@ RATE_ERRS
Definition: evrcdec.c:48
interpolate_delay
static void interpolate_delay(float *dst, float current, float prev, int index)
Definition: evrcdec.c:331
acelp_vectors.h
opt.h
decode_lspf
static int decode_lspf(EVRCContext *e)
Decode the 10 vector quantized line spectral pair frequencies from the LSP transmission codes of any ...
Definition: evrcdec.c:284
out
FILE * out
Definition: movenc.c:54
fcb_excitation
static void fcb_excitation(EVRCContext *e, const uint16_t *codebook, float *excitation, float pitch_gain, int pitch_lag, int subframe_size)
Definition: evrcdec.c:478
message
Definition: api-threadmessage-test.c:46
buf_size2bitrate
static evrc_packet_rate buf_size2bitrate(const int buf_size)
Definition: evrcdec.c:167
PfCoeff::p1
float p1
Definition: evrcdec.c:558
residual_filter
static void residual_filter(float *output, const float *input, const float *coef, float *memory, int length)
Definition: evrcdec.c:533
EVRCContext::prev_energy_gain
uint8_t prev_energy_gain
Definition: evrcdec.c:98
output
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce output
Definition: filter_design.txt:225
evrc_lspq_codebooks
static const float *const *const evrc_lspq_codebooks[]
Definition: evrcdata.h:1454
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:374
evrc_decode_frame
static int evrc_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)
Definition: evrcdec.c:744
AVOption
AVOption.
Definition: opt.h:251
EVRCContext::prev_error_flag
uint8_t prev_error_flag
Definition: evrcdec.c:99
b
#define b
Definition: input.c:34
codebooks
static const uint8_t codebooks[]
Definition: vorbis_enc_data.h:26
AV_CHANNEL_LAYOUT_MONO
#define AV_CHANNEL_LAYOUT_MONO
Definition: channel_layout.h:353
FFCodec
Definition: codec_internal.h:112
EVRCContext::pitch_back
float pitch_back[ACB_SIZE]
Definition: evrcdec.c:92
mathematics.h
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
evrc_energy_quant
static const float evrc_energy_quant[][3]
Rate 1/8 frame energy quantization.
Definition: evrcdata.h:38
EVRCContext::pitch
float pitch[ACB_SIZE+FILTER_ORDER+SUBFRAME_SIZE]
Definition: evrcdec.c:91
EVRCAFrame::fcb_gain
uint8_t fcb_gain[3]
fixed codebook gain index
Definition: evrcdec.c:66
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
EVRCAFrame::tty
uint8_t tty
tty baud rate bit
Definition: evrcdec.c:68
postfilter_coeffs
static const struct PfCoeff postfilter_coeffs[5]
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:116
b1
static double b1(void *priv, double x, double y)
Definition: vf_xfade.c:1703
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:2056
MIN_LSP_SEP
#define MIN_LSP_SEP
Definition: evrcdec.c:39
subframe_sizes
static const uint8_t subframe_sizes[]
Definition: evrcdata.h:1498
GetBitContext
Definition: get_bits.h:61
unpack_frame
static void unpack_frame(EVRCContext *e)
Frame unpacking for RATE_FULL, RATE_HALF and RATE_QUANT.
Definition: evrcdec.c:110
SILENCE
@ SILENCE
Definition: evrcdec.c:49
EVRCContext::last_valid_bitrate
evrc_packet_rate last_valid_bitrate
Definition: evrcdec.c:78
interpolate_lsp
static void interpolate_lsp(float *ilsp, const float *lsp, const float *prev, int index)
Definition: evrcdec.c:317
a1
#define a1
Definition: regdef.h:47
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
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:667
acb_excitation
static void acb_excitation(EVRCContext *e, float *excitation, float gain, const float delay[3], int length)
Definition: evrcdec.c:406
EVRCAFrame::fcb_shape
uint16_t fcb_shape[3][4]
fixed codebook shape
Definition: evrcdec.c:65
float
float
Definition: af_crystalizer.c:122
EVRCContext::warned_buf_mismatch_bitrate
uint8_t warned_buf_mismatch_bitrate
Definition: evrcdec.c:100
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:254
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
evrc_lspq_codebooks_row_sizes
static const uint8_t *const evrc_lspq_codebooks_row_sizes[]
Definition: evrcdata.h:1488
AD
#define AD
Definition: evrcdec.c:918
ff_acelp_lsf2lspd
void ff_acelp_lsf2lspd(double *lsp, const float *lsf, int lp_order)
Floating point version of ff_acelp_lsf2lsp()
Definition: lsp.c:93
EVRCAFrame::acb_gain
uint8_t acb_gain[3]
adaptive codebook gain
Definition: evrcdec.c:64
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
get_bits.h
EVRCContext::avg_fcb_gain
float avg_fcb_gain
average fixed codebook gain
Definition: evrcdec.c:90
EVRCAFrame::lpc_flag
uint8_t lpc_flag
spectral change indicator
Definition: evrcdec.c:60
EVRCContext::postfilter_fir
float postfilter_fir[FILTER_ORDER]
Definition: evrcdec.c:84
if
if(ret)
Definition: filter_design.txt:179
bl_intrp
static void bl_intrp(EVRCContext *e, float *ex, float delay)
Definition: evrcdec.c:378
EVRCContext::prev_lspf
float prev_lspf[FILTER_ORDER]
Definition: evrcdec.c:82
EVRCContext::postfilter_iir
float postfilter_iir[FILTER_ORDER]
Definition: evrcdec.c:85
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
EVRCAFrame::delay_diff
uint8_t delay_diff
delay difference for entire frame
Definition: evrcdec.c:63
bandwidth_expansion
static void bandwidth_expansion(float *coeff, const float *inbuf, float gamma)
Definition: evrcdec.c:522
decode_8_pulses_35bits
static void decode_8_pulses_35bits(const uint16_t *fixed_index, float *cod)
Definition: evrcdec.c:433
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
fabs
static __device__ float fabs(float a)
Definition: cuda_runtime.h:182
NULL
#define NULL
Definition: coverity.c:32
EVRCAFrame::pitch_delay
uint8_t pitch_delay
pitch delay for entire frame
Definition: evrcdec.c:62
PfCoeff
Definition: evrcdec.c:555
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
EVRCContext::interpolation_coeffs
float interpolation_coeffs[136]
Definition: evrcdec.c:93
MAX_DELAY
#define MAX_DELAY
Definition: evrcdec.c:41
EVRCContext::postfilter
int postfilter
Definition: evrcdec.c:74
av_clipf
av_clipf
Definition: af_crystalizer.c:122
OFFSET
#define OFFSET(x)
Definition: evrcdec.c:917
exp
int8_t exp
Definition: eval.c:72
estimation_delay
static const float estimation_delay[]
Definition: evrcdata.h:1497
decode_3_pulses_10bits
static void decode_3_pulses_10bits(uint16_t fixed_index, float *cod)
Definition: evrcdec.c:458
index
int index
Definition: gxfenc.c:89
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
ACB_SIZE
#define ACB_SIZE
Definition: evrcdec.c:45
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
f
f
Definition: af_crystalizer.c:122
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:117
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:290
codec_internal.h
EVRCAFrame
EVRC-A unpacked data frame.
Definition: evrcdec.c:59
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
EVRCContext::pitch_delay
float pitch_delay
Definition: evrcdec.c:87
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1014
EVRCContext::prev_pitch_delay
float prev_pitch_delay
Definition: evrcdec.c:88
EVRCContext::fade_scale
float fade_scale
Definition: evrcdec.c:95
b2
static double b2(void *priv, double x, double y)
Definition: vf_xfade.c:1704
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
RATE_QUARTER
@ RATE_QUARTER
Definition: evrcdec.c:51
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
RATE_HALF
@ RATE_HALF
Definition: evrcdec.c:52
EVRCContext::lspf
float lspf[FILTER_ORDER]
Definition: evrcdec.c:81
bitrate
int64_t bitrate
Definition: h264_levels.c:131
input
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some input
Definition: filter_design.txt:172
M_PI
#define M_PI
Definition: mathematics.h:52
evrc_packet_rate
evrc_packet_rate
Definition: evrcdec.c:47
options
static const AVOption options[]
Definition: evrcdec.c:920
PfCoeff::tilt
float tilt
Definition: evrcdec.c:556
EVRCContext::postfilter_residual
float postfilter_residual[ACB_SIZE+SUBFRAME_SIZE]
Definition: evrcdec.c:86
synthesis_filter
static void synthesis_filter(const float *in, const float *filter_coeffs, float *memory, int buffer_length, float *samples)
Synthesis of the decoder output signal.
Definition: evrcdec.c:506
lrintf
#define lrintf(x)
Definition: libm_mips.h:72
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
AV_CODEC_ID_EVRC
@ AV_CODEC_ID_EVRC
Definition: codec_id.h:498
NB_SUBFRAMES
#define NB_SUBFRAMES
Definition: evrcdec.c:42
a2
#define a2
Definition: regdef.h:48
xf
#define xf(width, name, var, range_min, range_max, subs,...)
Definition: cbs_av1.c:664
postfilter
static void postfilter(EVRCContext *e, float *in, const float *coeff, float *out, int idx, const struct PfCoeff *pfc, int length)
Definition: evrcdec.c:573
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
EVRCContext::frame
EVRCAFrame frame
Definition: evrcdec.c:79
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
PfCoeff::ltgain
float ltgain
Definition: evrcdec.c:557
EVRCContext::avg_acb_gain
float avg_acb_gain
average adaptive codebook gain
Definition: evrcdec.c:89
RATE_QUANT
@ RATE_QUANT
Definition: evrcdec.c:50
warn_insufficient_frame_quality
static void warn_insufficient_frame_quality(AVCodecContext *avctx, const char *message)
Definition: evrcdec.c:221
avcodec.h
ret
ret
Definition: filter_design.txt:187
EVRCContext::energy_vector
float energy_vector[NB_SUBFRAMES]
Definition: evrcdec.c:94
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
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
evrcdata.h
pos
unsigned int pos
Definition: spdifenc.c:412
AVCodecContext
main external API structure.
Definition: avcodec.h:389
channel_layout.h
EVRCContext::last
float last
Definition: evrcdec.c:96
MIN_DELAY
#define MIN_DELAY
Definition: evrcdec.c:40
temp
else temp
Definition: vf_mcdeint.c:248
SUBFRAME_SIZE
#define SUBFRAME_SIZE
Definition: evrcdec.c:43
RATE_FULL
@ RATE_FULL
Definition: evrcdec.c:53
frame_erasure
static void frame_erasure(EVRCContext *e, float *samples)
Definition: evrcdec.c:654
samples
Filter the word “frame” indicates either a video frame or a group of audio samples
Definition: filter_design.txt:8
EVRCAFrame::energy_gain
uint8_t energy_gain
frame energy gain index
Definition: evrcdec.c:67
evrc_lspq_nb_codebooks
static const uint8_t evrc_lspq_nb_codebooks[]
Definition: evrcdata.h:1462
AVCodecContext::frame_number
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:1037
ff_evrc_decoder
const FFCodec ff_evrc_decoder
Definition: evrcdec.c:932
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:416
EVRCContext::bitrate
evrc_packet_rate bitrate
Definition: evrcdec.c:77
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:244
coeff
static const double coeff[2][5]
Definition: vf_owdenoise.c:78
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
decode_predictor_coeffs
static void decode_predictor_coeffs(const float *ilspf, float *ilpc)
Definition: evrcdec.c:348
pitch_gain_vq
static const float pitch_gain_vq[]
Definition: evrcdata.h:1496
EVRCContext::synthesis
float synthesis[FILTER_ORDER]
Definition: evrcdec.c:83
EVRCContext
Definition: evrcdec.c:71
AV_SAMPLE_FMT_FLT
@ AV_SAMPLE_FMT_FLT
float
Definition: samplefmt.h:60
codebook
static const unsigned codebook[256][2]
Definition: cfhdenc.c:42
evrcdec_class
static const AVClass evrcdec_class
Definition: evrcdec.c:925
evrc_decode_init
static av_cold int evrc_decode_init(AVCodecContext *avctx)
Initialize the speech codec according to the specification.
Definition: evrcdec.c:233