quicktime/ffmpeg/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     static short block_size[16]={ 12, 13, 15, 17, 19, 20, 26, 31, 5, 0, 0, 0, 0, 0, 0, 0 };
 415     enum Mode dec_mode;
 416     int packet_size;
 417
 418     /* av_log(NULL,AV_LOG_DEBUG,"amr_decode_frame buf=%p buf_size=%d frameCount=%d!!\n",buf,buf_size,s->frameCount); */
 419
 420     if(buf_size==0) {
 421         /* nothing to do */
 422         return 0;
 423     }
 424
 425     dec_mode = (buf[0] >> 3) & 0x000F;
 426     packet_size = block_size[dec_mode]+1;
 427
 428     if(packet_size > buf_size) {
 429         av_log(avctx, AV_LOG_ERROR, "amr frame too short (%u, should be %u)\n", buf_size, packet_size);
 430         return -1;
 431     }
 432
 433     s->frameCount++;
 434     /* 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]); */
 435     /* call decoder */
 436     Decoder_Interface_Decode(s->decState, amrData, data, 0);
 437     *data_size=160*2;
 438
 439     return packet_size;
 440 }
 441
 442 static int amr_nb_encode_frame(AVCodecContext *avctx,
 443                             unsigned char *frame/*out*/, int buf_size, void *data/*in*/)
 444 {
 445     AMRContext *s = (AMRContext*)avctx->priv_data;
 446     int written;
 447
 448     written = Encoder_Interface_Encode(s->enstate,
 449         s->enc_bitrate,
 450         data,
 451         frame,
 452         0);
 453     /* 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] ); */
 454
 455     return written;
 456 }
 457
 458 #endif
 459
 460 AVCodec amr_nb_decoder =
 461 {
 462     "amr_nb",
 463     CODEC_TYPE_AUDIO,
 464     CODEC_ID_AMR_NB,
 465     sizeof(AMRContext),
 466     amr_nb_decode_init,
 467     NULL,
 468     amr_nb_decode_close,
 469     amr_nb_decode_frame,
 470 };
 471
 472 AVCodec amr_nb_encoder =
 473 {
 474     "amr_nb",
 475     CODEC_TYPE_AUDIO,
 476     CODEC_ID_AMR_NB,
 477     sizeof(AMRContext),
 478     amr_nb_encode_init,
 479     amr_nb_encode_frame,
 480     amr_nb_encode_close,
 481     NULL,
 482 };
 483
 484 /* -----------AMR wideband ------------*/
 485 #ifdef AMR_WB
 486
 487 #ifdef _TYPEDEF_H
 488 //To avoid duplicate typedefs from typdef in amr-nb
 489 #define typedef_h
 490 #endif
 491
 492 #include "amrwb_float/enc_if.h"
 493 #include "amrwb_float/dec_if.h"
 494
 495 /* Common code for fixed and float version*/
 496 typedef struct AMRWB_bitrates
 497 {
 498     int startrate;
 499     int stoprate;
 500     int mode;
 501
 502 } AMRWB_bitrates;
 503
 504 static int getWBBitrateMode(int bitrate)
 505 {
 506     /* Adjusted so that all bitrates can be used from commandline where
 507        only a multiple of 1000 can be specified*/
 508     AMRWB_bitrates rates[]={ {0,7999,0}, //6.6kHz
 509                            {8000,9999,1},//8.85
 510                            {10000,13000,2},//12.65
 511                            {13001,14999,3},//14.25
 512                            {15000,17000,4},//15.85
 513                            {17001,18000,5},//18.25
 514                            {18001,22000,6},//19.85
 515                            {22001,23000,7},//23.05
 516                            {23001,24000,8},//23.85
 517
 518                          };
 519     int i;
 520
 521     for(i=0;i<9;i++)
 522     {
 523         if(rates[i].startrate<=bitrate && rates[i].stoprate>=bitrate)
 524         {
 525             return(rates[i].mode);
 526         }
 527     }
 528     /*Return highest possible*/
 529     return(8);
 530 }
 531
 532
 533 typedef struct AMRWBContext {
 534     int frameCount;
 535     void *state;
 536     int mode;
 537     Word16 allow_dtx;
 538 } AMRWBContext;
 539
 540 static int amr_wb_encode_init(AVCodecContext * avctx)
 541 {
 542     AMRWBContext *s = (AMRWBContext*)avctx->priv_data;
 543     s->frameCount=0;
 544
 545     if(avctx->sample_rate!=16000)
 546     {
 547         if(avctx->debug)
 548         {
 549             av_log(avctx, AV_LOG_DEBUG, "Only 16000Hz sample rate supported\n");
 550         }
 551         return -1;
 552     }
 553
 554     if(avctx->channels!=1)
 555     {
 556         if(avctx->debug)
 557         {
 558             av_log(avctx, AV_LOG_DEBUG, "Only mono supported\n");
 559         }
 560         return -1;
 561     }
 562
 563     avctx->frame_size=320;
 564     avctx->coded_frame= avcodec_alloc_frame();
 565
 566     s->state = E_IF_init();
 567     s->mode=getWBBitrateMode(avctx->bit_rate);
 568     s->allow_dtx=0;
 569
 570     return 0;
 571 }
 572
 573 static int amr_wb_encode_close(AVCodecContext * avctx)
 574 {
 575     AMRWBContext *s = (AMRWBContext*) avctx->priv_data;
 576     E_IF_exit(s->state);
 577     av_freep(&avctx->coded_frame);
 578     s->frameCount++;
 579     return 0;
 580 }
 581
 582 static int amr_wb_encode_frame(AVCodecContext *avctx,
 583                             unsigned char *frame/*out*/, int buf_size, void *data/*in*/)
 584 {
 585     AMRWBContext *s = (AMRWBContext*) avctx->priv_data;
 586     int size = E_IF_encode(s->state, s->mode, data, frame, s->allow_dtx);
 587     return size;
 588 }
 589
 590 static int amr_wb_decode_init(AVCodecContext * avctx)
 591 {
 592     AMRWBContext *s = (AMRWBContext *)avctx->priv_data;
 593     s->frameCount=0;
 594     s->state = D_IF_init();
 595     return 0;
 596 }
 597
 598 extern const UWord8 block_size[];
 599
 600 static int amr_wb_decode_frame(AVCodecContext * avctx,
 601             void *data, int *data_size,
 602             uint8_t * buf, int buf_size)
 603 {
 604     AMRWBContext *s = (AMRWBContext*)avctx->priv_data;
 605
 606     uint8_t*amrData=buf;
 607     int mode;
 608     int packet_size;
 609
 610     if(buf_size==0) {
 611         /* nothing to do */
 612         return 0;
 613     }
 614
 615     mode = (amrData[0] >> 3) & 0x000F;
 616     packet_size = block_size[mode];
 617
 618     if(packet_size > buf_size) {
 619         av_log(avctx, AV_LOG_ERROR, "amr frame too short (%u, should be %u)\n", buf_size, packet_size+1);
 620         return -1;
 621     }
 622
 623     s->frameCount++;
 624     D_IF_decode( s->state, amrData, data, _good_frame);
 625     *data_size=320*2;
 626     return packet_size;
 627 }
 628
 629 static int amr_wb_decode_close(AVCodecContext * avctx)
 630 {
 631     AMRWBContext *s = (AMRWBContext *)avctx->priv_data;
 632     D_IF_exit(s->state);
 633     return 0;
 634 }
 635
 636 AVCodec amr_wb_decoder =
 637 {
 638     "amr_wb",
 639     CODEC_TYPE_AUDIO,
 640     CODEC_ID_AMR_WB,
 641     sizeof(AMRWBContext),
 642     amr_wb_decode_init,
 643     NULL,
 644     amr_wb_decode_close,
 645     amr_wb_decode_frame,
 646 };
 647
 648 AVCodec amr_wb_encoder =
 649 {
 650     "amr_wb",
 651     CODEC_TYPE_AUDIO,
 652     CODEC_ID_AMR_WB,
 653     sizeof(AMRWBContext),
 654     amr_wb_encode_init,
 655     amr_wb_encode_frame,
 656     amr_wb_encode_close,
 657     NULL,
 658 };
 659
 660 #endif //AMR_WB