static apt_bool_t mrcp_client_message_send(mrcp_client_session_t *session, mrcp_channel_t *channel, mrcp_message_t *message)
{
if(!session->base.id.length) {
mrcp_message_t *response = mrcp_response_create(message,message->pool);
response->start_line.status_code = MRCP_STATUS_CODE_METHOD_FAILED;
apt_obj_log(APT_LOG_MARK,APT_PRIO_DEBUG,session->base.log_obj,"Raise App Failure MRCP Response "APT_NAMESID_FMT,
MRCP_SESSION_NAMESID(session));
mrcp_app_control_message_raise(session,channel,response);
return TRUE;
}
message->channel_id.session_id = session->base.id;
message->start_line.request_id = ++session->base.last_request_id;
apt_obj_log(APT_LOG_MARK,APT_PRIO_INFO,session->base.log_obj,"Send MRCP Request "APT_NAMESIDRES_FMT" [%"MRCP_REQUEST_ID_FMT"]",
MRCP_SESSION_NAMESID(session),
channel->resource->name.buf,
message->start_line.request_id);
if(channel->control_channel) {
/* MRCPv2 */
mrcp_client_control_message_send(channel->control_channel,message);
}
else {
/* MRCPv1 */
mrcp_session_control_request(channel->session,message);
}
return TRUE;
}
static apt_bool_t mrcp_app_failure_message_raise(mrcp_client_session_t *session)
{
mrcp_app_message_t *response;
const mrcp_app_message_t *request = session->active_request;
if(!request) {
return FALSE;
}
session->active_request = NULL;
response = mrcp_client_app_response_create(request,session->status,session->base.pool);
if(response->message_type == MRCP_APP_MESSAGE_TYPE_SIGNALING) {
apt_obj_log(APT_LOG_MARK,APT_PRIO_INFO,session->base.log_obj,"Raise App Response "APT_NAMESID_FMT" [%d] %s [%d]",
MRCP_SESSION_NAMESID(session),
response->sig_message.command_id,
session->status == MRCP_SIG_STATUS_CODE_SUCCESS ? "SUCCESS" : "FAILURE",
session->status);
}
else if(response->control_message){
mrcp_message_t *mrcp_response = mrcp_response_create(response->control_message,response->control_message->pool);
mrcp_response->start_line.status_code = MRCP_STATUS_CODE_METHOD_FAILED;
response->control_message = mrcp_response;
apt_obj_log(APT_LOG_MARK,APT_PRIO_INFO,session->base.log_obj,"Raise App MRCP Response "APT_NAMESID_FMT,
MRCP_SESSION_NAMESID(session));
}
session->application->handler(response);
return TRUE;
}
static apt_bool_t mrcp_app_control_message_raise(mrcp_client_session_t *session, mrcp_channel_t *channel, mrcp_message_t *mrcp_message)
{
if(mrcp_message->start_line.message_type == MRCP_MESSAGE_TYPE_RESPONSE) {
mrcp_app_message_t *response;
mrcp_message_t *mrcp_request;
if(!session->active_request || !session->active_request->control_message) {
return FALSE;
}
response = mrcp_client_app_response_create(session->active_request,0,session->base.pool);
mrcp_request = session->active_request->control_message;
mrcp_message->start_line.method_id = mrcp_request->start_line.method_id;
mrcp_message->start_line.method_name = mrcp_request->start_line.method_name;
response->control_message = mrcp_message;
apt_obj_log(APT_LOG_MARK,APT_PRIO_INFO,session->base.log_obj,"Raise App MRCP Response "APT_NAMESID_FMT,
MRCP_SESSION_NAMESID(session));
session->application->handler(response);
session->active_request = apt_list_pop_front(session->request_queue);
if(session->active_request) {
mrcp_app_request_dispatch(session,session->active_request);
}
}
else if(mrcp_message->start_line.message_type == MRCP_MESSAGE_TYPE_EVENT) {
mrcp_app_message_t *app_message;
app_message = mrcp_client_app_control_message_create(session->base.pool);
app_message->control_message = mrcp_message;
app_message->application = session->application;
app_message->session = &session->base;
app_message->channel = channel;
apt_obj_log(APT_LOG_MARK,APT_PRIO_INFO,session->base.log_obj,"Raise App MRCP Event "APT_NAMESID_FMT,
MRCP_SESSION_NAMESID(session));
session->application->handler(app_message);
}
return TRUE;
}
static apt_bool_t mrcp_client_agent_messsage_send(mrcp_connection_agent_t *agent, mrcp_control_channel_t *channel, mrcp_message_t *message)
{
apt_bool_t status = FALSE;
mrcp_connection_t *connection = channel->connection;
apt_text_stream_t stream;
apt_message_status_e result;
if(!connection || !connection->sock) {
apt_obj_log(APT_LOG_MARK,APT_PRIO_WARNING,channel->log_obj,"Null MRCPv2 Connection "APT_SIDRES_FMT,MRCP_MESSAGE_SIDRES(message));
mrcp_client_agent_request_cancel(agent,channel,message);
return FALSE;
}
do {
apt_text_stream_init(&stream,connection->tx_buffer,connection->tx_buffer_size);
result = mrcp_generator_run(connection->generator,message,&stream);
if(result != APT_MESSAGE_STATUS_INVALID) {
stream.text.length = stream.pos - stream.text.buf;
*stream.pos = '\0';
apt_obj_log(APT_LOG_MARK,APT_PRIO_INFO,channel->log_obj,"Send MRCPv2 Data %s [%"APR_SIZE_T_FMT" bytes]\n%.*s",
connection->id,
stream.text.length,
connection->verbose == TRUE ? stream.text.length : 0,
stream.text.buf);
if(apr_socket_send(connection->sock,stream.text.buf,&stream.text.length) == APR_SUCCESS) {
status = TRUE;
}
else {
apt_obj_log(APT_LOG_MARK,APT_PRIO_WARNING,channel->log_obj,"Failed to Send MRCPv2 Data %s",
connection->id);
}
}
else {
apt_obj_log(APT_LOG_MARK,APT_PRIO_WARNING,channel->log_obj,"Failed to Generate MRCPv2 Data %s",
connection->id);
}
}
while(result == APT_MESSAGE_STATUS_INCOMPLETE);
if(status == TRUE) {
channel->active_request = message;
if(channel->request_timer && agent->request_timeout) {
apt_timer_set(channel->request_timer,agent->request_timeout);
}
}
else {
mrcp_client_agent_request_cancel(agent,channel,message);
}
return status;
}
static apt_bool_t mrcp_client_on_termination_subtract(mrcp_client_session_t *session, const mpf_message_t *mpf_message)
{
rtp_termination_slot_t *termination_slot;
if(!session) {
return FALSE;
}
apt_obj_log(APT_LOG_MARK,APT_PRIO_DEBUG,session->base.log_obj,"Media Termination Subtracted "APT_NAMESIDRES_FMT,
MRCP_SESSION_NAMESID(session),
mpf_termination_name_get(mpf_message->termination));
termination_slot = mrcp_client_rtp_termination_find(session,mpf_message->termination);
if(termination_slot) {
/* rtp termination */
if(termination_slot->waiting == FALSE) {
return FALSE;
}
termination_slot->waiting = FALSE;
if(mrcp_client_session_subrequest_remove(session) == TRUE) {
mrcp_app_session_terminate_raise(session,MRCP_SIG_STATUS_CODE_SUCCESS);
}
}
else {
/* channel termination */
mrcp_channel_t *channel = mrcp_client_channel_termination_find(session,mpf_message->termination);
if(channel && channel->waiting_for_termination == TRUE) {
channel->waiting_for_termination = FALSE;
if(mrcp_client_session_subrequest_remove(session) == TRUE) {
/* raise app response */
mrcp_app_sig_response_raise(session,TRUE);
}
}
}
return TRUE;
}
/** Create client session */
MRCP_DECLARE(mrcp_session_t*) mrcp_application_session_create(mrcp_application_t *application, const char *profile_name, void *obj)
{
mrcp_profile_t *profile;
mrcp_client_session_t *session;
if(!application || !application->client || !profile_name) {
return NULL;
}
profile = mrcp_client_profile_get(application->client,profile_name);
if(!profile) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"No Such Profile [%s]",profile_name);
return NULL;
}
session = mrcp_client_session_create(application->client);
if(!session) {
return NULL;
}
session->application = application;
session->app_obj = obj;
session->base.log_obj = obj;
session->profile = profile;
apt_obj_log(APT_LOG_MARK,APT_PRIO_NOTICE,session->base.log_obj,"Create MRCP Handle "APT_PTR_FMT" [%s]",
MRCP_SESSION_PTR(session),
profile_name);
return &session->base;
}
static apt_bool_t mrcp_app_sig_response_raise(mrcp_client_session_t *session, apt_bool_t process_pending_requests)
{
mrcp_app_message_t *response;
const mrcp_app_message_t *request = session->active_request;
if(!request) {
return FALSE;
}
session->active_request = NULL;
if(session->disconnected == TRUE) {
session->status = MRCP_SIG_STATUS_CODE_TERMINATE;
}
response = mrcp_client_app_response_create(request,session->status,session->base.pool);
apt_obj_log(APT_LOG_MARK,APT_PRIO_INFO,session->base.log_obj,"Raise App Response " APT_NAMESID_FMT " [%d] %s [%d]",
MRCP_SESSION_NAMESID(session),
response->sig_message.command_id,
session->status == MRCP_SIG_STATUS_CODE_SUCCESS ? "SUCCESS" : "FAILURE",
session->status);
session->application->handler(response);
if(process_pending_requests) {
session->active_request = apt_list_pop_front(session->request_queue);
if(session->active_request) {
mrcp_app_request_dispatch(session,session->active_request);
}
}
return TRUE;
}
static apt_bool_t mrcp_client_message_handler(mrcp_connection_t *connection, mrcp_message_t *message, apt_message_status_e status)
{
if(status == APT_MESSAGE_STATUS_COMPLETE) {
/* message is completely parsed */
mrcp_control_channel_t *channel;
apt_str_t identifier;
apt_id_resource_generate(&message->channel_id.session_id,&message->channel_id.resource_name,'@',&identifier,message->pool);
channel = mrcp_connection_channel_find(connection,&identifier);
if(channel) {
mrcp_connection_agent_t *agent = connection->agent;
if(message->start_line.message_type == MRCP_MESSAGE_TYPE_RESPONSE) {
if(!channel->active_request ||
channel->active_request->start_line.request_id != message->start_line.request_id) {
apt_obj_log(APT_LOG_MARK,APT_PRIO_WARNING,channel->log_obj,"Unexpected MRCP Response "APT_SIDRES_FMT" [%d]",
MRCP_MESSAGE_SIDRES(message),
message->start_line.request_id);
return FALSE;
}
if(channel->request_timer) {
apt_timer_kill(channel->request_timer);
}
channel->active_request = NULL;
}
mrcp_connection_message_receive(agent->vtable,channel,message);
}
else {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Find Channel "APT_SIDRES_FMT" in Connection %s [%d]",
MRCP_MESSAGE_SIDRES(message),
connection->id,
apr_hash_count(connection->channel_table));
}
}
return TRUE;
}
static void mrcp_sofia_on_state_change(
int status,
mrcp_sofia_agent_t *sofia_agent,
nua_handle_t *nh,
mrcp_sofia_session_t *sofia_session,
sip_t const *sip,
tagi_t tags[])
{
int ss_state = nua_callstate_init;
tl_gets(tags,
NUTAG_CALLSTATE_REF(ss_state),
TAG_END());
if(!sofia_session || !sofia_session->session) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"SIP Call State [%s]",
nua_callstate_name(ss_state));
return;
}
apt_obj_log(APT_LOG_MARK,APT_PRIO_NOTICE,sofia_session->session->log_obj,"SIP Call State %s [%s]",
sofia_session->session->name,
nua_callstate_name(ss_state));
switch(ss_state) {
case nua_callstate_ready:
mrcp_sofia_on_session_ready(status,sofia_agent,nh,sofia_session,sip,tags);
break;
case nua_callstate_terminated:
mrcp_sofia_on_session_terminate(status,sofia_agent,nh,sofia_session,sip,tags);
break;
}
}
static apt_bool_t mrcp_client_on_termination_modify(mrcp_client_session_t *session, const mpf_message_t *mpf_message)
{
rtp_termination_slot_t *termination_slot;
if(!session) {
return FALSE;
}
apt_obj_log(APT_LOG_MARK,APT_PRIO_DEBUG,session->base.log_obj,"Media Termination Modified "APT_NAMESIDRES_FMT,
MRCP_SESSION_NAMESID(session),
mpf_termination_name_get(mpf_message->termination));
termination_slot = mrcp_client_rtp_termination_find(session,mpf_message->termination);
if(termination_slot) {
/* rtp termination */
if(termination_slot->waiting == FALSE) {
return FALSE;
}
termination_slot->waiting = FALSE;
termination_slot->descriptor = mpf_message->descriptor;;
if(mrcp_client_session_subrequest_remove(session) == TRUE) {
if(session->state == SESSION_STATE_GENERATING_OFFER) {
/* send offer to server */
mrcp_client_session_offer_send(session);
}
else if(session->state == SESSION_STATE_PROCESSING_ANSWER) {
/* raise app response */
mrcp_app_sig_response_raise(session,TRUE);
}
}
}
return TRUE;
}
static void mrcp_sofia_on_resource_discover(
int status,
mrcp_sofia_agent_t *sofia_agent,
nua_handle_t *nh,
mrcp_sofia_session_t *sofia_session,
sip_t const *sip,
tagi_t tags[])
{
mrcp_session_t *session = sofia_session->session;
if(session) {
const char *remote_sdp_str = NULL;
mrcp_session_descriptor_t *descriptor = NULL;
if(sip->sip_payload) {
remote_sdp_str = sip->sip_payload->pl_data;
}
if(remote_sdp_str) {
sdp_parser_t *parser = NULL;
sdp_session_t *sdp = NULL;
apt_obj_log(APT_LOG_MARK,APT_PRIO_INFO,session->obj,"Resource Discovery SDP %s\n%s",
session->name,
remote_sdp_str);
parser = sdp_parse(sofia_session->home,remote_sdp_str,(int)strlen(remote_sdp_str),0);
sdp = sdp_session(parser);
descriptor = mrcp_descriptor_generate_by_sdp_session(sdp,NULL,session->pool);
descriptor->response_code = status;
sdp_parser_free(parser);
}
mrcp_session_discover_response(session,descriptor);
}
}
mrcp_channel_t* mrcp_client_channel_create(
mrcp_client_session_t *session,
mrcp_resource_t *resource,
mpf_termination_t *termination,
mpf_rtp_termination_descriptor_t *rtp_descriptor,
void *obj)
{
mrcp_channel_t *channel = apr_palloc(session->base.pool,sizeof(mrcp_channel_t));
channel->pool = session->base.pool;
channel->obj = obj;
channel->session = &session->base;
channel->control_channel = NULL;
channel->termination = termination;
channel->rtp_termination_slot = NULL;
channel->resource = resource;
channel->waiting_for_channel = FALSE;
channel->waiting_for_termination = FALSE;
if(rtp_descriptor) {
rtp_termination_slot_t *termination_slot = apr_palloc(channel->pool,sizeof(rtp_termination_slot_t));
termination_slot->descriptor = rtp_descriptor;
termination_slot->termination = NULL;
termination_slot->waiting = FALSE;
termination_slot->channel = channel;
termination_slot->id = 0;
channel->rtp_termination_slot = termination_slot;
}
apt_obj_log(APT_LOG_MARK,APT_PRIO_INFO,session->base.log_obj,"Create Channel "APT_NAMESID_FMT,
MRCP_SESSION_NAMESID(session));
return channel;
}
apt_bool_t mrcp_client_session_terminate_response_process(mrcp_client_session_t *session)
{
apt_obj_log(APT_LOG_MARK,APT_PRIO_INFO,session->base.log_obj,"Session Terminated "APT_NAMESID_FMT, MRCP_SESSION_NAMESID(session));
if(mrcp_client_session_subrequest_remove(session) == TRUE) {
mrcp_app_session_terminate_raise(session,MRCP_SIG_STATUS_CODE_SUCCESS);
}
return TRUE;
}
/** Destroy client session (session must be terminated prior to destroy) */
MRCP_DECLARE(apt_bool_t) mrcp_application_session_destroy(mrcp_session_t *session)
{
if(!session) {
return FALSE;
}
apt_obj_log(APT_LOG_MARK,APT_PRIO_NOTICE,session->log_obj,"Destroy MRCP Handle %s",session->name);
mrcp_session_destroy(session);
return TRUE;
}
static apt_bool_t mrcp_client_session_update(mrcp_client_session_t *session)
{
if(!session->offer) {
return FALSE;
}
apt_obj_log(APT_LOG_MARK,APT_PRIO_INFO,session->base.log_obj,"Update Session "APT_NAMESID_FMT,
MRCP_SESSION_NAMESID(session));
return mrcp_client_session_offer_send(session);
}
void mrcp_client_session_remove(mrcp_client_t *client, mrcp_client_session_t *session)
{
if(session) {
apt_obj_log(APT_LOG_MARK,APT_PRIO_INFO,session->base.log_obj,"Remove MRCP Handle "APT_NAMESID_FMT,
session->base.name,
MRCP_SESSION_SID(&session->base));
apr_hash_set(client->session_table,session,sizeof(session),NULL);
}
}
static apt_bool_t mrcp_client_agent_channel_modify(mrcp_connection_agent_t *agent, mrcp_control_channel_t *channel, mrcp_control_descriptor_t *descriptor)
{
apt_bool_t status = TRUE;
if(descriptor->port) {
if(!channel->connection) {
mrcp_connection_t *connection = NULL;
apt_id_resource_generate(&descriptor->session_id,&descriptor->resource_name,'@',&channel->identifier,channel->pool);
/* no connection yet */
if(descriptor->connection_type == MRCP_CONNECTION_TYPE_EXISTING) {
/* try to find existing connection */
connection = mrcp_client_agent_connection_find(agent,descriptor);
if(!connection) {
apt_obj_log(APT_LOG_MARK,APT_PRIO_WARNING,channel->log_obj,"Found No Existing TCP/MRCPv2 Connection");
}
}
if(!connection) {
/* create new connection */
connection = mrcp_client_agent_connection_create(agent,descriptor);
if(!connection) {
apt_obj_log(APT_LOG_MARK,APT_PRIO_WARNING,channel->log_obj,"Failed to Establish TCP/MRCPv2 Connection");
}
}
if(connection) {
mrcp_connection_channel_add(connection,channel);
apt_obj_log(APT_LOG_MARK,APT_PRIO_INFO,channel->log_obj,"Add Control Channel <%s> %s [%d]",
channel->identifier.buf,
connection->id,
apr_hash_count(connection->channel_table));
if(descriptor->connection_type == MRCP_CONNECTION_TYPE_NEW) {
/* set connection type to existing for the next offers / if any */
descriptor->connection_type = MRCP_CONNECTION_TYPE_EXISTING;
}
}
else {
descriptor->port = 0;
status = FALSE;
}
}
}
/* send response */
return mrcp_control_channel_modify_respond(agent->vtable,channel,descriptor,status);
}
static apt_bool_t mrcp_client_agent_request_cancel(mrcp_connection_agent_t *agent, mrcp_control_channel_t *channel, mrcp_message_t *message)
{
mrcp_message_t *response;
apt_obj_log(APT_LOG_MARK,APT_PRIO_WARNING,channel->log_obj,"Cancel MRCP Request <%s@%s> [%d]",
MRCP_MESSAGE_SIDRES(message),
message->start_line.request_id);
response = mrcp_response_create(message,message->pool);
response->start_line.status_code = MRCP_STATUS_CODE_METHOD_FAILED;
return mrcp_connection_message_receive(agent->vtable,channel,response);
}
apt_bool_t mrcp_client_mpf_message_process(mpf_message_container_t *mpf_message_container)
{
apr_size_t i;
mrcp_client_session_t *session;
const mpf_message_t *mpf_message;
for(i=0; i<mpf_message_container->count; i++) {
mpf_message = &mpf_message_container->messages[i];
if(mpf_message->context) {
session = mpf_engine_context_object_get(mpf_message->context);
}
else {
session = NULL;
}
if(!session) {
apt_log(APT_LOG_MARK,APT_PRIO_DEBUG,"Received MPF Message: NULL session");
continue;
}
if(mpf_message->message_type == MPF_MESSAGE_TYPE_RESPONSE) {
switch(mpf_message->command_id) {
case MPF_ADD_TERMINATION:
mrcp_client_on_termination_add(session,mpf_message);
break;
case MPF_MODIFY_TERMINATION:
mrcp_client_on_termination_modify(session,mpf_message);
break;
case MPF_SUBTRACT_TERMINATION:
mrcp_client_on_termination_subtract(session,mpf_message);
break;
case MPF_ADD_ASSOCIATION:
case MPF_REMOVE_ASSOCIATION:
case MPF_RESET_ASSOCIATIONS:
case MPF_APPLY_TOPOLOGY:
case MPF_DESTROY_TOPOLOGY:
if(mrcp_client_session_subrequest_remove(session) == TRUE) {
if(session->state == SESSION_STATE_GENERATING_OFFER) {
/* send offer to server */
mrcp_client_session_offer_send(session);
}
else if(session->state == SESSION_STATE_PROCESSING_ANSWER) {
/* raise app response */
mrcp_app_sig_response_raise(session,TRUE);
}
}
break;
default:
break;
}
}
else if(mpf_message->message_type == MPF_MESSAGE_TYPE_EVENT) {
apt_obj_log(APT_LOG_MARK,APT_PRIO_DEBUG,session->base.log_obj,"Process MPF Event " APT_NAMESID_FMT,
MRCP_SESSION_NAMESID(session));
}
}
return TRUE;
}
static void mrcp_sofia_on_session_redirect(
int status,
mrcp_sofia_agent_t *sofia_agent,
nua_handle_t *nh,
mrcp_sofia_session_t *sofia_session,
sip_t const *sip,
tagi_t tags[])
{
mrcp_session_t *session = sofia_session->session;
sip_contact_t *sip_contact;
if(!sip) {
return;
}
sip_contact = sip->sip_contact;
if(!sip_contact || !sip_contact->m_url) {
return;
}
if(sip_contact->m_url->url_user && sip_contact->m_url->url_user != '\0') {
sofia_session->sip_to_str = apr_psprintf(session->pool,"sip:%s@%s:%s",
sip_contact->m_url->url_user,
sip_contact->m_url->url_host,
sip_contact->m_url->url_port);
}
else {
sofia_session->sip_to_str = apr_psprintf(session->pool,"sip:%s:%s",
sip_contact->m_url->url_host,
sip_contact->m_url->url_port);
}
apr_thread_mutex_lock(sofia_session->mutex);
apt_obj_log(APT_LOG_MARK,APT_PRIO_INFO,session->log_obj,"Redirect "APT_NAMESID_FMT" to %s",
session->name,
MRCP_SESSION_SID(session),
sofia_session->sip_to_str);
if(sofia_session->nh) {
nua_handle_bind(sofia_session->nh, NULL);
nua_handle_destroy(sofia_session->nh);
sofia_session->nh = NULL;
}
sofia_session->nh = nua_handle(
sofia_agent->nua,
sofia_session,
SIPTAG_TO_STR(sofia_session->sip_to_str),
SIPTAG_FROM_STR(sofia_agent->sip_from_str),
SIPTAG_CONTACT_STR(sofia_agent->sip_contact_str),
TAG_END());
apr_thread_mutex_unlock(sofia_session->mutex);
mrcp_sofia_session_offer(sofia_session->session,sofia_session->descriptor);
}
apt_bool_t mrcp_client_session_terminate_event_process(mrcp_client_session_t *session)
{
if(session->state == SESSION_STATE_TERMINATING) {
/* session termination request has been sent, still waiting for the response,
all the events must be ignored at this stage */
apt_obj_log(APT_LOG_MARK,APT_PRIO_WARNING,session->base.log_obj,"Unexpected Event! " APT_NAMESID_FMT,
MRCP_SESSION_NAMESID(session));
return FALSE;
}
apt_obj_log(APT_LOG_MARK,APT_PRIO_DEBUG,session->base.log_obj,"Mark Session as Disconnected " APT_NAMESID_FMT,
MRCP_SESSION_NAMESID(session));
session->disconnected = TRUE;
if(!session->active_request) {
/* raise app event */
mrcp_app_sig_event_raise(session,NULL);
}
return TRUE;
}
static apt_bool_t mrcp_client_session_offer_send(mrcp_client_session_t *session)
{
mrcp_session_descriptor_t *descriptor = session->offer;
apt_obj_log(APT_LOG_MARK,APT_PRIO_INFO,session->base.log_obj,"Send Offer "APT_NAMESID_FMT" [c:%d a:%d v:%d] to %s:%hu",
MRCP_SESSION_NAMESID(session),
descriptor->control_media_arr->nelts,
descriptor->audio_media_arr->nelts,
descriptor->video_media_arr->nelts,
session->profile->signaling_settings->server_ip,
session->profile->signaling_settings->server_port);
return mrcp_session_offer(&session->base,descriptor);
}
static APR_INLINE void mrcp_client_session_state_set(mrcp_client_session_t *session, mrcp_client_session_state_e state)
{
if(session->subrequest_count != 0) {
/* error case */
apt_obj_log(APT_LOG_MARK,APT_PRIO_ERROR,session->base.log_obj,"Unexpected State Change [%d] pending subrequests [%d] " APT_NAMESID_FMT,
state,
session->subrequest_count,
MRCP_SESSION_NAMESID(session));
session->subrequest_count = 0;
}
session->state = state;
}
static apt_bool_t mrcp_client_av_media_answer_process(mrcp_client_session_t *session, mrcp_session_descriptor_t *descriptor)
{
rtp_termination_slot_t *slot;
int i;
int count = session->terminations->nelts;
if(count != descriptor->audio_media_arr->nelts) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Number of terminations [%d] != Number of audio media in answer [%d]",
count,descriptor->audio_media_arr->nelts);
count = descriptor->audio_media_arr->nelts;
}
/* update existing terminations */
for(i=0; i<count; i++) {
mpf_rtp_media_descriptor_t *remote_media;
mpf_rtp_termination_descriptor_t *rtp_descriptor;
/* get existing termination */
slot = &APR_ARRAY_IDX(session->terminations,i,rtp_termination_slot_t);
if(!slot) continue;
remote_media = mrcp_session_audio_media_get(descriptor,i);
if(slot->descriptor) {
slot->descriptor->audio.remote = remote_media;
}
if(slot->termination) {
/* construct termination descriptor */
rtp_descriptor = apr_palloc(session->base.pool,sizeof(mpf_rtp_termination_descriptor_t));
mpf_rtp_termination_descriptor_init(rtp_descriptor);
rtp_descriptor->audio.local = NULL;
rtp_descriptor->audio.remote = remote_media;
/* send modify termination request */
apt_obj_log(APT_LOG_MARK,APT_PRIO_DEBUG,session->base.log_obj,"Modify Media Termination "APT_NAMESIDRES_FMT,
MRCP_SESSION_NAMESID(session),
mpf_termination_name_get(slot->termination));
if(mpf_engine_termination_message_add(
session->profile->media_engine,
MPF_MODIFY_TERMINATION,session->context,slot->termination,rtp_descriptor,
&session->mpf_task_msg) == TRUE) {
slot->waiting = TRUE;
mrcp_client_session_subrequest_add(session);
}
if(slot->channel && slot->channel->termination) {
if(mpf_engine_assoc_message_add(
session->profile->media_engine,
MPF_ADD_ASSOCIATION,session->context,slot->termination,slot->channel->termination,
&session->mpf_task_msg) == TRUE) {
mrcp_client_session_subrequest_add(session);
}
}
}
}
return TRUE;
}
static apt_bool_t mrcp_app_sig_event_raise(mrcp_client_session_t *session, mrcp_channel_t *channel)
{
mrcp_app_message_t *app_event;
if(!session) {
return FALSE;
}
app_event = mrcp_client_app_signaling_event_create(MRCP_SIG_EVENT_TERMINATE,session->base.pool);
app_event->application = session->application;
app_event->session = &session->base;
app_event->channel = channel;
apt_obj_log(APT_LOG_MARK,APT_PRIO_INFO,session->base.log_obj,"Raise App Event "APT_NAMESID_FMT" [%d]",
MRCP_SESSION_NAMESID(session),
app_event->sig_message.event_id);
return session->application->handler(app_event);
}
apt_bool_t mrcp_client_app_message_process(mrcp_app_message_t *app_message)
{
mrcp_client_session_t *session = (mrcp_client_session_t*)app_message->session;
if(app_message->message_type == MRCP_APP_MESSAGE_TYPE_SIGNALING) {
apt_obj_log(APT_LOG_MARK,APT_PRIO_INFO,session->base.log_obj,"Receive App Request "APT_NAMESID_FMT" [%d]",
MRCP_SESSION_NAMESID(session),
app_message->sig_message.command_id);
}
else {
apt_obj_log(APT_LOG_MARK,APT_PRIO_INFO,session->base.log_obj,"Receive App MRCP Request "APT_NAMESID_FMT,
MRCP_SESSION_NAMESID(session));
}
if(session->active_request) {
apt_obj_log(APT_LOG_MARK,APT_PRIO_DEBUG,session->base.log_obj,"Push Request to Queue "APT_NAMESID_FMT,
MRCP_SESSION_NAMESID(session));
apt_list_push_back(session->request_queue,app_message,session->base.pool);
return TRUE;
}
session->active_request = app_message;
mrcp_app_request_dispatch(session,app_message);
return TRUE;
}
apt_bool_t mrcp_client_on_channel_add(mrcp_channel_t *channel, mrcp_control_descriptor_t *descriptor, apt_bool_t status)
{
mrcp_client_session_t *session = (mrcp_client_session_t*)channel->session;
apt_obj_log(APT_LOG_MARK,APT_PRIO_DEBUG,session->base.log_obj,"Control Channel Added "APT_NAMESIDRES_FMT,
MRCP_SESSION_NAMESID(session),
channel->resource->name.buf);
if(!channel->waiting_for_channel) {
return FALSE;
}
channel->waiting_for_channel = FALSE;
if(mrcp_client_session_subrequest_remove(session) == TRUE) {
/* send offer to server */
mrcp_client_session_offer_send(session);
}
return TRUE;
}
apt_bool_t mrcp_client_on_channel_remove(mrcp_channel_t *channel, apt_bool_t status)
{
mrcp_client_session_t *session = (mrcp_client_session_t*)channel->session;
apt_obj_log(APT_LOG_MARK,APT_PRIO_DEBUG,session->base.log_obj,"Control Channel Removed "APT_NAMESIDRES_FMT,
MRCP_SESSION_NAMESID(session),
channel->resource->name.buf);
if(!channel->waiting_for_channel) {
return FALSE;
}
channel->waiting_for_channel = FALSE;
if(mrcp_client_session_subrequest_remove(session) == TRUE) {
mrcp_app_session_terminate_raise(
session,
status == TRUE ? MRCP_SIG_STATUS_CODE_SUCCESS : MRCP_SIG_STATUS_CODE_FAILURE);
}
return TRUE;
}
apt_bool_t mrcp_client_session_terminate_event_process(mrcp_client_session_t *session)
{
if(session->state == SESSION_STATE_TERMINATING) {
/* session termination request has been sent, still waiting for the response,
all the events must be ignored at this stage */
apt_obj_log(APT_LOG_MARK,APT_PRIO_WARNING,session->base.log_obj,"Unexpected Event! "APT_NAMESID_FMT,
MRCP_SESSION_NAMESID(session));
return FALSE;
}
if(session->active_request) {
apt_bool_t process_pending_requests = TRUE;
/* raise app response */
session->status = MRCP_SIG_STATUS_CODE_TERMINATE;
mrcp_app_failure_message_raise(session);
/* cancel remaing requests, but do process session termination request (if any) */
do {
session->active_request = apt_list_pop_front(session->request_queue);
if(session->active_request) {
const mrcp_app_message_t *app_message = session->active_request;
if(app_message->message_type == MRCP_APP_MESSAGE_TYPE_SIGNALING &&
app_message->sig_message.command_id == MRCP_SIG_COMMAND_SESSION_TERMINATE) {
/* process session termination */
mrcp_app_request_dispatch(session,app_message);
break;
}
/* cancel pending request */
session->status = MRCP_SIG_STATUS_CODE_CANCEL;
mrcp_app_failure_message_raise(session);
}
else {
process_pending_requests = FALSE;
}
}
while(process_pending_requests == TRUE);
}
else {
/* raise app event */
mrcp_app_sig_event_raise(session,NULL);
}
return TRUE;
}
static apt_bool_t mrcp_client_agent_channel_remove(mrcp_connection_agent_t *agent, mrcp_control_channel_t *channel)
{
if(channel->connection) {
mrcp_connection_t *connection = channel->connection;
mrcp_connection_channel_remove(connection,channel);
apt_obj_log(APT_LOG_MARK,APT_PRIO_INFO,channel->log_obj,"Remove Control Channel <%s> [%d]",
channel->identifier.buf,
apr_hash_count(connection->channel_table));
if(!connection->access_count) {
mrcp_client_agent_connection_remove(agent,connection);
/* set connection to be destroyed on channel destroy */
channel->connection = connection;
channel->removed = TRUE;
}
}
/* send response */
return mrcp_control_channel_remove_respond(agent->vtable,channel,TRUE);
}
