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 #if FF_API_OLD_ENCODE_AUDIO
50  av_freep(&avctx->coded_frame);
51 #endif
52  av_freep(&avctx->extradata);
54 
55  if (s->faac_handle)
56  faacEncClose(s->faac_handle);
57 
58  return 0;
59 }
60 
61 static const int channel_maps[][6] = {
62  { 2, 0, 1 }, //< C L R
63  { 2, 0, 1, 3 }, //< C L R Cs
64  { 2, 0, 1, 3, 4 }, //< C L R Ls Rs
65  { 2, 0, 1, 4, 5, 3 }, //< C L R Ls Rs LFE
66 };
67 
69 {
70  FaacAudioContext *s = avctx->priv_data;
71  faacEncConfigurationPtr faac_cfg;
72  unsigned long samples_input, max_bytes_output;
73  int ret;
74 
75  /* number of channels */
76  if (avctx->channels < 1 || avctx->channels > 6) {
77  av_log(avctx, AV_LOG_ERROR, "encoding %d channel(s) is not allowed\n", avctx->channels);
78  ret = AVERROR(EINVAL);
79  goto error;
80  }
81 
82  s->faac_handle = faacEncOpen(avctx->sample_rate,
83  avctx->channels,
84  &samples_input, &max_bytes_output);
85  if (!s->faac_handle) {
86  av_log(avctx, AV_LOG_ERROR, "error in faacEncOpen()\n");
87  ret = AVERROR_UNKNOWN;
88  goto error;
89  }
90 
91  /* check faac version */
92  faac_cfg = faacEncGetCurrentConfiguration(s->faac_handle);
93  if (faac_cfg->version != FAAC_CFG_VERSION) {
94  av_log(avctx, AV_LOG_ERROR, "wrong libfaac version (compiled for: %d, using %d)\n", FAAC_CFG_VERSION, faac_cfg->version);
95  ret = AVERROR(EINVAL);
96  goto error;
97  }
98 
99  /* put the options in the configuration struct */
100  switch(avctx->profile) {
101  case FF_PROFILE_AAC_MAIN:
102  faac_cfg->aacObjectType = MAIN;
103  break;
104  case FF_PROFILE_UNKNOWN:
105  case FF_PROFILE_AAC_LOW:
106  faac_cfg->aacObjectType = LOW;
107  break;
108  case FF_PROFILE_AAC_SSR:
109  faac_cfg->aacObjectType = SSR;
110  break;
111  case FF_PROFILE_AAC_LTP:
112  faac_cfg->aacObjectType = LTP;
113  break;
114  default:
115  av_log(avctx, AV_LOG_ERROR, "invalid AAC profile\n");
116  ret = AVERROR(EINVAL);
117  goto error;
118  }
119  faac_cfg->mpegVersion = MPEG4;
120  faac_cfg->useTns = 0;
121  faac_cfg->allowMidside = 1;
122  faac_cfg->bitRate = avctx->bit_rate / avctx->channels;
123  faac_cfg->bandWidth = avctx->cutoff;
124  if(avctx->flags & CODEC_FLAG_QSCALE) {
125  faac_cfg->bitRate = 0;
126  faac_cfg->quantqual = avctx->global_quality / FF_QP2LAMBDA;
127  }
128  faac_cfg->outputFormat = 1;
129  faac_cfg->inputFormat = FAAC_INPUT_16BIT;
130  if (avctx->channels > 2)
131  memcpy(faac_cfg->channel_map, channel_maps[avctx->channels-3],
132  avctx->channels * sizeof(int));
133 
134  avctx->frame_size = samples_input / avctx->channels;
135 
136 #if FF_API_OLD_ENCODE_AUDIO
138  if (!avctx->coded_frame) {
139  ret = AVERROR(ENOMEM);
140  goto error;
141  }
142 #endif
143 
144  /* Set decoder specific info */
145  avctx->extradata_size = 0;
146  if (avctx->flags & CODEC_FLAG_GLOBAL_HEADER) {
147 
148  unsigned char *buffer = NULL;
149  unsigned long decoder_specific_info_size;
150 
151  if (!faacEncGetDecoderSpecificInfo(s->faac_handle, &buffer,
152  &decoder_specific_info_size)) {
153  avctx->extradata = av_malloc(decoder_specific_info_size + FF_INPUT_BUFFER_PADDING_SIZE);
154  if (!avctx->extradata) {
155  ret = AVERROR(ENOMEM);
156  goto error;
157  }
158  avctx->extradata_size = decoder_specific_info_size;
159  memcpy(avctx->extradata, buffer, avctx->extradata_size);
160  faac_cfg->outputFormat = 0;
161  }
162  free(buffer);
163  }
164 
165  if (!faacEncSetConfiguration(s->faac_handle, faac_cfg)) {
166  av_log(avctx, AV_LOG_ERROR, "libfaac doesn't support this output format!\n");
167  ret = AVERROR(EINVAL);
168  goto error;
169  }
170 
171  avctx->delay = FAAC_DELAY_SAMPLES;
172  ff_af_queue_init(avctx, &s->afq);
173 
174  return 0;
175 error:
176  Faac_encode_close(avctx);
177  return ret;
178 }
179 
180 static int Faac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
181  const AVFrame *frame, int *got_packet_ptr)
182 {
183  FaacAudioContext *s = avctx->priv_data;
184  int bytes_written, ret;
185  int num_samples = frame ? frame->nb_samples : 0;
186  void *samples = frame ? frame->data[0] : NULL;
187 
188  if ((ret = ff_alloc_packet(avpkt, (7 + 768) * avctx->channels))) {
189  av_log(avctx, AV_LOG_ERROR, "Error getting output packet\n");
190  return ret;
191  }
192 
193  bytes_written = faacEncEncode(s->faac_handle, samples,
194  num_samples * avctx->channels,
195  avpkt->data, avpkt->size);
196  if (bytes_written < 0) {
197  av_log(avctx, AV_LOG_ERROR, "faacEncEncode() error\n");
198  return bytes_written;
199  }
200 
201  /* add current frame to the queue */
202  if (frame) {
203  if ((ret = ff_af_queue_add(&s->afq, frame)) < 0)
204  return ret;
205  }
206 
207  if (!bytes_written)
208  return 0;
209 
210  /* Get the next frame pts/duration */
211  ff_af_queue_remove(&s->afq, avctx->frame_size, &avpkt->pts,
212  &avpkt->duration);
213 
214  avpkt->size = bytes_written;
215  *got_packet_ptr = 1;
216  return 0;
217 }
218 
219 static const AVProfile profiles[] = {
220  { FF_PROFILE_AAC_MAIN, "Main" },
221  { FF_PROFILE_AAC_LOW, "LC" },
222  { FF_PROFILE_AAC_SSR, "SSR" },
223  { FF_PROFILE_AAC_LTP, "LTP" },
224  { FF_PROFILE_UNKNOWN },
225 };
226 
227 static const uint64_t faac_channel_layouts[] = {
234  0
235 };
236 
238  .name = "libfaac",
239  .type = AVMEDIA_TYPE_AUDIO,
240  .id = AV_CODEC_ID_AAC,
241  .priv_data_size = sizeof(FaacAudioContext),
243  .encode2 = Faac_encode_frame,
246  .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
248  .long_name = NULL_IF_CONFIG_SMALL("libfaac AAC (Advanced Audio Coding)"),
249  .profiles = NULL_IF_CONFIG_SMALL(profiles),
250  .channel_layouts = faac_channel_layouts,
251 };
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:61
static int16_t * samples
This structure describes decoded (raw) audio or video data.
Definition: avcodec.h:989
#define AV_CH_LAYOUT_SURROUND
static av_cold int Faac_encode_init(AVCodecContext *avctx)
Definition: libfaac.c:68
AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:2725
int size
Definition: avcodec.h:916
#define AV_CH_LAYOUT_4POINT0
#define AV_CH_LAYOUT_STEREO
signed 16 bits
Definition: samplefmt.h:52
int profile
profile
Definition: avcodec.h:2815
AVCodec.
Definition: avcodec.h:2960
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:151
AudioFrameQueue afq
Definition: libfaac.c:41
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1454
static av_cold int Faac_encode_close(AVCodecContext *avctx)
Definition: libfaac.c:45
AVCodec ff_libfaac_encoder
Definition: libfaac.c:237
uint8_t * data
Definition: avcodec.h:915
int duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: avcodec.h:937
static int Faac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Definition: libfaac.c:180
static int init(AVCodecParserContext *s)
Definition: h264_parser.c:335
sample_fmts
Definition: avconv_filter.c:63
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:88
#define FAAC_DELAY_SAMPLES
Definition: libfaac.c:37
int flags
CODEC_FLAG_*.
Definition: avcodec.h:1434
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:146
const char * name
Name of the codec implementation.
Definition: avcodec.h:2967
int ff_af_queue_add(AudioFrameQueue *afq, const AVFrame *f)
Add a frame to the queue.
AVFrame * avcodec_alloc_frame(void)
Allocate an AVFrame and set its fields to default values.
Definition: utils.c:618
int bit_rate
the average bitrate
Definition: avcodec.h:1404
audio channel layout utility functions
static const uint64_t faac_channel_layouts[]
Definition: libfaac.c:227
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:880
#define AV_CH_LAYOUT_5POINT1_BACK
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:2124
NULL
Definition: eval.c:52
external API header
AV_SAMPLE_FMT_NONE
Definition: avconv_filter.c:63
int sample_rate
samples per second
Definition: avcodec.h:2104
main external API structure.
Definition: avcodec.h:1339
static void close(AVCodecParserContext *s)
Definition: h264_parser.c:326
int extradata_size
Definition: avcodec.h:1455
#define AV_CH_LAYOUT_5POINT0_BACK
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:1420
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: avcodec.h:997
static const AVProfile profiles[]
Definition: libfaac.c:219
common internal api header.
common internal and external API header
AVSampleFormat
Audio Sample Formats.
Definition: samplefmt.h:49
static const int channel_maps[][6]
Definition: libfaac.c:61
AVProfile.
Definition: avcodec.h:2948
void * priv_data
Definition: avcodec.h:1382
int cutoff
Audio cutoff bandwidth (0 means "automatic")
Definition: avcodec.h:2148
struct FaacAudioContext FaacAudioContext
void ff_af_queue_init(AVCodecContext *avctx, AudioFrameQueue *afq)
Initialize AudioFrameQueue.
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:2105
void ff_af_queue_close(AudioFrameQueue *afq)
Close AudioFrameQueue.
#define MAIN
Definition: vf_overlay.c:62
#define AV_CH_LAYOUT_MONO
This structure stores compressed data.
Definition: avcodec.h:898
int delay
Codec delay.
Definition: avcodec.h:1497
int nb_samples
number of audio samples (per channel) described by this frame
Definition: avcodec.h:1042
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:908