Statistics
| Branch: | Revision:

ffmpeg / libavcodec / amr.c @ e0b67c76

History | View | Annotate | Download (17.8 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
 /** @file
23
 * Adaptive Multi-Rate (AMR) Audio decoder stub.
24
 *
25
 * This code implements both an AMR-NarrowBand (AMR-NB) and an AMR-WideBand
26
 * (AMR-WB) audio encoder/decoder through external reference code from
27
 * http://www.3gpp.org/. The license of the code from 3gpp is unclear so you
28
 * have to download the code separately. Two versions exists: One fixed-point
29
 * and one with floats. For some reason the float-encoder is significant faster
30
 * at least on a P4 1.5GHz (0.9s instead of 9.9s on a 30s audio clip at MR102).
31
 * Both float and fixed point are supported for AMR-NB, but only float for
32
 * AMR-WB.
33
 *
34
 * \section AMR-NB
35
 *
36
 * \subsection Float
37
 * The float version (default) can be downloaded from:
38
 * http://www.3gpp.org/ftp/Specs/archive/26_series/26.104/26104-510.zip
39
 * Extract the source into \c "ffmpeg/libavcodec/amr_float".
40
 *
41
 * \subsection Fixed-point
42
 * The fixed-point (TS26.073) can be downloaded from:
43
 * http://www.3gpp.org/ftp/Specs/archive/26_series/26.073/26073-510.zip.
44
 * Extract the source into \c "ffmpeg/libavcodec/amr".
45
 * To use the fixed version run \c "./configure" with \c "--enable-amr_nb-fixed".
46
 *
47
 * \subsection Specification
48
 * The specification for AMR-NB can be found in TS 26.071
49
 * (http://www.3gpp.org/ftp/Specs/html-info/26071.htm) and some other
50
 * info at http://www.3gpp.org/ftp/Specs/html-info/26-series.htm.
51
 *
52
 * \section AMR-WB
53
 * \subsection Float
54
 * The reference code can be downloaded from:
55
 * http://www.3gpp.org/ftp/Specs/archive/26_series/26.204/26204-510.zip
56
 * It should be extracted to \c "ffmpeg/libavcodec/amrwb_float". Enable it with
57
 * \c "--enable-amr_wb".
58
 *
59
 * \subsection Fixed-point
60
 * If someone wants to use the fixed point version it can be downloaded from:
61
 * http://www.3gpp.org/ftp/Specs/archive/26_series/26.173/26173-571.zip.
62
 *
63
 * \subsection Specification
64
 * The specification for AMR-WB can be downloaded from:
65
 * http://www.3gpp.org/ftp/Specs/archive/26_series/26.171/26171-500.zip.
66
 *
67
 */
68

    
69
#include "avcodec.h"
70

    
71
#ifdef CONFIG_AMR_NB_FIXED
72

    
73
#define MMS_IO
74

    
75
#include "amr/sp_dec.h"
76
#include "amr/d_homing.h"
77
#include "amr/typedef.h"
78
#include "amr/sp_enc.h"
79
#include "amr/sid_sync.h"
80
#include "amr/e_homing.h"
81

    
82
#else
83
#include "amr_float/interf_dec.h"
84
#include "amr_float/interf_enc.h"
85
#endif
86

    
87
/* Common code for fixed and float version*/
88
typedef struct AMR_bitrates
89
{
90
    int startrate;
91
    int stoprate;
92
    enum Mode mode;
93

    
94
} AMR_bitrates;
95

    
96
/* Match desired bitrate with closest one*/
97
static enum Mode getBitrateMode(int bitrate)
98
{
99
    /* Adjusted so that all bitrates can be used from commandline where
100
       only a multiple of 1000 can be specified*/
101
    AMR_bitrates rates[]={ {0,4999,MR475}, //4
102
                           {5000,5899,MR515},//5
103
                           {5900,6699,MR59},//6
104
                           {6700,7000,MR67},//7
105
                           {7001,7949,MR74},//8
106
                           {7950,9999,MR795},//9
107
                           {10000,11999,MR102},//10
108
                           {12000,64000,MR122},//12
109

    
110
                         };
111
    int i;
112
    for(i=0;i<8;i++)
113
    {
114
        if(rates[i].startrate<=bitrate && rates[i].stoprate>=bitrate)
115
        {
116
            return(rates[i].mode);
117
        }
118
    }
119
    /*Return highest possible*/
120
    return(MR122);
121
}
122

    
123
static void amr_decode_fix_avctx(AVCodecContext * avctx)
124
{
125
    const int is_amr_wb = 1 + (avctx->codec_id == CODEC_ID_AMR_WB);
126

    
127
    if(avctx->sample_rate == 0)
128
    {
129
        avctx->sample_rate = 8000 * is_amr_wb;
130
    }
131

    
132
    if(avctx->channels == 0)
133
    {
134
        avctx->channels = 1;
135
    }
136

    
137
    avctx->frame_size = 160 * is_amr_wb;
138
}
139

    
140
#ifdef CONFIG_AMR_NB_FIXED
141
/* fixed point version*/
142
/* frame size in serial bitstream file (frame type + serial stream + flags) */
143
#define SERIAL_FRAMESIZE (1+MAX_SERIAL_SIZE+5)
144

    
145
typedef struct AMRContext {
146
    int frameCount;
147
    Speech_Decode_FrameState *speech_decoder_state;
148
    enum RXFrameType rx_type;
149
    enum Mode mode;
150
    Word16 reset_flag;
151
    Word16 reset_flag_old;
152

    
153
    enum Mode enc_bitrate;
154
    Speech_Encode_FrameState *enstate;
155
    sid_syncState *sidstate;
156
    enum TXFrameType tx_frametype;
157

    
158

    
159
} AMRContext;
160

    
161
static int amr_nb_decode_init(AVCodecContext * avctx)
162
{
163
    AMRContext *s = avctx->priv_data;
164
    s->frameCount=0;
165
    s->speech_decoder_state=NULL;
166
    s->rx_type = (enum RXFrameType)0;
167
    s->mode= (enum Mode)0;
168
    s->reset_flag=0;
169
    s->reset_flag_old=1;
170

    
171
    if(Speech_Decode_Frame_init(&s->speech_decoder_state, "Decoder"))
172
    {
173
        av_log(avctx, AV_LOG_ERROR, "Speech_Decode_Frame_init error\n");
174
        return -1;
175
    }
176

    
177
    amr_decode_fix_avctx(avctx);
178

    
179
    if(avctx->channels > 1)
180
    {
181
        av_log(avctx, AV_LOG_ERROR, "amr_nb: multichannel decoding not supported\n");
182
        return -1;
183
    }
184

    
185
    return 0;
186
}
187

    
188
static int amr_nb_encode_init(AVCodecContext * avctx)
189
{
190
    AMRContext *s = avctx->priv_data;
191
    s->frameCount=0;
192
    s->speech_decoder_state=NULL;
193
    s->rx_type = (enum RXFrameType)0;
194
    s->mode= (enum Mode)0;
195
    s->reset_flag=0;
196
    s->reset_flag_old=1;
197

    
198
    if(avctx->sample_rate!=8000)
199
    {
200
        av_log(avctx, AV_LOG_ERROR, "Only 8000Hz sample rate supported\n");
201
        return -1;
202
    }
203

    
204
    if(avctx->channels!=1)
205
    {
206
        av_log(avctx, AV_LOG_ERROR, "Only mono supported\n");
207
        return -1;
208
    }
209

    
210
    avctx->frame_size=160;
211
    avctx->coded_frame= avcodec_alloc_frame();
212

    
213
    if(Speech_Encode_Frame_init(&s->enstate, 0, "encoder") || sid_sync_init (&s->sidstate))
214
    {
215
        av_log(avctx, AV_LOG_ERROR, "Speech_Encode_Frame_init error\n");
216
        return -1;
217
    }
218

    
219
    s->enc_bitrate=getBitrateMode(avctx->bit_rate);
220

    
221
    return 0;
222
}
223

    
224
static int amr_nb_encode_close(AVCodecContext * avctx)
225
{
226
    AMRContext *s = avctx->priv_data;
227
    Speech_Encode_Frame_exit(&s->enstate);
228
    sid_sync_exit (&s->sidstate);
229
    av_freep(&avctx->coded_frame);
230
    return 0;
231
}
232

    
233
static int amr_nb_decode_close(AVCodecContext * avctx)
234
{
235
    AMRContext *s = avctx->priv_data;
236
    Speech_Decode_Frame_exit(&s->speech_decoder_state);
237
    return 0;
238
}
239

    
240
static int amr_nb_decode_frame(AVCodecContext * avctx,
241
            void *data, int *data_size,
242
            uint8_t * buf, int buf_size)
243
{
244
    AMRContext *s = avctx->priv_data;
245

    
246
    uint8_t*amrData=buf;
247
    int offset=0;
248

    
249
    UWord8 toc, q, ft;
250

    
251
    Word16 serial[SERIAL_FRAMESIZE];   /* coded bits */
252
    Word16 *synth;
253
    UWord8 *packed_bits;
254

    
255
    static Word16 packed_size[16] = {12, 13, 15, 17, 19, 20, 26, 31, 5, 0, 0, 0, 0, 0, 0, 0};
256
    int i;
257

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

    
260
    synth=data;
261

    
262
//    while(offset<buf_size)
263
    {
264
        toc=amrData[offset];
265
        /* read rest of the frame based on ToC byte */
266
        q  = (toc >> 2) & 0x01;
267
        ft = (toc >> 3) & 0x0F;
268

    
269
        //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]);
270

    
271
        offset++;
272

    
273
        packed_bits=amrData+offset;
274

    
275
        offset+=packed_size[ft];
276

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

    
280
        //We have a new frame
281
        s->frameCount++;
282

    
283
        if (s->rx_type == RX_NO_DATA)
284
        {
285
            s->mode = s->speech_decoder_state->prev_mode;
286
        }
287
        else {
288
            s->speech_decoder_state->prev_mode = s->mode;
289
        }
290

    
291
        /* if homed: check if this frame is another homing frame */
292
        if (s->reset_flag_old == 1)
293
        {
294
            /* only check until end of first subframe */
295
            s->reset_flag = decoder_homing_frame_test_first(&serial[1], s->mode);
296
        }
297
        /* produce encoder homing frame if homed & input=decoder homing frame */
298
        if ((s->reset_flag != 0) && (s->reset_flag_old != 0))
299
        {
300
            for (i = 0; i < L_FRAME; i++)
301
            {
302
                synth[i] = EHF_MASK;
303
            }
304
        }
305
        else
306
        {
307
            /* decode frame */
308
            Speech_Decode_Frame(s->speech_decoder_state, s->mode, &serial[1], s->rx_type, synth);
309
        }
310

    
311
        //Each AMR-frame results in 160 16-bit samples
312
        *data_size+=160*2;
313
        synth+=160;
314

    
315
        /* if not homed: check whether current frame is a homing frame */
316
        if (s->reset_flag_old == 0)
317
        {
318
            /* check whole frame */
319
            s->reset_flag = decoder_homing_frame_test(&serial[1], s->mode);
320
        }
321
        /* reset decoder if current frame is a homing frame */
322
        if (s->reset_flag != 0)
323
        {
324
            Speech_Decode_Frame_reset(s->speech_decoder_state);
325
        }
326
        s->reset_flag_old = s->reset_flag;
327

    
328
    }
329
    return offset;
330
}
331

    
332

    
333
static int amr_nb_encode_frame(AVCodecContext *avctx,
334
                            unsigned char *frame/*out*/, int buf_size, void *data/*in*/)
335
{
336
    short serial_data[250] = {0};
337

    
338
    AMRContext *s = avctx->priv_data;
339
    int written;
340

    
341
    s->reset_flag = encoder_homing_frame_test(data);
342

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

    
345
    /* add frame type and mode */
346
    sid_sync (s->sidstate, s->mode, &s->tx_frametype);
347

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

    
350
    if (s->reset_flag != 0)
351
    {
352
        Speech_Encode_Frame_reset(s->enstate);
353
        sid_sync_reset(s->sidstate);
354
    }
355
    return written;
356
}
357

    
358

    
359
#elif defined(CONFIG_AMR_NB) /* Float point version*/
360

    
361
typedef struct AMRContext {
362
    int frameCount;
363
    void * decState;
364
    int *enstate;
365
    enum Mode enc_bitrate;
366
} AMRContext;
367

    
368
static int amr_nb_decode_init(AVCodecContext * avctx)
369
{
370
    AMRContext *s = avctx->priv_data;
371
    s->frameCount=0;
372
    s->decState=Decoder_Interface_init();
373
    if(!s->decState)
374
    {
375
        av_log(avctx, AV_LOG_ERROR, "Decoder_Interface_init error\r\n");
376
        return -1;
377
    }
378

    
379
    amr_decode_fix_avctx(avctx);
380

    
381
    if(avctx->channels > 1)
382
    {
383
        av_log(avctx, AV_LOG_ERROR, "amr_nb: multichannel decoding not supported\n");
384
        return -1;
385
    }
386

    
387
    return 0;
388
}
389

    
390
static int amr_nb_encode_init(AVCodecContext * avctx)
391
{
392
    AMRContext *s = avctx->priv_data;
393
    s->frameCount=0;
394

    
395
    if(avctx->sample_rate!=8000)
396
    {
397
        av_log(avctx, AV_LOG_ERROR, "Only 8000Hz sample rate supported\n");
398
        return -1;
399
    }
400

    
401
    if(avctx->channels!=1)
402
    {
403
        av_log(avctx, AV_LOG_ERROR, "Only mono supported\n");
404
        return -1;
405
    }
406

    
407
    avctx->frame_size=160;
408
    avctx->coded_frame= avcodec_alloc_frame();
409

    
410
    s->enstate=Encoder_Interface_init(0);
411
    if(!s->enstate)
412
    {
413
        av_log(avctx, AV_LOG_ERROR, "Encoder_Interface_init error\n");
414
        return -1;
415
    }
416

    
417
    s->enc_bitrate=getBitrateMode(avctx->bit_rate);
418

    
419
    return 0;
420
}
421

    
422
static int amr_nb_decode_close(AVCodecContext * avctx)
423
{
424
    AMRContext *s = avctx->priv_data;
425
    Decoder_Interface_exit(s->decState);
426
    return 0;
427
}
428

    
429
static int amr_nb_encode_close(AVCodecContext * avctx)
430
{
431
    AMRContext *s = avctx->priv_data;
432
    Encoder_Interface_exit(s->enstate);
433
    av_freep(&avctx->coded_frame);
434
    return 0;
435
}
436

    
437
static int amr_nb_decode_frame(AVCodecContext * avctx,
438
            void *data, int *data_size,
439
            uint8_t * buf, int buf_size)
440
{
441
    AMRContext *s = (AMRContext*)avctx->priv_data;
442

    
443
    uint8_t*amrData=buf;
444
    static short block_size[16]={ 12, 13, 15, 17, 19, 20, 26, 31, 5, 0, 0, 0, 0, 0, 0, 0 };
445
    enum Mode dec_mode;
446
    int packet_size;
447

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

    
450
    dec_mode = (buf[0] >> 3) & 0x000F;
451
    packet_size = block_size[dec_mode]+1;
452

    
453
    if(packet_size > buf_size) {
454
        av_log(avctx, AV_LOG_ERROR, "amr frame too short (%u, should be %u)\n", buf_size, packet_size);
455
        return -1;
456
    }
457

    
458
    s->frameCount++;
459
    /* 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]); */
460
    /* call decoder */
461
    Decoder_Interface_Decode(s->decState, amrData, data, 0);
462
    *data_size=160*2;
463

    
464
    return packet_size;
465
}
466

    
467
static int amr_nb_encode_frame(AVCodecContext *avctx,
468
                            unsigned char *frame/*out*/, int buf_size, void *data/*in*/)
469
{
470
    AMRContext *s = (AMRContext*)avctx->priv_data;
471
    int written;
472

    
473
    s->enc_bitrate=getBitrateMode(avctx->bit_rate);
474

    
475
    written = Encoder_Interface_Encode(s->enstate,
476
        s->enc_bitrate,
477
        data,
478
        frame,
479
        0);
480
    /* 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] ); */
481

    
482
    return written;
483
}
484

    
485
#endif
486

    
487
#if defined(CONFIG_AMR_NB) || defined(CONFIG_AMR_NB_FIXED)
488

    
489
AVCodec amr_nb_decoder =
490
{
491
    "amr_nb",
492
    CODEC_TYPE_AUDIO,
493
    CODEC_ID_AMR_NB,
494
    sizeof(AMRContext),
495
    amr_nb_decode_init,
496
    NULL,
497
    amr_nb_decode_close,
498
    amr_nb_decode_frame,
499
};
500

    
501
AVCodec amr_nb_encoder =
502
{
503
    "amr_nb",
504
    CODEC_TYPE_AUDIO,
505
    CODEC_ID_AMR_NB,
506
    sizeof(AMRContext),
507
    amr_nb_encode_init,
508
    amr_nb_encode_frame,
509
    amr_nb_encode_close,
510
    NULL,
511
};
512

    
513
#endif
514

    
515
/* -----------AMR wideband ------------*/
516
#ifdef CONFIG_AMR_WB
517

    
518
#ifdef _TYPEDEF_H
519
//To avoid duplicate typedefs from typdef in amr-nb
520
#define typedef_h
521
#endif
522

    
523
#include "amrwb_float/enc_if.h"
524
#include "amrwb_float/dec_if.h"
525

    
526
/* Common code for fixed and float version*/
527
typedef struct AMRWB_bitrates
528
{
529
    int startrate;
530
    int stoprate;
531
    int mode;
532

    
533
} AMRWB_bitrates;
534

    
535
static int getWBBitrateMode(int bitrate)
536
{
537
    /* Adjusted so that all bitrates can be used from commandline where
538
       only a multiple of 1000 can be specified*/
539
    AMRWB_bitrates rates[]={ {0,7999,0}, //6.6kHz
540
                           {8000,9999,1},//8.85
541
                           {10000,13000,2},//12.65
542
                           {13001,14999,3},//14.25
543
                           {15000,17000,4},//15.85
544
                           {17001,18000,5},//18.25
545
                           {18001,22000,6},//19.85
546
                           {22001,23000,7},//23.05
547
                           {23001,24000,8},//23.85
548

    
549
                         };
550
    int i;
551

    
552
    for(i=0;i<9;i++)
553
    {
554
        if(rates[i].startrate<=bitrate && rates[i].stoprate>=bitrate)
555
        {
556
            return(rates[i].mode);
557
        }
558
    }
559
    /*Return highest possible*/
560
    return(8);
561
}
562

    
563

    
564
typedef struct AMRWBContext {
565
    int frameCount;
566
    void *state;
567
    int mode;
568
    Word16 allow_dtx;
569
} AMRWBContext;
570

    
571
static int amr_wb_encode_init(AVCodecContext * avctx)
572
{
573
    AMRWBContext *s = (AMRWBContext*)avctx->priv_data;
574
    s->frameCount=0;
575

    
576
    if(avctx->sample_rate!=16000)
577
    {
578
        av_log(avctx, AV_LOG_ERROR, "Only 16000Hz sample rate supported\n");
579
        return -1;
580
    }
581

    
582
    if(avctx->channels!=1)
583
    {
584
        av_log(avctx, AV_LOG_ERROR, "Only mono supported\n");
585
        return -1;
586
    }
587

    
588
    avctx->frame_size=320;
589
    avctx->coded_frame= avcodec_alloc_frame();
590

    
591
    s->state = E_IF_init();
592
    s->mode=getWBBitrateMode(avctx->bit_rate);
593
    s->allow_dtx=0;
594

    
595
    return 0;
596
}
597

    
598
static int amr_wb_encode_close(AVCodecContext * avctx)
599
{
600
    AMRWBContext *s = (AMRWBContext*) avctx->priv_data;
601
    E_IF_exit(s->state);
602
    av_freep(&avctx->coded_frame);
603
    s->frameCount++;
604
    return 0;
605
}
606

    
607
static int amr_wb_encode_frame(AVCodecContext *avctx,
608
                            unsigned char *frame/*out*/, int buf_size, void *data/*in*/)
609
{
610
    AMRWBContext *s;
611
    int size;
612
    s = (AMRWBContext*) avctx->priv_data;
613
    s->mode=getWBBitrateMode(avctx->bit_rate);
614
    size = E_IF_encode(s->state, s->mode, data, frame, s->allow_dtx);
615
    return size;
616
}
617

    
618
static int amr_wb_decode_init(AVCodecContext * avctx)
619
{
620
    AMRWBContext *s = (AMRWBContext *)avctx->priv_data;
621
    s->frameCount=0;
622
    s->state = D_IF_init();
623

    
624
    amr_decode_fix_avctx(avctx);
625

    
626
    if(avctx->channels > 1)
627
    {
628
        av_log(avctx, AV_LOG_ERROR, "amr_wb: multichannel decoding not supported\n");
629
        return -1;
630
    }
631

    
632
    return 0;
633
}
634

    
635
extern const UWord8 block_size[];
636

    
637
static int amr_wb_decode_frame(AVCodecContext * avctx,
638
            void *data, int *data_size,
639
            uint8_t * buf, int buf_size)
640
{
641
    AMRWBContext *s = (AMRWBContext*)avctx->priv_data;
642

    
643
    uint8_t*amrData=buf;
644
    int mode;
645
    int packet_size;
646

    
647
    if(buf_size==0) {
648
        /* nothing to do */
649
        return 0;
650
    }
651

    
652
    mode = (amrData[0] >> 3) & 0x000F;
653
    packet_size = block_size[mode];
654

    
655
    if(packet_size > buf_size) {
656
        av_log(avctx, AV_LOG_ERROR, "amr frame too short (%u, should be %u)\n", buf_size, packet_size+1);
657
        return -1;
658
    }
659

    
660
    s->frameCount++;
661
    D_IF_decode( s->state, amrData, data, _good_frame);
662
    *data_size=320*2;
663
    return packet_size;
664
}
665

    
666
static int amr_wb_decode_close(AVCodecContext * avctx)
667
{
668
    AMRWBContext *s = (AMRWBContext *)avctx->priv_data;
669
    D_IF_exit(s->state);
670
    return 0;
671
}
672

    
673
AVCodec amr_wb_decoder =
674
{
675
    "amr_wb",
676
    CODEC_TYPE_AUDIO,
677
    CODEC_ID_AMR_WB,
678
    sizeof(AMRWBContext),
679
    amr_wb_decode_init,
680
    NULL,
681
    amr_wb_decode_close,
682
    amr_wb_decode_frame,
683
};
684

    
685
AVCodec amr_wb_encoder =
686
{
687
    "amr_wb",
688
    CODEC_TYPE_AUDIO,
689
    CODEC_ID_AMR_WB,
690
    sizeof(AMRWBContext),
691
    amr_wb_encode_init,
692
    amr_wb_encode_frame,
693
    amr_wb_encode_close,
694
    NULL,
695
};
696

    
697
#endif //CONFIG_AMR_WB