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