void _ortp_logv_flush(int dummy, ...) {
OList *elem;
OList *msglist;
va_list empty_va_list;
va_start(empty_va_list, dummy);
ortp_mutex_lock(&__log_stored_messages_mutex);
msglist = __log_stored_messages_list;
__log_stored_messages_list = NULL;
ortp_mutex_unlock(&__log_stored_messages_mutex);
for (elem = msglist; elem != NULL; elem = o_list_next(elem)) {
ortp_stored_log_t *l = (ortp_stored_log_t *)elem->data;
#ifdef WIN32
ortp_logv_out(l->level, l->msg, empty_va_list);
#else
va_list cap;
va_copy(cap, empty_va_list);
ortp_logv_out(l->level, l->msg, cap);
va_end(cap);
#endif
ortp_free(l->msg);
ortp_free(l);
}
o_list_free(msglist);
va_end(empty_va_list);
}
OrtpEvent * ortp_ev_queue_get(OrtpEvQueue *q){
OrtpEvent *ev;
ortp_mutex_lock(&q->mutex);
ev=getq(&q->q);
ortp_mutex_unlock(&q->mutex);
return ev;
}
void rtp_scheduler_start(RtpScheduler *sched)
{
if (sched->thread_running==0){
sched->thread_running=1;
ortp_mutex_lock(&sched->lock);
ortp_thread_create(&sched->thread, NULL, rtp_scheduler_schedule,(void*)sched);
ortp_cond_wait(&sched->unblock_select_cond,&sched->lock);
ortp_mutex_unlock(&sched->lock);
}
else ortp_warning("Scheduler thread already running.");
}
void * rtp_scheduler_schedule(void * psched)
{
RtpScheduler *sched=(RtpScheduler*) psched;
RtpTimer *timer=sched->timer;
RtpSession *current;
/* take this lock to prevent the thread to start until g_thread_create() returns
because we need sched->thread to be initialized */
ortp_mutex_lock(&sched->lock);
ortp_cond_signal(&sched->unblock_select_cond); /* unblock the starting thread */
ortp_mutex_unlock(&sched->lock);
timer->timer_init();
while(sched->thread_running)
{
/* do the processing here: */
ortp_mutex_lock(&sched->lock);
current=sched->list;
/* processing all scheduled rtp sessions */
while (current!=NULL)
{
ortp_debug("scheduler: processing session=0x%x.\n",current);
rtp_session_process(current,sched->time_,sched);
current=current->next;
}
/* wake up all the threads that are sleeping in _select() */
ortp_cond_broadcast(&sched->unblock_select_cond);
ortp_mutex_unlock(&sched->lock);
/* now while the scheduler is going to sleep, the other threads can compute their
result mask and see if they have to leave, or to wait for next tick*/
//ortp_message("scheduler: sleeping.");
timer->timer_do();
sched->time_+=sched->timer_inc;
}
/* when leaving the thread, stop the timer */
timer->timer_uninit();
return NULL;
}
void ortp_logv(int level, const char *fmt, va_list args) {
if ((ortp_logv_out != NULL) && ortp_log_level_enabled(level)) {
if (__log_thread_id == 0) {
ortp_logv_out(level, fmt, args);
} else if (__log_thread_id == ortp_thread_self()) {
ortp_logv_flush();
ortp_logv_out(level, fmt, args);
} else {
ortp_stored_log_t *l = ortp_new(ortp_stored_log_t, 1);
l->level = level;
l->msg = ortp_strdup_vprintf(fmt, args);
ortp_mutex_lock(&__log_stored_messages_mutex);
__log_stored_messages_list = o_list_append(__log_stored_messages_list, l);
ortp_mutex_unlock(&__log_stored_messages_mutex);
}
}
#if !defined(_WIN32_WCE)
if (level == ORTP_FATAL) abort();
#endif
}
static void *pipe_thread(void*p) {
char tmp[250];
server_sock=create_server_socket();
if (server_sock==ORTP_PIPE_INVALID) return NULL;
while(pipe_reader_run) {
while(client_sock!=ORTP_PIPE_INVALID) { /*sleep until the last command is finished*/
#ifndef WIN32
usleep(20000);
#else
Sleep(20);
#endif
}
client_sock=ortp_server_pipe_accept_client(server_sock);
if (client_sock!=ORTP_PIPE_INVALID) {
int len;
/*now read from the client */
if ((len=ortp_pipe_read(client_sock,(uint8_t*)tmp,sizeof(tmp)-1))>0) {
ortp_mutex_lock(&prompt_mutex);
tmp[len]='\0';
strcpy(received_prompt,tmp);
printf("Receiving command '%s'\n",received_prompt);
fflush(stdout);
have_prompt=TRUE;
ortp_mutex_unlock(&prompt_mutex);
} else {
printf("read nothing\n");
fflush(stdout);
ortp_server_pipe_close_client(client_sock);
client_sock=ORTP_PIPE_INVALID;
}
} else {
if (pipe_reader_run) fprintf(stderr,"accept() failed: %s\n",strerror(errno));
}
}
ms_message("Exiting pipe_reader_thread.");
fflush(stdout);
return NULL;
}
void ortp_ev_queue_put(OrtpEvQueue *q, OrtpEvent *ev){
ortp_mutex_lock(&q->mutex);
putq(&q->q,ev);
ortp_mutex_unlock(&q->mutex);
}
/**
* Enter synchronization mutex.
*
* GNU ZRTP requires one mutex to synchronize its
* processing. Because mutex implementations depend on the
* underlying infrastructure, for example operating system or
* thread implementation, GNU ZRTP delegates mutex handling to the
* specific part of its implementation.
*
* @param ctx
* Pointer to the opaque ZrtpContext structure.
*/
static void ozrtp_synchEnter(ZrtpContext* ctx){
ortp_mutex_lock(&user_data(ctx)->mutex);
}
static void rtp_session_schedule_outbound_network_simulator(RtpSession *session, ortpTimeSpec *sleep_until){
mblk_t *om;
int count=0;
bool_t is_rtp_packet;
if (!session->net_sim_ctx)
return;
if (!session->net_sim_ctx->params.enabled)
return;
if (session->net_sim_ctx->params.mode==OrtpNetworkSimulatorOutbound){
sleep_until->tv_sec=0;
sleep_until->tv_nsec=0;
ortp_mutex_lock(&session->net_sim_ctx->mutex);
while((om=getq(&session->net_sim_ctx->send_q))!=NULL){
count++;
ortp_mutex_unlock(&session->net_sim_ctx->mutex);
is_rtp_packet=om->reserved1; /*it was set by _rtp_session_sendto()*/
om=rtp_session_network_simulate(session,om, &is_rtp_packet);
if (om){
_ortp_sendto(is_rtp_packet ? session->rtp.gs.socket : session->rtcp.gs.socket, om, 0, (struct sockaddr*)&om->net_addr, om->net_addrlen);
freemsg(om);
}
ortp_mutex_lock(&session->net_sim_ctx->mutex);
}
ortp_mutex_unlock(&session->net_sim_ctx->mutex);
if (count==0){
/*even if no packets were queued, we have to schedule the simulator*/
is_rtp_packet=TRUE;
om=rtp_session_network_simulate(session,NULL, &is_rtp_packet);
if (om){
_ortp_sendto(is_rtp_packet ? session->rtp.gs.socket : session->rtcp.gs.socket, om, 0, (struct sockaddr*)&om->net_addr, om->net_addrlen);
freemsg(om);
}
}
}else if (session->net_sim_ctx->params.mode==OrtpNetworkSimulatorOutboundControlled){
#if defined(ORTP_TIMESTAMP)
ortpTimeSpec current={0};
ortpTimeSpec packet_time;
mblk_t *todrop=NULL;
ortp_mutex_lock(&session->net_sim_ctx->mutex);
while((om=peekq(&session->net_sim_ctx->send_q))!=NULL){
ortp_mutex_unlock(&session->net_sim_ctx->mutex);
if (todrop) {
freemsg(todrop); /*free the last message while the mutex is not held*/
todrop=NULL;
}
_ortp_get_cur_time(¤t,TRUE);
packet_time.tv_sec=om->timestamp.tv_sec;
packet_time.tv_nsec=om->timestamp.tv_usec*1000LL;
if (om->timestamp.tv_sec==0 && om->timestamp.tv_usec==0){
todrop=om; /*simulate a packet loss*/
}else if (packet_time.tv_sec<=current.tv_sec && packet_time.tv_nsec<=current.tv_nsec){
is_rtp_packet=om->reserved1; /*it was set by _rtp_session_sendto()*/
_ortp_sendto(is_rtp_packet ? session->rtp.gs.socket : session->rtcp.gs.socket, om, 0, (struct sockaddr*)&om->net_addr, om->net_addrlen);
todrop=om;
}else {
/*no packet is to be sent yet; set the time at which we want to be called*/
*sleep_until=packet_time;
ortp_mutex_lock(&session->net_sim_ctx->mutex);
break;
}
ortp_mutex_lock(&session->net_sim_ctx->mutex);
if (todrop) getq(&session->net_sim_ctx->send_q); /* pop the message while the mutex is held*/
}
ortp_mutex_unlock(&session->net_sim_ctx->mutex);
if (todrop) freemsg(todrop);
if (sleep_until->tv_sec==0){
_ortp_get_cur_time(¤t,TRUE);
/*no pending packet in the queue yet, schedule a wake up not too far*/
sleep_until->tv_sec=current.tv_sec;
sleep_until->tv_nsec=current.tv_nsec+1000000LL; /*in 1 ms*/
}
#else
ortp_mutex_lock(&session->net_sim_ctx->mutex);
while((om=getq(&session->net_sim_ctx->send_q))!=NULL){
ortp_mutex_unlock(&session->net_sim_ctx->mutex);
freemsg(om);
ortp_error("Network simulator is in mode OrtpNetworkSimulatorOutboundControlled but oRTP wasn't compiled with --enable-ntp-timestamp.");
ortp_mutex_lock(&session->net_sim_ctx->mutex);
}
ortp_mutex_unlock(&session->net_sim_ctx->mutex);
#endif
}
}
