FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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 
350 static int aac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
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:218
HANDLE_AACENCODER handle
Definition: libfdk-aacenc.c:39
AVOption.
Definition: opt.h:246
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:1582
#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:2871
#define AV_OPT_FLAG_AUDIO_PARAM
Definition: opt.h:278
int size
Definition: avcodec.h:1445
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:2867
int profile
profile
Definition: avcodec.h:2858
AVCodec.
Definition: avcodec.h:3423
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:992
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:1462
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1633
static AVFrame * frame
static const AVClass aac_enc_class
Definition: libfdk-aacenc.c:68
uint8_t * data
Definition: avcodec.h:1444
#define FF_PROFILE_AAC_LD
Definition: avcodec.h:2868
#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 AVERROR(e)
Definition: error.h:43
#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:3046
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1612
int header_period
Definition: libfdk-aacenc.c:45
const char * name
Name of the codec implementation.
Definition: avcodec.h:3430
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:2869
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2239
audio channel layout utility functions
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:841
#define AV_CODEC_CAP_SMALL_LAST_FRAME
Codec can be fed a final frame with a smaller size.
Definition: avcodec.h:997
#define FF_PROFILE_AAC_LOW
Definition: avcodec.h:2863
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:2859
#define s(width, name)
Definition: cbs_vp9.c:257
#define AV_CH_LAYOUT_5POINT1_BACK
static void error(const char *err)
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:2208
Libavcodec external API header.
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
int sample_rate
samples per second
Definition: avcodec.h:2188
main external API structure.
Definition: avcodec.h:1532
static const AVCodecDefault aac_encode_defaults[]
int extradata_size
Definition: avcodec.h:1634
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:1598
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:232
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
Definition: avcodec.h:890
common internal api header.
common internal and external API header
if(ret< 0)
Definition: vf_mcdeint.c:279
signed 16 bits
Definition: samplefmt.h:61
AVProfile.
Definition: avcodec.h:3356
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:781
void * priv_data
Definition: avcodec.h:1559
int cutoff
Audio cutoff bandwidth (0 means "automatic")
Definition: avcodec.h:2232
int channels
number of audio channels
Definition: avcodec.h:2189
static const uint64_t aac_channel_layout[]
void ff_af_queue_close(AudioFrameQueue *afq)
Close AudioFrameQueue.
#define FF_PROFILE_AAC_HE
Definition: avcodec.h:2866
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:701
#define av_freep(p)
#define AV_CH_LAYOUT_MONO
This structure stores compressed data.
Definition: avcodec.h:1421
mode
Use these values in ebur128_init (or'ed).
Definition: ebur128.h:83
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:284
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1437
static const char * aac_get_error(AACENC_ERROR err)
Definition: libfdk-aacenc.c:75