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  */
147 static int unpack_bitstream(G723_1_ChannelContext *p, const uint8_t *buf,
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  }
207  if (p->subframe[i].ad_cb_gain < ad_cb_len) {
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++) {
297  if (temp >= 0)
298  continue;
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 */
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 {
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  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
1124 };
cng_bseg
static const int cng_bseg[3]
Definition: g723_1dec.c:113
ff_g723_1_fixed_cb_gain
const int16_t ff_g723_1_fixed_cb_gain[GAIN_LEVELS]
Definition: g723_1.c:454
AVCodec
AVCodec.
Definition: codec.h:202
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
FF_CODEC_CAP_INIT_THREADSAFE
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:42
square_root
static int16_t square_root(unsigned val)
Bitexact implementation of sqrt(val/2).
Definition: g723_1dec.c:265
av_clip
#define av_clip
Definition: common.h:96
g723_1dec_class
static const AVClass g723_1dec_class
Definition: g723_1dec.c:1106
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
acelp_vectors.h
PPFParam::index
int index
postfilter backward/forward lag
Definition: g723_1.h:94
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
AVCodecContext::channel_layout
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1043
G723_1_Subframe::ad_cb_gain
int ad_cb_gain
Definition: g723_1.h:82
FRAME_LEN
#define FRAME_LEN
Definition: g723_1.h:37
G723_1_ChannelContext::interp_gain
int interp_gain
Definition: g723_1.h:139
out
FILE * out
Definition: movenc.c:54
av_clip_uintp2
#define av_clip_uintp2
Definition: common.h:120
G723_1_ChannelContext::sid_gain
int sid_gain
Definition: g723_1.h:140
G723_1_ChannelContext::interp_index
int interp_index
Definition: g723_1.h:138
AV_CH_LAYOUT_MONO
#define AV_CH_LAYOUT_MONO
Definition: channel_layout.h:90
G723_1_ChannelContext::pitch_lag
int pitch_lag[2]
Definition: g723_1.h:125
gen_fcb_excitation
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
postfilter_tbl
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
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:26
index
fg index
Definition: ffmpeg_filter.c:168
Rate
Rate
G723.1 rate values.
Definition: g723_1.h:72
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:373
av_sat_dadd32
#define av_sat_dadd32
Definition: common.h:129
AVOption
AVOption.
Definition: opt.h:247
G723_1_Subframe::pulse_sign
int pulse_sign
Definition: g723_1.h:84
AD
#define AD
Definition: g723_1dec.c:1097
data
const char data[16]
Definition: mxf.c:143
G723_1_Subframe::ad_cb_lag
int ad_cb_lag
adaptive codebook lag
Definition: g723_1.h:81
ff_celp_lp_synthesis_filter
int ff_celp_lp_synthesis_filter(int16_t *out, const int16_t *filter_coeffs, const int16_t *in, int buffer_length, int filter_length, int stop_on_overflow, int shift, int rounder)
LP synthesis filter.
Definition: celp_filters.c:61
generate_noise
static void generate_noise(G723_1_ChannelContext *p)
Definition: g723_1dec.c:802
base
uint8_t base
Definition: vp3data.h:141
G723_1_Context
Definition: g723_1.h:159
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
ff_g723_1_inverse_quant
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:1273
cng_filt
static const int cng_filt[4]
Definition: g723_1dec.c:111
G723_1_ChannelContext::prev_excitation
int16_t prev_excitation[PITCH_MAX]
Definition: g723_1.h:130
state
static struct @319 state
G723_1_Subframe::pulse_pos
int pulse_pos
Definition: g723_1.h:87
ff_g723_1_normalize_bits
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:1121
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:380
PITCH_MIN
#define PITCH_MIN
Definition: g723_1.h:43
ff_g723_1_gen_dirac_train
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:1146
G723_1_ChannelContext::synth_mem
int16_t synth_mem[LPC_ORDER]
Definition: g723_1.h:132
GetBitContext
Definition: get_bits.h:62
GRID_SIZE
#define GRID_SIZE
Definition: g723_1.h:46
val
static double val(void *priv, double ch)
Definition: aeval.c:76
scale
static av_always_inline float scale(float x, float s)
Definition: vf_v360.c:1377
G723_1_ChannelContext::cur_frame_type
enum FrameType cur_frame_type
Definition: g723_1.h:121
ff_sqrt
#define ff_sqrt
Definition: mathops.h:206
AV_CH_LAYOUT_STEREO
#define AV_CH_LAYOUT_STEREO
Definition: channel_layout.h:91
G723_1_ChannelContext::cur_rate
enum Rate cur_rate
Definition: g723_1.h:123
options
static const AVOption options[]
Definition: g723_1dec.c:1099
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:678
cng_adaptive_cb_lag
static const int cng_adaptive_cb_lag[4]
Definition: g723_1dec.c:109
comp_ppf_gains
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
ff_g723_1_gen_acb_excitation
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:1158
av_memcpy_backptr
void av_memcpy_backptr(uint8_t *dst, int back, int cnt)
Overlapping memcpy() implementation.
Definition: mem.c:454
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
G723_1_ChannelContext::pf_gain
int pf_gain
formant postfilter gain scaling unit memory
Definition: g723_1.h:143
postfilter
static void postfilter(AMRContext *p, float *lpc, float *buf_out)
Perform adaptive post-filtering to enhance the quality of the speech.
Definition: amrnbdec.c:913
s
#define s(width, name)
Definition: cbs_vp9.c:257
bits1
static const uint8_t bits1[81]
Definition: aactab.c:135
G723_1_ChannelContext::cng_random_seed
int cng_random_seed
Definition: g723_1.h:137
frame_size
int frame_size
Definition: mxfenc.c:2205
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
G723_1_ChannelContext::fir_mem
int16_t fir_mem[LPC_ORDER]
Definition: g723_1.h:133
G723_1_ChannelContext::random_seed
int random_seed
Definition: g723_1.h:136
G723_1_ChannelContext::audio
int16_t audio[FRAME_LEN+LPC_ORDER+PITCH_MAX+4]
Definition: g723_1.h:145
get_bits.h
UNTRANSMITTED_FRAME
@ UNTRANSMITTED_FRAME
Definition: g723_1.h:66
LPC_ORDER
#define LPC_ORDER
Definition: g723_1.h:40
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:65
if
if(ret)
Definition: filter_design.txt:179
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
av_clip_int16
#define av_clip_int16
Definition: common.h:111
NULL
#define NULL
Definition: coverity.c:32
ff_g723_1_lsp_interpolate
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:1252
AV_CODEC_ID_G723_1
@ AV_CODEC_ID_G723_1
Definition: codec_id.h:475
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:499
G723_1_ChannelContext::sid_lsp
int16_t sid_lsp[LPC_ORDER]
Definition: g723_1.h:129
RATE_6300
@ RATE_6300
Definition: g723_1.h:73
ff_g723_1_dot_product
int ff_g723_1_dot_product(const int16_t *a, const int16_t *b, int length)
Definition: g723_1.c:1126
gain_scale
static void gain_scale(G723_1_ChannelContext *p, int16_t *buf, int energy)
Adjust gain of postfiltered signal.
Definition: g723_1dec.c:614
G723_1_ChannelContext::subframe
G723_1_Subframe subframe[4]
Definition: g723_1.h:120
FASTDIV
#define FASTDIV(a, b)
Definition: mathops.h:202
av_sat_add32
#define av_sat_add32
Definition: common.h:126
celp_filters.h
G723_1_Subframe::amp_index
int amp_index
Definition: g723_1.h:86
formant_postfilter
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
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
G723_1_ChannelContext::past_frame_type
enum FrameType past_frame_type
Definition: g723_1.h:122
SUBFRAMES
#define SUBFRAMES
Definition: dcaenc.c:51
GAIN_LEVELS
#define GAIN_LEVELS
Definition: g723_1.h:48
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1652
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
g723_1.h
AVPacket::size
int size
Definition: packet.h:374
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
pitch_contrib
static const int16_t pitch_contrib[340]
Definition: g723_1dec.c:48
av_clipl_int32
#define av_clipl_int32
Definition: common.h:114
OFFSET
#define OFFSET(x)
Definition: g723_1dec.c:1096
G723_1_ChannelContext::lsp_index
uint8_t lsp_index[LSP_BANDS]
Definition: g723_1.h:124
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1000
celp_math.h
ACTIVE_FRAME
@ ACTIVE_FRAME
Active speech.
Definition: g723_1.h:64
SUBFRAME_LEN
#define SUBFRAME_LEN
Definition: g723_1.h:36
G723_1_ChannelContext::excitation
int16_t excitation[PITCH_MAX+FRAME_LEN+4]
Definition: g723_1.h:131
G723_1_Subframe
G723.1 unpacked data subframe.
Definition: g723_1.h:80
PITCH_MAX
#define PITCH_MAX
Definition: g723_1.h:44
offset
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
Definition: writing_filters.txt:86
skip_bits1
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:539
AV_SAMPLE_FMT_S16P
@ AV_SAMPLE_FMT_S16P
signed 16 bits, planar
Definition: samplefmt.h:67
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:993
G723_1_ChannelContext::reflection_coef
int reflection_coef
Definition: g723_1.h:142
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
PPFParam::opt_gain
int16_t opt_gain
optimal gain
Definition: g723_1.h:95
ff_g723_1_scale_vector
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:1104
delta
float delta
Definition: vorbis_enc_data.h:430
cng_rand
static int cng_rand(int *state, int base)
Definition: g723_1dec.c:734
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:209
estimate_sid_gain
static int estimate_sid_gain(G723_1_ChannelContext *p)
Definition: g723_1dec.c:740
avcodec.h
limit
static double limit(double x)
Definition: vf_pseudocolor.c:128
ff_g723_1_combinatorial_table
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:410
ret
ret
Definition: filter_design.txt:187
AVClass::class_name
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:71
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
G723_1_ChannelContext::prev_lsp
int16_t prev_lsp[LPC_ORDER]
Definition: g723_1.h:128
pos
unsigned int pos
Definition: spdifenc.c:412
comp_interp_index
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
dc_lsp
static const int16_t dc_lsp[LPC_ORDER]
LSP DC component.
Definition: g723_1.h:227
RATE_5300
@ RATE_5300
Definition: g723_1.h:74
AVCodecContext
main external API structure.
Definition: avcodec.h:383
residual_interp
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
channel_layout.h
G723_1_ChannelContext::erased_frames
int erased_frames
Definition: g723_1.h:126
SID_FRAME
@ SID_FRAME
Silence Insertion Descriptor frame.
Definition: g723_1.h:65
G723_1_ChannelContext::iir_mem
int iir_mem[LPC_ORDER]
Definition: g723_1.h:134
temp
else temp
Definition: vf_mcdeint.c:248
comp_ppf_coeff
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
PULSE_MAX
#define PULSE_MAX
Definition: dss_sp.c:32
ff_acelp_weighted_vector_sum
void ff_acelp_weighted_vector_sum(int16_t *out, const int16_t *in_a, const int16_t *in_b, int16_t weight_coeff_a, int16_t weight_coeff_b, int16_t rounder, int shift, int length)
weighted sum of two vectors with rounding.
Definition: acelp_vectors.c:162
shift
static int shift(int a, int b)
Definition: sonic.c:83
mem.h
AV_CODEC_CAP_SUBFRAMES
#define AV_CODEC_CAP_SUBFRAMES
Codec can output multiple frames per AVPacket Normally demuxers return one frame at a time,...
Definition: codec.h:100
AVPacket
This structure stores compressed data.
Definition: packet.h:350
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:410
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:241
ppf_gain_weight
static const int16_t ppf_gain_weight[2]
Postfilter gain weighting factors scaled by 2^15.
Definition: g723_1dec.c:46
G723_1_ChannelContext::cur_gain
int cur_gain
Definition: g723_1.h:141
CNG_RANDOM_SEED
#define CNG_RANDOM_SEED
Definition: g723_1dec.c:41
int32_t
int32_t
Definition: audioconvert.c:56
G723_1_Subframe::grid_index
int grid_index
Definition: g723_1.h:85
iir_filter
#define iir_filter(fir_coef, iir_coef, src, dest, width)
Perform IIR filtering.
Definition: g723_1dec.c:589
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
autocorr_max
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
b0
static double b0(void *priv, double x, double y)
Definition: vf_xfade.c:1702
sid_gain_to_lsp_index
static int sid_gain_to_lsp_index(int gain)
Definition: g723_1dec.c:724
g723_1_decode_init
static av_cold int g723_1_decode_init(AVCodecContext *avctx)
Definition: g723_1dec.c:115
G723_1_Subframe::dirac_train
int dirac_train
Definition: g723_1.h:83
pulses
static const int8_t pulses[4]
Number of non-zero pulses in the MP-MLQ excitation.
Definition: g723_1.h:260
bits2
static const uint8_t bits2[81]
Definition: aactab.c:158
G723_1_ChannelContext
Definition: g723_1.h:119
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
unpack_bitstream
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
ff_g723_1_decoder
const AVCodec ff_g723_1_decoder
Definition: g723_1dec.c:1113
PPFParam::sc_gain
int16_t sc_gain
scaling gain
Definition: g723_1.h:96
PPFParam
Pitch postfilter parameters.
Definition: g723_1.h:93
max_pos
static const int32_t max_pos[4]
Size of the MP-MLQ fixed excitation codebooks.
Definition: g723_1dec.c:97
g723_1_decode_frame
static int g723_1_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: g723_1dec.c:927