int main(void)
{
FILE *fp;
FILE *decoder_fp;
int read_num = 0;
int write_num = 0;
char buffer[1024] = {0};
char decoder_buffer[1024] = {0};
int* fAudioCodec, *fAudioDecodec;
unsigned char fTo[1024] = {0};
fAudioCodec = (int*)Encoder_Interface_init(0);
fAudioDecodec = (int*)Decoder_Interface_init();
fp = fopen(AUDIO_FILE, "rb");
decoder_fp = fopen("temp.txt", "wb+");
if (fp < 0 || decoder_fp < 0)
{
}
while((read_num = fread(buffer, 1, 320, fp)))
{
Encoder_Interface_Encode(fAudioCodec, MR475, (const short int*)buffer, fTo, 0);
Decoder_Interface_Decode(fAudioDecodec, (const unsigned char *)fTo, (short int *)decoder_buffer, 0);
fseek(decoder_fp, write_num, SEEK_SET);
write_num += read_num;
fwrite(decoder_buffer, 1, 320, decoder_fp);
if(read_num < 320)
break;
}
fclose(fp);
fclose(decoder_fp);
}
int main(int argc, char *argv[]) {
FILE* in;
char header[6];
int n;
void *wav, *amr;
if (argc < 3) {
fprintf(stderr, "%s in.amr out.wav\n", argv[0]);
return 1;
}
in = fopen(argv[1], "rb");
if (!in) {
perror(argv[1]);
return 1;
}
n = fread(header, 1, 6, in);
if (n != 6 || memcmp(header, "#!AMR\n", 6)) {
fprintf(stderr, "Bad header\n");
return 1;
}
wav = wav_write_open(argv[2], 8000, 16, 1);
if (!wav) {
fprintf(stderr, "Unable to open %s\n", argv[2]);
return 1;
}
amr = Decoder_Interface_init();
while (1) {
uint8_t buffer[500], littleendian[320], *ptr;
int size, i;
int16_t outbuffer[160];
/* Read the mode byte */
n = fread(buffer, 1, 1, in);
if (n <= 0)
break;
/* Find the packet size */
size = sizes[(buffer[0] >> 3) & 0x0f];
n = fread(buffer + 1, 1, size, in);
if (n != size)
break;
/* Decode the packet */
Decoder_Interface_Decode(amr, buffer, outbuffer, 0);
/* Convert to little endian and write to wav */
ptr = littleendian;
for (i = 0; i < 160; i++) {
*ptr++ = (outbuffer[i] >> 0) & 0xff;
*ptr++ = (outbuffer[i] >> 8) & 0xff;
}
wav_write_data(wav, littleendian, 320);
}
fclose(in);
Decoder_Interface_exit(amr);
wav_write_close(wav);
return 0;
}
int decode_amr(const char* infile, const char* outfile) {
FILE* in = fopen(infile, "rb");
if (!in) {
return 1;
}
char header[6];
ssize_t n = fread(header, 1, 6, in);
if (n != 6 || memcmp(header, "#!AMR\n", 6)) {
fprintf(stderr, "Bad header\n");
return 1;
}
void* wav = wav_write_open(outfile, 8000, 16, 1);
void* amr = Decoder_Interface_init();
while (1) {
uint8_t buffer[500];
/* Read the mode byte */
n = fread(buffer, 1, 1, in);
if (n <= 0)
break;
/* Find the packet size */
int size = sizes[(buffer[0] >> 3) & 0x0f];
if (size <= 0)
continue;
n = fread(buffer + 1, 1, size, in);
if (n != size)
break;
/* Decode the packet */
int16_t outbuffer[160];
Decoder_Interface_Decode(amr, buffer, outbuffer, 0);
/* Convert to little endian and write to wav */
uint8_t littleendian[320];
uint8_t* ptr = littleendian;
for (int i = 0; i < 160; i++) {
*ptr++ = (outbuffer[i] >> 0) & 0xff;
*ptr++ = (outbuffer[i] >> 8) & 0xff;
}
wav_write_data(wav, littleendian, 320);
}
fclose(in);
Decoder_Interface_exit(amr);
wav_write_close(wav);
return 0;
}
static int decode_update(struct audec_state **adsp,
const struct aucodec *ac, const char *fmtp)
{
struct audec_state *st;
int err = 0;
(void)fmtp;
if (!adsp || !ac)
return EINVAL;
if (*adsp)
return 0;
st = mem_zalloc(sizeof(*st), decode_destructor);
if (!st)
return ENOMEM;
st->ac = ac;
switch (ac->srate) {
#ifdef AMR_NB
case 8000:
st->dec = Decoder_Interface_init();
break;
#endif
#ifdef AMR_WB
case 16000:
st->dec = D_IF_init();
break;
#endif
}
if (!st->dec)
err = ENOMEM;
if (err)
mem_deref(st);
else
*adsp = st;
return err;
}
static switch_status_t switch_amr_init(switch_codec_t *codec, switch_codec_flag_t flags, const switch_codec_settings_t *codec_settings)
{
#ifdef AMR_PASSTHROUGH
codec->flags |= SWITCH_CODEC_FLAG_PASSTHROUGH;
if (codec->fmtp_in) {
codec->fmtp_out = switch_core_strdup(codec->memory_pool, codec->fmtp_in);
}
return SWITCH_STATUS_SUCCESS;
#else
struct amr_context *context = NULL;
switch_codec_fmtp_t codec_fmtp;
amr_codec_settings_t amr_codec_settings;
int encoding, decoding;
int x, i, argc;
char *argv[10];
char fmtptmp[128];
encoding = (flags & SWITCH_CODEC_FLAG_ENCODE);
decoding = (flags & SWITCH_CODEC_FLAG_DECODE);
if (!(encoding || decoding) || (!(context = switch_core_alloc(codec->memory_pool, sizeof(struct amr_context))))) {
return SWITCH_STATUS_FALSE;
} else {
memset(&codec_fmtp, '\0', sizeof(struct switch_codec_fmtp));
codec_fmtp.private_info = &amr_codec_settings;
switch_amr_fmtp_parse(codec->fmtp_in, &codec_fmtp);
if (context->enc_modes) {
for (i = 7; i > -1; i++) {
if (context->enc_modes & (1 << i)) {
context->enc_mode = (switch_byte_t) i;
break;
}
}
}
if (!context->enc_mode) {
context->enc_mode = globals.default_bitrate;
}
switch_snprintf(fmtptmp, sizeof(fmtptmp), "octet-align=%d; mode-set=%d", switch_test_flag(context, AMR_OPT_OCTET_ALIGN) ? 1 : 0,
context->enc_mode);
codec->fmtp_out = switch_core_strdup(codec->memory_pool, fmtptmp);
context->enc_mode = AMR_DEFAULT_BITRATE;
context->encoder_state = NULL;
context->decoder_state = NULL;
if (encoding) {
context->encoder_state = Encoder_Interface_init(context->dtx_mode);
}
if (decoding) {
context->decoder_state = Decoder_Interface_init();
}
codec->private_info = context;
return SWITCH_STATUS_SUCCESS;
}
#endif
}
/*
* Open codec.
*/
static pj_status_t amr_codec_open( pjmedia_codec *codec,
pjmedia_codec_param *attr )
{
struct amr_data *amr_data = (struct amr_data*) codec->codec_data;
pjmedia_codec_amr_pack_setting *setting;
unsigned i;
pj_uint8_t octet_align = 0;
pj_int8_t enc_mode;
const pj_str_t STR_FMTP_OCTET_ALIGN = {"octet-align", 11};
unsigned idx;
PJ_ASSERT_RETURN(codec && attr, PJ_EINVAL);
PJ_ASSERT_RETURN(amr_data != NULL, PJ_EINVALIDOP);
idx = (attr->info.clock_rate <= 8000? IDX_AMR_NB: IDX_AMR_WB);
enc_mode = pjmedia_codec_amr_get_mode(attr->info.avg_bps);
pj_assert(enc_mode >= 0 && enc_mode < amr_bitrates_size[idx]);
/* Check octet-align */
for (i = 0; i < attr->setting.dec_fmtp.cnt; ++i) {
if (pj_stricmp(&attr->setting.dec_fmtp.param[i].name,
&STR_FMTP_OCTET_ALIGN) == 0)
{
octet_align = (pj_uint8_t)
(pj_strtoul(&attr->setting.dec_fmtp.param[i].val));
break;
}
}
/* Check mode-set */
for (i = 0; i < attr->setting.enc_fmtp.cnt; ++i) {
const pj_str_t STR_FMTP_MODE_SET = {"mode-set", 8};
if (pj_stricmp(&attr->setting.enc_fmtp.param[i].name,
&STR_FMTP_MODE_SET) == 0)
{
const char *p;
pj_size_t l;
pj_int8_t diff = 99;
/* Encoding mode is chosen based on local default mode setting:
* - if local default mode is included in the mode-set, use it
* - otherwise, find the closest mode to local default mode;
* if there are two closest modes, prefer to use the higher
* one, e.g: local default mode is 4, the mode-set param
* contains '2,3,5,6', then 5 will be chosen.
*/
p = pj_strbuf(&attr->setting.enc_fmtp.param[i].val);
l = pj_strlen(&attr->setting.enc_fmtp.param[i].val);
while (l--) {
if (*p>='0' && *p<=('0'+amr_bitrates_size[idx]-1)) {
pj_int8_t tmp = *p - '0' - enc_mode;
if (PJ_ABS(diff) > PJ_ABS(tmp) ||
(PJ_ABS(diff) == PJ_ABS(tmp) && tmp > diff))
{
diff = tmp;
if (diff == 0) break;
}
}
++p;
}
PJ_ASSERT_RETURN(diff != 99, PJMEDIA_CODEC_EFAILED);
enc_mode = enc_mode + diff;
break;
}
}
amr_data->clock_rate = attr->info.clock_rate;
amr_data->vad_enabled = (attr->setting.vad != 0);
amr_data->plc_enabled = (attr->setting.plc != 0);
amr_data->enc_mode = enc_mode;
if (idx == IDX_AMR_NB) {
#ifdef USE_AMRNB
amr_data->encoder = Encoder_Interface_init(amr_data->vad_enabled);
#endif
} else {
#ifdef USE_AMRWB
amr_data->encoder = E_IF_init();
#endif
}
if (amr_data->encoder == NULL) {
TRACE_((THIS_FILE, "Encoder initialization failed"));
amr_codec_close(codec);
return PJMEDIA_CODEC_EFAILED;
}
setting = &amr_data->enc_setting;
pj_bzero(setting, sizeof(pjmedia_codec_amr_pack_setting));
setting->amr_nb = (idx == IDX_AMR_NB? 1: 0);
setting->reorder = 0;
setting->octet_aligned = octet_align;
setting->cmr = 15;
if (idx == IDX_AMR_NB) {
#ifdef USE_AMRNB
amr_data->decoder = Decoder_Interface_init();
#endif
} else {
#ifdef USE_AMRWB
amr_data->decoder = D_IF_init();
#endif
}
if (amr_data->decoder == NULL) {
TRACE_((THIS_FILE, "Decoder initialization failed"));
amr_codec_close(codec);
return PJMEDIA_CODEC_EFAILED;
}
setting = &amr_data->dec_setting;
pj_bzero(setting, sizeof(pjmedia_codec_amr_pack_setting));
setting->amr_nb = (idx == IDX_AMR_NB? 1: 0);
setting->reorder = 0;
setting->octet_aligned = octet_align;
TRACE_((THIS_FILE, "AMR codec allocated: clockrate=%d vad=%d, plc=%d,"
" bitrate=%d", amr_data->clock_rate,
amr_data->vad_enabled, amr_data->plc_enabled,
amr_bitrates[idx][amr_data->enc_mode]));
return PJ_SUCCESS;
}
static void dec_init(MSFilter *f) {
f->data = Decoder_Interface_init();
}
static void * amr_create_decoder(const struct PluginCodec_Definition * codec)
{
return Decoder_Interface_init();
}
JNIEXPORT jint JNICALL Java_ac_robinson_mov_AMRtoPCMConverter_AmrDecoderInit(JNIEnv* env, jobject obj) {
return (jint) Decoder_Interface_init();
}
AMRDecoder::AMRDecoder() :
codecState(Decoder_Interface_init())
{
}
