Libav
wmaenc.c
Go to the documentation of this file.
1 /*
2  * WMA compatible encoder
3  * Copyright (c) 2007 Michael Niedermayer
4  *
5  * This file is part of Libav.
6  *
7  * Libav 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  * Libav 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 Libav; 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 
24 #include "avcodec.h"
25 #include "internal.h"
26 #include "wma.h"
27 
28 #undef NDEBUG
29 #include <assert.h>
30 
31 
33 {
34  WMACodecContext *s = avctx->priv_data;
35  int i, flags1, flags2, block_align;
36  uint8_t *extradata;
37 
38  s->avctx = avctx;
39 
40  if (avctx->channels > MAX_CHANNELS) {
41  av_log(avctx, AV_LOG_ERROR,
42  "too many channels: got %i, need %i or fewer",
43  avctx->channels, MAX_CHANNELS);
44  return AVERROR(EINVAL);
45  }
46 
47  if (avctx->sample_rate > 48000) {
48  av_log(avctx, AV_LOG_ERROR, "sample rate is too high: %d > 48kHz",
49  avctx->sample_rate);
50  return AVERROR(EINVAL);
51  }
52 
53  if (avctx->bit_rate < 24 * 1000) {
54  av_log(avctx, AV_LOG_ERROR,
55  "bitrate too low: got %i, need 24000 or higher\n",
56  avctx->bit_rate);
57  return AVERROR(EINVAL);
58  }
59 
60  /* extract flag info */
61  flags1 = 0;
62  flags2 = 1;
63  if (avctx->codec->id == AV_CODEC_ID_WMAV1) {
64  extradata = av_malloc(4);
65  if (!extradata)
66  return AVERROR(ENOMEM);
67  avctx->extradata_size = 4;
68  AV_WL16(extradata, flags1);
69  AV_WL16(extradata + 2, flags2);
70  } else if (avctx->codec->id == AV_CODEC_ID_WMAV2) {
71  extradata = av_mallocz(10);
72  if (!extradata)
73  return AVERROR(ENOMEM);
74  avctx->extradata_size = 10;
75  AV_WL32(extradata, flags1);
76  AV_WL16(extradata + 4, flags2);
77  } else {
78  assert(0);
79  }
80  avctx->extradata = extradata;
81  s->use_exp_vlc = flags2 & 0x0001;
82  s->use_bit_reservoir = flags2 & 0x0002;
83  s->use_variable_block_len = flags2 & 0x0004;
84  if (avctx->channels == 2)
85  s->ms_stereo = 1;
86 
87  ff_wma_init(avctx, flags2);
88 
89  /* init MDCT */
90  for (i = 0; i < s->nb_block_sizes; i++)
91  ff_mdct_init(&s->mdct_ctx[i], s->frame_len_bits - i + 1, 0, 1.0);
92 
93  block_align = avctx->bit_rate * (int64_t) s->frame_len /
94  (avctx->sample_rate * 8);
95  block_align = FFMIN(block_align, MAX_CODED_SUPERFRAME_SIZE);
96  avctx->block_align = block_align;
97  avctx->bit_rate = avctx->block_align * 8LL * avctx->sample_rate /
98  s->frame_len;
99  avctx->frame_size = avctx->initial_padding = s->frame_len;
100 
101  return 0;
102 }
103 
104 static void apply_window_and_mdct(AVCodecContext *avctx, const AVFrame *frame)
105 {
106  WMACodecContext *s = avctx->priv_data;
107  float **audio = (float **) frame->extended_data;
108  int len = frame->nb_samples;
109  int window_index = s->frame_len_bits - s->block_len_bits;
110  FFTContext *mdct = &s->mdct_ctx[window_index];
111  int ch;
112  const float *win = s->windows[window_index];
113  int window_len = 1 << s->block_len_bits;
114  float n = 2.0 * 32768.0 / window_len;
115 
116  for (ch = 0; ch < avctx->channels; ch++) {
117  memcpy(s->output, s->frame_out[ch], window_len * sizeof(*s->output));
118  s->fdsp.vector_fmul_scalar(s->frame_out[ch], audio[ch], n, len);
119  s->fdsp.vector_fmul_reverse(&s->output[window_len], s->frame_out[ch],
120  win, len);
121  s->fdsp.vector_fmul(s->frame_out[ch], s->frame_out[ch], win, len);
122  mdct->mdct_calc(mdct, s->coefs[ch], s->output);
123  }
124 }
125 
126 // FIXME use for decoding too
127 static void init_exp(WMACodecContext *s, int ch, const int *exp_param)
128 {
129  int n;
130  const uint16_t *ptr;
131  float v, *q, max_scale, *q_end;
132 
133  ptr = s->exponent_bands[s->frame_len_bits - s->block_len_bits];
134  q = s->exponents[ch];
135  q_end = q + s->block_len;
136  max_scale = 0;
137  while (q < q_end) {
138  /* XXX: use a table */
139  v = pow(10, *exp_param++ *(1.0 / 16.0));
140  max_scale = FFMAX(max_scale, v);
141  n = *ptr++;
142  do {
143  *q++ = v;
144  } while (--n);
145  }
146  s->max_exponent[ch] = max_scale;
147 }
148 
149 static void encode_exp_vlc(WMACodecContext *s, int ch, const int *exp_param)
150 {
151  int last_exp;
152  const uint16_t *ptr;
153  float *q, *q_end;
154 
155  ptr = s->exponent_bands[s->frame_len_bits - s->block_len_bits];
156  q = s->exponents[ch];
157  q_end = q + s->block_len;
158  if (s->version == 1) {
159  last_exp = *exp_param++;
160  assert(last_exp - 10 >= 0 && last_exp - 10 < 32);
161  put_bits(&s->pb, 5, last_exp - 10);
162  q += *ptr++;
163  } else
164  last_exp = 36;
165  while (q < q_end) {
166  int exp = *exp_param++;
167  int code = exp - last_exp + 60;
168  assert(code >= 0 && code < 120);
171  /* XXX: use a table */
172  q += *ptr++;
173  last_exp = exp;
174  }
175 }
176 
177 static int encode_block(WMACodecContext *s, float (*src_coefs)[BLOCK_MAX_SIZE],
178  int total_gain)
179 {
180  int v, bsize, ch, coef_nb_bits, parse_exponents;
181  float mdct_norm;
182  int nb_coefs[MAX_CHANNELS];
183  static const int fixed_exp[25] = {
184  20, 20, 20, 20, 20,
185  20, 20, 20, 20, 20,
186  20, 20, 20, 20, 20,
187  20, 20, 20, 20, 20,
188  20, 20, 20, 20, 20
189  };
190 
191  // FIXME remove duplication relative to decoder
192  if (s->use_variable_block_len) {
193  assert(0); // FIXME not implemented
194  } else {
195  /* fixed block len */
199  }
200 
201  s->block_len = 1 << s->block_len_bits;
202 // assert((s->block_pos + s->block_len) <= s->frame_len);
203  bsize = s->frame_len_bits - s->block_len_bits;
204 
205  // FIXME factor
206  v = s->coefs_end[bsize] - s->coefs_start;
207  for (ch = 0; ch < s->avctx->channels; ch++)
208  nb_coefs[ch] = v;
209  {
210  int n4 = s->block_len / 2;
211  mdct_norm = 1.0 / (float) n4;
212  if (s->version == 1)
213  mdct_norm *= sqrt(n4);
214  }
215 
216  if (s->avctx->channels == 2)
217  put_bits(&s->pb, 1, !!s->ms_stereo);
218 
219  for (ch = 0; ch < s->avctx->channels; ch++) {
220  // FIXME only set channel_coded when needed, instead of always
221  s->channel_coded[ch] = 1;
222  if (s->channel_coded[ch])
223  init_exp(s, ch, fixed_exp);
224  }
225 
226  for (ch = 0; ch < s->avctx->channels; ch++) {
227  if (s->channel_coded[ch]) {
228  WMACoef *coefs1;
229  float *coefs, *exponents, mult;
230  int i, n;
231 
232  coefs1 = s->coefs1[ch];
233  exponents = s->exponents[ch];
234  mult = pow(10, total_gain * 0.05) / s->max_exponent[ch];
235  mult *= mdct_norm;
236  coefs = src_coefs[ch];
237  if (s->use_noise_coding && 0) {
238  assert(0); // FIXME not implemented
239  } else {
240  coefs += s->coefs_start;
241  n = nb_coefs[ch];
242  for (i = 0; i < n; i++) {
243  double t = *coefs++ / (exponents[i] * mult);
244  if (t < -32768 || t > 32767)
245  return -1;
246 
247  coefs1[i] = lrint(t);
248  }
249  }
250  }
251  }
252 
253  v = 0;
254  for (ch = 0; ch < s->avctx->channels; ch++) {
255  int a = s->channel_coded[ch];
256  put_bits(&s->pb, 1, a);
257  v |= a;
258  }
259 
260  if (!v)
261  return 1;
262 
263  for (v = total_gain - 1; v >= 127; v -= 127)
264  put_bits(&s->pb, 7, 127);
265  put_bits(&s->pb, 7, v);
266 
267  coef_nb_bits = ff_wma_total_gain_to_bits(total_gain);
268 
269  if (s->use_noise_coding) {
270  for (ch = 0; ch < s->avctx->channels; ch++) {
271  if (s->channel_coded[ch]) {
272  int i, n;
273  n = s->exponent_high_sizes[bsize];
274  for (i = 0; i < n; i++) {
275  put_bits(&s->pb, 1, s->high_band_coded[ch][i] = 0);
276  if (0)
277  nb_coefs[ch] -= s->exponent_high_bands[bsize][i];
278  }
279  }
280  }
281  }
282 
283  parse_exponents = 1;
284  if (s->block_len_bits != s->frame_len_bits)
285  put_bits(&s->pb, 1, parse_exponents);
286 
287  if (parse_exponents) {
288  for (ch = 0; ch < s->avctx->channels; ch++) {
289  if (s->channel_coded[ch]) {
290  if (s->use_exp_vlc) {
291  encode_exp_vlc(s, ch, fixed_exp);
292  } else {
293  assert(0); // FIXME not implemented
294 // encode_exp_lsp(s, ch);
295  }
296  }
297  }
298  } else
299  assert(0); // FIXME not implemented
300 
301  for (ch = 0; ch < s->avctx->channels; ch++) {
302  if (s->channel_coded[ch]) {
303  int run, tindex;
304  WMACoef *ptr, *eptr;
305  tindex = (ch == 1 && s->ms_stereo);
306  ptr = &s->coefs1[ch][0];
307  eptr = ptr + nb_coefs[ch];
308 
309  run = 0;
310  for (; ptr < eptr; ptr++) {
311  if (*ptr) {
312  int level = *ptr;
313  int abs_level = FFABS(level);
314  int code = 0;
315  if (abs_level <= s->coef_vlcs[tindex]->max_level)
316  if (run < s->coef_vlcs[tindex]->levels[abs_level - 1])
317  code = run + s->int_table[tindex][abs_level - 1];
318 
319  assert(code < s->coef_vlcs[tindex]->n);
320  put_bits(&s->pb, s->coef_vlcs[tindex]->huffbits[code],
321  s->coef_vlcs[tindex]->huffcodes[code]);
322 
323  if (code == 0) {
324  if (1 << coef_nb_bits <= abs_level)
325  return -1;
326 
327  put_bits(&s->pb, coef_nb_bits, abs_level);
328  put_bits(&s->pb, s->frame_len_bits, run);
329  }
330  // FIXME the sign is flipped somewhere
331  put_bits(&s->pb, 1, level < 0);
332  run = 0;
333  } else
334  run++;
335  }
336  if (run)
337  put_bits(&s->pb, s->coef_vlcs[tindex]->huffbits[1],
338  s->coef_vlcs[tindex]->huffcodes[1]);
339  }
340  if (s->version == 1 && s->avctx->channels >= 2)
342  }
343  return 0;
344 }
345 
346 static int encode_frame(WMACodecContext *s, float (*src_coefs)[BLOCK_MAX_SIZE],
347  uint8_t *buf, int buf_size, int total_gain)
348 {
349  init_put_bits(&s->pb, buf, buf_size);
350 
351  if (s->use_bit_reservoir)
352  assert(0); // FIXME not implemented
353  else if (encode_block(s, src_coefs, total_gain) < 0)
354  return INT_MAX;
355 
357 
358  return put_bits_count(&s->pb) / 8 - s->avctx->block_align;
359 }
360 
361 static int encode_superframe(AVCodecContext *avctx, AVPacket *avpkt,
362  const AVFrame *frame, int *got_packet_ptr)
363 {
364  WMACodecContext *s = avctx->priv_data;
365  int i, total_gain, ret;
366 
367  s->block_len_bits = s->frame_len_bits; // required by non variable block len
368  s->block_len = 1 << s->block_len_bits;
369 
370  apply_window_and_mdct(avctx, frame);
371 
372  if (s->ms_stereo) {
373  float a, b;
374  int i;
375 
376  for (i = 0; i < s->block_len; i++) {
377  a = s->coefs[0][i] * 0.5;
378  b = s->coefs[1][i] * 0.5;
379  s->coefs[0][i] = a + b;
380  s->coefs[1][i] = a - b;
381  }
382  }
383 
384  if ((ret = ff_alloc_packet(avpkt, 2 * MAX_CODED_SUPERFRAME_SIZE))) {
385  av_log(avctx, AV_LOG_ERROR, "Error getting output packet\n");
386  return ret;
387  }
388 
389  total_gain = 128;
390  for (i = 64; i; i >>= 1) {
391  int error = encode_frame(s, s->coefs, avpkt->data, avpkt->size,
392  total_gain - i);
393  if (error < 0)
394  total_gain -= i;
395  }
396 
397  if ((i = encode_frame(s, s->coefs, avpkt->data, avpkt->size, total_gain)) >= 0) {
398  av_log(avctx, AV_LOG_ERROR, "required frame size too large. please "
399  "use a higher bit rate.\n");
400  return AVERROR(EINVAL);
401  }
402  assert((put_bits_count(&s->pb) & 7) == 0);
403  while (i++)
404  put_bits(&s->pb, 8, 'N');
405 
406  flush_put_bits(&s->pb);
407 
408  if (frame->pts != AV_NOPTS_VALUE)
409  avpkt->pts = frame->pts - ff_samples_to_time_base(avctx, avctx->initial_padding);
410 
411  avpkt->size = avctx->block_align;
412  *got_packet_ptr = 1;
413  return 0;
414 }
415 
417  .name = "wmav1",
418  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 1"),
419  .type = AVMEDIA_TYPE_AUDIO,
420  .id = AV_CODEC_ID_WMAV1,
421  .priv_data_size = sizeof(WMACodecContext),
422  .init = encode_init,
423  .encode2 = encode_superframe,
424  .close = ff_wma_end,
425  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
427 };
428 
430  .name = "wmav2",
431  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 2"),
432  .type = AVMEDIA_TYPE_AUDIO,
433  .id = AV_CODEC_ID_WMAV2,
434  .priv_data_size = sizeof(WMACodecContext),
435  .init = encode_init,
436  .encode2 = encode_superframe,
437  .close = ff_wma_end,
438  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
440 };
float, planar
Definition: samplefmt.h:71
const struct AVCodec * codec
Definition: avcodec.h:1418
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:62
static int encode_superframe(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Definition: wmaenc.c:361
This structure describes decoded (raw) audio or video data.
Definition: frame.h:140
int next_block_len_bits
log2 of next block length
Definition: wma.h:105
#define BLOCK_MAX_SIZE
Definition: wma.h:35
int size
Definition: avcodec.h:1347
av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (%s)\, len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic ? ac->func_descr_generic :ac->func_descr)
void avpriv_align_put_bits(PutBitContext *s)
Pad the bitstream with zeros up to the next byte boundary.
Definition: bitstream.c:46
int block_len
block length in samples
Definition: wma.h:107
const uint8_t * huffbits
VLC bit size.
Definition: wma.h:63
uint8_t run
Definition: svq3.c:203
float exponents[MAX_CHANNELS][BLOCK_MAX_SIZE]
Definition: wma.h:113
AVCodec.
Definition: avcodec.h:3120
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs...
Definition: avcodec.h:2189
Macro definitions for various function/variable attributes.
uint8_t
#define av_cold
Definition: attributes.h:66
float WMACoef
type for decoded coefficients, int16_t would be enough for wma 1/2
Definition: wma.h:57
void(* vector_fmul)(float *dst, const float *src0, const float *src1, int len)
Calculate the product of two vectors of floats and store the result in a vector of floats...
Definition: float_dsp.h:38
#define b
Definition: input.c:52
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:211
const uint8_t ff_aac_scalefactor_bits[121]
Definition: aactab.c:78
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1523
const uint32_t * huffcodes
VLC bit values.
Definition: wma.h:62
uint8_t * data
Definition: avcodec.h:1346
static int encode_frame(WMACodecContext *s, float(*src_coefs)[BLOCK_MAX_SIZE], uint8_t *buf, int buf_size, int total_gain)
Definition: wmaenc.c:346
#define AV_WL16(p, val)
Definition: intreadwrite.h:231
int nb_block_sizes
number of block sizes
Definition: wma.h:101
int ff_wma_total_gain_to_bits(int total_gain)
Definition: wma.c:347
uint16_t * int_table[2]
Definition: wma.h:96
enum AVCodecID id
Definition: avcodec.h:3134
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:124
static void encode_exp_vlc(WMACodecContext *s, int ch, const int *exp_param)
Definition: wmaenc.c:149
#define AVERROR(e)
Definition: error.h:43
uint16_t exponent_bands[BLOCK_NB_SIZES][25]
Definition: wma.h:79
uint8_t channel_coded[MAX_CHANNELS]
true if channel is coded
Definition: wma.h:111
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:148
static void apply_window_and_mdct(AVCodecContext *avctx, const AVFrame *frame)
Definition: wmaenc.c:104
int initial_padding
Audio only.
Definition: avcodec.h:3054
AVFloatDSPContext fdsp
Definition: wma.h:134
const char * name
Name of the codec implementation.
Definition: avcodec.h:3127
static void put_bits(PutBitContext *s, int n, unsigned int value)
Write up to 31 bits into a bitstream.
Definition: put_bits.h:134
FFTSample output[BLOCK_MAX_SIZE *2]
Definition: wma.h:117
#define ff_mdct_init
Definition: fft.h:151
#define FFMAX(a, b)
Definition: common.h:64
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:67
int exponent_high_bands[BLOCK_NB_SIZES][HIGH_BAND_MAX_SIZE]
Definition: wma.h:84
int ff_wma_end(AVCodecContext *avctx)
Definition: wma.c:361
Definition: fft.h:73
int bit_rate
the average bitrate
Definition: avcodec.h:1473
#define FFMIN(a, b)
Definition: common.h:66
int use_bit_reservoir
Definition: wma.h:72
float * windows[BLOCK_NB_SIZES]
Definition: wma.h:119
#define MAX_CODED_SUPERFRAME_SIZE
Definition: wma.h:45
av_cold int ff_wma_init(AVCodecContext *avctx, int flags2)
Definition: wma.c:81
#define FFABS(a)
Definition: common.h:61
int version
1 = 0x160 (WMAV1), 2 = 0x161 (WMAV2)
Definition: wma.h:71
int ff_alloc_packet(AVPacket *avpkt, int size)
Check AVPacket size and/or allocate data.
Definition: utils.c:1211
int frame_len
frame length in samples
Definition: wma.h:99
static void init_exp(WMACodecContext *s, int ch, const int *exp_param)
Definition: wmaenc.c:127
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:2172
int frame_len_bits
frame_len = 1 << frame_len_bits
Definition: wma.h:100
Libavcodec external API header.
AVSampleFormat
Audio Sample Formats.
Definition: samplefmt.h:60
int sample_rate
samples per second
Definition: avcodec.h:2152
int use_exp_vlc
exponent coding: 0 = lsp, 1 = vlc + delta
Definition: wma.h:74
main external API structure.
Definition: avcodec.h:1409
AVCodecContext * avctx
Definition: wma.h:68
float frame_out[MAX_CHANNELS][BLOCK_MAX_SIZE *2]
Definition: wma.h:121
static int16_t mult(Float11 *f1, Float11 *f2)
Definition: g726.c:55
int extradata_size
Definition: avcodec.h:1524
int exponent_high_sizes[BLOCK_NB_SIZES]
Definition: wma.h:83
int use_noise_coding
true if perceptual noise is added
Definition: wma.h:75
void(* vector_fmul_scalar)(float *dst, const float *src, float mul, int len)
Multiply a vector of floats by a scalar float.
Definition: float_dsp.h:69
AVCodec ff_wmav1_encoder
Definition: wmaenc.c:416
static av_always_inline av_const long int lrint(double x)
Definition: libm.h:137
#define MAX_CHANNELS
Definition: aac.h:42
int use_variable_block_len
Definition: wma.h:73
uint8_t ms_stereo
true if mid/side stereo mode
Definition: wma.h:110
static av_cold int encode_init(AVCodecContext *avctx)
Definition: wmaenc.c:32
FFTContext mdct_ctx[BLOCK_NB_SIZES]
Definition: wma.h:118
const uint32_t ff_aac_scalefactor_code[121]
Definition: aactab.c:59
AVCodec ff_wmav2_encoder
Definition: wmaenc.c:429
float coefs[MAX_CHANNELS][BLOCK_MAX_SIZE]
Definition: wma.h:116
uint8_t level
Definition: svq3.c:204
int prev_block_len_bits
log2 of prev block length
Definition: wma.h:106
static int encode_block(WMACodecContext *s, float(*src_coefs)[BLOCK_MAX_SIZE], int total_gain)
Definition: wmaenc.c:177
int coefs_end[BLOCK_NB_SIZES]
max number of coded coefficients
Definition: wma.h:82
common internal api header.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:83
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:48
static av_cold int init(AVCodecParserContext *s)
Definition: h264_parser.c:582
void * priv_data
Definition: avcodec.h:1451
int len
int channels
number of audio channels
Definition: avcodec.h:2153
WMACoef coefs1[MAX_CHANNELS][BLOCK_MAX_SIZE]
Definition: wma.h:115
#define AV_WL32(p, val)
Definition: intreadwrite.h:263
static const CoefVLCTable coef_vlcs[6]
Definition: wmadata.h:1375
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:700
float max_exponent[MAX_CHANNELS]
Definition: wma.h:114
int coefs_start
first coded coef
Definition: wma.h:81
static av_always_inline int64_t ff_samples_to_time_base(AVCodecContext *avctx, int64_t samples)
Rescale from sample rate to AVCodecContext.time_base.
Definition: internal.h:202
int block_len_bits
log2 of current block length
Definition: wma.h:104
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:174
This structure stores compressed data.
Definition: avcodec.h:1323
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:184
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:211
int high_band_coded[MAX_CHANNELS][HIGH_BAND_MAX_SIZE]
Definition: wma.h:88
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1339
for(j=16;j >0;--j)
const CoefVLCTable * coef_vlcs[2]
Definition: wma.h:97
PutBitContext pb
Definition: wma.h:70
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:235
void(* vector_fmul_reverse)(float *dst, const float *src0, const float *src1, int len)
Calculate the product of two vectors of floats, and store the result in a vector of floats...
Definition: float_dsp.h:138