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 = vlc_init(&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].table,
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  frame->pts = AV_NOPTS_VALUE;
849  for (i = 0; i < s->avctx->ch_layout.nb_channels; i++)
850  memcpy(frame->extended_data[i], &s->frame_out[i][0],
851  frame->nb_samples * sizeof(s->frame_out[i][0]));
852 
853  s->last_superframe_len = 0;
854  s->eof_done = 1;
855  *got_frame_ptr = 1;
856  return 0;
857  }
858  if (buf_size < avctx->block_align) {
859  av_log(avctx, AV_LOG_ERROR,
860  "Input packet size too small (%d < %d)\n",
861  buf_size, avctx->block_align);
862  return AVERROR_INVALIDDATA;
863  }
864  if (avctx->block_align)
865  buf_size = avctx->block_align;
866 
867  init_get_bits(&s->gb, buf, buf_size * 8);
868 
869  if (s->use_bit_reservoir) {
870  /* read super frame header */
871  skip_bits(&s->gb, 4); /* super frame index */
872  nb_frames = get_bits(&s->gb, 4) - (s->last_superframe_len <= 0);
873  if (nb_frames <= 0) {
874  int is_error = nb_frames < 0 || get_bits_left(&s->gb) <= 8;
875  av_log(avctx, is_error ? AV_LOG_ERROR : AV_LOG_WARNING,
876  "nb_frames is %d bits left %d\n",
877  nb_frames, get_bits_left(&s->gb));
878  if (is_error)
879  return AVERROR_INVALIDDATA;
880 
881  if ((s->last_superframe_len + buf_size - 1) >
883  goto fail;
884 
885  q = s->last_superframe + s->last_superframe_len;
886  len = buf_size - 1;
887  while (len > 0) {
888  *q++ = get_bits (&s->gb, 8);
889  len --;
890  }
891  memset(q, 0, AV_INPUT_BUFFER_PADDING_SIZE);
892 
893  s->last_superframe_len += 8*buf_size - 8;
894 // s->reset_block_lengths = 1; //XXX is this needed ?
895  *got_frame_ptr = 0;
896  return buf_size;
897  }
898  } else
899  nb_frames = 1;
900 
901  /* get output buffer */
902  frame->nb_samples = nb_frames * s->frame_len;
903  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
904  return ret;
905  samples = (float **) frame->extended_data;
906  samples_offset = 0;
907 
908  if (s->use_bit_reservoir) {
909  bit_offset = get_bits(&s->gb, s->byte_offset_bits + 3);
910  if (bit_offset > get_bits_left(&s->gb)) {
911  av_log(avctx, AV_LOG_ERROR,
912  "Invalid last frame bit offset %d > buf size %d (%d)\n",
913  bit_offset, get_bits_left(&s->gb), buf_size);
914  goto fail;
915  }
916 
917  if (s->last_superframe_len > 0) {
918  /* add bit_offset bits to last frame */
919  if ((s->last_superframe_len + ((bit_offset + 7) >> 3)) >
921  goto fail;
922  q = s->last_superframe + s->last_superframe_len;
923  len = bit_offset;
924  while (len > 7) {
925  *q++ = get_bits(&s->gb, 8);
926  len -= 8;
927  }
928  if (len > 0)
929  *q++ = get_bits(&s->gb, len) << (8 - len);
930  memset(q, 0, AV_INPUT_BUFFER_PADDING_SIZE);
931 
932  /* XXX: bit_offset bits into last frame */
933  init_get_bits(&s->gb, s->last_superframe,
934  s->last_superframe_len * 8 + bit_offset);
935  /* skip unused bits */
936  if (s->last_bitoffset > 0)
937  skip_bits(&s->gb, s->last_bitoffset);
938  /* this frame is stored in the last superframe and in the
939  * current one */
940  if (wma_decode_frame(s, samples, samples_offset) < 0)
941  goto fail;
942  samples_offset += s->frame_len;
943  nb_frames--;
944  }
945 
946  /* read each frame starting from bit_offset */
947  pos = bit_offset + 4 + 4 + s->byte_offset_bits + 3;
948  if (pos >= MAX_CODED_SUPERFRAME_SIZE * 8 || pos > buf_size * 8)
949  return AVERROR_INVALIDDATA;
950  init_get_bits(&s->gb, buf + (pos >> 3), (buf_size - (pos >> 3)) * 8);
951  len = pos & 7;
952  if (len > 0)
953  skip_bits(&s->gb, len);
954 
955  s->reset_block_lengths = 1;
956  for (i = 0; i < nb_frames; i++) {
957  if (wma_decode_frame(s, samples, samples_offset) < 0)
958  goto fail;
959  samples_offset += s->frame_len;
960  }
961 
962  /* we copy the end of the frame in the last frame buffer */
963  pos = get_bits_count(&s->gb) +
964  ((bit_offset + 4 + 4 + s->byte_offset_bits + 3) & ~7);
965  s->last_bitoffset = pos & 7;
966  pos >>= 3;
967  len = buf_size - pos;
968  if (len > MAX_CODED_SUPERFRAME_SIZE || len < 0) {
969  av_log(s->avctx, AV_LOG_ERROR, "len %d invalid\n", len);
970  goto fail;
971  }
972  s->last_superframe_len = len;
973  memcpy(s->last_superframe, buf + pos, len);
974  } else {
975  /* single frame decode */
976  if (wma_decode_frame(s, samples, samples_offset) < 0)
977  goto fail;
978  samples_offset += s->frame_len;
979  }
980 
981  ff_dlog(s->avctx, "%d %d %d %d eaten:%d\n",
982  s->frame_len_bits, s->block_len_bits, s->frame_len, s->block_len,
983  avctx->block_align);
984 
985  *got_frame_ptr = 1;
986 
987  return buf_size;
988 
989 fail:
990  /* when error, we reset the bit reservoir */
991  s->last_superframe_len = 0;
992  return -1;
993 }
994 
995 static av_cold void flush(AVCodecContext *avctx)
996 {
997  WMACodecContext *s = avctx->priv_data;
998 
999  s->last_bitoffset =
1000  s->last_superframe_len = 0;
1001 
1002  s->eof_done = 0;
1003  avctx->internal->skip_samples = s->frame_len * 2;
1004 }
1005 
1006 #if CONFIG_WMAV1_DECODER
1007 const FFCodec ff_wmav1_decoder = {
1008  .p.name = "wmav1",
1009  CODEC_LONG_NAME("Windows Media Audio 1"),
1010  .p.type = AVMEDIA_TYPE_AUDIO,
1011  .p.id = AV_CODEC_ID_WMAV1,
1012  .priv_data_size = sizeof(WMACodecContext),
1013  .init = wma_decode_init,
1014  .close = ff_wma_end,
1016  .flush = flush,
1017  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1018  .p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1020  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1021 };
1022 #endif
1023 #if CONFIG_WMAV2_DECODER
1024 const FFCodec ff_wmav2_decoder = {
1025  .p.name = "wmav2",
1026  CODEC_LONG_NAME("Windows Media Audio 2"),
1027  .p.type = AVMEDIA_TYPE_AUDIO,
1028  .p.id = AV_CODEC_ID_WMAV2,
1029  .priv_data_size = sizeof(WMACodecContext),
1030  .init = wma_decode_init,
1031  .close = ff_wma_end,
1033  .flush = flush,
1034  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1035  .p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1037  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1038 };
1039 #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:215
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_vlc_init_from_lengths
int ff_vlc_init_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:306
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:43
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:695
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:55
u
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:251
flush
static av_cold void flush(AVCodecContext *avctx)
Definition: wmadec.c:995
AVTXContext
Definition: tx_priv.h:235
AVCodecInternal::skip_samples
int skip_samples
Number of audio samples to skip at the start of the next decoded frame.
Definition: internal.h:125
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:266
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:389
w
uint8_t w
Definition: llviddspenc.c:38
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:539
wma_lsp_to_curve_init
static void wma_lsp_to_curve_init(WMACodecContext *s, int frame_len)
Definition: wmadec.c:173
b
#define b
Definition: input.c:41
FFCodec
Definition: codec_internal.h:127
ff_wma_run_level_decode
int ff_wma_run_level_decode(AVCodecContext *avctx, GetBitContext *gb, const VLCElem *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:427
AV_CODEC_ID_WMAV2
@ AV_CODEC_ID_WMAV2
Definition: codec_id.h:454
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:514
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:903
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:381
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:335
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
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:460
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:188
tab
static const struct twinvq_data tab
Definition: twinvq_data.h:10345
noise
static int noise(AVBSFContext *ctx, AVPacket *pkt)
Definition: noise.c:127
val
static double val(void *priv, double ch)
Definition: aeval.c:77
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:453
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
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:151
float
float
Definition: af_crystalizer.c:122
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:530
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:311
s
#define s(width, name)
Definition: cbs_vp9.c:198
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
vlc_init
#define vlc_init(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
Definition: vlc.h:62
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:353
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:296
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:175
HGAINMAX
#define HGAINMAX
Definition: wmadec.c:51
AVCodecContext::internal
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:486
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:388
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:652
index
int index
Definition: gxfenc.c:90
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:367
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:204
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:1697
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:368
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:540
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:1063
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
ff_wma_init
av_cold int ff_wma_init(AVCodecContext *avctx, int flags2)
Definition: wma.c:79
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:33
wma_decode_block
static int wma_decode_block(WMACodecContext *s)
Definition: wmadec.c:445
M_PI
#define M_PI
Definition: mathematics.h:67
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:201
LSP_POW_BITS
#define LSP_POW_BITS
Definition: wma.h:52
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
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:529
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:194
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:1089
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:561
pos
unsigned int pos
Definition: spdifenc.c:414
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:451
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:76
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
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: intra.c:291
ff_tlog
#define ff_tlog(ctx,...)
Definition: internal.h:141
AVPacket
This structure stores compressed data.
Definition: packet.h:516
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:478
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
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:185