Statistics
| Branch: | Revision:

ffmpeg / libavcodec / amr.c @ ee7388c9

History | View | Annotate | Download (16.9 KB)

1 891f64b3 joca@rixmail.se
/*
2
 * AMR Audio decoder stub
3
 * Copyright (c) 2003 the ffmpeg project
4
 *
5
 * This library is free software; you can redistribute it and/or
6
 * modify it under the terms of the GNU Lesser General Public
7
 * License as published by the Free Software Foundation; either
8
 * version 2 of the License, or (at your option) any later version.
9
 *
10
 * This library is distributed in the hope that it will be useful,
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13
 * Lesser General Public License for more details.
14
 *
15
 * You should have received a copy of the GNU Lesser General Public
16
 * License along with this library; if not, write to the Free Software
17 5509bffa Diego Biurrun
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18 891f64b3 joca@rixmail.se
 */
19 bc634f6f Zdenek Kabelac
 /*
20 d663a1fd Michael Niedermayer
    This code implements amr-nb and amr-wb audio encoder/decoder through external reference
21 bc634f6f Zdenek Kabelac
    code from www.3gpp.org. The licence of the code from 3gpp is unclear so you
22
    have to download the code separately. Two versions exists: One fixed-point
23
    and one with floats. For some reason the float-encoder is significant faster
24
    atleast on a P4 1.5GHz (0.9s instead of 9.9s on a 30s audio clip at MR102).
25 d663a1fd Michael Niedermayer
    Both float and fixed point is supported for amr-nb, but only float for
26
    amr-wb.
27 115329f1 Diego Biurrun

28 d663a1fd Michael Niedermayer
    --AMR-NB--
29 bc634f6f Zdenek Kabelac
    The fixed-point (TS26.073) can be downloaded from:
30 d663a1fd Michael Niedermayer
    http://www.3gpp.org/ftp/Specs/archive/26_series/26.073/26073-510.zip
31 bc634f6f Zdenek Kabelac
    Extract the soure into ffmpeg/libavcodec/amr
32 c562c4da Michael Niedermayer
    To use the fixed version run "./configure" with "--enable-amr_nb-fixed"
33 115329f1 Diego Biurrun

34 bc634f6f Zdenek Kabelac
    The float version (default) can be downloaded from:
35 d663a1fd Michael Niedermayer
    http://www.3gpp.org/ftp/Specs/archive/26_series/26.104/26104-510.zip
36 bc634f6f Zdenek Kabelac
    Extract the soure into ffmpeg/libavcodec/amr_float
37 d663a1fd Michael Niedermayer

38 bc634f6f Zdenek Kabelac
    The specification for amr-nb can be found in TS 26.071
39
    (http://www.3gpp.org/ftp/Specs/html-info/26071.htm) and some other
40
    info at http://www.3gpp.org/ftp/Specs/html-info/26-series.htm
41 115329f1 Diego Biurrun

42 d663a1fd Michael Niedermayer
    --AMR-WB--
43
    The reference code can be downloaded from:
44
    http://www.3gpp.org/ftp/Specs/archive/26_series/26.204/26204-510.zip
45
    It should be extracted to "libavcodec/amrwb_float". Enable it with
46 c562c4da Michael Niedermayer
    "--enable-amr_wb".
47 115329f1 Diego Biurrun

48 d663a1fd Michael Niedermayer
    The specification for amr-wb can be downloaded from:
49
    http://www.3gpp.org/ftp/Specs/archive/26_series/26.171/26171-500.zip
50 115329f1 Diego Biurrun

51 d663a1fd Michael Niedermayer
    If someone want to use the fixed point version it can be downloaded
52
    from: http://www.3gpp.org/ftp/Specs/archive/26_series/26.173/26173-571.zip
53 115329f1 Diego Biurrun

54 bc634f6f Zdenek Kabelac
 */
55 d663a1fd Michael Niedermayer
56 891f64b3 joca@rixmail.se
#include "avcodec.h"
57
58 bc634f6f Zdenek Kabelac
#ifdef AMR_NB_FIXED
59
60
#define MMS_IO
61
62 891f64b3 joca@rixmail.se
#include "amr/sp_dec.h"
63
#include "amr/d_homing.h"
64
#include "amr/typedef.h"
65 bc634f6f Zdenek Kabelac
#include "amr/sp_enc.h"
66
#include "amr/sid_sync.h"
67
#include "amr/e_homing.h"
68 891f64b3 joca@rixmail.se
69 bc634f6f Zdenek Kabelac
#else
70
#include "amr_float/interf_dec.h"
71
#include "amr_float/interf_enc.h"
72
#endif
73
74
/* Common code for fixed and float version*/
75
typedef struct AMR_bitrates
76
{
77
    int startrate;
78
    int stoprate;
79
    enum Mode mode;
80 115329f1 Diego Biurrun
81 bc634f6f Zdenek Kabelac
} AMR_bitrates;
82
83
/* Match desired bitrate with closest one*/
84
static enum Mode getBitrateMode(int bitrate)
85
{
86
    /* Adjusted so that all bitrates can be used from commandline where
87
       only a multiple of 1000 can be specified*/
88
    AMR_bitrates rates[]={ {0,4999,MR475}, //4
89
                           {5000,5899,MR515},//5
90
                           {5900,6699,MR59},//6
91
                           {6700,7000,MR67},//7
92
                           {7001,7949,MR74},//8
93
                           {7950,9999,MR795},//9
94
                           {10000,11999,MR102},//10
95
                           {12000,64000,MR122},//12
96 115329f1 Diego Biurrun
97 bc634f6f Zdenek Kabelac
                         };
98
    int i;
99 d663a1fd Michael Niedermayer
    for(i=0;i<8;i++)
100 bc634f6f Zdenek Kabelac
    {
101
        if(rates[i].startrate<=bitrate && rates[i].stoprate>=bitrate)
102
        {
103
            return(rates[i].mode);
104
        }
105
    }
106
    /*Return highest possible*/
107
    return(MR122);
108
}
109
110
#ifdef AMR_NB_FIXED
111
/* fixed point version*/
112 891f64b3 joca@rixmail.se
/* frame size in serial bitstream file (frame type + serial stream + flags) */
113
#define SERIAL_FRAMESIZE (1+MAX_SERIAL_SIZE+5)
114
115 bc634f6f Zdenek Kabelac
typedef struct AMRContext {
116 891f64b3 joca@rixmail.se
    int frameCount;
117
    Speech_Decode_FrameState *speech_decoder_state;
118
    enum RXFrameType rx_type;
119
    enum Mode mode;
120
    Word16 reset_flag;
121
    Word16 reset_flag_old;
122
123 bc634f6f Zdenek Kabelac
    enum Mode enc_bitrate;
124
    Speech_Encode_FrameState *enstate;
125
    sid_syncState *sidstate;
126
    enum TXFrameType tx_frametype;
127 115329f1 Diego Biurrun
128 bc634f6f Zdenek Kabelac
129
} AMRContext;
130 891f64b3 joca@rixmail.se
131
static int amr_nb_decode_init(AVCodecContext * avctx)
132
{
133 bc634f6f Zdenek Kabelac
    AMRContext *s = avctx->priv_data;
134 891f64b3 joca@rixmail.se
    s->frameCount=0;
135
    s->speech_decoder_state=NULL;
136
    s->rx_type = (enum RXFrameType)0;
137
    s->mode= (enum Mode)0;
138
    s->reset_flag=0;
139
    s->reset_flag_old=1;
140 115329f1 Diego Biurrun
141 891f64b3 joca@rixmail.se
    if(Speech_Decode_Frame_init(&s->speech_decoder_state, "Decoder"))
142
    {
143 560ff809 Michael Niedermayer
        av_log(avctx, AV_LOG_ERROR, "Speech_Decode_Frame_init error\n");
144 891f64b3 joca@rixmail.se
        return -1;
145
    }
146
    return 0;
147
}
148
149 bc634f6f Zdenek Kabelac
static int amr_nb_encode_init(AVCodecContext * avctx)
150 891f64b3 joca@rixmail.se
{
151 bc634f6f Zdenek Kabelac
    AMRContext *s = avctx->priv_data;
152
    s->frameCount=0;
153
    s->speech_decoder_state=NULL;
154
    s->rx_type = (enum RXFrameType)0;
155
    s->mode= (enum Mode)0;
156
    s->reset_flag=0;
157
    s->reset_flag_old=1;
158 115329f1 Diego Biurrun
159 bc634f6f Zdenek Kabelac
    if(avctx->sample_rate!=8000)
160
    {
161 d663a1fd Michael Niedermayer
        if(avctx->debug)
162
        {
163 560ff809 Michael Niedermayer
            av_log(avctx, AV_LOG_DEBUG, "Only 8000Hz sample rate supported\n");
164 d663a1fd Michael Niedermayer
        }
165 bc634f6f Zdenek Kabelac
        return -1;
166
    }
167
168
    if(avctx->channels!=1)
169
    {
170 d663a1fd Michael Niedermayer
        if(avctx->debug)
171
        {
172 560ff809 Michael Niedermayer
            av_log(avctx, AV_LOG_DEBUG, "Only mono supported\n");
173 d663a1fd Michael Niedermayer
        }
174 bc634f6f Zdenek Kabelac
        return -1;
175
    }
176
177
    avctx->frame_size=160;
178
    avctx->coded_frame= avcodec_alloc_frame();
179
180
    if(Speech_Encode_Frame_init(&s->enstate, 0, "encoder") || sid_sync_init (&s->sidstate))
181
    {
182 d663a1fd Michael Niedermayer
        if(avctx->debug)
183
        {
184 560ff809 Michael Niedermayer
            av_log(avctx, AV_LOG_DEBUG, "Speech_Encode_Frame_init error\n");
185 d663a1fd Michael Niedermayer
        }
186 bc634f6f Zdenek Kabelac
        return -1;
187
    }
188
189
    s->enc_bitrate=getBitrateMode(avctx->bit_rate);
190
191
    return 0;
192
}
193
194
static int amr_nb_encode_close(AVCodecContext * avctx)
195
{
196
    AMRContext *s = avctx->priv_data;
197
    Speech_Encode_Frame_exit(&s->enstate);
198
    sid_sync_exit (&s->sidstate);
199
    av_freep(&avctx->coded_frame);
200
    return 0;
201
}
202
203
static int amr_nb_decode_close(AVCodecContext * avctx)
204
{
205
    AMRContext *s = avctx->priv_data;
206 891f64b3 joca@rixmail.se
    Speech_Decode_Frame_exit(&s->speech_decoder_state);
207 bc634f6f Zdenek Kabelac
    return 0;
208 891f64b3 joca@rixmail.se
}
209
210
static int amr_nb_decode_frame(AVCodecContext * avctx,
211
            void *data, int *data_size,
212
            uint8_t * buf, int buf_size)
213
{
214 bc634f6f Zdenek Kabelac
    AMRContext *s = avctx->priv_data;
215 891f64b3 joca@rixmail.se
216
    uint8_t*amrData=buf;
217
    int offset=0;
218
219
    UWord8 toc, q, ft;
220 115329f1 Diego Biurrun
221 891f64b3 joca@rixmail.se
    Word16 serial[SERIAL_FRAMESIZE];   /* coded bits */
222
    Word16 *synth;
223
    UWord8 *packed_bits;
224
225
    static Word16 packed_size[16] = {12, 13, 15, 17, 19, 20, 26, 31, 5, 0, 0, 0, 0, 0, 0, 0};
226
    int i;
227
228 bc634f6f Zdenek Kabelac
    //printf("amr_decode_frame data_size=%i buf=0x%X buf_size=%d frameCount=%d!!\n",*data_size,buf,buf_size,s->frameCount);
229 891f64b3 joca@rixmail.se
230
    synth=data;
231
232 bc634f6f Zdenek Kabelac
//    while(offset<buf_size)
233 891f64b3 joca@rixmail.se
    {
234 bc634f6f Zdenek Kabelac
        toc=amrData[offset];
235 891f64b3 joca@rixmail.se
        /* read rest of the frame based on ToC byte */
236
        q  = (toc >> 2) & 0x01;
237
        ft = (toc >> 3) & 0x0F;
238
239 bc634f6f Zdenek Kabelac
        //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]);
240
241
        offset++;
242
243 891f64b3 joca@rixmail.se
        packed_bits=amrData+offset;
244
245
        offset+=packed_size[ft];
246
247 bc634f6f Zdenek Kabelac
        //Unsort and unpack bits
248 891f64b3 joca@rixmail.se
        s->rx_type = UnpackBits(q, ft, packed_bits, &s->mode, &serial[1]);
249
250 bc634f6f Zdenek Kabelac
        //We have a new frame
251 891f64b3 joca@rixmail.se
        s->frameCount++;
252
253 115329f1 Diego Biurrun
        if (s->rx_type == RX_NO_DATA)
254 891f64b3 joca@rixmail.se
        {
255
            s->mode = s->speech_decoder_state->prev_mode;
256
        }
257
        else {
258
            s->speech_decoder_state->prev_mode = s->mode;
259
        }
260 115329f1 Diego Biurrun
261 891f64b3 joca@rixmail.se
        /* if homed: check if this frame is another homing frame */
262
        if (s->reset_flag_old == 1)
263
        {
264
            /* only check until end of first subframe */
265
            s->reset_flag = decoder_homing_frame_test_first(&serial[1], s->mode);
266
        }
267
        /* produce encoder homing frame if homed & input=decoder homing frame */
268
        if ((s->reset_flag != 0) && (s->reset_flag_old != 0))
269
        {
270
            for (i = 0; i < L_FRAME; i++)
271
            {
272
                synth[i] = EHF_MASK;
273
            }
274
        }
275
        else
276 115329f1 Diego Biurrun
        {
277 891f64b3 joca@rixmail.se
            /* decode frame */
278
            Speech_Decode_Frame(s->speech_decoder_state, s->mode, &serial[1], s->rx_type, synth);
279
        }
280
281 bc634f6f Zdenek Kabelac
        //Each AMR-frame results in 160 16-bit samples
282 891f64b3 joca@rixmail.se
        *data_size+=160*2;
283
        synth+=160;
284 115329f1 Diego Biurrun
285 891f64b3 joca@rixmail.se
        /* if not homed: check whether current frame is a homing frame */
286
        if (s->reset_flag_old == 0)
287
        {
288
            /* check whole frame */
289
            s->reset_flag = decoder_homing_frame_test(&serial[1], s->mode);
290
        }
291
        /* reset decoder if current frame is a homing frame */
292
        if (s->reset_flag != 0)
293
        {
294
            Speech_Decode_Frame_reset(s->speech_decoder_state);
295
        }
296
        s->reset_flag_old = s->reset_flag;
297 115329f1 Diego Biurrun
298 891f64b3 joca@rixmail.se
    }
299 bc634f6f Zdenek Kabelac
    return offset;
300
}
301
302
303
static int amr_nb_encode_frame(AVCodecContext *avctx,
304 bb270c08 Diego Biurrun
                            unsigned char *frame/*out*/, int buf_size, void *data/*in*/)
305 bc634f6f Zdenek Kabelac
{
306
    short serial_data[250] = {0};
307
308
    AMRContext *s = avctx->priv_data;
309
    int written;
310 115329f1 Diego Biurrun
311 bc634f6f Zdenek Kabelac
    s->reset_flag = encoder_homing_frame_test(data);
312 115329f1 Diego Biurrun
313
    Speech_Encode_Frame(s->enstate, s->enc_bitrate, data, &serial_data[1], &s->mode);
314
315 bc634f6f Zdenek Kabelac
    /* add frame type and mode */
316
    sid_sync (s->sidstate, s->mode, &s->tx_frametype);
317 115329f1 Diego Biurrun
318 bc634f6f Zdenek Kabelac
    written = PackBits(s->mode, s->enc_bitrate, s->tx_frametype, &serial_data[1], frame);
319 115329f1 Diego Biurrun
320 bc634f6f Zdenek Kabelac
    if (s->reset_flag != 0)
321
    {
322
        Speech_Encode_Frame_reset(s->enstate);
323
        sid_sync_reset(s->sidstate);
324
    }
325
    return written;
326
}
327
328
329 399d8401 Michel Bardiaux
#elif defined(AMR_NB) /* Float point version*/
330 bc634f6f Zdenek Kabelac
331
typedef struct AMRContext {
332
    int frameCount;
333
    void * decState;
334
    int *enstate;
335
    enum Mode enc_bitrate;
336
} AMRContext;
337
338
static int amr_nb_decode_init(AVCodecContext * avctx)
339
{
340
    AMRContext *s = avctx->priv_data;
341
    s->frameCount=0;
342
    s->decState=Decoder_Interface_init();
343
    if(!s->decState)
344
    {
345 560ff809 Michael Niedermayer
        av_log(avctx, AV_LOG_ERROR, "Decoder_Interface_init error\r\n");
346 bc634f6f Zdenek Kabelac
        return -1;
347
    }
348
    return 0;
349
}
350
351
static int amr_nb_encode_init(AVCodecContext * avctx)
352
{
353
    AMRContext *s = avctx->priv_data;
354
    s->frameCount=0;
355 115329f1 Diego Biurrun
356 bc634f6f Zdenek Kabelac
    if(avctx->sample_rate!=8000)
357
    {
358 d663a1fd Michael Niedermayer
        if(avctx->debug)
359
        {
360 560ff809 Michael Niedermayer
            av_log(avctx, AV_LOG_DEBUG, "Only 8000Hz sample rate supported\n");
361 d663a1fd Michael Niedermayer
        }
362 bc634f6f Zdenek Kabelac
        return -1;
363
    }
364
365
    if(avctx->channels!=1)
366
    {
367 d663a1fd Michael Niedermayer
        if(avctx->debug)
368
        {
369 560ff809 Michael Niedermayer
            av_log(avctx, AV_LOG_DEBUG, "Only mono supported\n");
370 d663a1fd Michael Niedermayer
        }
371 bc634f6f Zdenek Kabelac
        return -1;
372
    }
373
374
    avctx->frame_size=160;
375
    avctx->coded_frame= avcodec_alloc_frame();
376
377
    s->enstate=Encoder_Interface_init(0);
378
    if(!s->enstate)
379
    {
380 d663a1fd Michael Niedermayer
        if(avctx->debug)
381
        {
382 560ff809 Michael Niedermayer
            av_log(avctx, AV_LOG_DEBUG, "Encoder_Interface_init error\n");
383 d663a1fd Michael Niedermayer
        }
384 bc634f6f Zdenek Kabelac
        return -1;
385
    }
386
387
    s->enc_bitrate=getBitrateMode(avctx->bit_rate);
388
389
    return 0;
390
}
391
392
static int amr_nb_decode_close(AVCodecContext * avctx)
393
{
394
    AMRContext *s = avctx->priv_data;
395
    Decoder_Interface_exit(s->decState);
396
    return 0;
397
}
398
399
static int amr_nb_encode_close(AVCodecContext * avctx)
400
{
401
    AMRContext *s = avctx->priv_data;
402
    Encoder_Interface_exit(s->enstate);
403
    av_freep(&avctx->coded_frame);
404
    return 0;
405
}
406
407
static int amr_nb_decode_frame(AVCodecContext * avctx,
408
            void *data, int *data_size,
409
            uint8_t * buf, int buf_size)
410
{
411
    AMRContext *s = (AMRContext*)avctx->priv_data;
412
413
    uint8_t*amrData=buf;
414
    static short block_size[16]={ 12, 13, 15, 17, 19, 20, 26, 31, 5, 0, 0, 0, 0, 0, 0, 0 };
415
    enum Mode dec_mode;
416
    int packet_size;
417
418 a319bbac Richard van der Hoff
    /* av_log(NULL,AV_LOG_DEBUG,"amr_decode_frame buf=%p buf_size=%d frameCount=%d!!\n",buf,buf_size,s->frameCount); */
419 115329f1 Diego Biurrun
420 a319bbac Richard van der Hoff
    if(buf_size==0) {
421
        /* nothing to do */
422
        return 0;
423
    }
424 bc634f6f Zdenek Kabelac
425 a319bbac Richard van der Hoff
    dec_mode = (buf[0] >> 3) & 0x000F;
426
    packet_size = block_size[dec_mode]+1;
427
428
    if(packet_size > buf_size) {
429
        av_log(avctx, AV_LOG_ERROR, "amr frame too short (%u, should be %u)\n", buf_size, packet_size);
430
        return -1;
431
    }
432 115329f1 Diego Biurrun
433 a319bbac Richard van der Hoff
    s->frameCount++;
434
    /* 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]); */
435
    /* call decoder */
436
    Decoder_Interface_Decode(s->decState, amrData, data, 0);
437
    *data_size=160*2;
438 115329f1 Diego Biurrun
439 a319bbac Richard van der Hoff
    return packet_size;
440 891f64b3 joca@rixmail.se
}
441
442 bc634f6f Zdenek Kabelac
static int amr_nb_encode_frame(AVCodecContext *avctx,
443 bb270c08 Diego Biurrun
                            unsigned char *frame/*out*/, int buf_size, void *data/*in*/)
444 bc634f6f Zdenek Kabelac
{
445
    AMRContext *s = (AMRContext*)avctx->priv_data;
446
    int written;
447
448 115329f1 Diego Biurrun
    written = Encoder_Interface_Encode(s->enstate,
449
        s->enc_bitrate,
450
        data,
451
        frame,
452 bc634f6f Zdenek Kabelac
        0);
453 1ba02582 Calcium
    /* 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] ); */
454 bc634f6f Zdenek Kabelac
455
    return written;
456
}
457
458
#endif
459
460 399d8401 Michel Bardiaux
#if defined(AMR_NB) || defined(AMR_NB_FIXED)
461
462 891f64b3 joca@rixmail.se
AVCodec amr_nb_decoder =
463
{
464
    "amr_nb",
465
    CODEC_TYPE_AUDIO,
466
    CODEC_ID_AMR_NB,
467 bc634f6f Zdenek Kabelac
    sizeof(AMRContext),
468 891f64b3 joca@rixmail.se
    amr_nb_decode_init,
469
    NULL,
470 bc634f6f Zdenek Kabelac
    amr_nb_decode_close,
471 891f64b3 joca@rixmail.se
    amr_nb_decode_frame,
472
};
473
474 bc634f6f Zdenek Kabelac
AVCodec amr_nb_encoder =
475
{
476
    "amr_nb",
477
    CODEC_TYPE_AUDIO,
478
    CODEC_ID_AMR_NB,
479
    sizeof(AMRContext),
480
    amr_nb_encode_init,
481
    amr_nb_encode_frame,
482
    amr_nb_encode_close,
483
    NULL,
484
};
485 d663a1fd Michael Niedermayer
486 399d8401 Michel Bardiaux
#endif
487
488 d663a1fd Michael Niedermayer
/* -----------AMR wideband ------------*/
489
#ifdef AMR_WB
490
491
#ifdef _TYPEDEF_H
492
//To avoid duplicate typedefs from typdef in amr-nb
493
#define typedef_h
494
#endif
495
496
#include "amrwb_float/enc_if.h"
497
#include "amrwb_float/dec_if.h"
498
499
/* Common code for fixed and float version*/
500
typedef struct AMRWB_bitrates
501
{
502
    int startrate;
503
    int stoprate;
504
    int mode;
505 115329f1 Diego Biurrun
506 d663a1fd Michael Niedermayer
} AMRWB_bitrates;
507
508
static int getWBBitrateMode(int bitrate)
509
{
510
    /* Adjusted so that all bitrates can be used from commandline where
511
       only a multiple of 1000 can be specified*/
512
    AMRWB_bitrates rates[]={ {0,7999,0}, //6.6kHz
513
                           {8000,9999,1},//8.85
514
                           {10000,13000,2},//12.65
515
                           {13001,14999,3},//14.25
516
                           {15000,17000,4},//15.85
517
                           {17001,18000,5},//18.25
518
                           {18001,22000,6},//19.85
519
                           {22001,23000,7},//23.05
520
                           {23001,24000,8},//23.85
521 115329f1 Diego Biurrun
522 d663a1fd Michael Niedermayer
                         };
523
    int i;
524
525
    for(i=0;i<9;i++)
526
    {
527
        if(rates[i].startrate<=bitrate && rates[i].stoprate>=bitrate)
528
        {
529
            return(rates[i].mode);
530
        }
531
    }
532
    /*Return highest possible*/
533
    return(8);
534
}
535
536
537
typedef struct AMRWBContext {
538
    int frameCount;
539
    void *state;
540
    int mode;
541
    Word16 allow_dtx;
542
} AMRWBContext;
543
544
static int amr_wb_encode_init(AVCodecContext * avctx)
545
{
546
    AMRWBContext *s = (AMRWBContext*)avctx->priv_data;
547
    s->frameCount=0;
548 115329f1 Diego Biurrun
549 d663a1fd Michael Niedermayer
    if(avctx->sample_rate!=16000)
550
    {
551
        if(avctx->debug)
552
        {
553 560ff809 Michael Niedermayer
            av_log(avctx, AV_LOG_DEBUG, "Only 16000Hz sample rate supported\n");
554 d663a1fd Michael Niedermayer
        }
555
        return -1;
556
    }
557
558
    if(avctx->channels!=1)
559
    {
560
        if(avctx->debug)
561
        {
562 560ff809 Michael Niedermayer
            av_log(avctx, AV_LOG_DEBUG, "Only mono supported\n");
563 d663a1fd Michael Niedermayer
        }
564
        return -1;
565
    }
566
567
    avctx->frame_size=320;
568
    avctx->coded_frame= avcodec_alloc_frame();
569
570
    s->state = E_IF_init();
571
    s->mode=getWBBitrateMode(avctx->bit_rate);
572
    s->allow_dtx=0;
573
574
    return 0;
575
}
576
577
static int amr_wb_encode_close(AVCodecContext * avctx)
578
{
579
    AMRWBContext *s = (AMRWBContext*) avctx->priv_data;
580
    E_IF_exit(s->state);
581
    av_freep(&avctx->coded_frame);
582
    s->frameCount++;
583
    return 0;
584
}
585
586
static int amr_wb_encode_frame(AVCodecContext *avctx,
587 bb270c08 Diego Biurrun
                            unsigned char *frame/*out*/, int buf_size, void *data/*in*/)
588 d663a1fd Michael Niedermayer
{
589
    AMRWBContext *s = (AMRWBContext*) avctx->priv_data;
590
    int size = E_IF_encode(s->state, s->mode, data, frame, s->allow_dtx);
591
    return size;
592
}
593
594
static int amr_wb_decode_init(AVCodecContext * avctx)
595
{
596
    AMRWBContext *s = (AMRWBContext *)avctx->priv_data;
597
    s->frameCount=0;
598
    s->state = D_IF_init();
599
    return 0;
600
}
601
602
extern const UWord8 block_size[];
603
604
static int amr_wb_decode_frame(AVCodecContext * avctx,
605
            void *data, int *data_size,
606
            uint8_t * buf, int buf_size)
607
{
608
    AMRWBContext *s = (AMRWBContext*)avctx->priv_data;
609
610
    uint8_t*amrData=buf;
611
    int mode;
612
    int packet_size;
613
614 a319bbac Richard van der Hoff
    if(buf_size==0) {
615
        /* nothing to do */
616
        return 0;
617
    }
618
619
    mode = (amrData[0] >> 3) & 0x000F;
620
    packet_size = block_size[mode];
621
622
    if(packet_size > buf_size) {
623
        av_log(avctx, AV_LOG_ERROR, "amr frame too short (%u, should be %u)\n", buf_size, packet_size+1);
624
        return -1;
625 d663a1fd Michael Niedermayer
    }
626 115329f1 Diego Biurrun
627 a319bbac Richard van der Hoff
    s->frameCount++;
628
    D_IF_decode( s->state, amrData, data, _good_frame);
629
    *data_size=320*2;
630
    return packet_size;
631 d663a1fd Michael Niedermayer
}
632
633
static int amr_wb_decode_close(AVCodecContext * avctx)
634
{
635
    AMRWBContext *s = (AMRWBContext *)avctx->priv_data;
636
    D_IF_exit(s->state);
637
    return 0;
638
}
639
640
AVCodec amr_wb_decoder =
641
{
642
    "amr_wb",
643
    CODEC_TYPE_AUDIO,
644
    CODEC_ID_AMR_WB,
645
    sizeof(AMRWBContext),
646
    amr_wb_decode_init,
647
    NULL,
648
    amr_wb_decode_close,
649
    amr_wb_decode_frame,
650
};
651
652
AVCodec amr_wb_encoder =
653
{
654
    "amr_wb",
655
    CODEC_TYPE_AUDIO,
656
    CODEC_ID_AMR_WB,
657
    sizeof(AMRWBContext),
658
    amr_wb_encode_init,
659
    amr_wb_encode_frame,
660
    amr_wb_encode_close,
661
    NULL,
662
};
663
664
#endif //AMR_WB