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  }
591 
592  /* parse spectral coefficients : just RLE encoding */
593  for (ch = 0; ch < s->avctx->channels; ch++) {
594  if (s->channel_coded[ch]) {
595  int tindex;
596  WMACoef *ptr = &s->coefs1[ch][0];
597 
598  /* special VLC tables are used for ms stereo because
599  * there is potentially less energy there */
600  tindex = (ch == 1 && s->ms_stereo);
601  memset(ptr, 0, s->block_len * sizeof(WMACoef));
602  ff_wma_run_level_decode(s->avctx, &s->gb, &s->coef_vlc[tindex],
603  s->level_table[tindex], s->run_table[tindex],
604  0, ptr, 0, nb_coefs[ch],
605  s->block_len, s->frame_len_bits, coef_nb_bits);
606  }
607  if (s->version == 1 && s->avctx->channels >= 2)
608  align_get_bits(&s->gb);
609  }
610 
611  /* normalize */
612  {
613  int n4 = s->block_len / 2;
614  mdct_norm = 1.0 / (float) n4;
615  if (s->version == 1)
616  mdct_norm *= sqrt(n4);
617  }
618 
619  /* finally compute the MDCT coefficients */
620  for (ch = 0; ch < s->avctx->channels; ch++) {
621  if (s->channel_coded[ch]) {
622  WMACoef *coefs1;
623  float *coefs, *exponents, mult, mult1, noise;
624  int i, j, n, n1, last_high_band, esize;
625  float exp_power[HIGH_BAND_MAX_SIZE];
626 
627  coefs1 = s->coefs1[ch];
628  exponents = s->exponents[ch];
629  esize = s->exponents_bsize[ch];
630  mult = ff_exp10(total_gain * 0.05) / s->max_exponent[ch];
631  mult *= mdct_norm;
632  coefs = s->coefs[ch];
633  if (s->use_noise_coding) {
634  mult1 = mult;
635  /* very low freqs : noise */
636  for (i = 0; i < s->coefs_start; i++) {
637  *coefs++ = s->noise_table[s->noise_index] *
638  exponents[i << bsize >> esize] * mult1;
639  s->noise_index = (s->noise_index + 1) &
640  (NOISE_TAB_SIZE - 1);
641  }
642 
643  n1 = s->exponent_high_sizes[bsize];
644 
645  /* compute power of high bands */
646  exponents = s->exponents[ch] +
647  (s->high_band_start[bsize] << bsize >> esize);
648  last_high_band = 0; /* avoid warning */
649  for (j = 0; j < n1; j++) {
651  s->block_len_bits][j];
652  if (s->high_band_coded[ch][j]) {
653  float e2, v;
654  e2 = 0;
655  for (i = 0; i < n; i++) {
656  v = exponents[i << bsize >> esize];
657  e2 += v * v;
658  }
659  exp_power[j] = e2 / n;
660  last_high_band = j;
661  ff_tlog(s->avctx, "%d: power=%f (%d)\n", j, exp_power[j], n);
662  }
663  exponents += n << bsize >> esize;
664  }
665 
666  /* main freqs and high freqs */
667  exponents = s->exponents[ch] + (s->coefs_start << bsize >> esize);
668  for (j = -1; j < n1; j++) {
669  if (j < 0)
670  n = s->high_band_start[bsize] - s->coefs_start;
671  else
673  s->block_len_bits][j];
674  if (j >= 0 && s->high_band_coded[ch][j]) {
675  /* use noise with specified power */
676  mult1 = sqrt(exp_power[j] / exp_power[last_high_band]);
677  /* XXX: use a table */
678  mult1 = mult1 * ff_exp10(s->high_band_values[ch][j] * 0.05);
679  mult1 = mult1 / (s->max_exponent[ch] * s->noise_mult);
680  mult1 *= mdct_norm;
681  for (i = 0; i < n; i++) {
682  noise = s->noise_table[s->noise_index];
683  s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1);
684  *coefs++ = noise * exponents[i << bsize >> esize] * mult1;
685  }
686  exponents += n << bsize >> esize;
687  } else {
688  /* coded values + small noise */
689  for (i = 0; i < n; i++) {
690  noise = s->noise_table[s->noise_index];
691  s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1);
692  *coefs++ = ((*coefs1++) + noise) *
693  exponents[i << bsize >> esize] * mult;
694  }
695  exponents += n << bsize >> esize;
696  }
697  }
698 
699  /* very high freqs : noise */
700  n = s->block_len - s->coefs_end[bsize];
701  mult1 = mult * exponents[(-(1 << bsize)) >> esize];
702  for (i = 0; i < n; i++) {
703  *coefs++ = s->noise_table[s->noise_index] * mult1;
704  s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1);
705  }
706  } else {
707  /* XXX: optimize more */
708  for (i = 0; i < s->coefs_start; i++)
709  *coefs++ = 0.0;
710  n = nb_coefs[ch];
711  for (i = 0; i < n; i++)
712  *coefs++ = coefs1[i] * exponents[i << bsize >> esize] * mult;
713  n = s->block_len - s->coefs_end[bsize];
714  for (i = 0; i < n; i++)
715  *coefs++ = 0.0;
716  }
717  }
718  }
719 
720 #ifdef TRACE
721  for (ch = 0; ch < s->avctx->channels; ch++) {
722  if (s->channel_coded[ch]) {
723  dump_floats(s, "exponents", 3, s->exponents[ch], s->block_len);
724  dump_floats(s, "coefs", 1, s->coefs[ch], s->block_len);
725  }
726  }
727 #endif /* TRACE */
728 
729  if (s->ms_stereo && s->channel_coded[1]) {
730  /* nominal case for ms stereo: we do it before mdct */
731  /* no need to optimize this case because it should almost
732  * never happen */
733  if (!s->channel_coded[0]) {
734  ff_tlog(s->avctx, "rare ms-stereo case happened\n");
735  memset(s->coefs[0], 0, sizeof(float) * s->block_len);
736  s->channel_coded[0] = 1;
737  }
738 
739  s->fdsp->butterflies_float(s->coefs[0], s->coefs[1], s->block_len);
740  }
741 
742 next:
743  mdct = &s->mdct_ctx[bsize];
744 
745  for (ch = 0; ch < s->avctx->channels; ch++) {
746  int n4, index;
747 
748  n4 = s->block_len / 2;
749  if (s->channel_coded[ch])
750  mdct->imdct_calc(mdct, s->output, s->coefs[ch]);
751  else if (!(s->ms_stereo && ch == 1))
752  memset(s->output, 0, sizeof(s->output));
753 
754  /* multiply by the window and add in the frame */
755  index = (s->frame_len / 2) + s->block_pos - n4;
756  wma_window(s, &s->frame_out[ch][index]);
757  }
758 
759  /* update block number */
760  s->block_num++;
761  s->block_pos += s->block_len;
762  if (s->block_pos >= s->frame_len)
763  return 1;
764  else
765  return 0;
766 }
767 
768 /* decode a frame of frame_len samples */
769 static int wma_decode_frame(WMACodecContext *s, float **samples,
770  int samples_offset)
771 {
772  int ret, ch;
773 
774 #ifdef TRACE
775  ff_tlog(s->avctx, "***decode_frame: %d size=%d\n",
776  s->frame_count++, s->frame_len);
777 #endif /* TRACE */
778 
779  /* read each block */
780  s->block_num = 0;
781  s->block_pos = 0;
782  for (;;) {
783  ret = wma_decode_block(s);
784  if (ret < 0)
785  return -1;
786  if (ret)
787  break;
788  }
789 
790  for (ch = 0; ch < s->avctx->channels; ch++) {
791  /* copy current block to output */
792  memcpy(samples[ch] + samples_offset, s->frame_out[ch],
793  s->frame_len * sizeof(*s->frame_out[ch]));
794  /* prepare for next block */
795  memmove(&s->frame_out[ch][0], &s->frame_out[ch][s->frame_len],
796  s->frame_len * sizeof(*s->frame_out[ch]));
797 
798 #ifdef TRACE
799  dump_floats(s, "samples", 6, samples[ch] + samples_offset,
800  s->frame_len);
801 #endif /* TRACE */
802  }
803 
804  return 0;
805 }
806 
807 static int wma_decode_superframe(AVCodecContext *avctx, void *data,
808  int *got_frame_ptr, AVPacket *avpkt)
809 {
810  AVFrame *frame = data;
811  const uint8_t *buf = avpkt->data;
812  int buf_size = avpkt->size;
813  WMACodecContext *s = avctx->priv_data;
814  int nb_frames, bit_offset, i, pos, len, ret;
815  uint8_t *q;
816  float **samples;
817  int samples_offset;
818 
819  ff_tlog(avctx, "***decode_superframe:\n");
820 
821  if (buf_size == 0) {
822  s->last_superframe_len = 0;
823  return 0;
824  }
825  if (buf_size < avctx->block_align) {
826  av_log(avctx, AV_LOG_ERROR,
827  "Input packet size too small (%d < %d)\n",
828  buf_size, avctx->block_align);
829  return AVERROR_INVALIDDATA;
830  }
831  if (avctx->block_align)
832  buf_size = avctx->block_align;
833 
834  init_get_bits(&s->gb, buf, buf_size * 8);
835 
836  if (s->use_bit_reservoir) {
837  /* read super frame header */
838  skip_bits(&s->gb, 4); /* super frame index */
839  nb_frames = get_bits(&s->gb, 4) - (s->last_superframe_len <= 0);
840  if (nb_frames <= 0) {
841  int is_error = nb_frames < 0 || get_bits_left(&s->gb) <= 8;
842  av_log(avctx, is_error ? AV_LOG_ERROR : AV_LOG_WARNING,
843  "nb_frames is %d bits left %d\n",
844  nb_frames, get_bits_left(&s->gb));
845  if (is_error)
846  return AVERROR_INVALIDDATA;
847 
848  if ((s->last_superframe_len + buf_size - 1) >
850  goto fail;
851 
853  len = buf_size - 1;
854  while (len > 0) {
855  *q++ = get_bits (&s->gb, 8);
856  len --;
857  }
858  memset(q, 0, AV_INPUT_BUFFER_PADDING_SIZE);
859 
860  s->last_superframe_len += 8*buf_size - 8;
861 // s->reset_block_lengths = 1; //XXX is this needed ?
862  *got_frame_ptr = 0;
863  return buf_size;
864  }
865  } else
866  nb_frames = 1;
867 
868  /* get output buffer */
869  frame->nb_samples = nb_frames * s->frame_len;
870  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
871  return ret;
872  samples = (float **) frame->extended_data;
873  samples_offset = 0;
874 
875  if (s->use_bit_reservoir) {
876  bit_offset = get_bits(&s->gb, s->byte_offset_bits + 3);
877  if (bit_offset > get_bits_left(&s->gb)) {
878  av_log(avctx, AV_LOG_ERROR,
879  "Invalid last frame bit offset %d > buf size %d (%d)\n",
880  bit_offset, get_bits_left(&s->gb), buf_size);
881  goto fail;
882  }
883 
884  if (s->last_superframe_len > 0) {
885  /* add bit_offset bits to last frame */
886  if ((s->last_superframe_len + ((bit_offset + 7) >> 3)) >
888  goto fail;
890  len = bit_offset;
891  while (len > 7) {
892  *q++ = (get_bits) (&s->gb, 8);
893  len -= 8;
894  }
895  if (len > 0)
896  *q++ = (get_bits) (&s->gb, len) << (8 - len);
897  memset(q, 0, AV_INPUT_BUFFER_PADDING_SIZE);
898 
899  /* XXX: bit_offset bits into last frame */
901  s->last_superframe_len * 8 + bit_offset);
902  /* skip unused bits */
903  if (s->last_bitoffset > 0)
904  skip_bits(&s->gb, s->last_bitoffset);
905  /* this frame is stored in the last superframe and in the
906  * current one */
907  if (wma_decode_frame(s, samples, samples_offset) < 0)
908  goto fail;
909  samples_offset += s->frame_len;
910  nb_frames--;
911  }
912 
913  /* read each frame starting from bit_offset */
914  pos = bit_offset + 4 + 4 + s->byte_offset_bits + 3;
915  if (pos >= MAX_CODED_SUPERFRAME_SIZE * 8 || pos > buf_size * 8)
916  return AVERROR_INVALIDDATA;
917  init_get_bits(&s->gb, buf + (pos >> 3), (buf_size - (pos >> 3)) * 8);
918  len = pos & 7;
919  if (len > 0)
920  skip_bits(&s->gb, len);
921 
922  s->reset_block_lengths = 1;
923  for (i = 0; i < nb_frames; i++) {
924  if (wma_decode_frame(s, samples, samples_offset) < 0)
925  goto fail;
926  samples_offset += s->frame_len;
927  }
928 
929  /* we copy the end of the frame in the last frame buffer */
930  pos = get_bits_count(&s->gb) +
931  ((bit_offset + 4 + 4 + s->byte_offset_bits + 3) & ~7);
932  s->last_bitoffset = pos & 7;
933  pos >>= 3;
934  len = buf_size - pos;
935  if (len > MAX_CODED_SUPERFRAME_SIZE || len < 0) {
936  av_log(s->avctx, AV_LOG_ERROR, "len %d invalid\n", len);
937  goto fail;
938  }
940  memcpy(s->last_superframe, buf + pos, len);
941  } else {
942  /* single frame decode */
943  if (wma_decode_frame(s, samples, samples_offset) < 0)
944  goto fail;
945  samples_offset += s->frame_len;
946  }
947 
948  ff_dlog(s->avctx, "%d %d %d %d outbytes:%"PTRDIFF_SPECIFIER" eaten:%d\n",
950  (int8_t *) samples - (int8_t *) data, avctx->block_align);
951 
952  *got_frame_ptr = 1;
953 
954  return buf_size;
955 
956 fail:
957  /* when error, we reset the bit reservoir */
958  s->last_superframe_len = 0;
959  return -1;
960 }
961 
962 static av_cold void flush(AVCodecContext *avctx)
963 {
964  WMACodecContext *s = avctx->priv_data;
965 
966  s->last_bitoffset =
967  s->last_superframe_len = 0;
968 }
969 
970 #if CONFIG_WMAV1_DECODER
972  .name = "wmav1",
973  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 1"),
974  .type = AVMEDIA_TYPE_AUDIO,
975  .id = AV_CODEC_ID_WMAV1,
976  .priv_data_size = sizeof(WMACodecContext),
978  .close = ff_wma_end,
980  .flush = flush,
981  .capabilities = AV_CODEC_CAP_DR1,
982  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
984 };
985 #endif
986 #if CONFIG_WMAV2_DECODER
988  .name = "wmav2",
989  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 2"),
990  .type = AVMEDIA_TYPE_AUDIO,
991  .id = AV_CODEC_ID_WMAV2,
992  .priv_data_size = sizeof(WMACodecContext),
994  .close = ff_wma_end,
996  .flush = flush,
997  .capabilities = AV_CODEC_CAP_DR1,
998  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1000 };
1001 #endif
float, planar
Definition: samplefmt.h:69
#define ff_tlog(ctx,...)
Definition: internal.h:75
const struct AVCodec * codec
Definition: avcodec.h:1574
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:1478
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/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0/(INT64_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 *(INT64_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 *(INT64_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
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:3481
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:2262
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:42
#define NOISE_TAB_SIZE
Definition: wma.h:49
float lsp_pow_m_table2[(1<< LSP_POW_BITS)]
Definition: wma.h:133
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:130
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:2233
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:1666
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:1477
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:132
#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:3495
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:3488
static int wma_decode_superframe(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: wmadec.c:807
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:127
#define fail()
Definition: checkasm.h:120
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:134
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:962
#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:769
#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:1565
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1964
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:1667
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
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
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:131
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:790
void * priv_data
Definition: avcodec.h:1592
int len
int channels
number of audio channels
Definition: avcodec.h:2226
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:1454
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:981
int high_band_coded[MAX_CHANNELS][HIGH_BAND_MAX_SIZE]
Definition: wma.h:88
float noise_table[NOISE_TAB_SIZE]
Definition: wma.h:126
const char * name
Definition: opengl_enc.c:102
AVCodec ff_wmav1_decoder
float noise_mult
Definition: wma.h:128
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