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 
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 channels = tctx->avctx->ch_layout.nb_channels;
221  int sub = mtab->fmode[ftype].sub;
222  float step = TWINVQ_AMP_MAX / ((1 << TWINVQ_GAIN_BITS) - 1);
223  float sub_step = TWINVQ_SUB_AMP_MAX / ((1 << TWINVQ_SUB_GAIN_BITS) - 1);
224 
225  if (ftype == TWINVQ_FT_LONG) {
226  for (i = 0; i < channels; i++)
227  out[i] = (1.0 / (1 << 13)) *
228  twinvq_mulawinv(step * 0.5 + step * bits->gain_bits[i],
230  } else {
231  for (i = 0; i < channels; i++) {
232  float val = (1.0 / (1 << 23)) *
233  twinvq_mulawinv(step * 0.5 + step * bits->gain_bits[i],
235 
236  for (j = 0; j < sub; j++)
237  out[i * sub + j] =
238  val * twinvq_mulawinv(sub_step * 0.5 +
239  sub_step * bits->sub_gain_bits[i * sub + j],
241  }
242  }
243 }
244 
245 /**
246  * Rearrange the LSP coefficients so that they have a minimum distance of
247  * min_dist. This function does it exactly as described in section of 3.2.4
248  * of the G.729 specification (but interestingly is different from what the
249  * reference decoder actually does).
250  */
251 static void rearrange_lsp(int order, float *lsp, float min_dist)
252 {
253  int i;
254  float min_dist2 = min_dist * 0.5;
255  for (i = 1; i < order; i++)
256  if (lsp[i] - lsp[i - 1] < min_dist) {
257  float avg = (lsp[i] + lsp[i - 1]) * 0.5;
258 
259  lsp[i - 1] = avg - min_dist2;
260  lsp[i] = avg + min_dist2;
261  }
262 }
263 
264 static void decode_lsp(TwinVQContext *tctx, int lpc_idx1, uint8_t *lpc_idx2,
265  int lpc_hist_idx, float *lsp, float *hist)
266 {
267  const TwinVQModeTab *mtab = tctx->mtab;
268  int i, j;
269 
270  const float *cb = mtab->lspcodebook;
271  const float *cb2 = cb + (1 << mtab->lsp_bit1) * mtab->n_lsp;
272  const float *cb3 = cb2 + (1 << mtab->lsp_bit2) * mtab->n_lsp;
273 
274  const int8_t funny_rounding[4] = {
275  -2,
276  mtab->lsp_split == 4 ? -2 : 1,
277  mtab->lsp_split == 4 ? -2 : 1,
278  0
279  };
280 
281  j = 0;
282  for (i = 0; i < mtab->lsp_split; i++) {
283  int chunk_end = ((i + 1) * mtab->n_lsp + funny_rounding[i]) /
284  mtab->lsp_split;
285  for (; j < chunk_end; j++)
286  lsp[j] = cb[lpc_idx1 * mtab->n_lsp + j] +
287  cb2[lpc_idx2[i] * mtab->n_lsp + j];
288  }
289 
290  rearrange_lsp(mtab->n_lsp, lsp, 0.0001);
291 
292  for (i = 0; i < mtab->n_lsp; i++) {
293  float tmp1 = 1.0 - cb3[lpc_hist_idx * mtab->n_lsp + i];
294  float tmp2 = hist[i] * cb3[lpc_hist_idx * mtab->n_lsp + i];
295  hist[i] = lsp[i];
296  lsp[i] = lsp[i] * tmp1 + tmp2;
297  }
298 
299  rearrange_lsp(mtab->n_lsp, lsp, 0.0001);
300  rearrange_lsp(mtab->n_lsp, lsp, 0.000095);
302 }
303 
304 static void dec_lpc_spectrum_inv(TwinVQContext *tctx, float *lsp,
305  enum TwinVQFrameType ftype, float *lpc)
306 {
307  int i;
308  int size = tctx->mtab->size / tctx->mtab->fmode[ftype].sub;
309 
310  for (i = 0; i < tctx->mtab->n_lsp; i++)
311  lsp[i] = 2 * cos(lsp[i]);
312 
313  switch (ftype) {
314  case TWINVQ_FT_LONG:
315  eval_lpcenv_2parts(tctx, ftype, lsp, lpc, size, 8);
316  break;
317  case TWINVQ_FT_MEDIUM:
318  eval_lpcenv_2parts(tctx, ftype, lsp, lpc, size, 2);
319  break;
320  case TWINVQ_FT_SHORT:
321  eval_lpcenv(tctx, lsp, lpc);
322  break;
323  }
324 }
325 
326 static const uint8_t wtype_to_wsize[] = { 0, 0, 2, 2, 2, 1, 0, 1, 1 };
327 
329  int wtype, float *in, float *prev, int ch)
330 {
331  FFTContext *mdct = &tctx->mdct_ctx[ftype];
332  const TwinVQModeTab *mtab = tctx->mtab;
333  int bsize = mtab->size / mtab->fmode[ftype].sub;
334  int size = mtab->size;
335  float *buf1 = tctx->tmp_buf;
336  int j, first_wsize, wsize; // Window size
337  float *out = tctx->curr_frame + 2 * ch * mtab->size;
338  float *out2 = out;
339  float *prev_buf;
340  int types_sizes[] = {
341  mtab->size / mtab->fmode[TWINVQ_FT_LONG].sub,
342  mtab->size / mtab->fmode[TWINVQ_FT_MEDIUM].sub,
343  mtab->size / (mtab->fmode[TWINVQ_FT_SHORT].sub * 2),
344  };
345 
346  wsize = types_sizes[wtype_to_wsize[wtype]];
347  first_wsize = wsize;
348  prev_buf = prev + (size - bsize) / 2;
349 
350  for (j = 0; j < mtab->fmode[ftype].sub; j++) {
351  int sub_wtype = ftype == TWINVQ_FT_MEDIUM ? 8 : wtype;
352 
353  if (!j && wtype == 4)
354  sub_wtype = 4;
355  else if (j == mtab->fmode[ftype].sub - 1 && wtype == 7)
356  sub_wtype = 7;
357 
358  wsize = types_sizes[wtype_to_wsize[sub_wtype]];
359 
360  mdct->imdct_half(mdct, buf1 + bsize * j, in + bsize * j);
361 
362  tctx->fdsp->vector_fmul_window(out2, prev_buf + (bsize - wsize) / 2,
363  buf1 + bsize * j,
364  ff_sine_windows[av_log2(wsize)],
365  wsize / 2);
366  out2 += wsize;
367 
368  memcpy(out2, buf1 + bsize * j + wsize / 2,
369  (bsize - wsize / 2) * sizeof(float));
370 
371  out2 += ftype == TWINVQ_FT_MEDIUM ? (bsize - wsize) / 2 : bsize - wsize;
372 
373  prev_buf = buf1 + bsize * j + bsize / 2;
374  }
375 
376  tctx->last_block_pos[ch] = (size + first_wsize) / 2;
377 }
378 
380  int wtype, float **out, int offset)
381 {
382  const TwinVQModeTab *mtab = tctx->mtab;
383  float *prev_buf = tctx->prev_frame + tctx->last_block_pos[0];
384  int channels = tctx->avctx->ch_layout.nb_channels;
385  int size1, size2, i;
386  float *out1, *out2;
387 
388  for (i = 0; i < channels; i++)
389  imdct_and_window(tctx, ftype, wtype,
390  tctx->spectrum + i * mtab->size,
391  prev_buf + 2 * i * mtab->size,
392  i);
393 
394  if (!out)
395  return;
396 
397  size2 = tctx->last_block_pos[0];
398  size1 = mtab->size - size2;
399 
400  out1 = &out[0][0] + offset;
401  memcpy(out1, prev_buf, size1 * sizeof(*out1));
402  memcpy(out1 + size1, tctx->curr_frame, size2 * sizeof(*out1));
403 
404  if (channels == 2) {
405  out2 = &out[1][0] + offset;
406  memcpy(out2, &prev_buf[2 * mtab->size],
407  size1 * sizeof(*out2));
408  memcpy(out2 + size1, &tctx->curr_frame[2 * mtab->size],
409  size2 * sizeof(*out2));
410  tctx->fdsp->butterflies_float(out1, out2, mtab->size);
411  }
412 }
413 
414 static void read_and_decode_spectrum(TwinVQContext *tctx, float *out,
415  enum TwinVQFrameType ftype)
416 {
417  const TwinVQModeTab *mtab = tctx->mtab;
418  TwinVQFrameData *bits = &tctx->bits[tctx->cur_frame];
419  int channels = tctx->avctx->ch_layout.nb_channels;
420  int sub = mtab->fmode[ftype].sub;
421  int block_size = mtab->size / sub;
423  float ppc_shape[TWINVQ_PPC_SHAPE_LEN_MAX * TWINVQ_CHANNELS_MAX * 4];
424 
425  int i, j;
426 
427  dequant(tctx, bits->main_coeffs, out, ftype,
428  mtab->fmode[ftype].cb0, mtab->fmode[ftype].cb1,
429  mtab->fmode[ftype].cb_len_read);
430 
431  dec_gain(tctx, ftype, gain);
432 
433  if (ftype == TWINVQ_FT_LONG) {
434  int cb_len_p = (tctx->n_div[3] + mtab->ppc_shape_len * channels - 1) /
435  tctx->n_div[3];
436  dequant(tctx, bits->ppc_coeffs, ppc_shape,
438  mtab->ppc_shape_cb + cb_len_p * TWINVQ_PPC_SHAPE_CB_SIZE,
439  cb_len_p);
440  }
441 
442  for (i = 0; i < channels; i++) {
443  float *chunk = out + mtab->size * i;
444  float lsp[TWINVQ_LSP_COEFS_MAX];
445 
446  for (j = 0; j < sub; j++) {
447  tctx->dec_bark_env(tctx, bits->bark1[i][j],
448  bits->bark_use_hist[i][j], i,
449  tctx->tmp_buf, gain[sub * i + j], ftype);
450 
451  tctx->fdsp->vector_fmul(chunk + block_size * j,
452  chunk + block_size * j,
453  tctx->tmp_buf, block_size);
454  }
455 
456  if (ftype == TWINVQ_FT_LONG)
457  tctx->decode_ppc(tctx, bits->p_coef[i], bits->g_coef[i],
458  ppc_shape + i * mtab->ppc_shape_len, chunk);
459 
460  decode_lsp(tctx, bits->lpc_idx1[i], bits->lpc_idx2[i],
461  bits->lpc_hist_idx[i], lsp, tctx->lsp_hist[i]);
462 
463  dec_lpc_spectrum_inv(tctx, lsp, ftype, tctx->tmp_buf);
464 
465  for (j = 0; j < mtab->fmode[ftype].sub; j++) {
466  tctx->fdsp->vector_fmul(chunk, chunk, tctx->tmp_buf, block_size);
467  chunk += block_size;
468  }
469  }
470 }
471 
476 };
477 
479  int *got_frame_ptr, AVPacket *avpkt)
480 {
481  const uint8_t *buf = avpkt->data;
482  int buf_size = avpkt->size;
483  TwinVQContext *tctx = avctx->priv_data;
484  const TwinVQModeTab *mtab = tctx->mtab;
485  float **out = NULL;
486  int ret;
487 
488  /* get output buffer */
489  if (tctx->discarded_packets >= 2) {
490  frame->nb_samples = mtab->size * tctx->frames_per_packet;
491  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
492  return ret;
493  out = (float **)frame->extended_data;
494  }
495 
496  if (buf_size < avctx->block_align) {
497  av_log(avctx, AV_LOG_ERROR,
498  "Frame too small (%d bytes). Truncated file?\n", buf_size);
499  return AVERROR(EINVAL);
500  }
501 
502  if ((ret = tctx->read_bitstream(avctx, tctx, buf, buf_size)) < 0)
503  return ret;
504 
505  for (tctx->cur_frame = 0; tctx->cur_frame < tctx->frames_per_packet;
506  tctx->cur_frame++) {
508  tctx->bits[tctx->cur_frame].ftype);
509 
510  imdct_output(tctx, tctx->bits[tctx->cur_frame].ftype,
511  tctx->bits[tctx->cur_frame].window_type, out,
512  tctx->cur_frame * mtab->size);
513 
514  FFSWAP(float *, tctx->curr_frame, tctx->prev_frame);
515  }
516 
517  if (tctx->discarded_packets < 2) {
518  tctx->discarded_packets++;
519  *got_frame_ptr = 0;
520  return buf_size;
521  }
522 
523  *got_frame_ptr = 1;
524 
525  // VQF can deliver packets 1 byte greater than block align
526  if (buf_size == avctx->block_align + 1)
527  return buf_size;
528  return avctx->block_align;
529 }
530 
531 /**
532  * Init IMDCT and windowing tables
533  */
535 {
536  int i, j, ret;
537  const TwinVQModeTab *mtab = tctx->mtab;
538  int size_s = mtab->size / mtab->fmode[TWINVQ_FT_SHORT].sub;
539  int size_m = mtab->size / mtab->fmode[TWINVQ_FT_MEDIUM].sub;
540  int channels = tctx->avctx->ch_layout.nb_channels;
541  float norm = channels == 1 ? 2.0 : 1.0;
542  int table_size = 2 * mtab->size * channels;
543 
544  for (i = 0; i < 3; i++) {
545  int bsize = tctx->mtab->size / tctx->mtab->fmode[i].sub;
546  if ((ret = ff_mdct_init(&tctx->mdct_ctx[i], av_log2(bsize) + 1, 1,
547  -sqrt(norm / bsize) / (1 << 15))))
548  return ret;
549  }
550 
551  if (!FF_ALLOC_TYPED_ARRAY(tctx->tmp_buf, mtab->size) ||
552  !FF_ALLOC_TYPED_ARRAY(tctx->spectrum, table_size) ||
553  !FF_ALLOC_TYPED_ARRAY(tctx->curr_frame, table_size) ||
554  !FF_ALLOC_TYPED_ARRAY(tctx->prev_frame, table_size))
555  return AVERROR(ENOMEM);
556 
557  for (i = 0; i < 3; i++) {
558  int m = 4 * mtab->size / mtab->fmode[i].sub;
559  double freq = 2 * M_PI / m;
560  if (!FF_ALLOC_TYPED_ARRAY(tctx->cos_tabs[i], m / 4))
561  return AVERROR(ENOMEM);
562  for (j = 0; j <= m / 8; j++)
563  tctx->cos_tabs[i][j] = cos((2 * j + 1) * freq);
564  for (j = 1; j < m / 8; j++)
565  tctx->cos_tabs[i][m / 4 - j] = tctx->cos_tabs[i][j];
566  }
567 
569  ff_init_ff_sine_windows(av_log2(size_s / 2));
571 
572  return 0;
573 }
574 
575 /**
576  * Interpret the data as if it were a num_blocks x line_len[0] matrix and for
577  * each line do a cyclic permutation, i.e.
578  * abcdefghijklm -> defghijklmabc
579  * where the amount to be shifted is evaluated depending on the column.
580  */
581 static void permutate_in_line(int16_t *tab, int num_vect, int num_blocks,
582  int block_size,
583  const uint8_t line_len[2], int length_div,
584  enum TwinVQFrameType ftype)
585 {
586  int i, j;
587 
588  for (i = 0; i < line_len[0]; i++) {
589  int shift;
590 
591  if (num_blocks == 1 ||
592  (ftype == TWINVQ_FT_LONG && num_vect % num_blocks) ||
593  (ftype != TWINVQ_FT_LONG && num_vect & 1) ||
594  i == line_len[1]) {
595  shift = 0;
596  } else if (ftype == TWINVQ_FT_LONG) {
597  shift = i;
598  } else
599  shift = i * i;
600 
601  for (j = 0; j < num_vect && (j + num_vect * i < block_size * num_blocks); j++)
602  tab[i * num_vect + j] = i * num_vect + (j + shift) % num_vect;
603  }
604 }
605 
606 /**
607  * Interpret the input data as in the following table:
608  *
609  * @verbatim
610  *
611  * abcdefgh
612  * ijklmnop
613  * qrstuvw
614  * x123456
615  *
616  * @endverbatim
617  *
618  * and transpose it, giving the output
619  * aiqxbjr1cks2dlt3emu4fvn5gow6hp
620  */
621 static void transpose_perm(int16_t *out, int16_t *in, int num_vect,
622  const uint8_t line_len[2], int length_div)
623 {
624  int i, j;
625  int cont = 0;
626 
627  for (i = 0; i < num_vect; i++)
628  for (j = 0; j < line_len[i >= length_div]; j++)
629  out[cont++] = in[j * num_vect + i];
630 }
631 
632 static void linear_perm(int16_t *out, int16_t *in, int n_blocks, int size)
633 {
634  int block_size = size / n_blocks;
635  int i;
636 
637  for (i = 0; i < size; i++)
638  out[i] = block_size * (in[i] % n_blocks) + in[i] / n_blocks;
639 }
640 
642  enum TwinVQFrameType ftype)
643 {
644  int block_size, size;
645  const TwinVQModeTab *mtab = tctx->mtab;
646  int16_t *tmp_perm = (int16_t *)tctx->tmp_buf;
647 
648  if (ftype == TWINVQ_FT_PPC) {
649  size = tctx->avctx->ch_layout.nb_channels;
650  block_size = mtab->ppc_shape_len;
651  } else {
652  size = tctx->avctx->ch_layout.nb_channels * mtab->fmode[ftype].sub;
653  block_size = mtab->size / mtab->fmode[ftype].sub;
654  }
655 
656  permutate_in_line(tmp_perm, tctx->n_div[ftype], size,
657  block_size, tctx->length[ftype],
658  tctx->length_change[ftype], ftype);
659 
660  transpose_perm(tctx->permut[ftype], tmp_perm, tctx->n_div[ftype],
661  tctx->length[ftype], tctx->length_change[ftype]);
662 
663  linear_perm(tctx->permut[ftype], tctx->permut[ftype], size,
664  size * block_size);
665 }
666 
668 {
669  const TwinVQModeTab *mtab = tctx->mtab;
670  int n_ch = tctx->avctx->ch_layout.nb_channels;
671  int total_fr_bits = tctx->avctx->bit_rate * mtab->size /
672  tctx->avctx->sample_rate;
673 
674  int lsp_bits_per_block = n_ch * (mtab->lsp_bit0 + mtab->lsp_bit1 +
675  mtab->lsp_split * mtab->lsp_bit2);
676 
677  int ppc_bits = n_ch * (mtab->pgain_bit + mtab->ppc_shape_bit +
678  mtab->ppc_period_bit);
679 
680  int bsize_no_main_cb[3], bse_bits[3], i;
681  enum TwinVQFrameType frametype;
682 
683  for (i = 0; i < 3; i++)
684  // +1 for history usage switch
685  bse_bits[i] = n_ch *
686  (mtab->fmode[i].bark_n_coef *
687  mtab->fmode[i].bark_n_bit + 1);
688 
689  bsize_no_main_cb[2] = bse_bits[2] + lsp_bits_per_block + ppc_bits +
691 
692  for (i = 0; i < 2; i++)
693  bsize_no_main_cb[i] =
694  lsp_bits_per_block + n_ch * TWINVQ_GAIN_BITS +
696  mtab->fmode[i].sub * (bse_bits[i] + n_ch * TWINVQ_SUB_GAIN_BITS);
697 
698  if (tctx->codec == TWINVQ_CODEC_METASOUND && !tctx->is_6kbps) {
699  bsize_no_main_cb[1] += 2;
700  bsize_no_main_cb[2] += 2;
701  }
702 
703  // The remaining bits are all used for the main spectrum coefficients
704  for (i = 0; i < 4; i++) {
705  int bit_size, vect_size;
706  int rounded_up, rounded_down, num_rounded_down, num_rounded_up;
707  if (i == 3) {
708  bit_size = n_ch * mtab->ppc_shape_bit;
709  vect_size = n_ch * mtab->ppc_shape_len;
710  } else {
711  bit_size = total_fr_bits - bsize_no_main_cb[i];
712  vect_size = n_ch * mtab->size;
713  }
714 
715  tctx->n_div[i] = (bit_size + 13) / 14;
716 
717  rounded_up = (bit_size + tctx->n_div[i] - 1) /
718  tctx->n_div[i];
719  rounded_down = (bit_size) / tctx->n_div[i];
720  num_rounded_down = rounded_up * tctx->n_div[i] - bit_size;
721  num_rounded_up = tctx->n_div[i] - num_rounded_down;
722  tctx->bits_main_spec[0][i][0] = (rounded_up + 1) / 2;
723  tctx->bits_main_spec[1][i][0] = rounded_up / 2;
724  tctx->bits_main_spec[0][i][1] = (rounded_down + 1) / 2;
725  tctx->bits_main_spec[1][i][1] = rounded_down / 2;
726  tctx->bits_main_spec_change[i] = num_rounded_up;
727 
728  rounded_up = (vect_size + tctx->n_div[i] - 1) /
729  tctx->n_div[i];
730  rounded_down = (vect_size) / tctx->n_div[i];
731  num_rounded_down = rounded_up * tctx->n_div[i] - vect_size;
732  num_rounded_up = tctx->n_div[i] - num_rounded_down;
733  tctx->length[i][0] = rounded_up;
734  tctx->length[i][1] = rounded_down;
735  tctx->length_change[i] = num_rounded_up;
736  }
737 
738  for (frametype = TWINVQ_FT_SHORT; frametype <= TWINVQ_FT_PPC; frametype++)
739  construct_perm_table(tctx, frametype);
740 }
741 
743 {
744  TwinVQContext *tctx = avctx->priv_data;
745  int i;
746 
747  for (i = 0; i < 3; i++) {
748  ff_mdct_end(&tctx->mdct_ctx[i]);
749  av_freep(&tctx->cos_tabs[i]);
750  }
751 
752  av_freep(&tctx->curr_frame);
753  av_freep(&tctx->spectrum);
754  av_freep(&tctx->prev_frame);
755  av_freep(&tctx->tmp_buf);
756  av_freep(&tctx->fdsp);
757 
758  return 0;
759 }
760 
762 {
763  int ret;
764  TwinVQContext *tctx = avctx->priv_data;
765  int64_t frames_per_packet;
766 
767  tctx->avctx = avctx;
769 
770  if (!avctx->block_align) {
771  avctx->block_align = tctx->frame_size + 7 >> 3;
772  }
773  frames_per_packet = avctx->block_align * 8LL / tctx->frame_size;
774  if (frames_per_packet <= 0) {
775  av_log(avctx, AV_LOG_ERROR, "Block align is %"PRId64" bits, expected %d\n",
776  avctx->block_align * (int64_t)8, tctx->frame_size);
777  return AVERROR_INVALIDDATA;
778  }
779  if (frames_per_packet > TWINVQ_MAX_FRAMES_PER_PACKET) {
780  av_log(avctx, AV_LOG_ERROR, "Too many frames per packet (%"PRId64")\n",
781  frames_per_packet);
782  return AVERROR_INVALIDDATA;
783  }
784  tctx->frames_per_packet = frames_per_packet;
785 
787  if (!tctx->fdsp)
788  return AVERROR(ENOMEM);
789  if ((ret = init_mdct_win(tctx))) {
790  av_log(avctx, AV_LOG_ERROR, "Error initializing MDCT\n");
791  return ret;
792  }
793  init_bitstream_params(tctx);
794 
795  twinvq_memset_float(tctx->bark_hist[0][0], 0.1,
796  FF_ARRAY_ELEMS(tctx->bark_hist));
797 
798  return 0;
799 }
TwinVQModeTab::lspcodebook
const float * lspcodebook
Definition: twinvq.h:115
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:66
linear_perm
static void linear_perm(int16_t *out, int16_t *in, int n_blocks, int size)
Definition: twinvq.c:632
TWINVQ_SUB_AMP_MAX
#define TWINVQ_SUB_AMP_MAX
Definition: twinvq.h:47
TwinVQContext::mtab
const TwinVQModeTab * mtab
Definition: twinvq.h:141
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:66
out
FILE * out
Definition: movenc.c:54
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1007
TwinVQContext::bits_main_spec
uint8_t bits_main_spec[2][4][2]
bits for the main codebook
Definition: twinvq.h:153
cb
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:239
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:50
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:166
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:264
TwinVQContext::curr_frame
float * curr_frame
non-interleaved output
Definition: twinvq.h:158
TWINVQ_GAIN_BITS
#define TWINVQ_GAIN_BITS
Definition: twinvq.h:49
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
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:169
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:374
TwinVQModeTab::ppc_shape_len
uint8_t ppc_shape_len
size of PPC shape CB
Definition: twinvq.h:129
ff_mdct_init
#define ff_mdct_init
Definition: fft.h:153
TwinVQModeTab::lsp_bit1
uint8_t lsp_bit1
Definition: twinvq.h:119
ff_twinvq_decode_init
av_cold int ff_twinvq_decode_init(AVCodecContext *avctx)
Requires the caller to call ff_twinvq_decode_close() upon failure.
Definition: twinvq.c:761
TwinVQContext::permut
int16_t permut[4][4096]
Definition: twinvq.h:150
imdct_output
static void imdct_output(TwinVQContext *tctx, enum TwinVQFrameType ftype, int wtype, float **out, int offset)
Definition: twinvq.c:379
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:130
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:300
TWINVQ_PPC_SHAPE_CB_SIZE
#define TWINVQ_PPC_SHAPE_CB_SIZE
Definition: twinvq.h:45
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:78
TwinVQContext::last_block_pos
int last_block_pos[2]
Definition: twinvq.h:160
TWINVQ_WINDOW_TYPE_BITS
#define TWINVQ_WINDOW_TYPE_BITS
Definition: twinvq.h:52
TwinVQFrameMode::cb1
const int16_t * cb1
Definition: twinvq.h:79
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:2065
TwinVQFrameMode::bark_n_coef
uint8_t bark_n_coef
number of BSE CB coefficients to read
Definition: twinvq.h:73
TwinVQFrameType
TwinVQFrameType
Definition: twinvq.h:38
tab
static const struct twinvq_data tab
Definition: twinvq_data.h:10345
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:478
val
static double val(void *priv, double ch)
Definition: aeval.c:77
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:113
twinvq_mulawinv
static float twinvq_mulawinv(float y, float clip, float mu)
Definition: twinvq.h:191
tab1
const int16_t * tab1
Definition: mace.c:145
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:175
TwinVQContext::n_div
int n_div[4]
Definition: twinvq.h:155
TwinVQContext::decode_ppc
void(* decode_ppc)(struct TwinVQContext *tctx, int period_coef, int g_coef, const float *shape, float *speech)
Definition: twinvq.h:178
chunk_end
static int chunk_end(AVFormatContext *s, int flush)
Definition: webm_chunk.c:177
ftype
#define ftype
Definition: afir_template.c:39
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:138
wtype_to_wsize
static const uint8_t wtype_to_wsize[]
Definition: twinvq.c:326
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:146
TwinVQModeTab::ppc_shape_bit
uint8_t ppc_shape_bit
number of bits of the PPC shape CB coeffs
Definition: twinvq.h:128
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:251
TWINVQ_LSP_COEFS_MAX
#define TWINVQ_LSP_COEFS_MAX
Definition: twinvq.h:54
TwinVQContext::codec
enum TwinVQCodec codec
Definition: twinvq.h:171
TwinVQContext::length_change
uint8_t length_change[4]
Definition: twinvq.h:152
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:40
TwinVQModeTab
Parameters and tables that are different for every combination of bitrate/sample rate.
Definition: twinvq.h:110
channels
channels
Definition: aptx.h:32
TwinVQModeTab::lsp_bit2
uint8_t lsp_bit2
Definition: twinvq.h:120
TWINVQ_MULAW_MU
#define TWINVQ_MULAW_MU
Definition: twinvq.h:48
twinvq_memset_float
static void twinvq_memset_float(float *buf, float val, int size)
Definition: twinvq.h:185
TwinVQContext::prev_frame
float * prev_frame
non-interleaved previous frame
Definition: twinvq.h:159
TWINVQ_FT_PPC
@ TWINVQ_FT_PPC
Periodic Peak Component (part of the long frame)
Definition: twinvq.h:42
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:742
TwinVQContext::length
uint8_t length[4][2]
main codebook stride
Definition: twinvq.h:151
NULL
#define NULL
Definition: coverity.c:32
TwinVQContext::mdct_ctx
FFTContext mdct_ctx[3]
Definition: twinvq.h:139
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:448
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
ff_twinvq_decode_frame
int ff_twinvq_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)
Definition: twinvq.c:478
TwinVQContext::is_6kbps
int is_6kbps
Definition: twinvq.h:143
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:621
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:137
dec_lpc_spectrum_inv
static void dec_lpc_spectrum_inv(TwinVQContext *tctx, float *lsp, enum TwinVQFrameType ftype, float *lpc)
Definition: twinvq.c:304
TwinVQModeTab::lsp_bit0
uint8_t lsp_bit0
Definition: twinvq.h:118
read_and_decode_spectrum
static void read_and_decode_spectrum(TwinVQContext *tctx, float *out, enum TwinVQFrameType ftype)
Definition: twinvq.c:414
TWINVQ_FT_LONG
@ TWINVQ_FT_LONG
Long frame (single sub-block + PPC)
Definition: twinvq.h:41
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1462
AVPacket::size
int size
Definition: packet.h:375
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:1023
TwinVQFrameMode::bark_n_bit
uint8_t bark_n_bit
number of bits of the BSE coefs
Definition: twinvq.h:74
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:126
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:154
TWINVQ_PPC_SHAPE_LEN_MAX
#define TWINVQ_PPC_SHAPE_LEN_MAX
Definition: twinvq.h:46
TWINVQ_CHANNELS_MAX
#define TWINVQ_CHANNELS_MAX
Definition: twinvq.h:56
TwinVQModeTab::ppc_shape_cb
const int16_t * ppc_shape_cb
PPC shape CB.
Definition: twinvq.h:123
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:667
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:534
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:173
TWINVQ_SUB_GAIN_BITS
#define TWINVQ_SUB_GAIN_BITS
Definition: twinvq.h:51
TwinVQContext::discarded_packets
int discarded_packets
Definition: twinvq.h:161
TWINVQ_CODEC_METASOUND
@ TWINVQ_CODEC_METASOUND
Definition: twinvq.h:35
FFTContext
Definition: fft.h:75
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
TwinVQContext::frame_size
int frame_size
Definition: twinvq.h:168
TwinVQContext::bark_hist
float bark_hist[3][2][40]
BSE coefficients of last frame.
Definition: twinvq.h:147
TwinVQFrameData
Definition: twinvq.h:85
TwinVQContext::cos_tabs
float * cos_tabs[3]
Definition: twinvq.h:163
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:581
avcodec.h
ret
ret
Definition: filter_design.txt:187
TwinVQContext::cur_frame
int cur_frame
Definition: twinvq.h:168
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:1052
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:39
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:328
fft.h
AVCodecContext
main external API structure.
Definition: avcodec.h:398
construct_perm_table
static av_cold void construct_perm_table(TwinVQContext *tctx, enum TwinVQFrameType ftype)
Definition: twinvq.c:641
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:82
TwinVQFrameData::ftype
enum TwinVQFrameType ftype
Definition: twinvq.h:87
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:168
shift
static int shift(int a, int b)
Definition: sonic.c:88
AV_CODEC_FLAG_BITEXACT
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:288
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:425
AVPacket
This structure stores compressed data.
Definition: packet.h:351
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
TWINVQ_SUBBLOCKS_MAX
#define TWINVQ_SUBBLOCKS_MAX
Definition: twinvq.h:57
TwinVQContext::spectrum
float * spectrum
Definition: twinvq.h:157
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:86
TWINVQ_MAX_FRAMES_PER_PACKET
#define TWINVQ_MAX_FRAMES_PER_PACKET
Definition: twinvq.h:60
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
TwinVQContext
Definition: twinvq.h:136
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:121
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:122
ff_twinvq_wtype_to_ftype_table
enum TwinVQFrameType ff_twinvq_wtype_to_ftype_table[]
Definition: twinvq.c:472
TwinVQModeTab::fmode
struct TwinVQFrameMode fmode[3]
frame type-dependent parameters
Definition: twinvq.h:111
TwinVQModeTab::n_lsp
uint8_t n_lsp
number of lsp coefficients
Definition: twinvq.h:114