FFmpeg
wma.c
Go to the documentation of this file.
1 /*
2  * WMA compatible codec
3  * Copyright (c) 2002-2007 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 #include "libavutil/attributes.h"
23 #include "libavutil/mem.h"
24 
25 #include "avcodec.h"
26 #include "sinewin.h"
27 #include "wma.h"
28 #include "wma_common.h"
29 #include "wma_freqs.h"
30 #include "wmadata.h"
31 
32 /* XXX: use same run/length optimization as mpeg decoders */
33 // FIXME maybe split decode / encode or pass flag
34 static av_cold int init_coef_vlc(VLC *vlc, uint16_t **prun_table,
35  float **plevel_table, uint16_t **pint_table,
36  const CoefVLCTable *vlc_table)
37 {
38  int n = vlc_table->n;
39  const uint8_t *table_bits = vlc_table->huffbits;
40  const uint32_t *table_codes = vlc_table->huffcodes;
41  const uint16_t *levels_table = vlc_table->levels;
42  uint16_t *run_table, *int_table;
43  float *flevel_table;
44  int i, l, j, k, level, ret;
45 
46  ret = vlc_init(vlc, VLCBITS, n, table_bits, 1, 1, table_codes, 4, 4, 0);
47  if (ret < 0)
48  return ret;
49 
50  run_table = av_malloc_array(n, sizeof(uint16_t));
51  flevel_table = av_malloc_array(n, sizeof(*flevel_table));
52  int_table = av_malloc_array(n, sizeof(uint16_t));
53  if (!run_table || !flevel_table || !int_table) {
54  av_freep(&run_table);
55  av_freep(&flevel_table);
56  av_freep(&int_table);
57  return AVERROR(ENOMEM);
58  }
59  i = 2;
60  level = 1;
61  k = 0;
62  while (i < n) {
63  int_table[k] = i;
64  l = levels_table[k++];
65  for (j = 0; j < l; j++) {
66  run_table[i] = j;
67  flevel_table[i] = level;
68  i++;
69  }
70  level++;
71  }
72  *prun_table = run_table;
73  *plevel_table = flevel_table;
74  *pint_table = int_table;
75 
76  return 0;
77 }
78 
79 av_cold int ff_wma_init(AVCodecContext *avctx, int flags2)
80 {
81  WMACodecContext *s = avctx->priv_data;
82  int channels = avctx->ch_layout.nb_channels;
83  int i, ret;
84  float bps1, high_freq;
85  float bps;
86  int sample_rate1;
87  int coef_vlc_table;
88 
89  if (avctx->sample_rate <= 0 || avctx->sample_rate > 50000 ||
91  avctx->bit_rate <= 0)
92  return -1;
93 
94 
95  if (avctx->codec->id == AV_CODEC_ID_WMAV1)
96  s->version = 1;
97  else
98  s->version = 2;
99 
100  /* compute MDCT block size */
101  s->frame_len_bits = ff_wma_get_frame_len_bits(avctx->sample_rate,
102  s->version, 0);
103  s->next_block_len_bits = s->frame_len_bits;
104  s->prev_block_len_bits = s->frame_len_bits;
105  s->block_len_bits = s->frame_len_bits;
106 
107  s->frame_len = 1 << s->frame_len_bits;
108  if (s->use_variable_block_len) {
109  int nb_max, nb;
110  nb = ((flags2 >> 3) & 3) + 1;
111  if ((avctx->bit_rate / channels) >= 32000)
112  nb += 2;
113  nb_max = s->frame_len_bits - BLOCK_MIN_BITS;
114  if (nb > nb_max)
115  nb = nb_max;
116  s->nb_block_sizes = nb + 1;
117  } else
118  s->nb_block_sizes = 1;
119 
120  /* init rate dependent parameters */
121  s->use_noise_coding = 1;
122  high_freq = avctx->sample_rate * 0.5;
123 
124  /* if version 2, then the rates are normalized */
125  sample_rate1 = avctx->sample_rate;
126  if (s->version == 2) {
127  if (sample_rate1 >= 44100)
128  sample_rate1 = 44100;
129  else if (sample_rate1 >= 22050)
130  sample_rate1 = 22050;
131  else if (sample_rate1 >= 16000)
132  sample_rate1 = 16000;
133  else if (sample_rate1 >= 11025)
134  sample_rate1 = 11025;
135  else if (sample_rate1 >= 8000)
136  sample_rate1 = 8000;
137  }
138 
139  bps = (float) avctx->bit_rate /
140  (float) (channels * avctx->sample_rate);
141  s->byte_offset_bits = av_log2((int) (bps * s->frame_len / 8.0 + 0.5)) + 2;
142  if (s->byte_offset_bits + 3 > MIN_CACHE_BITS) {
143  av_log(avctx, AV_LOG_ERROR, "byte_offset_bits %d is too large\n", s->byte_offset_bits);
144  return AVERROR_PATCHWELCOME;
145  }
146 
147  /* compute high frequency value and choose if noise coding should
148  * be activated */
149  bps1 = bps;
150  if (channels == 2)
151  bps1 = bps * 1.6;
152  if (sample_rate1 == 44100) {
153  if (bps1 >= 0.61)
154  s->use_noise_coding = 0;
155  else
156  high_freq = high_freq * 0.4;
157  } else if (sample_rate1 == 22050) {
158  if (bps1 >= 1.16)
159  s->use_noise_coding = 0;
160  else if (bps1 >= 0.72)
161  high_freq = high_freq * 0.7;
162  else
163  high_freq = high_freq * 0.6;
164  } else if (sample_rate1 == 16000) {
165  if (bps > 0.5)
166  high_freq = high_freq * 0.5;
167  else
168  high_freq = high_freq * 0.3;
169  } else if (sample_rate1 == 11025)
170  high_freq = high_freq * 0.7;
171  else if (sample_rate1 == 8000) {
172  if (bps <= 0.625)
173  high_freq = high_freq * 0.5;
174  else if (bps > 0.75)
175  s->use_noise_coding = 0;
176  else
177  high_freq = high_freq * 0.65;
178  } else {
179  if (bps >= 0.8)
180  high_freq = high_freq * 0.75;
181  else if (bps >= 0.6)
182  high_freq = high_freq * 0.6;
183  else
184  high_freq = high_freq * 0.5;
185  }
186  ff_dlog(s->avctx, "flags2=0x%x\n", flags2);
187  ff_dlog(s->avctx, "version=%d channels=%d sample_rate=%d bitrate=%"PRId64" block_align=%d\n",
188  s->version, channels, avctx->sample_rate, avctx->bit_rate,
189  avctx->block_align);
190  ff_dlog(s->avctx, "bps=%f bps1=%f high_freq=%f bitoffset=%d\n",
191  bps, bps1, high_freq, s->byte_offset_bits);
192  ff_dlog(s->avctx, "use_noise_coding=%d use_exp_vlc=%d nb_block_sizes=%d\n",
193  s->use_noise_coding, s->use_exp_vlc, s->nb_block_sizes);
194 
195  /* compute the scale factor band sizes for each MDCT block size */
196  {
197  int a, b, pos, lpos, k, block_len, i, j, n;
198  const uint8_t *table;
199 
200  if (s->version == 1)
201  s->coefs_start = 3;
202  else
203  s->coefs_start = 0;
204  for (k = 0; k < s->nb_block_sizes; k++) {
205  block_len = s->frame_len >> k;
206 
207  if (s->version == 1) {
208  lpos = 0;
209  for (i = 0; i < 25; i++) {
211  b = avctx->sample_rate;
212  pos = ((block_len * 2 * a) + (b >> 1)) / b;
213  if (pos > block_len)
214  pos = block_len;
215  s->exponent_bands[0][i] = pos - lpos;
216  if (pos >= block_len) {
217  i++;
218  break;
219  }
220  lpos = pos;
221  }
222  s->exponent_sizes[0] = i;
223  } else {
224  /* hardcoded tables */
225  table = NULL;
226  a = s->frame_len_bits - BLOCK_MIN_BITS - k;
227  if (a < 3) {
228  if (avctx->sample_rate >= 44100)
230  else if (avctx->sample_rate >= 32000)
232  else if (avctx->sample_rate >= 22050)
234  }
235  if (table) {
236  n = *table++;
237  for (i = 0; i < n; i++)
238  s->exponent_bands[k][i] = table[i];
239  s->exponent_sizes[k] = n;
240  } else {
241  j = 0;
242  lpos = 0;
243  for (i = 0; i < 25; i++) {
245  b = avctx->sample_rate;
246  pos = ((block_len * 2 * a) + (b << 1)) / (4 * b);
247  pos <<= 2;
248  if (pos > block_len)
249  pos = block_len;
250  if (pos > lpos)
251  s->exponent_bands[k][j++] = pos - lpos;
252  if (pos >= block_len)
253  break;
254  lpos = pos;
255  }
256  s->exponent_sizes[k] = j;
257  }
258  }
259 
260  /* max number of coefs */
261  s->coefs_end[k] = (s->frame_len - ((s->frame_len * 9) / 100)) >> k;
262  /* high freq computation */
263  s->high_band_start[k] = (int) ((block_len * 2 * high_freq) /
264  avctx->sample_rate + 0.5);
265  n = s->exponent_sizes[k];
266  j = 0;
267  pos = 0;
268  for (i = 0; i < n; i++) {
269  int start, end;
270  start = pos;
271  pos += s->exponent_bands[k][i];
272  end = pos;
273  if (start < s->high_band_start[k])
274  start = s->high_band_start[k];
275  if (end > s->coefs_end[k])
276  end = s->coefs_end[k];
277  if (end > start)
278  s->exponent_high_bands[k][j++] = end - start;
279  }
280  s->exponent_high_sizes[k] = j;
281  }
282  }
283 
284 #ifdef TRACE
285  {
286  int i, j;
287  for (i = 0; i < s->nb_block_sizes; i++) {
288  ff_tlog(s->avctx, "%5d: n=%2d:",
289  s->frame_len >> i,
290  s->exponent_sizes[i]);
291  for (j = 0; j < s->exponent_sizes[i]; j++)
292  ff_tlog(s->avctx, " %d", s->exponent_bands[i][j]);
293  ff_tlog(s->avctx, "\n");
294  }
295  }
296 #endif /* TRACE */
297 
298  /* init MDCT windows : simple sine window */
299  for (i = 0; i < s->nb_block_sizes; i++) {
300  ff_init_ff_sine_windows(s->frame_len_bits - i);
301  s->windows[i] = ff_sine_windows[s->frame_len_bits - i];
302  }
303 
304  s->reset_block_lengths = 1;
305 
306  if (s->use_noise_coding) {
307  /* init the noise generator */
308  if (s->use_exp_vlc)
309  s->noise_mult = 0.02;
310  else
311  s->noise_mult = 0.04;
312 
313 #ifdef TRACE
314  for (i = 0; i < NOISE_TAB_SIZE; i++)
315  s->noise_table[i] = 1.0 * s->noise_mult;
316 #else
317  {
318  unsigned int seed;
319  float norm;
320  seed = 1;
321  norm = (1.0 / (float) (1LL << 31)) * sqrt(3) * s->noise_mult;
322  for (i = 0; i < NOISE_TAB_SIZE; i++) {
323  seed = seed * 314159 + 1;
324  s->noise_table[i] = (float) ((int) seed) * norm;
325  }
326  }
327 #endif /* TRACE */
328  }
329 
330  s->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
331  if (!s->fdsp)
332  return AVERROR(ENOMEM);
333 
334  /* choose the VLC tables for the coefficients */
335  coef_vlc_table = 2;
336  if (avctx->sample_rate >= 32000) {
337  if (bps1 < 0.72)
338  coef_vlc_table = 0;
339  else if (bps1 < 1.16)
340  coef_vlc_table = 1;
341  }
342  s->coef_vlcs[0] = &coef_vlcs[coef_vlc_table * 2];
343  s->coef_vlcs[1] = &coef_vlcs[coef_vlc_table * 2 + 1];
344  ret = init_coef_vlc(&s->coef_vlc[0], &s->run_table[0], &s->level_table[0],
345  &s->int_table[0], s->coef_vlcs[0]);
346  if (ret < 0)
347  return ret;
348 
349  return init_coef_vlc(&s->coef_vlc[1], &s->run_table[1], &s->level_table[1],
350  &s->int_table[1], s->coef_vlcs[1]);
351 }
352 
353 int ff_wma_total_gain_to_bits(int total_gain)
354 {
355  if (total_gain < 15)
356  return 13;
357  else if (total_gain < 32)
358  return 12;
359  else if (total_gain < 40)
360  return 11;
361  else if (total_gain < 45)
362  return 10;
363  else
364  return 9;
365 }
366 
368 {
369  WMACodecContext *s = avctx->priv_data;
370  int i;
371 
372  for (i = 0; i < s->nb_block_sizes; i++)
373  av_tx_uninit(&s->mdct_ctx[i]);
374 
375  if (s->use_exp_vlc)
376  ff_vlc_free(&s->exp_vlc);
377  if (s->use_noise_coding)
378  ff_vlc_free(&s->hgain_vlc);
379  for (i = 0; i < 2; i++) {
380  ff_vlc_free(&s->coef_vlc[i]);
381  av_freep(&s->run_table[i]);
382  av_freep(&s->level_table[i]);
383  av_freep(&s->int_table[i]);
384  }
385  av_freep(&s->fdsp);
386 
387  return 0;
388 }
389 
390 /**
391  * Decode an uncompressed coefficient.
392  * @param gb GetBitContext
393  * @return the decoded coefficient
394  */
396 {
397  /** consumes up to 34 bits */
398  int n_bits = 8;
399  /** decode length */
400  if (get_bits1(gb)) {
401  n_bits += 8;
402  if (get_bits1(gb)) {
403  n_bits += 8;
404  if (get_bits1(gb))
405  n_bits += 7;
406  }
407  }
408  return get_bits_long(gb, n_bits);
409 }
410 
411 /**
412  * Decode run level compressed coefficients.
413  * @param avctx codec context
414  * @param gb bitstream reader context
415  * @param vlc vlc table for get_vlc2
416  * @param level_table level codes
417  * @param run_table run codes
418  * @param version 0 for wma1,2 1 for wmapro
419  * @param ptr output buffer
420  * @param offset offset in the output buffer
421  * @param num_coefs number of input coefficients
422  * @param block_len input buffer length (2^n)
423  * @param frame_len_bits number of bits for escaped run codes
424  * @param coef_nb_bits number of bits for escaped level codes
425  * @return 0 on success, -1 otherwise
426  */
428  const VLCElem *vlc, const float *level_table,
429  const uint16_t *run_table, int version,
430  WMACoef *ptr, int offset, int num_coefs,
431  int block_len, int frame_len_bits,
432  int coef_nb_bits)
433 {
434  int code, level, sign;
435  const uint32_t *ilvl = (const uint32_t *) level_table;
436  uint32_t *iptr = (uint32_t *) ptr;
437  const unsigned int coef_mask = block_len - 1;
438  for (; offset < num_coefs; offset++) {
439  code = get_vlc2(gb, vlc, VLCBITS, VLCMAX);
440  if (code > 1) {
441  /** normal code */
442  offset += run_table[code];
443  sign = get_bits1(gb) - 1;
444  iptr[offset & coef_mask] = ilvl[code] ^ (sign & 0x80000000);
445  } else if (code == 1) {
446  /** EOB */
447  break;
448  } else {
449  /** escape */
450  if (!version) {
451  level = get_bits(gb, coef_nb_bits);
452  /** NOTE: this is rather suboptimal. reading
453  * block_len_bits would be better */
454  offset += get_bits(gb, frame_len_bits);
455  } else {
457  /** escape decode */
458  if (get_bits1(gb)) {
459  if (get_bits1(gb)) {
460  if (get_bits1(gb)) {
461  av_log(avctx, AV_LOG_ERROR,
462  "broken escape sequence\n");
463  return AVERROR_INVALIDDATA;
464  } else
465  offset += get_bits(gb, frame_len_bits) + 4;
466  } else
467  offset += get_bits(gb, 2) + 1;
468  }
469  }
470  sign = get_bits1(gb) - 1;
471  ptr[offset & coef_mask] = (level ^ sign) - sign;
472  }
473  }
474  /** NOTE: EOB can be omitted */
475  if (offset > num_coefs) {
476  av_log(avctx, AV_LOG_ERROR,
477  "overflow (%d > %d) in spectral RLE, ignoring\n",
478  offset,
479  num_coefs
480  );
481  return AVERROR_INVALIDDATA;
482  }
483 
484  return 0;
485 }
level
uint8_t level
Definition: svq3.c:205
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
ff_sine_windows
SINETABLE_CONST float *const ff_sine_windows[]
Definition: sinewin_tablegen.h:51
coef_vlcs
static const CoefVLCTable coef_vlcs[6]
Definition: wmadata.h:1371
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1050
wma_freqs.h
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:421
exponent_band_32000
static const uint8_t exponent_band_32000[3][25]
Definition: wmadata.h:42
BLOCK_MIN_BITS
#define BLOCK_MIN_BITS
Definition: wma.h:34
b
#define b
Definition: input.c:41
table
static const uint16_t table[]
Definition: prosumer.c:203
CoefVLCTable::n
int n
total number of codes
Definition: wma.h:61
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
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:313
VLCBITS
#define VLCBITS
Definition: wma.h:55
CoefVLCTable::huffbits
const uint8_t * huffbits
VLC bit size.
Definition: wma.h:64
VLCMAX
#define VLCMAX
Definition: wma.h:56
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:335
init_coef_vlc
static av_cold int init_coef_vlc(VLC *vlc, uint16_t **prun_table, float **plevel_table, uint16_t **pint_table, const CoefVLCTable *vlc_table)
Definition: wma.c:34
CoefVLCTable
Definition: wma.h:60
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:454
WMACoef
float WMACoef
type for decoded coefficients, int16_t would be enough for wma 1/2
Definition: wma.h:58
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:1065
GetBitContext
Definition: get_bits.h:108
WMACodecContext
Definition: wma.h:68
AV_CODEC_ID_WMAV1
@ AV_CODEC_ID_WMAV1
Definition: codec_id.h:447
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
wma_common.h
float
float
Definition: af_crystalizer.c:121
s
#define s(width, name)
Definition: cbs_vp9.c:198
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
channels
channels
Definition: aptx.h:31
ff_wma_critical_freqs
const uint16_t ff_wma_critical_freqs[25]
Definition: wma_freqs.c:23
wma.h
ff_wma_total_gain_to_bits
int ff_wma_total_gain_to_bits(int total_gain)
Definition: wma.c:353
CoefVLCTable::huffcodes
const uint32_t * huffcodes
VLC bit values.
Definition: wma.h:63
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:495
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:388
seed
static unsigned int seed
Definition: videogen.c:78
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
ff_wma_end
int ff_wma_end(AVCodecContext *avctx)
Definition: wma.c:367
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:28
bps
unsigned bps
Definition: movenc.c:1852
VLCElem
Definition: vlc.h:32
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
sinewin.h
offset
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 offset
Definition: writing_filters.txt:86
attributes.h
version
version
Definition: libkvazaar.c:321
av_tx_uninit
av_cold void av_tx_uninit(AVTXContext **ctx)
Frees a context and sets *ctx to NULL, does nothing when *ctx == NULL.
Definition: tx.c:295
AVCodec::id
enum AVCodecID id
Definition: codec.h:201
wmadata.h
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
exponent_band_44100
static const uint8_t exponent_band_44100[3][25]
Definition: wmadata.h:48
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
MIN_CACHE_BITS
#define MIN_CACHE_BITS
Definition: get_bits.h:169
avcodec.h
ff_vlc_free
void ff_vlc_free(VLC *vlc)
Definition: vlc.c:580
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:1083
pos
unsigned int pos
Definition: spdifenc.c:414
AVCodecContext
main external API structure.
Definition: avcodec.h:445
ff_wma_get_frame_len_bits
av_cold int ff_wma_get_frame_len_bits(int sample_rate, int version, unsigned int decode_flags)
Get the samples per frame for this stream.
Definition: wma_common.c:32
VLC
Definition: vlc.h:36
ff_init_ff_sine_windows
void ff_init_ff_sine_windows(int index)
initialize the specified entry of ff_sine_windows
Definition: sinewin_tablegen.h:101
mem.h
AV_CODEC_FLAG_BITEXACT
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:342
ff_tlog
#define ff_tlog(ctx,...)
Definition: internal.h:141
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
avpriv_float_dsp_alloc
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:135
exponent_band_22050
static const uint8_t exponent_band_22050[3][25]
Definition: wmadata.h:35
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
CoefVLCTable::levels
const uint16_t * levels
table to build run/level tables
Definition: wma.h:65
ff_wma_get_large_val
unsigned int ff_wma_get_large_val(GetBitContext *gb)
Decode an uncompressed coefficient.
Definition: wma.c:395
int
int
Definition: ffmpeg_filter.c:424
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26