Statistics
| Branch: | Revision:

ffmpeg / libavcodec / amr.c @ 930344d8

History | View | Annotate | Download (17.5 KB)

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
    This code implements amr-nb and amr-wb audio encoder/decoder through external reference
23
    code from www.3gpp.org. The license of the code from 3gpp is unclear so you
24
    have to download the code separately. Two versions exists: One fixed-point
25
    and one with floats. For some reason the float-encoder is significant faster
26
    at least on a P4 1.5GHz (0.9s instead of 9.9s on a 30s audio clip at MR102).
27
    Both float and fixed point are supported for amr-nb, but only float for
28
    amr-wb.
29

30
    --AMR-NB--
31
    The fixed-point (TS26.073) can be downloaded from:
32
    http://www.3gpp.org/ftp/Specs/archive/26_series/26.073/26073-510.zip
33
    Extract the source into ffmpeg/libavcodec/amr
34
    To use the fixed version run "./configure" with "--enable-amr_nb-fixed"
35

36
    The float version (default) can be downloaded from:
37
    http://www.3gpp.org/ftp/Specs/archive/26_series/26.104/26104-510.zip
38
    Extract the source into ffmpeg/libavcodec/amr_float
39

40
    The specification for amr-nb can be found in TS 26.071
41
    (http://www.3gpp.org/ftp/Specs/html-info/26071.htm) and some other
42
    info at http://www.3gpp.org/ftp/Specs/html-info/26-series.htm
43

44
    --AMR-WB--
45
    The reference code can be downloaded from:
46
    http://www.3gpp.org/ftp/Specs/archive/26_series/26.204/26204-510.zip
47
    It should be extracted to "libavcodec/amrwb_float". Enable it with
48
    "--enable-amr_wb".
49

50
    The specification for amr-wb can be downloaded from:
51
    http://www.3gpp.org/ftp/Specs/archive/26_series/26.171/26171-500.zip
52

53
    If someone wants to use the fixed point version it can be downloaded
54
    from: http://www.3gpp.org/ftp/Specs/archive/26_series/26.173/26173-571.zip
55

56
 */
57

    
58
#include "avcodec.h"
59

    
60
#ifdef CONFIG_AMR_NB_FIXED
61

    
62
#define MMS_IO
63

    
64
#include "amr/sp_dec.h"
65
#include "amr/d_homing.h"
66
#include "amr/typedef.h"
67
#include "amr/sp_enc.h"
68
#include "amr/sid_sync.h"
69
#include "amr/e_homing.h"
70

    
71
#else
72
#include "amr_float/interf_dec.h"
73
#include "amr_float/interf_enc.h"
74
#endif
75

    
76
/* Common code for fixed and float version*/
77
typedef struct AMR_bitrates
78
{
79
    int startrate;
80
    int stoprate;
81
    enum Mode mode;
82

    
83
} AMR_bitrates;
84

    
85
/* Match desired bitrate with closest one*/
86
static enum Mode getBitrateMode(int bitrate)
87
{
88
    /* Adjusted so that all bitrates can be used from commandline where
89
       only a multiple of 1000 can be specified*/
90
    AMR_bitrates rates[]={ {0,4999,MR475}, //4
91
                           {5000,5899,MR515},//5
92
                           {5900,6699,MR59},//6
93
                           {6700,7000,MR67},//7
94
                           {7001,7949,MR74},//8
95
                           {7950,9999,MR795},//9
96
                           {10000,11999,MR102},//10
97
                           {12000,64000,MR122},//12
98

    
99
                         };
100
    int i;
101
    for(i=0;i<8;i++)
102
    {
103
        if(rates[i].startrate<=bitrate && rates[i].stoprate>=bitrate)
104
        {
105
            return(rates[i].mode);
106
        }
107
    }
108
    /*Return highest possible*/
109
    return(MR122);
110
}
111

    
112
static void amr_decode_fix_avctx(AVCodecContext * avctx)
113
{
114
    const int is_amr_wb = 1 + (avctx->codec_id == CODEC_ID_AMR_WB);
115

    
116
    if(avctx->sample_rate == 0)
117
    {
118
        avctx->sample_rate = 8000 * is_amr_wb;
119
    }
120

    
121
    if(avctx->channels == 0)
122
    {
123
        avctx->channels = 1;
124
    }
125

    
126
    avctx->frame_size = 160 * is_amr_wb;
127
}
128

    
129
#ifdef CONFIG_AMR_NB_FIXED
130
/* fixed point version*/
131
/* frame size in serial bitstream file (frame type + serial stream + flags) */
132
#define SERIAL_FRAMESIZE (1+MAX_SERIAL_SIZE+5)
133

    
134
typedef struct AMRContext {
135
    int frameCount;
136
    Speech_Decode_FrameState *speech_decoder_state;
137
    enum RXFrameType rx_type;
138
    enum Mode mode;
139
    Word16 reset_flag;
140
    Word16 reset_flag_old;
141

    
142
    enum Mode enc_bitrate;
143
    Speech_Encode_FrameState *enstate;
144
    sid_syncState *sidstate;
145
    enum TXFrameType tx_frametype;
146

    
147

    
148
} AMRContext;
149

    
150
static int amr_nb_decode_init(AVCodecContext * avctx)
151
{
152
    AMRContext *s = avctx->priv_data;
153
    s->frameCount=0;
154
    s->speech_decoder_state=NULL;
155
    s->rx_type = (enum RXFrameType)0;
156
    s->mode= (enum Mode)0;
157
    s->reset_flag=0;
158
    s->reset_flag_old=1;
159

    
160
    if(Speech_Decode_Frame_init(&s->speech_decoder_state, "Decoder"))
161
    {
162
        av_log(avctx, AV_LOG_ERROR, "Speech_Decode_Frame_init error\n");
163
        return -1;
164
    }
165

    
166
    amr_decode_fix_avctx(avctx);
167

    
168
    if(avctx->channels > 1)
169
    {
170
        av_log(avctx, AV_LOG_ERROR, "amr_nb: multichannel decoding not supported\n");
171
        return -1;
172
    }
173

    
174
    return 0;
175
}
176

    
177
static int amr_nb_encode_init(AVCodecContext * avctx)
178
{
179
    AMRContext *s = avctx->priv_data;
180
    s->frameCount=0;
181
    s->speech_decoder_state=NULL;
182
    s->rx_type = (enum RXFrameType)0;
183
    s->mode= (enum Mode)0;
184
    s->reset_flag=0;
185
    s->reset_flag_old=1;
186

    
187
    if(avctx->sample_rate!=8000)
188
    {
189
        av_log(avctx, AV_LOG_ERROR, "Only 8000Hz sample rate supported\n");
190
        return -1;
191
    }
192

    
193
    if(avctx->channels!=1)
194
    {
195
        av_log(avctx, AV_LOG_ERROR, "Only mono supported\n");
196
        return -1;
197
    }
198

    
199
    avctx->frame_size=160;
200
    avctx->coded_frame= avcodec_alloc_frame();
201

    
202
    if(Speech_Encode_Frame_init(&s->enstate, 0, "encoder") || sid_sync_init (&s->sidstate))
203
    {
204
        av_log(avctx, AV_LOG_ERROR, "Speech_Encode_Frame_init error\n");
205
        return -1;
206
    }
207

    
208
    s->enc_bitrate=getBitrateMode(avctx->bit_rate);
209

    
210
    return 0;
211
}
212

    
213
static int amr_nb_encode_close(AVCodecContext * avctx)
214
{
215
    AMRContext *s = avctx->priv_data;
216
    Speech_Encode_Frame_exit(&s->enstate);
217
    sid_sync_exit (&s->sidstate);
218
    av_freep(&avctx->coded_frame);
219
    return 0;
220
}
221

    
222
static int amr_nb_decode_close(AVCodecContext * avctx)
223
{
224
    AMRContext *s = avctx->priv_data;
225
    Speech_Decode_Frame_exit(&s->speech_decoder_state);
226
    return 0;
227
}
228

    
229
static int amr_nb_decode_frame(AVCodecContext * avctx,
230
            void *data, int *data_size,
231
            uint8_t * buf, int buf_size)
232
{
233
    AMRContext *s = avctx->priv_data;
234

    
235
    uint8_t*amrData=buf;
236
    int offset=0;
237

    
238
    UWord8 toc, q, ft;
239

    
240
    Word16 serial[SERIAL_FRAMESIZE];   /* coded bits */
241
    Word16 *synth;
242
    UWord8 *packed_bits;
243

    
244
    static Word16 packed_size[16] = {12, 13, 15, 17, 19, 20, 26, 31, 5, 0, 0, 0, 0, 0, 0, 0};
245
    int i;
246

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

    
249
    synth=data;
250

    
251
//    while(offset<buf_size)
252
    {
253
        toc=amrData[offset];
254
        /* read rest of the frame based on ToC byte */
255
        q  = (toc >> 2) & 0x01;
256
        ft = (toc >> 3) & 0x0F;
257

    
258
        //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]);
259

    
260
        offset++;
261

    
262
        packed_bits=amrData+offset;
263

    
264
        offset+=packed_size[ft];
265

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

    
269
        //We have a new frame
270
        s->frameCount++;
271

    
272
        if (s->rx_type == RX_NO_DATA)
273
        {
274
            s->mode = s->speech_decoder_state->prev_mode;
275
        }
276
        else {
277
            s->speech_decoder_state->prev_mode = s->mode;
278
        }
279

    
280
        /* if homed: check if this frame is another homing frame */
281
        if (s->reset_flag_old == 1)
282
        {
283
            /* only check until end of first subframe */
284
            s->reset_flag = decoder_homing_frame_test_first(&serial[1], s->mode);
285
        }
286
        /* produce encoder homing frame if homed & input=decoder homing frame */
287
        if ((s->reset_flag != 0) && (s->reset_flag_old != 0))
288
        {
289
            for (i = 0; i < L_FRAME; i++)
290
            {
291
                synth[i] = EHF_MASK;
292
            }
293
        }
294
        else
295
        {
296
            /* decode frame */
297
            Speech_Decode_Frame(s->speech_decoder_state, s->mode, &serial[1], s->rx_type, synth);
298
        }
299

    
300
        //Each AMR-frame results in 160 16-bit samples
301
        *data_size+=160*2;
302
        synth+=160;
303

    
304
        /* if not homed: check whether current frame is a homing frame */
305
        if (s->reset_flag_old == 0)
306
        {
307
            /* check whole frame */
308
            s->reset_flag = decoder_homing_frame_test(&serial[1], s->mode);
309
        }
310
        /* reset decoder if current frame is a homing frame */
311
        if (s->reset_flag != 0)
312
        {
313
            Speech_Decode_Frame_reset(s->speech_decoder_state);
314
        }
315
        s->reset_flag_old = s->reset_flag;
316

    
317
    }
318
    return offset;
319
}
320

    
321

    
322
static int amr_nb_encode_frame(AVCodecContext *avctx,
323
                            unsigned char *frame/*out*/, int buf_size, void *data/*in*/)
324
{
325
    short serial_data[250] = {0};
326

    
327
    AMRContext *s = avctx->priv_data;
328
    int written;
329

    
330
    s->reset_flag = encoder_homing_frame_test(data);
331

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

    
334
    /* add frame type and mode */
335
    sid_sync (s->sidstate, s->mode, &s->tx_frametype);
336

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

    
339
    if (s->reset_flag != 0)
340
    {
341
        Speech_Encode_Frame_reset(s->enstate);
342
        sid_sync_reset(s->sidstate);
343
    }
344
    return written;
345
}
346

    
347

    
348
#elif defined(CONFIG_AMR_NB) /* Float point version*/
349

    
350
typedef struct AMRContext {
351
    int frameCount;
352
    void * decState;
353
    int *enstate;
354
    enum Mode enc_bitrate;
355
} AMRContext;
356

    
357
static int amr_nb_decode_init(AVCodecContext * avctx)
358
{
359
    AMRContext *s = avctx->priv_data;
360
    s->frameCount=0;
361
    s->decState=Decoder_Interface_init();
362
    if(!s->decState)
363
    {
364
        av_log(avctx, AV_LOG_ERROR, "Decoder_Interface_init error\r\n");
365
        return -1;
366
    }
367

    
368
    amr_decode_fix_avctx(avctx);
369

    
370
    if(avctx->channels > 1)
371
    {
372
        av_log(avctx, AV_LOG_ERROR, "amr_nb: multichannel decoding not supported\n");
373
        return -1;
374
    }
375

    
376
    return 0;
377
}
378

    
379
static int amr_nb_encode_init(AVCodecContext * avctx)
380
{
381
    AMRContext *s = avctx->priv_data;
382
    s->frameCount=0;
383

    
384
    if(avctx->sample_rate!=8000)
385
    {
386
        av_log(avctx, AV_LOG_ERROR, "Only 8000Hz sample rate supported\n");
387
        return -1;
388
    }
389

    
390
    if(avctx->channels!=1)
391
    {
392
        av_log(avctx, AV_LOG_ERROR, "Only mono supported\n");
393
        return -1;
394
    }
395

    
396
    avctx->frame_size=160;
397
    avctx->coded_frame= avcodec_alloc_frame();
398

    
399
    s->enstate=Encoder_Interface_init(0);
400
    if(!s->enstate)
401
    {
402
        av_log(avctx, AV_LOG_ERROR, "Encoder_Interface_init error\n");
403
        return -1;
404
    }
405

    
406
    s->enc_bitrate=getBitrateMode(avctx->bit_rate);
407

    
408
    return 0;
409
}
410

    
411
static int amr_nb_decode_close(AVCodecContext * avctx)
412
{
413
    AMRContext *s = avctx->priv_data;
414
    Decoder_Interface_exit(s->decState);
415
    return 0;
416
}
417

    
418
static int amr_nb_encode_close(AVCodecContext * avctx)
419
{
420
    AMRContext *s = avctx->priv_data;
421
    Encoder_Interface_exit(s->enstate);
422
    av_freep(&avctx->coded_frame);
423
    return 0;
424
}
425

    
426
static int amr_nb_decode_frame(AVCodecContext * avctx,
427
            void *data, int *data_size,
428
            uint8_t * buf, int buf_size)
429
{
430
    AMRContext *s = (AMRContext*)avctx->priv_data;
431

    
432
    uint8_t*amrData=buf;
433
    static short block_size[16]={ 12, 13, 15, 17, 19, 20, 26, 31, 5, 0, 0, 0, 0, 0, 0, 0 };
434
    enum Mode dec_mode;
435
    int packet_size;
436

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

    
439
    dec_mode = (buf[0] >> 3) & 0x000F;
440
    packet_size = block_size[dec_mode]+1;
441

    
442
    if(packet_size > buf_size) {
443
        av_log(avctx, AV_LOG_ERROR, "amr frame too short (%u, should be %u)\n", buf_size, packet_size);
444
        return -1;
445
    }
446

    
447
    s->frameCount++;
448
    /* 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]); */
449
    /* call decoder */
450
    Decoder_Interface_Decode(s->decState, amrData, data, 0);
451
    *data_size=160*2;
452

    
453
    return packet_size;
454
}
455

    
456
static int amr_nb_encode_frame(AVCodecContext *avctx,
457
                            unsigned char *frame/*out*/, int buf_size, void *data/*in*/)
458
{
459
    AMRContext *s = (AMRContext*)avctx->priv_data;
460
    int written;
461

    
462
    s->enc_bitrate=getBitrateMode(avctx->bit_rate);
463

    
464
    written = Encoder_Interface_Encode(s->enstate,
465
        s->enc_bitrate,
466
        data,
467
        frame,
468
        0);
469
    /* 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] ); */
470

    
471
    return written;
472
}
473

    
474
#endif
475

    
476
#if defined(CONFIG_AMR_NB) || defined(CONFIG_AMR_NB_FIXED)
477

    
478
AVCodec amr_nb_decoder =
479
{
480
    "amr_nb",
481
    CODEC_TYPE_AUDIO,
482
    CODEC_ID_AMR_NB,
483
    sizeof(AMRContext),
484
    amr_nb_decode_init,
485
    NULL,
486
    amr_nb_decode_close,
487
    amr_nb_decode_frame,
488
};
489

    
490
AVCodec amr_nb_encoder =
491
{
492
    "amr_nb",
493
    CODEC_TYPE_AUDIO,
494
    CODEC_ID_AMR_NB,
495
    sizeof(AMRContext),
496
    amr_nb_encode_init,
497
    amr_nb_encode_frame,
498
    amr_nb_encode_close,
499
    NULL,
500
};
501

    
502
#endif
503

    
504
/* -----------AMR wideband ------------*/
505
#ifdef CONFIG_AMR_WB
506

    
507
#ifdef _TYPEDEF_H
508
//To avoid duplicate typedefs from typdef in amr-nb
509
#define typedef_h
510
#endif
511

    
512
#include "amrwb_float/enc_if.h"
513
#include "amrwb_float/dec_if.h"
514

    
515
/* Common code for fixed and float version*/
516
typedef struct AMRWB_bitrates
517
{
518
    int startrate;
519
    int stoprate;
520
    int mode;
521

    
522
} AMRWB_bitrates;
523

    
524
static int getWBBitrateMode(int bitrate)
525
{
526
    /* Adjusted so that all bitrates can be used from commandline where
527
       only a multiple of 1000 can be specified*/
528
    AMRWB_bitrates rates[]={ {0,7999,0}, //6.6kHz
529
                           {8000,9999,1},//8.85
530
                           {10000,13000,2},//12.65
531
                           {13001,14999,3},//14.25
532
                           {15000,17000,4},//15.85
533
                           {17001,18000,5},//18.25
534
                           {18001,22000,6},//19.85
535
                           {22001,23000,7},//23.05
536
                           {23001,24000,8},//23.85
537

    
538
                         };
539
    int i;
540

    
541
    for(i=0;i<9;i++)
542
    {
543
        if(rates[i].startrate<=bitrate && rates[i].stoprate>=bitrate)
544
        {
545
            return(rates[i].mode);
546
        }
547
    }
548
    /*Return highest possible*/
549
    return(8);
550
}
551

    
552

    
553
typedef struct AMRWBContext {
554
    int frameCount;
555
    void *state;
556
    int mode;
557
    Word16 allow_dtx;
558
} AMRWBContext;
559

    
560
static int amr_wb_encode_init(AVCodecContext * avctx)
561
{
562
    AMRWBContext *s = (AMRWBContext*)avctx->priv_data;
563
    s->frameCount=0;
564

    
565
    if(avctx->sample_rate!=16000)
566
    {
567
        av_log(avctx, AV_LOG_ERROR, "Only 16000Hz sample rate supported\n");
568
        return -1;
569
    }
570

    
571
    if(avctx->channels!=1)
572
    {
573
        av_log(avctx, AV_LOG_ERROR, "Only mono supported\n");
574
        return -1;
575
    }
576

    
577
    avctx->frame_size=320;
578
    avctx->coded_frame= avcodec_alloc_frame();
579

    
580
    s->state = E_IF_init();
581
    s->mode=getWBBitrateMode(avctx->bit_rate);
582
    s->allow_dtx=0;
583

    
584
    return 0;
585
}
586

    
587
static int amr_wb_encode_close(AVCodecContext * avctx)
588
{
589
    AMRWBContext *s = (AMRWBContext*) avctx->priv_data;
590
    E_IF_exit(s->state);
591
    av_freep(&avctx->coded_frame);
592
    s->frameCount++;
593
    return 0;
594
}
595

    
596
static int amr_wb_encode_frame(AVCodecContext *avctx,
597
                            unsigned char *frame/*out*/, int buf_size, void *data/*in*/)
598
{
599
    AMRWBContext *s;
600
    int size;
601
    s = (AMRWBContext*) avctx->priv_data;
602
    s->mode=getWBBitrateMode(avctx->bit_rate);
603
    size = E_IF_encode(s->state, s->mode, data, frame, s->allow_dtx);
604
    return size;
605
}
606

    
607
static int amr_wb_decode_init(AVCodecContext * avctx)
608
{
609
    AMRWBContext *s = (AMRWBContext *)avctx->priv_data;
610
    s->frameCount=0;
611
    s->state = D_IF_init();
612

    
613
    amr_decode_fix_avctx(avctx);
614

    
615
    if(avctx->channels > 1)
616
    {
617
        av_log(avctx, AV_LOG_ERROR, "amr_wb: multichannel decoding not supported\n");
618
        return -1;
619
    }
620

    
621
    return 0;
622
}
623

    
624
extern const UWord8 block_size[];
625

    
626
static int amr_wb_decode_frame(AVCodecContext * avctx,
627
            void *data, int *data_size,
628
            uint8_t * buf, int buf_size)
629
{
630
    AMRWBContext *s = (AMRWBContext*)avctx->priv_data;
631

    
632
    uint8_t*amrData=buf;
633
    int mode;
634
    int packet_size;
635

    
636
    if(buf_size==0) {
637
        /* nothing to do */
638
        return 0;
639
    }
640

    
641
    mode = (amrData[0] >> 3) & 0x000F;
642
    packet_size = block_size[mode];
643

    
644
    if(packet_size > buf_size) {
645
        av_log(avctx, AV_LOG_ERROR, "amr frame too short (%u, should be %u)\n", buf_size, packet_size+1);
646
        return -1;
647
    }
648

    
649
    s->frameCount++;
650
    D_IF_decode( s->state, amrData, data, _good_frame);
651
    *data_size=320*2;
652
    return packet_size;
653
}
654

    
655
static int amr_wb_decode_close(AVCodecContext * avctx)
656
{
657
    AMRWBContext *s = (AMRWBContext *)avctx->priv_data;
658
    D_IF_exit(s->state);
659
    return 0;
660
}
661

    
662
AVCodec amr_wb_decoder =
663
{
664
    "amr_wb",
665
    CODEC_TYPE_AUDIO,
666
    CODEC_ID_AMR_WB,
667
    sizeof(AMRWBContext),
668
    amr_wb_decode_init,
669
    NULL,
670
    amr_wb_decode_close,
671
    amr_wb_decode_frame,
672
};
673

    
674
AVCodec amr_wb_encoder =
675
{
676
    "amr_wb",
677
    CODEC_TYPE_AUDIO,
678
    CODEC_ID_AMR_WB,
679
    sizeof(AMRWBContext),
680
    amr_wb_encode_init,
681
    amr_wb_encode_frame,
682
    amr_wb_encode_close,
683
    NULL,
684
};
685

    
686
#endif //CONFIG_AMR_WB