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 
29 #ifdef AACENCODER_LIB_VL0
30 #define FDKENC_VER_AT_LEAST(vl0, vl1) \
31  ((AACENCODER_LIB_VL0 > vl0) || \
32  (AACENCODER_LIB_VL0 == vl0 && AACENCODER_LIB_VL1 >= vl1))
33 #else
34 #define FDKENC_VER_AT_LEAST(vl0, vl1) 0
35 #endif
36 
37 typedef struct AACContext {
38  const AVClass *class;
39  HANDLE_AACENCODER handle;
41  int eld_sbr;
42  int eld_v2;
43  int signaling;
44  int latm;
46  int vbr;
47 
49 } AACContext;
50 
51 static const AVOption aac_enc_options[] = {
52  { "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 },
53  { "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 },
54 #if FDKENC_VER_AT_LEAST(4, 0) // 4.0.0
55  { "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 },
56 #endif
57  { "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" },
58  { "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" },
59  { "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" },
60  { "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" },
61  { "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" },
62  { "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 },
63  { "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 },
64  { "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 },
65  { NULL }
66 };
67 
68 static const AVClass aac_enc_class = {
69  .class_name = "libfdk_aac",
70  .item_name = av_default_item_name,
71  .option = aac_enc_options,
72  .version = LIBAVUTIL_VERSION_INT,
73 };
74 
75 static const char *aac_get_error(AACENC_ERROR err)
76 {
77  switch (err) {
78  case AACENC_OK:
79  return "No error";
80  case AACENC_INVALID_HANDLE:
81  return "Invalid handle";
82  case AACENC_MEMORY_ERROR:
83  return "Memory allocation error";
84  case AACENC_UNSUPPORTED_PARAMETER:
85  return "Unsupported parameter";
86  case AACENC_INVALID_CONFIG:
87  return "Invalid config";
88  case AACENC_INIT_ERROR:
89  return "Initialization error";
90  case AACENC_INIT_AAC_ERROR:
91  return "AAC library initialization error";
92  case AACENC_INIT_SBR_ERROR:
93  return "SBR library initialization error";
94  case AACENC_INIT_TP_ERROR:
95  return "Transport library initialization error";
96  case AACENC_INIT_META_ERROR:
97  return "Metadata library initialization error";
98  case AACENC_ENCODE_ERROR:
99  return "Encoding error";
100  case AACENC_ENCODE_EOF:
101  return "End of file";
102  default:
103  return "Unknown error";
104  }
105 }
106 
108 {
109  AACContext *s = avctx->priv_data;
110 
111  if (s->handle)
112  aacEncClose(&s->handle);
113  av_freep(&avctx->extradata);
114  ff_af_queue_close(&s->afq);
115 
116  return 0;
117 }
118 
120 {
121  AACContext *s = avctx->priv_data;
122  int ret = AVERROR(EINVAL);
123  AACENC_InfoStruct info = { 0 };
124  CHANNEL_MODE mode;
125  AACENC_ERROR err;
126  int aot = FF_PROFILE_AAC_LOW + 1;
127  int sce = 0, cpe = 0;
128 
129  if ((err = aacEncOpen(&s->handle, 0, avctx->channels)) != AACENC_OK) {
130  av_log(avctx, AV_LOG_ERROR, "Unable to open the encoder: %s\n",
131  aac_get_error(err));
132  goto error;
133  }
134 
135  if (avctx->profile != FF_PROFILE_UNKNOWN)
136  aot = avctx->profile + 1;
137 
138  if ((err = aacEncoder_SetParam(s->handle, AACENC_AOT, aot)) != AACENC_OK) {
139  av_log(avctx, AV_LOG_ERROR, "Unable to set the AOT %d: %s\n",
140  aot, aac_get_error(err));
141  goto error;
142  }
143 
144  if (aot == FF_PROFILE_AAC_ELD + 1 && s->eld_sbr) {
145  if ((err = aacEncoder_SetParam(s->handle, AACENC_SBR_MODE,
146  1)) != AACENC_OK) {
147  av_log(avctx, AV_LOG_ERROR, "Unable to enable SBR for ELD: %s\n",
148  aac_get_error(err));
149  goto error;
150  }
151  }
152 
153  if ((err = aacEncoder_SetParam(s->handle, AACENC_SAMPLERATE,
154  avctx->sample_rate)) != AACENC_OK) {
155  av_log(avctx, AV_LOG_ERROR, "Unable to set the sample rate %d: %s\n",
156  avctx->sample_rate, aac_get_error(err));
157  goto error;
158  }
159 
160  switch (avctx->channels) {
161  case 1: mode = MODE_1; sce = 1; cpe = 0; break;
162  case 2:
163 #if FDKENC_VER_AT_LEAST(4, 0) // 4.0.0
164  // (profile + 1) to map from profile range to AOT range
165  if (aot == FF_PROFILE_AAC_ELD + 1 && s->eld_v2) {
166  if ((err = aacEncoder_SetParam(s->handle, AACENC_CHANNELMODE,
167  128)) != AACENC_OK) {
168  av_log(avctx, AV_LOG_ERROR, "Unable to enable ELDv2: %s\n",
169  aac_get_error(err));
170  goto error;
171  } else {
172  mode = MODE_212;
173  sce = 1;
174  cpe = 0;
175  }
176  } else
177 #endif
178  {
179  mode = MODE_2;
180  sce = 0;
181  cpe = 1;
182  }
183  break;
184  case 3: mode = MODE_1_2; sce = 1; cpe = 1; break;
185  case 4: mode = MODE_1_2_1; sce = 2; cpe = 1; break;
186  case 5: mode = MODE_1_2_2; sce = 1; cpe = 2; break;
187  case 6: mode = MODE_1_2_2_1; sce = 2; cpe = 2; break;
188 /* The version macro is introduced the same time as the 7.1 support, so this
189  should suffice. */
190 #if FDKENC_VER_AT_LEAST(3, 4) // 3.4.12
191  case 8:
192  sce = 2;
193  cpe = 3;
194  if (avctx->channel_layout == AV_CH_LAYOUT_7POINT1) {
195  mode = MODE_7_1_REAR_SURROUND;
196  } else {
197  // MODE_1_2_2_2_1 and MODE_7_1_FRONT_CENTER use the same channel layout
198  mode = MODE_7_1_FRONT_CENTER;
199  }
200  break;
201 #endif
202  default:
203  av_log(avctx, AV_LOG_ERROR,
204  "Unsupported number of channels %d\n", avctx->channels);
205  goto error;
206  }
207 
208  if ((err = aacEncoder_SetParam(s->handle, AACENC_CHANNELMODE,
209  mode)) != AACENC_OK) {
210  av_log(avctx, AV_LOG_ERROR,
211  "Unable to set channel mode %d: %s\n", mode, aac_get_error(err));
212  goto error;
213  }
214 
215  if ((err = aacEncoder_SetParam(s->handle, AACENC_CHANNELORDER,
216  1)) != AACENC_OK) {
217  av_log(avctx, AV_LOG_ERROR,
218  "Unable to set wav channel order %d: %s\n",
219  mode, aac_get_error(err));
220  goto error;
221  }
222 
223  if (avctx->flags & AV_CODEC_FLAG_QSCALE || s->vbr) {
224  int mode = s->vbr ? s->vbr : avctx->global_quality;
225  if (mode < 1 || mode > 5) {
226  av_log(avctx, AV_LOG_WARNING,
227  "VBR quality %d out of range, should be 1-5\n", mode);
228  mode = av_clip(mode, 1, 5);
229  }
230  av_log(avctx, AV_LOG_WARNING,
231  "Note, the VBR setting is unsupported and only works with "
232  "some parameter combinations\n");
233  if ((err = aacEncoder_SetParam(s->handle, AACENC_BITRATEMODE,
234  mode)) != AACENC_OK) {
235  av_log(avctx, AV_LOG_ERROR, "Unable to set the VBR bitrate mode %d: %s\n",
236  mode, aac_get_error(err));
237  goto error;
238  }
239  } else {
240  if (avctx->bit_rate <= 0) {
241  if (avctx->profile == FF_PROFILE_AAC_HE_V2) {
242  sce = 1;
243  cpe = 0;
244  }
245  avctx->bit_rate = (96*sce + 128*cpe) * avctx->sample_rate / 44;
246  if (avctx->profile == FF_PROFILE_AAC_HE ||
247  avctx->profile == FF_PROFILE_AAC_HE_V2 ||
248  avctx->profile == FF_PROFILE_MPEG2_AAC_HE ||
249  s->eld_sbr)
250  avctx->bit_rate /= 2;
251  }
252  if ((err = aacEncoder_SetParam(s->handle, AACENC_BITRATE,
253  avctx->bit_rate)) != AACENC_OK) {
254  av_log(avctx, AV_LOG_ERROR, "Unable to set the bitrate %"PRId64": %s\n",
255  avctx->bit_rate, aac_get_error(err));
256  goto error;
257  }
258  }
259 
260  /* Choose bitstream format - if global header is requested, use
261  * raw access units, otherwise use ADTS. */
262  if ((err = aacEncoder_SetParam(s->handle, AACENC_TRANSMUX,
263  avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER ? TT_MP4_RAW :
264  s->latm ? TT_MP4_LOAS : TT_MP4_ADTS)) != AACENC_OK) {
265  av_log(avctx, AV_LOG_ERROR, "Unable to set the transmux format: %s\n",
266  aac_get_error(err));
267  goto error;
268  }
269 
270  if (s->latm && s->header_period) {
271  if ((err = aacEncoder_SetParam(s->handle, AACENC_HEADER_PERIOD,
272  s->header_period)) != AACENC_OK) {
273  av_log(avctx, AV_LOG_ERROR, "Unable to set header period: %s\n",
274  aac_get_error(err));
275  goto error;
276  }
277  }
278 
279  /* If no signaling mode is chosen, use explicit hierarchical signaling
280  * if using mp4 mode (raw access units, with global header) and
281  * implicit signaling if using ADTS. */
282  if (s->signaling < 0)
283  s->signaling = avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER ? 2 : 0;
284 
285  if ((err = aacEncoder_SetParam(s->handle, AACENC_SIGNALING_MODE,
286  s->signaling)) != AACENC_OK) {
287  av_log(avctx, AV_LOG_ERROR, "Unable to set signaling mode %d: %s\n",
288  s->signaling, aac_get_error(err));
289  goto error;
290  }
291 
292  if ((err = aacEncoder_SetParam(s->handle, AACENC_AFTERBURNER,
293  s->afterburner)) != AACENC_OK) {
294  av_log(avctx, AV_LOG_ERROR, "Unable to set afterburner to %d: %s\n",
295  s->afterburner, aac_get_error(err));
296  goto error;
297  }
298 
299  if (avctx->cutoff > 0) {
300  if (avctx->cutoff < (avctx->sample_rate + 255) >> 8 || avctx->cutoff > 20000) {
301  av_log(avctx, AV_LOG_ERROR, "cutoff valid range is %d-20000\n",
302  (avctx->sample_rate + 255) >> 8);
303  goto error;
304  }
305  if ((err = aacEncoder_SetParam(s->handle, AACENC_BANDWIDTH,
306  avctx->cutoff)) != AACENC_OK) {
307  av_log(avctx, AV_LOG_ERROR, "Unable to set the encoder bandwidth to %d: %s\n",
308  avctx->cutoff, aac_get_error(err));
309  goto error;
310  }
311  }
312 
313  if ((err = aacEncEncode(s->handle, NULL, NULL, NULL, NULL)) != AACENC_OK) {
314  av_log(avctx, AV_LOG_ERROR, "Unable to initialize the encoder: %s\n",
315  aac_get_error(err));
316  return AVERROR(EINVAL);
317  }
318 
319  if ((err = aacEncInfo(s->handle, &info)) != AACENC_OK) {
320  av_log(avctx, AV_LOG_ERROR, "Unable to get encoder info: %s\n",
321  aac_get_error(err));
322  goto error;
323  }
324 
325  avctx->frame_size = info.frameLength;
326 #if FDKENC_VER_AT_LEAST(4, 0) // 4.0.0
327  avctx->initial_padding = info.nDelay;
328 #else
329  avctx->initial_padding = info.encoderDelay;
330 #endif
331  ff_af_queue_init(avctx, &s->afq);
332 
333  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
334  avctx->extradata_size = info.confSize;
335  avctx->extradata = av_mallocz(avctx->extradata_size +
337  if (!avctx->extradata) {
338  ret = AVERROR(ENOMEM);
339  goto error;
340  }
341 
342  memcpy(avctx->extradata, info.confBuf, info.confSize);
343  }
344  return 0;
345 error:
346  aac_encode_close(avctx);
347  return ret;
348 }
349 
351  const AVFrame *frame, int *got_packet_ptr)
352 {
353  AACContext *s = avctx->priv_data;
354  AACENC_BufDesc in_buf = { 0 }, out_buf = { 0 };
355  AACENC_InArgs in_args = { 0 };
356  AACENC_OutArgs out_args = { 0 };
357  int in_buffer_identifier = IN_AUDIO_DATA;
358  int in_buffer_size, in_buffer_element_size;
359  int out_buffer_identifier = OUT_BITSTREAM_DATA;
360  int out_buffer_size, out_buffer_element_size;
361  void *in_ptr, *out_ptr;
362  int ret;
363  uint8_t dummy_buf[1];
364  AACENC_ERROR err;
365 
366  /* handle end-of-stream small frame and flushing */
367  if (!frame) {
368  /* Must be a non-null pointer, even if it's a dummy. We could use
369  * the address of anything else on the stack as well. */
370  in_ptr = dummy_buf;
371  in_buffer_size = 0;
372 
373  in_args.numInSamples = -1;
374  } else {
375  in_ptr = frame->data[0];
376  in_buffer_size = 2 * avctx->channels * frame->nb_samples;
377 
378  in_args.numInSamples = avctx->channels * frame->nb_samples;
379 
380  /* add current frame to the queue */
381  if ((ret = ff_af_queue_add(&s->afq, frame)) < 0)
382  return ret;
383  }
384 
385  in_buffer_element_size = 2;
386  in_buf.numBufs = 1;
387  in_buf.bufs = &in_ptr;
388  in_buf.bufferIdentifiers = &in_buffer_identifier;
389  in_buf.bufSizes = &in_buffer_size;
390  in_buf.bufElSizes = &in_buffer_element_size;
391 
392  /* The maximum packet size is 6144 bits aka 768 bytes per channel. */
393  if ((ret = ff_alloc_packet2(avctx, avpkt, FFMAX(8192, 768 * avctx->channels), 0)) < 0)
394  return ret;
395 
396  out_ptr = avpkt->data;
397  out_buffer_size = avpkt->size;
398  out_buffer_element_size = 1;
399  out_buf.numBufs = 1;
400  out_buf.bufs = &out_ptr;
401  out_buf.bufferIdentifiers = &out_buffer_identifier;
402  out_buf.bufSizes = &out_buffer_size;
403  out_buf.bufElSizes = &out_buffer_element_size;
404 
405  if ((err = aacEncEncode(s->handle, &in_buf, &out_buf, &in_args,
406  &out_args)) != AACENC_OK) {
407  if (!frame && err == AACENC_ENCODE_EOF)
408  return 0;
409  av_log(avctx, AV_LOG_ERROR, "Unable to encode frame: %s\n",
410  aac_get_error(err));
411  return AVERROR(EINVAL);
412  }
413 
414  if (!out_args.numOutBytes)
415  return 0;
416 
417  /* Get the next frame pts & duration */
418  ff_af_queue_remove(&s->afq, avctx->frame_size, &avpkt->pts,
419  &avpkt->duration);
420 
421  avpkt->size = out_args.numOutBytes;
422  *got_packet_ptr = 1;
423  return 0;
424 }
425 
426 static const AVProfile profiles[] = {
427  { FF_PROFILE_AAC_LOW, "LC" },
428  { FF_PROFILE_AAC_HE, "HE-AAC" },
429  { FF_PROFILE_AAC_HE_V2, "HE-AACv2" },
430  { FF_PROFILE_AAC_LD, "LD" },
431  { FF_PROFILE_AAC_ELD, "ELD" },
432  { FF_PROFILE_UNKNOWN },
433 };
434 
436  { "b", "0" },
437  { NULL }
438 };
439 
440 static const uint64_t aac_channel_layout[] = {
447 #if FDKENC_VER_AT_LEAST(3, 4) // 3.4.12
450 #endif
451  0,
452 };
453 
454 static const int aac_sample_rates[] = {
455  96000, 88200, 64000, 48000, 44100, 32000,
456  24000, 22050, 16000, 12000, 11025, 8000, 0
457 };
458 
460  .name = "libfdk_aac",
461  .long_name = NULL_IF_CONFIG_SMALL("Fraunhofer FDK AAC"),
462  .type = AVMEDIA_TYPE_AUDIO,
463  .id = AV_CODEC_ID_AAC,
464  .priv_data_size = sizeof(AACContext),
466  .encode2 = aac_encode_frame,
467  .close = aac_encode_close,
469  .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
471  .priv_class = &aac_enc_class,
472  .defaults = aac_encode_defaults,
473  .profiles = profiles,
474  .supported_samplerates = aac_sample_rates,
475  .channel_layouts = aac_channel_layout,
476  .wrapper_name = "libfdk",
477 };
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:295
HANDLE_AACENCODER handle
Definition: libfdk-aacenc.c:39
AVOption.
Definition: opt.h:246
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:182
int64_t bit_rate
the average bitrate
Definition: avcodec.h:1618
#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:2914
#define AV_OPT_FLAG_AUDIO_PARAM
Definition: opt.h:278
int size
Definition: avcodec.h:1481
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
#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:236
#define AV_CH_LAYOUT_STEREO
#define FF_PROFILE_AAC_HE_V2
Definition: avcodec.h:2910
int profile
profile
Definition: avcodec.h:2901
AVCodec.
Definition: avcodec.h:3492
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: avcodec.h:1009
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:32
uint8_t
#define av_cold
Definition: attributes.h:82
static int aac_encode_close(AVCodecContext *avctx)
AVOptions.
AVCodec ff_libfdk_aac_encoder
AudioFrameQueue afq
Definition: libfdk-aacenc.c:48
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: avcodec.h:1498
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1669
static const AVClass aac_enc_class
Definition: libfdk-aacenc.c:68
uint8_t * data
Definition: avcodec.h:1480
#define FF_PROFILE_AAC_LD
Definition: avcodec.h:2911
#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:276
static av_cold int aac_encode_init(AVCodecContext *avctx)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
int initial_padding
Audio only.
Definition: avcodec.h:3099
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1648
int header_period
Definition: libfdk-aacenc.c:45
const char * name
Name of the codec implementation.
Definition: avcodec.h:3499
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:2912
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2279
MIPS optimizations info
Definition: mips.txt:2
audio channel layout utility functions
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:853
#define AV_CODEC_CAP_SMALL_LAST_FRAME
Codec can be fed a final frame with a smaller size.
Definition: avcodec.h:1014
#define FF_PROFILE_AAC_LOW
Definition: avcodec.h:2906
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:2902
#define s(width, name)
Definition: cbs_vp9.c:257
#define AV_CH_LAYOUT_5POINT1_BACK
static void error(const char *err)
if(ret)
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:2248
Libavcodec external API header.
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
int sample_rate
samples per second
Definition: avcodec.h:2228
main external API structure.
Definition: avcodec.h:1568
static const AVCodecDefault aac_encode_defaults[]
int extradata_size
Definition: avcodec.h:1670
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:1634
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
Definition: avcodec.h:907
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: avcodec.h:3425
static const AVOption aac_enc_options[]
Definition: libfdk-aacenc.c:51
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:793
void * priv_data
Definition: avcodec.h:1595
int cutoff
Audio cutoff bandwidth (0 means "automatic")
Definition: avcodec.h:2272
int channels
number of audio channels
Definition: avcodec.h:2229
static const uint64_t aac_channel_layout[]
void ff_af_queue_close(AudioFrameQueue *afq)
Close AudioFrameQueue.
#define FF_PROFILE_AAC_HE
Definition: avcodec.h:2909
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:701
#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: avcodec.h:1457
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:361
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1473
static const char * aac_get_error(AACENC_ERROR err)
Definition: libfdk-aacenc.c:75