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;
}
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;
}
FILE* VerifierSession::GetAudioIn(const mpf_codec_descriptor_t* pDescriptor, apr_pool_t* pool) const
{
const VerifierScenario* pScenario = GetScenario();
const char* pVoiceprintIdentifier = pScenario->GetVoiceprintIdentifier();
if(!pVoiceprintIdentifier)
{
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"No Voiceprint Specified");
return NULL;
}
const char* pFileName = apr_psprintf(pool,"%s-%dkHz.pcm",
pVoiceprintIdentifier,
pDescriptor->sampling_rate/1000);
apt_dir_layout_t* pDirLayout = pScenario->GetDirLayout();
const char* pFilePath = apt_datadir_filepath_get(pDirLayout,pFileName,pool);
if(!pFilePath)
return NULL;
FILE* pFile = fopen(pFilePath,"rb");
if(!pFile)
{
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Cannot Find [%s]",pFilePath);
return NULL;
}
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Set [%s] as Speech Source",pFilePath);
return pFile;
}
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;
}
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;
}
bool RecogSession::OnDefineGrammar(mrcp_channel_t* pMrcpChannel)
{
if(GetScenario()->IsRecognizeEnabled())
{
return StartRecognition(pMrcpChannel);
}
return Terminate();
}
FILE* SynthSession::GetAudioOut(const mpf_codec_descriptor_t* pDescriptor, apr_pool_t* pool) const
{
char* pFileName = apr_psprintf(pool,"synth-%dkHz-%s.pcm",pDescriptor->sampling_rate/1000, GetMrcpSessionId());
apt_dir_layout_t* pDirLayout = GetScenario()->GetDirLayout();
char* pFilePath = apt_datadir_filepath_get(pDirLayout,pFileName,pool);
if(!pFilePath)
return NULL;
return fopen(pFilePath,"wb");
}
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;
}
FILE* RecorderSession::GetAudioIn(const mpf_codec_descriptor_t* pDescriptor, apr_pool_t* pool) const
{
const char* pFileName = GetScenario()->GetAudioSource();
if(!pFileName)
{
pFileName = apr_psprintf(pool,"demo-%dkHz.pcm",pDescriptor->sampling_rate/1000);
}
apt_dir_layout_t* pDirLayout = GetScenario()->GetDirLayout();
const char* pFilePath = apt_datadir_filepath_get(pDirLayout,pFileName,pool);
if(!pFilePath)
return NULL;
FILE* pFile = fopen(pFilePath,"rb");
if(!pFile)
{
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Cannot Find [%s]",pFilePath);
return NULL;
}
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Set [%s] as Speech Source",pFilePath);
return pFile;
}
RecogChannel* RecogSession::CreateRecogChannel()
{
mrcp_channel_t* pChannel;
mpf_termination_t* pTermination;
mpf_stream_capabilities_t* pCapabilities;
apr_pool_t* pool = GetSessionPool();
/* create channel */
RecogChannel *pRecogChannel = new RecogChannel;
pRecogChannel->m_pMrcpChannel = NULL;
pRecogChannel->m_Streaming = false;
pRecogChannel->m_pAudioIn = NULL;
pRecogChannel->m_TimeToComplete = 0;
/* create source stream capabilities */
pCapabilities = mpf_source_stream_capabilities_create(pool);
GetScenario()->InitCapabilities(pCapabilities);
static const mpf_audio_stream_vtable_t audio_stream_vtable =
{
NULL,
NULL,
NULL,
ReadStream,
NULL,
NULL,
NULL
};
pTermination = CreateAudioTermination(
&audio_stream_vtable, /* virtual methods table of audio stream */
pCapabilities, /* capabilities of audio stream */
pRecogChannel); /* object to associate */
pChannel = CreateMrcpChannel(
MRCP_RECOGNIZER_RESOURCE, /* MRCP resource identifier */
pTermination, /* media termination, used to terminate audio stream */
NULL, /* RTP descriptor, used to create RTP termination (NULL by default) */
pRecogChannel); /* object to associate */
if(!pChannel)
{
delete pRecogChannel;
return NULL;
}
pRecogChannel->m_pMrcpChannel = pChannel;
return pRecogChannel;
}
SynthChannel* SynthSession::CreateSynthChannel()
{
mrcp_channel_t* pChannel;
mpf_termination_t* pTermination;
mpf_stream_capabilities_t* pCapabilities;
apr_pool_t* pool = GetSessionPool();
/* create channel */
SynthChannel* pSynthChannel = new SynthChannel;
/* create sink stream capabilities */
pCapabilities = mpf_sink_stream_capabilities_create(pool);
GetScenario()->InitCapabilities(pCapabilities);
static const mpf_audio_stream_vtable_t audio_stream_vtable =
{
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
WriteStream,
NULL
};
pTermination = CreateAudioTermination(
&audio_stream_vtable, /* virtual methods table of audio stream */
pCapabilities, /* capabilities of audio stream */
pSynthChannel); /* object to associate */
pChannel = CreateMrcpChannel(
MRCP_SYNTHESIZER_RESOURCE, /* MRCP resource identifier */
pTermination, /* media termination, used to terminate audio stream */
NULL, /* RTP descriptor, used to create RTP termination (NULL by default) */
pSynthChannel); /* object to associate */
if(!pChannel)
{
delete pSynthChannel;
return NULL;
}
pSynthChannel->m_pMrcpChannel = pChannel;
return pSynthChannel;
}
FILE* SynthSession::GetAudioOut(const mpf_codec_descriptor_t* pDescriptor, apr_pool_t* pool) const
{
FILE* file;
char* pFileName = apr_psprintf(pool,"synth-%dkHz-%s.pcm",pDescriptor->sampling_rate/1000, GetMrcpSessionId());
apt_dir_layout_t* pDirLayout = GetScenario()->GetDirLayout();
char* pFilePath = apt_vardir_filepath_get(pDirLayout,pFileName,pool);
if(!pFilePath)
return NULL;
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Open Speech Output File [%s] for Writing",pFilePath);
file = fopen(pFilePath,"wb");
if(!file)
{
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Open Speech Output File [%s] for Writing",pFilePath);
return NULL;
}
return file;
}
bool SynthSession::Start()
{
if(!GetScenario()->IsSpeakEnabled())
return false;
/* create channel and associate all the required data */
m_pSynthChannel = CreateSynthChannel();
if(!m_pSynthChannel)
return false;
/* add channel to session (send asynchronous request) */
if(!AddMrcpChannel(m_pSynthChannel->m_pMrcpChannel))
{
delete m_pSynthChannel;
m_pSynthChannel = NULL;
return false;
}
return true;
}
bool RecorderSession::Start()
{
const RecorderScenario* pScenario = GetScenario();
if(!pScenario->IsRecordEnabled())
return false;
/* create channel and associate all the required data */
m_pRecorderChannel = CreateRecorderChannel();
if(!m_pRecorderChannel)
return false;
/* add channel to session (send asynchronous request) */
if(!AddMrcpChannel(m_pRecorderChannel->m_pMrcpChannel))
{
delete m_pRecorderChannel;
m_pRecorderChannel = NULL;
return false;
}
return true;
}
bool RecogSession::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();
}
if(GetScenario()->IsDefineGrammarEnabled())
{
mrcp_message_t* pMrcpMessage = CreateDefineGrammarRequest(pMrcpChannel);
if(pMrcpMessage)
SendMrcpRequest(pMrcpChannel,pMrcpMessage);
return true;
}
return StartRecognition(pMrcpChannel);
}