FFmpeg
libfdk-aacenc.c
Go to the documentation of this file.
1 /*
2  * AAC encoder wrapper
3  * Copyright (c) 2012 Martin Storsjo
4  *
5  * This file is part of FFmpeg.
6  *
7  * Permission to use, copy, modify, and/or distribute this software for any
8  * purpose with or without fee is hereby granted, provided that the above
9  * copyright notice and this permission notice appear in all copies.
10  *
11  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
12  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
13  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
14  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
15  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
16  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
17  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18  */
19 
20 #include <fdk-aac/aacenc_lib.h>
21 
23 #include "libavutil/common.h"
24 #include "libavutil/opt.h"
25 #include "avcodec.h"
26 #include "audio_frame_queue.h"
27 #include "encode.h"
28 #include "internal.h"
29 #include "profiles.h"
30 
31 #ifdef AACENCODER_LIB_VL0
32 #define FDKENC_VER_AT_LEAST(vl0, vl1) \
33  ((AACENCODER_LIB_VL0 > vl0) || \
34  (AACENCODER_LIB_VL0 == vl0 && AACENCODER_LIB_VL1 >= vl1))
35 #else
36 #define FDKENC_VER_AT_LEAST(vl0, vl1) 0
37 #endif
38 
39 typedef struct AACContext {
40  const AVClass *class;
41  HANDLE_AACENCODER handle;
43  int eld_sbr;
44  int eld_v2;
45  int signaling;
46  int latm;
48  int vbr;
49 
51 } AACContext;
52 
53 static const AVOption aac_enc_options[] = {
54  { "afterburner", "Afterburner (improved quality)", offsetof(AACContext, afterburner), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 1, AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM },
55  { "eld_sbr", "Enable SBR for ELD (for SBR in other configurations, use the -profile parameter)", offsetof(AACContext, eld_sbr), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM },
56 #if FDKENC_VER_AT_LEAST(4, 0) // 4.0.0
57  { "eld_v2", "Enable ELDv2 (LD-MPS extension for ELD stereo signals)", offsetof(AACContext, eld_v2), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM },
58 #endif
59  { "signaling", "SBR/PS signaling style", offsetof(AACContext, signaling), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 2, AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "signaling" },
60  { "default", "Choose signaling implicitly (explicit hierarchical by default, implicit if global header is disabled)", 0, AV_OPT_TYPE_CONST, { .i64 = -1 }, 0, 0, AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "signaling" },
61  { "implicit", "Implicit backwards compatible signaling", 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, 0, 0, AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "signaling" },
62  { "explicit_sbr", "Explicit SBR, implicit PS signaling", 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, 0, 0, AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "signaling" },
63  { "explicit_hierarchical", "Explicit hierarchical signaling", 0, AV_OPT_TYPE_CONST, { .i64 = 2 }, 0, 0, AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "signaling" },
64  { "latm", "Output LATM/LOAS encapsulated data", offsetof(AACContext, latm), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM },
65  { "header_period", "StreamMuxConfig and PCE repetition period (in frames)", offsetof(AACContext, header_period), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 0xffff, AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM },
66  { "vbr", "VBR mode (1-5)", offsetof(AACContext, vbr), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 5, AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM },
68  { NULL }
69 };
70 
71 static const AVClass aac_enc_class = {
72  .class_name = "libfdk_aac",
73  .item_name = av_default_item_name,
74  .option = aac_enc_options,
75  .version = LIBAVUTIL_VERSION_INT,
76 };
77 
78 static const char *aac_get_error(AACENC_ERROR err)
79 {
80  switch (err) {
81  case AACENC_OK:
82  return "No error";
83  case AACENC_INVALID_HANDLE:
84  return "Invalid handle";
85  case AACENC_MEMORY_ERROR:
86  return "Memory allocation error";
87  case AACENC_UNSUPPORTED_PARAMETER:
88  return "Unsupported parameter";
89  case AACENC_INVALID_CONFIG:
90  return "Invalid config";
91  case AACENC_INIT_ERROR:
92  return "Initialization error";
93  case AACENC_INIT_AAC_ERROR:
94  return "AAC library initialization error";
95  case AACENC_INIT_SBR_ERROR:
96  return "SBR library initialization error";
97  case AACENC_INIT_TP_ERROR:
98  return "Transport library initialization error";
99  case AACENC_INIT_META_ERROR:
100  return "Metadata library initialization error";
101  case AACENC_ENCODE_ERROR:
102  return "Encoding error";
103  case AACENC_ENCODE_EOF:
104  return "End of file";
105  default:
106  return "Unknown error";
107  }
108 }
109 
111 {
112  AACContext *s = avctx->priv_data;
113 
114  if (s->handle)
115  aacEncClose(&s->handle);
116  ff_af_queue_close(&s->afq);
117 
118  return 0;
119 }
120 
122 {
123  AACContext *s = avctx->priv_data;
124  int ret = AVERROR(EINVAL);
125  AACENC_InfoStruct info = { 0 };
126  CHANNEL_MODE mode;
127  AACENC_ERROR err;
128  int aot = FF_PROFILE_AAC_LOW + 1;
129  int sce = 0, cpe = 0;
130 
131  if ((err = aacEncOpen(&s->handle, 0, avctx->channels)) != AACENC_OK) {
132  av_log(avctx, AV_LOG_ERROR, "Unable to open the encoder: %s\n",
133  aac_get_error(err));
134  goto error;
135  }
136 
137  if (avctx->profile != FF_PROFILE_UNKNOWN)
138  aot = avctx->profile + 1;
139 
140  if ((err = aacEncoder_SetParam(s->handle, AACENC_AOT, aot)) != AACENC_OK) {
141  av_log(avctx, AV_LOG_ERROR, "Unable to set the AOT %d: %s\n",
142  aot, aac_get_error(err));
143  goto error;
144  }
145 
146  if (aot == FF_PROFILE_AAC_ELD + 1 && s->eld_sbr) {
147  if ((err = aacEncoder_SetParam(s->handle, AACENC_SBR_MODE,
148  1)) != AACENC_OK) {
149  av_log(avctx, AV_LOG_ERROR, "Unable to enable SBR for ELD: %s\n",
150  aac_get_error(err));
151  goto error;
152  }
153  }
154 
155  if ((err = aacEncoder_SetParam(s->handle, AACENC_SAMPLERATE,
156  avctx->sample_rate)) != AACENC_OK) {
157  av_log(avctx, AV_LOG_ERROR, "Unable to set the sample rate %d: %s\n",
158  avctx->sample_rate, aac_get_error(err));
159  goto error;
160  }
161 
162  switch (avctx->channels) {
163  case 1: mode = MODE_1; sce = 1; cpe = 0; break;
164  case 2:
165 #if FDKENC_VER_AT_LEAST(4, 0) // 4.0.0
166  // (profile + 1) to map from profile range to AOT range
167  if (aot == FF_PROFILE_AAC_ELD + 1 && s->eld_v2) {
168  if ((err = aacEncoder_SetParam(s->handle, AACENC_CHANNELMODE,
169  128)) != AACENC_OK) {
170  av_log(avctx, AV_LOG_ERROR, "Unable to enable ELDv2: %s\n",
171  aac_get_error(err));
172  goto error;
173  } else {
174  mode = MODE_212;
175  sce = 1;
176  cpe = 0;
177  }
178  } else
179 #endif
180  {
181  mode = MODE_2;
182  sce = 0;
183  cpe = 1;
184  }
185  break;
186  case 3: mode = MODE_1_2; sce = 1; cpe = 1; break;
187  case 4: mode = MODE_1_2_1; sce = 2; cpe = 1; break;
188  case 5: mode = MODE_1_2_2; sce = 1; cpe = 2; break;
189  case 6: mode = MODE_1_2_2_1; sce = 2; cpe = 2; break;
190 /* The version macro is introduced the same time as the 7.1 support, so this
191  should suffice. */
192 #if FDKENC_VER_AT_LEAST(3, 4) // 3.4.12
193  case 8:
194  sce = 2;
195  cpe = 3;
196  if (avctx->channel_layout == AV_CH_LAYOUT_7POINT1) {
197  mode = MODE_7_1_REAR_SURROUND;
198  } else {
199  // MODE_1_2_2_2_1 and MODE_7_1_FRONT_CENTER use the same channel layout
200  mode = MODE_7_1_FRONT_CENTER;
201  }
202  break;
203 #endif
204  default:
205  av_log(avctx, AV_LOG_ERROR,
206  "Unsupported number of channels %d\n", avctx->channels);
207  goto error;
208  }
209 
210  if ((err = aacEncoder_SetParam(s->handle, AACENC_CHANNELMODE,
211  mode)) != AACENC_OK) {
212  av_log(avctx, AV_LOG_ERROR,
213  "Unable to set channel mode %d: %s\n", mode, aac_get_error(err));
214  goto error;
215  }
216 
217  if ((err = aacEncoder_SetParam(s->handle, AACENC_CHANNELORDER,
218  1)) != AACENC_OK) {
219  av_log(avctx, AV_LOG_ERROR,
220  "Unable to set wav channel order %d: %s\n",
221  mode, aac_get_error(err));
222  goto error;
223  }
224 
225  if (avctx->flags & AV_CODEC_FLAG_QSCALE || s->vbr) {
226  int mode = s->vbr ? s->vbr : avctx->global_quality;
227  if (mode < 1 || mode > 5) {
228  av_log(avctx, AV_LOG_WARNING,
229  "VBR quality %d out of range, should be 1-5\n", mode);
230  mode = av_clip(mode, 1, 5);
231  }
232  av_log(avctx, AV_LOG_WARNING,
233  "Note, the VBR setting is unsupported and only works with "
234  "some parameter combinations\n");
235  if ((err = aacEncoder_SetParam(s->handle, AACENC_BITRATEMODE,
236  mode)) != AACENC_OK) {
237  av_log(avctx, AV_LOG_ERROR, "Unable to set the VBR bitrate mode %d: %s\n",
238  mode, aac_get_error(err));
239  goto error;
240  }
241  } else {
242  if (avctx->bit_rate <= 0) {
243  if (avctx->profile == FF_PROFILE_AAC_HE_V2) {
244  sce = 1;
245  cpe = 0;
246  }
247  avctx->bit_rate = (96*sce + 128*cpe) * avctx->sample_rate / 44;
248  if (avctx->profile == FF_PROFILE_AAC_HE ||
249  avctx->profile == FF_PROFILE_AAC_HE_V2 ||
250  avctx->profile == FF_PROFILE_MPEG2_AAC_HE ||
251  s->eld_sbr)
252  avctx->bit_rate /= 2;
253  }
254  if ((err = aacEncoder_SetParam(s->handle, AACENC_BITRATE,
255  avctx->bit_rate)) != AACENC_OK) {
256  av_log(avctx, AV_LOG_ERROR, "Unable to set the bitrate %"PRId64": %s\n",
257  avctx->bit_rate, aac_get_error(err));
258  goto error;
259  }
260  }
261 
262  /* Choose bitstream format - if global header is requested, use
263  * raw access units, otherwise use ADTS. */
264  if ((err = aacEncoder_SetParam(s->handle, AACENC_TRANSMUX,
265  avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER ? TT_MP4_RAW :
266  s->latm ? TT_MP4_LOAS : TT_MP4_ADTS)) != AACENC_OK) {
267  av_log(avctx, AV_LOG_ERROR, "Unable to set the transmux format: %s\n",
268  aac_get_error(err));
269  goto error;
270  }
271 
272  if (s->latm && s->header_period) {
273  if ((err = aacEncoder_SetParam(s->handle, AACENC_HEADER_PERIOD,
274  s->header_period)) != AACENC_OK) {
275  av_log(avctx, AV_LOG_ERROR, "Unable to set header period: %s\n",
276  aac_get_error(err));
277  goto error;
278  }
279  }
280 
281  /* If no signaling mode is chosen, use explicit hierarchical signaling
282  * if using mp4 mode (raw access units, with global header) and
283  * implicit signaling if using ADTS. */
284  if (s->signaling < 0)
285  s->signaling = avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER ? 2 : 0;
286 
287  if ((err = aacEncoder_SetParam(s->handle, AACENC_SIGNALING_MODE,
288  s->signaling)) != AACENC_OK) {
289  av_log(avctx, AV_LOG_ERROR, "Unable to set signaling mode %d: %s\n",
290  s->signaling, aac_get_error(err));
291  goto error;
292  }
293 
294  if ((err = aacEncoder_SetParam(s->handle, AACENC_AFTERBURNER,
295  s->afterburner)) != AACENC_OK) {
296  av_log(avctx, AV_LOG_ERROR, "Unable to set afterburner to %d: %s\n",
297  s->afterburner, aac_get_error(err));
298  goto error;
299  }
300 
301  if (avctx->cutoff > 0) {
302  if (avctx->cutoff < (avctx->sample_rate + 255) >> 8 || avctx->cutoff > 20000) {
303  av_log(avctx, AV_LOG_ERROR, "cutoff valid range is %d-20000\n",
304  (avctx->sample_rate + 255) >> 8);
305  goto error;
306  }
307  if ((err = aacEncoder_SetParam(s->handle, AACENC_BANDWIDTH,
308  avctx->cutoff)) != AACENC_OK) {
309  av_log(avctx, AV_LOG_ERROR, "Unable to set the encoder bandwidth to %d: %s\n",
310  avctx->cutoff, aac_get_error(err));
311  goto error;
312  }
313  }
314 
315  if ((err = aacEncEncode(s->handle, NULL, NULL, NULL, NULL)) != AACENC_OK) {
316  av_log(avctx, AV_LOG_ERROR, "Unable to initialize the encoder: %s\n",
317  aac_get_error(err));
318  return AVERROR(EINVAL);
319  }
320 
321  if ((err = aacEncInfo(s->handle, &info)) != AACENC_OK) {
322  av_log(avctx, AV_LOG_ERROR, "Unable to get encoder info: %s\n",
323  aac_get_error(err));
324  goto error;
325  }
326 
327  avctx->frame_size = info.frameLength;
328 #if FDKENC_VER_AT_LEAST(4, 0) // 4.0.0
329  avctx->initial_padding = info.nDelay;
330 #else
331  avctx->initial_padding = info.encoderDelay;
332 #endif
333  ff_af_queue_init(avctx, &s->afq);
334 
335  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
336  avctx->extradata_size = info.confSize;
337  avctx->extradata = av_mallocz(avctx->extradata_size +
339  if (!avctx->extradata) {
340  ret = AVERROR(ENOMEM);
341  goto error;
342  }
343 
344  memcpy(avctx->extradata, info.confBuf, info.confSize);
345  }
346  return 0;
347 error:
348  aac_encode_close(avctx);
349  return ret;
350 }
351 
352 static int aac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
353  const AVFrame *frame, int *got_packet_ptr)
354 {
355  AACContext *s = avctx->priv_data;
356  AACENC_BufDesc in_buf = { 0 }, out_buf = { 0 };
357  AACENC_InArgs in_args = { 0 };
358  AACENC_OutArgs out_args = { 0 };
359  int in_buffer_identifier = IN_AUDIO_DATA;
360  int in_buffer_size, in_buffer_element_size;
361  int out_buffer_identifier = OUT_BITSTREAM_DATA;
362  int out_buffer_size, out_buffer_element_size;
363  void *in_ptr, *out_ptr;
364  int ret;
365  uint8_t dummy_buf[1];
366  AACENC_ERROR err;
367 
368  /* handle end-of-stream small frame and flushing */
369  if (!frame) {
370  /* Must be a non-null pointer, even if it's a dummy. We could use
371  * the address of anything else on the stack as well. */
372  in_ptr = dummy_buf;
373  in_buffer_size = 0;
374 
375  in_args.numInSamples = -1;
376  } else {
377  in_ptr = frame->data[0];
378  in_buffer_size = 2 * avctx->channels * frame->nb_samples;
379 
380  in_args.numInSamples = avctx->channels * frame->nb_samples;
381 
382  /* add current frame to the queue */
383  if ((ret = ff_af_queue_add(&s->afq, frame)) < 0)
384  return ret;
385  }
386 
387  in_buffer_element_size = 2;
388  in_buf.numBufs = 1;
389  in_buf.bufs = &in_ptr;
390  in_buf.bufferIdentifiers = &in_buffer_identifier;
391  in_buf.bufSizes = &in_buffer_size;
392  in_buf.bufElSizes = &in_buffer_element_size;
393 
394  /* The maximum packet size is 6144 bits aka 768 bytes per channel. */
395  ret = ff_alloc_packet(avctx, avpkt, FFMAX(8192, 768 * avctx->channels));
396  if (ret < 0)
397  return ret;
398 
399  out_ptr = avpkt->data;
400  out_buffer_size = avpkt->size;
401  out_buffer_element_size = 1;
402  out_buf.numBufs = 1;
403  out_buf.bufs = &out_ptr;
404  out_buf.bufferIdentifiers = &out_buffer_identifier;
405  out_buf.bufSizes = &out_buffer_size;
406  out_buf.bufElSizes = &out_buffer_element_size;
407 
408  if ((err = aacEncEncode(s->handle, &in_buf, &out_buf, &in_args,
409  &out_args)) != AACENC_OK) {
410  if (!frame && err == AACENC_ENCODE_EOF)
411  return 0;
412  av_log(avctx, AV_LOG_ERROR, "Unable to encode frame: %s\n",
413  aac_get_error(err));
414  return AVERROR(EINVAL);
415  }
416 
417  if (!out_args.numOutBytes)
418  return 0;
419 
420  /* Get the next frame pts & duration */
421  ff_af_queue_remove(&s->afq, avctx->frame_size, &avpkt->pts,
422  &avpkt->duration);
423 
424  avpkt->size = out_args.numOutBytes;
425  *got_packet_ptr = 1;
426  return 0;
427 }
428 
429 static const AVProfile profiles[] = {
430  { FF_PROFILE_AAC_LOW, "LC" },
431  { FF_PROFILE_AAC_HE, "HE-AAC" },
432  { FF_PROFILE_AAC_HE_V2, "HE-AACv2" },
433  { FF_PROFILE_AAC_LD, "LD" },
434  { FF_PROFILE_AAC_ELD, "ELD" },
435  { FF_PROFILE_UNKNOWN },
436 };
437 
439  { "b", "0" },
440  { NULL }
441 };
442 
443 static const uint64_t aac_channel_layout[] = {
450 #if FDKENC_VER_AT_LEAST(3, 4) // 3.4.12
453 #endif
454  0,
455 };
456 
457 static const int aac_sample_rates[] = {
458  96000, 88200, 64000, 48000, 44100, 32000,
459  24000, 22050, 16000, 12000, 11025, 8000, 0
460 };
461 
463  .name = "libfdk_aac",
464  .long_name = NULL_IF_CONFIG_SMALL("Fraunhofer FDK AAC"),
465  .type = AVMEDIA_TYPE_AUDIO,
466  .id = AV_CODEC_ID_AAC,
467  .priv_data_size = sizeof(AACContext),
469  .encode2 = aac_encode_frame,
470  .close = aac_encode_close,
472  .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
474  .priv_class = &aac_enc_class,
475  .defaults = aac_encode_defaults,
476  .profiles = profiles,
477  .supported_samplerates = aac_sample_rates,
478  .channel_layouts = aac_channel_layout,
479  .wrapper_name = "libfdk",
480 };
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:31
AVCodecContext::frame_size
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1012
AVCodec
AVCodec.
Definition: codec.h:202
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AV_CH_LAYOUT_7POINT1_WIDE_BACK
#define AV_CH_LAYOUT_7POINT1_WIDE_BACK
Definition: channel_layout.h:114
AV_CH_LAYOUT_5POINT0_BACK
#define AV_CH_LAYOUT_5POINT0_BACK
Definition: channel_layout.h:102
av_clip
#define av_clip
Definition: common.h:96
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
opt.h
FF_PROFILE_MPEG2_AAC_HE
#define FF_PROFILE_MPEG2_AAC_HE
Definition: avcodec.h:1538
aac_enc_class
static const AVClass aac_enc_class
Definition: libfdk-aacenc.c:71
AVCodecContext::channel_layout
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1043
ff_af_queue_remove
void ff_af_queue_remove(AudioFrameQueue *afq, int nb_samples, int64_t *pts, int64_t *duration)
Remove frame(s) from the queue.
Definition: audio_frame_queue.c:75
aac_channel_layout
static const uint64_t aac_channel_layout[]
Definition: libfdk-aacenc.c:443
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:992
ff_af_queue_close
void ff_af_queue_close(AudioFrameQueue *afq)
Close AudioFrameQueue.
Definition: audio_frame_queue.c:36
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:948
AV_CH_LAYOUT_MONO
#define AV_CH_LAYOUT_MONO
Definition: channel_layout.h:90
AV_CODEC_FLAG_QSCALE
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:210
ff_af_queue_init
av_cold void ff_af_queue_init(AVCodecContext *avctx, AudioFrameQueue *afq)
Initialize AudioFrameQueue.
Definition: audio_frame_queue.c:28
aac_encode_frame
static int aac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Definition: libfdk-aacenc.c:352
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:310
aac_encode_init
static av_cold int aac_encode_init(AVCodecContext *avctx)
Definition: libfdk-aacenc.c:121
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:373
AACContext::signaling
int signaling
Definition: libfdk-aacenc.c:45
AVOption
AVOption.
Definition: opt.h:247
encode.h
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:391
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AV_CODEC_FLAG_GLOBAL_HEADER
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
Definition: avcodec.h:268
AVProfile
AVProfile.
Definition: codec.h:188
aac_get_error
static const char * aac_get_error(AACENC_ERROR err)
Definition: libfdk-aacenc.c:78
audio_frame_queue.h
AVCodecContext::initial_padding
int initial_padding
Audio only.
Definition: avcodec.h:1701
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:463
ff_af_queue_add
int ff_af_queue_add(AudioFrameQueue *afq, const AVFrame *f)
Add a frame to the queue.
Definition: audio_frame_queue.c:44
AV_CH_LAYOUT_STEREO
#define AV_CH_LAYOUT_STEREO
Definition: channel_layout.h:91
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
FF_PROFILE_AAC_HE_V2
#define FF_PROFILE_AAC_HE_V2
Definition: avcodec.h:1534
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:485
s
#define s(width, name)
Definition: cbs_vp9.c:257
AVCodecContext::global_quality
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:449
AV_OPT_FLAG_ENCODING_PARAM
#define AV_OPT_FLAG_ENCODING_PARAM
a generic parameter which can be set by the user for muxing or encoding
Definition: opt.h:277
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
info
MIPS optimizations info
Definition: mips.txt:2
AACContext::eld_v2
int eld_v2
Definition: libfdk-aacenc.c:44
FF_PROFILE_UNKNOWN
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:1526
AudioFrameQueue
Definition: audio_frame_queue.h:32
AACContext::vbr
int vbr
Definition: libfdk-aacenc.c:48
AACContext::header_period
int header_period
Definition: libfdk-aacenc.c:47
AACContext::latm
int latm
Definition: libfdk-aacenc.c:46
AV_OPT_FLAG_AUDIO_PARAM
#define AV_OPT_FLAG_AUDIO_PARAM
Definition: opt.h:279
if
if(ret)
Definition: filter_design.txt:179
AVCodecDefault
Definition: internal.h:215
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:433
FF_PROFILE_AAC_LD
#define FF_PROFILE_AAC_LD
Definition: avcodec.h:1535
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
profiles.h
aac_encode_close
static int aac_encode_close(AVCodecContext *avctx)
Definition: libfdk-aacenc.c:110
aac_encode_defaults
static const AVCodecDefault aac_encode_defaults[]
Definition: libfdk-aacenc.c:438
AACContext::afterburner
int afterburner
Definition: libfdk-aacenc.c:42
FF_PROFILE_AAC_ELD
#define FF_PROFILE_AAC_ELD
Definition: avcodec.h:1536
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition: codec_id.h:425
AVPacket::size
int size
Definition: packet.h:374
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_PROFILE_AAC_LOW
#define FF_PROFILE_AAC_LOW
Definition: avcodec.h:1530
AACContext::afq
AudioFrameQueue afq
Definition: libfdk-aacenc.c:50
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
AV_CH_LAYOUT_5POINT1_BACK
#define AV_CH_LAYOUT_5POINT1_BACK
Definition: channel_layout.h:103
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:993
AACContext::eld_sbr
int eld_sbr
Definition: libfdk-aacenc.c:43
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:366
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:484
common.h
AVCodecContext::cutoff
int cutoff
Audio cutoff bandwidth (0 means "automatic")
Definition: avcodec.h:1036
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
AV_CH_LAYOUT_7POINT1
#define AV_CH_LAYOUT_7POINT1
Definition: channel_layout.h:112
AV_SAMPLE_FMT_S16
@ AV_SAMPLE_FMT_S16
signed 16 bits
Definition: samplefmt.h:61
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:263
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:209
ff_libfdk_aac_encoder
const AVCodec ff_libfdk_aac_encoder
Definition: libfdk-aacenc.c:462
avcodec.h
FF_PROFILE_AAC_HE
#define FF_PROFILE_AAC_HE
Definition: avcodec.h:1533
ret
ret
Definition: filter_design.txt:187
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
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
AV_CH_LAYOUT_SURROUND
#define AV_CH_LAYOUT_SURROUND
Definition: channel_layout.h:94
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
AVCodecContext
main external API structure.
Definition: avcodec.h:383
channel_layout.h
mode
mode
Definition: ebur128.h:83
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:224
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1525
profiles
static const AVProfile profiles[]
Definition: libfdk-aacenc.c:429
AV_CODEC_CAP_DELAY
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: codec.h:82
FF_AAC_PROFILE_OPTS
#define FF_AAC_PROFILE_OPTS
Definition: profiles.h:28
AVPacket
This structure stores compressed data.
Definition: packet.h:350
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:410
aac_sample_rates
static const int aac_sample_rates[]
Definition: libfdk-aacenc.c:457
AV_CH_LAYOUT_4POINT0
#define AV_CH_LAYOUT_4POINT0
Definition: channel_layout.h:96
AACContext
main AAC context
Definition: aac.h:294
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AACContext::handle
HANDLE_AACENCODER handle
Definition: libfdk-aacenc.c:41
AV_CODEC_CAP_SMALL_LAST_FRAME
#define AV_CODEC_CAP_SMALL_LAST_FRAME
Codec can be fed a final frame with a smaller size.
Definition: codec.h:87
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:233
ff_alloc_packet
int ff_alloc_packet(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
Check AVPacket size and allocate data.
Definition: encode.c:34
aac_enc_options
static const AVOption aac_enc_options[]
Definition: libfdk-aacenc.c:53