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 
44 {
45  G723_1_Context *s = avctx->priv_data;
46 
48  if (avctx->channels < 1 || avctx->channels > 2) {
49  av_log(avctx, AV_LOG_ERROR, "Only mono and stereo are supported (requested channels: %d).\n", avctx->channels);
50  return AVERROR(EINVAL);
51  }
53  for (int ch = 0; ch < avctx->channels; ch++) {
54  G723_1_ChannelContext *p = &s->ch[ch];
55 
56  p->pf_gain = 1 << 12;
57 
58  memcpy(p->prev_lsp, dc_lsp, LPC_ORDER * sizeof(*p->prev_lsp));
59  memcpy(p->sid_lsp, dc_lsp, LPC_ORDER * sizeof(*p->sid_lsp));
60 
63  }
64 
65  return 0;
66 }
67 
68 /**
69  * Unpack the frame into parameters.
70  *
71  * @param p the context
72  * @param buf pointer to the input buffer
73  * @param buf_size size of the input buffer
74  */
76  int buf_size)
77 {
78  GetBitContext gb;
79  int ad_cb_len;
80  int temp, info_bits, i;
81  int ret;
82 
83  ret = init_get_bits8(&gb, buf, buf_size);
84  if (ret < 0)
85  return ret;
86 
87  /* Extract frame type and rate info */
88  info_bits = get_bits(&gb, 2);
89 
90  if (info_bits == 3) {
92  return 0;
93  }
94 
95  /* Extract 24 bit lsp indices, 8 bit for each band */
96  p->lsp_index[2] = get_bits(&gb, 8);
97  p->lsp_index[1] = get_bits(&gb, 8);
98  p->lsp_index[0] = get_bits(&gb, 8);
99 
100  if (info_bits == 2) {
102  p->subframe[0].amp_index = get_bits(&gb, 6);
103  return 0;
104  }
105 
106  /* Extract the info common to both rates */
107  p->cur_rate = info_bits ? RATE_5300 : RATE_6300;
109 
110  p->pitch_lag[0] = get_bits(&gb, 7);
111  if (p->pitch_lag[0] > 123) /* test if forbidden code */
112  return -1;
113  p->pitch_lag[0] += PITCH_MIN;
114  p->subframe[1].ad_cb_lag = get_bits(&gb, 2);
115 
116  p->pitch_lag[1] = get_bits(&gb, 7);
117  if (p->pitch_lag[1] > 123)
118  return -1;
119  p->pitch_lag[1] += PITCH_MIN;
120  p->subframe[3].ad_cb_lag = get_bits(&gb, 2);
121  p->subframe[0].ad_cb_lag = 1;
122  p->subframe[2].ad_cb_lag = 1;
123 
124  for (i = 0; i < SUBFRAMES; i++) {
125  /* Extract combined gain */
126  temp = get_bits(&gb, 12);
127  ad_cb_len = 170;
128  p->subframe[i].dirac_train = 0;
129  if (p->cur_rate == RATE_6300 && p->pitch_lag[i >> 1] < SUBFRAME_LEN - 2) {
130  p->subframe[i].dirac_train = temp >> 11;
131  temp &= 0x7FF;
132  ad_cb_len = 85;
133  }
134  p->subframe[i].ad_cb_gain = FASTDIV(temp, GAIN_LEVELS);
135  if (p->subframe[i].ad_cb_gain < ad_cb_len) {
136  p->subframe[i].amp_index = temp - p->subframe[i].ad_cb_gain *
137  GAIN_LEVELS;
138  } else {
139  return -1;
140  }
141  }
142 
143  p->subframe[0].grid_index = get_bits1(&gb);
144  p->subframe[1].grid_index = get_bits1(&gb);
145  p->subframe[2].grid_index = get_bits1(&gb);
146  p->subframe[3].grid_index = get_bits1(&gb);
147 
148  if (p->cur_rate == RATE_6300) {
149  skip_bits1(&gb); /* skip reserved bit */
150 
151  /* Compute pulse_pos index using the 13-bit combined position index */
152  temp = get_bits(&gb, 13);
153  p->subframe[0].pulse_pos = temp / 810;
154 
155  temp -= p->subframe[0].pulse_pos * 810;
156  p->subframe[1].pulse_pos = FASTDIV(temp, 90);
157 
158  temp -= p->subframe[1].pulse_pos * 90;
159  p->subframe[2].pulse_pos = FASTDIV(temp, 9);
160  p->subframe[3].pulse_pos = temp - p->subframe[2].pulse_pos * 9;
161 
162  p->subframe[0].pulse_pos = (p->subframe[0].pulse_pos << 16) +
163  get_bits(&gb, 16);
164  p->subframe[1].pulse_pos = (p->subframe[1].pulse_pos << 14) +
165  get_bits(&gb, 14);
166  p->subframe[2].pulse_pos = (p->subframe[2].pulse_pos << 16) +
167  get_bits(&gb, 16);
168  p->subframe[3].pulse_pos = (p->subframe[3].pulse_pos << 14) +
169  get_bits(&gb, 14);
170 
171  p->subframe[0].pulse_sign = get_bits(&gb, 6);
172  p->subframe[1].pulse_sign = get_bits(&gb, 5);
173  p->subframe[2].pulse_sign = get_bits(&gb, 6);
174  p->subframe[3].pulse_sign = get_bits(&gb, 5);
175  } else { /* 5300 bps */
176  p->subframe[0].pulse_pos = get_bits(&gb, 12);
177  p->subframe[1].pulse_pos = get_bits(&gb, 12);
178  p->subframe[2].pulse_pos = get_bits(&gb, 12);
179  p->subframe[3].pulse_pos = get_bits(&gb, 12);
180 
181  p->subframe[0].pulse_sign = get_bits(&gb, 4);
182  p->subframe[1].pulse_sign = get_bits(&gb, 4);
183  p->subframe[2].pulse_sign = get_bits(&gb, 4);
184  p->subframe[3].pulse_sign = get_bits(&gb, 4);
185  }
186 
187  return 0;
188 }
189 
190 /**
191  * Bitexact implementation of sqrt(val/2).
192  */
193 static int16_t square_root(unsigned val)
194 {
195  av_assert2(!(val & 0x80000000));
196 
197  return (ff_sqrt(val << 1) >> 1) & (~1);
198 }
199 
200 /**
201  * Generate fixed codebook excitation vector.
202  *
203  * @param vector decoded excitation vector
204  * @param subfrm current subframe
205  * @param cur_rate current bitrate
206  * @param pitch_lag closed loop pitch lag
207  * @param index current subframe index
208  */
209 static void gen_fcb_excitation(int16_t *vector, G723_1_Subframe *subfrm,
210  enum Rate cur_rate, int pitch_lag, int index)
211 {
212  int temp, i, j;
213 
214  memset(vector, 0, SUBFRAME_LEN * sizeof(*vector));
215 
216  if (cur_rate == RATE_6300) {
217  if (subfrm->pulse_pos >= max_pos[index])
218  return;
219 
220  /* Decode amplitudes and positions */
221  j = PULSE_MAX - pulses[index];
222  temp = subfrm->pulse_pos;
223  for (i = 0; i < SUBFRAME_LEN / GRID_SIZE; i++) {
224  temp -= combinatorial_table[j][i];
225  if (temp >= 0)
226  continue;
227  temp += combinatorial_table[j++][i];
228  if (subfrm->pulse_sign & (1 << (PULSE_MAX - j))) {
229  vector[subfrm->grid_index + GRID_SIZE * i] =
230  -fixed_cb_gain[subfrm->amp_index];
231  } else {
232  vector[subfrm->grid_index + GRID_SIZE * i] =
233  fixed_cb_gain[subfrm->amp_index];
234  }
235  if (j == PULSE_MAX)
236  break;
237  }
238  if (subfrm->dirac_train == 1)
239  ff_g723_1_gen_dirac_train(vector, pitch_lag);
240  } else { /* 5300 bps */
241  int cb_gain = fixed_cb_gain[subfrm->amp_index];
242  int cb_shift = subfrm->grid_index;
243  int cb_sign = subfrm->pulse_sign;
244  int cb_pos = subfrm->pulse_pos;
245  int offset, beta, lag;
246 
247  for (i = 0; i < 8; i += 2) {
248  offset = ((cb_pos & 7) << 3) + cb_shift + i;
249  vector[offset] = (cb_sign & 1) ? cb_gain : -cb_gain;
250  cb_pos >>= 3;
251  cb_sign >>= 1;
252  }
253 
254  /* Enhance harmonic components */
255  lag = pitch_contrib[subfrm->ad_cb_gain << 1] + pitch_lag +
256  subfrm->ad_cb_lag - 1;
257  beta = pitch_contrib[(subfrm->ad_cb_gain << 1) + 1];
258 
259  if (lag < SUBFRAME_LEN - 2) {
260  for (i = lag; i < SUBFRAME_LEN; i++)
261  vector[i] += beta * vector[i - lag] >> 15;
262  }
263  }
264 }
265 
266 /**
267  * Estimate maximum auto-correlation around pitch lag.
268  *
269  * @param buf buffer with offset applied
270  * @param offset offset of the excitation vector
271  * @param ccr_max pointer to the maximum auto-correlation
272  * @param pitch_lag decoded pitch lag
273  * @param length length of autocorrelation
274  * @param dir forward lag(1) / backward lag(-1)
275  */
276 static int autocorr_max(const int16_t *buf, int offset, int *ccr_max,
277  int pitch_lag, int length, int dir)
278 {
279  int limit, ccr, lag = 0;
280  int i;
281 
282  pitch_lag = FFMIN(PITCH_MAX - 3, pitch_lag);
283  if (dir > 0)
284  limit = FFMIN(FRAME_LEN + PITCH_MAX - offset - length, pitch_lag + 3);
285  else
286  limit = pitch_lag + 3;
287 
288  for (i = pitch_lag - 3; i <= limit; i++) {
289  ccr = ff_g723_1_dot_product(buf, buf + dir * i, length);
290 
291  if (ccr > *ccr_max) {
292  *ccr_max = ccr;
293  lag = i;
294  }
295  }
296  return lag;
297 }
298 
299 /**
300  * Calculate pitch postfilter optimal and scaling gains.
301  *
302  * @param lag pitch postfilter forward/backward lag
303  * @param ppf pitch postfilter parameters
304  * @param cur_rate current bitrate
305  * @param tgt_eng target energy
306  * @param ccr cross-correlation
307  * @param res_eng residual energy
308  */
309 static void comp_ppf_gains(int lag, PPFParam *ppf, enum Rate cur_rate,
310  int tgt_eng, int ccr, int res_eng)
311 {
312  int pf_residual; /* square of postfiltered residual */
313  int temp1, temp2;
314 
315  ppf->index = lag;
316 
317  temp1 = tgt_eng * res_eng >> 1;
318  temp2 = ccr * ccr << 1;
319 
320  if (temp2 > temp1) {
321  if (ccr >= res_eng) {
322  ppf->opt_gain = ppf_gain_weight[cur_rate];
323  } else {
324  ppf->opt_gain = (ccr << 15) / res_eng *
325  ppf_gain_weight[cur_rate] >> 15;
326  }
327  /* pf_res^2 = tgt_eng + 2*ccr*gain + res_eng*gain^2 */
328  temp1 = (tgt_eng << 15) + (ccr * ppf->opt_gain << 1);
329  temp2 = (ppf->opt_gain * ppf->opt_gain >> 15) * res_eng;
330  pf_residual = av_sat_add32(temp1, temp2 + (1 << 15)) >> 16;
331 
332  if (tgt_eng >= pf_residual << 1) {
333  temp1 = 0x7fff;
334  } else {
335  temp1 = (tgt_eng << 14) / pf_residual;
336  }
337 
338  /* scaling_gain = sqrt(tgt_eng/pf_res^2) */
339  ppf->sc_gain = square_root(temp1 << 16);
340  } else {
341  ppf->opt_gain = 0;
342  ppf->sc_gain = 0x7fff;
343  }
344 
345  ppf->opt_gain = av_clip_int16(ppf->opt_gain * ppf->sc_gain >> 15);
346 }
347 
348 /**
349  * Calculate pitch postfilter parameters.
350  *
351  * @param p the context
352  * @param offset offset of the excitation vector
353  * @param pitch_lag decoded pitch lag
354  * @param ppf pitch postfilter parameters
355  * @param cur_rate current bitrate
356  */
357 static void comp_ppf_coeff(G723_1_ChannelContext *p, int offset, int pitch_lag,
358  PPFParam *ppf, enum Rate cur_rate)
359 {
360 
361  int16_t scale;
362  int i;
363  int temp1, temp2;
364 
365  /*
366  * 0 - target energy
367  * 1 - forward cross-correlation
368  * 2 - forward residual energy
369  * 3 - backward cross-correlation
370  * 4 - backward residual energy
371  */
372  int energy[5] = {0, 0, 0, 0, 0};
373  int16_t *buf = p->audio + LPC_ORDER + offset;
374  int fwd_lag = autocorr_max(buf, offset, &energy[1], pitch_lag,
375  SUBFRAME_LEN, 1);
376  int back_lag = autocorr_max(buf, offset, &energy[3], pitch_lag,
377  SUBFRAME_LEN, -1);
378 
379  ppf->index = 0;
380  ppf->opt_gain = 0;
381  ppf->sc_gain = 0x7fff;
382 
383  /* Case 0, Section 3.6 */
384  if (!back_lag && !fwd_lag)
385  return;
386 
387  /* Compute target energy */
388  energy[0] = ff_g723_1_dot_product(buf, buf, SUBFRAME_LEN);
389 
390  /* Compute forward residual energy */
391  if (fwd_lag)
392  energy[2] = ff_g723_1_dot_product(buf + fwd_lag, buf + fwd_lag,
393  SUBFRAME_LEN);
394 
395  /* Compute backward residual energy */
396  if (back_lag)
397  energy[4] = ff_g723_1_dot_product(buf - back_lag, buf - back_lag,
398  SUBFRAME_LEN);
399 
400  /* Normalize and shorten */
401  temp1 = 0;
402  for (i = 0; i < 5; i++)
403  temp1 = FFMAX(energy[i], temp1);
404 
405  scale = ff_g723_1_normalize_bits(temp1, 31);
406  for (i = 0; i < 5; i++)
407  energy[i] = (energy[i] << scale) >> 16;
408 
409  if (fwd_lag && !back_lag) { /* Case 1 */
410  comp_ppf_gains(fwd_lag, ppf, cur_rate, energy[0], energy[1],
411  energy[2]);
412  } else if (!fwd_lag) { /* Case 2 */
413  comp_ppf_gains(-back_lag, ppf, cur_rate, energy[0], energy[3],
414  energy[4]);
415  } else { /* Case 3 */
416 
417  /*
418  * Select the largest of energy[1]^2/energy[2]
419  * and energy[3]^2/energy[4]
420  */
421  temp1 = energy[4] * ((energy[1] * energy[1] + (1 << 14)) >> 15);
422  temp2 = energy[2] * ((energy[3] * energy[3] + (1 << 14)) >> 15);
423  if (temp1 >= temp2) {
424  comp_ppf_gains(fwd_lag, ppf, cur_rate, energy[0], energy[1],
425  energy[2]);
426  } else {
427  comp_ppf_gains(-back_lag, ppf, cur_rate, energy[0], energy[3],
428  energy[4]);
429  }
430  }
431 }
432 
433 /**
434  * Classify frames as voiced/unvoiced.
435  *
436  * @param p the context
437  * @param pitch_lag decoded pitch_lag
438  * @param exc_eng excitation energy estimation
439  * @param scale scaling factor of exc_eng
440  *
441  * @return residual interpolation index if voiced, 0 otherwise
442  */
443 static int comp_interp_index(G723_1_ChannelContext *p, int pitch_lag,
444  int *exc_eng, int *scale)
445 {
446  int offset = PITCH_MAX + 2 * SUBFRAME_LEN;
447  int16_t *buf = p->audio + LPC_ORDER;
448 
449  int index, ccr, tgt_eng, best_eng, temp;
450 
452  buf += offset;
453 
454  /* Compute maximum backward cross-correlation */
455  ccr = 0;
456  index = autocorr_max(buf, offset, &ccr, pitch_lag, SUBFRAME_LEN * 2, -1);
457  ccr = av_sat_add32(ccr, 1 << 15) >> 16;
458 
459  /* Compute target energy */
460  tgt_eng = ff_g723_1_dot_product(buf, buf, SUBFRAME_LEN * 2);
461  *exc_eng = av_sat_add32(tgt_eng, 1 << 15) >> 16;
462 
463  if (ccr <= 0)
464  return 0;
465 
466  /* Compute best energy */
467  best_eng = ff_g723_1_dot_product(buf - index, buf - index,
468  SUBFRAME_LEN * 2);
469  best_eng = av_sat_add32(best_eng, 1 << 15) >> 16;
470 
471  temp = best_eng * *exc_eng >> 3;
472 
473  if (temp < ccr * ccr) {
474  return index;
475  } else
476  return 0;
477 }
478 
479 /**
480  * Perform residual interpolation based on frame classification.
481  *
482  * @param buf decoded excitation vector
483  * @param out output vector
484  * @param lag decoded pitch lag
485  * @param gain interpolated gain
486  * @param rseed seed for random number generator
487  */
488 static void residual_interp(int16_t *buf, int16_t *out, int lag,
489  int gain, int *rseed)
490 {
491  int i;
492  if (lag) { /* Voiced */
493  int16_t *vector_ptr = buf + PITCH_MAX;
494  /* Attenuate */
495  for (i = 0; i < lag; i++)
496  out[i] = vector_ptr[i - lag] * 3 >> 2;
497  av_memcpy_backptr((uint8_t*)(out + lag), lag * sizeof(*out),
498  (FRAME_LEN - lag) * sizeof(*out));
499  } else { /* Unvoiced */
500  for (i = 0; i < FRAME_LEN; i++) {
501  *rseed = (int16_t)(*rseed * 521 + 259);
502  out[i] = gain * *rseed >> 15;
503  }
504  memset(buf, 0, (FRAME_LEN + PITCH_MAX) * sizeof(*buf));
505  }
506 }
507 
508 /**
509  * Perform IIR filtering.
510  *
511  * @param fir_coef FIR coefficients
512  * @param iir_coef IIR coefficients
513  * @param src source vector
514  * @param dest destination vector
515  * @param width width of the output, 16 bits(0) / 32 bits(1)
516  */
517 #define iir_filter(fir_coef, iir_coef, src, dest, width)\
518 {\
519  int m, n;\
520  int res_shift = 16 & ~-(width);\
521  int in_shift = 16 - res_shift;\
522 \
523  for (m = 0; m < SUBFRAME_LEN; m++) {\
524  int64_t filter = 0;\
525  for (n = 1; n <= LPC_ORDER; n++) {\
526  filter -= (fir_coef)[n - 1] * (src)[m - n] -\
527  (iir_coef)[n - 1] * ((dest)[m - n] >> in_shift);\
528  }\
529 \
530  (dest)[m] = av_clipl_int32(((src)[m] * 65536) + (filter * 8) +\
531  (1 << 15)) >> res_shift;\
532  }\
533 }
534 
535 /**
536  * Adjust gain of postfiltered signal.
537  *
538  * @param p the context
539  * @param buf postfiltered output vector
540  * @param energy input energy coefficient
541  */
542 static void gain_scale(G723_1_ChannelContext *p, int16_t * buf, int energy)
543 {
544  int num, denom, gain, bits1, bits2;
545  int i;
546 
547  num = energy;
548  denom = 0;
549  for (i = 0; i < SUBFRAME_LEN; i++) {
550  int temp = buf[i] >> 2;
551  temp *= temp;
552  denom = av_sat_dadd32(denom, temp);
553  }
554 
555  if (num && denom) {
556  bits1 = ff_g723_1_normalize_bits(num, 31);
557  bits2 = ff_g723_1_normalize_bits(denom, 31);
558  num = num << bits1 >> 1;
559  denom <<= bits2;
560 
561  bits2 = 5 + bits1 - bits2;
562  bits2 = av_clip_uintp2(bits2, 5);
563 
564  gain = (num >> 1) / (denom >> 16);
565  gain = square_root(gain << 16 >> bits2);
566  } else {
567  gain = 1 << 12;
568  }
569 
570  for (i = 0; i < SUBFRAME_LEN; i++) {
571  p->pf_gain = (15 * p->pf_gain + gain + (1 << 3)) >> 4;
572  buf[i] = av_clip_int16((buf[i] * (p->pf_gain + (p->pf_gain >> 4)) +
573  (1 << 10)) >> 11);
574  }
575 }
576 
577 /**
578  * Perform formant filtering.
579  *
580  * @param p the context
581  * @param lpc quantized lpc coefficients
582  * @param buf input buffer
583  * @param dst output buffer
584  */
585 static void formant_postfilter(G723_1_ChannelContext *p, int16_t *lpc,
586  int16_t *buf, int16_t *dst)
587 {
588  int16_t filter_coef[2][LPC_ORDER];
589  int filter_signal[LPC_ORDER + FRAME_LEN], *signal_ptr;
590  int i, j, k;
591 
592  memcpy(buf, p->fir_mem, LPC_ORDER * sizeof(*buf));
593  memcpy(filter_signal, p->iir_mem, LPC_ORDER * sizeof(*filter_signal));
594 
595  for (i = LPC_ORDER, j = 0; j < SUBFRAMES; i += SUBFRAME_LEN, j++) {
596  for (k = 0; k < LPC_ORDER; k++) {
597  filter_coef[0][k] = (-lpc[k] * postfilter_tbl[0][k] +
598  (1 << 14)) >> 15;
599  filter_coef[1][k] = (-lpc[k] * postfilter_tbl[1][k] +
600  (1 << 14)) >> 15;
601  }
602  iir_filter(filter_coef[0], filter_coef[1], buf + i, filter_signal + i, 1);
603  lpc += LPC_ORDER;
604  }
605 
606  memcpy(p->fir_mem, buf + FRAME_LEN, LPC_ORDER * sizeof(int16_t));
607  memcpy(p->iir_mem, filter_signal + FRAME_LEN, LPC_ORDER * sizeof(int));
608 
609  buf += LPC_ORDER;
610  signal_ptr = filter_signal + LPC_ORDER;
611  for (i = 0; i < SUBFRAMES; i++) {
612  int temp;
613  int auto_corr[2];
614  int scale, energy;
615 
616  /* Normalize */
617  scale = ff_g723_1_scale_vector(dst, buf, SUBFRAME_LEN);
618 
619  /* Compute auto correlation coefficients */
620  auto_corr[0] = ff_g723_1_dot_product(dst, dst + 1, SUBFRAME_LEN - 1);
621  auto_corr[1] = ff_g723_1_dot_product(dst, dst, SUBFRAME_LEN);
622 
623  /* Compute reflection coefficient */
624  temp = auto_corr[1] >> 16;
625  if (temp) {
626  temp = (auto_corr[0] >> 2) / temp;
627  }
628  p->reflection_coef = (3 * p->reflection_coef + temp + 2) >> 2;
629  temp = -p->reflection_coef >> 1 & ~3;
630 
631  /* Compensation filter */
632  for (j = 0; j < SUBFRAME_LEN; j++) {
633  dst[j] = av_sat_dadd32(signal_ptr[j],
634  (signal_ptr[j - 1] >> 16) * temp) >> 16;
635  }
636 
637  /* Compute normalized signal energy */
638  temp = 2 * scale + 4;
639  if (temp < 0) {
640  energy = av_clipl_int32((int64_t)auto_corr[1] << -temp);
641  } else
642  energy = auto_corr[1] >> temp;
643 
644  gain_scale(p, dst, energy);
645 
646  buf += SUBFRAME_LEN;
647  signal_ptr += SUBFRAME_LEN;
648  dst += SUBFRAME_LEN;
649  }
650 }
651 
652 static int sid_gain_to_lsp_index(int gain)
653 {
654  if (gain < 0x10)
655  return gain << 6;
656  else if (gain < 0x20)
657  return gain - 8 << 7;
658  else
659  return gain - 20 << 8;
660 }
661 
662 static inline int cng_rand(int *state, int base)
663 {
664  *state = (*state * 521 + 259) & 0xFFFF;
665  return (*state & 0x7FFF) * base >> 15;
666 }
667 
669 {
670  int i, shift, seg, seg2, t, val, val_add, x, y;
671 
672  shift = 16 - p->cur_gain * 2;
673  if (shift > 0) {
674  if (p->sid_gain == 0) {
675  t = 0;
676  } else if (shift >= 31 || (int32_t)((uint32_t)p->sid_gain << shift) >> shift != p->sid_gain) {
677  if (p->sid_gain < 0) t = INT32_MIN;
678  else t = INT32_MAX;
679  } else
680  t = p->sid_gain << shift;
681  }else
682  t = p->sid_gain >> -shift;
683  x = av_clipl_int32(t * (int64_t)cng_filt[0] >> 16);
684 
685  if (x >= cng_bseg[2])
686  return 0x3F;
687 
688  if (x >= cng_bseg[1]) {
689  shift = 4;
690  seg = 3;
691  } else {
692  shift = 3;
693  seg = (x >= cng_bseg[0]);
694  }
695  seg2 = FFMIN(seg, 3);
696 
697  val = 1 << shift;
698  val_add = val >> 1;
699  for (i = 0; i < shift; i++) {
700  t = seg * 32 + (val << seg2);
701  t *= t;
702  if (x >= t)
703  val += val_add;
704  else
705  val -= val_add;
706  val_add >>= 1;
707  }
708 
709  t = seg * 32 + (val << seg2);
710  y = t * t - x;
711  if (y <= 0) {
712  t = seg * 32 + (val + 1 << seg2);
713  t = t * t - x;
714  val = (seg2 - 1) * 16 + val;
715  if (t >= y)
716  val++;
717  } else {
718  t = seg * 32 + (val - 1 << seg2);
719  t = t * t - x;
720  val = (seg2 - 1) * 16 + val;
721  if (t >= y)
722  val--;
723  }
724 
725  return val;
726 }
727 
729 {
730  int i, j, idx, t;
731  int off[SUBFRAMES];
732  int signs[SUBFRAMES / 2 * 11], pos[SUBFRAMES / 2 * 11];
733  int tmp[SUBFRAME_LEN * 2];
734  int16_t *vector_ptr;
735  int64_t sum;
736  int b0, c, delta, x, shift;
737 
738  p->pitch_lag[0] = cng_rand(&p->cng_random_seed, 21) + 123;
739  p->pitch_lag[1] = cng_rand(&p->cng_random_seed, 19) + 123;
740 
741  for (i = 0; i < SUBFRAMES; i++) {
742  p->subframe[i].ad_cb_gain = cng_rand(&p->cng_random_seed, 50) + 1;
744  }
745 
746  for (i = 0; i < SUBFRAMES / 2; i++) {
747  t = cng_rand(&p->cng_random_seed, 1 << 13);
748  off[i * 2] = t & 1;
749  off[i * 2 + 1] = ((t >> 1) & 1) + SUBFRAME_LEN;
750  t >>= 2;
751  for (j = 0; j < 11; j++) {
752  signs[i * 11 + j] = ((t & 1) * 2 - 1) * (1 << 14);
753  t >>= 1;
754  }
755  }
756 
757  idx = 0;
758  for (i = 0; i < SUBFRAMES; i++) {
759  for (j = 0; j < SUBFRAME_LEN / 2; j++)
760  tmp[j] = j;
761  t = SUBFRAME_LEN / 2;
762  for (j = 0; j < pulses[i]; j++, idx++) {
763  int idx2 = cng_rand(&p->cng_random_seed, t);
764 
765  pos[idx] = tmp[idx2] * 2 + off[i];
766  tmp[idx2] = tmp[--t];
767  }
768  }
769 
770  vector_ptr = p->audio + LPC_ORDER;
771  memcpy(vector_ptr, p->prev_excitation,
772  PITCH_MAX * sizeof(*p->excitation));
773  for (i = 0; i < SUBFRAMES; i += 2) {
774  ff_g723_1_gen_acb_excitation(vector_ptr, vector_ptr,
775  p->pitch_lag[i >> 1], &p->subframe[i],
776  p->cur_rate);
778  vector_ptr + SUBFRAME_LEN,
779  p->pitch_lag[i >> 1], &p->subframe[i + 1],
780  p->cur_rate);
781 
782  t = 0;
783  for (j = 0; j < SUBFRAME_LEN * 2; j++)
784  t |= FFABS(vector_ptr[j]);
785  t = FFMIN(t, 0x7FFF);
786  if (!t) {
787  shift = 0;
788  } else {
789  shift = -10 + av_log2(t);
790  if (shift < -2)
791  shift = -2;
792  }
793  sum = 0;
794  if (shift < 0) {
795  for (j = 0; j < SUBFRAME_LEN * 2; j++) {
796  t = vector_ptr[j] * (1 << -shift);
797  sum += t * t;
798  tmp[j] = t;
799  }
800  } else {
801  for (j = 0; j < SUBFRAME_LEN * 2; j++) {
802  t = vector_ptr[j] >> shift;
803  sum += t * t;
804  tmp[j] = t;
805  }
806  }
807 
808  b0 = 0;
809  for (j = 0; j < 11; j++)
810  b0 += tmp[pos[(i / 2) * 11 + j]] * signs[(i / 2) * 11 + j];
811  b0 = b0 * 2 * 2979LL + (1 << 29) >> 30; // approximated division by 11
812 
813  c = p->cur_gain * (p->cur_gain * SUBFRAME_LEN >> 5);
814  if (shift * 2 + 3 >= 0)
815  c >>= shift * 2 + 3;
816  else
817  c <<= -(shift * 2 + 3);
818  c = (av_clipl_int32(sum << 1) - c) * 2979LL >> 15;
819 
820  delta = b0 * b0 * 2 - c;
821  if (delta <= 0) {
822  x = -b0;
823  } else {
824  delta = square_root(delta);
825  x = delta - b0;
826  t = delta + b0;
827  if (FFABS(t) < FFABS(x))
828  x = -t;
829  }
830  shift++;
831  if (shift < 0)
832  x >>= -shift;
833  else
834  x *= 1 << shift;
835  x = av_clip(x, -10000, 10000);
836 
837  for (j = 0; j < 11; j++) {
838  idx = (i / 2) * 11 + j;
839  vector_ptr[pos[idx]] = av_clip_int16(vector_ptr[pos[idx]] +
840  (x * signs[idx] >> 15));
841  }
842 
843  /* copy decoded data to serve as a history for the next decoded subframes */
844  memcpy(vector_ptr + PITCH_MAX, vector_ptr,
845  sizeof(*vector_ptr) * SUBFRAME_LEN * 2);
846  vector_ptr += SUBFRAME_LEN * 2;
847  }
848  /* Save the excitation for the next frame */
849  memcpy(p->prev_excitation, p->audio + LPC_ORDER + FRAME_LEN,
850  PITCH_MAX * sizeof(*p->excitation));
851 }
852 
853 static int g723_1_decode_frame(AVCodecContext *avctx, void *data,
854  int *got_frame_ptr, AVPacket *avpkt)
855 {
856  G723_1_Context *s = avctx->priv_data;
857  AVFrame *frame = data;
858  const uint8_t *buf = avpkt->data;
859  int buf_size = avpkt->size;
860  int dec_mode = buf[0] & 3;
861 
862  PPFParam ppf[SUBFRAMES];
863  int16_t cur_lsp[LPC_ORDER];
864  int16_t lpc[SUBFRAMES * LPC_ORDER];
865  int16_t acb_vector[SUBFRAME_LEN];
866  int16_t *out;
867  int bad_frame = 0, i, j, ret;
868 
869  if (buf_size < frame_size[dec_mode] * avctx->channels) {
870  if (buf_size)
871  av_log(avctx, AV_LOG_WARNING,
872  "Expected %d bytes, got %d - skipping packet\n",
873  frame_size[dec_mode], buf_size);
874  *got_frame_ptr = 0;
875  return buf_size;
876  }
877 
878  frame->nb_samples = FRAME_LEN;
879  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
880  return ret;
881 
882  for (int ch = 0; ch < avctx->channels; ch++) {
883  G723_1_ChannelContext *p = &s->ch[ch];
884  int16_t *audio = p->audio;
885 
886  if (unpack_bitstream(p, buf + ch * (buf_size / avctx->channels),
887  buf_size / avctx->channels) < 0) {
888  bad_frame = 1;
889  if (p->past_frame_type == ACTIVE_FRAME)
891  else
893  }
894 
895  out = (int16_t *)frame->extended_data[ch];
896 
897  if (p->cur_frame_type == ACTIVE_FRAME) {
898  if (!bad_frame)
899  p->erased_frames = 0;
900  else if (p->erased_frames != 3)
901  p->erased_frames++;
902 
903  ff_g723_1_inverse_quant(cur_lsp, p->prev_lsp, p->lsp_index, bad_frame);
904  ff_g723_1_lsp_interpolate(lpc, cur_lsp, p->prev_lsp);
905 
906  /* Save the lsp_vector for the next frame */
907  memcpy(p->prev_lsp, cur_lsp, LPC_ORDER * sizeof(*p->prev_lsp));
908 
909  /* Generate the excitation for the frame */
910  memcpy(p->excitation, p->prev_excitation,
911  PITCH_MAX * sizeof(*p->excitation));
912  if (!p->erased_frames) {
913  int16_t *vector_ptr = p->excitation + PITCH_MAX;
914 
915  /* Update interpolation gain memory */
917  p->subframe[3].amp_index) >> 1];
918  for (i = 0; i < SUBFRAMES; i++) {
919  gen_fcb_excitation(vector_ptr, &p->subframe[i], p->cur_rate,
920  p->pitch_lag[i >> 1], i);
921  ff_g723_1_gen_acb_excitation(acb_vector,
922  &p->excitation[SUBFRAME_LEN * i],
923  p->pitch_lag[i >> 1],
924  &p->subframe[i], p->cur_rate);
925  /* Get the total excitation */
926  for (j = 0; j < SUBFRAME_LEN; j++) {
927  int v = av_clip_int16(vector_ptr[j] * 2);
928  vector_ptr[j] = av_clip_int16(v + acb_vector[j]);
929  }
930  vector_ptr += SUBFRAME_LEN;
931  }
932 
933  vector_ptr = p->excitation + PITCH_MAX;
934 
936  &p->sid_gain, &p->cur_gain);
937 
938  /* Perform pitch postfiltering */
939  if (s->postfilter) {
940  i = PITCH_MAX;
941  for (j = 0; j < SUBFRAMES; i += SUBFRAME_LEN, j++)
942  comp_ppf_coeff(p, i, p->pitch_lag[j >> 1],
943  ppf + j, p->cur_rate);
944 
945  for (i = 0, j = 0; j < SUBFRAMES; i += SUBFRAME_LEN, j++)
947  vector_ptr + i,
948  vector_ptr + i + ppf[j].index,
949  ppf[j].sc_gain,
950  ppf[j].opt_gain,
951  1 << 14, 15, SUBFRAME_LEN);
952  } else {
953  audio = vector_ptr - LPC_ORDER;
954  }
955 
956  /* Save the excitation for the next frame */
957  memcpy(p->prev_excitation, p->excitation + FRAME_LEN,
958  PITCH_MAX * sizeof(*p->excitation));
959  } else {
960  p->interp_gain = (p->interp_gain * 3 + 2) >> 2;
961  if (p->erased_frames == 3) {
962  /* Mute output */
963  memset(p->excitation, 0,
964  (FRAME_LEN + PITCH_MAX) * sizeof(*p->excitation));
965  memset(p->prev_excitation, 0,
966  PITCH_MAX * sizeof(*p->excitation));
967  memset(frame->data[0], 0,
968  (FRAME_LEN + LPC_ORDER) * sizeof(int16_t));
969  } else {
970  int16_t *buf = p->audio + LPC_ORDER;
971 
972  /* Regenerate frame */
974  p->interp_gain, &p->random_seed);
975 
976  /* Save the excitation for the next frame */
977  memcpy(p->prev_excitation, buf + (FRAME_LEN - PITCH_MAX),
978  PITCH_MAX * sizeof(*p->excitation));
979  }
980  }
982  } else {
983  if (p->cur_frame_type == SID_FRAME) {
986  } else if (p->past_frame_type == ACTIVE_FRAME) {
987  p->sid_gain = estimate_sid_gain(p);
988  }
989 
990  if (p->past_frame_type == ACTIVE_FRAME)
991  p->cur_gain = p->sid_gain;
992  else
993  p->cur_gain = (p->cur_gain * 7 + p->sid_gain) >> 3;
994  generate_noise(p);
996  /* Save the lsp_vector for the next frame */
997  memcpy(p->prev_lsp, p->sid_lsp, LPC_ORDER * sizeof(*p->prev_lsp));
998  }
999 
1001 
1002  memcpy(p->audio, p->synth_mem, LPC_ORDER * sizeof(*p->audio));
1003  for (i = LPC_ORDER, j = 0; j < SUBFRAMES; i += SUBFRAME_LEN, j++)
1004  ff_celp_lp_synthesis_filter(p->audio + i, &lpc[j * LPC_ORDER],
1005  audio + i, SUBFRAME_LEN, LPC_ORDER,
1006  0, 1, 1 << 12);
1007  memcpy(p->synth_mem, p->audio + FRAME_LEN, LPC_ORDER * sizeof(*p->audio));
1008 
1009  if (s->postfilter) {
1010  formant_postfilter(p, lpc, p->audio, out);
1011  } else { // if output is not postfiltered it should be scaled by 2
1012  for (i = 0; i < FRAME_LEN; i++)
1013  out[i] = av_clip_int16(p->audio[LPC_ORDER + i] << 1);
1014  }
1015  }
1016 
1017  *got_frame_ptr = 1;
1018 
1019  return frame_size[dec_mode] * avctx->channels;
1020 }
1021 
1022 #define OFFSET(x) offsetof(G723_1_Context, x)
1023 #define AD AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM
1024 
1025 static const AVOption options[] = {
1026  { "postfilter", "enable postfilter", OFFSET(postfilter), AV_OPT_TYPE_BOOL,
1027  { .i64 = 1 }, 0, 1, AD },
1028  { NULL }
1029 };
1030 
1031 
1032 static const AVClass g723_1dec_class = {
1033  .class_name = "G.723.1 decoder",
1034  .item_name = av_default_item_name,
1035  .option = options,
1036  .version = LIBAVUTIL_VERSION_INT,
1037 };
1038 
1040  .name = "g723_1",
1041  .long_name = NULL_IF_CONFIG_SMALL("G.723.1"),
1042  .type = AVMEDIA_TYPE_AUDIO,
1043  .id = AV_CODEC_ID_G723_1,
1044  .priv_data_size = sizeof(G723_1_Context),
1047  .capabilities = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1,
1048  .priv_class = &g723_1dec_class,
1049 };
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:309
int16_t excitation[PITCH_MAX+FRAME_LEN+4]
Definition: g723_1.h:131
#define NULL
Definition: coverity.c:32
const char const char void * val
Definition: avisynth_c.h:863
static int shift(int a, int b)
Definition: sonic.c:82
int dirac_train
Definition: g723_1.h:83
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
int ad_cb_gain
Definition: g723_1.h:82
AVOption.
Definition: opt.h:246
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
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:209
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
static const int32_t max_pos[4]
Size of the MP-MLQ fixed excitation codebooks.
Definition: g723_1.h:728
#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:35
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:1032
static const int8_t pulses[4]
Number of non-zero pulses in the MP-MLQ excitation.
Definition: g723_1.h:723
int size
Definition: avcodec.h:1478
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi-0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0f/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(INT64_C(1)<< 63)))#define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64),};static void cpy1(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, len);}static void cpy2(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 2 *len);}static void cpy4(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 4 *len);}static void cpy8(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 8 *len);}AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags){AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);}ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map){switch(av_get_bytes_per_sample(in_fmt)){case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;}}if(HAVE_X86ASM &&1) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);return ctx;}void swri_audio_convert_free(AudioConvert **ctx){av_freep(ctx);}int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len){int ch;int off=0;const int os=(out->planar?1:out->ch_count)*out->bps;unsigned misaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask){int planes=in->planar?in->ch_count:1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;}if(ctx->out_simd_align_mask){int planes=out->planar?out->ch_count:1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;}if(ctx->simd_f &&!ctx->ch_map &&!misaligned){off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){if(out->planar==in->planar){int planes=out->planar?out->ch_count:1;for(ch=0;ch< planes;ch++){ctx->simd_f(out-> ch ch
Definition: audioconvert.c:56
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
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 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:488
static void formant_postfilter(G723_1_ChannelContext *p, int16_t *lpc, int16_t *buf, int16_t *dst)
Perform formant filtering.
Definition: g723_1dec.c:585
#define AV_CH_LAYOUT_STEREO
AVCodec.
Definition: avcodec.h:3481
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:42
static int estimate_sid_gain(G723_1_ChannelContext *p)
Definition: g723_1dec.c:668
#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
static struct @315 state
uint8_t base
Definition: vp3data.h:202
#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:201
static const int cng_filt[4]
Definition: g723_1.h:1440
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2233
uint8_t
#define av_cold
Definition: attributes.h:82
#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:728
uint8_t * data
Definition: avcodec.h:1477
static const uint8_t bits2[81]
Definition: aactab.c:140
void av_memcpy_backptr(uint8_t *dst, int back, int cnt)
Overlapping memcpy() implementation.
Definition: mem.c:426
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:180
#define GRID_SIZE
Definition: g723_1.h:46
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
static const int32_t 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.h:630
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int ff_g723_1_normalize_bits(int num, int width)
Calculate the number of left-shifts required for normalizing the input.
Definition: g723_1.c:49
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:186
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:74
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: avcodec.h:3488
#define FFMAX(a, b)
Definition: common.h:94
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2276
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:86
enum FrameType past_frame_type
Definition: g723_1.h:122
#define PITCH_MAX
Definition: g723_1.h:44
static const int16_t fixed_cb_gain[GAIN_LEVELS]
Definition: g723_1.h:730
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.
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_1.h:1383
audio channel layout utility functions
#define FFMIN(a, b)
Definition: common.h:96
AVCodec ff_g723_1_decoder
Definition: g723_1dec.c:1039
static const int cng_adaptive_cb_lag[4]
Definition: g723_1.h:1438
int32_t
int ff_g723_1_dot_product(const int16_t *a, const int16_t *b, int length)
Definition: g723_1.c:54
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:1022
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:276
int iir_mem[LPC_ORDER]
Definition: g723_1.h:134
if(ret)
#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:517
int16_t opt_gain
optimal gain
Definition: g723_1.h:95
int postfilter
Definition: g723_1.h:161
int frame_size
Definition: mxfenc.c:2215
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:357
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:32
Libavcodec external API header.
static const int16_t dc_lsp[LPC_ORDER]
LSP DC component.
Definition: g723_1.h:232
static const int16_t pitch_contrib[340]
Definition: g723_1.h:674
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:542
main external API structure.
Definition: avcodec.h:1565
static const int16_t ppf_gain_weight[2]
Postfilter gain weighting factors scaled by 2^15.
Definition: g723_1.h:227
static int sid_gain_to_lsp_index(int gain)
Definition: g723_1dec.c:652
#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:1964
G.723.1 types, functions and data tables.
void * buf
Definition: avisynth_c.h:766
int16_t fir_mem[LPC_ORDER]
Definition: g723_1.h:133
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:32
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: avcodec.h:1024
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:309
#define SUBFRAMES
Definition: dcaenc.c:50
int16_t synth_mem[LPC_ORDER]
Definition: g723_1.h:132
#define AD
Definition: g723_1dec.c:1023
common internal api header.
Pitch postfilter parameters.
Definition: g723_1.h:93
static int unpack_bitstream(G723_1_ChannelContext *p, const uint8_t *buf, int buf_size)
Unpack the frame into parameters.
Definition: g723_1dec.c:75
void * priv_data
Definition: avcodec.h:1592
enum FrameType cur_frame_type
Definition: g723_1.h:121
static const int cng_bseg[3]
Definition: g723_1.h:1442
int channels
number of audio channels
Definition: avcodec.h:2226
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:193
static const AVOption options[]
Definition: g723_1dec.c:1025
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:443
static av_cold int g723_1_decode_init(AVCodecContext *avctx)
Definition: g723_1dec.c:43
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:662
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:342
#define AV_CH_LAYOUT_MONO
This structure stores compressed data.
Definition: avcodec.h:1454
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:361
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:981
static int g723_1_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: g723_1dec.c:853
static const uint8_t bits1[81]
Definition: aactab.c:117
int ad_cb_lag
adaptive codebook lag
Definition: g723_1.h:81
static uint8_t tmp[11]
Definition: aes_ctr.c:26