static apt_bool_t mrcp_server_session_offer_process(mrcp_server_session_t *session, mrcp_session_descriptor_t *descriptor)
{
	if(!session->context) {
		/* initial offer received, generate session id and add to session's table */
		if(!session->base.id.length) {
			apt_unique_id_generate(&session->base.id,MRCP_SESSION_ID_HEX_STRING_LENGTH,session->base.pool);
		}
		mrcp_server_session_add(session);

		session->context = mpf_engine_context_create(session->profile->media_engine,session,5,session->base.pool);
	}
	apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Receive Offer "APT_SID_FMT" [c:%d a:%d v:%d]",
		MRCP_SESSION_SID(&session->base),
		descriptor->control_media_arr->nelts,
		descriptor->audio_media_arr->nelts,
		descriptor->video_media_arr->nelts);

	/* store received offer */
	session->offer = descriptor;
	session->answer = mrcp_session_answer_create(descriptor,session->base.pool);

	mrcp_server_session_state_set(session,SESSION_STATE_GENERATING_ANSWER);

	/* first, reset/destroy existing associations and topology */
	if(mpf_engine_topology_message_add(
				session->profile->media_engine,
				MPF_RESET_ASSOCIATIONS,session->context,
				&session->mpf_task_msg) == TRUE){
		mrcp_server_session_subrequest_add(session);
	}

	if(mrcp_session_version_get(session) == MRCP_VERSION_1) {
		if(mrcp_server_resource_offer_process(session,descriptor) == TRUE) {
			mrcp_server_av_media_offer_process(session,descriptor);
		}
		else {
			session->answer->resource_state = FALSE;
		}
	}
	else {
		mrcp_server_control_media_offer_process(session,descriptor);
		mrcp_server_av_media_offer_process(session,descriptor);
	}

	/* apply topology based on assigned associations */
	if(mpf_engine_topology_message_add(
				session->profile->media_engine,
				MPF_APPLY_TOPOLOGY,session->context,
				&session->mpf_task_msg) == TRUE) {
		mrcp_server_session_subrequest_add(session);
	}
	mpf_engine_message_send(session->profile->media_engine,&session->mpf_task_msg);

	if(!session->subrequest_count) {
		/* send answer to client */
		mrcp_server_session_answer_send(session);
	}
	return TRUE;
}
Example #2
0
/** Process MPF event  */
static apt_bool_t mpf_suite_event_process(mpf_suite_agent_t *agent, const mpf_message_t *mpf_message)
{
	mpf_task_msg_t *task_msg = NULL;
	mpf_suite_session_t *session;
	apt_log(APT_LOG_MARK,APT_PRIO_DEBUG,"Process MPF Event");
	if(mpf_message->termination) {
		session = mpf_termination_object_get(mpf_message->termination);
		/* first destroy existing topology */
		mpf_engine_topology_message_add(
					agent->engine,
					MPF_DESTROY_TOPOLOGY,session->context,
					&task_msg);

		if(session->file_termination) {
			apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Subtract Termination [File]");
			mpf_engine_termination_message_add(
				agent->engine,
				MPF_SUBTRACT_TERMINATION,session->context,session->file_termination,NULL,
				&task_msg);
		}
		if(session->rtp_termination) {
			apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Subtract Termination [RTP]");
			mpf_engine_termination_message_add(
				agent->engine,
				MPF_SUBTRACT_TERMINATION,session->context,session->rtp_termination,NULL,
				&task_msg);
		}
	}
	return mpf_engine_message_send(agent->engine,&task_msg);
}
Example #3
0
/** Process MPF response  */
static apt_bool_t mpf_suite_response_process(mpf_suite_agent_t *agent, const mpf_message_t *mpf_message)
{
	mpf_task_msg_t *task_msg = NULL;
	apt_log(APT_LOG_MARK,APT_PRIO_DEBUG,"Process MPF Response");
	if(mpf_message->command_id == MPF_ADD_TERMINATION) {
		apt_log(APT_LOG_MARK,APT_PRIO_DEBUG,"On Add Termination");
		if(mpf_message->termination) {
			mpf_suite_session_t *session;
			session = mpf_termination_object_get(mpf_message->termination);
			if(session->rtp_termination == mpf_message->termination) {
				mpf_rtp_stream_descriptor_t *descriptor = NULL;
				if(session == agent->rx_session) {
					descriptor = mpf_rtp_rx_remote_descriptor_create(agent,session);
				}
				if(session == agent->tx_session) {
					descriptor = mpf_rtp_tx_remote_descriptor_create(agent,session);
				}

				if(descriptor) {
					mpf_engine_termination_message_add(
						agent->engine,
						MPF_MODIFY_TERMINATION,session->context,session->rtp_termination,descriptor,
						&task_msg);
				}

				mpf_engine_assoc_message_add(
						agent->engine,
						MPF_ADD_ASSOCIATION,session->context,session->file_termination,session->rtp_termination,
						&task_msg);

				mpf_engine_topology_message_add(
						agent->engine,
						MPF_APPLY_TOPOLOGY,session->context,
						&task_msg);
			}
		}
	}
	else if(mpf_message->command_id == MPF_SUBTRACT_TERMINATION) {
		apt_log(APT_LOG_MARK,APT_PRIO_DEBUG,"On Subtract Termination");
		if(mpf_message->termination) {
			mpf_suite_session_t *session;
			session = mpf_termination_object_get(mpf_message->termination);
			if(session->file_termination == mpf_message->termination) {
				session->file_termination = NULL;
			}
			else if(session->rtp_termination == mpf_message->termination) {
				session->rtp_termination = NULL;
			}
			mpf_termination_destroy(mpf_message->termination);

			if(!session->file_termination && !session->rtp_termination) {
				mpf_suite_session_destroy(agent,session);
			}
		}
	}
	return mpf_engine_message_send(agent->engine,&task_msg);
}
static apt_bool_t mrcp_server_session_terminate_process(mrcp_server_session_t *session)
{
	mrcp_channel_t *channel;
	mrcp_termination_slot_t *slot;
	int i;
	apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Receive Terminate Request "APT_SID_FMT,MRCP_SESSION_SID(&session->base));

	mrcp_server_session_state_set(session,SESSION_STATE_TERMINATING);

	if(session->context) {
		/* first, destroy existing topology */
		if(mpf_engine_topology_message_add(
					session->profile->media_engine,
					MPF_RESET_ASSOCIATIONS,session->context,
					&session->mpf_task_msg) == TRUE){
			mrcp_server_session_subrequest_add(session);
		}
	}

	for(i=0; i<session->channels->nelts; i++) {
		channel = APR_ARRAY_IDX(session->channels,i,mrcp_channel_t*);
		if(!channel) continue;

		/* send remove channel request */
		apt_log(APT_LOG_MARK,APT_PRIO_DEBUG,"Remove Control Channel [%d]",i);
		if(channel->control_channel) {
			if(mrcp_server_control_channel_remove(channel->control_channel) == TRUE) {
				channel->waiting_for_channel = TRUE;
				mrcp_server_session_subrequest_add(session);
			}
		}

		if(channel->engine_channel) {
			mpf_termination_t *termination = channel->engine_channel->termination;
			/* send subtract termination request */
			if(termination) {
				apt_log(APT_LOG_MARK,APT_PRIO_DEBUG,"Subtract Channel Termination");
				if(mpf_engine_termination_message_add(
							session->profile->media_engine,
							MPF_SUBTRACT_TERMINATION,session->context,termination,NULL,
							&session->mpf_task_msg) == TRUE) {
					channel->waiting_for_termination = TRUE;
					mrcp_server_session_subrequest_add(session);
				}
			}

			/* close engine channel */
			if(mrcp_engine_channel_virtual_close(channel->engine_channel) == TRUE) {
				mrcp_server_session_subrequest_add(session);
			}
		}
	}
	for(i=0; i<session->terminations->nelts; i++) {
		/* get existing termination */
		slot = &APR_ARRAY_IDX(session->terminations,i,mrcp_termination_slot_t);
		if(!slot || !slot->termination) continue;

		/* send subtract termination request */
		apt_log(APT_LOG_MARK,APT_PRIO_DEBUG,"Subtract RTP Termination [%d]",i);
		if(mpf_engine_termination_message_add(
				session->profile->media_engine,
				MPF_SUBTRACT_TERMINATION,session->context,slot->termination,NULL,
				&session->mpf_task_msg) == TRUE) {
			slot->waiting = TRUE;
			mrcp_server_session_subrequest_add(session);
		}
	}

	if(session->context) {
		mpf_engine_message_send(session->profile->media_engine,&session->mpf_task_msg);
	}

	mrcp_server_session_remove(session);

	if(!session->subrequest_count) {
		mrcp_server_session_terminate_send(session);
	}

	return TRUE;
}
static apt_bool_t mrcp_client_session_terminate(mrcp_client_session_t *session)
{
	mrcp_profile_t *profile;
	mrcp_channel_t *channel;
	rtp_termination_slot_t *slot;
	int i;
	
	apt_obj_log(APT_LOG_MARK,APT_PRIO_INFO,session->base.log_obj,"Terminate Session "APT_NAMESID_FMT, 
		MRCP_SESSION_NAMESID(session));
	profile = session->profile;

	mrcp_client_session_state_set(session,SESSION_STATE_TERMINATING);
	if(session->context) {
		/* first destroy existing topology */
		if(mpf_engine_topology_message_add(
					session->profile->media_engine,
					MPF_DESTROY_TOPOLOGY,session->context,
					&session->mpf_task_msg) == TRUE){
			mrcp_client_session_subrequest_add(session);
		}
	}
	/* remove existing control channels */
	for(i=0; i<session->channels->nelts; i++) {
		/* get existing channel */
		channel = APR_ARRAY_IDX(session->channels,i,mrcp_channel_t*);
		if(!channel) continue;

		if(channel->control_channel) {
			/* remove channel */
			apt_obj_log(APT_LOG_MARK,APT_PRIO_DEBUG,session->base.log_obj,"Remove Control Channel "APT_NAMESID_FMT, 
				MRCP_SESSION_NAMESID(session));
			if(mrcp_client_control_channel_remove(channel->control_channel) == TRUE) {
				channel->waiting_for_channel = TRUE;
				mrcp_client_session_subrequest_add(session);
			}
		}

		/* send subtract termination request */
		if(channel->termination) {
			apt_obj_log(APT_LOG_MARK,APT_PRIO_DEBUG,session->base.log_obj,"Subtract Media Termination "APT_NAMESIDRES_FMT, 
				MRCP_SESSION_NAMESID(session),
				mpf_termination_name_get(channel->termination));
			if(mpf_engine_termination_message_add(
					profile->media_engine,
					MPF_SUBTRACT_TERMINATION,session->context,channel->termination,NULL,
					&session->mpf_task_msg) == TRUE) {
				channel->waiting_for_termination = TRUE;
				mrcp_client_session_subrequest_add(session);
			}
		}
	}

	if(session->context) {
		/* subtract existing terminations */
		for(i=0; i<session->terminations->nelts; i++) {
			/* get existing termination */
			slot = &APR_ARRAY_IDX(session->terminations,i,rtp_termination_slot_t);
			if(!slot || !slot->termination) continue;

			/* send subtract termination request */
			apt_obj_log(APT_LOG_MARK,APT_PRIO_DEBUG,session->base.log_obj,"Subtract Media Termination "APT_NAMESIDRES_FMT, 
				MRCP_SESSION_NAMESID(session),
				mpf_termination_name_get(slot->termination));
			if(mpf_engine_termination_message_add(
					profile->media_engine,
					MPF_SUBTRACT_TERMINATION,session->context,slot->termination,NULL,
					&session->mpf_task_msg) == TRUE) {
				slot->waiting = TRUE;
				mrcp_client_session_subrequest_add(session);
			}
		}

		mpf_engine_message_send(profile->media_engine,&session->mpf_task_msg);
	}

	mrcp_client_session_subrequest_add(session);
	mrcp_session_terminate_request(&session->base);
	return TRUE;
}
apt_bool_t mrcp_client_session_answer_process(mrcp_client_session_t *session, mrcp_session_descriptor_t *descriptor)
{
	if(!session->offer) {
		return FALSE;
	}
	if(!descriptor) {
		apt_obj_log(APT_LOG_MARK,APT_PRIO_INFO,session->base.log_obj,"Receive Answer "APT_NAMESID_FMT" [null descriptor]",
			MRCP_SESSION_NAMESID(session));
		session->status = MRCP_SIG_STATUS_CODE_FAILURE;
		/* raise app response */
		return mrcp_app_sig_response_raise(session,TRUE);
	}

	apt_obj_log(APT_LOG_MARK,APT_PRIO_INFO,session->base.log_obj,"Receive Answer "APT_NAMESID_FMT" [c:%d a:%d v:%d] Status %d",
		MRCP_SESSION_NAMESID(session),
		descriptor->control_media_arr->nelts,
		descriptor->audio_media_arr->nelts,
		descriptor->video_media_arr->nelts,
		descriptor->response_code);

	if(descriptor->response_code >=200 && descriptor->response_code < 300) {
		mrcp_client_session_state_set(session,SESSION_STATE_PROCESSING_ANSWER);
		if(session->context) {
			/* first, reset/destroy existing associations and topology */
			if(mpf_engine_topology_message_add(
						session->profile->media_engine,
						MPF_RESET_ASSOCIATIONS,session->context,
						&session->mpf_task_msg) == TRUE){
				mrcp_client_session_subrequest_add(session);
			}
		}

		if(mrcp_session_version_get(session) == MRCP_VERSION_1) {
			if(mrcp_client_resource_answer_process(session,descriptor) != TRUE) {
				session->status = MRCP_SIG_STATUS_CODE_FAILURE;
			}
		}
		else {
			mrcp_client_control_media_answer_process(session,descriptor);
			mrcp_client_av_media_answer_process(session,descriptor);
		}

		if(session->context) {
			/* apply topology based on assigned associations */
			if(mpf_engine_topology_message_add(
						session->profile->media_engine,
						MPF_APPLY_TOPOLOGY,session->context,
						&session->mpf_task_msg) == TRUE) {
				mrcp_client_session_subrequest_add(session);
			}

			mpf_engine_message_send(session->profile->media_engine,&session->mpf_task_msg);
		}
	}
	else {
		session->status = MRCP_SIG_STATUS_CODE_TERMINATE;
	}

	/* store received answer */
	session->answer = descriptor;

	if(!session->subrequest_count) {
		/* raise app response */
		mrcp_app_sig_response_raise(session,TRUE);
	}

	return TRUE;
}