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 "internal.h"
31 
32 
33 #include "g729.h"
34 #include "lsp.h"
35 #include "celp_math.h"
36 #include "celp_filters.h"
37 #include "acelp_filters.h"
38 #include "acelp_pitch_delay.h"
39 #include "acelp_vectors.h"
40 #include "g729data.h"
41 #include "g729postfilter.h"
42 
43 /**
44  * minimum quantized LSF value (3.2.4)
45  * 0.005 in Q13
46  */
47 #define LSFQ_MIN 40
48 
49 /**
50  * maximum quantized LSF value (3.2.4)
51  * 3.135 in Q13
52  */
53 #define LSFQ_MAX 25681
54 
55 /**
56  * minimum LSF distance (3.2.4)
57  * 0.0391 in Q13
58  */
59 #define LSFQ_DIFF_MIN 321
60 
61 /// interpolation filter length
62 #define INTERPOL_LEN 11
63 
64 /**
65  * minimum gain pitch value (3.8, Equation 47)
66  * 0.2 in (1.14)
67  */
68 #define SHARP_MIN 3277
69 
70 /**
71  * maximum gain pitch value (3.8, Equation 47)
72  * (EE) This does not comply with the specification.
73  * Specification says about 0.8, which should be
74  * 13107 in (1.14), but reference C code uses
75  * 13017 (equals to 0.7945) instead of it.
76  */
77 #define SHARP_MAX 13017
78 
79 /**
80  * MR_ENERGY (mean removed energy) = mean_energy + 10 * log10(2^26 * subframe_size) in (7.13)
81  */
82 #define MR_ENERGY 1018156
83 
84 #define DECISION_NOISE 0
85 #define DECISION_INTERMEDIATE 1
86 #define DECISION_VOICE 2
87 
88 typedef enum {
92 } G729Formats;
93 
94 typedef struct {
95  uint8_t ac_index_bits[2]; ///< adaptive codebook index for second subframe (size in bits)
96  uint8_t parity_bit; ///< parity bit for pitch delay
97  uint8_t gc_1st_index_bits; ///< gain codebook (first stage) index (size in bits)
98  uint8_t gc_2nd_index_bits; ///< gain codebook (second stage) index (size in bits)
99  uint8_t fc_signs_bits; ///< number of pulses in fixed-codebook vector
100  uint8_t fc_indexes_bits; ///< size (in bits) of fixed-codebook index entry
101  uint8_t block_size;
103 
104 typedef struct {
105  /// past excitation signal buffer
107 
108  int16_t* exc; ///< start of past excitation data in buffer
109  int pitch_delay_int_prev; ///< integer part of previous subframe's pitch delay (4.1.3)
110 
111  /// (2.13) LSP quantizer outputs
112  int16_t past_quantizer_output_buf[MA_NP + 1][10];
113  int16_t* past_quantizer_outputs[MA_NP + 1];
114 
115  int16_t lsfq[10]; ///< (2.13) quantized LSF coefficients from previous frame
116  int16_t lsp_buf[2][10]; ///< (0.15) LSP coefficients (previous and current frames) (3.2.5)
117  int16_t *lsp[2]; ///< pointers to lsp_buf
118 
119  int16_t quant_energy[4]; ///< (5.10) past quantized energy
120 
121  /// previous speech data for LP synthesis filter
122  int16_t syn_filter_data[10];
123 
124 
125  /// residual signal buffer (used in long-term postfilter)
126  int16_t residual[SUBFRAME_SIZE + RES_PREV_DATA_SIZE];
127 
128  /// previous speech data for residual calculation filter
129  int16_t res_filter_data[SUBFRAME_SIZE+10];
130 
131  /// previous speech data for short-term postfilter
132  int16_t pos_filter_data[SUBFRAME_SIZE+10];
133 
134  /// (1.14) pitch gain of current and five previous subframes
135  int16_t past_gain_pitch[6];
136 
137  /// (14.1) gain code from current and previous subframe
138  int16_t past_gain_code[2];
139 
140  /// voice decision on previous subframe (0-noise, 1-intermediate, 2-voice), G.729D
141  int16_t voice_decision;
142 
143  int16_t onset; ///< detected onset level (0-2)
144  int16_t was_periodic; ///< whether previous frame was declared as periodic or not (4.4)
145  int16_t ht_prev_data; ///< previous data for 4.2.3, equation 86
146  int gain_coeff; ///< (1.14) gain coefficient (4.2.4)
147  uint16_t rand_value; ///< random number generator value (4.4.4)
148  int ma_predictor_prev; ///< switched MA predictor of LSP quantizer from last good frame
149 
150  /// (14.14) high-pass filter data (past input)
151  int hpf_f[2];
152 
153  /// high-pass filter data (past output)
154  int16_t hpf_z[2];
156 
157 typedef struct {
159 
161 } G729Context;
162 
164  .ac_index_bits = {8,5},
165  .parity_bit = 1,
166  .gc_1st_index_bits = GC_1ST_IDX_BITS_8K,
167  .gc_2nd_index_bits = GC_2ND_IDX_BITS_8K,
168  .fc_signs_bits = 4,
169  .fc_indexes_bits = 13,
170  .block_size = G729_8K_BLOCK_SIZE,
171 };
172 
174  .ac_index_bits = {8,4},
175  .parity_bit = 0,
176  .gc_1st_index_bits = GC_1ST_IDX_BITS_6K4,
177  .gc_2nd_index_bits = GC_2ND_IDX_BITS_6K4,
178  .fc_signs_bits = 2,
179  .fc_indexes_bits = 9,
180  .block_size = G729D_6K4_BLOCK_SIZE,
181 };
182 
183 /**
184  * @brief pseudo random number generator
185  */
186 static inline uint16_t g729_prng(uint16_t value)
187 {
188  return 31821 * value + 13849;
189 }
190 
191 /**
192  * Decodes LSF (Line Spectral Frequencies) from L0-L3 (3.2.4).
193  * @param[out] lsfq (2.13) quantized LSF coefficients
194  * @param[in,out] past_quantizer_outputs (2.13) quantizer outputs from previous frames
195  * @param ma_predictor switched MA predictor of LSP quantizer
196  * @param vq_1st first stage vector of quantizer
197  * @param vq_2nd_low second stage lower vector of LSP quantizer
198  * @param vq_2nd_high second stage higher vector of LSP quantizer
199  */
200 static void lsf_decode(int16_t* lsfq, int16_t* past_quantizer_outputs[MA_NP + 1],
201  int16_t ma_predictor,
202  int16_t vq_1st, int16_t vq_2nd_low, int16_t vq_2nd_high)
203 {
204  int i,j;
205  static const uint8_t min_distance[2]={10, 5}; //(2.13)
206  int16_t* quantizer_output = past_quantizer_outputs[MA_NP];
207 
208  for (i = 0; i < 5; i++) {
209  quantizer_output[i] = cb_lsp_1st[vq_1st][i ] + cb_lsp_2nd[vq_2nd_low ][i ];
210  quantizer_output[i + 5] = cb_lsp_1st[vq_1st][i + 5] + cb_lsp_2nd[vq_2nd_high][i + 5];
211  }
212 
213  for (j = 0; j < 2; j++) {
214  for (i = 1; i < 10; i++) {
215  int diff = (quantizer_output[i - 1] - quantizer_output[i] + min_distance[j]) >> 1;
216  if (diff > 0) {
217  quantizer_output[i - 1] -= diff;
218  quantizer_output[i ] += diff;
219  }
220  }
221  }
222 
223  for (i = 0; i < 10; i++) {
224  int sum = quantizer_output[i] * cb_ma_predictor_sum[ma_predictor][i];
225  for (j = 0; j < MA_NP; j++)
226  sum += past_quantizer_outputs[j][i] * cb_ma_predictor[ma_predictor][j][i];
227 
228  lsfq[i] = sum >> 15;
229  }
230 
232 }
233 
234 /**
235  * Restores past LSP quantizer output using LSF from previous frame
236  * @param[in,out] lsfq (2.13) quantized LSF coefficients
237  * @param[in,out] past_quantizer_outputs (2.13) quantizer outputs from previous frames
238  * @param ma_predictor_prev MA predictor from previous frame
239  * @param lsfq_prev (2.13) quantized LSF coefficients from previous frame
240  */
241 static void lsf_restore_from_previous(int16_t* lsfq,
242  int16_t* past_quantizer_outputs[MA_NP + 1],
243  int ma_predictor_prev)
244 {
245  int16_t* quantizer_output = past_quantizer_outputs[MA_NP];
246  int i,k;
247 
248  for (i = 0; i < 10; i++) {
249  int tmp = lsfq[i] << 15;
250 
251  for (k = 0; k < MA_NP; k++)
252  tmp -= past_quantizer_outputs[k][i] * cb_ma_predictor[ma_predictor_prev][k][i];
253 
254  quantizer_output[i] = ((tmp >> 15) * cb_ma_predictor_sum_inv[ma_predictor_prev][i]) >> 12;
255  }
256 }
257 
258 /**
259  * Constructs new excitation signal and applies phase filter to it
260  * @param[out] out constructed speech signal
261  * @param in original excitation signal
262  * @param fc_cur (2.13) original fixed-codebook vector
263  * @param gain_code (14.1) gain code
264  * @param subframe_size length of the subframe
265  */
266 static void g729d_get_new_exc(
267  int16_t* out,
268  const int16_t* in,
269  const int16_t* fc_cur,
270  int dstate,
271  int gain_code,
272  int subframe_size)
273 {
274  int i;
275  int16_t fc_new[SUBFRAME_SIZE];
276 
277  ff_celp_convolve_circ(fc_new, fc_cur, phase_filter[dstate], subframe_size);
278 
279  for (i = 0; i < subframe_size; i++) {
280  out[i] = in[i];
281  out[i] -= (gain_code * fc_cur[i] + 0x2000) >> 14;
282  out[i] += (gain_code * fc_new[i] + 0x2000) >> 14;
283  }
284 }
285 
286 /**
287  * Makes decision about onset in current subframe
288  * @param past_onset decision result of previous subframe
289  * @param past_gain_code gain code of current and previous subframe
290  *
291  * @return onset decision result for current subframe
292  */
293 static int g729d_onset_decision(int past_onset, const int16_t* past_gain_code)
294 {
295  if ((past_gain_code[0] >> 1) > past_gain_code[1])
296  return 2;
297 
298  return FFMAX(past_onset-1, 0);
299 }
300 
301 /**
302  * Makes decision about voice presence in current subframe
303  * @param onset onset level
304  * @param prev_voice_decision voice decision result from previous subframe
305  * @param past_gain_pitch pitch gain of current and previous subframes
306  *
307  * @return voice decision result for current subframe
308  */
309 static int16_t g729d_voice_decision(int onset, int prev_voice_decision, const int16_t* past_gain_pitch)
310 {
311  int i, low_gain_pitch_cnt, voice_decision;
312 
313  if (past_gain_pitch[0] >= 14745) { // 0.9
314  voice_decision = DECISION_VOICE;
315  } else if (past_gain_pitch[0] <= 9830) { // 0.6
316  voice_decision = DECISION_NOISE;
317  } else {
318  voice_decision = DECISION_INTERMEDIATE;
319  }
320 
321  for (i = 0, low_gain_pitch_cnt = 0; i < 6; i++)
322  if (past_gain_pitch[i] < 9830)
323  low_gain_pitch_cnt++;
324 
325  if (low_gain_pitch_cnt > 2 && !onset)
326  voice_decision = DECISION_NOISE;
327 
328  if (!onset && voice_decision > prev_voice_decision + 1)
329  voice_decision--;
330 
331  if (onset && voice_decision < DECISION_VOICE)
332  voice_decision++;
333 
334  return voice_decision;
335 }
336 
337 static int32_t scalarproduct_int16_c(const int16_t * v1, const int16_t * v2, int order)
338 {
339  int64_t res = 0;
340 
341  while (order--)
342  res += *v1++ * *v2++;
343 
344  if (res > INT32_MAX) return INT32_MAX;
345  else if (res < INT32_MIN) return INT32_MIN;
346 
347  return res;
348 }
349 
351 {
352  G729Context *s = avctx->priv_data;
354  int channels = avctx->ch_layout.nb_channels;
355  int c,i,k;
356 
358  av_log(avctx, AV_LOG_ERROR, "Only mono and stereo are supported (requested channels: %d).\n", channels);
359  return AVERROR(EINVAL);
360  }
362 
363  /* Both 8kbit/s and 6.4kbit/s modes uses two subframes per frame. */
364  avctx->frame_size = SUBFRAME_SIZE << 1;
365 
366  ctx =
367  s->channel_context = av_mallocz(sizeof(G729ChannelContext) * channels);
368  if (!ctx)
369  return AVERROR(ENOMEM);
370 
371  for (c = 0; c < channels; c++) {
372  ctx->gain_coeff = 16384; // 1.0 in (1.14)
373 
374  for (k = 0; k < MA_NP + 1; k++) {
375  ctx->past_quantizer_outputs[k] = ctx->past_quantizer_output_buf[k];
376  for (i = 1; i < 11; i++)
377  ctx->past_quantizer_outputs[k][i - 1] = (18717 * i) >> 3;
378  }
379 
380  ctx->lsp[0] = ctx->lsp_buf[0];
381  ctx->lsp[1] = ctx->lsp_buf[1];
382  memcpy(ctx->lsp[0], lsp_init, 10 * sizeof(int16_t));
383 
384  ctx->exc = &ctx->exc_base[PITCH_DELAY_MAX+INTERPOL_LEN];
385 
386  ctx->pitch_delay_int_prev = PITCH_DELAY_MIN;
387 
388  /* random seed initialization */
389  ctx->rand_value = 21845;
390 
391  /* quantized prediction error */
392  for (i = 0; i < 4; i++)
393  ctx->quant_energy[i] = -14336; // -14 in (5.10)
394 
395  ctx++;
396  }
397 
398  ff_audiodsp_init(&s->adsp);
399  s->adsp.scalarproduct_int16 = scalarproduct_int16_c;
400 
401  return 0;
402 }
403 
405  int *got_frame_ptr, AVPacket *avpkt)
406 {
407  const uint8_t *buf = avpkt->data;
408  int buf_size = avpkt->size;
409  int16_t *out_frame;
410  GetBitContext gb;
412  int c, i;
413  int16_t *tmp;
414  G729Formats packet_type;
415  G729Context *s = avctx->priv_data;
416  G729ChannelContext *ctx = s->channel_context;
417  int channels = avctx->ch_layout.nb_channels;
418  int16_t lp[2][11]; // (3.12)
419  uint8_t ma_predictor; ///< switched MA predictor of LSP quantizer
420  uint8_t quantizer_1st; ///< first stage vector of quantizer
421  uint8_t quantizer_2nd_lo; ///< second stage lower vector of quantizer (size in bits)
422  uint8_t quantizer_2nd_hi; ///< second stage higher vector of quantizer (size in bits)
423 
424  int pitch_delay_int[2]; // pitch delay, integer part
425  int pitch_delay_3x; // pitch delay, multiplied by 3
426  int16_t fc[SUBFRAME_SIZE]; // fixed-codebook vector
427  int16_t synth[SUBFRAME_SIZE+10]; // fixed-codebook vector
428  int j, ret;
429  int gain_before, gain_after;
430 
431  frame->nb_samples = SUBFRAME_SIZE<<1;
432  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
433  return ret;
434 
435  if (buf_size && buf_size % ((G729_8K_BLOCK_SIZE + (avctx->codec_id == AV_CODEC_ID_ACELP_KELVIN)) * channels) == 0) {
436  packet_type = FORMAT_G729_8K;
438  //Reset voice decision
439  ctx->onset = 0;
440  ctx->voice_decision = DECISION_VOICE;
441  av_log(avctx, AV_LOG_DEBUG, "Packet type: %s\n", "G.729 @ 8kbit/s");
442  } else if (buf_size == G729D_6K4_BLOCK_SIZE * channels && avctx->codec_id != AV_CODEC_ID_ACELP_KELVIN) {
443  packet_type = FORMAT_G729D_6K4;
445  av_log(avctx, AV_LOG_DEBUG, "Packet type: %s\n", "G.729D @ 6.4kbit/s");
446  } else {
447  av_log(avctx, AV_LOG_ERROR, "Packet size %d is unknown.\n", buf_size);
448  return AVERROR_INVALIDDATA;
449  }
450 
451  for (c = 0; c < channels; c++) {
452  int frame_erasure = 0; ///< frame erasure detected during decoding
453  int bad_pitch = 0; ///< parity check failed
454  int is_periodic = 0; ///< whether one of the subframes is declared as periodic or not
455  out_frame = (int16_t*)frame->data[c];
456  if (avctx->codec_id == AV_CODEC_ID_ACELP_KELVIN) {
457  if (*buf != ((avctx->ch_layout.nb_channels - 1 - c) * 0x80 | 2))
458  avpriv_request_sample(avctx, "First byte value %x for channel %d", *buf, c);
459  buf++;
460  }
461 
462  for (i = 0; i < format->block_size; i++)
463  frame_erasure |= buf[i];
465 
466  init_get_bits8(&gb, buf, format->block_size);
467 
468  ma_predictor = get_bits(&gb, 1);
469  quantizer_1st = get_bits(&gb, VQ_1ST_BITS);
470  quantizer_2nd_lo = get_bits(&gb, VQ_2ND_BITS);
471  quantizer_2nd_hi = get_bits(&gb, VQ_2ND_BITS);
472 
473  if (frame_erasure) {
474  lsf_restore_from_previous(ctx->lsfq, ctx->past_quantizer_outputs,
475  ctx->ma_predictor_prev);
476  } else {
477  lsf_decode(ctx->lsfq, ctx->past_quantizer_outputs,
478  ma_predictor,
479  quantizer_1st, quantizer_2nd_lo, quantizer_2nd_hi);
480  ctx->ma_predictor_prev = ma_predictor;
481  }
482 
483  tmp = ctx->past_quantizer_outputs[MA_NP];
484  memmove(ctx->past_quantizer_outputs + 1, ctx->past_quantizer_outputs,
485  MA_NP * sizeof(int16_t*));
486  ctx->past_quantizer_outputs[0] = tmp;
487 
488  ff_acelp_lsf2lsp(ctx->lsp[1], ctx->lsfq, 10);
489 
490  ff_acelp_lp_decode(&lp[0][0], &lp[1][0], ctx->lsp[1], ctx->lsp[0], 10);
491 
492  FFSWAP(int16_t*, ctx->lsp[1], ctx->lsp[0]);
493 
494  for (i = 0; i < 2; i++) {
495  int gain_corr_factor;
496 
497  uint8_t ac_index; ///< adaptive codebook index
498  uint8_t pulses_signs; ///< fixed-codebook vector pulse signs
499  int fc_indexes; ///< fixed-codebook indexes
500  uint8_t gc_1st_index; ///< gain codebook (first stage) index
501  uint8_t gc_2nd_index; ///< gain codebook (second stage) index
502 
503  ac_index = get_bits(&gb, format->ac_index_bits[i]);
504  if (!i && format->parity_bit)
505  bad_pitch = av_parity(ac_index >> 2) == get_bits1(&gb);
506  fc_indexes = get_bits(&gb, format->fc_indexes_bits);
507  pulses_signs = get_bits(&gb, format->fc_signs_bits);
508  gc_1st_index = get_bits(&gb, format->gc_1st_index_bits);
509  gc_2nd_index = get_bits(&gb, format->gc_2nd_index_bits);
510 
511  if (frame_erasure) {
512  pitch_delay_3x = 3 * ctx->pitch_delay_int_prev;
513  } else if (!i) {
514  if (bad_pitch) {
515  pitch_delay_3x = 3 * ctx->pitch_delay_int_prev;
516  } else {
517  pitch_delay_3x = ff_acelp_decode_8bit_to_1st_delay3(ac_index);
518  }
519  } else {
520  int pitch_delay_min = av_clip(ctx->pitch_delay_int_prev - 5,
522 
523  if (packet_type == FORMAT_G729D_6K4) {
524  pitch_delay_3x = ff_acelp_decode_4bit_to_2nd_delay3(ac_index, pitch_delay_min);
525  } else {
526  pitch_delay_3x = ff_acelp_decode_5_6_bit_to_2nd_delay3(ac_index, pitch_delay_min);
527  }
528  }
529 
530  /* Round pitch delay to nearest (used everywhere except ff_acelp_interpolate). */
531  pitch_delay_int[i] = (pitch_delay_3x + 1) / 3;
532  if (pitch_delay_int[i] > PITCH_DELAY_MAX) {
533  av_log(avctx, AV_LOG_WARNING, "pitch_delay_int %d is too large\n", pitch_delay_int[i]);
534  pitch_delay_int[i] = PITCH_DELAY_MAX;
535  }
536 
537  if (frame_erasure) {
538  ctx->rand_value = g729_prng(ctx->rand_value);
539  fc_indexes = av_mod_uintp2(ctx->rand_value, format->fc_indexes_bits);
540 
541  ctx->rand_value = g729_prng(ctx->rand_value);
542  pulses_signs = ctx->rand_value;
543  }
544 
545 
546  memset(fc, 0, sizeof(int16_t) * SUBFRAME_SIZE);
547  switch (packet_type) {
548  case FORMAT_G729_8K:
551  fc_indexes, pulses_signs, 3, 3);
552  break;
553  case FORMAT_G729D_6K4:
556  fc_indexes, pulses_signs, 1, 4);
557  break;
558  }
559 
560  /*
561  This filter enhances harmonic components of the fixed-codebook vector to
562  improve the quality of the reconstructed speech.
563 
564  / fc_v[i], i < pitch_delay
565  fc_v[i] = <
566  \ fc_v[i] + gain_pitch * fc_v[i-pitch_delay], i >= pitch_delay
567  */
568  if (SUBFRAME_SIZE > pitch_delay_int[i])
569  ff_acelp_weighted_vector_sum(fc + pitch_delay_int[i],
570  fc + pitch_delay_int[i],
571  fc, 1 << 14,
572  av_clip(ctx->past_gain_pitch[0], SHARP_MIN, SHARP_MAX),
573  0, 14,
574  SUBFRAME_SIZE - pitch_delay_int[i]);
575 
576  memmove(ctx->past_gain_pitch+1, ctx->past_gain_pitch, 5 * sizeof(int16_t));
577  ctx->past_gain_code[1] = ctx->past_gain_code[0];
578 
579  if (frame_erasure) {
580  ctx->past_gain_pitch[0] = (29491 * ctx->past_gain_pitch[0]) >> 15; // 0.90 (0.15)
581  ctx->past_gain_code[0] = ( 2007 * ctx->past_gain_code[0] ) >> 11; // 0.98 (0.11)
582 
583  gain_corr_factor = 0;
584  } else {
585  if (packet_type == FORMAT_G729D_6K4) {
586  ctx->past_gain_pitch[0] = cb_gain_1st_6k4[gc_1st_index][0] +
587  cb_gain_2nd_6k4[gc_2nd_index][0];
588  gain_corr_factor = cb_gain_1st_6k4[gc_1st_index][1] +
589  cb_gain_2nd_6k4[gc_2nd_index][1];
590 
591  /* Without check below overflow can occur in ff_acelp_update_past_gain.
592  It is not issue for G.729, because gain_corr_factor in it's case is always
593  greater than 1024, while in G.729D it can be even zero. */
594  gain_corr_factor = FFMAX(gain_corr_factor, 1024);
595  #ifndef G729_BITEXACT
596  gain_corr_factor >>= 1;
597  #endif
598  } else {
599  ctx->past_gain_pitch[0] = cb_gain_1st_8k[gc_1st_index][0] +
600  cb_gain_2nd_8k[gc_2nd_index][0];
601  gain_corr_factor = cb_gain_1st_8k[gc_1st_index][1] +
602  cb_gain_2nd_8k[gc_2nd_index][1];
603  }
604 
605  /* Decode the fixed-codebook gain. */
606  ctx->past_gain_code[0] = ff_acelp_decode_gain_code(&s->adsp, gain_corr_factor,
607  fc, MR_ENERGY,
608  ctx->quant_energy,
610  SUBFRAME_SIZE, 4);
611  #ifdef G729_BITEXACT
612  /*
613  This correction required to get bit-exact result with
614  reference code, because gain_corr_factor in G.729D is
615  two times larger than in original G.729.
616 
617  If bit-exact result is not issue then gain_corr_factor
618  can be simpler divided by 2 before call to g729_get_gain_code
619  instead of using correction below.
620  */
621  if (packet_type == FORMAT_G729D_6K4) {
622  gain_corr_factor >>= 1;
623  ctx->past_gain_code[0] >>= 1;
624  }
625  #endif
626  }
627  ff_acelp_update_past_gain(ctx->quant_energy, gain_corr_factor, 2, frame_erasure);
628 
629  /* Routine requires rounding to lowest. */
631  ctx->exc + i * SUBFRAME_SIZE - pitch_delay_3x / 3,
633  (pitch_delay_3x % 3) << 1,
634  10, SUBFRAME_SIZE);
635 
637  ctx->exc + i * SUBFRAME_SIZE, fc,
638  (!ctx->was_periodic && frame_erasure) ? 0 : ctx->past_gain_pitch[0],
639  ( ctx->was_periodic && frame_erasure) ? 0 : ctx->past_gain_code[0],
640  1 << 13, 14, SUBFRAME_SIZE);
641 
642  memcpy(synth, ctx->syn_filter_data, 10 * sizeof(int16_t));
643 
645  synth+10,
646  &lp[i][1],
647  ctx->exc + i * SUBFRAME_SIZE,
649  10,
650  1,
651  0,
652  0x800))
653  /* Overflow occurred, downscale excitation signal... */
654  for (j = 0; j < 2 * SUBFRAME_SIZE + PITCH_DELAY_MAX + INTERPOL_LEN; j++)
655  ctx->exc_base[j] >>= 2;
656 
657  /* ... and make synthesis again. */
658  if (packet_type == FORMAT_G729D_6K4) {
659  int16_t exc_new[SUBFRAME_SIZE];
660 
661  ctx->onset = g729d_onset_decision(ctx->onset, ctx->past_gain_code);
662  ctx->voice_decision = g729d_voice_decision(ctx->onset, ctx->voice_decision, ctx->past_gain_pitch);
663 
664  g729d_get_new_exc(exc_new, ctx->exc + i * SUBFRAME_SIZE, fc, ctx->voice_decision, ctx->past_gain_code[0], SUBFRAME_SIZE);
665 
667  synth+10,
668  &lp[i][1],
669  exc_new,
671  10,
672  0,
673  0,
674  0x800);
675  } else {
677  synth+10,
678  &lp[i][1],
679  ctx->exc + i * SUBFRAME_SIZE,
681  10,
682  0,
683  0,
684  0x800);
685  }
686  /* Save data (without postfilter) for use in next subframe. */
687  memcpy(ctx->syn_filter_data, synth+SUBFRAME_SIZE, 10 * sizeof(int16_t));
688 
689  /* Calculate gain of unfiltered signal for use in AGC. */
690  gain_before = 0;
691  for (j = 0; j < SUBFRAME_SIZE; j++)
692  gain_before += FFABS(synth[j+10]);
693 
694  /* Call postfilter and also update voicing decision for use in next frame. */
696  &s->adsp,
697  &ctx->ht_prev_data,
698  &is_periodic,
699  &lp[i][0],
700  pitch_delay_int[0],
701  ctx->residual,
702  ctx->res_filter_data,
703  ctx->pos_filter_data,
704  synth+10,
705  SUBFRAME_SIZE);
706 
707  /* Calculate gain of filtered signal for use in AGC. */
708  gain_after = 0;
709  for (j = 0; j < SUBFRAME_SIZE; j++)
710  gain_after += FFABS(synth[j+10]);
711 
712  ctx->gain_coeff = ff_g729_adaptive_gain_control(
713  gain_before,
714  gain_after,
715  synth+10,
717  ctx->gain_coeff);
718 
719  if (frame_erasure) {
720  ctx->pitch_delay_int_prev = FFMIN(ctx->pitch_delay_int_prev + 1, PITCH_DELAY_MAX);
721  } else {
722  ctx->pitch_delay_int_prev = pitch_delay_int[i];
723  }
724 
725  memcpy(synth+8, ctx->hpf_z, 2*sizeof(int16_t));
727  out_frame + i*SUBFRAME_SIZE,
728  ctx->hpf_f,
729  synth+10,
730  SUBFRAME_SIZE);
731  memcpy(ctx->hpf_z, synth+8+SUBFRAME_SIZE, 2*sizeof(int16_t));
732  }
733 
734  ctx->was_periodic = is_periodic;
735 
736  /* Save signal for use in next frame. */
737  memmove(ctx->exc_base, ctx->exc_base + 2 * SUBFRAME_SIZE, (PITCH_DELAY_MAX+INTERPOL_LEN)*sizeof(int16_t));
738 
739  buf += format->block_size;
740  ctx++;
741  }
742 
743  *got_frame_ptr = 1;
744  return (format->block_size + (avctx->codec_id == AV_CODEC_ID_ACELP_KELVIN)) * channels;
745 }
746 
748 {
749  G729Context *s = avctx->priv_data;
750  av_freep(&s->channel_context);
751 
752  return 0;
753 }
754 
756  .p.name = "g729",
757  .p.long_name = NULL_IF_CONFIG_SMALL("G.729"),
758  .p.type = AVMEDIA_TYPE_AUDIO,
759  .p.id = AV_CODEC_ID_G729,
760  .priv_data_size = sizeof(G729Context),
761  .init = decoder_init,
763  .close = decode_close,
764  .p.capabilities = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1,
765 };
766 
768  .p.name = "acelp.kelvin",
769  .p.long_name = NULL_IF_CONFIG_SMALL("Sipro ACELP.KELVIN"),
770  .p.type = AVMEDIA_TYPE_AUDIO,
771  .p.id = AV_CODEC_ID_ACELP_KELVIN,
772  .priv_data_size = sizeof(G729Context),
773  .init = decoder_init,
775  .close = decode_close,
776  .p.capabilities = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1,
777 };
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:94
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:186
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:47
format_g729d_6k4
static const G729FormatDescription format_g729d_6k4
Definition: g729dec.c:173
ff_acelp_kelvin_decoder
const FFCodec ff_acelp_kelvin_decoder
Definition: g729dec.c:767
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:91
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:144
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
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
internal.h
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:118
ff_audiodsp_init
av_cold void ff_audiodsp_init(AudioDSPContext *c)
Definition: audiodsp.c:106
G729Context::channel_context
G729ChannelContext * channel_context
Definition: g729dec.c:160
MR_ENERGY
#define MR_ENERGY
MR_ENERGY (mean removed energy) = mean_energy + 10 * log10(2^26 * subframe_size) in (7....
Definition: g729dec.c:82
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:158
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:99
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:300
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:747
G729FormatDescription::ac_index_bits
uint8_t ac_index_bits[2]
adaptive codebook index for second subframe (size in bits)
Definition: g729dec.c:95
LSFQ_DIFF_MIN
#define LSFQ_DIFF_MIN
minimum LSF distance (3.2.4) 0.0391 in Q13
Definition: g729dec.c:59
format_g729_8k
static const G729FormatDescription format_g729_8k
Definition: g729dec.c:163
init
static int init
Definition: av_tx.c:47
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:379
g729postfilter.h
G729ChannelContext
Definition: g729dec.c:104
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:122
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:337
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:2065
DECISION_VOICE
#define DECISION_VOICE
Definition: g729dec.c:86
GetBitContext
Definition: get_bits.h:61
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:141
G729Context
Definition: g729dec.c:157
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:266
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
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:260
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:33
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:404
DECISION_NOISE
#define DECISION_NOISE
Definition: g729dec.c:84
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:32
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
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:309
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:85
G729FormatDescription::fc_indexes_bits
uint8_t fc_indexes_bits
size (in bits) of fixed-codebook index entry
Definition: g729dec.c:100
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
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:108
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:200
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:171
G729FormatDescription::block_size
uint8_t block_size
Definition: g729dec.c:101
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:519
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1462
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
codec_internal.h
INTERPOL_LEN
#define INTERPOL_LEN
interpolation filter length
Definition: g729dec.c:62
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1023
celp_math.h
G729Formats
G729Formats
Definition: g729dec.c:88
decoder_init
static av_cold int decoder_init(AVCodecContext *avctx)
Definition: g729dec.c:350
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:145
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:241
G729ChannelContext::rand_value
uint16_t rand_value
random number generator value (4.4.4)
Definition: g729dec.c:147
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:755
LSFQ_MAX
#define LSFQ_MAX
maximum quantized LSF value (3.2.4) 3.135 in Q13
Definition: g729dec.c:53
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:68
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:482
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:98
G729FormatDescription::parity_bit
uint8_t parity_bit
parity bit for pitch delay
Definition: g729dec.c:96
FORMAT_G729_8K
@ FORMAT_G729_8K
Definition: g729dec.c:89
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:146
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:293
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:143
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
diff
static av_always_inline int diff(const uint32_t a, const uint32_t b)
Definition: vf_palettegen.c:139
FORMAT_G729D_6K4
@ FORMAT_G729D_6K4
Definition: g729dec.c:90
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:148
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:83
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:77
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:109
G729FormatDescription::gc_1st_index_bits
uint8_t gc_1st_index_bits
gain codebook (first stage) index (size in bits)
Definition: g729dec.c:97
acelp_pitch_delay.h