Statistics
| Branch: | Revision:

ffmpeg / libavcodec / amr.c @ 450420ce

History | View | Annotate | Download (16.6 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
    *data_size=0;
225

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

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

    
231
    synth=data;
232

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

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

    
242
        offset++;
243

    
244
        packed_bits=amrData+offset;
245

    
246
        offset+=packed_size[ft];
247

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

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

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

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

    
303

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

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

    
329

    
330
#else /* Float point version*/
331

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

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

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

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

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

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

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

    
390
    return 0;
391
}
392

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

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

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

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

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

    
423
    while(offset<buf_size)
424
    {
425
            dec_mode = (amrData[offset] >> 3) & 0x000F;
426
            packet_size = block_size[dec_mode];
427
    
428
        s->frameCount++;
429
        //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]);
430
            /* call decoder */
431
            Decoder_Interface_Decode(s->decState, &amrData[offset], data+*data_size, 0);
432
            *data_size+=160*2;
433
   
434
        offset+=packet_size+1; 
435
    }
436
    return buf_size;
437
}
438

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

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

    
451
    return written;
452
}
453

    
454
#endif
455

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

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

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

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

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

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

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

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

    
528

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

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

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

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

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

    
566
    return 0;
567
}
568

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

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

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

    
594
extern const UWord8 block_size[];
595

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

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

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

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

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

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

    
651
#endif //AMR_WB