FFmpeg: libavcodec/libfdk-aacenc.c Source File

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 
22 #include "libavutil/channel_layout.h"
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;
32   int afterburner;
33   int eld_sbr;
34   int signaling;
35   int latm;
36   int header_period;
37   int vbr;
38 
39   AudioFrameQueue afq;
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  "libfdk_aac", av_default_item_name, aac_enc_options, LIBAVUTIL_VERSION_INT
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);
99  ff_af_queue_close(&s->afq);
100 
101  return 0;
102 }
103 
104  static av_cold int aac_encode_init(AVCodecContext *avctx)
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 & 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 %d: %s\n",
219  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 & 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 & 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->delay = info.encoderDelay;
290  ff_af_queue_init(avctx, &s->afq);
291 
292  if (avctx->flags & CODEC_FLAG_GLOBAL_HEADER) {
293  avctx->extradata_size = info.confSize;
294  avctx->extradata = av_mallocz(avctx->extradata_size +
295  FF_INPUT_BUFFER_PADDING_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)
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 
387  static const AVCodecDefault aac_encode_defaults[] = {
388  { "b", "0" },
389  { NULL }
390 };
391 
392  static const uint64_t aac_channel_layout[] = {
393  AV_CH_LAYOUT_MONO,
394  AV_CH_LAYOUT_STEREO,
395  AV_CH_LAYOUT_SURROUND,
396  AV_CH_LAYOUT_4POINT0,
397  AV_CH_LAYOUT_5POINT0_BACK,
398  AV_CH_LAYOUT_5POINT1_BACK,
399 #ifdef AACENCODER_LIB_VL0
400  AV_CH_LAYOUT_7POINT1_WIDE_BACK,
401  AV_CH_LAYOUT_7POINT1,
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 
411  AVCodec ff_libfdk_aac_encoder = {
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),
417  .init = aac_encode_init,
418  .encode2 = aac_encode_frame,
419  .close = aac_encode_close,
420  .capabilities = CODEC_CAP_SMALL_LAST_FRAME | CODEC_CAP_DELAY,
421  .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
422  AV_SAMPLE_FMT_NONE },
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 };
Generated on Sun Jul 20 2014 23:05:50 for FFmpeg by   doxygen 1.8.2

AltStyle によって変換されたページ (->オリジナル) /