Add a libfdk-aac decoder
[ffmpeg.git] / libavcodec / libfdk-aacdec.c
1 /*
2  * AAC decoder wrapper
3  * Copyright (c) 2012 Martin Storsjo
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
22 #include <fdk-aac/aacdecoder_lib.h>
23
24 #include "libavutil/channel_layout.h"
25 #include "libavutil/common.h"
26 #include "libavutil/opt.h"
27 #include "avcodec.h"
28 #include "internal.h"
29
30 enum ConcealMethod {
31     CONCEAL_METHOD_DEFAULT              = -1,
32     CONCEAL_METHOD_SPECTRAL_MUTING      =  0,
33     CONCEAL_METHOD_NOISE_SUBSTITUTION   =  1,
34     CONCEAL_METHOD_ENERGY_INTERPOLATION =  2,
35     CONCEAL_METHOD_NB,
36 };
37
38 typedef struct FDKAACDecContext {
39     const AVClass *class;
40     HANDLE_AACDECODER handle;
41     int initialized;
42     enum ConcealMethod conceal_method;
43 } FDKAACDecContext;
44
45 #define OFFSET(x) offsetof(FDKAACDecContext, x)
46 #define AD AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM
47 static const AVOption fdk_aac_dec_options[] = {
48     { "conceal", "Error concealment method", OFFSET(conceal_method), AV_OPT_TYPE_INT, { .i64 = CONCEAL_METHOD_DEFAULT }, CONCEAL_METHOD_DEFAULT, CONCEAL_METHOD_NB - 1, AD, "conceal" },
49     { "default",  "Default",              0, AV_OPT_TYPE_CONST, { .i64 = CONCEAL_METHOD_DEFAULT },              INT_MIN, INT_MAX, AD, "conceal" },
50     { "spectral", "Spectral muting",      0, AV_OPT_TYPE_CONST, { .i64 = CONCEAL_METHOD_SPECTRAL_MUTING },      INT_MIN, INT_MAX, AD, "conceal" },
51     { "noise",    "Noise Substitution",   0, AV_OPT_TYPE_CONST, { .i64 = CONCEAL_METHOD_NOISE_SUBSTITUTION },   INT_MIN, INT_MAX, AD, "conceal" },
52     { "energy",   "Energy Interpolation", 0, AV_OPT_TYPE_CONST, { .i64 = CONCEAL_METHOD_ENERGY_INTERPOLATION }, INT_MIN, INT_MAX, AD, "conceal" },
53     { NULL }
54 };
55
56 static const AVClass fdk_aac_dec_class = {
57     "libfdk-aac decoder", av_default_item_name, fdk_aac_dec_options, LIBAVUTIL_VERSION_INT
58 };
59
60 static int get_stream_info(AVCodecContext *avctx)
61 {
62     FDKAACDecContext *s   = avctx->priv_data;
63     CStreamInfo *info     = aacDecoder_GetStreamInfo(s->handle);
64     int channel_counts[9] = { 0 };
65     int i, ch_error       = 0;
66     uint64_t ch_layout    = 0;
67
68     if (!info) {
69         av_log(avctx, AV_LOG_ERROR, "Unable to get stream info\n");
70         return AVERROR_UNKNOWN;
71     }
72
73     if (info->sampleRate <= 0) {
74         av_log(avctx, AV_LOG_ERROR, "Stream info not initialized\n");
75         return AVERROR_UNKNOWN;
76     }
77     avctx->sample_rate = info->sampleRate;
78     avctx->frame_size  = info->frameSize;
79
80     for (i = 0; i < info->numChannels; i++) {
81         AUDIO_CHANNEL_TYPE ctype = info->pChannelType[i];
82         if (ctype <= ACT_NONE || ctype > ACT_TOP) {
83             av_log(avctx, AV_LOG_WARNING, "unknown channel type\n");
84             break;
85         }
86         channel_counts[ctype]++;
87     }
88     av_log(avctx, AV_LOG_DEBUG, "%d channels - front:%d side:%d back:%d lfe:%d top:%d\n",
89            info->numChannels,
90            channel_counts[ACT_FRONT], channel_counts[ACT_SIDE],
91            channel_counts[ACT_BACK],  channel_counts[ACT_LFE],
92            channel_counts[ACT_FRONT_TOP] + channel_counts[ACT_SIDE_TOP] +
93            channel_counts[ACT_BACK_TOP] +  channel_counts[ACT_TOP]);
94
95     switch (channel_counts[ACT_FRONT]) {
96     case 4:
97         ch_layout |= AV_CH_LAYOUT_STEREO | AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER;
98         break;
99     case 3:
100         ch_layout |= AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER;
101         break;
102     case 2:
103         ch_layout |= AV_CH_LAYOUT_STEREO;
104         break;
105     case 1:
106         ch_layout |= AV_CH_FRONT_CENTER;
107         break;
108     default:
109         av_log(avctx, AV_LOG_WARNING, "unsupported number of front channels: %d\n",
110                 channel_counts[ACT_FRONT]);
111         ch_error = 1;
112         break;
113     }
114     if (channel_counts[ACT_SIDE] > 0) {
115         if (channel_counts[ACT_SIDE] == 2) {
116             ch_layout |= AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT;
117         } else {
118             av_log(avctx, AV_LOG_WARNING, "unsupported number of side channels: %d\n",
119                    channel_counts[ACT_SIDE]);
120             ch_error = 1;
121         }
122     }
123     if (channel_counts[ACT_BACK] > 0) {
124         switch (channel_counts[ACT_BACK]) {
125         case 3:
126             ch_layout |= AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT | AV_CH_BACK_CENTER;
127             break;
128         case 2:
129             ch_layout |= AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT;
130             break;
131         case 1:
132             ch_layout |= AV_CH_BACK_CENTER;
133             break;
134         default:
135             av_log(avctx, AV_LOG_WARNING, "unsupported number of back channels: %d\n",
136                     channel_counts[ACT_BACK]);
137             ch_error = 1;
138             break;
139         }
140     }
141     if (channel_counts[ACT_LFE] > 0) {
142         if (channel_counts[ACT_LFE] == 1) {
143             ch_layout |= AV_CH_LOW_FREQUENCY;
144         } else {
145             av_log(avctx, AV_LOG_WARNING, "unsupported number of LFE channels: %d\n",
146                    channel_counts[ACT_LFE]);
147             ch_error = 1;
148         }
149     }
150     if (!ch_error &&
151         av_get_channel_layout_nb_channels(ch_layout) != info->numChannels) {
152         av_log(avctx, AV_LOG_WARNING, "unsupported channel configuration\n");
153         ch_error = 1;
154     }
155     if (ch_error)
156         avctx->channel_layout = 0;
157     else
158         avctx->channel_layout = ch_layout;
159
160     avctx->channels = info->numChannels;
161
162     return 0;
163 }
164
165 static av_cold int fdk_aac_decode_close(AVCodecContext *avctx)
166 {
167     FDKAACDecContext *s = avctx->priv_data;
168
169     if (s->handle)
170         aacDecoder_Close(s->handle);
171
172     return 0;
173 }
174
175 static av_cold int fdk_aac_decode_init(AVCodecContext *avctx)
176 {
177     FDKAACDecContext *s = avctx->priv_data;
178     AAC_DECODER_ERROR err;
179
180     s->handle = aacDecoder_Open(avctx->extradata_size ? TT_MP4_RAW : TT_MP4_ADTS, 1);
181     if (!s->handle) {
182         av_log(avctx, AV_LOG_ERROR, "Error opening decoder\n");
183         return AVERROR_UNKNOWN;
184     }
185
186     if (avctx->extradata_size) {
187         if ((err = aacDecoder_ConfigRaw(s->handle, &avctx->extradata, &avctx->extradata_size)) != AAC_DEC_OK) {
188             av_log(avctx, AV_LOG_ERROR, "Unable to set extradata\n");
189             return AVERROR_INVALIDDATA;
190         }
191     }
192
193     if (s->conceal_method != CONCEAL_METHOD_DEFAULT) {
194         if ((err = aacDecoder_SetParam(s->handle, AAC_CONCEAL_METHOD, s->conceal_method)) != AAC_DEC_OK) {
195             av_log(avctx, AV_LOG_ERROR, "Unable to set error concealment method\n");
196             return AVERROR_UNKNOWN;
197         }
198     }
199
200     avctx->sample_fmt = AV_SAMPLE_FMT_S16;
201
202     return 0;
203 }
204
205 static int fdk_aac_decode_frame(AVCodecContext *avctx, void *data,
206                                 int *got_frame_ptr, AVPacket *avpkt)
207 {
208     FDKAACDecContext *s = avctx->priv_data;
209     AVFrame *frame = data;
210     int ret;
211     AAC_DECODER_ERROR err;
212     UINT valid = avpkt->size;
213     uint8_t *buf, *tmpptr = NULL;
214     int buf_size;
215
216     err = aacDecoder_Fill(s->handle, &avpkt->data, &avpkt->size, &valid);
217     if (err != AAC_DEC_OK) {
218         av_log(avctx, AV_LOG_ERROR, "aacDecoder_Fill() failed: %x\n", err);
219         return AVERROR_INVALIDDATA;
220     }
221
222     if (s->initialized) {
223         frame->nb_samples = avctx->frame_size;
224         if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
225             av_log(avctx, AV_LOG_ERROR, "ff_get_buffer() failed\n");
226             return ret;
227         }
228         buf = frame->extended_data[0];
229         buf_size = avctx->channels * frame->nb_samples *
230                    av_get_bytes_per_sample(avctx->sample_fmt);
231     } else {
232         buf_size = 50 * 1024;
233         buf = tmpptr = av_malloc(buf_size);
234         if (!buf)
235             return AVERROR(ENOMEM);
236     }
237
238     err = aacDecoder_DecodeFrame(s->handle, (INT_PCM *) buf, buf_size, 0);
239     if (err == AAC_DEC_NOT_ENOUGH_BITS) {
240         ret = avpkt->size - valid;
241         goto end;
242     }
243     if (err != AAC_DEC_OK) {
244         av_log(avctx, AV_LOG_ERROR, "aacDecoder_DecodeFrame() failed: %x\n", err);
245         ret = AVERROR_UNKNOWN;
246         goto end;
247     }
248
249     if (!s->initialized) {
250         if ((ret = get_stream_info(avctx)) < 0)
251             goto end;
252         s->initialized = 1;
253         frame->nb_samples = avctx->frame_size;
254     }
255
256     if (tmpptr) {
257         frame->nb_samples = avctx->frame_size;
258         if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
259             av_log(avctx, AV_LOG_ERROR, "ff_get_buffer() failed\n");
260             goto end;
261         }
262         memcpy(frame->extended_data[0], tmpptr,
263                avctx->channels * avctx->frame_size *
264                av_get_bytes_per_sample(avctx->sample_fmt));
265     }
266
267     *got_frame_ptr = 1;
268     ret = avpkt->size - valid;
269
270 end:
271     av_free(tmpptr);
272     return ret;
273 }
274
275 static av_cold void fdk_aac_decode_flush(AVCodecContext *avctx)
276 {
277     FDKAACDecContext *s = avctx->priv_data;
278     AAC_DECODER_ERROR err;
279
280     if (!s->handle)
281         return;
282
283     if ((err = aacDecoder_SetParam(s->handle, AAC_TPDEC_CLEAR_BUFFER, 1)) != AAC_DEC_OK)
284         av_log(avctx, AV_LOG_WARNING, "failed to clear buffer when flushing\n");
285 }
286
287 AVCodec ff_libfdk_aac_decoder = {
288     .name           = "libfdk_aac",
289     .long_name      = NULL_IF_CONFIG_SMALL("Fraunhofer FDK AAC"),
290     .type           = AVMEDIA_TYPE_AUDIO,
291     .id             = AV_CODEC_ID_AAC,
292     .priv_data_size = sizeof(FDKAACDecContext),
293     .init           = fdk_aac_decode_init,
294     .decode         = fdk_aac_decode_frame,
295     .close          = fdk_aac_decode_close,
296     .flush          = fdk_aac_decode_flush,
297     .capabilities   = CODEC_CAP_DR1,
298     .priv_class     = &fdk_aac_dec_class,
299 };