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