FFmpeg
twinvq.c
Go to the documentation of this file.
1 /*
2  * TwinVQ decoder
3  * Copyright (c) 2009 Vitor Sessak
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 #include <math.h>
23 #include <stdint.h>
24 
26 #include "libavutil/float_dsp.h"
27 #include "avcodec.h"
28 #include "fft.h"
29 #include "internal.h"
30 #include "lsp.h"
31 #include "sinewin.h"
32 #include "twinvq.h"
33 
34 /**
35  * Evaluate a single LPC amplitude spectrum envelope coefficient from the line
36  * spectrum pairs.
37  *
38  * @param lsp a vector of the cosine of the LSP values
39  * @param cos_val cos(PI*i/N) where i is the index of the LPC amplitude
40  * @param order the order of the LSP (and the size of the *lsp buffer). Must
41  * be a multiple of four.
42  * @return the LPC value
43  *
44  * @todo reuse code from Vorbis decoder: vorbis_floor0_decode
45  */
46 static float eval_lpc_spectrum(const float *lsp, float cos_val, int order)
47 {
48  int j;
49  float p = 0.5f;
50  float q = 0.5f;
51  float two_cos_w = 2.0f * cos_val;
52 
53  for (j = 0; j + 1 < order; j += 2 * 2) {
54  // Unroll the loop once since order is a multiple of four
55  q *= lsp[j] - two_cos_w;
56  p *= lsp[j + 1] - two_cos_w;
57 
58  q *= lsp[j + 2] - two_cos_w;
59  p *= lsp[j + 3] - two_cos_w;
60  }
61 
62  p *= p * (2.0f - two_cos_w);
63  q *= q * (2.0f + two_cos_w);
64 
65  return 0.5 / (p + q);
66 }
67 
68 /**
69  * Evaluate the LPC amplitude spectrum envelope from the line spectrum pairs.
70  */
71 static void eval_lpcenv(TwinVQContext *tctx, const float *cos_vals, float *lpc)
72 {
73  int i;
74  const TwinVQModeTab *mtab = tctx->mtab;
75  int size_s = mtab->size / mtab->fmode[TWINVQ_FT_SHORT].sub;
76 
77  for (i = 0; i < size_s / 2; i++) {
78  float cos_i = tctx->cos_tabs[0][i];
79  lpc[i] = eval_lpc_spectrum(cos_vals, cos_i, mtab->n_lsp);
80  lpc[size_s - i - 1] = eval_lpc_spectrum(cos_vals, -cos_i, mtab->n_lsp);
81  }
82 }
83 
84 static void interpolate(float *out, float v1, float v2, int size)
85 {
86  int i;
87  float step = (v1 - v2) / (size + 1);
88 
89  for (i = 0; i < size; i++) {
90  v2 += step;
91  out[i] = v2;
92  }
93 }
94 
95 static inline float get_cos(int idx, int part, const float *cos_tab, int size)
96 {
97  return part ? -cos_tab[size - idx - 1]
98  : cos_tab[idx];
99 }
100 
101 /**
102  * Evaluate the LPC amplitude spectrum envelope from the line spectrum pairs.
103  * Probably for speed reasons, the coefficients are evaluated as
104  * siiiibiiiisiiiibiiiisiiiibiiiisiiiibiiiis ...
105  * where s is an evaluated value, i is a value interpolated from the others
106  * and b might be either calculated or interpolated, depending on an
107  * unexplained condition.
108  *
109  * @param step the size of a block "siiiibiiii"
110  * @param in the cosine of the LSP data
111  * @param part is 0 for 0...PI (positive cosine values) and 1 for PI...2PI
112  * (negative cosine values)
113  * @param size the size of the whole output
114  */
115 static inline void eval_lpcenv_or_interp(TwinVQContext *tctx,
116  enum TwinVQFrameType ftype,
117  float *out, const float *in,
118  int size, int step, int part)
119 {
120  int i;
121  const TwinVQModeTab *mtab = tctx->mtab;
122  const float *cos_tab = tctx->cos_tabs[ftype];
123 
124  // Fill the 's'
125  for (i = 0; i < size; i += step)
126  out[i] =
128  get_cos(i, part, cos_tab, size),
129  mtab->n_lsp);
130 
131  // Fill the 'iiiibiiii'
132  for (i = step; i <= size - 2 * step; i += step) {
133  if (out[i + step] + out[i - step] > 1.95 * out[i] ||
134  out[i + step] >= out[i - step]) {
135  interpolate(out + i - step + 1, out[i], out[i - step], step - 1);
136  } else {
137  out[i - step / 2] =
139  get_cos(i - step / 2, part, cos_tab, size),
140  mtab->n_lsp);
141  interpolate(out + i - step + 1, out[i - step / 2],
142  out[i - step], step / 2 - 1);
143  interpolate(out + i - step / 2 + 1, out[i],
144  out[i - step / 2], step / 2 - 1);
145  }
146  }
147 
148  interpolate(out + size - 2 * step + 1, out[size - step],
149  out[size - 2 * step], step - 1);
150 }
151 
152 static void eval_lpcenv_2parts(TwinVQContext *tctx, enum TwinVQFrameType ftype,
153  const float *buf, float *lpc,
154  int size, int step)
155 {
156  eval_lpcenv_or_interp(tctx, ftype, lpc, buf, size / 2, step, 0);
157  eval_lpcenv_or_interp(tctx, ftype, lpc + size / 2, buf, size / 2,
158  2 * step, 1);
159 
160  interpolate(lpc + size / 2 - step + 1, lpc[size / 2],
161  lpc[size / 2 - step], step);
162 
163  twinvq_memset_float(lpc + size - 2 * step + 1, lpc[size - 2 * step],
164  2 * step - 1);
165 }
166 
167 /**
168  * Inverse quantization. Read CB coefficients for cb1 and cb2 from the
169  * bitstream, sum the corresponding vectors and write the result to *out
170  * after permutation.
171  */
172 static void dequant(TwinVQContext *tctx, const uint8_t *cb_bits, float *out,
173  enum TwinVQFrameType ftype,
174  const int16_t *cb0, const int16_t *cb1, int cb_len)
175 {
176  int pos = 0;
177  int i, j;
178 
179  for (i = 0; i < tctx->n_div[ftype]; i++) {
180  int tmp0, tmp1;
181  int sign0 = 1;
182  int sign1 = 1;
183  const int16_t *tab0, *tab1;
184  int length = tctx->length[ftype][i >= tctx->length_change[ftype]];
185  int bitstream_second_part = (i >= tctx->bits_main_spec_change[ftype]);
186 
187  int bits = tctx->bits_main_spec[0][ftype][bitstream_second_part];
188  tmp0 = *cb_bits++;
189  if (bits == 7) {
190  if (tmp0 & 0x40)
191  sign0 = -1;
192  tmp0 &= 0x3F;
193  }
194 
195  bits = tctx->bits_main_spec[1][ftype][bitstream_second_part];
196  tmp1 = *cb_bits++;
197  if (bits == 7) {
198  if (tmp1 & 0x40)
199  sign1 = -1;
200  tmp1 &= 0x3F;
201  }
202 
203  tab0 = cb0 + tmp0 * cb_len;
204  tab1 = cb1 + tmp1 * cb_len;
205 
206  for (j = 0; j < length; j++)
207  out[tctx->permut[ftype][pos + j]] = sign0 * tab0[j] +
208  sign1 * tab1[j];
209 
210  pos += length;
211  }
212 }
213 
214 static void dec_gain(TwinVQContext *tctx,
215  enum TwinVQFrameType ftype, float *out)
216 {
217  const TwinVQModeTab *mtab = tctx->mtab;
218  const TwinVQFrameData *bits = &tctx->bits[tctx->cur_frame];
219  int i, j;
220  int sub = mtab->fmode[ftype].sub;
221  float step = TWINVQ_AMP_MAX / ((1 << TWINVQ_GAIN_BITS) - 1);
222  float sub_step = TWINVQ_SUB_AMP_MAX / ((1 << TWINVQ_SUB_GAIN_BITS) - 1);
223 
224  if (ftype == TWINVQ_FT_LONG) {
225  for (i = 0; i < tctx->avctx->channels; i++)
226  out[i] = (1.0 / (1 << 13)) *
227  twinvq_mulawinv(step * 0.5 + step * bits->gain_bits[i],
229  } else {
230  for (i = 0; i < tctx->avctx->channels; i++) {
231  float val = (1.0 / (1 << 23)) *
232  twinvq_mulawinv(step * 0.5 + step * bits->gain_bits[i],
234 
235  for (j = 0; j < sub; j++)
236  out[i * sub + j] =
237  val * twinvq_mulawinv(sub_step * 0.5 +
238  sub_step * bits->sub_gain_bits[i * sub + j],
240  }
241  }
242 }
243 
244 /**
245  * Rearrange the LSP coefficients so that they have a minimum distance of
246  * min_dist. This function does it exactly as described in section of 3.2.4
247  * of the G.729 specification (but interestingly is different from what the
248  * reference decoder actually does).
249  */
250 static void rearrange_lsp(int order, float *lsp, float min_dist)
251 {
252  int i;
253  float min_dist2 = min_dist * 0.5;
254  for (i = 1; i < order; i++)
255  if (lsp[i] - lsp[i - 1] < min_dist) {
256  float avg = (lsp[i] + lsp[i - 1]) * 0.5;
257 
258  lsp[i - 1] = avg - min_dist2;
259  lsp[i] = avg + min_dist2;
260  }
261 }
262 
263 static void decode_lsp(TwinVQContext *tctx, int lpc_idx1, uint8_t *lpc_idx2,
264  int lpc_hist_idx, float *lsp, float *hist)
265 {
266  const TwinVQModeTab *mtab = tctx->mtab;
267  int i, j;
268 
269  const float *cb = mtab->lspcodebook;
270  const float *cb2 = cb + (1 << mtab->lsp_bit1) * mtab->n_lsp;
271  const float *cb3 = cb2 + (1 << mtab->lsp_bit2) * mtab->n_lsp;
272 
273  const int8_t funny_rounding[4] = {
274  -2,
275  mtab->lsp_split == 4 ? -2 : 1,
276  mtab->lsp_split == 4 ? -2 : 1,
277  0
278  };
279 
280  j = 0;
281  for (i = 0; i < mtab->lsp_split; i++) {
282  int chunk_end = ((i + 1) * mtab->n_lsp + funny_rounding[i]) /
283  mtab->lsp_split;
284  for (; j < chunk_end; j++)
285  lsp[j] = cb[lpc_idx1 * mtab->n_lsp + j] +
286  cb2[lpc_idx2[i] * mtab->n_lsp + j];
287  }
288 
289  rearrange_lsp(mtab->n_lsp, lsp, 0.0001);
290 
291  for (i = 0; i < mtab->n_lsp; i++) {
292  float tmp1 = 1.0 - cb3[lpc_hist_idx * mtab->n_lsp + i];
293  float tmp2 = hist[i] * cb3[lpc_hist_idx * mtab->n_lsp + i];
294  hist[i] = lsp[i];
295  lsp[i] = lsp[i] * tmp1 + tmp2;
296  }
297 
298  rearrange_lsp(mtab->n_lsp, lsp, 0.0001);
299  rearrange_lsp(mtab->n_lsp, lsp, 0.000095);
301 }
302 
303 static void dec_lpc_spectrum_inv(TwinVQContext *tctx, float *lsp,
304  enum TwinVQFrameType ftype, float *lpc)
305 {
306  int i;
307  int size = tctx->mtab->size / tctx->mtab->fmode[ftype].sub;
308 
309  for (i = 0; i < tctx->mtab->n_lsp; i++)
310  lsp[i] = 2 * cos(lsp[i]);
311 
312  switch (ftype) {
313  case TWINVQ_FT_LONG:
314  eval_lpcenv_2parts(tctx, ftype, lsp, lpc, size, 8);
315  break;
316  case TWINVQ_FT_MEDIUM:
317  eval_lpcenv_2parts(tctx, ftype, lsp, lpc, size, 2);
318  break;
319  case TWINVQ_FT_SHORT:
320  eval_lpcenv(tctx, lsp, lpc);
321  break;
322  }
323 }
324 
325 static const uint8_t wtype_to_wsize[] = { 0, 0, 2, 2, 2, 1, 0, 1, 1 };
326 
327 static void imdct_and_window(TwinVQContext *tctx, enum TwinVQFrameType ftype,
328  int wtype, float *in, float *prev, int ch)
329 {
330  FFTContext *mdct = &tctx->mdct_ctx[ftype];
331  const TwinVQModeTab *mtab = tctx->mtab;
332  int bsize = mtab->size / mtab->fmode[ftype].sub;
333  int size = mtab->size;
334  float *buf1 = tctx->tmp_buf;
335  int j, first_wsize, wsize; // Window size
336  float *out = tctx->curr_frame + 2 * ch * mtab->size;
337  float *out2 = out;
338  float *prev_buf;
339  int types_sizes[] = {
340  mtab->size / mtab->fmode[TWINVQ_FT_LONG].sub,
341  mtab->size / mtab->fmode[TWINVQ_FT_MEDIUM].sub,
342  mtab->size / (mtab->fmode[TWINVQ_FT_SHORT].sub * 2),
343  };
344 
345  wsize = types_sizes[wtype_to_wsize[wtype]];
346  first_wsize = wsize;
347  prev_buf = prev + (size - bsize) / 2;
348 
349  for (j = 0; j < mtab->fmode[ftype].sub; j++) {
350  int sub_wtype = ftype == TWINVQ_FT_MEDIUM ? 8 : wtype;
351 
352  if (!j && wtype == 4)
353  sub_wtype = 4;
354  else if (j == mtab->fmode[ftype].sub - 1 && wtype == 7)
355  sub_wtype = 7;
356 
357  wsize = types_sizes[wtype_to_wsize[sub_wtype]];
358 
359  mdct->imdct_half(mdct, buf1 + bsize * j, in + bsize * j);
360 
361  tctx->fdsp->vector_fmul_window(out2, prev_buf + (bsize - wsize) / 2,
362  buf1 + bsize * j,
363  ff_sine_windows[av_log2(wsize)],
364  wsize / 2);
365  out2 += wsize;
366 
367  memcpy(out2, buf1 + bsize * j + wsize / 2,
368  (bsize - wsize / 2) * sizeof(float));
369 
370  out2 += ftype == TWINVQ_FT_MEDIUM ? (bsize - wsize) / 2 : bsize - wsize;
371 
372  prev_buf = buf1 + bsize * j + bsize / 2;
373  }
374 
375  tctx->last_block_pos[ch] = (size + first_wsize) / 2;
376 }
377 
378 static void imdct_output(TwinVQContext *tctx, enum TwinVQFrameType ftype,
379  int wtype, float **out, int offset)
380 {
381  const TwinVQModeTab *mtab = tctx->mtab;
382  float *prev_buf = tctx->prev_frame + tctx->last_block_pos[0];
383  int size1, size2, i;
384  float *out1, *out2;
385 
386  for (i = 0; i < tctx->avctx->channels; i++)
387  imdct_and_window(tctx, ftype, wtype,
388  tctx->spectrum + i * mtab->size,
389  prev_buf + 2 * i * mtab->size,
390  i);
391 
392  if (!out)
393  return;
394 
395  size2 = tctx->last_block_pos[0];
396  size1 = mtab->size - size2;
397 
398  out1 = &out[0][0] + offset;
399  memcpy(out1, prev_buf, size1 * sizeof(*out1));
400  memcpy(out1 + size1, tctx->curr_frame, size2 * sizeof(*out1));
401 
402  if (tctx->avctx->channels == 2) {
403  out2 = &out[1][0] + offset;
404  memcpy(out2, &prev_buf[2 * mtab->size],
405  size1 * sizeof(*out2));
406  memcpy(out2 + size1, &tctx->curr_frame[2 * mtab->size],
407  size2 * sizeof(*out2));
408  tctx->fdsp->butterflies_float(out1, out2, mtab->size);
409  }
410 }
411 
412 static void read_and_decode_spectrum(TwinVQContext *tctx, float *out,
413  enum TwinVQFrameType ftype)
414 {
415  const TwinVQModeTab *mtab = tctx->mtab;
416  TwinVQFrameData *bits = &tctx->bits[tctx->cur_frame];
417  int channels = tctx->avctx->channels;
418  int sub = mtab->fmode[ftype].sub;
419  int block_size = mtab->size / sub;
421  float ppc_shape[TWINVQ_PPC_SHAPE_LEN_MAX * TWINVQ_CHANNELS_MAX * 4];
422 
423  int i, j;
424 
425  dequant(tctx, bits->main_coeffs, out, ftype,
426  mtab->fmode[ftype].cb0, mtab->fmode[ftype].cb1,
427  mtab->fmode[ftype].cb_len_read);
428 
429  dec_gain(tctx, ftype, gain);
430 
431  if (ftype == TWINVQ_FT_LONG) {
432  int cb_len_p = (tctx->n_div[3] + mtab->ppc_shape_len * channels - 1) /
433  tctx->n_div[3];
434  dequant(tctx, bits->ppc_coeffs, ppc_shape,
436  mtab->ppc_shape_cb + cb_len_p * TWINVQ_PPC_SHAPE_CB_SIZE,
437  cb_len_p);
438  }
439 
440  for (i = 0; i < channels; i++) {
441  float *chunk = out + mtab->size * i;
442  float lsp[TWINVQ_LSP_COEFS_MAX];
443 
444  for (j = 0; j < sub; j++) {
445  tctx->dec_bark_env(tctx, bits->bark1[i][j],
446  bits->bark_use_hist[i][j], i,
447  tctx->tmp_buf, gain[sub * i + j], ftype);
448 
449  tctx->fdsp->vector_fmul(chunk + block_size * j,
450  chunk + block_size * j,
451  tctx->tmp_buf, block_size);
452  }
453 
454  if (ftype == TWINVQ_FT_LONG)
455  tctx->decode_ppc(tctx, bits->p_coef[i], bits->g_coef[i],
456  ppc_shape + i * mtab->ppc_shape_len, chunk);
457 
458  decode_lsp(tctx, bits->lpc_idx1[i], bits->lpc_idx2[i],
459  bits->lpc_hist_idx[i], lsp, tctx->lsp_hist[i]);
460 
461  dec_lpc_spectrum_inv(tctx, lsp, ftype, tctx->tmp_buf);
462 
463  for (j = 0; j < mtab->fmode[ftype].sub; j++) {
464  tctx->fdsp->vector_fmul(chunk, chunk, tctx->tmp_buf, block_size);
465  chunk += block_size;
466  }
467  }
468 }
469 
474 };
475 
477  int *got_frame_ptr, AVPacket *avpkt)
478 {
479  AVFrame *frame = data;
480  const uint8_t *buf = avpkt->data;
481  int buf_size = avpkt->size;
482  TwinVQContext *tctx = avctx->priv_data;
483  const TwinVQModeTab *mtab = tctx->mtab;
484  float **out = NULL;
485  int ret;
486 
487  /* get output buffer */
488  if (tctx->discarded_packets >= 2) {
489  frame->nb_samples = mtab->size * tctx->frames_per_packet;
490  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
491  return ret;
492  out = (float **)frame->extended_data;
493  }
494 
495  if (buf_size < avctx->block_align) {
496  av_log(avctx, AV_LOG_ERROR,
497  "Frame too small (%d bytes). Truncated file?\n", buf_size);
498  return AVERROR(EINVAL);
499  }
500 
501  if ((ret = tctx->read_bitstream(avctx, tctx, buf, buf_size)) < 0)
502  return ret;
503 
504  for (tctx->cur_frame = 0; tctx->cur_frame < tctx->frames_per_packet;
505  tctx->cur_frame++) {
507  tctx->bits[tctx->cur_frame].ftype);
508 
509  imdct_output(tctx, tctx->bits[tctx->cur_frame].ftype,
510  tctx->bits[tctx->cur_frame].window_type, out,
511  tctx->cur_frame * mtab->size);
512 
513  FFSWAP(float *, tctx->curr_frame, tctx->prev_frame);
514  }
515 
516  if (tctx->discarded_packets < 2) {
517  tctx->discarded_packets++;
518  *got_frame_ptr = 0;
519  return buf_size;
520  }
521 
522  *got_frame_ptr = 1;
523 
524  // VQF can deliver packets 1 byte greater than block align
525  if (buf_size == avctx->block_align + 1)
526  return buf_size;
527  return avctx->block_align;
528 }
529 
530 /**
531  * Init IMDCT and windowing tables
532  */
534 {
535  int i, j, ret;
536  const TwinVQModeTab *mtab = tctx->mtab;
537  int size_s = mtab->size / mtab->fmode[TWINVQ_FT_SHORT].sub;
538  int size_m = mtab->size / mtab->fmode[TWINVQ_FT_MEDIUM].sub;
539  int channels = tctx->avctx->channels;
540  float norm = channels == 1 ? 2.0 : 1.0;
541  int table_size = 2 * mtab->size * channels;
542 
543  for (i = 0; i < 3; i++) {
544  int bsize = tctx->mtab->size / tctx->mtab->fmode[i].sub;
545  if ((ret = ff_mdct_init(&tctx->mdct_ctx[i], av_log2(bsize) + 1, 1,
546  -sqrt(norm / bsize) / (1 << 15))))
547  return ret;
548  }
549 
550  if (!FF_ALLOC_TYPED_ARRAY(tctx->tmp_buf, mtab->size) ||
551  !FF_ALLOC_TYPED_ARRAY(tctx->spectrum, table_size) ||
552  !FF_ALLOC_TYPED_ARRAY(tctx->curr_frame, table_size) ||
553  !FF_ALLOC_TYPED_ARRAY(tctx->prev_frame, table_size))
554  return AVERROR(ENOMEM);
555 
556  for (i = 0; i < 3; i++) {
557  int m = 4 * mtab->size / mtab->fmode[i].sub;
558  double freq = 2 * M_PI / m;
559  if (!FF_ALLOC_TYPED_ARRAY(tctx->cos_tabs[i], m / 4))
560  return AVERROR(ENOMEM);
561  for (j = 0; j <= m / 8; j++)
562  tctx->cos_tabs[i][j] = cos((2 * j + 1) * freq);
563  for (j = 1; j < m / 8; j++)
564  tctx->cos_tabs[i][m / 4 - j] = tctx->cos_tabs[i][j];
565  }
566 
568  ff_init_ff_sine_windows(av_log2(size_s / 2));
570 
571  return 0;
572 }
573 
574 /**
575  * Interpret the data as if it were a num_blocks x line_len[0] matrix and for
576  * each line do a cyclic permutation, i.e.
577  * abcdefghijklm -> defghijklmabc
578  * where the amount to be shifted is evaluated depending on the column.
579  */
580 static void permutate_in_line(int16_t *tab, int num_vect, int num_blocks,
581  int block_size,
582  const uint8_t line_len[2], int length_div,
583  enum TwinVQFrameType ftype)
584 {
585  int i, j;
586 
587  for (i = 0; i < line_len[0]; i++) {
588  int shift;
589 
590  if (num_blocks == 1 ||
591  (ftype == TWINVQ_FT_LONG && num_vect % num_blocks) ||
592  (ftype != TWINVQ_FT_LONG && num_vect & 1) ||
593  i == line_len[1]) {
594  shift = 0;
595  } else if (ftype == TWINVQ_FT_LONG) {
596  shift = i;
597  } else
598  shift = i * i;
599 
600  for (j = 0; j < num_vect && (j + num_vect * i < block_size * num_blocks); j++)
601  tab[i * num_vect + j] = i * num_vect + (j + shift) % num_vect;
602  }
603 }
604 
605 /**
606  * Interpret the input data as in the following table:
607  *
608  * @verbatim
609  *
610  * abcdefgh
611  * ijklmnop
612  * qrstuvw
613  * x123456
614  *
615  * @endverbatim
616  *
617  * and transpose it, giving the output
618  * aiqxbjr1cks2dlt3emu4fvn5gow6hp
619  */
620 static void transpose_perm(int16_t *out, int16_t *in, int num_vect,
621  const uint8_t line_len[2], int length_div)
622 {
623  int i, j;
624  int cont = 0;
625 
626  for (i = 0; i < num_vect; i++)
627  for (j = 0; j < line_len[i >= length_div]; j++)
628  out[cont++] = in[j * num_vect + i];
629 }
630 
631 static void linear_perm(int16_t *out, int16_t *in, int n_blocks, int size)
632 {
633  int block_size = size / n_blocks;
634  int i;
635 
636  for (i = 0; i < size; i++)
637  out[i] = block_size * (in[i] % n_blocks) + in[i] / n_blocks;
638 }
639 
641  enum TwinVQFrameType ftype)
642 {
643  int block_size, size;
644  const TwinVQModeTab *mtab = tctx->mtab;
645  int16_t *tmp_perm = (int16_t *)tctx->tmp_buf;
646 
647  if (ftype == TWINVQ_FT_PPC) {
648  size = tctx->avctx->channels;
649  block_size = mtab->ppc_shape_len;
650  } else {
651  size = tctx->avctx->channels * mtab->fmode[ftype].sub;
652  block_size = mtab->size / mtab->fmode[ftype].sub;
653  }
654 
655  permutate_in_line(tmp_perm, tctx->n_div[ftype], size,
656  block_size, tctx->length[ftype],
657  tctx->length_change[ftype], ftype);
658 
659  transpose_perm(tctx->permut[ftype], tmp_perm, tctx->n_div[ftype],
660  tctx->length[ftype], tctx->length_change[ftype]);
661 
662  linear_perm(tctx->permut[ftype], tctx->permut[ftype], size,
663  size * block_size);
664 }
665 
667 {
668  const TwinVQModeTab *mtab = tctx->mtab;
669  int n_ch = tctx->avctx->channels;
670  int total_fr_bits = tctx->avctx->bit_rate * mtab->size /
671  tctx->avctx->sample_rate;
672 
673  int lsp_bits_per_block = n_ch * (mtab->lsp_bit0 + mtab->lsp_bit1 +
674  mtab->lsp_split * mtab->lsp_bit2);
675 
676  int ppc_bits = n_ch * (mtab->pgain_bit + mtab->ppc_shape_bit +
677  mtab->ppc_period_bit);
678 
679  int bsize_no_main_cb[3], bse_bits[3], i;
680  enum TwinVQFrameType frametype;
681 
682  for (i = 0; i < 3; i++)
683  // +1 for history usage switch
684  bse_bits[i] = n_ch *
685  (mtab->fmode[i].bark_n_coef *
686  mtab->fmode[i].bark_n_bit + 1);
687 
688  bsize_no_main_cb[2] = bse_bits[2] + lsp_bits_per_block + ppc_bits +
690 
691  for (i = 0; i < 2; i++)
692  bsize_no_main_cb[i] =
693  lsp_bits_per_block + n_ch * TWINVQ_GAIN_BITS +
695  mtab->fmode[i].sub * (bse_bits[i] + n_ch * TWINVQ_SUB_GAIN_BITS);
696 
697  if (tctx->codec == TWINVQ_CODEC_METASOUND && !tctx->is_6kbps) {
698  bsize_no_main_cb[1] += 2;
699  bsize_no_main_cb[2] += 2;
700  }
701 
702  // The remaining bits are all used for the main spectrum coefficients
703  for (i = 0; i < 4; i++) {
704  int bit_size, vect_size;
705  int rounded_up, rounded_down, num_rounded_down, num_rounded_up;
706  if (i == 3) {
707  bit_size = n_ch * mtab->ppc_shape_bit;
708  vect_size = n_ch * mtab->ppc_shape_len;
709  } else {
710  bit_size = total_fr_bits - bsize_no_main_cb[i];
711  vect_size = n_ch * mtab->size;
712  }
713 
714  tctx->n_div[i] = (bit_size + 13) / 14;
715 
716  rounded_up = (bit_size + tctx->n_div[i] - 1) /
717  tctx->n_div[i];
718  rounded_down = (bit_size) / tctx->n_div[i];
719  num_rounded_down = rounded_up * tctx->n_div[i] - bit_size;
720  num_rounded_up = tctx->n_div[i] - num_rounded_down;
721  tctx->bits_main_spec[0][i][0] = (rounded_up + 1) / 2;
722  tctx->bits_main_spec[1][i][0] = rounded_up / 2;
723  tctx->bits_main_spec[0][i][1] = (rounded_down + 1) / 2;
724  tctx->bits_main_spec[1][i][1] = rounded_down / 2;
725  tctx->bits_main_spec_change[i] = num_rounded_up;
726 
727  rounded_up = (vect_size + tctx->n_div[i] - 1) /
728  tctx->n_div[i];
729  rounded_down = (vect_size) / tctx->n_div[i];
730  num_rounded_down = rounded_up * tctx->n_div[i] - vect_size;
731  num_rounded_up = tctx->n_div[i] - num_rounded_down;
732  tctx->length[i][0] = rounded_up;
733  tctx->length[i][1] = rounded_down;
734  tctx->length_change[i] = num_rounded_up;
735  }
736 
737  for (frametype = TWINVQ_FT_SHORT; frametype <= TWINVQ_FT_PPC; frametype++)
738  construct_perm_table(tctx, frametype);
739 }
740 
742 {
743  TwinVQContext *tctx = avctx->priv_data;
744  int i;
745 
746  for (i = 0; i < 3; i++) {
747  ff_mdct_end(&tctx->mdct_ctx[i]);
748  av_freep(&tctx->cos_tabs[i]);
749  }
750 
751  av_freep(&tctx->curr_frame);
752  av_freep(&tctx->spectrum);
753  av_freep(&tctx->prev_frame);
754  av_freep(&tctx->tmp_buf);
755  av_freep(&tctx->fdsp);
756 
757  return 0;
758 }
759 
761 {
762  int ret;
763  TwinVQContext *tctx = avctx->priv_data;
764  int64_t frames_per_packet;
765 
766  tctx->avctx = avctx;
768 
769  if (!avctx->block_align) {
770  avctx->block_align = tctx->frame_size + 7 >> 3;
771  }
772  frames_per_packet = avctx->block_align * 8LL / tctx->frame_size;
773  if (frames_per_packet <= 0) {
774  av_log(avctx, AV_LOG_ERROR, "Block align is %"PRId64" bits, expected %d\n",
775  avctx->block_align * (int64_t)8, tctx->frame_size);
776  return AVERROR_INVALIDDATA;
777  }
778  if (frames_per_packet > TWINVQ_MAX_FRAMES_PER_PACKET) {
779  av_log(avctx, AV_LOG_ERROR, "Too many frames per packet (%"PRId64")\n",
780  frames_per_packet);
781  return AVERROR_INVALIDDATA;
782  }
783  tctx->frames_per_packet = frames_per_packet;
784 
786  if (!tctx->fdsp) {
787  ff_twinvq_decode_close(avctx);
788  return AVERROR(ENOMEM);
789  }
790  if ((ret = init_mdct_win(tctx))) {
791  av_log(avctx, AV_LOG_ERROR, "Error initializing MDCT\n");
792  ff_twinvq_decode_close(avctx);
793  return ret;
794  }
795  init_bitstream_params(tctx);
796 
797  twinvq_memset_float(tctx->bark_hist[0][0], 0.1,
798  FF_ARRAY_ELEMS(tctx->bark_hist));
799 
800  return 0;
801 }
TwinVQModeTab::lspcodebook
const float * lspcodebook
Definition: twinvq.h:116
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:69
linear_perm
static void linear_perm(int16_t *out, int16_t *in, int n_blocks, int size)
Definition: twinvq.c:631
TWINVQ_SUB_AMP_MAX
#define TWINVQ_SUB_AMP_MAX
Definition: twinvq.h:48
TwinVQContext::mtab
const TwinVQModeTab * mtab
Definition: twinvq.h:142
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
ff_sine_windows
SINETABLE_CONST float *const ff_sine_windows[]
Definition: sinewin_tablegen.h:51
TwinVQFrameMode::sub
uint8_t sub
Number subblocks in each frame.
Definition: twinvq.h:67
out
FILE * out
Definition: movenc.c:54
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:992
TwinVQContext::bits_main_spec
uint8_t bits_main_spec[2][4][2]
bits for the main codebook
Definition: twinvq.h:154
cb
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:215
dequant
static void dequant(TwinVQContext *tctx, const uint8_t *cb_bits, float *out, enum TwinVQFrameType ftype, const int16_t *cb0, const int16_t *cb1, int cb_len)
Inverse quantization.
Definition: twinvq.c:172
TWINVQ_AMP_MAX
#define TWINVQ_AMP_MAX
Definition: twinvq.h:51
sub
static float sub(float src0, float src1)
Definition: dnn_backend_native_layer_mathbinary.c:31
TwinVQContext::tmp_buf
float * tmp_buf
Definition: twinvq.h:167
decode_lsp
static void decode_lsp(TwinVQContext *tctx, int lpc_idx1, uint8_t *lpc_idx2, int lpc_hist_idx, float *lsp, float *hist)
Definition: twinvq.c:263
TwinVQContext::curr_frame
float * curr_frame
non-interleaved output
Definition: twinvq.h:159
TWINVQ_GAIN_BITS
#define TWINVQ_GAIN_BITS
Definition: twinvq.h:50
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
step
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step
Definition: rate_distortion.txt:58
TwinVQContext::bits
TwinVQFrameData bits[TWINVQ_MAX_FRAMES_PER_PACKET]
Definition: twinvq.h:170
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:373
data
const char data[16]
Definition: mxf.c:143
TwinVQModeTab::ppc_shape_len
uint8_t ppc_shape_len
size of PPC shape CB
Definition: twinvq.h:130
ff_mdct_init
#define ff_mdct_init
Definition: fft.h:153
TwinVQModeTab::lsp_bit1
uint8_t lsp_bit1
Definition: twinvq.h:120
ff_twinvq_decode_init
av_cold int ff_twinvq_decode_init(AVCodecContext *avctx)
Definition: twinvq.c:760
TwinVQContext::permut
int16_t permut[4][4096]
Definition: twinvq.h:151
imdct_output
static void imdct_output(TwinVQContext *tctx, enum TwinVQFrameType ftype, int wtype, float **out, int offset)
Definition: twinvq.c:378
ff_sort_nearly_sorted_floats
void ff_sort_nearly_sorted_floats(float *vals, int len)
Sort values in ascending order.
Definition: lsp.c:228
TwinVQModeTab::pgain_bit
uint8_t pgain_bit
bits for PPC gain
Definition: twinvq.h:131
TWINVQ_PPC_SHAPE_CB_SIZE
#define TWINVQ_PPC_SHAPE_CB_SIZE
Definition: twinvq.h:46
AVFloatDSPContext::butterflies_float
void(* butterflies_float)(float *av_restrict v1, float *av_restrict v2, int len)
Calculate the sum and difference of two vectors of floats.
Definition: float_dsp.h:164
TwinVQFrameMode::cb0
const int16_t * cb0
main codebooks for spectrum data
Definition: twinvq.h:79
TwinVQContext::last_block_pos
int last_block_pos[2]
Definition: twinvq.h:161
TWINVQ_WINDOW_TYPE_BITS
#define TWINVQ_WINDOW_TYPE_BITS
Definition: twinvq.h:53
TwinVQFrameMode::cb1
const int16_t * cb1
Definition: twinvq.h:80
TwinVQFrameMode::bark_n_coef
uint8_t bark_n_coef
number of BSE CB coefficients to read
Definition: twinvq.h:74
TwinVQFrameType
TwinVQFrameType
Definition: twinvq.h:39
tab
static const struct twinvq_data tab
Definition: twinvq_data.h:10345
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:463
val
static double val(void *priv, double ch)
Definition: aeval.c:76
FF_ALLOC_TYPED_ARRAY
#define FF_ALLOC_TYPED_ARRAY(p, nelem)
Definition: internal.h:97
TwinVQModeTab::size
uint16_t size
frame size in samples
Definition: twinvq.h:114
twinvq_mulawinv
static float twinvq_mulawinv(float y, float clip, float mu)
Definition: twinvq.h:192
tab1
const int16_t * tab1
Definition: mace.c:144
TwinVQContext::dec_bark_env
void(* dec_bark_env)(struct TwinVQContext *tctx, const uint8_t *in, int use_hist, int ch, float *out, float gain, enum TwinVQFrameType ftype)
Definition: twinvq.h:176
ff_twinvq_decode_frame
int ff_twinvq_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: twinvq.c:476
TwinVQContext::n_div
int n_div[4]
Definition: twinvq.h:156
TwinVQContext::decode_ppc
void(* decode_ppc)(struct TwinVQContext *tctx, int period_coef, int g_coef, const float *shape, float *speech)
Definition: twinvq.h:179
chunk_end
static int chunk_end(AVFormatContext *s, int flush)
Definition: webm_chunk.c:176
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
TwinVQContext::fdsp
AVFloatDSPContext * fdsp
Definition: twinvq.h:139
wtype_to_wsize
static const uint8_t wtype_to_wsize[]
Definition: twinvq.c:325
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
TwinVQContext::lsp_hist
float lsp_hist[2][20]
LSP coefficients of the last frame.
Definition: twinvq.h:147
TwinVQModeTab::ppc_shape_bit
uint8_t ppc_shape_bit
number of bits of the PPC shape CB coeffs
Definition: twinvq.h:129
rearrange_lsp
static void rearrange_lsp(int order, float *lsp, float min_dist)
Rearrange the LSP coefficients so that they have a minimum distance of min_dist.
Definition: twinvq.c:250
TWINVQ_LSP_COEFS_MAX
#define TWINVQ_LSP_COEFS_MAX
Definition: twinvq.h:55
TwinVQContext::codec
enum TwinVQCodec codec
Definition: twinvq.h:172
TwinVQContext::length_change
uint8_t length_change[4]
Definition: twinvq.h:153
bits
uint8_t bits
Definition: vp3data.h:141
TWINVQ_FT_MEDIUM
@ TWINVQ_FT_MEDIUM
Medium frame (divided in m<n sub-blocks)
Definition: twinvq.h:41
TwinVQModeTab
Parameters and tables that are different for every combination of bitrate/sample rate.
Definition: twinvq.h:111
channels
channels
Definition: aptx.h:33
TwinVQModeTab::lsp_bit2
uint8_t lsp_bit2
Definition: twinvq.h:121
TWINVQ_MULAW_MU
#define TWINVQ_MULAW_MU
Definition: twinvq.h:49
twinvq_memset_float
static void twinvq_memset_float(float *buf, float val, int size)
Definition: twinvq.h:186
TwinVQContext::prev_frame
float * prev_frame
non-interleaved previous frame
Definition: twinvq.h:160
TWINVQ_FT_PPC
@ TWINVQ_FT_PPC
Periodic Peak Component (part of the long frame)
Definition: twinvq.h:43
eval_lpcenv
static void eval_lpcenv(TwinVQContext *tctx, const float *cos_vals, float *lpc)
Evaluate the LPC amplitude spectrum envelope from the line spectrum pairs.
Definition: twinvq.c:71
if
if(ret)
Definition: filter_design.txt:179
ff_twinvq_decode_close
av_cold int ff_twinvq_decode_close(AVCodecContext *avctx)
Definition: twinvq.c:741
TwinVQContext::length
uint8_t length[4][2]
main codebook stride
Definition: twinvq.h:152
NULL
#define NULL
Definition: coverity.c:32
TwinVQContext::mdct_ctx
FFTContext mdct_ctx[3]
Definition: twinvq.h:140
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:433
get_cos
static float get_cos(int idx, int part, const float *cos_tab, int size)
Definition: twinvq.c:95
eval_lpc_spectrum
static float eval_lpc_spectrum(const float *lsp, float cos_val, int order)
Evaluate a single LPC amplitude spectrum envelope coefficient from the line spectrum pairs.
Definition: twinvq.c:46
TwinVQContext::is_6kbps
int is_6kbps
Definition: twinvq.h:144
transpose_perm
static void transpose_perm(int16_t *out, int16_t *in, int num_vect, const uint8_t line_len[2], int length_div)
Interpret the input data as in the following table:
Definition: twinvq.c:620
float_dsp.h
FFTContext::imdct_half
void(* imdct_half)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
Definition: fft.h:95
TwinVQContext::avctx
AVCodecContext * avctx
Definition: twinvq.h:138
dec_lpc_spectrum_inv
static void dec_lpc_spectrum_inv(TwinVQContext *tctx, float *lsp, enum TwinVQFrameType ftype, float *lpc)
Definition: twinvq.c:303
TwinVQModeTab::lsp_bit0
uint8_t lsp_bit0
Definition: twinvq.h:119
read_and_decode_spectrum
static void read_and_decode_spectrum(TwinVQContext *tctx, float *out, enum TwinVQFrameType ftype)
Definition: twinvq.c:412
TWINVQ_FT_LONG
@ TWINVQ_FT_LONG
Long frame (single sub-block + PPC)
Definition: twinvq.h:42
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1652
AVPacket::size
int size
Definition: packet.h:374
AVFloatDSPContext::vector_fmul
void(* vector_fmul)(float *dst, const float *src0, const float *src1, int len)
Calculate the entry wise product of two vectors of floats and store the result in a vector of floats.
Definition: float_dsp.h:38
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1000
TwinVQFrameMode::bark_n_bit
uint8_t bark_n_bit
number of bits of the BSE coefs
Definition: twinvq.h:75
size
int size
Definition: twinvq_data.h:10344
TwinVQModeTab::ppc_period_bit
uint8_t ppc_period_bit
number of the bits for the PPC period value
Definition: twinvq.h:127
ff_mdct_end
#define ff_mdct_end
Definition: fft.h:154
TwinVQContext::bits_main_spec_change
int bits_main_spec_change[4]
Definition: twinvq.h:155
TWINVQ_PPC_SHAPE_LEN_MAX
#define TWINVQ_PPC_SHAPE_LEN_MAX
Definition: twinvq.h:47
TWINVQ_CHANNELS_MAX
#define TWINVQ_CHANNELS_MAX
Definition: twinvq.h:57
TwinVQModeTab::ppc_shape_cb
const int16_t * ppc_shape_cb
PPC shape CB.
Definition: twinvq.h:124
avg
#define avg(a, b, c, d)
Definition: colorspacedsp_template.c:28
sinewin.h
init_bitstream_params
static av_cold void init_bitstream_params(TwinVQContext *tctx)
Definition: twinvq.c:666
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
init_mdct_win
static av_cold int init_mdct_win(TwinVQContext *tctx)
Init IMDCT and windowing tables.
Definition: twinvq.c:533
interpolate
static void interpolate(float *out, float v1, float v2, int size)
Definition: twinvq.c:84
M_PI
#define M_PI
Definition: mathematics.h:52
TwinVQContext::read_bitstream
int(* read_bitstream)(AVCodecContext *avctx, struct TwinVQContext *tctx, const uint8_t *buf, int buf_size)
Definition: twinvq.h:174
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:993
TWINVQ_SUB_GAIN_BITS
#define TWINVQ_SUB_GAIN_BITS
Definition: twinvq.h:52
TwinVQContext::discarded_packets
int discarded_packets
Definition: twinvq.h:162
TWINVQ_CODEC_METASOUND
@ TWINVQ_CODEC_METASOUND
Definition: twinvq.h:36
FFTContext
Definition: fft.h:75
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
TwinVQContext::frame_size
int frame_size
Definition: twinvq.h:169
TwinVQContext::bark_hist
float bark_hist[3][2][40]
BSE coefficients of last frame.
Definition: twinvq.h:148
TwinVQFrameData
Definition: twinvq.h:86
TwinVQContext::cos_tabs
float * cos_tabs[3]
Definition: twinvq.h:164
permutate_in_line
static void permutate_in_line(int16_t *tab, int num_vect, int num_blocks, int block_size, const uint8_t line_len[2], int length_div, enum TwinVQFrameType ftype)
Interpret the data as if it were a num_blocks x line_len[0] matrix and for each line do a cyclic perm...
Definition: twinvq.c:580
avcodec.h
ret
ret
Definition: filter_design.txt:187
TwinVQContext::cur_frame
int cur_frame
Definition: twinvq.h:169
AVCodecContext::block_align
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs.
Definition: avcodec.h:1029
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
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
pos
unsigned int pos
Definition: spdifenc.c:412
TWINVQ_FT_SHORT
@ TWINVQ_FT_SHORT
Short frame (divided in n sub-blocks)
Definition: twinvq.h:40
twinvq.h
imdct_and_window
static void imdct_and_window(TwinVQContext *tctx, enum TwinVQFrameType ftype, int wtype, float *in, float *prev, int ch)
Definition: twinvq.c:327
fft.h
AVCodecContext
main external API structure.
Definition: avcodec.h:383
construct_perm_table
static av_cold void construct_perm_table(TwinVQContext *tctx, enum TwinVQFrameType ftype)
Definition: twinvq.c:640
channel_layout.h
ff_init_ff_sine_windows
void ff_init_ff_sine_windows(int index)
initialize the specified entry of ff_sine_windows
Definition: sinewin_tablegen.h:101
TwinVQFrameMode::cb_len_read
uint8_t cb_len_read
number of spectrum coefficients to read
Definition: twinvq.h:83
TwinVQFrameData::ftype
enum TwinVQFrameType ftype
Definition: twinvq.h:88
eval_lpcenv_or_interp
static void eval_lpcenv_or_interp(TwinVQContext *tctx, enum TwinVQFrameType ftype, float *out, const float *in, int size, int step, int part)
Evaluate the LPC amplitude spectrum envelope from the line spectrum pairs.
Definition: twinvq.c:115
TwinVQContext::frames_per_packet
int frames_per_packet
Definition: twinvq.h:169
shift
static int shift(int a, int b)
Definition: sonic.c:83
AV_CODEC_FLAG_BITEXACT
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:272
dec_gain
static void dec_gain(TwinVQContext *tctx, enum TwinVQFrameType ftype, float *out)
Definition: twinvq.c:214
eval_lpcenv_2parts
static void eval_lpcenv_2parts(TwinVQContext *tctx, enum TwinVQFrameType ftype, const float *buf, float *lpc, int size, int step)
Definition: twinvq.c:152
AVFloatDSPContext::vector_fmul_window
void(* vector_fmul_window)(float *dst, const float *src0, const float *src1, const float *win, int len)
Overlap/add with window function.
Definition: float_dsp.h:119
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:410
AVPacket
This structure stores compressed data.
Definition: packet.h:350
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
TWINVQ_SUBBLOCKS_MAX
#define TWINVQ_SUBBLOCKS_MAX
Definition: twinvq.h:58
TwinVQContext::spectrum
float * spectrum
Definition: twinvq.h:158
avpriv_float_dsp_alloc
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:135
TwinVQFrameData::window_type
int window_type
Definition: twinvq.h:87
TWINVQ_MAX_FRAMES_PER_PACKET
#define TWINVQ_MAX_FRAMES_PER_PACKET
Definition: twinvq.h:61
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
TwinVQContext
Definition: twinvq.h:137
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
cos_tab
static float cos_tab[256]
Definition: dca_lbr.c:124
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
TwinVQModeTab::lsp_split
uint8_t lsp_split
number of CB entries for the LSP decoding
Definition: twinvq.h:123
ff_twinvq_wtype_to_ftype_table
enum TwinVQFrameType ff_twinvq_wtype_to_ftype_table[]
Definition: twinvq.c:470
TwinVQModeTab::fmode
struct TwinVQFrameMode fmode[3]
frame type-dependent parameters
Definition: twinvq.h:112
TwinVQModeTab::n_lsp
uint8_t n_lsp
number of lsp coefficients
Definition: twinvq.h:115