00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00066 #include "avcodec.h"
00067
00068 #if CONFIG_LIBAMR_NB_FIXED
00069
00070 #define MMS_IO
00071
00072 #include "amr/sp_dec.h"
00073 #include "amr/d_homing.h"
00074 #include "amr/typedef.h"
00075 #include "amr/sp_enc.h"
00076 #include "amr/sid_sync.h"
00077 #include "amr/e_homing.h"
00078
00079 #else
00080 #include <amrnb/interf_dec.h>
00081 #include <amrnb/interf_enc.h>
00082 #endif
00083
00084 static const char nb_bitrate_unsupported[] =
00085 "bitrate not supported: use one of 4.75k, 5.15k, 5.9k, 6.7k, 7.4k, 7.95k, 10.2k or 12.2k\n";
00086 static const char wb_bitrate_unsupported[] =
00087 "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";
00088
00089
00090 typedef struct AMR_bitrates
00091 {
00092 int rate;
00093 enum Mode mode;
00094 } AMR_bitrates;
00095
00096
00097 static int getBitrateMode(int bitrate)
00098 {
00099
00100 AMR_bitrates rates[]={ {4750,MR475},
00101 {5150,MR515},
00102 {5900,MR59},
00103 {6700,MR67},
00104 {7400,MR74},
00105 {7950,MR795},
00106 {10200,MR102},
00107 {12200,MR122},
00108 };
00109 int i;
00110
00111 for(i=0;i<8;i++)
00112 {
00113 if(rates[i].rate==bitrate)
00114 {
00115 return rates[i].mode;
00116 }
00117 }
00118
00119 return -1;
00120 }
00121
00122 static void amr_decode_fix_avctx(AVCodecContext * avctx)
00123 {
00124 const int is_amr_wb = 1 + (avctx->codec_id == CODEC_ID_AMR_WB);
00125
00126 if(avctx->sample_rate == 0)
00127 {
00128 avctx->sample_rate = 8000 * is_amr_wb;
00129 }
00130
00131 if(avctx->channels == 0)
00132 {
00133 avctx->channels = 1;
00134 }
00135
00136 avctx->frame_size = 160 * is_amr_wb;
00137 avctx->sample_fmt = SAMPLE_FMT_S16;
00138 }
00139
00140 #if CONFIG_LIBAMR_NB_FIXED
00141
00142
00143 #define SERIAL_FRAMESIZE (1+MAX_SERIAL_SIZE+5)
00144
00145 typedef struct AMRContext {
00146 int frameCount;
00147 Speech_Decode_FrameState *speech_decoder_state;
00148 enum RXFrameType rx_type;
00149 enum Mode mode;
00150 Word16 reset_flag;
00151 Word16 reset_flag_old;
00152
00153 int enc_bitrate;
00154 Speech_Encode_FrameState *enstate;
00155 sid_syncState *sidstate;
00156 enum TXFrameType tx_frametype;
00157 } AMRContext;
00158
00159 static av_cold int amr_nb_decode_init(AVCodecContext * avctx)
00160 {
00161 AMRContext *s = avctx->priv_data;
00162
00163 s->frameCount=0;
00164 s->speech_decoder_state=NULL;
00165 s->rx_type = (enum RXFrameType)0;
00166 s->mode= (enum Mode)0;
00167 s->reset_flag=0;
00168 s->reset_flag_old=1;
00169
00170 if(Speech_Decode_Frame_init(&s->speech_decoder_state, "Decoder"))
00171 {
00172 av_log(avctx, AV_LOG_ERROR, "Speech_Decode_Frame_init error\n");
00173 return -1;
00174 }
00175
00176 amr_decode_fix_avctx(avctx);
00177
00178 if(avctx->channels > 1)
00179 {
00180 av_log(avctx, AV_LOG_ERROR, "amr_nb: multichannel decoding not supported\n");
00181 return -1;
00182 }
00183
00184 return 0;
00185 }
00186
00187 static av_cold int amr_nb_encode_init(AVCodecContext * avctx)
00188 {
00189 AMRContext *s = avctx->priv_data;
00190
00191 s->frameCount=0;
00192 s->speech_decoder_state=NULL;
00193 s->rx_type = (enum RXFrameType)0;
00194 s->mode= (enum Mode)0;
00195 s->reset_flag=0;
00196 s->reset_flag_old=1;
00197
00198 if(avctx->sample_rate!=8000)
00199 {
00200 av_log(avctx, AV_LOG_ERROR, "Only 8000Hz sample rate supported\n");
00201 return -1;
00202 }
00203
00204 if(avctx->channels!=1)
00205 {
00206 av_log(avctx, AV_LOG_ERROR, "Only mono supported\n");
00207 return -1;
00208 }
00209
00210 avctx->frame_size=160;
00211 avctx->coded_frame= avcodec_alloc_frame();
00212
00213 if(Speech_Encode_Frame_init(&s->enstate, 0, "encoder") || sid_sync_init (&s->sidstate))
00214 {
00215 av_log(avctx, AV_LOG_ERROR, "Speech_Encode_Frame_init error\n");
00216 return -1;
00217 }
00218
00219 if((s->enc_bitrate=getBitrateMode(avctx->bit_rate))<0)
00220 {
00221 av_log(avctx, AV_LOG_ERROR, nb_bitrate_unsupported);
00222 return -1;
00223 }
00224
00225 return 0;
00226 }
00227
00228 static av_cold int amr_nb_encode_close(AVCodecContext * avctx)
00229 {
00230 AMRContext *s = avctx->priv_data;
00231
00232 Speech_Encode_Frame_exit(&s->enstate);
00233 sid_sync_exit (&s->sidstate);
00234 av_freep(&avctx->coded_frame);
00235 return 0;
00236 }
00237
00238 static av_cold int amr_nb_decode_close(AVCodecContext * avctx)
00239 {
00240 AMRContext *s = avctx->priv_data;
00241
00242 Speech_Decode_Frame_exit(&s->speech_decoder_state);
00243 return 0;
00244 }
00245
00246 static int amr_nb_decode_frame(AVCodecContext * avctx,
00247 void *data, int *data_size,
00248 const uint8_t * buf, int buf_size)
00249 {
00250 AMRContext *s = avctx->priv_data;
00251 const uint8_t*amrData=buf;
00252 int offset=0;
00253 UWord8 toc, q, ft;
00254 Word16 serial[SERIAL_FRAMESIZE];
00255 Word16 *synth;
00256 UWord8 *packed_bits;
00257 static Word16 packed_size[16] = {12, 13, 15, 17, 19, 20, 26, 31, 5, 0, 0, 0, 0, 0, 0, 0};
00258 int i;
00259
00260
00261
00262 synth=data;
00263
00264 toc=amrData[offset];
00265
00266 q = (toc >> 2) & 0x01;
00267 ft = (toc >> 3) & 0x0F;
00268
00269
00270
00271 offset++;
00272
00273 packed_bits=amrData+offset;
00274
00275 offset+=packed_size[ft];
00276
00277
00278 s->rx_type = UnpackBits(q, ft, packed_bits, &s->mode, &serial[1]);
00279
00280
00281 s->frameCount++;
00282
00283 if (s->rx_type == RX_NO_DATA)
00284 {
00285 s->mode = s->speech_decoder_state->prev_mode;
00286 }
00287 else {
00288 s->speech_decoder_state->prev_mode = s->mode;
00289 }
00290
00291
00292 if (s->reset_flag_old == 1)
00293 {
00294
00295 s->reset_flag = decoder_homing_frame_test_first(&serial[1], s->mode);
00296 }
00297
00298 if ((s->reset_flag != 0) && (s->reset_flag_old != 0))
00299 {
00300 for (i = 0; i < L_FRAME; i++)
00301 {
00302 synth[i] = EHF_MASK;
00303 }
00304 }
00305 else
00306 {
00307
00308 Speech_Decode_Frame(s->speech_decoder_state, s->mode, &serial[1], s->rx_type, synth);
00309 }
00310
00311
00312 *data_size=160*2;
00313
00314
00315 if (s->reset_flag_old == 0)
00316 {
00317
00318 s->reset_flag = decoder_homing_frame_test(&serial[1], s->mode);
00319 }
00320
00321 if (s->reset_flag != 0)
00322 {
00323 Speech_Decode_Frame_reset(s->speech_decoder_state);
00324 }
00325 s->reset_flag_old = s->reset_flag;
00326
00327 return offset;
00328 }
00329
00330
00331 static int amr_nb_encode_frame(AVCodecContext *avctx,
00332 unsigned char *frame, int buf_size, void *data)
00333 {
00334 short serial_data[250] = {0};
00335 AMRContext *s = avctx->priv_data;
00336 int written;
00337
00338 s->reset_flag = encoder_homing_frame_test(data);
00339
00340 Speech_Encode_Frame(s->enstate, s->enc_bitrate, data, &serial_data[1], &s->mode);
00341
00342
00343 sid_sync (s->sidstate, s->mode, &s->tx_frametype);
00344
00345 written = PackBits(s->mode, s->enc_bitrate, s->tx_frametype, &serial_data[1], frame);
00346
00347 if (s->reset_flag != 0)
00348 {
00349 Speech_Encode_Frame_reset(s->enstate);
00350 sid_sync_reset(s->sidstate);
00351 }
00352 return written;
00353 }
00354
00355
00356 #elif CONFIG_LIBAMR_NB
00357
00358 typedef struct AMRContext {
00359 int frameCount;
00360 void * decState;
00361 int *enstate;
00362 int enc_bitrate;
00363 } AMRContext;
00364
00365 static av_cold int amr_nb_decode_init(AVCodecContext * avctx)
00366 {
00367 AMRContext *s = avctx->priv_data;
00368
00369 s->frameCount=0;
00370 s->decState=Decoder_Interface_init();
00371 if(!s->decState)
00372 {
00373 av_log(avctx, AV_LOG_ERROR, "Decoder_Interface_init error\r\n");
00374 return -1;
00375 }
00376
00377 amr_decode_fix_avctx(avctx);
00378
00379 if(avctx->channels > 1)
00380 {
00381 av_log(avctx, AV_LOG_ERROR, "amr_nb: multichannel decoding not supported\n");
00382 return -1;
00383 }
00384
00385 return 0;
00386 }
00387
00388 static av_cold int amr_nb_encode_init(AVCodecContext * avctx)
00389 {
00390 AMRContext *s = avctx->priv_data;
00391
00392 s->frameCount=0;
00393
00394 if(avctx->sample_rate!=8000)
00395 {
00396 av_log(avctx, AV_LOG_ERROR, "Only 8000Hz sample rate supported\n");
00397 return -1;
00398 }
00399
00400 if(avctx->channels!=1)
00401 {
00402 av_log(avctx, AV_LOG_ERROR, "Only mono supported\n");
00403 return -1;
00404 }
00405
00406 avctx->frame_size=160;
00407 avctx->coded_frame= avcodec_alloc_frame();
00408
00409 s->enstate=Encoder_Interface_init(0);
00410 if(!s->enstate)
00411 {
00412 av_log(avctx, AV_LOG_ERROR, "Encoder_Interface_init error\n");
00413 return -1;
00414 }
00415
00416 if((s->enc_bitrate=getBitrateMode(avctx->bit_rate))<0)
00417 {
00418 av_log(avctx, AV_LOG_ERROR, nb_bitrate_unsupported);
00419 return -1;
00420 }
00421
00422 return 0;
00423 }
00424
00425 static av_cold int amr_nb_decode_close(AVCodecContext * avctx)
00426 {
00427 AMRContext *s = avctx->priv_data;
00428
00429 Decoder_Interface_exit(s->decState);
00430 return 0;
00431 }
00432
00433 static av_cold int amr_nb_encode_close(AVCodecContext * avctx)
00434 {
00435 AMRContext *s = avctx->priv_data;
00436
00437 Encoder_Interface_exit(s->enstate);
00438 av_freep(&avctx->coded_frame);
00439 return 0;
00440 }
00441
00442 static int amr_nb_decode_frame(AVCodecContext * avctx,
00443 void *data, int *data_size,
00444 const uint8_t * buf, int buf_size)
00445 {
00446 AMRContext *s = avctx->priv_data;
00447 const uint8_t*amrData=buf;
00448 static const uint8_t block_size[16]={ 12, 13, 15, 17, 19, 20, 26, 31, 5, 0, 0, 0, 0, 0, 0, 0 };
00449 enum Mode dec_mode;
00450 int packet_size;
00451
00452
00453
00454 dec_mode = (buf[0] >> 3) & 0x000F;
00455 packet_size = block_size[dec_mode]+1;
00456
00457 if(packet_size > buf_size) {
00458 av_log(avctx, AV_LOG_ERROR, "amr frame too short (%u, should be %u)\n", buf_size, packet_size);
00459 return -1;
00460 }
00461
00462 s->frameCount++;
00463
00464
00465 Decoder_Interface_Decode(s->decState, amrData, data, 0);
00466 *data_size=160*2;
00467
00468 return packet_size;
00469 }
00470
00471 static int amr_nb_encode_frame(AVCodecContext *avctx,
00472 unsigned char *frame, int buf_size, void *data)
00473 {
00474 AMRContext *s = avctx->priv_data;
00475 int written;
00476
00477 if((s->enc_bitrate=getBitrateMode(avctx->bit_rate))<0)
00478 {
00479 av_log(avctx, AV_LOG_ERROR, nb_bitrate_unsupported);
00480 return -1;
00481 }
00482
00483 written = Encoder_Interface_Encode(s->enstate,
00484 s->enc_bitrate,
00485 data,
00486 frame,
00487 0);
00488
00489
00490 return written;
00491 }
00492
00493 #endif
00494
00495 #if CONFIG_LIBAMR_NB || CONFIG_LIBAMR_NB_FIXED
00496
00497 AVCodec libamr_nb_decoder =
00498 {
00499 "libamr_nb",
00500 CODEC_TYPE_AUDIO,
00501 CODEC_ID_AMR_NB,
00502 sizeof(AMRContext),
00503 amr_nb_decode_init,
00504 NULL,
00505 amr_nb_decode_close,
00506 amr_nb_decode_frame,
00507 .long_name = NULL_IF_CONFIG_SMALL("libamr-nb Adaptive Multi-Rate (AMR) Narrow-Band"),
00508 };
00509
00510 AVCodec libamr_nb_encoder =
00511 {
00512 "libamr_nb",
00513 CODEC_TYPE_AUDIO,
00514 CODEC_ID_AMR_NB,
00515 sizeof(AMRContext),
00516 amr_nb_encode_init,
00517 amr_nb_encode_frame,
00518 amr_nb_encode_close,
00519 NULL,
00520 .sample_fmts = (enum SampleFormat[]){SAMPLE_FMT_S16,SAMPLE_FMT_NONE},
00521 .long_name = NULL_IF_CONFIG_SMALL("libamr-nb Adaptive Multi-Rate (AMR) Narrow-Band"),
00522 };
00523
00524 #endif
00525
00526
00527 #if CONFIG_LIBAMR_WB
00528
00529 #ifdef _TYPEDEF_H
00530
00531 #define typedef_h
00532 #endif
00533
00534 #include <amrwb/enc_if.h>
00535 #include <amrwb/dec_if.h>
00536 #include <amrwb/if_rom.h>
00537
00538
00539 typedef struct AMRWB_bitrates
00540 {
00541 int rate;
00542 int mode;
00543 } AMRWB_bitrates;
00544
00545 static int getWBBitrateMode(int bitrate)
00546 {
00547
00548 AMRWB_bitrates rates[]={ {6600,0},
00549 {8850,1},
00550 {12650,2},
00551 {14250,3},
00552 {15850,4},
00553 {18250,5},
00554 {19850,6},
00555 {23050,7},
00556 {23850,8},
00557 };
00558 int i;
00559
00560 for(i=0;i<9;i++)
00561 {
00562 if(rates[i].rate==bitrate)
00563 {
00564 return rates[i].mode;
00565 }
00566 }
00567
00568 return -1;
00569 }
00570
00571
00572 typedef struct AMRWBContext {
00573 int frameCount;
00574 void *state;
00575 int mode;
00576 Word16 allow_dtx;
00577 } AMRWBContext;
00578
00579 static int amr_wb_encode_init(AVCodecContext * avctx)
00580 {
00581 AMRWBContext *s = avctx->priv_data;
00582
00583 s->frameCount=0;
00584
00585 if(avctx->sample_rate!=16000)
00586 {
00587 av_log(avctx, AV_LOG_ERROR, "Only 16000Hz sample rate supported\n");
00588 return -1;
00589 }
00590
00591 if(avctx->channels!=1)
00592 {
00593 av_log(avctx, AV_LOG_ERROR, "Only mono supported\n");
00594 return -1;
00595 }
00596
00597 if((s->mode=getWBBitrateMode(avctx->bit_rate))<0)
00598 {
00599 av_log(avctx, AV_LOG_ERROR, wb_bitrate_unsupported);
00600 return -1;
00601 }
00602
00603 avctx->frame_size=320;
00604 avctx->coded_frame= avcodec_alloc_frame();
00605
00606 s->state = E_IF_init();
00607 s->allow_dtx=0;
00608
00609 return 0;
00610 }
00611
00612 static int amr_wb_encode_close(AVCodecContext * avctx)
00613 {
00614 AMRWBContext *s = avctx->priv_data;
00615
00616 E_IF_exit(s->state);
00617 av_freep(&avctx->coded_frame);
00618 s->frameCount++;
00619 return 0;
00620 }
00621
00622 static int amr_wb_encode_frame(AVCodecContext *avctx,
00623 unsigned char *frame, int buf_size, void *data)
00624 {
00625 AMRWBContext *s = avctx->priv_data;
00626 int size;
00627
00628 if((s->mode=getWBBitrateMode(avctx->bit_rate))<0)
00629 {
00630 av_log(avctx, AV_LOG_ERROR, wb_bitrate_unsupported);
00631 return -1;
00632 }
00633 size = E_IF_encode(s->state, s->mode, data, frame, s->allow_dtx);
00634 return size;
00635 }
00636
00637 static int amr_wb_decode_init(AVCodecContext * avctx)
00638 {
00639 AMRWBContext *s = avctx->priv_data;
00640
00641 s->frameCount=0;
00642 s->state = D_IF_init();
00643
00644 amr_decode_fix_avctx(avctx);
00645
00646 if(avctx->channels > 1)
00647 {
00648 av_log(avctx, AV_LOG_ERROR, "amr_wb: multichannel decoding not supported\n");
00649 return -1;
00650 }
00651
00652 return 0;
00653 }
00654
00655 static int amr_wb_decode_frame(AVCodecContext * avctx,
00656 void *data, int *data_size,
00657 const uint8_t * buf, int buf_size)
00658 {
00659 AMRWBContext *s = avctx->priv_data;
00660 const uint8_t*amrData=buf;
00661 int mode;
00662 int packet_size;
00663 static const uint8_t block_size[16] = {18, 23, 33, 37, 41, 47, 51, 59, 61, 6, 6, 0, 0, 0, 1, 1};
00664
00665 if(buf_size==0) {
00666
00667 return 0;
00668 }
00669
00670 mode = (amrData[0] >> 3) & 0x000F;
00671 packet_size = block_size[mode];
00672
00673 if(packet_size > buf_size) {
00674 av_log(avctx, AV_LOG_ERROR, "amr frame too short (%u, should be %u)\n", buf_size, packet_size+1);
00675 return -1;
00676 }
00677
00678 s->frameCount++;
00679 D_IF_decode( s->state, amrData, data, _good_frame);
00680 *data_size=320*2;
00681 return packet_size;
00682 }
00683
00684 static int amr_wb_decode_close(AVCodecContext * avctx)
00685 {
00686 AMRWBContext *s = avctx->priv_data;
00687
00688 D_IF_exit(s->state);
00689 return 0;
00690 }
00691
00692 AVCodec libamr_wb_decoder =
00693 {
00694 "libamr_wb",
00695 CODEC_TYPE_AUDIO,
00696 CODEC_ID_AMR_WB,
00697 sizeof(AMRWBContext),
00698 amr_wb_decode_init,
00699 NULL,
00700 amr_wb_decode_close,
00701 amr_wb_decode_frame,
00702 .long_name = NULL_IF_CONFIG_SMALL("libamr-wb Adaptive Multi-Rate (AMR) Wide-Band"),
00703 };
00704
00705 AVCodec libamr_wb_encoder =
00706 {
00707 "libamr_wb",
00708 CODEC_TYPE_AUDIO,
00709 CODEC_ID_AMR_WB,
00710 sizeof(AMRWBContext),
00711 amr_wb_encode_init,
00712 amr_wb_encode_frame,
00713 amr_wb_encode_close,
00714 NULL,
00715 .sample_fmts = (enum SampleFormat[]){SAMPLE_FMT_S16,SAMPLE_FMT_NONE},
00716 .long_name = NULL_IF_CONFIG_SMALL("libamr-wb Adaptive Multi-Rate (AMR) Wide-Band"),
00717 };
00718
00719 #endif //CONFIG_LIBAMR_WB