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 
473  TWINVQ_FT_MEDIUM
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 }
float, planar
Definition: samplefmt.h:69
#define NULL
Definition: coverity.c:32
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
uint8_t bark_n_bit
number of bits of the BSE coefs
Definition: twinvq.h:75
static int shift(int a, int b)
Definition: sonic.c:82
static void linear_perm(int16_t *out, int16_t *in, int n_blocks, int size)
Definition: twinvq.c:631
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
uint8_t length_change[4]
Definition: twinvq.h:153
int discarded_packets
Definition: twinvq.h:162
int window_type
Definition: twinvq.h:87
uint8_t ppc_coeffs[TWINVQ_PPC_SHAPE_LEN_MAX]
Definition: twinvq.h:91
int bits_main_spec_change[4]
Definition: twinvq.h:155
const TwinVQModeTab * mtab
Definition: twinvq.h:142
int64_t bit_rate
the average bitrate
Definition: avcodec.h:576
TwinVQFrameData bits[TWINVQ_MAX_FRAMES_PER_PACKET]
Definition: twinvq.h:170
int p_coef[TWINVQ_CHANNELS_MAX]
Definition: twinvq.h:103
uint8_t cb_len_read
number of spectrum coefficients to read
Definition: twinvq.h:83
Medium frame (divided in m<n sub-blocks)
Definition: twinvq.h:41
uint8_t bark_n_coef
number of BSE CB coefficients to read
Definition: twinvq.h:74
static float cos_tab[256]
Definition: dca_lbr.c:123
int size
Definition: packet.h:356
int av_log2(unsigned v)
Definition: intmath.c:26
#define FF_ALLOC_TYPED_ARRAY(p, nelem)
Definition: internal.h:140
uint16_t size
frame size in samples
Definition: twinvq.h:114
uint8_t lsp_bit0
Definition: twinvq.h:119
uint8_t bark_use_hist[TWINVQ_CHANNELS_MAX][TWINVQ_SUBBLOCKS_MAX]
Definition: twinvq.h:97
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs...
Definition: avcodec.h:1223
uint8_t lpc_idx1[TWINVQ_CHANNELS_MAX]
Definition: twinvq.h:99
static const uint8_t wtype_to_wsize[]
Definition: twinvq.c:325
enum TwinVQFrameType ff_twinvq_wtype_to_ftype_table[]
Definition: twinvq.c:470
uint8_t sub_gain_bits[TWINVQ_CHANNELS_MAX *TWINVQ_SUBBLOCKS_MAX]
Definition: twinvq.h:94
Short frame (divided in n sub-blocks)
Definition: twinvq.h:40
void(* decode_ppc)(struct TwinVQContext *tctx, int period_coef, int g_coef, const float *shape, float *speech)
Definition: twinvq.h:179
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:215
uint8_t lpc_idx2[TWINVQ_CHANNELS_MAX][TWINVQ_LSP_SPLIT_MAX]
Definition: twinvq.h:100
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1194
uint8_t
#define av_cold
Definition: attributes.h:88
const int16_t * ppc_shape_cb
PPC shape CB.
Definition: twinvq.h:124
int g_coef[TWINVQ_CHANNELS_MAX]
Definition: twinvq.h:104
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
uint8_t ppc_period_bit
number of the bits for the PPC period value
Definition: twinvq.h:127
av_cold int ff_twinvq_decode_close(AVCodecContext *avctx)
Definition: twinvq.c:741
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
uint8_t gain_bits[TWINVQ_CHANNELS_MAX]
Definition: twinvq.h:93
#define TWINVQ_SUBBLOCKS_MAX
Definition: twinvq.h:58
#define TWINVQ_MULAW_MU
Definition: twinvq.h:49
static void imdct_output(TwinVQContext *tctx, enum TwinVQFrameType ftype, int wtype, float **out, int offset)
Definition: twinvq.c:378
#define TWINVQ_GAIN_BITS
Definition: twinvq.h:50
TwinVQFrameType
Definition: twinvq.h:39
static void interpolate(float *out, float v1, float v2, int size)
Definition: twinvq.c:84
uint8_t * data
Definition: packet.h:355
int last_block_pos[2]
Definition: twinvq.h:161
#define TWINVQ_WINDOW_TYPE_BITS
Definition: twinvq.h:53
Parameters and tables that are different for every combination of bitrate/sample rate.
Definition: twinvq.h:111
uint8_t lpc_hist_idx[TWINVQ_CHANNELS_MAX]
Definition: twinvq.h:101
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
ptrdiff_t size
Definition: opengl_enc.c:100
channels
Definition: aptx.h:33
int cur_frame
Definition: twinvq.h:169
Long frame (single sub-block + PPC)
Definition: twinvq.h:42
#define av_log(a,...)
static float twinvq_mulawinv(float y, float clip, float mu)
Definition: twinvq.h:192
int frame_size
Definition: twinvq.h:169
static av_cold void init_bitstream_params(TwinVQContext *tctx)
Definition: twinvq.c:666
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
float * tmp_buf
Definition: twinvq.h:167
uint8_t main_coeffs[1024]
Definition: twinvq.h:90
#define TWINVQ_MAX_FRAMES_PER_PACKET
Definition: twinvq.h:61
float * cos_tabs[3]
Definition: twinvq.h:164
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:135
#define TWINVQ_PPC_SHAPE_CB_SIZE
Definition: twinvq.h:46
unsigned int pos
Definition: spdifenc.c:410
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:606
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
GLsizei GLsizei * length
Definition: opengl_enc.c:114
float * spectrum
Definition: twinvq.h:158
uint8_t bits
Definition: vp3data.h:202
static void eval_lpcenv_2parts(TwinVQContext *tctx, enum TwinVQFrameType ftype, const float *buf, float *lpc, int size, int step)
Definition: twinvq.c:152
#define ff_mdct_init
Definition: fft.h:169
const int16_t * cb0
main codebooks for spectrum data
Definition: twinvq.h:79
static void dec_lpc_spectrum_inv(TwinVQContext *tctx, float *lsp, enum TwinVQFrameType ftype, float *lpc)
Definition: twinvq.c:303
Definition: fft.h:88
audio channel layout utility functions
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:333
uint8_t sub
Number subblocks in each frame.
Definition: twinvq.h:67
uint8_t bits_main_spec[2][4][2]
bits for the main codebook
Definition: twinvq.h:154
static void twinvq_memset_float(float *buf, float val, int size)
Definition: twinvq.h:186
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
uint8_t n_lsp
number of lsp coefficients
Definition: twinvq.h:115
int ff_twinvq_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: twinvq.c:476
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
int is_6kbps
Definition: twinvq.h:144
#define FF_ARRAY_ELEMS(a)
int n_div[4]
Definition: twinvq.h:156
if(ret)
uint8_t ppc_shape_bit
number of bits of the PPC shape CB coeffs
Definition: twinvq.h:129
int(* read_bitstream)(AVCodecContext *avctx, struct TwinVQContext *tctx, const uint8_t *buf, int buf_size)
Definition: twinvq.h:174
Libavcodec external API header.
float bark_hist[3][2][40]
BSE coefficients of last frame.
Definition: twinvq.h:148
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
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
int sample_rate
samples per second
Definition: avcodec.h:1186
Periodic Peak Component (part of the long frame)
Definition: twinvq.h:43
main external API structure.
Definition: avcodec.h:526
AVFloatDSPContext * fdsp
Definition: twinvq.h:139
enum TwinVQFrameType ftype
Definition: twinvq.h:88
int frames_per_packet
Definition: twinvq.h:169
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1854
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
const int16_t * tab1
Definition: mace.c:144
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31))))#define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac){}void ff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map){AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);return NULL;}return ac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;}int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){int use_generic=1;int len=in->nb_samples;int p;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
const int16_t * cb1
Definition: twinvq.h:80
struct TwinVQFrameMode fmode[3]
frame type-dependent parameters
Definition: twinvq.h:112
int16_t permut[4][4096]
Definition: twinvq.h:151
static void read_and_decode_spectrum(TwinVQContext *tctx, float *out, enum TwinVQFrameType ftype)
Definition: twinvq.c:412
#define TWINVQ_PPC_SHAPE_LEN_MAX
Definition: twinvq.h:47
float * prev_frame
non-interleaved previous frame
Definition: twinvq.h:160
uint8_t pgain_bit
bits for PPC gain
Definition: twinvq.h:131
void(* imdct_half)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
Definition: fft.h:108
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi-0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0f/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(UINT64_C(1)<< 63)))#define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64),};static void cpy1(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, len);}static void cpy2(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 2 *len);}static void cpy4(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 4 *len);}static void cpy8(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 8 *len);}AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags){AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);}ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map){switch(av_get_bytes_per_sample(in_fmt)){case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;}}if(HAVE_X86ASM &&1) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);return ctx;}void swri_audio_convert_free(AudioConvert **ctx){av_freep(ctx);}int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len){int ch;int off=0;const int os=(out->planar?1:out->ch_count)*out->bps;unsigned misaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask){int planes=in->planar?in->ch_count:1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;}if(ctx->out_simd_align_mask){int planes=out->planar?out->ch_count:1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;}if(ctx->simd_f &&!ctx->ch_map &&!misaligned){off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){if(out->planar==in->planar){int planes=out->planar?out->ch_count:1;for(ch=0;ch< planes;ch++){ctx->simd_f(out-> ch ch
Definition: audioconvert.c:56
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
static void imdct_and_window(TwinVQContext *tctx, enum TwinVQFrameType ftype, int wtype, float *in, float *prev, int ch)
Definition: twinvq.c:327
const float * lspcodebook
Definition: twinvq.h:116
#define avg(a, b, c, d)
uint8_t lsp_bit1
Definition: twinvq.h:120
enum TwinVQCodec codec
Definition: twinvq.h:172
static av_cold int init_mdct_win(TwinVQContext *tctx)
Init IMDCT and windowing tables.
Definition: twinvq.c:533
float lsp_hist[2][20]
LSP coefficients of the last frame.
Definition: twinvq.h:147
#define TWINVQ_LSP_COEFS_MAX
Definition: twinvq.h:55
common internal api header.
#define ff_mdct_end
Definition: fft.h:170
uint8_t ppc_shape_len
size of PPC shape CB
Definition: twinvq.h:130
#define TWINVQ_SUB_GAIN_BITS
Definition: twinvq.h:52
void ff_sort_nearly_sorted_floats(float *vals, int len)
Sort values in ascending order.
Definition: lsp.c:228
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
void * priv_data
Definition: avcodec.h:553
int channels
number of audio channels
Definition: avcodec.h:1187
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
static const struct twinvq_data tab
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
static int chunk_end(AVFormatContext *s, int flush)
Definition: webm_chunk.c:182
static float get_cos(int idx, int part, const float *cos_tab, int size)
Definition: twinvq.c:95
FILE * out
Definition: movenc.c:54
FFTContext mdct_ctx[3]
Definition: twinvq.h:140
#define av_freep(p)
float * curr_frame
non-interleaved output
Definition: twinvq.h:159
#define M_PI
Definition: mathematics.h:52
#define TWINVQ_AMP_MAX
Definition: twinvq.h:51
#define FFSWAP(type, a, b)
Definition: common.h:99
static void dec_gain(TwinVQContext *tctx, enum TwinVQFrameType ftype, float *out)
Definition: twinvq.c:214
#define TWINVQ_CHANNELS_MAX
Definition: twinvq.h:57
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:355
uint8_t length[4][2]
main codebook stride
Definition: twinvq.h:152
static double val(void *priv, double ch)
Definition: aeval.c:76
This structure stores compressed data.
Definition: packet.h:332
static av_cold void construct_perm_table(TwinVQContext *tctx, enum TwinVQFrameType ftype)
Definition: twinvq.c:640
#define TWINVQ_SUB_AMP_MAX
Definition: twinvq.h:48
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:374
AVCodecContext * avctx
Definition: twinvq.h:138
uint8_t lsp_bit2
Definition: twinvq.h:121
int i
Definition: input.c:406
uint8_t lsp_split
number of CB entries for the LSP decoding
Definition: twinvq.h:123
void AAC_RENAME() ff_init_ff_sine_windows(int index)
initialize the specified entry of ff_sine_windows
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
uint8_t bark1[TWINVQ_CHANNELS_MAX][TWINVQ_SUBBLOCKS_MAX][TWINVQ_BARK_N_COEF_MAX]
Definition: twinvq.h:96
av_cold int ff_twinvq_decode_init(AVCodecContext *avctx)
Definition: twinvq.c:760