FFmpeg
g723_1dec.c
Go to the documentation of this file.
1 /*
2  * G.723.1 compatible decoder
3  * Copyright (c) 2006 Benjamin Larsson
4  * Copyright (c) 2010 Mohamed Naufal Basheer
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 /**
24  * @file
25  * G.723.1 compatible decoder
26  */
27 
29 #include "libavutil/mem.h"
30 #include "libavutil/opt.h"
31 
32 #define BITSTREAM_READER_LE
33 #include "acelp_vectors.h"
34 #include "avcodec.h"
35 #include "celp_filters.h"
36 #include "celp_math.h"
37 #include "get_bits.h"
38 #include "internal.h"
39 #include "g723_1.h"
40 
41 #define CNG_RANDOM_SEED 12345
42 
43 /**
44  * Postfilter gain weighting factors scaled by 2^15
45  */
46 static const int16_t ppf_gain_weight[2] = {0x1800, 0x2000};
47 
48 static const int16_t pitch_contrib[340] = {
49  60, 0, 0, 2489, 60, 0, 0, 5217,
50  1, 6171, 0, 3953, 0, 10364, 1, 9357,
51  -1, 8843, 1, 9396, 0, 5794, -1, 10816,
52  2, 11606, -2, 12072, 0, 8616, 1, 12170,
53  0, 14440, 0, 7787, -1, 13721, 0, 18205,
54  0, 14471, 0, 15807, 1, 15275, 0, 13480,
55  -1, 18375, -1, 0, 1, 11194, -1, 13010,
56  1, 18836, -2, 20354, 1, 16233, -1, 0,
57  60, 0, 0, 12130, 0, 13385, 1, 17834,
58  1, 20875, 0, 21996, 1, 0, 1, 18277,
59  -1, 21321, 1, 13738, -1, 19094, -1, 20387,
60  -1, 0, 0, 21008, 60, 0, -2, 22807,
61  0, 15900, 1, 0, 0, 17989, -1, 22259,
62  1, 24395, 1, 23138, 0, 23948, 1, 22997,
63  2, 22604, -1, 25942, 0, 26246, 1, 25321,
64  0, 26423, 0, 24061, 0, 27247, 60, 0,
65  -1, 25572, 1, 23918, 1, 25930, 2, 26408,
66  -1, 19049, 1, 27357, -1, 24538, 60, 0,
67  -1, 25093, 0, 28549, 1, 0, 0, 22793,
68  -1, 25659, 0, 29377, 0, 30276, 0, 26198,
69  1, 22521, -1, 28919, 0, 27384, 1, 30162,
70  -1, 0, 0, 24237, -1, 30062, 0, 21763,
71  1, 30917, 60, 0, 0, 31284, 0, 29433,
72  1, 26821, 1, 28655, 0, 31327, 2, 30799,
73  1, 31389, 0, 32322, 1, 31760, -2, 31830,
74  0, 26936, -1, 31180, 1, 30875, 0, 27873,
75  -1, 30429, 1, 31050, 0, 0, 0, 31912,
76  1, 31611, 0, 31565, 0, 25557, 0, 31357,
77  60, 0, 1, 29536, 1, 28985, -1, 26984,
78  -1, 31587, 2, 30836, -2, 31133, 0, 30243,
79  -1, 30742, -1, 32090, 60, 0, 2, 30902,
80  60, 0, 0, 30027, 0, 29042, 60, 0,
81  0, 31756, 0, 24553, 0, 25636, -2, 30501,
82  60, 0, -1, 29617, 0, 30649, 60, 0,
83  0, 29274, 2, 30415, 0, 27480, 0, 31213,
84  -1, 28147, 0, 30600, 1, 31652, 2, 29068,
85  60, 0, 1, 28571, 1, 28730, 1, 31422,
86  0, 28257, 0, 24797, 60, 0, 0, 0,
87  60, 0, 0, 22105, 0, 27852, 60, 0,
88  60, 0, -1, 24214, 0, 24642, 0, 23305,
89  60, 0, 60, 0, 1, 22883, 0, 21601,
90  60, 0, 2, 25650, 60, 0, -2, 31253,
91  -2, 25144, 0, 17998
92 };
93 
94 /**
95  * Size of the MP-MLQ fixed excitation codebooks
96  */
97 static const int32_t max_pos[4] = {593775, 142506, 593775, 142506};
98 
99 /**
100  * 0.65^i (Zero part) and 0.75^i (Pole part) scaled by 2^15
101  */
102 static const int16_t postfilter_tbl[2][LPC_ORDER] = {
103  /* Zero */
104  {21299, 13844, 8999, 5849, 3802, 2471, 1606, 1044, 679, 441},
105  /* Pole */
106  {24576, 18432, 13824, 10368, 7776, 5832, 4374, 3281, 2460, 1845}
107 };
108 
109 static const int cng_adaptive_cb_lag[4] = { 1, 0, 1, 3 };
110 
111 static const int cng_filt[4] = { 273, 998, 499, 333 };
112 
113 static const int cng_bseg[3] = { 2048, 18432, 231233 };
114 
116 {
117  G723_1_Context *s = avctx->priv_data;
118 
120  if (avctx->channels < 1 || avctx->channels > 2) {
121  av_log(avctx, AV_LOG_ERROR, "Only mono and stereo are supported (requested channels: %d).\n", avctx->channels);
122  return AVERROR(EINVAL);
123  }
125  for (int ch = 0; ch < avctx->channels; ch++) {
126  G723_1_ChannelContext *p = &s->ch[ch];
127 
128  p->pf_gain = 1 << 12;
129 
130  memcpy(p->prev_lsp, dc_lsp, LPC_ORDER * sizeof(*p->prev_lsp));
131  memcpy(p->sid_lsp, dc_lsp, LPC_ORDER * sizeof(*p->sid_lsp));
132 
135  }
136 
137  return 0;
138 }
139 
140 /**
141  * Unpack the frame into parameters.
142  *
143  * @param p the context
144  * @param buf pointer to the input buffer
145  * @param buf_size size of the input buffer
146  */
148  int buf_size)
149 {
150  GetBitContext gb;
151  int ad_cb_len;
152  int temp, info_bits, i;
153  int ret;
154 
155  ret = init_get_bits8(&gb, buf, buf_size);
156  if (ret < 0)
157  return ret;
158 
159  /* Extract frame type and rate info */
160  info_bits = get_bits(&gb, 2);
161 
162  if (info_bits == 3) {
164  return 0;
165  }
166 
167  /* Extract 24 bit lsp indices, 8 bit for each band */
168  p->lsp_index[2] = get_bits(&gb, 8);
169  p->lsp_index[1] = get_bits(&gb, 8);
170  p->lsp_index[0] = get_bits(&gb, 8);
171 
172  if (info_bits == 2) {
174  p->subframe[0].amp_index = get_bits(&gb, 6);
175  return 0;
176  }
177 
178  /* Extract the info common to both rates */
179  p->cur_rate = info_bits ? RATE_5300 : RATE_6300;
181 
182  p->pitch_lag[0] = get_bits(&gb, 7);
183  if (p->pitch_lag[0] > 123) /* test if forbidden code */
184  return -1;
185  p->pitch_lag[0] += PITCH_MIN;
186  p->subframe[1].ad_cb_lag = get_bits(&gb, 2);
187 
188  p->pitch_lag[1] = get_bits(&gb, 7);
189  if (p->pitch_lag[1] > 123)
190  return -1;
191  p->pitch_lag[1] += PITCH_MIN;
192  p->subframe[3].ad_cb_lag = get_bits(&gb, 2);
193  p->subframe[0].ad_cb_lag = 1;
194  p->subframe[2].ad_cb_lag = 1;
195 
196  for (i = 0; i < SUBFRAMES; i++) {
197  /* Extract combined gain */
198  temp = get_bits(&gb, 12);
199  ad_cb_len = 170;
200  p->subframe[i].dirac_train = 0;
201  if (p->cur_rate == RATE_6300 && p->pitch_lag[i >> 1] < SUBFRAME_LEN - 2) {
202  p->subframe[i].dirac_train = temp >> 11;
203  temp &= 0x7FF;
204  ad_cb_len = 85;
205  }
206  p->subframe[i].ad_cb_gain = FASTDIV(temp, GAIN_LEVELS);
207  if (p->subframe[i].ad_cb_gain < ad_cb_len) {
208  p->subframe[i].amp_index = temp - p->subframe[i].ad_cb_gain *
209  GAIN_LEVELS;
210  } else {
211  return -1;
212  }
213  }
214 
215  p->subframe[0].grid_index = get_bits1(&gb);
216  p->subframe[1].grid_index = get_bits1(&gb);
217  p->subframe[2].grid_index = get_bits1(&gb);
218  p->subframe[3].grid_index = get_bits1(&gb);
219 
220  if (p->cur_rate == RATE_6300) {
221  skip_bits1(&gb); /* skip reserved bit */
222 
223  /* Compute pulse_pos index using the 13-bit combined position index */
224  temp = get_bits(&gb, 13);
225  p->subframe[0].pulse_pos = temp / 810;
226 
227  temp -= p->subframe[0].pulse_pos * 810;
228  p->subframe[1].pulse_pos = FASTDIV(temp, 90);
229 
230  temp -= p->subframe[1].pulse_pos * 90;
231  p->subframe[2].pulse_pos = FASTDIV(temp, 9);
232  p->subframe[3].pulse_pos = temp - p->subframe[2].pulse_pos * 9;
233 
234  p->subframe[0].pulse_pos = (p->subframe[0].pulse_pos << 16) +
235  get_bits(&gb, 16);
236  p->subframe[1].pulse_pos = (p->subframe[1].pulse_pos << 14) +
237  get_bits(&gb, 14);
238  p->subframe[2].pulse_pos = (p->subframe[2].pulse_pos << 16) +
239  get_bits(&gb, 16);
240  p->subframe[3].pulse_pos = (p->subframe[3].pulse_pos << 14) +
241  get_bits(&gb, 14);
242 
243  p->subframe[0].pulse_sign = get_bits(&gb, 6);
244  p->subframe[1].pulse_sign = get_bits(&gb, 5);
245  p->subframe[2].pulse_sign = get_bits(&gb, 6);
246  p->subframe[3].pulse_sign = get_bits(&gb, 5);
247  } else { /* 5300 bps */
248  p->subframe[0].pulse_pos = get_bits(&gb, 12);
249  p->subframe[1].pulse_pos = get_bits(&gb, 12);
250  p->subframe[2].pulse_pos = get_bits(&gb, 12);
251  p->subframe[3].pulse_pos = get_bits(&gb, 12);
252 
253  p->subframe[0].pulse_sign = get_bits(&gb, 4);
254  p->subframe[1].pulse_sign = get_bits(&gb, 4);
255  p->subframe[2].pulse_sign = get_bits(&gb, 4);
256  p->subframe[3].pulse_sign = get_bits(&gb, 4);
257  }
258 
259  return 0;
260 }
261 
262 /**
263  * Bitexact implementation of sqrt(val/2).
264  */
265 static int16_t square_root(unsigned val)
266 {
267  av_assert2(!(val & 0x80000000));
268 
269  return (ff_sqrt(val << 1) >> 1) & (~1);
270 }
271 
272 /**
273  * Generate fixed codebook excitation vector.
274  *
275  * @param vector decoded excitation vector
276  * @param subfrm current subframe
277  * @param cur_rate current bitrate
278  * @param pitch_lag closed loop pitch lag
279  * @param index current subframe index
280  */
281 static void gen_fcb_excitation(int16_t *vector, G723_1_Subframe *subfrm,
282  enum Rate cur_rate, int pitch_lag, int index)
283 {
284  int temp, i, j;
285 
286  memset(vector, 0, SUBFRAME_LEN * sizeof(*vector));
287 
288  if (cur_rate == RATE_6300) {
289  if (subfrm->pulse_pos >= max_pos[index])
290  return;
291 
292  /* Decode amplitudes and positions */
293  j = PULSE_MAX - pulses[index];
294  temp = subfrm->pulse_pos;
295  for (i = 0; i < SUBFRAME_LEN / GRID_SIZE; i++) {
296  temp -= ff_g723_1_combinatorial_table[j][i];
297  if (temp >= 0)
298  continue;
299  temp += ff_g723_1_combinatorial_table[j++][i];
300  if (subfrm->pulse_sign & (1 << (PULSE_MAX - j))) {
301  vector[subfrm->grid_index + GRID_SIZE * i] =
303  } else {
304  vector[subfrm->grid_index + GRID_SIZE * i] =
306  }
307  if (j == PULSE_MAX)
308  break;
309  }
310  if (subfrm->dirac_train == 1)
311  ff_g723_1_gen_dirac_train(vector, pitch_lag);
312  } else { /* 5300 bps */
313  int cb_gain = ff_g723_1_fixed_cb_gain[subfrm->amp_index];
314  int cb_shift = subfrm->grid_index;
315  int cb_sign = subfrm->pulse_sign;
316  int cb_pos = subfrm->pulse_pos;
317  int offset, beta, lag;
318 
319  for (i = 0; i < 8; i += 2) {
320  offset = ((cb_pos & 7) << 3) + cb_shift + i;
321  vector[offset] = (cb_sign & 1) ? cb_gain : -cb_gain;
322  cb_pos >>= 3;
323  cb_sign >>= 1;
324  }
325 
326  /* Enhance harmonic components */
327  lag = pitch_contrib[subfrm->ad_cb_gain << 1] + pitch_lag +
328  subfrm->ad_cb_lag - 1;
329  beta = pitch_contrib[(subfrm->ad_cb_gain << 1) + 1];
330 
331  if (lag < SUBFRAME_LEN - 2) {
332  for (i = lag; i < SUBFRAME_LEN; i++)
333  vector[i] += beta * vector[i - lag] >> 15;
334  }
335  }
336 }
337 
338 /**
339  * Estimate maximum auto-correlation around pitch lag.
340  *
341  * @param buf buffer with offset applied
342  * @param offset offset of the excitation vector
343  * @param ccr_max pointer to the maximum auto-correlation
344  * @param pitch_lag decoded pitch lag
345  * @param length length of autocorrelation
346  * @param dir forward lag(1) / backward lag(-1)
347  */
348 static int autocorr_max(const int16_t *buf, int offset, int *ccr_max,
349  int pitch_lag, int length, int dir)
350 {
351  int limit, ccr, lag = 0;
352  int i;
353 
354  pitch_lag = FFMIN(PITCH_MAX - 3, pitch_lag);
355  if (dir > 0)
356  limit = FFMIN(FRAME_LEN + PITCH_MAX - offset - length, pitch_lag + 3);
357  else
358  limit = pitch_lag + 3;
359 
360  for (i = pitch_lag - 3; i <= limit; i++) {
361  ccr = ff_g723_1_dot_product(buf, buf + dir * i, length);
362 
363  if (ccr > *ccr_max) {
364  *ccr_max = ccr;
365  lag = i;
366  }
367  }
368  return lag;
369 }
370 
371 /**
372  * Calculate pitch postfilter optimal and scaling gains.
373  *
374  * @param lag pitch postfilter forward/backward lag
375  * @param ppf pitch postfilter parameters
376  * @param cur_rate current bitrate
377  * @param tgt_eng target energy
378  * @param ccr cross-correlation
379  * @param res_eng residual energy
380  */
381 static void comp_ppf_gains(int lag, PPFParam *ppf, enum Rate cur_rate,
382  int tgt_eng, int ccr, int res_eng)
383 {
384  int pf_residual; /* square of postfiltered residual */
385  int temp1, temp2;
386 
387  ppf->index = lag;
388 
389  temp1 = tgt_eng * res_eng >> 1;
390  temp2 = ccr * ccr << 1;
391 
392  if (temp2 > temp1) {
393  if (ccr >= res_eng) {
394  ppf->opt_gain = ppf_gain_weight[cur_rate];
395  } else {
396  ppf->opt_gain = (ccr << 15) / res_eng *
397  ppf_gain_weight[cur_rate] >> 15;
398  }
399  /* pf_res^2 = tgt_eng + 2*ccr*gain + res_eng*gain^2 */
400  temp1 = (tgt_eng << 15) + (ccr * ppf->opt_gain << 1);
401  temp2 = (ppf->opt_gain * ppf->opt_gain >> 15) * res_eng;
402  pf_residual = av_sat_add32(temp1, temp2 + (1 << 15)) >> 16;
403 
404  if (tgt_eng >= pf_residual << 1) {
405  temp1 = 0x7fff;
406  } else {
407  temp1 = (tgt_eng << 14) / pf_residual;
408  }
409 
410  /* scaling_gain = sqrt(tgt_eng/pf_res^2) */
411  ppf->sc_gain = square_root(temp1 << 16);
412  } else {
413  ppf->opt_gain = 0;
414  ppf->sc_gain = 0x7fff;
415  }
416 
417  ppf->opt_gain = av_clip_int16(ppf->opt_gain * ppf->sc_gain >> 15);
418 }
419 
420 /**
421  * Calculate pitch postfilter parameters.
422  *
423  * @param p the context
424  * @param offset offset of the excitation vector
425  * @param pitch_lag decoded pitch lag
426  * @param ppf pitch postfilter parameters
427  * @param cur_rate current bitrate
428  */
429 static void comp_ppf_coeff(G723_1_ChannelContext *p, int offset, int pitch_lag,
430  PPFParam *ppf, enum Rate cur_rate)
431 {
432 
433  int16_t scale;
434  int i;
435  int temp1, temp2;
436 
437  /*
438  * 0 - target energy
439  * 1 - forward cross-correlation
440  * 2 - forward residual energy
441  * 3 - backward cross-correlation
442  * 4 - backward residual energy
443  */
444  int energy[5] = {0, 0, 0, 0, 0};
445  int16_t *buf = p->audio + LPC_ORDER + offset;
446  int fwd_lag = autocorr_max(buf, offset, &energy[1], pitch_lag,
447  SUBFRAME_LEN, 1);
448  int back_lag = autocorr_max(buf, offset, &energy[3], pitch_lag,
449  SUBFRAME_LEN, -1);
450 
451  ppf->index = 0;
452  ppf->opt_gain = 0;
453  ppf->sc_gain = 0x7fff;
454 
455  /* Case 0, Section 3.6 */
456  if (!back_lag && !fwd_lag)
457  return;
458 
459  /* Compute target energy */
460  energy[0] = ff_g723_1_dot_product(buf, buf, SUBFRAME_LEN);
461 
462  /* Compute forward residual energy */
463  if (fwd_lag)
464  energy[2] = ff_g723_1_dot_product(buf + fwd_lag, buf + fwd_lag,
465  SUBFRAME_LEN);
466 
467  /* Compute backward residual energy */
468  if (back_lag)
469  energy[4] = ff_g723_1_dot_product(buf - back_lag, buf - back_lag,
470  SUBFRAME_LEN);
471 
472  /* Normalize and shorten */
473  temp1 = 0;
474  for (i = 0; i < 5; i++)
475  temp1 = FFMAX(energy[i], temp1);
476 
477  scale = ff_g723_1_normalize_bits(temp1, 31);
478  for (i = 0; i < 5; i++)
479  energy[i] = (energy[i] << scale) >> 16;
480 
481  if (fwd_lag && !back_lag) { /* Case 1 */
482  comp_ppf_gains(fwd_lag, ppf, cur_rate, energy[0], energy[1],
483  energy[2]);
484  } else if (!fwd_lag) { /* Case 2 */
485  comp_ppf_gains(-back_lag, ppf, cur_rate, energy[0], energy[3],
486  energy[4]);
487  } else { /* Case 3 */
488 
489  /*
490  * Select the largest of energy[1]^2/energy[2]
491  * and energy[3]^2/energy[4]
492  */
493  temp1 = energy[4] * ((energy[1] * energy[1] + (1 << 14)) >> 15);
494  temp2 = energy[2] * ((energy[3] * energy[3] + (1 << 14)) >> 15);
495  if (temp1 >= temp2) {
496  comp_ppf_gains(fwd_lag, ppf, cur_rate, energy[0], energy[1],
497  energy[2]);
498  } else {
499  comp_ppf_gains(-back_lag, ppf, cur_rate, energy[0], energy[3],
500  energy[4]);
501  }
502  }
503 }
504 
505 /**
506  * Classify frames as voiced/unvoiced.
507  *
508  * @param p the context
509  * @param pitch_lag decoded pitch_lag
510  * @param exc_eng excitation energy estimation
511  * @param scale scaling factor of exc_eng
512  *
513  * @return residual interpolation index if voiced, 0 otherwise
514  */
515 static int comp_interp_index(G723_1_ChannelContext *p, int pitch_lag,
516  int *exc_eng, int *scale)
517 {
518  int offset = PITCH_MAX + 2 * SUBFRAME_LEN;
519  int16_t *buf = p->audio + LPC_ORDER;
520 
521  int index, ccr, tgt_eng, best_eng, temp;
522 
524  buf += offset;
525 
526  /* Compute maximum backward cross-correlation */
527  ccr = 0;
528  index = autocorr_max(buf, offset, &ccr, pitch_lag, SUBFRAME_LEN * 2, -1);
529  ccr = av_sat_add32(ccr, 1 << 15) >> 16;
530 
531  /* Compute target energy */
532  tgt_eng = ff_g723_1_dot_product(buf, buf, SUBFRAME_LEN * 2);
533  *exc_eng = av_sat_add32(tgt_eng, 1 << 15) >> 16;
534 
535  if (ccr <= 0)
536  return 0;
537 
538  /* Compute best energy */
539  best_eng = ff_g723_1_dot_product(buf - index, buf - index,
540  SUBFRAME_LEN * 2);
541  best_eng = av_sat_add32(best_eng, 1 << 15) >> 16;
542 
543  temp = best_eng * *exc_eng >> 3;
544 
545  if (temp < ccr * ccr) {
546  return index;
547  } else
548  return 0;
549 }
550 
551 /**
552  * Perform residual interpolation based on frame classification.
553  *
554  * @param buf decoded excitation vector
555  * @param out output vector
556  * @param lag decoded pitch lag
557  * @param gain interpolated gain
558  * @param rseed seed for random number generator
559  */
560 static void residual_interp(int16_t *buf, int16_t *out, int lag,
561  int gain, int *rseed)
562 {
563  int i;
564  if (lag) { /* Voiced */
565  int16_t *vector_ptr = buf + PITCH_MAX;
566  /* Attenuate */
567  for (i = 0; i < lag; i++)
568  out[i] = vector_ptr[i - lag] * 3 >> 2;
569  av_memcpy_backptr((uint8_t*)(out + lag), lag * sizeof(*out),
570  (FRAME_LEN - lag) * sizeof(*out));
571  } else { /* Unvoiced */
572  for (i = 0; i < FRAME_LEN; i++) {
573  *rseed = (int16_t)(*rseed * 521 + 259);
574  out[i] = gain * *rseed >> 15;
575  }
576  memset(buf, 0, (FRAME_LEN + PITCH_MAX) * sizeof(*buf));
577  }
578 }
579 
580 /**
581  * Perform IIR filtering.
582  *
583  * @param fir_coef FIR coefficients
584  * @param iir_coef IIR coefficients
585  * @param src source vector
586  * @param dest destination vector
587  * @param width width of the output, 16 bits(0) / 32 bits(1)
588  */
589 #define iir_filter(fir_coef, iir_coef, src, dest, width)\
590 {\
591  int m, n;\
592  int res_shift = 16 & ~-(width);\
593  int in_shift = 16 - res_shift;\
594 \
595  for (m = 0; m < SUBFRAME_LEN; m++) {\
596  int64_t filter = 0;\
597  for (n = 1; n <= LPC_ORDER; n++) {\
598  filter -= (fir_coef)[n - 1] * (src)[m - n] -\
599  (iir_coef)[n - 1] * ((dest)[m - n] >> in_shift);\
600  }\
601 \
602  (dest)[m] = av_clipl_int32(((src)[m] * 65536) + (filter * 8) +\
603  (1 << 15)) >> res_shift;\
604  }\
605 }
606 
607 /**
608  * Adjust gain of postfiltered signal.
609  *
610  * @param p the context
611  * @param buf postfiltered output vector
612  * @param energy input energy coefficient
613  */
614 static void gain_scale(G723_1_ChannelContext *p, int16_t * buf, int energy)
615 {
616  int num, denom, gain, bits1, bits2;
617  int i;
618 
619  num = energy;
620  denom = 0;
621  for (i = 0; i < SUBFRAME_LEN; i++) {
622  int temp = buf[i] >> 2;
623  temp *= temp;
624  denom = av_sat_dadd32(denom, temp);
625  }
626 
627  if (num && denom) {
628  bits1 = ff_g723_1_normalize_bits(num, 31);
629  bits2 = ff_g723_1_normalize_bits(denom, 31);
630  num = num << bits1 >> 1;
631  denom <<= bits2;
632 
633  bits2 = 5 + bits1 - bits2;
634  bits2 = av_clip_uintp2(bits2, 5);
635 
636  gain = (num >> 1) / (denom >> 16);
637  gain = square_root(gain << 16 >> bits2);
638  } else {
639  gain = 1 << 12;
640  }
641 
642  for (i = 0; i < SUBFRAME_LEN; i++) {
643  p->pf_gain = (15 * p->pf_gain + gain + (1 << 3)) >> 4;
644  buf[i] = av_clip_int16((buf[i] * (p->pf_gain + (p->pf_gain >> 4)) +
645  (1 << 10)) >> 11);
646  }
647 }
648 
649 /**
650  * Perform formant filtering.
651  *
652  * @param p the context
653  * @param lpc quantized lpc coefficients
654  * @param buf input buffer
655  * @param dst output buffer
656  */
657 static void formant_postfilter(G723_1_ChannelContext *p, int16_t *lpc,
658  int16_t *buf, int16_t *dst)
659 {
660  int16_t filter_coef[2][LPC_ORDER];
661  int filter_signal[LPC_ORDER + FRAME_LEN], *signal_ptr;
662  int i, j, k;
663 
664  memcpy(buf, p->fir_mem, LPC_ORDER * sizeof(*buf));
665  memcpy(filter_signal, p->iir_mem, LPC_ORDER * sizeof(*filter_signal));
666 
667  for (i = LPC_ORDER, j = 0; j < SUBFRAMES; i += SUBFRAME_LEN, j++) {
668  for (k = 0; k < LPC_ORDER; k++) {
669  filter_coef[0][k] = (-lpc[k] * postfilter_tbl[0][k] +
670  (1 << 14)) >> 15;
671  filter_coef[1][k] = (-lpc[k] * postfilter_tbl[1][k] +
672  (1 << 14)) >> 15;
673  }
674  iir_filter(filter_coef[0], filter_coef[1], buf + i, filter_signal + i, 1);
675  lpc += LPC_ORDER;
676  }
677 
678  memcpy(p->fir_mem, buf + FRAME_LEN, LPC_ORDER * sizeof(int16_t));
679  memcpy(p->iir_mem, filter_signal + FRAME_LEN, LPC_ORDER * sizeof(int));
680 
681  buf += LPC_ORDER;
682  signal_ptr = filter_signal + LPC_ORDER;
683  for (i = 0; i < SUBFRAMES; i++) {
684  int temp;
685  int auto_corr[2];
686  int scale, energy;
687 
688  /* Normalize */
689  scale = ff_g723_1_scale_vector(dst, buf, SUBFRAME_LEN);
690 
691  /* Compute auto correlation coefficients */
692  auto_corr[0] = ff_g723_1_dot_product(dst, dst + 1, SUBFRAME_LEN - 1);
693  auto_corr[1] = ff_g723_1_dot_product(dst, dst, SUBFRAME_LEN);
694 
695  /* Compute reflection coefficient */
696  temp = auto_corr[1] >> 16;
697  if (temp) {
698  temp = (auto_corr[0] >> 2) / temp;
699  }
700  p->reflection_coef = (3 * p->reflection_coef + temp + 2) >> 2;
701  temp = -p->reflection_coef >> 1 & ~3;
702 
703  /* Compensation filter */
704  for (j = 0; j < SUBFRAME_LEN; j++) {
705  dst[j] = av_sat_dadd32(signal_ptr[j],
706  (signal_ptr[j - 1] >> 16) * temp) >> 16;
707  }
708 
709  /* Compute normalized signal energy */
710  temp = 2 * scale + 4;
711  if (temp < 0) {
712  energy = av_clipl_int32((int64_t)auto_corr[1] << -temp);
713  } else
714  energy = auto_corr[1] >> temp;
715 
716  gain_scale(p, dst, energy);
717 
718  buf += SUBFRAME_LEN;
719  signal_ptr += SUBFRAME_LEN;
720  dst += SUBFRAME_LEN;
721  }
722 }
723 
724 static int sid_gain_to_lsp_index(int gain)
725 {
726  if (gain < 0x10)
727  return gain << 6;
728  else if (gain < 0x20)
729  return gain - 8 << 7;
730  else
731  return gain - 20 << 8;
732 }
733 
734 static inline int cng_rand(int *state, int base)
735 {
736  *state = (*state * 521 + 259) & 0xFFFF;
737  return (*state & 0x7FFF) * base >> 15;
738 }
739 
741 {
742  int i, shift, seg, seg2, t, val, val_add, x, y;
743 
744  shift = 16 - p->cur_gain * 2;
745  if (shift > 0) {
746  if (p->sid_gain == 0) {
747  t = 0;
748  } else if (shift >= 31 || (int32_t)((uint32_t)p->sid_gain << shift) >> shift != p->sid_gain) {
749  if (p->sid_gain < 0) t = INT32_MIN;
750  else t = INT32_MAX;
751  } else
752  t = p->sid_gain * (1 << shift);
753  } else if(shift < -31) {
754  t = (p->sid_gain < 0) ? -1 : 0;
755  }else
756  t = p->sid_gain >> -shift;
757  x = av_clipl_int32(t * (int64_t)cng_filt[0] >> 16);
758 
759  if (x >= cng_bseg[2])
760  return 0x3F;
761 
762  if (x >= cng_bseg[1]) {
763  shift = 4;
764  seg = 3;
765  } else {
766  shift = 3;
767  seg = (x >= cng_bseg[0]);
768  }
769  seg2 = FFMIN(seg, 3);
770 
771  val = 1 << shift;
772  val_add = val >> 1;
773  for (i = 0; i < shift; i++) {
774  t = seg * 32 + (val << seg2);
775  t *= t;
776  if (x >= t)
777  val += val_add;
778  else
779  val -= val_add;
780  val_add >>= 1;
781  }
782 
783  t = seg * 32 + (val << seg2);
784  y = t * t - x;
785  if (y <= 0) {
786  t = seg * 32 + (val + 1 << seg2);
787  t = t * t - x;
788  val = (seg2 - 1) * 16 + val;
789  if (t >= y)
790  val++;
791  } else {
792  t = seg * 32 + (val - 1 << seg2);
793  t = t * t - x;
794  val = (seg2 - 1) * 16 + val;
795  if (t >= y)
796  val--;
797  }
798 
799  return val;
800 }
801 
803 {
804  int i, j, idx, t;
805  int off[SUBFRAMES];
806  int signs[SUBFRAMES / 2 * 11], pos[SUBFRAMES / 2 * 11];
807  int tmp[SUBFRAME_LEN * 2];
808  int16_t *vector_ptr;
809  int64_t sum;
810  int b0, c, delta, x, shift;
811 
812  p->pitch_lag[0] = cng_rand(&p->cng_random_seed, 21) + 123;
813  p->pitch_lag[1] = cng_rand(&p->cng_random_seed, 19) + 123;
814 
815  for (i = 0; i < SUBFRAMES; i++) {
816  p->subframe[i].ad_cb_gain = cng_rand(&p->cng_random_seed, 50) + 1;
818  }
819 
820  for (i = 0; i < SUBFRAMES / 2; i++) {
821  t = cng_rand(&p->cng_random_seed, 1 << 13);
822  off[i * 2] = t & 1;
823  off[i * 2 + 1] = ((t >> 1) & 1) + SUBFRAME_LEN;
824  t >>= 2;
825  for (j = 0; j < 11; j++) {
826  signs[i * 11 + j] = ((t & 1) * 2 - 1) * (1 << 14);
827  t >>= 1;
828  }
829  }
830 
831  idx = 0;
832  for (i = 0; i < SUBFRAMES; i++) {
833  for (j = 0; j < SUBFRAME_LEN / 2; j++)
834  tmp[j] = j;
835  t = SUBFRAME_LEN / 2;
836  for (j = 0; j < pulses[i]; j++, idx++) {
837  int idx2 = cng_rand(&p->cng_random_seed, t);
838 
839  pos[idx] = tmp[idx2] * 2 + off[i];
840  tmp[idx2] = tmp[--t];
841  }
842  }
843 
844  vector_ptr = p->audio + LPC_ORDER;
845  memcpy(vector_ptr, p->prev_excitation,
846  PITCH_MAX * sizeof(*p->excitation));
847  for (i = 0; i < SUBFRAMES; i += 2) {
848  ff_g723_1_gen_acb_excitation(vector_ptr, vector_ptr,
849  p->pitch_lag[i >> 1], &p->subframe[i],
850  p->cur_rate);
852  vector_ptr + SUBFRAME_LEN,
853  p->pitch_lag[i >> 1], &p->subframe[i + 1],
854  p->cur_rate);
855 
856  t = 0;
857  for (j = 0; j < SUBFRAME_LEN * 2; j++)
858  t |= FFABS(vector_ptr[j]);
859  t = FFMIN(t, 0x7FFF);
860  if (!t) {
861  shift = 0;
862  } else {
863  shift = -10 + av_log2(t);
864  if (shift < -2)
865  shift = -2;
866  }
867  sum = 0;
868  if (shift < 0) {
869  for (j = 0; j < SUBFRAME_LEN * 2; j++) {
870  t = vector_ptr[j] * (1 << -shift);
871  sum += t * t;
872  tmp[j] = t;
873  }
874  } else {
875  for (j = 0; j < SUBFRAME_LEN * 2; j++) {
876  t = vector_ptr[j] >> shift;
877  sum += t * t;
878  tmp[j] = t;
879  }
880  }
881 
882  b0 = 0;
883  for (j = 0; j < 11; j++)
884  b0 += tmp[pos[(i / 2) * 11 + j]] * signs[(i / 2) * 11 + j];
885  b0 = b0 * 2 * 2979LL + (1 << 29) >> 30; // approximated division by 11
886 
887  c = p->cur_gain * (p->cur_gain * SUBFRAME_LEN >> 5);
888  if (shift * 2 + 3 >= 0)
889  c >>= shift * 2 + 3;
890  else
891  c <<= -(shift * 2 + 3);
892  c = (av_clipl_int32(sum << 1) - c) * 2979LL >> 15;
893 
894  delta = b0 * b0 * 2 - c;
895  if (delta <= 0) {
896  x = -b0;
897  } else {
898  delta = square_root(delta);
899  x = delta - b0;
900  t = delta + b0;
901  if (FFABS(t) < FFABS(x))
902  x = -t;
903  }
904  shift++;
905  if (shift < 0)
906  x >>= -shift;
907  else
908  x *= 1 << shift;
909  x = av_clip(x, -10000, 10000);
910 
911  for (j = 0; j < 11; j++) {
912  idx = (i / 2) * 11 + j;
913  vector_ptr[pos[idx]] = av_clip_int16(vector_ptr[pos[idx]] +
914  (x * signs[idx] >> 15));
915  }
916 
917  /* copy decoded data to serve as a history for the next decoded subframes */
918  memcpy(vector_ptr + PITCH_MAX, vector_ptr,
919  sizeof(*vector_ptr) * SUBFRAME_LEN * 2);
920  vector_ptr += SUBFRAME_LEN * 2;
921  }
922  /* Save the excitation for the next frame */
923  memcpy(p->prev_excitation, p->audio + LPC_ORDER + FRAME_LEN,
924  PITCH_MAX * sizeof(*p->excitation));
925 }
926 
927 static int g723_1_decode_frame(AVCodecContext *avctx, void *data,
928  int *got_frame_ptr, AVPacket *avpkt)
929 {
930  G723_1_Context *s = avctx->priv_data;
931  AVFrame *frame = data;
932  const uint8_t *buf = avpkt->data;
933  int buf_size = avpkt->size;
934  int dec_mode = buf[0] & 3;
935 
936  PPFParam ppf[SUBFRAMES];
937  int16_t cur_lsp[LPC_ORDER];
938  int16_t lpc[SUBFRAMES * LPC_ORDER];
939  int16_t acb_vector[SUBFRAME_LEN];
940  int16_t *out;
941  int bad_frame = 0, i, j, ret;
942 
943  if (buf_size < frame_size[dec_mode] * avctx->channels) {
944  if (buf_size)
945  av_log(avctx, AV_LOG_WARNING,
946  "Expected %d bytes, got %d - skipping packet\n",
947  frame_size[dec_mode], buf_size);
948  *got_frame_ptr = 0;
949  return buf_size;
950  }
951 
952  frame->nb_samples = FRAME_LEN;
953  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
954  return ret;
955 
956  for (int ch = 0; ch < avctx->channels; ch++) {
957  G723_1_ChannelContext *p = &s->ch[ch];
958  int16_t *audio = p->audio;
959 
960  if (unpack_bitstream(p, buf + ch * (buf_size / avctx->channels),
961  buf_size / avctx->channels) < 0) {
962  bad_frame = 1;
963  if (p->past_frame_type == ACTIVE_FRAME)
965  else
967  }
968 
969  out = (int16_t *)frame->extended_data[ch];
970 
971  if (p->cur_frame_type == ACTIVE_FRAME) {
972  if (!bad_frame)
973  p->erased_frames = 0;
974  else if (p->erased_frames != 3)
975  p->erased_frames++;
976 
977  ff_g723_1_inverse_quant(cur_lsp, p->prev_lsp, p->lsp_index, bad_frame);
978  ff_g723_1_lsp_interpolate(lpc, cur_lsp, p->prev_lsp);
979 
980  /* Save the lsp_vector for the next frame */
981  memcpy(p->prev_lsp, cur_lsp, LPC_ORDER * sizeof(*p->prev_lsp));
982 
983  /* Generate the excitation for the frame */
984  memcpy(p->excitation, p->prev_excitation,
985  PITCH_MAX * sizeof(*p->excitation));
986  if (!p->erased_frames) {
987  int16_t *vector_ptr = p->excitation + PITCH_MAX;
988 
989  /* Update interpolation gain memory */
991  p->subframe[3].amp_index) >> 1];
992  for (i = 0; i < SUBFRAMES; i++) {
993  gen_fcb_excitation(vector_ptr, &p->subframe[i], p->cur_rate,
994  p->pitch_lag[i >> 1], i);
995  ff_g723_1_gen_acb_excitation(acb_vector,
996  &p->excitation[SUBFRAME_LEN * i],
997  p->pitch_lag[i >> 1],
998  &p->subframe[i], p->cur_rate);
999  /* Get the total excitation */
1000  for (j = 0; j < SUBFRAME_LEN; j++) {
1001  int v = av_clip_int16(vector_ptr[j] * 2);
1002  vector_ptr[j] = av_clip_int16(v + acb_vector[j]);
1003  }
1004  vector_ptr += SUBFRAME_LEN;
1005  }
1006 
1007  vector_ptr = p->excitation + PITCH_MAX;
1008 
1010  &p->sid_gain, &p->cur_gain);
1011 
1012  /* Perform pitch postfiltering */
1013  if (s->postfilter) {
1014  i = PITCH_MAX;
1015  for (j = 0; j < SUBFRAMES; i += SUBFRAME_LEN, j++)
1016  comp_ppf_coeff(p, i, p->pitch_lag[j >> 1],
1017  ppf + j, p->cur_rate);
1018 
1019  for (i = 0, j = 0; j < SUBFRAMES; i += SUBFRAME_LEN, j++)
1021  vector_ptr + i,
1022  vector_ptr + i + ppf[j].index,
1023  ppf[j].sc_gain,
1024  ppf[j].opt_gain,
1025  1 << 14, 15, SUBFRAME_LEN);
1026  } else {
1027  audio = vector_ptr - LPC_ORDER;
1028  }
1029 
1030  /* Save the excitation for the next frame */
1031  memcpy(p->prev_excitation, p->excitation + FRAME_LEN,
1032  PITCH_MAX * sizeof(*p->excitation));
1033  } else {
1034  p->interp_gain = (p->interp_gain * 3 + 2) >> 2;
1035  if (p->erased_frames == 3) {
1036  /* Mute output */
1037  memset(p->excitation, 0,
1038  (FRAME_LEN + PITCH_MAX) * sizeof(*p->excitation));
1039  memset(p->prev_excitation, 0,
1040  PITCH_MAX * sizeof(*p->excitation));
1041  memset(frame->data[0], 0,
1042  (FRAME_LEN + LPC_ORDER) * sizeof(int16_t));
1043  } else {
1044  int16_t *buf = p->audio + LPC_ORDER;
1045 
1046  /* Regenerate frame */
1048  p->interp_gain, &p->random_seed);
1049 
1050  /* Save the excitation for the next frame */
1051  memcpy(p->prev_excitation, buf + (FRAME_LEN - PITCH_MAX),
1052  PITCH_MAX * sizeof(*p->excitation));
1053  }
1054  }
1056  } else {
1057  if (p->cur_frame_type == SID_FRAME) {
1060  } else if (p->past_frame_type == ACTIVE_FRAME) {
1061  p->sid_gain = estimate_sid_gain(p);
1062  }
1063 
1064  if (p->past_frame_type == ACTIVE_FRAME)
1065  p->cur_gain = p->sid_gain;
1066  else
1067  p->cur_gain = (p->cur_gain * 7 + p->sid_gain) >> 3;
1068  generate_noise(p);
1070  /* Save the lsp_vector for the next frame */
1071  memcpy(p->prev_lsp, p->sid_lsp, LPC_ORDER * sizeof(*p->prev_lsp));
1072  }
1073 
1075 
1076  memcpy(p->audio, p->synth_mem, LPC_ORDER * sizeof(*p->audio));
1077  for (i = LPC_ORDER, j = 0; j < SUBFRAMES; i += SUBFRAME_LEN, j++)
1078  ff_celp_lp_synthesis_filter(p->audio + i, &lpc[j * LPC_ORDER],
1079  audio + i, SUBFRAME_LEN, LPC_ORDER,
1080  0, 1, 1 << 12);
1081  memcpy(p->synth_mem, p->audio + FRAME_LEN, LPC_ORDER * sizeof(*p->audio));
1082 
1083  if (s->postfilter) {
1084  formant_postfilter(p, lpc, p->audio, out);
1085  } else { // if output is not postfiltered it should be scaled by 2
1086  for (i = 0; i < FRAME_LEN; i++)
1087  out[i] = av_clip_int16(2 * p->audio[LPC_ORDER + i]);
1088  }
1089  }
1090 
1091  *got_frame_ptr = 1;
1092 
1093  return frame_size[dec_mode] * avctx->channels;
1094 }
1095 
1096 #define OFFSET(x) offsetof(G723_1_Context, x)
1097 #define AD AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM
1098 
1099 static const AVOption options[] = {
1100  { "postfilter", "enable postfilter", OFFSET(postfilter), AV_OPT_TYPE_BOOL,
1101  { .i64 = 1 }, 0, 1, AD },
1102  { NULL }
1103 };
1104 
1105 
1106 static const AVClass g723_1dec_class = {
1107  .class_name = "G.723.1 decoder",
1108  .item_name = av_default_item_name,
1109  .option = options,
1110  .version = LIBAVUTIL_VERSION_INT,
1111 };
1112 
1114  .name = "g723_1",
1115  .long_name = NULL_IF_CONFIG_SMALL("G.723.1"),
1116  .type = AVMEDIA_TYPE_AUDIO,
1117  .id = AV_CODEC_ID_G723_1,
1118  .priv_data_size = sizeof(G723_1_Context),
1121  .capabilities = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1,
1122  .priv_class = &g723_1dec_class,
1123 };
static void comp_ppf_gains(int lag, PPFParam *ppf, enum Rate cur_rate, int tgt_eng, int ccr, int res_eng)
Calculate pitch postfilter optimal and scaling gains.
Definition: g723_1dec.c:381
int16_t excitation[PITCH_MAX+FRAME_LEN+4]
Definition: g723_1.h:131
#define NULL
Definition: coverity.c:32
static int shift(int a, int b)
Definition: sonic.c:82
int dirac_train
Definition: g723_1.h:83
#define av_clip_uintp2
Definition: common.h:146
This structure describes decoded (raw) audio or video data.
Definition: frame.h:314
int ad_cb_gain
Definition: g723_1.h:82
AVOption.
Definition: opt.h:248
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
const int16_t ff_g723_1_fixed_cb_gain[GAIN_LEVELS]
Definition: g723_1.c:453
static void gen_fcb_excitation(int16_t *vector, G723_1_Subframe *subfrm, enum Rate cur_rate, int pitch_lag, int index)
Generate fixed codebook excitation vector.
Definition: g723_1dec.c:281
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:200
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
Memory handling functions.
else temp
Definition: vf_mcdeint.c:256
G723_1_Subframe subframe[4]
Definition: g723_1.h:120
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
G723.1 unpacked data subframe.
Definition: g723_1.h:80
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
static const AVClass g723_1dec_class
Definition: g723_1dec.c:1106
static const int8_t pulses[4]
Number of non-zero pulses in the MP-MLQ excitation.
Definition: g723_1.h:260
static const int32_t max_pos[4]
Size of the MP-MLQ fixed excitation codebooks.
Definition: g723_1dec.c:97
int size
Definition: packet.h:364
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
int16_t audio[FRAME_LEN+LPC_ORDER+PITCH_MAX+4]
Definition: g723_1.h:145
int av_log2(unsigned v)
Definition: intmath.c:26
static const int16_t postfilter_tbl[2][LPC_ORDER]
0.65^i (Zero part) and 0.75^i (Pole part) scaled by 2^15
Definition: g723_1dec.c:102
static void residual_interp(int16_t *buf, int16_t *out, int lag, int gain, int *rseed)
Perform residual interpolation based on frame classification.
Definition: g723_1dec.c:560
static void formant_postfilter(G723_1_ChannelContext *p, int16_t *lpc, int16_t *buf, int16_t *dst)
Perform formant filtering.
Definition: g723_1dec.c:657
#define AV_CH_LAYOUT_STEREO
AVCodec.
Definition: codec.h:190
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
static int estimate_sid_gain(G723_1_ChannelContext *p)
Definition: g723_1dec.c:740
#define PITCH_MIN
Definition: g723_1.h:43
static void postfilter(AMRContext *p, float *lpc, float *buf_out)
Perform adaptive post-filtering to enhance the quality of the speech.
Definition: amrnbdec.c:904
uint8_t base
Definition: vp3data.h:141
static const int cng_adaptive_cb_lag[4]
Definition: g723_1dec.c:109
#define FRAME_LEN
Definition: g723_1.h:37
uint8_t lsp_index[LSP_BANDS]
Definition: g723_1.h:124
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
void ff_g723_1_inverse_quant(int16_t *cur_lsp, int16_t *prev_lsp, uint8_t *lsp_index, int bad_frame)
Perform inverse quantization of LSP frequencies.
Definition: g723_1.c:1272
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1199
uint8_t
#define av_cold
Definition: attributes.h:88
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
float delta
AVOptions.
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
#define LPC_ORDER
Definition: g723_1.h:40
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
Rate
G723.1 rate values.
Definition: g723_1.h:72
int pulse_sign
Definition: g723_1.h:84
static void generate_noise(G723_1_ChannelContext *p)
Definition: g723_1dec.c:802
#define av_clip
Definition: common.h:122
uint8_t * data
Definition: packet.h:363
static const uint8_t bits2[81]
Definition: aactab.c:159
void av_memcpy_backptr(uint8_t *dst, int back, int cnt)
Overlapping memcpy() implementation.
Definition: mem.c:428
bitstream reader API header.
void ff_g723_1_lsp_interpolate(int16_t *lpc, int16_t *cur_lsp, int16_t *prev_lsp)
Quantize LSP frequencies by interpolation and convert them to the corresponding LPC coefficients...
Definition: g723_1.c:1251
#define GRID_SIZE
Definition: g723_1.h:46
static struct @321 state
int pf_gain
formant postfilter gain scaling unit memory
Definition: g723_1.h:143
#define av_log(a,...)
#define ff_sqrt
Definition: mathops.h:206
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
int ff_g723_1_normalize_bits(int num, int width)
Calculate the number of left-shifts required for normalizing the input.
Definition: g723_1.c:1120
int amp_index
Definition: g723_1.h:86
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:115
void ff_g723_1_gen_dirac_train(int16_t *buf, int pitch_lag)
Generate a train of dirac functions with period as pitch lag.
Definition: g723_1.c:1145
unsigned int pos
Definition: spdifenc.c:410
#define av_clip_int16
Definition: common.h:137
GLsizei GLsizei * length
Definition: opengl_enc.c:114
int grid_index
Definition: g723_1.h:85
const char * name
Name of the codec implementation.
Definition: codec.h:197
#define FFMAX(a, b)
Definition: common.h:103
static const int cng_bseg[3]
Definition: g723_1dec.c:113
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1242
void ff_g723_1_gen_acb_excitation(int16_t *vector, int16_t *prev_excitation, int pitch_lag, G723_1_Subframe *subfrm, enum Rate cur_rate)
Generate adaptive codebook excitation.
Definition: g723_1.c:1157
enum FrameType past_frame_type
Definition: g723_1.h:122
#define PITCH_MAX
Definition: g723_1.h:44
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.
audio channel layout utility functions
#define FFMIN(a, b)
Definition: common.h:105
AVCodec ff_g723_1_decoder
Definition: g723_1dec.c:1113
#define av_sat_add32
Definition: common.h:152
int32_t
static double b0(void *priv, double x, double y)
Definition: vf_xfade.c:1664
int ff_g723_1_dot_product(const int16_t *a, const int16_t *b, int length)
Definition: g723_1.c:1125
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
#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
#define OFFSET(x)
Definition: g723_1dec.c:1096
int index
postfilter backward/forward lag
Definition: g723_1.h:94
static int autocorr_max(const int16_t *buf, int offset, int *ccr_max, int pitch_lag, int length, int dir)
Estimate maximum auto-correlation around pitch lag.
Definition: g723_1dec.c:348
const int32_t ff_g723_1_combinatorial_table[PULSE_MAX][SUBFRAME_LEN/GRID_SIZE]
Used for the coding/decoding of the pulses positions for the MP-MLQ codebook.
Definition: g723_1.c:409
int iir_mem[LPC_ORDER]
Definition: g723_1.h:134
if(ret)
static const int16_t pitch_contrib[340]
Definition: g723_1dec.c:48
#define GAIN_LEVELS
Definition: g723_1.h:48
#define iir_filter(fir_coef, iir_coef, src, dest, width)
Perform IIR filtering.
Definition: g723_1dec.c:589
int16_t opt_gain
optimal gain
Definition: g723_1.h:95
int postfilter
Definition: g723_1.h:161
int frame_size
Definition: mxfenc.c:2205
static void comp_ppf_coeff(G723_1_ChannelContext *p, int offset, int pitch_lag, PPFParam *ppf, enum Rate cur_rate)
Calculate pitch postfilter parameters.
Definition: g723_1dec.c:429
int ff_g723_1_scale_vector(int16_t *dst, const int16_t *vector, int length)
Scale vector contents based on the largest of their absolutes.
Definition: g723_1.c:1103
Libavcodec external API header.
static const int16_t dc_lsp[LPC_ORDER]
LSP DC component.
Definition: g723_1.h:227
static const int cng_filt[4]
Definition: g723_1dec.c:111
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
static void gain_scale(G723_1_ChannelContext *p, int16_t *buf, int energy)
Adjust gain of postfiltered signal.
Definition: g723_1dec.c:614
main external API structure.
Definition: avcodec.h:531
static int sid_gain_to_lsp_index(int gain)
Definition: g723_1dec.c:724
#define FASTDIV(a, b)
Definition: mathops.h:202
Silence Insertion Descriptor frame.
Definition: g723_1.h:65
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1884
G.723.1 types, functions and data tables.
int16_t fir_mem[LPC_ORDER]
Definition: g723_1.h:133
#define av_clipl_int32
Definition: common.h:140
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:538
Describe the class of an AVClass context structure.
Definition: log.h:67
#define PULSE_MAX
Definition: dss_sp.c:33
int16_t sc_gain
scaling gain
Definition: g723_1.h:96
int index
Definition: gxfenc.c:89
#define AV_CODEC_CAP_SUBFRAMES
Codec can output multiple frames per AVPacket Normally demuxers return one frame at a time...
Definition: codec.h:93
G723_1_ChannelContext ch[2]
Definition: g723_1.h:163
Active speech.
Definition: g723_1.h:64
int16_t prev_lsp[LPC_ORDER]
Definition: g723_1.h:128
#define CNG_RANDOM_SEED
Definition: g723_1dec.c:41
#define SUBFRAME_LEN
Definition: g723_1.h:36
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:328
#define SUBFRAMES
Definition: dcaenc.c:51
int16_t synth_mem[LPC_ORDER]
Definition: g723_1.h:132
#define AD
Definition: g723_1dec.c:1097
common internal api header.
Pitch postfilter parameters.
Definition: g723_1.h:93
static const int16_t ppf_gain_weight[2]
Postfilter gain weighting factors scaled by 2^15.
Definition: g723_1dec.c:46
static int unpack_bitstream(G723_1_ChannelContext *p, const uint8_t *buf, int buf_size)
Unpack the frame into parameters.
Definition: g723_1dec.c:147
void * priv_data
Definition: avcodec.h:558
#define av_sat_dadd32
Definition: common.h:155
enum FrameType cur_frame_type
Definition: g723_1.h:121
int channels
number of audio channels
Definition: avcodec.h:1192
enum Rate cur_rate
Definition: g723_1.h:123
static int16_t square_root(unsigned val)
Bitexact implementation of sqrt(val/2).
Definition: g723_1dec.c:265
static const AVOption options[]
Definition: g723_1dec.c:1099
int pulse_pos
Definition: g723_1.h:87
static int comp_interp_index(G723_1_ChannelContext *p, int pitch_lag, int *exc_eng, int *scale)
Classify frames as voiced/unvoiced.
Definition: g723_1dec.c:515
static av_cold int g723_1_decode_init(AVCodecContext *avctx)
Definition: g723_1dec.c:115
FILE * out
Definition: movenc.c:54
signed 16 bits, planar
Definition: samplefmt.h:67
static int cng_rand(int *state, int base)
Definition: g723_1dec.c:734
int16_t sid_lsp[LPC_ORDER]
Definition: g723_1.h:129
int16_t prev_excitation[PITCH_MAX]
Definition: g723_1.h:130
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
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:361
#define AV_CH_LAYOUT_MONO
static double val(void *priv, double ch)
Definition: aeval.c:76
This structure stores compressed data.
Definition: packet.h:340
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:380
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:50
static int g723_1_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: g723_1dec.c:927
int i
Definition: input.c:407
static const uint8_t bits1[81]
Definition: aactab.c:136
int ad_cb_lag
adaptive codebook lag
Definition: g723_1.h:81
static uint8_t tmp[11]
Definition: aes_ctr.c:27