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 typedef struct AACContext {
30  const AVClass *class;
31  HANDLE_AACENCODER handle;
33  int eld_sbr;
34  int signaling;
35  int latm;
37  int vbr;
38 
40 } AACContext;
41 
42 static const AVOption aac_enc_options[] = {
43  { "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 },
44  { "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 },
45  { "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" },
46  { "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" },
47  { "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" },
48  { "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" },
49  { "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" },
50  { "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 },
51  { "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 },
52  { "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 },
53  { NULL }
54 };
55 
56 static const AVClass aac_enc_class = {
58 };
59 
60 static const char *aac_get_error(AACENC_ERROR err)
61 {
62  switch (err) {
63  case AACENC_OK:
64  return "No error";
65  case AACENC_INVALID_HANDLE:
66  return "Invalid handle";
67  case AACENC_MEMORY_ERROR:
68  return "Memory allocation error";
69  case AACENC_UNSUPPORTED_PARAMETER:
70  return "Unsupported parameter";
71  case AACENC_INVALID_CONFIG:
72  return "Invalid config";
73  case AACENC_INIT_ERROR:
74  return "Initialization error";
75  case AACENC_INIT_AAC_ERROR:
76  return "AAC library initialization error";
77  case AACENC_INIT_SBR_ERROR:
78  return "SBR library initialization error";
79  case AACENC_INIT_TP_ERROR:
80  return "Transport library initialization error";
81  case AACENC_INIT_META_ERROR:
82  return "Metadata library initialization error";
83  case AACENC_ENCODE_ERROR:
84  return "Encoding error";
85  case AACENC_ENCODE_EOF:
86  return "End of file";
87  default:
88  return "Unknown error";
89  }
90 }
91 
92 static int aac_encode_close(AVCodecContext *avctx)
93 {
94  AACContext *s = avctx->priv_data;
95 
96  if (s->handle)
97  aacEncClose(&s->handle);
98  av_freep(&avctx->extradata);
100 
101  return 0;
102 }
103 
105 {
106  AACContext *s = avctx->priv_data;
107  int ret = AVERROR(EINVAL);
108  AACENC_InfoStruct info = { 0 };
109  CHANNEL_MODE mode;
110  AACENC_ERROR err;
111  int aot = FF_PROFILE_AAC_LOW + 1;
112  int sce = 0, cpe = 0;
113 
114  if ((err = aacEncOpen(&s->handle, 0, avctx->channels)) != AACENC_OK) {
115  av_log(avctx, AV_LOG_ERROR, "Unable to open the encoder: %s\n",
116  aac_get_error(err));
117  goto error;
118  }
119 
120  if (avctx->profile != FF_PROFILE_UNKNOWN)
121  aot = avctx->profile + 1;
122 
123  if ((err = aacEncoder_SetParam(s->handle, AACENC_AOT, aot)) != AACENC_OK) {
124  av_log(avctx, AV_LOG_ERROR, "Unable to set the AOT %d: %s\n",
125  aot, aac_get_error(err));
126  goto error;
127  }
128 
129  if (aot == FF_PROFILE_AAC_ELD + 1 && s->eld_sbr) {
130  if ((err = aacEncoder_SetParam(s->handle, AACENC_SBR_MODE,
131  1)) != AACENC_OK) {
132  av_log(avctx, AV_LOG_ERROR, "Unable to enable SBR for ELD: %s\n",
133  aac_get_error(err));
134  goto error;
135  }
136  }
137 
138  if ((err = aacEncoder_SetParam(s->handle, AACENC_SAMPLERATE,
139  avctx->sample_rate)) != AACENC_OK) {
140  av_log(avctx, AV_LOG_ERROR, "Unable to set the sample rate %d: %s\n",
141  avctx->sample_rate, aac_get_error(err));
142  goto error;
143  }
144 
145  switch (avctx->channels) {
146  case 1: mode = MODE_1; sce = 1; cpe = 0; break;
147  case 2: mode = MODE_2; sce = 0; cpe = 1; break;
148  case 3: mode = MODE_1_2; sce = 1; cpe = 1; break;
149  case 4: mode = MODE_1_2_1; sce = 2; cpe = 1; break;
150  case 5: mode = MODE_1_2_2; sce = 1; cpe = 2; break;
151  case 6: mode = MODE_1_2_2_1; sce = 2; cpe = 2; break;
152 /* The version macro is introduced the same time as the 7.1 support, so this
153  should suffice. */
154 #ifdef AACENCODER_LIB_VL0
155  case 8:
156  sce = 2;
157  cpe = 3;
158  if (avctx->channel_layout == AV_CH_LAYOUT_7POINT1) {
159  mode = MODE_7_1_REAR_SURROUND;
160  } else {
161  // MODE_1_2_2_2_1 and MODE_7_1_FRONT_CENTER use the same channel layout
162  mode = MODE_7_1_FRONT_CENTER;
163  }
164  break;
165 #endif
166  default:
167  av_log(avctx, AV_LOG_ERROR,
168  "Unsupported number of channels %d\n", avctx->channels);
169  goto error;
170  }
171 
172  if ((err = aacEncoder_SetParam(s->handle, AACENC_CHANNELMODE,
173  mode)) != AACENC_OK) {
174  av_log(avctx, AV_LOG_ERROR,
175  "Unable to set channel mode %d: %s\n", mode, aac_get_error(err));
176  goto error;
177  }
178 
179  if ((err = aacEncoder_SetParam(s->handle, AACENC_CHANNELORDER,
180  1)) != AACENC_OK) {
181  av_log(avctx, AV_LOG_ERROR,
182  "Unable to set wav channel order %d: %s\n",
183  mode, aac_get_error(err));
184  goto error;
185  }
186 
187  if (avctx->flags & AV_CODEC_FLAG_QSCALE || s->vbr) {
188  int mode = s->vbr ? s->vbr : avctx->global_quality;
189  if (mode < 1 || mode > 5) {
190  av_log(avctx, AV_LOG_WARNING,
191  "VBR quality %d out of range, should be 1-5\n", mode);
192  mode = av_clip(mode, 1, 5);
193  }
194  av_log(avctx, AV_LOG_WARNING,
195  "Note, the VBR setting is unsupported and only works with "
196  "some parameter combinations\n");
197  if ((err = aacEncoder_SetParam(s->handle, AACENC_BITRATEMODE,
198  mode)) != AACENC_OK) {
199  av_log(avctx, AV_LOG_ERROR, "Unable to set the VBR bitrate mode %d: %s\n",
200  mode, aac_get_error(err));
201  goto error;
202  }
203  } else {
204  if (avctx->bit_rate <= 0) {
205  if (avctx->profile == FF_PROFILE_AAC_HE_V2) {
206  sce = 1;
207  cpe = 0;
208  }
209  avctx->bit_rate = (96*sce + 128*cpe) * avctx->sample_rate / 44;
210  if (avctx->profile == FF_PROFILE_AAC_HE ||
211  avctx->profile == FF_PROFILE_AAC_HE_V2 ||
212  avctx->profile == FF_PROFILE_MPEG2_AAC_HE ||
213  s->eld_sbr)
214  avctx->bit_rate /= 2;
215  }
216  if ((err = aacEncoder_SetParam(s->handle, AACENC_BITRATE,
217  avctx->bit_rate)) != AACENC_OK) {
218  av_log(avctx, AV_LOG_ERROR, "Unable to set the bitrate %"PRId64": %s\n",
219  (int64_t)avctx->bit_rate, aac_get_error(err));
220  goto error;
221  }
222  }
223 
224  /* Choose bitstream format - if global header is requested, use
225  * raw access units, otherwise use ADTS. */
226  if ((err = aacEncoder_SetParam(s->handle, AACENC_TRANSMUX,
227  avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER ? 0 : s->latm ? 10 : 2)) != AACENC_OK) {
228  av_log(avctx, AV_LOG_ERROR, "Unable to set the transmux format: %s\n",
229  aac_get_error(err));
230  goto error;
231  }
232 
233  if (s->latm && s->header_period) {
234  if ((err = aacEncoder_SetParam(s->handle, AACENC_HEADER_PERIOD,
235  s->header_period)) != AACENC_OK) {
236  av_log(avctx, AV_LOG_ERROR, "Unable to set header period: %s\n",
237  aac_get_error(err));
238  goto error;
239  }
240  }
241 
242  /* If no signaling mode is chosen, use explicit hierarchical signaling
243  * if using mp4 mode (raw access units, with global header) and
244  * implicit signaling if using ADTS. */
245  if (s->signaling < 0)
246  s->signaling = avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER ? 2 : 0;
247 
248  if ((err = aacEncoder_SetParam(s->handle, AACENC_SIGNALING_MODE,
249  s->signaling)) != AACENC_OK) {
250  av_log(avctx, AV_LOG_ERROR, "Unable to set signaling mode %d: %s\n",
251  s->signaling, aac_get_error(err));
252  goto error;
253  }
254 
255  if ((err = aacEncoder_SetParam(s->handle, AACENC_AFTERBURNER,
256  s->afterburner)) != AACENC_OK) {
257  av_log(avctx, AV_LOG_ERROR, "Unable to set afterburner to %d: %s\n",
258  s->afterburner, aac_get_error(err));
259  goto error;
260  }
261 
262  if (avctx->cutoff > 0) {
263  if (avctx->cutoff < (avctx->sample_rate + 255) >> 8 || avctx->cutoff > 20000) {
264  av_log(avctx, AV_LOG_ERROR, "cutoff valid range is %d-20000\n",
265  (avctx->sample_rate + 255) >> 8);
266  goto error;
267  }
268  if ((err = aacEncoder_SetParam(s->handle, AACENC_BANDWIDTH,
269  avctx->cutoff)) != AACENC_OK) {
270  av_log(avctx, AV_LOG_ERROR, "Unable to set the encoder bandwidth to %d: %s\n",
271  avctx->cutoff, aac_get_error(err));
272  goto error;
273  }
274  }
275 
276  if ((err = aacEncEncode(s->handle, NULL, NULL, NULL, NULL)) != AACENC_OK) {
277  av_log(avctx, AV_LOG_ERROR, "Unable to initialize the encoder: %s\n",
278  aac_get_error(err));
279  return AVERROR(EINVAL);
280  }
281 
282  if ((err = aacEncInfo(s->handle, &info)) != AACENC_OK) {
283  av_log(avctx, AV_LOG_ERROR, "Unable to get encoder info: %s\n",
284  aac_get_error(err));
285  goto error;
286  }
287 
288  avctx->frame_size = info.frameLength;
289  avctx->initial_padding = info.encoderDelay;
290  ff_af_queue_init(avctx, &s->afq);
291 
292  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
293  avctx->extradata_size = info.confSize;
294  avctx->extradata = av_mallocz(avctx->extradata_size +
296  if (!avctx->extradata) {
297  ret = AVERROR(ENOMEM);
298  goto error;
299  }
300 
301  memcpy(avctx->extradata, info.confBuf, info.confSize);
302  }
303  return 0;
304 error:
305  aac_encode_close(avctx);
306  return ret;
307 }
308 
309 static int aac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
310  const AVFrame *frame, int *got_packet_ptr)
311 {
312  AACContext *s = avctx->priv_data;
313  AACENC_BufDesc in_buf = { 0 }, out_buf = { 0 };
314  AACENC_InArgs in_args = { 0 };
315  AACENC_OutArgs out_args = { 0 };
316  int in_buffer_identifier = IN_AUDIO_DATA;
317  int in_buffer_size, in_buffer_element_size;
318  int out_buffer_identifier = OUT_BITSTREAM_DATA;
319  int out_buffer_size, out_buffer_element_size;
320  void *in_ptr, *out_ptr;
321  int ret;
322  AACENC_ERROR err;
323 
324  /* handle end-of-stream small frame and flushing */
325  if (!frame) {
326  in_args.numInSamples = -1;
327  } else {
328  in_ptr = frame->data[0];
329  in_buffer_size = 2 * avctx->channels * frame->nb_samples;
330  in_buffer_element_size = 2;
331 
332  in_args.numInSamples = avctx->channels * frame->nb_samples;
333  in_buf.numBufs = 1;
334  in_buf.bufs = &in_ptr;
335  in_buf.bufferIdentifiers = &in_buffer_identifier;
336  in_buf.bufSizes = &in_buffer_size;
337  in_buf.bufElSizes = &in_buffer_element_size;
338 
339  /* add current frame to the queue */
340  if ((ret = ff_af_queue_add(&s->afq, frame)) < 0)
341  return ret;
342  }
343 
344  /* The maximum packet size is 6144 bits aka 768 bytes per channel. */
345  if ((ret = ff_alloc_packet2(avctx, avpkt, FFMAX(8192, 768 * avctx->channels), 0)) < 0)
346  return ret;
347 
348  out_ptr = avpkt->data;
349  out_buffer_size = avpkt->size;
350  out_buffer_element_size = 1;
351  out_buf.numBufs = 1;
352  out_buf.bufs = &out_ptr;
353  out_buf.bufferIdentifiers = &out_buffer_identifier;
354  out_buf.bufSizes = &out_buffer_size;
355  out_buf.bufElSizes = &out_buffer_element_size;
356 
357  if ((err = aacEncEncode(s->handle, &in_buf, &out_buf, &in_args,
358  &out_args)) != AACENC_OK) {
359  if (!frame && err == AACENC_ENCODE_EOF)
360  return 0;
361  av_log(avctx, AV_LOG_ERROR, "Unable to encode frame: %s\n",
362  aac_get_error(err));
363  return AVERROR(EINVAL);
364  }
365 
366  if (!out_args.numOutBytes)
367  return 0;
368 
369  /* Get the next frame pts & duration */
370  ff_af_queue_remove(&s->afq, avctx->frame_size, &avpkt->pts,
371  &avpkt->duration);
372 
373  avpkt->size = out_args.numOutBytes;
374  *got_packet_ptr = 1;
375  return 0;
376 }
377 
378 static const AVProfile profiles[] = {
379  { FF_PROFILE_AAC_LOW, "LC" },
380  { FF_PROFILE_AAC_HE, "HE-AAC" },
381  { FF_PROFILE_AAC_HE_V2, "HE-AACv2" },
382  { FF_PROFILE_AAC_LD, "LD" },
383  { FF_PROFILE_AAC_ELD, "ELD" },
384  { FF_PROFILE_UNKNOWN },
385 };
386 
388  { "b", "0" },
389  { NULL }
390 };
391 
392 static const uint64_t aac_channel_layout[] = {
399 #ifdef AACENCODER_LIB_VL0
402 #endif
403  0,
404 };
405 
406 static const int aac_sample_rates[] = {
407  96000, 88200, 64000, 48000, 44100, 32000,
408  24000, 22050, 16000, 12000, 11025, 8000, 0
409 };
410 
412  .name = "libfdk_aac",
413  .long_name = NULL_IF_CONFIG_SMALL("Fraunhofer FDK AAC"),
414  .type = AVMEDIA_TYPE_AUDIO,
415  .id = AV_CODEC_ID_AAC,
416  .priv_data_size = sizeof(AACContext),
418  .encode2 = aac_encode_frame,
419  .close = aac_encode_close,
421  .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
423  .priv_class = &aac_enc_class,
424  .defaults = aac_encode_defaults,
425  .profiles = profiles,
426  .supported_samplerates = aac_sample_rates,
427  .channel_layouts = aac_channel_layout,
428 };
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
const char * s
Definition: avisynth_c.h:768
This structure describes decoded (raw) audio or video data.
Definition: frame.h:187
HANDLE_AACENCODER handle
Definition: libfdk-aacenc.c:31
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:1797
#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:3248
#define AV_OPT_FLAG_AUDIO_PARAM
Definition: opt.h:281
int size
Definition: avcodec.h:1658
#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:222
#define AV_CH_LAYOUT_STEREO
#define FF_PROFILE_AAC_HE_V2
Definition: avcodec.h:3244
int profile
profile
Definition: avcodec.h:3235
AVCodec.
Definition: avcodec.h:3681
#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:1019
#define av_cold
Definition: attributes.h:82
static int aac_encode_close(AVCodecContext *avctx)
Definition: libfdk-aacenc.c:92
AVOptions.
AVCodec ff_libfdk_aac_encoder
AudioFrameQueue afq
Definition: libfdk-aacenc.c:39
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:1675
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1847
static AVFrame * frame
static const AVClass aac_enc_class
Definition: libfdk-aacenc.c:56
uint8_t * data
Definition: avcodec.h:1657
#define FF_PROFILE_AAC_LD
Definition: avcodec.h:3245
#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
av_default_item_name
#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:179
int initial_padding
Audio only.
Definition: avcodec.h:3420
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1827
int header_period
Definition: libfdk-aacenc.c:36
const char * name
Name of the codec implementation.
Definition: avcodec.h:3688
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:3246
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2545
audio channel layout utility functions
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:868
#define AV_CODEC_CAP_SMALL_LAST_FRAME
Codec can be fed a final frame with a smaller size.
Definition: avcodec.h:1024
#define FF_PROFILE_AAC_LOW
Definition: avcodec.h:3240
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:3236
#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:2514
Libavcodec external API header.
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
int sample_rate
samples per second
Definition: avcodec.h:2494
main external API structure.
Definition: avcodec.h:1732
static const AVCodecDefault aac_encode_defaults[]
int extradata_size
Definition: avcodec.h:1848
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 ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
Definition: utils.c:1736
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:1813
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:201
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
Definition: avcodec.h:917
common internal api header.
common internal and external API header
if(ret< 0)
Definition: vf_mcdeint.c:282
signed 16 bits
Definition: samplefmt.h:61
AVProfile.
Definition: avcodec.h:3669
static const AVOption aac_enc_options[]
Definition: libfdk-aacenc.c:42
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:769
void * priv_data
Definition: avcodec.h:1774
int cutoff
Audio cutoff bandwidth (0 means "automatic")
Definition: avcodec.h:2538
int channels
number of audio channels
Definition: avcodec.h:2495
static const uint64_t aac_channel_layout[]
void ff_af_queue_close(AudioFrameQueue *afq)
Close AudioFrameQueue.
#define FF_PROFILE_AAC_HE
Definition: avcodec.h:3243
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:1634
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:244
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1650
static const char * aac_get_error(AACENC_ERROR err)
Definition: libfdk-aacenc.c:60