mrcp_message_t* RecogSession::CreateDefineGrammarRequest(mrcp_channel_t* pMrcpChannel) { mrcp_message_t* pMrcpMessage = CreateMrcpMessage(pMrcpChannel,RECOGNIZER_DEFINE_GRAMMAR); if(!pMrcpMessage) return NULL; const RecogScenario* pScenario = GetScenario(); mrcp_generic_header_t* pGenericHeader; /* get/allocate generic header */ pGenericHeader = (mrcp_generic_header_t*) mrcp_generic_header_prepare(pMrcpMessage); if(pGenericHeader) { /* set generic header fields */ if(pScenario->GetContentType()) { apt_string_assign(&pGenericHeader->content_type,pScenario->GetContentType(),pMrcpMessage->pool); mrcp_generic_header_property_add(pMrcpMessage,GENERIC_HEADER_CONTENT_TYPE); } 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(&pMrcpMessage->body,pScenario->GetContent(),pMrcpMessage->pool); return pMrcpMessage; }
/** 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; }
/** Create demo MRCP message (DEFINE-GRAMMAR request) */ mrcp_message_t* demo_define_grammar_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,RECOGNIZER_DEFINE_GRAMMAR); if(mrcp_message) { 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 */ if(mrcp_message->start_line.version == MRCP_VERSION_2) { apt_string_assign(&generic_header->content_type,"application/srgs+xml",mrcp_message->pool); } else { apt_string_assign(&generic_header->content_type,"application/grammar+xml",mrcp_message->pool); } mrcp_generic_header_property_add(mrcp_message,GENERIC_HEADER_CONTENT_TYPE); apt_string_assign(&generic_header->content_id,"*****@*****.**",mrcp_message->pool); mrcp_generic_header_property_add(mrcp_message,GENERIC_HEADER_CONTENT_ID); } /* set message body */ demo_message_body_set(mrcp_message,dir_layout,"grammar.xml"); } return mrcp_message; }
bool SynthSession::Stop() { if(!UmcSession::Stop()) return false; if(!m_pSynthChannel) return false; mrcp_message_t* pStopMessage = CreateMrcpMessage(m_pSynthChannel->m_pMrcpChannel,SYNTHESIZER_STOP); if(!pStopMessage) return false; if(m_pSynthChannel->m_pSpeakRequest) { mrcp_generic_header_t* pGenericHeader; /* get/allocate generic header */ pGenericHeader = (mrcp_generic_header_t*) mrcp_generic_header_prepare(pStopMessage); if(pGenericHeader) { pGenericHeader->active_request_id_list.count = 1; pGenericHeader->active_request_id_list.ids[0] = m_pSynthChannel->m_pSpeakRequest->start_line.request_id; mrcp_generic_header_property_add(pStopMessage,GENERIC_HEADER_ACTIVE_REQUEST_ID_LIST); } m_pSynthChannel->m_pSpeakRequest = NULL; } return SendMrcpRequest(m_pSynthChannel->m_pMrcpChannel,pStopMessage); }
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; }
static apt_bool_t recog_pending_requests_remove(mrcp_recog_state_machine_t *state_machine, mrcp_message_t *request_message, mrcp_message_t *response_message) { apt_list_elem_t *elem; mrcp_message_t *pending_message; mrcp_request_id_list_t *request_id_list = NULL; mrcp_generic_header_t *generic_header = mrcp_generic_header_get(request_message); mrcp_generic_header_t *response_generic_header = mrcp_generic_header_prepare(response_message); if(generic_header && mrcp_generic_header_property_check(request_message,GENERIC_HEADER_ACTIVE_REQUEST_ID_LIST) == TRUE) { if(generic_header->active_request_id_list.count) { /* selective STOP request */ request_id_list = &generic_header->active_request_id_list; } } elem = apt_list_first_elem_get(state_machine->queue); while(elem) { pending_message = apt_list_elem_object_get(elem); if(!request_id_list || active_request_id_list_find(generic_header,pending_message->start_line.request_id) == TRUE) { apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Remove Pending RECOGNIZE Request "APT_SIDRES_FMT" [%"MRCP_REQUEST_ID_FMT"]", MRCP_MESSAGE_SIDRES(pending_message), pending_message->start_line.request_id); elem = apt_list_elem_remove(state_machine->queue,elem); /* append active id list */ active_request_id_list_append(response_generic_header,pending_message->start_line.request_id); } else { /* speak request remains in the queue, just proceed to the next one */ elem = apt_list_next_elem_get(state_machine->queue,elem); } } if(response_generic_header->active_request_id_list.count) { mrcp_generic_header_property_add(response_message,GENERIC_HEADER_ACTIVE_REQUEST_ID_LIST); } return TRUE; }
/** Create DEFINE-GRAMMAR request */ static mrcp_message_t* define_grammar_message_create(asr_session_t *asr_session, const char *grammar_file) { /* create MRCP message */ mrcp_message_t *mrcp_message = mrcp_application_message_create( asr_session->mrcp_session, asr_session->mrcp_channel, RECOGNIZER_DEFINE_GRAMMAR); if(mrcp_message) { mrcp_generic_header_t *generic_header; /* set message body */ const apt_dir_layout_t *dir_layout = mrcp_application_dir_layout_get(asr_session->engine->mrcp_app); apr_pool_t *pool = mrcp_application_session_pool_get(asr_session->mrcp_session); char *grammar_file_path = apt_datadir_filepath_get(dir_layout,grammar_file,pool); if(grammar_file_path) { apr_finfo_t finfo; apr_file_t *grammar_file; apt_str_t *content = &mrcp_message->body; if(apr_file_open(&grammar_file,grammar_file_path,APR_FOPEN_READ|APR_FOPEN_BINARY,0,pool) != APR_SUCCESS) { apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Open Grammar File %s",grammar_file_path); return NULL; } if(apr_file_info_get(&finfo,APR_FINFO_SIZE,grammar_file) != APR_SUCCESS) { apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Get Grammar File Info %s",grammar_file_path); apr_file_close(grammar_file); return NULL; } content->length = (apr_size_t)finfo.size; content->buf = (char*) apr_palloc(pool,content->length+1); apt_log(APT_LOG_MARK,APT_PRIO_DEBUG,"Load Grammar File Content size [%"APR_SIZE_T_FMT" bytes] %s", content->length,grammar_file_path); if(apr_file_read(grammar_file,content->buf,&content->length) != APR_SUCCESS) { apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Read Grammar File Content %s",grammar_file_path); apr_file_close(grammar_file); return NULL; } content->buf[content->length] = '\0'; apr_file_close(grammar_file); } /* get/allocate generic header */ generic_header = mrcp_generic_header_prepare(mrcp_message); if(generic_header) { /* set generic header fields */ if(mrcp_message->start_line.version == MRCP_VERSION_2) { apt_string_assign(&generic_header->content_type,"application/srgs+xml",mrcp_message->pool); } else { apt_string_assign(&generic_header->content_type,"application/grammar+xml",mrcp_message->pool); } mrcp_generic_header_property_add(mrcp_message,GENERIC_HEADER_CONTENT_TYPE); apt_string_assign(&generic_header->content_id,"demo-grammar",mrcp_message->pool); mrcp_generic_header_property_add(mrcp_message,GENERIC_HEADER_CONTENT_ID); } } return mrcp_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; }
/* 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; }
/* Load demo verification result */ static apt_bool_t demo_verifier_result_load(demo_verifier_channel_t *verifier_channel, mrcp_message_t *message) { FILE *file; mrcp_engine_channel_t *channel = verifier_channel->channel; const apt_dir_layout_t *dir_layout = channel->engine->dir_layout; char *file_path = apt_datadir_filepath_get(dir_layout,"result-verification.xml",message->pool); if(!file_path) { return FALSE; } /* read the demo result from file */ file = fopen(file_path,"r"); if(file) { mrcp_generic_header_t *generic_header; char text[1024]; apr_size_t size; size = fread(text,1,sizeof(text),file); apt_string_assign_n(&message->body,text,size,message->pool); fclose(file); /* get/allocate generic header */ generic_header = mrcp_generic_header_prepare(message); if(generic_header) { /* set content types */ apt_string_assign(&generic_header->content_type,"application/nlsml+xml",message->pool); mrcp_generic_header_property_add(message,GENERIC_HEADER_CONTENT_TYPE); } } return TRUE; }
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 synth_response_define_lexicon(mrcp_synth_state_machine_t *state_machine, mrcp_message_t *message) { mrcp_generic_header_t *generic_header = mrcp_generic_header_prepare(message); apt_log(APT_PRIO_INFO,"Process DEFINE-LEXICON Response [%d]",message->start_line.request_id); /* append active id list */ active_request_id_list_append(generic_header,state_machine->speaker->start_line.request_id); mrcp_generic_header_property_add(message,GENERIC_HEADER_ACTIVE_REQUEST_ID_LIST); return synth_response_dispatch(state_machine,message); }
static apt_bool_t synth_response_control(mrcp_synth_state_machine_t *state_machine, mrcp_message_t *message) { mrcp_generic_header_t *generic_header = mrcp_generic_header_prepare(message); apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Process CONTROL Response [%"MRCP_REQUEST_ID_FMT"]", message->start_line.request_id); /* append active id list */ active_request_id_list_append(generic_header,state_machine->speaker->start_line.request_id); mrcp_generic_header_property_add(message,GENERIC_HEADER_ACTIVE_REQUEST_ID_LIST); return synth_response_dispatch(state_machine,message); }
static apt_bool_t synth_response_barge_in_occurred(mrcp_synth_state_machine_t *state_machine, mrcp_message_t *message) { mrcp_generic_header_t *generic_header = mrcp_generic_header_prepare(message); apt_log(APT_PRIO_INFO,"Process BARGE-IN Response [%d]",message->start_line.request_id); /* append active id list */ active_request_id_list_append(generic_header,state_machine->speaker->start_line.request_id); mrcp_generic_header_property_add(message,GENERIC_HEADER_ACTIVE_REQUEST_ID_LIST); synth_pending_requests_remove(state_machine,state_machine->active_request,message); synth_state_change(state_machine,SYNTHESIZER_STATE_IDLE); return synth_response_dispatch(state_machine,message); }
static apt_bool_t synth_response_resume(mrcp_synth_state_machine_t *state_machine, mrcp_message_t *message) { apt_log(APT_PRIO_INFO,"Process RESUME Response [%d]",message->start_line.request_id); if(message->start_line.status_code == MRCP_STATUS_CODE_SUCCESS) { mrcp_generic_header_t *generic_header = mrcp_generic_header_prepare(message); /* append active id list */ active_request_id_list_append(generic_header,state_machine->speaker->start_line.request_id); mrcp_generic_header_property_add(message,GENERIC_HEADER_ACTIVE_REQUEST_ID_LIST); synth_state_change(state_machine,SYNTHESIZER_STATE_SPEAKING); } synth_response_dispatch(state_machine,message); return TRUE; }
mrcp_message_t* SetParamSession::CreateSetParams3(mrcp_channel_t* pMrcpChannel) { mrcp_message_t* pMrcpMessage = CreateMrcpMessage(pMrcpChannel,RECOGNIZER_SET_PARAMS); if(!pMrcpMessage) return NULL; mrcp_generic_header_t* pGenericHeader; /* get/allocate generic header */ pGenericHeader = (mrcp_generic_header_t*) mrcp_generic_header_prepare(pMrcpMessage); if(pGenericHeader) { apr_pool_t* pool = GetSessionPool(); /* set generic header fields */ apt_pair_arr_t* pVSP = apt_pair_array_create(3,pool); if(pVSP) { apt_str_t name; apt_str_t value; apt_string_set(&name,"confidencelevel"); apt_string_set(&value,"500"); apt_pair_array_append(pVSP,&name,&value,pool); apt_string_set(&name,"sensitivity"); apt_string_set(&value,"0.500"); apt_pair_array_append(pVSP,&name,&value,pool); apt_string_set(&name,"speedvsaccuracy"); apt_string_set(&value,"0.789"); apt_pair_array_append(pVSP,&name,&value,pool); apt_string_set(&name,"timeout"); apt_string_set(&value,"1000"); apt_pair_array_append(pVSP,&name,&value,pool); apt_string_set(&name,"swirec_application_name"); apt_string_set(&value,"UniMRCP"); apt_pair_array_append(pVSP,&name,&value,pool); apt_string_set(&name,"swirec_phoneme_lookahead_beam"); apt_string_set(&value,"-50"); apt_pair_array_append(pVSP,&name,&value,pool); pGenericHeader->vendor_specific_params = pVSP; mrcp_generic_header_property_add(pMrcpMessage,GENERIC_HEADER_VENDOR_SPECIFIC_PARAMS); } } return pMrcpMessage; }
/** \brief Unload a local grammar */ static int uni_recog_unload_grammar(struct ast_speech *speech, ast_compat_const char *grammar_name) { uni_speech_t *uni_speech = speech->data; mrcp_message_t *mrcp_message; mrcp_generic_header_t *generic_header; if(uni_speech->is_inprogress) { uni_recog_stop(speech); } ast_log(LOG_NOTICE, "Unload grammar name:%s '%s'\n", grammar_name, uni_speech_id_get(uni_speech)); apr_hash_set(uni_speech->active_grammars,grammar_name,APR_HASH_KEY_STRING,NULL); mrcp_message = mrcp_application_message_create( uni_speech->session, uni_speech->channel, RECOGNIZER_DEFINE_GRAMMAR); 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) { /* Set generic header fields */ apt_string_assign(&generic_header->content_id,grammar_name,mrcp_message->pool); mrcp_generic_header_property_add(mrcp_message,GENERIC_HEADER_CONTENT_ID); } /* 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; } return 0; }
/** Validate MRCP message */ MRCP_DECLARE(apt_bool_t) mrcp_message_validate(mrcp_message_t *message) { if(message->body.length) { /* content length must be specified */ mrcp_generic_header_t *generic_header = mrcp_generic_header_prepare(message); if(!generic_header) { return FALSE; } if(mrcp_generic_header_property_check(message,GENERIC_HEADER_CONTENT_LENGTH) != TRUE || !generic_header->content_length) { generic_header->content_length = message->body.length; mrcp_generic_header_property_add(message,GENERIC_HEADER_CONTENT_LENGTH); } } return TRUE; }
/** 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 DEFINE-GRAMMAR request */ static mrcp_message_t* define_grammar_message_create(asr_session_t *asr_session, const char *grammar_file) { /* create MRCP message */ mrcp_message_t *mrcp_message = mrcp_application_message_create( asr_session->mrcp_session, asr_session->mrcp_channel, RECOGNIZER_DEFINE_GRAMMAR); if(mrcp_message) { mrcp_generic_header_t *generic_header; /* set message body */ const apt_dir_layout_t *dir_layout = mrcp_application_dir_layout_get(asr_session->engine->mrcp_app); apr_pool_t *pool = mrcp_application_session_pool_get(asr_session->mrcp_session); char *grammar_file_path = apt_datadir_filepath_get(dir_layout,grammar_file,pool); if(grammar_file_path) { char text[1024]; apr_size_t size; FILE *grammar = fopen(grammar_file_path,"r"); if(!grammar) { apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Cannot Open [%s]",grammar_file_path); return NULL; } size = fread(text,1,sizeof(text),grammar); apt_string_assign_n(&mrcp_message->body,text,size,mrcp_message->pool); fclose(grammar); } /* get/allocate generic header */ generic_header = mrcp_generic_header_prepare(mrcp_message); if(generic_header) { /* set generic header fields */ if(mrcp_message->start_line.version == MRCP_VERSION_2) { apt_string_assign(&generic_header->content_type,"application/srgs+xml",mrcp_message->pool); } else { apt_string_assign(&generic_header->content_type,"application/grammar+xml",mrcp_message->pool); } mrcp_generic_header_property_add(mrcp_message,GENERIC_HEADER_CONTENT_TYPE); apt_string_assign(&generic_header->content_id,"demo-grammar",mrcp_message->pool); mrcp_generic_header_property_add(mrcp_message,GENERIC_HEADER_CONTENT_ID); } } return mrcp_message; }
static apt_bool_t synth_response_stop(mrcp_synth_state_machine_t *state_machine, mrcp_message_t *message) { mrcp_message_t *pending_request; mrcp_generic_header_t *generic_header = mrcp_generic_header_prepare(message); apt_log(APT_PRIO_INFO,"Process STOP Response [%d]",message->start_line.request_id); /* append active id list */ active_request_id_list_append(generic_header,state_machine->speaker->start_line.request_id); mrcp_generic_header_property_add(message,GENERIC_HEADER_ACTIVE_REQUEST_ID_LIST); synth_pending_requests_remove(state_machine,state_machine->active_request,message); synth_state_change(state_machine,SYNTHESIZER_STATE_IDLE); synth_response_dispatch(state_machine,message); /* process pending SPEAK requests / if any */ pending_request = apt_list_pop_front(state_machine->queue); if(pending_request) { apt_log(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; }
mrcp_message_t* SetParamSession::CreateGetParams3(mrcp_channel_t* pMrcpChannel) { mrcp_message_t* pMrcpMessage = CreateMrcpMessage(pMrcpChannel,RECOGNIZER_GET_PARAMS); if(!pMrcpMessage) return NULL; mrcp_generic_header_t* pGenericHeader; /* get/allocate generic header */ pGenericHeader = (mrcp_generic_header_t*) mrcp_generic_header_prepare(pMrcpMessage); if(pGenericHeader) { mrcp_generic_header_name_property_add(pMrcpMessage,GENERIC_HEADER_ACCEPT_CHARSET); mrcp_generic_header_name_property_add(pMrcpMessage,GENERIC_HEADER_CACHE_CONTROL); mrcp_generic_header_name_property_add(pMrcpMessage,GENERIC_HEADER_LOGGING_TAG); mrcp_generic_header_name_property_add(pMrcpMessage,GENERIC_HEADER_VENDOR_SPECIFIC_PARAMS); mrcp_generic_header_name_property_add(pMrcpMessage,GENERIC_HEADER_FETCH_TIMEOUT); mrcp_generic_header_name_property_add(pMrcpMessage,GENERIC_HEADER_SET_COOKIE); mrcp_generic_header_name_property_add(pMrcpMessage,GENERIC_HEADER_SET_COOKIE2); } return pMrcpMessage; }
static apt_bool_t recog_response_stop(mrcp_recog_state_machine_t *state_machine, mrcp_message_t *message) { mrcp_message_t *pending_request; mrcp_generic_header_t *generic_header = mrcp_generic_header_prepare(message); /* append active id list */ active_request_id_list_append(generic_header,state_machine->recog->start_line.request_id); mrcp_generic_header_property_add(message,GENERIC_HEADER_ACTIVE_REQUEST_ID_LIST); recog_pending_requests_remove(state_machine,state_machine->active_request,message); recog_state_change(state_machine,RECOGNIZER_STATE_IDLE,message); pending_request = apt_list_pop_front(state_machine->queue); recog_response_dispatch(state_machine,message); /* process pending RECOGNIZE requests / if any */ 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; }
/* 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; }
/** 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; }
/* 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; }
/*! \brief Load a local grammar on the speech structure */ static int uni_recog_load_grammar(struct ast_speech *speech, ast_compat_const char *grammar_name, ast_compat_const char *grammar_path) { uni_speech_t *uni_speech = speech->data; mrcp_message_t *mrcp_message; mrcp_generic_header_t *generic_header; const char *content_type = NULL; apt_bool_t inline_content = FALSE; char *tmp; apr_file_t *file; apt_str_t *body = NULL; mrcp_message = mrcp_application_message_create( uni_speech->session, uni_speech->channel, RECOGNIZER_DEFINE_GRAMMAR); if(!mrcp_message) { ast_log(LOG_WARNING, "Failed to create MRCP message\n"); return -1; } /* * Grammar name and path are mandatory attributes, * grammar type can be optionally specified with path. * * SpeechLoadGrammar(name|path) * SpeechLoadGrammar(name|type:path) * SpeechLoadGrammar(name|uri:path) * SpeechLoadGrammar(name|builtin:grammar/digits) */ tmp = strchr(grammar_path,':'); if(tmp) { const char builtin_token[] = "builtin"; const char uri_token[] = "uri"; if(strncmp(grammar_path,builtin_token,sizeof(builtin_token)-1) == 0) { content_type = "text/uri-list"; inline_content = TRUE; } else if(strncmp(grammar_path,uri_token,sizeof(uri_token)-1) == 0) { content_type = "text/uri-list"; inline_content = TRUE; grammar_path = tmp+1; } else { *tmp = '\0'; content_type = grammar_path; grammar_path = tmp+1; } } if(inline_content == TRUE) { body = &mrcp_message->body; apt_string_assign(body,grammar_path,mrcp_message->pool); } else { if(apr_file_open(&file,grammar_path,APR_FOPEN_READ|APR_FOPEN_BINARY,0,mrcp_message->pool) == APR_SUCCESS) { apr_finfo_t finfo; if(apr_file_info_get(&finfo,APR_FINFO_SIZE,file) == APR_SUCCESS) { /* Read message body */ body = &mrcp_message->body; body->buf = apr_palloc(mrcp_message->pool,finfo.size+1); body->length = (apr_size_t)finfo.size; if(apr_file_read(file,body->buf,&body->length) != APR_SUCCESS) { ast_log(LOG_WARNING, "Failed to read the content of grammar file: %s\n",grammar_path); } body->buf[body->length] = '\0'; } apr_file_close(file); } else { ast_log(LOG_WARNING, "No such grammar file available: %s\n",grammar_path); return -1; } } if(!body || !body->buf) { ast_log(LOG_WARNING, "No content available: %s\n",grammar_path); return -1; } /* Try to implicitly detect content type, if it's not specified */ if(!content_type) { if(strstr(body->buf,"#JSGF")) { content_type = "application/x-jsgf"; } else if(strstr(body->buf,"#ABNF")) { content_type = "application/srgs"; } else { content_type = "application/srgs+xml"; } } ast_log(LOG_NOTICE, "Load grammar name:%s type:%s path:%s '%s'\n", grammar_name, content_type, grammar_path, uni_speech_id_get(uni_speech)); /* 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,content_type,mrcp_message->pool); mrcp_generic_header_property_add(mrcp_message,GENERIC_HEADER_CONTENT_TYPE); apt_string_assign(&generic_header->content_id,grammar_name,mrcp_message->pool); mrcp_generic_header_property_add(mrcp_message,GENERIC_HEADER_CONTENT_ID); } /* 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; } return 0; }
/** 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; }