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) {
113  init_vlc(&s->hgain_vlc, HGAINVLCBITS, sizeof(ff_wma_hgain_huffbits),
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
123  wma_lsp_to_curve_init(s, s->frame_len);
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  */
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) {
452  av_log(s->avctx, AV_LOG_ERROR,
453  "prev_block_len_bits %d out of range\n",
454  s->frame_len_bits - v);
455  return -1;
456  }
457  s->prev_block_len_bits = s->frame_len_bits - v;
458  v = get_bits(&s->gb, n);
459  if (v >= s->nb_block_sizes) {
460  av_log(s->avctx, AV_LOG_ERROR,
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 */
468  s->prev_block_len_bits = s->block_len_bits;
469  s->block_len_bits = s->next_block_len_bits;
470  }
471  v = get_bits(&s->gb, n);
472  if (v >= s->nb_block_sizes) {
473  av_log(s->avctx, AV_LOG_ERROR,
474  "next_block_len_bits %d out of range\n",
475  s->frame_len_bits - v);
476  return -1;
477  }
478  s->next_block_len_bits = s->frame_len_bits - v;
479  } else {
480  /* fixed block len */
481  s->next_block_len_bits = s->frame_len_bits;
482  s->prev_block_len_bits = s->frame_len_bits;
483  s->block_len_bits = s->frame_len_bits;
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) {
564  av_log(s->avctx, AV_LOG_ERROR,
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  s->exponents_initialized[ch] = 1;
589  }
590  }
591  }
592 
593  for (ch = 0; ch < s->avctx->channels; ch++) {
594  if (s->channel_coded[ch] && !s->exponents_initialized[ch])
595  return AVERROR_INVALIDDATA;
596  }
597 
598  /* parse spectral coefficients : just RLE encoding */
599  for (ch = 0; ch < s->avctx->channels; ch++) {
600  if (s->channel_coded[ch]) {
601  int tindex;
602  WMACoef *ptr = &s->coefs1[ch][0];
603 
604  /* special VLC tables are used for ms stereo because
605  * there is potentially less energy there */
606  tindex = (ch == 1 && s->ms_stereo);
607  memset(ptr, 0, s->block_len * sizeof(WMACoef));
608  ff_wma_run_level_decode(s->avctx, &s->gb, &s->coef_vlc[tindex],
609  s->level_table[tindex], s->run_table[tindex],
610  0, ptr, 0, nb_coefs[ch],
611  s->block_len, s->frame_len_bits, coef_nb_bits);
612  }
613  if (s->version == 1 && s->avctx->channels >= 2)
614  align_get_bits(&s->gb);
615  }
616 
617  /* normalize */
618  {
619  int n4 = s->block_len / 2;
620  mdct_norm = 1.0 / (float) n4;
621  if (s->version == 1)
622  mdct_norm *= sqrt(n4);
623  }
624 
625  /* finally compute the MDCT coefficients */
626  for (ch = 0; ch < s->avctx->channels; ch++) {
627  if (s->channel_coded[ch]) {
628  WMACoef *coefs1;
629  float *coefs, *exponents, mult, mult1, noise;
630  int i, j, n, n1, last_high_band, esize;
631  float exp_power[HIGH_BAND_MAX_SIZE];
632 
633  coefs1 = s->coefs1[ch];
634  exponents = s->exponents[ch];
635  esize = s->exponents_bsize[ch];
636  mult = ff_exp10(total_gain * 0.05) / s->max_exponent[ch];
637  mult *= mdct_norm;
638  coefs = s->coefs[ch];
639  if (s->use_noise_coding) {
640  mult1 = mult;
641  /* very low freqs : noise */
642  for (i = 0; i < s->coefs_start; i++) {
643  *coefs++ = s->noise_table[s->noise_index] *
644  exponents[i << bsize >> esize] * mult1;
645  s->noise_index = (s->noise_index + 1) &
646  (NOISE_TAB_SIZE - 1);
647  }
648 
649  n1 = s->exponent_high_sizes[bsize];
650 
651  /* compute power of high bands */
652  exponents = s->exponents[ch] +
653  (s->high_band_start[bsize] << bsize >> esize);
654  last_high_band = 0; /* avoid warning */
655  for (j = 0; j < n1; j++) {
656  n = s->exponent_high_bands[s->frame_len_bits -
657  s->block_len_bits][j];
658  if (s->high_band_coded[ch][j]) {
659  float e2, v;
660  e2 = 0;
661  for (i = 0; i < n; i++) {
662  v = exponents[i << bsize >> esize];
663  e2 += v * v;
664  }
665  exp_power[j] = e2 / n;
666  last_high_band = j;
667  ff_tlog(s->avctx, "%d: power=%f (%d)\n", j, exp_power[j], n);
668  }
669  exponents += n << bsize >> esize;
670  }
671 
672  /* main freqs and high freqs */
673  exponents = s->exponents[ch] + (s->coefs_start << bsize >> esize);
674  for (j = -1; j < n1; j++) {
675  if (j < 0)
676  n = s->high_band_start[bsize] - s->coefs_start;
677  else
678  n = s->exponent_high_bands[s->frame_len_bits -
679  s->block_len_bits][j];
680  if (j >= 0 && s->high_band_coded[ch][j]) {
681  /* use noise with specified power */
682  mult1 = sqrt(exp_power[j] / exp_power[last_high_band]);
683  /* XXX: use a table */
684  mult1 = mult1 * ff_exp10(s->high_band_values[ch][j] * 0.05);
685  mult1 = mult1 / (s->max_exponent[ch] * s->noise_mult);
686  mult1 *= mdct_norm;
687  for (i = 0; i < n; i++) {
688  noise = s->noise_table[s->noise_index];
689  s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1);
690  *coefs++ = noise * exponents[i << bsize >> esize] * mult1;
691  }
692  exponents += n << bsize >> esize;
693  } else {
694  /* coded values + small noise */
695  for (i = 0; i < n; i++) {
696  noise = s->noise_table[s->noise_index];
697  s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1);
698  *coefs++ = ((*coefs1++) + noise) *
699  exponents[i << bsize >> esize] * mult;
700  }
701  exponents += n << bsize >> esize;
702  }
703  }
704 
705  /* very high freqs : noise */
706  n = s->block_len - s->coefs_end[bsize];
707  mult1 = mult * exponents[(-(1 << bsize)) >> esize];
708  for (i = 0; i < n; i++) {
709  *coefs++ = s->noise_table[s->noise_index] * mult1;
710  s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1);
711  }
712  } else {
713  /* XXX: optimize more */
714  for (i = 0; i < s->coefs_start; i++)
715  *coefs++ = 0.0;
716  n = nb_coefs[ch];
717  for (i = 0; i < n; i++)
718  *coefs++ = coefs1[i] * exponents[i << bsize >> esize] * mult;
719  n = s->block_len - s->coefs_end[bsize];
720  for (i = 0; i < n; i++)
721  *coefs++ = 0.0;
722  }
723  }
724  }
725 
726 #ifdef TRACE
727  for (ch = 0; ch < s->avctx->channels; ch++) {
728  if (s->channel_coded[ch]) {
729  dump_floats(s, "exponents", 3, s->exponents[ch], s->block_len);
730  dump_floats(s, "coefs", 1, s->coefs[ch], s->block_len);
731  }
732  }
733 #endif /* TRACE */
734 
735  if (s->ms_stereo && s->channel_coded[1]) {
736  /* nominal case for ms stereo: we do it before mdct */
737  /* no need to optimize this case because it should almost
738  * never happen */
739  if (!s->channel_coded[0]) {
740  ff_tlog(s->avctx, "rare ms-stereo case happened\n");
741  memset(s->coefs[0], 0, sizeof(float) * s->block_len);
742  s->channel_coded[0] = 1;
743  }
744 
745  s->fdsp->butterflies_float(s->coefs[0], s->coefs[1], s->block_len);
746  }
747 
748 next:
749  mdct = &s->mdct_ctx[bsize];
750 
751  for (ch = 0; ch < s->avctx->channels; ch++) {
752  int n4, index;
753 
754  n4 = s->block_len / 2;
755  if (s->channel_coded[ch])
756  mdct->imdct_calc(mdct, s->output, s->coefs[ch]);
757  else if (!(s->ms_stereo && ch == 1))
758  memset(s->output, 0, sizeof(s->output));
759 
760  /* multiply by the window and add in the frame */
761  index = (s->frame_len / 2) + s->block_pos - n4;
762  wma_window(s, &s->frame_out[ch][index]);
763  }
764 
765  /* update block number */
766  s->block_num++;
767  s->block_pos += s->block_len;
768  if (s->block_pos >= s->frame_len)
769  return 1;
770  else
771  return 0;
772 }
773 
774 /* decode a frame of frame_len samples */
776  int samples_offset)
777 {
778  int ret, ch;
779 
780 #ifdef TRACE
781  ff_tlog(s->avctx, "***decode_frame: %d size=%d\n",
782  s->frame_count++, s->frame_len);
783 #endif /* TRACE */
784 
785  /* read each block */
786  s->block_num = 0;
787  s->block_pos = 0;
788  for (;;) {
790  if (ret < 0)
791  return -1;
792  if (ret)
793  break;
794  }
795 
796  for (ch = 0; ch < s->avctx->channels; ch++) {
797  /* copy current block to output */
798  memcpy(samples[ch] + samples_offset, s->frame_out[ch],
799  s->frame_len * sizeof(*s->frame_out[ch]));
800  /* prepare for next block */
801  memmove(&s->frame_out[ch][0], &s->frame_out[ch][s->frame_len],
802  s->frame_len * sizeof(*s->frame_out[ch]));
803 
804 #ifdef TRACE
805  dump_floats(s, "samples", 6, samples[ch] + samples_offset,
806  s->frame_len);
807 #endif /* TRACE */
808  }
809 
810  return 0;
811 }
812 
813 static int wma_decode_superframe(AVCodecContext *avctx, void *data,
814  int *got_frame_ptr, AVPacket *avpkt)
815 {
816  AVFrame *frame = data;
817  const uint8_t *buf = avpkt->data;
818  int buf_size = avpkt->size;
819  WMACodecContext *s = avctx->priv_data;
820  int nb_frames, bit_offset, i, pos, len, ret;
821  uint8_t *q;
822  float **samples;
823  int samples_offset;
824 
825  ff_tlog(avctx, "***decode_superframe:\n");
826 
827  if (buf_size == 0) {
828  s->last_superframe_len = 0;
829  return 0;
830  }
831  if (buf_size < avctx->block_align) {
832  av_log(avctx, AV_LOG_ERROR,
833  "Input packet size too small (%d < %d)\n",
834  buf_size, avctx->block_align);
835  return AVERROR_INVALIDDATA;
836  }
837  if (avctx->block_align)
838  buf_size = avctx->block_align;
839 
840  init_get_bits(&s->gb, buf, buf_size * 8);
841 
842  if (s->use_bit_reservoir) {
843  /* read super frame header */
844  skip_bits(&s->gb, 4); /* super frame index */
845  nb_frames = get_bits(&s->gb, 4) - (s->last_superframe_len <= 0);
846  if (nb_frames <= 0) {
847  int is_error = nb_frames < 0 || get_bits_left(&s->gb) <= 8;
848  av_log(avctx, is_error ? AV_LOG_ERROR : AV_LOG_WARNING,
849  "nb_frames is %d bits left %d\n",
850  nb_frames, get_bits_left(&s->gb));
851  if (is_error)
852  return AVERROR_INVALIDDATA;
853 
854  if ((s->last_superframe_len + buf_size - 1) >
856  goto fail;
857 
858  q = s->last_superframe + s->last_superframe_len;
859  len = buf_size - 1;
860  while (len > 0) {
861  *q++ = get_bits (&s->gb, 8);
862  len --;
863  }
864  memset(q, 0, AV_INPUT_BUFFER_PADDING_SIZE);
865 
866  s->last_superframe_len += 8*buf_size - 8;
867 // s->reset_block_lengths = 1; //XXX is this needed ?
868  *got_frame_ptr = 0;
869  return buf_size;
870  }
871  } else
872  nb_frames = 1;
873 
874  /* get output buffer */
875  frame->nb_samples = nb_frames * s->frame_len;
876  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
877  return ret;
878  samples = (float **) frame->extended_data;
879  samples_offset = 0;
880 
881  if (s->use_bit_reservoir) {
882  bit_offset = get_bits(&s->gb, s->byte_offset_bits + 3);
883  if (bit_offset > get_bits_left(&s->gb)) {
884  av_log(avctx, AV_LOG_ERROR,
885  "Invalid last frame bit offset %d > buf size %d (%d)\n",
886  bit_offset, get_bits_left(&s->gb), buf_size);
887  goto fail;
888  }
889 
890  if (s->last_superframe_len > 0) {
891  /* add bit_offset bits to last frame */
892  if ((s->last_superframe_len + ((bit_offset + 7) >> 3)) >
894  goto fail;
895  q = s->last_superframe + s->last_superframe_len;
896  len = bit_offset;
897  while (len > 7) {
898  *q++ = (get_bits) (&s->gb, 8);
899  len -= 8;
900  }
901  if (len > 0)
902  *q++ = (get_bits) (&s->gb, len) << (8 - len);
903  memset(q, 0, AV_INPUT_BUFFER_PADDING_SIZE);
904 
905  /* XXX: bit_offset bits into last frame */
906  init_get_bits(&s->gb, s->last_superframe,
907  s->last_superframe_len * 8 + bit_offset);
908  /* skip unused bits */
909  if (s->last_bitoffset > 0)
910  skip_bits(&s->gb, s->last_bitoffset);
911  /* this frame is stored in the last superframe and in the
912  * current one */
913  if (wma_decode_frame(s, samples, samples_offset) < 0)
914  goto fail;
915  samples_offset += s->frame_len;
916  nb_frames--;
917  }
918 
919  /* read each frame starting from bit_offset */
920  pos = bit_offset + 4 + 4 + s->byte_offset_bits + 3;
921  if (pos >= MAX_CODED_SUPERFRAME_SIZE * 8 || pos > buf_size * 8)
922  return AVERROR_INVALIDDATA;
923  init_get_bits(&s->gb, buf + (pos >> 3), (buf_size - (pos >> 3)) * 8);
924  len = pos & 7;
925  if (len > 0)
926  skip_bits(&s->gb, len);
927 
928  s->reset_block_lengths = 1;
929  for (i = 0; i < nb_frames; i++) {
930  if (wma_decode_frame(s, samples, samples_offset) < 0)
931  goto fail;
932  samples_offset += s->frame_len;
933  }
934 
935  /* we copy the end of the frame in the last frame buffer */
936  pos = get_bits_count(&s->gb) +
937  ((bit_offset + 4 + 4 + s->byte_offset_bits + 3) & ~7);
938  s->last_bitoffset = pos & 7;
939  pos >>= 3;
940  len = buf_size - pos;
941  if (len > MAX_CODED_SUPERFRAME_SIZE || len < 0) {
942  av_log(s->avctx, AV_LOG_ERROR, "len %d invalid\n", len);
943  goto fail;
944  }
945  s->last_superframe_len = len;
946  memcpy(s->last_superframe, buf + pos, len);
947  } else {
948  /* single frame decode */
949  if (wma_decode_frame(s, samples, samples_offset) < 0)
950  goto fail;
951  samples_offset += s->frame_len;
952  }
953 
954  ff_dlog(s->avctx, "%d %d %d %d outbytes:%"PTRDIFF_SPECIFIER" eaten:%d\n",
955  s->frame_len_bits, s->block_len_bits, s->frame_len, s->block_len,
956  (int8_t *) samples - (int8_t *) data, avctx->block_align);
957 
958  *got_frame_ptr = 1;
959 
960  return buf_size;
961 
962 fail:
963  /* when error, we reset the bit reservoir */
964  s->last_superframe_len = 0;
965  return -1;
966 }
967 
968 static av_cold void flush(AVCodecContext *avctx)
969 {
970  WMACodecContext *s = avctx->priv_data;
971 
972  s->last_bitoffset =
973  s->last_superframe_len = 0;
974 }
975 
976 #if CONFIG_WMAV1_DECODER
978  .name = "wmav1",
979  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 1"),
980  .type = AVMEDIA_TYPE_AUDIO,
981  .id = AV_CODEC_ID_WMAV1,
982  .priv_data_size = sizeof(WMACodecContext),
984  .close = ff_wma_end,
986  .flush = flush,
987  .capabilities = AV_CODEC_CAP_DR1,
988  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
990 };
991 #endif
992 #if CONFIG_WMAV2_DECODER
994  .name = "wmav2",
995  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 2"),
996  .type = AVMEDIA_TYPE_AUDIO,
997  .id = AV_CODEC_ID_WMAV2,
998  .priv_data_size = sizeof(WMACodecContext),
1000  .close = ff_wma_end,
1002  .flush = flush,
1003  .capabilities = AV_CODEC_CAP_DR1,
1004  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1006 };
1007 #endif
AVCodec
AVCodec.
Definition: avcodec.h:3481
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:69
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
ff_exp10
static av_always_inline double ff_exp10(double x)
Compute 10^x for floating point values.
Definition: ffmath.h:42
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
out
FILE * out
Definition: movenc.c:54
n
int n
Definition: avisynth_c.h:760
u
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:252
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:686
flush
static av_cold void flush(AVCodecContext *avctx)
Definition: wmadec.c:968
ff_wma_hgain_huffcodes
const uint16_t ff_wma_hgain_huffcodes[37]
Definition: wmadata.h:54
ch
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
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
w
uint8_t w
Definition: llviddspenc.c:38
internal.h
name
const char * name
Definition: avisynth_c.h:867
AVPacket::data
uint8_t * data
Definition: avcodec.h:1477
wma_lsp_to_curve_init
static void wma_lsp_to_curve_init(WMACodecContext *s, int frame_len)
Definition: wmadec.c:155
init_vlc
#define init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
Definition: vlc.h:38
b
#define b
Definition: input.c:41
ff_wma_hgain_huffbits
const uint8_t ff_wma_hgain_huffbits[37]
Definition: wmadata.h:62
data
const char data[16]
Definition: mxf.c:91
ff_mdct_init
#define ff_mdct_init
Definition: fft.h:169
get_vlc2
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
AV_CODEC_ID_WMAV2
@ AV_CODEC_ID_WMAV2
Definition: avcodec.h:572
ff_tlog
#define ff_tlog(ctx,...)
Definition: internal.h:75
wma_decode_frame
static int wma_decode_frame(WMACodecContext *s, float **samples, int samples_offset)
Definition: wmadec.c:775
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
HIGH_BAND_MAX_SIZE
#define HIGH_BAND_MAX_SIZE
Definition: wma.h:40
decode_exp_lsp
static void decode_exp_lsp(WMACodecContext *s, int ch)
decode exponents coded with LSP coefficients (same idea as Vorbis)
Definition: wmadec.c:216
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:1574
WMACoef
float WMACoef
type for decoded coefficients, int16_t would be enough for wma 1/2
Definition: wma.h:57
fail
#define fail()
Definition: checkasm.h:120
tab
static const struct twinvq_data tab
Definition: twinvq_data.h:11135
WMACodecContext
Definition: wma.h:67
mult
static int16_t mult(Float11 *f1, Float11 *f2)
Definition: g726.c:55
AV_CODEC_ID_WMAV1
@ AV_CODEC_ID_WMAV1
Definition: avcodec.h:571
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
buf
void * buf
Definition: avisynth_c.h:766
av_cold
#define av_cold
Definition: attributes.h:84
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:42
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:1667
EXPVLCBITS
#define EXPVLCBITS
Definition: wmadec.c:43
s
#define s(width, name)
Definition: cbs_vp9.c:257
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
exp2f
#define exp2f(x)
Definition: libm.h:293
AV_RL16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:90
wma.h
ff_wma_total_gain_to_bits
int ff_wma_total_gain_to_bits(int total_gain)
Definition: wma.c:354
f
#define f(width, name)
Definition: cbs_vp9.c:255
if
if(ret)
Definition: filter_design.txt:179
PTRDIFF_SPECIFIER
#define PTRDIFF_SPECIFIER
Definition: internal.h:263
HGAINMAX
#define HGAINMAX
Definition: wmadec.c:47
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
index
int index
Definition: gxfenc.c:89
MAX_CODED_SUPERFRAME_SIZE
#define MAX_CODED_SUPERFRAME_SIZE
Definition: wma.h:45
ff_wma_end
int ff_wma_end(AVCodecContext *avctx)
Definition: wma.c:368
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:29
FFTContext::imdct_calc
void(* imdct_calc)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
Definition: fft.h:107
ff_aac_scalefactor_bits
const uint8_t ff_aac_scalefactor_bits[121]
Definition: aactab.c:92
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1965
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:981
AVPacket::size
int size
Definition: avcodec.h:1478
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:188
wma_lsp_to_curve
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
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2233
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
ff_wma_init
av_cold int ff_wma_init(AVCodecContext *avctx, int flags2)
Definition: wma.c:81
NOISE_TAB_SIZE
#define NOISE_TAB_SIZE
Definition: wma.h:49
val
const char const char void * val
Definition: avisynth_c.h:863
a
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:41
attributes.h
MAX_CHANNELS
#define MAX_CHANNELS
Definition: aac.h:47
wma_decode_block
static int wma_decode_block(WMACodecContext *s)
Definition: wmadec.c:431
M_PI
#define M_PI
Definition: mathematics.h:52
pow_tab
static const float pow_tab[]
pow(10, i / 16.0) for i in -60..95
Definition: wmadec.c:234
AVCodec::id
enum AVCodecID id
Definition: avcodec.h:3495
in
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
Definition: audio_convert.c:326
LSP_POW_BITS
#define LSP_POW_BITS
Definition: wma.h:51
FFTContext
Definition: fft.h:88
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
code
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
Definition: filter_design.txt:178
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1666
ff_wmav1_decoder
AVCodec ff_wmav1_decoder
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
uint8_t
uint8_t
Definition: audio_convert.c:194
ff_wmav2_decoder
AVCodec ff_wmav2_decoder
wma_window
static void wma_window(WMACodecContext *s, float *out)
Apply MDCT window and add into output.
Definition: wmadec.c:381
AVCodec::name
const char * name
Name of the codec implementation.
Definition: avcodec.h:3488
len
int len
Definition: vorbis_enc_data.h:452
avcodec.h
ret
ret
Definition: filter_design.txt:187
AVCodecContext::block_align
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs.
Definition: avcodec.h:2262
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
HGAINVLCBITS
#define HGAINVLCBITS
Definition: wmadec.c:46
align_get_bits
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:693
EXPMAX
#define EXPMAX
Definition: wmadec.c:44
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: avcodec.h:790
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen_template.c:38
AVCodecContext
main external API structure.
Definition: avcodec.h:1565
noise
static int noise(AVBSFContext *ctx, AVPacket *pkt)
Definition: noise_bsf.c:38
decode_exp_vlc
static int decode_exp_vlc(WMACodecContext *s, int ch)
decode exponents coded with VLC codes
Definition: wmadec.c:318
samples
Filter the word “frame” indicates either a video frame or a group of audio samples
Definition: filter_design.txt:8
ffmath.h
ff_wma_lsp_codebook
const float ff_wma_lsp_codebook[NB_LSP_COEFS][16]
Definition: wmadata.h:68
ff_wma_run_level_decode
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
AVPacket
This structure stores compressed data.
Definition: avcodec.h:1454
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:1592
NB_LSP_COEFS
#define NB_LSP_COEFS
Definition: wma.h:42
wma_decode_init
static av_cold int wma_decode_init(AVCodecContext *avctx)
Definition: wmadec.c:70
pow_m1_4
static float pow_m1_4(WMACodecContext *s, float x)
compute x^-0.25 with an exponent and mantissa table.
Definition: wmadec.c:136
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
int
int
Definition: ffmpeg_filter.c:191
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
wma_decode_superframe
static int wma_decode_superframe(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: wmadec.c:813
ff_aac_scalefactor_code
const uint32_t ff_aac_scalefactor_code[121]
Definition: aactab.c:73