freeswitch mrcp 源码分析--数据包的发送
在MRCP 开始语音识别后会调用recog_channel_start（）函数
static switch_status_t recog_channel_start(speech_channel_t *schannel)
{
switch_status_t status = SWITCH_STATUS_SUCCESS;
switch_hash_index_t *egk;
mrcp_message_t *mrcp_message;
mrcp_recog_header_t *recog_header;
mrcp_generic_header_t *generic_header;
recognizer_data_t *r;
char *start_input_timers;
const char *mime_type;
char *key = NULL;
switch_size_t len;
grammar_t *grammar = NULL;
switch_size_t grammar_uri_count = 0;
switch_size_t grammar_uri_list_len = 0;
char *grammar_uri_list = NULL;
int warned = 0;
switch_mutex_lock(schannel->mutex);
if (schannel->state != SPEECH_CHANNEL_READY) {
status = SWITCH_STATUS_FALSE;
goto done;
}
if (schannel->data == NULL) {
status = SWITCH_STATUS_FALSE;
goto done;
}
r = (recognizer_data_t *) schannel->data;
r->result = NULL;
if (r->result_headers) {
switch_event_destroy(&r->result_headers);
}
r->start_of_input = 0;
/* input timers are started by default unless the start-input-timers=false param is set */
start_input_timers = (char *) switch_core_hash_find(schannel->params, "start-input-timers");
r->timers_started = zstr(start_input_timers) || strcasecmp(start_input_timers, "false");
/* count enabled grammars */
for (egk = switch_core_hash_first(r->enabled_grammars); egk; egk = switch_core_hash_next(&egk)) {
// NOTE: This postponed type check is necessary to allow a non-URI-list grammar to execute alone
if (grammar_uri_count == 1 && grammar->type != GRAMMAR_TYPE_URI)
goto no_grammar_alone;
++grammar_uri_count;
switch_core_hash_this(egk, (void *) &key, NULL, (void *) &grammar);
if (grammar->type != GRAMMAR_TYPE_URI && grammar_uri_count != 1) {
no_grammar_alone:
switch_log_printf(SWITCH_CHANNEL_UUID_LOG(schannel->session_uuid), SWITCH_LOG_ERROR, "(%s) Grammar '%s' can only be used alone (not a URI list)\n", schannel->name, key);
status = SWITCH_STATUS_FALSE;
switch_safe_free(egk);
goto done;
}
len = strlen(grammar->data);
if (!len)
continue;
grammar_uri_list_len += len;
if (grammar->data[len - 1] != '\n')
grammar_uri_list_len += 2;
}
switch (grammar_uri_count) {
case 0:
switch_log_printf(SWITCH_CHANNEL_UUID_LOG(schannel->session_uuid), SWITCH_LOG_ERROR, "(%s) No grammar specified\n", schannel->name);
status = SWITCH_STATUS_FALSE;
goto done;
case 1:
/* grammar should already be the unique grammar */
break;
default:
/* get the enabled grammars list */
grammar_uri_list = switch_core_alloc(schannel->memory_pool, grammar_uri_list_len + 1);
grammar_uri_list_len = 0;
for (egk = switch_core_hash_first(r->enabled_grammars); egk; egk = switch_core_hash_next(&egk)) {
switch_core_hash_this(egk, (void *) &key, NULL, (void *) &grammar);
len = strlen(grammar->data);
if (!len)
continue;
memcpy(&(grammar_uri_list[grammar_uri_list_len]), grammar->data, len);
grammar_uri_list_len += len;
if (grammar_uri_list[grammar_uri_list_len - 1] != '\n')
{
grammar_uri_list_len += 2;
grammar_uri_list[grammar_uri_list_len - 2] = '\r';
grammar_uri_list[grammar_uri_list_len - 1] = '\n';
}
}
grammar_uri_list[grammar_uri_list_len++] = '\0';
grammar = NULL;
}
/* create MRCP message */
mrcp_message = mrcp_application_message_create(schannel->unimrcp_session, schannel->unimrcp_channel, RECOGNIZER_RECOGNIZE);
if (mrcp_message == NULL) {
status = SWITCH_STATUS_FALSE;
goto done;
}
/* allocate generic header */
generic_header = (mrcp_generic_header_t *) mrcp_generic_header_prepare(mrcp_message);
if (generic_header == NULL) {
status = SWITCH_STATUS_FALSE;
goto done;
}
/* set Content-Type */
mime_type = grammar_type_to_mime(grammar ? grammar->type : GRAMMAR_TYPE_URI, schannel->profile);
if (zstr(mime_type)) {
status = SWITCH_STATUS_FALSE;
goto done;
}
apt_string_assign(&generic_header->content_type, mime_type, mrcp_message->pool);
mrcp_generic_header_property_add(mrcp_message, GENERIC_HEADER_CONTENT_TYPE);
/* set Content-ID for inline grammars */
if (grammar && grammar->type != GRAMMAR_TYPE_URI) {
apt_string_assign(&generic_header->content_id, grammar->name, mrcp_message->pool);
mrcp_generic_header_property_add(mrcp_message, GENERIC_HEADER_CONTENT_ID);
}
/* allocate recognizer-specific header */
recog_header = (mrcp_recog_header_t *) mrcp_resource_header_prepare(mrcp_message);
if (recog_header == NULL) {
status = SWITCH_STATUS_FALSE;
goto done;
}
/* set Cancel-If-Queue */
if (mrcp_message->start_line.version == MRCP_VERSION_2) {
recog_header->cancel_if_queue = FALSE;
mrcp_resource_header_property_add(mrcp_message, RECOGNIZER_HEADER_CANCEL_IF_QUEUE);
}
/* set parameters */
recog_channel_set_params(schannel, mrcp_message, generic_header, recog_header);
/* set message body */
apt_string_assign(&mrcp_message->body, grammar ? grammar->data : grammar_uri_list, mrcp_message->pool);
/* Empty audio queue and send RECOGNIZE to MRCP server */
audio_queue_clear(schannel->audio_queue);
if (mrcp_application_message_send(schannel->unimrcp_session, schannel->unimrcp_channel, mrcp_message) == FALSE) {
status = SWITCH_STATUS_FALSE;
goto done;
}
/* wait for IN-PROGRESS */
while (schannel->state == SPEECH_CHANNEL_READY) {
if (switch_thread_cond_timedwait(schannel->cond, schannel->mutex, SPEECH_CHANNEL_TIMEOUT_USEC) == SWITCH_STATUS_TIMEOUT && !warned) {
warned = 1;
switch_log_printf(SWITCH_CHANNEL_UUID_LOG(schannel->session_uuid), SWITCH_LOG_WARNING, "(%s) IN-PROGRESS not received for RECOGNIZE after %d ms.\n", schannel->name, SPEECH_CHANNEL_TIMEOUT_USEC / (1000));
}
}
if (schannel->state != SPEECH_CHANNEL_PROCESSING) {
status = SWITCH_STATUS_FALSE;
goto done;
}
done:
switch_mutex_unlock(schannel->mutex);
return status;
}
这里做了如下几件事情
1.检查grammer的设置情况，然后设置真正的grammer。
2.调用mrcp_application_message_create（）创建一个mrcp_message_t结构体。
3.调用recog_channel_set_params（）设置MRCP的参数，也就是消息的头部信息，包括系统参数和厂商参数。
4.调用apt_string_assign（）设置MRCP的body，从代码可以看到body的值就是grammer的内容。
5.调用mrcp_application_message_send（）将数据发送给MRCP的Server。
下面我们重点分析mrcp_application_message_send（）的实现
MRCP_DECLARE(apt_bool_t) mrcp_application_message_send(mrcp_session_t *session, mrcp_channel_t *channel, mrcp_message_t *message)
{
if(!session || !channel || !message) {
return FALSE;
}
return mrcp_app_control_task_msg_signal(session,channel,message);
}
所以其实调用mrcp_app_control_task_msg_signal（）来处理。
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);
}
return FALSE;
}
这里将数据封装成两个对象:apt_task_t与apt_task_msg_t，（注意这里的apt_task_t是 apt_consumer_task类型对象的base属性），并且设置apt_task_msg_t的type为：MRCP_CLIENT_APPLICATION_TASK_MSG,而他的data指向一个mrcp_app_message_t结构体，这个结构体的message_type为：MRCP_APP_MESSAGE_TYPE_CONTROL。
如此之后就调用apt_task_msg_signal将这个消息任务分发出去。
这个函数的实现我们在前面的两篇文章中已经做了介绍：
freeswitch mrcp 源码分析–数据接收（上）
freeswitch mrcp 源码分析–数据接收（下）
所以，从这里也可以看出，不管是mrcp的消息发送还是接收，都是采用同样的模型：创建一个消息任务，然后加到队列里面，而另一个线程就去处理消费这些消息，并调用对应的函数处理。
与MRCP数据的接收一样，最后会调用mrcp_client_msg_process（）这个函数来处理消息任务：
static apt_bool_t mrcp_client_msg_process(apt_task_t *task, apt_task_msg_t *msg)
{
apt_consumer_task_t *consumer_task = apt_task_object_get(task);
mrcp_client_t *client = apt_consumer_task_object_get(consumer_task);
if(!client) {
return FALSE;
}
switch(msg->type) {
case MRCP_CLIENT_SIGNALING_TASK_MSG:
{
const sig_agent_task_msg_data_t *sig_message = (const sig_agent_task_msg_data_t*)msg->data;
switch(msg->sub_type) {
case SIG_AGENT_TASK_MSG_ANSWER:
mrcp_client_session_answer_process(sig_message->session,sig_message->descriptor);
break;
case SIG_AGENT_TASK_MSG_TERMINATE_RESPONSE:
mrcp_client_session_terminate_response_process(sig_message->session);
break;
case SIG_AGENT_TASK_MSG_CONTROL_RESPONSE:
mrcp_client_session_control_response_process(sig_message->session,sig_message->message);
break;
case SIG_AGENT_TASK_MSG_DISCOVER_RESPONSE:
mrcp_client_session_discover_response_process(sig_message->session,sig_message->descriptor);
break;
case SIG_AGENT_TASK_MSG_TERMINATE_EVENT:
mrcp_client_session_terminate_event_process(sig_message->session);
break;
default:
break;
}
break;
}
case MRCP_CLIENT_CONNECTION_TASK_MSG:
{
const connection_agent_task_msg_data_t *data = (const connection_agent_task_msg_data_t*)msg->data;
switch(msg->sub_type) {
case CONNECTION_AGENT_TASK_MSG_ADD_CHANNEL:
mrcp_client_on_channel_add(data->channel,data->descriptor,data->status);
break;
case CONNECTION_AGENT_TASK_MSG_MODIFY_CHANNEL:
mrcp_client_on_channel_modify(data->channel,data->descriptor,data->status);
break;
case CONNECTION_AGENT_TASK_MSG_REMOVE_CHANNEL:
mrcp_client_on_channel_remove(data->channel,data->status);
break;
case CONNECTION_AGENT_TASK_MSG_RECEIVE_MESSAGE:
mrcp_client_on_message_receive(data->channel,data->message);
break;
case CONNECTION_AGENT_TASK_MSG_DISCONNECT:
mrcp_client_on_disconnect(data->channel);
break;
default:
break;
}
break;
}
case MRCP_CLIENT_MEDIA_TASK_MSG:
{
mpf_message_container_t *container = (mpf_message_container_t*) msg->data;
mrcp_client_mpf_message_process(container);
break;
}
case MRCP_CLIENT_APPLICATION_TASK_MSG:
{
mrcp_app_message_t **app_message = (mrcp_app_message_t**) msg->data;
mrcp_client_app_message_process(*app_message);
break;
}
default:
{
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Unknown Task Message Received [%d;%d]", msg->type,msg->sub_type);
break;
}
}
return TRUE;
}
可以看到这里会依据不同的任务类型，调用不同的函数来处理，这里type为：MRCP_CLIENT_APPLICATION_TASK_MSG，所以会调用mrcp_client_app_message_process（）处理。
这个函数里面主要调用：
mrcp_app_request_dispatch（）将消息分发给各个对应的函数处理。
static apt_bool_t mrcp_app_request_dispatch(mrcp_client_session_t *session, const mrcp_app_message_t *app_message)
{
if(session->state == SESSION_STATE_TERMINATING) {
/* no more requests are allowed, as session is being terminated!
just return, it is horribly wrong and can crash anytime here */
apt_obj_log(APT_LOG_MARK,APT_PRIO_ERROR,session->base.log_obj,"Inappropriate Application Request "APT_NAMESID_FMT" [%d]",
MRCP_SESSION_NAMESID(session),
app_message->sig_message.command_id);
return FALSE;
}
if(session->disconnected == TRUE) {
/* cancel all the requests besides session termination one */
if(!IS_SESSION_TERMINATE(app_message)) {
apt_obj_log(APT_LOG_MARK,APT_PRIO_WARNING,session->base.log_obj,"Cancel App Request "APT_NAMESID_FMT" [%d]",
MRCP_SESSION_NAMESID(session), app_message->sig_message.command_id);
session->status = MRCP_SIG_STATUS_CODE_CANCEL;
return mrcp_app_failure_message_raise(session);
}
}
if(session->registered == FALSE) {
if(IS_SESSION_TERMINATE(app_message)) {
/* if session is not registered, nothing to terminate, just respond with success */
session->status = MRCP_SIG_STATUS_CODE_SUCCESS;
return mrcp_app_sig_response_raise(session,FALSE);
}
/* select signaling agent */
session->base.signaling_agent = mrcp_sa_factory_agent_select(session->profile->sa_factory);
if(!session->base.signaling_agent) {
apt_obj_log(APT_LOG_MARK,APT_PRIO_WARNING,session->base.log_obj,"Failed to Select Signaling Agent "APT_NAMESID_FMT" [%d]",
MRCP_SESSION_NAMESID(session),
app_message->sig_message.command_id);
session->status = MRCP_SIG_STATUS_CODE_FAILURE;
}
if(session->profile->mrcp_version == MRCP_VERSION_2) {
/* select connection agent */
session->base.connection_agent = mrcp_ca_factory_agent_select(session->profile->ca_factory);
if(!session->base.connection_agent) {
apt_obj_log(APT_LOG_MARK,APT_PRIO_WARNING,session->base.log_obj,"Failed to Select Connection Agent "APT_NAMESID_FMT" [%d]",
MRCP_SESSION_NAMESID(session),
app_message->sig_message.command_id);
session->status = MRCP_SIG_STATUS_CODE_FAILURE;
}
}
if(session->profile->mpf_factory) {
/* select media engine */
session->base.media_engine = mpf_engine_factory_engine_select(session->profile->mpf_factory);
if(!session->base.media_engine) {
apt_obj_log(APT_LOG_MARK,APT_PRIO_WARNING,session->base.log_obj,"Failed to Select Media Engine "APT_NAMESID_FMT" [%d]",
MRCP_SESSION_NAMESID(session),
app_message->sig_message.command_id);
session->status = MRCP_SIG_STATUS_CODE_FAILURE;
}
}
/* set rtp termination factory */
session->base.rtp_factory = session->profile->rtp_termination_factory;
if(session->status == MRCP_SIG_STATUS_CODE_FAILURE) {
/* raise app response in case of failure */
return mrcp_app_failure_message_raise(session);
}
if(session->base.signaling_agent->create_client_session(&session->base,session->profile->signaling_settings) != TRUE) {
/* raise app response */
apt_obj_log(APT_LOG_MARK,APT_PRIO_WARNING,session->base.log_obj,"Failed to Create Session "APT_NAMESID_FMT" [%d]",
MRCP_SESSION_NAMESID(session),
app_message->sig_message.command_id);
session->status = MRCP_SIG_STATUS_CODE_FAILURE;
return mrcp_app_failure_message_raise(session);
}
mrcp_client_session_add(session->application->client,session);
session->registered = TRUE;
}
session->status = MRCP_SIG_STATUS_CODE_SUCCESS;
switch(app_message->message_type) {
case MRCP_APP_MESSAGE_TYPE_SIGNALING:
{
apt_obj_log(APT_LOG_MARK,APT_PRIO_DEBUG,session->base.log_obj,"Dispatch App Request "APT_NAMESID_FMT" [%d]",
MRCP_SESSION_NAMESID(session),
app_message->sig_message.command_id);
switch(app_message->sig_message.command_id) {
case MRCP_SIG_COMMAND_SESSION_UPDATE:
mrcp_client_session_update(session);
break;
case MRCP_SIG_COMMAND_SESSION_TERMINATE:
mrcp_client_session_terminate(session);
break;
case MRCP_SIG_COMMAND_CHANNEL_ADD:
mrcp_client_channel_add(session,app_message->channel);
break;
case MRCP_SIG_COMMAND_CHANNEL_REMOVE:
mrcp_client_channel_modify(session,app_message->channel,FALSE);
break;
case MRCP_SIG_COMMAND_RESOURCE_DISCOVER:
mrcp_client_resource_discover(session);
break;
default:
break;
}
break;
}
case MRCP_APP_MESSAGE_TYPE_CONTROL:
{
mrcp_client_message_send(session,app_message->channel,app_message->control_message);
break;
}
}
return TRUE;
}
前面说了message_type为：MRCP_APP_MESSAGE_TYPE_CONTROL，
所以处理函数是：mrcp_client_message_send（）
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;
}
对于MRCP2,显然调用的是：
mrcp_client_control_message_send（）
/** Send MRCPv2 message */
MRCP_DECLARE(apt_bool_t) mrcp_client_control_message_send(mrcp_control_channel_t *channel, mrcp_message_t *message)
{
return mrcp_client_control_message_signal(CONNECTION_TASK_MSG_SEND_MESSAGE,channel->agent,channel,NULL,message);
}
直接调用了：mrcp_client_control_message_signal（）
/** 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_task_t，apt_task_msg_t两个对象，然后又将消费任务放到队列里面去，但是这里有两点需要 注意的：
1.这次的apt_task_t是：apt_poller_task_base_get(agent->task)的方式获取的（注意这里的apt_task_t是 apt_poller_task类型对象的base属性，与前面的不一样），它是在mrcp_client_connection_agent_create中定义的：
agent->task = apt_poller_task_create(
max_connection_count,
mrcp_client_poller_signal_process,
agent,
msg_pool,
pool);
if(!agent->task) {
return NULL;
}
task = apt_poller_task_base_get(agent->task);
if(task) {
apt_task_name_set(task,id);
}
vtable = apt_poller_task_vtable_get(agent->task);
if(vtable) {
vtable->process_msg = mrcp_client_agent_msg_process;
}
2.这次的消息任务的类型为：CONNECTION_TASK_MSG_SEND_MESSAGE。
所以调用的是：mrcp_client_agent_msg_process（），然后会调用：mrcp_client_agent_messsage_send（），在这个函数里面完成真正的工作，组装待发送的字符串，并调用apr_socket_send（）通过socket发送出去。
————————————————
版权声明：本文为CSDN博主「罗自荣」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/luozirong/article/details/79006335