static void iaxc_refresh_registrations()
{
struct iaxc_registration *cur;
struct timeval now;
now = iax_tvnow();
for ( cur = registrations; cur != NULL; cur = cur->next )
{
// If there is less than three seconds before the registration is about
// to expire, renew it.
if ( iaxci_usecdiff(&now, &cur->last) > (cur->refresh - 3) * 1000 *1000 )
{
if ( cur->session != NULL )
{
iax_destroy( cur->session );
}
cur->session = iax_session_new();
if ( !cur->session )
{
iaxci_usermsg(IAXC_ERROR, "Can't make new registration session");
return;
}
iax_register(cur->session, cur->host, cur->user, cur->pass, cur->refresh);
cur->last = now;
}
}
}
static int do_level_callback()
{
static struct timeval last = {0,0};
struct timeval now;
float input_db;
float output_db;
now = iax_tvnow();
if ( last.tv_sec != 0 && iaxci_usecdiff(&now, &last) < 100000 )
return 0;
last = now;
/* if input has not been processed in the last second, set to silent */
input_db = iaxci_usecdiff(&now, &timeLastInput) < 1000000 ?
vol_to_db(input_level) : AUDIO_ENCODE_SILENCE_DB;
/* if output has not been processed in the last second, set to silent */
output_db = iaxci_usecdiff(&now, &timeLastOutput) < 1000000 ?
vol_to_db(output_level) : AUDIO_ENCODE_SILENCE_DB;
iaxci_do_levels_callback(input_db, output_db);
return 0;
}
/* decode encoded audio; return the number of bytes decoded
* negative indicates error */
int audio_decode_audio(struct iaxc_call * call, void * out, void * data, int len,
int format, int * samples)
{
int insize = len;
int outsize = *samples;
timeLastOutput = iax_tvnow();
if ( format == 0 )
{
fprintf(stderr, "audio_decode_audio: Format is zero (should't happen)!\n");
return -1;
}
/* destroy decoder if it is incorrect type */
if ( call->decoder && call->decoder->format != format )
{
call->decoder->destroy(call->decoder);
call->decoder = NULL;
}
/* create decoder if necessary */
if ( !call->decoder )
{
call->decoder = create_codec(format);
}
if ( !call->decoder )
{
fprintf(stderr, "ERROR: Codec could not be created: %d\n",
format);
return -1;
}
if ( call->decoder->decode(call->decoder,
&insize, (unsigned char *)data,
&outsize, (short *)out) )
{
fprintf(stderr, "ERROR: decode error: %d\n", format);
return -1;
}
output_postprocess(out, *samples - outsize);
*samples = outsize;
return len - insize;
}
EXPORT int iaxc_register_ex(const char * user, const char * pass, const char * host, int refresh)
{
struct iaxc_registration *newreg;
newreg = (struct iaxc_registration *)malloc(sizeof (struct iaxc_registration));
if ( !newreg )
{
iaxci_usermsg(IAXC_ERROR, "Can't make new registration");
return -1;
}
get_iaxc_lock();
newreg->session = iax_session_new();
if ( !newreg->session )
{
iaxci_usermsg(IAXC_ERROR, "Can't make new registration session");
put_iaxc_lock();
return -1;
}
newreg->last = iax_tvnow();
newreg->refresh = refresh;
strncpy(newreg->host, host, 256);
strncpy(newreg->user, user, 256);
strncpy(newreg->pass, pass, 256);
/* send out the initial registration with refresh seconds */
iax_register(newreg->session, host, user, pass, refresh);
/* add it to the list; */
newreg->id = ++next_registration_id;
newreg->next = registrations;
registrations = newreg;
put_iaxc_lock();
return newreg->id;
}
static void iaxc_note_activity(int callNo)
{
if ( callNo < 0 )
return;
calls[callNo].last_activity = iax_tvnow();
}
int audio_send_encoded_audio(struct iaxc_call *call, int callNo, void *data,
int format, int samples)
{
unsigned char outbuf[1024];
int outsize = 1024;
int silent;
int insize = samples;
/* update last input timestamp */
timeLastInput = iax_tvnow();
silent = input_postprocess(data, insize, 8000);
if(silent)
{
if(!call->tx_silent)
{ /* send a Comfort Noise Frame */
call->tx_silent = 1;
if ( iaxci_filters & IAXC_FILTER_CN )
iax_send_cng(call->session, 10, NULL, 0);
}
return 0; /* poof! no encoding! */
}
/* we're going to send voice now */
call->tx_silent = 0;
/* destroy encoder if it is incorrect type */
if(call->encoder && call->encoder->format != format)
{
call->encoder->destroy(call->encoder);
call->encoder = NULL;
}
/* just break early if there's no format defined: this happens for the
* first couple of frames of new calls */
if(format == 0) return 0;
/* create encoder if necessary */
if(!call->encoder)
{
call->encoder = create_codec(format);
}
if(!call->encoder)
{
/* ERROR: no codec */
fprintf(stderr, "ERROR: Codec could not be created: %d\n", format);
return 0;
}
if(call->encoder->encode(call->encoder, &insize, (short *)data,
&outsize, outbuf))
{
/* ERROR: codec error */
fprintf(stderr, "ERROR: encode error: %d\n", format);
return 0;
}
if(samples-insize == 0)
{
fprintf(stderr, "ERROR encoding (no samples output (samples=%d)\n", samples);
return -1;
}
// Send the encoded audio data back to the app if required
// TODO: fix the stupid way in which the encoded audio size is returned
if ( iaxc_get_audio_prefs() & IAXC_AUDIO_PREF_RECV_LOCAL_ENCODED )
iaxci_do_audio_callback(callNo, 0, IAXC_SOURCE_LOCAL, 1,
call->encoder->format & IAXC_AUDIO_FORMAT_MASK,
sizeof(outbuf) - outsize, outbuf);
if(iax_send_voice(call->session,format, outbuf,
sizeof(outbuf) - outsize, samples-insize) == -1)
{
fprintf(stderr, "Failed to send voice! %s\n", iax_errstr);
return -1;
}
return 0;
}