FFmpeg
g729dec.c
Go to the documentation of this file.
1 /*
2  * G.729, G729 Annex D decoders
3  * Copyright (c) 2008 Vladimir Voroshilov
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 #include <inttypes.h>
23 #include <string.h>
24 
25 #include "avcodec.h"
26 #include "libavutil/avutil.h"
27 #include "get_bits.h"
28 #include "audiodsp.h"
29 #include "codec_internal.h"
30 #include "decode.h"
31 
32 
33 #include "g729.h"
34 #include "lsp.h"
35 #include "celp_filters.h"
36 #include "acelp_filters.h"
37 #include "acelp_pitch_delay.h"
38 #include "acelp_vectors.h"
39 #include "g729data.h"
40 #include "g729postfilter.h"
41 
42 /**
43  * minimum quantized LSF value (3.2.4)
44  * 0.005 in Q13
45  */
46 #define LSFQ_MIN 40
47 
48 /**
49  * maximum quantized LSF value (3.2.4)
50  * 3.135 in Q13
51  */
52 #define LSFQ_MAX 25681
53 
54 /**
55  * minimum LSF distance (3.2.4)
56  * 0.0391 in Q13
57  */
58 #define LSFQ_DIFF_MIN 321
59 
60 /// interpolation filter length
61 #define INTERPOL_LEN 11
62 
63 /**
64  * minimum gain pitch value (3.8, Equation 47)
65  * 0.2 in (1.14)
66  */
67 #define SHARP_MIN 3277
68 
69 /**
70  * maximum gain pitch value (3.8, Equation 47)
71  * (EE) This does not comply with the specification.
72  * Specification says about 0.8, which should be
73  * 13107 in (1.14), but reference C code uses
74  * 13017 (equals to 0.7945) instead of it.
75  */
76 #define SHARP_MAX 13017
77 
78 /**
79  * MR_ENERGY (mean removed energy) = mean_energy + 10 * log10(2^26 * subframe_size) in (7.13)
80  */
81 #define MR_ENERGY 1018156
82 
83 #define DECISION_NOISE 0
84 #define DECISION_INTERMEDIATE 1
85 #define DECISION_VOICE 2
86 
87 typedef enum {
91 } G729Formats;
92 
93 typedef struct {
94  uint8_t ac_index_bits[2]; ///< adaptive codebook index for second subframe (size in bits)
95  uint8_t parity_bit; ///< parity bit for pitch delay
96  uint8_t gc_1st_index_bits; ///< gain codebook (first stage) index (size in bits)
97  uint8_t gc_2nd_index_bits; ///< gain codebook (second stage) index (size in bits)
98  uint8_t fc_signs_bits; ///< number of pulses in fixed-codebook vector
99  uint8_t fc_indexes_bits; ///< size (in bits) of fixed-codebook index entry
100  uint8_t block_size;
102 
103 typedef struct {
104  /// past excitation signal buffer
106 
107  int16_t* exc; ///< start of past excitation data in buffer
108  int pitch_delay_int_prev; ///< integer part of previous subframe's pitch delay (4.1.3)
109 
110  /// (2.13) LSP quantizer outputs
111  int16_t past_quantizer_output_buf[MA_NP + 1][10];
112  int16_t* past_quantizer_outputs[MA_NP + 1];
113 
114  int16_t lsfq[10]; ///< (2.13) quantized LSF coefficients from previous frame
115  int16_t lsp_buf[2][10]; ///< (0.15) LSP coefficients (previous and current frames) (3.2.5)
116  int16_t *lsp[2]; ///< pointers to lsp_buf
117 
118  int16_t quant_energy[4]; ///< (5.10) past quantized energy
119 
120  /// previous speech data for LP synthesis filter
121  int16_t syn_filter_data[10];
122 
123 
124  /// residual signal buffer (used in long-term postfilter)
125  int16_t residual[SUBFRAME_SIZE + RES_PREV_DATA_SIZE];
126 
127  /// previous speech data for residual calculation filter
128  int16_t res_filter_data[SUBFRAME_SIZE+10];
129 
130  /// previous speech data for short-term postfilter
131  int16_t pos_filter_data[SUBFRAME_SIZE+10];
132 
133  /// (1.14) pitch gain of current and five previous subframes
134  int16_t past_gain_pitch[6];
135 
136  /// (14.1) gain code from current and previous subframe
137  int16_t past_gain_code[2];
138 
139  /// voice decision on previous subframe (0-noise, 1-intermediate, 2-voice), G.729D
140  int16_t voice_decision;
141 
142  int16_t onset; ///< detected onset level (0-2)
143  int16_t was_periodic; ///< whether previous frame was declared as periodic or not (4.4)
144  int16_t ht_prev_data; ///< previous data for 4.2.3, equation 86
145  int gain_coeff; ///< (1.14) gain coefficient (4.2.4)
146  uint16_t rand_value; ///< random number generator value (4.4.4)
147  int ma_predictor_prev; ///< switched MA predictor of LSP quantizer from last good frame
148 
149  /// (14.14) high-pass filter data (past input)
150  int hpf_f[2];
151 
152  /// high-pass filter data (past output)
153  int16_t hpf_z[2];
155 
156 typedef struct {
158 
160 } G729Context;
161 
163  .ac_index_bits = {8,5},
164  .parity_bit = 1,
165  .gc_1st_index_bits = GC_1ST_IDX_BITS_8K,
166  .gc_2nd_index_bits = GC_2ND_IDX_BITS_8K,
167  .fc_signs_bits = 4,
168  .fc_indexes_bits = 13,
169  .block_size = G729_8K_BLOCK_SIZE,
170 };
171 
173  .ac_index_bits = {8,4},
174  .parity_bit = 0,
175  .gc_1st_index_bits = GC_1ST_IDX_BITS_6K4,
176  .gc_2nd_index_bits = GC_2ND_IDX_BITS_6K4,
177  .fc_signs_bits = 2,
178  .fc_indexes_bits = 9,
179  .block_size = G729D_6K4_BLOCK_SIZE,
180 };
181 
182 /**
183  * @brief pseudo random number generator
184  */
185 static inline uint16_t g729_prng(uint16_t value)
186 {
187  return 31821 * value + 13849;
188 }
189 
190 /**
191  * Decodes LSF (Line Spectral Frequencies) from L0-L3 (3.2.4).
192  * @param[out] lsfq (2.13) quantized LSF coefficients
193  * @param[in,out] past_quantizer_outputs (2.13) quantizer outputs from previous frames
194  * @param ma_predictor switched MA predictor of LSP quantizer
195  * @param vq_1st first stage vector of quantizer
196  * @param vq_2nd_low second stage lower vector of LSP quantizer
197  * @param vq_2nd_high second stage higher vector of LSP quantizer
198  */
199 static void lsf_decode(int16_t* lsfq, int16_t* past_quantizer_outputs[MA_NP + 1],
200  int16_t ma_predictor,
201  int16_t vq_1st, int16_t vq_2nd_low, int16_t vq_2nd_high)
202 {
203  int i,j;
204  static const uint8_t min_distance[2]={10, 5}; //(2.13)
205  int16_t* quantizer_output = past_quantizer_outputs[MA_NP];
206 
207  for (i = 0; i < 5; i++) {
208  quantizer_output[i] = cb_lsp_1st[vq_1st][i ] + cb_lsp_2nd[vq_2nd_low ][i ];
209  quantizer_output[i + 5] = cb_lsp_1st[vq_1st][i + 5] + cb_lsp_2nd[vq_2nd_high][i + 5];
210  }
211 
212  for (j = 0; j < 2; j++) {
213  for (i = 1; i < 10; i++) {
214  int diff = (quantizer_output[i - 1] - quantizer_output[i] + min_distance[j]) >> 1;
215  if (diff > 0) {
216  quantizer_output[i - 1] -= diff;
217  quantizer_output[i ] += diff;
218  }
219  }
220  }
221 
222  for (i = 0; i < 10; i++) {
223  int sum = quantizer_output[i] * cb_ma_predictor_sum[ma_predictor][i];
224  for (j = 0; j < MA_NP; j++)
225  sum += past_quantizer_outputs[j][i] * cb_ma_predictor[ma_predictor][j][i];
226 
227  lsfq[i] = sum >> 15;
228  }
229 
231 }
232 
233 /**
234  * Restores past LSP quantizer output using LSF from previous frame
235  * @param[in,out] lsfq (2.13) quantized LSF coefficients
236  * @param[in,out] past_quantizer_outputs (2.13) quantizer outputs from previous frames
237  * @param ma_predictor_prev MA predictor from previous frame
238  * @param lsfq_prev (2.13) quantized LSF coefficients from previous frame
239  */
240 static void lsf_restore_from_previous(int16_t* lsfq,
241  int16_t* past_quantizer_outputs[MA_NP + 1],
242  int ma_predictor_prev)
243 {
244  int16_t* quantizer_output = past_quantizer_outputs[MA_NP];
245  int i,k;
246 
247  for (i = 0; i < 10; i++) {
248  int tmp = lsfq[i] << 15;
249 
250  for (k = 0; k < MA_NP; k++)
251  tmp -= past_quantizer_outputs[k][i] * cb_ma_predictor[ma_predictor_prev][k][i];
252 
253  quantizer_output[i] = ((tmp >> 15) * cb_ma_predictor_sum_inv[ma_predictor_prev][i]) >> 12;
254  }
255 }
256 
257 /**
258  * Constructs new excitation signal and applies phase filter to it
259  * @param[out] out constructed speech signal
260  * @param in original excitation signal
261  * @param fc_cur (2.13) original fixed-codebook vector
262  * @param gain_code (14.1) gain code
263  * @param subframe_size length of the subframe
264  */
265 static void g729d_get_new_exc(
266  int16_t* out,
267  const int16_t* in,
268  const int16_t* fc_cur,
269  int dstate,
270  int gain_code,
271  int subframe_size)
272 {
273  int i;
274  int16_t fc_new[SUBFRAME_SIZE];
275 
276  ff_celp_convolve_circ(fc_new, fc_cur, phase_filter[dstate], subframe_size);
277 
278  for (i = 0; i < subframe_size; i++) {
279  out[i] = in[i];
280  out[i] -= (gain_code * fc_cur[i] + 0x2000) >> 14;
281  out[i] += (gain_code * fc_new[i] + 0x2000) >> 14;
282  }
283 }
284 
285 /**
286  * Makes decision about onset in current subframe
287  * @param past_onset decision result of previous subframe
288  * @param past_gain_code gain code of current and previous subframe
289  *
290  * @return onset decision result for current subframe
291  */
292 static int g729d_onset_decision(int past_onset, const int16_t* past_gain_code)
293 {
294  if ((past_gain_code[0] >> 1) > past_gain_code[1])
295  return 2;
296 
297  return FFMAX(past_onset-1, 0);
298 }
299 
300 /**
301  * Makes decision about voice presence in current subframe
302  * @param onset onset level
303  * @param prev_voice_decision voice decision result from previous subframe
304  * @param past_gain_pitch pitch gain of current and previous subframes
305  *
306  * @return voice decision result for current subframe
307  */
308 static int16_t g729d_voice_decision(int onset, int prev_voice_decision, const int16_t* past_gain_pitch)
309 {
310  int i, low_gain_pitch_cnt, voice_decision;
311 
312  if (past_gain_pitch[0] >= 14745) { // 0.9
313  voice_decision = DECISION_VOICE;
314  } else if (past_gain_pitch[0] <= 9830) { // 0.6
315  voice_decision = DECISION_NOISE;
316  } else {
317  voice_decision = DECISION_INTERMEDIATE;
318  }
319 
320  for (i = 0, low_gain_pitch_cnt = 0; i < 6; i++)
321  if (past_gain_pitch[i] < 9830)
322  low_gain_pitch_cnt++;
323 
324  if (low_gain_pitch_cnt > 2 && !onset)
325  voice_decision = DECISION_NOISE;
326 
327  if (!onset && voice_decision > prev_voice_decision + 1)
328  voice_decision--;
329 
330  if (onset && voice_decision < DECISION_VOICE)
331  voice_decision++;
332 
333  return voice_decision;
334 }
335 
336 static int32_t scalarproduct_int16_c(const int16_t * v1, const int16_t * v2, int order)
337 {
338  int64_t res = 0;
339 
340  while (order--)
341  res += *v1++ * *v2++;
342 
343  if (res > INT32_MAX) return INT32_MAX;
344  else if (res < INT32_MIN) return INT32_MIN;
345 
346  return res;
347 }
348 
350 {
351  G729Context *s = avctx->priv_data;
353  int channels = avctx->ch_layout.nb_channels;
354  int c,i,k;
355 
357  av_log(avctx, AV_LOG_ERROR, "Only mono and stereo are supported (requested channels: %d).\n", channels);
358  return AVERROR(EINVAL);
359  }
361 
362  /* Both 8kbit/s and 6.4kbit/s modes uses two subframes per frame. */
363  avctx->frame_size = SUBFRAME_SIZE << 1;
364 
365  ctx =
366  s->channel_context = av_mallocz(sizeof(G729ChannelContext) * channels);
367  if (!ctx)
368  return AVERROR(ENOMEM);
369 
370  for (c = 0; c < channels; c++) {
371  ctx->gain_coeff = 16384; // 1.0 in (1.14)
372 
373  for (k = 0; k < MA_NP + 1; k++) {
374  ctx->past_quantizer_outputs[k] = ctx->past_quantizer_output_buf[k];
375  for (i = 1; i < 11; i++)
376  ctx->past_quantizer_outputs[k][i - 1] = (18717 * i) >> 3;
377  }
378 
379  ctx->lsp[0] = ctx->lsp_buf[0];
380  ctx->lsp[1] = ctx->lsp_buf[1];
381  memcpy(ctx->lsp[0], lsp_init, 10 * sizeof(int16_t));
382 
383  ctx->exc = &ctx->exc_base[PITCH_DELAY_MAX+INTERPOL_LEN];
384 
385  ctx->pitch_delay_int_prev = PITCH_DELAY_MIN;
386 
387  /* random seed initialization */
388  ctx->rand_value = 21845;
389 
390  /* quantized prediction error */
391  for (i = 0; i < 4; i++)
392  ctx->quant_energy[i] = -14336; // -14 in (5.10)
393 
394  ctx++;
395  }
396 
397  ff_audiodsp_init(&s->adsp);
398  s->adsp.scalarproduct_int16 = scalarproduct_int16_c;
399 
400  return 0;
401 }
402 
404  int *got_frame_ptr, AVPacket *avpkt)
405 {
406  const uint8_t *buf = avpkt->data;
407  int buf_size = avpkt->size;
408  int16_t *out_frame;
409  GetBitContext gb;
411  int c, i;
412  int16_t *tmp;
413  G729Formats packet_type;
414  G729Context *s = avctx->priv_data;
415  G729ChannelContext *ctx = s->channel_context;
416  int channels = avctx->ch_layout.nb_channels;
417  int16_t lp[2][11]; // (3.12)
418  uint8_t ma_predictor; ///< switched MA predictor of LSP quantizer
419  uint8_t quantizer_1st; ///< first stage vector of quantizer
420  uint8_t quantizer_2nd_lo; ///< second stage lower vector of quantizer (size in bits)
421  uint8_t quantizer_2nd_hi; ///< second stage higher vector of quantizer (size in bits)
422 
423  int pitch_delay_int[2]; // pitch delay, integer part
424  int pitch_delay_3x; // pitch delay, multiplied by 3
425  int16_t fc[SUBFRAME_SIZE]; // fixed-codebook vector
426  int16_t synth[SUBFRAME_SIZE+10]; // fixed-codebook vector
427  int j, ret;
428  int gain_before, gain_after;
429 
430  frame->nb_samples = SUBFRAME_SIZE<<1;
431  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
432  return ret;
433 
434  if (buf_size && buf_size % ((G729_8K_BLOCK_SIZE + (avctx->codec_id == AV_CODEC_ID_ACELP_KELVIN)) * channels) == 0) {
435  packet_type = FORMAT_G729_8K;
437  //Reset voice decision
438  ctx->onset = 0;
439  ctx->voice_decision = DECISION_VOICE;
440  av_log(avctx, AV_LOG_DEBUG, "Packet type: %s\n", "G.729 @ 8kbit/s");
441  } else if (buf_size == G729D_6K4_BLOCK_SIZE * channels && avctx->codec_id != AV_CODEC_ID_ACELP_KELVIN) {
442  packet_type = FORMAT_G729D_6K4;
444  av_log(avctx, AV_LOG_DEBUG, "Packet type: %s\n", "G.729D @ 6.4kbit/s");
445  } else {
446  av_log(avctx, AV_LOG_ERROR, "Packet size %d is unknown.\n", buf_size);
447  return AVERROR_INVALIDDATA;
448  }
449 
450  for (c = 0; c < channels; c++) {
451  int frame_erasure = 0; ///< frame erasure detected during decoding
452  int bad_pitch = 0; ///< parity check failed
453  int is_periodic = 0; ///< whether one of the subframes is declared as periodic or not
454  out_frame = (int16_t*)frame->data[c];
455  if (avctx->codec_id == AV_CODEC_ID_ACELP_KELVIN) {
456  if (*buf != ((avctx->ch_layout.nb_channels - 1 - c) * 0x80 | 2))
457  avpriv_request_sample(avctx, "First byte value %x for channel %d", *buf, c);
458  buf++;
459  }
460 
461  for (i = 0; i < format->block_size; i++)
462  frame_erasure |= buf[i];
464 
465  init_get_bits8(&gb, buf, format->block_size);
466 
467  ma_predictor = get_bits(&gb, 1);
468  quantizer_1st = get_bits(&gb, VQ_1ST_BITS);
469  quantizer_2nd_lo = get_bits(&gb, VQ_2ND_BITS);
470  quantizer_2nd_hi = get_bits(&gb, VQ_2ND_BITS);
471 
472  if (frame_erasure) {
473  lsf_restore_from_previous(ctx->lsfq, ctx->past_quantizer_outputs,
474  ctx->ma_predictor_prev);
475  } else {
476  lsf_decode(ctx->lsfq, ctx->past_quantizer_outputs,
477  ma_predictor,
478  quantizer_1st, quantizer_2nd_lo, quantizer_2nd_hi);
479  ctx->ma_predictor_prev = ma_predictor;
480  }
481 
482  tmp = ctx->past_quantizer_outputs[MA_NP];
483  memmove(ctx->past_quantizer_outputs + 1, ctx->past_quantizer_outputs,
484  MA_NP * sizeof(int16_t*));
485  ctx->past_quantizer_outputs[0] = tmp;
486 
487  ff_acelp_lsf2lsp(ctx->lsp[1], ctx->lsfq, 10);
488 
489  ff_acelp_lp_decode(&lp[0][0], &lp[1][0], ctx->lsp[1], ctx->lsp[0], 10);
490 
491  FFSWAP(int16_t*, ctx->lsp[1], ctx->lsp[0]);
492 
493  for (i = 0; i < 2; i++) {
494  int gain_corr_factor;
495 
496  uint8_t ac_index; ///< adaptive codebook index
497  uint8_t pulses_signs; ///< fixed-codebook vector pulse signs
498  int fc_indexes; ///< fixed-codebook indexes
499  uint8_t gc_1st_index; ///< gain codebook (first stage) index
500  uint8_t gc_2nd_index; ///< gain codebook (second stage) index
501 
502  ac_index = get_bits(&gb, format->ac_index_bits[i]);
503  if (!i && format->parity_bit)
504  bad_pitch = av_parity(ac_index >> 2) == get_bits1(&gb);
505  fc_indexes = get_bits(&gb, format->fc_indexes_bits);
506  pulses_signs = get_bits(&gb, format->fc_signs_bits);
507  gc_1st_index = get_bits(&gb, format->gc_1st_index_bits);
508  gc_2nd_index = get_bits(&gb, format->gc_2nd_index_bits);
509 
510  if (frame_erasure) {
511  pitch_delay_3x = 3 * ctx->pitch_delay_int_prev;
512  } else if (!i) {
513  if (bad_pitch) {
514  pitch_delay_3x = 3 * ctx->pitch_delay_int_prev;
515  } else {
516  pitch_delay_3x = ff_acelp_decode_8bit_to_1st_delay3(ac_index);
517  }
518  } else {
519  int pitch_delay_min = av_clip(ctx->pitch_delay_int_prev - 5,
521 
522  if (packet_type == FORMAT_G729D_6K4) {
523  pitch_delay_3x = ff_acelp_decode_4bit_to_2nd_delay3(ac_index, pitch_delay_min);
524  } else {
525  pitch_delay_3x = ff_acelp_decode_5_6_bit_to_2nd_delay3(ac_index, pitch_delay_min);
526  }
527  }
528 
529  /* Round pitch delay to nearest (used everywhere except ff_acelp_interpolate). */
530  pitch_delay_int[i] = (pitch_delay_3x + 1) / 3;
531  if (pitch_delay_int[i] > PITCH_DELAY_MAX) {
532  av_log(avctx, AV_LOG_WARNING, "pitch_delay_int %d is too large\n", pitch_delay_int[i]);
533  pitch_delay_int[i] = PITCH_DELAY_MAX;
534  }
535 
536  if (frame_erasure) {
537  ctx->rand_value = g729_prng(ctx->rand_value);
538  fc_indexes = av_mod_uintp2(ctx->rand_value, format->fc_indexes_bits);
539 
540  ctx->rand_value = g729_prng(ctx->rand_value);
541  pulses_signs = ctx->rand_value;
542  }
543 
544 
545  memset(fc, 0, sizeof(int16_t) * SUBFRAME_SIZE);
546  switch (packet_type) {
547  case FORMAT_G729_8K:
550  fc_indexes, pulses_signs, 3, 3);
551  break;
552  case FORMAT_G729D_6K4:
555  fc_indexes, pulses_signs, 1, 4);
556  break;
557  }
558 
559  /*
560  This filter enhances harmonic components of the fixed-codebook vector to
561  improve the quality of the reconstructed speech.
562 
563  / fc_v[i], i < pitch_delay
564  fc_v[i] = <
565  \ fc_v[i] + gain_pitch * fc_v[i-pitch_delay], i >= pitch_delay
566  */
567  if (SUBFRAME_SIZE > pitch_delay_int[i])
568  ff_acelp_weighted_vector_sum(fc + pitch_delay_int[i],
569  fc + pitch_delay_int[i],
570  fc, 1 << 14,
571  av_clip(ctx->past_gain_pitch[0], SHARP_MIN, SHARP_MAX),
572  0, 14,
573  SUBFRAME_SIZE - pitch_delay_int[i]);
574 
575  memmove(ctx->past_gain_pitch+1, ctx->past_gain_pitch, 5 * sizeof(int16_t));
576  ctx->past_gain_code[1] = ctx->past_gain_code[0];
577 
578  if (frame_erasure) {
579  ctx->past_gain_pitch[0] = (29491 * ctx->past_gain_pitch[0]) >> 15; // 0.90 (0.15)
580  ctx->past_gain_code[0] = ( 2007 * ctx->past_gain_code[0] ) >> 11; // 0.98 (0.11)
581 
582  gain_corr_factor = 0;
583  } else {
584  if (packet_type == FORMAT_G729D_6K4) {
585  ctx->past_gain_pitch[0] = cb_gain_1st_6k4[gc_1st_index][0] +
586  cb_gain_2nd_6k4[gc_2nd_index][0];
587  gain_corr_factor = cb_gain_1st_6k4[gc_1st_index][1] +
588  cb_gain_2nd_6k4[gc_2nd_index][1];
589 
590  /* Without check below overflow can occur in ff_acelp_update_past_gain.
591  It is not issue for G.729, because gain_corr_factor in it's case is always
592  greater than 1024, while in G.729D it can be even zero. */
593  gain_corr_factor = FFMAX(gain_corr_factor, 1024);
594  #ifndef G729_BITEXACT
595  gain_corr_factor >>= 1;
596  #endif
597  } else {
598  ctx->past_gain_pitch[0] = cb_gain_1st_8k[gc_1st_index][0] +
599  cb_gain_2nd_8k[gc_2nd_index][0];
600  gain_corr_factor = cb_gain_1st_8k[gc_1st_index][1] +
601  cb_gain_2nd_8k[gc_2nd_index][1];
602  }
603 
604  /* Decode the fixed-codebook gain. */
605  ctx->past_gain_code[0] = ff_acelp_decode_gain_code(&s->adsp, gain_corr_factor,
606  fc, MR_ENERGY,
607  ctx->quant_energy,
609  SUBFRAME_SIZE, 4);
610  #ifdef G729_BITEXACT
611  /*
612  This correction required to get bit-exact result with
613  reference code, because gain_corr_factor in G.729D is
614  two times larger than in original G.729.
615 
616  If bit-exact result is not issue then gain_corr_factor
617  can be simpler divided by 2 before call to g729_get_gain_code
618  instead of using correction below.
619  */
620  if (packet_type == FORMAT_G729D_6K4) {
621  gain_corr_factor >>= 1;
622  ctx->past_gain_code[0] >>= 1;
623  }
624  #endif
625  }
626  ff_acelp_update_past_gain(ctx->quant_energy, gain_corr_factor, 2, frame_erasure);
627 
628  /* Routine requires rounding to lowest. */
630  ctx->exc + i * SUBFRAME_SIZE - pitch_delay_3x / 3,
632  (pitch_delay_3x % 3) << 1,
633  10, SUBFRAME_SIZE);
634 
636  ctx->exc + i * SUBFRAME_SIZE, fc,
637  (!ctx->was_periodic && frame_erasure) ? 0 : ctx->past_gain_pitch[0],
638  ( ctx->was_periodic && frame_erasure) ? 0 : ctx->past_gain_code[0],
639  1 << 13, 14, SUBFRAME_SIZE);
640 
641  memcpy(synth, ctx->syn_filter_data, 10 * sizeof(int16_t));
642 
644  synth+10,
645  &lp[i][1],
646  ctx->exc + i * SUBFRAME_SIZE,
648  10,
649  1,
650  0,
651  0x800))
652  /* Overflow occurred, downscale excitation signal... */
653  for (j = 0; j < 2 * SUBFRAME_SIZE + PITCH_DELAY_MAX + INTERPOL_LEN; j++)
654  ctx->exc_base[j] >>= 2;
655 
656  /* ... and make synthesis again. */
657  if (packet_type == FORMAT_G729D_6K4) {
658  int16_t exc_new[SUBFRAME_SIZE];
659 
660  ctx->onset = g729d_onset_decision(ctx->onset, ctx->past_gain_code);
661  ctx->voice_decision = g729d_voice_decision(ctx->onset, ctx->voice_decision, ctx->past_gain_pitch);
662 
663  g729d_get_new_exc(exc_new, ctx->exc + i * SUBFRAME_SIZE, fc, ctx->voice_decision, ctx->past_gain_code[0], SUBFRAME_SIZE);
664 
666  synth+10,
667  &lp[i][1],
668  exc_new,
670  10,
671  0,
672  0,
673  0x800);
674  } else {
676  synth+10,
677  &lp[i][1],
678  ctx->exc + i * SUBFRAME_SIZE,
680  10,
681  0,
682  0,
683  0x800);
684  }
685  /* Save data (without postfilter) for use in next subframe. */
686  memcpy(ctx->syn_filter_data, synth+SUBFRAME_SIZE, 10 * sizeof(int16_t));
687 
688  /* Calculate gain of unfiltered signal for use in AGC. */
689  gain_before = 0;
690  for (j = 0; j < SUBFRAME_SIZE; j++)
691  gain_before += FFABS(synth[j+10]);
692 
693  /* Call postfilter and also update voicing decision for use in next frame. */
695  &s->adsp,
696  &ctx->ht_prev_data,
697  &is_periodic,
698  &lp[i][0],
699  pitch_delay_int[0],
700  ctx->residual,
701  ctx->res_filter_data,
702  ctx->pos_filter_data,
703  synth+10,
704  SUBFRAME_SIZE);
705 
706  /* Calculate gain of filtered signal for use in AGC. */
707  gain_after = 0;
708  for (j = 0; j < SUBFRAME_SIZE; j++)
709  gain_after += FFABS(synth[j+10]);
710 
711  ctx->gain_coeff = ff_g729_adaptive_gain_control(
712  gain_before,
713  gain_after,
714  synth+10,
716  ctx->gain_coeff);
717 
718  if (frame_erasure) {
719  ctx->pitch_delay_int_prev = FFMIN(ctx->pitch_delay_int_prev + 1, PITCH_DELAY_MAX);
720  } else {
721  ctx->pitch_delay_int_prev = pitch_delay_int[i];
722  }
723 
724  memcpy(synth+8, ctx->hpf_z, 2*sizeof(int16_t));
726  out_frame + i*SUBFRAME_SIZE,
727  ctx->hpf_f,
728  synth+10,
729  SUBFRAME_SIZE);
730  memcpy(ctx->hpf_z, synth+8+SUBFRAME_SIZE, 2*sizeof(int16_t));
731  }
732 
733  ctx->was_periodic = is_periodic;
734 
735  /* Save signal for use in next frame. */
736  memmove(ctx->exc_base, ctx->exc_base + 2 * SUBFRAME_SIZE, (PITCH_DELAY_MAX+INTERPOL_LEN)*sizeof(int16_t));
737 
738  buf += format->block_size;
739  ctx++;
740  }
741 
742  *got_frame_ptr = 1;
743  return (format->block_size + (avctx->codec_id == AV_CODEC_ID_ACELP_KELVIN)) * channels;
744 }
745 
747 {
748  G729Context *s = avctx->priv_data;
749  av_freep(&s->channel_context);
750 
751  return 0;
752 }
753 
755  .p.name = "g729",
756  CODEC_LONG_NAME("G.729"),
757  .p.type = AVMEDIA_TYPE_AUDIO,
758  .p.id = AV_CODEC_ID_G729,
759  .priv_data_size = sizeof(G729Context),
760  .init = decoder_init,
762  .close = decode_close,
763  .p.capabilities = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1,
764 };
765 
767  .p.name = "acelp.kelvin",
768  CODEC_LONG_NAME("Sipro ACELP.KELVIN"),
769  .p.type = AVMEDIA_TYPE_AUDIO,
770  .p.id = AV_CODEC_ID_ACELP_KELVIN,
771  .priv_data_size = sizeof(G729Context),
772  .init = decoder_init,
774  .close = decode_close,
775  .p.capabilities = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1,
776 };
AVCodecContext::frame_size
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1035
G729_8K_BLOCK_SIZE
#define G729_8K_BLOCK_SIZE
Definition: g729.h:30
G729FormatDescription
Definition: g729dec.c:93
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
cb_gain_2nd_8k
static const int16_t cb_gain_2nd_8k[1<< GC_2ND_IDX_BITS_8K][2]
gain codebook (second stage), 8k mode (3.9.2 of G.729)
Definition: g729data.h:229
av_clip
#define av_clip
Definition: common.h:95
acelp_vectors.h
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
g729_prng
static uint16_t g729_prng(uint16_t value)
pseudo random number generator
Definition: g729dec.c:185
lsp_init
static const int16_t lsp_init[10]
initial LSP coefficients belongs to virtual frame preceding the first frame of the stream
Definition: g729data.h:351
out
FILE * out
Definition: movenc.c:54
LSFQ_MIN
#define LSFQ_MIN
minimum quantized LSF value (3.2.4) 0.005 in Q13
Definition: g729dec.c:46
format_g729d_6k4
static const G729FormatDescription format_g729d_6k4
Definition: g729dec.c:172
ff_acelp_kelvin_decoder
const FFCodec ff_acelp_kelvin_decoder
Definition: g729dec.c:766
ff_acelp_interp_filter
const int16_t ff_acelp_interp_filter[61]
low-pass Finite Impulse Response filter coefficients.
Definition: acelp_filters.c:32
FORMAT_COUNT
@ FORMAT_COUNT
Definition: g729dec.c:90
ff_acelp_fc_pulse_per_track
void ff_acelp_fc_pulse_per_track(int16_t *fc_v, const uint8_t *tab1, const uint8_t *tab2, int pulse_indexes, int pulse_signs, int pulse_count, int bits)
Decode fixed-codebook vector (3.8 and D.5.8 of G.729, 5.7.1 of AMR).
Definition: acelp_vectors.c:117
ff_acelp_interpolate
void ff_acelp_interpolate(int16_t *out, const int16_t *in, const int16_t *filter_coeffs, int precision, int frac_pos, int filter_length, int length)
Generic FIR interpolation routine.
Definition: acelp_filters.c:46
av_mod_uintp2
#define av_mod_uintp2
Definition: common.h:122
G729ChannelContext::was_periodic
int16_t was_periodic
whether previous frame was declared as periodic or not (4.4)
Definition: g729dec.c:143
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:330
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
ff_acelp_high_pass_filter
void ff_acelp_high_pass_filter(int16_t *out, int hpf_f[2], const int16_t *in, int length)
high-pass filtering and upscaling (4.2.5 of G.729).
Definition: acelp_filters.c:101
ff_acelp_decode_4bit_to_2nd_delay3
static int ff_acelp_decode_4bit_to_2nd_delay3(int ac_index, int pitch_delay_min)
Decode pitch delay with 1/3 precision.
Definition: acelp_pitch_delay.h:89
AVPacket::data
uint8_t * data
Definition: packet.h:374
ff_celp_lp_synthesis_filter
int ff_celp_lp_synthesis_filter(int16_t *out, const int16_t *filter_coeffs, const int16_t *in, int buffer_length, int filter_length, int stop_on_overflow, int shift, int rounder)
LP synthesis filter.
Definition: celp_filters.c:61
FFCodec
Definition: codec_internal.h:119
ff_audiodsp_init
av_cold void ff_audiodsp_init(AudioDSPContext *c)
Definition: audiodsp.c:106
G729Context::channel_context
G729ChannelContext * channel_context
Definition: g729dec.c:159
MR_ENERGY
#define MR_ENERGY
MR_ENERGY (mean removed energy) = mean_energy + 10 * log10(2^26 * subframe_size) in (7....
Definition: g729dec.c:81
fc
#define fc(width, name, range_min, range_max)
Definition: cbs_av1.c:551
cb_gain_1st_6k4
static const int16_t cb_gain_1st_6k4[1<< GC_1ST_IDX_BITS_6K4][2]
gain codebook (first stage), 6.4k mode (D.3.9.2 of G.729)
Definition: g729data.h:251
G729Context::adsp
AudioDSPContext adsp
Definition: g729dec.c:157
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
G729FormatDescription::fc_signs_bits
uint8_t fc_signs_bits
number of pulses in fixed-codebook vector
Definition: g729dec.c:98
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:311
MA_NP
#define MA_NP
Moving Average (MA) prediction order.
Definition: g729data.h:27
ff_acelp_decode_8bit_to_1st_delay3
static int ff_acelp_decode_8bit_to_1st_delay3(int ac_index)
Decode pitch delay of the first subframe encoded by 8 bits with 1/3 resolution.
Definition: acelp_pitch_delay.h:44
decode_close
static av_cold int decode_close(AVCodecContext *avctx)
Definition: g729dec.c:746
G729FormatDescription::ac_index_bits
uint8_t ac_index_bits[2]
adaptive codebook index for second subframe (size in bits)
Definition: g729dec.c:94
LSFQ_DIFF_MIN
#define LSFQ_DIFF_MIN
minimum LSF distance (3.2.4) 0.0391 in Q13
Definition: g729dec.c:58
format_g729_8k
static const G729FormatDescription format_g729_8k
Definition: g729dec.c:162
ff_acelp_decode_5_6_bit_to_2nd_delay3
static int ff_acelp_decode_5_6_bit_to_2nd_delay3(int ac_index, int pitch_delay_min)
Decode pitch delay of the second subframe encoded by 5 or 6 bits with 1/3 precision.
Definition: acelp_pitch_delay.h:67
GC_1ST_IDX_BITS_8K
#define GC_1ST_IDX_BITS_8K
gain codebook (first stage) index, 8k mode (size in bits)
Definition: g729data.h:32
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:325
g729postfilter.h
G729ChannelContext
Definition: g729dec.c:103
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:123
PITCH_DELAY_MAX
#define PITCH_DELAY_MAX
Definition: acelp_pitch_delay.h:31
scalarproduct_int16_c
static int32_t scalarproduct_int16_c(const int16_t *v1, const int16_t *v2, int order)
Definition: g729dec.c:336
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:2059
DECISION_VOICE
#define DECISION_VOICE
Definition: g729dec.c:85
GetBitContext
Definition: get_bits.h:107
ff_g729_postfilter
void ff_g729_postfilter(AudioDSPContext *adsp, int16_t *ht_prev_data, int *voicing, const int16_t *lp_filter_coeffs, int pitch_delay_int, int16_t *residual, int16_t *res_filter_data, int16_t *pos_filter_data, int16_t *speech, int subframe_size)
Signal postfiltering (4.2)
Definition: g729postfilter.c:520
G729ChannelContext::voice_decision
int16_t voice_decision
voice decision on previous subframe (0-noise, 1-intermediate, 2-voice), G.729D
Definition: g729dec.c:140
G729Context
Definition: g729dec.c:156
g729d_get_new_exc
static void g729d_get_new_exc(int16_t *out, const int16_t *in, const int16_t *fc_cur, int dstate, int gain_code, int subframe_size)
Constructs new excitation signal and applies phase filter to it.
Definition: g729dec.c:265
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:524
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:298
s
#define s(width, name)
Definition: cbs_vp9.c:256
format
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample format(the sample packing is implied by the sample format) and sample rate. The lists are not just lists
VQ_2ND_BITS
#define VQ_2ND_BITS
second stage vector of quantizer (size in bits)
Definition: g729data.h:30
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
RES_PREV_DATA_SIZE
#define RES_PREV_DATA_SIZE
Amount of past residual signal data stored in buffer.
Definition: g729postfilter.h:77
ff_acelp_reorder_lsf
void ff_acelp_reorder_lsf(int16_t *lsfq, int lsfq_min_distance, int lsfq_min, int lsfq_max, int lp_order)
(I.F) means fixed-point value with F fractional and I integer bits
Definition: lsp.c:37
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:365
av_parity
#define av_parity
Definition: common.h:155
decode_frame
static int decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)
Definition: g729dec.c:403
DECISION_NOISE
#define DECISION_NOISE
Definition: g729dec.c:83
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
channels
channels
Definition: aptx.h:31
decode.h
get_bits.h
ff_fc_2pulses_9bits_track2_gray
const uint8_t ff_fc_2pulses_9bits_track2_gray[32]
Definition: acelp_vectors.c:43
cb_ma_predictor_sum
static const int16_t cb_ma_predictor_sum[2][10]
Definition: g729data.h:321
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:264
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:408
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:64
if
if(ret)
Definition: filter_design.txt:179
g729d_voice_decision
static int16_t g729d_voice_decision(int onset, int prev_voice_decision, const int16_t *past_gain_pitch)
Makes decision about voice presence in current subframe.
Definition: g729dec.c:308
cb_ma_predictor_sum_inv
static const int16_t cb_ma_predictor_sum_inv[2][10]
Definition: g729data.h:335
DECISION_INTERMEDIATE
#define DECISION_INTERMEDIATE
Definition: g729dec.c:84
G729FormatDescription::fc_indexes_bits
uint8_t fc_indexes_bits
size (in bits) of fixed-codebook index entry
Definition: g729dec.c:99
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:378
cb_lsp_1st
static const int16_t cb_lsp_1st[1<< VQ_1ST_BITS][10]
first stage LSP codebook (10-dimensional, with 128 entries (3.24 of G.729)
Definition: g729data.h:42
ff_g729_adaptive_gain_control
int16_t ff_g729_adaptive_gain_control(int gain_before, int gain_after, int16_t *speech, int subframe_size, int16_t gain_prev)
Adaptive gain control (4.2.4)
Definition: g729postfilter.c:581
ff_celp_convolve_circ
void ff_celp_convolve_circ(int16_t *fc_out, const int16_t *fc_in, const int16_t *filter, int len)
Circularly convolve fixed vector with a phase dispersion impulse response filter (D....
Definition: celp_filters.c:31
G729ChannelContext::exc
int16_t * exc
start of past excitation data in buffer
Definition: g729dec.c:107
ff_acelp_update_past_gain
void ff_acelp_update_past_gain(int16_t *quant_energy, int gain_corr_factor, int log2_ma_pred_order, int erasure)
Update past quantized energies.
Definition: acelp_pitch_delay.c:30
ff_fc_4pulses_8bits_tracks_13
const uint8_t ff_fc_4pulses_8bits_tracks_13[16]
Definition: acelp_vectors.c:63
GC_2ND_IDX_BITS_8K
#define GC_2ND_IDX_BITS_8K
gain codebook (second stage) index, 8k mode (size in bits)
Definition: g729data.h:33
celp_filters.h
lsf_decode
static void lsf_decode(int16_t *lsfq, int16_t *past_quantizer_outputs[MA_NP+1], int16_t ma_predictor, int16_t vq_1st, int16_t vq_2nd_low, int16_t vq_2nd_high)
Decodes LSF (Line Spectral Frequencies) from L0-L3 (3.2.4).
Definition: g729dec.c:199
ff_acelp_lp_decode
void ff_acelp_lp_decode(int16_t *lp_1st, int16_t *lp_2nd, const int16_t *lsp_2nd, const int16_t *lsp_prev, int lp_order)
Interpolate LSP for the first subframe and convert LSP -> LP for both subframes (3....
Definition: lsp.c:201
G729FormatDescription::block_size
uint8_t block_size
Definition: g729dec.c:100
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
cb_ma_predictor
static const int16_t cb_ma_predictor[2][MA_NP][10]
4th order Moving Average (MA) Predictor codebook (3.2.4 of G.729)
Definition: g729data.h:300
ma_prediction_coeff
static const uint16_t ma_prediction_coeff[4]
MA prediction coefficients (3.9.1 of G.729, near Equation 69)
Definition: g729data.h:343
AV_CODEC_ID_ACELP_KELVIN
@ AV_CODEC_ID_ACELP_KELVIN
Definition: codec_id.h:526
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1461
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
codec_internal.h
INTERPOL_LEN
#define INTERPOL_LEN
interpolation filter length
Definition: g729dec.c:61
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1023
G729Formats
G729Formats
Definition: g729dec.c:87
decoder_init
static av_cold int decoder_init(AVCodecContext *avctx)
Definition: g729dec.c:349
diff
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
Definition: vf_paletteuse.c:162
AV_SAMPLE_FMT_S16P
@ AV_SAMPLE_FMT_S16P
signed 16 bits, planar
Definition: samplefmt.h:64
G729ChannelContext::ht_prev_data
int16_t ht_prev_data
previous data for 4.2.3, equation 86
Definition: g729dec.c:144
lsf_restore_from_previous
static void lsf_restore_from_previous(int16_t *lsfq, int16_t *past_quantizer_outputs[MA_NP+1], int ma_predictor_prev)
Restores past LSP quantizer output using LSF from previous frame.
Definition: g729dec.c:240
G729ChannelContext::rand_value
uint16_t rand_value
random number generator value (4.4.4)
Definition: g729dec.c:146
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
g729.h
ff_g729_decoder
const FFCodec ff_g729_decoder
Definition: g729dec.c:754
LSFQ_MAX
#define LSFQ_MAX
maximum quantized LSF value (3.2.4) 3.135 in Q13
Definition: g729dec.c:52
value
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 default value
Definition: writing_filters.txt:86
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
VQ_1ST_BITS
#define VQ_1ST_BITS
first stage vector of quantizer (size in bits)
Definition: g729data.h:29
acelp_filters.h
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:264
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:211
avcodec.h
cb_gain_2nd_6k4
static const int16_t cb_gain_2nd_6k4[1<< GC_2ND_IDX_BITS_6K4][2]
gain codebook (second stage), 6.4k mode (D.3.9.2 of G.729)
Definition: g729data.h:266
SHARP_MIN
#define SHARP_MIN
minimum gain pitch value (3.8, Equation 47) 0.2 in (1.14)
Definition: g729dec.c:67
ret
ret
Definition: filter_design.txt:187
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
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
AVCodecContext
main external API structure.
Definition: avcodec.h:398
ff_fc_2pulses_9bits_track1_gray
const uint8_t ff_fc_2pulses_9bits_track1_gray[16]
Definition: acelp_vectors.c:31
AV_CODEC_ID_G729
@ AV_CODEC_ID_G729
Definition: codec_id.h:489
SUBFRAME_SIZE
#define SUBFRAME_SIZE
Definition: evrcdec.c:43
frame_erasure
static void frame_erasure(EVRCContext *e, float *samples)
Definition: evrcdec.c:654
G729FormatDescription::gc_2nd_index_bits
uint8_t gc_2nd_index_bits
gain codebook (second stage) index (size in bits)
Definition: g729dec.c:97
G729FormatDescription::parity_bit
uint8_t parity_bit
parity bit for pitch delay
Definition: g729dec.c:95
FORMAT_G729_8K
@ FORMAT_G729_8K
Definition: g729dec.c:88
ff_acelp_weighted_vector_sum
void ff_acelp_weighted_vector_sum(int16_t *out, const int16_t *in_a, const int16_t *in_b, int16_t weight_coeff_a, int16_t weight_coeff_b, int16_t rounder, int shift, int length)
weighted sum of two vectors with rounding.
Definition: acelp_vectors.c:162
G729ChannelContext::gain_coeff
int gain_coeff
(1.14) gain coefficient (4.2.4)
Definition: g729dec.c:145
g729d_onset_decision
static int g729d_onset_decision(int past_onset, const int16_t *past_gain_code)
Makes decision about onset in current subframe.
Definition: g729dec.c:292
phase_filter
static const int16_t phase_filter[3][40]
additional "phase" post-processing filter impulse response (D.6.2 of G.729)
Definition: g729data.h:361
G729ChannelContext::onset
int16_t onset
detected onset level (0-2)
Definition: g729dec.c:142
avutil.h
audiodsp.h
AV_CODEC_CAP_SUBFRAMES
#define AV_CODEC_CAP_SUBFRAMES
Codec can output multiple frames per AVPacket Normally demuxers return one frame at a time,...
Definition: codec.h:100
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
AudioDSPContext
Definition: audiodsp.h:24
FORMAT_G729D_6K4
@ FORMAT_G729D_6K4
Definition: g729dec.c:89
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:425
G729ChannelContext::ma_predictor_prev
int ma_predictor_prev
switched MA predictor of LSP quantizer from last good frame
Definition: g729dec.c:147
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
ff_acelp_lsf2lsp
void ff_acelp_lsf2lsp(int16_t *lsp, const int16_t *lsf, int lp_order)
Convert LSF to LSP.
Definition: lsp.c:87
int32_t
int32_t
Definition: audioconvert.c:56
ff_acelp_decode_gain_code
int16_t ff_acelp_decode_gain_code(AudioDSPContext *adsp, int gain_corr_factor, const int16_t *fc_v, int mr_energy, const int16_t *quant_energy, const int16_t *ma_prediction_coeff, int subframe_size, int ma_pred_order)
Decode the adaptive codebook gain and add correction (4.1.5 and 3.9.1 of G.729).
Definition: acelp_pitch_delay.c:51
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
ff_fc_4pulses_8bits_track_4
const uint8_t ff_fc_4pulses_8bits_track_4[32]
Definition: acelp_vectors.c:68
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
G729D_6K4_BLOCK_SIZE
#define G729D_6K4_BLOCK_SIZE
Definition: g729.h:31
SHARP_MAX
#define SHARP_MAX
maximum gain pitch value (3.8, Equation 47) (EE) This does not comply with the specification.
Definition: g729dec.c:76
cb_gain_1st_8k
static const int16_t cb_gain_1st_8k[1<< GC_1ST_IDX_BITS_8K][2]
gain codebook (first stage), 8k mode (3.9.2 of G.729)
Definition: g729data.h:215
g729data.h
GC_2ND_IDX_BITS_6K4
#define GC_2ND_IDX_BITS_6K4
gain codebook (second stage) index, 6.4k mode (size in bits)
Definition: g729data.h:36
cb_lsp_2nd
static const int16_t cb_lsp_2nd[1<< VQ_2ND_BITS][10]
second stage LSP codebook, high and low parts (both 5-dimensional, with 32 entries (3....
Definition: g729data.h:177
GC_1ST_IDX_BITS_6K4
#define GC_1ST_IDX_BITS_6K4
gain codebook (first stage) index, 6.4k mode (size in bits)
Definition: g729data.h:35
PITCH_DELAY_MIN
#define PITCH_DELAY_MIN
Definition: acelp_pitch_delay.h:30
G729ChannelContext::pitch_delay_int_prev
int pitch_delay_int_prev
integer part of previous subframe's pitch delay (4.1.3)
Definition: g729dec.c:108
G729FormatDescription::gc_1st_index_bits
uint8_t gc_1st_index_bits
gain codebook (first stage) index (size in bits)
Definition: g729dec.c:96
acelp_pitch_delay.h