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->codec_id == AV_CODEC_ID_ACELP_KELVIN)) * 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  if (avctx->codec_id == AV_CODEC_ID_ACELP_KELVIN) {
449  if (*buf != ((avctx->channels - 1 - c) * 0x80 | 2))
450  avpriv_request_sample(avctx, "First byte value %x for channel %d", *buf, c);
451  buf++;
452  }
453 
454  for (i = 0; i < buf_size; i++)
455  frame_erasure |= buf[i];
456  frame_erasure = !frame_erasure;
457 
458  init_get_bits(&gb, buf, 8*buf_size);
459 
460  ma_predictor = get_bits(&gb, 1);
461  quantizer_1st = get_bits(&gb, VQ_1ST_BITS);
462  quantizer_2nd_lo = get_bits(&gb, VQ_2ND_BITS);
463  quantizer_2nd_hi = get_bits(&gb, VQ_2ND_BITS);
464 
465  if (frame_erasure) {
467  ctx->ma_predictor_prev);
468  } else {
470  ma_predictor,
471  quantizer_1st, quantizer_2nd_lo, quantizer_2nd_hi);
472  ctx->ma_predictor_prev = ma_predictor;
473  }
474 
475  tmp = ctx->past_quantizer_outputs[MA_NP];
476  memmove(ctx->past_quantizer_outputs + 1, ctx->past_quantizer_outputs,
477  MA_NP * sizeof(int16_t*));
478  ctx->past_quantizer_outputs[0] = tmp;
479 
480  ff_acelp_lsf2lsp(ctx->lsp[1], ctx->lsfq, 10);
481 
482  ff_acelp_lp_decode(&lp[0][0], &lp[1][0], ctx->lsp[1], ctx->lsp[0], 10);
483 
484  FFSWAP(int16_t*, ctx->lsp[1], ctx->lsp[0]);
485 
486  for (i = 0; i < 2; i++) {
487  int gain_corr_factor;
488 
489  uint8_t ac_index; ///< adaptive codebook index
490  uint8_t pulses_signs; ///< fixed-codebook vector pulse signs
491  int fc_indexes; ///< fixed-codebook indexes
492  uint8_t gc_1st_index; ///< gain codebook (first stage) index
493  uint8_t gc_2nd_index; ///< gain codebook (second stage) index
494 
495  ac_index = get_bits(&gb, format->ac_index_bits[i]);
496  if (!i && format->parity_bit)
497  bad_pitch = av_parity(ac_index >> 2) == get_bits1(&gb);
498  fc_indexes = get_bits(&gb, format->fc_indexes_bits);
499  pulses_signs = get_bits(&gb, format->fc_signs_bits);
500  gc_1st_index = get_bits(&gb, format->gc_1st_index_bits);
501  gc_2nd_index = get_bits(&gb, format->gc_2nd_index_bits);
502 
503  if (frame_erasure) {
504  pitch_delay_3x = 3 * ctx->pitch_delay_int_prev;
505  } else if (!i) {
506  if (bad_pitch) {
507  pitch_delay_3x = 3 * ctx->pitch_delay_int_prev;
508  } else {
509  pitch_delay_3x = ff_acelp_decode_8bit_to_1st_delay3(ac_index);
510  }
511  } else {
512  int pitch_delay_min = av_clip(ctx->pitch_delay_int_prev - 5,
514 
515  if (packet_type == FORMAT_G729D_6K4) {
516  pitch_delay_3x = ff_acelp_decode_4bit_to_2nd_delay3(ac_index, pitch_delay_min);
517  } else {
518  pitch_delay_3x = ff_acelp_decode_5_6_bit_to_2nd_delay3(ac_index, pitch_delay_min);
519  }
520  }
521 
522  /* Round pitch delay to nearest (used everywhere except ff_acelp_interpolate). */
523  pitch_delay_int[i] = (pitch_delay_3x + 1) / 3;
524  if (pitch_delay_int[i] > PITCH_DELAY_MAX) {
525  av_log(avctx, AV_LOG_WARNING, "pitch_delay_int %d is too large\n", pitch_delay_int[i]);
526  pitch_delay_int[i] = PITCH_DELAY_MAX;
527  }
528 
529  if (frame_erasure) {
530  ctx->rand_value = g729_prng(ctx->rand_value);
531  fc_indexes = av_mod_uintp2(ctx->rand_value, format->fc_indexes_bits);
532 
533  ctx->rand_value = g729_prng(ctx->rand_value);
534  pulses_signs = ctx->rand_value;
535  }
536 
537 
538  memset(fc, 0, sizeof(int16_t) * SUBFRAME_SIZE);
539  switch (packet_type) {
540  case FORMAT_G729_8K:
543  fc_indexes, pulses_signs, 3, 3);
544  break;
545  case FORMAT_G729D_6K4:
548  fc_indexes, pulses_signs, 1, 4);
549  break;
550  }
551 
552  /*
553  This filter enhances harmonic components of the fixed-codebook vector to
554  improve the quality of the reconstructed speech.
555 
556  / fc_v[i], i < pitch_delay
557  fc_v[i] = <
558  \ fc_v[i] + gain_pitch * fc_v[i-pitch_delay], i >= pitch_delay
559  */
560  ff_acelp_weighted_vector_sum(fc + pitch_delay_int[i],
561  fc + pitch_delay_int[i],
562  fc, 1 << 14,
563  av_clip(ctx->past_gain_pitch[0], SHARP_MIN, SHARP_MAX),
564  0, 14,
565  SUBFRAME_SIZE - pitch_delay_int[i]);
566 
567  memmove(ctx->past_gain_pitch+1, ctx->past_gain_pitch, 5 * sizeof(int16_t));
568  ctx->past_gain_code[1] = ctx->past_gain_code[0];
569 
570  if (frame_erasure) {
571  ctx->past_gain_pitch[0] = (29491 * ctx->past_gain_pitch[0]) >> 15; // 0.90 (0.15)
572  ctx->past_gain_code[0] = ( 2007 * ctx->past_gain_code[0] ) >> 11; // 0.98 (0.11)
573 
574  gain_corr_factor = 0;
575  } else {
576  if (packet_type == FORMAT_G729D_6K4) {
577  ctx->past_gain_pitch[0] = cb_gain_1st_6k4[gc_1st_index][0] +
578  cb_gain_2nd_6k4[gc_2nd_index][0];
579  gain_corr_factor = cb_gain_1st_6k4[gc_1st_index][1] +
580  cb_gain_2nd_6k4[gc_2nd_index][1];
581 
582  /* Without check below overflow can occur in ff_acelp_update_past_gain.
583  It is not issue for G.729, because gain_corr_factor in it's case is always
584  greater than 1024, while in G.729D it can be even zero. */
585  gain_corr_factor = FFMAX(gain_corr_factor, 1024);
586  #ifndef G729_BITEXACT
587  gain_corr_factor >>= 1;
588  #endif
589  } else {
590  ctx->past_gain_pitch[0] = cb_gain_1st_8k[gc_1st_index][0] +
591  cb_gain_2nd_8k[gc_2nd_index][0];
592  gain_corr_factor = cb_gain_1st_8k[gc_1st_index][1] +
593  cb_gain_2nd_8k[gc_2nd_index][1];
594  }
595 
596  /* Decode the fixed-codebook gain. */
597  ctx->past_gain_code[0] = ff_acelp_decode_gain_code(&s->adsp, gain_corr_factor,
598  fc, MR_ENERGY,
599  ctx->quant_energy,
601  SUBFRAME_SIZE, 4);
602  #ifdef G729_BITEXACT
603  /*
604  This correction required to get bit-exact result with
605  reference code, because gain_corr_factor in G.729D is
606  two times larger than in original G.729.
607 
608  If bit-exact result is not issue then gain_corr_factor
609  can be simpler divided by 2 before call to g729_get_gain_code
610  instead of using correction below.
611  */
612  if (packet_type == FORMAT_G729D_6K4) {
613  gain_corr_factor >>= 1;
614  ctx->past_gain_code[0] >>= 1;
615  }
616  #endif
617  }
618  ff_acelp_update_past_gain(ctx->quant_energy, gain_corr_factor, 2, frame_erasure);
619 
620  /* Routine requires rounding to lowest. */
621  ff_acelp_interpolate(ctx->exc + i * SUBFRAME_SIZE,
622  ctx->exc + i * SUBFRAME_SIZE - pitch_delay_3x / 3,
624  (pitch_delay_3x % 3) << 1,
625  10, SUBFRAME_SIZE);
626 
627  ff_acelp_weighted_vector_sum(ctx->exc + i * SUBFRAME_SIZE,
628  ctx->exc + i * SUBFRAME_SIZE, fc,
629  (!ctx->was_periodic && frame_erasure) ? 0 : ctx->past_gain_pitch[0],
630  ( ctx->was_periodic && frame_erasure) ? 0 : ctx->past_gain_code[0],
631  1 << 13, 14, SUBFRAME_SIZE);
632 
633  memcpy(synth, ctx->syn_filter_data, 10 * sizeof(int16_t));
634 
636  synth+10,
637  &lp[i][1],
638  ctx->exc + i * SUBFRAME_SIZE,
639  SUBFRAME_SIZE,
640  10,
641  1,
642  0,
643  0x800))
644  /* Overflow occurred, downscale excitation signal... */
645  for (j = 0; j < 2 * SUBFRAME_SIZE + PITCH_DELAY_MAX + INTERPOL_LEN; j++)
646  ctx->exc_base[j] >>= 2;
647 
648  /* ... and make synthesis again. */
649  if (packet_type == FORMAT_G729D_6K4) {
650  int16_t exc_new[SUBFRAME_SIZE];
651 
652  ctx->onset = g729d_onset_decision(ctx->onset, ctx->past_gain_code);
654 
655  g729d_get_new_exc(exc_new, ctx->exc + i * SUBFRAME_SIZE, fc, ctx->voice_decision, ctx->past_gain_code[0], SUBFRAME_SIZE);
656 
658  synth+10,
659  &lp[i][1],
660  exc_new,
661  SUBFRAME_SIZE,
662  10,
663  0,
664  0,
665  0x800);
666  } else {
668  synth+10,
669  &lp[i][1],
670  ctx->exc + i * SUBFRAME_SIZE,
671  SUBFRAME_SIZE,
672  10,
673  0,
674  0,
675  0x800);
676  }
677  /* Save data (without postfilter) for use in next subframe. */
678  memcpy(ctx->syn_filter_data, synth+SUBFRAME_SIZE, 10 * sizeof(int16_t));
679 
680  /* Calculate gain of unfiltered signal for use in AGC. */
681  gain_before = 0;
682  for (j = 0; j < SUBFRAME_SIZE; j++)
683  gain_before += FFABS(synth[j+10]);
684 
685  /* Call postfilter and also update voicing decision for use in next frame. */
687  &s->adsp,
688  &ctx->ht_prev_data,
689  &is_periodic,
690  &lp[i][0],
691  pitch_delay_int[0],
692  ctx->residual,
693  ctx->res_filter_data,
694  ctx->pos_filter_data,
695  synth+10,
696  SUBFRAME_SIZE);
697 
698  /* Calculate gain of filtered signal for use in AGC. */
699  gain_after = 0;
700  for (j = 0; j < SUBFRAME_SIZE; j++)
701  gain_after += FFABS(synth[j+10]);
702 
704  gain_before,
705  gain_after,
706  synth+10,
707  SUBFRAME_SIZE,
708  ctx->gain_coeff);
709 
710  if (frame_erasure) {
712  } else {
713  ctx->pitch_delay_int_prev = pitch_delay_int[i];
714  }
715 
716  memcpy(synth+8, ctx->hpf_z, 2*sizeof(int16_t));
718  out_frame + i*SUBFRAME_SIZE,
719  ctx->hpf_f,
720  synth+10,
721  SUBFRAME_SIZE);
722  memcpy(ctx->hpf_z, synth+8+SUBFRAME_SIZE, 2*sizeof(int16_t));
723  }
724 
725  ctx->was_periodic = is_periodic;
726 
727  /* Save signal for use in next frame. */
728  memmove(ctx->exc_base, ctx->exc_base + 2 * SUBFRAME_SIZE, (PITCH_DELAY_MAX+INTERPOL_LEN)*sizeof(int16_t));
729 
730  buf += packet_type == FORMAT_G729_8K ? G729_8K_BLOCK_SIZE : G729D_6K4_BLOCK_SIZE;
731  ctx++;
732  }
733 
734  *got_frame_ptr = 1;
735  return packet_type == FORMAT_G729_8K ? (G729_8K_BLOCK_SIZE + (avctx->codec_id == AV_CODEC_ID_ACELP_KELVIN)) * avctx->channels : G729D_6K4_BLOCK_SIZE * avctx->channels;
736 }
737 
739 {
740  G729Context *s = avctx->priv_data;
742 
743  return 0;
744 }
745 
747  .name = "g729",
748  .long_name = NULL_IF_CONFIG_SMALL("G.729"),
749  .type = AVMEDIA_TYPE_AUDIO,
750  .id = AV_CODEC_ID_G729,
751  .priv_data_size = sizeof(G729Context),
752  .init = decoder_init,
753  .decode = decode_frame,
754  .close = decode_close,
755  .capabilities = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1,
756 };
757 
759  .name = "acelp.kelvin",
760  .long_name = NULL_IF_CONFIG_SMALL("Sipro ACELP.KELVIN"),
761  .type = AVMEDIA_TYPE_AUDIO,
763  .priv_data_size = sizeof(G729Context),
764  .init = decoder_init,
765  .decode = decode_frame,
766  .close = decode_close,
767  .capabilities = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1,
768 };
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
AVCodec ff_acelp_kelvin_decoder
Definition: g729dec.c:758
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
#define avpriv_request_sample(...)
int size
Definition: avcodec.h:1480
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:3483
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:71
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:2235
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:746
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:1479
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:738
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:3490
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:2247
#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
enum AVCodecID codec_id
Definition: avcodec.h:1577
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:1567
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1963
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:1026
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:1594
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:2228
#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:1456
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:983
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
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