/** Create demo MRCP message (SPEAK request) */
mrcp_message_t* demo_speak_message_create(mrcp_session_t *session, mrcp_channel_t *channel, const apt_dir_layout_t *dir_layout)
{
/* create MRCP message */
mrcp_message_t *mrcp_message = mrcp_application_message_create(session,channel,SYNTHESIZER_SPEAK);
if(mrcp_message) {
mrcp_generic_header_t *generic_header;
mrcp_synth_header_t *synth_header;
/* get/allocate generic header */
generic_header = mrcp_generic_header_prepare(mrcp_message);
if(generic_header) {
/* set generic header fields */
apt_string_assign(&generic_header->content_type,"application/synthesis+ssml",mrcp_message->pool);
mrcp_generic_header_property_add(mrcp_message,GENERIC_HEADER_CONTENT_TYPE);
}
/* get/allocate synthesizer header */
synth_header = mrcp_resource_header_prepare(mrcp_message);
if(synth_header) {
/* set synthesizer header fields */
synth_header->voice_param.age = 28;
mrcp_resource_header_property_add(mrcp_message,SYNTHESIZER_HEADER_VOICE_AGE);
}
/* set message body */
demo_message_body_set(mrcp_message,dir_layout,"speak.xml");
}
return mrcp_message;
}
/** Raise SPEAK-COMPLETE event */
static apt_bool_t synth_speak_complete_raise(mrcp_swift_channel_t *synth_channel)
{
mrcp_message_t *message;
mrcp_synth_header_t *synth_header;
if(!synth_channel->speak_request) {
return FALSE;
}
message = mrcp_event_create(
synth_channel->speak_request,
SYNTHESIZER_SPEAK_COMPLETE,
synth_channel->speak_request->pool);
if(!message) {
return FALSE;
}
/* get/allocate synthesizer header */
synth_header = mrcp_resource_header_prepare(message);
if(synth_header) {
/* set completion cause */
synth_header->completion_cause = SYNTHESIZER_COMPLETION_CAUSE_NORMAL;
mrcp_resource_header_property_add(message,SYNTHESIZER_HEADER_COMPLETION_CAUSE);
}
/* set request state */
message->start_line.request_state = MRCP_REQUEST_STATE_COMPLETE;
synth_channel->speak_request = NULL;
/* send asynch event */
return mrcp_engine_channel_message_send(synth_channel->channel,message);
}
mrcp_message_t* DtmfSession::CreateRecognizeRequest(mrcp_channel_t* pMrcpChannel)
{
mrcp_message_t* pMrcpMessage = CreateMrcpMessage(pMrcpChannel,RECOGNIZER_RECOGNIZE);
if(!pMrcpMessage)
return NULL;
const DtmfScenario* pScenario = GetScenario();
mrcp_generic_header_t* pGenericHeader;
mrcp_recog_header_t* pRecogHeader;
/* get/allocate generic header */
pGenericHeader = (mrcp_generic_header_t*) mrcp_generic_header_prepare(pMrcpMessage);
if(pGenericHeader)
{
apt_string_assign(&pGenericHeader->content_type,pScenario->GetContentType(),pMrcpMessage->pool);
mrcp_generic_header_property_add(pMrcpMessage,GENERIC_HEADER_CONTENT_TYPE);
/* set message body */
if(pScenario->GetGrammar())
apt_string_assign(&pMrcpMessage->body,pScenario->GetGrammar(),pMrcpMessage->pool);
}
/* get/allocate recognizer header */
pRecogHeader = (mrcp_recog_header_t*) mrcp_resource_header_prepare(pMrcpMessage);
if(pRecogHeader)
{
/* set recognizer header fields */
if(pMrcpMessage->start_line.version == MRCP_VERSION_2)
{
pRecogHeader->cancel_if_queue = FALSE;
mrcp_resource_header_property_add(pMrcpMessage,RECOGNIZER_HEADER_CANCEL_IF_QUEUE);
}
}
return pMrcpMessage;
}
mrcp_message_t* SynthSession::CreateSpeakRequest(mrcp_channel_t* pMrcpChannel)
{
mrcp_message_t* pMrcpMessage = CreateMrcpMessage(pMrcpChannel,SYNTHESIZER_SPEAK);
if(!pMrcpMessage)
return NULL;
const SynthScenario* pScenario = GetScenario();
mrcp_generic_header_t* pGenericHeader;
mrcp_synth_header_t* pSynthHeader;
/* get/allocate generic header */
pGenericHeader = (mrcp_generic_header_t*) mrcp_generic_header_prepare(pMrcpMessage);
if(pGenericHeader)
{
/* set generic header fields */
apt_string_assign(&pGenericHeader->content_type,pScenario->GetContentType(),pMrcpMessage->pool);
mrcp_generic_header_property_add(pMrcpMessage,GENERIC_HEADER_CONTENT_TYPE);
/* set message body */
if(pScenario->GetContent())
apt_string_assign(&pMrcpMessage->body,pScenario->GetContent(),pMrcpMessage->pool);
}
/* get/allocate synthesizer header */
pSynthHeader = (mrcp_synth_header_t*) mrcp_resource_header_prepare(pMrcpMessage);
if(pSynthHeader)
{
/* set synthesizer header fields */
pSynthHeader->voice_param.age = 28;
mrcp_resource_header_property_add(pMrcpMessage,SYNTHESIZER_HEADER_VOICE_AGE);
}
return pMrcpMessage;
}
mrcp_message_t* VerifierSession::CreateStartSessionRequest(mrcp_channel_t* pMrcpChannel)
{
mrcp_message_t* pMrcpMessage = CreateMrcpMessage(pMrcpChannel,VERIFIER_START_SESSION);
if(!pMrcpMessage)
return NULL;
mrcp_verifier_header_t* pVerifierHeader;
/* get/allocate verifier header */
pVerifierHeader = (mrcp_verifier_header_t*) mrcp_resource_header_prepare(pMrcpMessage);
if(pVerifierHeader)
{
const VerifierScenario* pScenario = GetScenario();
const char* pRepositoryURI = pScenario->GetRepositoryURI();
if(pRepositoryURI)
{
apt_string_set(&pVerifierHeader->repository_uri,pRepositoryURI);
mrcp_resource_header_property_add(pMrcpMessage,VERIFIER_HEADER_REPOSITORY_URI);
}
const char* pVoiceprintIdentifier = pScenario->GetVoiceprintIdentifier();
if(pVoiceprintIdentifier)
{
apt_string_set(&pVerifierHeader->voiceprint_identifier,pVoiceprintIdentifier);
mrcp_resource_header_property_add(pMrcpMessage,VERIFIER_HEADER_VOICEPRINT_IDENTIFIER);
}
const char* pVerificationMode = pScenario->GetVerificationMode();
if(pVerificationMode)
{
apt_string_set(&pVerifierHeader->verification_mode,pVerificationMode);
mrcp_resource_header_property_add(pMrcpMessage,VERIFIER_HEADER_VERIFICATION_MODE);
}
}
return pMrcpMessage;
}
/* Create SPEAK request */
static mrcp_message_t* speak_request_create(mrcp_resource_factory_t *factory, apr_pool_t *pool)
{
mrcp_message_t *message;
mrcp_resource_t *resource = mrcp_resource_get(factory,MRCP_SYNTHESIZER_RESOURCE);
if(!resource) {
return NULL;
}
apt_log(APT_LOG_MARK,APT_PRIO_NOTICE,"Create SPEAK Request");
message = mrcp_request_create(resource,MRCP_VERSION_2,SYNTHESIZER_SPEAK,pool);
if(message) {
mrcp_generic_header_t *generic_header;
mrcp_synth_header_t *synth_header;
/* get/allocate generic header */
generic_header = mrcp_generic_header_prepare(message);
if(generic_header) {
/* set generic header fields */
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Set Content-Type: %s",SAMPLE_CONTENT_TYPE);
apt_string_assign(&generic_header->content_type,SAMPLE_CONTENT_TYPE,message->pool);
mrcp_generic_header_property_add(message,GENERIC_HEADER_CONTENT_TYPE);
}
/* get/allocate synthesizer header */
synth_header = mrcp_resource_header_prepare(message);
if(synth_header) {
/* set synthesizer header fields */
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Set Voice-Age: %d",SAMPLE_VOICE_AGE);
synth_header->voice_param.age = SAMPLE_VOICE_AGE;
mrcp_resource_header_property_add(message,SYNTHESIZER_HEADER_VOICE_AGE);
}
/* set message body */
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Set Body: %s",SAMPLE_CONTENT);
apt_string_assign(&message->body,SAMPLE_CONTENT,message->pool);
}
return message;
}
/* Raise demo RECOGNITION-COMPLETE event */
static apt_bool_t demo_recog_recognition_complete(demo_recog_channel_t *recog_channel, mrcp_recog_completion_cause_e cause)
{
mrcp_recog_header_t *recog_header;
/* create RECOGNITION-COMPLETE event */
mrcp_message_t *message = mrcp_event_create(
recog_channel->recog_request,
RECOGNIZER_RECOGNITION_COMPLETE,
recog_channel->recog_request->pool);
if(!message) {
return FALSE;
}
/* get/allocate recognizer header */
recog_header = mrcp_resource_header_prepare(message);
if(recog_header) {
/* set completion cause */
recog_header->completion_cause = cause;
mrcp_resource_header_property_add(message,RECOGNIZER_HEADER_COMPLETION_CAUSE);
}
/* set request state */
message->start_line.request_state = MRCP_REQUEST_STATE_COMPLETE;
if(cause == RECOGNIZER_COMPLETION_CAUSE_SUCCESS) {
demo_recog_result_load(recog_channel,message);
}
recog_channel->recog_request = NULL;
/* send asynch event */
return mrcp_engine_channel_message_send(recog_channel->channel,message);
}
/* Raise RECORD-COMPLETE event */
static apt_bool_t recorder_record_complete(recorder_channel_t *recorder_channel, mrcp_recorder_completion_cause_e cause)
{
mrcp_recorder_header_t *recorder_header;
/* create RECORD-COMPLETE event */
mrcp_message_t *message = mrcp_event_create(
recorder_channel->record_request,
RECORDER_RECORD_COMPLETE,
recorder_channel->record_request->pool);
if(!message) {
return FALSE;
}
if(recorder_channel->audio_out) {
fclose(recorder_channel->audio_out);
recorder_channel->audio_out = NULL;
}
/* get/allocate recorder header */
recorder_header = mrcp_resource_header_prepare(message);
if(recorder_header) {
/* set completion cause */
recorder_header->completion_cause = cause;
mrcp_resource_header_property_add(message,RECORDER_HEADER_COMPLETION_CAUSE);
}
/* set record-uri */
recorder_channel_uri_set(recorder_channel,message);
/* set request state */
message->start_line.request_state = MRCP_REQUEST_STATE_COMPLETE;
recorder_channel->record_request = NULL;
/* send asynch event */
return mrcp_engine_channel_message_send(recorder_channel->channel,message);
}
mrcp_message_t* SetParamSession::CreateSetParams1(mrcp_channel_t* pMrcpChannel)
{
mrcp_message_t* pMrcpMessage = CreateMrcpMessage(pMrcpChannel,RECOGNIZER_SET_PARAMS);
if(!pMrcpMessage)
return NULL;
mrcp_recog_header_t* pRecogHeader;
/* get/allocate recog header */
pRecogHeader = (mrcp_recog_header_t*) mrcp_resource_header_prepare(pMrcpMessage);
if(pRecogHeader)
{
/* set recog header fields */
pRecogHeader->confidence_threshold = 0.4f;
mrcp_resource_header_property_add(pMrcpMessage,RECOGNIZER_HEADER_CONFIDENCE_THRESHOLD);
pRecogHeader->sensitivity_level = 0.531f;
mrcp_resource_header_property_add(pMrcpMessage,RECOGNIZER_HEADER_SENSITIVITY_LEVEL);
pRecogHeader->speed_vs_accuracy = 0.5f;
mrcp_resource_header_property_add(pMrcpMessage,RECOGNIZER_HEADER_SPEED_VS_ACCURACY);
pRecogHeader->n_best_list_length = 5;
mrcp_resource_header_property_add(pMrcpMessage,RECOGNIZER_HEADER_N_BEST_LIST_LENGTH);
pRecogHeader->no_input_timeout = 5000;
mrcp_resource_header_property_add(pMrcpMessage,RECOGNIZER_HEADER_NO_INPUT_TIMEOUT);
}
return pMrcpMessage;
}
/* Raise demo VERIFICATION-COMPLETE event */
static apt_bool_t demo_verifier_verification_complete(demo_verifier_channel_t *verifier_channel, mrcp_verifier_completion_cause_e cause)
{
mrcp_verifier_header_t *verifier_header;
/* create VERIFICATION-COMPLETE event */
mrcp_message_t *message = mrcp_event_create(
verifier_channel->verifier_request,
VERIFIER_VERIFICATION_COMPLETE,
verifier_channel->verifier_request->pool);
if(!message) {
return FALSE;
}
/* get/allocate verifier header */
verifier_header = mrcp_resource_header_prepare(message);
if(verifier_header) {
/* set completion cause */
verifier_header->completion_cause = cause;
mrcp_resource_header_property_add(message,VERIFIER_HEADER_COMPLETION_CAUSE);
}
/* set request state */
message->start_line.request_state = MRCP_REQUEST_STATE_COMPLETE;
if(cause == VERIFIER_COMPLETION_CAUSE_SUCCESS) {
demo_verifier_result_load(verifier_channel,message);
}
verifier_channel->verifier_request = NULL;
/* send asynch event */
return mrcp_engine_channel_message_send(verifier_channel->channel,message);
}
mrcp_message_t* RecogSession::CreateRecognizeRequest(mrcp_channel_t* pMrcpChannel)
{
mrcp_message_t* pMrcpMessage = CreateMrcpMessage(pMrcpChannel,RECOGNIZER_RECOGNIZE);
if(!pMrcpMessage)
return NULL;
const RecogScenario* pScenario = GetScenario();
mrcp_generic_header_t* pGenericHeader;
mrcp_recog_header_t* pRecogHeader;
/* get/allocate generic header */
pGenericHeader = (mrcp_generic_header_t*) mrcp_generic_header_prepare(pMrcpMessage);
if(pGenericHeader)
{
/* set generic header fields */
if(pScenario->IsDefineGrammarEnabled())
{
apt_string_assign(&pGenericHeader->content_type,"text/uri-list",pMrcpMessage->pool);
/* set message body */
const char* pContent = apr_pstrcat(pMrcpMessage->pool,"session:",m_ContentId,NULL);
apt_string_set(&pMrcpMessage->body,pContent);
}
else
{
apt_string_assign(&pGenericHeader->content_type,pScenario->GetContentType(),pMrcpMessage->pool);
/* set content-id */
apt_string_assign(&pGenericHeader->content_id,m_ContentId,pMrcpMessage->pool);
mrcp_generic_header_property_add(pMrcpMessage,GENERIC_HEADER_CONTENT_ID);
/* set message body */
if(pScenario->GetContent())
apt_string_assign_n(&pMrcpMessage->body,pScenario->GetContent(),pScenario->GetContentLength(),pMrcpMessage->pool);
}
mrcp_generic_header_property_add(pMrcpMessage,GENERIC_HEADER_CONTENT_TYPE);
}
/* get/allocate recognizer header */
pRecogHeader = (mrcp_recog_header_t*) mrcp_resource_header_prepare(pMrcpMessage);
if(pRecogHeader)
{
/* set recognizer header fields */
if(pMrcpMessage->start_line.version == MRCP_VERSION_2)
{
pRecogHeader->cancel_if_queue = FALSE;
mrcp_resource_header_property_add(pMrcpMessage,RECOGNIZER_HEADER_CANCEL_IF_QUEUE);
}
pRecogHeader->no_input_timeout = 5000;
mrcp_resource_header_property_add(pMrcpMessage,RECOGNIZER_HEADER_NO_INPUT_TIMEOUT);
pRecogHeader->recognition_timeout = 10000;
mrcp_resource_header_property_add(pMrcpMessage,RECOGNIZER_HEADER_RECOGNITION_TIMEOUT);
pRecogHeader->start_input_timers = TRUE;
mrcp_resource_header_property_add(pMrcpMessage,RECOGNIZER_HEADER_START_INPUT_TIMERS);
pRecogHeader->confidence_threshold = 0.87f;
mrcp_resource_header_property_add(pMrcpMessage,RECOGNIZER_HEADER_CONFIDENCE_THRESHOLD);
pRecogHeader->save_waveform = TRUE;
mrcp_resource_header_property_add(pMrcpMessage,RECOGNIZER_HEADER_SAVE_WAVEFORM);
}
return pMrcpMessage;
}
static apt_bool_t recog_event_interpretation_complete(mrcp_recog_state_machine_t *state_machine, mrcp_message_t *message)
{
if(mrcp_resource_header_property_check(message,RECOGNIZER_HEADER_COMPLETION_CAUSE) != TRUE) {
mrcp_recog_header_t *recog_header = mrcp_resource_header_prepare(message);
recog_header->completion_cause = RECOGNIZER_COMPLETION_CAUSE_SUCCESS;
mrcp_resource_header_property_add(message,RECOGNIZER_HEADER_COMPLETION_CAUSE);
}
return recog_event_dispatch(state_machine,message);
}
static apt_bool_t recog_response_define_grammar(mrcp_recog_state_machine_t *state_machine, mrcp_message_t *message)
{
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Process DEFINE-GRAMMAR Response [%d]",message->start_line.request_id);
if(mrcp_resource_header_property_check(message,RECOGNIZER_HEADER_COMPLETION_CAUSE) != TRUE) {
mrcp_recog_header_t *recog_header = mrcp_resource_header_prepare(message);
recog_header->completion_cause = RECOGNIZER_COMPLETION_CAUSE_SUCCESS;
mrcp_resource_header_property_add(message,RECOGNIZER_HEADER_COMPLETION_CAUSE);
}
return recog_response_dispatch(state_machine,message);
}
/** Create RECOGNIZE request */
static mrcp_message_t* recognize_message_create(asr_session_t *asr_session)
{
/* create MRCP message */
mrcp_message_t *mrcp_message = mrcp_application_message_create(
asr_session->mrcp_session,
asr_session->mrcp_channel,
RECOGNIZER_RECOGNIZE);
if(mrcp_message) {
mrcp_recog_header_t *recog_header;
mrcp_generic_header_t *generic_header;
/* get/allocate generic header */
generic_header = mrcp_generic_header_prepare(mrcp_message);
if(generic_header) {
/* set generic header fields */
apt_string_assign(&generic_header->content_type,"text/uri-list",mrcp_message->pool);
mrcp_generic_header_property_add(mrcp_message,GENERIC_HEADER_CONTENT_TYPE);
/* set message body */
apt_string_assign(&mrcp_message->body,"session:demo-grammar",mrcp_message->pool);
}
/* get/allocate recognizer header */
recog_header = mrcp_resource_header_prepare(mrcp_message);
if(recog_header) {
if(mrcp_message->start_line.version == MRCP_VERSION_2) {
/* set recognizer header fields */
recog_header->cancel_if_queue = FALSE;
mrcp_resource_header_property_add(mrcp_message,RECOGNIZER_HEADER_CANCEL_IF_QUEUE);
}
recog_header->no_input_timeout = 5000;
mrcp_resource_header_property_add(mrcp_message,RECOGNIZER_HEADER_NO_INPUT_TIMEOUT);
recog_header->recognition_timeout = 20000;
mrcp_resource_header_property_add(mrcp_message,RECOGNIZER_HEADER_RECOGNITION_TIMEOUT);
recog_header->speech_complete_timeout = 400;
mrcp_resource_header_property_add(mrcp_message,RECOGNIZER_HEADER_SPEECH_COMPLETE_TIMEOUT);
recog_header->dtmf_term_timeout = 3000;
mrcp_resource_header_property_add(mrcp_message,RECOGNIZER_HEADER_DTMF_TERM_TIMEOUT);
recog_header->dtmf_interdigit_timeout = 3000;
mrcp_resource_header_property_add(mrcp_message,RECOGNIZER_HEADER_DTMF_INTERDIGIT_TIMEOUT);
recog_header->confidence_threshold = 0.5f;
mrcp_resource_header_property_add(mrcp_message,RECOGNIZER_HEADER_CONFIDENCE_THRESHOLD);
recog_header->start_input_timers = TRUE;
mrcp_resource_header_property_add(mrcp_message,RECOGNIZER_HEADER_START_INPUT_TIMERS);
}
}
return mrcp_message;
}
/* Create SPEAK-COMPLETE event */
static mrcp_message_t* speak_event_create(mrcp_resource_factory_t *factory, const mrcp_message_t *request)
{
mrcp_message_t *event_message;
apt_log(APT_LOG_MARK,APT_PRIO_NOTICE,"Create SPEAK-COMPLETE Event");
event_message = mrcp_event_create(request,SYNTHESIZER_SPEAK_COMPLETE,request->pool);
if(event_message) {
/* get/allocate synthesizer header */
mrcp_synth_header_t *synth_header = mrcp_resource_header_prepare(event_message);
if(synth_header) {
/* set completion cause */
synth_header->completion_cause = SYNTHESIZER_COMPLETION_CAUSE_NORMAL;
mrcp_resource_header_property_add(event_message,SYNTHESIZER_HEADER_COMPLETION_CAUSE);
}
/* set request state */
event_message->start_line.request_state = MRCP_REQUEST_STATE_COMPLETE;
}
return event_message;
}
static apt_bool_t recog_event_recognition_complete(mrcp_recog_state_machine_t *state_machine, mrcp_message_t *message)
{
mrcp_message_t *pending_request;
if(!state_machine->recog) {
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Unexpected RECOGNITION-COMPLETE Event "APT_SIDRES_FMT" [%"MRCP_REQUEST_ID_FMT"]",
MRCP_MESSAGE_SIDRES(message),
message->start_line.request_id);
return FALSE;
}
if(state_machine->recog->start_line.request_id != message->start_line.request_id) {
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Unexpected RECOGNITION-COMPLETE Event "APT_SIDRES_FMT" [%"MRCP_REQUEST_ID_FMT"]",
MRCP_MESSAGE_SIDRES(message),
message->start_line.request_id);
return FALSE;
}
if(state_machine->active_request && state_machine->active_request->start_line.method_id == RECOGNIZER_STOP) {
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Ignore RECOGNITION-COMPLETE Event "APT_SIDRES_FMT" [%"MRCP_REQUEST_ID_FMT"]: waiting for STOP response",
MRCP_MESSAGE_SIDRES(message),
message->start_line.request_id);
return FALSE;
}
if(mrcp_resource_header_property_check(message,RECOGNIZER_HEADER_COMPLETION_CAUSE) != TRUE) {
mrcp_recog_header_t *recog_header = mrcp_resource_header_prepare(message);
recog_header->completion_cause = RECOGNIZER_COMPLETION_CAUSE_SUCCESS;
mrcp_resource_header_property_add(message,RECOGNIZER_HEADER_COMPLETION_CAUSE);
}
recog_state_change(state_machine,RECOGNIZER_STATE_RECOGNIZED,message);
recog_event_dispatch(state_machine,message);
/* process pending RECOGNIZE requests */
pending_request = apt_list_pop_front(state_machine->queue);
if(pending_request) {
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Process Pending RECOGNIZE Request "APT_SIDRES_FMT" [%"MRCP_REQUEST_ID_FMT"]",
MRCP_MESSAGE_SIDRES(pending_request),
pending_request->start_line.request_id);
state_machine->is_pending = TRUE;
recog_request_dispatch(state_machine,pending_request);
}
return TRUE;
}
mrcp_message_t* VerifierSession::CreateVerificationRequest(mrcp_channel_t* pMrcpChannel)
{
mrcp_message_t* pMrcpMessage = CreateMrcpMessage(pMrcpChannel,VERIFIER_VERIFY);
if(!pMrcpMessage)
return NULL;
mrcp_verifier_header_t* pVerifierHeader;
/* get/allocate verifier header */
pVerifierHeader = (mrcp_verifier_header_t*) mrcp_resource_header_prepare(pMrcpMessage);
if(pVerifierHeader)
{
pVerifierHeader->no_input_timeout = 5000;
mrcp_resource_header_property_add(pMrcpMessage,VERIFIER_HEADER_NO_INPUT_TIMEOUT);
pVerifierHeader->start_input_timers = TRUE;
mrcp_resource_header_property_add(pMrcpMessage,VERIFIER_HEADER_START_INPUT_TIMERS);
}
return pMrcpMessage;
}
mrcp_message_t* SetParamSession::CreateGetParams2(mrcp_channel_t* pMrcpChannel)
{
mrcp_message_t* pMrcpMessage = CreateMrcpMessage(pMrcpChannel,RECOGNIZER_GET_PARAMS);
if(!pMrcpMessage)
return NULL;
mrcp_recog_header_t* pRecogHeader;
/* get/allocate recog header */
pRecogHeader = (mrcp_recog_header_t*) mrcp_resource_header_prepare(pMrcpMessage);
if(pRecogHeader)
{
/* set recog header fields */
mrcp_resource_header_name_property_add(pMrcpMessage,RECOGNIZER_HEADER_RECOGNITION_TIMEOUT);
mrcp_resource_header_name_property_add(pMrcpMessage,RECOGNIZER_HEADER_SPEECH_COMPLETE_TIMEOUT);
mrcp_resource_header_name_property_add(pMrcpMessage,RECOGNIZER_HEADER_SPEECH_INCOMPLETE_TIMEOUT);
mrcp_resource_header_name_property_add(pMrcpMessage,RECOGNIZER_HEADER_DTMF_INTERDIGIT_TIMEOUT);
}
return pMrcpMessage;
}
/** Set Record-URI header field */
static apt_bool_t recorder_channel_uri_set(recorder_channel_t *recorder_channel, mrcp_message_t *message)
{
char *record_uri;
/* get/allocate recorder header */
mrcp_recorder_header_t *recorder_header = mrcp_resource_header_prepare(message);
if(!recorder_header) {
return FALSE;
}
record_uri = apr_psprintf(
message->pool,
"<file://mediaserver/data/%s>;size=%"APR_SIZE_T_FMT";duration=%"APR_SIZE_T_FMT,
recorder_channel->file_name,
recorder_channel->cur_size,
recorder_channel->cur_time);
apt_string_set(&recorder_header->record_uri,record_uri);
mrcp_resource_header_property_add(message,RECORDER_HEADER_RECORD_URI);
return TRUE;
}
mrcp_message_t* SetParamSession::CreateGetParams1(mrcp_channel_t* pMrcpChannel)
{
mrcp_message_t* pMrcpMessage = CreateMrcpMessage(pMrcpChannel,RECOGNIZER_GET_PARAMS);
if(!pMrcpMessage)
return NULL;
mrcp_recog_header_t* pRecogHeader;
/* get/allocate recog header */
pRecogHeader = (mrcp_recog_header_t*) mrcp_resource_header_prepare(pMrcpMessage);
if(pRecogHeader)
{
/* set recog header fields */
mrcp_resource_header_name_property_add(pMrcpMessage,RECOGNIZER_HEADER_CONFIDENCE_THRESHOLD);
mrcp_resource_header_name_property_add(pMrcpMessage,RECOGNIZER_HEADER_SENSITIVITY_LEVEL);
mrcp_resource_header_name_property_add(pMrcpMessage,RECOGNIZER_HEADER_SPEED_VS_ACCURACY);
mrcp_resource_header_name_property_add(pMrcpMessage,RECOGNIZER_HEADER_N_BEST_LIST_LENGTH);
mrcp_resource_header_name_property_add(pMrcpMessage,RECOGNIZER_HEADER_NO_INPUT_TIMEOUT);
}
return pMrcpMessage;
}
/* Create GET-PARAMS request */
static mrcp_message_t* get_params_request_create(mrcp_resource_factory_t *factory, apr_pool_t *pool)
{
mrcp_message_t *message;
mrcp_resource_t *resource = mrcp_resource_get(factory,MRCP_SYNTHESIZER_RESOURCE);
if(!resource) {
return NULL;
}
apt_log(APT_LOG_MARK,APT_PRIO_NOTICE,"Create GET-PARAMS Request");
message = mrcp_request_create(resource,MRCP_VERSION_2,SYNTHESIZER_GET_PARAMS,pool);
if(message) {
apt_str_t param_name;
apt_str_t param_value;
mrcp_generic_header_t *generic_header;
mrcp_synth_header_t *synth_header;
/* get/allocate generic header */
generic_header = mrcp_generic_header_prepare(message);
if(generic_header) {
/* set content id empty header */
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Set Content-ID: <empty>");
mrcp_generic_header_name_property_add(message,GENERIC_HEADER_CONTENT_ID);
/* set vendor specific params header */
generic_header->vendor_specific_params = apt_pair_array_create(1,pool);
apt_string_set(¶m_name,SAMPLE_PARAM_NAME);
apt_string_reset(¶m_value);
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Set Vendor-Specific-Params: %s",param_name.buf);
apt_pair_array_append(generic_header->vendor_specific_params,¶m_name,¶m_value,pool);
mrcp_generic_header_property_add(message,GENERIC_HEADER_VENDOR_SPECIFIC_PARAMS);
}
/* get/allocate synthesizer header */
synth_header = mrcp_resource_header_prepare(message);
if(synth_header) {
/* set voice age empty header */
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Set Voice-Age: <empty>");
mrcp_resource_header_name_property_add(message,SYNTHESIZER_HEADER_VOICE_AGE);
}
}
return message;
}
static apt_bool_t synth_event_speak_complete(mrcp_synth_state_machine_t *state_machine, mrcp_message_t *message)
{
mrcp_message_t *pending_request;
if(!state_machine->speaker) {
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Unexpected SPEAK-COMPLETE Event [%"MRCP_REQUEST_ID_FMT"]",
message->start_line.request_id);
return FALSE;
}
if(state_machine->speaker->start_line.request_id != message->start_line.request_id) {
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Unexpected SPEAK-COMPLETE Event [%"MRCP_REQUEST_ID_FMT"]",
message->start_line.request_id);
return FALSE;
}
if(state_machine->active_request && state_machine->active_request->start_line.method_id == SYNTHESIZER_STOP) {
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Ignore SPEAK-COMPLETE Event [%d]: waiting for STOP response",message->start_line.request_id);
return FALSE;
}
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Process SPEAK-COMPLETE Event [%"MRCP_REQUEST_ID_FMT"]",
message->start_line.request_id);
if(mrcp_resource_header_property_check(message,SYNTHESIZER_HEADER_COMPLETION_CAUSE) != TRUE) {
mrcp_synth_header_t *synth_header = mrcp_resource_header_prepare(message);
synth_header->completion_cause = SYNTHESIZER_COMPLETION_CAUSE_NORMAL;
mrcp_resource_header_property_add(message,SYNTHESIZER_HEADER_COMPLETION_CAUSE);
}
synth_state_change(state_machine,SYNTHESIZER_STATE_IDLE);
synth_event_dispatch(state_machine,message);
/* process pending SPEAK requests */
pending_request = apt_list_pop_front(state_machine->queue);
if(pending_request) {
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Process Pending SPEAK Request [%d]",pending_request->start_line.request_id);
state_machine->is_pending = TRUE;
synth_request_dispatch(state_machine,pending_request);
}
return TRUE;
}
/** Create demo MRCP message (RECOGNIZE request) */
mrcp_message_t* demo_recognize_message_create(mrcp_session_t *session, mrcp_channel_t *channel, const apt_dir_layout_t *dir_layout)
{
const char text[] = "session:[email protected]";
/* create MRCP message */
mrcp_message_t *mrcp_message = mrcp_application_message_create(session,channel,RECOGNIZER_RECOGNIZE);
if(mrcp_message) {
mrcp_recog_header_t *recog_header;
mrcp_generic_header_t *generic_header;
/* get/allocate generic header */
generic_header = mrcp_generic_header_prepare(mrcp_message);
if(generic_header) {
/* set generic header fields */
apt_string_assign(&generic_header->content_type,"text/uri-list",mrcp_message->pool);
mrcp_generic_header_property_add(mrcp_message,GENERIC_HEADER_CONTENT_TYPE);
}
/* get/allocate recognizer header */
recog_header = mrcp_resource_header_prepare(mrcp_message);
if(recog_header) {
if(mrcp_message->start_line.version == MRCP_VERSION_2) {
/* set recognizer header fields */
recog_header->cancel_if_queue = FALSE;
mrcp_resource_header_property_add(mrcp_message,RECOGNIZER_HEADER_CANCEL_IF_QUEUE);
}
recog_header->no_input_timeout = 5000;
mrcp_resource_header_property_add(mrcp_message,RECOGNIZER_HEADER_NO_INPUT_TIMEOUT);
recog_header->recognition_timeout = 10000;
mrcp_resource_header_property_add(mrcp_message,RECOGNIZER_HEADER_RECOGNITION_TIMEOUT);
recog_header->start_input_timers = TRUE;
mrcp_resource_header_property_add(mrcp_message,RECOGNIZER_HEADER_START_INPUT_TIMERS);
recog_header->confidence_threshold = 0.87f;
mrcp_resource_header_property_add(mrcp_message,RECOGNIZER_HEADER_CONFIDENCE_THRESHOLD);
}
/* set message body */
apt_string_assign(&mrcp_message->body,text,mrcp_message->pool);
}
return mrcp_message;
}
/** Process GET-PARAMS request */
static apt_bool_t demo_synth_channel_get_params(mrcp_engine_channel_t *channel, mrcp_message_t *request, mrcp_message_t *response)
{
mrcp_synth_header_t *req_synth_header;
/* get synthesizer header */
req_synth_header = mrcp_resource_header_get(request);
if(req_synth_header) {
mrcp_synth_header_t *res_synth_header = mrcp_resource_header_prepare(response);
/* check voice age header */
if(mrcp_resource_header_property_check(request,SYNTHESIZER_HEADER_VOICE_AGE) == TRUE) {
res_synth_header->voice_param.age = 25;
mrcp_resource_header_property_add(response,SYNTHESIZER_HEADER_VOICE_AGE);
}
/* check voice name header */
if(mrcp_resource_header_property_check(request,SYNTHESIZER_HEADER_VOICE_NAME) == TRUE) {
apt_string_set(&res_synth_header->voice_param.name,"David");
mrcp_resource_header_property_add(response,SYNTHESIZER_HEADER_VOICE_NAME);
}
}
/* send asynchronous response */
mrcp_engine_channel_message_send(channel,response);
return TRUE;
}
mrcp_message_t* RecorderSession::CreateRecordRequest(mrcp_channel_t* pMrcpChannel)
{
mrcp_message_t* pMrcpMessage = CreateMrcpMessage(pMrcpChannel,RECORDER_RECORD);
if(!pMrcpMessage)
return NULL;
mrcp_recorder_header_t* pRecorderHeader;
/* get/allocate recorder header */
pRecorderHeader = (mrcp_recorder_header_t*) mrcp_resource_header_prepare(pMrcpMessage);
if(pRecorderHeader)
{
/* set recorder header fields */
pRecorderHeader->no_input_timeout = 5000;
mrcp_resource_header_property_add(pMrcpMessage,RECORDER_HEADER_NO_INPUT_TIMEOUT);
pRecorderHeader->final_silence = 300;
mrcp_resource_header_property_add(pMrcpMessage,RECORDER_HEADER_FINAL_SILENCE);
pRecorderHeader->max_time = 10000;
mrcp_resource_header_property_add(pMrcpMessage,RECORDER_HEADER_MAX_TIME);
}
return pMrcpMessage;
}
mrcp_message_t* SetParamSession::CreateSetParams2(mrcp_channel_t* pMrcpChannel)
{
mrcp_message_t* pMrcpMessage = CreateMrcpMessage(pMrcpChannel,RECOGNIZER_SET_PARAMS);
if(!pMrcpMessage)
return NULL;
mrcp_recog_header_t* pRecogHeader;
/* get/allocate recog header */
pRecogHeader = (mrcp_recog_header_t*) mrcp_resource_header_prepare(pMrcpMessage);
if(pRecogHeader)
{
/* set recog header fields */
pRecogHeader->recognition_timeout = 5000;
mrcp_resource_header_property_add(pMrcpMessage,RECOGNIZER_HEADER_RECOGNITION_TIMEOUT);
pRecogHeader->speech_complete_timeout = 1000;
mrcp_resource_header_property_add(pMrcpMessage,RECOGNIZER_HEADER_SPEECH_COMPLETE_TIMEOUT);
pRecogHeader->speech_incomplete_timeout = 2000;
mrcp_resource_header_property_add(pMrcpMessage,RECOGNIZER_HEADER_SPEECH_INCOMPLETE_TIMEOUT);
pRecogHeader->dtmf_interdigit_timeout = 3000;
mrcp_resource_header_property_add(pMrcpMessage,RECOGNIZER_HEADER_DTMF_INTERDIGIT_TIMEOUT);
}
return pMrcpMessage;
}
/* Create GET-PARAMS response */
static mrcp_message_t* get_params_response_create(mrcp_resource_factory_t *factory, mrcp_message_t *request)
{
apt_bool_t res;
mrcp_message_t *response;
apt_log(APT_LOG_MARK,APT_PRIO_NOTICE,"Create GET-PARAMS Response");
response = mrcp_response_create(request,request->pool);
if(response) {
mrcp_generic_header_t *generic_header;
mrcp_synth_header_t *synth_header;
res = FALSE;
/* get generic header */
generic_header = mrcp_generic_header_get(request);
if(generic_header) {
mrcp_generic_header_t *res_generic_header = mrcp_generic_header_prepare(response);
/* test content id header */
if(mrcp_generic_header_property_check(request,GENERIC_HEADER_CONTENT_ID) == TRUE) {
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Set Content-ID: %s",SAMPLE_CONTENT_ID);
apt_string_assign(&res_generic_header->content_id,SAMPLE_CONTENT_ID,response->pool);
mrcp_generic_header_property_add(response,GENERIC_HEADER_CONTENT_ID);
res = TRUE;
}
/* test vendor specific header */
if(mrcp_generic_header_property_check(request,GENERIC_HEADER_VENDOR_SPECIFIC_PARAMS) == TRUE) {
apt_str_t name;
const apt_pair_t *pair;
res_generic_header->vendor_specific_params = apt_pair_array_create(1,response->pool);
apt_string_set(&name,SAMPLE_PARAM_NAME);
pair = apt_pair_array_find(generic_header->vendor_specific_params,&name);
if(pair) {
apt_str_t value;
apt_string_set(&value,SAMPLE_PARAM_VALUE);
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Set Vendor-Specific-Params: %s=%s",name.buf,value.buf);
apt_pair_array_append(res_generic_header->vendor_specific_params,&name,&value,response->pool);
}
mrcp_generic_header_property_add(response,GENERIC_HEADER_VENDOR_SPECIFIC_PARAMS);
res = TRUE;
}
}
if(res == FALSE) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Test Generic Header");
return NULL;
}
res = FALSE;
/* get synthesizer header */
synth_header = mrcp_resource_header_get(request);
if(synth_header) {
mrcp_synth_header_t *res_synth_header = mrcp_resource_header_prepare(response);
/* test voice age header */
if(mrcp_resource_header_property_check(request,SYNTHESIZER_HEADER_VOICE_AGE) == TRUE) {
res_synth_header->voice_param.age = SAMPLE_VOICE_AGE;
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Set Voice-Age: %"APR_SIZE_T_FMT,res_synth_header->voice_param.age);
mrcp_resource_header_property_add(response,SYNTHESIZER_HEADER_VOICE_AGE);
res = TRUE;
}
}
if(res == FALSE) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Test Synthesizer Header");
return NULL;
}
}
return response;
}
/** Callback is called from MPF engine context to read/get new frame */
static apt_bool_t demo_synth_stream_read(mpf_audio_stream_t *stream, mpf_frame_t *frame)
{
demo_synth_channel_t *synth_channel = stream->obj;
/* check if STOP was requested */
if(synth_channel->stop_response) {
/* send asynchronous response to STOP request */
mrcp_engine_channel_message_send(synth_channel->channel,synth_channel->stop_response);
synth_channel->stop_response = NULL;
synth_channel->speak_request = NULL;
synth_channel->paused = FALSE;
if(synth_channel->audio_file) {
fclose(synth_channel->audio_file);
synth_channel->audio_file = NULL;
}
return TRUE;
}
/* check if there is active SPEAK request and it isn't in paused state */
if(synth_channel->speak_request && synth_channel->paused == FALSE) {
/* normal processing */
apt_bool_t completed = FALSE;
if(synth_channel->audio_file) {
/* read speech from file */
apr_size_t size = frame->codec_frame.size;
if(fread(frame->codec_frame.buffer,1,size,synth_channel->audio_file) == size) {
frame->type |= MEDIA_FRAME_TYPE_AUDIO;
}
else {
completed = TRUE;
}
}
else {
/* fill with silence in case no file available */
if(synth_channel->time_to_complete >= CODEC_FRAME_TIME_BASE) {
memset(frame->codec_frame.buffer,0,frame->codec_frame.size);
frame->type |= MEDIA_FRAME_TYPE_AUDIO;
synth_channel->time_to_complete -= CODEC_FRAME_TIME_BASE;
}
else {
completed = TRUE;
}
}
if(completed) {
/* raise SPEAK-COMPLETE event */
mrcp_message_t *message = mrcp_event_create(
synth_channel->speak_request,
SYNTHESIZER_SPEAK_COMPLETE,
synth_channel->speak_request->pool);
if(message) {
/* get/allocate synthesizer header */
mrcp_synth_header_t *synth_header = mrcp_resource_header_prepare(message);
if(synth_header) {
/* set completion cause */
synth_header->completion_cause = SYNTHESIZER_COMPLETION_CAUSE_NORMAL;
mrcp_resource_header_property_add(message,SYNTHESIZER_HEADER_COMPLETION_CAUSE);
}
/* set request state */
message->start_line.request_state = MRCP_REQUEST_STATE_COMPLETE;
synth_channel->speak_request = NULL;
if(synth_channel->audio_file) {
fclose(synth_channel->audio_file);
synth_channel->audio_file = NULL;
}
/* send asynch event */
mrcp_engine_channel_message_send(synth_channel->channel,message);
}
}
}
return TRUE;
}
/** brief Prepare engine to accept audio */
static int uni_recog_start(struct ast_speech *speech)
{
uni_speech_t *uni_speech = speech->data;
mrcp_message_t *mrcp_message;
mrcp_generic_header_t *generic_header;
mrcp_recog_header_t *recog_header;
if(uni_speech->is_inprogress) {
uni_recog_stop(speech);
}
ast_log(LOG_NOTICE, "Start audio '%s'\n",uni_speech_id_get(uni_speech));
mrcp_message = mrcp_application_message_create(
uni_speech->session,
uni_speech->channel,
RECOGNIZER_RECOGNIZE);
if(!mrcp_message) {
ast_log(LOG_WARNING, "Failed to create MRCP message\n");
return -1;
}
/* Get/allocate generic header */
generic_header = mrcp_generic_header_prepare(mrcp_message);
if(generic_header) {
apr_hash_index_t *it;
void *val;
const char *grammar_name;
const char *content = NULL;
/* Set generic header fields */
apt_string_assign(&generic_header->content_type,"text/uri-list",mrcp_message->pool);
mrcp_generic_header_property_add(mrcp_message,GENERIC_HEADER_CONTENT_TYPE);
/* Construct and set message body */
it = apr_hash_first(mrcp_message->pool,uni_speech->active_grammars);
if(it) {
apr_hash_this(it,NULL,NULL,&val);
grammar_name = val;
content = apr_pstrcat(mrcp_message->pool,"session:",grammar_name,NULL);
it = apr_hash_next(it);
}
for(; it; it = apr_hash_next(it)) {
apr_hash_this(it,NULL,NULL,&val);
grammar_name = val;
content = apr_pstrcat(mrcp_message->pool,content,"\nsession:",grammar_name,NULL);
}
if(content) {
apt_string_set(&mrcp_message->body,content);
}
}
/* Get/allocate recognizer header */
recog_header = (mrcp_recog_header_t*) mrcp_resource_header_prepare(mrcp_message);
if(recog_header) {
/* Set recognizer header fields */
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);
}
recog_header->start_input_timers = TRUE;
mrcp_resource_header_property_add(mrcp_message,RECOGNIZER_HEADER_START_INPUT_TIMERS);
}
/* Reset last event (if any) */
uni_speech->mrcp_event = NULL;
/* Send MRCP request and wait for response */
if(uni_recog_mrcp_request_send(uni_speech,mrcp_message) != TRUE) {
ast_log(LOG_WARNING, "Failed to send MRCP message\n");
return -1;
}
/* Check received response */
if(!uni_speech->mrcp_response || uni_speech->mrcp_response->start_line.status_code != MRCP_STATUS_CODE_SUCCESS) {
ast_log(LOG_WARNING, "Received failure response\n");
return -1;
}
/* Reset media buffer */
mpf_frame_buffer_restart(uni_speech->media_buffer);
ast_speech_change_state(speech, AST_SPEECH_STATE_READY);
uni_speech->is_inprogress = TRUE;
return 0;
}
/* Send SPEAK request to synthesizer. */
static int synth_channel_speak(speech_channel_t *schannel, const char *content, const char *content_type, apr_hash_t *header_fields)
{
int status = 0;
mrcp_message_t *mrcp_message = NULL;
mrcp_generic_header_t *generic_header = NULL;
mrcp_synth_header_t *synth_header = NULL;
if (!schannel || !content || !content_type) {
ast_log(LOG_ERROR, "synth_channel_speak: unknown channel error!\n");
return -1;
}
apr_thread_mutex_lock(schannel->mutex);
if (schannel->state != SPEECH_CHANNEL_READY) {
apr_thread_mutex_unlock(schannel->mutex);
return -1;
}
if ((mrcp_message = mrcp_application_message_create(schannel->unimrcp_session, schannel->unimrcp_channel, SYNTHESIZER_SPEAK)) == NULL) {
ast_log(LOG_ERROR, "(%s) Failed to create SPEAK message\n", schannel->name);
apr_thread_mutex_unlock(schannel->mutex);
return -1;
}
/* Set generic header fields (content-type). */
if ((generic_header = (mrcp_generic_header_t *)mrcp_generic_header_prepare(mrcp_message)) == NULL) {
apr_thread_mutex_unlock(schannel->mutex);
return -1;
}
apt_string_assign(&generic_header->content_type, content_type, mrcp_message->pool);
mrcp_generic_header_property_add(mrcp_message, GENERIC_HEADER_CONTENT_TYPE);
/* Set synthesizer header fields (voice, rate, etc.). */
if ((synth_header = (mrcp_synth_header_t *)mrcp_resource_header_prepare(mrcp_message)) == NULL) {
apr_thread_mutex_unlock(schannel->mutex);
return -1;
}
/* Add params to MRCP message. */
speech_channel_set_params(schannel, mrcp_message, header_fields);
/* Set body (plain text or SSML). */
apt_string_assign(&mrcp_message->body, content, schannel->pool);
/* Empty audio queue and send SPEAK to MRCP server. */
audio_queue_clear(schannel->audio_queue);
if (!mrcp_application_message_send(schannel->unimrcp_session, schannel->unimrcp_channel, mrcp_message)) {
ast_log(LOG_ERROR,"(%s) Failed to send SPEAK message", schannel->name);
apr_thread_mutex_unlock(schannel->mutex);
return -1;
}
/* Wait for IN PROGRESS. */
apr_thread_cond_timedwait(schannel->cond, schannel->mutex, SPEECH_CHANNEL_TIMEOUT_USEC);
if (schannel->state != SPEECH_CHANNEL_PROCESSING) {
apr_thread_mutex_unlock(schannel->mutex);
return -1;
}
apr_thread_mutex_unlock(schannel->mutex);
return status;
}
