/* Response or event from the server arrived */
static apt_bool_t OnMessageReceive(mrcp_application_t* application, mrcp_session_t* session, mrcp_channel_t* channel, mrcp_message_t* message)
{
(void) application;
(void) session;
(void) channel;
/* Analyze, update your application state and reply messages here */
if (message->start_line.message_type == MRCP_MESSAGE_TYPE_RESPONSE) {
if (message->start_line.status_code != MRCP_STATUS_CODE_SUCCESS)
return sess_failed("SPEAK request failed");
if (message->start_line.request_state != MRCP_REQUEST_STATE_INPROGRESS)
return sess_failed("Failed to start SPEAK processing");
/* Start writing audio to file */
stream_started = TRUE;
return TRUE; /* Does not actually matter */
}
if (message->start_line.message_type != MRCP_MESSAGE_TYPE_EVENT)
return sess_failed("Unexpected message from the server");
if (message->start_line.method_id == SYNTHESIZER_SPEAK_COMPLETE) {
mrcp_synth_header_t* hdr = (mrcp_synth_header_t*) mrcp_resource_header_get(message);
printf("Speak complete: %d %.*s", hdr->completion_cause,
(int) hdr->completion_reason.length, hdr->completion_reason.buf);
stream_started = FALSE;
err = 0;
apr_thread_cond_signal(cond);
return TRUE; /* Does not actually matter */
}
return sess_failed("Unknown message recived");
}
cst_voice* flite_voices_best_match_get(flite_voices_t *voices, mrcp_message_t *message)
{
cst_voice *voice = NULL;
const char *voice_name = NULL;
mrcp_synth_header_t *synth_header = mrcp_resource_header_get(message);
if(synth_header) {
if(mrcp_resource_header_property_check(message,SYNTHESIZER_HEADER_VOICE_NAME) == TRUE) {
voice_name = synth_header->voice_param.name.buf;
}
}
if(voice_name) {
/* get voice by name */
flite_voice_t *flite_voice;
flite_voice = apr_hash_get(voices->table,voice_name,APR_HASH_KEY_STRING);
if(flite_voice) {
voice = flite_voice->self;
}
}
if(!voice) {
/* still no voice found, get the default one */
flite_voice_t *flite_voice = NULL;
void *val;
apr_hash_index_t *it = apr_hash_first(voices->pool,voices->table);
apr_hash_this(it,NULL,NULL,&val);
if(val) {
flite_voice = val;
voice = flite_voice->self;
}
}
return voice;
}
/** Process VERIFY request */
static apt_bool_t demo_verifier_channel_verify(mrcp_engine_channel_t *channel, mrcp_message_t *request, mrcp_message_t *response)
{
/* process verify request */
mrcp_verifier_header_t *verifier_header;
demo_verifier_channel_t *verifier_channel = channel->method_obj;
const mpf_codec_descriptor_t *descriptor = mrcp_engine_sink_stream_codec_get(channel);
if(!descriptor) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Get Codec Descriptor "APT_SIDRES_FMT, MRCP_MESSAGE_SIDRES(request));
response->start_line.status_code = MRCP_STATUS_CODE_METHOD_FAILED;
return FALSE;
}
verifier_channel->timers_started = TRUE;
/* get verifier header */
verifier_header = mrcp_resource_header_get(request);
if(verifier_header) {
if(mrcp_resource_header_property_check(request,VERIFIER_HEADER_START_INPUT_TIMERS) == TRUE) {
verifier_channel->timers_started = verifier_header->start_input_timers;
}
if(mrcp_resource_header_property_check(request,VERIFIER_HEADER_NO_INPUT_TIMEOUT) == TRUE) {
mpf_activity_detector_noinput_timeout_set(verifier_channel->detector,verifier_header->no_input_timeout);
}
if(mrcp_resource_header_property_check(request,VERIFIER_HEADER_SPEECH_COMPLETE_TIMEOUT) == TRUE) {
mpf_activity_detector_silence_timeout_set(verifier_channel->detector,verifier_header->speech_complete_timeout);
}
}
if(!verifier_channel->audio_out) {
const apt_dir_layout_t *dir_layout = channel->engine->dir_layout;
char *file_name = apr_psprintf(channel->pool,"voiceprint-%dkHz-%s.pcm",
descriptor->sampling_rate/1000,
request->channel_id.session_id.buf);
char *file_path = apt_vardir_filepath_get(dir_layout,file_name,channel->pool);
if(file_path) {
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Open Utterance Output File [%s] for Writing",file_path);
verifier_channel->audio_out = fopen(file_path,"wb");
if(!verifier_channel->audio_out) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Open Utterance Output File [%s] for Writing",file_path);
}
}
}
response->start_line.request_state = MRCP_REQUEST_STATE_INPROGRESS;
/* send asynchronous response */
mrcp_engine_channel_message_send(channel,response);
verifier_channel->verifier_request = request;
return TRUE;
}
/* Test SPEAK request */
static apt_bool_t speak_request_test(mrcp_resource_factory_t *factory, mrcp_message_t *message)
{
apt_bool_t res;
mrcp_generic_header_t *generic_header;
mrcp_synth_header_t *synth_header;
apt_log(APT_LOG_MARK,APT_PRIO_NOTICE,"Test SPEAK Request");
res = FALSE;
/* get generic header */
generic_header = mrcp_generic_header_get(message);
if(generic_header) {
/* test content type header */
if(mrcp_generic_header_property_check(message,GENERIC_HEADER_CONTENT_TYPE) == TRUE) {
if(strncasecmp(generic_header->content_type.buf,SAMPLE_CONTENT_TYPE,generic_header->content_type.length) == 0) {
/* OK */
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Get Content-Type: %s",generic_header->content_type.buf);
res = TRUE;
}
}
}
if(res == FALSE) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Test Generic Header");
return FALSE;
}
res = FALSE;
/* get synthesizer header */
synth_header = mrcp_resource_header_get(message);
if(synth_header) {
/* test voice age header */
if(mrcp_resource_header_property_check(message,SYNTHESIZER_HEADER_VOICE_AGE) == TRUE) {
if(synth_header->voice_param.age == SAMPLE_VOICE_AGE) {
/* OK */
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Get Voice-Age: %"APR_SIZE_T_FMT,synth_header->voice_param.age);
res = TRUE;
}
}
}
if(res == FALSE) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Test Synthesizer Header");
return FALSE;
}
if(strncasecmp(message->body.buf,SAMPLE_CONTENT,message->body.length) != 0) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Test Message Body");
return FALSE;
}
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Get Body: %s",message->body.buf);
return TRUE;
}
/** \brief Try to get result */
struct ast_speech_result* uni_recog_get(struct ast_speech *speech)
{
struct ast_speech_result *result;
mrcp_recog_header_t *recog_header;
uni_speech_t *uni_speech = speech->data;
if(uni_speech->is_inprogress) {
uni_recog_stop(speech);
}
if(!uni_speech->mrcp_event) {
ast_log(LOG_WARNING, "(%s) No RECOGNITION-COMPLETE message received\n",uni_speech->name);
return NULL;
}
/* Get recognizer header */
recog_header = mrcp_resource_header_get(uni_speech->mrcp_event);
if(!recog_header || mrcp_resource_header_property_check(uni_speech->mrcp_event,RECOGNIZER_HEADER_COMPLETION_CAUSE) != TRUE) {
ast_log(LOG_WARNING, "(%s) Missing completion cause in RECOGNITION-COMPLETE message\n",uni_speech->name);
return NULL;
}
ast_log(LOG_NOTICE, "(%s) Get result completion cause: %03d reason: %s\n",
uni_speech->name,
recog_header->completion_cause,
recog_header->completion_reason.buf ? recog_header->completion_reason.buf : "none");
if(recog_header->completion_cause != RECOGNIZER_COMPLETION_CAUSE_SUCCESS) {
ast_log(LOG_WARNING, "(%s) Recognition completed abnormally cause: %03d reason: %s\n",
uni_speech->name,
recog_header->completion_cause,
recog_header->completion_reason.buf ? recog_header->completion_reason.buf : "none");
return NULL;
}
result = uni_recog_speech_result_build(
uni_speech,
&uni_speech->mrcp_event->body,
uni_speech->mrcp_event->start_line.version);
if(result)
ast_set_flag(speech,AST_SPEECH_HAVE_RESULTS);
return result;
}
/** \brief Try to get result */
struct ast_speech_result* uni_recog_get(struct ast_speech *speech)
{
mrcp_recog_header_t *recog_header;
uni_speech_t *uni_speech = speech->data;
if(uni_speech->is_inprogress) {
uni_recog_stop(speech);
}
ast_log(LOG_NOTICE, "Get result '%s'\n",uni_speech_id_get(uni_speech));
if(!uni_speech->mrcp_event) {
ast_log(LOG_WARNING, "No RECOGNITION-COMPLETE message received\n");
return NULL;
}
/* Get recognizer header */
recog_header = mrcp_resource_header_get(uni_speech->mrcp_event);
if(!recog_header || mrcp_resource_header_property_check(uni_speech->mrcp_event,RECOGNIZER_HEADER_COMPLETION_CAUSE) != TRUE) {
ast_log(LOG_WARNING, "Missing Completion-Cause in RECOGNITION-COMPLETE message\n");
return NULL;
}
if(recog_header->completion_cause != RECOGNIZER_COMPLETION_CAUSE_SUCCESS) {
ast_log(LOG_WARNING, "Unsuccessful completion cause:%d reason:%s\n",
recog_header->completion_cause,
recog_header->completion_reason.buf ? recog_header->completion_reason.buf : "none");
return NULL;
}
if(speech->results) {
ast_speech_results_free(speech->results);
}
speech->results = uni_recog_speech_result_build(
&uni_speech->mrcp_event->body,
uni_speech->mrcp_event->start_line.version,
mrcp_application_session_pool_get(uni_speech->session));
if(speech->results) {
ast_set_flag(speech,AST_SPEECH_HAVE_RESULTS);
}
return speech->results;
}
/** Set Swift port params */
static apt_bool_t mrcp_swift_channel_params_set(mrcp_swift_channel_t *synth_channel, mrcp_message_t *message)
{
const char *name;
mrcp_synth_header_t *synth_header = mrcp_resource_header_get(message);
mrcp_generic_header_t *generic_header = mrcp_generic_header_get(message);
if(synth_header) {
if(mrcp_resource_header_property_check(message,SYNTHESIZER_HEADER_PROSODY_VOLUME) == TRUE) {
int volume = 0;
if(swift_prosody_volume_get(&synth_header->prosody_param.volume,&volume) == TRUE) {
name = "audio/volume";
apt_log(APT_LOG_MARK,APT_PRIO_DEBUG,"Swift Param %s=%d",name,volume);
mrcp_swift_channel_param_set(synth_channel,name,swift_val_int(volume));
}
}
if(mrcp_resource_header_property_check(message,SYNTHESIZER_HEADER_PROSODY_RATE) == TRUE) {
int rate = 0;
if(swift_prosody_rate_get(&synth_header->prosody_param.rate,&rate) == TRUE) {
name = "speech/rate";
apt_log(APT_LOG_MARK,APT_PRIO_DEBUG,"Swift Param %s=%d",name,rate);
mrcp_swift_channel_param_set(synth_channel,name,swift_val_int(rate));
}
}
}
if(generic_header) {
if(mrcp_generic_header_property_check(message,GENERIC_HEADER_CONTENT_TYPE) == TRUE) {
name = "tts/content-type";
apt_log(APT_LOG_MARK,APT_PRIO_DEBUG,"Swift Param %s=%s",name,generic_header->content_type);
mrcp_swift_channel_param_set(synth_channel,name,swift_val_string(generic_header->content_type.buf));
}
if(mrcp_generic_header_property_check(message,GENERIC_HEADER_CONTENT_ENCODING) == TRUE) {
name = "tts/text-encoding";
apt_log(APT_LOG_MARK,APT_PRIO_DEBUG,"Swift Param %s=%s",name,generic_header->content_encoding);
mrcp_swift_channel_param_set(synth_channel,name,swift_val_string(generic_header->content_encoding.buf));
}
}
return TRUE;
}
/** Process RECORD request */
static apt_bool_t recorder_channel_record(recorder_channel_t *recorder_channel, mrcp_message_t *request, mrcp_message_t *response)
{
/* process RECORD request */
mrcp_recorder_header_t *recorder_header;
recorder_channel->timers_started = TRUE;
/* get recorder header */
recorder_header = mrcp_resource_header_get(request);
if(recorder_header) {
if(mrcp_resource_header_property_check(request,RECORDER_HEADER_START_INPUT_TIMERS) == TRUE) {
recorder_channel->timers_started = recorder_header->start_input_timers;
}
if(mrcp_resource_header_property_check(request,RECORDER_HEADER_NO_INPUT_TIMEOUT) == TRUE) {
mpf_activity_detector_noinput_timeout_set(recorder_channel->detector,recorder_header->no_input_timeout);
}
if(mrcp_resource_header_property_check(request,RECORDER_HEADER_FINAL_SILENCE) == TRUE) {
mpf_activity_detector_silence_timeout_set(recorder_channel->detector,recorder_header->final_silence);
}
if(mrcp_resource_header_property_check(request,RECORDER_HEADER_MAX_TIME) == TRUE) {
recorder_channel->max_time = recorder_header->max_time;
}
}
/* open file to record */
if(recorder_file_open(recorder_channel,request) == FALSE) {
response->start_line.request_state = MRCP_REQUEST_STATE_COMPLETE;
response->start_line.status_code = MRCP_STATUS_CODE_METHOD_FAILED;
/* send asynchronous response */
mrcp_engine_channel_message_send(recorder_channel->channel,response);
return TRUE;
}
recorder_channel->cur_time = 0;
recorder_channel->cur_size = 0;
response->start_line.request_state = MRCP_REQUEST_STATE_INPROGRESS;
/* send asynchronous response */
mrcp_engine_channel_message_send(recorder_channel->channel,response);
recorder_channel->record_request = request;
return TRUE;
}
static apt_bool_t synth_request_barge_in_occurred(mrcp_synth_state_machine_t *state_machine, mrcp_message_t *message)
{
mrcp_message_t *response_message;
if(state_machine->speaker) {
apt_bool_t kill_on_barge_in = TRUE;
mrcp_synth_header_t *synth_header = mrcp_resource_header_get(message);
if(synth_header) {
if(mrcp_resource_header_property_check(message,SYNTHESIZER_HEADER_KILL_ON_BARGE_IN) == TRUE) {
kill_on_barge_in = synth_header->kill_on_barge_in;
}
}
if(kill_on_barge_in == TRUE) {
apt_log(APT_PRIO_INFO,"Process BARGE-IN Request [%d]",message->start_line.request_id);
return synth_request_dispatch(state_machine,message);
}
}
/* found no kill-on-bargein enabled in-progress SPEAK request, sending immediate response */
response_message = mrcp_response_create(message,message->pool);
return synth_response_dispatch(state_machine,response_message);
}
/** Process RECOGNIZE request */
static apt_bool_t demo_recog_channel_recognize(mrcp_engine_channel_t *channel, mrcp_message_t *request, mrcp_message_t *response)
{
/* process RECOGNIZE request */
mrcp_recog_header_t *recog_header;
demo_recog_channel_t *recog_channel = channel->method_obj;
recog_channel->timers_started = TRUE;
/* get recognizer header */
recog_header = mrcp_resource_header_get(request);
if(recog_header) {
if(mrcp_resource_header_property_check(request,RECOGNIZER_HEADER_START_INPUT_TIMERS) == TRUE) {
recog_channel->timers_started = recog_header->start_input_timers;
}
if(mrcp_resource_header_property_check(request,RECOGNIZER_HEADER_NO_INPUT_TIMEOUT) == TRUE) {
mpf_activity_detector_noinput_timeout_set(recog_channel->detector,recog_header->no_input_timeout);
}
if(mrcp_resource_header_property_check(request,RECOGNIZER_HEADER_SPEECH_COMPLETE_TIMEOUT) == TRUE) {
mpf_activity_detector_silence_timeout_set(recog_channel->detector,recog_header->speech_complete_timeout);
}
}
if(!recog_channel->audio_out) {
const apt_dir_layout_t *dir_layout = channel->engine->dir_layout;
const mpf_codec_descriptor_t *descriptor = mrcp_engine_sink_stream_codec_get(channel);
char *file_name = apr_psprintf(channel->pool,"utter-%dkHz-%s.pcm",
descriptor ? descriptor->sampling_rate/1000 : 8,
request->channel_id.session_id.buf);
char *file_path = apt_datadir_filepath_get(dir_layout,file_name,channel->pool);
if(file_path) {
recog_channel->audio_out = fopen(file_path,"wb");
}
}
response->start_line.request_state = MRCP_REQUEST_STATE_INPROGRESS;
/* send asynchronous response */
mrcp_engine_channel_message_send(channel,response);
recog_channel->recog_request = request;
return TRUE;
}
/** Process SET-PARAMS request */
static apt_bool_t demo_synth_channel_set_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) {
/* check voice age header */
if(mrcp_resource_header_property_check(request,SYNTHESIZER_HEADER_VOICE_AGE) == TRUE) {
apt_log(SYNTH_LOG_MARK,APT_PRIO_INFO,"Set Voice Age [%"APR_SIZE_T_FMT"]",
req_synth_header->voice_param.age);
}
/* check voice name header */
if(mrcp_resource_header_property_check(request,SYNTHESIZER_HEADER_VOICE_NAME) == TRUE) {
apt_log(SYNTH_LOG_MARK,APT_PRIO_INFO,"Set Voice Name [%s]",
req_synth_header->voice_param.name.buf);
}
}
/* send asynchronous response */
mrcp_engine_channel_message_send(channel,response);
return TRUE;
}
/** 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;
}
/** Set voice matching specified criteria */
static apt_bool_t mrcp_swift_channel_voice_set(mrcp_swift_channel_t *synth_channel, mrcp_message_t *message)
{
mrcp_synth_header_t *synth_header = mrcp_resource_header_get(message);
char search_criteria[1024];
int offset = 0;
swift_voice *voice;
swift_result_t res;
if(!synth_header) {
/* no params to set */
return TRUE;
}
if(mrcp_resource_header_property_check(message,SYNTHESIZER_HEADER_VOICE_NAME) == TRUE) {
offset += search_criteria_delimiter_add(search_criteria+offset,sizeof(search_criteria)-offset,(offset == 0));
offset += apr_snprintf(search_criteria+offset,sizeof(search_criteria)-offset,"speaker/name=%s",synth_header->voice_param.name.buf);
}
if(mrcp_resource_header_property_check(message,SYNTHESIZER_HEADER_VOICE_GENDER) == TRUE) {
switch(synth_header->voice_param.gender) {
case VOICE_GENDER_MALE:
offset += search_criteria_delimiter_add(search_criteria+offset,sizeof(search_criteria)-offset,offset == 0);
offset += apr_snprintf(search_criteria+offset,sizeof(search_criteria)-offset,"speaker/gender=male");
break;
case VOICE_GENDER_FEMALE:
offset += search_criteria_delimiter_add(search_criteria+offset,sizeof(search_criteria)-offset,offset == 0);
offset += apr_snprintf(search_criteria+offset,sizeof(search_criteria)-offset,"speaker/gender=female");
break;
default:
break;
}
}
if(mrcp_resource_header_property_check(message,SYNTHESIZER_HEADER_VOICE_AGE) == TRUE) {
offset += search_criteria_delimiter_add(search_criteria+offset,sizeof(search_criteria)-offset,offset == 0);
offset += apr_snprintf(search_criteria+offset,sizeof(search_criteria)-offset,"speaker/age=%d",synth_header->voice_param.age);
}
if(mrcp_resource_header_property_check(message,SYNTHESIZER_HEADER_SPEECH_LANGUAGE) == TRUE) {
const char *swift_lang_name = NULL;
if(swift_speech_language_table) {
swift_lang_name = apr_table_get(swift_speech_language_table,synth_header->speech_language.buf);
}
if(!swift_lang_name) {
swift_lang_name = synth_header->speech_language.buf;
}
offset += search_criteria_delimiter_add(search_criteria+offset,sizeof(search_criteria)-offset,offset == 0);
offset += apr_snprintf(search_criteria+offset,sizeof(search_criteria)-offset,"language/name=%s",swift_lang_name);
}
if(offset > 0) {
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Find Voices Matching the Criteria [%s]",search_criteria);
if((voice = swift_port_find_first_voice(synth_channel->port,search_criteria,NULL)) == NULL) {
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"No Swift Voice Available Matching the Criteria [%s]",search_criteria);
voice = swift_port_find_first_voice(synth_channel->port,NULL,NULL);
}
if(SWIFT_FAILED(res = swift_port_set_voice(synth_channel->port,voice)) ) {
const char *error_string = swift_strerror(res);
apt_log(APT_LOG_MARK,APT_PRIO_INFO,error_string);
return FALSE;
}
}
return TRUE;
}
/* 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;
}
