Statistics
| Branch: | Revision:

ffmpeg / libavcodec / libamr.c @ 6f1af735

History | View | Annotate | Download (17.5 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 floating-point. For some reason the float encoder is significantly
30
 * faster at least on a P4 1.5GHz (0.9s instead of 9.9s on a 30s audio clip
31
 * at MR102). Both float and fixed point are supported for AMR-NB, but only
32
 * float for 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
 *
40
 * \subsection Fixed-point
41
 * The fixed-point (TS26.073) can be downloaded from:
42
 * http://www.3gpp.org/ftp/Specs/archive/26_series/26.073/26073-600.zip
43
 *
44
 * \subsection Specification
45
 * The specification for AMR-NB can be found in TS 26.071
46
 * (http://www.3gpp.org/ftp/Specs/html-info/26071.htm) and some other
47
 * info at http://www.3gpp.org/ftp/Specs/html-info/26-series.htm.
48
 *
49
 * \section AMR-WB
50
 *
51
 * \subsection Float
52
 * The reference code can be downloaded from:
53
 * http://www.3gpp.org/ftp/Specs/archive/26_series/26.204/26204-600.zip
54
 *
55
 * \subsection Fixed-point
56
 * If someone wants to use the fixed point version it can be downloaded from:
57
 * http://www.3gpp.org/ftp/Specs/archive/26_series/26.173/26173-571.zip.
58
 *
59
 * \subsection Specification
60
 * The specification for AMR-WB can be found in TS 26.171
61
 * (http://www.3gpp.org/ftp/Specs/html-info/26171.htm) and some other
62
 * info at http://www.3gpp.org/ftp/Specs/html-info/26-series.htm.
63
 *
64
 */
65

    
66
#include "avcodec.h"
67

    
68
#ifdef CONFIG_LIBAMR_NB_FIXED
69

    
70
#define MMS_IO
71

    
72
#include "amr/sp_dec.h"
73
#include "amr/d_homing.h"
74
#include "amr/typedef.h"
75
#include "amr/sp_enc.h"
76
#include "amr/sid_sync.h"
77
#include "amr/e_homing.h"
78

    
79
#else
80
#include <amrnb/interf_dec.h>
81
#include <amrnb/interf_enc.h>
82
#endif
83

    
84
static const char *nb_bitrate_unsupported =
85
    "bitrate not supported: use one of 4.75k, 5.15k, 5.9k, 6.7k, 7.4k, 7.95k, 10.2k or 12.2k\n";
86
static const char *wb_bitrate_unsupported =
87
    "bitrate not supported: use one of 6.6k, 8.85k, 12.65k, 14.25k, 15.85k, 18.25k, 19.85k, 23.05k, or 23.85k\n";
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_LIBAMR_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, nb_bitrate_unsupported);
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_LIBAMR_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, nb_bitrate_unsupported);
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, nb_bitrate_unsupported);
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_LIBAMR_NB) || defined(CONFIG_LIBAMR_NB_FIXED)
495

    
496
AVCodec libamr_nb_decoder =
497
{
498
    "libamr_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 libamr_nb_encoder =
509
{
510
    "libamr_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_LIBAMR_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/enc_if.h>
531
#include <amrwb/dec_if.h>
532
#include <amrwb/if_rom.h>
533

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

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

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

    
567

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

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

    
579
    s->frameCount=0;
580

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

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

    
593
    if((s->mode=getWBBitrateMode(avctx->bit_rate))<0)
594
    {
595
        av_log(avctx, AV_LOG_ERROR, wb_bitrate_unsupported);
596
        return -1;
597
    }
598

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

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

    
605
    return 0;
606
}
607

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

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

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

    
624
    if((s->mode=getWBBitrateMode(avctx->bit_rate))<0)
625
    {
626
        av_log(avctx, AV_LOG_ERROR, wb_bitrate_unsupported);
627
        return -1;
628
    }
629
    size = E_IF_encode(s->state, s->mode, data, frame, s->allow_dtx);
630
    return size;
631
}
632

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

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

    
640
    amr_decode_fix_avctx(avctx);
641

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

    
648
    return 0;
649
}
650

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

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

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

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

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

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

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

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

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

    
711
#endif //CONFIG_LIBAMR_WB