Revision 6f1af735

View differences:

libavcodec/Makefile
277 277
OBJS-$(CONFIG_ADPCM_YAMAHA_ENCODER)    += adpcm.o
278 278

  
279 279
# external codec libraries
280
OBJS-$(CONFIG_LIBAMR)                  += amr.o
281
OBJS-$(CONFIG_LIBA52)                  += a52dec.o
282
OBJS-$(CONFIG_LIBFAAC)                 += faac.o
283
OBJS-$(CONFIG_LIBFAAD)                 += faad.o
280
OBJS-$(CONFIG_LIBA52)                  += liba52.o
281
OBJS-$(CONFIG_LIBAMR)                  += libamr.o
282
OBJS-$(CONFIG_LIBFAAC)                 += libfaac.o
283
OBJS-$(CONFIG_LIBFAAD)                 += libfaad.o
284 284
OBJS-$(CONFIG_LIBGSM)                  += libgsm.o
285
OBJS-$(CONFIG_LIBMP3LAME)              += mp3lameaudio.o
285
OBJS-$(CONFIG_LIBMP3LAME)              += libmp3lame.o
286 286
OBJS-$(CONFIG_LIBTHEORA)               += libtheoraenc.o
287
OBJS-$(CONFIG_LIBVORBIS)               += oggvorbis.o
288
OBJS-$(CONFIG_X264)                    += x264.o
289
OBJS-$(CONFIG_XVID)                    += xvidff.o xvid_rc.o
287
OBJS-$(CONFIG_LIBVORBIS)               += libvorbis.o
288
OBJS-$(CONFIG_X264)                    += libx264.o
289
OBJS-$(CONFIG_XVID)                    += libxvidff.o libxvid_rc.o
290 290

  
291 291

  
292 292
OBJS-$(CONFIG_AAC_PARSER)              += aac_parser.o aac_ac3_parser.o
libavcodec/a52dec.c
1
/*
2
 * A52 decoder using liba52
3
 * Copyright (c) 2001 Fabrice Bellard.
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg 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
 * FFmpeg 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 FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21

  
22
/**
23
 * @file a52dec.c
24
 * A52 decoder using liba52
25
 */
26

  
27
#include "avcodec.h"
28
#include <a52dec/a52.h>
29

  
30
#ifdef CONFIG_LIBA52BIN
31
#include <dlfcn.h>
32
static const char* liba52name = "liba52.so.0";
33
#endif
34

  
35
/**
36
 * liba52 - Copyright (C) Aaron Holtzman
37
 * released under the GPL license.
38
 */
39
typedef struct AC3DecodeState {
40
    uint8_t inbuf[4096]; /* input buffer */
41
    uint8_t *inbuf_ptr;
42
    int frame_size;
43
    int flags;
44
    int channels;
45
    a52_state_t* state;
46
    sample_t* samples;
47

  
48
    /*
49
     * virtual method table
50
     *
51
     * using this function table so the liba52 doesn't
52
     * have to be really linked together with ffmpeg
53
     * and might be linked in runtime - this allows binary
54
     * distribution of ffmpeg library which doens't depend
55
     * on liba52 library - but if user has it installed
56
     * it will be used - user might install such library
57
     * separately
58
     */
59
    void* handle;
60
    a52_state_t* (*a52_init)(uint32_t mm_accel);
61
    sample_t* (*a52_samples)(a52_state_t * state);
62
    int (*a52_syncinfo)(uint8_t * buf, int * flags,
63
                          int * sample_rate, int * bit_rate);
64
    int (*a52_frame)(a52_state_t * state, uint8_t * buf, int * flags,
65
                       sample_t * level, sample_t bias);
66
    void (*a52_dynrng)(a52_state_t * state,
67
                         sample_t (* call) (sample_t, void *), void * data);
68
    int (*a52_block)(a52_state_t * state);
69
    void (*a52_free)(a52_state_t * state);
70

  
71
} AC3DecodeState;
72

  
73
#ifdef CONFIG_LIBA52BIN
74
static void* dlsymm(void* handle, const char* symbol)
75
{
76
    void* f = dlsym(handle, symbol);
77
    if (!f)
78
        av_log( NULL, AV_LOG_ERROR, "A52 Decoder - function '%s' can't be resolved\n", symbol);
79
    return f;
80
}
81
#endif
82

  
83
static int a52_decode_init(AVCodecContext *avctx)
84
{
85
    AC3DecodeState *s = avctx->priv_data;
86

  
87
#ifdef CONFIG_LIBA52BIN
88
    s->handle = dlopen(liba52name, RTLD_LAZY);
89
    if (!s->handle)
90
    {
91
        av_log( avctx, AV_LOG_ERROR, "A52 library %s could not be opened! \n%s\n", liba52name, dlerror());
92
        return -1;
93
    }
94
    s->a52_init = (a52_state_t* (*)(uint32_t)) dlsymm(s->handle, "a52_init");
95
    s->a52_samples = (sample_t* (*)(a52_state_t*)) dlsymm(s->handle, "a52_samples");
96
    s->a52_syncinfo = (int (*)(uint8_t*, int*, int*, int*)) dlsymm(s->handle, "a52_syncinfo");
97
    s->a52_frame = (int (*)(a52_state_t*, uint8_t*, int*, sample_t*, sample_t)) dlsymm(s->handle, "a52_frame");
98
    s->a52_block = (int (*)(a52_state_t*)) dlsymm(s->handle, "a52_block");
99
    s->a52_free = (void (*)(a52_state_t*)) dlsymm(s->handle, "a52_free");
100
    if (!s->a52_init || !s->a52_samples || !s->a52_syncinfo
101
        || !s->a52_frame || !s->a52_block || !s->a52_free)
102
    {
103
        dlclose(s->handle);
104
        return -1;
105
    }
106
#else
107
    s->handle = 0;
108
    s->a52_init = a52_init;
109
    s->a52_samples = a52_samples;
110
    s->a52_syncinfo = a52_syncinfo;
111
    s->a52_frame = a52_frame;
112
    s->a52_block = a52_block;
113
    s->a52_free = a52_free;
114
#endif
115
    s->state = s->a52_init(0); /* later use CPU flags */
116
    s->samples = s->a52_samples(s->state);
117
    s->inbuf_ptr = s->inbuf;
118
    s->frame_size = 0;
119

  
120
    return 0;
121
}
122

  
123
/**** the following two functions comes from a52dec */
124
static inline int blah (int32_t i)
125
{
126
    if (i > 0x43c07fff)
127
        return 32767;
128
    else if (i < 0x43bf8000)
129
        return -32768;
130
    return i - 0x43c00000;
131
}
132

  
133
static inline void float_to_int (float * _f, int16_t * s16, int nchannels)
134
{
135
    int i, j, c;
136
    int32_t * f = (int32_t *) _f;       // XXX assumes IEEE float format
137

  
138
    j = 0;
139
    nchannels *= 256;
140
    for (i = 0; i < 256; i++) {
141
        for (c = 0; c < nchannels; c += 256)
142
            s16[j++] = blah (f[i + c]);
143
    }
144
}
145

  
146
/**** end */
147

  
148
#define HEADER_SIZE 7
149

  
150
static int a52_decode_frame(AVCodecContext *avctx,
151
                            void *data, int *data_size,
152
                            uint8_t *buf, int buf_size)
153
{
154
    AC3DecodeState *s = avctx->priv_data;
155
    uint8_t *buf_ptr;
156
    int flags, i, len;
157
    int sample_rate, bit_rate;
158
    short *out_samples = data;
159
    float level;
160
    static const int ac3_channels[8] = {
161
        2, 1, 2, 3, 3, 4, 4, 5
162
    };
163

  
164
    *data_size= 0;
165

  
166
    buf_ptr = buf;
167
    while (buf_size > 0) {
168
        len = s->inbuf_ptr - s->inbuf;
169
        if (s->frame_size == 0) {
170
            /* no header seen : find one. We need at least 7 bytes to parse it */
171
            len = HEADER_SIZE - len;
172
            if (len > buf_size)
173
                len = buf_size;
174
            memcpy(s->inbuf_ptr, buf_ptr, len);
175
            buf_ptr += len;
176
            s->inbuf_ptr += len;
177
            buf_size -= len;
178
            if ((s->inbuf_ptr - s->inbuf) == HEADER_SIZE) {
179
                len = s->a52_syncinfo(s->inbuf, &s->flags, &sample_rate, &bit_rate);
180
                if (len == 0) {
181
                    /* no sync found : move by one byte (inefficient, but simple!) */
182
                    memcpy(s->inbuf, s->inbuf + 1, HEADER_SIZE - 1);
183
                    s->inbuf_ptr--;
184
                } else {
185
                    s->frame_size = len;
186
                    /* update codec info */
187
                    avctx->sample_rate = sample_rate;
188
                    s->channels = ac3_channels[s->flags & 7];
189
                    if (s->flags & A52_LFE)
190
                        s->channels++;
191
                    if (avctx->channels == 0)
192
                        /* No specific number of channel requested */
193
                        avctx->channels = s->channels;
194
                    else if (s->channels < avctx->channels) {
195
                        av_log(avctx, AV_LOG_ERROR, "ac3dec: AC3 Source channels are less than specified: output to %d channels.. (frmsize: %d)\n", s->channels, len);
196
                        avctx->channels = s->channels;
197
                    }
198
                    avctx->bit_rate = bit_rate;
199
                }
200
            }
201
        } else if (len < s->frame_size) {
202
            len = s->frame_size - len;
203
            if (len > buf_size)
204
                len = buf_size;
205

  
206
            memcpy(s->inbuf_ptr, buf_ptr, len);
207
            buf_ptr += len;
208
            s->inbuf_ptr += len;
209
            buf_size -= len;
210
        } else {
211
            flags = s->flags;
212
            if (avctx->channels == 1)
213
                flags = A52_MONO;
214
            else if (avctx->channels == 2)
215
                flags = A52_STEREO;
216
            else
217
                flags |= A52_ADJUST_LEVEL;
218
            level = 1;
219
            if (s->a52_frame(s->state, s->inbuf, &flags, &level, 384)) {
220
            fail:
221
                av_log(avctx, AV_LOG_ERROR, "Error decoding frame\n");
222
                s->inbuf_ptr = s->inbuf;
223
                s->frame_size = 0;
224
                continue;
225
            }
226
            for (i = 0; i < 6; i++) {
227
                if (s->a52_block(s->state))
228
                    goto fail;
229
                float_to_int(s->samples, out_samples + i * 256 * avctx->channels, avctx->channels);
230
            }
231
            s->inbuf_ptr = s->inbuf;
232
            s->frame_size = 0;
233
            *data_size = 6 * avctx->channels * 256 * sizeof(int16_t);
234
            break;
235
        }
236
    }
237
    return buf_ptr - buf;
238
}
239

  
240
static int a52_decode_end(AVCodecContext *avctx)
241
{
242
    AC3DecodeState *s = avctx->priv_data;
243
    s->a52_free(s->state);
244
#ifdef CONFIG_LIBA52BIN
245
    dlclose(s->handle);
246
#endif
247
    return 0;
248
}
249

  
250
AVCodec liba52_decoder = {
251
    "ac3",
252
    CODEC_TYPE_AUDIO,
253
    CODEC_ID_AC3,
254
    sizeof(AC3DecodeState),
255
    a52_decode_init,
256
    NULL,
257
    a52_decode_end,
258
    a52_decode_frame,
259
};
libavcodec/amr.c
1
/*
2
 * AMR Audio decoder stub
3
 * Copyright (c) 2003 the ffmpeg project
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg 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
 * FFmpeg 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 FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21

  
22
 /** @file
23
 * Adaptive Multi-Rate (AMR) Audio decoder stub.
24
 *
25
 * This code implements both an AMR-NarrowBand (AMR-NB) and an AMR-WideBand
26
 * (AMR-WB) audio encoder/decoder through external reference code from
27
 * http://www.3gpp.org/. The license of the code from 3gpp is unclear so you
28
 * have to download the code separately. Two versions exists: One fixed-point
29
 * and one floating-point. For some reason the float encoder is significantly
30
 * faster at least on a P4 1.5GHz (0.9s instead of 9.9s on a 30s audio clip
31
 * at MR102). Both float and fixed point are supported for AMR-NB, but only
32
 * float for AMR-WB.
33
 *
34
 * \section AMR-NB
35
 *
36
 * \subsection Float
37
 * The float version (default) can be downloaded from:
38
 * http://www.3gpp.org/ftp/Specs/archive/26_series/26.104/26104-610.zip
39
 *
40
 * \subsection Fixed-point
41
 * The fixed-point (TS26.073) can be downloaded from:
42
 * http://www.3gpp.org/ftp/Specs/archive/26_series/26.073/26073-600.zip
43
 *
44
 * \subsection Specification
45
 * The specification for AMR-NB can be found in TS 26.071
46
 * (http://www.3gpp.org/ftp/Specs/html-info/26071.htm) and some other
47
 * info at http://www.3gpp.org/ftp/Specs/html-info/26-series.htm.
48
 *
49
 * \section AMR-WB
50
 *
51
 * \subsection Float
52
 * The reference code can be downloaded from:
53
 * http://www.3gpp.org/ftp/Specs/archive/26_series/26.204/26204-600.zip
54
 *
55
 * \subsection Fixed-point
56
 * If someone wants to use the fixed point version it can be downloaded from:
57
 * http://www.3gpp.org/ftp/Specs/archive/26_series/26.173/26173-571.zip.
58
 *
59
 * \subsection Specification
60
 * The specification for AMR-WB can be found in TS 26.171
61
 * (http://www.3gpp.org/ftp/Specs/html-info/26171.htm) and some other
62
 * info at http://www.3gpp.org/ftp/Specs/html-info/26-series.htm.
63
 *
64
 */
65

  
66
#include "avcodec.h"
67

  
68
#ifdef CONFIG_LIBAMR_NB_FIXED
69

  
70
#define MMS_IO
71

  
72
#include "amr/sp_dec.h"
73
#include "amr/d_homing.h"
74
#include "amr/typedef.h"
75
#include "amr/sp_enc.h"
76
#include "amr/sid_sync.h"
77
#include "amr/e_homing.h"
78

  
79
#else
80
#include <amrnb/interf_dec.h>
81
#include <amrnb/interf_enc.h>
82
#endif
83

  
84
static const char *nb_bitrate_unsupported =
85
    "bitrate not supported: use one of 4.75k, 5.15k, 5.9k, 6.7k, 7.4k, 7.95k, 10.2k or 12.2k\n";
86
static const char *wb_bitrate_unsupported =
87
    "bitrate not supported: use one of 6.6k, 8.85k, 12.65k, 14.25k, 15.85k, 18.25k, 19.85k, 23.05k, or 23.85k\n";
88

  
89
/* Common code for fixed and float version*/
90
typedef struct AMR_bitrates
91
{
92
    int rate;
93
    enum Mode mode;
94
} AMR_bitrates;
95

  
96
/* Match desired bitrate */
97
static int getBitrateMode(int bitrate)
98
{
99
    /* make the correspondance between bitrate and mode */
100
    AMR_bitrates rates[]={ {4750,MR475},
101
                           {5150,MR515},
102
                           {5900,MR59},
103
                           {6700,MR67},
104
                           {7400,MR74},
105
                           {7950,MR795},
106
                           {10200,MR102},
107
                           {12200,MR122},
108
                         };
109
    int i;
110

  
111
    for(i=0;i<8;i++)
112
    {
113
        if(rates[i].rate==bitrate)
114
        {
115
            return(rates[i].mode);
116
        }
117
    }
118
    /* no bitrate matching, return an error */
119
    return -1;
120
}
121

  
122
static void amr_decode_fix_avctx(AVCodecContext * avctx)
123
{
124
    const int is_amr_wb = 1 + (avctx->codec_id == CODEC_ID_AMR_WB);
125

  
126
    if(avctx->sample_rate == 0)
127
    {
128
        avctx->sample_rate = 8000 * is_amr_wb;
129
    }
130

  
131
    if(avctx->channels == 0)
132
    {
133
        avctx->channels = 1;
134
    }
135

  
136
    avctx->frame_size = 160 * is_amr_wb;
137
}
138

  
139
#ifdef CONFIG_LIBAMR_NB_FIXED
140
/* fixed point version*/
141
/* frame size in serial bitstream file (frame type + serial stream + flags) */
142
#define SERIAL_FRAMESIZE (1+MAX_SERIAL_SIZE+5)
143

  
144
typedef struct AMRContext {
145
    int frameCount;
146
    Speech_Decode_FrameState *speech_decoder_state;
147
    enum RXFrameType rx_type;
148
    enum Mode mode;
149
    Word16 reset_flag;
150
    Word16 reset_flag_old;
151

  
152
    int enc_bitrate;
153
    Speech_Encode_FrameState *enstate;
154
    sid_syncState *sidstate;
155
    enum TXFrameType tx_frametype;
156
} AMRContext;
157

  
158
static int amr_nb_decode_init(AVCodecContext * avctx)
159
{
160
    AMRContext *s = avctx->priv_data;
161

  
162
    s->frameCount=0;
163
    s->speech_decoder_state=NULL;
164
    s->rx_type = (enum RXFrameType)0;
165
    s->mode= (enum Mode)0;
166
    s->reset_flag=0;
167
    s->reset_flag_old=1;
168

  
169
    if(Speech_Decode_Frame_init(&s->speech_decoder_state, "Decoder"))
170
    {
171
        av_log(avctx, AV_LOG_ERROR, "Speech_Decode_Frame_init error\n");
172
        return -1;
173
    }
174

  
175
    amr_decode_fix_avctx(avctx);
176

  
177
    if(avctx->channels > 1)
178
    {
179
        av_log(avctx, AV_LOG_ERROR, "amr_nb: multichannel decoding not supported\n");
180
        return -1;
181
    }
182

  
183
    return 0;
184
}
185

  
186
static int amr_nb_encode_init(AVCodecContext * avctx)
187
{
188
    AMRContext *s = avctx->priv_data;
189

  
190
    s->frameCount=0;
191
    s->speech_decoder_state=NULL;
192
    s->rx_type = (enum RXFrameType)0;
193
    s->mode= (enum Mode)0;
194
    s->reset_flag=0;
195
    s->reset_flag_old=1;
196

  
197
    if(avctx->sample_rate!=8000)
198
    {
199
        av_log(avctx, AV_LOG_ERROR, "Only 8000Hz sample rate supported\n");
200
        return -1;
201
    }
202

  
203
    if(avctx->channels!=1)
204
    {
205
        av_log(avctx, AV_LOG_ERROR, "Only mono supported\n");
206
        return -1;
207
    }
208

  
209
    avctx->frame_size=160;
210
    avctx->coded_frame= avcodec_alloc_frame();
211

  
212
    if(Speech_Encode_Frame_init(&s->enstate, 0, "encoder") || sid_sync_init (&s->sidstate))
213
    {
214
        av_log(avctx, AV_LOG_ERROR, "Speech_Encode_Frame_init error\n");
215
        return -1;
216
    }
217

  
218
    if((s->enc_bitrate=getBitrateMode(avctx->bit_rate))<0)
219
    {
220
        av_log(avctx, AV_LOG_ERROR, nb_bitrate_unsupported);
221
        return -1;
222
    }
223

  
224
    return 0;
225
}
226

  
227
static int amr_nb_encode_close(AVCodecContext * avctx)
228
{
229
    AMRContext *s = avctx->priv_data;
230

  
231
    Speech_Encode_Frame_exit(&s->enstate);
232
    sid_sync_exit (&s->sidstate);
233
    av_freep(&avctx->coded_frame);
234
    return 0;
235
}
236

  
237
static int amr_nb_decode_close(AVCodecContext * avctx)
238
{
239
    AMRContext *s = avctx->priv_data;
240

  
241
    Speech_Decode_Frame_exit(&s->speech_decoder_state);
242
    return 0;
243
}
244

  
245
static int amr_nb_decode_frame(AVCodecContext * avctx,
246
            void *data, int *data_size,
247
            uint8_t * buf, int buf_size)
248
{
249
    AMRContext *s = avctx->priv_data;
250
    uint8_t*amrData=buf;
251
    int offset=0;
252
    UWord8 toc, q, ft;
253
    Word16 serial[SERIAL_FRAMESIZE];   /* coded bits */
254
    Word16 *synth;
255
    UWord8 *packed_bits;
256
    static Word16 packed_size[16] = {12, 13, 15, 17, 19, 20, 26, 31, 5, 0, 0, 0, 0, 0, 0, 0};
257
    int i;
258

  
259
    //printf("amr_decode_frame data_size=%i buf=0x%X buf_size=%d frameCount=%d!!\n",*data_size,buf,buf_size,s->frameCount);
260

  
261
    synth=data;
262

  
263
    toc=amrData[offset];
264
    /* read rest of the frame based on ToC byte */
265
    q  = (toc >> 2) & 0x01;
266
    ft = (toc >> 3) & 0x0F;
267

  
268
    //printf("offset=%d, packet_size=%d amrData= 0x%X %X %X %X\n",offset,packed_size[ft],amrData[offset],amrData[offset+1],amrData[offset+2],amrData[offset+3]);
269

  
270
    offset++;
271

  
272
    packed_bits=amrData+offset;
273

  
274
    offset+=packed_size[ft];
275

  
276
    //Unsort and unpack bits
277
    s->rx_type = UnpackBits(q, ft, packed_bits, &s->mode, &serial[1]);
278

  
279
    //We have a new frame
280
    s->frameCount++;
281

  
282
    if (s->rx_type == RX_NO_DATA)
283
    {
284
        s->mode = s->speech_decoder_state->prev_mode;
285
    }
286
    else {
287
        s->speech_decoder_state->prev_mode = s->mode;
288
    }
289

  
290
    /* if homed: check if this frame is another homing frame */
291
    if (s->reset_flag_old == 1)
292
    {
293
        /* only check until end of first subframe */
294
        s->reset_flag = decoder_homing_frame_test_first(&serial[1], s->mode);
295
    }
296
    /* produce encoder homing frame if homed & input=decoder homing frame */
297
    if ((s->reset_flag != 0) && (s->reset_flag_old != 0))
298
    {
299
        for (i = 0; i < L_FRAME; i++)
300
        {
301
            synth[i] = EHF_MASK;
302
        }
303
    }
304
    else
305
    {
306
        /* decode frame */
307
        Speech_Decode_Frame(s->speech_decoder_state, s->mode, &serial[1], s->rx_type, synth);
308
    }
309

  
310
    //Each AMR-frame results in 160 16-bit samples
311
    *data_size=160*2;
312

  
313
    /* if not homed: check whether current frame is a homing frame */
314
    if (s->reset_flag_old == 0)
315
    {
316
        /* check whole frame */
317
        s->reset_flag = decoder_homing_frame_test(&serial[1], s->mode);
318
    }
319
    /* reset decoder if current frame is a homing frame */
320
    if (s->reset_flag != 0)
321
    {
322
        Speech_Decode_Frame_reset(s->speech_decoder_state);
323
    }
324
    s->reset_flag_old = s->reset_flag;
325

  
326
    return offset;
327
}
328

  
329

  
330
static int amr_nb_encode_frame(AVCodecContext *avctx,
331
                            unsigned char *frame/*out*/, int buf_size, void *data/*in*/)
332
{
333
    short serial_data[250] = {0};
334
    AMRContext *s = avctx->priv_data;
335
    int written;
336

  
337
    s->reset_flag = encoder_homing_frame_test(data);
338

  
339
    Speech_Encode_Frame(s->enstate, s->enc_bitrate, data, &serial_data[1], &s->mode);
340

  
341
    /* add frame type and mode */
342
    sid_sync (s->sidstate, s->mode, &s->tx_frametype);
343

  
344
    written = PackBits(s->mode, s->enc_bitrate, s->tx_frametype, &serial_data[1], frame);
345

  
346
    if (s->reset_flag != 0)
347
    {
348
        Speech_Encode_Frame_reset(s->enstate);
349
        sid_sync_reset(s->sidstate);
350
    }
351
    return written;
352
}
353

  
354

  
355
#elif defined(CONFIG_LIBAMR_NB) /* Float point version*/
356

  
357
typedef struct AMRContext {
358
    int frameCount;
359
    void * decState;
360
    int *enstate;
361
    int enc_bitrate;
362
} AMRContext;
363

  
364
static int amr_nb_decode_init(AVCodecContext * avctx)
365
{
366
    AMRContext *s = avctx->priv_data;
367

  
368
    s->frameCount=0;
369
    s->decState=Decoder_Interface_init();
370
    if(!s->decState)
371
    {
372
        av_log(avctx, AV_LOG_ERROR, "Decoder_Interface_init error\r\n");
373
        return -1;
374
    }
375

  
376
    amr_decode_fix_avctx(avctx);
377

  
378
    if(avctx->channels > 1)
379
    {
380
        av_log(avctx, AV_LOG_ERROR, "amr_nb: multichannel decoding not supported\n");
381
        return -1;
382
    }
383

  
384
    return 0;
385
}
386

  
387
static int amr_nb_encode_init(AVCodecContext * avctx)
388
{
389
    AMRContext *s = avctx->priv_data;
390

  
391
    s->frameCount=0;
392

  
393
    if(avctx->sample_rate!=8000)
394
    {
395
        av_log(avctx, AV_LOG_ERROR, "Only 8000Hz sample rate supported\n");
396
        return -1;
397
    }
398

  
399
    if(avctx->channels!=1)
400
    {
401
        av_log(avctx, AV_LOG_ERROR, "Only mono supported\n");
402
        return -1;
403
    }
404

  
405
    avctx->frame_size=160;
406
    avctx->coded_frame= avcodec_alloc_frame();
407

  
408
    s->enstate=Encoder_Interface_init(0);
409
    if(!s->enstate)
410
    {
411
        av_log(avctx, AV_LOG_ERROR, "Encoder_Interface_init error\n");
412
        return -1;
413
    }
414

  
415
    if((s->enc_bitrate=getBitrateMode(avctx->bit_rate))<0)
416
    {
417
        av_log(avctx, AV_LOG_ERROR, nb_bitrate_unsupported);
418
        return -1;
419
    }
420

  
421
    return 0;
422
}
423

  
424
static int amr_nb_decode_close(AVCodecContext * avctx)
425
{
426
    AMRContext *s = avctx->priv_data;
427

  
428
    Decoder_Interface_exit(s->decState);
429
    return 0;
430
}
431

  
432
static int amr_nb_encode_close(AVCodecContext * avctx)
433
{
434
    AMRContext *s = avctx->priv_data;
435

  
436
    Encoder_Interface_exit(s->enstate);
437
    av_freep(&avctx->coded_frame);
438
    return 0;
439
}
440

  
441
static int amr_nb_decode_frame(AVCodecContext * avctx,
442
            void *data, int *data_size,
443
            uint8_t * buf, int buf_size)
444
{
445
    AMRContext *s = avctx->priv_data;
446
    uint8_t*amrData=buf;
447
    static short block_size[16]={ 12, 13, 15, 17, 19, 20, 26, 31, 5, 0, 0, 0, 0, 0, 0, 0 };
448
    enum Mode dec_mode;
449
    int packet_size;
450

  
451
    /* av_log(NULL,AV_LOG_DEBUG,"amr_decode_frame buf=%p buf_size=%d frameCount=%d!!\n",buf,buf_size,s->frameCount); */
452

  
453
    dec_mode = (buf[0] >> 3) & 0x000F;
454
    packet_size = block_size[dec_mode]+1;
455

  
456
    if(packet_size > buf_size) {
457
        av_log(avctx, AV_LOG_ERROR, "amr frame too short (%u, should be %u)\n", buf_size, packet_size);
458
        return -1;
459
    }
460

  
461
    s->frameCount++;
462
    /* av_log(NULL,AV_LOG_DEBUG,"packet_size=%d amrData= 0x%X %X %X %X\n",packet_size,amrData[0],amrData[1],amrData[2],amrData[3]); */
463
    /* call decoder */
464
    Decoder_Interface_Decode(s->decState, amrData, data, 0);
465
    *data_size=160*2;
466

  
467
    return packet_size;
468
}
469

  
470
static int amr_nb_encode_frame(AVCodecContext *avctx,
471
                            unsigned char *frame/*out*/, int buf_size, void *data/*in*/)
472
{
473
    AMRContext *s = avctx->priv_data;
474
    int written;
475

  
476
    if((s->enc_bitrate=getBitrateMode(avctx->bit_rate))<0)
477
    {
478
        av_log(avctx, AV_LOG_ERROR, nb_bitrate_unsupported);
479
        return -1;
480
    }
481

  
482
    written = Encoder_Interface_Encode(s->enstate,
483
        s->enc_bitrate,
484
        data,
485
        frame,
486
        0);
487
    /* av_log(NULL,AV_LOG_DEBUG,"amr_nb_encode_frame encoded %u bytes, bitrate %u, first byte was %#02x\n",written, s->enc_bitrate, frame[0] ); */
488

  
489
    return written;
490
}
491

  
492
#endif
493

  
494
#if defined(CONFIG_LIBAMR_NB) || defined(CONFIG_LIBAMR_NB_FIXED)
495

  
496
AVCodec libamr_nb_decoder =
497
{
498
    "libamr_nb",
499
    CODEC_TYPE_AUDIO,
500
    CODEC_ID_AMR_NB,
501
    sizeof(AMRContext),
502
    amr_nb_decode_init,
503
    NULL,
504
    amr_nb_decode_close,
505
    amr_nb_decode_frame,
506
};
507

  
508
AVCodec libamr_nb_encoder =
509
{
510
    "libamr_nb",
511
    CODEC_TYPE_AUDIO,
512
    CODEC_ID_AMR_NB,
513
    sizeof(AMRContext),
514
    amr_nb_encode_init,
515
    amr_nb_encode_frame,
516
    amr_nb_encode_close,
517
    NULL,
518
};
519

  
520
#endif
521

  
522
/* -----------AMR wideband ------------*/
523
#ifdef CONFIG_LIBAMR_WB
524

  
525
#ifdef _TYPEDEF_H
526
//To avoid duplicate typedefs from typdef in amr-nb
527
#define typedef_h
528
#endif
529

  
530
#include <amrwb/enc_if.h>
531
#include <amrwb/dec_if.h>
532
#include <amrwb/if_rom.h>
533

  
534
/* Common code for fixed and float version*/
535
typedef struct AMRWB_bitrates
536
{
537
    int rate;
538
    int mode;
539
} AMRWB_bitrates;
540

  
541
static int getWBBitrateMode(int bitrate)
542
{
543
    /* make the correspondance between bitrate and mode */
544
    AMRWB_bitrates rates[]={ {6600,0},
545
                           {8850,1},
546
                           {12650,2},
547
                           {14250,3},
548
                           {15850,4},
549
                           {18250,5},
550
                           {19850,6},
551
                           {23050,7},
552
                           {23850,8},
553
                         };
554
    int i;
555

  
556
    for(i=0;i<9;i++)
557
    {
558
        if(rates[i].rate==bitrate)
559
        {
560
            return(rates[i].mode);
561
        }
562
    }
563
    /* no bitrate matching, return an error */
564
    return -1;
565
}
566

  
567

  
568
typedef struct AMRWBContext {
569
    int frameCount;
570
    void *state;
571
    int mode;
572
    Word16 allow_dtx;
573
} AMRWBContext;
574

  
575
static int amr_wb_encode_init(AVCodecContext * avctx)
576
{
577
    AMRWBContext *s = avctx->priv_data;
578

  
579
    s->frameCount=0;
580

  
581
    if(avctx->sample_rate!=16000)
582
    {
583
        av_log(avctx, AV_LOG_ERROR, "Only 16000Hz sample rate supported\n");
584
        return -1;
585
    }
586

  
587
    if(avctx->channels!=1)
588
    {
589
        av_log(avctx, AV_LOG_ERROR, "Only mono supported\n");
590
        return -1;
591
    }
592

  
593
    if((s->mode=getWBBitrateMode(avctx->bit_rate))<0)
594
    {
595
        av_log(avctx, AV_LOG_ERROR, wb_bitrate_unsupported);
596
        return -1;
597
    }
598

  
599
    avctx->frame_size=320;
600
    avctx->coded_frame= avcodec_alloc_frame();
601

  
602
    s->state = E_IF_init();
603
    s->allow_dtx=0;
604

  
605
    return 0;
606
}
607

  
608
static int amr_wb_encode_close(AVCodecContext * avctx)
609
{
610
    AMRWBContext *s = avctx->priv_data;
611

  
612
    E_IF_exit(s->state);
613
    av_freep(&avctx->coded_frame);
614
    s->frameCount++;
615
    return 0;
616
}
617

  
618
static int amr_wb_encode_frame(AVCodecContext *avctx,
619
                            unsigned char *frame/*out*/, int buf_size, void *data/*in*/)
620
{
621
    AMRWBContext *s = avctx->priv_data;
622
    int size;
623

  
624
    if((s->mode=getWBBitrateMode(avctx->bit_rate))<0)
625
    {
626
        av_log(avctx, AV_LOG_ERROR, wb_bitrate_unsupported);
627
        return -1;
628
    }
629
    size = E_IF_encode(s->state, s->mode, data, frame, s->allow_dtx);
630
    return size;
631
}
632

  
633
static int amr_wb_decode_init(AVCodecContext * avctx)
634
{
635
    AMRWBContext *s = avctx->priv_data;
636

  
637
    s->frameCount=0;
638
    s->state = D_IF_init();
639

  
640
    amr_decode_fix_avctx(avctx);
641

  
642
    if(avctx->channels > 1)
643
    {
644
        av_log(avctx, AV_LOG_ERROR, "amr_wb: multichannel decoding not supported\n");
645
        return -1;
646
    }
647

  
648
    return 0;
649
}
650

  
651
static int amr_wb_decode_frame(AVCodecContext * avctx,
652
            void *data, int *data_size,
653
            uint8_t * buf, int buf_size)
654
{
655
    AMRWBContext *s = avctx->priv_data;
656
    uint8_t*amrData=buf;
657
    int mode;
658
    int packet_size;
659

  
660
    if(buf_size==0) {
661
        /* nothing to do */
662
        return 0;
663
    }
664

  
665
    mode = (amrData[0] >> 3) & 0x000F;
666
    packet_size = block_size[mode];
667

  
668
    if(packet_size > buf_size) {
669
        av_log(avctx, AV_LOG_ERROR, "amr frame too short (%u, should be %u)\n", buf_size, packet_size+1);
670
        return -1;
671
    }
672

  
673
    s->frameCount++;
674
    D_IF_decode( s->state, amrData, data, _good_frame);
675
    *data_size=320*2;
676
    return packet_size;
677
}
678

  
679
static int amr_wb_decode_close(AVCodecContext * avctx)
680
{
681
    AMRWBContext *s = avctx->priv_data;
682

  
683
    D_IF_exit(s->state);
684
    return 0;
685
}
686

  
687
AVCodec libamr_wb_decoder =
688
{
689
    "libamr_wb",
690
    CODEC_TYPE_AUDIO,
691
    CODEC_ID_AMR_WB,
692
    sizeof(AMRWBContext),
693
    amr_wb_decode_init,
694
    NULL,
695
    amr_wb_decode_close,
696
    amr_wb_decode_frame,
697
};
698

  
699
AVCodec libamr_wb_encoder =
700
{
701
    "libamr_wb",
702
    CODEC_TYPE_AUDIO,
703
    CODEC_ID_AMR_WB,
704
    sizeof(AMRWBContext),
705
    amr_wb_encode_init,
706
    amr_wb_encode_frame,
707
    amr_wb_encode_close,
708
    NULL,
709
};
710

  
711
#endif //CONFIG_LIBAMR_WB
libavcodec/faac.c
1
/*
2
 * Interface to libfaac for aac encoding
3
 * Copyright (c) 2002 Gildas Bazin <gbazin@netcourrier.com>
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg 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
 * FFmpeg 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 FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21

  
22
/**
23
 * @file faacaudio.c
24
 * Interface to libfaac for aac encoding.
25
 */
26

  
27
#include "avcodec.h"
28
#include <faac.h>
29

  
30
typedef struct FaacAudioContext {
31
    faacEncHandle faac_handle;
32
} FaacAudioContext;
33

  
34
static int Faac_encode_init(AVCodecContext *avctx)
35
{
36
    FaacAudioContext *s = avctx->priv_data;
37
    faacEncConfigurationPtr faac_cfg;
38
    unsigned long samples_input, max_bytes_output;
39

  
40
    /* number of channels */
41
    if (avctx->channels < 1 || avctx->channels > 6)
42
        return -1;
43

  
44
    s->faac_handle = faacEncOpen(avctx->sample_rate,
45
                                 avctx->channels,
46
                                 &samples_input, &max_bytes_output);
47

  
48
    /* check faac version */
49
    faac_cfg = faacEncGetCurrentConfiguration(s->faac_handle);
50
    if (faac_cfg->version != FAAC_CFG_VERSION) {
51
        av_log(avctx, AV_LOG_ERROR, "wrong libfaac version (compiled for: %d, using %d)\n", FAAC_CFG_VERSION, faac_cfg->version);
52
        faacEncClose(s->faac_handle);
53
        return -1;
54
    }
55

  
56
    /* put the options in the configuration struct */
57
    switch(avctx->profile) {
58
        case FF_PROFILE_AAC_MAIN:
59
            faac_cfg->aacObjectType = MAIN;
60
            break;
61
        case FF_PROFILE_UNKNOWN:
62
        case FF_PROFILE_AAC_LOW:
63
            faac_cfg->aacObjectType = LOW;
64
            break;
65
        case FF_PROFILE_AAC_SSR:
66
            faac_cfg->aacObjectType = SSR;
67
            break;
68
        case FF_PROFILE_AAC_LTP:
69
            faac_cfg->aacObjectType = LTP;
70
            break;
71
        default:
72
            av_log(avctx, AV_LOG_ERROR, "invalid AAC profile\n");
73
            faacEncClose(s->faac_handle);
74
            return -1;
75
    }
76
    faac_cfg->mpegVersion = MPEG4;
77
    faac_cfg->useTns = 0;
78
    faac_cfg->allowMidside = 1;
79
    faac_cfg->bitRate = avctx->bit_rate / avctx->channels;
80
    faac_cfg->bandWidth = avctx->cutoff;
81
    if(avctx->flags & CODEC_FLAG_QSCALE) {
82
        faac_cfg->bitRate = 0;
83
        faac_cfg->quantqual = avctx->global_quality / FF_QP2LAMBDA;
84
    }
85
    faac_cfg->outputFormat = 1;
86
    faac_cfg->inputFormat = FAAC_INPUT_16BIT;
87

  
88
    avctx->frame_size = samples_input / avctx->channels;
89

  
90
    avctx->coded_frame= avcodec_alloc_frame();
91
    avctx->coded_frame->key_frame= 1;
92

  
93
    /* Set decoder specific info */
94
    avctx->extradata_size = 0;
95
    if (avctx->flags & CODEC_FLAG_GLOBAL_HEADER) {
96

  
97
        unsigned char *buffer = NULL;
98
        unsigned long decoder_specific_info_size;
99

  
100
        if (!faacEncGetDecoderSpecificInfo(s->faac_handle, &buffer,
101
                                           &decoder_specific_info_size)) {
102
            avctx->extradata = av_malloc(decoder_specific_info_size + FF_INPUT_BUFFER_PADDING_SIZE);
103
            avctx->extradata_size = decoder_specific_info_size;
104
            memcpy(avctx->extradata, buffer, avctx->extradata_size);
105
            faac_cfg->outputFormat = 0;
106
        }
107
#undef free
108
        free(buffer);
109
#define free please_use_av_free
110
    }
111

  
112
    if (!faacEncSetConfiguration(s->faac_handle, faac_cfg)) {
113
        av_log(avctx, AV_LOG_ERROR, "libfaac doesn't support this output format!\n");
114
        return -1;
115
    }
116

  
117
    return 0;
118
}
119

  
120
static int Faac_encode_frame(AVCodecContext *avctx,
121
                             unsigned char *frame, int buf_size, void *data)
122
{
123
    FaacAudioContext *s = avctx->priv_data;
124
    int bytes_written;
125

  
126
    bytes_written = faacEncEncode(s->faac_handle,
127
                                  data,
128
                                  avctx->frame_size * avctx->channels,
129
                                  frame,
130
                                  buf_size);
131

  
132
    return bytes_written;
133
}
134

  
135
static int Faac_encode_close(AVCodecContext *avctx)
136
{
137
    FaacAudioContext *s = avctx->priv_data;
138

  
139
    av_freep(&avctx->coded_frame);
140
    av_freep(&avctx->extradata);
141

  
142
    faacEncClose(s->faac_handle);
143
    return 0;
144
}
145

  
146
AVCodec libfaac_encoder = {
147
    "libfaac",
148
    CODEC_TYPE_AUDIO,
149
    CODEC_ID_AAC,
150
    sizeof(FaacAudioContext),
151
    Faac_encode_init,
152
    Faac_encode_frame,
153
    Faac_encode_close
154
};
libavcodec/faad.c
1
/*
2
 * Faad decoder
3
 * Copyright (c) 2003 Zdenek Kabelac.
4
 * Copyright (c) 2004 Thomas Raivio.
5
 *
6
 * This file is part of FFmpeg.
7
 *
8
 * FFmpeg is free software; you can redistribute it and/or
9
 * modify it under the terms of the GNU Lesser General Public
10
 * License as published by the Free Software Foundation; either
11
 * version 2.1 of the License, or (at your option) any later version.
12
 *
13
 * FFmpeg is distributed in the hope that it will be useful,
14
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16
 * Lesser General Public License for more details.
17
 *
18
 * You should have received a copy of the GNU Lesser General Public
19
 * License along with FFmpeg; if not, write to the Free Software
20
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21
 */
22

  
23
/**
24
 * @file faad.c
25
 * AAC decoder.
26
 *
27
 * still a bit unfinished - but it plays something
28
 */
29

  
30
#include "avcodec.h"
31
#include "faad.h"
32

  
33
#ifndef FAADAPI
34
#define FAADAPI
35
#endif
36

  
37
/*
38
 * when CONFIG_LIBFAADBIN is defined the libfaad will be opened at runtime
39
 */
40
//#undef CONFIG_LIBFAADBIN
41
//#define CONFIG_LIBFAADBIN
42

  
43
#ifdef CONFIG_LIBFAADBIN
44
#include <dlfcn.h>
45
static const char* libfaadname = "libfaad.so.0";
46
#else
47
#define dlopen(a)
48
#define dlclose(a)
49
#endif
50

  
51
typedef struct {
52
    void* handle;               /* dlopen handle */
53
    void* faac_handle;          /* FAAD library handle */
54
    int sample_size;
55
    int init;
56

  
57
    /* faad calls */
58
    faacDecHandle FAADAPI (*faacDecOpen)(void);
59
    faacDecConfigurationPtr FAADAPI (*faacDecGetCurrentConfiguration)(faacDecHandle hDecoder);
60
#ifndef FAAD2_VERSION
61
        int FAADAPI (*faacDecSetConfiguration)(faacDecHandle hDecoder,
62
                                           faacDecConfigurationPtr config);
63
        int FAADAPI (*faacDecInit)(faacDecHandle hDecoder,
64
                                unsigned char *buffer,
65
                                unsigned long *samplerate,
66
                                unsigned long *channels);
67
        int FAADAPI (*faacDecInit2)(faacDecHandle hDecoder, unsigned char *pBuffer,
68
                                unsigned long SizeOfDecoderSpecificInfo,
69
                                unsigned long *samplerate, unsigned long *channels);
70
        int FAADAPI (*faacDecDecode)(faacDecHandle hDecoder,
71
                                unsigned char *buffer,
72
                                unsigned long *bytesconsumed,
73
                                short *sample_buffer,
74
                                unsigned long *samples);
75
#else
76
        unsigned char FAADAPI (*faacDecSetConfiguration)(faacDecHandle hDecoder,
77
                                                     faacDecConfigurationPtr config);
78
        long FAADAPI (*faacDecInit)(faacDecHandle hDecoder,
79
                                   unsigned char *buffer,
80
                                 unsigned long buffer_size,
81
                                 unsigned long *samplerate,
82
                                 unsigned char *channels);
83
        char FAADAPI (*faacDecInit2)(faacDecHandle hDecoder, unsigned char *pBuffer,
84
                                 unsigned long SizeOfDecoderSpecificInfo,
85
                                 unsigned long *samplerate, unsigned char *channels);
86
        void *FAADAPI (*faacDecDecode)(faacDecHandle hDecoder,
87
                                         faacDecFrameInfo *hInfo,
88
                                         unsigned char *buffer,
89
                                                                 unsigned long buffer_size);
90
        char* FAADAPI (*faacDecGetErrorMessage)(unsigned char errcode);
91
#endif
92

  
93
    void FAADAPI (*faacDecClose)(faacDecHandle hDecoder);
94

  
95

  
96
} FAACContext;
97

  
98
static const unsigned long faac_srates[] =
99
{
100
    96000, 88200, 64000, 48000, 44100, 32000,
101
    24000, 22050, 16000, 12000, 11025, 8000
102
};
103

  
104
static int faac_init_mp4(AVCodecContext *avctx)
105
{
106
    FAACContext *s = avctx->priv_data;
107
    unsigned long samplerate;
108
#ifndef FAAD2_VERSION
109
    unsigned long channels;
110
#else
111
    unsigned char channels;
112
#endif
113
    int r = 0;
114

  
115
    if (avctx->extradata){
116
        r = s->faacDecInit2(s->faac_handle, (uint8_t*) avctx->extradata,
117
                            avctx->extradata_size,
118
                            &samplerate, &channels);
119
        if (r < 0){
120
            av_log(avctx, AV_LOG_ERROR,
121
                   "faacDecInit2 failed r:%d   sr:%ld  ch:%ld  s:%d\n",
122
                   r, samplerate, (long)channels, avctx->extradata_size);
123
        } else {
124
            avctx->sample_rate = samplerate;
125
            avctx->channels = channels;
126
            s->init = 1;
127
        }
128
    }
129

  
130
    return r;
131
}
132

  
133
static int faac_decode_frame(AVCodecContext *avctx,
134
                             void *data, int *data_size,
135
                             uint8_t *buf, int buf_size)
136
{
137
    FAACContext *s = avctx->priv_data;
138
#ifndef FAAD2_VERSION
139
    unsigned long bytesconsumed;
140
    short *sample_buffer = NULL;
141
    unsigned long samples;
142
    int out;
143
#else
144
    faacDecFrameInfo frame_info;
145
    void *out;
146
#endif
147
    if(buf_size == 0)
148
        return 0;
149
#ifndef FAAD2_VERSION
150
    out = s->faacDecDecode(s->faac_handle,
151
                           (unsigned char*)buf,
152
                           &bytesconsumed,
153
                           data,
154
                           &samples);
155
    samples *= s->sample_size;
156
    if (data_size)
157
        *data_size = samples;
158
    return (buf_size < (int)bytesconsumed)
159
        ? buf_size : (int)bytesconsumed;
160
#else
161

  
162
    if(!s->init){
163
        unsigned long srate;
164
        unsigned char channels;
165
        int r = s->faacDecInit(s->faac_handle, buf, buf_size, &srate, &channels);
166
        if(r < 0){
167
            av_log(avctx, AV_LOG_ERROR, "faac: codec init failed: %s\n",
168
                   s->faacDecGetErrorMessage(frame_info.error));
169
            return -1;
170
        }
171
        avctx->sample_rate = srate;
172
        avctx->channels = channels;
173
        s->init = 1;
174
    }
175

  
176
    out = s->faacDecDecode(s->faac_handle, &frame_info, (unsigned char*)buf, (unsigned long)buf_size);
177

  
178
    if (frame_info.error > 0) {
179
        av_log(avctx, AV_LOG_ERROR, "faac: frame decoding failed: %s\n",
180
                s->faacDecGetErrorMessage(frame_info.error));
181
        return -1;
182
    }
183

  
184
    frame_info.samples *= s->sample_size;
185
    memcpy(data, out, frame_info.samples); // CHECKME - can we cheat this one
186

  
187
    if (data_size)
188
        *data_size = frame_info.samples;
189

  
190
    return (buf_size < (int)frame_info.bytesconsumed)
191
        ? buf_size : (int)frame_info.bytesconsumed;
192
#endif
193
}
194

  
195
static int faac_decode_end(AVCodecContext *avctx)
196
{
197
    FAACContext *s = avctx->priv_data;
198

  
199
    s->faacDecClose(s->faac_handle);
200

  
201
    dlclose(s->handle);
202
    return 0;
203
}
204

  
205
static int faac_decode_init(AVCodecContext *avctx)
206
{
207
    FAACContext *s = avctx->priv_data;
208
    faacDecConfigurationPtr faac_cfg;
209

  
210
#ifdef CONFIG_LIBFAADBIN
211
    const char* err = 0;
212

  
213
    s->handle = dlopen(libfaadname, RTLD_LAZY);
214
    if (!s->handle)
215
    {
216
        av_log(avctx, AV_LOG_ERROR, "FAAD library: %s could not be opened! \n%s\n",
217
                libfaadname, dlerror());
218
        return -1;
219
    }
220
#define dfaac(a, b) \
221
    do { static const char* n = "faacDec" #a; \
222
    if ((s->faacDec ## a = b dlsym( s->handle, n )) == NULL) { err = n; break; } } while(0)
223
    for(;;) {
224
#else  /* !CONFIG_LIBFAADBIN */
225
#define dfaac(a, b)     s->faacDec ## a = faacDec ## a
226
#endif /* CONFIG_LIBFAADBIN */
227

  
228
        // resolve all needed function calls
229
        dfaac(Open, (faacDecHandle FAADAPI (*)(void)));
230
        dfaac(Close, (void FAADAPI (*)(faacDecHandle hDecoder)));
231
        dfaac(GetCurrentConfiguration, (faacDecConfigurationPtr
232
                                        FAADAPI (*)(faacDecHandle)));
233
#ifndef FAAD2_VERSION
234
        dfaac(SetConfiguration, (int FAADAPI (*)(faacDecHandle,
235
                                                           faacDecConfigurationPtr)));
236

  
237
        dfaac(Init, (int FAADAPI (*)(faacDecHandle, unsigned char*,
238
                                     unsigned long*, unsigned long*)));
239
    dfaac(Init2, (int FAADAPI (*)(faacDecHandle, unsigned char*,
240
                                       unsigned long, unsigned long*,
241
                                       unsigned long*)));
242
        dfaac(Decode, (int FAADAPI (*)(faacDecHandle, unsigned char*,
243
                             unsigned long*, short*, unsigned long*)));
244
#else
245
        dfaac(SetConfiguration, (unsigned char FAADAPI (*)(faacDecHandle,
246
                                                           faacDecConfigurationPtr)));
247
        dfaac(Init, (long FAADAPI (*)(faacDecHandle, unsigned char*,
248
                                     unsigned long, unsigned long*, unsigned char*)));
249
        dfaac(Init2, (char FAADAPI (*)(faacDecHandle, unsigned char*,
250
                                       unsigned long, unsigned long*,
251
                                       unsigned char*)));
252
        dfaac(Decode, (void *FAADAPI (*)(faacDecHandle, faacDecFrameInfo*,
253
                             unsigned char*, unsigned long)));
254
        dfaac(GetErrorMessage, (char* FAADAPI (*)(unsigned char)));
255
#endif
256
#undef dfacc
257

  
258
#ifdef CONFIG_LIBFAADBIN
259
        break;
260
    }
261
    if (err) {
262
        dlclose(s->handle);
263
        av_log(avctx, AV_LOG_ERROR, "FAAD library: cannot resolve %s in %s!\n",
264
                err, libfaadname);
265
        return -1;
266
    }
267
#endif
268

  
269
    s->faac_handle = s->faacDecOpen();
270
    if (!s->faac_handle) {
271
        av_log(avctx, AV_LOG_ERROR, "FAAD library: cannot create handler!\n");
272
        faac_decode_end(avctx);
273
        return -1;
274
    }
275

  
276

  
277
    faac_cfg = s->faacDecGetCurrentConfiguration(s->faac_handle);
278

  
279
    if (faac_cfg) {
280
        switch (avctx->bits_per_sample) {
281
        case 8: av_log(avctx, AV_LOG_ERROR, "FAADlib unsupported bps %d\n", avctx->bits_per_sample); break;
282
        default:
283
        case 16:
284
#ifdef FAAD2_VERSION
285
            faac_cfg->outputFormat = FAAD_FMT_16BIT;
286
#endif
287
            s->sample_size = 2;
288
            break;
289
        case 24:
290
#ifdef FAAD2_VERSION
291
            faac_cfg->outputFormat = FAAD_FMT_24BIT;
292
#endif
293
            s->sample_size = 3;
294
            break;
295
        case 32:
296
#ifdef FAAD2_VERSION
297
            faac_cfg->outputFormat = FAAD_FMT_32BIT;
298
#endif
299
            s->sample_size = 4;
300
            break;
301
        }
302

  
303
        faac_cfg->defSampleRate = (!avctx->sample_rate) ? 44100 : avctx->sample_rate;
304
        faac_cfg->defObjectType = LC;
305
    }
306

  
307
    s->faacDecSetConfiguration(s->faac_handle, faac_cfg);
308

  
309
    faac_init_mp4(avctx);
310

  
311
    return 0;
312
}
313

  
314
#define AAC_CODEC(id, name)     \
315
AVCodec name ## _decoder = {    \
316
    #name,                      \
... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff