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