Statistics
| Branch: | Revision:

ffmpeg / libavcodec / libopencore-amr.c @ 02c63a10

History | View | Annotate | Download (8.26 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

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

    
28
    if (!avctx->sample_rate)
29
        avctx->sample_rate = 8000 * is_amr_wb;
30

    
31
    if (!avctx->channels)
32
        avctx->channels = 1;
33

    
34
    avctx->frame_size = 160 * is_amr_wb;
35
    avctx->sample_fmt = AV_SAMPLE_FMT_S16;
36
}
37

    
38
#if CONFIG_LIBOPENCORE_AMRNB
39

    
40
#include <opencore-amrnb/interf_dec.h>
41
#include <opencore-amrnb/interf_enc.h>
42

    
43
static const char nb_bitrate_unsupported[] =
44
    "bitrate not supported: use one of 4.75k, 5.15k, 5.9k, 6.7k, 7.4k, 7.95k, 10.2k or 12.2k\n";
45

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

    
52
/* Match desired bitrate */
53
static int get_bitrate_mode(int bitrate)
54
{
55
    /* make the correspondance between bitrate and mode */
56
    static const AMR_bitrates rates[] = {{ 4750, MR475},
57
                             { 5150, MR515},
58
                             { 5900, MR59},
59
                             { 6700, MR67},
60
                             { 7400, MR74},
61
                             { 7950, MR795},
62
                             {10200, MR102},
63
                             {12200, MR122}, };
64
    int i;
65

    
66
    for (i = 0; i < 8; i++)
67
        if (rates[i].rate == bitrate)
68
            return rates[i].mode;
69
    /* no bitrate matching, return an error */
70
    return -1;
71
}
72

    
73
typedef struct AMRContext {
74
    int   frame_count;
75
    void *dec_state;
76
    void *enc_state;
77
    int   enc_bitrate;
78
} AMRContext;
79

    
80
static av_cold int amr_nb_decode_init(AVCodecContext *avctx)
81
{
82
    AMRContext *s = avctx->priv_data;
83

    
84
    s->frame_count = 0;
85
    s->dec_state   = Decoder_Interface_init();
86
    if (!s->dec_state) {
87
        av_log(avctx, AV_LOG_ERROR, "Decoder_Interface_init error\n");
88
        return -1;
89
    }
90

    
91
    amr_decode_fix_avctx(avctx);
92

    
93
    if (avctx->channels > 1) {
94
        av_log(avctx, AV_LOG_ERROR, "amr_nb: multichannel decoding not supported\n");
95
        return AVERROR(ENOSYS);
96
    }
97

    
98
    return 0;
99
}
100

    
101
static av_cold int amr_nb_decode_close(AVCodecContext *avctx)
102
{
103
    AMRContext *s = avctx->priv_data;
104

    
105
    Decoder_Interface_exit(s->dec_state);
106
    return 0;
107
}
108

    
109
static int amr_nb_decode_frame(AVCodecContext *avctx, void *data,
110
                               int *data_size, AVPacket *avpkt)
111
{
112
    const uint8_t *buf = avpkt->data;
113
    int buf_size       = avpkt->size;
114
    AMRContext *s = avctx->priv_data;
115
    static const uint8_t block_size[16] = { 12, 13, 15, 17, 19, 20, 26, 31, 5, 0, 0, 0, 0, 0, 0, 0 };
116
    enum Mode dec_mode;
117
    int packet_size;
118

    
119
    av_dlog(avctx, "amr_decode_frame buf=%p buf_size=%d frame_count=%d!!\n",
120
            buf, buf_size, s->frame_count);
121

    
122
    dec_mode = (buf[0] >> 3) & 0x000F;
123
    packet_size = block_size[dec_mode] + 1;
124

    
125
    if (packet_size > buf_size) {
126
        av_log(avctx, AV_LOG_ERROR, "amr frame too short (%u, should be %u)\n",
127
               buf_size, packet_size);
128
        return AVERROR_INVALIDDATA;
129
    }
130

    
131
    s->frame_count++;
132
    av_dlog(avctx, "packet_size=%d buf= 0x%X %X %X %X\n",
133
              packet_size, buf[0], buf[1], buf[2], buf[3]);
134
    /* call decoder */
135
    Decoder_Interface_Decode(s->dec_state, buf, data, 0);
136
    *data_size = 160 * 2;
137

    
138
    return packet_size;
139
}
140

    
141
AVCodec ff_libopencore_amrnb_decoder = {
142
    "libopencore_amrnb",
143
    AVMEDIA_TYPE_AUDIO,
144
    CODEC_ID_AMR_NB,
145
    sizeof(AMRContext),
146
    amr_nb_decode_init,
147
    NULL,
148
    amr_nb_decode_close,
149
    amr_nb_decode_frame,
150
    .long_name = NULL_IF_CONFIG_SMALL("OpenCORE Adaptive Multi-Rate (AMR) Narrow-Band"),
151
};
152

    
153
static av_cold int amr_nb_encode_init(AVCodecContext *avctx)
154
{
155
    AMRContext *s = avctx->priv_data;
156

    
157
    s->frame_count = 0;
158

    
159
    if (avctx->sample_rate != 8000) {
160
        av_log(avctx, AV_LOG_ERROR, "Only 8000Hz sample rate supported\n");
161
        return AVERROR(ENOSYS);
162
    }
163

    
164
    if (avctx->channels != 1) {
165
        av_log(avctx, AV_LOG_ERROR, "Only mono supported\n");
166
        return AVERROR(ENOSYS);
167
    }
168

    
169
    avctx->frame_size  = 160;
170
    avctx->coded_frame = avcodec_alloc_frame();
171

    
172
    s->enc_state = Encoder_Interface_init(0);
173
    if (!s->enc_state) {
174
        av_log(avctx, AV_LOG_ERROR, "Encoder_Interface_init error\n");
175
        return -1;
176
    }
177

    
178
    if ((s->enc_bitrate = get_bitrate_mode(avctx->bit_rate)) < 0) {
179
        av_log(avctx, AV_LOG_ERROR, nb_bitrate_unsupported);
180
        return AVERROR(ENOSYS);
181
    }
182

    
183
    return 0;
184
}
185

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

    
190
    Encoder_Interface_exit(s->enc_state);
191
    av_freep(&avctx->coded_frame);
192
    return 0;
193
}
194

    
195
static int amr_nb_encode_frame(AVCodecContext *avctx,
196
                               unsigned char *frame/*out*/,
197
                               int buf_size, void *data/*in*/)
198
{
199
    AMRContext *s = avctx->priv_data;
200
    int written;
201

    
202
    if ((s->enc_bitrate = get_bitrate_mode(avctx->bit_rate)) < 0) {
203
        av_log(avctx, AV_LOG_ERROR, nb_bitrate_unsupported);
204
        return AVERROR(ENOSYS);
205
    }
206

    
207
    written = Encoder_Interface_Encode(s->enc_state, s->enc_bitrate, data,
208
                                       frame, 0);
209
    av_dlog(avctx, "amr_nb_encode_frame encoded %u bytes, bitrate %u, first byte was %#02x\n",
210
            written, s->enc_bitrate, frame[0]);
211

    
212
    return written;
213
}
214

    
215
AVCodec ff_libopencore_amrnb_encoder = {
216
    "libopencore_amrnb",
217
    AVMEDIA_TYPE_AUDIO,
218
    CODEC_ID_AMR_NB,
219
    sizeof(AMRContext),
220
    amr_nb_encode_init,
221
    amr_nb_encode_frame,
222
    amr_nb_encode_close,
223
    NULL,
224
    .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
225
    .long_name = NULL_IF_CONFIG_SMALL("OpenCORE Adaptive Multi-Rate (AMR) Narrow-Band"),
226
};
227

    
228
#endif
229

    
230
/* -----------AMR wideband ------------*/
231
#if CONFIG_LIBOPENCORE_AMRWB
232

    
233
#include <opencore-amrwb/dec_if.h>
234
#include <opencore-amrwb/if_rom.h>
235

    
236
typedef struct AMRWBContext {
237
    void  *state;
238
} AMRWBContext;
239

    
240
static av_cold int amr_wb_decode_init(AVCodecContext *avctx)
241
{
242
    AMRWBContext *s = avctx->priv_data;
243

    
244
    s->state      = D_IF_init();
245

    
246
    amr_decode_fix_avctx(avctx);
247

    
248
    if (avctx->channels > 1) {
249
        av_log(avctx, AV_LOG_ERROR, "amr_wb: multichannel decoding not supported\n");
250
        return AVERROR(ENOSYS);
251
    }
252

    
253
    return 0;
254
}
255

    
256
static int amr_wb_decode_frame(AVCodecContext *avctx, void *data,
257
                               int *data_size, AVPacket *avpkt)
258
{
259
    const uint8_t *buf = avpkt->data;
260
    int buf_size       = avpkt->size;
261
    AMRWBContext *s = avctx->priv_data;
262
    int mode;
263
    int packet_size;
264
    static const uint8_t block_size[16] = {18, 24, 33, 37, 41, 47, 51, 59, 61, 6, 6, 0, 0, 0, 1, 1};
265

    
266
    if (!buf_size)
267
        /* nothing to do */
268
        return 0;
269

    
270
    mode = (buf[0] >> 3) & 0x000F;
271
    packet_size = block_size[mode];
272

    
273
    if (packet_size > buf_size) {
274
        av_log(avctx, AV_LOG_ERROR, "amr frame too short (%u, should be %u)\n",
275
               buf_size, packet_size + 1);
276
        return AVERROR_INVALIDDATA;
277
    }
278

    
279
    D_IF_decode(s->state, buf, data, _good_frame);
280
    *data_size = 320 * 2;
281
    return packet_size;
282
}
283

    
284
static int amr_wb_decode_close(AVCodecContext *avctx)
285
{
286
    AMRWBContext *s = avctx->priv_data;
287

    
288
    D_IF_exit(s->state);
289
    return 0;
290
}
291

    
292
AVCodec ff_libopencore_amrwb_decoder = {
293
    "libopencore_amrwb",
294
    AVMEDIA_TYPE_AUDIO,
295
    CODEC_ID_AMR_WB,
296
    sizeof(AMRWBContext),
297
    amr_wb_decode_init,
298
    NULL,
299
    amr_wb_decode_close,
300
    amr_wb_decode_frame,
301
    .long_name = NULL_IF_CONFIG_SMALL("OpenCORE Adaptive Multi-Rate (AMR) Wide-Band"),
302
};
303

    
304
#endif /* CONFIG_LIBOPENCORE_AMRWB */