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