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 "internal.h"
30 
31 
32 #include "g729.h"
33 #include "lsp.h"
34 #include "celp_math.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
101 
102 typedef struct {
103  /// past excitation signal buffer
105 
106  int16_t* exc; ///< start of past excitation data in buffer
107  int pitch_delay_int_prev; ///< integer part of previous subframe's pitch delay (4.1.3)
108 
109  /// (2.13) LSP quantizer outputs
110  int16_t past_quantizer_output_buf[MA_NP + 1][10];
111  int16_t* past_quantizer_outputs[MA_NP + 1];
112 
113  int16_t lsfq[10]; ///< (2.13) quantized LSF coefficients from previous frame
114  int16_t lsp_buf[2][10]; ///< (0.15) LSP coefficients (previous and current frames) (3.2.5)
115  int16_t *lsp[2]; ///< pointers to lsp_buf
116 
117  int16_t quant_energy[4]; ///< (5.10) past quantized energy
118 
119  /// previous speech data for LP synthesis filter
120  int16_t syn_filter_data[10];
121 
122 
123  /// residual signal buffer (used in long-term postfilter)
125 
126  /// previous speech data for residual calculation filter
127  int16_t res_filter_data[SUBFRAME_SIZE+10];
128 
129  /// previous speech data for short-term postfilter
130  int16_t pos_filter_data[SUBFRAME_SIZE+10];
131 
132  /// (1.14) pitch gain of current and five previous subframes
133  int16_t past_gain_pitch[6];
134 
135  /// (14.1) gain code from current and previous subframe
136  int16_t past_gain_code[2];
137 
138  /// voice decision on previous subframe (0-noise, 1-intermediate, 2-voice), G.729D
139  int16_t voice_decision;
140 
141  int16_t onset; ///< detected onset level (0-2)
142  int16_t was_periodic; ///< whether previous frame was declared as periodic or not (4.4)
143  int16_t ht_prev_data; ///< previous data for 4.2.3, equation 86
144  int gain_coeff; ///< (1.14) gain coefficient (4.2.4)
145  uint16_t rand_value; ///< random number generator value (4.4.4)
146  int ma_predictor_prev; ///< switched MA predictor of LSP quantizer from last good frame
147 
148  /// (14.14) high-pass filter data (past input)
149  int hpf_f[2];
150 
151  /// high-pass filter data (past output)
152  int16_t hpf_z[2];
154 
155 typedef struct {
157 
159 } G729Context;
160 
162  .ac_index_bits = {8,5},
163  .parity_bit = 1,
164  .gc_1st_index_bits = GC_1ST_IDX_BITS_8K,
165  .gc_2nd_index_bits = GC_2ND_IDX_BITS_8K,
166  .fc_signs_bits = 4,
167  .fc_indexes_bits = 13,
168 };
169 
171  .ac_index_bits = {8,4},
172  .parity_bit = 0,
173  .gc_1st_index_bits = GC_1ST_IDX_BITS_6K4,
174  .gc_2nd_index_bits = GC_2ND_IDX_BITS_6K4,
175  .fc_signs_bits = 2,
176  .fc_indexes_bits = 9,
177 };
178 
179 /**
180  * @brief pseudo random number generator
181  */
182 static inline uint16_t g729_prng(uint16_t value)
183 {
184  return 31821 * value + 13849;
185 }
186 
187 /**
188  * Decodes LSF (Line Spectral Frequencies) from L0-L3 (3.2.4).
189  * @param[out] lsfq (2.13) quantized LSF coefficients
190  * @param[in,out] past_quantizer_outputs (2.13) quantizer outputs from previous frames
191  * @param ma_predictor switched MA predictor of LSP quantizer
192  * @param vq_1st first stage vector of quantizer
193  * @param vq_2nd_low second stage lower vector of LSP quantizer
194  * @param vq_2nd_high second stage higher vector of LSP quantizer
195  */
196 static void lsf_decode(int16_t* lsfq, int16_t* past_quantizer_outputs[MA_NP + 1],
197  int16_t ma_predictor,
198  int16_t vq_1st, int16_t vq_2nd_low, int16_t vq_2nd_high)
199 {
200  int i,j;
201  static const uint8_t min_distance[2]={10, 5}; //(2.13)
202  int16_t* quantizer_output = past_quantizer_outputs[MA_NP];
203 
204  for (i = 0; i < 5; i++) {
205  quantizer_output[i] = cb_lsp_1st[vq_1st][i ] + cb_lsp_2nd[vq_2nd_low ][i ];
206  quantizer_output[i + 5] = cb_lsp_1st[vq_1st][i + 5] + cb_lsp_2nd[vq_2nd_high][i + 5];
207  }
208 
209  for (j = 0; j < 2; j++) {
210  for (i = 1; i < 10; i++) {
211  int diff = (quantizer_output[i - 1] - quantizer_output[i] + min_distance[j]) >> 1;
212  if (diff > 0) {
213  quantizer_output[i - 1] -= diff;
214  quantizer_output[i ] += diff;
215  }
216  }
217  }
218 
219  for (i = 0; i < 10; i++) {
220  int sum = quantizer_output[i] * cb_ma_predictor_sum[ma_predictor][i];
221  for (j = 0; j < MA_NP; j++)
222  sum += past_quantizer_outputs[j][i] * cb_ma_predictor[ma_predictor][j][i];
223 
224  lsfq[i] = sum >> 15;
225  }
226 
228 }
229 
230 /**
231  * Restores past LSP quantizer output using LSF from previous frame
232  * @param[in,out] lsfq (2.13) quantized LSF coefficients
233  * @param[in,out] past_quantizer_outputs (2.13) quantizer outputs from previous frames
234  * @param ma_predictor_prev MA predictor from previous frame
235  * @param lsfq_prev (2.13) quantized LSF coefficients from previous frame
236  */
237 static void lsf_restore_from_previous(int16_t* lsfq,
238  int16_t* past_quantizer_outputs[MA_NP + 1],
239  int ma_predictor_prev)
240 {
241  int16_t* quantizer_output = past_quantizer_outputs[MA_NP];
242  int i,k;
243 
244  for (i = 0; i < 10; i++) {
245  int tmp = lsfq[i] << 15;
246 
247  for (k = 0; k < MA_NP; k++)
248  tmp -= past_quantizer_outputs[k][i] * cb_ma_predictor[ma_predictor_prev][k][i];
249 
250  quantizer_output[i] = ((tmp >> 15) * cb_ma_predictor_sum_inv[ma_predictor_prev][i]) >> 12;
251  }
252 }
253 
254 /**
255  * Constructs new excitation signal and applies phase filter to it
256  * @param[out] out constructed speech signal
257  * @param in original excitation signal
258  * @param fc_cur (2.13) original fixed-codebook vector
259  * @param gain_code (14.1) gain code
260  * @param subframe_size length of the subframe
261  */
262 static void g729d_get_new_exc(
263  int16_t* out,
264  const int16_t* in,
265  const int16_t* fc_cur,
266  int dstate,
267  int gain_code,
268  int subframe_size)
269 {
270  int i;
271  int16_t fc_new[SUBFRAME_SIZE];
272 
273  ff_celp_convolve_circ(fc_new, fc_cur, phase_filter[dstate], subframe_size);
274 
275  for (i = 0; i < subframe_size; i++) {
276  out[i] = in[i];
277  out[i] -= (gain_code * fc_cur[i] + 0x2000) >> 14;
278  out[i] += (gain_code * fc_new[i] + 0x2000) >> 14;
279  }
280 }
281 
282 /**
283  * Makes decision about onset in current subframe
284  * @param past_onset decision result of previous subframe
285  * @param past_gain_code gain code of current and previous subframe
286  *
287  * @return onset decision result for current subframe
288  */
289 static int g729d_onset_decision(int past_onset, const int16_t* past_gain_code)
290 {
291  if ((past_gain_code[0] >> 1) > past_gain_code[1])
292  return 2;
293 
294  return FFMAX(past_onset-1, 0);
295 }
296 
297 /**
298  * Makes decision about voice presence in current subframe
299  * @param onset onset level
300  * @param prev_voice_decision voice decision result from previous subframe
301  * @param past_gain_pitch pitch gain of current and previous subframes
302  *
303  * @return voice decision result for current subframe
304  */
305 static int16_t g729d_voice_decision(int onset, int prev_voice_decision, const int16_t* past_gain_pitch)
306 {
307  int i, low_gain_pitch_cnt, voice_decision;
308 
309  if (past_gain_pitch[0] >= 14745) { // 0.9
310  voice_decision = DECISION_VOICE;
311  } else if (past_gain_pitch[0] <= 9830) { // 0.6
312  voice_decision = DECISION_NOISE;
313  } else {
314  voice_decision = DECISION_INTERMEDIATE;
315  }
316 
317  for (i = 0, low_gain_pitch_cnt = 0; i < 6; i++)
318  if (past_gain_pitch[i] < 9830)
319  low_gain_pitch_cnt++;
320 
321  if (low_gain_pitch_cnt > 2 && !onset)
322  voice_decision = DECISION_NOISE;
323 
324  if (!onset && voice_decision > prev_voice_decision + 1)
325  voice_decision--;
326 
327  if (onset && voice_decision < DECISION_VOICE)
328  voice_decision++;
329 
330  return voice_decision;
331 }
332 
333 static int32_t scalarproduct_int16_c(const int16_t * v1, const int16_t * v2, int order)
334 {
335  int res = 0;
336 
337  while (order--)
338  res += *v1++ * *v2++;
339 
340  return res;
341 }
342 
344 {
345  G729Context *s = avctx->priv_data;
347  int c,i,k;
348 
349  if (avctx->channels < 1 || avctx->channels > 2) {
350  av_log(avctx, AV_LOG_ERROR, "Only mono and stereo are supported (requested channels: %d).\n", avctx->channels);
351  return AVERROR(EINVAL);
352  }
354 
355  /* Both 8kbit/s and 6.4kbit/s modes uses two subframes per frame. */
356  avctx->frame_size = SUBFRAME_SIZE << 1;
357 
358  ctx =
359  s->channel_context = av_mallocz(sizeof(G729ChannelContext) * avctx->channels);
360  if (!ctx)
361  return AVERROR(ENOMEM);
362 
363  for (c = 0; c < avctx->channels; c++) {
364  ctx->gain_coeff = 16384; // 1.0 in (1.14)
365 
366  for (k = 0; k < MA_NP + 1; k++) {
368  for (i = 1; i < 11; i++)
369  ctx->past_quantizer_outputs[k][i - 1] = (18717 * i) >> 3;
370  }
371 
372  ctx->lsp[0] = ctx->lsp_buf[0];
373  ctx->lsp[1] = ctx->lsp_buf[1];
374  memcpy(ctx->lsp[0], lsp_init, 10 * sizeof(int16_t));
375 
377 
379 
380  /* random seed initialization */
381  ctx->rand_value = 21845;
382 
383  /* quantized prediction error */
384  for (i = 0; i < 4; i++)
385  ctx->quant_energy[i] = -14336; // -14 in (5.10)
386 
387  ctx++;
388  }
389 
390  ff_audiodsp_init(&s->adsp);
392 
393  return 0;
394 }
395 
396 static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr,
397  AVPacket *avpkt)
398 {
399  const uint8_t *buf = avpkt->data;
400  int buf_size = avpkt->size;
401  int16_t *out_frame;
402  GetBitContext gb;
404  int c, i;
405  int16_t *tmp;
406  G729Formats packet_type;
407  G729Context *s = avctx->priv_data;
409  int16_t lp[2][11]; // (3.12)
410  uint8_t ma_predictor; ///< switched MA predictor of LSP quantizer
411  uint8_t quantizer_1st; ///< first stage vector of quantizer
412  uint8_t quantizer_2nd_lo; ///< second stage lower vector of quantizer (size in bits)
413  uint8_t quantizer_2nd_hi; ///< second stage higher vector of quantizer (size in bits)
414 
415  int pitch_delay_int[2]; // pitch delay, integer part
416  int pitch_delay_3x; // pitch delay, multiplied by 3
417  int16_t fc[SUBFRAME_SIZE]; // fixed-codebook vector
418  int16_t synth[SUBFRAME_SIZE+10]; // fixed-codebook vector
419  int j, ret;
420  int gain_before, gain_after;
421  AVFrame *frame = data;
422 
423  frame->nb_samples = SUBFRAME_SIZE<<1;
424  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
425  return ret;
426 
427  if (buf_size % (G729_8K_BLOCK_SIZE * avctx->channels) == 0) {
428  packet_type = FORMAT_G729_8K;
429  format = &format_g729_8k;
430  //Reset voice decision
431  ctx->onset = 0;
433  av_log(avctx, AV_LOG_DEBUG, "Packet type: %s\n", "G.729 @ 8kbit/s");
434  } else if (buf_size == G729D_6K4_BLOCK_SIZE * avctx->channels) {
435  packet_type = FORMAT_G729D_6K4;
436  format = &format_g729d_6k4;
437  av_log(avctx, AV_LOG_DEBUG, "Packet type: %s\n", "G.729D @ 6.4kbit/s");
438  } else {
439  av_log(avctx, AV_LOG_ERROR, "Packet size %d is unknown.\n", buf_size);
440  return AVERROR_INVALIDDATA;
441  }
442 
443  for (c = 0; c < avctx->channels; c++) {
444  int frame_erasure = 0; ///< frame erasure detected during decoding
445  int bad_pitch = 0; ///< parity check failed
446  int is_periodic = 0; ///< whether one of the subframes is declared as periodic or not
447  out_frame = (int16_t*)frame->data[c];
448 
449  for (i = 0; i < buf_size; i++)
450  frame_erasure |= buf[i];
451  frame_erasure = !frame_erasure;
452 
453  init_get_bits(&gb, buf, 8*buf_size);
454 
455  ma_predictor = get_bits(&gb, 1);
456  quantizer_1st = get_bits(&gb, VQ_1ST_BITS);
457  quantizer_2nd_lo = get_bits(&gb, VQ_2ND_BITS);
458  quantizer_2nd_hi = get_bits(&gb, VQ_2ND_BITS);
459 
460  if (frame_erasure) {
462  ctx->ma_predictor_prev);
463  } else {
465  ma_predictor,
466  quantizer_1st, quantizer_2nd_lo, quantizer_2nd_hi);
467  ctx->ma_predictor_prev = ma_predictor;
468  }
469 
470  tmp = ctx->past_quantizer_outputs[MA_NP];
471  memmove(ctx->past_quantizer_outputs + 1, ctx->past_quantizer_outputs,
472  MA_NP * sizeof(int16_t*));
473  ctx->past_quantizer_outputs[0] = tmp;
474 
475  ff_acelp_lsf2lsp(ctx->lsp[1], ctx->lsfq, 10);
476 
477  ff_acelp_lp_decode(&lp[0][0], &lp[1][0], ctx->lsp[1], ctx->lsp[0], 10);
478 
479  FFSWAP(int16_t*, ctx->lsp[1], ctx->lsp[0]);
480 
481  for (i = 0; i < 2; i++) {
482  int gain_corr_factor;
483 
484  uint8_t ac_index; ///< adaptive codebook index
485  uint8_t pulses_signs; ///< fixed-codebook vector pulse signs
486  int fc_indexes; ///< fixed-codebook indexes
487  uint8_t gc_1st_index; ///< gain codebook (first stage) index
488  uint8_t gc_2nd_index; ///< gain codebook (second stage) index
489 
490  ac_index = get_bits(&gb, format->ac_index_bits[i]);
491  if (!i && format->parity_bit)
492  bad_pitch = av_parity(ac_index >> 2) == get_bits1(&gb);
493  fc_indexes = get_bits(&gb, format->fc_indexes_bits);
494  pulses_signs = get_bits(&gb, format->fc_signs_bits);
495  gc_1st_index = get_bits(&gb, format->gc_1st_index_bits);
496  gc_2nd_index = get_bits(&gb, format->gc_2nd_index_bits);
497 
498  if (frame_erasure) {
499  pitch_delay_3x = 3 * ctx->pitch_delay_int_prev;
500  } else if (!i) {
501  if (bad_pitch) {
502  pitch_delay_3x = 3 * ctx->pitch_delay_int_prev;
503  } else {
504  pitch_delay_3x = ff_acelp_decode_8bit_to_1st_delay3(ac_index);
505  }
506  } else {
507  int pitch_delay_min = av_clip(ctx->pitch_delay_int_prev - 5,
509 
510  if (packet_type == FORMAT_G729D_6K4) {
511  pitch_delay_3x = ff_acelp_decode_4bit_to_2nd_delay3(ac_index, pitch_delay_min);
512  } else {
513  pitch_delay_3x = ff_acelp_decode_5_6_bit_to_2nd_delay3(ac_index, pitch_delay_min);
514  }
515  }
516 
517  /* Round pitch delay to nearest (used everywhere except ff_acelp_interpolate). */
518  pitch_delay_int[i] = (pitch_delay_3x + 1) / 3;
519  if (pitch_delay_int[i] > PITCH_DELAY_MAX) {
520  av_log(avctx, AV_LOG_WARNING, "pitch_delay_int %d is too large\n", pitch_delay_int[i]);
521  pitch_delay_int[i] = PITCH_DELAY_MAX;
522  }
523 
524  if (frame_erasure) {
525  ctx->rand_value = g729_prng(ctx->rand_value);
526  fc_indexes = av_mod_uintp2(ctx->rand_value, format->fc_indexes_bits);
527 
528  ctx->rand_value = g729_prng(ctx->rand_value);
529  pulses_signs = ctx->rand_value;
530  }
531 
532 
533  memset(fc, 0, sizeof(int16_t) * SUBFRAME_SIZE);
534  switch (packet_type) {
535  case FORMAT_G729_8K:
538  fc_indexes, pulses_signs, 3, 3);
539  break;
540  case FORMAT_G729D_6K4:
543  fc_indexes, pulses_signs, 1, 4);
544  break;
545  }
546 
547  /*
548  This filter enhances harmonic components of the fixed-codebook vector to
549  improve the quality of the reconstructed speech.
550 
551  / fc_v[i], i < pitch_delay
552  fc_v[i] = <
553  \ fc_v[i] + gain_pitch * fc_v[i-pitch_delay], i >= pitch_delay
554  */
555  ff_acelp_weighted_vector_sum(fc + pitch_delay_int[i],
556  fc + pitch_delay_int[i],
557  fc, 1 << 14,
558  av_clip(ctx->past_gain_pitch[0], SHARP_MIN, SHARP_MAX),
559  0, 14,
560  SUBFRAME_SIZE - pitch_delay_int[i]);
561 
562  memmove(ctx->past_gain_pitch+1, ctx->past_gain_pitch, 5 * sizeof(int16_t));
563  ctx->past_gain_code[1] = ctx->past_gain_code[0];
564 
565  if (frame_erasure) {
566  ctx->past_gain_pitch[0] = (29491 * ctx->past_gain_pitch[0]) >> 15; // 0.90 (0.15)
567  ctx->past_gain_code[0] = ( 2007 * ctx->past_gain_code[0] ) >> 11; // 0.98 (0.11)
568 
569  gain_corr_factor = 0;
570  } else {
571  if (packet_type == FORMAT_G729D_6K4) {
572  ctx->past_gain_pitch[0] = cb_gain_1st_6k4[gc_1st_index][0] +
573  cb_gain_2nd_6k4[gc_2nd_index][0];
574  gain_corr_factor = cb_gain_1st_6k4[gc_1st_index][1] +
575  cb_gain_2nd_6k4[gc_2nd_index][1];
576 
577  /* Without check below overflow can occur in ff_acelp_update_past_gain.
578  It is not issue for G.729, because gain_corr_factor in it's case is always
579  greater than 1024, while in G.729D it can be even zero. */
580  gain_corr_factor = FFMAX(gain_corr_factor, 1024);
581  #ifndef G729_BITEXACT
582  gain_corr_factor >>= 1;
583  #endif
584  } else {
585  ctx->past_gain_pitch[0] = cb_gain_1st_8k[gc_1st_index][0] +
586  cb_gain_2nd_8k[gc_2nd_index][0];
587  gain_corr_factor = cb_gain_1st_8k[gc_1st_index][1] +
588  cb_gain_2nd_8k[gc_2nd_index][1];
589  }
590 
591  /* Decode the fixed-codebook gain. */
592  ctx->past_gain_code[0] = ff_acelp_decode_gain_code(&s->adsp, gain_corr_factor,
593  fc, MR_ENERGY,
594  ctx->quant_energy,
596  SUBFRAME_SIZE, 4);
597  #ifdef G729_BITEXACT
598  /*
599  This correction required to get bit-exact result with
600  reference code, because gain_corr_factor in G.729D is
601  two times larger than in original G.729.
602 
603  If bit-exact result is not issue then gain_corr_factor
604  can be simpler divided by 2 before call to g729_get_gain_code
605  instead of using correction below.
606  */
607  if (packet_type == FORMAT_G729D_6K4) {
608  gain_corr_factor >>= 1;
609  ctx->past_gain_code[0] >>= 1;
610  }
611  #endif
612  }
613  ff_acelp_update_past_gain(ctx->quant_energy, gain_corr_factor, 2, frame_erasure);
614 
615  /* Routine requires rounding to lowest. */
616  ff_acelp_interpolate(ctx->exc + i * SUBFRAME_SIZE,
617  ctx->exc + i * SUBFRAME_SIZE - pitch_delay_3x / 3,
619  (pitch_delay_3x % 3) << 1,
620  10, SUBFRAME_SIZE);
621 
622  ff_acelp_weighted_vector_sum(ctx->exc + i * SUBFRAME_SIZE,
623  ctx->exc + i * SUBFRAME_SIZE, fc,
624  (!ctx->was_periodic && frame_erasure) ? 0 : ctx->past_gain_pitch[0],
625  ( ctx->was_periodic && frame_erasure) ? 0 : ctx->past_gain_code[0],
626  1 << 13, 14, SUBFRAME_SIZE);
627 
628  memcpy(synth, ctx->syn_filter_data, 10 * sizeof(int16_t));
629 
631  synth+10,
632  &lp[i][1],
633  ctx->exc + i * SUBFRAME_SIZE,
634  SUBFRAME_SIZE,
635  10,
636  1,
637  0,
638  0x800))
639  /* Overflow occurred, downscale excitation signal... */
640  for (j = 0; j < 2 * SUBFRAME_SIZE + PITCH_DELAY_MAX + INTERPOL_LEN; j++)
641  ctx->exc_base[j] >>= 2;
642 
643  /* ... and make synthesis again. */
644  if (packet_type == FORMAT_G729D_6K4) {
645  int16_t exc_new[SUBFRAME_SIZE];
646 
647  ctx->onset = g729d_onset_decision(ctx->onset, ctx->past_gain_code);
649 
650  g729d_get_new_exc(exc_new, ctx->exc + i * SUBFRAME_SIZE, fc, ctx->voice_decision, ctx->past_gain_code[0], SUBFRAME_SIZE);
651 
653  synth+10,
654  &lp[i][1],
655  exc_new,
656  SUBFRAME_SIZE,
657  10,
658  0,
659  0,
660  0x800);
661  } else {
663  synth+10,
664  &lp[i][1],
665  ctx->exc + i * SUBFRAME_SIZE,
666  SUBFRAME_SIZE,
667  10,
668  0,
669  0,
670  0x800);
671  }
672  /* Save data (without postfilter) for use in next subframe. */
673  memcpy(ctx->syn_filter_data, synth+SUBFRAME_SIZE, 10 * sizeof(int16_t));
674 
675  /* Calculate gain of unfiltered signal for use in AGC. */
676  gain_before = 0;
677  for (j = 0; j < SUBFRAME_SIZE; j++)
678  gain_before += FFABS(synth[j+10]);
679 
680  /* Call postfilter and also update voicing decision for use in next frame. */
682  &s->adsp,
683  &ctx->ht_prev_data,
684  &is_periodic,
685  &lp[i][0],
686  pitch_delay_int[0],
687  ctx->residual,
688  ctx->res_filter_data,
689  ctx->pos_filter_data,
690  synth+10,
691  SUBFRAME_SIZE);
692 
693  /* Calculate gain of filtered signal for use in AGC. */
694  gain_after = 0;
695  for (j = 0; j < SUBFRAME_SIZE; j++)
696  gain_after += FFABS(synth[j+10]);
697 
699  gain_before,
700  gain_after,
701  synth+10,
702  SUBFRAME_SIZE,
703  ctx->gain_coeff);
704 
705  if (frame_erasure) {
707  } else {
708  ctx->pitch_delay_int_prev = pitch_delay_int[i];
709  }
710 
711  memcpy(synth+8, ctx->hpf_z, 2*sizeof(int16_t));
713  out_frame + i*SUBFRAME_SIZE,
714  ctx->hpf_f,
715  synth+10,
716  SUBFRAME_SIZE);
717  memcpy(ctx->hpf_z, synth+8+SUBFRAME_SIZE, 2*sizeof(int16_t));
718  }
719 
720  ctx->was_periodic = is_periodic;
721 
722  /* Save signal for use in next frame. */
723  memmove(ctx->exc_base, ctx->exc_base + 2 * SUBFRAME_SIZE, (PITCH_DELAY_MAX+INTERPOL_LEN)*sizeof(int16_t));
724 
725  buf += packet_type == FORMAT_G729_8K ? G729_8K_BLOCK_SIZE : G729D_6K4_BLOCK_SIZE;
726  ctx++;
727  }
728 
729  *got_frame_ptr = 1;
730  return packet_type == FORMAT_G729_8K ? G729_8K_BLOCK_SIZE * avctx->channels : G729D_6K4_BLOCK_SIZE * avctx->channels;
731 }
732 
734 {
735  G729Context *s = avctx->priv_data;
737 
738  return 0;
739 }
740 
742  .name = "g729",
743  .long_name = NULL_IF_CONFIG_SMALL("G.729"),
744  .type = AVMEDIA_TYPE_AUDIO,
745  .id = AV_CODEC_ID_G729,
746  .priv_data_size = sizeof(G729Context),
747  .init = decoder_init,
748  .decode = decode_frame,
749  .close = decode_close,
750  .capabilities = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1,
751 };
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:99
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).
AudioDSPContext adsp
Definition: g729dec.c:156
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
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
int16_t lsp_buf[2][10]
(0.15) LSP coefficients (previous and current frames) (3.2.5)
Definition: g729dec.c:114
#define LSFQ_MIN
minimum quantized LSF value (3.2.4) 0.005 in Q13
Definition: g729dec.c:46
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
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
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
void ff_acelp_lsf2lsp(int16_t *lsp, const int16_t *lsf, int lp_order)
Convert LSF to LSP.
Definition: lsp.c:83
#define GC_2ND_IDX_BITS_8K
gain codebook (second stage) index, 8k mode (size in bits)
Definition: g729data.h:33
static const uint16_t ma_prediction_coeff[4]
MA prediction coefficients (3.9.1 of G.729, near Equation 69)
Definition: g729data.h:343
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
const int16_t ff_acelp_interp_filter[61]
low-pass Finite Impulse Response filter coefficients.
Definition: acelp_filters.c:30
int16_t lsfq[10]
(2.13) quantized LSF coefficients from previous frame
Definition: g729dec.c:113
#define MR_ENERGY
MR_ENERGY (mean removed energy) = mean_energy + 10 * log10(2^26 * subframe_size) in (7...
Definition: g729dec.c:81
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:60
int size
Definition: avcodec.h:1478
const uint8_t ff_fc_2pulses_9bits_track1_gray[16]
Definition: acelp_vectors.c:42
int pitch_delay_int_prev
integer part of previous subframe&#39;s pitch delay (4.1.3)
Definition: g729dec.c:107
int ff_acelp_decode_4bit_to_2nd_delay3(int ac_index, int pitch_delay_min)
Decode pitch delay with 1/3 precision.
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
Convenience header that includes libavutil&#39;s core.
static const G729FormatDescription format_g729_8k
Definition: g729dec.c:161
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.
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
int16_t quant_energy[4]
(5.10) past quantized energy
Definition: g729dec.c:117
#define LSFQ_DIFF_MIN
minimum LSF distance (3.2.4) 0.0391 in Q13
Definition: g729dec.c:58
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
AVCodec.
Definition: avcodec.h:3481
uint16_t rand_value
random number generator value (4.4.4)
Definition: g729dec.c:145
int16_t ht_prev_data
previous data for 4.2.3, equation 86
Definition: g729dec.c:143
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:42
static int32_t scalarproduct_int16_c(const int16_t *v1, const int16_t *v2, int order)
Definition: g729dec.c:333
int16_t * lsp[2]
pointers to lsp_buf
Definition: g729dec.c:115
uint8_t fc_indexes_bits
size (in bits) of fixed-codebook index entry
Definition: g729dec.c:99
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2233
const uint8_t ff_fc_4pulses_8bits_track_4[32]
Track|Pulse| Positions 4 | 3 | 3, 8, 13, 18, 23, 28, 33, 38, 43, 48, 53, 58, 63, 68, 73, 78 | | 4, 9, 14, 19, 24, 29, 34, 39, 44, 49, 54, 59, 64, 69, 74, 79
Definition: acelp_vectors.c:79
uint8_t
#define av_cold
Definition: attributes.h:82
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:262
av_cold void ff_audiodsp_init(AudioDSPContext *c)
Definition: audiodsp.c:106
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
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:108
#define PITCH_DELAY_MAX
AVCodec ff_g729_decoder
Definition: g729dec.c:741
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.
#define DECISION_VOICE
Definition: g729dec.c:85
uint8_t * data
Definition: avcodec.h:1477
bitstream reader API header.
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:305
static av_cold int decode_close(AVCodecContext *avctx)
Definition: g729dec.c:733
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)
#define DECISION_NOISE
Definition: g729dec.c:83
#define av_log(a,...)
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:196
int16_t * past_quantizer_outputs[MA_NP+1]
Definition: g729dec.c:111
#define fc(width, name, range_min, range_max)
Definition: cbs_av1.c:551
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int ma_predictor_prev
switched MA predictor of LSP quantizer from last good frame
Definition: g729dec.c:146
uint8_t gc_2nd_index_bits
gain codebook (second stage) index (size in bits)
Definition: g729dec.c:97
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
#define DECISION_INTERMEDIATE
Definition: g729dec.c:84
const char * name
Name of the codec implementation.
Definition: avcodec.h:3488
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.6.2 of G.729 and 6.1.5 of AMR).
Definition: celp_filters.c:30
static av_cold int decoder_init(AVCodecContext *avctx)
Definition: g729dec.c:343
int16_t pos_filter_data[SUBFRAME_SIZE+10]
previous speech data for short-term postfilter
Definition: g729dec.c:130
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
uint8_t ac_index_bits[2]
adaptive codebook index for second subframe (size in bits)
Definition: g729dec.c:94
#define FFMAX(a, b)
Definition: common.h:94
uint64_t residual
Definition: dirac_vlc.h:29
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
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.
uint8_t parity_bit
parity bit for pitch delay
Definition: g729dec.c:95
G729ChannelContext * channel_context
Definition: g729dec.c:158
#define FFMIN(a, b)
Definition: common.h:96
int gain_coeff
(1.14) gain coefficient (4.2.4)
Definition: g729dec.c:144
uint8_t fc_signs_bits
number of pulses in fixed-codebook vector
Definition: g729dec.c:98
#define GC_2ND_IDX_BITS_6K4
gain codebook (second stage) index, 6.4k mode (size in bits)
Definition: g729data.h:36
int32_t
AVFormatContext * ctx
Definition: movenc.c:48
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
int16_t past_quantizer_output_buf[MA_NP+1][10]
(2.13) LSP quantizer outputs
Definition: g729dec.c:110
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
#define s(width, name)
Definition: cbs_vp9.c:257
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.
int16_t onset
detected onset level (0-2)
Definition: g729dec.c:141
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.2.5 and 3.2.6 of G.729)
Definition: lsp.c:171
static const int16_t cb_ma_predictor_sum_inv[2][10]
12 ...
Definition: g729data.h:335
int16_t res_filter_data[SUBFRAME_SIZE+10]
previous speech data for residual calculation filter
Definition: g729dec.c:127
int16_t voice_decision
voice decision on previous subframe (0-noise, 1-intermediate, 2-voice), G.729D
Definition: g729dec.c:139
if(ret)
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:2245
#define SHARP_MIN
minimum gain pitch value (3.8, Equation 47) 0.2 in (1.14)
Definition: g729dec.c:67
Libavcodec external API header.
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:237
uint8_t gc_1st_index_bits
gain codebook (first stage) index (size in bits)
Definition: g729dec.c:96
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: g729dec.c:396
int32_t(* scalarproduct_int16)(const int16_t *v1, const int16_t *v2, int len)
Calculate scalar product of two vectors.
Definition: audiodsp.h:29
main external API structure.
Definition: avcodec.h:1565
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1964
void * buf
Definition: avisynth_c.h:766
#define G729D_6K4_BLOCK_SIZE
Definition: g729.h:31
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31))))#define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac){}void ff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map){AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);return NULL;}return ac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;}int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){int use_generic=1;int len=in->nb_samples;int p;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
const uint8_t ff_fc_4pulses_8bits_tracks_13[16]
Track|Pulse| Positions 1 | 0 | 0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75 2 | 1 | 1, 6, 11, 16, 21, 26, 31, 36, 41, 46, 51, 56, 61, 66, 71, 76 3 | 2 | 2, 7, 12, 17, 22, 27, 32, 37, 42, 47, 52, 57, 62, 67, 72, 77
Definition: acelp_vectors.c:74
#define AV_CODEC_CAP_SUBFRAMES
Codec can output multiple frames per AVPacket Normally demuxers return one frame at a time...
Definition: avcodec.h:1024
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
#define INTERPOL_LEN
interpolation filter length
Definition: g729dec.c:61
G729Formats
Definition: g729dec.c:87
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)
#define MA_NP
Moving Average (MA) prediction order.
Definition: g729data.h:27
#define G729_8K_BLOCK_SIZE
Definition: g729.h:30
const uint8_t ff_fc_2pulses_9bits_track2_gray[32]
Track|Pulse| Positions 2 | 1 | 0, 7, 14, 20, 27, 34, 1, 21 | | 2, 9, 15, 22, 29, 35, 6, 26 | | 4,10, 17, 24, 30, 37, 11, 31 | | 5,12, 19, 25, 32, 39, 16, 36
Definition: acelp_vectors.c:54
#define LSFQ_MAX
maximum quantized LSF value (3.2.4) 3.135 in Q13
Definition: g729dec.c:52
int16_t exc_base[2 *SUBFRAME_SIZE+PITCH_DELAY_MAX+INTERPOL_LEN]
past excitation signal buffer
Definition: g729dec.c:104
int16_t past_gain_pitch[6]
(1.14) pitch gain of current and five previous subframes
Definition: g729dec.c:133
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
#define SHARP_MAX
maximum gain pitch value (3.8, Equation 47) (EE) This does not comply with the specification.
Definition: g729dec.c:76
int16_t hpf_z[2]
high-pass filter data (past output)
Definition: g729dec.c:152
#define av_parity
Definition: intmath.h:158
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:44
#define VQ_2ND_BITS
second stage vector of quantizer (size in bits)
Definition: g729data.h:30
#define GC_1ST_IDX_BITS_8K
gain codebook (first stage) index, 8k mode (size in bits)
Definition: g729data.h:32
common internal api header.
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
static int g729d_onset_decision(int past_onset, const int16_t *past_gain_code)
Makes decision about onset in current subframe.
Definition: g729dec.c:289
#define VQ_1ST_BITS
first stage vector of quantizer (size in bits)
Definition: g729data.h:29
#define GC_1ST_IDX_BITS_6K4
gain codebook (first stage) index, 6.4k mode (size in bits)
Definition: g729data.h:35
void * priv_data
Definition: avcodec.h:1592
static av_always_inline int diff(const uint32_t a, const uint32_t b)
int16_t past_gain_code[2]
(14.1) gain code from current and previous subframe
Definition: g729dec.c:136
int channels
number of audio channels
Definition: avcodec.h:2226
#define SUBFRAME_SIZE
Definition: evrcdec.c:41
static const int16_t cb_ma_predictor_sum[2][10]
15 3 cb_ma_predictor_sum[j][i] = floor( 2 * (1...
Definition: g729data.h:321
static void frame_erasure(EVRCContext *e, float *samples)
Definition: evrcdec.c:652
int hpf_f[2]
(14.14) high-pass filter data (past input)
Definition: g729dec.c:149
static uint16_t g729_prng(uint16_t value)
pseudo random number generator
Definition: g729dec.c:182
#define RES_PREV_DATA_SIZE
Amount of past residual signal data stored in buffer.
static const G729FormatDescription format_g729d_6k4
Definition: g729dec.c:170
FILE * out
Definition: movenc.c:54
#define av_freep(p)
signed 16 bits, planar
Definition: samplefmt.h:67
#define PITCH_DELAY_MIN
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
#define FFSWAP(type, a, b)
Definition: common.h:99
int16_t syn_filter_data[10]
previous speech data for LP synthesis filter
Definition: g729dec.c:120
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
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
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
This structure stores compressed data.
Definition: avcodec.h:1454
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:361
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:981
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).
int16_t residual[SUBFRAME_SIZE+RES_PREV_DATA_SIZE]
residual signal buffer (used in long-term postfilter)
Definition: g729dec.c:124
int16_t was_periodic
whether previous frame was declared as periodic or not (4.4)
Definition: g729dec.c:142
for(j=16;j >0;--j)
int16_t * exc
start of past excitation data in buffer
Definition: g729dec.c:106
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
static uint8_t tmp[11]
Definition: aes_ctr.c:26