Libav
libfaac.c
Go to the documentation of this file.
1 /*
2  * Interface to libfaac for aac encoding
3  * Copyright (c) 2002 Gildas Bazin <gbazin@netcourrier.com>
4  *
5  * This file is part of Libav.
6  *
7  * Libav is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * Libav is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
27 #include <faac.h>
28 
30 #include "libavutil/common.h"
31 #include "avcodec.h"
32 #include "audio_frame_queue.h"
33 #include "internal.h"
34 
35 
36 /* libfaac has an encoder delay of 1024 samples */
37 #define FAAC_DELAY_SAMPLES 1024
38 
39 typedef struct FaacAudioContext {
40  faacEncHandle faac_handle;
43 
44 
46 {
47  FaacAudioContext *s = avctx->priv_data;
48 
49  av_freep(&avctx->extradata);
51 
52  if (s->faac_handle)
53  faacEncClose(s->faac_handle);
54 
55  return 0;
56 }
57 
58 static const int channel_maps[][6] = {
59  { 2, 0, 1 }, //< C L R
60  { 2, 0, 1, 3 }, //< C L R Cs
61  { 2, 0, 1, 3, 4 }, //< C L R Ls Rs
62  { 2, 0, 1, 4, 5, 3 }, //< C L R Ls Rs LFE
63 };
64 
66 {
67  FaacAudioContext *s = avctx->priv_data;
68  faacEncConfigurationPtr faac_cfg;
69  unsigned long samples_input, max_bytes_output;
70  int ret;
71 
72  /* number of channels */
73  if (avctx->channels < 1 || avctx->channels > 6) {
74  av_log(avctx, AV_LOG_ERROR, "encoding %d channel(s) is not allowed\n", avctx->channels);
75  ret = AVERROR(EINVAL);
76  goto error;
77  }
78 
79  s->faac_handle = faacEncOpen(avctx->sample_rate,
80  avctx->channels,
81  &samples_input, &max_bytes_output);
82  if (!s->faac_handle) {
83  av_log(avctx, AV_LOG_ERROR, "error in faacEncOpen()\n");
84  ret = AVERROR_UNKNOWN;
85  goto error;
86  }
87 
88  /* check faac version */
89  faac_cfg = faacEncGetCurrentConfiguration(s->faac_handle);
90  if (faac_cfg->version != FAAC_CFG_VERSION) {
91  av_log(avctx, AV_LOG_ERROR, "wrong libfaac version (compiled for: %d, using %d)\n", FAAC_CFG_VERSION, faac_cfg->version);
92  ret = AVERROR(EINVAL);
93  goto error;
94  }
95 
96  /* put the options in the configuration struct */
97  switch(avctx->profile) {
99  faac_cfg->aacObjectType = MAIN;
100  break;
101  case FF_PROFILE_UNKNOWN:
102  case FF_PROFILE_AAC_LOW:
103  faac_cfg->aacObjectType = LOW;
104  break;
105  case FF_PROFILE_AAC_SSR:
106  faac_cfg->aacObjectType = SSR;
107  break;
108  case FF_PROFILE_AAC_LTP:
109  faac_cfg->aacObjectType = LTP;
110  break;
111  default:
112  av_log(avctx, AV_LOG_ERROR, "invalid AAC profile\n");
113  ret = AVERROR(EINVAL);
114  goto error;
115  }
116  faac_cfg->mpegVersion = MPEG4;
117  faac_cfg->useTns = 0;
118  faac_cfg->allowMidside = 1;
119  faac_cfg->bitRate = avctx->bit_rate / avctx->channels;
120  faac_cfg->bandWidth = avctx->cutoff;
121  if(avctx->flags & CODEC_FLAG_QSCALE) {
122  faac_cfg->bitRate = 0;
123  faac_cfg->quantqual = avctx->global_quality / FF_QP2LAMBDA;
124  }
125  faac_cfg->outputFormat = 1;
126  faac_cfg->inputFormat = FAAC_INPUT_16BIT;
127  if (avctx->channels > 2)
128  memcpy(faac_cfg->channel_map, channel_maps[avctx->channels-3],
129  avctx->channels * sizeof(int));
130 
131  avctx->frame_size = samples_input / avctx->channels;
132 
133  /* Set decoder specific info */
134  avctx->extradata_size = 0;
135  if (avctx->flags & CODEC_FLAG_GLOBAL_HEADER) {
136 
137  unsigned char *buffer = NULL;
138  unsigned long decoder_specific_info_size;
139 
140  if (!faacEncGetDecoderSpecificInfo(s->faac_handle, &buffer,
141  &decoder_specific_info_size)) {
142  avctx->extradata = av_malloc(decoder_specific_info_size + FF_INPUT_BUFFER_PADDING_SIZE);
143  if (!avctx->extradata) {
144  ret = AVERROR(ENOMEM);
145  goto error;
146  }
147  avctx->extradata_size = decoder_specific_info_size;
148  memcpy(avctx->extradata, buffer, avctx->extradata_size);
149  faac_cfg->outputFormat = 0;
150  }
151  free(buffer);
152  }
153 
154  if (!faacEncSetConfiguration(s->faac_handle, faac_cfg)) {
155  av_log(avctx, AV_LOG_ERROR, "libfaac doesn't support this output format!\n");
156  ret = AVERROR(EINVAL);
157  goto error;
158  }
159 
160  avctx->delay = FAAC_DELAY_SAMPLES;
161  ff_af_queue_init(avctx, &s->afq);
162 
163  return 0;
164 error:
165  Faac_encode_close(avctx);
166  return ret;
167 }
168 
169 static int Faac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
170  const AVFrame *frame, int *got_packet_ptr)
171 {
172  FaacAudioContext *s = avctx->priv_data;
173  int bytes_written, ret;
174  int num_samples = frame ? frame->nb_samples : 0;
175  void *samples = frame ? frame->data[0] : NULL;
176 
177  if ((ret = ff_alloc_packet(avpkt, (7 + 768) * avctx->channels))) {
178  av_log(avctx, AV_LOG_ERROR, "Error getting output packet\n");
179  return ret;
180  }
181 
182  bytes_written = faacEncEncode(s->faac_handle, samples,
183  num_samples * avctx->channels,
184  avpkt->data, avpkt->size);
185  if (bytes_written < 0) {
186  av_log(avctx, AV_LOG_ERROR, "faacEncEncode() error\n");
187  return bytes_written;
188  }
189 
190  /* add current frame to the queue */
191  if (frame) {
192  if ((ret = ff_af_queue_add(&s->afq, frame)) < 0)
193  return ret;
194  }
195 
196  if (!bytes_written)
197  return 0;
198 
199  /* Get the next frame pts/duration */
200  ff_af_queue_remove(&s->afq, avctx->frame_size, &avpkt->pts,
201  &avpkt->duration);
202 
203  avpkt->size = bytes_written;
204  *got_packet_ptr = 1;
205  return 0;
206 }
207 
208 static const AVProfile profiles[] = {
209  { FF_PROFILE_AAC_MAIN, "Main" },
210  { FF_PROFILE_AAC_LOW, "LC" },
211  { FF_PROFILE_AAC_SSR, "SSR" },
212  { FF_PROFILE_AAC_LTP, "LTP" },
213  { FF_PROFILE_UNKNOWN },
214 };
215 
216 static const uint64_t faac_channel_layouts[] = {
223  0
224 };
225 
227  .name = "libfaac",
228  .long_name = NULL_IF_CONFIG_SMALL("libfaac AAC (Advanced Audio Coding)"),
229  .type = AVMEDIA_TYPE_AUDIO,
230  .id = AV_CODEC_ID_AAC,
231  .priv_data_size = sizeof(FaacAudioContext),
233  .encode2 = Faac_encode_frame,
236  .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
238  .profiles = NULL_IF_CONFIG_SMALL(profiles),
239  .channel_layouts = faac_channel_layouts,
240 };
faacEncHandle faac_handle
Definition: libfaac.c:40
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:62
This structure describes decoded (raw) audio or video data.
Definition: frame.h:135
#define AV_CH_LAYOUT_SURROUND
static av_cold int Faac_encode_init(AVCodecContext *avctx)
Definition: libfaac.c:65
int size
Definition: avcodec.h:974
#define FF_PROFILE_AAC_MAIN
Definition: avcodec.h:2626
#define AV_CH_LAYOUT_4POINT0
#define AV_CH_LAYOUT_STEREO
int profile
profile
Definition: avcodec.h:2622
AVCodec.
Definition: avcodec.h:2796
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
Definition: mem.c:198
AudioFrameQueue afq
Definition: libfaac.c:41
#define av_cold
Definition: attributes.h:66
#define CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
Definition: avcodec.h:657
av_cold void ff_af_queue_init(AVCodecContext *avctx, AudioFrameQueue *afq)
Initialize AudioFrameQueue.
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1164
static av_cold int Faac_encode_close(AVCodecContext *avctx)
Definition: libfaac.c:45
AVCodec ff_libfaac_encoder
Definition: libfaac.c:226
#define FF_PROFILE_AAC_LTP
Definition: avcodec.h:2629
uint8_t * data
Definition: avcodec.h:973
int duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: avcodec.h:991
static int Faac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Definition: libfaac.c:169
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:123
#define 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:713
#define AVERROR(e)
Definition: error.h:43
sample_fmts
Definition: avconv_filter.c:68
#define CODEC_CAP_SMALL_LAST_FRAME
Codec can be fed a final frame with a smaller size.
Definition: avcodec.h:718
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:150
#define FAAC_DELAY_SAMPLES
Definition: libfaac.c:37
int flags
CODEC_FLAG_*.
Definition: avcodec.h:1144
#define CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:611
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:168
const char * name
Name of the codec implementation.
Definition: avcodec.h:2803
int ff_af_queue_add(AudioFrameQueue *afq, const AVFrame *f)
Add a frame to the queue.
#define FF_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:531
int bit_rate
the average bitrate
Definition: avcodec.h:1114
audio channel layout utility functions
#define FF_PROFILE_AAC_LOW
Definition: avcodec.h:2627
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:2623
static const uint64_t faac_channel_layouts[]
Definition: libfaac.c:216
static char buffer[20]
Definition: seek-test.c:31
int ff_alloc_packet(AVPacket *avpkt, int size)
Check AVPacket size and/or allocate data.
Definition: utils.c:1245
#define AV_CH_LAYOUT_5POINT1_BACK
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1811
NULL
Definition: eval.c:55
Libavcodec external API header.
AVSampleFormat
Audio Sample Formats.
Definition: samplefmt.h:61
AV_SAMPLE_FMT_NONE
Definition: avconv_filter.c:68
int sample_rate
samples per second
Definition: avcodec.h:1791
main external API structure.
Definition: avcodec.h:1050
static void close(AVCodecParserContext *s)
Definition: h264_parser.c:490
#define FF_PROFILE_AAC_SSR
Definition: avcodec.h:2628
int extradata_size
Definition: avcodec.h:1165
#define AV_CH_LAYOUT_5POINT0_BACK
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:1130
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:141
static const AVProfile profiles[]
Definition: libfaac.c:208
common internal api header.
common internal and external API header
signed 16 bits
Definition: samplefmt.h:64
static const int channel_maps[][6]
Definition: libfaac.c:58
AVProfile.
Definition: avcodec.h:2784
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:61
static av_cold int init(AVCodecParserContext *s)
Definition: h264_parser.c:499
void * priv_data
Definition: avcodec.h:1092
int cutoff
Audio cutoff bandwidth (0 means "automatic")
Definition: avcodec.h:1835
void ff_af_queue_remove(AudioFrameQueue *afq, int nb_samples, int64_t *pts, int *duration)
Remove frame(s) from the queue.
int channels
number of audio channels
Definition: avcodec.h:1792
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:207
void ff_af_queue_close(AudioFrameQueue *afq)
Close AudioFrameQueue.
#define MAIN
Definition: vf_overlay.c:73
#define AV_CH_LAYOUT_MONO
This structure stores compressed data.
Definition: avcodec.h:950
int delay
Codec delay.
Definition: avcodec.h:1212
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:179
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:966