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 } }