Statistics
| Branch: | Revision:

ffmpeg / libavcodec / amr.c @ 8dbcc9f2

History | View | Annotate | Download (16.5 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 "../config.h"
57
#include "avcodec.h"
58

    
59
#ifdef AMR_NB_FIXED
60

    
61
#define MMS_IO
62

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

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

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

    
84
/* Match desired bitrate with closest one*/
85
static enum Mode getBitrateMode(int bitrate)
86
{
87
    /* Adjusted so that all bitrates can be used from commandline where
88
       only a multiple of 1000 can be specified*/
89
    AMR_bitrates rates[]={ {0,4999,MR475}, //4
90
                           {5000,5899,MR515},//5
91
                           {5900,6699,MR59},//6
92
                           {6700,7000,MR67},//7
93
                           {7001,7949,MR74},//8
94
                           {7950,9999,MR795},//9
95
                           {10000,11999,MR102},//10
96
                           {12000,64000,MR122},//12
97
                           
98
                         };
99
    int i;
100
    for(i=0;i<8;i++)
101
    {
102
        if(rates[i].startrate<=bitrate && rates[i].stoprate>=bitrate)
103
        {
104
            return(rates[i].mode);
105
        }
106
    }
107
    /*Return highest possible*/
108
    return(MR122);
109
}
110

    
111
#ifdef AMR_NB_FIXED
112
/* fixed point version*/
113
/* frame size in serial bitstream file (frame type + serial stream + flags) */
114
#define SERIAL_FRAMESIZE (1+MAX_SERIAL_SIZE+5)
115

    
116
typedef struct AMRContext {
117
    int frameCount;
118
    Speech_Decode_FrameState *speech_decoder_state;
119
    enum RXFrameType rx_type;
120
    enum Mode mode;
121
    Word16 reset_flag;
122
    Word16 reset_flag_old;
123

    
124
    enum Mode enc_bitrate;
125
    Speech_Encode_FrameState *enstate;
126
    sid_syncState *sidstate;
127
    enum TXFrameType tx_frametype;
128
    
129

    
130
} AMRContext;
131

    
132
static int amr_nb_decode_init(AVCodecContext * avctx)
133
{
134
    AMRContext *s = avctx->priv_data;
135
    s->frameCount=0;
136
    s->speech_decoder_state=NULL;
137
    s->rx_type = (enum RXFrameType)0;
138
    s->mode= (enum Mode)0;
139
    s->reset_flag=0;
140
    s->reset_flag_old=1;
141
    
142
    if(Speech_Decode_Frame_init(&s->speech_decoder_state, "Decoder"))
143
    {
144
        printf("Speech_Decode_Frame_init error\n");
145
        return -1;
146
    }
147
    return 0;
148
}
149

    
150
static int amr_nb_encode_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(avctx->sample_rate!=8000)
161
    {
162
        if(avctx->debug)
163
        {
164
            fprintf(stderr, "Only 8000Hz sample rate supported\n");
165
        }
166
        return -1;
167
    }
168

    
169
    if(avctx->channels!=1)
170
    {
171
        if(avctx->debug)
172
        {
173
            fprintf(stderr, "Only mono supported\n");
174
        }
175
        return -1;
176
    }
177

    
178
    avctx->frame_size=160;
179
    avctx->coded_frame= avcodec_alloc_frame();
180

    
181
    if(Speech_Encode_Frame_init(&s->enstate, 0, "encoder") || sid_sync_init (&s->sidstate))
182
    {
183
        if(avctx->debug)
184
        {
185
            fprintf(stderr, "Speech_Encode_Frame_init error\n");
186
        }
187
        return -1;
188
    }
189

    
190
    s->enc_bitrate=getBitrateMode(avctx->bit_rate);
191

    
192
    return 0;
193
}
194

    
195
static int amr_nb_encode_close(AVCodecContext * avctx)
196
{
197
    AMRContext *s = avctx->priv_data;
198
    Speech_Encode_Frame_exit(&s->enstate);
199
    sid_sync_exit (&s->sidstate);
200
    av_freep(&avctx->coded_frame);
201
    return 0;
202
}
203

    
204
static int amr_nb_decode_close(AVCodecContext * avctx)
205
{
206
    AMRContext *s = avctx->priv_data;
207
    Speech_Decode_Frame_exit(&s->speech_decoder_state);
208
    return 0;
209
}
210

    
211
static int amr_nb_decode_frame(AVCodecContext * avctx,
212
            void *data, int *data_size,
213
            uint8_t * buf, int buf_size)
214
{
215
    AMRContext *s = avctx->priv_data;
216

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

    
220
    UWord8 toc, q, ft;
221
    
222
    Word16 serial[SERIAL_FRAMESIZE];   /* coded bits */
223
    Word16 *synth;
224
    UWord8 *packed_bits;
225
    *data_size=0;
226

    
227
    static Word16 packed_size[16] = {12, 13, 15, 17, 19, 20, 26, 31, 5, 0, 0, 0, 0, 0, 0, 0};
228
    int i;
229

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

    
232
    synth=data;
233

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

    
241
        //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]);
242

    
243
        offset++;
244

    
245
        packed_bits=amrData+offset;
246

    
247
        offset+=packed_size[ft];
248

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

    
252
        //We have a new frame
253
        s->frameCount++;
254

    
255
        if (s->rx_type == RX_NO_DATA) 
256
        {
257
            s->mode = s->speech_decoder_state->prev_mode;
258
        }
259
        else {
260
            s->speech_decoder_state->prev_mode = s->mode;
261
        }
262
        
263
        /* if homed: check if this frame is another homing frame */
264
        if (s->reset_flag_old == 1)
265
        {
266
            /* only check until end of first subframe */
267
            s->reset_flag = decoder_homing_frame_test_first(&serial[1], s->mode);
268
        }
269
        /* produce encoder homing frame if homed & input=decoder homing frame */
270
        if ((s->reset_flag != 0) && (s->reset_flag_old != 0))
271
        {
272
            for (i = 0; i < L_FRAME; i++)
273
            {
274
                synth[i] = EHF_MASK;
275
            }
276
        }
277
        else
278
        {     
279
            /* decode frame */
280
            Speech_Decode_Frame(s->speech_decoder_state, s->mode, &serial[1], s->rx_type, synth);
281
        }
282

    
283
        //Each AMR-frame results in 160 16-bit samples
284
        *data_size+=160*2;
285
        synth+=160;
286
        
287
        /* if not homed: check whether current frame is a homing frame */
288
        if (s->reset_flag_old == 0)
289
        {
290
            /* check whole frame */
291
            s->reset_flag = decoder_homing_frame_test(&serial[1], s->mode);
292
        }
293
        /* reset decoder if current frame is a homing frame */
294
        if (s->reset_flag != 0)
295
        {
296
            Speech_Decode_Frame_reset(s->speech_decoder_state);
297
        }
298
        s->reset_flag_old = s->reset_flag;
299
        
300
    }
301
    return offset;
302
}
303

    
304

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

    
310
    AMRContext *s = avctx->priv_data;
311
    int written;
312
   
313
    s->reset_flag = encoder_homing_frame_test(data);
314
    
315
    Speech_Encode_Frame(s->enstate, s->enc_bitrate, data, &serial_data[1], &s->mode); 
316
    
317
    /* add frame type and mode */
318
    sid_sync (s->sidstate, s->mode, &s->tx_frametype);
319
    
320
    written = PackBits(s->mode, s->enc_bitrate, s->tx_frametype, &serial_data[1], frame);
321
    
322
    if (s->reset_flag != 0)
323
    {
324
        Speech_Encode_Frame_reset(s->enstate);
325
        sid_sync_reset(s->sidstate);
326
    }
327
    return written;
328
}
329

    
330

    
331
#else /* Float point version*/
332

    
333
typedef struct AMRContext {
334
    int frameCount;
335
    void * decState;
336
    int *enstate;
337
    enum Mode enc_bitrate;
338
} AMRContext;
339

    
340
static int amr_nb_decode_init(AVCodecContext * avctx)
341
{
342
    AMRContext *s = avctx->priv_data;
343
    s->frameCount=0;
344
    s->decState=Decoder_Interface_init();
345
    if(!s->decState)
346
    {
347
        printf("Decoder_Interface_init error\r\n");
348
        return -1;
349
    }
350
    return 0;
351
}
352

    
353
static int amr_nb_encode_init(AVCodecContext * avctx)
354
{
355
    AMRContext *s = avctx->priv_data;
356
    s->frameCount=0;
357
    
358
    if(avctx->sample_rate!=8000)
359
    {
360
        if(avctx->debug)
361
        {
362
            fprintf(stderr, "Only 8000Hz sample rate supported\n");
363
        }
364
        return -1;
365
    }
366

    
367
    if(avctx->channels!=1)
368
    {
369
        if(avctx->debug)
370
        {
371
            fprintf(stderr, "Only mono supported\n");
372
        }
373
        return -1;
374
    }
375

    
376
    avctx->frame_size=160;
377
    avctx->coded_frame= avcodec_alloc_frame();
378

    
379
    s->enstate=Encoder_Interface_init(0);
380
    if(!s->enstate)
381
    {
382
        if(avctx->debug)
383
        {
384
            fprintf(stderr, "Encoder_Interface_init error\n");
385
        }
386
        return -1;
387
    }
388

    
389
    s->enc_bitrate=getBitrateMode(avctx->bit_rate);
390

    
391
    return 0;
392
}
393

    
394
static int amr_nb_decode_close(AVCodecContext * avctx)
395
{
396
    AMRContext *s = avctx->priv_data;
397
    Decoder_Interface_exit(s->decState);
398
    return 0;
399
}
400

    
401
static int amr_nb_encode_close(AVCodecContext * avctx)
402
{
403
    AMRContext *s = avctx->priv_data;
404
    Encoder_Interface_exit(s->enstate);
405
    av_freep(&avctx->coded_frame);
406
    return 0;
407
}
408

    
409
static int amr_nb_decode_frame(AVCodecContext * avctx,
410
            void *data, int *data_size,
411
            uint8_t * buf, int buf_size)
412
{
413
    AMRContext *s = (AMRContext*)avctx->priv_data;
414

    
415
    uint8_t*amrData=buf;
416
    int offset=0;
417
    static short block_size[16]={ 12, 13, 15, 17, 19, 20, 26, 31, 5, 0, 0, 0, 0, 0, 0, 0 };
418
    enum Mode dec_mode;
419
    int packet_size;
420
    *data_size=0;
421

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

    
424
    while(offset<buf_size)
425
    {
426
            dec_mode = (amrData[offset] >> 3) & 0x000F;
427
            packet_size = block_size[dec_mode];
428
    
429
        s->frameCount++;
430
        //printf("offset=%d, packet_size=%d amrData= 0x%X %X %X %X\n",offset,packet_size,amrData[offset],amrData[offset+1],amrData[offset+2],amrData[offset+3]);
431
            /* call decoder */
432
            Decoder_Interface_Decode(s->decState, &amrData[offset], data+*data_size, 0);
433
            *data_size+=160*2;
434
   
435
        offset+=packet_size+1; 
436
    }
437
    return buf_size;
438
}
439

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

    
446
    written = Encoder_Interface_Encode(s->enstate, 
447
        s->enc_bitrate, 
448
        data, 
449
        frame, 
450
        0);
451

    
452
    return written;
453
}
454

    
455
#endif
456

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

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

    
481
/* -----------AMR wideband ------------*/
482
#ifdef AMR_WB
483

    
484
#ifdef _TYPEDEF_H
485
//To avoid duplicate typedefs from typdef in amr-nb
486
#define typedef_h
487
#endif
488

    
489
#include "amrwb_float/enc_if.h"
490
#include "amrwb_float/dec_if.h"
491

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

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

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

    
529

    
530
typedef struct AMRWBContext {
531
    int frameCount;
532
    void *state;
533
    int mode;
534
    Word16 allow_dtx;
535
} AMRWBContext;
536

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

    
551
    if(avctx->channels!=1)
552
    {
553
        if(avctx->debug)
554
        {
555
            fprintf(stderr, "Only mono supported\n");
556
        }
557
        return -1;
558
    }
559

    
560
    avctx->frame_size=320;
561
    avctx->coded_frame= avcodec_alloc_frame();
562

    
563
    s->state = E_IF_init();
564
    s->mode=getWBBitrateMode(avctx->bit_rate);
565
    s->allow_dtx=0;
566

    
567
    return 0;
568
}
569

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

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

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

    
595
extern const UWord8 block_size[];
596

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

    
603
    uint8_t*amrData=buf;
604
    int offset=0;
605
    int mode;
606
    int packet_size;
607
    *data_size=0;
608

    
609
    while(offset<buf_size)
610
    {
611
        s->frameCount++;
612
        mode = (Word16)((amrData[offset] >> 3) & 0x0F);
613
        packet_size = block_size[mode];
614
        D_IF_decode( s->state, &amrData[offset], data+*data_size, _good_frame);
615
            *data_size+=320*2;
616
        offset+=packet_size; 
617
    }
618
    return buf_size;
619
}
620

    
621
static int amr_wb_decode_close(AVCodecContext * avctx)
622
{
623
    AMRWBContext *s = (AMRWBContext *)avctx->priv_data;
624
    D_IF_exit(s->state);
625
    return 0;
626
}
627

    
628
AVCodec amr_wb_decoder =
629
{
630
    "amr_wb",
631
    CODEC_TYPE_AUDIO,
632
    CODEC_ID_AMR_WB,
633
    sizeof(AMRWBContext),
634
    amr_wb_decode_init,
635
    NULL,
636
    amr_wb_decode_close,
637
    amr_wb_decode_frame,
638
};
639

    
640
AVCodec amr_wb_encoder =
641
{
642
    "amr_wb",
643
    CODEC_TYPE_AUDIO,
644
    CODEC_ID_AMR_WB,
645
    sizeof(AMRWBContext),
646
    amr_wb_encode_init,
647
    amr_wb_encode_frame,
648
    amr_wb_encode_close,
649
    NULL,
650
};
651

    
652
#endif //AMR_WB