Statistics
| Branch: | Revision:

ffmpeg / libavcodec / amr.c @ 1ba02582

History | View | Annotate | Download (16.9 KB)

1
/*
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
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
 */
19
 /*
20
    This code implements amr-nb and amr-wb audio encoder/decoder through external reference
21
    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
    Both float and fixed point is supported for amr-nb, but only float for
26
    amr-wb.
27
    
28
    --AMR-NB--
29
    The fixed-point (TS26.073) can be downloaded from:
30
    http://www.3gpp.org/ftp/Specs/archive/26_series/26.073/26073-510.zip
31
    Extract the soure into ffmpeg/libavcodec/amr
32
    To use the fixed version run "./configure" with "--enable-amr_nb-fixed"
33
    
34
    The float version (default) can be downloaded from:
35
    http://www.3gpp.org/ftp/Specs/archive/26_series/26.104/26104-510.zip
36
    Extract the soure into ffmpeg/libavcodec/amr_float
37

38
    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
    
42
    --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
    "--enable-amr_wb".
47
    
48
    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
    
51
    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
 
54
 */
55

    
56
#include "avcodec.h"
57

    
58
#ifdef AMR_NB_FIXED
59

    
60
#define MMS_IO
61

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

    
69
#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
    
81
} 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
                           
97
                         };
98
    int i;
99
    for(i=0;i<8;i++)
100
    {
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
/* frame size in serial bitstream file (frame type + serial stream + flags) */
113
#define SERIAL_FRAMESIZE (1+MAX_SERIAL_SIZE+5)
114

    
115
typedef struct AMRContext {
116
    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
    enum Mode enc_bitrate;
124
    Speech_Encode_FrameState *enstate;
125
    sid_syncState *sidstate;
126
    enum TXFrameType tx_frametype;
127
    
128

    
129
} AMRContext;
130

    
131
static int amr_nb_decode_init(AVCodecContext * avctx)
132
{
133
    AMRContext *s = avctx->priv_data;
134
    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
    
141
    if(Speech_Decode_Frame_init(&s->speech_decoder_state, "Decoder"))
142
    {
143
        av_log(avctx, AV_LOG_ERROR, "Speech_Decode_Frame_init error\n");
144
        return -1;
145
    }
146
    return 0;
147
}
148

    
149
static int amr_nb_encode_init(AVCodecContext * avctx)
150
{
151
    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
    
159
    if(avctx->sample_rate!=8000)
160
    {
161
        if(avctx->debug)
162
        {
163
            av_log(avctx, AV_LOG_DEBUG, "Only 8000Hz sample rate supported\n");
164
        }
165
        return -1;
166
    }
167

    
168
    if(avctx->channels!=1)
169
    {
170
        if(avctx->debug)
171
        {
172
            av_log(avctx, AV_LOG_DEBUG, "Only mono supported\n");
173
        }
174
        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
        if(avctx->debug)
183
        {
184
            av_log(avctx, AV_LOG_DEBUG, "Speech_Encode_Frame_init error\n");
185
        }
186
        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
    Speech_Decode_Frame_exit(&s->speech_decoder_state);
207
    return 0;
208
}
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
    AMRContext *s = avctx->priv_data;
215

    
216
    uint8_t*amrData=buf;
217
    int offset=0;
218

    
219
    UWord8 toc, q, ft;
220
    
221
    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
    //printf("amr_decode_frame data_size=%i buf=0x%X buf_size=%d frameCount=%d!!\n",*data_size,buf,buf_size,s->frameCount);
229

    
230
    synth=data;
231

    
232
//    while(offset<buf_size)
233
    {
234
        toc=amrData[offset];
235
        /* read rest of the frame based on ToC byte */
236
        q  = (toc >> 2) & 0x01;
237
        ft = (toc >> 3) & 0x0F;
238

    
239
        //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
        packed_bits=amrData+offset;
244

    
245
        offset+=packed_size[ft];
246

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

    
250
        //We have a new frame
251
        s->frameCount++;
252

    
253
        if (s->rx_type == RX_NO_DATA) 
254
        {
255
            s->mode = s->speech_decoder_state->prev_mode;
256
        }
257
        else {
258
            s->speech_decoder_state->prev_mode = s->mode;
259
        }
260
        
261
        /* 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
        {     
277
            /* decode frame */
278
            Speech_Decode_Frame(s->speech_decoder_state, s->mode, &serial[1], s->rx_type, synth);
279
        }
280

    
281
        //Each AMR-frame results in 160 16-bit samples
282
        *data_size+=160*2;
283
        synth+=160;
284
        
285
        /* 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
        
298
    }
299
    return offset;
300
}
301

    
302

    
303
static int amr_nb_encode_frame(AVCodecContext *avctx,
304
                            unsigned char *frame/*out*/, int buf_size, void *data/*in*/)
305
{
306
    short serial_data[250] = {0};
307

    
308
    AMRContext *s = avctx->priv_data;
309
    int written;
310
   
311
    s->reset_flag = encoder_homing_frame_test(data);
312
    
313
    Speech_Encode_Frame(s->enstate, s->enc_bitrate, data, &serial_data[1], &s->mode); 
314
    
315
    /* add frame type and mode */
316
    sid_sync (s->sidstate, s->mode, &s->tx_frametype);
317
    
318
    written = PackBits(s->mode, s->enc_bitrate, s->tx_frametype, &serial_data[1], frame);
319
    
320
    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
#else /* Float point version*/
330

    
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
        av_log(avctx, AV_LOG_ERROR, "Decoder_Interface_init error\r\n");
346
        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
    
356
    if(avctx->sample_rate!=8000)
357
    {
358
        if(avctx->debug)
359
        {
360
            av_log(avctx, AV_LOG_DEBUG, "Only 8000Hz sample rate supported\n");
361
        }
362
        return -1;
363
    }
364

    
365
    if(avctx->channels!=1)
366
    {
367
        if(avctx->debug)
368
        {
369
            av_log(avctx, AV_LOG_DEBUG, "Only mono supported\n");
370
        }
371
        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
        if(avctx->debug)
381
        {
382
            av_log(avctx, AV_LOG_DEBUG, "Encoder_Interface_init error\n");
383
        }
384
        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
    /* av_log(NULL,AV_LOG_DEBUG,"amr_decode_frame buf=%p buf_size=%d frameCount=%d!!\n",buf,buf_size,s->frameCount); */
419
    
420
    if(buf_size==0) {
421
        /* nothing to do */
422
        return 0;
423
    }
424

    
425
    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
    
433
    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
   
439
    return packet_size;
440
}
441

    
442
static int amr_nb_encode_frame(AVCodecContext *avctx,
443
                            unsigned char *frame/*out*/, int buf_size, void *data/*in*/)
444
{
445
    AMRContext *s = (AMRContext*)avctx->priv_data;
446
    int written;
447

    
448
    written = Encoder_Interface_Encode(s->enstate, 
449
        s->enc_bitrate, 
450
        data, 
451
        frame, 
452
        0);
453
    /* 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

    
455
    return written;
456
}
457

    
458
#endif
459

    
460
AVCodec amr_nb_decoder =
461
{
462
    "amr_nb",
463
    CODEC_TYPE_AUDIO,
464
    CODEC_ID_AMR_NB,
465
    sizeof(AMRContext),
466
    amr_nb_decode_init,
467
    NULL,
468
    amr_nb_decode_close,
469
    amr_nb_decode_frame,
470
};
471

    
472
AVCodec amr_nb_encoder =
473
{
474
    "amr_nb",
475
    CODEC_TYPE_AUDIO,
476
    CODEC_ID_AMR_NB,
477
    sizeof(AMRContext),
478
    amr_nb_encode_init,
479
    amr_nb_encode_frame,
480
    amr_nb_encode_close,
481
    NULL,
482
};
483

    
484
/* -----------AMR wideband ------------*/
485
#ifdef AMR_WB
486

    
487
#ifdef _TYPEDEF_H
488
//To avoid duplicate typedefs from typdef in amr-nb
489
#define typedef_h
490
#endif
491

    
492
#include "amrwb_float/enc_if.h"
493
#include "amrwb_float/dec_if.h"
494

    
495
/* Common code for fixed and float version*/
496
typedef struct AMRWB_bitrates
497
{
498
    int startrate;
499
    int stoprate;
500
    int mode;
501
    
502
} AMRWB_bitrates;
503

    
504
static int getWBBitrateMode(int bitrate)
505
{
506
    /* Adjusted so that all bitrates can be used from commandline where
507
       only a multiple of 1000 can be specified*/
508
    AMRWB_bitrates rates[]={ {0,7999,0}, //6.6kHz
509
                           {8000,9999,1},//8.85
510
                           {10000,13000,2},//12.65
511
                           {13001,14999,3},//14.25
512
                           {15000,17000,4},//15.85
513
                           {17001,18000,5},//18.25
514
                           {18001,22000,6},//19.85
515
                           {22001,23000,7},//23.05
516
                           {23001,24000,8},//23.85
517
                           
518
                         };
519
    int i;
520

    
521
    for(i=0;i<9;i++)
522
    {
523
        if(rates[i].startrate<=bitrate && rates[i].stoprate>=bitrate)
524
        {
525
            return(rates[i].mode);
526
        }
527
    }
528
    /*Return highest possible*/
529
    return(8);
530
}
531

    
532

    
533
typedef struct AMRWBContext {
534
    int frameCount;
535
    void *state;
536
    int mode;
537
    Word16 allow_dtx;
538
} AMRWBContext;
539

    
540
static int amr_wb_encode_init(AVCodecContext * avctx)
541
{
542
    AMRWBContext *s = (AMRWBContext*)avctx->priv_data;
543
    s->frameCount=0;
544
    
545
    if(avctx->sample_rate!=16000)
546
    {
547
        if(avctx->debug)
548
        {
549
            av_log(avctx, AV_LOG_DEBUG, "Only 16000Hz sample rate supported\n");
550
        }
551
        return -1;
552
    }
553

    
554
    if(avctx->channels!=1)
555
    {
556
        if(avctx->debug)
557
        {
558
            av_log(avctx, AV_LOG_DEBUG, "Only mono supported\n");
559
        }
560
        return -1;
561
    }
562

    
563
    avctx->frame_size=320;
564
    avctx->coded_frame= avcodec_alloc_frame();
565

    
566
    s->state = E_IF_init();
567
    s->mode=getWBBitrateMode(avctx->bit_rate);
568
    s->allow_dtx=0;
569

    
570
    return 0;
571
}
572

    
573
static int amr_wb_encode_close(AVCodecContext * avctx)
574
{
575
    AMRWBContext *s = (AMRWBContext*) avctx->priv_data;
576
    E_IF_exit(s->state);
577
    av_freep(&avctx->coded_frame);
578
    s->frameCount++;
579
    return 0;
580
}
581

    
582
static int amr_wb_encode_frame(AVCodecContext *avctx,
583
                            unsigned char *frame/*out*/, int buf_size, void *data/*in*/)
584
{
585
    AMRWBContext *s = (AMRWBContext*) avctx->priv_data;
586
    int size = E_IF_encode(s->state, s->mode, data, frame, s->allow_dtx);
587
    return size;
588
}
589

    
590
static int amr_wb_decode_init(AVCodecContext * avctx)
591
{
592
    AMRWBContext *s = (AMRWBContext *)avctx->priv_data;
593
    s->frameCount=0;
594
    s->state = D_IF_init();
595
    return 0;
596
}
597

    
598
extern const UWord8 block_size[];
599

    
600
static int amr_wb_decode_frame(AVCodecContext * avctx,
601
            void *data, int *data_size,
602
            uint8_t * buf, int buf_size)
603
{
604
    AMRWBContext *s = (AMRWBContext*)avctx->priv_data;
605

    
606
    uint8_t*amrData=buf;
607
    int mode;
608
    int packet_size;
609

    
610
    if(buf_size==0) {
611
        /* nothing to do */
612
        return 0;
613
    }
614

    
615
    mode = (amrData[0] >> 3) & 0x000F;
616
    packet_size = block_size[mode];
617

    
618
    if(packet_size > buf_size) {
619
        av_log(avctx, AV_LOG_ERROR, "amr frame too short (%u, should be %u)\n", buf_size, packet_size+1);
620
        return -1;
621
    }
622
    
623
    s->frameCount++;
624
    D_IF_decode( s->state, amrData, data, _good_frame);
625
    *data_size=320*2;
626
    return packet_size;
627
}
628

    
629
static int amr_wb_decode_close(AVCodecContext * avctx)
630
{
631
    AMRWBContext *s = (AMRWBContext *)avctx->priv_data;
632
    D_IF_exit(s->state);
633
    return 0;
634
}
635

    
636
AVCodec amr_wb_decoder =
637
{
638
    "amr_wb",
639
    CODEC_TYPE_AUDIO,
640
    CODEC_ID_AMR_WB,
641
    sizeof(AMRWBContext),
642
    amr_wb_decode_init,
643
    NULL,
644
    amr_wb_decode_close,
645
    amr_wb_decode_frame,
646
};
647

    
648
AVCodec amr_wb_encoder =
649
{
650
    "amr_wb",
651
    CODEC_TYPE_AUDIO,
652
    CODEC_ID_AMR_WB,
653
    sizeof(AMRWBContext),
654
    amr_wb_encode_init,
655
    amr_wb_encode_frame,
656
    amr_wb_encode_close,
657
    NULL,
658
};
659

    
660
#endif //AMR_WB