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 "config_components.h"
23 
24 #include "libavutil/attributes.h"
25 #include "libavutil/ffmath.h"
26 #include "libavutil/mem.h"
27 
28 #include "avcodec.h"
29 #include "codec_internal.h"
30 #include "encode.h"
31 #include "wma.h"
32 #include "libavutil/avassert.h"
33 
34 
36 {
37  WMACodecContext *s = avctx->priv_data;
38  int i, flags1, flags2, block_align;
39  uint8_t *extradata;
40  int ret;
41 
42  s->avctx = avctx;
43 
44  if (avctx->ch_layout.nb_channels > MAX_CHANNELS) {
45  av_log(avctx, AV_LOG_ERROR,
46  "too many channels: got %i, need %i or fewer\n",
48  return AVERROR(EINVAL);
49  }
50 
51  if (avctx->sample_rate > 48000) {
52  av_log(avctx, AV_LOG_ERROR, "sample rate is too high: %d > 48kHz\n",
53  avctx->sample_rate);
54  return AVERROR(EINVAL);
55  }
56 
57  if (avctx->bit_rate < 24 * 1000) {
58  av_log(avctx, AV_LOG_ERROR,
59  "bitrate too low: got %"PRId64", need 24000 or higher\n",
60  avctx->bit_rate);
61  return AVERROR(EINVAL);
62  }
63 
64  /* extract flag info */
65  flags1 = 0;
66  flags2 = 1;
67  if (avctx->codec->id == AV_CODEC_ID_WMAV1) {
68  extradata = av_malloc(4);
69  if (!extradata)
70  return AVERROR(ENOMEM);
71  avctx->extradata_size = 4;
72  AV_WL16(extradata, flags1);
73  AV_WL16(extradata + 2, flags2);
74  } else if (avctx->codec->id == AV_CODEC_ID_WMAV2) {
75  extradata = av_mallocz(10);
76  if (!extradata)
77  return AVERROR(ENOMEM);
78  avctx->extradata_size = 10;
79  AV_WL32(extradata, flags1);
80  AV_WL16(extradata + 4, flags2);
81  } else {
82  av_assert0(0);
83  }
84  avctx->extradata = extradata;
85  s->use_exp_vlc = flags2 & 0x0001;
86  s->use_bit_reservoir = flags2 & 0x0002;
87  s->use_variable_block_len = flags2 & 0x0004;
88  if (avctx->ch_layout.nb_channels == 2)
89  s->ms_stereo = 1;
90 
91  if ((ret = ff_wma_init(avctx, flags2)) < 0)
92  return ret;
93 
94  /* init MDCT */
95  for (i = 0; i < s->nb_block_sizes; i++) {
96  float scale = 1.0f;
97  ret = av_tx_init(&s->mdct_ctx[i], &s->mdct_fn[i], AV_TX_FLOAT_MDCT,
98  0, 1 << (s->frame_len_bits - i), &scale, 0);
99  if (ret < 0)
100  return ret;
101  }
102 
103  block_align = avctx->bit_rate * (int64_t) s->frame_len /
104  (avctx->sample_rate * 8);
105  block_align = FFMIN(block_align, MAX_CODED_SUPERFRAME_SIZE);
106  avctx->block_align = block_align;
107  avctx->frame_size = avctx->initial_padding = s->frame_len;
108 
109  return 0;
110 }
111 
113 {
114  WMACodecContext *s = avctx->priv_data;
115  const float *const *audio = (const float *const *) frame->extended_data;
116  int len = frame->nb_samples;
117  int window_index = s->frame_len_bits - s->block_len_bits;
118  AVTXContext *mdct = s->mdct_ctx[window_index];
119  av_tx_fn mdct_fn = s->mdct_fn[window_index];
120  int ch;
121  const float *win = s->windows[window_index];
122  int window_len = 1 << s->block_len_bits;
123  float n = 2.0 * 32768.0 / window_len;
124 
125  for (ch = 0; ch < avctx->ch_layout.nb_channels; ch++) {
126  memcpy(s->output, s->frame_out[ch], window_len * sizeof(*s->output));
127  s->fdsp->vector_fmul_scalar(s->frame_out[ch], audio[ch], n, len);
128  s->fdsp->vector_fmul_reverse(&s->output[window_len], s->frame_out[ch],
129  win, len);
130  s->fdsp->vector_fmul(s->frame_out[ch], s->frame_out[ch], win, len);
131  mdct_fn(mdct, s->coefs[ch], s->output, sizeof(float));
132  if (!isfinite(s->coefs[ch][0])) {
133  av_log(avctx, AV_LOG_ERROR, "Input contains NaN/+-Inf\n");
134  return AVERROR(EINVAL);
135  }
136  }
137 
138  return 0;
139 }
140 
141 // FIXME use for decoding too
142 static void init_exp(WMACodecContext *s, int ch, const int *exp_param)
143 {
144  int n;
145  const uint16_t *ptr;
146  float v, *q, max_scale, *q_end;
147 
148  ptr = s->exponent_bands[s->frame_len_bits - s->block_len_bits];
149  q = s->exponents[ch];
150  q_end = q + s->block_len;
151  max_scale = 0;
152  while (q < q_end) {
153  /* XXX: use a table */
154  v = ff_exp10(*exp_param++ *(1.0 / 16.0));
155  max_scale = FFMAX(max_scale, v);
156  n = *ptr++;
157  do {
158  *q++ = v;
159  } while (--n);
160  }
161  s->max_exponent[ch] = max_scale;
162 }
163 
164 static void encode_exp_vlc(WMACodecContext *s, int ch, const int *exp_param)
165 {
166  int last_exp;
167  const uint16_t *ptr;
168  float *q, *q_end;
169 
170  ptr = s->exponent_bands[s->frame_len_bits - s->block_len_bits];
171  q = s->exponents[ch];
172  q_end = q + s->block_len;
173  if (s->version == 1) {
174  last_exp = *exp_param++;
175  av_assert0(last_exp - 10 >= 0 && last_exp - 10 < 32);
176  put_bits(&s->pb, 5, last_exp - 10);
177  q += *ptr++;
178  } else
179  last_exp = 36;
180  while (q < q_end) {
181  int exp = *exp_param++;
182  int code = exp - last_exp + 60;
183  av_assert1(code >= 0 && code < 120);
186  /* XXX: use a table */
187  q += *ptr++;
188  last_exp = exp;
189  }
190 }
191 
192 static int encode_block(WMACodecContext *s, float (*src_coefs)[BLOCK_MAX_SIZE],
193  int total_gain)
194 {
195  int channels = s->avctx->ch_layout.nb_channels;
196  int v, bsize, ch, coef_nb_bits, parse_exponents;
197  float mdct_norm;
198  int nb_coefs[MAX_CHANNELS];
199  static const int fixed_exp[25] = {
200  20, 20, 20, 20, 20,
201  20, 20, 20, 20, 20,
202  20, 20, 20, 20, 20,
203  20, 20, 20, 20, 20,
204  20, 20, 20, 20, 20
205  };
206 
207  // FIXME remove duplication relative to decoder
208  if (s->use_variable_block_len) {
209  av_assert0(0); // FIXME not implemented
210  } else {
211  /* fixed block len */
212  s->next_block_len_bits = s->frame_len_bits;
213  s->prev_block_len_bits = s->frame_len_bits;
214  s->block_len_bits = s->frame_len_bits;
215  }
216 
217  s->block_len = 1 << s->block_len_bits;
218 // av_assert0((s->block_pos + s->block_len) <= s->frame_len);
219  bsize = s->frame_len_bits - s->block_len_bits;
220 
221  // FIXME factor
222  v = s->coefs_end[bsize] - s->coefs_start;
223  for (ch = 0; ch < channels; ch++)
224  nb_coefs[ch] = v;
225  {
226  int n4 = s->block_len / 2;
227  mdct_norm = 1.0 / (float) n4;
228  if (s->version == 1)
229  mdct_norm *= sqrt(n4);
230  }
231 
232  if (channels == 2)
233  put_bits(&s->pb, 1, !!s->ms_stereo);
234 
235  for (ch = 0; ch < channels; ch++) {
236  // FIXME only set channel_coded when needed, instead of always
237  s->channel_coded[ch] = 1;
238  if (s->channel_coded[ch])
239  init_exp(s, ch, fixed_exp);
240  }
241 
242  for (ch = 0; ch < channels; ch++) {
243  if (s->channel_coded[ch]) {
244  WMACoef *coefs1;
245  float *coefs, *exponents, mult;
246  int i, n;
247 
248  coefs1 = s->coefs1[ch];
249  exponents = s->exponents[ch];
250  mult = ff_exp10(total_gain * 0.05) / s->max_exponent[ch];
251  mult *= mdct_norm;
252  coefs = src_coefs[ch];
253  if (s->use_noise_coding && 0) {
254  av_assert0(0); // FIXME not implemented
255  } else {
256  coefs += s->coefs_start;
257  n = nb_coefs[ch];
258  for (i = 0; i < n; i++) {
259  double t = *coefs++ / (exponents[i] * mult);
260  if (t < -32768 || t > 32767)
261  return -1;
262 
263  coefs1[i] = lrint(t);
264  }
265  }
266  }
267  }
268 
269  v = 0;
270  for (ch = 0; ch < channels; ch++) {
271  int a = s->channel_coded[ch];
272  put_bits(&s->pb, 1, a);
273  v |= a;
274  }
275 
276  if (!v)
277  return 1;
278 
279  for (v = total_gain - 1; v >= 127; v -= 127)
280  put_bits(&s->pb, 7, 127);
281  put_bits(&s->pb, 7, v);
282 
283  coef_nb_bits = ff_wma_total_gain_to_bits(total_gain);
284 
285  if (s->use_noise_coding) {
286  for (ch = 0; ch < channels; ch++) {
287  if (s->channel_coded[ch]) {
288  int i, n;
289  n = s->exponent_high_sizes[bsize];
290  for (i = 0; i < n; i++) {
291  put_bits(&s->pb, 1, s->high_band_coded[ch][i] = 0);
292  if (0)
293  nb_coefs[ch] -= s->exponent_high_bands[bsize][i];
294  }
295  }
296  }
297  }
298 
299  parse_exponents = 1;
300  if (s->block_len_bits != s->frame_len_bits)
301  put_bits(&s->pb, 1, parse_exponents);
302 
303  if (parse_exponents) {
304  for (ch = 0; ch < channels; ch++) {
305  if (s->channel_coded[ch]) {
306  if (s->use_exp_vlc) {
307  encode_exp_vlc(s, ch, fixed_exp);
308  } else {
309  av_assert0(0); // FIXME not implemented
310 // encode_exp_lsp(s, ch);
311  }
312  }
313  }
314  } else
315  av_assert0(0); // FIXME not implemented
316 
317  for (ch = 0; ch < channels; ch++) {
318  if (s->channel_coded[ch]) {
319  int run, tindex;
320  WMACoef *ptr, *eptr;
321  tindex = (ch == 1 && s->ms_stereo);
322  ptr = &s->coefs1[ch][0];
323  eptr = ptr + nb_coefs[ch];
324 
325  run = 0;
326  for (; ptr < eptr; ptr++) {
327  if (*ptr) {
328  int level = *ptr;
329  int abs_level = FFABS(level);
330  int code = 0;
331  if (abs_level <= s->coef_vlcs[tindex]->max_level)
332  if (run < s->coef_vlcs[tindex]->levels[abs_level - 1])
333  code = run + s->int_table[tindex][abs_level - 1];
334 
335  av_assert2(code < s->coef_vlcs[tindex]->n);
336  put_bits(&s->pb, s->coef_vlcs[tindex]->huffbits[code],
337  s->coef_vlcs[tindex]->huffcodes[code]);
338 
339  if (code == 0) {
340  if (1 << coef_nb_bits <= abs_level)
341  return -1;
342 
343  put_bits(&s->pb, coef_nb_bits, abs_level);
344  put_bits(&s->pb, s->frame_len_bits, run);
345  }
346  // FIXME the sign is flipped somewhere
347  put_bits(&s->pb, 1, level < 0);
348  run = 0;
349  } else
350  run++;
351  }
352  if (run)
353  put_bits(&s->pb, s->coef_vlcs[tindex]->huffbits[1],
354  s->coef_vlcs[tindex]->huffcodes[1]);
355  }
356  if (s->version == 1 && channels >= 2)
357  align_put_bits(&s->pb);
358  }
359  return 0;
360 }
361 
362 static int encode_frame(WMACodecContext *s, float (*src_coefs)[BLOCK_MAX_SIZE],
363  uint8_t *buf, int buf_size, int total_gain)
364 {
365  init_put_bits(&s->pb, buf, buf_size);
366 
367  if (s->use_bit_reservoir)
368  av_assert0(0); // FIXME not implemented
369  else if (encode_block(s, src_coefs, total_gain) < 0)
370  return INT_MAX;
371 
372  align_put_bits(&s->pb);
373 
374  return put_bits_count(&s->pb) / 8 - s->avctx->block_align;
375 }
376 
377 static int encode_superframe(AVCodecContext *avctx, AVPacket *avpkt,
378  const AVFrame *frame, int *got_packet_ptr)
379 {
380  WMACodecContext *s = avctx->priv_data;
381  int i, total_gain, ret, error;
382 
383  s->block_len_bits = s->frame_len_bits; // required by non variable block len
384  s->block_len = 1 << s->block_len_bits;
385 
386  ret = apply_window_and_mdct(avctx, frame);
387 
388  if (ret < 0)
389  return ret;
390 
391  if (s->ms_stereo) {
392  float a, b;
393  int i;
394 
395  for (i = 0; i < s->block_len; i++) {
396  a = s->coefs[0][i] * 0.5;
397  b = s->coefs[1][i] * 0.5;
398  s->coefs[0][i] = a + b;
399  s->coefs[1][i] = a - b;
400  }
401  }
402 
403  if ((ret = ff_alloc_packet(avctx, avpkt, 2 * MAX_CODED_SUPERFRAME_SIZE)) < 0)
404  return ret;
405 
406  total_gain = 128;
407  for (i = 64; i; i >>= 1) {
408  error = encode_frame(s, s->coefs, avpkt->data, avpkt->size,
409  total_gain - i);
410  if (error <= 0)
411  total_gain -= i;
412  }
413 
414  while(total_gain <= 128 && error > 0)
415  error = encode_frame(s, s->coefs, avpkt->data, avpkt->size, total_gain++);
416  if (error > 0) {
417  av_log(avctx, AV_LOG_ERROR, "Invalid input data or requested bitrate too low, cannot encode\n");
418  avpkt->size = 0;
419  return AVERROR(EINVAL);
420  }
421  av_assert0((put_bits_count(&s->pb) & 7) == 0);
422  i = avctx->block_align - put_bytes_count(&s->pb, 0);
423  av_assert0(i>=0);
424  while(i--)
425  put_bits(&s->pb, 8, 'N');
426 
427  flush_put_bits(&s->pb);
428  av_assert0(put_bits_ptr(&s->pb) - s->pb.buf == avctx->block_align);
429 
430  if (frame->pts != AV_NOPTS_VALUE)
431  avpkt->pts = frame->pts - ff_samples_to_time_base(avctx, avctx->initial_padding);
432 
433  avpkt->size = avctx->block_align;
434  *got_packet_ptr = 1;
435  return 0;
436 }
437 
438 #if CONFIG_WMAV1_ENCODER
439 const FFCodec ff_wmav1_encoder = {
440  .p.name = "wmav1",
441  CODEC_LONG_NAME("Windows Media Audio 1"),
442  .p.type = AVMEDIA_TYPE_AUDIO,
443  .p.id = AV_CODEC_ID_WMAV1,
445  .priv_data_size = sizeof(WMACodecContext),
446  .init = encode_init,
448  .close = ff_wma_end,
449  .p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
451  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
452 };
453 #endif
454 #if CONFIG_WMAV2_ENCODER
455 const FFCodec ff_wmav2_encoder = {
456  .p.name = "wmav2",
457  CODEC_LONG_NAME("Windows Media Audio 2"),
458  .p.type = AVMEDIA_TYPE_AUDIO,
459  .p.id = AV_CODEC_ID_WMAV2,
461  .priv_data_size = sizeof(WMACodecContext),
462  .init = encode_init,
464  .close = ff_wma_end,
465  .p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
467  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
468 };
469 #endif
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:32
AVCodecContext::frame_size
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1083
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:66
nb_coefs
static int nb_coefs(int length, int level, uint64_t sn)
Definition: af_afwtdn.c:515
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:205
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:43
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:422
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:420
coef_vlcs
static const CoefVLCTable coef_vlcs[6]
Definition: wmadata.h:1371
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1056
AVTXContext
Definition: tx_priv.h:235
int64_t
long long int64_t
Definition: coverity.c:34
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:62
apply_window_and_mdct
static int apply_window_and_mdct(AVCodecContext *avctx, const AVFrame *frame)
Definition: wmaenc.c:112
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:389
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:223
AVPacket::data
uint8_t * data
Definition: packet.h:539
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:100
init_exp
static void init_exp(WMACodecContext *s, int ch, const int *exp_param)
Definition: wmaenc.c:142
FFCodec
Definition: codec_internal.h:127
AV_CODEC_ID_WMAV2
@ AV_CODEC_ID_WMAV2
Definition: codec_id.h:454
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:327
av_tx_init
av_cold int av_tx_init(AVTXContext **ctx, av_tx_fn *tx, enum AVTXType type, int inv, int len, const void *scale, uint64_t flags)
Initialize a transform context with the given configuration (i)MDCTs with an odd length are currently...
Definition: tx.c:903
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
win
static float win(SuperEqualizerContext *s, float n, int N)
Definition: af_superequalizer.c:119
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:460
WMACoef
float WMACoef
type for decoded coefficients, int16_t would be enough for wma 1/2
Definition: wma.h:58
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:1071
encode_block
static int encode_block(WMACodecContext *s, float(*src_coefs)[BLOCK_MAX_SIZE], int total_gain)
Definition: wmaenc.c:192
AVCodecContext::initial_padding
int initial_padding
Audio only.
Definition: avcodec.h:1128
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:320
WMACodecContext
Definition: wma.h:68
encode_init
static av_cold int encode_init(AVCodecContext *avctx)
Definition: wmaenc.c:35
mult
static int16_t mult(Float11 *f1, Float11 *f2)
Definition: g726.c:60
AV_CODEC_ID_WMAV1
@ AV_CODEC_ID_WMAV1
Definition: codec_id.h:453
avassert.h
lrint
#define lrint
Definition: tablegen.h:53
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
av_cold
#define av_cold
Definition: attributes.h:90
av_tx_fn
void(* av_tx_fn)(AVTXContext *s, void *out, void *in, ptrdiff_t stride)
Function pointer to a function to perform the transform.
Definition: tx.h:151
float
float
Definition: af_crystalizer.c:122
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:530
AV_TX_FLOAT_MDCT
@ AV_TX_FLOAT_MDCT
Standard MDCT with a sample data type of float, double or int32_t, respecively.
Definition: tx.h:68
s
#define s(width, name)
Definition: cbs_vp9.c:198
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
This encoder can reorder user opaque values from input AVFrames and return them with corresponding ou...
Definition: codec.h:159
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:40
channels
channels
Definition: aptx.h:31
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:353
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:296
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:74
ff_wmav1_encoder
const FFCodec ff_wmav1_encoder
run
uint8_t run
Definition: svq3.c:204
parse_exponents
static int parse_exponents(DBEContext *s, DBEChannel *c)
Definition: dolby_e.c:663
ff_samples_to_time_base
static av_always_inline int64_t ff_samples_to_time_base(const AVCodecContext *avctx, int64_t samples)
Rescale from sample rate to AVCodecContext.time_base.
Definition: encode.h:90
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:501
ff_wmav2_encoder
const FFCodec ff_wmav2_encoder
encode_superframe
static int encode_superframe(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Definition: wmaenc.c:377
exp
int8_t exp
Definition: eval.c:73
MAX_CODED_SUPERFRAME_SIZE
#define MAX_CODED_SUPERFRAME_SIZE
Definition: wma.h:46
ff_wma_end
int ff_wma_end(AVCodecContext *avctx)
Definition: wma.c:367
ff_aac_scalefactor_bits
const uint8_t ff_aac_scalefactor_bits[121]
Definition: aactab.c:204
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:368
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:540
codec_internal.h
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
ff_wma_init
av_cold int ff_wma_init(AVCodecContext *avctx, int flags2)
Definition: wma.c:79
AV_WL16
#define AV_WL16(p, v)
Definition: intreadwrite.h:408
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
fixed_exp
static int fixed_exp(int x)
Definition: aacsbr_fixed.c:109
attributes.h
MAX_CHANNELS
#define MAX_CHANNELS
Definition: aac.h:33
AVCodec::id
enum AVCodecID id
Definition: codec.h:201
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:67
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:532
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:80
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:529
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:56
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:55
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
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:256
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
len
int len
Definition: vorbis_enc_data.h:426
avcodec.h
ret
ret
Definition: filter_design.txt:187
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:362
AVCodecContext::block_align
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs.
Definition: avcodec.h:1089
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
AVCodecContext
main external API structure.
Definition: avcodec.h:451
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:377
encode_exp_vlc
static void encode_exp_vlc(WMACodecContext *s, int ch, const int *exp_param)
Definition: wmaenc.c:164
ffmath.h
mem.h
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:143
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: intra.c:291
AVPacket
This structure stores compressed data.
Definition: packet.h:516
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:478
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
ff_alloc_packet
int ff_alloc_packet(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
Check AVPacket size and allocate data.
Definition: encode.c:62
ff_aac_scalefactor_code
const uint32_t ff_aac_scalefactor_code[121]
Definition: aactab.c:185