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 "internal.h"
28 #include "profiles.h"
29 
30 #ifdef AACENCODER_LIB_VL0
31 #define FDKENC_VER_AT_LEAST(vl0, vl1) \
32  ((AACENCODER_LIB_VL0 > vl0) || \
33  (AACENCODER_LIB_VL0 == vl0 && AACENCODER_LIB_VL1 >= vl1))
34 #else
35 #define FDKENC_VER_AT_LEAST(vl0, vl1) 0
36 #endif
37 
38 typedef struct AACContext {
39  const AVClass *class;
40  HANDLE_AACENCODER handle;
42  int eld_sbr;
43  int eld_v2;
44  int signaling;
45  int latm;
47  int vbr;
48 
50 } AACContext;
51 
52 static const AVOption aac_enc_options[] = {
53  { "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 },
54  { "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 },
55 #if FDKENC_VER_AT_LEAST(4, 0) // 4.0.0
56  { "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 },
57 #endif
58  { "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" },
59  { "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" },
60  { "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" },
61  { "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" },
62  { "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" },
63  { "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 },
64  { "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 },
65  { "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 },
67  { NULL }
68 };
69 
70 static const AVClass aac_enc_class = {
71  .class_name = "libfdk_aac",
72  .item_name = av_default_item_name,
73  .option = aac_enc_options,
74  .version = LIBAVUTIL_VERSION_INT,
75 };
76 
77 static const char *aac_get_error(AACENC_ERROR err)
78 {
79  switch (err) {
80  case AACENC_OK:
81  return "No error";
82  case AACENC_INVALID_HANDLE:
83  return "Invalid handle";
84  case AACENC_MEMORY_ERROR:
85  return "Memory allocation error";
86  case AACENC_UNSUPPORTED_PARAMETER:
87  return "Unsupported parameter";
88  case AACENC_INVALID_CONFIG:
89  return "Invalid config";
90  case AACENC_INIT_ERROR:
91  return "Initialization error";
92  case AACENC_INIT_AAC_ERROR:
93  return "AAC library initialization error";
94  case AACENC_INIT_SBR_ERROR:
95  return "SBR library initialization error";
96  case AACENC_INIT_TP_ERROR:
97  return "Transport library initialization error";
98  case AACENC_INIT_META_ERROR:
99  return "Metadata library initialization error";
100  case AACENC_ENCODE_ERROR:
101  return "Encoding error";
102  case AACENC_ENCODE_EOF:
103  return "End of file";
104  default:
105  return "Unknown error";
106  }
107 }
108 
110 {
111  AACContext *s = avctx->priv_data;
112 
113  if (s->handle)
114  aacEncClose(&s->handle);
115  av_freep(&avctx->extradata);
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 
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  if ((ret = ff_alloc_packet2(avctx, avpkt, FFMAX(8192, 768 * avctx->channels), 0)) < 0)
396  return ret;
397 
398  out_ptr = avpkt->data;
399  out_buffer_size = avpkt->size;
400  out_buffer_element_size = 1;
401  out_buf.numBufs = 1;
402  out_buf.bufs = &out_ptr;
403  out_buf.bufferIdentifiers = &out_buffer_identifier;
404  out_buf.bufSizes = &out_buffer_size;
405  out_buf.bufElSizes = &out_buffer_element_size;
406 
407  if ((err = aacEncEncode(s->handle, &in_buf, &out_buf, &in_args,
408  &out_args)) != AACENC_OK) {
409  if (!frame && err == AACENC_ENCODE_EOF)
410  return 0;
411  av_log(avctx, AV_LOG_ERROR, "Unable to encode frame: %s\n",
412  aac_get_error(err));
413  return AVERROR(EINVAL);
414  }
415 
416  if (!out_args.numOutBytes)
417  return 0;
418 
419  /* Get the next frame pts & duration */
420  ff_af_queue_remove(&s->afq, avctx->frame_size, &avpkt->pts,
421  &avpkt->duration);
422 
423  avpkt->size = out_args.numOutBytes;
424  *got_packet_ptr = 1;
425  return 0;
426 }
427 
428 static const AVProfile profiles[] = {
429  { FF_PROFILE_AAC_LOW, "LC" },
430  { FF_PROFILE_AAC_HE, "HE-AAC" },
431  { FF_PROFILE_AAC_HE_V2, "HE-AACv2" },
432  { FF_PROFILE_AAC_LD, "LD" },
433  { FF_PROFILE_AAC_ELD, "ELD" },
434  { FF_PROFILE_UNKNOWN },
435 };
436 
438  { "b", "0" },
439  { NULL }
440 };
441 
442 static const uint64_t aac_channel_layout[] = {
449 #if FDKENC_VER_AT_LEAST(3, 4) // 3.4.12
452 #endif
453  0,
454 };
455 
456 static const int aac_sample_rates[] = {
457  96000, 88200, 64000, 48000, 44100, 32000,
458  24000, 22050, 16000, 12000, 11025, 8000, 0
459 };
460 
462  .name = "libfdk_aac",
463  .long_name = NULL_IF_CONFIG_SMALL("Fraunhofer FDK AAC"),
464  .type = AVMEDIA_TYPE_AUDIO,
465  .id = AV_CODEC_ID_AAC,
466  .priv_data_size = sizeof(AACContext),
468  .encode2 = aac_encode_frame,
469  .close = aac_encode_close,
471  .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
473  .priv_class = &aac_enc_class,
474  .defaults = aac_encode_defaults,
475  .profiles = profiles,
476  .supported_samplerates = aac_sample_rates,
477  .channel_layouts = aac_channel_layout,
478  .wrapper_name = "libfdk",
479 };
void ff_af_queue_remove(AudioFrameQueue *afq, int nb_samples, int64_t *pts, int64_t *duration)
Remove frame(s) from the queue.
#define NULL
Definition: coverity.c:32
#define AV_CH_LAYOUT_7POINT1
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
HANDLE_AACENCODER handle
Definition: libfdk-aacenc.c:40
AVOption.
Definition: opt.h:248
AVCodecContext * avctx
Definition: aac.h:295
static const int aac_sample_rates[]
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
int64_t bit_rate
the average bitrate
Definition: avcodec.h:576
#define AV_CH_LAYOUT_SURROUND
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
#define FF_PROFILE_MPEG2_AAC_HE
Definition: avcodec.h:1872
#define AV_OPT_FLAG_AUDIO_PARAM
Definition: opt.h:280
int size
Definition: packet.h:364
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
#define AV_CH_LAYOUT_4POINT0
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
#define AV_CH_LAYOUT_STEREO
static void error(const char *err)
#define FF_PROFILE_AAC_HE_V2
Definition: avcodec.h:1868
int profile
profile
Definition: avcodec.h:1859
AVCodec.
Definition: codec.h:190
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:72
#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:75
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
Definition: encode.c:33
uint8_t
#define av_cold
Definition: attributes.h:88
static int aac_encode_close(AVCodecContext *avctx)
AVOptions.
AVCodec ff_libfdk_aac_encoder
AudioFrameQueue afq
Definition: libfdk-aacenc.c:49
av_cold void ff_af_queue_init(AVCodecContext *avctx, AudioFrameQueue *afq)
Initialize AudioFrameQueue.
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:381
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:627
static const AVClass aac_enc_class
Definition: libfdk-aacenc.c:70
uint8_t * data
Definition: packet.h:363
#define FF_PROFILE_AAC_LD
Definition: avcodec.h:1869
#define av_log(a,...)
#define AV_OPT_FLAG_ENCODING_PARAM
a generic parameter which can be set by the user for muxing or encoding
Definition: opt.h:278
static av_cold int aac_encode_init(AVCodecContext *avctx)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:153
#define FF_AAC_PROFILE_OPTS
Definition: profiles.h:28
int initial_padding
Audio only.
Definition: avcodec.h:2060
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:606
int header_period
Definition: libfdk-aacenc.c:46
const char * name
Name of the codec implementation.
Definition: codec.h:197
int ff_af_queue_add(AudioFrameQueue *afq, const AVFrame *f)
Add a frame to the queue.
#define FFMAX(a, b)
Definition: common.h:94
#define FF_PROFILE_AAC_ELD
Definition: avcodec.h:1870
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1237
MIPS optimizations info
Definition: mips.txt:2
audio channel layout utility functions
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:275
#define AV_CODEC_CAP_SMALL_LAST_FRAME
Codec can be fed a final frame with a smaller size.
Definition: codec.h:80
#define FF_PROFILE_AAC_LOW
Definition: avcodec.h:1864
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:1860
#define s(width, name)
Definition: cbs_vp9.c:257
#define AV_CH_LAYOUT_5POINT1_BACK
if(ret)
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1206
Libavcodec external API header.
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
int sample_rate
samples per second
Definition: avcodec.h:1186
main external API structure.
Definition: avcodec.h:526
static const AVCodecDefault aac_encode_defaults[]
int extradata_size
Definition: avcodec.h:628
Describe the class of an AVClass context structure.
Definition: log.h:67
#define AV_CH_LAYOUT_7POINT1_WIDE_BACK
static const AVProfile profiles[]
#define AV_CH_LAYOUT_5POINT0_BACK
main AAC context
Definition: aac.h:293
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:592
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:322
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
Definition: avcodec.h:329
AVFrame * frame
Definition: aac.h:296
common internal api header.
common internal and external API header
signed 16 bits
Definition: samplefmt.h:61
AVProfile.
Definition: codec.h:176
static const AVOption aac_enc_options[]
Definition: libfdk-aacenc.c:52
static int aac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:215
void * priv_data
Definition: avcodec.h:553
int cutoff
Audio cutoff bandwidth (0 means "automatic")
Definition: avcodec.h:1230
int channels
number of audio channels
Definition: avcodec.h:1187
static const uint64_t aac_channel_layout[]
void ff_af_queue_close(AudioFrameQueue *afq)
Close AudioFrameQueue.
#define FF_PROFILE_AAC_HE
Definition: avcodec.h:1867
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:884
#define av_freep(p)
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
#define AV_CH_LAYOUT_MONO
This structure stores compressed data.
Definition: packet.h:340
mode
Use these values in ebur128_init (or&#39;ed).
Definition: ebur128.h:83
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:374
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:356
static const char * aac_get_error(AACENC_ERROR err)
Definition: libfdk-aacenc.c:77