/** Handle the responses sent to channel add requests */
static apt_bool_t synth_application_on_channel_add(mrcp_application_t *application, mrcp_session_t *session, mrcp_channel_t *channel, mrcp_sig_status_code_e status)
{
synth_app_channel_t *synth_channel = mrcp_application_channel_object_get(channel);
if(status == MRCP_SIG_STATUS_CODE_SUCCESS) {
mrcp_message_t *mrcp_message;
const apt_dir_layout_t *dir_layout = mrcp_application_dir_layout_get(application);
/* create and send SPEAK request */
mrcp_message = demo_speak_message_create(session,channel,dir_layout);
if(mrcp_message) {
mrcp_application_message_send(session,channel,mrcp_message);
}
if(synth_channel && session) {
char *file_name = apr_pstrcat(session->pool,"synth-",session->id.buf,".pcm",NULL);
char *file_path = apt_datadir_filepath_get(dir_layout,file_name,session->pool);
if(file_path) {
synth_channel->audio_out = fopen(file_path,"wb");
}
}
}
else {
/* error case, just terminate the demo */
mrcp_application_session_terminate(session);
}
return TRUE;
}
/** \brief Received channel add response */
static apt_bool_t on_channel_add(mrcp_application_t *application, mrcp_session_t *session, mrcp_channel_t *channel, mrcp_sig_status_code_e status)
{
uni_speech_t *uni_speech = mrcp_application_channel_object_get(channel);
ast_log(LOG_DEBUG, "(%s) Channel added status: %d\n",uni_speech->name, status);
return uni_recog_sm_response_signal(uni_speech,MRCP_SIG_COMMAND_CHANNEL_ADD,status);
}
bool SynthSession::OnChannelAdd(mrcp_channel_t* pMrcpChannel, mrcp_sig_status_code_e status)
{
if(!UmcSession::OnChannelAdd(pMrcpChannel,status))
return false;
const mpf_codec_descriptor_t* pDescriptor = mrcp_application_sink_descriptor_get(pMrcpChannel);
if(!pDescriptor)
{
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Get Media Sink Descriptor");
return Terminate();
}
SynthChannel* pSynthChannel = (SynthChannel*) mrcp_application_channel_object_get(pMrcpChannel);
if(status != MRCP_SIG_STATUS_CODE_SUCCESS)
{
/* error case, just terminate the demo */
return Terminate();
}
/* create MRCP message */
mrcp_message_t* pMrcpMessage = CreateSpeakRequest(pMrcpChannel);
if(pMrcpMessage)
{
SendMrcpRequest(pSynthChannel->m_pMrcpChannel,pMrcpMessage);
}
pSynthChannel->m_pAudioOut = GetAudioOut(pDescriptor,GetSessionPool());
return true;
}
/** \brief Received channel remove response */
static apt_bool_t on_channel_remove(mrcp_application_t *application, mrcp_session_t *session, mrcp_channel_t *channel, mrcp_sig_status_code_e status)
{
uni_speech_t *uni_speech = mrcp_application_channel_object_get(channel);
ast_log(LOG_DEBUG, "On channel remove\n");
return uni_recog_sm_response_signal(uni_speech,MRCP_SIG_COMMAND_CHANNEL_REMOVE,status);
}
/** Handle the DEFINE-GRAMMAR responses */
static apt_bool_t recog_application_on_define_grammar(mrcp_application_t *application, mrcp_session_t *session, mrcp_channel_t *channel)
{
recog_app_channel_t *recog_channel = mrcp_application_channel_object_get(channel);
mrcp_message_t *mrcp_message;
const apt_dir_layout_t *dir_layout = mrcp_application_dir_layout_get(application);
/* create and send RECOGNIZE request */
mrcp_message = demo_recognize_message_create(session,channel,dir_layout);
if(mrcp_message) {
mrcp_application_message_send(session,channel,mrcp_message);
}
if(recog_channel) {
const mpf_codec_descriptor_t *descriptor = mrcp_application_source_descriptor_get(channel);
char *file_name = apr_psprintf(session->pool,"one-%dkHz.pcm",
descriptor ? descriptor->sampling_rate/1000 : 8);
char *file_path = apt_datadir_filepath_get(dir_layout,file_name,session->pool);
if(file_path) {
recog_channel->audio_in = fopen(file_path,"rb");
if(recog_channel->audio_in) {
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Set [%s] as Speech Source",file_path);
}
else {
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Cannot Find [%s]",file_path);
/* set some estimated time to complete */
recog_channel->time_to_complete = 5000; // 5 sec
}
}
}
return TRUE;
}
/* Handle the UniMRCP responses sent to channel remove requests. */
static apt_bool_t speech_on_channel_remove(mrcp_application_t *application, mrcp_session_t *session, mrcp_channel_t *channel, mrcp_sig_status_code_e status)
{
speech_channel_t *schannel;
if (channel != NULL)
schannel = (speech_channel_t *)mrcp_application_channel_object_get(channel);
else
schannel = NULL;
ast_log(LOG_DEBUG, "(%s) speech_on_channel_remove\n", schannel->name);
if (schannel != NULL) {
ast_log(LOG_NOTICE, "(%s) Channel removed\n", schannel->name);
schannel->unimrcp_channel = NULL;
if (session != NULL) {
ast_log(LOG_DEBUG, "(%s) Terminating MRCP session\n", schannel->name);
if (!mrcp_application_session_terminate(session))
ast_log(LOG_WARNING, "(%s) Unable to terminate application session\n", schannel->name);
}
} else
ast_log(LOG_ERROR, "(unknown) channel error!\n");
return TRUE;
}
/** \brief Received MRCP message */
static apt_bool_t on_message_receive(mrcp_application_t *application, mrcp_session_t *session, mrcp_channel_t *channel, mrcp_message_t *message)
{
uni_speech_t *uni_speech = mrcp_application_channel_object_get(channel);
ast_log(LOG_DEBUG, "On message receive\n");
if(message->start_line.message_type == MRCP_MESSAGE_TYPE_RESPONSE) {
return uni_recog_mrcp_response_signal(uni_speech,message);
}
if(message->start_line.message_type == MRCP_MESSAGE_TYPE_EVENT) {
if(message->start_line.method_id == RECOGNIZER_RECOGNITION_COMPLETE) {
uni_speech->is_inprogress = FALSE;
if (uni_speech->speech_base->state != AST_SPEECH_STATE_NOT_READY) {
uni_speech->mrcp_event = message;
ast_speech_change_state(uni_speech->speech_base,AST_SPEECH_STATE_DONE);
}
else {
uni_speech->mrcp_event = NULL;
ast_speech_change_state(uni_speech->speech_base,AST_SPEECH_STATE_NOT_READY);
}
}
else if(message->start_line.method_id == RECOGNIZER_START_OF_INPUT) {
ast_set_flag(uni_speech->speech_base,AST_SPEECH_QUIET);
}
}
return TRUE;
}
bool VerifierSession::StartVerification(mrcp_channel_t* pMrcpChannel)
{
const mpf_codec_descriptor_t* pDescriptor = mrcp_application_source_descriptor_get(pMrcpChannel);
if(!pDescriptor)
{
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Get Media Source Descriptor");
return Terminate();
}
VerifierChannel* pVerifierChannel = (VerifierChannel*) mrcp_application_channel_object_get(pMrcpChannel);
/* create and send Verification request */
mrcp_message_t* pMrcpMessage = CreateStartSessionRequest(pMrcpChannel);
if(pMrcpMessage)
{
SendMrcpRequest(pVerifierChannel->m_pMrcpChannel,pMrcpMessage);
}
pVerifierChannel->m_pAudioIn = GetAudioIn(pDescriptor,GetSessionPool());
if(!pVerifierChannel->m_pAudioIn)
{
/* no audio input availble, set some estimated time to complete instead */
pVerifierChannel->m_TimeToComplete = 5000; // 5 sec
}
return true;
}
bool SynthSession::OnMessageReceive(mrcp_channel_t* pMrcpChannel, mrcp_message_t* pMrcpMessage)
{
if(!UmcSession::OnMessageReceive(pMrcpChannel,pMrcpMessage))
return false;
if(pMrcpMessage->start_line.message_type == MRCP_MESSAGE_TYPE_RESPONSE)
{
/* received MRCP response */
if(pMrcpMessage->start_line.method_id == SYNTHESIZER_SPEAK)
{
/* received the response to SPEAK request */
if(pMrcpMessage->start_line.request_state == MRCP_REQUEST_STATE_INPROGRESS)
{
SynthChannel* pSynthChannel = (SynthChannel*) mrcp_application_channel_object_get(pMrcpChannel);
if(pSynthChannel)
pSynthChannel->m_pSpeakRequest = GetMrcpMessage();
/* waiting for SPEAK-COMPLETE event */
}
else
{
/* received unexpected response, terminate the session */
Terminate();
}
}
else
{
/* received unexpected response */
}
}
else if(pMrcpMessage->start_line.message_type == MRCP_MESSAGE_TYPE_EVENT)
{
/* received MRCP event */
if(pMrcpMessage->start_line.method_id == SYNTHESIZER_SPEAK_COMPLETE)
{
SynthChannel* pSynthChannel = (SynthChannel*) mrcp_application_channel_object_get(pMrcpChannel);
if(pSynthChannel)
pSynthChannel->m_pSpeakRequest = NULL;
/* received SPEAK-COMPLETE event, terminate the session */
Terminate();
}
}
return true;
}
bool DtmfSession::OnMessageReceive(mrcp_channel_t* pMrcpChannel, mrcp_message_t* pMrcpMessage)
{
if(!UmcSession::OnMessageReceive(pMrcpChannel,pMrcpMessage))
return false;
const DtmfScenario* pScenario = GetScenario();
RecogChannel* pRecogChannel = (RecogChannel*) mrcp_application_channel_object_get(pMrcpChannel);
if(pMrcpMessage->start_line.message_type == MRCP_MESSAGE_TYPE_RESPONSE)
{
if(pMrcpMessage->start_line.method_id == RECOGNIZER_RECOGNIZE)
{
/* received the response to RECOGNIZE request */
if(pMrcpMessage->start_line.request_state == MRCP_REQUEST_STATE_INPROGRESS)
{
/* start to stream the DTMFs to recognize */
if(pRecogChannel && pRecogChannel->m_pDtmfGenerator)
{
const char* digits = pScenario->GetDigits();
if(digits)
{
mpf_dtmf_generator_enqueue(pRecogChannel->m_pDtmfGenerator,digits);
pRecogChannel->m_Streaming = true;
}
}
}
else
{
/* received unexpected response, terminate the session */
Terminate();
}
}
else
{
/* received unexpected response */
}
}
else if(pMrcpMessage->start_line.message_type == MRCP_MESSAGE_TYPE_EVENT)
{
if(pMrcpMessage->start_line.method_id == RECOGNIZER_RECOGNITION_COMPLETE)
{
ParseNLSMLResult(pMrcpMessage);
if(pRecogChannel)
{
pRecogChannel->m_Streaming = false;
}
Terminate();
}
else if(pMrcpMessage->start_line.method_id == RECOGNIZER_START_OF_INPUT)
{
/* received start-of-input, do whatever you need here */
}
}
return true;
}
bool DtmfSession::StartRecognition(mrcp_channel_t* pMrcpChannel)
{
RecogChannel* pRecogChannel = (RecogChannel*) mrcp_application_channel_object_get(pMrcpChannel);
/* create and send RECOGNIZE request */
mrcp_message_t* pMrcpMessage = CreateRecognizeRequest(pMrcpChannel);
if(pMrcpMessage)
{
SendMrcpRequest(pRecogChannel->m_pMrcpChannel,pMrcpMessage);
}
return true;
}
/* Handle the UniMRCP responses sent to channel add requests. */
static apt_bool_t speech_on_channel_add(mrcp_application_t *application, mrcp_session_t *session, mrcp_channel_t *channel, mrcp_sig_status_code_e status)
{
speech_channel_t *schannel;
if (channel != NULL)
schannel = (speech_channel_t *)mrcp_application_channel_object_get(channel);
else
schannel = NULL;
ast_log(LOG_DEBUG, "(%s) speech_on_channel_add\n", schannel->name);
if ((schannel != NULL) && (application != NULL) && (session != NULL) && (channel != NULL)) {
if ((session != NULL) && (status == MRCP_SIG_STATUS_CODE_SUCCESS)) {
const mpf_codec_descriptor_t *descriptor = descriptor = mrcp_application_sink_descriptor_get(channel);
if (!descriptor) {
ast_log(LOG_ERROR, "(%s) Unable to determine codec descriptor\n", schannel->name);
speech_channel_set_state(schannel, SPEECH_CHANNEL_ERROR);
ast_log(LOG_DEBUG, "(%s) Terminating MRCP session\n", schannel->name);
if (!mrcp_application_session_terminate(session))
ast_log(LOG_WARNING, "(%s) Unable to terminate application session\n", schannel->name);
return FALSE;
}
schannel->rate = descriptor->sampling_rate;
const char *codec_name = NULL;
if (descriptor->name.length > 0)
codec_name = descriptor->name.buf;
else
codec_name = "unknown";
ast_log(LOG_NOTICE, "(%s) Channel ready, codec=%s, sample rate=%d\n",
schannel->name,
codec_name,
schannel->rate);
speech_channel_set_state(schannel, SPEECH_CHANNEL_READY);
} else {
ast_log(LOG_ERROR, "(%s) Channel error!\n", schannel->name);
if (session != NULL) {
ast_log(LOG_DEBUG, "(%s) Terminating MRCP session\n", schannel->name);
speech_channel_set_state(schannel, SPEECH_CHANNEL_ERROR);
if (!mrcp_application_session_terminate(session))
ast_log(LOG_WARNING, "(%s) Unable to terminate application session\n", schannel->name);
}
}
} else
ast_log(LOG_ERROR, "(unknown) channel error!\n");
return TRUE;
}
bool RecorderSession::StartRecorder(mrcp_channel_t* pMrcpChannel)
{
RecorderChannel* pRecorderChannel = (RecorderChannel*) mrcp_application_channel_object_get(pMrcpChannel);
/* create and send RECORD request */
mrcp_message_t* pMrcpMessage = CreateRecordRequest(pMrcpChannel);
if(pMrcpMessage)
{
SendMrcpRequest(pRecorderChannel->m_pMrcpChannel,pMrcpMessage);
}
const mpf_codec_descriptor_t* pDescriptor = mrcp_application_source_descriptor_get(pMrcpChannel);
pRecorderChannel->m_pAudioIn = GetAudioIn(pDescriptor,GetSessionPool());
return true;
}
bool RecorderSession::OnMessageReceive(mrcp_channel_t* pMrcpChannel, mrcp_message_t* pMrcpMessage)
{
if(!UmcSession::OnMessageReceive(pMrcpChannel,pMrcpMessage))
return false;
RecorderChannel* pRecorderChannel = (RecorderChannel*) mrcp_application_channel_object_get(pMrcpChannel);
if(pMrcpMessage->start_line.message_type == MRCP_MESSAGE_TYPE_RESPONSE)
{
/* received MRCP response */
if(pMrcpMessage->start_line.method_id == RECORDER_RECORD)
{
/* received the response to RECORD request */
if(pMrcpMessage->start_line.request_state == MRCP_REQUEST_STATE_INPROGRESS)
{
/* start to stream the speech to record */
if(pRecorderChannel)
{
pRecorderChannel->m_Streaming = true;
}
}
else
{
/* received unexpected response, terminate the session */
Terminate();
}
}
else
{
/* received unexpected response */
}
}
else if(pMrcpMessage->start_line.message_type == MRCP_MESSAGE_TYPE_EVENT)
{
if(pMrcpMessage->start_line.method_id == RECORDER_RECORD_COMPLETE)
{
if(pRecorderChannel)
{
pRecorderChannel->m_Streaming = false;
}
Terminate();
}
else if(pMrcpMessage->start_line.method_id == RECORDER_START_OF_INPUT)
{
/* received start-of-input, do whatever you need here */
}
}
return true;
}
static apt_bool_t recog_application_on_channel_remove(mrcp_application_t *application, mrcp_session_t *session, mrcp_channel_t *channel, mrcp_sig_status_code_e status)
{
recog_app_channel_t *recog_channel = mrcp_application_channel_object_get(channel);
/* terminate the demo */
mrcp_application_session_terminate(session);
if(recog_channel) {
FILE *audio_in = recog_channel->audio_in;
if(audio_in) {
recog_channel->audio_in = NULL;
fclose(audio_in);
}
}
return TRUE;
}
/** Handle the responses sent to channel remove requests */
static apt_bool_t synth_application_on_channel_remove(mrcp_application_t *application, mrcp_session_t *session, mrcp_channel_t *channel, mrcp_sig_status_code_e status)
{
synth_app_channel_t *synth_channel = mrcp_application_channel_object_get(channel);
/* terminate the demo */
mrcp_application_session_terminate(session);
if(synth_channel) {
FILE *audio_out = synth_channel->audio_out;
if(audio_out) {
synth_channel->audio_out = NULL;
fclose(audio_out);
}
}
return TRUE;
}
static apt_bool_t recog_application_on_message_receive(mrcp_application_t *application, mrcp_session_t *session, mrcp_channel_t *channel, mrcp_message_t *message)
{
recog_app_channel_t *recog_channel = mrcp_application_channel_object_get(channel);
if(message->start_line.message_type == MRCP_MESSAGE_TYPE_RESPONSE) {
/* received MRCP response */
if(message->start_line.method_id == RECOGNIZER_DEFINE_GRAMMAR) {
/* received the response to DEFINE-GRAMMAR request */
if(message->start_line.request_state == MRCP_REQUEST_STATE_COMPLETE) {
recog_application_on_define_grammar(application,session,channel);
}
else {
/* received unexpected response, remove channel */
mrcp_application_channel_remove(session,channel);
}
}
else if(message->start_line.method_id == RECOGNIZER_RECOGNIZE) {
/* received the response to RECOGNIZE request */
if(message->start_line.request_state == MRCP_REQUEST_STATE_INPROGRESS) {
/* start to stream the speech to recognize */
if(recog_channel) {
recog_channel->streaming = TRUE;
}
}
else {
/* received unexpected response, remove channel */
mrcp_application_channel_remove(session,channel);
}
}
else {
/* received unexpected response */
}
}
else if(message->start_line.message_type == MRCP_MESSAGE_TYPE_EVENT) {
if(message->start_line.method_id == RECOGNIZER_RECOGNITION_COMPLETE) {
demo_nlsml_result_parse(message);
if(recog_channel) {
recog_channel->streaming = FALSE;
}
mrcp_application_channel_remove(session,channel);
}
else if(message->start_line.method_id == RECOGNIZER_START_OF_INPUT) {
/* received start-of-input, do whatever you need here */
}
}
return TRUE;
}
bool RecogSession::StartRecognition(mrcp_channel_t* pMrcpChannel)
{
RecogChannel* pRecogChannel = (RecogChannel*) mrcp_application_channel_object_get(pMrcpChannel);
/* create and send RECOGNIZE request */
mrcp_message_t* pMrcpMessage = CreateRecognizeRequest(pMrcpChannel);
if(pMrcpMessage)
{
SendMrcpRequest(pRecogChannel->m_pMrcpChannel,pMrcpMessage);
}
const mpf_codec_descriptor_t* pDescriptor = mrcp_application_source_descriptor_get(pMrcpChannel);
pRecogChannel->m_pAudioIn = GetAudioIn(pDescriptor,GetSessionPool());
if(!pRecogChannel->m_pAudioIn)
{
/* no audio input availble, set some estimated time to complete instead */
pRecogChannel->m_TimeToComplete = 5000; // 5 sec
}
return true;
}
bool RecorderSession::StartRecorder(mrcp_channel_t* pMrcpChannel)
{
const mpf_codec_descriptor_t* pDescriptor = mrcp_application_source_descriptor_get(pMrcpChannel);
if(!pDescriptor)
{
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Get Media Source Descriptor");
return Terminate();
}
RecorderChannel* pRecorderChannel = (RecorderChannel*) mrcp_application_channel_object_get(pMrcpChannel);
/* create and send RECORD request */
mrcp_message_t* pMrcpMessage = CreateRecordRequest(pMrcpChannel);
if(pMrcpMessage)
{
SendMrcpRequest(pRecorderChannel->m_pMrcpChannel,pMrcpMessage);
}
pRecorderChannel->m_pAudioIn = GetAudioIn(pDescriptor,GetSessionPool());
return true;
}
/** \brief Received MRCP message */
static apt_bool_t on_message_receive(mrcp_application_t *application, mrcp_session_t *session, mrcp_channel_t *channel, mrcp_message_t *message)
{
uni_speech_t *uni_speech = mrcp_application_channel_object_get(channel);
if(message->start_line.message_type == MRCP_MESSAGE_TYPE_RESPONSE) {
ast_log(LOG_DEBUG, "(%s) Received MRCP response method-id: %d status-code: %d req-state: %d\n",
uni_speech->name,
(int)message->start_line.method_id,
message->start_line.status_code,
(int)message->start_line.request_state);
return uni_recog_mrcp_response_signal(uni_speech,message);
}
if(message->start_line.message_type == MRCP_MESSAGE_TYPE_EVENT) {
if(message->start_line.method_id == RECOGNIZER_RECOGNITION_COMPLETE) {
ast_log(LOG_DEBUG, "(%s) Recognition complete req-state: %d\n",
uni_speech->name,
(int)message->start_line.request_state);
uni_speech->is_inprogress = FALSE;
if (uni_speech->speech_base->state != AST_SPEECH_STATE_NOT_READY) {
uni_speech->mrcp_event = message;
ast_speech_change_state(uni_speech->speech_base,AST_SPEECH_STATE_DONE);
}
else {
ast_log(LOG_DEBUG, "(%s) Unexpected RECOGNITION-COMPLETE event\n",uni_speech->name);
}
}
else if(message->start_line.method_id == RECOGNIZER_START_OF_INPUT) {
ast_log(LOG_DEBUG, "(%s) Start of input\n",uni_speech->name);
ast_set_flag(uni_speech->speech_base, AST_SPEECH_QUIET | AST_SPEECH_SPOKE);
}
else {
ast_log(LOG_DEBUG, "(%s) Received unhandled MRCP event id: %d req-state: %d\n",
uni_speech->name,
(int)message->start_line.method_id,
(int)message->start_line.request_state);
}
}
return TRUE;
}
bool DtmfSession::OnChannelAdd(mrcp_channel_t* pMrcpChannel, mrcp_sig_status_code_e status)
{
if(!UmcSession::OnChannelAdd(pMrcpChannel,status))
return false;
if(status != MRCP_SIG_STATUS_CODE_SUCCESS)
{
/* error case, just terminate the demo */
return Terminate();
}
RecogChannel* pRecogChannel = (RecogChannel*) mrcp_application_channel_object_get(pMrcpChannel);
if(pRecogChannel)
{
const mpf_audio_stream_t* pStream = mrcp_application_audio_stream_get(pMrcpChannel);
if(pStream)
{
pRecogChannel->m_pDtmfGenerator = mpf_dtmf_generator_create(pStream,GetSessionPool());
}
}
return StartRecognition(pMrcpChannel);
}
/** Handle the responses sent to channel add requests */
static apt_bool_t synth_application_on_channel_add(mrcp_application_t *application, mrcp_session_t *session, mrcp_channel_t *channel, mrcp_sig_status_code_e status)
{
if(status == MRCP_SIG_STATUS_CODE_SUCCESS) {
mrcp_message_t *mrcp_message;
synth_app_channel_t *synth_channel = mrcp_application_channel_object_get(channel);
apr_pool_t *pool = mrcp_application_session_pool_get(session);
const apt_dir_layout_t *dir_layout = mrcp_application_dir_layout_get(application);
const mpf_codec_descriptor_t *descriptor = mrcp_application_sink_descriptor_get(channel);
if(!descriptor) {
/* terminate the demo */
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Get Media Sink Descriptor");
return mrcp_application_session_terminate(session);
}
/* create and send SPEAK request */
mrcp_message = demo_speak_message_create(session,channel,dir_layout);
if(mrcp_message) {
mrcp_application_message_send(session,channel,mrcp_message);
}
if(synth_channel) {
const apt_str_t *id = mrcp_application_session_id_get(session);
char *file_name = apr_psprintf(pool,"synth-%dkHz-%s.pcm",
descriptor->sampling_rate/1000,
id->buf);
char *file_path = apt_datadir_filepath_get(dir_layout,file_name,pool);
if(file_path) {
synth_channel->audio_out = fopen(file_path,"wb");
}
}
}
else {
/* error case, just terminate the demo */
mrcp_application_session_terminate(session);
}
return TRUE;
}
/** \brief Received unexpected session/channel termination event */
static apt_bool_t on_terminate_event(mrcp_application_t *application, mrcp_session_t *session, mrcp_channel_t *channel)
{
uni_speech_t *uni_speech = mrcp_application_channel_object_get(channel);
ast_log(LOG_WARNING, "(%s) Received unexpected session termination event\n",uni_speech->name);
return TRUE;
}
/* Handle the MRCP synthesizer responses/events from UniMRCP. */
static apt_bool_t synth_on_message_receive(mrcp_application_t *application, mrcp_session_t *session, mrcp_channel_t *channel, mrcp_message_t *message)
{
speech_channel_t *schannel;
if (channel != NULL)
schannel = (speech_channel_t *)mrcp_application_channel_object_get(channel);
else
schannel = NULL;
if ((schannel != NULL) && (application != NULL) && (session != NULL) && (channel != NULL) && (message != NULL)) {
if (message->start_line.message_type == MRCP_MESSAGE_TYPE_RESPONSE) {
/* Received MRCP response. */
if (message->start_line.method_id == SYNTHESIZER_SPEAK) {
/* received the response to SPEAK request */
if (message->start_line.request_state == MRCP_REQUEST_STATE_INPROGRESS) {
/* Waiting for SPEAK-COMPLETE event. */
ast_log(LOG_DEBUG, "(%s) REQUEST IN PROGRESS\n", schannel->name);
speech_channel_set_state(schannel, SPEECH_CHANNEL_PROCESSING);
} else {
/* Received unexpected request_state. */
ast_log(LOG_DEBUG, "(%s) Unexpected SPEAK response, request_state = %d\n", schannel->name, message->start_line.request_state);
speech_channel_set_state(schannel, SPEECH_CHANNEL_ERROR);
}
} else if (message->start_line.method_id == SYNTHESIZER_STOP) {
/* Received response to the STOP request. */
if (message->start_line.request_state == MRCP_REQUEST_STATE_COMPLETE) {
/* Got COMPLETE. */
ast_log(LOG_DEBUG, "(%s) COMPLETE\n", schannel->name);
speech_channel_set_state(schannel, SPEECH_CHANNEL_READY);
} else {
/* Received unexpected request state. */
ast_log(LOG_DEBUG, "(%s) Unexpected STOP response, request_state = %d\n", schannel->name, message->start_line.request_state);
speech_channel_set_state(schannel, SPEECH_CHANNEL_ERROR);
}
} else if (message->start_line.method_id == SYNTHESIZER_BARGE_IN_OCCURRED) {
/* Received response to the BARGE_IN_OCCURRED request. */
if (message->start_line.request_state == MRCP_REQUEST_STATE_COMPLETE) {
/* Got COMPLETE. */
ast_log(LOG_DEBUG, "(%s) COMPLETE\n", schannel->name);
speech_channel_set_state(schannel, SPEECH_CHANNEL_READY);
} else {
/* Received unexpected request state. */
ast_log(LOG_DEBUG, "(%s) Unexpected BARGE-IN-OCCURRED response, request_state = %d\n", schannel->name, message->start_line.request_state);
speech_channel_set_state(schannel, SPEECH_CHANNEL_ERROR);
}
} else {
/* Received unexpected response. */
ast_log(LOG_DEBUG, "(%s) Unexpected response, method_id = %d\n", schannel->name, (int)message->start_line.method_id);
speech_channel_set_state(schannel, SPEECH_CHANNEL_ERROR);
}
} else if (message->start_line.message_type == MRCP_MESSAGE_TYPE_EVENT) {
/* Received MRCP event. */
if (message->start_line.method_id == SYNTHESIZER_SPEAK_COMPLETE) {
/* Got SPEAK-COMPLETE. */
ast_log(LOG_DEBUG, "(%s) SPEAK-COMPLETE\n", schannel->name);
speech_channel_set_state(schannel, SPEECH_CHANNEL_READY);
} else {
ast_log(LOG_DEBUG, "(%s) Unexpected event, method_id = %d\n", schannel->name, (int)message->start_line.method_id);
speech_channel_set_state(schannel, SPEECH_CHANNEL_ERROR);
}
} else {
ast_log(LOG_DEBUG, "(%s) Unexpected message type, message_type = %d\n", schannel->name, message->start_line.message_type);
speech_channel_set_state(schannel, SPEECH_CHANNEL_ERROR);
}
} else
ast_log(LOG_ERROR, "(unknown) channel error!\n");
return TRUE;
}
bool RecogSession::OnMessageReceive(mrcp_channel_t* pMrcpChannel, mrcp_message_t* pMrcpMessage)
{
if(!UmcSession::OnMessageReceive(pMrcpChannel,pMrcpMessage))
return false;
RecogChannel* pRecogChannel = (RecogChannel*) mrcp_application_channel_object_get(pMrcpChannel);
if(pMrcpMessage->start_line.message_type == MRCP_MESSAGE_TYPE_RESPONSE)
{
/* received MRCP response */
if(pMrcpMessage->start_line.method_id == RECOGNIZER_DEFINE_GRAMMAR)
{
/* received the response to DEFINE-GRAMMAR request */
if(pMrcpMessage->start_line.request_state == MRCP_REQUEST_STATE_COMPLETE)
{
OnDefineGrammar(pMrcpChannel);
}
else
{
/* received unexpected response, terminate the session */
Terminate();
}
}
else if(pMrcpMessage->start_line.method_id == RECOGNIZER_RECOGNIZE)
{
/* received the response to RECOGNIZE request */
if(pMrcpMessage->start_line.request_state == MRCP_REQUEST_STATE_INPROGRESS)
{
RecogChannel* pRecogChannel = (RecogChannel*) mrcp_application_channel_object_get(pMrcpChannel);
if(pRecogChannel)
pRecogChannel->m_pRecogRequest = GetMrcpMessage();
/* start to stream the speech to recognize */
if(pRecogChannel)
pRecogChannel->m_Streaming = true;
}
else
{
/* received unexpected response, terminate the session */
Terminate();
}
}
else
{
/* received unexpected response */
}
}
else if(pMrcpMessage->start_line.message_type == MRCP_MESSAGE_TYPE_EVENT)
{
if(pMrcpMessage->start_line.method_id == RECOGNIZER_RECOGNITION_COMPLETE)
{
ParseNLSMLResult(pMrcpMessage);
if(pRecogChannel)
pRecogChannel->m_Streaming = false;
RecogChannel* pRecogChannel = (RecogChannel*) mrcp_application_channel_object_get(pMrcpChannel);
if(pRecogChannel)
pRecogChannel->m_pRecogRequest = NULL;
Terminate();
}
else if(pMrcpMessage->start_line.method_id == RECOGNIZER_START_OF_INPUT)
{
/* received start-of-input, do whatever you need here */
}
}
return true;
}
bool VerifierSession::OnMessageReceive(mrcp_channel_t* pMrcpChannel, mrcp_message_t* pMrcpMessage)
{
if(!UmcSession::OnMessageReceive(pMrcpChannel,pMrcpMessage))
return false;
VerifierChannel* pVerifierChannel = (VerifierChannel*) mrcp_application_channel_object_get(pMrcpChannel);
if(pMrcpMessage->start_line.message_type == MRCP_MESSAGE_TYPE_RESPONSE)
{
/* received MRCP response */
if(pMrcpMessage->start_line.method_id == VERIFIER_START_SESSION)
{
/* received the response to START-SESSION request */
/* create and send VERIFY request */
mrcp_message_t* pMrcpMessage = CreateVerificationRequest(pMrcpChannel);
if(pMrcpMessage)
{
SendMrcpRequest(pVerifierChannel->m_pMrcpChannel,pMrcpMessage);
}
}
else if(pMrcpMessage->start_line.method_id == VERIFIER_END_SESSION)
{
/* received the response to END-SESSION request */
Terminate();
}
else if(pMrcpMessage->start_line.method_id == VERIFIER_VERIFY)
{
/* received the response to VERIFY request */
if(pMrcpMessage->start_line.request_state == MRCP_REQUEST_STATE_INPROGRESS)
{
VerifierChannel* pVerifierChannel = (VerifierChannel*) mrcp_application_channel_object_get(pMrcpChannel);
if(pVerifierChannel)
pVerifierChannel->m_pVerificationRequest = GetMrcpMessage();
/* start to stream the speech to Verify */
if(pVerifierChannel)
pVerifierChannel->m_Streaming = true;
}
else
{
/* create and send END-SESSION request */
mrcp_message_t* pMrcpMessage = CreateEndSessionRequest(pMrcpChannel);
if(pMrcpMessage)
{
SendMrcpRequest(pVerifierChannel->m_pMrcpChannel,pMrcpMessage);
}
}
}
else
{
/* received unexpected response */
}
}
else if(pMrcpMessage->start_line.message_type == MRCP_MESSAGE_TYPE_EVENT)
{
if(pMrcpMessage->start_line.method_id == VERIFIER_VERIFICATION_COMPLETE)
{
if(pVerifierChannel)
pVerifierChannel->m_Streaming = false;
VerifierChannel* pVerifierChannel = (VerifierChannel*) mrcp_application_channel_object_get(pMrcpChannel);
if(pVerifierChannel)
pVerifierChannel->m_pVerificationRequest = NULL;
/* create and send END-SESSION request */
mrcp_message_t* pMrcpMessage = CreateEndSessionRequest(pMrcpChannel);
if(pVerifierChannel && pMrcpMessage)
{
SendMrcpRequest(pVerifierChannel->m_pMrcpChannel,pMrcpMessage);
}
}
else if(pMrcpMessage->start_line.method_id == VERIFIER_START_OF_INPUT)
{
/* received start-of-input, do whatever you need here */
}
}
return true;
}
