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 "config_components.h"
37 
38 #include "libavutil/attributes.h"
39 #include "libavutil/ffmath.h"
40 
41 #include "avcodec.h"
42 #include "codec_internal.h"
43 #include "decode.h"
44 #include "internal.h"
45 #include "wma.h"
46 
47 #define EXPVLCBITS 8
48 #define EXPMAX ((19 + EXPVLCBITS - 1) / EXPVLCBITS)
49 
50 #define HGAINVLCBITS 9
51 #define HGAINMAX ((13 + HGAINVLCBITS - 1) / HGAINVLCBITS)
52 
53 static void wma_lsp_to_curve_init(WMACodecContext *s, int frame_len);
54 
55 #ifdef TRACE
56 static void dump_floats(WMACodecContext *s, const char *name,
57  int prec, const float *tab, int n)
58 {
59  int i;
60 
61  ff_tlog(s->avctx, "%s[%d]:\n", name, n);
62  for (i = 0; i < n; i++) {
63  if ((i & 7) == 0)
64  ff_tlog(s->avctx, "%4d: ", i);
65  ff_tlog(s->avctx, " %8.*f", prec, tab[i]);
66  if ((i & 7) == 7)
67  ff_tlog(s->avctx, "\n");
68  }
69  if ((i & 7) != 0)
70  ff_tlog(s->avctx, "\n");
71 }
72 #endif /* TRACE */
73 
75 {
76  WMACodecContext *s = avctx->priv_data;
77  int i, flags2, ret;
78  uint8_t *extradata;
79 
80  if (!avctx->block_align) {
81  av_log(avctx, AV_LOG_ERROR, "block_align is not set\n");
82  return AVERROR(EINVAL);
83  }
84 
85  s->avctx = avctx;
86 
87  /* extract flag info */
88  flags2 = 0;
89  extradata = avctx->extradata;
90  if (avctx->codec->id == AV_CODEC_ID_WMAV1 && avctx->extradata_size >= 4)
91  flags2 = AV_RL16(extradata + 2);
92  else if (avctx->codec->id == AV_CODEC_ID_WMAV2 && avctx->extradata_size >= 6)
93  flags2 = AV_RL16(extradata + 4);
94 
95  s->use_exp_vlc = flags2 & 0x0001;
96  s->use_bit_reservoir = flags2 & 0x0002;
97  s->use_variable_block_len = flags2 & 0x0004;
98 
99  if (avctx->codec->id == AV_CODEC_ID_WMAV2 && avctx->extradata_size >= 8){
100  if (AV_RL16(extradata+4)==0xd && s->use_variable_block_len){
101  av_log(avctx, AV_LOG_WARNING, "Disabling use_variable_block_len, if this fails contact the ffmpeg developers and send us the file\n");
102  s->use_variable_block_len= 0; // this fixes issue1503
103  }
104  }
105 
106  for (i=0; i<MAX_CHANNELS; i++)
107  s->max_exponent[i] = 1.0;
108 
109  if ((ret = ff_wma_init(avctx, flags2)) < 0)
110  return ret;
111 
112  /* init MDCT */
113  for (i = 0; i < s->nb_block_sizes; i++) {
114  float scale = 1.0 / 32768.0;
115  ret = av_tx_init(&s->mdct_ctx[i], &s->mdct_fn[i], AV_TX_FLOAT_MDCT,
116  1, 1 << (s->frame_len_bits - i), &scale, AV_TX_FULL_IMDCT);
117  if (ret < 0)
118  return ret;
119  }
120 
121  if (s->use_noise_coding) {
124  &ff_wma_hgain_hufftab[0][1], 2,
125  &ff_wma_hgain_hufftab[0][0], 2, 1,
126  -18, 0, avctx);
127  if (ret < 0)
128  return ret;
129  }
130 
131  if (s->use_exp_vlc) {
132  // FIXME move out of context
133  ret = init_vlc(&s->exp_vlc, EXPVLCBITS, sizeof(ff_aac_scalefactor_bits),
135  ff_aac_scalefactor_code, 4, 4, 0);
136  if (ret < 0)
137  return ret;
138  } else
139  wma_lsp_to_curve_init(s, s->frame_len);
140 
142 
143  avctx->internal->skip_samples = s->frame_len * 2;
144 
145  return 0;
146 }
147 
148 /**
149  * compute x^-0.25 with an exponent and mantissa table. We use linear
150  * interpolation to reduce the mantissa table size at a small speed
151  * expense (linear interpolation approximately doubles the number of
152  * bits of precision).
153  */
154 static inline float pow_m1_4(WMACodecContext *s, float x)
155 {
156  union {
157  float f;
158  unsigned int v;
159  } u, t;
160  unsigned int e, m;
161  float a, b;
162 
163  u.f = x;
164  e = u.v >> 23;
165  m = (u.v >> (23 - LSP_POW_BITS)) & ((1 << LSP_POW_BITS) - 1);
166  /* build interpolation scale: 1 <= t < 2. */
167  t.v = ((u.v << LSP_POW_BITS) & ((1 << 23) - 1)) | (127 << 23);
168  a = s->lsp_pow_m_table1[m];
169  b = s->lsp_pow_m_table2[m];
170  return s->lsp_pow_e_table[e] * (a + b * t.f);
171 }
172 
173 static av_cold void wma_lsp_to_curve_init(WMACodecContext *s, int frame_len)
174 {
175  float wdel, a, b;
176  int i, e, m;
177 
178  wdel = M_PI / frame_len;
179  for (i = 0; i < frame_len; i++)
180  s->lsp_cos_table[i] = 2.0f * cos(wdel * i);
181 
182  /* tables for x^-0.25 computation */
183  for (i = 0; i < 256; i++) {
184  e = i - 126;
185  s->lsp_pow_e_table[i] = exp2f(e * -0.25);
186  }
187 
188  /* NOTE: these two tables are needed to avoid two operations in
189  * pow_m1_4 */
190  b = 1.0;
191  for (i = (1 << LSP_POW_BITS) - 1; i >= 0; i--) {
192  m = (1 << LSP_POW_BITS) + i;
193  a = (float) m * (0.5 / (1 << LSP_POW_BITS));
194  a = 1/sqrt(sqrt(a));
195  s->lsp_pow_m_table1[i] = 2 * a - b;
196  s->lsp_pow_m_table2[i] = b - a;
197  b = a;
198  }
199 }
200 
201 /**
202  * NOTE: We use the same code as Vorbis here
203  * @todo optimize it further with SSE/3Dnow
204  */
205 static void wma_lsp_to_curve(WMACodecContext *s, float *out, float *val_max_ptr,
206  int n, float *lsp)
207 {
208  int i, j;
209  float p, q, w, v, val_max;
210 
211  val_max = 0;
212  for (i = 0; i < n; i++) {
213  p = 0.5f;
214  q = 0.5f;
215  w = s->lsp_cos_table[i];
216  for (j = 1; j < NB_LSP_COEFS; j += 2) {
217  q *= w - lsp[j - 1];
218  p *= w - lsp[j];
219  }
220  p *= p * (2.0f - w);
221  q *= q * (2.0f + w);
222  v = p + q;
223  v = pow_m1_4(s, v);
224  if (v > val_max)
225  val_max = v;
226  out[i] = v;
227  }
228  *val_max_ptr = val_max;
229 }
230 
231 /**
232  * decode exponents coded with LSP coefficients (same idea as Vorbis)
233  */
234 static void decode_exp_lsp(WMACodecContext *s, int ch)
235 {
236  float lsp_coefs[NB_LSP_COEFS];
237  int val, i;
238 
239  for (i = 0; i < NB_LSP_COEFS; i++) {
240  if (i == 0 || i >= 8)
241  val = get_bits(&s->gb, 3);
242  else
243  val = get_bits(&s->gb, 4);
244  lsp_coefs[i] = ff_wma_lsp_codebook[i][val];
245  }
246 
247  wma_lsp_to_curve(s, s->exponents[ch], &s->max_exponent[ch],
248  s->block_len, lsp_coefs);
249 }
250 
251 /** pow(10, i / 16.0) for i in -60..95 */
252 static const float pow_tab[] = {
253  1.7782794100389e-04, 2.0535250264571e-04,
254  2.3713737056617e-04, 2.7384196342644e-04,
255  3.1622776601684e-04, 3.6517412725484e-04,
256  4.2169650342858e-04, 4.8696752516586e-04,
257  5.6234132519035e-04, 6.4938163157621e-04,
258  7.4989420933246e-04, 8.6596432336006e-04,
259  1.0000000000000e-03, 1.1547819846895e-03,
260  1.3335214321633e-03, 1.5399265260595e-03,
261  1.7782794100389e-03, 2.0535250264571e-03,
262  2.3713737056617e-03, 2.7384196342644e-03,
263  3.1622776601684e-03, 3.6517412725484e-03,
264  4.2169650342858e-03, 4.8696752516586e-03,
265  5.6234132519035e-03, 6.4938163157621e-03,
266  7.4989420933246e-03, 8.6596432336006e-03,
267  1.0000000000000e-02, 1.1547819846895e-02,
268  1.3335214321633e-02, 1.5399265260595e-02,
269  1.7782794100389e-02, 2.0535250264571e-02,
270  2.3713737056617e-02, 2.7384196342644e-02,
271  3.1622776601684e-02, 3.6517412725484e-02,
272  4.2169650342858e-02, 4.8696752516586e-02,
273  5.6234132519035e-02, 6.4938163157621e-02,
274  7.4989420933246e-02, 8.6596432336007e-02,
275  1.0000000000000e-01, 1.1547819846895e-01,
276  1.3335214321633e-01, 1.5399265260595e-01,
277  1.7782794100389e-01, 2.0535250264571e-01,
278  2.3713737056617e-01, 2.7384196342644e-01,
279  3.1622776601684e-01, 3.6517412725484e-01,
280  4.2169650342858e-01, 4.8696752516586e-01,
281  5.6234132519035e-01, 6.4938163157621e-01,
282  7.4989420933246e-01, 8.6596432336007e-01,
283  1.0000000000000e+00, 1.1547819846895e+00,
284  1.3335214321633e+00, 1.5399265260595e+00,
285  1.7782794100389e+00, 2.0535250264571e+00,
286  2.3713737056617e+00, 2.7384196342644e+00,
287  3.1622776601684e+00, 3.6517412725484e+00,
288  4.2169650342858e+00, 4.8696752516586e+00,
289  5.6234132519035e+00, 6.4938163157621e+00,
290  7.4989420933246e+00, 8.6596432336007e+00,
291  1.0000000000000e+01, 1.1547819846895e+01,
292  1.3335214321633e+01, 1.5399265260595e+01,
293  1.7782794100389e+01, 2.0535250264571e+01,
294  2.3713737056617e+01, 2.7384196342644e+01,
295  3.1622776601684e+01, 3.6517412725484e+01,
296  4.2169650342858e+01, 4.8696752516586e+01,
297  5.6234132519035e+01, 6.4938163157621e+01,
298  7.4989420933246e+01, 8.6596432336007e+01,
299  1.0000000000000e+02, 1.1547819846895e+02,
300  1.3335214321633e+02, 1.5399265260595e+02,
301  1.7782794100389e+02, 2.0535250264571e+02,
302  2.3713737056617e+02, 2.7384196342644e+02,
303  3.1622776601684e+02, 3.6517412725484e+02,
304  4.2169650342858e+02, 4.8696752516586e+02,
305  5.6234132519035e+02, 6.4938163157621e+02,
306  7.4989420933246e+02, 8.6596432336007e+02,
307  1.0000000000000e+03, 1.1547819846895e+03,
308  1.3335214321633e+03, 1.5399265260595e+03,
309  1.7782794100389e+03, 2.0535250264571e+03,
310  2.3713737056617e+03, 2.7384196342644e+03,
311  3.1622776601684e+03, 3.6517412725484e+03,
312  4.2169650342858e+03, 4.8696752516586e+03,
313  5.6234132519035e+03, 6.4938163157621e+03,
314  7.4989420933246e+03, 8.6596432336007e+03,
315  1.0000000000000e+04, 1.1547819846895e+04,
316  1.3335214321633e+04, 1.5399265260595e+04,
317  1.7782794100389e+04, 2.0535250264571e+04,
318  2.3713737056617e+04, 2.7384196342644e+04,
319  3.1622776601684e+04, 3.6517412725484e+04,
320  4.2169650342858e+04, 4.8696752516586e+04,
321  5.6234132519035e+04, 6.4938163157621e+04,
322  7.4989420933246e+04, 8.6596432336007e+04,
323  1.0000000000000e+05, 1.1547819846895e+05,
324  1.3335214321633e+05, 1.5399265260595e+05,
325  1.7782794100389e+05, 2.0535250264571e+05,
326  2.3713737056617e+05, 2.7384196342644e+05,
327  3.1622776601684e+05, 3.6517412725484e+05,
328  4.2169650342858e+05, 4.8696752516586e+05,
329  5.6234132519035e+05, 6.4938163157621e+05,
330  7.4989420933246e+05, 8.6596432336007e+05,
331 };
332 
333 /**
334  * decode exponents coded with VLC codes
335  */
336 static int decode_exp_vlc(WMACodecContext *s, int ch)
337 {
338  int last_exp, n, code;
339  const uint16_t *ptr;
340  float v, max_scale;
341  uint32_t *q, *q_end, iv;
342  const float *ptab = pow_tab + 60;
343  const uint32_t *iptab = (const uint32_t *) ptab;
344 
345  ptr = s->exponent_bands[s->frame_len_bits - s->block_len_bits];
346  q = (uint32_t *) s->exponents[ch];
347  q_end = q + s->block_len;
348  max_scale = 0;
349  if (s->version == 1) {
350  last_exp = get_bits(&s->gb, 5) + 10;
351  v = ptab[last_exp];
352  iv = iptab[last_exp];
353  max_scale = v;
354  n = *ptr++;
355  switch (n & 3) do {
356  case 0: *q++ = iv;
357  case 3: *q++ = iv;
358  case 2: *q++ = iv;
359  case 1: *q++ = iv;
360  } while ((n -= 4) > 0);
361  } else
362  last_exp = 36;
363 
364  while (q < q_end) {
365  code = get_vlc2(&s->gb, s->exp_vlc.table, EXPVLCBITS, EXPMAX);
366  /* NOTE: this offset is the same as MPEG-4 AAC! */
367  last_exp += code - 60;
368  if ((unsigned) last_exp + 60 >= FF_ARRAY_ELEMS(pow_tab)) {
369  av_log(s->avctx, AV_LOG_ERROR, "Exponent out of range: %d\n",
370  last_exp);
371  return -1;
372  }
373  v = ptab[last_exp];
374  iv = iptab[last_exp];
375  if (v > max_scale)
376  max_scale = v;
377  n = *ptr++;
378  switch (n & 3) do {
379  case 0: *q++ = iv;
380  case 3: *q++ = iv;
381  case 2: *q++ = iv;
382  case 1: *q++ = iv;
383  } while ((n -= 4) > 0);
384  }
385  s->max_exponent[ch] = max_scale;
386  return 0;
387 }
388 
389 /**
390  * Apply MDCT window and add into output.
391  *
392  * We ensure that when the windows overlap their squared sum
393  * is always 1 (MDCT reconstruction rule).
394  */
395 static void wma_window(WMACodecContext *s, float *out)
396 {
397  float *in = s->output;
398  int block_len, bsize, n;
399 
400  /* left part */
401  if (s->block_len_bits <= s->prev_block_len_bits) {
402  block_len = s->block_len;
403  bsize = s->frame_len_bits - s->block_len_bits;
404 
405  s->fdsp->vector_fmul_add(out, in, s->windows[bsize],
406  out, block_len);
407  } else {
408  block_len = 1 << s->prev_block_len_bits;
409  n = (s->block_len - block_len) / 2;
410  bsize = s->frame_len_bits - s->prev_block_len_bits;
411 
412  s->fdsp->vector_fmul_add(out + n, in + n, s->windows[bsize],
413  out + n, block_len);
414 
415  memcpy(out + n + block_len, in + n + block_len, n * sizeof(float));
416  }
417 
418  out += s->block_len;
419  in += s->block_len;
420 
421  /* right part */
422  if (s->block_len_bits <= s->next_block_len_bits) {
423  block_len = s->block_len;
424  bsize = s->frame_len_bits - s->block_len_bits;
425 
426  s->fdsp->vector_fmul_reverse(out, in, s->windows[bsize], block_len);
427  } else {
428  block_len = 1 << s->next_block_len_bits;
429  n = (s->block_len - block_len) / 2;
430  bsize = s->frame_len_bits - s->next_block_len_bits;
431 
432  memcpy(out, in, n * sizeof(float));
433 
434  s->fdsp->vector_fmul_reverse(out + n, in + n, s->windows[bsize],
435  block_len);
436 
437  memset(out + n + block_len, 0, n * sizeof(float));
438  }
439 }
440 
441 /**
442  * @return 0 if OK. 1 if last block of frame. return -1 if
443  * unrecoverable error.
444  */
446 {
447  int channels = s->avctx->ch_layout.nb_channels;
448  int n, v, a, ch, bsize;
449  int coef_nb_bits, total_gain;
450  int nb_coefs[MAX_CHANNELS];
451  float mdct_norm;
452  AVTXContext *mdct;
453  av_tx_fn mdct_fn;
454 
455 #ifdef TRACE
456  ff_tlog(s->avctx, "***decode_block: %d:%d\n",
457  s->frame_count - 1, s->block_num);
458 #endif /* TRACE */
459 
460  /* compute current block length */
461  if (s->use_variable_block_len) {
462  n = av_log2(s->nb_block_sizes - 1) + 1;
463 
464  if (s->reset_block_lengths) {
465  s->reset_block_lengths = 0;
466  v = get_bits(&s->gb, n);
467  if (v >= s->nb_block_sizes) {
468  av_log(s->avctx, AV_LOG_ERROR,
469  "prev_block_len_bits %d out of range\n",
470  s->frame_len_bits - v);
471  return -1;
472  }
473  s->prev_block_len_bits = s->frame_len_bits - v;
474  v = get_bits(&s->gb, n);
475  if (v >= s->nb_block_sizes) {
476  av_log(s->avctx, AV_LOG_ERROR,
477  "block_len_bits %d out of range\n",
478  s->frame_len_bits - v);
479  return -1;
480  }
481  s->block_len_bits = s->frame_len_bits - v;
482  } else {
483  /* update block lengths */
484  s->prev_block_len_bits = s->block_len_bits;
485  s->block_len_bits = s->next_block_len_bits;
486  }
487  v = get_bits(&s->gb, n);
488  if (v >= s->nb_block_sizes) {
489  av_log(s->avctx, AV_LOG_ERROR,
490  "next_block_len_bits %d out of range\n",
491  s->frame_len_bits - v);
492  return -1;
493  }
494  s->next_block_len_bits = s->frame_len_bits - v;
495  } else {
496  /* fixed block len */
497  s->next_block_len_bits = s->frame_len_bits;
498  s->prev_block_len_bits = s->frame_len_bits;
499  s->block_len_bits = s->frame_len_bits;
500  }
501 
502  if (s->frame_len_bits - s->block_len_bits >= s->nb_block_sizes){
503  av_log(s->avctx, AV_LOG_ERROR, "block_len_bits not initialized to a valid value\n");
504  return -1;
505  }
506 
507  /* now check if the block length is coherent with the frame length */
508  s->block_len = 1 << s->block_len_bits;
509  if ((s->block_pos + s->block_len) > s->frame_len) {
510  av_log(s->avctx, AV_LOG_ERROR, "frame_len overflow\n");
511  return -1;
512  }
513 
514  if (channels == 2)
515  s->ms_stereo = get_bits1(&s->gb);
516  v = 0;
517  for (ch = 0; ch < channels; ch++) {
518  a = get_bits1(&s->gb);
519  s->channel_coded[ch] = a;
520  v |= a;
521  }
522 
523  bsize = s->frame_len_bits - s->block_len_bits;
524 
525  /* if no channel coded, no need to go further */
526  /* XXX: fix potential framing problems */
527  if (!v)
528  goto next;
529 
530  /* read total gain and extract corresponding number of bits for
531  * coef escape coding */
532  total_gain = 1;
533  for (;;) {
534  if (get_bits_left(&s->gb) < 7) {
535  av_log(s->avctx, AV_LOG_ERROR, "total_gain overread\n");
536  return AVERROR_INVALIDDATA;
537  }
538  a = get_bits(&s->gb, 7);
539  total_gain += a;
540  if (a != 127)
541  break;
542  }
543 
544  coef_nb_bits = ff_wma_total_gain_to_bits(total_gain);
545 
546  /* compute number of coefficients */
547  n = s->coefs_end[bsize] - s->coefs_start;
548  for (ch = 0; ch < channels; ch++)
549  nb_coefs[ch] = n;
550 
551  /* complex coding */
552  if (s->use_noise_coding) {
553  for (ch = 0; ch < channels; ch++) {
554  if (s->channel_coded[ch]) {
555  int i, n, a;
556  n = s->exponent_high_sizes[bsize];
557  for (i = 0; i < n; i++) {
558  a = get_bits1(&s->gb);
559  s->high_band_coded[ch][i] = a;
560  /* if noise coding, the coefficients are not transmitted */
561  if (a)
562  nb_coefs[ch] -= s->exponent_high_bands[bsize][i];
563  }
564  }
565  }
566  for (ch = 0; ch < channels; ch++) {
567  if (s->channel_coded[ch]) {
568  int i, n, val;
569 
570  n = s->exponent_high_sizes[bsize];
571  val = (int) 0x80000000;
572  for (i = 0; i < n; i++) {
573  if (s->high_band_coded[ch][i]) {
574  if (val == (int) 0x80000000) {
575  val = get_bits(&s->gb, 7) - 19;
576  } else {
577  val += get_vlc2(&s->gb, s->hgain_vlc.table,
579  }
580  s->high_band_values[ch][i] = val;
581  }
582  }
583  }
584  }
585  }
586 
587  /* exponents can be reused in short blocks. */
588  if ((s->block_len_bits == s->frame_len_bits) || get_bits1(&s->gb)) {
589  for (ch = 0; ch < channels; ch++) {
590  if (s->channel_coded[ch]) {
591  if (s->use_exp_vlc) {
592  if (decode_exp_vlc(s, ch) < 0)
593  return -1;
594  } else {
595  decode_exp_lsp(s, ch);
596  }
597  s->exponents_bsize[ch] = bsize;
598  s->exponents_initialized[ch] = 1;
599  }
600  }
601  }
602 
603  for (ch = 0; ch < channels; ch++) {
604  if (s->channel_coded[ch] && !s->exponents_initialized[ch])
605  return AVERROR_INVALIDDATA;
606  }
607 
608  /* parse spectral coefficients : just RLE encoding */
609  for (ch = 0; ch < channels; ch++) {
610  if (s->channel_coded[ch]) {
611  int tindex;
612  WMACoef *ptr = &s->coefs1[ch][0];
613  int ret;
614 
615  /* special VLC tables are used for ms stereo because
616  * there is potentially less energy there */
617  tindex = (ch == 1 && s->ms_stereo);
618  memset(ptr, 0, s->block_len * sizeof(WMACoef));
619  ret = ff_wma_run_level_decode(s->avctx, &s->gb, &s->coef_vlc[tindex],
620  s->level_table[tindex], s->run_table[tindex],
621  0, ptr, 0, nb_coefs[ch],
622  s->block_len, s->frame_len_bits, coef_nb_bits);
623  if (ret < 0)
624  return ret;
625  }
626  if (s->version == 1 && channels >= 2)
627  align_get_bits(&s->gb);
628  }
629 
630  /* normalize */
631  {
632  int n4 = s->block_len / 2;
633  mdct_norm = 1.0 / (float) n4;
634  if (s->version == 1)
635  mdct_norm *= sqrt(n4);
636  }
637 
638  /* finally compute the MDCT coefficients */
639  for (ch = 0; ch < channels; ch++) {
640  if (s->channel_coded[ch]) {
641  WMACoef *coefs1;
642  float *coefs, *exponents, mult, mult1, noise;
643  int i, j, n, n1, last_high_band, esize;
644  float exp_power[HIGH_BAND_MAX_SIZE];
645 
646  coefs1 = s->coefs1[ch];
647  exponents = s->exponents[ch];
648  esize = s->exponents_bsize[ch];
649  mult = ff_exp10(total_gain * 0.05) / s->max_exponent[ch];
650  mult *= mdct_norm;
651  coefs = s->coefs[ch];
652  if (s->use_noise_coding) {
653  mult1 = mult;
654  /* very low freqs : noise */
655  for (i = 0; i < s->coefs_start; i++) {
656  *coefs++ = s->noise_table[s->noise_index] *
657  exponents[i << bsize >> esize] * mult1;
658  s->noise_index = (s->noise_index + 1) &
659  (NOISE_TAB_SIZE - 1);
660  }
661 
662  n1 = s->exponent_high_sizes[bsize];
663 
664  /* compute power of high bands */
665  exponents = s->exponents[ch] +
666  (s->high_band_start[bsize] << bsize >> esize);
667  last_high_band = 0; /* avoid warning */
668  for (j = 0; j < n1; j++) {
669  n = s->exponent_high_bands[s->frame_len_bits -
670  s->block_len_bits][j];
671  if (s->high_band_coded[ch][j]) {
672  float e2, v;
673  e2 = 0;
674  for (i = 0; i < n; i++) {
675  v = exponents[i << bsize >> esize];
676  e2 += v * v;
677  }
678  exp_power[j] = e2 / n;
679  last_high_band = j;
680  ff_tlog(s->avctx, "%d: power=%f (%d)\n", j, exp_power[j], n);
681  }
682  exponents += n << bsize >> esize;
683  }
684 
685  /* main freqs and high freqs */
686  exponents = s->exponents[ch] + (s->coefs_start << bsize >> esize);
687  for (j = -1; j < n1; j++) {
688  if (j < 0)
689  n = s->high_band_start[bsize] - s->coefs_start;
690  else
691  n = s->exponent_high_bands[s->frame_len_bits -
692  s->block_len_bits][j];
693  if (j >= 0 && s->high_band_coded[ch][j]) {
694  /* use noise with specified power */
695  mult1 = sqrt(exp_power[j] / exp_power[last_high_band]);
696  /* XXX: use a table */
697  mult1 = mult1 * ff_exp10(s->high_band_values[ch][j] * 0.05);
698  mult1 = mult1 / (s->max_exponent[ch] * s->noise_mult);
699  mult1 *= mdct_norm;
700  for (i = 0; i < n; i++) {
701  noise = s->noise_table[s->noise_index];
702  s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1);
703  *coefs++ = noise * exponents[i << bsize >> esize] * mult1;
704  }
705  exponents += n << bsize >> esize;
706  } else {
707  /* coded values + small noise */
708  for (i = 0; i < n; i++) {
709  noise = s->noise_table[s->noise_index];
710  s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1);
711  *coefs++ = ((*coefs1++) + noise) *
712  exponents[i << bsize >> esize] * mult;
713  }
714  exponents += n << bsize >> esize;
715  }
716  }
717 
718  /* very high freqs : noise */
719  n = s->block_len - s->coefs_end[bsize];
720  mult1 = mult * exponents[(-(1 << bsize)) >> esize];
721  for (i = 0; i < n; i++) {
722  *coefs++ = s->noise_table[s->noise_index] * mult1;
723  s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1);
724  }
725  } else {
726  /* XXX: optimize more */
727  for (i = 0; i < s->coefs_start; i++)
728  *coefs++ = 0.0;
729  n = nb_coefs[ch];
730  for (i = 0; i < n; i++)
731  *coefs++ = coefs1[i] * exponents[i << bsize >> esize] * mult;
732  n = s->block_len - s->coefs_end[bsize];
733  for (i = 0; i < n; i++)
734  *coefs++ = 0.0;
735  }
736  }
737  }
738 
739 #ifdef TRACE
740  for (ch = 0; ch < channels; ch++) {
741  if (s->channel_coded[ch]) {
742  dump_floats(s, "exponents", 3, s->exponents[ch], s->block_len);
743  dump_floats(s, "coefs", 1, s->coefs[ch], s->block_len);
744  }
745  }
746 #endif /* TRACE */
747 
748  if (s->ms_stereo && s->channel_coded[1]) {
749  /* nominal case for ms stereo: we do it before mdct */
750  /* no need to optimize this case because it should almost
751  * never happen */
752  if (!s->channel_coded[0]) {
753  ff_tlog(s->avctx, "rare ms-stereo case happened\n");
754  memset(s->coefs[0], 0, sizeof(float) * s->block_len);
755  s->channel_coded[0] = 1;
756  }
757 
758  s->fdsp->butterflies_float(s->coefs[0], s->coefs[1], s->block_len);
759  }
760 
761 next:
762  mdct = s->mdct_ctx[bsize];
763  mdct_fn = s->mdct_fn[bsize];
764 
765  for (ch = 0; ch < channels; ch++) {
766  int n4, index;
767 
768  n4 = s->block_len / 2;
769  if (s->channel_coded[ch])
770  mdct_fn(mdct, s->output, s->coefs[ch], sizeof(float));
771  else if (!(s->ms_stereo && ch == 1))
772  memset(s->output, 0, sizeof(s->output));
773 
774  /* multiply by the window and add in the frame */
775  index = (s->frame_len / 2) + s->block_pos - n4;
776  wma_window(s, &s->frame_out[ch][index]);
777  }
778 
779  /* update block number */
780  s->block_num++;
781  s->block_pos += s->block_len;
782  if (s->block_pos >= s->frame_len)
783  return 1;
784  else
785  return 0;
786 }
787 
788 /* decode a frame of frame_len samples */
790  int samples_offset)
791 {
792  int ret, ch;
793 
794 #ifdef TRACE
795  ff_tlog(s->avctx, "***decode_frame: %d size=%d\n",
796  s->frame_count++, s->frame_len);
797 #endif /* TRACE */
798 
799  /* read each block */
800  s->block_num = 0;
801  s->block_pos = 0;
802  for (;;) {
804  if (ret < 0)
805  return -1;
806  if (ret)
807  break;
808  }
809 
810  for (ch = 0; ch < s->avctx->ch_layout.nb_channels; ch++) {
811  /* copy current block to output */
812  memcpy(samples[ch] + samples_offset, s->frame_out[ch],
813  s->frame_len * sizeof(*s->frame_out[ch]));
814  /* prepare for next block */
815  memmove(&s->frame_out[ch][0], &s->frame_out[ch][s->frame_len],
816  s->frame_len * sizeof(*s->frame_out[ch]));
817 
818 #ifdef TRACE
819  dump_floats(s, "samples", 6, samples[ch] + samples_offset,
820  s->frame_len);
821 #endif /* TRACE */
822  }
823 
824  return 0;
825 }
826 
828  int *got_frame_ptr, AVPacket *avpkt)
829 {
830  const uint8_t *buf = avpkt->data;
831  int buf_size = avpkt->size;
832  WMACodecContext *s = avctx->priv_data;
833  int nb_frames, bit_offset, i, pos, len, ret;
834  uint8_t *q;
835  float **samples;
836  int samples_offset;
837 
838  ff_tlog(avctx, "***decode_superframe:\n");
839 
840  if (buf_size == 0) {
841  if (s->eof_done)
842  return 0;
843 
844  frame->nb_samples = s->frame_len;
845  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
846  return ret;
847 
848  for (i = 0; i < s->avctx->ch_layout.nb_channels; i++)
849  memcpy(frame->extended_data[i], &s->frame_out[i][0],
850  frame->nb_samples * sizeof(s->frame_out[i][0]));
851 
852  s->last_superframe_len = 0;
853  s->eof_done = 1;
854  *got_frame_ptr = 1;
855  return 0;
856  }
857  if (buf_size < avctx->block_align) {
858  av_log(avctx, AV_LOG_ERROR,
859  "Input packet size too small (%d < %d)\n",
860  buf_size, avctx->block_align);
861  return AVERROR_INVALIDDATA;
862  }
863  if (avctx->block_align)
864  buf_size = avctx->block_align;
865 
866  init_get_bits(&s->gb, buf, buf_size * 8);
867 
868  if (s->use_bit_reservoir) {
869  /* read super frame header */
870  skip_bits(&s->gb, 4); /* super frame index */
871  nb_frames = get_bits(&s->gb, 4) - (s->last_superframe_len <= 0);
872  if (nb_frames <= 0) {
873  int is_error = nb_frames < 0 || get_bits_left(&s->gb) <= 8;
874  av_log(avctx, is_error ? AV_LOG_ERROR : AV_LOG_WARNING,
875  "nb_frames is %d bits left %d\n",
876  nb_frames, get_bits_left(&s->gb));
877  if (is_error)
878  return AVERROR_INVALIDDATA;
879 
880  if ((s->last_superframe_len + buf_size - 1) >
882  goto fail;
883 
884  q = s->last_superframe + s->last_superframe_len;
885  len = buf_size - 1;
886  while (len > 0) {
887  *q++ = get_bits (&s->gb, 8);
888  len --;
889  }
890  memset(q, 0, AV_INPUT_BUFFER_PADDING_SIZE);
891 
892  s->last_superframe_len += 8*buf_size - 8;
893 // s->reset_block_lengths = 1; //XXX is this needed ?
894  *got_frame_ptr = 0;
895  return buf_size;
896  }
897  } else
898  nb_frames = 1;
899 
900  /* get output buffer */
901  frame->nb_samples = nb_frames * s->frame_len;
902  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
903  return ret;
904  samples = (float **) frame->extended_data;
905  samples_offset = 0;
906 
907  if (s->use_bit_reservoir) {
908  bit_offset = get_bits(&s->gb, s->byte_offset_bits + 3);
909  if (bit_offset > get_bits_left(&s->gb)) {
910  av_log(avctx, AV_LOG_ERROR,
911  "Invalid last frame bit offset %d > buf size %d (%d)\n",
912  bit_offset, get_bits_left(&s->gb), buf_size);
913  goto fail;
914  }
915 
916  if (s->last_superframe_len > 0) {
917  /* add bit_offset bits to last frame */
918  if ((s->last_superframe_len + ((bit_offset + 7) >> 3)) >
920  goto fail;
921  q = s->last_superframe + s->last_superframe_len;
922  len = bit_offset;
923  while (len > 7) {
924  *q++ = get_bits(&s->gb, 8);
925  len -= 8;
926  }
927  if (len > 0)
928  *q++ = get_bits(&s->gb, len) << (8 - len);
929  memset(q, 0, AV_INPUT_BUFFER_PADDING_SIZE);
930 
931  /* XXX: bit_offset bits into last frame */
932  init_get_bits(&s->gb, s->last_superframe,
933  s->last_superframe_len * 8 + bit_offset);
934  /* skip unused bits */
935  if (s->last_bitoffset > 0)
936  skip_bits(&s->gb, s->last_bitoffset);
937  /* this frame is stored in the last superframe and in the
938  * current one */
939  if (wma_decode_frame(s, samples, samples_offset) < 0)
940  goto fail;
941  samples_offset += s->frame_len;
942  nb_frames--;
943  }
944 
945  /* read each frame starting from bit_offset */
946  pos = bit_offset + 4 + 4 + s->byte_offset_bits + 3;
947  if (pos >= MAX_CODED_SUPERFRAME_SIZE * 8 || pos > buf_size * 8)
948  return AVERROR_INVALIDDATA;
949  init_get_bits(&s->gb, buf + (pos >> 3), (buf_size - (pos >> 3)) * 8);
950  len = pos & 7;
951  if (len > 0)
952  skip_bits(&s->gb, len);
953 
954  s->reset_block_lengths = 1;
955  for (i = 0; i < nb_frames; i++) {
956  if (wma_decode_frame(s, samples, samples_offset) < 0)
957  goto fail;
958  samples_offset += s->frame_len;
959  }
960 
961  /* we copy the end of the frame in the last frame buffer */
962  pos = get_bits_count(&s->gb) +
963  ((bit_offset + 4 + 4 + s->byte_offset_bits + 3) & ~7);
964  s->last_bitoffset = pos & 7;
965  pos >>= 3;
966  len = buf_size - pos;
967  if (len > MAX_CODED_SUPERFRAME_SIZE || len < 0) {
968  av_log(s->avctx, AV_LOG_ERROR, "len %d invalid\n", len);
969  goto fail;
970  }
971  s->last_superframe_len = len;
972  memcpy(s->last_superframe, buf + pos, len);
973  } else {
974  /* single frame decode */
975  if (wma_decode_frame(s, samples, samples_offset) < 0)
976  goto fail;
977  samples_offset += s->frame_len;
978  }
979 
980  ff_dlog(s->avctx, "%d %d %d %d eaten:%d\n",
981  s->frame_len_bits, s->block_len_bits, s->frame_len, s->block_len,
982  avctx->block_align);
983 
984  *got_frame_ptr = 1;
985 
986  return buf_size;
987 
988 fail:
989  /* when error, we reset the bit reservoir */
990  s->last_superframe_len = 0;
991  return -1;
992 }
993 
994 static av_cold void flush(AVCodecContext *avctx)
995 {
996  WMACodecContext *s = avctx->priv_data;
997 
998  s->last_bitoffset =
999  s->last_superframe_len = 0;
1000 
1001  s->eof_done = 0;
1002  avctx->internal->skip_samples = s->frame_len * 2;
1003 }
1004 
1005 #if CONFIG_WMAV1_DECODER
1006 const FFCodec ff_wmav1_decoder = {
1007  .p.name = "wmav1",
1008  CODEC_LONG_NAME("Windows Media Audio 1"),
1009  .p.type = AVMEDIA_TYPE_AUDIO,
1010  .p.id = AV_CODEC_ID_WMAV1,
1011  .priv_data_size = sizeof(WMACodecContext),
1012  .init = wma_decode_init,
1013  .close = ff_wma_end,
1015  .flush = flush,
1016  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1017  .p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1019  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1020 };
1021 #endif
1022 #if CONFIG_WMAV2_DECODER
1023 const FFCodec ff_wmav2_decoder = {
1024  .p.name = "wmav2",
1025  CODEC_LONG_NAME("Windows Media Audio 2"),
1026  .p.type = AVMEDIA_TYPE_AUDIO,
1027  .p.id = AV_CODEC_ID_WMAV2,
1028  .priv_data_size = sizeof(WMACodecContext),
1029  .init = wma_decode_init,
1030  .close = ff_wma_end,
1032  .flush = flush,
1033  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1034  .p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1036  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1037 };
1038 #endif
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:66
nb_coefs
static int nb_coefs(int length, int level, uint64_t sn)
Definition: af_afwtdn.c:515
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
name
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
ff_exp10
static av_always_inline double ff_exp10(double x)
Compute 10^x for floating point values.
Definition: ffmath.h:42
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:42
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:839
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
u
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:262
flush
static av_cold void flush(AVCodecContext *avctx)
Definition: wmadec.c:994
AVTXContext
Definition: tx_priv.h:225
AVCodecInternal::skip_samples
int skip_samples
Number of audio samples to skip at the start of the next decoded frame.
Definition: internal.h:133
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:325
w
uint8_t w
Definition: llviddspenc.c:38
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:374
wma_lsp_to_curve_init
static void wma_lsp_to_curve_init(WMACodecContext *s, int frame_len)
Definition: wmadec.c:173
init_vlc
#define init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
Definition: vlc.h:43
b
#define b
Definition: input.c:41
FFCodec
Definition: codec_internal.h:119
AV_CODEC_ID_WMAV2
@ AV_CODEC_ID_WMAV2
Definition: codec_id.h:443
ff_wmav2_decoder
const FFCodec ff_wmav2_decoder
wma_decode_frame
static int wma_decode_frame(WMACodecContext *s, float **samples, int samples_offset)
Definition: wmadec.c:789
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:649
av_tx_init
av_cold int av_tx_init(AVTXContext **ctx, av_tx_fn *tx, enum AVTXType type, int inv, int len, const void *scale, uint64_t flags)
Initialize a transform context with the given configuration (i)MDCTs with an odd length are currently...
Definition: tx.c:883
ff_wma_hgain_hufftab
const uint8_t ff_wma_hgain_hufftab[37][2]
Definition: wmadata.h:54
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
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:123
HIGH_BAND_MAX_SIZE
#define HIGH_BAND_MAX_SIZE
Definition: wma.h:41
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:234
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:407
WMACoef
float WMACoef
type for decoded coefficients, int16_t would be enough for wma 1/2
Definition: wma.h:58
fail
#define fail()
Definition: checkasm.h:134
tab
static const struct twinvq_data tab
Definition: twinvq_data.h:10345
val
static double val(void *priv, double ch)
Definition: aeval.c:77
scale
static av_always_inline float scale(float x, float s)
Definition: vf_v360.c:1389
WMACodecContext
Definition: wma.h:68
mult
static int16_t mult(Float11 *f1, Float11 *f2)
Definition: g726.c:60
AV_CODEC_ID_WMAV1
@ AV_CODEC_ID_WMAV1
Definition: codec_id.h:442
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
av_tx_fn
void(* av_tx_fn)(AVTXContext *s, void *out, void *in, ptrdiff_t stride)
Function pointer to a function to perform the transform.
Definition: tx.h:127
float
float
Definition: af_crystalizer.c:122
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:500
AV_TX_FLOAT_MDCT
@ AV_TX_FLOAT_MDCT
Standard MDCT with a sample data type of float, double or int32_t, respecively.
Definition: tx.h:68
EXPVLCBITS
#define EXPVLCBITS
Definition: wmadec.c:47
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:298
s
#define s(width, name)
Definition: cbs_vp9.c:256
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:363
exp2f
#define exp2f(x)
Definition: libm.h:293
channels
channels
Definition: aptx.h:31
decode.h
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:94
wma.h
ff_wma_total_gain_to_bits
int ff_wma_total_gain_to_bits(int total_gain)
Definition: wma.c:352
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:264
if
if(ret)
Definition: filter_design.txt:179
AV_TX_FULL_IMDCT
@ AV_TX_FULL_IMDCT
Performs a full inverse MDCT rather than leaving out samples that can be derived through symmetry.
Definition: tx.h:151
HGAINMAX
#define HGAINMAX
Definition: wmadec.c:51
AVCodecContext::internal
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:433
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
ff_init_vlc_from_lengths
int ff_init_vlc_from_lengths(VLC *vlc, int nb_bits, int nb_codes, const int8_t *lens, int lens_wrap, const void *symbols, int symbols_wrap, int symbols_size, int offset, int flags, void *logctx)
Build VLC decoding tables suitable for use with get_vlc2()
Definition: vlc.c:328
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:787
index
int index
Definition: gxfenc.c:89
MAX_CODED_SUPERFRAME_SIZE
#define MAX_CODED_SUPERFRAME_SIZE
Definition: wma.h:46
ff_wma_end
int ff_wma_end(AVCodecContext *avctx)
Definition: wma.c:366
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:28
ff_aac_scalefactor_bits
const uint8_t ff_aac_scalefactor_bits[121]
Definition: aactab.c:111
f
f
Definition: af_crystalizer.c:122
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1450
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:375
ff_wmav1_decoder
const FFCodec ff_wmav1_decoder
codec_internal.h
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:205
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1023
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
ff_wma_init
av_cold int ff_wma_init(AVCodecContext *avctx, int flags2)
Definition: wma.c:78
NOISE_TAB_SIZE
#define NOISE_TAB_SIZE
Definition: wma.h:50
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:46
wma_decode_block
static int wma_decode_block(WMACodecContext *s)
Definition: wmadec.c:445
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:252
AVCodec::id
enum AVCodecID id
Definition: codec.h:218
LSP_POW_BITS
#define LSP_POW_BITS
Definition: wma.h:52
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
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:499
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:55
wma_window
static void wma_window(WMACodecContext *s, float *out)
Apply MDCT window and add into output.
Definition: wmadec.c:395
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:211
len
int len
Definition: vorbis_enc_data.h:426
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:1052
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
wma_decode_superframe
static int wma_decode_superframe(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)
Definition: wmadec.c:827
HGAINVLCBITS
#define HGAINVLCBITS
Definition: wmadec.c:50
align_get_bits
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:683
pos
unsigned int pos
Definition: spdifenc.c:412
EXPMAX
#define EXPMAX
Definition: wmadec.c:48
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
AVCodecContext
main external API structure.
Definition: avcodec.h:398
noise
static int noise(AVBSFContext *ctx, AVPacket *pkt)
Definition: noise_bsf.c:120
decode_exp_vlc
static int decode_exp_vlc(WMACodecContext *s, int ch)
decode exponents coded with VLC codes
Definition: wmadec.c:336
AV_CODEC_CAP_DELAY
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: codec.h:82
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:64
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:426
ff_tlog
#define ff_tlog(ctx,...)
Definition: internal.h:162
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:425
NB_LSP_COEFS
#define NB_LSP_COEFS
Definition: wma.h:43
wma_decode_init
static av_cold int wma_decode_init(AVCodecContext *avctx)
Definition: wmadec.c:74
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:154
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
int
int
Definition: ffmpeg_filter.c:156
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
ff_aac_scalefactor_code
const uint32_t ff_aac_scalefactor_code[121]
Definition: aactab.c:92