t_time NAMESPACE::Time::milliseconds()
{
#ifdef WIN32
static bool init = false;
static t_time freq;
if (!init) { // TODO / FIXME move into a global timer init ?
init = true;
LARGE_INTEGER lfreq;
sl_assert(QueryPerformanceFrequency(&lfreq) != 0);
freq = t_time(lfreq.QuadPart);
}
LARGE_INTEGER tps;
QueryPerformanceCounter(&tps);
return t_time(t_time(tps.QuadPart)*1000/freq);
#else
struct timeval now;
uint ticks;
static struct timeval start;
static bool init=false;
if (!init) { // TODO / FIXME move into a global timer init ?
gettimeofday(&start, NULL);
init=true;
}
gettimeofday(&now, NULL);
uint ms=uint((now.tv_sec-start.tv_sec)*1000+(now.tv_usec-start.tv_usec)/1000);
return (ms);
#endif
}
int tty_expect(char *what,int timeout)
{
time_t t1;
int to=timeout,got=0,p=0,ch;
calling=0;
while(!got&&to>0) {
t1=t_start();
ch=tty_getc(to);
if(ch<0)return ch;
to-=t_time(t1);
if(ch==what[p])p++;
else p=0;
if(!what[p])got=1;
}
return got?OK:TIMEOUT;
}
/* main poll for event execution */
void* event_poll( void* _event_handler_p )
{
event_handler_t* _event_handler = _event_handler_p;
uint32_t* _frequms = &_event_handler->_frequms;
while ( _event_handler->_running )
{
if ( _event_handler->_events_count ){
pthread_mutex_lock(&_event_handler->_mutex);
int i;
for ( i = 0; i < _event_handler->_events_count; i ++ ){
_event_handler->_events[i]._event(_event_handler->_events[i]._event_args);
}
clear_events(&_event_handler->_events, &_event_handler->_events_count);
pthread_mutex_unlock(&_event_handler->_mutex);
}
if ( _event_handler->_timed_events_count ){
pthread_mutex_lock(&_event_handler->_mutex);
uint32_t _time = t_time();
if ( _event_handler->_timed_events[0]._timeout < _time ) {
_event_handler->_timed_events[0]._event(_event_handler->_timed_events[0]._event_args);
pop_id(&_event_handler->_timed_events,
&_event_handler->_timed_events_count,
_event_handler->_timed_events[0]._id);
}
pthread_mutex_unlock(&_event_handler->_mutex);
}
usleep(*_frequms);
}
_event_handler->_running = -1;
pthread_exit(NULL);
}
int tty_gets(char *what,size_t n,int timeout)
{
time_t t1;
int to=timeout,p=0,ch=0;
*what=0;
while(to>0&&p<n-1&&ch!='\r'&&ch!='\n') {
t1=t_start();
ch=tty_getc(to);
if(NOTTO(ch))return ch;
to-=t_time(t1);
if(ch>=0)what[p++]=ch;
}
what[p>0?--p:0]=0;
if(p>0)DEBUG(('M',1,"<< %s",what));
if(ch=='\r'||ch=='\n') {
DEBUG(('M',5,"tty_gets: completed"));
return OK;
} else if(to<=0) {
DEBUG(('M',3,"tty_gets: timed out"));
} else DEBUG(('M',3,"tty_gets: line too long"));
return TIMEOUT;
}
int throw_timer_event ( void* _event_handler_p, event_t _func, event_arg_t _arg, uint32_t _timeout)
{
if ( !_func )
return FAILURE;
event_handler_t* _event_handler = _event_handler_p;
pthread_mutex_lock(&_event_handler->_mutex);
push_event(&_event_handler->_timed_events, &_event_handler->_timed_events_count, _func, _arg);
size_t _counter = _event_handler->_timed_events_count;
_event_handler->_timed_events[_counter - 1]._timeout = _timeout + t_time();
_event_handler->_timed_events[_counter - 1]._id = _unique_id; ++_unique_id;
/* reorder */
if ( _counter > 1 ) {
int i = _counter - 1;
/* start from behind excluding last added member */
event_container_t* _it = &_event_handler->_timed_events[i - 1];
event_container_t _last_added = _event_handler->_timed_events[i];
for ( ; i > 0; --i ) {
if ( _it->_timeout > _timeout ){
*(_it + 1) = *_it;
*_it = _last_added; -- _it;
}
}
}
pthread_mutex_unlock(&_event_handler->_mutex);
return _event_handler->_timed_events[_counter - 1]._id;
}
rtp_session_t* rtp_init_session ( int max_users, int _multi_session )
{
#ifdef _USE_ERRORS
REGISTER_RTP_ERRORS
#endif /* _USE_ERRORS */
rtp_session_t* _retu = calloc(sizeof(rtp_session_t), 1);
assert(_retu);
_retu->_dest_list = _retu->_last_user = NULL;
_retu->_max_users = max_users;
_retu->_packets_recv = 0;
_retu->_packets_sent = 0;
_retu->_bytes_sent = 0;
_retu->_bytes_recv = 0;
_retu->_last_error = NULL;
_retu->_packet_loss = 0;
/*
* SET HEADER FIELDS
*/
_retu->_version = RTP_VERSION; /* It's always 2 */
_retu->_padding = 0; /* If some additional data is needed about
* the packet */
_retu->_extension = 0; /* If extension to header is needed */
_retu->_cc = 1; /* It basically represents amount of contributors */
_retu->_csrc = NULL; /* Container */
_retu->_ssrc = t_random ( -1 );
_retu->_marker = 0;
_retu->_payload_type = 0; /* You should specify payload type */
/* Sequence starts at random number and goes to _MAX_SEQU_NUM */
_retu->_sequence_number = t_random ( _MAX_SEQU_NUM );
_retu->_last_sequence_number = _retu->_sequence_number; /* Do not touch this variable */
_retu->_initial_time = t_time(); /* In seconds */
assert(_retu->_initial_time);
_retu->_time_elapsed = 0; /* In seconds */
_retu->_ext_header = NULL; /* When needed allocate */
_retu->_exthdr_framerate = -1;
_retu->_exthdr_resolution = -1;
_retu->_csrc = calloc(sizeof(uint32_t), 1);
assert(_retu->_csrc);
_retu->_csrc[0] = _retu->_ssrc; /* Set my ssrc to the list receive */
_retu->_prefix_length = 0;
_retu->_prefix = NULL;
_retu->_multi_session = _multi_session;
/* Initial */
_retu->_current_framerate = 0;
_retu->_oldest_msg = _retu->_last_msg = NULL;
pthread_mutex_init(&_retu->_mutex, NULL);
/*
*
*/
return _retu;
}
