Statistics
| Branch: | Revision:

ffmpeg / libavcodec / amr.c @ 967be700

History | View | Annotate | Download (16.5 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
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
 */
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 bc634f6f Zdenek Kabelac
    
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 d663a1fd Michael Niedermayer
    To use the fixed version run "./configure" with "--enable-amr-nb-fixed"
33 bc634f6f Zdenek Kabelac
    
34
    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
    
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
    "--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 bc634f6f Zdenek Kabelac
 
54
 */
55 d663a1fd Michael Niedermayer
56 bc634f6f Zdenek Kabelac
#include "../config.h"
57 891f64b3 joca@rixmail.se
#include "avcodec.h"
58
59 bc634f6f Zdenek Kabelac
#ifdef AMR_NB_FIXED
60
61
#define MMS_IO
62
63 891f64b3 joca@rixmail.se
#include "amr/sp_dec.h"
64
#include "amr/d_homing.h"
65
#include "amr/typedef.h"
66 bc634f6f Zdenek Kabelac
#include "amr/sp_enc.h"
67
#include "amr/sid_sync.h"
68
#include "amr/e_homing.h"
69 891f64b3 joca@rixmail.se
70 bc634f6f Zdenek Kabelac
#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 d663a1fd Michael Niedermayer
    for(i=0;i<8;i++)
101 bc634f6f Zdenek Kabelac
    {
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 891f64b3 joca@rixmail.se
/* frame size in serial bitstream file (frame type + serial stream + flags) */
114
#define SERIAL_FRAMESIZE (1+MAX_SERIAL_SIZE+5)
115
116 bc634f6f Zdenek Kabelac
typedef struct AMRContext {
117 891f64b3 joca@rixmail.se
    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 bc634f6f Zdenek Kabelac
    enum Mode enc_bitrate;
125
    Speech_Encode_FrameState *enstate;
126
    sid_syncState *sidstate;
127
    enum TXFrameType tx_frametype;
128
    
129
130
} AMRContext;
131 891f64b3 joca@rixmail.se
132
static int amr_nb_decode_init(AVCodecContext * avctx)
133
{
134 bc634f6f Zdenek Kabelac
    AMRContext *s = avctx->priv_data;
135 891f64b3 joca@rixmail.se
    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 bc634f6f Zdenek Kabelac
        printf("Speech_Decode_Frame_init error\n");
145 891f64b3 joca@rixmail.se
        return -1;
146
    }
147
    return 0;
148
}
149
150 bc634f6f Zdenek Kabelac
static int amr_nb_encode_init(AVCodecContext * avctx)
151 891f64b3 joca@rixmail.se
{
152 bc634f6f Zdenek Kabelac
    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 d663a1fd Michael Niedermayer
        if(avctx->debug)
163
        {
164
            fprintf(stderr, "Only 8000Hz sample rate supported\n");
165
        }
166 bc634f6f Zdenek Kabelac
        return -1;
167
    }
168
169
    if(avctx->channels!=1)
170
    {
171 d663a1fd Michael Niedermayer
        if(avctx->debug)
172
        {
173
            fprintf(stderr, "Only mono supported\n");
174
        }
175 bc634f6f Zdenek Kabelac
        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 d663a1fd Michael Niedermayer
        if(avctx->debug)
184
        {
185
            fprintf(stderr, "Speech_Encode_Frame_init error\n");
186
        }
187 bc634f6f Zdenek Kabelac
        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 891f64b3 joca@rixmail.se
    Speech_Decode_Frame_exit(&s->speech_decoder_state);
208 bc634f6f Zdenek Kabelac
    return 0;
209 891f64b3 joca@rixmail.se
}
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 bc634f6f Zdenek Kabelac
    AMRContext *s = avctx->priv_data;
216 891f64b3 joca@rixmail.se
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 bc634f6f Zdenek Kabelac
    *data_size=0;
226 891f64b3 joca@rixmail.se
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 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);
231 891f64b3 joca@rixmail.se
232
    synth=data;
233
234 bc634f6f Zdenek Kabelac
//    while(offset<buf_size)
235 891f64b3 joca@rixmail.se
    {
236 bc634f6f Zdenek Kabelac
        toc=amrData[offset];
237 891f64b3 joca@rixmail.se
        /* read rest of the frame based on ToC byte */
238
        q  = (toc >> 2) & 0x01;
239
        ft = (toc >> 3) & 0x0F;
240
241 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]);
242
243
        offset++;
244
245 891f64b3 joca@rixmail.se
        packed_bits=amrData+offset;
246
247
        offset+=packed_size[ft];
248
249 bc634f6f Zdenek Kabelac
        //Unsort and unpack bits
250 891f64b3 joca@rixmail.se
        s->rx_type = UnpackBits(q, ft, packed_bits, &s->mode, &serial[1]);
251
252 bc634f6f Zdenek Kabelac
        //We have a new frame
253 891f64b3 joca@rixmail.se
        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 bc634f6f Zdenek Kabelac
        //Each AMR-frame results in 160 16-bit samples
284 891f64b3 joca@rixmail.se
        *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 bc634f6f Zdenek Kabelac
    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 d663a1fd Michael Niedermayer
        if(avctx->debug)
361
        {
362
            fprintf(stderr, "Only 8000Hz sample rate supported\n");
363
        }
364 bc634f6f Zdenek Kabelac
        return -1;
365
    }
366
367
    if(avctx->channels!=1)
368
    {
369 d663a1fd Michael Niedermayer
        if(avctx->debug)
370
        {
371
            fprintf(stderr, "Only mono supported\n");
372
        }
373 bc634f6f Zdenek Kabelac
        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 d663a1fd Michael Niedermayer
        if(avctx->debug)
383
        {
384
            fprintf(stderr, "Encoder_Interface_init error\n");
385
        }
386 bc634f6f Zdenek Kabelac
        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 891f64b3 joca@rixmail.se
    return buf_size;
438
}
439
440 bc634f6f Zdenek Kabelac
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 891f64b3 joca@rixmail.se
AVCodec amr_nb_decoder =
458
{
459
    "amr_nb",
460
    CODEC_TYPE_AUDIO,
461
    CODEC_ID_AMR_NB,
462 bc634f6f Zdenek Kabelac
    sizeof(AMRContext),
463 891f64b3 joca@rixmail.se
    amr_nb_decode_init,
464
    NULL,
465 bc634f6f Zdenek Kabelac
    amr_nb_decode_close,
466 891f64b3 joca@rixmail.se
    amr_nb_decode_frame,
467
};
468
469 bc634f6f Zdenek Kabelac
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 d663a1fd Michael Niedermayer
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