static void mrcp_sofia_task_initialize(apt_task_t *task)
{
mrcp_sofia_agent_t *sofia_agent = apt_task_object_get(task);
mrcp_sofia_server_config_t *sofia_config = sofia_agent->config;
/* Initialize Sofia-SIP library and create event loop */
su_init();
sofia_agent->root = su_root_create(NULL);
/* Create a user agent instance. The stack will call the 'event_callback()'
* callback when events such as succesful registration to network,
* an incoming call, etc, occur.
*/
sofia_agent->nua = nua_create(
sofia_agent->root, /* Event loop */
mrcp_sofia_event_callback, /* Callback for processing events */
sofia_agent, /* Additional data to pass to callback */
NUTAG_URL(sofia_agent->sip_bind_str), /* Address to bind to */
NUTAG_AUTOANSWER(0),
NUTAG_APPL_METHOD("OPTIONS"),
TAG_IF(sofia_config->sip_t1,NTATAG_SIP_T1(sofia_config->sip_t1)),
TAG_IF(sofia_config->sip_t2,NTATAG_SIP_T2(sofia_config->sip_t2)),
TAG_IF(sofia_config->sip_t4,NTATAG_SIP_T4(sofia_config->sip_t4)),
TAG_IF(sofia_config->sip_t1x64,NTATAG_SIP_T1X64(sofia_config->sip_t1x64)),
SIPTAG_USER_AGENT_STR(sofia_config->user_agent_name),
TAG_IF(sofia_config->tport_log == TRUE,TPTAG_LOG(1)), /* Print out SIP messages to the console */
TAG_IF(sofia_config->tport_dump_file,TPTAG_DUMP(sofia_config->tport_dump_file)), /* Dump SIP messages to the file */
TAG_END()); /* Last tag should always finish the sequence */
if(!sofia_agent->nua) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Create NUA [%s] %s",
apt_task_name_get(task),
sofia_agent->sip_bind_str);
}
}
static apt_bool_t apt_consumer_task_run(apt_task_t *task)
{
apr_status_t rv;
void *msg;
apt_bool_t *running;
apt_consumer_task_t *consumer_task;
consumer_task = apt_task_object_get(task);
if(!consumer_task) {
return FALSE;
}
running = apt_task_running_flag_get(task);
if(!running) {
return FALSE;
}
while(*running) {
apt_log(APT_LOG_MARK,APT_PRIO_DEBUG,"Wait for Messages [%s]",apt_task_name_get(task));
rv = apr_queue_pop(consumer_task->msg_queue,&msg);
if(rv == APR_SUCCESS) {
if(msg) {
apt_task_msg_t *task_msg = msg;
apt_task_msg_process(consumer_task->base,task_msg);
}
}
}
return TRUE;
}
static apt_bool_t mrcp_sofia_task_terminate(apt_task_t *task)
{
mrcp_sofia_agent_t *sofia_agent = apt_task_object_get(task);
if(sofia_agent->nua) {
apt_log(APT_LOG_MARK,APT_PRIO_DEBUG,"Send Shutdown Signal to NUA [%s]",
apt_task_name_get(task));
nua_shutdown(sofia_agent->nua);
}
return TRUE;
}
static apt_bool_t mpf_engine_msg_signal(apt_task_t *task, apt_task_msg_t *msg)
{
mpf_engine_t *engine = apt_task_object_get(task);
apr_thread_mutex_lock(engine->request_queue_guard);
if(apt_cyclic_queue_push(engine->request_queue,msg) == FALSE) {
apt_log(APT_LOG_MARK,APT_PRIO_ERROR,"MPF Request Queue is Full [%s]",apt_task_name_get(task));
}
apr_thread_mutex_unlock(engine->request_queue_guard);
return TRUE;
}
/** Create listening socket and add it to pollset */
static apt_bool_t mrcp_server_agent_listening_socket_create(mrcp_connection_agent_t *agent)
{
apr_status_t status;
if(!agent->sockaddr) {
return FALSE;
}
/* create listening socket */
status = apr_socket_create(&agent->listen_sock, agent->sockaddr->family, SOCK_STREAM, APR_PROTO_TCP, agent->pool);
if(status != APR_SUCCESS) {
return FALSE;
}
apr_socket_opt_set(agent->listen_sock, APR_SO_NONBLOCK, 0);
apr_socket_timeout_set(agent->listen_sock, -1);
apr_socket_opt_set(agent->listen_sock, APR_SO_REUSEADDR, 1);
status = apr_socket_bind(agent->listen_sock, agent->sockaddr);
if(status != APR_SUCCESS) {
apr_socket_close(agent->listen_sock);
agent->listen_sock = NULL;
return FALSE;
}
status = apr_socket_listen(agent->listen_sock, SOMAXCONN);
if(status != APR_SUCCESS) {
apr_socket_close(agent->listen_sock);
agent->listen_sock = NULL;
return FALSE;
}
/* add listening socket to pollset */
memset(&agent->listen_sock_pfd,0,sizeof(apr_pollfd_t));
agent->listen_sock_pfd.desc_type = APR_POLL_SOCKET;
agent->listen_sock_pfd.reqevents = APR_POLLIN;
agent->listen_sock_pfd.desc.s = agent->listen_sock;
agent->listen_sock_pfd.client_data = agent->listen_sock;
if(apt_poller_task_descriptor_add(agent->task, &agent->listen_sock_pfd) != TRUE) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Add Listening Socket to Pollset [%s]",
apt_task_name_get(apt_poller_task_base_get(agent->task)));
apr_socket_close(agent->listen_sock);
agent->listen_sock = NULL;
return FALSE;
}
return TRUE;
}
/** Get string identifier */
MRCP_DECLARE(const char*) mrcp_client_connection_agent_id_get(const mrcp_connection_agent_t *agent)
{
apt_task_t *task = apt_poller_task_base_get(agent->task);
return apt_task_name_get(task);
}
/** Get string identifier */
static const char* rtsp_server_id_get(const rtsp_server_t *server)
{
apt_task_t *task = apt_poller_task_base_get(server->task);
return apt_task_name_get(task);
}
/** Get string identifier */
static const char* rtsp_client_id_get(const rtsp_client_t *client)
{
apt_task_t *task = apt_poller_task_base_get(client->task);
return apt_task_name_get(task);
}
static apt_bool_t apt_poller_task_run(apt_task_t *base)
{
apt_poller_task_t *task = apt_task_object_get(base);
apt_bool_t running = TRUE;
apr_status_t status;
apr_int32_t num;
const apr_pollfd_t *ret_pfd;
apr_interval_time_t timeout;
apr_uint32_t queue_timeout;
apr_time_t time_now, time_last = 0;
int i;
const char *task_name;
if(!task) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Start Poller Task");
return FALSE;
}
task_name = apt_task_name_get(task->base),
/* explicitly indicate task is ready to process messages */
apt_task_ready(task->base);
while(running) {
if(apt_timer_queue_timeout_get(task->timer_queue,&queue_timeout) == TRUE) {
timeout = queue_timeout * 1000;
time_last = apr_time_now();
apt_log(APT_LOG_MARK,APT_PRIO_DEBUG,"Wait for Messages [%s] timeout [%lu]",
task_name, queue_timeout);
}
else {
timeout = -1;
apt_log(APT_LOG_MARK,APT_PRIO_DEBUG,"Wait for Messages [%s]",task_name);
}
status = apt_pollset_poll(task->pollset, timeout, &num, &ret_pfd);
if(status != APR_SUCCESS && status != APR_TIMEUP) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Poll status: %d",status);
continue;
}
for(i = 0; i < num; i++) {
if(apt_pollset_is_wakeup(task->pollset,&ret_pfd[i])) {
apt_log(APT_LOG_MARK,APT_PRIO_DEBUG,"Process Poller Wakeup [%s]",task_name);
if(apt_poller_task_wakeup_process(task) == FALSE) {
running = FALSE;
break;
}
continue;
}
apt_log(APT_LOG_MARK,APT_PRIO_DEBUG,"Process Signalled Descriptor [%s]",task_name);
task->signal_handler(task->obj,&ret_pfd[i]);
}
if(timeout != -1) {
time_now = apr_time_now();
if(time_now > time_last) {
apt_timer_queue_advance(task->timer_queue,(apr_uint32_t)((time_now - time_last)/1000));
}
}
}
return TRUE;
}
static apt_bool_t apt_consumer_task_run(apt_task_t *task)
{
apr_status_t rv;
void *msg;
apt_bool_t *running;
apt_consumer_task_t *consumer_task;
#if APR_HAS_QUEUE_TIMEOUT
apr_interval_time_t timeout;
apr_uint32_t queue_timeout;
apr_time_t time_now, time_last = 0;
#endif
const char *task_name;
consumer_task = apt_task_object_get(task);
if(!consumer_task) {
return FALSE;
}
task_name = apt_task_name_get(consumer_task->base),
running = apt_task_running_flag_get(task);
if(!running) {
return FALSE;
}
while(*running) {
#if APR_HAS_QUEUE_TIMEOUT
if(apt_timer_queue_timeout_get(consumer_task->timer_queue,&queue_timeout) == TRUE) {
timeout = (apr_interval_time_t)queue_timeout * 1000;
time_last = apr_time_now();
apt_log(APT_LOG_MARK,APT_PRIO_DEBUG,"Wait for Messages [%s] timeout [%u]",
task_name, queue_timeout);
rv = apr_queue_timedpop(consumer_task->msg_queue,timeout,&msg);
}
else
{
timeout = -1;
apt_log(APT_LOG_MARK,APT_PRIO_DEBUG,"Wait for Messages [%s]",task_name);
rv = apr_queue_pop(consumer_task->msg_queue,&msg);
}
#else
apt_log(APT_LOG_MARK,APT_PRIO_DEBUG,"Wait for Messages [%s]",task_name);
rv = apr_queue_pop(consumer_task->msg_queue,&msg);
#endif
if(rv == APR_SUCCESS) {
if(msg) {
apt_task_msg_t *task_msg = msg;
apt_task_msg_process(consumer_task->base,task_msg);
}
}
else if(rv != APR_TIMEUP) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Pop Message [%s] status: %d",task_name,rv);
}
#if APR_HAS_QUEUE_TIMEOUT
if(timeout != -1) {
time_now = apr_time_now();
if(time_now > time_last) {
apt_timer_queue_advance(consumer_task->timer_queue,(apr_uint32_t)((time_now - time_last)/1000));
}
}
#endif
}
return TRUE;
}
MPF_DECLARE(const char*) mpf_engine_id_get(const mpf_engine_t *engine)
{
return apt_task_name_get(engine->task);
}
