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