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     *data_size=0;
 225
 226     static Word16 packed_size[16] = {12, 13, 15, 17, 19, 20, 26, 31, 5, 0, 0, 0, 0, 0, 0, 0};
 227     int i;
 228
 229     //printf("amr_decode_frame data_size=%i buf=0x%X buf_size=%d frameCount=%d!!\n",*data_size,buf,buf_size,s->frameCount);
 230
 231     synth=data;
 232
 233 //    while(offset<buf_size)
 234     {
 235         toc=amrData[offset];
 236         /* read rest of the frame based on ToC byte */
 237         q  = (toc >> 2) & 0x01;
 238         ft = (toc >> 3) & 0x0F;
 239
 240         //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]);
 241
 242         offset++;
 243
 244         packed_bits=amrData+offset;
 245
 246         offset+=packed_size[ft];
 247
 248         //Unsort and unpack bits
 249         s->rx_type = UnpackBits(q, ft, packed_bits, &s->mode, &serial[1]);
 250
 251         //We have a new frame
 252         s->frameCount++;
 253
 254         if (s->rx_type == RX_NO_DATA)
 255         {
 256             s->mode = s->speech_decoder_state->prev_mode;
 257         }
 258         else {
 259             s->speech_decoder_state->prev_mode = s->mode;
 260         }
 261
 262         /* if homed: check if this frame is another homing frame */
 263         if (s->reset_flag_old == 1)
 264         {
 265             /* only check until end of first subframe */
 266             s->reset_flag = decoder_homing_frame_test_first(&serial[1], s->mode);
 267         }
 268         /* produce encoder homing frame if homed & input=decoder homing frame */
 269         if ((s->reset_flag != 0) && (s->reset_flag_old != 0))
 270         {
 271             for (i = 0; i < L_FRAME; i++)
 272             {
 273                 synth[i] = EHF_MASK;
 274             }
 275         }
 276         else
 277         {
 278             /* decode frame */
 279             Speech_Decode_Frame(s->speech_decoder_state, s->mode, &serial[1], s->rx_type, synth);
 280         }
 281
 282         //Each AMR-frame results in 160 16-bit samples
 283         *data_size+=160*2;
 284         synth+=160;
 285
 286         /* if not homed: check whether current frame is a homing frame */
 287         if (s->reset_flag_old == 0)
 288         {
 289             /* check whole frame */
 290             s->reset_flag = decoder_homing_frame_test(&serial[1], s->mode);
 291         }
 292         /* reset decoder if current frame is a homing frame */
 293         if (s->reset_flag != 0)
 294         {
 295             Speech_Decode_Frame_reset(s->speech_decoder_state);
 296         }
 297         s->reset_flag_old = s->reset_flag;
 298
 299     }
 300     return offset;
 301 }
 302
 303
 304 static int amr_nb_encode_frame(AVCodecContext *avctx,
 305                             unsigned char *frame/*out*/, int buf_size, void *data/*in*/)
 306 {
 307     short serial_data[250] = {0};
 308
 309     AMRContext *s = avctx->priv_data;
 310     int written;
 311
 312     s->reset_flag = encoder_homing_frame_test(data);
 313
 314     Speech_Encode_Frame(s->enstate, s->enc_bitrate, data, &serial_data[1], &s->mode);
 315
 316     /* add frame type and mode */
 317     sid_sync (s->sidstate, s->mode, &s->tx_frametype);
 318
 319     written = PackBits(s->mode, s->enc_bitrate, s->tx_frametype, &serial_data[1], frame);
 320
 321     if (s->reset_flag != 0)
 322     {
 323         Speech_Encode_Frame_reset(s->enstate);
 324         sid_sync_reset(s->sidstate);
 325     }
 326     return written;
 327 }
 328
 329
 330 #else /* Float point version*/
 331
 332 typedef struct AMRContext {
 333     int frameCount;
 334     void * decState;
 335     int *enstate;
 336     enum Mode enc_bitrate;
 337 } AMRContext;
 338
 339 static int amr_nb_decode_init(AVCodecContext * avctx)
 340 {
 341     AMRContext *s = avctx->priv_data;
 342     s->frameCount=0;
 343     s->decState=Decoder_Interface_init();
 344     if(!s->decState)
 345     {
 346         av_log(avctx, AV_LOG_ERROR, "Decoder_Interface_init error\r\n");
 347         return -1;
 348     }
 349     return 0;
 350 }
 351
 352 static int amr_nb_encode_init(AVCodecContext * avctx)
 353 {
 354     AMRContext *s = avctx->priv_data;
 355     s->frameCount=0;
 356
 357     if(avctx->sample_rate!=8000)
 358     {
 359         if(avctx->debug)
 360         {
 361             av_log(avctx, AV_LOG_DEBUG, "Only 8000Hz sample rate supported\n");
 362         }
 363         return -1;
 364     }
 365
 366     if(avctx->channels!=1)
 367     {
 368         if(avctx->debug)
 369         {
 370             av_log(avctx, AV_LOG_DEBUG, "Only mono supported\n");
 371         }
 372         return -1;
 373     }
 374
 375     avctx->frame_size=160;
 376     avctx->coded_frame= avcodec_alloc_frame();
 377
 378     s->enstate=Encoder_Interface_init(0);
 379     if(!s->enstate)
 380     {
 381         if(avctx->debug)
 382         {
 383             av_log(avctx, AV_LOG_DEBUG, "Encoder_Interface_init error\n");
 384         }
 385         return -1;
 386     }
 387
 388     s->enc_bitrate=getBitrateMode(avctx->bit_rate);
 389
 390     return 0;
 391 }
 392
 393 static int amr_nb_decode_close(AVCodecContext * avctx)
 394 {
 395     AMRContext *s = avctx->priv_data;
 396     Decoder_Interface_exit(s->decState);
 397     return 0;
 398 }
 399
 400 static int amr_nb_encode_close(AVCodecContext * avctx)
 401 {
 402     AMRContext *s = avctx->priv_data;
 403     Encoder_Interface_exit(s->enstate);
 404     av_freep(&avctx->coded_frame);
 405     return 0;
 406 }
 407
 408 static int amr_nb_decode_frame(AVCodecContext * avctx,
 409             void *data, int *data_size,
 410             uint8_t * buf, int buf_size)
 411 {
 412     AMRContext *s = (AMRContext*)avctx->priv_data;
 413
 414     uint8_t*amrData=buf;
 415     int offset=0;
 416     static short block_size[16]={ 12, 13, 15, 17, 19, 20, 26, 31, 5, 0, 0, 0, 0, 0, 0, 0 };
 417     enum Mode dec_mode;
 418     int packet_size;
 419     *data_size=0;
 420
 421     //printf("amr_decode_frame data_size=%i buf=0x%X buf_size=%d frameCount=%d!!\n",*data_size,buf,buf_size,s->frameCount);
 422
 423     while(offset<buf_size)
 424     {
 425         dec_mode = (amrData[offset] >> 3) & 0x000F;
 426         packet_size = block_size[dec_mode];
 427
 428         s->frameCount++;
 429         //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]);
 430         /* call decoder */
 431         Decoder_Interface_Decode(s->decState, &amrData[offset], data+*data_size, 0);
 432         *data_size+=160*2;
 433
 434         offset+=packet_size+1;
 435     }
 436     return buf_size;
 437 }
 438
 439 static int amr_nb_encode_frame(AVCodecContext *avctx,
 440                             unsigned char *frame/*out*/, int buf_size, void *data/*in*/)
 441 {
 442     AMRContext *s = (AMRContext*)avctx->priv_data;
 443     int written;
 444
 445     written = Encoder_Interface_Encode(s->enstate,
 446         s->enc_bitrate,
 447         data,
 448         frame,
 449         0);
 450
 451     return written;
 452 }
 453
 454 #endif
 455
 456 AVCodec amr_nb_decoder =
 457 {
 458     "amr_nb",
 459     CODEC_TYPE_AUDIO,
 460     CODEC_ID_AMR_NB,
 461     sizeof(AMRContext),
 462     amr_nb_decode_init,
 463     NULL,
 464     amr_nb_decode_close,
 465     amr_nb_decode_frame,
 466 };
 467
 468 AVCodec amr_nb_encoder =
 469 {
 470     "amr_nb",
 471     CODEC_TYPE_AUDIO,
 472     CODEC_ID_AMR_NB,
 473     sizeof(AMRContext),
 474     amr_nb_encode_init,
 475     amr_nb_encode_frame,
 476     amr_nb_encode_close,
 477     NULL,
 478 };
 479
 480 /* -----------AMR wideband ------------*/
 481 #ifdef AMR_WB
 482
 483 #ifdef _TYPEDEF_H
 484 //To avoid duplicate typedefs from typdef in amr-nb
 485 #define typedef_h
 486 #endif
 487
 488 #include "amrwb_float/enc_if.h"
 489 #include "amrwb_float/dec_if.h"
 490
 491 /* Common code for fixed and float version*/
 492 typedef struct AMRWB_bitrates
 493 {
 494     int startrate;
 495     int stoprate;
 496     int mode;
 497
 498 } AMRWB_bitrates;
 499
 500 static int getWBBitrateMode(int bitrate)
 501 {
 502     /* Adjusted so that all bitrates can be used from commandline where
 503        only a multiple of 1000 can be specified*/
 504     AMRWB_bitrates rates[]={ {0,7999,0}, //6.6kHz
 505                            {8000,9999,1},//8.85
 506                            {10000,13000,2},//12.65
 507                            {13001,14999,3},//14.25
 508                            {15000,17000,4},//15.85
 509                            {17001,18000,5},//18.25
 510                            {18001,22000,6},//19.85
 511                            {22001,23000,7},//23.05
 512                            {23001,24000,8},//23.85
 513
 514                          };
 515     int i;
 516
 517     for(i=0;i<9;i++)
 518     {
 519         if(rates[i].startrate<=bitrate && rates[i].stoprate>=bitrate)
 520         {
 521             return(rates[i].mode);
 522         }
 523     }
 524     /*Return highest possible*/
 525     return(8);
 526 }
 527
 528
 529 typedef struct AMRWBContext {
 530     int frameCount;
 531     void *state;
 532     int mode;
 533     Word16 allow_dtx;
 534 } AMRWBContext;
 535
 536 static int amr_wb_encode_init(AVCodecContext * avctx)
 537 {
 538     AMRWBContext *s = (AMRWBContext*)avctx->priv_data;
 539     s->frameCount=0;
 540
 541     if(avctx->sample_rate!=16000)
 542     {
 543         if(avctx->debug)
 544         {
 545             av_log(avctx, AV_LOG_DEBUG, "Only 16000Hz sample rate supported\n");
 546         }
 547         return -1;
 548     }
 549
 550     if(avctx->channels!=1)
 551     {
 552         if(avctx->debug)
 553         {
 554             av_log(avctx, AV_LOG_DEBUG, "Only mono supported\n");
 555         }
 556         return -1;
 557     }
 558
 559     avctx->frame_size=320;
 560     avctx->coded_frame= avcodec_alloc_frame();
 561
 562     s->state = E_IF_init();
 563     s->mode=getWBBitrateMode(avctx->bit_rate);
 564     s->allow_dtx=0;
 565
 566     return 0;
 567 }
 568
 569 static int amr_wb_encode_close(AVCodecContext * avctx)
 570 {
 571     AMRWBContext *s = (AMRWBContext*) avctx->priv_data;
 572     E_IF_exit(s->state);
 573     av_freep(&avctx->coded_frame);
 574     s->frameCount++;
 575     return 0;
 576 }
 577
 578 static int amr_wb_encode_frame(AVCodecContext *avctx,
 579                             unsigned char *frame/*out*/, int buf_size, void *data/*in*/)
 580 {
 581     AMRWBContext *s = (AMRWBContext*) avctx->priv_data;
 582     int size = E_IF_encode(s->state, s->mode, data, frame, s->allow_dtx);
 583     return size;
 584 }
 585
 586 static int amr_wb_decode_init(AVCodecContext * avctx)
 587 {
 588     AMRWBContext *s = (AMRWBContext *)avctx->priv_data;
 589     s->frameCount=0;
 590     s->state = D_IF_init();
 591     return 0;
 592 }
 593
 594 extern const UWord8 block_size[];
 595
 596 static int amr_wb_decode_frame(AVCodecContext * avctx,
 597             void *data, int *data_size,
 598             uint8_t * buf, int buf_size)
 599 {
 600     AMRWBContext *s = (AMRWBContext*)avctx->priv_data;
 601
 602     uint8_t*amrData=buf;
 603     int offset=0;
 604     int mode;
 605     int packet_size;
 606     *data_size=0;
 607
 608     while(offset<buf_size)
 609     {
 610         s->frameCount++;
 611         mode = (Word16)((amrData[offset] >> 3) & 0x0F);
 612         packet_size = block_size[mode];
 613         D_IF_decode( s->state, &amrData[offset], data+*data_size, _good_frame);
 614         *data_size+=320*2;
 615         offset+=packet_size;
 616     }
 617     return buf_size;
 618 }
 619
 620 static int amr_wb_decode_close(AVCodecContext * avctx)
 621 {
 622     AMRWBContext *s = (AMRWBContext *)avctx->priv_data;
 623     D_IF_exit(s->state);
 624     return 0;
 625 }
 626
 627 AVCodec amr_wb_decoder =
 628 {
 629     "amr_wb",
 630     CODEC_TYPE_AUDIO,
 631     CODEC_ID_AMR_WB,
 632     sizeof(AMRWBContext),
 633     amr_wb_decode_init,
 634     NULL,
 635     amr_wb_decode_close,
 636     amr_wb_decode_frame,
 637 };
 638
 639 AVCodec amr_wb_encoder =
 640 {
 641     "amr_wb",
 642     CODEC_TYPE_AUDIO,
 643     CODEC_ID_AMR_WB,
 644     sizeof(AMRWBContext),
 645     amr_wb_encode_init,
 646     amr_wb_encode_frame,
 647     amr_wb_encode_close,
 648     NULL,
 649 };
 650
 651 #endif //AMR_WB