Statistics
| Branch: | Revision:

ffmpeg / libavcodec / amr.c @ 5558bda8

History | View | Annotate | Download (17.6 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-610.zip
39
 * Extract the source into \c "ffmpeg/libavcodec/amr_float".
40
 * Enable it by passing \c "--enable-amr-nb" to \c "./configure".
41
 *
42
 * \subsection Fixed-point
43
 * The fixed-point (TS26.073) can be downloaded from:
44
 * http://www.3gpp.org/ftp/Specs/archive/26_series/26.073/26073-510.zip.
45
 * Extract the source into \c "ffmpeg/libavcodec/amr".
46
 * Enable it by passing \c "--enable-amr-nb-fixed" to \c "./configure".
47
 *
48
 * \subsection Specification
49
 * The specification for AMR-NB can be found in TS 26.071
50
 * (http://www.3gpp.org/ftp/Specs/html-info/26071.htm) and some other
51
 * info at http://www.3gpp.org/ftp/Specs/html-info/26-series.htm.
52
 *
53
 * \section AMR-WB
54
 * \subsection Float
55
 * The reference code can be downloaded from:
56
 * http://www.3gpp.org/ftp/Specs/archive/26_series/26.204/26204-600.zip
57
 * It should be extracted to \c "ffmpeg/libavcodec/amrwb_float".
58
 * Enable it by passing \c "--enable-amr-wb" to \c "./configure".
59
 *
60
 * \subsection Fixed-point
61
 * If someone wants to use the fixed point version it can be downloaded from:
62
 * http://www.3gpp.org/ftp/Specs/archive/26_series/26.173/26173-571.zip.
63
 *
64
 * \subsection Specification
65
 * The specification for AMR-WB can be found in TS 26.171
66
 * (http://www.3gpp.org/ftp/Specs/html-info/26171.htm) and some other
67
 * info at http://www.3gpp.org/ftp/Specs/html-info/26-series.htm.
68
 *
69
 */
70

    
71
#include "avcodec.h"
72

    
73
#ifdef CONFIG_AMR_NB_FIXED
74

    
75
#define MMS_IO
76

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

    
84
#else
85
#include "amr_float/interf_dec.h"
86
#include "amr_float/interf_enc.h"
87
#endif
88

    
89
/* Common code for fixed and float version*/
90
typedef struct AMR_bitrates
91
{
92
    int rate;
93
    enum Mode mode;
94
} AMR_bitrates;
95

    
96
/* Match desired bitrate */
97
static int getBitrateMode(int bitrate)
98
{
99
    /* make the correspondance between bitrate and mode */
100
    AMR_bitrates rates[]={ {4750,MR475},
101
                           {5150,MR515},
102
                           {5900,MR59},
103
                           {6700,MR67},
104
                           {7400,MR74},
105
                           {7950,MR795},
106
                           {10200,MR102},
107
                           {12200,MR122},
108
                         };
109
    int i;
110

    
111
    for(i=0;i<8;i++)
112
    {
113
        if(rates[i].rate==bitrate)
114
        {
115
            return(rates[i].mode);
116
        }
117
    }
118
    /* no bitrate matching, return an error */
119
    return -1;
120
}
121

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

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

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

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

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

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

    
152
    int enc_bitrate;
153
    Speech_Encode_FrameState *enstate;
154
    sid_syncState *sidstate;
155
    enum TXFrameType tx_frametype;
156
} AMRContext;
157

    
158
static int amr_nb_decode_init(AVCodecContext * avctx)
159
{
160
    AMRContext *s = avctx->priv_data;
161

    
162
    s->frameCount=0;
163
    s->speech_decoder_state=NULL;
164
    s->rx_type = (enum RXFrameType)0;
165
    s->mode= (enum Mode)0;
166
    s->reset_flag=0;
167
    s->reset_flag_old=1;
168

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

    
175
    amr_decode_fix_avctx(avctx);
176

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

    
183
    return 0;
184
}
185

    
186
static int amr_nb_encode_init(AVCodecContext * avctx)
187
{
188
    AMRContext *s = avctx->priv_data;
189

    
190
    s->frameCount=0;
191
    s->speech_decoder_state=NULL;
192
    s->rx_type = (enum RXFrameType)0;
193
    s->mode= (enum Mode)0;
194
    s->reset_flag=0;
195
    s->reset_flag_old=1;
196

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

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

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

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

    
218
    if((s->enc_bitrate=getBitrateMode(avctx->bit_rate))<0)
219
    {
220
        av_log(avctx, AV_LOG_ERROR, "bitrate not supported\n");
221
        return -1;
222
    }
223

    
224
    return 0;
225
}
226

    
227
static int amr_nb_encode_close(AVCodecContext * avctx)
228
{
229
    AMRContext *s = avctx->priv_data;
230

    
231
    Speech_Encode_Frame_exit(&s->enstate);
232
    sid_sync_exit (&s->sidstate);
233
    av_freep(&avctx->coded_frame);
234
    return 0;
235
}
236

    
237
static int amr_nb_decode_close(AVCodecContext * avctx)
238
{
239
    AMRContext *s = avctx->priv_data;
240

    
241
    Speech_Decode_Frame_exit(&s->speech_decoder_state);
242
    return 0;
243
}
244

    
245
static int amr_nb_decode_frame(AVCodecContext * avctx,
246
            void *data, int *data_size,
247
            uint8_t * buf, int buf_size)
248
{
249
    AMRContext *s = avctx->priv_data;
250
    uint8_t*amrData=buf;
251
    int offset=0;
252
    UWord8 toc, q, ft;
253
    Word16 serial[SERIAL_FRAMESIZE];   /* coded bits */
254
    Word16 *synth;
255
    UWord8 *packed_bits;
256
    static Word16 packed_size[16] = {12, 13, 15, 17, 19, 20, 26, 31, 5, 0, 0, 0, 0, 0, 0, 0};
257
    int i;
258

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

    
261
    synth=data;
262

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

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

    
270
    offset++;
271

    
272
    packed_bits=amrData+offset;
273

    
274
    offset+=packed_size[ft];
275

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

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

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

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

    
310
    //Each AMR-frame results in 160 16-bit samples
311
    *data_size=160*2;
312

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

    
326
    return offset;
327
}
328

    
329

    
330
static int amr_nb_encode_frame(AVCodecContext *avctx,
331
                            unsigned char *frame/*out*/, int buf_size, void *data/*in*/)
332
{
333
    short serial_data[250] = {0};
334
    AMRContext *s = avctx->priv_data;
335
    int written;
336

    
337
    s->reset_flag = encoder_homing_frame_test(data);
338

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

    
341
    /* add frame type and mode */
342
    sid_sync (s->sidstate, s->mode, &s->tx_frametype);
343

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

    
346
    if (s->reset_flag != 0)
347
    {
348
        Speech_Encode_Frame_reset(s->enstate);
349
        sid_sync_reset(s->sidstate);
350
    }
351
    return written;
352
}
353

    
354

    
355
#elif defined(CONFIG_AMR_NB) /* Float point version*/
356

    
357
typedef struct AMRContext {
358
    int frameCount;
359
    void * decState;
360
    int *enstate;
361
    int enc_bitrate;
362
} AMRContext;
363

    
364
static int amr_nb_decode_init(AVCodecContext * avctx)
365
{
366
    AMRContext *s = avctx->priv_data;
367

    
368
    s->frameCount=0;
369
    s->decState=Decoder_Interface_init();
370
    if(!s->decState)
371
    {
372
        av_log(avctx, AV_LOG_ERROR, "Decoder_Interface_init error\r\n");
373
        return -1;
374
    }
375

    
376
    amr_decode_fix_avctx(avctx);
377

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

    
384
    return 0;
385
}
386

    
387
static int amr_nb_encode_init(AVCodecContext * avctx)
388
{
389
    AMRContext *s = avctx->priv_data;
390

    
391
    s->frameCount=0;
392

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

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

    
405
    avctx->frame_size=160;
406
    avctx->coded_frame= avcodec_alloc_frame();
407

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

    
415
    if((s->enc_bitrate=getBitrateMode(avctx->bit_rate))<0)
416
    {
417
        av_log(avctx, AV_LOG_ERROR, "bitrate not supported\n");
418
        return -1;
419
    }
420

    
421
    return 0;
422
}
423

    
424
static int amr_nb_decode_close(AVCodecContext * avctx)
425
{
426
    AMRContext *s = avctx->priv_data;
427

    
428
    Decoder_Interface_exit(s->decState);
429
    return 0;
430
}
431

    
432
static int amr_nb_encode_close(AVCodecContext * avctx)
433
{
434
    AMRContext *s = avctx->priv_data;
435

    
436
    Encoder_Interface_exit(s->enstate);
437
    av_freep(&avctx->coded_frame);
438
    return 0;
439
}
440

    
441
static int amr_nb_decode_frame(AVCodecContext * avctx,
442
            void *data, int *data_size,
443
            uint8_t * buf, int buf_size)
444
{
445
    AMRContext *s = avctx->priv_data;
446
    uint8_t*amrData=buf;
447
    static short block_size[16]={ 12, 13, 15, 17, 19, 20, 26, 31, 5, 0, 0, 0, 0, 0, 0, 0 };
448
    enum Mode dec_mode;
449
    int packet_size;
450

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

    
453
    dec_mode = (buf[0] >> 3) & 0x000F;
454
    packet_size = block_size[dec_mode]+1;
455

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

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

    
467
    return packet_size;
468
}
469

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

    
476
    if((s->enc_bitrate=getBitrateMode(avctx->bit_rate))<0)
477
    {
478
        av_log(avctx, AV_LOG_ERROR, "bitrate not supported\n");
479
        return -1;
480
    }
481

    
482
    written = Encoder_Interface_Encode(s->enstate,
483
        s->enc_bitrate,
484
        data,
485
        frame,
486
        0);
487
    /* 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] ); */
488

    
489
    return written;
490
}
491

    
492
#endif
493

    
494
#if defined(CONFIG_AMR_NB) || defined(CONFIG_AMR_NB_FIXED)
495

    
496
AVCodec amr_nb_decoder =
497
{
498
    "amr_nb",
499
    CODEC_TYPE_AUDIO,
500
    CODEC_ID_AMR_NB,
501
    sizeof(AMRContext),
502
    amr_nb_decode_init,
503
    NULL,
504
    amr_nb_decode_close,
505
    amr_nb_decode_frame,
506
};
507

    
508
AVCodec amr_nb_encoder =
509
{
510
    "amr_nb",
511
    CODEC_TYPE_AUDIO,
512
    CODEC_ID_AMR_NB,
513
    sizeof(AMRContext),
514
    amr_nb_encode_init,
515
    amr_nb_encode_frame,
516
    amr_nb_encode_close,
517
    NULL,
518
};
519

    
520
#endif
521

    
522
/* -----------AMR wideband ------------*/
523
#ifdef CONFIG_AMR_WB
524

    
525
#ifdef _TYPEDEF_H
526
//To avoid duplicate typedefs from typdef in amr-nb
527
#define typedef_h
528
#endif
529

    
530
#include "amrwb_float/enc_if.h"
531
#include "amrwb_float/dec_if.h"
532

    
533
/* Common code for fixed and float version*/
534
typedef struct AMRWB_bitrates
535
{
536
    int rate;
537
    int mode;
538
} AMRWB_bitrates;
539

    
540
static int getWBBitrateMode(int bitrate)
541
{
542
    /* make the correspondance between bitrate and mode */
543
    AMRWB_bitrates rates[]={ {6600,0},
544
                           {8850,1},
545
                           {12650,2},
546
                           {14250,3},
547
                           {15850,4},
548
                           {18250,5},
549
                           {19850,6},
550
                           {23050,7},
551
                           {23850,8},
552
                         };
553
    int i;
554

    
555
    for(i=0;i<9;i++)
556
    {
557
        if(rates[i].rate==bitrate)
558
        {
559
            return(rates[i].mode);
560
        }
561
    }
562
    /* no bitrate matching, return an error */
563
    return -1;
564
}
565

    
566

    
567
typedef struct AMRWBContext {
568
    int frameCount;
569
    void *state;
570
    int mode;
571
    Word16 allow_dtx;
572
} AMRWBContext;
573

    
574
static int amr_wb_encode_init(AVCodecContext * avctx)
575
{
576
    AMRWBContext *s = avctx->priv_data;
577

    
578
    s->frameCount=0;
579

    
580
    if(avctx->sample_rate!=16000)
581
    {
582
        av_log(avctx, AV_LOG_ERROR, "Only 16000Hz sample rate supported\n");
583
        return -1;
584
    }
585

    
586
    if(avctx->channels!=1)
587
    {
588
        av_log(avctx, AV_LOG_ERROR, "Only mono supported\n");
589
        return -1;
590
    }
591

    
592
    if((s->mode=getWBBitrateMode(avctx->bit_rate))<0)
593
    {
594
        av_log(avctx, AV_LOG_ERROR, "bitrate not supported\n");
595
        return -1;
596
    }
597

    
598
    avctx->frame_size=320;
599
    avctx->coded_frame= avcodec_alloc_frame();
600

    
601
    s->state = E_IF_init();
602
    s->allow_dtx=0;
603

    
604
    return 0;
605
}
606

    
607
static int amr_wb_encode_close(AVCodecContext * avctx)
608
{
609
    AMRWBContext *s = avctx->priv_data;
610

    
611
    E_IF_exit(s->state);
612
    av_freep(&avctx->coded_frame);
613
    s->frameCount++;
614
    return 0;
615
}
616

    
617
static int amr_wb_encode_frame(AVCodecContext *avctx,
618
                            unsigned char *frame/*out*/, int buf_size, void *data/*in*/)
619
{
620
    AMRWBContext *s = avctx->priv_data;
621
    int size;
622

    
623
    if((s->mode=getWBBitrateMode(avctx->bit_rate))<0)
624
    {
625
        av_log(avctx, AV_LOG_ERROR, "bitrate not supported\n");
626
        return -1;
627
    }
628
    size = E_IF_encode(s->state, s->mode, data, frame, s->allow_dtx);
629
    return size;
630
}
631

    
632
static int amr_wb_decode_init(AVCodecContext * avctx)
633
{
634
    AMRWBContext *s = avctx->priv_data;
635

    
636
    s->frameCount=0;
637
    s->state = D_IF_init();
638

    
639
    amr_decode_fix_avctx(avctx);
640

    
641
    if(avctx->channels > 1)
642
    {
643
        av_log(avctx, AV_LOG_ERROR, "amr_wb: multichannel decoding not supported\n");
644
        return -1;
645
    }
646

    
647
    return 0;
648
}
649

    
650
extern const UWord8 block_size[];
651

    
652
static int amr_wb_decode_frame(AVCodecContext * avctx,
653
            void *data, int *data_size,
654
            uint8_t * buf, int buf_size)
655
{
656
    AMRWBContext *s = avctx->priv_data;
657
    uint8_t*amrData=buf;
658
    int mode;
659
    int packet_size;
660

    
661
    if(buf_size==0) {
662
        /* nothing to do */
663
        return 0;
664
    }
665

    
666
    mode = (amrData[0] >> 3) & 0x000F;
667
    packet_size = block_size[mode];
668

    
669
    if(packet_size > buf_size) {
670
        av_log(avctx, AV_LOG_ERROR, "amr frame too short (%u, should be %u)\n", buf_size, packet_size+1);
671
        return -1;
672
    }
673

    
674
    s->frameCount++;
675
    D_IF_decode( s->state, amrData, data, _good_frame);
676
    *data_size=320*2;
677
    return packet_size;
678
}
679

    
680
static int amr_wb_decode_close(AVCodecContext * avctx)
681
{
682
    AMRWBContext *s = avctx->priv_data;
683

    
684
    D_IF_exit(s->state);
685
    return 0;
686
}
687

    
688
AVCodec amr_wb_decoder =
689
{
690
    "amr_wb",
691
    CODEC_TYPE_AUDIO,
692
    CODEC_ID_AMR_WB,
693
    sizeof(AMRWBContext),
694
    amr_wb_decode_init,
695
    NULL,
696
    amr_wb_decode_close,
697
    amr_wb_decode_frame,
698
};
699

    
700
AVCodec amr_wb_encoder =
701
{
702
    "amr_wb",
703
    CODEC_TYPE_AUDIO,
704
    CODEC_ID_AMR_WB,
705
    sizeof(AMRWBContext),
706
    amr_wb_encode_init,
707
    amr_wb_encode_frame,
708
    amr_wb_encode_close,
709
    NULL,
710
};
711

    
712
#endif //CONFIG_AMR_WB