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