static apt_bool_t mrcp_client_connection_task_msg_signal(
connection_agent_task_msg_type_e type,
mrcp_connection_agent_t *agent,
mrcp_control_channel_t *channel,
mrcp_control_descriptor_t *descriptor,
mrcp_message_t *message,
apt_bool_t status)
{
apt_task_t *task;
apt_task_msg_t *task_msg;
connection_agent_task_msg_data_t *data;
mrcp_client_t *client = mrcp_client_connection_agent_object_get(agent);
if(!client || !client->cnt_msg_pool) {
return FALSE;
}
task = apt_consumer_task_base_get(client->task);
task_msg = apt_task_msg_acquire(client->cnt_msg_pool);
task_msg->type = MRCP_CLIENT_CONNECTION_TASK_MSG;
task_msg->sub_type = type;
data = (connection_agent_task_msg_data_t*) task_msg->data;
data->channel = channel ? channel->obj : NULL;
data->descriptor = descriptor;
data->message = message;
data->status = status;
return apt_task_msg_signal(task,task_msg);
}
static apt_bool_t mrcp_client_mpf_request_send(
mpf_engine_t *engine,
mpf_command_type_e command_id,
mpf_context_t *context,
mpf_termination_t *termination,
void *descriptor)
{
apt_task_t *media_task;
apt_task_msg_t *msg;
mpf_message_t *mpf_message;
if(!engine) {
return FALSE;
}
media_task = mpf_task_get(engine);
msg = apt_task_msg_get(media_task);
msg->type = TASK_MSG_USER;
mpf_message = (mpf_message_t*) msg->data;
mpf_message->message_type = MPF_MESSAGE_TYPE_REQUEST;
mpf_message->command_id = command_id;
mpf_message->context = context;
mpf_message->termination = termination;
mpf_message->descriptor = descriptor;
return apt_task_msg_signal(media_task,msg);
}
MPF_DECLARE(apt_bool_t) mpf_engine_message_send(mpf_engine_t *engine, mpf_task_msg_t **task_msg)
{
apt_bool_t status = FALSE;
if(*task_msg) {
status = apt_task_msg_signal(engine->task,*task_msg);
*task_msg = NULL;
}
return status;
}
void UmcFramework::ShowSessions()
{
apt_task_t* pTask = apt_consumer_task_base_get(m_pTask);
apt_task_msg_t* pTaskMsg = apt_task_msg_get(pTask);
if(!pTaskMsg)
return;
pTaskMsg->type = TASK_MSG_USER;
pTaskMsg->sub_type = UMC_TASK_SHOW_SESSIONS_MSG;
apt_task_msg_signal(pTask,pTaskMsg);
}
void UmcFramework::ExitSession(UmcSession* pUmcSession)
{
apt_task_t* pTask = apt_consumer_task_base_get(m_pTask);
apt_task_msg_t* pTaskMsg = apt_task_msg_get(pTask);
if(!pTaskMsg)
return;
pTaskMsg->type = TASK_MSG_USER;
pTaskMsg->sub_type = UMC_TASK_EXIT_SESSION_MSG;
UmcTaskMsg* pUmcMsg = (UmcTaskMsg*) pTaskMsg->data;
pUmcMsg->m_pSession = pUmcSession;
apt_task_msg_signal(pTask,pTaskMsg);
}
static apt_bool_t consumer_task_test_run(apt_test_suite_t *suite, int argc, const char * const *argv)
{
apt_consumer_task_t *consumer_task;
apt_task_t *task;
apt_task_vtable_t *vtable;
apt_task_msg_pool_t *msg_pool;
apt_task_msg_t *msg;
sample_msg_data_t *data;
int i;
msg_pool = apt_task_msg_pool_create_dynamic(sizeof(sample_msg_data_t),suite->pool);
apt_log(APT_LOG_MARK,APT_PRIO_NOTICE,"Create Consumer Task");
consumer_task = apt_consumer_task_create(NULL,msg_pool,suite->pool);
if(!consumer_task) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Create Consumer Task");
return FALSE;
}
task = apt_consumer_task_base_get(consumer_task);
vtable = apt_task_vtable_get(task);
if(vtable) {
vtable->process_msg = task_msg_process;
vtable->on_start_complete = task_on_start_complete;
vtable->on_terminate_complete = task_on_terminate_complete;
}
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Start Task");
if(apt_task_start(task) == FALSE) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Start Task");
apt_task_destroy(task);
return FALSE;
}
for(i=0; i<10; i++) {
msg = apt_task_msg_acquire(msg_pool);
msg->type = TASK_MSG_USER;
data = (sample_msg_data_t*) msg->data;
data->number = i;
data->timestamp = apr_time_now();
apt_log(APT_LOG_MARK,APT_PRIO_DEBUG,"Signal Message [%d]",data->number);
apt_task_msg_signal(task,msg);
}
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Terminate Task [wait till complete]");
apt_task_terminate(task,TRUE);
apt_log(APT_LOG_MARK,APT_PRIO_NOTICE,"Destroy Task");
apt_task_destroy(task);
return TRUE;
}
void UmcFramework::RunSession(const char* pScenarioName, const char* pProfileName)
{
apt_task_t* pTask = apt_consumer_task_base_get(m_pTask);
apt_task_msg_t* pTaskMsg = apt_task_msg_get(pTask);
if(!pTaskMsg)
return;
pTaskMsg->type = TASK_MSG_USER;
pTaskMsg->sub_type = UMC_TASK_RUN_SESSION_MSG;
UmcTaskMsg* pUmcMsg = (UmcTaskMsg*) pTaskMsg->data;
strncpy(pUmcMsg->m_ScenarioName,pScenarioName,sizeof(pUmcMsg->m_ScenarioName)-1);
strncpy(pUmcMsg->m_ProfileName,pProfileName,sizeof(pUmcMsg->m_ProfileName)-1);
pUmcMsg->m_pAppMessage = NULL;
apt_task_msg_signal(pTask,pTaskMsg);
}
void UmcFramework::KillSession(const char* id)
{
apt_task_t* pTask = apt_consumer_task_base_get(m_pTask);
apt_task_msg_t* pTaskMsg = apt_task_msg_get(pTask);
if(!pTaskMsg)
return;
pTaskMsg->type = TASK_MSG_USER;
pTaskMsg->sub_type = UMC_TASK_KILL_SESSION_MSG;
UmcTaskMsg* pUmcMsg = (UmcTaskMsg*) pTaskMsg->data;
strncpy(pUmcMsg->m_SessionId,id,sizeof(pUmcMsg->m_SessionId)-1);
pUmcMsg->m_pAppMessage = NULL;
apt_task_msg_signal(pTask,pTaskMsg);
}
/** Run demo application */
apt_bool_t demo_framework_app_run(demo_framework_t *framework, const char *app_name, const char *profile_name)
{
apt_task_t *task = apt_consumer_task_base_get(framework->task);
apt_task_msg_t *task_msg = apt_task_msg_get(task);
if(task_msg) {
framework_task_data_t *framework_task_data = (framework_task_data_t*)task_msg->data;
task_msg->type = TASK_MSG_USER;
task_msg->sub_type = DEMO_CONSOLE_MSG_ID;
framework_task_data = (framework_task_data_t*) task_msg->data;
strcpy(framework_task_data->app_name,app_name);
strcpy(framework_task_data->profile_name,profile_name);
framework_task_data->app_message = NULL;
framework_task_data->demo_application = NULL;
apt_task_msg_signal(task,task_msg);
}
return TRUE;
}
/** Signal task message */
static apt_bool_t rtsp_server_control_message_signal(
task_msg_data_type_e type,
rtsp_server_t *server,
rtsp_server_session_t *session,
rtsp_message_t *message)
{
apt_task_t *task = apt_poller_task_base_get(server->task);
apt_task_msg_t *task_msg = apt_task_msg_get(task);
if(task_msg) {
task_msg_data_t *data = (task_msg_data_t*)task_msg->data;
data->type = type;
data->server = server;
data->session = session;
data->message = message;
apt_task_msg_signal(task,task_msg);
}
return TRUE;
}
/** Signal task message */
static apt_bool_t rtsp_client_control_message_signal(
task_msg_data_type_e type,
rtsp_client_t *client,
rtsp_client_session_t *session,
rtsp_message_t *message)
{
apt_task_t *task = apt_net_client_task_base_get(client->task);
apt_task_msg_t *task_msg = apt_task_msg_get(task);
if(task_msg) {
task_msg_data_t *data = (task_msg_data_t*)task_msg->data;
data->type = type;
data->client = client;
data->session = session;
data->message = message;
apt_task_msg_signal(task,task_msg);
}
return TRUE;
}
static apt_bool_t demo_verifier_msg_signal(demo_verifier_msg_type_e type, mrcp_engine_channel_t *channel, mrcp_message_t *request)
{
apt_bool_t status = FALSE;
demo_verifier_channel_t *demo_channel = channel->method_obj;
demo_verifier_engine_t *demo_engine = demo_channel->demo_engine;
apt_task_t *task = apt_consumer_task_base_get(demo_engine->task);
apt_task_msg_t *msg = apt_task_msg_get(task);
if(msg) {
demo_verifier_msg_t *demo_msg;
msg->type = TASK_MSG_USER;
demo_msg = (demo_verifier_msg_t*) msg->data;
demo_msg->type = type;
demo_msg->channel = channel;
demo_msg->request = request;
status = apt_task_msg_signal(task,msg);
}
return status;
}
static apt_bool_t mrcp_server_engine_task_msg_signal(
engine_task_msg_type_e type,
mrcp_engine_t *engine,
apt_bool_t status)
{
mrcp_server_t *server = engine->event_obj;
apt_task_t *task = apt_consumer_task_base_get(server->task);
engine_task_msg_data_t *data;
apt_task_msg_t *task_msg = apt_task_msg_acquire(server->engine_msg_pool);
task_msg->type = MRCP_SERVER_ENGINE_TASK_MSG;
task_msg->sub_type = type;
data = (engine_task_msg_data_t*) task_msg->data;
data->engine = engine;
data->channel = NULL;
data->status = status;
data->mrcp_message = NULL;
return apt_task_msg_signal(task,task_msg);
}
apt_bool_t mrcp_app_control_task_msg_signal(mrcp_session_t *session, mrcp_channel_t *channel, mrcp_message_t *message)
{
mrcp_client_session_t *client_session = (mrcp_client_session_t*)session;
mrcp_application_t *application = client_session->application;
apt_task_t *task = apt_consumer_task_base_get(application->client->task);
apt_task_msg_t *task_msg = apt_task_msg_acquire(application->msg_pool);
if(task_msg) {
mrcp_app_message_t **slot = ((mrcp_app_message_t**)task_msg->data);
mrcp_app_message_t *app_message;
task_msg->type = MRCP_CLIENT_APPLICATION_TASK_MSG;
app_message = mrcp_client_app_control_message_create(session->pool);
app_message->application = client_session->application;
app_message->session = session;
app_message->channel = channel;
app_message->control_message = message;
*slot = app_message;
}
return apt_task_msg_signal(task,task_msg);
}
/** Signal task message */
static apt_bool_t mrcp_client_control_message_signal(
connection_task_msg_type_e type,
mrcp_connection_agent_t *agent,
mrcp_control_channel_t *channel,
mrcp_control_descriptor_t *descriptor,
mrcp_message_t *message)
{
apt_task_t *task = apt_poller_task_base_get(agent->task);
apt_task_msg_t *task_msg = apt_task_msg_get(task);
if(task_msg) {
connection_task_msg_t *msg = (connection_task_msg_t*)task_msg->data;
msg->type = type;
msg->agent = agent;
msg->channel = channel;
msg->descriptor = descriptor;
msg->message = message;
apt_task_msg_signal(task,task_msg);
}
return TRUE;
}
apt_bool_t AppMessageHandler(const mrcp_app_message_t* pMessage)
{
UmcFramework* pFramework = (UmcFramework*) mrcp_application_object_get(pMessage->application);
if(!pFramework)
return FALSE;
apt_task_t* pTask = apt_consumer_task_base_get(pFramework->m_pTask);
apt_task_msg_t* pTaskMsg = apt_task_msg_get(pTask);
if(pTaskMsg)
{
pTaskMsg->type = TASK_MSG_USER;
pTaskMsg->sub_type = UMC_TASK_CLIENT_MSG;
UmcTaskMsg* pUmcMsg = (UmcTaskMsg*) pTaskMsg->data;
pUmcMsg->m_pAppMessage = pMessage;
apt_task_msg_signal(pTask,pTaskMsg);
}
return TRUE;
}
static apt_bool_t mrcp_client_connection_task_msg_signal(
connection_agent_task_msg_type_e type,
mrcp_connection_agent_t *agent,
mrcp_control_channel_t *channel,
mrcp_control_descriptor_t *descriptor,
mrcp_message_t *message)
{
mrcp_client_t *client = mrcp_client_connection_agent_object_get(agent);
apt_task_t *task = apt_consumer_task_base_get(client->task);
connection_agent_task_msg_data_t *data;
apt_task_msg_t *task_msg = apt_task_msg_acquire(client->cnt_msg_pool);
task_msg->type = MRCP_CLIENT_CONNECTION_TASK_MSG;
task_msg->sub_type = type;
data = (connection_agent_task_msg_data_t*) task_msg->data;
data->channel = channel ? channel->obj : NULL;
data->descriptor = descriptor;
data->message = message;
apt_log(APT_PRIO_DEBUG,"Signal Connection Task Message");
return apt_task_msg_signal(task,task_msg);
}
static apt_bool_t mrcp_server_channel_task_msg_signal(
engine_task_msg_type_e type,
mrcp_engine_channel_t *engine_channel,
apt_bool_t status,
mrcp_message_t *message)
{
mrcp_channel_t *channel = engine_channel->event_obj;
mrcp_session_t *session = mrcp_server_channel_session_get(channel);
mrcp_server_t *server = session->signaling_agent->parent;
apt_task_t *task = apt_consumer_task_base_get(server->task);
engine_task_msg_data_t *data;
apt_task_msg_t *task_msg = apt_task_msg_acquire(server->engine_msg_pool);
task_msg->type = MRCP_SERVER_ENGINE_TASK_MSG;
task_msg->sub_type = type;
data = (engine_task_msg_data_t*) task_msg->data;
data->engine = engine_channel->engine;
data->channel = channel;
data->status = status;
data->mrcp_message = message;
return apt_task_msg_signal(task,task_msg);
}
static apt_bool_t mrcp_server_engine_task_msg_signal(
resource_engine_task_msg_type_e type,
mrcp_engine_channel_t *engine_channel,
apt_bool_t status,
mrcp_message_t *message)
{
mrcp_channel_t *channel = engine_channel->event_obj;
mrcp_session_t *session = mrcp_server_channel_session_get(channel);
mrcp_server_t *server = session->signaling_agent->parent;
apt_task_t *task = apt_consumer_task_base_get(server->task);
resource_engine_task_msg_data_t *data;
apt_task_msg_t *task_msg = apt_task_msg_acquire(server->resource_engine_msg_pool);
task_msg->type = MRCP_SERVER_RESOURCE_ENGINE_TASK_MSG;
task_msg->sub_type = type;
data = (resource_engine_task_msg_data_t*) task_msg->data;
data->channel = channel;
data->status = status;
data->mrcp_message = message;
apt_log(APT_LOG_MARK,APT_PRIO_DEBUG,"Signal Resource Engine Task Message");
return apt_task_msg_signal(task,task_msg);
}
static apt_bool_t mrcp_app_control_task_msg_signal(mrcp_session_t *session, mrcp_channel_t *channel, mrcp_message_t *message)
{
mrcp_client_session_t *client_session = (mrcp_client_session_t*)session;
mrcp_application_t *application = client_session->application;
apt_task_t *task = apt_consumer_task_base_get(application->client->task);
apt_task_msg_t *task_msg = apt_task_msg_acquire(application->msg_pool);
if(task_msg) {
mrcp_app_message_t **slot = ((mrcp_app_message_t**)task_msg->data);
mrcp_app_message_t *app_message;
task_msg->type = MRCP_CLIENT_APPLICATION_TASK_MSG;
app_message = apr_palloc(session->pool,sizeof(mrcp_app_message_t));
app_message->message_type = MRCP_APP_MESSAGE_TYPE_CONTROL;
app_message->application = client_session->application;
app_message->session = session;
app_message->channel = channel;
app_message->control_message = message;
*slot = app_message;
}
apt_log(APT_PRIO_DEBUG,"Signal Application Task Message");
return apt_task_msg_signal(task,task_msg);
}
static apt_bool_t mrcp_server_connection_task_msg_signal(
connection_agent_task_msg_type_e type,
mrcp_connection_agent_t *agent,
mrcp_control_channel_t *channel,
mrcp_control_descriptor_t *descriptor,
mrcp_message_t *message,
apt_bool_t status)
{
mrcp_server_t *server = mrcp_server_connection_agent_object_get(agent);
apt_task_t *task = apt_consumer_task_base_get(server->task);
connection_agent_task_msg_data_t *data;
apt_task_msg_t *task_msg = apt_task_msg_acquire(server->connection_msg_pool);
task_msg->type = MRCP_SERVER_CONNECTION_TASK_MSG;
task_msg->sub_type = type;
data = (connection_agent_task_msg_data_t*) task_msg->data;
data->channel = channel ? channel->obj : NULL;
data->descriptor = descriptor;
data->message = message;
data->status = status;
return apt_task_msg_signal(task,task_msg);
}
/** Callback is called from MRCP client stack (task) context.
* Signal app_message to the main consumer task of the demo framework
* for further processing (see demo_framework_msg_process).
*/
static apt_bool_t demo_framework_message_handler(const mrcp_app_message_t *app_message)
{
demo_application_t *demo_application;
if(!app_message->application) {
return FALSE;
}
demo_application = mrcp_application_object_get(app_message->application);
if(demo_application && demo_application->framework) {
demo_framework_t *framework = demo_application->framework;
apt_task_t *task = apt_consumer_task_base_get(framework->task);
apt_task_msg_t *task_msg = apt_task_msg_get(task);
if(task_msg) {
framework_task_data_t *framework_task_data = (framework_task_data_t*)task_msg->data;
task_msg->type = TASK_MSG_USER;
task_msg->sub_type = DEMO_APPLICATION_MSG_ID;
framework_task_data = (framework_task_data_t*) task_msg->data;
framework_task_data->app_message = app_message;
framework_task_data->demo_application = demo_application;
apt_task_msg_signal(task,task_msg);
}
}
return TRUE;
}
/** Process task messages */
static apt_bool_t mpf_suite_msg_process(apt_task_t *task, apt_task_msg_t *msg)
{
const mpf_message_t *mpf_message = (const mpf_message_t*) msg->data;
if(mpf_message->message_type == MPF_MESSAGE_TYPE_RESPONSE) {
apt_log(APT_PRIO_DEBUG,"Process MPF Response");
if(mpf_message->command_id == MPF_COMMAND_ADD) {
apt_log(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->termination2 == mpf_message->termination && session->rtp_mode == TRUE) {
apt_task_msg_t *msg;
mpf_message_t *request;
apt_task_t *consumer_task;
mpf_suite_engine_t *suite_engine;
consumer_task = apt_task_object_get(task);
suite_engine = apt_task_object_get(consumer_task);
msg = apt_task_msg_get(task);
msg->type = TASK_MSG_USER;
request = (mpf_message_t*) msg->data;
request->message_type = MPF_MESSAGE_TYPE_REQUEST;
request->command_id = MPF_COMMAND_MODIFY;
request->context = session->context;
request->termination = session->termination2;
request->descriptor = mpf_rtp_remote_descriptor_create(session);
apt_task_msg_signal(suite_engine->engine_task,msg);
}
}
}
else if(mpf_message->command_id == MPF_COMMAND_SUBTRACT) {
apt_log(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->termination1 == mpf_message->termination) {
session->termination1 = NULL;
}
if(session->termination2 == mpf_message->termination) {
session->termination2 = NULL;
}
mpf_termination_destroy(mpf_message->termination);
if(!session->termination1 && !session->termination2) {
apt_task_t *consumer_task;
mpf_suite_engine_t *suite_engine;
mpf_context_destroy(session->context);
session->context = NULL;
apr_pool_destroy(session->pool);
consumer_task = apt_task_object_get(task);
suite_engine = apt_task_object_get(consumer_task);
apr_thread_mutex_lock(suite_engine->wait_object_mutex);
apr_thread_cond_signal(suite_engine->wait_object);
apr_thread_mutex_unlock(suite_engine->wait_object_mutex);
}
}
}
}
else if(mpf_message->message_type == MPF_MESSAGE_TYPE_EVENT) {
apt_task_t *consumer_task;
mpf_suite_engine_t *suite_engine;
apt_task_msg_t *msg;
mpf_message_t *request;
mpf_suite_session_t *session;
apt_log(APT_PRIO_DEBUG,"Process MPF Event");
if(mpf_message->termination) {
session = mpf_termination_object_get(mpf_message->termination);
if(session->termination1) {
apt_log(APT_PRIO_INFO,"Subtract Termination [1]");
msg = apt_task_msg_get(task);
msg->type = TASK_MSG_USER;
request = (mpf_message_t*) msg->data;
request->message_type = MPF_MESSAGE_TYPE_REQUEST;
request->command_id = MPF_COMMAND_SUBTRACT;
request->context = session->context;
request->termination = session->termination1;
consumer_task = apt_task_object_get(task);
suite_engine = apt_task_object_get(consumer_task);
apt_task_msg_signal(suite_engine->engine_task,msg);
}
if(session->termination2) {
apt_log(APT_PRIO_INFO,"Subtract Termination [2]");
msg = apt_task_msg_get(task);
msg->type = TASK_MSG_USER;
request = (mpf_message_t*) msg->data;
request->message_type = MPF_MESSAGE_TYPE_REQUEST;
request->command_id = MPF_COMMAND_SUBTRACT;
request->context = session->context;
request->termination = session->termination2;
consumer_task = apt_task_object_get(task);
suite_engine = apt_task_object_get(consumer_task);
apt_task_msg_signal(suite_engine->engine_task,msg);
}
}
}
return TRUE;
}
/** Start execution of MPF test suite scenario */
static void mpf_suite_on_start_complete(apt_task_t *task)
{
mpf_suite_session_t *session;
apt_task_t *consumer_task;
mpf_suite_engine_t *suite_engine;
apt_task_msg_t *msg;
mpf_message_t *mpf_message;
apr_pool_t *pool = NULL;
consumer_task = apt_task_object_get(task);
suite_engine = apt_task_object_get(consumer_task);
apt_log(APT_PRIO_INFO,"On MPF Suite Start");
apr_pool_create(&pool,NULL);
session = apr_palloc(pool,sizeof(mpf_suite_session_t));
session->pool = pool;
session->context = NULL;
session->termination1 = NULL;
session->termination2 = NULL;
session->rtp_mode = TRUE;
apt_log(APT_PRIO_INFO,"Create MPF Context");
session->context = mpf_context_create(session,2,pool);
apt_log(APT_PRIO_INFO,"Create Termination [1]");
session->termination1 = mpf_termination_create(suite_engine->file_termination_factory,session,session->pool);
apt_log(APT_PRIO_INFO,"Add Termination [1]");
msg = apt_task_msg_get(task);
msg->type = TASK_MSG_USER;
mpf_message = (mpf_message_t*) msg->data;
mpf_message->message_type = MPF_MESSAGE_TYPE_REQUEST;
mpf_message->command_id = MPF_COMMAND_ADD;
mpf_message->context = session->context;
mpf_message->termination = session->termination1;
mpf_message->descriptor = mpf_file_reader_descriptor_create(session);
apt_task_msg_signal(suite_engine->engine_task,msg);
apt_log(APT_PRIO_INFO,"Create Termination [2]");
if(session->rtp_mode == TRUE) {
session->termination2 = mpf_termination_create(suite_engine->rtp_termination_factory,session,session->pool);
}
else {
session->termination2 = mpf_termination_create(suite_engine->file_termination_factory,session,session->pool);
}
apt_log(APT_PRIO_INFO,"Add Termination [2]");
msg = apt_task_msg_get(task);
msg->type = TASK_MSG_USER;
mpf_message = (mpf_message_t*) msg->data;
mpf_message->message_type = MPF_MESSAGE_TYPE_REQUEST;
mpf_message->command_id = MPF_COMMAND_ADD;
mpf_message->context = session->context;
mpf_message->termination = session->termination2;
if(session->rtp_mode == TRUE) {
mpf_message->descriptor = mpf_rtp_local_descriptor_create(session);
}
else {
mpf_message->descriptor = mpf_file_writer_descriptor_create(session);
}
apt_task_msg_signal(suite_engine->engine_task,msg);
}
