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