/** Generate MRCP descriptor by RTSP request */ MRCP_DECLARE(mrcp_session_descriptor_t*) mrcp_descriptor_generate_by_rtsp_request( const rtsp_message_t *request, const char *force_destination_ip, const apr_table_t *resource_map, apr_pool_t *pool, su_home_t *home) { mrcp_session_descriptor_t *descriptor = NULL; const char *resource_name = mrcp_name_get_by_rtsp_name( resource_map, request->start_line.common.request_line.resource_name); if(!resource_name) { return NULL; } if(request->start_line.common.request_line.method_id == RTSP_METHOD_SETUP) { if(rtsp_header_property_check(&request->header.property_set,RTSP_HEADER_FIELD_CONTENT_TYPE) == TRUE && rtsp_header_property_check(&request->header.property_set,RTSP_HEADER_FIELD_CONTENT_LENGTH) == TRUE && request->body.buf) { sdp_parser_t *parser; sdp_session_t *sdp; parser = sdp_parse(home,request->body.buf,request->body.length,0); sdp = sdp_session(parser); if(sdp) { descriptor = mrcp_session_descriptor_create(pool); mrcp_descriptor_generate_by_sdp_session(descriptor,sdp,force_destination_ip,pool); } else { apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Parse SDP Message"); } sdp_parser_free(parser); } else { /* create default descriptor in case RTSP SETUP contains no SDP */ mpf_rtp_media_descriptor_t *media; descriptor = mrcp_session_descriptor_create(pool); media = apr_palloc(pool,sizeof(mpf_rtp_media_descriptor_t)); mpf_rtp_media_descriptor_init(media); media->state = MPF_MEDIA_ENABLED; media->id = mrcp_session_audio_media_add(descriptor,media); if(rtsp_header_property_check(&request->header.property_set,RTSP_HEADER_FIELD_TRANSPORT) == TRUE) { media->port = request->header.transport.client_port_range.min; media->ip = request->header.transport.destination; } } if(descriptor) { apt_string_assign(&descriptor->resource_name,resource_name,pool); descriptor->resource_state = TRUE; } } else if(request->start_line.common.request_line.method_id == RTSP_METHOD_TEARDOWN) { descriptor = mrcp_session_descriptor_create(pool); apt_string_assign(&descriptor->resource_name,resource_name,pool); descriptor->resource_state = FALSE; } return descriptor; }
/* 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; }
/** 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; }
/** Generate RTP media descriptor by SDP media */ static apt_bool_t mpf_rtp_media_generate(mpf_rtp_media_descriptor_t *rtp_media, const sdp_media_t *sdp_media, const apt_str_t *ip, apr_pool_t *pool) { mpf_rtp_attrib_e id; apt_str_t name; sdp_attribute_t *attrib = NULL; sdp_rtpmap_t *map; mpf_codec_descriptor_t *codec; for(attrib = sdp_media->m_attributes; attrib; attrib=attrib->a_next) { apt_string_set(&name,attrib->a_name); id = mpf_rtp_attrib_id_find(&name); switch(id) { case RTP_ATTRIB_PTIME: rtp_media->ptime = (apr_uint16_t)atoi(attrib->a_value); break; default: break; } } mpf_codec_list_init(&rtp_media->codec_list,5,pool); for(map = sdp_media->m_rtpmaps; map; map = map->rm_next) { codec = mpf_codec_list_add(&rtp_media->codec_list); if(codec) { codec->payload_type = (apr_byte_t)map->rm_pt; apt_string_assign(&codec->name,map->rm_encoding,pool); codec->sampling_rate = (apr_uint16_t)map->rm_rate; codec->channel_count = 1; } } switch(sdp_media->m_mode) { case sdp_inactive: rtp_media->direction = STREAM_DIRECTION_NONE; break; case sdp_sendonly: rtp_media->direction = STREAM_DIRECTION_SEND; break; case sdp_recvonly: rtp_media->direction = STREAM_DIRECTION_RECEIVE; break; case sdp_sendrecv: rtp_media->direction = STREAM_DIRECTION_DUPLEX; break; } if(sdp_media->m_connections) { apt_string_assign(&rtp_media->ip,sdp_media->m_connections->c_address,pool); } else { rtp_media->ip = *ip; } if(sdp_media->m_port) { rtp_media->port = (apr_port_t)sdp_media->m_port; rtp_media->state = MPF_MEDIA_ENABLED; } else { rtp_media->state = MPF_MEDIA_DISABLED; } return TRUE; }
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* 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* 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 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; }
/** Create RTSP session handle */ RTSP_DECLARE(rtsp_client_session_t*) rtsp_client_session_create( rtsp_client_t *client, const char *server_ip, apr_port_t server_port, const char *resource_location) { rtsp_client_session_t *session; apr_pool_t *pool = apt_pool_create(); session = apr_palloc(pool,sizeof(rtsp_client_session_t)); session->pool = pool; session->obj = NULL; session->connection = NULL; session->active_request = NULL; session->pending_request_queue = apt_list_create(pool); session->request_timer = apt_poller_task_timer_create( client->task, rtsp_client_timer_proc, session, pool); session->resource_table = apr_hash_make(pool); session->term_state = TERMINATION_STATE_NONE; apt_string_assign(&session->server_ip,server_ip,pool); session->server_port = server_port; apt_string_assign(&session->resource_location,resource_location,pool); apt_string_reset(&session->id); apt_log(RTSP_LOG_MARK,APT_PRIO_NOTICE,"Create RTSP Handle " APT_PTR_FMT,session); return session; }
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; }
/** Generate MRCP descriptor by RTSP response */ MRCP_DECLARE(mrcp_session_descriptor_t*) mrcp_descriptor_generate_by_rtsp_response( const rtsp_message_t *request, const rtsp_message_t *response, const char *force_destination_ip, const apr_table_t *resource_map, apr_pool_t *pool, su_home_t *home) { mrcp_session_descriptor_t *descriptor = NULL; const char *resource_name = mrcp_name_get_by_rtsp_name( resource_map, request->start_line.common.request_line.resource_name); if(!resource_name) { return NULL; } if(request->start_line.common.request_line.method_id == RTSP_METHOD_SETUP) { if(rtsp_header_property_check(&response->header,RTSP_HEADER_FIELD_CONTENT_TYPE) == TRUE && rtsp_header_property_check(&response->header,RTSP_HEADER_FIELD_CONTENT_LENGTH) == TRUE && response->body.buf) { sdp_parser_t *parser; sdp_session_t *sdp; parser = sdp_parse(home,response->body.buf,response->body.length,0); sdp = sdp_session(parser); if(sdp) { descriptor = mrcp_session_descriptor_create(pool); mrcp_descriptor_generate_by_sdp_session(descriptor,sdp,force_destination_ip,pool); apt_string_assign(&descriptor->resource_name,resource_name,pool); descriptor->resource_state = TRUE; descriptor->response_code = response->start_line.common.status_line.status_code; } else { apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Parse SDP Message"); } sdp_parser_free(parser); } else { descriptor = mrcp_session_descriptor_create(pool); apt_string_assign(&descriptor->resource_name,resource_name,pool); descriptor->resource_state = FALSE; } } else if(request->start_line.common.request_line.method_id == RTSP_METHOD_TEARDOWN) { descriptor = mrcp_session_descriptor_create(pool); apt_string_assign(&descriptor->resource_name,resource_name,pool); descriptor->resource_state = FALSE; } return descriptor; }
/** Generate MRCP descriptor by SDP session */ MRCP_DECLARE(mrcp_session_descriptor_t*) mrcp_descriptor_generate_by_sdp_session(const sdp_session_t *sdp, const char *force_destination_ip, apr_pool_t *pool) { sdp_media_t *sdp_media; mrcp_session_descriptor_t *descriptor; if(!sdp) { apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Invalid SDP Message"); return NULL; } descriptor = mrcp_session_descriptor_create(pool); if(force_destination_ip) { apt_string_assign(&descriptor->ip,force_destination_ip,pool); } else if(sdp->sdp_connection) { apt_string_assign(&descriptor->ip,sdp->sdp_connection->c_address,pool); } for(sdp_media=sdp->sdp_media; sdp_media; sdp_media=sdp_media->m_next) { switch(sdp_media->m_type) { case sdp_media_audio: { mpf_rtp_media_descriptor_t *media = apr_palloc(pool,sizeof(mpf_rtp_media_descriptor_t)); mpf_rtp_media_descriptor_init(media); media->id = mrcp_session_audio_media_add(descriptor,media); mpf_rtp_media_generate(media,sdp_media,&descriptor->ip,pool); break; } case sdp_media_video: { mpf_rtp_media_descriptor_t *media = apr_palloc(pool,sizeof(mpf_rtp_media_descriptor_t)); mpf_rtp_media_descriptor_init(media); media->id = mrcp_session_video_media_add(descriptor,media); mpf_rtp_media_generate(media,sdp_media,&descriptor->ip,pool); break; } case sdp_media_application: { mrcp_control_descriptor_t *control_media = mrcp_control_descriptor_create(pool); control_media->id = mrcp_session_control_media_add(descriptor,control_media); mrcp_control_media_generate(control_media,sdp_media,&descriptor->ip,pool); break; } default: apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Not Supported SDP Media [%s]", sdp_media->m_type_name); break; } } return descriptor; }
/** Generate MRCP control media by SDP media */ static apt_bool_t mrcp_control_media_generate(mrcp_control_descriptor_t *control_media, const sdp_media_t *sdp_media, const apt_str_t *ip, apr_pool_t *pool) { mrcp_attrib_e id; apt_str_t name; apt_str_t value; sdp_attribute_t *attrib = NULL; apt_string_set(&name,sdp_media->m_proto_name); control_media->proto = mrcp_proto_find(&name); if(control_media->proto != MRCP_PROTO_TCP) { apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Not supported SDP Proto [%s], expected [%s]",sdp_media->m_proto_name,mrcp_proto_get(MRCP_PROTO_TCP)->buf); return FALSE; } for(attrib = sdp_media->m_attributes; attrib; attrib=attrib->a_next) { apt_string_set(&name,attrib->a_name); id = mrcp_attrib_id_find(&name); switch(id) { case MRCP_ATTRIB_SETUP: apt_string_set(&value,attrib->a_value); control_media->setup_type = mrcp_setup_type_find(&value); break; case MRCP_ATTRIB_CONNECTION: apt_string_set(&value,attrib->a_value); control_media->connection_type = mrcp_connection_type_find(&value); break; case MRCP_ATTRIB_RESOURCE: apt_string_assign(&control_media->resource_name,attrib->a_value,pool); break; case MRCP_ATTRIB_CHANNEL: apt_string_set(&value,attrib->a_value); apt_id_resource_parse(&value,'@',&control_media->session_id,&control_media->resource_name,pool); break; case MRCP_ATTRIB_CMID: mrcp_cmid_add(control_media->cmid_arr,atoi(attrib->a_value)); break; default: break; } } if(sdp_media->m_connections) { apt_string_assign(&control_media->ip,sdp_media->m_connections->c_address,pool); } else { control_media->ip = *ip; } control_media->port = (apr_port_t)sdp_media->m_port; return TRUE; }
/** Generate MRCP descriptor by SDP session */ static mrcp_session_descriptor_t* mrcp_descriptor_generate_by_sdp_session(const sdp_session_t *sdp, apr_pool_t *pool) { sdp_media_t *sdp_media; mrcp_session_descriptor_t *descriptor = mrcp_session_descriptor_create(pool); if(sdp->sdp_connection) { apt_string_assign(&descriptor->ip,sdp->sdp_connection->c_address,pool); } for(sdp_media=sdp->sdp_media; sdp_media; sdp_media=sdp_media->m_next) { switch(sdp_media->m_type) { case sdp_media_audio: { mpf_rtp_media_descriptor_t *media = apr_palloc(pool,sizeof(mpf_rtp_media_descriptor_t)); mpf_rtp_media_descriptor_init(media); media->base.id = mrcp_session_audio_media_add(descriptor,media); mpf_rtp_media_generate(media,sdp_media,&descriptor->ip,pool); break; } case sdp_media_video: { mpf_rtp_media_descriptor_t *media = apr_palloc(pool,sizeof(mpf_rtp_media_descriptor_t)); mpf_rtp_media_descriptor_init(media); media->base.id = mrcp_session_video_media_add(descriptor,media); mpf_rtp_media_generate(media,sdp_media,&descriptor->ip,pool); break; } default: apt_log(APT_PRIO_INFO,"Not Supported SDP Media [%s]", sdp_media->m_type_name); break; } } return descriptor; }
static apt_bool_t rtsp_server_message_handler(rtsp_server_connection_t *rtsp_connection, rtsp_message_t *message, apt_message_status_e status) { if(status == APT_MESSAGE_STATUS_COMPLETE) { /* message is completely parsed */ apt_str_t *destination; destination = &message->header.transport.destination; if(!destination->buf && rtsp_connection->client_ip) { apt_string_assign(destination,rtsp_connection->client_ip,rtsp_connection->pool); } rtsp_server_session_request_process(rtsp_connection->server,rtsp_connection,message); } else if(status == APT_MESSAGE_STATUS_INVALID) { /* error case */ rtsp_message_t *response; apt_log(RTSP_LOG_MARK,APT_PRIO_WARNING,"Failed to Parse RTSP Data"); if(message) { response = rtsp_response_create(message,RTSP_STATUS_CODE_BAD_REQUEST, RTSP_REASON_PHRASE_BAD_REQUEST,message->pool); if(rtsp_server_message_send(rtsp_connection->server,rtsp_connection,response) == FALSE) { apt_log(RTSP_LOG_MARK,APT_PRIO_WARNING,"Failed to Send RTSP Response"); } } } return TRUE; }
/* 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) { /* set transparent header fields */ apt_header_field_t *header_field; header_field = apt_header_field_create_c("Content-Type",SAMPLE_CONTENT_TYPE,message->pool); if(header_field) { apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Set %s: %s",header_field->name.buf,header_field->value.buf); mrcp_message_header_field_add(message,header_field); } header_field = apt_header_field_create_c("Voice-Age",SAMPLE_VOICE_AGE,message->pool); if(header_field) { apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Set %s: %s",header_field->name.buf,header_field->value.buf); mrcp_message_header_field_add(message,header_field); } /* 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; }
/** Create demo RTP termination descriptor */ mpf_rtp_termination_descriptor_t* demo_rtp_descriptor_create(apr_pool_t *pool) { mpf_codec_descriptor_t *codec_descriptor; mpf_rtp_media_descriptor_t *media; /* create rtp descriptor */ mpf_rtp_termination_descriptor_t *rtp_descriptor = apr_palloc(pool,sizeof(mpf_rtp_termination_descriptor_t)); mpf_rtp_termination_descriptor_init(rtp_descriptor); /* create rtp local media */ media = apr_palloc(pool,sizeof(mpf_rtp_media_descriptor_t)); mpf_rtp_media_descriptor_init(media); apt_string_assign(&media->ip,"127.0.0.1",pool); media->port = 6000; media->state = MPF_MEDIA_ENABLED; media->direction = STREAM_DIRECTION_RECEIVE; /* initialize codec list */ mpf_codec_list_init(&media->codec_list,2,pool); /* set codec descriptor */ codec_descriptor = mpf_codec_list_add(&media->codec_list); if(codec_descriptor) { codec_descriptor->payload_type = 0; } /* set another codec descriptor */ codec_descriptor = mpf_codec_list_add(&media->codec_list); if(codec_descriptor) { codec_descriptor->payload_type = 96; apt_string_set(&codec_descriptor->name,"PCMU"); codec_descriptor->sampling_rate = 16000; codec_descriptor->channel_count = 1; } rtp_descriptor->audio.local = media; return rtp_descriptor; }
/** 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; }
/* 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; }
/** 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; }
/** 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; }
/** Generate resource discovery descriptor by RTSP response */ MRCP_DECLARE(mrcp_session_descriptor_t*) mrcp_resource_discovery_response_generate( const rtsp_message_t *request, const rtsp_message_t *response, const apr_table_t *resource_map, apr_pool_t *pool, su_home_t *home) { mrcp_session_descriptor_t *descriptor = NULL; const char *resource_name = mrcp_name_get_by_rtsp_name( resource_map, request->start_line.common.request_line.resource_name); if(!resource_name) { return NULL; } descriptor = mrcp_session_descriptor_create(pool); apt_string_assign(&descriptor->resource_name,resource_name,pool); if(rtsp_header_property_check(&response->header,RTSP_HEADER_FIELD_CONTENT_TYPE) == TRUE && rtsp_header_property_check(&response->header,RTSP_HEADER_FIELD_CONTENT_LENGTH) == TRUE && response->body.buf) { sdp_parser_t *parser; sdp_session_t *sdp; parser = sdp_parse(home,response->body.buf,response->body.length,0); sdp = sdp_session(parser); if(sdp) { mrcp_descriptor_generate_by_sdp_session(descriptor,sdp,0,pool); descriptor->resource_state = TRUE; descriptor->response_code = response->start_line.common.status_line.status_code; } else { apt_string_assign(&descriptor->resource_name,resource_name,pool); descriptor->resource_state = TRUE; } sdp_parser_free(parser); } else { descriptor->resource_state = FALSE; } return descriptor; }
/** Generate MRCP descriptor by RTSP response */ MRCP_DECLARE(mrcp_session_descriptor_t*) mrcp_descriptor_generate_by_rtsp_response(const rtsp_message_t *request, const rtsp_message_t *response, apr_pool_t *pool, su_home_t *home) { mrcp_session_descriptor_t *descriptor = NULL; const char *resource_name = request->start_line.common.request_line.resource_name; if(!resource_name) { return NULL; } if(request->start_line.common.request_line.method_id == RTSP_METHOD_SETUP) { if(rtsp_header_property_check(&response->header.property_set,RTSP_HEADER_FIELD_CONTENT_TYPE) == TRUE && rtsp_header_property_check(&response->header.property_set,RTSP_HEADER_FIELD_CONTENT_LENGTH) == TRUE && response->body.buf) { sdp_parser_t *parser; sdp_session_t *sdp; parser = sdp_parse(home,response->body.buf,response->body.length,0); sdp = sdp_session(parser); descriptor = mrcp_descriptor_generate_by_sdp_session(sdp,pool); if(descriptor) { apt_string_assign(&descriptor->resource_name,resource_name,pool); descriptor->resource_state = TRUE; } sdp_parser_free(parser); } else { descriptor = mrcp_session_descriptor_create(pool); if(descriptor) { apt_string_assign(&descriptor->resource_name,resource_name,pool); descriptor->resource_state = FALSE; } } } else if(request->start_line.common.request_line.method_id == RTSP_METHOD_TEARDOWN) { descriptor = mrcp_session_descriptor_create(pool); if(descriptor) { apt_string_assign(&descriptor->resource_name,resource_name,pool); descriptor->resource_state = FALSE; } } return descriptor; }
APT_DECLARE(apt_test_suite_t*) apt_test_suite_create(apr_pool_t *pool, const char *name, void *obj, apt_test_f tester) { apt_test_suite_t *suite = apr_palloc(pool,sizeof(apt_test_suite_t)); suite->pool = pool; apt_string_assign(&suite->name,name,pool); suite->obj = obj; suite->tester = tester; return suite; }
/* Receive RTSP message through RTSP connection */ static apt_bool_t rtsp_server_message_receive(apt_net_server_task_t *task, apt_net_server_connection_t *connection) { rtsp_server_t *server = apt_net_server_task_object_get(task); char buffer[RTSP_MESSAGE_MAX_SIZE]; apt_bool_t more_messages_on_buffer = FALSE; apr_status_t status; apt_text_stream_t text_stream; rtsp_message_t *message; if(!connection || !connection->sock) { return FALSE; } text_stream.text.buf = buffer; text_stream.text.length = sizeof(buffer)-1; status = apr_socket_recv(connection->sock, text_stream.text.buf, &text_stream.text.length); if(status == APR_EOF || text_stream.text.length == 0) { return apt_net_server_connection_close(task,connection); } text_stream.text.buf[text_stream.text.length] = '\0'; text_stream.pos = text_stream.text.buf; apt_log(APT_PRIO_INFO,"Receive RTSP Message size=%lu\n%s",text_stream.text.length,text_stream.text.buf); do { message = rtsp_message_create(RTSP_MESSAGE_TYPE_UNKNOWN,connection->pool); if(rtsp_message_parse(message,&text_stream) == TRUE) { apt_str_t *destination = &message->header.transport.destination; if(!destination->buf && connection->client_ip) { apt_string_assign(destination,connection->client_ip,connection->pool); } rtsp_server_session_request_process(server,connection->obj,message); } else { rtsp_message_t *response; apt_log(APT_PRIO_WARNING,"Failed to Parse RTSP Message"); response = rtsp_response_create(message,RTSP_STATUS_CODE_BAD_REQUEST, RTSP_REASON_PHRASE_BAD_REQUEST,message->pool); if(rtsp_server_message_send(server,connection,response) == FALSE) { apt_log(APT_PRIO_WARNING,"Failed to Send RTSP Response"); } } more_messages_on_buffer = FALSE; if(text_stream.text.length > (apr_size_t)(text_stream.pos - text_stream.text.buf)) { /* there are more RTSP messages to signal */ more_messages_on_buffer = TRUE; text_stream.text.length -= text_stream.pos - text_stream.text.buf; text_stream.text.buf = text_stream.pos; apt_log(APT_PRIO_DEBUG,"Saving Remaining Buffer for Next Message"); } } while(more_messages_on_buffer); return TRUE; }
static apt_bool_t mpf_codec_manager_codec_parse(const mpf_codec_manager_t *codec_manager, mpf_codec_list_t *codec_list, char *codec_desc_str, apr_pool_t *pool) { const mpf_codec_t *codec; mpf_codec_descriptor_t *descriptor; const char *separator = "/"; char *state; /* parse codec name */ char *str = apr_strtok(codec_desc_str, separator, &state); codec_desc_str = NULL; /* make sure we pass NULL on subsequent calls of apr_strtok() */ if(str) { apt_str_t name; apt_string_assign(&name,str,pool); /* find codec by name */ codec = mpf_codec_manager_codec_find(codec_manager,&name); if(!codec) { apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"No Such Codec [%s]",str); return FALSE; } descriptor = mpf_codec_list_add(codec_list); descriptor->name = name; /* set defualt attributes */ if(codec->static_descriptor) { descriptor->payload_type = codec->static_descriptor->payload_type; descriptor->sampling_rate = codec->static_descriptor->sampling_rate; descriptor->channel_count = codec->static_descriptor->channel_count; } else { descriptor->payload_type = 96; descriptor->sampling_rate = 8000; descriptor->channel_count = 1; } /* parse optional payload type */ str = apr_strtok(codec_desc_str, separator, &state); if(str) { descriptor->payload_type = (apr_byte_t)atol(str); /* parse optional sampling rate */ str = apr_strtok(codec_desc_str, separator, &state); if(str) { descriptor->sampling_rate = (apr_uint16_t)atol(str); /* parse optional channel count */ str = apr_strtok(codec_desc_str, separator, &state); if(str) { descriptor->channel_count = (apr_byte_t)atol(str); } } } } 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; }
/** Generate MRCP descriptor by SDP session */ static apt_bool_t mrcp_descriptor_generate_by_sdp_session(mrcp_session_descriptor_t *descriptor, const sdp_session_t *sdp, const char *force_destination_ip, apr_pool_t *pool) { sdp_media_t *sdp_media; if(force_destination_ip) { apt_string_assign(&descriptor->ip,force_destination_ip,pool); } else if(sdp->sdp_connection) { apt_string_assign(&descriptor->ip,sdp->sdp_connection->c_address,pool); } for(sdp_media=sdp->sdp_media; sdp_media; sdp_media=sdp_media->m_next) { switch(sdp_media->m_type) { case sdp_media_audio: { mpf_rtp_media_descriptor_t *media = apr_palloc(pool,sizeof(mpf_rtp_media_descriptor_t)); mpf_rtp_media_descriptor_init(media); media->id = mrcp_session_audio_media_add(descriptor,media); mpf_rtp_media_generate(media,sdp_media,&descriptor->ip,pool); break; } case sdp_media_video: { mpf_rtp_media_descriptor_t *media = apr_palloc(pool,sizeof(mpf_rtp_media_descriptor_t)); mpf_rtp_media_descriptor_init(media); media->id = mrcp_session_video_media_add(descriptor,media); mpf_rtp_media_generate(media,sdp_media,&descriptor->ip,pool); break; } default: apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Not Supported SDP Media [%s]", sdp_media->m_type_name); break; } } return TRUE; }
/** \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; }
/* 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; }