← Back to branch summary

~ubuntu-branches/ubuntu/trusty/libav/trusty-proposed

« back to all changes in this revision

Viewing changes to libavcodec/libfdk-aacenc.c

  • Committer: Package Import Robot
  • Author(s): Reinhard Tartler
  • Date: 2013-10-22 23:24:08 UTC
  • mfrom: (1.3.36 sid)
  • Revision ID: package-import@ubuntu.com-20131022232408-b8tvvn4pyzri9mi3
Tags: 6:9.10-1ubuntu1
https://launchpad.net/bugs/1243235
https://launchpad.net/bugs/1180288
https://launchpad.net/bugs/1242802
* Build all -extra flavors from this source package, as libav got demoted
  from main to universe, cf LP: #1243235
* Simplify debian/rules to follow exactly the code that debian executes
* New upstream (LP: #1180288) fixes lots of security issues (LP: #1242802)
* Merge from unstable, remaining changes:
  - build-depend on libtiff5-dev rather than libtiff4-dev,
    avoids FTBFS caused by imlib
  - follow the regular debian codepaths

Show diffs side-by-side

added added

removed removed

Lines of Context:
libavcodec/libfdk-aacenc.c
 
1
/*
 
2
 * AAC encoder 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/aacenc_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 "audio_frame_queue.h"
 
29
#include "internal.h"
 
30
 
 
31
typedef struct AACContext {
 
32
    const AVClass *class;
 
33
    HANDLE_AACENCODER handle;
 
34
    int afterburner;
 
35
    int eld_sbr;
 
36
    int signaling;
 
37
    int latm;
 
38
    int header_period;
 
39
    int vbr;
 
40
 
 
41
    AudioFrameQueue afq;
 
42
} AACContext;
 
43
 
 
44
static const AVOption aac_enc_options[] = {
 
45
    { "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 },
 
46
    { "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 },
 
47
    { "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" },
 
48
    { "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" },
 
49
    { "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" },
 
50
    { "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" },
 
51
    { "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" },
 
52
    { "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 },
 
53
    { "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 },
 
54
    { "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 },
 
55
    { NULL }
 
56
};
 
57
 
 
58
static const AVClass aac_enc_class = {
 
59
    "libfdk_aac", av_default_item_name, aac_enc_options, LIBAVUTIL_VERSION_INT
 
60
};
 
61
 
 
62
static const char *aac_get_error(AACENC_ERROR err)
 
63
{
 
64
    switch (err) {
 
65
    case AACENC_OK:
 
66
        return "No error";
 
67
    case AACENC_INVALID_HANDLE:
 
68
        return "Invalid handle";
 
69
    case AACENC_MEMORY_ERROR:
 
70
        return "Memory allocation error";
 
71
    case AACENC_UNSUPPORTED_PARAMETER:
 
72
        return "Unsupported parameter";
 
73
    case AACENC_INVALID_CONFIG:
 
74
        return "Invalid config";
 
75
    case AACENC_INIT_ERROR:
 
76
        return "Initialization error";
 
77
    case AACENC_INIT_AAC_ERROR:
 
78
        return "AAC library initialization error";
 
79
    case AACENC_INIT_SBR_ERROR:
 
80
        return "SBR library initialization error";
 
81
    case AACENC_INIT_TP_ERROR:
 
82
        return "Transport library initialization error";
 
83
    case AACENC_INIT_META_ERROR:
 
84
        return "Metadata library initialization error";
 
85
    case AACENC_ENCODE_ERROR:
 
86
        return "Encoding error";
 
87
    case AACENC_ENCODE_EOF:
 
88
        return "End of file";
 
89
    default:
 
90
        return "Unknown error";
 
91
    }
 
92
}
 
93
 
 
94
static int aac_encode_close(AVCodecContext *avctx)
 
95
{
 
96
    AACContext *s = avctx->priv_data;
 
97
 
 
98
    if (s->handle)
 
99
        aacEncClose(&s->handle);
 
100
#if FF_API_OLD_ENCODE_AUDIO
 
101
    av_freep(&avctx->coded_frame);
 
102
#endif
 
103
    av_freep(&avctx->extradata);
 
104
    ff_af_queue_close(&s->afq);
 
105
 
 
106
    return 0;
 
107
}
 
108
 
 
109
static av_cold int aac_encode_init(AVCodecContext *avctx)
 
110
{
 
111
    AACContext *s = avctx->priv_data;
 
112
    int ret = AVERROR(EINVAL);
 
113
    AACENC_InfoStruct info = { 0 };
 
114
    CHANNEL_MODE mode;
 
115
    AACENC_ERROR err;
 
116
    int aot = FF_PROFILE_AAC_LOW + 1;
 
117
    int sce = 0, cpe = 0;
 
118
 
 
119
    if ((err = aacEncOpen(&s->handle, 0, avctx->channels)) != AACENC_OK) {
 
120
        av_log(avctx, AV_LOG_ERROR, "Unable to open the encoder: %s\n",
 
121
               aac_get_error(err));
 
122
        goto error;
 
123
    }
 
124
 
 
125
    if (avctx->profile != FF_PROFILE_UNKNOWN)
 
126
        aot = avctx->profile + 1;
 
127
 
 
128
    if ((err = aacEncoder_SetParam(s->handle, AACENC_AOT, aot)) != AACENC_OK) {
 
129
        av_log(avctx, AV_LOG_ERROR, "Unable to set the AOT %d: %s\n",
 
130
               aot, aac_get_error(err));
 
131
        goto error;
 
132
    }
 
133
 
 
134
    if (aot == FF_PROFILE_AAC_ELD + 1 && s->eld_sbr) {
 
135
        if ((err = aacEncoder_SetParam(s->handle, AACENC_SBR_MODE,
 
136
                                       1)) != AACENC_OK) {
 
137
            av_log(avctx, AV_LOG_ERROR, "Unable to enable SBR for ELD: %s\n",
 
138
                   aac_get_error(err));
 
139
            goto error;
 
140
        }
 
141
    }
 
142
 
 
143
    if ((err = aacEncoder_SetParam(s->handle, AACENC_SAMPLERATE,
 
144
                                   avctx->sample_rate)) != AACENC_OK) {
 
145
        av_log(avctx, AV_LOG_ERROR, "Unable to set the sample rate %d: %s\n",
 
146
               avctx->sample_rate, aac_get_error(err));
 
147
        goto error;
 
148
    }
 
149
 
 
150
    switch (avctx->channels) {
 
151
    case 1: mode = MODE_1;       sce = 1; cpe = 0; break;
 
152
    case 2: mode = MODE_2;       sce = 0; cpe = 1; break;
 
153
    case 3: mode = MODE_1_2;     sce = 1; cpe = 1; break;
 
154
    case 4: mode = MODE_1_2_1;   sce = 2; cpe = 1; break;
 
155
    case 5: mode = MODE_1_2_2;   sce = 1; cpe = 2; break;
 
156
    case 6: mode = MODE_1_2_2_1; sce = 2; cpe = 2; break;
 
157
    default:
 
158
        av_log(avctx, AV_LOG_ERROR,
 
159
               "Unsupported number of channels %d\n", avctx->channels);
 
160
        goto error;
 
161
    }
 
162
 
 
163
    if ((err = aacEncoder_SetParam(s->handle, AACENC_CHANNELMODE,
 
164
                                   mode)) != AACENC_OK) {
 
165
        av_log(avctx, AV_LOG_ERROR,
 
166
               "Unable to set channel mode %d: %s\n", mode, aac_get_error(err));
 
167
        goto error;
 
168
    }
 
169
 
 
170
    if ((err = aacEncoder_SetParam(s->handle, AACENC_CHANNELORDER,
 
171
                                   1)) != AACENC_OK) {
 
172
        av_log(avctx, AV_LOG_ERROR,
 
173
               "Unable to set wav channel order %d: %s\n",
 
174
               mode, aac_get_error(err));
 
175
        goto error;
 
176
    }
 
177
 
 
178
    if (avctx->flags & CODEC_FLAG_QSCALE || s->vbr) {
 
179
        int mode = s->vbr ? s->vbr : avctx->global_quality;
 
180
        if (mode <  1 || mode > 5) {
 
181
            av_log(avctx, AV_LOG_WARNING,
 
182
                   "VBR quality %d out of range, should be 1-5\n", mode);
 
183
            mode = av_clip(mode, 1, 5);
 
184
        }
 
185
        av_log(avctx, AV_LOG_WARNING,
 
186
               "Note, the VBR setting is unsupported and only works with "
 
187
               "some parameter combinations\n");
 
188
        if ((err = aacEncoder_SetParam(s->handle, AACENC_BITRATEMODE,
 
189
                                       mode)) != AACENC_OK) {
 
190
            av_log(avctx, AV_LOG_ERROR, "Unable to set the VBR bitrate mode %d: %s\n",
 
191
                   mode, aac_get_error(err));
 
192
            goto error;
 
193
        }
 
194
    } else {
 
195
        if (avctx->bit_rate <= 0) {
 
196
            if (avctx->profile == FF_PROFILE_AAC_HE_V2) {
 
197
                sce = 1;
 
198
                cpe = 0;
 
199
            }
 
200
            avctx->bit_rate = (96*sce + 128*cpe) * avctx->sample_rate / 44;
 
201
            if (avctx->profile == FF_PROFILE_AAC_HE ||
 
202
                avctx->profile == FF_PROFILE_AAC_HE_V2 ||
 
203
                s->eld_sbr)
 
204
                avctx->bit_rate /= 2;
 
205
        }
 
206
        if ((err = aacEncoder_SetParam(s->handle, AACENC_BITRATE,
 
207
                                       avctx->bit_rate)) != AACENC_OK) {
 
208
            av_log(avctx, AV_LOG_ERROR, "Unable to set the bitrate %d: %s\n",
 
209
                   avctx->bit_rate, aac_get_error(err));
 
210
            goto error;
 
211
        }
 
212
    }
 
213
 
 
214
    /* Choose bitstream format - if global header is requested, use
 
215
     * raw access units, otherwise use ADTS. */
 
216
    if ((err = aacEncoder_SetParam(s->handle, AACENC_TRANSMUX,
 
217
                                   avctx->flags & CODEC_FLAG_GLOBAL_HEADER ? 0 : s->latm ? 10 : 2)) != AACENC_OK) {
 
218
        av_log(avctx, AV_LOG_ERROR, "Unable to set the transmux format: %s\n",
 
219
               aac_get_error(err));
 
220
        goto error;
 
221
    }
 
222
 
 
223
    if (s->latm && s->header_period) {
 
224
        if ((err = aacEncoder_SetParam(s->handle, AACENC_HEADER_PERIOD,
 
225
                                       s->header_period)) != AACENC_OK) {
 
226
             av_log(avctx, AV_LOG_ERROR, "Unable to set header period: %s\n",
 
227
                    aac_get_error(err));
 
228
             goto error;
 
229
        }
 
230
    }
 
231
 
 
232
    /* If no signaling mode is chosen, use explicit hierarchical signaling
 
233
     * if using mp4 mode (raw access units, with global header) and
 
234
     * implicit signaling if using ADTS. */
 
235
    if (s->signaling < 0)
 
236
        s->signaling = avctx->flags & CODEC_FLAG_GLOBAL_HEADER ? 2 : 0;
 
237
 
 
238
    if ((err = aacEncoder_SetParam(s->handle, AACENC_SIGNALING_MODE,
 
239
                                   s->signaling)) != AACENC_OK) {
 
240
        av_log(avctx, AV_LOG_ERROR, "Unable to set signaling mode %d: %s\n",
 
241
               s->signaling, aac_get_error(err));
 
242
        goto error;
 
243
    }
 
244
 
 
245
    if ((err = aacEncoder_SetParam(s->handle, AACENC_AFTERBURNER,
 
246
                                   s->afterburner)) != AACENC_OK) {
 
247
        av_log(avctx, AV_LOG_ERROR, "Unable to set afterburner to %d: %s\n",
 
248
               s->afterburner, aac_get_error(err));
 
249
        goto error;
 
250
    }
 
251
 
 
252
    if (avctx->cutoff > 0) {
 
253
        if (avctx->cutoff < (avctx->sample_rate + 255) >> 8) {
 
254
            av_log(avctx, AV_LOG_ERROR, "cutoff valid range is %d-20000\n",
 
255
                   (avctx->sample_rate + 255) >> 8);
 
256
            goto error;
 
257
        }
 
258
        if ((err = aacEncoder_SetParam(s->handle, AACENC_BANDWIDTH,
 
259
                                       avctx->cutoff)) != AACENC_OK) {
 
260
            av_log(avctx, AV_LOG_ERROR, "Unable to set the encoder bandwidth to %d: %s\n",
 
261
                   avctx->cutoff, aac_get_error(err));
 
262
            goto error;
 
263
        }
 
264
    }
 
265
 
 
266
    if ((err = aacEncEncode(s->handle, NULL, NULL, NULL, NULL)) != AACENC_OK) {
 
267
        av_log(avctx, AV_LOG_ERROR, "Unable to initialize the encoder: %s\n",
 
268
               aac_get_error(err));
 
269
        return AVERROR(EINVAL);
 
270
    }
 
271
 
 
272
    if ((err = aacEncInfo(s->handle, &info)) != AACENC_OK) {
 
273
        av_log(avctx, AV_LOG_ERROR, "Unable to get encoder info: %s\n",
 
274
               aac_get_error(err));
 
275
        goto error;
 
276
    }
 
277
 
 
278
#if FF_API_OLD_ENCODE_AUDIO
 
279
    avctx->coded_frame = avcodec_alloc_frame();
 
280
    if (!avctx->coded_frame) {
 
281
        ret = AVERROR(ENOMEM);
 
282
        goto error;
 
283
    }
 
284
#endif
 
285
    avctx->frame_size = info.frameLength;
 
286
    avctx->delay      = info.encoderDelay;
 
287
    ff_af_queue_init(avctx, &s->afq);
 
288
 
 
289
    if (avctx->flags & CODEC_FLAG_GLOBAL_HEADER) {
 
290
        avctx->extradata_size = info.confSize;
 
291
        avctx->extradata      = av_mallocz(avctx->extradata_size +
 
292
                                           FF_INPUT_BUFFER_PADDING_SIZE);
 
293
        if (!avctx->extradata) {
 
294
            ret = AVERROR(ENOMEM);
 
295
            goto error;
 
296
        }
 
297
 
 
298
        memcpy(avctx->extradata, info.confBuf, info.confSize);
 
299
    }
 
300
    return 0;
 
301
error:
 
302
    aac_encode_close(avctx);
 
303
    return ret;
 
304
}
 
305
 
 
306
static int aac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
 
307
                            const AVFrame *frame, int *got_packet_ptr)
 
308
{
 
309
    AACContext    *s        = avctx->priv_data;
 
310
    AACENC_BufDesc in_buf   = { 0 }, out_buf = { 0 };
 
311
    AACENC_InArgs  in_args  = { 0 };
 
312
    AACENC_OutArgs out_args = { 0 };
 
313
    int in_buffer_identifier = IN_AUDIO_DATA;
 
314
    int in_buffer_size, in_buffer_element_size;
 
315
    int out_buffer_identifier = OUT_BITSTREAM_DATA;
 
316
    int out_buffer_size, out_buffer_element_size;
 
317
    void *in_ptr, *out_ptr;
 
318
    int ret;
 
319
    AACENC_ERROR err;
 
320
 
 
321
    /* handle end-of-stream small frame and flushing */
 
322
    if (!frame) {
 
323
        in_args.numInSamples = -1;
 
324
    } else {
 
325
        in_ptr                   = frame->data[0];
 
326
        in_buffer_size           = 2 * avctx->channels * frame->nb_samples;
 
327
        in_buffer_element_size   = 2;
 
328
 
 
329
        in_args.numInSamples     = avctx->channels * frame->nb_samples;
 
330
        in_buf.numBufs           = 1;
 
331
        in_buf.bufs              = &in_ptr;
 
332
        in_buf.bufferIdentifiers = &in_buffer_identifier;
 
333
        in_buf.bufSizes          = &in_buffer_size;
 
334
        in_buf.bufElSizes        = &in_buffer_element_size;
 
335
 
 
336
        /* add current frame to the queue */
 
337
        if ((ret = ff_af_queue_add(&s->afq, frame)) < 0)
 
338
            return ret;
 
339
    }
 
340
 
 
341
    /* The maximum packet size is 6144 bits aka 768 bytes per channel. */
 
342
    if ((ret = ff_alloc_packet(avpkt, FFMAX(8192, 768 * avctx->channels)))) {
 
343
        av_log(avctx, AV_LOG_ERROR, "Error getting output packet\n");
 
344
        return ret;
 
345
    }
 
346
 
 
347
    out_ptr                   = avpkt->data;
 
348
    out_buffer_size           = avpkt->size;
 
349
    out_buffer_element_size   = 1;
 
350
    out_buf.numBufs           = 1;
 
351
    out_buf.bufs              = &out_ptr;
 
352
    out_buf.bufferIdentifiers = &out_buffer_identifier;
 
353
    out_buf.bufSizes          = &out_buffer_size;
 
354
    out_buf.bufElSizes        = &out_buffer_element_size;
 
355
 
 
356
    if ((err = aacEncEncode(s->handle, &in_buf, &out_buf, &in_args,
 
357
                            &out_args)) != AACENC_OK) {
 
358
        if (!frame && err == AACENC_ENCODE_EOF)
 
359
            return 0;
 
360
        av_log(avctx, AV_LOG_ERROR, "Unable to encode frame: %s\n",
 
361
               aac_get_error(err));
 
362
        return AVERROR(EINVAL);
 
363
    }
 
364
 
 
365
    if (!out_args.numOutBytes)
 
366
        return 0;
 
367
 
 
368
    /* Get the next frame pts & duration */
 
369
    ff_af_queue_remove(&s->afq, avctx->frame_size, &avpkt->pts,
 
370
                       &avpkt->duration);
 
371
 
 
372
    avpkt->size     = out_args.numOutBytes;
 
373
    *got_packet_ptr = 1;
 
374
    return 0;
 
375
}
 
376
 
 
377
static const AVProfile profiles[] = {
 
378
    { FF_PROFILE_AAC_LOW,   "LC"       },
 
379
    { FF_PROFILE_AAC_HE,    "HE-AAC"   },
 
380
    { FF_PROFILE_AAC_HE_V2, "HE-AACv2" },
 
381
    { FF_PROFILE_AAC_LD,    "LD"       },
 
382
    { FF_PROFILE_AAC_ELD,   "ELD"      },
 
383
    { FF_PROFILE_UNKNOWN },
 
384
};
 
385
 
 
386
static const AVCodecDefault aac_encode_defaults[] = {
 
387
    { "b", "0" },
 
388
    { NULL }
 
389
};
 
390
 
 
391
static const uint64_t aac_channel_layout[] = {
 
392
    AV_CH_LAYOUT_MONO,
 
393
    AV_CH_LAYOUT_STEREO,
 
394
    AV_CH_LAYOUT_SURROUND,
 
395
    AV_CH_LAYOUT_4POINT0,
 
396
    AV_CH_LAYOUT_5POINT0_BACK,
 
397
    AV_CH_LAYOUT_5POINT1_BACK,
 
398
    0,
 
399
};
 
400
 
 
401
static const int aac_sample_rates[] = {
 
402
    96000, 88200, 64000, 48000, 44100, 32000,
 
403
    24000, 22050, 16000, 12000, 11025, 8000, 0
 
404
};
 
405
 
 
406
AVCodec ff_libfdk_aac_encoder = {
 
407
    .name                  = "libfdk_aac",
 
408
    .type                  = AVMEDIA_TYPE_AUDIO,
 
409
    .id                    = AV_CODEC_ID_AAC,
 
410
    .priv_data_size        = sizeof(AACContext),
 
411
    .init                  = aac_encode_init,
 
412
    .encode2               = aac_encode_frame,
 
413
    .close                 = aac_encode_close,
 
414
    .capabilities          = CODEC_CAP_SMALL_LAST_FRAME | CODEC_CAP_DELAY,
 
415
    .sample_fmts           = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
 
416
                                                            AV_SAMPLE_FMT_NONE },
 
417
    .long_name             = NULL_IF_CONFIG_SMALL("Fraunhofer FDK AAC"),
 
418
    .priv_class            = &aac_enc_class,
 
419
    .defaults              = aac_encode_defaults,
 
420
    .profiles              = profiles,
 
421
    .supported_samplerates = aac_sample_rates,
 
422
    .channel_layouts       = aac_channel_layout,
 
423
};