FFmpeg
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 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/ffmath.h"
24 
25 #include "avcodec.h"
26 #include "encode.h"
27 #include "internal.h"
28 #include "wma.h"
29 #include "libavutil/avassert.h"
30 
31 
33 {
34  WMACodecContext *s = avctx->priv_data;
35  int i, flags1, flags2, block_align;
36  uint8_t *extradata;
37  int ret;
38 
39  s->avctx = avctx;
40 
41  if (avctx->channels > MAX_CHANNELS) {
42  av_log(avctx, AV_LOG_ERROR,
43  "too many channels: got %i, need %i or fewer\n",
44  avctx->channels, MAX_CHANNELS);
45  return AVERROR(EINVAL);
46  }
47 
48  if (avctx->sample_rate > 48000) {
49  av_log(avctx, AV_LOG_ERROR, "sample rate is too high: %d > 48kHz\n",
50  avctx->sample_rate);
51  return AVERROR(EINVAL);
52  }
53 
54  if (avctx->bit_rate < 24 * 1000) {
55  av_log(avctx, AV_LOG_ERROR,
56  "bitrate too low: got %"PRId64", need 24000 or higher\n",
57  avctx->bit_rate);
58  return AVERROR(EINVAL);
59  }
60 
61  /* extract flag info */
62  flags1 = 0;
63  flags2 = 1;
64  if (avctx->codec->id == AV_CODEC_ID_WMAV1) {
65  extradata = av_malloc(4);
66  if (!extradata)
67  return AVERROR(ENOMEM);
68  avctx->extradata_size = 4;
69  AV_WL16(extradata, flags1);
70  AV_WL16(extradata + 2, flags2);
71  } else if (avctx->codec->id == AV_CODEC_ID_WMAV2) {
72  extradata = av_mallocz(10);
73  if (!extradata)
74  return AVERROR(ENOMEM);
75  avctx->extradata_size = 10;
76  AV_WL32(extradata, flags1);
77  AV_WL16(extradata + 4, flags2);
78  } else {
79  av_assert0(0);
80  }
81  avctx->extradata = extradata;
82  s->use_exp_vlc = flags2 & 0x0001;
83  s->use_bit_reservoir = flags2 & 0x0002;
84  s->use_variable_block_len = flags2 & 0x0004;
85  if (avctx->channels == 2)
86  s->ms_stereo = 1;
87 
88  if ((ret = ff_wma_init(avctx, flags2)) < 0)
89  return ret;
90 
91  /* init MDCT */
92  for (i = 0; i < s->nb_block_sizes; i++) {
93  ret = ff_mdct_init(&s->mdct_ctx[i], s->frame_len_bits - i + 1, 0, 1.0);
94  if (ret < 0)
95  return ret;
96  }
97 
98  block_align = avctx->bit_rate * (int64_t) s->frame_len /
99  (avctx->sample_rate * 8);
100  block_align = FFMIN(block_align, MAX_CODED_SUPERFRAME_SIZE);
101  avctx->block_align = block_align;
102  avctx->frame_size = avctx->initial_padding = s->frame_len;
103 
104  return 0;
105 }
106 
108 {
109  WMACodecContext *s = avctx->priv_data;
110  float **audio = (float **) frame->extended_data;
111  int len = frame->nb_samples;
112  int window_index = s->frame_len_bits - s->block_len_bits;
113  FFTContext *mdct = &s->mdct_ctx[window_index];
114  int ch;
115  const float *win = s->windows[window_index];
116  int window_len = 1 << s->block_len_bits;
117  float n = 2.0 * 32768.0 / window_len;
118 
119  for (ch = 0; ch < avctx->channels; ch++) {
120  memcpy(s->output, s->frame_out[ch], window_len * sizeof(*s->output));
121  s->fdsp->vector_fmul_scalar(s->frame_out[ch], audio[ch], n, len);
122  s->fdsp->vector_fmul_reverse(&s->output[window_len], s->frame_out[ch],
123  win, len);
124  s->fdsp->vector_fmul(s->frame_out[ch], s->frame_out[ch], win, len);
125  mdct->mdct_calc(mdct, s->coefs[ch], s->output);
126  if (!isfinite(s->coefs[ch][0])) {
127  av_log(avctx, AV_LOG_ERROR, "Input contains NaN/+-Inf\n");
128  return AVERROR(EINVAL);
129  }
130  }
131 
132  return 0;
133 }
134 
135 // FIXME use for decoding too
136 static void init_exp(WMACodecContext *s, int ch, const int *exp_param)
137 {
138  int n;
139  const uint16_t *ptr;
140  float v, *q, max_scale, *q_end;
141 
142  ptr = s->exponent_bands[s->frame_len_bits - s->block_len_bits];
143  q = s->exponents[ch];
144  q_end = q + s->block_len;
145  max_scale = 0;
146  while (q < q_end) {
147  /* XXX: use a table */
148  v = ff_exp10(*exp_param++ *(1.0 / 16.0));
149  max_scale = FFMAX(max_scale, v);
150  n = *ptr++;
151  do {
152  *q++ = v;
153  } while (--n);
154  }
155  s->max_exponent[ch] = max_scale;
156 }
157 
158 static void encode_exp_vlc(WMACodecContext *s, int ch, const int *exp_param)
159 {
160  int last_exp;
161  const uint16_t *ptr;
162  float *q, *q_end;
163 
164  ptr = s->exponent_bands[s->frame_len_bits - s->block_len_bits];
165  q = s->exponents[ch];
166  q_end = q + s->block_len;
167  if (s->version == 1) {
168  last_exp = *exp_param++;
169  av_assert0(last_exp - 10 >= 0 && last_exp - 10 < 32);
170  put_bits(&s->pb, 5, last_exp - 10);
171  q += *ptr++;
172  } else
173  last_exp = 36;
174  while (q < q_end) {
175  int exp = *exp_param++;
176  int code = exp - last_exp + 60;
177  av_assert1(code >= 0 && code < 120);
180  /* XXX: use a table */
181  q += *ptr++;
182  last_exp = exp;
183  }
184 }
185 
186 static int encode_block(WMACodecContext *s, float (*src_coefs)[BLOCK_MAX_SIZE],
187  int total_gain)
188 {
189  int v, bsize, ch, coef_nb_bits, parse_exponents;
190  float mdct_norm;
191  int nb_coefs[MAX_CHANNELS];
192  static const int fixed_exp[25] = {
193  20, 20, 20, 20, 20,
194  20, 20, 20, 20, 20,
195  20, 20, 20, 20, 20,
196  20, 20, 20, 20, 20,
197  20, 20, 20, 20, 20
198  };
199 
200  // FIXME remove duplication relative to decoder
201  if (s->use_variable_block_len) {
202  av_assert0(0); // FIXME not implemented
203  } else {
204  /* fixed block len */
205  s->next_block_len_bits = s->frame_len_bits;
206  s->prev_block_len_bits = s->frame_len_bits;
207  s->block_len_bits = s->frame_len_bits;
208  }
209 
210  s->block_len = 1 << s->block_len_bits;
211 // av_assert0((s->block_pos + s->block_len) <= s->frame_len);
212  bsize = s->frame_len_bits - s->block_len_bits;
213 
214  // FIXME factor
215  v = s->coefs_end[bsize] - s->coefs_start;
216  for (ch = 0; ch < s->avctx->channels; ch++)
217  nb_coefs[ch] = v;
218  {
219  int n4 = s->block_len / 2;
220  mdct_norm = 1.0 / (float) n4;
221  if (s->version == 1)
222  mdct_norm *= sqrt(n4);
223  }
224 
225  if (s->avctx->channels == 2)
226  put_bits(&s->pb, 1, !!s->ms_stereo);
227 
228  for (ch = 0; ch < s->avctx->channels; ch++) {
229  // FIXME only set channel_coded when needed, instead of always
230  s->channel_coded[ch] = 1;
231  if (s->channel_coded[ch])
232  init_exp(s, ch, fixed_exp);
233  }
234 
235  for (ch = 0; ch < s->avctx->channels; ch++) {
236  if (s->channel_coded[ch]) {
237  WMACoef *coefs1;
238  float *coefs, *exponents, mult;
239  int i, n;
240 
241  coefs1 = s->coefs1[ch];
242  exponents = s->exponents[ch];
243  mult = ff_exp10(total_gain * 0.05) / s->max_exponent[ch];
244  mult *= mdct_norm;
245  coefs = src_coefs[ch];
246  if (s->use_noise_coding && 0) {
247  av_assert0(0); // FIXME not implemented
248  } else {
249  coefs += s->coefs_start;
250  n = nb_coefs[ch];
251  for (i = 0; i < n; i++) {
252  double t = *coefs++ / (exponents[i] * mult);
253  if (t < -32768 || t > 32767)
254  return -1;
255 
256  coefs1[i] = lrint(t);
257  }
258  }
259  }
260  }
261 
262  v = 0;
263  for (ch = 0; ch < s->avctx->channels; ch++) {
264  int a = s->channel_coded[ch];
265  put_bits(&s->pb, 1, a);
266  v |= a;
267  }
268 
269  if (!v)
270  return 1;
271 
272  for (v = total_gain - 1; v >= 127; v -= 127)
273  put_bits(&s->pb, 7, 127);
274  put_bits(&s->pb, 7, v);
275 
276  coef_nb_bits = ff_wma_total_gain_to_bits(total_gain);
277 
278  if (s->use_noise_coding) {
279  for (ch = 0; ch < s->avctx->channels; ch++) {
280  if (s->channel_coded[ch]) {
281  int i, n;
282  n = s->exponent_high_sizes[bsize];
283  for (i = 0; i < n; i++) {
284  put_bits(&s->pb, 1, s->high_band_coded[ch][i] = 0);
285  if (0)
286  nb_coefs[ch] -= s->exponent_high_bands[bsize][i];
287  }
288  }
289  }
290  }
291 
292  parse_exponents = 1;
293  if (s->block_len_bits != s->frame_len_bits)
294  put_bits(&s->pb, 1, parse_exponents);
295 
296  if (parse_exponents) {
297  for (ch = 0; ch < s->avctx->channels; ch++) {
298  if (s->channel_coded[ch]) {
299  if (s->use_exp_vlc) {
300  encode_exp_vlc(s, ch, fixed_exp);
301  } else {
302  av_assert0(0); // FIXME not implemented
303 // encode_exp_lsp(s, ch);
304  }
305  }
306  }
307  } else
308  av_assert0(0); // FIXME not implemented
309 
310  for (ch = 0; ch < s->avctx->channels; ch++) {
311  if (s->channel_coded[ch]) {
312  int run, tindex;
313  WMACoef *ptr, *eptr;
314  tindex = (ch == 1 && s->ms_stereo);
315  ptr = &s->coefs1[ch][0];
316  eptr = ptr + nb_coefs[ch];
317 
318  run = 0;
319  for (; ptr < eptr; ptr++) {
320  if (*ptr) {
321  int level = *ptr;
322  int abs_level = FFABS(level);
323  int code = 0;
324  if (abs_level <= s->coef_vlcs[tindex]->max_level)
325  if (run < s->coef_vlcs[tindex]->levels[abs_level - 1])
326  code = run + s->int_table[tindex][abs_level - 1];
327 
328  av_assert2(code < s->coef_vlcs[tindex]->n);
329  put_bits(&s->pb, s->coef_vlcs[tindex]->huffbits[code],
330  s->coef_vlcs[tindex]->huffcodes[code]);
331 
332  if (code == 0) {
333  if (1 << coef_nb_bits <= abs_level)
334  return -1;
335 
336  put_bits(&s->pb, coef_nb_bits, abs_level);
337  put_bits(&s->pb, s->frame_len_bits, run);
338  }
339  // FIXME the sign is flipped somewhere
340  put_bits(&s->pb, 1, level < 0);
341  run = 0;
342  } else
343  run++;
344  }
345  if (run)
346  put_bits(&s->pb, s->coef_vlcs[tindex]->huffbits[1],
347  s->coef_vlcs[tindex]->huffcodes[1]);
348  }
349  if (s->version == 1 && s->avctx->channels >= 2)
350  align_put_bits(&s->pb);
351  }
352  return 0;
353 }
354 
355 static int encode_frame(WMACodecContext *s, float (*src_coefs)[BLOCK_MAX_SIZE],
356  uint8_t *buf, int buf_size, int total_gain)
357 {
358  init_put_bits(&s->pb, buf, buf_size);
359 
360  if (s->use_bit_reservoir)
361  av_assert0(0); // FIXME not implemented
362  else if (encode_block(s, src_coefs, total_gain) < 0)
363  return INT_MAX;
364 
365  align_put_bits(&s->pb);
366 
367  return put_bits_count(&s->pb) / 8 - s->avctx->block_align;
368 }
369 
370 static int encode_superframe(AVCodecContext *avctx, AVPacket *avpkt,
371  const AVFrame *frame, int *got_packet_ptr)
372 {
373  WMACodecContext *s = avctx->priv_data;
374  int i, total_gain, ret, error;
375 
376  s->block_len_bits = s->frame_len_bits; // required by non variable block len
377  s->block_len = 1 << s->block_len_bits;
378 
379  ret = apply_window_and_mdct(avctx, frame);
380 
381  if (ret < 0)
382  return ret;
383 
384  if (s->ms_stereo) {
385  float a, b;
386  int i;
387 
388  for (i = 0; i < s->block_len; i++) {
389  a = s->coefs[0][i] * 0.5;
390  b = s->coefs[1][i] * 0.5;
391  s->coefs[0][i] = a + b;
392  s->coefs[1][i] = a - b;
393  }
394  }
395 
396  if ((ret = ff_alloc_packet(avctx, avpkt, 2 * MAX_CODED_SUPERFRAME_SIZE)) < 0)
397  return ret;
398 
399  total_gain = 128;
400  for (i = 64; i; i >>= 1) {
401  error = encode_frame(s, s->coefs, avpkt->data, avpkt->size,
402  total_gain - i);
403  if (error <= 0)
404  total_gain -= i;
405  }
406 
407  while(total_gain <= 128 && error > 0)
408  error = encode_frame(s, s->coefs, avpkt->data, avpkt->size, total_gain++);
409  if (error > 0) {
410  av_log(avctx, AV_LOG_ERROR, "Invalid input data or requested bitrate too low, cannot encode\n");
411  avpkt->size = 0;
412  return AVERROR(EINVAL);
413  }
414  av_assert0((put_bits_count(&s->pb) & 7) == 0);
415  i = avctx->block_align - put_bytes_count(&s->pb, 0);
416  av_assert0(i>=0);
417  while(i--)
418  put_bits(&s->pb, 8, 'N');
419 
420  flush_put_bits(&s->pb);
421  av_assert0(put_bits_ptr(&s->pb) - s->pb.buf == avctx->block_align);
422 
423  if (frame->pts != AV_NOPTS_VALUE)
424  avpkt->pts = frame->pts - ff_samples_to_time_base(avctx, avctx->initial_padding);
425 
426  avpkt->size = avctx->block_align;
427  *got_packet_ptr = 1;
428  return 0;
429 }
430 
431 #if CONFIG_WMAV1_ENCODER
432 const AVCodec ff_wmav1_encoder = {
433  .name = "wmav1",
434  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 1"),
435  .type = AVMEDIA_TYPE_AUDIO,
436  .id = AV_CODEC_ID_WMAV1,
437  .priv_data_size = sizeof(WMACodecContext),
438  .init = encode_init,
439  .encode2 = encode_superframe,
440  .close = ff_wma_end,
441  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
444 };
445 #endif
446 #if CONFIG_WMAV2_ENCODER
447 const AVCodec ff_wmav2_encoder = {
448  .name = "wmav2",
449  .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 2"),
450  .type = AVMEDIA_TYPE_AUDIO,
451  .id = AV_CODEC_ID_WMAV2,
452  .priv_data_size = sizeof(WMACodecContext),
453  .init = encode_init,
454  .encode2 = encode_superframe,
455  .close = ff_wma_end,
456  .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
459 };
460 #endif
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:30
AVCodecContext::frame_size
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1001
AVCodec
AVCodec.
Definition: codec.h:197
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:69
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
ff_exp10
static av_always_inline double ff_exp10(double x)
Compute 10^x for floating point values.
Definition: ffmath.h:42
level
uint8_t level
Definition: svq3.c:204
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
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
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
align_put_bits
static void align_put_bits(PutBitContext *s)
Pad the bitstream with zeros up to the next byte boundary.
Definition: put_bits.h:412
coef_vlcs
static const CoefVLCTable coef_vlcs[6]
Definition: wmadata.h:1371
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:981
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:953
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:61
ff_wmav1_encoder
const AVCodec ff_wmav1_encoder
apply_window_and_mdct
static int apply_window_and_mdct(AVCodecContext *avctx, const AVFrame *frame)
Definition: wmaenc.c:107
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:220
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:365
encode.h
b
#define b
Definition: input.c:41
put_bytes_count
static int put_bytes_count(const PutBitContext *s, int round_up)
Definition: put_bits.h:99
init_exp
static void init_exp(WMACodecContext *s, int ch, const int *exp_param)
Definition: wmaenc.c:136
ff_mdct_init
#define ff_mdct_init
Definition: fft.h:161
AV_CODEC_ID_WMAV2
@ AV_CODEC_ID_WMAV2
Definition: codec_id.h:430
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
win
static float win(SuperEqualizerContext *s, float n, int N)
Definition: af_superequalizer.c:119
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
encode_block
static int encode_block(WMACodecContext *s, float(*src_coefs)[BLOCK_MAX_SIZE], int total_gain)
Definition: wmaenc.c:186
AVCodecContext::initial_padding
int initial_padding
Audio only.
Definition: avcodec.h:1690
WMACodecContext
Definition: wma.h:68
encode_init
static av_cold int encode_init(AVCodecContext *avctx)
Definition: wmaenc.c:32
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
avassert.h
lrint
#define lrint
Definition: tablegen.h:53
ff_samples_to_time_base
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:239
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:181
av_cold
#define av_cold
Definition: attributes.h:90
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:486
s
#define s(width, name)
Definition: cbs_vp9.c:257
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
BLOCK_MAX_SIZE
#define BLOCK_MAX_SIZE
Definition: wma.h:36
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
isfinite
#define isfinite(x)
Definition: libm.h:359
wma.h
ff_wma_total_gain_to_bits
int ff_wma_total_gain_to_bits(int total_gain)
Definition: wma.c:352
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
run
uint8_t run
Definition: svq3.c:203
parse_exponents
static int parse_exponents(DBEContext *s, DBEChannel *c)
Definition: dolby_e.c:653
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:434
encode_superframe
static int encode_superframe(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Definition: wmaenc.c:370
exp
int8_t exp
Definition: eval.c:72
MAX_CODED_SUPERFRAME_SIZE
#define MAX_CODED_SUPERFRAME_SIZE
Definition: wma.h:46
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
ff_wma_end
int ff_wma_end(AVCodecContext *avctx)
Definition: wma.c:366
ff_aac_scalefactor_bits
const uint8_t ff_aac_scalefactor_bits[121]
Definition: aactab.c:111
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
ff_wmav2_encoder
const AVCodec ff_wmav2_encoder
FFMAX
#define FFMAX(a, b)
Definition: common.h:103
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
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
AV_WL16
#define AV_WL16(p, v)
Definition: intreadwrite.h:412
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
FFMIN
#define FFMIN(a, b)
Definition: common.h:105
fixed_exp
static int fixed_exp(int x)
Definition: aacsbr_fixed.c:111
attributes.h
MAX_CHANNELS
#define MAX_CHANNELS
Definition: aac.h:48
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:982
AVCodec::id
enum AVCodecID id
Definition: codec.h:211
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
FFTContext
Definition: fft.h:83
i
int i
Definition: input.c:407
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:358
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
put_bits_count
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:79
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
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:244
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
encode_frame
static int encode_frame(WMACodecContext *s, float(*src_coefs)[BLOCK_MAX_SIZE], uint8_t *buf, int buf_size, int total_gain)
Definition: wmaenc.c:355
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
AVCodecContext
main external API structure.
Definition: avcodec.h:384
put_bits_ptr
static uint8_t * put_bits_ptr(PutBitContext *s)
Return the pointer to the byte where the bitstream writer will put the next bit.
Definition: put_bits.h:369
encode_exp_vlc
static void encode_exp_vlc(WMACodecContext *s, int ch, const int *exp_param)
Definition: wmaenc.c:158
ffmath.h
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:142
AVPacket
This structure stores compressed data.
Definition: packet.h:342
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:411
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
ff_alloc_packet
int ff_alloc_packet(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
Check AVPacket size and allocate data.
Definition: encode.c:33
ff_aac_scalefactor_code
const uint32_t ff_aac_scalefactor_code[121]
Definition: aactab.c:92