static void encodeForFlash(void * self, AS3_Val args)
{
AS3_Val progress;
AS3_Val src, dest;
int len, srcLen, remainingBytes, yieldTicks;
short raw_data[BLOCKL_MAX], encoded_data[ILBCNOOFWORDS_MAX];
AS3_ArrayValue(args, "AS3ValType, AS3ValType, AS3ValType, IntType, IntType", &progress, &src, &dest, &srcLen, &yieldTicks);
iLBC_Enc_Inst_t Enc_Inst;
initEncode(&Enc_Inst, 30);
remainingBytes = srcLen;
int i = 0;
resetPositionByteArray(src);
while (remainingBytes > 0){
remainingBytes -= AS3_ByteArray_readBytes(raw_data, src, Enc_Inst.blockl * sizeof(short));
len = encode(&Enc_Inst, encoded_data, raw_data);
AS3_ByteArray_writeBytes(dest, encoded_data, len);
if(i % yieldTicks == 0){
AS3_CallT(progress, NULL, "IntType", (int)((1 - ((float)remainingBytes / srcLen)) * 100));
flyield();//yield to main process
}
i++;
}
resetPositionByteArray(src);
resetPositionByteArray(dest);
// Don't remove progess 100 call here, else complete won't be called!
AS3_CallT(progress, NULL, "IntType", 100);
}
static void set_encoder_mode(struct auenc_state *st, int mode)
{
if (st->mode == mode)
return;
info("ilbc: set iLBC encoder mode %dms\n", mode);
st->mode = mode;
switch (mode) {
case 20:
st->enc_bytes = NO_OF_BYTES_20MS;
break;
case 30:
st->enc_bytes = NO_OF_BYTES_30MS;
break;
default:
warning("ilbc: unknown encoder mode %d\n", mode);
return;
}
st->enc_bytes = initEncode(&st->enc, mode);
}
static int lintoilbc_new(struct ast_trans_pvt *pvt)
{
struct ilbc_coder_pvt *tmp = pvt->pvt;
initEncode(&tmp->enc, ILBC_MS);
return 0;
}
static int tdav_codec_ilbc_open(tmedia_codec_t* self)
{
tdav_codec_ilbc_t* ilbc = (tdav_codec_ilbc_t*)self;
initEncode(&ilbc->encoder, TDAV_ILBC_MODE);
initDecode(&ilbc->decoder, TDAV_ILBC_MODE, tsk_true/* Enhancer */);
return 0;
}
static struct ast_translator_pvt *lintoilbc_new(void)
{
struct ilbc_coder_pvt *tmp;
tmp = malloc(sizeof(struct ilbc_coder_pvt));
if (tmp) {
/* Shut valgrind up */
memset(&tmp->enc, 0, sizeof(tmp->enc));
initEncode(&tmp->enc);
tmp->tail = 0;
localusecnt++;
}
return tmp;
}
long iLBC_create(const char* format_parameters, amci_codec_fmt_info_t* format_description) {
iLBC_Codec_Inst_t* codec_inst;
int mode;
char* mbegin;
char* msep;
char modeb[8];
if ((!format_parameters)||(!*format_parameters)||(!(mbegin=strstr(format_parameters, "mode")))) {
mode = 30; // default to 30 ms mode if no parameter given.
} else {
msep=mbegin;
while (*msep!='=' && *msep!='\0') msep++;
msep++; mbegin=msep;
while (*msep!='=' && *msep!='\0') msep++;
if ((msep-mbegin)>8) {
DBG("Error in fmtp line >>'%s<<.\n", format_parameters);
mode=30;
} else {
memcpy(modeb, mbegin, msep-mbegin);
modeb[msep-mbegin]='\0';
if ((!(mode=atoi(modeb))) || (mode != 30 && mode!= 20)) {
DBG("Error in fmtp line >>'%s<<.\n", format_parameters);
mode=30;
}
}
}
format_description[0].id = AMCI_FMT_FRAME_LENGTH ;
format_description[0].value = mode;
format_description[1].id = AMCI_FMT_FRAME_SIZE;
format_description[1].value = mode==30 ? 240 : 160;
format_description[2].id = AMCI_FMT_ENCODED_FRAME_SIZE;
format_description[2].value = mode==30 ? 50 : 38;
format_description[3].id = 0;
if (format_parameters) {
DBG("ilbc with format parameters : '%s', mode=%d.\n", format_parameters, mode);
}
codec_inst = (iLBC_Codec_Inst_t*)malloc(sizeof(iLBC_Codec_Inst_t));
codec_inst->mode = mode;
if (!codec_inst)
return -1;
initEncode(&codec_inst->iLBC_Enc_Inst, mode);
initDecode(&codec_inst->iLBC_Dec_Inst, mode, 0 /* 1=use_enhancer */);
return (long)codec_inst;
}
t_ilbc_audio_encoder::t_ilbc_audio_encoder(uint16 payload_id, uint16 ptime,
t_user *user_config) :
t_audio_encoder(payload_id, (ptime < 25 ? 20 : 30), user_config)
{
_codec = CODEC_ILBC;
_mode = _ptime;
if (_mode == 20) {
_max_payload_size = NO_OF_BYTES_20MS;
} else {
_max_payload_size = NO_OF_BYTES_30MS;
}
initEncode(&_ilbc_encoder, _mode);
}
void ms_ilbc_encoder_setup(MSILBCEncoder *r)
{
MSFilterClass *klass = NULL;
switch (r->ms_per_frame) {
case 20:
r->samples_per_frame = BLOCKL_20MS;
r->bytes_per_compressed_frame = NO_OF_BYTES_20MS;
break;
case 30:
r->samples_per_frame = BLOCKL_30MS;
r->bytes_per_compressed_frame = NO_OF_BYTES_30MS;
break;
default:
g_error("Bad bitrate value (%i) for ilbc encoder!", r->ms_per_frame);
break;
}
MS_FILTER(r)->r_mingran= (r->samples_per_frame * 2);
g_message("Using ilbc encoder with %i ms frames mode.",r->ms_per_frame);
initEncode(&r->ilbc_enc, r->ms_per_frame /* ms frames */);
}
static int set_codec_options(const struct PluginCodec_Definition * defn,
void * context,
const char * name,
void * parm,
unsigned * parmLen)
{
const char * const * option;
if (context == NULL || parm == NULL || parmLen == NULL || *parmLen != sizeof(const char **))
return 0;
for (option = (const char * const *)parm; *option != NULL; option += 2) {
if (STRCMPI(option[0], PreferredModeStr) == 0) {
unsigned mode = get_mode(option[1]);
if (defn->destFormat[0] == 'L')
initDecode(context, mode, 0);
else
initEncode(context, mode);
}
}
return 1;
}
static void enc_preprocess(MSFilter *f){
EncState *s=(EncState*)f->data;
initEncode(&s->ilbc_enc,s->ms_per_frame);
}
OsStatus MpEncoderBase::initEncode()
{
return initEncode(mDefaultFmtp);
}
/*
* Open codec.
*/
static pj_status_t ilbc_codec_open(pjmedia_codec *codec,
pjmedia_codec_param *attr )
{
struct ilbc_codec *ilbc_codec = (struct ilbc_codec*)codec;
pj_status_t status;
unsigned i;
pj_uint16_t dec_fmtp_mode = DEFAULT_MODE,
enc_fmtp_mode = DEFAULT_MODE;
#if defined(PJMEDIA_ILBC_CODEC_USE_COREAUDIO)&& PJMEDIA_ILBC_CODEC_USE_COREAUDIO
AudioStreamBasicDescription srcFormat, dstFormat;
UInt32 size;
srcFormat.mSampleRate = attr->info.clock_rate;
srcFormat.mFormatID = kAudioFormatLinearPCM;
srcFormat.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger
| kLinearPCMFormatFlagIsPacked;
srcFormat.mBitsPerChannel = attr->info.pcm_bits_per_sample;
srcFormat.mChannelsPerFrame = attr->info.channel_cnt;
srcFormat.mBytesPerFrame = srcFormat.mChannelsPerFrame
* srcFormat.mBitsPerChannel >> 3;
srcFormat.mFramesPerPacket = 1;
srcFormat.mBytesPerPacket = srcFormat.mBytesPerFrame *
srcFormat.mFramesPerPacket;
memset(&dstFormat, 0, sizeof(dstFormat));
dstFormat.mSampleRate = attr->info.clock_rate;
dstFormat.mFormatID = kAudioFormatiLBC;
dstFormat.mChannelsPerFrame = attr->info.channel_cnt;
#endif
pj_assert(ilbc_codec != NULL);
pj_assert(ilbc_codec->enc_ready == PJ_FALSE &&
ilbc_codec->dec_ready == PJ_FALSE);
/* Get decoder mode */
for (i = 0; i < attr->setting.dec_fmtp.cnt; ++i) {
if (pj_stricmp(&attr->setting.dec_fmtp.param[i].name, &STR_MODE) == 0)
{
dec_fmtp_mode = (pj_uint16_t)
pj_strtoul(&attr->setting.dec_fmtp.param[i].val);
break;
}
}
/* Decoder mode must be set */
PJ_ASSERT_RETURN(dec_fmtp_mode == 20 || dec_fmtp_mode == 30,
PJMEDIA_CODEC_EINMODE);
/* Get encoder mode */
for (i = 0; i < attr->setting.enc_fmtp.cnt; ++i) {
if (pj_stricmp(&attr->setting.enc_fmtp.param[i].name, &STR_MODE) == 0)
{
enc_fmtp_mode = (pj_uint16_t)
pj_strtoul(&attr->setting.enc_fmtp.param[i].val);
break;
}
}
PJ_ASSERT_RETURN(enc_fmtp_mode==20 || enc_fmtp_mode==30,
PJMEDIA_CODEC_EINMODE);
/* Both sides of a bi-directional session MUST use the same "mode" value.
* In this point, possible values are only 20 or 30, so when encoder and
* decoder modes are not same, just use the default mode, it is 30.
*/
if (enc_fmtp_mode != dec_fmtp_mode) {
enc_fmtp_mode = dec_fmtp_mode = DEFAULT_MODE;
PJ_LOG(4,(ilbc_codec->obj_name,
"Normalized iLBC encoder and decoder modes to %d",
DEFAULT_MODE));
}
/* Update some attributes based on negotiated mode. */
attr->info.avg_bps = (dec_fmtp_mode == 30? 13333 : 15200);
attr->info.frm_ptime = dec_fmtp_mode;
/* Create encoder */
#if defined(PJMEDIA_ILBC_CODEC_USE_COREAUDIO)&& PJMEDIA_ILBC_CODEC_USE_COREAUDIO
dstFormat.mFramesPerPacket = CLOCK_RATE * enc_fmtp_mode / 1000;
dstFormat.mBytesPerPacket = (enc_fmtp_mode == 20? 38 : 50);
/* Use AudioFormat API to fill out the rest of the description */
size = sizeof(dstFormat);
AudioFormatGetProperty(kAudioFormatProperty_FormatInfo,
0, NULL, &size, &dstFormat);
if (AudioConverterNew(&srcFormat, &dstFormat, &ilbc_codec->enc) != noErr)
return PJMEDIA_CODEC_EFAILED;
ilbc_codec->enc_frame_size = (enc_fmtp_mode == 20? 38 : 50);
#else
ilbc_codec->enc_frame_size = initEncode(&ilbc_codec->enc, enc_fmtp_mode);
#endif
ilbc_codec->enc_samples_per_frame = CLOCK_RATE * enc_fmtp_mode / 1000;
ilbc_codec->enc_ready = PJ_TRUE;
/* Create decoder */
#if defined(PJMEDIA_ILBC_CODEC_USE_COREAUDIO)&& PJMEDIA_ILBC_CODEC_USE_COREAUDIO
if (AudioConverterNew(&dstFormat, &srcFormat, &ilbc_codec->dec) != noErr)
return PJMEDIA_CODEC_EFAILED;
ilbc_codec->dec_samples_per_frame = CLOCK_RATE * dec_fmtp_mode / 1000;
#else
ilbc_codec->dec_samples_per_frame = initDecode(&ilbc_codec->dec,
dec_fmtp_mode,
attr->setting.penh);
#endif
ilbc_codec->dec_frame_size = (dec_fmtp_mode == 20? 38 : 50);
ilbc_codec->dec_ready = PJ_TRUE;
/* Save plc flags */
ilbc_codec->plc_enabled = (attr->setting.plc != 0);
/* Create silence detector. */
ilbc_codec->vad_enabled = (attr->setting.vad != 0);
status = pjmedia_silence_det_create(ilbc_codec->pool, CLOCK_RATE,
ilbc_codec->enc_samples_per_frame,
&ilbc_codec->vad);
if (status != PJ_SUCCESS)
return status;
/* Init last_tx (not necessary because of zalloc, but better
* be safe in case someone remove zalloc later.
*/
pj_set_timestamp32(&ilbc_codec->last_tx, 0, 0);
PJ_LOG(4,(ilbc_codec->obj_name,
"iLBC codec opened, mode=%d", dec_fmtp_mode));
return PJ_SUCCESS;
}
static void * create_encoder(const struct PluginCodec_Definition * codec)
{
struct iLBC_Enc_Inst_t_ * context = (struct iLBC_Enc_Inst_t_ *)malloc((unsigned)sizeof(struct iLBC_Enc_Inst_t_));
initEncode(context, codec->bitsPerSec != BITRATE_30MS ? 20 : 30);
return context;
}
/*
* Open codec.
*/
static pj_status_t ilbc_codec_open(pjmedia_codec *codec,
pjmedia_codec_param *attr )
{
struct ilbc_codec *ilbc_codec = (struct ilbc_codec*)codec;
pj_status_t status;
unsigned i, dec_fmtp_mode = 0, enc_fmtp_mode = 0;
pj_assert(ilbc_codec != NULL);
pj_assert(ilbc_codec->enc_ready == PJ_FALSE &&
ilbc_codec->dec_ready == PJ_FALSE);
/* Get decoder mode */
for (i = 0; i < attr->setting.dec_fmtp.cnt; ++i) {
if (pj_stricmp(&attr->setting.dec_fmtp.param[i].name, &STR_MODE) == 0)
{
dec_fmtp_mode = (unsigned)
pj_strtoul(&attr->setting.dec_fmtp.param[i].val);
break;
}
}
/* Decoder mode must be set */
PJ_ASSERT_RETURN(dec_fmtp_mode == 20 || dec_fmtp_mode == 30,
PJMEDIA_CODEC_EINMODE);
/* Get encoder mode */
for (i = 0; i < attr->setting.enc_fmtp.cnt; ++i) {
if (pj_stricmp(&attr->setting.enc_fmtp.param[i].name, &STR_MODE) == 0)
{
enc_fmtp_mode = (unsigned)
pj_strtoul(&attr->setting.enc_fmtp.param[i].val);
break;
}
}
/* The enc mode must be set in the attribute
* (from the mode parameter in fmtp attribute in the SDP
* received from remote)
*/
if (enc_fmtp_mode == 0)
enc_fmtp_mode = dec_fmtp_mode;
PJ_ASSERT_RETURN(enc_fmtp_mode==20 ||
enc_fmtp_mode==30, PJMEDIA_CODEC_EINMODE);
/* Update enc_ptime in the param */
if (enc_fmtp_mode != dec_fmtp_mode) {
attr->info.enc_ptime = (pj_uint16_t)enc_fmtp_mode;
} else {
attr->info.enc_ptime = 0;
}
/* Create enc */
ilbc_codec->enc_frame_size = initEncode(&ilbc_codec->enc, enc_fmtp_mode);
ilbc_codec->enc_samples_per_frame = CLOCK_RATE * enc_fmtp_mode / 1000;
ilbc_codec->enc_ready = PJ_TRUE;
/* Create decoder */
ilbc_codec->dec_samples_per_frame = initDecode(&ilbc_codec->dec,
dec_fmtp_mode,
attr->setting.penh);
if (dec_fmtp_mode == 20)
ilbc_codec->dec_frame_size = 38;
else if (dec_fmtp_mode == 30)
ilbc_codec->dec_frame_size = 50;
else {
pj_assert(!"Invalid iLBC mode");
ilbc_codec->dec_frame_size = ilbc_codec->enc_frame_size;
}
ilbc_codec->dec_ready = PJ_TRUE;
/* Save plc flags */
ilbc_codec->plc_enabled = (attr->setting.plc != 0);
/* Create silence detector. */
ilbc_codec->vad_enabled = (attr->setting.vad != 0);
status = pjmedia_silence_det_create(ilbc_codec->pool, CLOCK_RATE,
ilbc_codec->enc_samples_per_frame,
&ilbc_codec->vad);
if (status != PJ_SUCCESS)
return status;
/* Init last_tx (not necessary because of zalloc, but better
* be safe in case someone remove zalloc later.
*/
pj_set_timestamp32(&ilbc_codec->last_tx, 0, 0);
PJ_LOG(5,(ilbc_codec->obj_name,
"iLBC codec opened, encoder mode=%d, decoder mode=%d",
enc_fmtp_mode, dec_fmtp_mode));
return PJ_SUCCESS;
}
int main(int argc, char* argv[])
{
/* Runtime statistics */
float starttime;
float runtime;
float outtime;
FILE *ifileid,*efileid,*ofileid, *cfileid;
short data[BLOCKL_MAX];
short encoded_data[ILBCNOOFWORDS_MAX], decoded_data[BLOCKL_MAX];
int len;
short pli, mode;
int blockcount = 0;
int packetlosscount = 0;
/* Create structs */
iLBC_Enc_Inst_t Enc_Inst;
iLBC_Dec_Inst_t Dec_Inst;
/* get arguments and open files */
if ((argc!=5) && (argc!=6)) {
fprintf(stderr,
"\n*-----------------------------------------------*\n");
fprintf(stderr,
" %s <20,30> input encoded decoded (channel)\n\n",
argv[0]);
fprintf(stderr,
" mode : Frame size for the encoding/decoding\n");
fprintf(stderr,
" 20 - 20 ms\n");
fprintf(stderr,
" 30 - 30 ms\n");
fprintf(stderr,
" input : Speech for encoder (16-bit pcm file)\n");
fprintf(stderr,
" encoded : Encoded bit stream\n");
fprintf(stderr,
" decoded : Decoded speech (16-bit pcm file)\n");
fprintf(stderr,
" channel : Packet loss pattern, optional (16-bit)\n");
fprintf(stderr,
" 1 - Packet received correctly\n");
fprintf(stderr,
" 0 - Packet Lost\n");
fprintf(stderr,
"*-----------------------------------------------*\n\n");
exit(1);
}
mode=atoi(argv[1]);
if (mode != 20 && mode != 30) {
fprintf(stderr,"Wrong mode %s, must be 20, or 30\n",
argv[1]);
exit(2);
}
ifileid=fopen(argv[2],"rb");
if ( (efileid=fopen(argv[3],(ifileid?"wb":"rb"))) == NULL) {
fprintf(stderr, "Cannot open encoded file %s\n",
argv[3]); exit(1);}
if ( (ofileid=fopen(argv[4],"wb")) == NULL) {
fprintf(stderr, "Cannot open decoded file %s\n",
argv[4]); exit(1);}
if (argc==6) {
if( (cfileid=fopen(argv[5],"rb")) == NULL) {
fprintf(stderr, "Cannot open channel file %s\n",
argv[5]);
exit(1);
}
} else {
cfileid=NULL;
}
/* print info */
fprintf(stderr, "\n");
fprintf(stderr,
"*---------------------------------------------------*\n");
fprintf(stderr,
"* *\n");
fprintf(stderr,
"* iLBC test program *\n");
fprintf(stderr,
"* *\n");
fprintf(stderr,
"* *\n");
fprintf(stderr,
"*---------------------------------------------------*\n");
fprintf(stderr,"\nMode : %2d ms\n", mode);
fprintf(stderr,"Input file : %s\n", argv[2]);
fprintf(stderr,"Encoded file : %s\n", argv[3]);
fprintf(stderr,"Output file : %s\n", argv[4]);
if (argc==6) {
fprintf(stderr,"Channel file : %s\n", argv[5]);
}
fprintf(stderr,"\n");
/* Initialization */
initEncode(&Enc_Inst, mode);
initDecode(&Dec_Inst, mode, 1);
/* Runtime statistics */
starttime=clock()/(float)CLOCKS_PER_SEC;
/* loop over input blocks */
if(ifileid)
{
while (fread(data,sizeof(short),Enc_Inst.blockl,ifileid)==
Enc_Inst.blockl) {
blockcount++;
/* encoding */
fprintf(stderr, "--- Encoding block %i --- ",blockcount);
len=encode(&Enc_Inst, encoded_data, data);
fprintf(stderr, "\r");
/* write byte file */
fwrite(encoded_data, sizeof(unsigned char), len, efileid);
/* get channel data if provided */
if (argc==6) {
if (fread(&pli, sizeof(short), 1, cfileid)) {
if ((pli!=0)&&(pli!=1)) {
fprintf(stderr, "Error in channel file\n");
exit(0);
}
if (pli==0) {
/* Packet loss -> remove info from frame */
memset(encoded_data, 0,
sizeof(short)*ILBCNOOFWORDS_MAX);
packetlosscount++;
}
} else {
fprintf(stderr, "Error. Channel file too short\n");
exit(0);
}
} else {
pli=1;
}
/* decoding */
fprintf(stderr, "--- Decoding block %i --- ",blockcount);
len=decode(&Dec_Inst, decoded_data, encoded_data, pli);
fprintf(stderr, "\r");
/* write output file */
fwrite(decoded_data,sizeof(short),len,ofileid);
}
}
else
{
fseek(efileid,0,SEEK_END);
int inlen = ftell(efileid);
int inpos=0;
char *input = malloc(inlen);
fseek(efileid,0,SEEK_SET);
fread(input,1,inlen,efileid);
while (inpos < inlen) {
blockcount++;
/* get channel data if provided */
if (argc==6) {
if (fread(&pli, sizeof(short), 1, cfileid)) {
if ((pli!=0)&&(pli!=1)) {
fprintf(stderr, "Error in channel file\n");
exit(0);
}
if (pli==0) {
/* Packet loss -> remove info from frame */
memset(encoded_data, 0,
sizeof(short)*ILBCNOOFWORDS_MAX);
packetlosscount++;
}
} else {
fprintf(stderr, "Error. Channel file too short\n");
exit(0);
}
} else {
pli=1;
}
/* decoding */
fprintf(stderr, "--- Decoding block %i --- ",blockcount);
len=decode(&Dec_Inst, decoded_data, &input[inpos], pli);
fprintf(stderr, "\r");
/* write output file */
fwrite(decoded_data,sizeof(short),len,ofileid);
inpos += Dec_Inst.no_of_bytes;
}
}
/* Runtime statistics */
runtime = (float)(clock()/(float)CLOCKS_PER_SEC-starttime);
outtime = (float)((float)blockcount*(float)mode/1000.0);
printf("\n\nLength of speech file: %.1f s\n", outtime);
printf("Packet loss : %.1f%%\n",
100.0*(float)packetlosscount/(float)blockcount);
printf("Time to run iLBC :");
printf(" %.1f s (%.1f %% of realtime)\n\n", runtime,
(100*runtime/outtime));
/* close files */
if(ifileid) fclose(ifileid); fclose(efileid); fclose(ofileid);
if (argc==6) {
fclose(cfileid);
}
return(0);
}