Statistics
| Branch: | Revision:

ffmpeg / libavcodec / libopencore-amr.c @ 651b276e

History | View | Annotate | Download (8.92 KB)

1
/*
2
 * AMR Audio decoder stub
3
 * Copyright (c) 2003 the ffmpeg project
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 "avcodec.h"
23
#include "libavutil/avstring.h"
24
#include "libavutil/opt.h"
25

    
26
static void amr_decode_fix_avctx(AVCodecContext *avctx)
27
{
28
    const int is_amr_wb = 1 + (avctx->codec_id == CODEC_ID_AMR_WB);
29

    
30
    if (!avctx->sample_rate)
31
        avctx->sample_rate = 8000 * is_amr_wb;
32

    
33
    if (!avctx->channels)
34
        avctx->channels = 1;
35

    
36
    avctx->frame_size = 160 * is_amr_wb;
37
    avctx->sample_fmt = AV_SAMPLE_FMT_S16;
38
}
39

    
40
#if CONFIG_LIBOPENCORE_AMRNB
41

    
42
#include <opencore-amrnb/interf_dec.h>
43
#include <opencore-amrnb/interf_enc.h>
44

    
45
/* Common code for fixed and float version*/
46
typedef struct AMR_bitrates {
47
    int       rate;
48
    enum Mode mode;
49
} AMR_bitrates;
50

    
51
/* Match desired bitrate */
52
static int get_bitrate_mode(int bitrate, void *log_ctx)
53
{
54
    /* make the correspondance between bitrate and mode */
55
    static const AMR_bitrates rates[] = {
56
        { 4750, MR475 }, { 5150, MR515 }, {  5900, MR59  }, {  6700, MR67  },
57
        { 7400, MR74 },  { 7950, MR795 }, { 10200, MR102 }, { 12200, MR122 }
58
    };
59
    int i, best = -1, min_diff = 0;
60
    char log_buf[200];
61

    
62
    for (i = 0; i < 8; i++) {
63
        if (rates[i].rate == bitrate)
64
            return rates[i].mode;
65
        if (best < 0 || abs(rates[i].rate - bitrate) < min_diff) {
66
            best     = i;
67
            min_diff = abs(rates[i].rate - bitrate);
68
        }
69
    }
70
    /* no bitrate matching exactly, log a warning */
71
    snprintf(log_buf, sizeof(log_buf), "bitrate not supported: use one of ");
72
    for (i = 0; i < 8; i++)
73
        av_strlcatf(log_buf, sizeof(log_buf), "%.2fk, ", rates[i].rate    / 1000.f);
74
    av_strlcatf(log_buf, sizeof(log_buf), "using %.2fk", rates[best].rate / 1000.f);
75
    av_log(log_ctx, AV_LOG_WARNING, "%s\n", log_buf);
76

    
77
    return best;
78
}
79

    
80
typedef struct AMRContext {
81
    AVClass *av_class;
82
    int   frame_count;
83
    void *dec_state;
84
    void *enc_state;
85
    int   enc_bitrate;
86
    int   enc_mode;
87
    int   enc_dtx;
88
} AMRContext;
89

    
90
static const AVOption options[] = {
91
    { "dtx", "Allow DTX (generate comfort noise)", offsetof(AMRContext, enc_dtx), FF_OPT_TYPE_INT, 0, 0, 1, AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM },
92
    { NULL }
93
};
94

    
95
static const AVClass class = {
96
    "libopencore_amrnb", av_default_item_name, options, LIBAVUTIL_VERSION_INT
97
};
98

    
99
static av_cold int amr_nb_decode_init(AVCodecContext *avctx)
100
{
101
    AMRContext *s  = avctx->priv_data;
102

    
103
    s->frame_count = 0;
104
    s->dec_state   = Decoder_Interface_init();
105
    if (!s->dec_state) {
106
        av_log(avctx, AV_LOG_ERROR, "Decoder_Interface_init error\n");
107
        return -1;
108
    }
109

    
110
    amr_decode_fix_avctx(avctx);
111

    
112
    if (avctx->channels > 1) {
113
        av_log(avctx, AV_LOG_ERROR, "amr_nb: multichannel decoding not supported\n");
114
        return AVERROR(ENOSYS);
115
    }
116

    
117
    return 0;
118
}
119

    
120
static av_cold int amr_nb_decode_close(AVCodecContext *avctx)
121
{
122
    AMRContext *s = avctx->priv_data;
123

    
124
    Decoder_Interface_exit(s->dec_state);
125
    return 0;
126
}
127

    
128
static int amr_nb_decode_frame(AVCodecContext *avctx, void *data,
129
                               int *data_size, AVPacket *avpkt)
130
{
131
    const uint8_t *buf = avpkt->data;
132
    int buf_size       = avpkt->size;
133
    AMRContext *s      = avctx->priv_data;
134
    static const uint8_t block_size[16] = { 12, 13, 15, 17, 19, 20, 26, 31, 5, 0, 0, 0, 0, 0, 0, 0 };
135
    enum Mode dec_mode;
136
    int packet_size;
137

    
138
    av_dlog(avctx, "amr_decode_frame buf=%p buf_size=%d frame_count=%d!!\n",
139
            buf, buf_size, s->frame_count);
140

    
141
    dec_mode    = (buf[0] >> 3) & 0x000F;
142
    packet_size = block_size[dec_mode] + 1;
143

    
144
    if (packet_size > buf_size) {
145
        av_log(avctx, AV_LOG_ERROR, "amr frame too short (%u, should be %u)\n",
146
               buf_size, packet_size);
147
        return AVERROR_INVALIDDATA;
148
    }
149

    
150
    s->frame_count++;
151
    av_dlog(avctx, "packet_size=%d buf= 0x%X %X %X %X\n",
152
              packet_size, buf[0], buf[1], buf[2], buf[3]);
153
    /* call decoder */
154
    Decoder_Interface_Decode(s->dec_state, buf, data, 0);
155
    *data_size = 160 * 2;
156

    
157
    return packet_size;
158
}
159

    
160
AVCodec ff_libopencore_amrnb_decoder = {
161
    "libopencore_amrnb",
162
    AVMEDIA_TYPE_AUDIO,
163
    CODEC_ID_AMR_NB,
164
    sizeof(AMRContext),
165
    amr_nb_decode_init,
166
    NULL,
167
    amr_nb_decode_close,
168
    amr_nb_decode_frame,
169
    .long_name = NULL_IF_CONFIG_SMALL("OpenCORE Adaptive Multi-Rate (AMR) Narrow-Band"),
170
};
171

    
172
static av_cold int amr_nb_encode_init(AVCodecContext *avctx)
173
{
174
    AMRContext *s = avctx->priv_data;
175

    
176
    s->frame_count = 0;
177

    
178
    if (avctx->sample_rate != 8000) {
179
        av_log(avctx, AV_LOG_ERROR, "Only 8000Hz sample rate supported\n");
180
        return AVERROR(ENOSYS);
181
    }
182

    
183
    if (avctx->channels != 1) {
184
        av_log(avctx, AV_LOG_ERROR, "Only mono supported\n");
185
        return AVERROR(ENOSYS);
186
    }
187

    
188
    avctx->frame_size  = 160;
189
    avctx->coded_frame = avcodec_alloc_frame();
190

    
191
    s->enc_state = Encoder_Interface_init(s->enc_dtx);
192
    if (!s->enc_state) {
193
        av_log(avctx, AV_LOG_ERROR, "Encoder_Interface_init error\n");
194
        return -1;
195
    }
196

    
197
    s->enc_mode    = get_bitrate_mode(avctx->bit_rate, avctx);
198
    s->enc_bitrate = avctx->bit_rate;
199

    
200
    return 0;
201
}
202

    
203
static av_cold int amr_nb_encode_close(AVCodecContext *avctx)
204
{
205
    AMRContext *s = avctx->priv_data;
206

    
207
    Encoder_Interface_exit(s->enc_state);
208
    av_freep(&avctx->coded_frame);
209
    return 0;
210
}
211

    
212
static int amr_nb_encode_frame(AVCodecContext *avctx,
213
                               unsigned char *frame/*out*/,
214
                               int buf_size, void *data/*in*/)
215
{
216
    AMRContext *s = avctx->priv_data;
217
    int written;
218

    
219
    if (s->enc_bitrate != avctx->bit_rate) {
220
        s->enc_mode    = get_bitrate_mode(avctx->bit_rate, avctx);
221
        s->enc_bitrate = avctx->bit_rate;
222
    }
223

    
224
    written = Encoder_Interface_Encode(s->enc_state, s->enc_mode, data,
225
                                       frame, 0);
226
    av_dlog(avctx, "amr_nb_encode_frame encoded %u bytes, bitrate %u, first byte was %#02x\n",
227
            written, s->enc_mode, frame[0]);
228

    
229
    return written;
230
}
231

    
232
AVCodec ff_libopencore_amrnb_encoder = {
233
    "libopencore_amrnb",
234
    AVMEDIA_TYPE_AUDIO,
235
    CODEC_ID_AMR_NB,
236
    sizeof(AMRContext),
237
    amr_nb_encode_init,
238
    amr_nb_encode_frame,
239
    amr_nb_encode_close,
240
    NULL,
241
    .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
242
    .long_name = NULL_IF_CONFIG_SMALL("OpenCORE Adaptive Multi-Rate (AMR) Narrow-Band"),
243
    .priv_class = &class,
244
};
245

    
246
#endif
247

    
248
/* -----------AMR wideband ------------*/
249
#if CONFIG_LIBOPENCORE_AMRWB
250

    
251
#include <opencore-amrwb/dec_if.h>
252
#include <opencore-amrwb/if_rom.h>
253

    
254
typedef struct AMRWBContext {
255
    void  *state;
256
} AMRWBContext;
257

    
258
static av_cold int amr_wb_decode_init(AVCodecContext *avctx)
259
{
260
    AMRWBContext *s = avctx->priv_data;
261

    
262
    s->state        = D_IF_init();
263

    
264
    amr_decode_fix_avctx(avctx);
265

    
266
    if (avctx->channels > 1) {
267
        av_log(avctx, AV_LOG_ERROR, "amr_wb: multichannel decoding not supported\n");
268
        return AVERROR(ENOSYS);
269
    }
270

    
271
    return 0;
272
}
273

    
274
static int amr_wb_decode_frame(AVCodecContext *avctx, void *data,
275
                               int *data_size, AVPacket *avpkt)
276
{
277
    const uint8_t *buf = avpkt->data;
278
    int buf_size       = avpkt->size;
279
    AMRWBContext *s    = avctx->priv_data;
280
    int mode;
281
    int packet_size;
282
    static const uint8_t block_size[16] = {18, 24, 33, 37, 41, 47, 51, 59, 61, 6, 6, 0, 0, 0, 1, 1};
283

    
284
    if (!buf_size)
285
        /* nothing to do */
286
        return 0;
287

    
288
    mode        = (buf[0] >> 3) & 0x000F;
289
    packet_size = block_size[mode];
290

    
291
    if (packet_size > buf_size) {
292
        av_log(avctx, AV_LOG_ERROR, "amr frame too short (%u, should be %u)\n",
293
               buf_size, packet_size + 1);
294
        return AVERROR_INVALIDDATA;
295
    }
296

    
297
    D_IF_decode(s->state, buf, data, _good_frame);
298
    *data_size = 320 * 2;
299
    return packet_size;
300
}
301

    
302
static int amr_wb_decode_close(AVCodecContext *avctx)
303
{
304
    AMRWBContext *s = avctx->priv_data;
305

    
306
    D_IF_exit(s->state);
307
    return 0;
308
}
309

    
310
AVCodec ff_libopencore_amrwb_decoder = {
311
    "libopencore_amrwb",
312
    AVMEDIA_TYPE_AUDIO,
313
    CODEC_ID_AMR_WB,
314
    sizeof(AMRWBContext),
315
    amr_wb_decode_init,
316
    NULL,
317
    amr_wb_decode_close,
318
    amr_wb_decode_frame,
319
    .long_name = NULL_IF_CONFIG_SMALL("OpenCORE Adaptive Multi-Rate (AMR) Wide-Band"),
320
};
321

    
322
#endif /* CONFIG_LIBOPENCORE_AMRWB */