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
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)
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 c,i,k;
354 
355  if (avctx->channels < 1 || avctx->channels > 2) {
356  av_log(avctx, AV_LOG_ERROR, "Only mono and stereo are supported (requested channels: %d).\n", avctx->channels);
357  return AVERROR(EINVAL);
358  }
360 
361  /* Both 8kbit/s and 6.4kbit/s modes uses two subframes per frame. */
362  avctx->frame_size = SUBFRAME_SIZE << 1;
363 
364  ctx =
365  s->channel_context = av_mallocz(sizeof(G729ChannelContext) * avctx->channels);
366  if (!ctx)
367  return AVERROR(ENOMEM);
368 
369  for (c = 0; c < avctx->channels; c++) {
370  ctx->gain_coeff = 16384; // 1.0 in (1.14)
371 
372  for (k = 0; k < MA_NP + 1; k++) {
374  for (i = 1; i < 11; i++)
375  ctx->past_quantizer_outputs[k][i - 1] = (18717 * i) >> 3;
376  }
377 
378  ctx->lsp[0] = ctx->lsp_buf[0];
379  ctx->lsp[1] = ctx->lsp_buf[1];
380  memcpy(ctx->lsp[0], lsp_init, 10 * sizeof(int16_t));
381 
383 
385 
386  /* random seed initialization */
387  ctx->rand_value = 21845;
388 
389  /* quantized prediction error */
390  for (i = 0; i < 4; i++)
391  ctx->quant_energy[i] = -14336; // -14 in (5.10)
392 
393  ctx++;
394  }
395 
396  ff_audiodsp_init(&s->adsp);
398 
399  return 0;
400 }
401 
402 static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr,
403  AVPacket *avpkt)
404 {
405  const uint8_t *buf = avpkt->data;
406  int buf_size = avpkt->size;
407  int16_t *out_frame;
408  GetBitContext gb;
410  int c, i;
411  int16_t *tmp;
412  G729Formats packet_type;
413  G729Context *s = avctx->priv_data;
415  int16_t lp[2][11]; // (3.12)
416  uint8_t ma_predictor; ///< switched MA predictor of LSP quantizer
417  uint8_t quantizer_1st; ///< first stage vector of quantizer
418  uint8_t quantizer_2nd_lo; ///< second stage lower vector of quantizer (size in bits)
419  uint8_t quantizer_2nd_hi; ///< second stage higher vector of quantizer (size in bits)
420 
421  int pitch_delay_int[2]; // pitch delay, integer part
422  int pitch_delay_3x; // pitch delay, multiplied by 3
423  int16_t fc[SUBFRAME_SIZE]; // fixed-codebook vector
424  int16_t synth[SUBFRAME_SIZE+10]; // fixed-codebook vector
425  int j, ret;
426  int gain_before, gain_after;
427  AVFrame *frame = data;
428 
429  frame->nb_samples = SUBFRAME_SIZE<<1;
430  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
431  return ret;
432 
433  if (buf_size && buf_size % ((G729_8K_BLOCK_SIZE + (avctx->codec_id == AV_CODEC_ID_ACELP_KELVIN)) * avctx->channels) == 0) {
434  packet_type = FORMAT_G729_8K;
435  format = &format_g729_8k;
436  //Reset voice decision
437  ctx->onset = 0;
439  av_log(avctx, AV_LOG_DEBUG, "Packet type: %s\n", "G.729 @ 8kbit/s");
440  } else if (buf_size == G729D_6K4_BLOCK_SIZE * avctx->channels && avctx->codec_id != AV_CODEC_ID_ACELP_KELVIN) {
441  packet_type = FORMAT_G729D_6K4;
442  format = &format_g729d_6k4;
443  av_log(avctx, AV_LOG_DEBUG, "Packet type: %s\n", "G.729D @ 6.4kbit/s");
444  } else {
445  av_log(avctx, AV_LOG_ERROR, "Packet size %d is unknown.\n", buf_size);
446  return AVERROR_INVALIDDATA;
447  }
448 
449  for (c = 0; c < avctx->channels; c++) {
450  int frame_erasure = 0; ///< frame erasure detected during decoding
451  int bad_pitch = 0; ///< parity check failed
452  int is_periodic = 0; ///< whether one of the subframes is declared as periodic or not
453  out_frame = (int16_t*)frame->data[c];
454  if (avctx->codec_id == AV_CODEC_ID_ACELP_KELVIN) {
455  if (*buf != ((avctx->channels - 1 - c) * 0x80 | 2))
456  avpriv_request_sample(avctx, "First byte value %x for channel %d", *buf, c);
457  buf++;
458  }
459 
460  for (i = 0; i < format->block_size; i++)
461  frame_erasure |= buf[i];
462  frame_erasure = !frame_erasure;
463 
464  init_get_bits8(&gb, buf, format->block_size);
465 
466  ma_predictor = get_bits(&gb, 1);
467  quantizer_1st = get_bits(&gb, VQ_1ST_BITS);
468  quantizer_2nd_lo = get_bits(&gb, VQ_2ND_BITS);
469  quantizer_2nd_hi = get_bits(&gb, VQ_2ND_BITS);
470 
471  if (frame_erasure) {
473  ctx->ma_predictor_prev);
474  } else {
476  ma_predictor,
477  quantizer_1st, quantizer_2nd_lo, quantizer_2nd_hi);
478  ctx->ma_predictor_prev = ma_predictor;
479  }
480 
481  tmp = ctx->past_quantizer_outputs[MA_NP];
482  memmove(ctx->past_quantizer_outputs + 1, ctx->past_quantizer_outputs,
483  MA_NP * sizeof(int16_t*));
484  ctx->past_quantizer_outputs[0] = tmp;
485 
486  ff_acelp_lsf2lsp(ctx->lsp[1], ctx->lsfq, 10);
487 
488  ff_acelp_lp_decode(&lp[0][0], &lp[1][0], ctx->lsp[1], ctx->lsp[0], 10);
489 
490  FFSWAP(int16_t*, ctx->lsp[1], ctx->lsp[0]);
491 
492  for (i = 0; i < 2; i++) {
493  int gain_corr_factor;
494 
495  uint8_t ac_index; ///< adaptive codebook index
496  uint8_t pulses_signs; ///< fixed-codebook vector pulse signs
497  int fc_indexes; ///< fixed-codebook indexes
498  uint8_t gc_1st_index; ///< gain codebook (first stage) index
499  uint8_t gc_2nd_index; ///< gain codebook (second stage) index
500 
501  ac_index = get_bits(&gb, format->ac_index_bits[i]);
502  if (!i && format->parity_bit)
503  bad_pitch = av_parity(ac_index >> 2) == get_bits1(&gb);
504  fc_indexes = get_bits(&gb, format->fc_indexes_bits);
505  pulses_signs = get_bits(&gb, format->fc_signs_bits);
506  gc_1st_index = get_bits(&gb, format->gc_1st_index_bits);
507  gc_2nd_index = get_bits(&gb, format->gc_2nd_index_bits);
508 
509  if (frame_erasure) {
510  pitch_delay_3x = 3 * ctx->pitch_delay_int_prev;
511  } else if (!i) {
512  if (bad_pitch) {
513  pitch_delay_3x = 3 * ctx->pitch_delay_int_prev;
514  } else {
515  pitch_delay_3x = ff_acelp_decode_8bit_to_1st_delay3(ac_index);
516  }
517  } else {
518  int pitch_delay_min = av_clip(ctx->pitch_delay_int_prev - 5,
520 
521  if (packet_type == FORMAT_G729D_6K4) {
522  pitch_delay_3x = ff_acelp_decode_4bit_to_2nd_delay3(ac_index, pitch_delay_min);
523  } else {
524  pitch_delay_3x = ff_acelp_decode_5_6_bit_to_2nd_delay3(ac_index, pitch_delay_min);
525  }
526  }
527 
528  /* Round pitch delay to nearest (used everywhere except ff_acelp_interpolate). */
529  pitch_delay_int[i] = (pitch_delay_3x + 1) / 3;
530  if (pitch_delay_int[i] > PITCH_DELAY_MAX) {
531  av_log(avctx, AV_LOG_WARNING, "pitch_delay_int %d is too large\n", pitch_delay_int[i]);
532  pitch_delay_int[i] = PITCH_DELAY_MAX;
533  }
534 
535  if (frame_erasure) {
536  ctx->rand_value = g729_prng(ctx->rand_value);
537  fc_indexes = av_mod_uintp2(ctx->rand_value, format->fc_indexes_bits);
538 
539  ctx->rand_value = g729_prng(ctx->rand_value);
540  pulses_signs = ctx->rand_value;
541  }
542 
543 
544  memset(fc, 0, sizeof(int16_t) * SUBFRAME_SIZE);
545  switch (packet_type) {
546  case FORMAT_G729_8K:
549  fc_indexes, pulses_signs, 3, 3);
550  break;
551  case FORMAT_G729D_6K4:
554  fc_indexes, pulses_signs, 1, 4);
555  break;
556  }
557 
558  /*
559  This filter enhances harmonic components of the fixed-codebook vector to
560  improve the quality of the reconstructed speech.
561 
562  / fc_v[i], i < pitch_delay
563  fc_v[i] = <
564  \ fc_v[i] + gain_pitch * fc_v[i-pitch_delay], i >= pitch_delay
565  */
566  if (SUBFRAME_SIZE > pitch_delay_int[i])
567  ff_acelp_weighted_vector_sum(fc + pitch_delay_int[i],
568  fc + pitch_delay_int[i],
569  fc, 1 << 14,
570  av_clip(ctx->past_gain_pitch[0], SHARP_MIN, SHARP_MAX),
571  0, 14,
572  SUBFRAME_SIZE - pitch_delay_int[i]);
573 
574  memmove(ctx->past_gain_pitch+1, ctx->past_gain_pitch, 5 * sizeof(int16_t));
575  ctx->past_gain_code[1] = ctx->past_gain_code[0];
576 
577  if (frame_erasure) {
578  ctx->past_gain_pitch[0] = (29491 * ctx->past_gain_pitch[0]) >> 15; // 0.90 (0.15)
579  ctx->past_gain_code[0] = ( 2007 * ctx->past_gain_code[0] ) >> 11; // 0.98 (0.11)
580 
581  gain_corr_factor = 0;
582  } else {
583  if (packet_type == FORMAT_G729D_6K4) {
584  ctx->past_gain_pitch[0] = cb_gain_1st_6k4[gc_1st_index][0] +
585  cb_gain_2nd_6k4[gc_2nd_index][0];
586  gain_corr_factor = cb_gain_1st_6k4[gc_1st_index][1] +
587  cb_gain_2nd_6k4[gc_2nd_index][1];
588 
589  /* Without check below overflow can occur in ff_acelp_update_past_gain.
590  It is not issue for G.729, because gain_corr_factor in it's case is always
591  greater than 1024, while in G.729D it can be even zero. */
592  gain_corr_factor = FFMAX(gain_corr_factor, 1024);
593  #ifndef G729_BITEXACT
594  gain_corr_factor >>= 1;
595  #endif
596  } else {
597  ctx->past_gain_pitch[0] = cb_gain_1st_8k[gc_1st_index][0] +
598  cb_gain_2nd_8k[gc_2nd_index][0];
599  gain_corr_factor = cb_gain_1st_8k[gc_1st_index][1] +
600  cb_gain_2nd_8k[gc_2nd_index][1];
601  }
602 
603  /* Decode the fixed-codebook gain. */
604  ctx->past_gain_code[0] = ff_acelp_decode_gain_code(&s->adsp, gain_corr_factor,
605  fc, MR_ENERGY,
606  ctx->quant_energy,
608  SUBFRAME_SIZE, 4);
609  #ifdef G729_BITEXACT
610  /*
611  This correction required to get bit-exact result with
612  reference code, because gain_corr_factor in G.729D is
613  two times larger than in original G.729.
614 
615  If bit-exact result is not issue then gain_corr_factor
616  can be simpler divided by 2 before call to g729_get_gain_code
617  instead of using correction below.
618  */
619  if (packet_type == FORMAT_G729D_6K4) {
620  gain_corr_factor >>= 1;
621  ctx->past_gain_code[0] >>= 1;
622  }
623  #endif
624  }
625  ff_acelp_update_past_gain(ctx->quant_energy, gain_corr_factor, 2, frame_erasure);
626 
627  /* Routine requires rounding to lowest. */
628  ff_acelp_interpolate(ctx->exc + i * SUBFRAME_SIZE,
629  ctx->exc + i * SUBFRAME_SIZE - pitch_delay_3x / 3,
631  (pitch_delay_3x % 3) << 1,
632  10, SUBFRAME_SIZE);
633 
634  ff_acelp_weighted_vector_sum(ctx->exc + i * SUBFRAME_SIZE,
635  ctx->exc + i * SUBFRAME_SIZE, fc,
636  (!ctx->was_periodic && frame_erasure) ? 0 : ctx->past_gain_pitch[0],
637  ( ctx->was_periodic && frame_erasure) ? 0 : ctx->past_gain_code[0],
638  1 << 13, 14, SUBFRAME_SIZE);
639 
640  memcpy(synth, ctx->syn_filter_data, 10 * sizeof(int16_t));
641 
643  synth+10,
644  &lp[i][1],
645  ctx->exc + i * SUBFRAME_SIZE,
646  SUBFRAME_SIZE,
647  10,
648  1,
649  0,
650  0x800))
651  /* Overflow occurred, downscale excitation signal... */
652  for (j = 0; j < 2 * SUBFRAME_SIZE + PITCH_DELAY_MAX + INTERPOL_LEN; j++)
653  ctx->exc_base[j] >>= 2;
654 
655  /* ... and make synthesis again. */
656  if (packet_type == FORMAT_G729D_6K4) {
657  int16_t exc_new[SUBFRAME_SIZE];
658 
659  ctx->onset = g729d_onset_decision(ctx->onset, ctx->past_gain_code);
661 
662  g729d_get_new_exc(exc_new, ctx->exc + i * SUBFRAME_SIZE, fc, ctx->voice_decision, ctx->past_gain_code[0], SUBFRAME_SIZE);
663 
665  synth+10,
666  &lp[i][1],
667  exc_new,
668  SUBFRAME_SIZE,
669  10,
670  0,
671  0,
672  0x800);
673  } else {
675  synth+10,
676  &lp[i][1],
677  ctx->exc + i * SUBFRAME_SIZE,
678  SUBFRAME_SIZE,
679  10,
680  0,
681  0,
682  0x800);
683  }
684  /* Save data (without postfilter) for use in next subframe. */
685  memcpy(ctx->syn_filter_data, synth+SUBFRAME_SIZE, 10 * sizeof(int16_t));
686 
687  /* Calculate gain of unfiltered signal for use in AGC. */
688  gain_before = 0;
689  for (j = 0; j < SUBFRAME_SIZE; j++)
690  gain_before += FFABS(synth[j+10]);
691 
692  /* Call postfilter and also update voicing decision for use in next frame. */
694  &s->adsp,
695  &ctx->ht_prev_data,
696  &is_periodic,
697  &lp[i][0],
698  pitch_delay_int[0],
699  ctx->residual,
700  ctx->res_filter_data,
701  ctx->pos_filter_data,
702  synth+10,
703  SUBFRAME_SIZE);
704 
705  /* Calculate gain of filtered signal for use in AGC. */
706  gain_after = 0;
707  for (j = 0; j < SUBFRAME_SIZE; j++)
708  gain_after += FFABS(synth[j+10]);
709 
711  gain_before,
712  gain_after,
713  synth+10,
714  SUBFRAME_SIZE,
715  ctx->gain_coeff);
716 
717  if (frame_erasure) {
719  } else {
720  ctx->pitch_delay_int_prev = pitch_delay_int[i];
721  }
722 
723  memcpy(synth+8, ctx->hpf_z, 2*sizeof(int16_t));
725  out_frame + i*SUBFRAME_SIZE,
726  ctx->hpf_f,
727  synth+10,
728  SUBFRAME_SIZE);
729  memcpy(ctx->hpf_z, synth+8+SUBFRAME_SIZE, 2*sizeof(int16_t));
730  }
731 
732  ctx->was_periodic = is_periodic;
733 
734  /* Save signal for use in next frame. */
735  memmove(ctx->exc_base, ctx->exc_base + 2 * SUBFRAME_SIZE, (PITCH_DELAY_MAX+INTERPOL_LEN)*sizeof(int16_t));
736 
737  buf += format->block_size;
738  ctx++;
739  }
740 
741  *got_frame_ptr = 1;
742  return (format->block_size + (avctx->codec_id == AV_CODEC_ID_ACELP_KELVIN)) * avctx->channels;
743 }
744 
746 {
747  G729Context *s = avctx->priv_data;
749 
750  return 0;
751 }
752 
754  .name = "g729",
755  .long_name = NULL_IF_CONFIG_SMALL("G.729"),
756  .type = AVMEDIA_TYPE_AUDIO,
757  .id = AV_CODEC_ID_G729,
758  .priv_data_size = sizeof(G729Context),
759  .init = decoder_init,
760  .decode = decode_frame,
761  .close = decode_close,
762  .capabilities = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1,
763 };
764 
766  .name = "acelp.kelvin",
767  .long_name = NULL_IF_CONFIG_SMALL("Sipro ACELP.KELVIN"),
768  .type = AVMEDIA_TYPE_AUDIO,
770  .priv_data_size = sizeof(G729Context),
771  .init = decoder_init,
772  .decode = decode_frame,
773  .close = decode_close,
774  .capabilities = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1,
775 };
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:157
#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:115
#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
AVCodec ff_acelp_kelvin_decoder
Definition: g729dec.c:765
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:114
#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
#define avpriv_request_sample(...)
int size
Definition: avcodec.h:1483
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:108
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:162
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:118
#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:3494
uint16_t rand_value
random number generator value (4.4.4)
Definition: g729dec.c:146
int16_t ht_prev_data
previous data for 4.2.3, equation 86
Definition: g729dec.c:144
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
static int32_t scalarproduct_int16_c(const int16_t *v1, const int16_t *v2, int order)
Definition: g729dec.c:336
int16_t * lsp[2]
pointers to lsp_buf
Definition: g729dec.c:116
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:2238
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:265
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:753
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:1482
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:308
static av_cold int decode_close(AVCodecContext *avctx)
Definition: g729dec.c:745
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:199
int16_t * past_quantizer_outputs[MA_NP+1]
Definition: g729dec.c:112
#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:147
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:3501
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:349
int16_t pos_filter_data[SUBFRAME_SIZE+10]
previous speech data for short-term postfilter
Definition: g729dec.c:131
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:159
#define FFMIN(a, b)
Definition: common.h:96
int gain_coeff
(1.14) gain coefficient (4.2.4)
Definition: g729dec.c:145
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:111
#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:142
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:128
int16_t voice_decision
voice decision on previous subframe (0-noise, 1-intermediate, 2-voice), G.729D
Definition: g729dec.c:140
if(ret)
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:2250
#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:240
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:402
enum AVCodecID codec_id
Definition: avcodec.h:1580
int32_t(* scalarproduct_int16)(const int16_t *v1, const int16_t *v2, int len)
Calculate scalar product of two vectors.
Definition: audiodsp.h:29
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
main external API structure.
Definition: avcodec.h:1570
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1968
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:1029
#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:105
int16_t past_gain_pitch[6]
(1.14) pitch gain of current and five previous subframes
Definition: g729dec.c:134
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:153
#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:292
#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:1597
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:137
int channels
number of audio channels
Definition: avcodec.h:2231
#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:150
static uint16_t g729_prng(uint16_t value)
pseudo random number generator
Definition: g729dec.c:185
#define RES_PREV_DATA_SIZE
Amount of past residual signal data stored in buffer.
static const G729FormatDescription format_g729d_6k4
Definition: g729dec.c:172
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:121
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:1459
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:986
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:125
int16_t was_periodic
whether previous frame was declared as periodic or not (4.4)
Definition: g729dec.c:143
int16_t * exc
start of past excitation data in buffer
Definition: g729dec.c:107
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