FFmpeg
wmadec.c
Go to the documentation of this file.
1 /*
2  * WMA compatible decoder
3  * Copyright (c) 2002 The FFmpeg Project
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * WMA compatible decoder.
25  * This decoder handles Microsoft Windows Media Audio data, versions 1 & 2.
26  * WMA v1 is identified by audio format 0x160 in Microsoft media files
27  * (ASF/AVI/WAV). WMA v2 is identified by audio format 0x161.
28  *
29  * To use this decoder, a calling application must supply the extra data
30  * bytes provided with the WMA data. These are the extra, codec-specific
31  * bytes at the end of a WAVEFORMATEX data structure. Transmit these bytes
32  * to the decoder using the extradata[_size] fields in AVCodecContext. There
33  * should be 4 extra bytes for v1 data and 6 extra bytes for v2 data.
34  */
35 
36 #include "libavutil/attributes.h"
37 #include "libavutil/ffmath.h"
38 
39 #include "avcodec.h"
40 #include "internal.h"
41 #include "wma.h"
42 
43 #define EXPVLCBITS 8
44 #define EXPMAX ((19 + EXPVLCBITS - 1) / EXPVLCBITS)
45 
46 #define HGAINVLCBITS 9
47 #define HGAINMAX ((13 + HGAINVLCBITS - 1) / HGAINVLCBITS)
48 
49 static void wma_lsp_to_curve_init(WMACodecContext *s, int frame_len);
50 
51 #ifdef TRACE
52 static void dump_floats(WMACodecContext *s, const char *name,
53  int prec, const float *tab, int n)
54 {
55  int i;
56 
57  ff_tlog(s->avctx, "%s[%d]:\n", name, n);
58  for (i = 0; i < n; i++) {
59  if ((i & 7) == 0)
60  ff_tlog(s->avctx, "%4d: ", i);
61  ff_tlog(s->avctx, " %8.*f", prec, tab[i]);
62  if ((i & 7) == 7)
63  ff_tlog(s->avctx, "\n");
64  }
65  if ((i & 7) != 0)
66  ff_tlog(s->avctx, "\n");
67 }
68 #endif /* TRACE */
69 
71 {
72  WMACodecContext *s = avctx->priv_data;
73  int i, flags2;
74  uint8_t *extradata;
75 
76  if (!avctx->block_align) {
77  av_log(avctx, AV_LOG_ERROR, "block_align is not set\n");
78  return AVERROR(EINVAL);
79  }
80 
81  s->avctx = avctx;
82 
83  /* extract flag info */
84  flags2 = 0;
85  extradata = avctx->extradata;
86  if (avctx->codec->id == AV_CODEC_ID_WMAV1 && avctx->extradata_size >= 4)
87  flags2 = AV_RL16(extradata + 2);
88  else if (avctx->codec->id == AV_CODEC_ID_WMAV2 && avctx->extradata_size >= 6)
89  flags2 = AV_RL16(extradata + 4);
90 
91  s->use_exp_vlc = flags2 & 0x0001;
92  s->use_bit_reservoir = flags2 & 0x0002;
93  s->use_variable_block_len = flags2 & 0x0004;
94 
95  if (avctx->codec->id == AV_CODEC_ID_WMAV2 && avctx->extradata_size >= 8){
96  if (AV_RL16(extradata+4)==0xd && s->use_variable_block_len){
97  av_log(avctx, AV_LOG_WARNING, "Disabling use_variable_block_len, if this fails contact the ffmpeg developers and send us the file\n");
98  s->use_variable_block_len= 0; // this fixes issue1503
99  }
100  }
101 
102  for (i=0; i<MAX_CHANNELS; i++)
103  s->max_exponent[i] = 1.0;
104 
105  if (ff_wma_init(avctx, flags2) < 0)
106  return -1;
107 
108  /* init MDCT */
109  for (i = 0; i < s->nb_block_sizes; i++)
110  ff_mdct_init(&s->mdct_ctx[i], s->frame_len_bits - i + 1, 1, 1.0 / 32768.0);
111 
112  if (s->use_noise_coding) {
114  ff_wma_hgain_huffbits, 1, 1,
115  ff_wma_hgain_huffcodes, 2, 2, 0);
116  }
117 
118  if (s->use_exp_vlc)
119  init_vlc(&s->exp_vlc, EXPVLCBITS, sizeof(ff_aac_scalefactor_bits), // FIXME move out of context
121  ff_aac_scalefactor_code, 4, 4, 0);
122  else
124 
126 
127  return 0;
128 }
129 
130 /**
131  * compute x^-0.25 with an exponent and mantissa table. We use linear
132  * interpolation to reduce the mantissa table size at a small speed
133  * expense (linear interpolation approximately doubles the number of
134  * bits of precision).
135  */
136 static inline float pow_m1_4(WMACodecContext *s, float x)
137 {
138  union {
139  float f;
140  unsigned int v;
141  } u, t;
142  unsigned int e, m;
143  float a, b;
144 
145  u.f = x;
146  e = u.v >> 23;
147  m = (u.v >> (23 - LSP_POW_BITS)) & ((1 << LSP_POW_BITS) - 1);
148  /* build interpolation scale: 1 <= t < 2. */
149  t.v = ((u.v << LSP_POW_BITS) & ((1 << 23) - 1)) | (127 << 23);
150  a = s->lsp_pow_m_table1[m];
151  b = s->lsp_pow_m_table2[m];
152  return s->lsp_pow_e_table[e] * (a + b * t.f);
153 }
154 
155 static av_cold void wma_lsp_to_curve_init(WMACodecContext *s, int frame_len)
156 {
157  float wdel, a, b;
158  int i, e, m;
159 
160  wdel = M_PI / frame_len;
161  for (i = 0; i < frame_len; i++)
162  s->lsp_cos_table[i] = 2.0f * cos(wdel * i);
163 
164  /* tables for x^-0.25 computation */
165  for (i = 0; i < 256; i++) {
166  e = i - 126;
167  s->lsp_pow_e_table[i] = exp2f(e * -0.25);
168  }
169 
170  /* NOTE: these two tables are needed to avoid two operations in
171  * pow_m1_4 */
172  b = 1.0;
173  for (i = (1 << LSP_POW_BITS) - 1; i >= 0; i--) {
174  m = (1 << LSP_POW_BITS) + i;
175  a = (float) m * (0.5 / (1 << LSP_POW_BITS));
176  a = 1/sqrt(sqrt(a));
177  s->lsp_pow_m_table1[i] = 2 * a - b;
178  s->lsp_pow_m_table2[i] = b - a;
179  b = a;
180  }
181 }
182 
183 /**
184  * NOTE: We use the same code as Vorbis here
185  * @todo optimize it further with SSE/3Dnow
186  */
187 static void wma_lsp_to_curve(WMACodecContext *s, float *out, float *val_max_ptr,
188  int n, float *lsp)
189 {
190  int i, j;
191  float p, q, w, v, val_max;
192 
193  val_max = 0;
194  for (i = 0; i < n; i++) {
195  p = 0.5f;
196  q = 0.5f;
197  w = s->lsp_cos_table[i];
198  for (j = 1; j < NB_LSP_COEFS; j += 2) {
199  q *= w - lsp[j - 1];
200  p *= w - lsp[j];
201  }
202  p *= p * (2.0f - w);
203  q *= q * (2.0f + w);
204  v = p + q;
205  v = pow_m1_4(s, v);
206  if (v > val_max)
207  val_max = v;
208  out[i] = v;
209  }
210  *val_max_ptr = val_max;
211 }
212 
213 /**
214  * decode exponents coded with LSP coefficients (same idea as Vorbis)
215  */
216 static void decode_exp_lsp(WMACodecContext *s, int ch)
217 {
218  float lsp_coefs[NB_LSP_COEFS];
219  int val, i;
220 
221  for (i = 0; i < NB_LSP_COEFS; i++) {
222  if (i == 0 || i >= 8)
223  val = get_bits(&s->gb, 3);
224  else
225  val = get_bits(&s->gb, 4);
226  lsp_coefs[i] = ff_wma_lsp_codebook[i][val];
227  }
228 
229  wma_lsp_to_curve(s, s->exponents[ch], &s->max_exponent[ch],
230  s->block_len, lsp_coefs);
231 }
232 
233 /** pow(10, i / 16.0) for i in -60..95 */
234 static const float pow_tab[] = {
235  1.7782794100389e-04, 2.0535250264571e-04,
236  2.3713737056617e-04, 2.7384196342644e-04,
237  3.1622776601684e-04, 3.6517412725484e-04,
238  4.2169650342858e-04, 4.8696752516586e-04,
239  5.6234132519035e-04, 6.4938163157621e-04,
240  7.4989420933246e-04, 8.6596432336006e-04,
241  1.0000000000000e-03, 1.1547819846895e-03,
242  1.3335214321633e-03, 1.5399265260595e-03,
243  1.7782794100389e-03, 2.0535250264571e-03,
244  2.3713737056617e-03, 2.7384196342644e-03,
245  3.1622776601684e-03, 3.6517412725484e-03,
246  4.2169650342858e-03, 4.8696752516586e-03,
247  5.6234132519035e-03, 6.4938163157621e-03,
248  7.4989420933246e-03, 8.6596432336006e-03,
249  1.0000000000000e-02, 1.1547819846895e-02,
250  1.3335214321633e-02, 1.5399265260595e-02,
251  1.7782794100389e-02, 2.0535250264571e-02,
252  2.3713737056617e-02, 2.7384196342644e-02,
253  3.1622776601684e-02, 3.6517412725484e-02,
254  4.2169650342858e-02, 4.8696752516586e-02,
255  5.6234132519035e-02, 6.4938163157621e-02,
256  7.4989420933246e-02, 8.6596432336007e-02,
257  1.0000000000000e-01, 1.1547819846895e-01,
258  1.3335214321633e-01, 1.5399265260595e-01,
259  1.7782794100389e-01, 2.0535250264571e-01,
260  2.3713737056617e-01, 2.7384196342644e-01,
261  3.1622776601684e-01, 3.6517412725484e-01,
262  4.2169650342858e-01, 4.8696752516586e-01,
263  5.6234132519035e-01, 6.4938163157621e-01,
264  7.4989420933246e-01, 8.6596432336007e-01,
265  1.0000000000000e+00, 1.1547819846895e+00,
266  1.3335214321633e+00, 1.5399265260595e+00,
267  1.7782794100389e+00, 2.0535250264571e+00,
268  2.3713737056617e+00, 2.7384196342644e+00,
269  3.1622776601684e+00, 3.6517412725484e+00,
270  4.2169650342858e+00, 4.8696752516586e+00,
271  5.6234132519035e+00, 6.4938163157621e+00,
272  7.4989420933246e+00, 8.6596432336007e+00,
273  1.0000000000000e+01, 1.1547819846895e+01,
274  1.3335214321633e+01, 1.5399265260595e+01,
275  1.7782794100389e+01, 2.0535250264571e+01,
276  2.3713737056617e+01, 2.7384196342644e+01,
277  3.1622776601684e+01, 3.6517412725484e+01,
278  4.2169650342858e+01, 4.8696752516586e+01,
279  5.6234132519035e+01, 6.4938163157621e+01,
280  7.4989420933246e+01, 8.6596432336007e+01,
281  1.0000000000000e+02, 1.1547819846895e+02,
282  1.3335214321633e+02, 1.5399265260595e+02,
283  1.7782794100389e+02, 2.0535250264571e+02,
284  2.3713737056617e+02, 2.7384196342644e+02,
285  3.1622776601684e+02, 3.6517412725484e+02,
286  4.2169650342858e+02, 4.8696752516586e+02,
287  5.6234132519035e+02, 6.4938163157621e+02,
288  7.4989420933246e+02, 8.6596432336007e+02,
289  1.0000000000000e+03, 1.1547819846895e+03,
290  1.3335214321633e+03, 1.5399265260595e+03,
291  1.7782794100389e+03, 2.0535250264571e+03,
292  2.3713737056617e+03, 2.7384196342644e+03,
293  3.1622776601684e+03, 3.6517412725484e+03,
294  4.2169650342858e+03, 4.8696752516586e+03,
295  5.6234132519035e+03, 6.4938163157621e+03,
296  7.4989420933246e+03, 8.6596432336007e+03,
297  1.0000000000000e+04, 1.1547819846895e+04,
298  1.3335214321633e+04, 1.5399265260595e+04,
299  1.7782794100389e+04, 2.0535250264571e+04,
300  2.3713737056617e+04, 2.7384196342644e+04,
301  3.1622776601684e+04, 3.6517412725484e+04,
302  4.2169650342858e+04, 4.8696752516586e+04,
303  5.6234132519035e+04, 6.4938163157621e+04,
304  7.4989420933246e+04, 8.6596432336007e+04,
305  1.0000000000000e+05, 1.1547819846895e+05,
306  1.3335214321633e+05, 1.5399265260595e+05,
307  1.7782794100389e+05, 2.0535250264571e+05,
308  2.3713737056617e+05, 2.7384196342644e+05,
309  3.1622776601684e+05, 3.6517412725484e+05,
310  4.2169650342858e+05, 4.8696752516586e+05,
311  5.6234132519035e+05, 6.4938163157621e+05,
312  7.4989420933246e+05, 8.6596432336007e+05,
313 };
314 
315 /**
316  * decode exponents coded with VLC codes
317  */
318 static int decode_exp_vlc(WMACodecContext *s, int ch)
319 {
320  int last_exp, n, code;
321  const uint16_t *ptr;
322  float v, max_scale;
323  uint32_t *q, *q_end, iv;
324  const float *ptab = pow_tab + 60;
325  const uint32_t *iptab = (const uint32_t *) ptab;
326 
327  ptr = s->exponent_bands[s->frame_len_bits - s->block_len_bits];
328  q = (uint32_t *) s->exponents[ch];
329  q_end = q + s->block_len;
330  max_scale = 0;
331  if (s->version == 1) {
332  last_exp = get_bits(&s->gb, 5) + 10;
333  v = ptab[last_exp];
334  iv = iptab[last_exp];
335  max_scale = v;
336  n = *ptr++;
337  switch (n & 3) do {
338  case 0: *q++ = iv;
339  case 3: *q++ = iv;
340  case 2: *q++ = iv;
341  case 1: *q++ = iv;
342  } while ((n -= 4) > 0);
343  } else
344  last_exp = 36;
345 
346  while (q < q_end) {
347  code = get_vlc2(&s->gb, s->exp_vlc.table, EXPVLCBITS, EXPMAX);
348  if (code < 0) {
349  av_log(s->avctx, AV_LOG_ERROR, "Exponent vlc invalid\n");
350  return -1;
351  }
352  /* NOTE: this offset is the same as MPEG-4 AAC! */
353  last_exp += code - 60;
354  if ((unsigned) last_exp + 60 >= FF_ARRAY_ELEMS(pow_tab)) {
355  av_log(s->avctx, AV_LOG_ERROR, "Exponent out of range: %d\n",
356  last_exp);
357  return -1;
358  }
359  v = ptab[last_exp];
360  iv = iptab[last_exp];
361  if (v > max_scale)
362  max_scale = v;
363  n = *ptr++;
364  switch (n & 3) do {
365  case 0: *q++ = iv;
366  case 3: *q++ = iv;
367  case 2: *q++ = iv;
368  case 1: *q++ = iv;
369  } while ((n -= 4) > 0);
370  }
371  s->max_exponent[ch] = max_scale;
372  return 0;
373 }
374 
375 /**
376  * Apply MDCT window and add into output.
377  *
378  * We ensure that when the windows overlap their squared sum
379  * is always 1 (MDCT reconstruction rule).
380  */
381 static void wma_window(WMACodecContext *s, float *out)
382 {
383  float *in = s->output;
384  int block_len, bsize, n;
385 
386  /* left part */
387  if (s->block_len_bits <= s->prev_block_len_bits) {
388  block_len = s->block_len;
389  bsize = s->frame_len_bits - s->block_len_bits;
390 
391  s->fdsp->vector_fmul_add(out, in, s->windows[bsize],
392  out, block_len);
393  } else {
394  block_len = 1 << s->prev_block_len_bits;
395  n = (s->block_len - block_len) / 2;
396  bsize = s->frame_len_bits - s->prev_block_len_bits;
397 
398  s->fdsp->vector_fmul_add(out + n, in + n, s->windows[bsize],
399  out + n, block_len);
400 
401  memcpy(out + n + block_len, in + n + block_len, n * sizeof(float));
402  }
403 
404  out += s->block_len;
405  in += s->block_len;
406 
407  /* right part */
408  if (s->block_len_bits <= s->next_block_len_bits) {
409  block_len = s->block_len;
410  bsize = s->frame_len_bits - s->block_len_bits;
411 
412  s->fdsp->vector_fmul_reverse(out, in, s->windows[bsize], block_len);
413  } else {
414  block_len = 1 << s->next_block_len_bits;
415  n = (s->block_len - block_len) / 2;
416  bsize = s->frame_len_bits - s->next_block_len_bits;
417 
418  memcpy(out, in, n * sizeof(float));
419 
420  s->fdsp->vector_fmul_reverse(out + n, in + n, s->windows[bsize],
421  block_len);
422 
423  memset(out + n + block_len, 0, n * sizeof(float));
424  }
425 }
426 
427 /**
428  * @return 0 if OK. 1 if last block of frame. return -1 if
429  * unrecoverable error.
430  */
432 {
433  int n, v, a, ch, bsize;
434  int coef_nb_bits, total_gain;
435  int nb_coefs[MAX_CHANNELS];
436  float mdct_norm;
437  FFTContext *mdct;
438 
439 #ifdef TRACE
440  ff_tlog(s->avctx, "***decode_block: %d:%d\n",
441  s->frame_count - 1, s->block_num);
442 #endif /* TRACE */
443 
444  /* compute current block length */
445  if (s->use_variable_block_len) {
446  n = av_log2(s->nb_block_sizes - 1) + 1;
447 
448  if (s->reset_block_lengths) {
449  s->reset_block_lengths = 0;
450  v = get_bits(&s->gb, n);
451  if (v >= s->nb_block_sizes) {
453  "prev_block_len_bits %d out of range\n",
454  s->frame_len_bits - v);
455  return -1;
456  }
458  v = get_bits(&s->gb, n);
459  if (v >= s->nb_block_sizes) {
461  "block_len_bits %d out of range\n",
462  s->frame_len_bits - v);
463  return -1;
464  }
465  s->block_len_bits = s->frame_len_bits - v;
466  } else {
467  /* update block lengths */
470  }
471  v = get_bits(&s->gb, n);
472  if (v >= s->nb_block_sizes) {
474  "next_block_len_bits %d out of range\n",
475  s->frame_len_bits - v);
476  return -1;
477  }
479  } else {
480  /* fixed block len */
484  }
485 
486  if (s->frame_len_bits - s->block_len_bits >= s->nb_block_sizes){
487  av_log(s->avctx, AV_LOG_ERROR, "block_len_bits not initialized to a valid value\n");
488  return -1;
489  }
490 
491  /* now check if the block length is coherent with the frame length */
492  s->block_len = 1 << s->block_len_bits;
493  if ((s->block_pos + s->block_len) > s->frame_len) {
494  av_log(s->avctx, AV_LOG_ERROR, "frame_len overflow\n");
495  return -1;
496  }
497 
498  if (s->avctx->channels == 2)
499  s->ms_stereo = get_bits1(&s->gb);
500  v = 0;
501  for (ch = 0; ch < s->avctx->channels; ch++) {
502  a = get_bits1(&s->gb);
503  s->channel_coded[ch] = a;
504  v |= a;
505  }
506 
507  bsize = s->frame_len_bits - s->block_len_bits;
508 
509  /* if no channel coded, no need to go further */
510  /* XXX: fix potential framing problems */
511  if (!v)
512  goto next;
513 
514  /* read total gain and extract corresponding number of bits for
515  * coef escape coding */
516  total_gain = 1;
517  for (;;) {
518  if (get_bits_left(&s->gb) < 7) {
519  av_log(s->avctx, AV_LOG_ERROR, "total_gain overread\n");
520  return AVERROR_INVALIDDATA;
521  }
522  a = get_bits(&s->gb, 7);
523  total_gain += a;
524  if (a != 127)
525  break;
526  }
527 
528  coef_nb_bits = ff_wma_total_gain_to_bits(total_gain);
529 
530  /* compute number of coefficients */
531  n = s->coefs_end[bsize] - s->coefs_start;
532  for (ch = 0; ch < s->avctx->channels; ch++)
533  nb_coefs[ch] = n;
534 
535  /* complex coding */
536  if (s->use_noise_coding) {
537  for (ch = 0; ch < s->avctx->channels; ch++) {
538  if (s->channel_coded[ch]) {
539  int i, n, a;
540  n = s->exponent_high_sizes[bsize];
541  for (i = 0; i < n; i++) {
542  a = get_bits1(&s->gb);
543  s->high_band_coded[ch][i] = a;
544  /* if noise coding, the coefficients are not transmitted */
545  if (a)
546  nb_coefs[ch] -= s->exponent_high_bands[bsize][i];
547  }
548  }
549  }
550  for (ch = 0; ch < s->avctx->channels; ch++) {
551  if (s->channel_coded[ch]) {
552  int i, n, val, code;
553 
554  n = s->exponent_high_sizes[bsize];
555  val = (int) 0x80000000;
556  for (i = 0; i < n; i++) {
557  if (s->high_band_coded[ch][i]) {
558  if (val == (int) 0x80000000) {
559  val = get_bits(&s->gb, 7) - 19;
560  } else {
561  code = get_vlc2(&s->gb, s->hgain_vlc.table,
563  if (code < 0) {
565  "hgain vlc invalid\n");
566  return -1;
567  }
568  val += code - 18;
569  }
570  s->high_band_values[ch][i] = val;
571  }
572  }
573  }
574  }
575  }
576 
577  /* exponents can be reused in short blocks. */
578  if ((s->block_len_bits == s->frame_len_bits) || get_bits1(&s->gb)) {
579  for (ch = 0; ch < s->avctx->channels; ch++) {
580  if (s->channel_coded[ch]) {
581  if (s->use_exp_vlc) {
582  if (decode_exp_vlc(s, ch) < 0)
583  return -1;
584  } else {
585  decode_exp_lsp(s, ch);
586  }
587  s->exponents_bsize[ch] = bsize;
588  }
589  }
590  s->exponents_initialized = 1;
591  }else if (!s->exponents_initialized) {
592  return AVERROR_INVALIDDATA;
593  }
594 
595  /* parse spectral coefficients : just RLE encoding */
596  for (ch = 0; ch < s->avctx->channels; ch++) {
597  if (s->channel_coded[ch]) {
598  int tindex;
599  WMACoef *ptr = &s->coefs1[ch][0];
600 
601  /* special VLC tables are used for ms stereo because
602  * there is potentially less energy there */
603  tindex = (ch == 1 && s->ms_stereo);
604  memset(ptr, 0, s->block_len * sizeof(WMACoef));
605  ff_wma_run_level_decode(s->avctx, &s->gb, &s->coef_vlc[tindex],
606  s->level_table[tindex], s->run_table[tindex],
607  0, ptr, 0, nb_coefs[ch],
608  s->block_len, s->frame_len_bits, coef_nb_bits);
609  }
610  if (s->version == 1 && s->avctx->channels >= 2)
611  align_get_bits(&s->gb);
612  }
613 
614  /* normalize */
615  {
616  int n4 = s->block_len / 2;
617  mdct_norm = 1.0 / (float) n4;
618  if (s->version == 1)
619  mdct_norm *= sqrt(n4);
620  }
621 
622  /* finally compute the MDCT coefficients */
623  for (ch = 0; ch < s->avctx->channels; ch++) {
624  if (s->channel_coded[ch]) {
625  WMACoef *coefs1;
626  float *coefs, *exponents, mult, mult1, noise;
627  int i, j, n, n1, last_high_band, esize;
628  float exp_power[HIGH_BAND_MAX_SIZE];
629 
630  coefs1 = s->coefs1[ch];
631  exponents = s->exponents[ch];
632  esize = s->exponents_bsize[ch];
633  mult = ff_exp10(total_gain * 0.05) / s->max_exponent[ch];
634  mult *= mdct_norm;
635  coefs = s->coefs[ch];
636  if (s->use_noise_coding) {
637  mult1 = mult;
638  /* very low freqs : noise */
639  for (i = 0; i < s->coefs_start; i++) {
640  *coefs++ = s->noise_table[s->noise_index] *
641  exponents[i << bsize >> esize] * mult1;
642  s->noise_index = (s->noise_index + 1) &
643  (NOISE_TAB_SIZE - 1);
644  }
645 
646  n1 = s->exponent_high_sizes[bsize];
647 
648  /* compute power of high bands */
649  exponents = s->exponents[ch] +
650  (s->high_band_start[bsize] << bsize >> esize);
651  last_high_band = 0; /* avoid warning */
652  for (j = 0; j < n1; j++) {
654  s->block_len_bits][j];
655  if (s->high_band_coded[ch][j]) {
656  float e2, v;
657  e2 = 0;
658  for (i = 0; i < n; i++) {
659  v = exponents[i << bsize >> esize];
660  e2 += v * v;
661  }
662  exp_power[j] = e2 / n;
663  last_high_band = j;
664  ff_tlog(s->avctx, "%d: power=%f (%d)\n", j, exp_power[j], n);
665  }
666  exponents += n << bsize >> esize;
667  }
668 
669  /* main freqs and high freqs */
670  exponents = s->exponents[ch] + (s->coefs_start << bsize >> esize);
671  for (j = -1; j < n1; j++) {
672  if (j < 0)
673  n = s->high_band_start[bsize] - s->coefs_start;
674  else
676  s->block_len_bits][j];
677  if (j >= 0 && s->high_band_coded[ch][j]) {
678  /* use noise with specified power */
679  mult1 = sqrt(exp_power[j] / exp_power[last_high_band]);
680  /* XXX: use a table */
681  mult1 = mult1 * ff_exp10(s->high_band_values[ch][j] * 0.05);
682  mult1 = mult1 / (s->max_exponent[ch] * s->noise_mult);
683  mult1 *= mdct_norm;
684  for (i = 0; i < n; i++) {
685  noise = s->noise_table[s->noise_index];
686  s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1);
687  *coefs++ = noise * exponents[i << bsize >> esize] * mult1;
688  }
689  exponents += n << bsize >> esize;
690  } else {
691  /* coded values + small noise */
692  for (i = 0; i < n; i++) {
693  noise = s->noise_table[s->noise_index];
694  s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1);
695  *coefs++ = ((*coefs1++) + noise) *
696  exponents[i << bsize >> esize] * mult;
697  }
698  exponents += n << bsize >> esize;
699  }
700  }
701 
702  /* very high freqs : noise */
703  n = s->block_len - s->coefs_end[bsize];
704  mult1 = mult * exponents[(-(1 << bsize)) >> esize];
705  for (i = 0; i < n; i++) {
706  *coefs++ = s->noise_table[s->noise_index] * mult1;
707  s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1);
708  }
709  } else {
710  /* XXX: optimize more */
711  for (i = 0; i < s->coefs_start; i++)
712  *coefs++ = 0.0;
713  n = nb_coefs[ch];
714  for (i = 0; i < n; i++)
715  *coefs++ = coefs1[i] * exponents[i << bsize >> esize] * mult;
716  n = s->block_len - s->coefs_end[bsize];
717  for (i = 0; i < n; i++)
718  *coefs++ = 0.0;
719  }
720  }
721  }
722 
723 #ifdef TRACE
724  for (ch = 0; ch < s->avctx->channels; ch++) {
725  if (s->channel_coded[ch]) {
726  dump_floats(s, "exponents", 3, s->exponents[ch], s->block_len);
727  dump_floats(s, "coefs", 1, s->coefs[ch], s->block_len);
728  }
729  }
730 #endif /* TRACE */
731 
732  if (s->ms_stereo && s->channel_coded[1]) {
733  /* nominal case for ms stereo: we do it before mdct */
734  /* no need to optimize this case because it should almost
735  * never happen */
736  if (!s->channel_coded[0]) {
737  ff_tlog(s->avctx, "rare ms-stereo case happened\n");
738  memset(s->coefs[0], 0, sizeof(float) * s->block_len);
739  s->channel_coded[0] = 1;
740  }
741 
742  s->fdsp->butterflies_float(s->coefs[0], s->coefs[1], s->block_len);
743  }
744 
745 next:
746  mdct = &s->mdct_ctx[bsize];
747 
748  for (ch = 0; ch < s->avctx->channels; ch++) {
749  int n4, index;
750 
751  n4 = s->block_len / 2;
752  if (s->channel_coded[ch])
753  mdct->imdct_calc(mdct, s->output, s->coefs[ch]);
754  else if (!(s->ms_stereo && ch == 1))
755  memset(s->output, 0, sizeof(s->output));
756 
757  /* multiply by the window and add in the frame */
758  index = (s->frame_len / 2) + s->block_pos - n4;
759  wma_window(s, &s->frame_out[ch][index]);
760  }
761 
762  /* update block number */
763  s->block_num++;
764  s->block_pos += s->block_len;
765  if (s->block_pos >= s->frame_len)
766  return 1;
767  else
768  return 0;
769 }
770 
771 /* decode a frame of frame_len samples */
772 static int wma_decode_frame(WMACodecContext *s, float **samples,
773  int samples_offset)
774 {
775  int ret, ch;
776 
777 #ifdef TRACE
778  ff_tlog(s->avctx, "***decode_frame: %d size=%d\n",
779  s->frame_count++, s->frame_len);
780 #endif /* TRACE */
781 
782  /* read each block */
783  s->block_num = 0;
784  s->block_pos = 0;
785  for (;;) {
786  ret = wma_decode_block(s);
787  if (ret < 0)
788  return -1;
789  if (ret)
790  break;
791  }
792 
793  for (ch = 0; ch < s->avctx->channels; ch++) {
794  /* copy current block to output */
795  memcpy(samples[ch] + samples_offset, s->frame_out[ch],
796  s->frame_len * sizeof(*s->frame_out[ch]));
797  /* prepare for next block */
798  memmove(&s->frame_out[ch][0], &s->frame_out[ch][s->frame_len],
799  s->frame_len * sizeof(*s->frame_out[ch]));
800 
801 #ifdef TRACE
802  dump_floats(s, "samples", 6, samples[ch] + samples_offset,
803  s->frame_len);
804 #endif /* TRACE */
805  }
806 
807  return 0;
808 }
809 
810 static int wma_decode_superframe(AVCodecContext *avctx, void *data,
811  int *got_frame_ptr, AVPacket *avpkt)
812 {
813  AVFrame *frame = data;
814  const uint8_t *buf = avpkt->data;
815  int buf_size = avpkt->size;
816  WMACodecContext *s = avctx->priv_data;
817  int nb_frames, bit_offset, i, pos, len, ret;
818  uint8_t *q;
819  float **samples;
820  int samples_offset;
821 
822  ff_tlog(avctx, "***decode_superframe:\n");
823 
824  if (buf_size == 0) {
825  s->last_superframe_len = 0;
826  return 0;
827  }
828  if (buf_size < avctx->block_align) {
829  av_log(avctx, AV_LOG_ERROR,
830  "Input packet size too small (%d < %d)\n",
831  buf_size, avctx->block_align);
832  return AVERROR_INVALIDDATA;
833  }
834  if (avctx->block_align)
835  buf_size = avctx->block_align;
836 
837  init_get_bits(&s->gb, buf, buf_size * 8);
838 
839  if (s->use_bit_reservoir) {
840  /* read super frame header */
841  skip_bits(&s->gb, 4); /* super frame index */
842  nb_frames = get_bits(&s->gb, 4) - (s->last_superframe_len <= 0);
843  if (nb_frames <= 0) {
844  int is_error = nb_frames < 0 || get_bits_left(&s->gb) <= 8;
845  av_log(avctx, is_error ? AV_LOG_ERROR : AV_LOG_WARNING,
846  "nb_frames is %d bits left %d\n",
847  nb_frames, get_bits_left(&s->gb));
848  if (is_error)
849  return AVERROR_INVALIDDATA;
850 
851  if ((s->last_superframe_len + buf_size - 1) >
853  goto fail;
854 
856  len = buf_size - 1;
857  while (len > 0) {
858  *q++ = get_bits (&s->gb, 8);
859  len --;
860  }
861  memset(q, 0, AV_INPUT_BUFFER_PADDING_SIZE);
862 
863  s->last_superframe_len += 8*buf_size - 8;
864 // s->reset_block_lengths = 1; //XXX is this needed ?
865  *got_frame_ptr = 0;
866  return buf_size;
867  }
868  } else
869  nb_frames = 1;
870 
871  /* get output buffer */
872  frame->nb_samples = nb_frames * s->frame_len;
873  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
874  return ret;
875  samples = (float **) frame->extended_data;
876  samples_offset = 0;
877 
878  if (s->use_bit_reservoir) {
879  bit_offset = get_bits(&s->gb, s->byte_offset_bits + 3);
880  if (bit_offset > get_bits_left(&s->gb)) {
881  av_log(avctx, AV_LOG_ERROR,
882  "Invalid last frame bit offset %d > buf size %d (%d)\n",
883  bit_offset, get_bits_left(&s->gb), buf_size);
884  goto fail;
885  }
886 
887  if (s->last_superframe_len > 0) {
888  /* add bit_offset bits to last frame */
889  if ((s->last_superframe_len + ((bit_offset + 7) >> 3)) >
891  goto fail;
893  len = bit_offset;
894  while (len > 7) {
895  *q++ = (get_bits) (&s->gb, 8);
896  len -= 8;
897  }
898  if (len > 0)
899  *q++ = (get_bits) (&s->gb, len) << (8 - len);
900  memset(q, 0, AV_INPUT_BUFFER_PADDING_SIZE);
901 
902  /* XXX: bit_offset bits into last frame */
904  s->last_superframe_len * 8 + bit_offset);
905  /* skip unused bits */
906  if (s->last_bitoffset > 0)
907  skip_bits(&s->gb, s->last_bitoffset);
908  /* this frame is stored in the last superframe and in the
909  * current one */
910  if (wma_decode_frame(s, samples, samples_offset) < 0)
911  goto fail;
912  samples_offset += s->frame_len;
913  nb_frames--;
914  }
915 
916  /* read each frame starting from bit_offset */
917  pos = bit_offset + 4 + 4 + s->byte_offset_bits + 3;
918  if (pos >= MAX_CODED_SUPERFRAME_SIZE * 8 || pos > buf_size * 8)
919  return AVERROR_INVALIDDATA;
920  init_get_bits(&s->gb, buf + (pos >> 3), (buf_size - (pos >> 3)) * 8);
921  len = pos & 7;
922  if (len > 0)
923  skip_bits(&s->gb, len);
924 
925  s->reset_block_lengths = 1;
926  for (i = 0; i < nb_frames; i++) {
927  if (wma_decode_frame(s, samples, samples_offset) < 0)
928  goto fail;
929  samples_offset += s->frame_len;
930  }
931 
932  /* we copy the end of the frame in the last frame buffer */
933  pos = get_bits_count(&s->gb) +
934  ((bit_offset + 4 + 4 + s->byte_offset_bits + 3) & ~7);
935  s->last_bitoffset = pos & 7;
936  pos >>= 3;
937  len = buf_size - pos;
938  if (len > MAX_CODED_SUPERFRAME_SIZE || len < 0) {
939  av_log(s->avctx, AV_LOG_ERROR, "len %d invalid\n", len);
940  goto fail;
941  }
943  memcpy(s->last_superframe, buf + pos, len);
944  } else {
945  /* single frame decode */
946  if (wma_decode_frame(s, samples, samples_offset) < 0)
947  goto fail;
948  samples_offset += s->frame_len;
949  }
950 
951  ff_dlog(s->avctx, "%d %d %d %d outbytes:%"PTRDIFF_SPECIFIER" eaten:%d\n",
953  (int8_t *) samples - (int8_t *) data, avctx->block_align);
954 
955  *got_frame_ptr = 1;
956 
957  return buf_size;
958 
959 fail:
960  /* when error, we reset the bit reservoir */
961  s->last_superframe_len = 0;
962  return -1;
963 }
964 
965 static av_cold void flush(AVCodecContext *avctx)
966 {
967  WMACodecContext *s = avctx->priv_data;
968 
969  s->last_bitoffset =
970  s->last_superframe_len = 0;
971 }
972 
973 #if CONFIG_WMAV1_DECODER
975  .name = "wmav1",
976  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 1"),
977  .type = AVMEDIA_TYPE_AUDIO,
978  .id = AV_CODEC_ID_WMAV1,
979  .priv_data_size = sizeof(WMACodecContext),
981  .close = ff_wma_end,
983  .flush = flush,
984  .capabilities = AV_CODEC_CAP_DR1,
985  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
987 };
988 #endif
989 #if CONFIG_WMAV2_DECODER
991  .name = "wmav2",
992  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 2"),
993  .type = AVMEDIA_TYPE_AUDIO,
994  .id = AV_CODEC_ID_WMAV2,
995  .priv_data_size = sizeof(WMACodecContext),
997  .close = ff_wma_end,
999  .flush = flush,
1000  .capabilities = AV_CODEC_CAP_DR1,
1001  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1003 };
1004 #endif
float, planar
Definition: samplefmt.h:69
#define ff_tlog(ctx,...)
Definition: internal.h:75
const struct AVCodec * codec
Definition: avcodec.h:1579
const char const char void * val
Definition: avisynth_c.h:863
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
static void wma_lsp_to_curve(WMACodecContext *s, float *out, float *val_max_ptr, int n, float *lsp)
NOTE: We use the same code as Vorbis here.
Definition: wmadec.c:187
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
int next_block_len_bits
log2 of next block length
Definition: wma.h:105
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
static const float pow_tab[]
pow(10, i / 16.0) for i in -60..95
Definition: wmadec.c:234
int size
Definition: avcodec.h:1483
GetBitContext gb
Definition: wma.h:69
int av_log2(unsigned v)
Definition: intmath.c:26
int ff_wma_run_level_decode(AVCodecContext *avctx, GetBitContext *gb, VLC *vlc, const float *level_table, const uint16_t *run_table, int version, WMACoef *ptr, int offset, int num_coefs, int block_len, int frame_len_bits, int coef_nb_bits)
Decode run level compressed coefficients.
Definition: wma.c:428
int block_len
block length in samples
Definition: wma.h:107
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
float exponents[MAX_CHANNELS][BLOCK_MAX_SIZE]
Definition: wma.h:113
AVCodec.
Definition: avcodec.h:3494
static void wma_window(WMACodecContext *s, float *out)
Apply MDCT window and add into output.
Definition: wmadec.c:381
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:87
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs...
Definition: avcodec.h:2267
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
#define NOISE_TAB_SIZE
Definition: wma.h:49
float lsp_pow_m_table2[(1<< LSP_POW_BITS)]
Definition: wma.h:134
Macro definitions for various function/variable attributes.
static int wma_decode_block(WMACodecContext *s)
Definition: wmadec.c:431
float lsp_cos_table[BLOCK_MAX_SIZE]
Definition: wma.h:131
int high_band_start[BLOCK_NB_SIZES]
index of first coef in high band
Definition: wma.h:80
#define HGAINVLCBITS
Definition: wmadec.c:46
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2238
uint8_t
#define av_cold
Definition: attributes.h:82
float WMACoef
type for decoded coefficients, int16_t would be enough for wma 1/2
Definition: wma.h:57
#define f(width, name)
Definition: cbs_vp9.c:255
const uint8_t ff_aac_scalefactor_bits[121]
Definition: aactab.c:92
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1671
int block_pos
current position in frame
Definition: wma.h:109
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:252
static int decode_exp_vlc(WMACodecContext *s, int ch)
decode exponents coded with VLC codes
Definition: wmadec.c:318
uint8_t * data
Definition: avcodec.h:1482
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
#define ff_dlog(a,...)
float lsp_pow_m_table1[(1<< LSP_POW_BITS)]
Definition: wma.h:133
#define EXPMAX
Definition: wmadec.c:44
#define av_log(a,...)
int reset_block_lengths
Definition: wma.h:103
int nb_block_sizes
number of block sizes
Definition: wma.h:101
int ff_wma_total_gain_to_bits(int total_gain)
Definition: wma.c:354
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
enum AVCodecID id
Definition: avcodec.h:3508
static float pow_m1_4(WMACodecContext *s, float x)
compute x^-0.25 with an exponent and mantissa table.
Definition: wmadec.c:136
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
static av_always_inline double ff_exp10(double x)
Compute 10^x for floating point values.
Definition: ffmath.h:42
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#define PTRDIFF_SPECIFIER
Definition: internal.h:261
#define init_vlc(vlc, nb_bits, nb_codes,bits, bits_wrap, bits_size,codes, codes_wrap, codes_size,flags)
Definition: vlc.h:38
uint16_t exponent_bands[BLOCK_NB_SIZES][25]
Definition: wma.h:79
uint8_t channel_coded[MAX_CHANNELS]
true if channel is coded
Definition: wma.h:111
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
uint8_t last_superframe[MAX_CODED_SUPERFRAME_SIZE+AV_INPUT_BUFFER_PADDING_SIZE]
Definition: wma.h:123
int last_superframe_len
Definition: wma.h:125
const char * name
Name of the codec implementation.
Definition: avcodec.h:3501
static int wma_decode_superframe(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: wmadec.c:810
void(* imdct_calc)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
Definition: fft.h:107
FFTSample output[BLOCK_MAX_SIZE *2]
Definition: wma.h:117
#define ff_mdct_init
Definition: fft.h:169
const uint8_t ff_wma_hgain_huffbits[37]
Definition: wmadata.h:62
int noise_index
Definition: wma.h:128
#define fail()
Definition: checkasm.h:122
static av_cold int wma_decode_init(AVCodecContext *avctx)
Definition: wmadec.c:70
int exponent_high_bands[BLOCK_NB_SIZES][HIGH_BAND_MAX_SIZE]
Definition: wma.h:84
int ff_wma_end(AVCodecContext *avctx)
Definition: wma.c:368
int high_band_values[MAX_CHANNELS][HIGH_BAND_MAX_SIZE]
Definition: wma.h:89
#define b
Definition: input.c:41
AVFloatDSPContext * fdsp
Definition: wma.h:135
Definition: fft.h:88
static int16_t mult(Float11 *f1, Float11 *f2)
Definition: g726.c:55
int use_bit_reservoir
Definition: wma.h:72
#define MAX_CODED_SUPERFRAME_SIZE
Definition: wma.h:45
uint8_t w
Definition: llviddspenc.c:38
av_cold int ff_wma_init(AVCodecContext *avctx, int flags2)
Definition: wma.c:81
uint16_t * run_table[2]
Definition: wma.h:94
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
#define s(width, name)
Definition: cbs_vp9.c:257
const uint16_t ff_wma_hgain_huffcodes[37]
Definition: wmadata.h:54
int version
1 = 0x160 (WMAV1), 2 = 0x161 (WMAV2)
Definition: wma.h:71
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:797
int n
Definition: avisynth_c.h:760
int frame_len
frame length in samples
Definition: wma.h:99
AVCodec ff_wmav2_decoder
#define FF_ARRAY_ELEMS(a)
if(ret)
int last_bitoffset
Definition: wma.h:124
static av_cold void flush(AVCodecContext *avctx)
Definition: wmadec.c:965
#define exp2f(x)
Definition: libm.h:293
int frame_len_bits
frame_len = 1 << frame_len_bits
Definition: wma.h:100
Libavcodec external API header.
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
static int wma_decode_frame(WMACodecContext *s, float **samples, int samples_offset)
Definition: wmadec.c:772
#define HIGH_BAND_MAX_SIZE
Definition: wma.h:40
int use_exp_vlc
exponent coding: 0 = lsp, 1 = vlc + delta
Definition: wma.h:74
VLC coef_vlc[2]
Definition: wma.h:93
#define NB_LSP_COEFS
Definition: wma.h:42
main external API structure.
Definition: avcodec.h:1570
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1968
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
static void wma_lsp_to_curve_init(WMACodecContext *s, int frame_len)
Definition: wmadec.c:155
AVCodecContext * avctx
Definition: wma.h:68
void * buf
Definition: avisynth_c.h:766
float frame_out[MAX_CHANNELS][BLOCK_MAX_SIZE *2]
Definition: wma.h:121
int extradata_size
Definition: avcodec.h:1672
int exponent_high_sizes[BLOCK_NB_SIZES]
Definition: wma.h:83
static void decode_exp_lsp(WMACodecContext *s, int ch)
decode exponents coded with LSP coefficients (same idea as Vorbis)
Definition: wmadec.c:216
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
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
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
int index
Definition: gxfenc.c:89
int block_num
block number in current frame
Definition: wma.h:108
int use_noise_coding
true if perceptual noise is added
Definition: wma.h:75
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
float * level_table[2]
Definition: wma.h:95
#define LSP_POW_BITS
Definition: wma.h:51
#define MAX_CHANNELS
Definition: aac.h:47
int use_variable_block_len
Definition: wma.h:73
uint8_t ms_stereo
true if mid/side stereo mode
Definition: wma.h:110
int exponents_initialized
Definition: wma.h:126
VLC exp_vlc
Definition: wma.h:77
FFTContext mdct_ctx[BLOCK_NB_SIZES]
Definition: wma.h:118
const uint32_t ff_aac_scalefactor_code[121]
Definition: aactab.c:73
int exponents_bsize[MAX_CHANNELS]
log2 ratio frame/exp. length
Definition: wma.h:112
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 int noise(AVBSFContext *ctx, AVPacket *pkt)
Definition: noise_bsf.c:38
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
float coefs[MAX_CHANNELS][BLOCK_MAX_SIZE]
Definition: wma.h:116
int prev_block_len_bits
log2 of prev block length
Definition: wma.h:106
int coefs_end[BLOCK_NB_SIZES]
max number of coded coefficients
Definition: wma.h:82
internal math functions header
int
float lsp_pow_e_table[256]
Definition: wma.h:132
const float ff_wma_lsp_codebook[NB_LSP_COEFS][16]
Definition: wmadata.h:68
common internal api header.
void(* vector_fmul_add)(float *dst, const float *src0, const float *src1, const float *src2, int len)
Calculate the entry wise product of two vectors of floats, add a third vector of floats and store the...
Definition: float_dsp.h:137
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:795
void * priv_data
Definition: avcodec.h:1597
int len
int channels
number of audio channels
Definition: avcodec.h:2231
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
#define EXPVLCBITS
Definition: wmadec.c:43
WMACoef coefs1[MAX_CHANNELS][BLOCK_MAX_SIZE]
Definition: wma.h:115
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:693
#define HGAINMAX
Definition: wmadec.c:47
static const struct twinvq_data tab
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:701
float max_exponent[MAX_CHANNELS]
Definition: wma.h:114
FILE * out
Definition: movenc.c:54
Filter the word “frame” indicates either a video frame or a group of audio samples
VLC hgain_vlc
Definition: wma.h:85
int coefs_start
first coded coef
Definition: wma.h:81
#define M_PI
Definition: mathematics.h:52
int block_len_bits
log2 of current block length
Definition: wma.h:104
int byte_offset_bits
Definition: wma.h:76
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:342
This structure stores compressed data.
Definition: avcodec.h:1459
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:361
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:986
int high_band_coded[MAX_CHANNELS][HIGH_BAND_MAX_SIZE]
Definition: wma.h:88
float noise_table[NOISE_TAB_SIZE]
Definition: wma.h:127
const char * name
Definition: opengl_enc.c:102
AVCodec ff_wmav1_decoder
float noise_mult
Definition: wma.h:129
void(* vector_fmul_reverse)(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:154
const float * windows[BLOCK_NB_SIZES]
Definition: wma.h:119