FFmpeg: libavcodec/qcelpdec.c Source File

FFmpeg
qcelpdec.c
Go to the documentation of this file.
1 /*
2  * QCELP decoder
3  * Copyright (c) 2007 Reynaldo H. Verdejo Pinochet
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * QCELP decoder
25  * @author Reynaldo H. Verdejo Pinochet
26  * @remark FFmpeg merging spearheaded by Kenan Gillet
27  * @remark Development mentored by Benjamin Larson
28  */
29 
30 #include "libavutil/avassert.h"
31 #include "libavutil/channel_layout.h"
32 #include "libavutil/float_dsp.h"
33 #include "avcodec.h"
34 #include "codec_internal.h"
35 #include "decode.h"
36 #include "get_bits.h"
37 #include "qcelpdata.h"
38 #include "celp_filters.h"
39 #include "acelp_filters.h"
40 #include "acelp_vectors.h"
41 #include "lsp.h"
42 
43  typedef enum {
44   I_F_Q = -1, /**< insufficient frame quality */
45   SILENCE,
46   RATE_OCTAVE,
47   RATE_QUARTER,
48   RATE_HALF,
49   RATE_FULL
50 } qcelp_packet_rate;
51 
52  typedef struct QCELPContext {
53   GetBitContext gb;
54   qcelp_packet_rate bitrate;
55   QCELPFrame frame; /**< unpacked data frame */
56 
57   uint8_t erasure_count;
58   uint8_t octave_count; /**< count the consecutive RATE_OCTAVE frames */
59   float prev_lspf[10];
60   float predictor_lspf[10];/**< LSP predictor for RATE_OCTAVE and I_F_Q */
61   float pitch_synthesis_filter_mem[303];
62   float pitch_pre_filter_mem[303];
63   float rnd_fir_filter_mem[180];
64   float formant_mem[170];
65   float last_codebook_gain;
66   int prev_g1[2];
67   int prev_bitrate;
68   float pitch_gain[4];
69   uint8_t pitch_lag[4];
70   uint16_t first16bits;
71   uint8_t warned_buf_mismatch_bitrate;
72 
73  /* postfilter */
74   float postfilter_synth_mem[10];
75   float postfilter_agc_mem;
76   float postfilter_tilt_mem;
77 } QCELPContext;
78 
79 /**
80  * Initialize the speech codec according to the specification.
81  *
82  * TIA/EIA/IS-733 2.4.9
83  */
84  static av_cold int qcelp_decode_init(AVCodecContext *avctx)
85 {
86  QCELPContext *q = avctx->priv_data;
87  int i;
88 
89  av_channel_layout_uninit(&avctx->ch_layout);
90  avctx->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_MONO;
91  avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
92  if (!avctx->sample_rate)
93  avctx->sample_rate = 8000;
94 
95  for (i = 0; i < 10; i++)
96  q->prev_lspf[i] = (i + 1) / 11.0;
97 
98  return 0;
99 }
100 
101 /**
102  * Decode the 10 quantized LSP frequencies from the LSPV/LSP
103  * transmission codes of any bitrate and check for badly received packets.
104  *
105  * @param q the context
106  * @param lspf line spectral pair frequencies
107  *
108  * @return 0 on success, -1 if the packet is badly received
109  *
110  * TIA/EIA/IS-733 2.4.3.2.6.2-2, 2.4.8.7.3
111  */
112  static int decode_lspf(QCELPContext *q, float *lspf)
113 {
114  int i;
115  float tmp_lspf, smooth, erasure_coeff;
116  const float *predictors;
117 
118  if (q->bitrate == RATE_OCTAVE || q->bitrate == I_F_Q) {
119  predictors = q->prev_bitrate != RATE_OCTAVE &&
120  q->prev_bitrate != I_F_Q ? q->prev_lspf
121  : q->predictor_lspf;
122 
123  if (q->bitrate == RATE_OCTAVE) {
124  q->octave_count++;
125 
126  for (i = 0; i < 10; i++) {
127  q->predictor_lspf[i] =
128  lspf[i] = (q->frame.lspv[i] ? QCELP_LSP_SPREAD_FACTOR
129  : -QCELP_LSP_SPREAD_FACTOR) +
130  predictors[i] * QCELP_LSP_OCTAVE_PREDICTOR +
131  (i + 1) * ((1 - QCELP_LSP_OCTAVE_PREDICTOR) / 11);
132  }
133  smooth = q->octave_count < 10 ? .875 : 0.1;
134  } else {
135  erasure_coeff = QCELP_LSP_OCTAVE_PREDICTOR;
136 
137  av_assert2(q->bitrate == I_F_Q);
138 
139  if (q->erasure_count > 1)
140  erasure_coeff *= q->erasure_count < 4 ? 0.9 : 0.7;
141 
142  for (i = 0; i < 10; i++) {
143  q->predictor_lspf[i] =
144  lspf[i] = (i + 1) * (1 - erasure_coeff) / 11 +
145  erasure_coeff * predictors[i];
146  }
147  smooth = 0.125;
148  }
149 
150  // Check the stability of the LSP frequencies.
151  lspf[0] = FFMAX(lspf[0], QCELP_LSP_SPREAD_FACTOR);
152  for (i = 1; i < 10; i++)
153  lspf[i] = FFMAX(lspf[i], lspf[i - 1] + QCELP_LSP_SPREAD_FACTOR);
154 
155  lspf[9] = FFMIN(lspf[9], 1.0 - QCELP_LSP_SPREAD_FACTOR);
156  for (i = 9; i > 0; i--)
157  lspf[i - 1] = FFMIN(lspf[i - 1], lspf[i] - QCELP_LSP_SPREAD_FACTOR);
158 
159  // Low-pass filter the LSP frequencies.
160  ff_weighted_vector_sumf(lspf, lspf, q->prev_lspf, smooth, 1.0 - smooth, 10);
161  } else {
162  q->octave_count = 0;
163 
164  tmp_lspf = 0.0;
165  for (i = 0; i < 5; i++) {
166  lspf[2 * i + 0] = tmp_lspf += qcelp_lspvq[i][q->frame.lspv[i]][0] * 0.0001;
167  lspf[2 * i + 1] = tmp_lspf += qcelp_lspvq[i][q->frame.lspv[i]][1] * 0.0001;
168  }
169 
170  // Check for badly received packets.
171  if (q->bitrate == RATE_QUARTER) {
172  if (lspf[9] <= .70 || lspf[9] >= .97)
173  return -1;
174  for (i = 3; i < 10; i++)
175  if (fabs(lspf[i] - lspf[i - 2]) < .08)
176  return -1;
177  } else {
178  if (lspf[9] <= .66 || lspf[9] >= .985)
179  return -1;
180  for (i = 4; i < 10; i++)
181  if (fabs(lspf[i] - lspf[i - 4]) < .0931)
182  return -1;
183  }
184  }
185  return 0;
186 }
187 
188 /**
189  * Convert codebook transmission codes to GAIN and INDEX.
190  *
191  * @param q the context
192  * @param gain array holding the decoded gain
193  *
194  * TIA/EIA/IS-733 2.4.6.2
195  */
196  static void decode_gain_and_index(QCELPContext *q, float *gain)
197 {
198  int i, subframes_count, g1[16];
199  float slope;
200 
201  if (q->bitrate >= RATE_QUARTER) {
202  switch (q->bitrate) {
203  case RATE_FULL: subframes_count = 16; break;
204  case RATE_HALF: subframes_count = 4; break;
205  default: subframes_count = 5;
206  }
207  for (i = 0; i < subframes_count; i++) {
208  g1[i] = 4 * q->frame.cbgain[i];
209  if (q->bitrate == RATE_FULL && !((i + 1) & 3)) {
210  g1[i] += av_clip((g1[i - 1] + g1[i - 2] + g1[i - 3]) / 3 - 6, 0, 32);
211  }
212 
213  gain[i] = qcelp_g12ga[g1[i]];
214 
215  if (q->frame.cbsign[i]) {
216  gain[i] = -gain[i];
217  q->frame.cindex[i] = (q->frame.cindex[i] - 89) & 127;
218  }
219  }
220 
221  q->prev_g1[0] = g1[i - 2];
222  q->prev_g1[1] = g1[i - 1];
223  q->last_codebook_gain = qcelp_g12ga[g1[i - 1]];
224 
225  if (q->bitrate == RATE_QUARTER) {
226  // Provide smoothing of the unvoiced excitation energy.
227  gain[7] = gain[4];
228  gain[6] = 0.4 * gain[3] + 0.6 * gain[4];
229  gain[5] = gain[3];
230  gain[4] = 0.8 * gain[2] + 0.2 * gain[3];
231  gain[3] = 0.2 * gain[1] + 0.8 * gain[2];
232  gain[2] = gain[1];
233  gain[1] = 0.6 * gain[0] + 0.4 * gain[1];
234  }
235  } else if (q->bitrate != SILENCE) {
236  if (q->bitrate == RATE_OCTAVE) {
237  g1[0] = 2 * q->frame.cbgain[0] +
238  av_clip((q->prev_g1[0] + q->prev_g1[1]) / 2 - 5, 0, 54);
239  subframes_count = 8;
240  } else {
241  av_assert2(q->bitrate == I_F_Q);
242 
243  g1[0] = q->prev_g1[1];
244  switch (q->erasure_count) {
245  case 1 : break;
246  case 2 : g1[0] -= 1; break;
247  case 3 : g1[0] -= 2; break;
248  default: g1[0] -= 6;
249  }
250  if (g1[0] < 0)
251  g1[0] = 0;
252  subframes_count = 4;
253  }
254  // This interpolation is done to produce smoother background noise.
255  slope = 0.5 * (qcelp_g12ga[g1[0]] - q->last_codebook_gain) / subframes_count;
256  for (i = 1; i <= subframes_count; i++)
257  gain[i - 1] = q->last_codebook_gain + slope * i;
258 
259  q->last_codebook_gain = gain[i - 2];
260  q->prev_g1[0] = q->prev_g1[1];
261  q->prev_g1[1] = g1[0];
262  }
263 }
264 
265 /**
266  * If the received packet is Rate 1/4 a further sanity check is made of the
267  * codebook gain.
268  *
269  * @param cbgain the unpacked cbgain array
270  * @return -1 if the sanity check fails, 0 otherwise
271  *
272  * TIA/EIA/IS-733 2.4.8.7.3
273  */
274  static int codebook_sanity_check_for_rate_quarter(const uint8_t *cbgain)
275 {
276  int i, diff, prev_diff = 0;
277 
278  for (i = 1; i < 5; i++) {
279  diff = cbgain[i] - cbgain[i-1];
280  if (FFABS(diff) > 10)
281  return -1;
282  else if (FFABS(diff - prev_diff) > 12)
283  return -1;
284  prev_diff = diff;
285  }
286  return 0;
287 }
288 
289 /**
290  * Compute the scaled codebook vector Cdn From INDEX and GAIN
291  * for all rates.
292  *
293  * The specification lacks some information here.
294  *
295  * TIA/EIA/IS-733 has an omission on the codebook index determination
296  * formula for RATE_FULL and RATE_HALF frames at section 2.4.8.1.1. It says
297  * you have to subtract the decoded index parameter from the given scaled
298  * codebook vector index 'n' to get the desired circular codebook index, but
299  * it does not mention that you have to clamp 'n' to [0-9] in order to get
300  * RI-compliant results.
301  *
302  * The reason for this mistake seems to be the fact they forgot to mention you
303  * have to do these calculations per codebook subframe and adjust given
304  * equation values accordingly.
305  *
306  * @param q the context
307  * @param gain array holding the 4 pitch subframe gain values
308  * @param cdn_vector array for the generated scaled codebook vector
309  */
310  static void compute_svector(QCELPContext *q, const float *gain,
311  float *cdn_vector)
312 {
313  int i, j, k;
314  uint16_t cbseed, cindex;
315  float *rnd, tmp_gain, fir_filter_value;
316 
317  switch (q->bitrate) {
318  case RATE_FULL:
319  for (i = 0; i < 16; i++) {
320  tmp_gain = gain[i] * QCELP_RATE_FULL_CODEBOOK_RATIO;
321  cindex = -q->frame.cindex[i];
322  for (j = 0; j < 10; j++)
323  *cdn_vector++ = tmp_gain *
324  qcelp_rate_full_codebook[cindex++ & 127];
325  }
326  break;
327  case RATE_HALF:
328  for (i = 0; i < 4; i++) {
329  tmp_gain = gain[i] * QCELP_RATE_HALF_CODEBOOK_RATIO;
330  cindex = -q->frame.cindex[i];
331  for (j = 0; j < 40; j++)
332  *cdn_vector++ = tmp_gain *
333  qcelp_rate_half_codebook[cindex++ & 127];
334  }
335  break;
336  case RATE_QUARTER:
337  cbseed = (0x0003 & q->frame.lspv[4]) << 14 |
338  (0x003F & q->frame.lspv[3]) << 8 |
339  (0x0060 & q->frame.lspv[2]) << 1 |
340  (0x0007 & q->frame.lspv[1]) << 3 |
341  (0x0038 & q->frame.lspv[0]) >> 3;
342  rnd = q->rnd_fir_filter_mem + 20;
343  for (i = 0; i < 8; i++) {
344  tmp_gain = gain[i] * (QCELP_SQRT1887 / 32768.0);
345  for (k = 0; k < 20; k++) {
346  cbseed = 521 * cbseed + 259;
347  *rnd = (int16_t) cbseed;
348 
349  // FIR filter
350  fir_filter_value = 0.0;
351  for (j = 0; j < 10; j++)
352  fir_filter_value += qcelp_rnd_fir_coefs[j] *
353  (rnd[-j] + rnd[-20+j]);
354 
355  fir_filter_value += qcelp_rnd_fir_coefs[10] * rnd[-10];
356  *cdn_vector++ = tmp_gain * fir_filter_value;
357  rnd++;
358  }
359  }
360  memcpy(q->rnd_fir_filter_mem, q->rnd_fir_filter_mem + 160,
361  20 * sizeof(float));
362  break;
363  case RATE_OCTAVE:
364  cbseed = q->first16bits;
365  for (i = 0; i < 8; i++) {
366  tmp_gain = gain[i] * (QCELP_SQRT1887 / 32768.0);
367  for (j = 0; j < 20; j++) {
368  cbseed = 521 * cbseed + 259;
369  *cdn_vector++ = tmp_gain * (int16_t) cbseed;
370  }
371  }
372  break;
373  case I_F_Q:
374  cbseed = -44; // random codebook index
375  for (i = 0; i < 4; i++) {
376  tmp_gain = gain[i] * QCELP_RATE_FULL_CODEBOOK_RATIO;
377  for (j = 0; j < 40; j++)
378  *cdn_vector++ = tmp_gain *
379  qcelp_rate_full_codebook[cbseed++ & 127];
380  }
381  break;
382  case SILENCE:
383  memset(cdn_vector, 0, 160 * sizeof(float));
384  break;
385  }
386 }
387 
388 /**
389  * Apply generic gain control.
390  *
391  * @param v_out output vector
392  * @param v_in gain-controlled vector
393  * @param v_ref vector to control gain of
394  *
395  * TIA/EIA/IS-733 2.4.8.3, 2.4.8.6
396  */
397  static void apply_gain_ctrl(float *v_out, const float *v_ref, const float *v_in)
398 {
399  int i;
400 
401  for (i = 0; i < 160; i += 40) {
402  float res = ff_scalarproduct_float_c(v_ref + i, v_ref + i, 40);
403  ff_scale_vector_to_given_sum_of_squares(v_out + i, v_in + i, res, 40);
404  }
405 }
406 
407 /**
408  * Apply filter in pitch-subframe steps.
409  *
410  * @param memory buffer for the previous state of the filter
411  * - must be able to contain 303 elements
412  * - the 143 first elements are from the previous state
413  * - the next 160 are for output
414  * @param v_in input filter vector
415  * @param gain per-subframe gain array, each element is between 0.0 and 2.0
416  * @param lag per-subframe lag array, each element is
417  * - between 16 and 143 if its corresponding pfrac is 0,
418  * - between 16 and 139 otherwise
419  * @param pfrac per-subframe boolean array, 1 if the lag is fractional, 0
420  * otherwise
421  *
422  * @return filter output vector
423  */
424  static const float *do_pitchfilter(float memory[303], const float v_in[160],
425  const float gain[4], const uint8_t *lag,
426  const uint8_t pfrac[4])
427 {
428  int i, j;
429  float *v_lag, *v_out;
430  const float *v_len;
431 
432  v_out = memory + 143; // Output vector starts at memory[143].
433 
434  for (i = 0; i < 4; i++) {
435  if (gain[i]) {
436  v_lag = memory + 143 + 40 * i - lag[i];
437  for (v_len = v_in + 40; v_in < v_len; v_in++) {
438  if (pfrac[i]) { // If it is a fractional lag...
439  for (j = 0, *v_out = 0.0; j < 4; j++)
440  *v_out += qcelp_hammsinc_table[j] *
441  (v_lag[j - 4] + v_lag[3 - j]);
442  } else
443  *v_out = *v_lag;
444 
445  *v_out = *v_in + gain[i] * *v_out;
446 
447  v_lag++;
448  v_out++;
449  }
450  } else {
451  memcpy(v_out, v_in, 40 * sizeof(float));
452  v_in += 40;
453  v_out += 40;
454  }
455  }
456 
457  memmove(memory, memory + 160, 143 * sizeof(float));
458  return memory + 143;
459 }
460 
461 /**
462  * Apply pitch synthesis filter and pitch prefilter to the scaled codebook vector.
463  * TIA/EIA/IS-733 2.4.5.2, 2.4.8.7.2
464  *
465  * @param q the context
466  * @param cdn_vector the scaled codebook vector
467  */
468  static void apply_pitch_filters(QCELPContext *q, float *cdn_vector)
469 {
470  int i;
471  const float *v_synthesis_filtered, *v_pre_filtered;
472 
473  if (q->bitrate >= RATE_HALF || q->bitrate == SILENCE ||
474  (q->bitrate == I_F_Q && (q->prev_bitrate >= RATE_HALF))) {
475 
476  if (q->bitrate >= RATE_HALF) {
477  // Compute gain & lag for the whole frame.
478  for (i = 0; i < 4; i++) {
479  q->pitch_gain[i] = q->frame.plag[i] ? (q->frame.pgain[i] + 1) * 0.25 : 0.0;
480 
481  q->pitch_lag[i] = q->frame.plag[i] + 16;
482  }
483  } else {
484  float max_pitch_gain;
485 
486  if (q->bitrate == I_F_Q) {
487  if (q->erasure_count < 3)
488  max_pitch_gain = 0.9 - 0.3 * (q->erasure_count - 1);
489  else
490  max_pitch_gain = 0.0;
491  } else {
492  av_assert2(q->bitrate == SILENCE);
493  max_pitch_gain = 1.0;
494  }
495  for (i = 0; i < 4; i++)
496  q->pitch_gain[i] = FFMIN(q->pitch_gain[i], max_pitch_gain);
497 
498  memset(q->frame.pfrac, 0, sizeof(q->frame.pfrac));
499  }
500 
501  // pitch synthesis filter
502  v_synthesis_filtered = do_pitchfilter(q->pitch_synthesis_filter_mem,
503  cdn_vector, q->pitch_gain,
504  q->pitch_lag, q->frame.pfrac);
505 
506  // pitch prefilter update
507  for (i = 0; i < 4; i++)
508  q->pitch_gain[i] = 0.5 * FFMIN(q->pitch_gain[i], 1.0);
509 
510  v_pre_filtered = do_pitchfilter(q->pitch_pre_filter_mem,
511  v_synthesis_filtered,
512  q->pitch_gain, q->pitch_lag,
513  q->frame.pfrac);
514 
515  apply_gain_ctrl(cdn_vector, v_synthesis_filtered, v_pre_filtered);
516  } else {
517  memcpy(q->pitch_synthesis_filter_mem,
518  cdn_vector + 17, 143 * sizeof(float));
519  memcpy(q->pitch_pre_filter_mem, cdn_vector + 17, 143 * sizeof(float));
520  memset(q->pitch_gain, 0, sizeof(q->pitch_gain));
521  memset(q->pitch_lag, 0, sizeof(q->pitch_lag));
522  }
523 }
524 
525 /**
526  * Reconstruct LPC coefficients from the line spectral pair frequencies
527  * and perform bandwidth expansion.
528  *
529  * @param lspf line spectral pair frequencies
530  * @param lpc linear predictive coding coefficients
531  *
532  * @note: bandwidth_expansion_coeff could be precalculated into a table
533  * but it seems to be slower on x86
534  *
535  * TIA/EIA/IS-733 2.4.3.3.5
536  */
537  static void lspf2lpc(const float *lspf, float *lpc)
538 {
539  double lsp[10];
540  double bandwidth_expansion_coeff = QCELP_BANDWIDTH_EXPANSION_COEFF;
541  int i;
542 
543  for (i = 0; i < 10; i++)
544  lsp[i] = cos(M_PI * lspf[i]);
545 
546  ff_acelp_lspd2lpc(lsp, lpc, 5);
547 
548  for (i = 0; i < 10; i++) {
549  lpc[i] *= bandwidth_expansion_coeff;
550  bandwidth_expansion_coeff *= QCELP_BANDWIDTH_EXPANSION_COEFF;
551  }
552 }
553 
554 /**
555  * Interpolate LSP frequencies and compute LPC coefficients
556  * for a given bitrate & pitch subframe.
557  *
558  * TIA/EIA/IS-733 2.4.3.3.4, 2.4.8.7.2
559  *
560  * @param q the context
561  * @param curr_lspf LSP frequencies vector of the current frame
562  * @param lpc float vector for the resulting LPC
563  * @param subframe_num frame number in decoded stream
564  */
565  static void interpolate_lpc(QCELPContext *q, const float *curr_lspf,
566  float *lpc, const int subframe_num)
567 {
568  float interpolated_lspf[10];
569  float weight;
570 
571  if (q->bitrate >= RATE_QUARTER)
572  weight = 0.25 * (subframe_num + 1);
573  else if (q->bitrate == RATE_OCTAVE && !subframe_num)
574  weight = 0.625;
575  else
576  weight = 1.0;
577 
578  if (weight != 1.0) {
579  ff_weighted_vector_sumf(interpolated_lspf, curr_lspf, q->prev_lspf,
580  weight, 1.0 - weight, 10);
581  lspf2lpc(interpolated_lspf, lpc);
582  } else if (q->bitrate >= RATE_QUARTER ||
583  (q->bitrate == I_F_Q && !subframe_num))
584  lspf2lpc(curr_lspf, lpc);
585  else if (q->bitrate == SILENCE && !subframe_num)
586  lspf2lpc(q->prev_lspf, lpc);
587 }
588 
589  static qcelp_packet_rate buf_size2bitrate(const int buf_size)
590 {
591  switch (buf_size) {
592  case 35: return RATE_FULL;
593  case 17: return RATE_HALF;
594  case 8: return RATE_QUARTER;
595  case 4: return RATE_OCTAVE;
596  case 1: return SILENCE;
597  }
598 
599  return I_F_Q;
600 }
601 
602 /**
603  * Determine the bitrate from the frame size and/or the first byte of the frame.
604  *
605  * @param avctx the AV codec context
606  * @param buf_size length of the buffer
607  * @param buf the buffer
608  *
609  * @return the bitrate on success,
610  * I_F_Q if the bitrate cannot be satisfactorily determined
611  *
612  * TIA/EIA/IS-733 2.4.8.7.1
613  */
614  static qcelp_packet_rate determine_bitrate(AVCodecContext *avctx,
615  const int buf_size,
616  const uint8_t **buf)
617 {
618  qcelp_packet_rate bitrate;
619 
620  if ((bitrate = buf_size2bitrate(buf_size)) >= 0) {
621  if (bitrate > **buf) {
622  QCELPContext *q = avctx->priv_data;
623  if (!q->warned_buf_mismatch_bitrate) {
624  av_log(avctx, AV_LOG_WARNING,
625  "Claimed bitrate and buffer size mismatch.\n");
626  q->warned_buf_mismatch_bitrate = 1;
627  }
628  bitrate = **buf;
629  } else if (bitrate < **buf) {
630  av_log(avctx, AV_LOG_ERROR,
631  "Buffer is too small for the claimed bitrate.\n");
632  return I_F_Q;
633  }
634  (*buf)++;
635  } else if ((bitrate = buf_size2bitrate(buf_size + 1)) >= 0) {
636  av_log(avctx, AV_LOG_WARNING,
637  "Bitrate byte missing, guessing bitrate from packet size.\n");
638  } else
639  return I_F_Q;
640 
641  if (bitrate == SILENCE) {
642  // FIXME: Remove this warning when tested with samples.
643  avpriv_request_sample(avctx, "Blank frame handling");
644  }
645  return bitrate;
646 }
647 
648  static void warn_insufficient_frame_quality(AVCodecContext *avctx,
649  const char *message)
650 {
651  av_log(avctx, AV_LOG_WARNING, "Frame #%"PRId64", IFQ: %s\n",
652  avctx->frame_num, message);
653 }
654 
655  static void postfilter(QCELPContext *q, float *samples, float *lpc)
656 {
657  static const float pow_0_775[10] = {
658  0.775000, 0.600625, 0.465484, 0.360750, 0.279582,
659  0.216676, 0.167924, 0.130141, 0.100859, 0.078166
660  }, pow_0_625[10] = {
661  0.625000, 0.390625, 0.244141, 0.152588, 0.095367,
662  0.059605, 0.037253, 0.023283, 0.014552, 0.009095
663  };
664  float lpc_s[10], lpc_p[10], pole_out[170], zero_out[160];
665  int n;
666 
667  for (n = 0; n < 10; n++) {
668  lpc_s[n] = lpc[n] * pow_0_625[n];
669  lpc_p[n] = lpc[n] * pow_0_775[n];
670  }
671 
672  ff_celp_lp_zero_synthesis_filterf(zero_out, lpc_s,
673  q->formant_mem + 10, 160, 10);
674  memcpy(pole_out, q->postfilter_synth_mem, sizeof(float) * 10);
675  ff_celp_lp_synthesis_filterf(pole_out + 10, lpc_p, zero_out, 160, 10);
676  memcpy(q->postfilter_synth_mem, pole_out + 160, sizeof(float) * 10);
677 
678  ff_tilt_compensation(&q->postfilter_tilt_mem, 0.3, pole_out + 10, 160);
679 
680  ff_adaptive_gain_control(samples, pole_out + 10,
681  ff_scalarproduct_float_c(q->formant_mem + 10,
682  q->formant_mem + 10,
683  160),
684  160, 0.9375, &q->postfilter_agc_mem);
685 }
686 
687  static int qcelp_decode_frame(AVCodecContext *avctx, AVFrame *frame,
688  int *got_frame_ptr, AVPacket *avpkt)
689 {
690  const uint8_t *buf = avpkt->data;
691  int buf_size = avpkt->size;
692  QCELPContext *q = avctx->priv_data;
693  float *outbuffer;
694  int i, ret;
695  float quantized_lspf[10], lpc[10];
696  float gain[16];
697  float *formant_mem;
698 
699  /* get output buffer */
700  frame->nb_samples = 160;
701  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
702  return ret;
703  outbuffer = (float *)frame->data[0];
704 
705  if ((q->bitrate = determine_bitrate(avctx, buf_size, &buf)) == I_F_Q) {
706  warn_insufficient_frame_quality(avctx, "Bitrate cannot be determined.");
707  goto erasure;
708  }
709 
710  if (q->bitrate == RATE_OCTAVE &&
711  (q->first16bits = AV_RB16(buf)) == 0xFFFF) {
712  warn_insufficient_frame_quality(avctx, "Bitrate is 1/8 and first 16 bits are on.");
713  goto erasure;
714  }
715 
716  if (q->bitrate > SILENCE) {
717  const QCELPBitmap *bitmaps = qcelp_unpacking_bitmaps_per_rate[q->bitrate];
718  const QCELPBitmap *bitmaps_end = qcelp_unpacking_bitmaps_per_rate[q->bitrate] +
719  qcelp_unpacking_bitmaps_lengths[q->bitrate];
720  uint8_t *unpacked_data = (uint8_t *)&q->frame;
721 
722  if ((ret = init_get_bits8(&q->gb, buf, buf_size)) < 0)
723  return ret;
724 
725  memset(&q->frame, 0, sizeof(QCELPFrame));
726 
727  for (; bitmaps < bitmaps_end; bitmaps++)
728  unpacked_data[bitmaps->index] |= get_bits(&q->gb, bitmaps->bitlen) << bitmaps->bitpos;
729 
730  // Check for erasures/blanks on rates 1, 1/4 and 1/8.
731  if (q->frame.reserved) {
732  warn_insufficient_frame_quality(avctx, "Wrong data in reserved frame area.");
733  goto erasure;
734  }
735  if (q->bitrate == RATE_QUARTER &&
736  codebook_sanity_check_for_rate_quarter(q->frame.cbgain)) {
737  warn_insufficient_frame_quality(avctx, "Codebook gain sanity check failed.");
738  goto erasure;
739  }
740 
741  if (q->bitrate >= RATE_HALF) {
742  for (i = 0; i < 4; i++) {
743  if (q->frame.pfrac[i] && q->frame.plag[i] >= 124) {
744  warn_insufficient_frame_quality(avctx, "Cannot initialize pitch filter.");
745  goto erasure;
746  }
747  }
748  }
749  }
750 
751  decode_gain_and_index(q, gain);
752  compute_svector(q, gain, outbuffer);
753 
754  if (decode_lspf(q, quantized_lspf) < 0) {
755  warn_insufficient_frame_quality(avctx, "Badly received packets in frame.");
756  goto erasure;
757  }
758 
759  apply_pitch_filters(q, outbuffer);
760 
761  if (q->bitrate == I_F_Q) {
762 erasure:
763  q->bitrate = I_F_Q;
764  q->erasure_count++;
765  decode_gain_and_index(q, gain);
766  compute_svector(q, gain, outbuffer);
767  decode_lspf(q, quantized_lspf);
768  apply_pitch_filters(q, outbuffer);
769  } else
770  q->erasure_count = 0;
771 
772  formant_mem = q->formant_mem + 10;
773  for (i = 0; i < 4; i++) {
774  interpolate_lpc(q, quantized_lspf, lpc, i);
775  ff_celp_lp_synthesis_filterf(formant_mem, lpc,
776  outbuffer + i * 40, 40, 10);
777  formant_mem += 40;
778  }
779 
780  // postfilter, as per TIA/EIA/IS-733 2.4.8.6
781  postfilter(q, outbuffer, lpc);
782 
783  memcpy(q->formant_mem, q->formant_mem + 160, 10 * sizeof(float));
784 
785  memcpy(q->prev_lspf, quantized_lspf, sizeof(q->prev_lspf));
786  q->prev_bitrate = q->bitrate;
787 
788  *got_frame_ptr = 1;
789 
790  return buf_size;
791 }
792 
793  const FFCodec ff_qcelp_decoder = {
794  .p.name = "qcelp",
795  CODEC_LONG_NAME("QCELP / PureVoice"),
796  .p.type = AVMEDIA_TYPE_AUDIO,
797  .p.id = AV_CODEC_ID_QCELP,
798  .init = qcelp_decode_init,
799  FF_CODEC_DECODE_CB(qcelp_decode_frame),
800  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
801  .priv_data_size = sizeof(QCELPContext),
802 };
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:216
codebook_sanity_check_for_rate_quarter
static int codebook_sanity_check_for_rate_quarter(const uint8_t *cbgain)
If the received packet is Rate 1/4 a further sanity check is made of the codebook gain.
Definition: qcelpdec.c:274
av_clip
#define av_clip
Definition: common.h:100
SILENCE
@ SILENCE
Definition: qcelpdec.c:45
acelp_vectors.h
qcelp_lspvq
static const qcelp_vector *const qcelp_lspvq[5]
Definition: qcelpdata.h:414
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1024
QCELPContext::erasure_count
uint8_t erasure_count
Definition: qcelpdec.c:57
message
Definition: api-threadmessage-test.c:47
QCELPContext::pitch_lag
uint8_t pitch_lag[4]
Definition: qcelpdec.c:69
QCELPContext::gb
GetBitContext gb
Definition: qcelpdec.c:53
qcelp_unpacking_bitmaps_per_rate
static const QCELPBitmap *const qcelp_unpacking_bitmaps_per_rate[5]
Bitmapping data position for each packet type in the QCELPContext.
Definition: qcelpdata.h:268
QCELPFrame::cindex
uint8_t cindex[16]
codebook index for each codebook subframe
Definition: qcelpdata.h:45
qcelp_rate_full_codebook
static const int16_t qcelp_rate_full_codebook[128]
Circular codebook for rate 1 frames in x*100 form.
Definition: qcelpdata.h:459
QCELP_LSP_OCTAVE_PREDICTOR
#define QCELP_LSP_OCTAVE_PREDICTOR
Predictor coefficient for the conversion of LSP codes to LSP frequencies for 1/8 and I_F_Q.
Definition: qcelpdata.h:541
qcelp_decode_init
static av_cold int qcelp_decode_init(AVCodecContext *avctx)
Initialize the speech codec according to the specification.
Definition: qcelpdec.c:84
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:427
AVPacket::data
uint8_t * data
Definition: packet.h:588
qcelp_decode_frame
static int qcelp_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)
Definition: qcelpdec.c:687
FFCodec
Definition: codec_internal.h:127
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
QCELPContext::postfilter_synth_mem
float postfilter_synth_mem[10]
Definition: qcelpdec.c:74
qcelp_packet_rate
qcelp_packet_rate
Definition: qcelpdec.c:43
QCELPFrame::lspv
uint8_t lspv[10]
line spectral pair frequencies (LSP) for RATE_OCTAVE, line spectral pair frequencies grouped into fiv...
Definition: qcelpdata.h:60
ff_celp_lp_synthesis_filterf
void ff_celp_lp_synthesis_filterf(float *out, const float *filter_coeffs, const float *in, int buffer_length, int filter_length)
LP synthesis filter.
Definition: celp_filters.c:86
RATE_FULL
@ RATE_FULL
Definition: qcelpdec.c:49
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:337
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
QCELPContext::prev_g1
int prev_g1[2]
Definition: qcelpdec.c:66
QCELP_SQRT1887
#define QCELP_SQRT1887
sqrt(1.887) is the maximum of the pseudorandom white sequence used to generate the scaled codebook ve...
Definition: qcelpdata.h:511
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:1039
QCELPBitmap::index
uint8_t index
index into the QCELPContext structure
Definition: qcelpdata.h:77
GetBitContext
Definition: get_bits.h:109
QCELPFrame::plag
uint8_t plag[4]
pitch lag for each pitch subframe
Definition: qcelpdata.h:50
RATE_OCTAVE
@ RATE_OCTAVE
Definition: qcelpdec.c:46
weight
const h264_weight_func weight
Definition: h264dsp_init.c:33
ff_adaptive_gain_control
void ff_adaptive_gain_control(float *out, const float *in, float speech_energ, int size, float alpha, float *gain_mem)
Adaptive gain control (as used in AMR postfiltering)
Definition: acelp_vectors.c:192
avassert.h
rnd
#define rnd()
Definition: checkasm.h:191
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
av_cold
#define av_cold
Definition: attributes.h:106
do_pitchfilter
static const float * do_pitchfilter(float memory[303], const float v_in[160], const float gain[4], const uint8_t *lag, const uint8_t pfrac[4])
Apply filter in pitch-subframe steps.
Definition: qcelpdec.c:424
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:544
QCELP_LSP_SPREAD_FACTOR
#define QCELP_LSP_SPREAD_FACTOR
This spread factor is used, for bitrate 1/8 and I_F_Q, to force LSP frequencies to be at least 80 Hz ...
Definition: qcelpdata.h:533
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:347
buf_size2bitrate
static qcelp_packet_rate buf_size2bitrate(const int buf_size)
Definition: qcelpdec.c:589
QCELPContext::formant_mem
float formant_mem[170]
Definition: qcelpdec.c:64
bitrate
int64_t bitrate
Definition: av1_levels.c:47
qcelp_unpacking_bitmaps_lengths
static const uint16_t qcelp_unpacking_bitmaps_lengths[5]
Definition: qcelpdata.h:276
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:201
decode.h
get_bits.h
QCELPContext::first16bits
uint16_t first16bits
Definition: qcelpdec.c:70
qcelp_rate_half_codebook
static const int8_t qcelp_rate_half_codebook[128]
Circular codebook for rate 1/2 frames in x*2 form.
Definition: qcelpdata.h:484
qcelp_hammsinc_table
static const float qcelp_hammsinc_table[4]
Pre-calculated table for hammsinc function.
Definition: qcelpdata.h:74
I_F_Q
@ I_F_Q
insufficient frame quality
Definition: qcelpdec.c:44
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:332
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:74
QCELPContext::pitch_gain
float pitch_gain[4]
Definition: qcelpdec.c:68
if
if(ret)
Definition: filter_design.txt:179
QCELPContext::rnd_fir_filter_mem
float rnd_fir_filter_mem[180]
Definition: qcelpdec.c:63
fabs
static __device__ float fabs(float a)
Definition: cuda_runtime.h:182
apply_pitch_filters
static void apply_pitch_filters(QCELPContext *q, float *cdn_vector)
Apply pitch synthesis filter and pitch prefilter to the scaled codebook vector.
Definition: qcelpdec.c:468
QCELPFrame::cbsign
uint8_t cbsign[16]
sign of the codebook gain for each codebook subframe
Definition: qcelpdata.h:43
QCELPContext::predictor_lspf
float predictor_lspf[10]
LSP predictor for RATE_OCTAVE and I_F_Q.
Definition: qcelpdec.c:60
QCELPContext::warned_buf_mismatch_bitrate
uint8_t warned_buf_mismatch_bitrate
Definition: qcelpdec.c:71
QCELPContext::prev_bitrate
int prev_bitrate
Definition: qcelpdec.c:67
celp_filters.h
QCELPContext::postfilter_agc_mem
float postfilter_agc_mem
Definition: qcelpdec.c:75
lspf2lpc
static void lspf2lpc(const float *lspf, float *lpc)
Reconstruct LPC coefficients from the line spectral pair frequencies and perform bandwidth expansion.
Definition: qcelpdec.c:537
float_dsp.h
QCELPContext::prev_lspf
float prev_lspf[10]
Definition: qcelpdec.c:59
ff_scalarproduct_float_c
float ff_scalarproduct_float_c(const float *v1, const float *v2, int len)
Return the scalar product of two vectors of floats.
Definition: float_scalarproduct.c:24
AV_CODEC_CAP_CHANNEL_CONF
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:91
warn_insufficient_frame_quality
static void warn_insufficient_frame_quality(AVCodecContext *avctx, const char *message)
Definition: qcelpdec.c:648
AV_CODEC_ID_QCELP
@ AV_CODEC_ID_QCELP
Definition: codec_id.h:483
QCELPFrame::pgain
uint8_t pgain[4]
pitch gain for each pitch subframe
Definition: qcelpdata.h:52
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1728
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
QCELPContext::bitrate
qcelp_packet_rate bitrate
Definition: qcelpdec.c:54
AVPacket::size
int size
Definition: packet.h:589
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:319
codec_internal.h
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1031
QCELPBitmap::bitlen
uint8_t bitlen
number of bits to read
Definition: qcelpdata.h:79
diff
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
Definition: vf_paletteuse.c:166
interpolate_lpc
static void interpolate_lpc(QCELPContext *q, const float *curr_lspf, float *lpc, const int subframe_num)
Interpolate LSP frequencies and compute LPC coefficients for a given bitrate & pitch subframe.
Definition: qcelpdec.c:565
QCELPFrame
QCELP unpacked data frame.
Definition: qcelpdata.h:40
M_PI
#define M_PI
Definition: mathematics.h:67
ff_tilt_compensation
void ff_tilt_compensation(float *mem, float tilt, float *samples, int size)
Apply tilt compensation filter, 1 - tilt * z-1.
Definition: acelp_filters.c:138
QCELPBitmap
Definition: qcelpdata.h:76
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:68
qcelpdata.h
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
apply_gain_ctrl
static void apply_gain_ctrl(float *v_out, const float *v_ref, const float *v_in)
Apply generic gain control.
Definition: qcelpdec.c:397
QCELPBitmap::bitpos
uint8_t bitpos
position of the lowest bit in the value's byte
Definition: qcelpdata.h:78
QCELPContext::octave_count
uint8_t octave_count
count the consecutive RATE_OCTAVE frames
Definition: qcelpdec.c:58
decode_lspf
static int decode_lspf(QCELPContext *q, float *lspf)
Decode the 10 quantized LSP frequencies from the LSPV/LSP transmission codes of any bitrate and check...
Definition: qcelpdec.c:112
determine_bitrate
static qcelp_packet_rate determine_bitrate(AVCodecContext *avctx, const int buf_size, const uint8_t **buf)
Determine the bitrate from the frame size and/or the first byte of the frame.
Definition: qcelpdec.c:614
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
acelp_filters.h
ff_weighted_vector_sumf
void ff_weighted_vector_sumf(float *out, const float *in_a, const float *in_b, float weight_coeff_a, float weight_coeff_b, int length)
float implementation of weighted sum of two vectors.
Definition: acelp_vectors.c:182
qcelp_g12ga
static const float qcelp_g12ga[61]
Table for computing Ga (decoded linear codebook gain magnitude)
Definition: qcelpdata.h:436
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:179
QCELPContext::pitch_pre_filter_mem
float pitch_pre_filter_mem[303]
Definition: qcelpdec.c:62
avcodec.h
AVCodecContext::frame_num
int64_t frame_num
Frame counter, set by libavcodec.
Definition: avcodec.h:1878
ret
ret
Definition: filter_design.txt:187
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:265
lsp.h
ff_celp_lp_zero_synthesis_filterf
void ff_celp_lp_zero_synthesis_filterf(float *out, const float *filter_coeffs, const float *in, int buffer_length, int filter_length)
LP zero synthesis filter.
Definition: celp_filters.c:201
compute_svector
static void compute_svector(QCELPContext *q, const float *gain, float *cdn_vector)
Compute the scaled codebook vector Cdn From INDEX and GAIN for all rates.
Definition: qcelpdec.c:310
QCELPContext::postfilter_tilt_mem
float postfilter_tilt_mem
Definition: qcelpdec.c:76
AVCodecContext
main external API structure.
Definition: avcodec.h:431
RATE_HALF
@ RATE_HALF
Definition: qcelpdec.c:48
channel_layout.h
decode_gain_and_index
static void decode_gain_and_index(QCELPContext *q, float *gain)
Convert codebook transmission codes to GAIN and INDEX.
Definition: qcelpdec.c:196
QCELPContext
Definition: qcelpdec.c:52
av_channel_layout_uninit
void av_channel_layout_uninit(AVChannelLayout *channel_layout)
Free any allocated data in the channel layout and reset the channel count to 0.
Definition: channel_layout.c:442
QCELP_BANDWIDTH_EXPANSION_COEFF
#define QCELP_BANDWIDTH_EXPANSION_COEFF
Initial coefficient to perform bandwidth expansion on LPC.
Definition: qcelpdata.h:550
RATE_QUARTER
@ RATE_QUARTER
Definition: qcelpdec.c:47
samples
Filter the word "frame" indicates either a video frame or a group of audio samples
Definition: filter_design.txt:8
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:37
QCELPContext::frame
QCELPFrame frame
unpacked data frame
Definition: qcelpdec.c:55
QCELP_RATE_HALF_CODEBOOK_RATIO
#define QCELP_RATE_HALF_CODEBOOK_RATIO
Definition: qcelpdata.h:502
AV_CHANNEL_LAYOUT_MONO
#define AV_CHANNEL_LAYOUT_MONO
Definition: channel_layout.h:394
smooth
static float smooth(DeshakeOpenCLContext *deshake_ctx, float *gauss_kernel, int length, float max_val, AVFifo *values)
Definition: vf_deshake_opencl.c:887
AVPacket
This structure stores compressed data.
Definition: packet.h:565
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:458
ff_qcelp_decoder
const FFCodec ff_qcelp_decoder
Definition: qcelpdec.c:793
ff_scale_vector_to_given_sum_of_squares
void ff_scale_vector_to_given_sum_of_squares(float *out, const float *in, float sum_of_squares, const int n)
Set the sum of squares of a signal by scaling.
Definition: acelp_vectors.c:213
QCELPFrame::reserved
uint8_t reserved
reserved bits only present in bitrate 1, 1/4 and 1/8 packets
Definition: qcelpdata.h:65
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
ff_acelp_lspd2lpc
void ff_acelp_lspd2lpc(const double *lsp, float *lpc, int lp_half_order)
Reconstruct LPC coefficients from the line spectral pair frequencies.
Definition: lsp.c:226
qcelp_rnd_fir_coefs
static const double qcelp_rnd_fir_coefs[11]
Table for impulse response of BPF used to filter the white excitation for bitrate 1/4 synthesis.
Definition: qcelpdata.h:521
QCELPContext::last_codebook_gain
float last_codebook_gain
Definition: qcelpdec.c:65
QCELPFrame::pfrac
uint8_t pfrac[4]
fractional pitch lag for each pitch subframe
Definition: qcelpdata.h:51
AV_SAMPLE_FMT_FLT
@ AV_SAMPLE_FMT_FLT
float
Definition: samplefmt.h:60
QCELPFrame::cbgain
uint8_t cbgain[16]
unsigned codebook gain for each codebook subframe
Definition: qcelpdata.h:44
QCELP_RATE_FULL_CODEBOOK_RATIO
#define QCELP_RATE_FULL_CODEBOOK_RATIO
Definition: qcelpdata.h:477
postfilter
static void postfilter(QCELPContext *q, float *samples, float *lpc)
Definition: qcelpdec.c:655
AV_RB16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
Definition: bytestream.h:98
QCELPContext::pitch_synthesis_filter_mem
float pitch_synthesis_filter_mem[303]
Definition: qcelpdec.c:61
Generated on Wed Nov 19 2025 19:22:25 for FFmpeg by   doxygen 1.8.17

AltStyle によって変換されたページ (->オリジナル) /