git.sesse.net Git - ffmpeg/blob - libavcodec/amr.c

   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     This code implements amr-nb and amr-wb audio encoder/decoder through external reference
  23     code from www.3gpp.org. The licence of the code from 3gpp is unclear so you
  24     have to download the code separately. Two versions exists: One fixed-point
  25     and one with floats. For some reason the float-encoder is significant faster
  26     atleast on a P4 1.5GHz (0.9s instead of 9.9s on a 30s audio clip at MR102).
  27     Both float and fixed point is supported for amr-nb, but only float for
  28     amr-wb.
  29
  30     --AMR-NB--
  31     The fixed-point (TS26.073) can be downloaded from:
  32     http://www.3gpp.org/ftp/Specs/archive/26_series/26.073/26073-510.zip
  33     Extract the soure into ffmpeg/libavcodec/amr
  34     To use the fixed version run "./configure" with "--enable-amr_nb-fixed"
  35
  36     The float version (default) can be downloaded from:
  37     http://www.3gpp.org/ftp/Specs/archive/26_series/26.104/26104-510.zip
  38     Extract the soure into ffmpeg/libavcodec/amr_float
  39
  40     The specification for amr-nb can be found in TS 26.071
  41     (http://www.3gpp.org/ftp/Specs/html-info/26071.htm) and some other
  42     info at http://www.3gpp.org/ftp/Specs/html-info/26-series.htm
  43
  44     --AMR-WB--
  45     The reference code can be downloaded from:
  46     http://www.3gpp.org/ftp/Specs/archive/26_series/26.204/26204-510.zip
  47     It should be extracted to "libavcodec/amrwb_float". Enable it with
  48     "--enable-amr_wb".
  49
  50     The specification for amr-wb can be downloaded from:
  51     http://www.3gpp.org/ftp/Specs/archive/26_series/26.171/26171-500.zip
  52
  53     If someone want to use the fixed point version it can be downloaded
  54     from: http://www.3gpp.org/ftp/Specs/archive/26_series/26.173/26173-571.zip
  55
  56  */
  57
  58 #include "avcodec.h"
  59
  60 #ifdef CONFIG_AMR_NB_FIXED
  61
  62 #define MMS_IO
  63
  64 #include "amr/sp_dec.h"
  65 #include "amr/d_homing.h"
  66 #include "amr/typedef.h"
  67 #include "amr/sp_enc.h"
  68 #include "amr/sid_sync.h"
  69 #include "amr/e_homing.h"
  70
  71 #else
  72 #include "amr_float/interf_dec.h"
  73 #include "amr_float/interf_enc.h"
  74 #endif
  75
  76 /* Common code for fixed and float version*/
  77 typedef struct AMR_bitrates
  78 {
  79     int startrate;
  80     int stoprate;
  81     enum Mode mode;
  82
  83 } AMR_bitrates;
  84
  85 /* Match desired bitrate with closest one*/
  86 static enum Mode getBitrateMode(int bitrate)
  87 {
  88     /* Adjusted so that all bitrates can be used from commandline where
  89        only a multiple of 1000 can be specified*/
  90     AMR_bitrates rates[]={ {0,4999,MR475}, //4
  91                            {5000,5899,MR515},//5
  92                            {5900,6699,MR59},//6
  93                            {6700,7000,MR67},//7
  94                            {7001,7949,MR74},//8
  95                            {7950,9999,MR795},//9
  96                            {10000,11999,MR102},//10
  97                            {12000,64000,MR122},//12
  98
  99                          };
 100     int i;
 101     for(i=0;i<8;i++)
 102     {
 103         if(rates[i].startrate<=bitrate && rates[i].stoprate>=bitrate)
 104         {
 105             return(rates[i].mode);
 106         }
 107     }
 108     /*Return highest possible*/
 109     return(MR122);
 110 }
 111
 112 static void amr_decode_fix_avctx(AVCodecContext * avctx)
 113 {
 114     const int is_amr_wb = 1 + (avctx->codec_id == CODEC_ID_AMR_WB);
 115
 116     if(avctx->sample_rate == 0)
 117     {
 118         avctx->sample_rate = 8000 * is_amr_wb;
 119     }
 120
 121     if(avctx->channels == 0)
 122     {
 123         avctx->channels = 1;
 124     }
 125
 126     avctx->frame_size = 160 * is_amr_wb;
 127 }
 128
 129 #ifdef CONFIG_AMR_NB_FIXED
 130 /* fixed point version*/
 131 /* frame size in serial bitstream file (frame type + serial stream + flags) */
 132 #define SERIAL_FRAMESIZE (1+MAX_SERIAL_SIZE+5)
 133
 134 typedef struct AMRContext {
 135     int frameCount;
 136     Speech_Decode_FrameState *speech_decoder_state;
 137     enum RXFrameType rx_type;
 138     enum Mode mode;
 139     Word16 reset_flag;
 140     Word16 reset_flag_old;
 141
 142     enum Mode enc_bitrate;
 143     Speech_Encode_FrameState *enstate;
 144     sid_syncState *sidstate;
 145     enum TXFrameType tx_frametype;
 146
 147
 148 } AMRContext;
 149
 150 static int amr_nb_decode_init(AVCodecContext * avctx)
 151 {
 152     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(Speech_Decode_Frame_init(&s->speech_decoder_state, "Decoder"))
 161     {
 162         av_log(avctx, AV_LOG_ERROR, "Speech_Decode_Frame_init error\n");
 163         return -1;
 164     }
 165
 166     amr_decode_fix_avctx(avctx);
 167
 168     if(avctx->channels > 1)
 169     {
 170         av_log(avctx, AV_LOG_ERROR, "amr_nb: multichannel decoding not supported\n");
 171         return -1;
 172     }
 173
 174     return 0;
 175 }
 176
 177 static int amr_nb_encode_init(AVCodecContext * avctx)
 178 {
 179     AMRContext *s = avctx->priv_data;
 180     s->frameCount=0;
 181     s->speech_decoder_state=NULL;
 182     s->rx_type = (enum RXFrameType)0;
 183     s->mode= (enum Mode)0;
 184     s->reset_flag=0;
 185     s->reset_flag_old=1;
 186
 187     if(avctx->sample_rate!=8000)
 188     {
 189         if(avctx->debug)
 190         {
 191             av_log(avctx, AV_LOG_DEBUG, "Only 8000Hz sample rate supported\n");
 192         }
 193         return -1;
 194     }
 195
 196     if(avctx->channels!=1)
 197     {
 198         if(avctx->debug)
 199         {
 200             av_log(avctx, AV_LOG_DEBUG, "Only mono supported\n");
 201         }
 202         return -1;
 203     }
 204
 205     avctx->frame_size=160;
 206     avctx->coded_frame= avcodec_alloc_frame();
 207
 208     if(Speech_Encode_Frame_init(&s->enstate, 0, "encoder") || sid_sync_init (&s->sidstate))
 209     {
 210         if(avctx->debug)
 211         {
 212             av_log(avctx, AV_LOG_DEBUG, "Speech_Encode_Frame_init error\n");
 213         }
 214         return -1;
 215     }
 216
 217     s->enc_bitrate=getBitrateMode(avctx->bit_rate);
 218
 219     return 0;
 220 }
 221
 222 static int amr_nb_encode_close(AVCodecContext * avctx)
 223 {
 224     AMRContext *s = avctx->priv_data;
 225     Speech_Encode_Frame_exit(&s->enstate);
 226     sid_sync_exit (&s->sidstate);
 227     av_freep(&avctx->coded_frame);
 228     return 0;
 229 }
 230
 231 static int amr_nb_decode_close(AVCodecContext * avctx)
 232 {
 233     AMRContext *s = avctx->priv_data;
 234     Speech_Decode_Frame_exit(&s->speech_decoder_state);
 235     return 0;
 236 }
 237
 238 static int amr_nb_decode_frame(AVCodecContext * avctx,
 239             void *data, int *data_size,
 240             uint8_t * buf, int buf_size)
 241 {
 242     AMRContext *s = avctx->priv_data;
 243
 244     uint8_t*amrData=buf;
 245     int offset=0;
 246
 247     UWord8 toc, q, ft;
 248
 249     Word16 serial[SERIAL_FRAMESIZE];   /* coded bits */
 250     Word16 *synth;
 251     UWord8 *packed_bits;
 252
 253     static Word16 packed_size[16] = {12, 13, 15, 17, 19, 20, 26, 31, 5, 0, 0, 0, 0, 0, 0, 0};
 254     int i;
 255
 256     //printf("amr_decode_frame data_size=%i buf=0x%X buf_size=%d frameCount=%d!!\n",*data_size,buf,buf_size,s->frameCount);
 257
 258     synth=data;
 259
 260 //    while(offset<buf_size)
 261     {
 262         toc=amrData[offset];
 263         /* read rest of the frame based on ToC byte */
 264         q  = (toc >> 2) & 0x01;
 265         ft = (toc >> 3) & 0x0F;
 266
 267         //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]);
 268
 269         offset++;
 270
 271         packed_bits=amrData+offset;
 272
 273         offset+=packed_size[ft];
 274
 275         //Unsort and unpack bits
 276         s->rx_type = UnpackBits(q, ft, packed_bits, &s->mode, &serial[1]);
 277
 278         //We have a new frame
 279         s->frameCount++;
 280
 281         if (s->rx_type == RX_NO_DATA)
 282         {
 283             s->mode = s->speech_decoder_state->prev_mode;
 284         }
 285         else {
 286             s->speech_decoder_state->prev_mode = s->mode;
 287         }
 288
 289         /* if homed: check if this frame is another homing frame */
 290         if (s->reset_flag_old == 1)
 291         {
 292             /* only check until end of first subframe */
 293             s->reset_flag = decoder_homing_frame_test_first(&serial[1], s->mode);
 294         }
 295         /* produce encoder homing frame if homed & input=decoder homing frame */
 296         if ((s->reset_flag != 0) && (s->reset_flag_old != 0))
 297         {
 298             for (i = 0; i < L_FRAME; i++)
 299             {
 300                 synth[i] = EHF_MASK;
 301             }
 302         }
 303         else
 304         {
 305             /* decode frame */
 306             Speech_Decode_Frame(s->speech_decoder_state, s->mode, &serial[1], s->rx_type, synth);
 307         }
 308
 309         //Each AMR-frame results in 160 16-bit samples
 310         *data_size+=160*2;
 311         synth+=160;
 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     }
 327     return offset;
 328 }
 329
 330
 331 static int amr_nb_encode_frame(AVCodecContext *avctx,
 332                             unsigned char *frame/*out*/, int buf_size, void *data/*in*/)
 333 {
 334     short serial_data[250] = {0};
 335
 336     AMRContext *s = avctx->priv_data;
 337     int written;
 338
 339     s->reset_flag = encoder_homing_frame_test(data);
 340
 341     Speech_Encode_Frame(s->enstate, s->enc_bitrate, data, &serial_data[1], &s->mode);
 342
 343     /* add frame type and mode */
 344     sid_sync (s->sidstate, s->mode, &s->tx_frametype);
 345
 346     written = PackBits(s->mode, s->enc_bitrate, s->tx_frametype, &serial_data[1], frame);
 347
 348     if (s->reset_flag != 0)
 349     {
 350         Speech_Encode_Frame_reset(s->enstate);
 351         sid_sync_reset(s->sidstate);
 352     }
 353     return written;
 354 }
 355
 356
 357 #elif defined(CONFIG_AMR_NB) /* Float point version*/
 358
 359 typedef struct AMRContext {
 360     int frameCount;
 361     void * decState;
 362     int *enstate;
 363     enum Mode enc_bitrate;
 364 } AMRContext;
 365
 366 static int amr_nb_decode_init(AVCodecContext * avctx)
 367 {
 368     AMRContext *s = avctx->priv_data;
 369     s->frameCount=0;
 370     s->decState=Decoder_Interface_init();
 371     if(!s->decState)
 372     {
 373         av_log(avctx, AV_LOG_ERROR, "Decoder_Interface_init error\r\n");
 374         return -1;
 375     }
 376
 377     amr_decode_fix_avctx(avctx);
 378
 379     if(avctx->channels > 1)
 380     {
 381         av_log(avctx, AV_LOG_ERROR, "amr_nb: multichannel decoding not supported\n");
 382         return -1;
 383     }
 384
 385     return 0;
 386 }
 387
 388 static int amr_nb_encode_init(AVCodecContext * avctx)
 389 {
 390     AMRContext *s = avctx->priv_data;
 391     s->frameCount=0;
 392
 393     if(avctx->sample_rate!=8000)
 394     {
 395         if(avctx->debug)
 396         {
 397             av_log(avctx, AV_LOG_DEBUG, "Only 8000Hz sample rate supported\n");
 398         }
 399         return -1;
 400     }
 401
 402     if(avctx->channels!=1)
 403     {
 404         if(avctx->debug)
 405         {
 406             av_log(avctx, AV_LOG_DEBUG, "Only mono supported\n");
 407         }
 408         return -1;
 409     }
 410
 411     avctx->frame_size=160;
 412     avctx->coded_frame= avcodec_alloc_frame();
 413
 414     s->enstate=Encoder_Interface_init(0);
 415     if(!s->enstate)
 416     {
 417         if(avctx->debug)
 418         {
 419             av_log(avctx, AV_LOG_DEBUG, "Encoder_Interface_init error\n");
 420         }
 421         return -1;
 422     }
 423
 424     s->enc_bitrate=getBitrateMode(avctx->bit_rate);
 425
 426     return 0;
 427 }
 428
 429 static int amr_nb_decode_close(AVCodecContext * avctx)
 430 {
 431     AMRContext *s = avctx->priv_data;
 432     Decoder_Interface_exit(s->decState);
 433     return 0;
 434 }
 435
 436 static int amr_nb_encode_close(AVCodecContext * avctx)
 437 {
 438     AMRContext *s = avctx->priv_data;
 439     Encoder_Interface_exit(s->enstate);
 440     av_freep(&avctx->coded_frame);
 441     return 0;
 442 }
 443
 444 static int amr_nb_decode_frame(AVCodecContext * avctx,
 445             void *data, int *data_size,
 446             uint8_t * buf, int buf_size)
 447 {
 448     AMRContext *s = (AMRContext*)avctx->priv_data;
 449
 450     uint8_t*amrData=buf;
 451     static short block_size[16]={ 12, 13, 15, 17, 19, 20, 26, 31, 5, 0, 0, 0, 0, 0, 0, 0 };
 452     enum Mode dec_mode;
 453     int packet_size;
 454
 455     /* av_log(NULL,AV_LOG_DEBUG,"amr_decode_frame buf=%p buf_size=%d frameCount=%d!!\n",buf,buf_size,s->frameCount); */
 456
 457     if(buf_size==0) {
 458         /* nothing to do */
 459         return 0;
 460     }
 461
 462     dec_mode = (buf[0] >> 3) & 0x000F;
 463     packet_size = block_size[dec_mode]+1;
 464
 465     if(packet_size > buf_size) {
 466         av_log(avctx, AV_LOG_ERROR, "amr frame too short (%u, should be %u)\n", buf_size, packet_size);
 467         return -1;
 468     }
 469
 470     s->frameCount++;
 471     /* 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]); */
 472     /* call decoder */
 473     Decoder_Interface_Decode(s->decState, amrData, data, 0);
 474     *data_size=160*2;
 475
 476     return packet_size;
 477 }
 478
 479 static int amr_nb_encode_frame(AVCodecContext *avctx,
 480                             unsigned char *frame/*out*/, int buf_size, void *data/*in*/)
 481 {
 482     AMRContext *s = (AMRContext*)avctx->priv_data;
 483     int written;
 484
 485     s->enc_bitrate=getBitrateMode(avctx->bit_rate);
 486
 487     written = Encoder_Interface_Encode(s->enstate,
 488         s->enc_bitrate,
 489         data,
 490         frame,
 491         0);
 492     /* 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] ); */
 493
 494     return written;
 495 }
 496
 497 #endif
 498
 499 #if defined(CONFIG_AMR_NB) || defined(CONFIG_AMR_NB_FIXED)
 500
 501 AVCodec amr_nb_decoder =
 502 {
 503     "amr_nb",
 504     CODEC_TYPE_AUDIO,
 505     CODEC_ID_AMR_NB,
 506     sizeof(AMRContext),
 507     amr_nb_decode_init,
 508     NULL,
 509     amr_nb_decode_close,
 510     amr_nb_decode_frame,
 511 };
 512
 513 AVCodec amr_nb_encoder =
 514 {
 515     "amr_nb",
 516     CODEC_TYPE_AUDIO,
 517     CODEC_ID_AMR_NB,
 518     sizeof(AMRContext),
 519     amr_nb_encode_init,
 520     amr_nb_encode_frame,
 521     amr_nb_encode_close,
 522     NULL,
 523 };
 524
 525 #endif
 526
 527 /* -----------AMR wideband ------------*/
 528 #ifdef CONFIG_AMR_WB
 529
 530 #ifdef _TYPEDEF_H
 531 //To avoid duplicate typedefs from typdef in amr-nb
 532 #define typedef_h
 533 #endif
 534
 535 #include "amrwb_float/enc_if.h"
 536 #include "amrwb_float/dec_if.h"
 537
 538 /* Common code for fixed and float version*/
 539 typedef struct AMRWB_bitrates
 540 {
 541     int startrate;
 542     int stoprate;
 543     int mode;
 544
 545 } AMRWB_bitrates;
 546
 547 static int getWBBitrateMode(int bitrate)
 548 {
 549     /* Adjusted so that all bitrates can be used from commandline where
 550        only a multiple of 1000 can be specified*/
 551     AMRWB_bitrates rates[]={ {0,7999,0}, //6.6kHz
 552                            {8000,9999,1},//8.85
 553                            {10000,13000,2},//12.65
 554                            {13001,14999,3},//14.25
 555                            {15000,17000,4},//15.85
 556                            {17001,18000,5},//18.25
 557                            {18001,22000,6},//19.85
 558                            {22001,23000,7},//23.05
 559                            {23001,24000,8},//23.85
 560
 561                          };
 562     int i;
 563
 564     for(i=0;i<9;i++)
 565     {
 566         if(rates[i].startrate<=bitrate && rates[i].stoprate>=bitrate)
 567         {
 568             return(rates[i].mode);
 569         }
 570     }
 571     /*Return highest possible*/
 572     return(8);
 573 }
 574
 575
 576 typedef struct AMRWBContext {
 577     int frameCount;
 578     void *state;
 579     int mode;
 580     Word16 allow_dtx;
 581 } AMRWBContext;
 582
 583 static int amr_wb_encode_init(AVCodecContext * avctx)
 584 {
 585     AMRWBContext *s = (AMRWBContext*)avctx->priv_data;
 586     s->frameCount=0;
 587
 588     if(avctx->sample_rate!=16000)
 589     {
 590         if(avctx->debug)
 591         {
 592             av_log(avctx, AV_LOG_DEBUG, "Only 16000Hz sample rate supported\n");
 593         }
 594         return -1;
 595     }
 596
 597     if(avctx->channels!=1)
 598     {
 599         if(avctx->debug)
 600         {
 601             av_log(avctx, AV_LOG_DEBUG, "Only mono supported\n");
 602         }
 603         return -1;
 604     }
 605
 606     avctx->frame_size=320;
 607     avctx->coded_frame= avcodec_alloc_frame();
 608
 609     s->state = E_IF_init();
 610     s->mode=getWBBitrateMode(avctx->bit_rate);
 611     s->allow_dtx=0;
 612
 613     return 0;
 614 }
 615
 616 static int amr_wb_encode_close(AVCodecContext * avctx)
 617 {
 618     AMRWBContext *s = (AMRWBContext*) avctx->priv_data;
 619     E_IF_exit(s->state);
 620     av_freep(&avctx->coded_frame);
 621     s->frameCount++;
 622     return 0;
 623 }
 624
 625 static int amr_wb_encode_frame(AVCodecContext *avctx,
 626                             unsigned char *frame/*out*/, int buf_size, void *data/*in*/)
 627 {
 628     AMRWBContext *s;
 629     int size;
 630     s = (AMRWBContext*) avctx->priv_data;
 631     s->mode=getWBBitrateMode(avctx->bit_rate);
 632     size = E_IF_encode(s->state, s->mode, data, frame, s->allow_dtx);
 633     return size;
 634 }
 635
 636 static int amr_wb_decode_init(AVCodecContext * avctx)
 637 {
 638     AMRWBContext *s = (AMRWBContext *)avctx->priv_data;
 639     s->frameCount=0;
 640     s->state = D_IF_init();
 641
 642     amr_decode_fix_avctx(avctx);
 643
 644     if(avctx->channels > 1)
 645     {
 646         av_log(avctx, AV_LOG_ERROR, "amr_wb: multichannel decoding not supported\n");
 647         return -1;
 648     }
 649
 650     return 0;
 651 }
 652
 653 extern const UWord8 block_size[];
 654
 655 static int amr_wb_decode_frame(AVCodecContext * avctx,
 656             void *data, int *data_size,
 657             uint8_t * buf, int buf_size)
 658 {
 659     AMRWBContext *s = (AMRWBContext*)avctx->priv_data;
 660
 661     uint8_t*amrData=buf;
 662     int mode;
 663     int packet_size;
 664
 665     if(buf_size==0) {
 666         /* nothing to do */
 667         return 0;
 668     }
 669
 670     mode = (amrData[0] >> 3) & 0x000F;
 671     packet_size = block_size[mode];
 672
 673     if(packet_size > buf_size) {
 674         av_log(avctx, AV_LOG_ERROR, "amr frame too short (%u, should be %u)\n", buf_size, packet_size+1);
 675         return -1;
 676     }
 677
 678     s->frameCount++;
 679     D_IF_decode( s->state, amrData, data, _good_frame);
 680     *data_size=320*2;
 681     return packet_size;
 682 }
 683
 684 static int amr_wb_decode_close(AVCodecContext * avctx)
 685 {
 686     AMRWBContext *s = (AMRWBContext *)avctx->priv_data;
 687     D_IF_exit(s->state);
 688     return 0;
 689 }
 690
 691 AVCodec amr_wb_decoder =
 692 {
 693     "amr_wb",
 694     CODEC_TYPE_AUDIO,
 695     CODEC_ID_AMR_WB,
 696     sizeof(AMRWBContext),
 697     amr_wb_decode_init,
 698     NULL,
 699     amr_wb_decode_close,
 700     amr_wb_decode_frame,
 701 };
 702
 703 AVCodec amr_wb_encoder =
 704 {
 705     "amr_wb",
 706     CODEC_TYPE_AUDIO,
 707     CODEC_ID_AMR_WB,
 708     sizeof(AMRWBContext),
 709     amr_wb_encode_init,
 710     amr_wb_encode_frame,
 711     amr_wb_encode_close,
 712     NULL,
 713 };
 714
 715 #endif //CONFIG_AMR_WB