/** Append name-value pair */
APT_DECLARE(apt_bool_t) apt_pair_array_append(apt_pair_arr_t *arr, const apt_str_t *name, const apt_str_t *value, apr_pool_t *pool)
{
apt_pair_t *pair = apr_array_push(arr);
apt_pair_init(pair);
if(name) {
apt_string_copy(&pair->name,name,pool);
}
if(value) {
apt_string_copy(&pair->value,value,pool);
}
return TRUE;
}
/** Copy MRCP control offer */
MRCP_DECLARE(mrcp_control_descriptor_t*) mrcp_control_offer_copy(const mrcp_control_descriptor_t *offer, apr_pool_t *pool)
{
mrcp_control_descriptor_t *descriptor = mrcp_control_descriptor_create(pool);
if(offer) {
*descriptor = *offer;
descriptor->cmid_arr = apr_array_copy(pool,offer->cmid_arr);
apt_string_copy(&descriptor->ip,&offer->ip,pool);
apt_string_copy(&descriptor->resource_name,&offer->resource_name,pool);
apt_string_copy(&descriptor->session_id,&offer->session_id,pool);
}
return descriptor;
}
/** Parse MRCP speech-length value */
static apt_bool_t mrcp_speech_length_value_parse(mrcp_speech_length_value_t *speech_length, const apt_str_t *value, apr_pool_t *pool)
{
if(!value->length) {
return FALSE;
}
switch(*value->buf) {
case '+': speech_length->type = SPEECH_LENGTH_TYPE_NUMERIC_POSITIVE; break;
case '-': speech_length->type = SPEECH_LENGTH_TYPE_NUMERIC_NEGATIVE; break;
default : speech_length->type = SPEECH_LENGTH_TYPE_TEXT;
}
if(speech_length->type == SPEECH_LENGTH_TYPE_TEXT) {
apt_string_copy(&speech_length->value.tag,value,pool);
}
else {
mrcp_numeric_speech_length_t *numeric = &speech_length->value.numeric;
apt_str_t str;
apt_text_stream_t stream;
stream.text = *value;
apt_text_stream_reset(&stream);
stream.pos++;
if(apt_text_field_read(&stream,APT_TOKEN_SP,TRUE,&str) == FALSE) {
return FALSE;
}
numeric->length = apt_size_value_parse(&str);
if(apt_text_field_read(&stream,APT_TOKEN_SP,TRUE,&str) == FALSE) {
return FALSE;
}
numeric->unit = apt_string_table_value_parse(speech_unit_string_table,SPEECH_UNIT_COUNT,&str);
}
return TRUE;
}
/** Parse RTSP header field */
static apt_bool_t rtsp_header_field_parse(rtsp_header_t *header, rtsp_header_field_id id, const apt_str_t *value, apr_pool_t *pool)
{
apt_bool_t status = TRUE;
switch(id) {
case RTSP_HEADER_FIELD_CSEQ:
header->cseq = apt_size_value_parse(value);
break;
case RTSP_HEADER_FIELD_TRANSPORT:
status = rtsp_transport_parse(&header->transport,value,pool);
break;
case RTSP_HEADER_FIELD_SESSION_ID:
status = rtsp_session_id_parse(&header->session_id,value,pool);
break;
case RTSP_HEADER_FIELD_RTP_INFO:
apt_string_copy(&header->rtp_info,value,pool);
break;
case RTSP_HEADER_FIELD_CONTENT_TYPE:
header->content_type = apt_string_table_id_find(rtsp_content_type_string_table,RTSP_CONTENT_TYPE_COUNT,value);
break;
case RTSP_HEADER_FIELD_CONTENT_LENGTH:
header->content_length = apt_size_value_parse(value);
break;
default:
status = FALSE;
}
return status;
}
static size_t string_table_read(apt_str_table_item_t table[], apr_size_t max_count, FILE *file, apr_pool_t *pool)
{
apt_str_table_item_t *item;
size_t count = 0;
apt_str_t line;
apt_text_stream_t text_stream;
text_stream.text.length = fread(parse_buffer, 1, sizeof(parse_buffer)-1, file);
parse_buffer[text_stream.text.length] = '\0';
text_stream.text.buf = parse_buffer;
text_stream.pos = parse_buffer;
do {
if(apt_text_line_read(&text_stream,&line) == FALSE || !line.length) {
break;
}
item = &table[count];
apt_string_copy(&item->value,&line,pool);
item->key = 0;
count++;
}
while(count < max_count);
return count;
}
/** Generate MRCP speech-length value */
static apt_bool_t mrcp_speech_length_generate(mrcp_speech_length_value_t *speech_length, apt_str_t *str, apr_pool_t *pool)
{
if(speech_length->type == SPEECH_LENGTH_TYPE_TEXT) {
apt_str_t *tag = &speech_length->value.tag;
if(tag->length) {
apt_string_copy(str,tag,pool);
}
}
else {
char buf[256];
apt_text_stream_t stream;
apt_text_stream_init(&stream,buf,sizeof(buf));
if(speech_length->type == SPEECH_LENGTH_TYPE_NUMERIC_POSITIVE) {
*stream.pos++ = '+';
}
else {
*stream.pos++ = '-';
}
apt_text_size_value_insert(&stream,speech_length->value.numeric.length);
*stream.pos++ = APT_TOKEN_SP;
apt_string_table_value_generate(speech_unit_string_table,SPEECH_UNIT_COUNT,speech_length->value.numeric.unit,&stream);
apt_string_assign_n(str,stream.text.buf, stream.pos - stream.text.buf, pool);
}
return TRUE;
}
static apt_bool_t mrcp_client_resource_discover(mrcp_client_session_t *session)
{
mrcp_session_descriptor_t *descriptor = NULL;
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Discover Resources "APT_PTR_FMT, MRCP_SESSION_PTR(&session->base));
session->answer = NULL;
mrcp_client_session_state_set(session,SESSION_STATE_DISCOVERING);
if(mrcp_session_version_get(session) == MRCP_VERSION_1) {
mrcp_resource_t *resource;
mrcp_resource_id i;
for(i=0; i<MRCP_RESOURCE_TYPE_COUNT; i++) {
resource = mrcp_resource_get(session->profile->resource_factory,i);
if(!resource) continue;
descriptor = mrcp_session_descriptor_create(session->base.pool);
apt_string_copy(&descriptor->resource_name,&resource->name,session->base.pool);
if(mrcp_session_discover_request(&session->base,descriptor) == TRUE) {
mrcp_client_session_subrequest_add(session);
}
}
}
else {
if(mrcp_session_discover_request(&session->base,descriptor) == TRUE) {
mrcp_client_session_subrequest_add(session);
}
}
if(session->subrequest_count == 0) {
session->status = MRCP_SIG_STATUS_CODE_FAILURE;
mrcp_app_sig_response_raise(session,TRUE);
}
return TRUE;
}
/** Duplicate generic-header */
static apt_bool_t mrcp_generic_header_duplicate(mrcp_header_accessor_t *accessor, const mrcp_header_accessor_t *src, size_t id, apr_pool_t *pool)
{
mrcp_generic_header_t *generic_header = accessor->data;
const mrcp_generic_header_t *src_generic_header = src->data;
apt_bool_t status = TRUE;
if(!generic_header || !src_generic_header) {
return FALSE;
}
switch(id) {
case GENERIC_HEADER_ACTIVE_REQUEST_ID_LIST:
break;
case GENERIC_HEADER_PROXY_SYNC_ID:
apt_string_copy(&generic_header->proxy_sync_id,&src_generic_header->proxy_sync_id,pool);
break;
case GENERIC_HEADER_ACCEPT_CHARSET:
apt_string_copy(&generic_header->accept_charset,&src_generic_header->accept_charset,pool);
break;
case GENERIC_HEADER_CONTENT_TYPE:
apt_string_copy(&generic_header->content_type,&src_generic_header->content_type,pool);
break;
case GENERIC_HEADER_CONTENT_ID:
apt_string_copy(&generic_header->content_id,&src_generic_header->content_id,pool);
break;
case GENERIC_HEADER_CONTENT_BASE:
apt_string_copy(&generic_header->content_base,&src_generic_header->content_base,pool);
break;
case GENERIC_HEADER_CONTENT_ENCODING:
apt_string_copy(&generic_header->content_encoding,&src_generic_header->content_encoding,pool);
break;
case GENERIC_HEADER_CONTENT_LOCATION:
apt_string_copy(&generic_header->content_location,&src_generic_header->content_location,pool);
break;
case GENERIC_HEADER_CONTENT_LENGTH:
generic_header->content_length = src_generic_header->content_length;
break;
case GENERIC_HEADER_CACHE_CONTROL:
apt_string_copy(&generic_header->cache_control,&src_generic_header->cache_control,pool);
break;
case GENERIC_HEADER_LOGGING_TAG:
apt_string_copy(&generic_header->logging_tag,&src_generic_header->logging_tag,pool);
break;
case GENERIC_HEADER_VENDOR_SPECIFIC_PARAMS:
generic_header->vendor_specific_params = apt_pair_array_copy(src_generic_header->vendor_specific_params,pool);
break;
default:
status = FALSE;
}
return status;
}
/** Parse id@resource string */
APT_DECLARE(apt_bool_t) apt_id_resource_parse(const apt_str_t *str, char separator, apt_str_t *id, apt_str_t *resource, apr_pool_t *pool)
{
apt_str_t field = *str;
const char *pos = strchr(str->buf,separator);
if(!pos) {
return FALSE;
}
field.length = pos - field.buf;
if(field.length >= str->length) {
return FALSE;
}
apt_string_copy(id,&field,pool);
field.buf += field.length + 1;
field.length = str->length - (field.length + 1);
apt_string_copy(resource,&field,pool);
return TRUE;
}
/** Parse name=value pair */
static apt_bool_t apt_pair_parse(apt_pair_t *pair, const apt_str_t *field, apr_pool_t *pool)
{
apt_text_stream_t stream;
apt_str_t item;
stream.text = *field;
apt_text_stream_reset(&stream);
/* read name */
if(apt_text_field_read(&stream,'=',TRUE,&item) == FALSE) {
return FALSE;
}
apt_string_copy(&pair->name,&item,pool);
/* read value */
apt_text_field_read(&stream,';',TRUE,&item);
apt_string_copy(&pair->value,&item,pool);
return TRUE;
}
/** Parse generic-header */
static apt_bool_t mrcp_generic_header_parse(mrcp_header_accessor_t *accessor, size_t id, const apt_str_t *value, apr_pool_t *pool)
{
apt_bool_t status = TRUE;
mrcp_generic_header_t *generic_header = accessor->data;
switch(id) {
case GENERIC_HEADER_ACTIVE_REQUEST_ID_LIST:
mrcp_request_id_list_parse(&generic_header->active_request_id_list,value);
break;
case GENERIC_HEADER_PROXY_SYNC_ID:
apt_string_copy(&generic_header->proxy_sync_id,value,pool);
break;
case GENERIC_HEADER_ACCEPT_CHARSET:
apt_string_copy(&generic_header->accept_charset,value,pool);
break;
case GENERIC_HEADER_CONTENT_TYPE:
apt_string_copy(&generic_header->content_type,value,pool);
break;
case GENERIC_HEADER_CONTENT_ID:
apt_string_copy(&generic_header->content_id,value,pool);
break;
case GENERIC_HEADER_CONTENT_BASE:
apt_string_copy(&generic_header->content_base,value,pool);
break;
case GENERIC_HEADER_CONTENT_ENCODING:
apt_string_copy(&generic_header->content_encoding,value,pool);
break;
case GENERIC_HEADER_CONTENT_LOCATION:
apt_string_copy(&generic_header->content_location,value,pool);
break;
case GENERIC_HEADER_CONTENT_LENGTH:
generic_header->content_length = apt_size_value_parse(value);
break;
case GENERIC_HEADER_CACHE_CONTROL:
apt_string_copy(&generic_header->cache_control,value,pool);
break;
case GENERIC_HEADER_LOGGING_TAG:
apt_string_copy(&generic_header->logging_tag,value,pool);
break;
case GENERIC_HEADER_VENDOR_SPECIFIC_PARAMS:
if(!generic_header->vendor_specific_params) {
generic_header->vendor_specific_params = apt_pair_array_create(1,pool);
}
apt_pair_array_parse(generic_header->vendor_specific_params,value,pool);
break;
default:
status = FALSE;
}
return status;
}
/** Parse text value of RTSP transport attrib (source/destination, e.t.c) */
static apt_bool_t rtsp_transport_attrib_value_parse(apt_str_t *value, apt_text_stream_t *stream, apr_pool_t *pool)
{
apt_str_t field;
/* read value */
if(apt_text_field_read(stream,';',TRUE,&field) == FALSE) {
return FALSE;
}
apt_string_copy(value,&field,pool);
return TRUE;
}
static apt_bool_t apt_string_table_value_pgenerate(const apt_str_table_item_t *string_table, apr_size_t count, apr_size_t id, apt_str_t *str, apr_pool_t *pool)
{
const apt_str_t *name = apt_string_table_str_get(string_table,count,id);
if(!name) {
return FALSE;
}
apt_string_copy(str,name,pool);
return TRUE;
}
/** Parse MRCP v2 start-line */
static apt_bool_t mrcp_v2_start_line_parse(mrcp_start_line_t *start_line, apt_text_stream_t *stream, apr_pool_t *pool)
{
apt_str_t field;
if(apt_text_field_read(stream,APT_TOKEN_SP,TRUE,&field) == FALSE) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Cannot parse message-length in v2 start-line");
return FALSE;
}
start_line->length = apt_size_value_parse(&field);
if(apt_text_field_read(stream,APT_TOKEN_SP,TRUE,&field) == FALSE) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Cannot parse request-id in v2 start-line");
return FALSE;
}
start_line->request_id = mrcp_request_id_parse(&field);
if(start_line->request_id == 0 && *field.buf != '0') {
/* parsing MRCP v2 request or event */
start_line->message_type = MRCP_MESSAGE_TYPE_REQUEST;
apt_string_copy(&start_line->method_name,&field,pool);
if(apt_text_field_read(stream,APT_TOKEN_SP,TRUE,&field) == FALSE) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Cannot parse request-id in v2 start-line");
return FALSE;
}
start_line->request_id = mrcp_request_id_parse(&field);
if(apt_text_field_read(stream,APT_TOKEN_SP,TRUE,&field) == TRUE) {
/* parsing MRCP v2 event */
start_line->request_state = mrcp_request_state_parse(&field);
start_line->message_type = MRCP_MESSAGE_TYPE_EVENT;
}
}
else {
/* parsing MRCP v2 response */
start_line->message_type = MRCP_MESSAGE_TYPE_RESPONSE;
if(apt_text_field_read(stream,APT_TOKEN_SP,TRUE,&field) == FALSE) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Cannot parse status-code in v2 start-line");
return FALSE;
}
start_line->status_code = mrcp_status_code_parse(&field);
if(apt_text_field_read(stream,APT_TOKEN_SP,TRUE,&field) == FALSE) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Cannot parse request-state in v2 start-line");
return FALSE;
}
start_line->request_state = mrcp_request_state_parse(&field);
}
return TRUE;
}
/** Parse RTSP transport */
static apt_bool_t rtsp_session_id_parse(apt_str_t *session_id, const apt_str_t *value, apr_pool_t *pool)
{
char *sep;
if(!value->buf) {
return FALSE;
}
apt_string_copy(session_id,value,pool);
sep = strchr(session_id->buf,';');
if(sep) {
session_id->length = sep - session_id->buf;
*sep = '\0';
}
return TRUE;
}
/** Parse MRCP start-line */
MRCP_DECLARE(apt_bool_t) mrcp_start_line_parse(mrcp_start_line_t *start_line, apt_text_stream_t *text_stream, apr_pool_t *pool)
{
apt_text_stream_t line;
apt_str_t field;
apt_bool_t status = TRUE;
start_line->message_type = MRCP_MESSAGE_TYPE_UNKNOWN;
if(apt_text_line_read(text_stream,&line.text) == FALSE) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Cannot parse MRCP start-line");
return FALSE;
}
apt_text_stream_reset(&line);
if(apt_text_field_read(&line,APT_TOKEN_SP,TRUE,&field) == FALSE) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Cannot read the first field in start-line");
return FALSE;
}
if(field.buf == strstr(field.buf,MRCP_NAME)) {
start_line->version = mrcp_version_parse(&field);
if(start_line->version == MRCP_VERSION_1) {
/* parsing MRCP v1 response */
start_line->message_type = MRCP_MESSAGE_TYPE_RESPONSE;
status = mrcp_response_line_parse(start_line,&line);
}
else if(start_line->version == MRCP_VERSION_2) {
/* parsing MRCP v2 start-line (request/response/event) */
status = mrcp_v2_start_line_parse(start_line,&line,pool);
}
else {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Unknown MRCP version");
return FALSE;
}
}
else {
/* parsing MRCP v1 request or event */
apt_string_copy(&start_line->method_name,&field,pool);
status = mrcp_request_line_parse(start_line,&line);
}
return status;
}
/** Set (copy) MRCP header fields */
MRCP_DECLARE(apt_bool_t) mrcp_header_fields_set(mrcp_message_header_t *header, const mrcp_message_header_t *src_header, apr_pool_t *pool)
{
apt_header_field_t *header_field;
const apt_header_field_t *src_header_field;
for(src_header_field = APR_RING_FIRST(&src_header->header_section.ring);
src_header_field != APR_RING_SENTINEL(&src_header->header_section.ring, apt_header_field_t, link);
src_header_field = APR_RING_NEXT(src_header_field, link)) {
header_field = apt_header_section_field_get(&header->header_section,src_header_field->id);
if(header_field) {
/* this header field has already been set, just copy its value */
apt_string_copy(&header_field->value,&src_header_field->value,pool);
}
else {
/* copy the entire header field and add it to the header section */
header_field = apt_header_field_copy(src_header_field,pool);
apt_header_section_field_add(&header->header_section,header_field);
}
mrcp_header_accessor_value_duplicate(header,header_field,src_header,src_header_field,pool);
}
return TRUE;
}
/** Create message and read start line */
static apt_bool_t mrcp_parser_on_start(apt_message_parser_t *parser, apt_message_context_t *context, apt_text_stream_t *stream, apr_pool_t *pool)
{
mrcp_message_t *mrcp_message;
apt_str_t start_line;
/* read start line */
if(apt_text_line_read(stream,&start_line) == FALSE) {
return FALSE;
}
/* create new MRCP message */
mrcp_message = mrcp_message_create(pool);
/* parse start-line */
if(mrcp_start_line_parse(&mrcp_message->start_line,&start_line,mrcp_message->pool) == FALSE) {
return FALSE;
}
if(mrcp_message->start_line.version == MRCP_VERSION_1) {
mrcp_parser_t *mrcp_parser = apt_message_parser_object_get(parser);
if(!mrcp_parser->resource) {
return FALSE;
}
apt_string_copy(
&mrcp_message->channel_id.resource_name,
&mrcp_parser->resource->name,
pool);
if(mrcp_message_resource_set(mrcp_message,mrcp_parser->resource) == FALSE) {
return FALSE;
}
}
context->message = mrcp_message;
context->header = &mrcp_message->header.header_section;
context->body = &mrcp_message->body;
return TRUE;
}
/** Parse MRCP recognizer header */
static apt_bool_t mrcp_recog_header_parse(mrcp_recog_header_t *recog_header, apr_size_t id, const apt_str_t *value, apr_pool_t *pool)
{
apt_bool_t status = TRUE;
switch(id) {
case RECOGNIZER_HEADER_N_BEST_LIST_LENGTH:
recog_header->n_best_list_length = apt_size_value_parse(value);
break;
case RECOGNIZER_HEADER_NO_INPUT_TIMEOUT:
recog_header->no_input_timeout = apt_size_value_parse(value);
break;
case RECOGNIZER_HEADER_RECOGNITION_TIMEOUT:
recog_header->recognition_timeout = apt_size_value_parse(value);
break;
case RECOGNIZER_HEADER_WAVEFORM_URI:
apt_string_copy(&recog_header->waveform_uri,value,pool);
break;
case RECOGNIZER_HEADER_COMPLETION_CAUSE:
recog_header->completion_cause = apt_size_value_parse(value);
break;
case RECOGNIZER_HEADER_RECOGNIZER_CONTEXT_BLOCK:
apt_string_copy(&recog_header->recognizer_context_block,value,pool);
break;
case RECOGNIZER_HEADER_START_INPUT_TIMERS:
apt_boolean_value_parse(value,&recog_header->start_input_timers);
break;
case RECOGNIZER_HEADER_SPEECH_COMPLETE_TIMEOUT:
recog_header->speech_complete_timeout = apt_size_value_parse(value);
break;
case RECOGNIZER_HEADER_SPEECH_INCOMPLETE_TIMEOUT:
recog_header->speech_incomplete_timeout = apt_size_value_parse(value);
break;
case RECOGNIZER_HEADER_DTMF_INTERDIGIT_TIMEOUT:
recog_header->dtmf_interdigit_timeout = apt_size_value_parse(value);
break;
case RECOGNIZER_HEADER_DTMF_TERM_TIMEOUT:
recog_header->dtmf_term_timeout = apt_size_value_parse(value);
break;
case RECOGNIZER_HEADER_DTMF_TERM_CHAR:
recog_header->dtmf_term_char = *value->buf;
break;
case RECOGNIZER_HEADER_FAILED_URI:
apt_string_copy(&recog_header->failed_uri,value,pool);
break;
case RECOGNIZER_HEADER_FAILED_URI_CAUSE:
apt_string_copy(&recog_header->failed_uri_cause,value,pool);
break;
case RECOGNIZER_HEADER_SAVE_WAVEFORM:
apt_boolean_value_parse(value,&recog_header->save_waveform);
break;
case RECOGNIZER_HEADER_NEW_AUDIO_CHANNEL:
apt_boolean_value_parse(value,&recog_header->new_audio_channel);
break;
case RECOGNIZER_HEADER_SPEECH_LANGUAGE:
apt_string_copy(&recog_header->speech_language,value,pool);
break;
case RECOGNIZER_HEADER_INPUT_TYPE:
apt_string_copy(&recog_header->input_type,value,pool);
break;
case RECOGNIZER_HEADER_MEDIA_TYPE:
apt_string_copy(&recog_header->media_type,value,pool);
break;
case RECOGNIZER_HEADER_INPUT_WAVEFORM_URI:
apt_string_copy(&recog_header->input_waveform_uri,value,pool);
break;
case RECOGNIZER_HEADER_COMPLETION_REASON:
apt_string_copy(&recog_header->completion_reason,value,pool);
break;
case RECOGNIZER_HEADER_VER_BUFFER_UTTERANCE:
apt_boolean_value_parse(value,&recog_header->ver_buffer_utterance);
break;
case RECOGNIZER_HEADER_RECOGNITION_MODE:
apt_string_copy(&recog_header->recognition_mode,value,pool);
break;
case RECOGNIZER_HEADER_CANCEL_IF_QUEUE:
apt_boolean_value_parse(value,&recog_header->cancel_if_queue);
break;
case RECOGNIZER_HEADER_HOTWORD_MAX_DURATION:
recog_header->hotword_max_duration = apt_size_value_parse(value);
break;
case RECOGNIZER_HEADER_HOTWORD_MIN_DURATION:
recog_header->hotword_min_duration = apt_size_value_parse(value);
break;
case RECOGNIZER_HEADER_INTERPRET_TEXT:
apt_string_copy(&recog_header->interpret_text,value,pool);
break;
case RECOGNIZER_HEADER_DTMF_BUFFER_TIME:
recog_header->dtmf_buffer_time = apt_size_value_parse(value);
break;
case RECOGNIZER_HEADER_CLEAR_DTMF_BUFFER:
apt_boolean_value_parse(value,&recog_header->clear_dtmf_buffer);
break;
case RECOGNIZER_HEADER_EARLY_NO_MATCH:
apt_boolean_value_parse(value,&recog_header->early_no_match);
break;
default:
status = FALSE;
}
return status;
}
/** Duplicate MRCP recognizer header */
static apt_bool_t mrcp_recog_header_duplicate(mrcp_header_accessor_t *accessor, const mrcp_header_accessor_t *src, apr_size_t id, apr_pool_t *pool)
{
mrcp_recog_header_t *recog_header = accessor->data;
const mrcp_recog_header_t *src_recog_header = src->data;
apt_bool_t status = TRUE;
if(!recog_header || !src_recog_header) {
return FALSE;
}
switch(id) {
case RECOGNIZER_HEADER_CONFIDENCE_THRESHOLD:
recog_header->confidence_threshold = src_recog_header->confidence_threshold;
break;
case RECOGNIZER_HEADER_SENSITIVITY_LEVEL:
recog_header->sensitivity_level = src_recog_header->sensitivity_level;
break;
case RECOGNIZER_HEADER_SPEED_VS_ACCURACY:
recog_header->speed_vs_accuracy = src_recog_header->speed_vs_accuracy;
break;
case RECOGNIZER_HEADER_N_BEST_LIST_LENGTH:
recog_header->n_best_list_length = src_recog_header->n_best_list_length;
break;
case RECOGNIZER_HEADER_NO_INPUT_TIMEOUT:
recog_header->no_input_timeout = src_recog_header->no_input_timeout;
break;
case RECOGNIZER_HEADER_RECOGNITION_TIMEOUT:
recog_header->recognition_timeout = src_recog_header->recognition_timeout;
break;
case RECOGNIZER_HEADER_WAVEFORM_URI:
apt_string_copy(&recog_header->waveform_uri,&src_recog_header->waveform_uri,pool);
break;
case RECOGNIZER_HEADER_COMPLETION_CAUSE:
recog_header->completion_cause = src_recog_header->completion_cause;
break;
case RECOGNIZER_HEADER_RECOGNIZER_CONTEXT_BLOCK:
apt_string_copy(&recog_header->recognizer_context_block,&src_recog_header->recognizer_context_block,pool);
break;
case RECOGNIZER_HEADER_START_INPUT_TIMERS:
recog_header->start_input_timers = src_recog_header->start_input_timers;
break;
case RECOGNIZER_HEADER_SPEECH_COMPLETE_TIMEOUT:
recog_header->speech_complete_timeout = src_recog_header->speech_complete_timeout;
break;
case RECOGNIZER_HEADER_SPEECH_INCOMPLETE_TIMEOUT:
recog_header->speech_incomplete_timeout = src_recog_header->speech_incomplete_timeout;
break;
case RECOGNIZER_HEADER_DTMF_INTERDIGIT_TIMEOUT:
recog_header->dtmf_interdigit_timeout = src_recog_header->dtmf_interdigit_timeout;
break;
case RECOGNIZER_HEADER_DTMF_TERM_TIMEOUT:
recog_header->dtmf_term_timeout = src_recog_header->dtmf_term_timeout;
break;
case RECOGNIZER_HEADER_DTMF_TERM_CHAR:
recog_header->dtmf_term_char = src_recog_header->dtmf_term_char;
break;
case RECOGNIZER_HEADER_FAILED_URI:
apt_string_copy(&recog_header->failed_uri,&src_recog_header->failed_uri,pool);
break;
case RECOGNIZER_HEADER_FAILED_URI_CAUSE:
apt_string_copy(&recog_header->failed_uri_cause,&src_recog_header->failed_uri_cause,pool);
break;
case RECOGNIZER_HEADER_SAVE_WAVEFORM:
recog_header->save_waveform = src_recog_header->save_waveform;
break;
case RECOGNIZER_HEADER_NEW_AUDIO_CHANNEL:
recog_header->new_audio_channel = src_recog_header->new_audio_channel;
break;
case RECOGNIZER_HEADER_SPEECH_LANGUAGE:
apt_string_copy(&recog_header->speech_language,&src_recog_header->speech_language,pool);
break;
case RECOGNIZER_HEADER_INPUT_TYPE:
apt_string_copy(&recog_header->input_type,&src_recog_header->input_type,pool);
break;
case RECOGNIZER_HEADER_INPUT_WAVEFORM_URI:
apt_string_copy(&recog_header->input_waveform_uri,&src_recog_header->input_waveform_uri,pool);
break;
case RECOGNIZER_HEADER_COMPLETION_REASON:
apt_string_copy(&recog_header->completion_reason,&src_recog_header->completion_reason,pool);
break;
case RECOGNIZER_HEADER_MEDIA_TYPE:
apt_string_copy(&recog_header->media_type,&src_recog_header->media_type,pool);
break;
case RECOGNIZER_HEADER_VER_BUFFER_UTTERANCE:
recog_header->ver_buffer_utterance = src_recog_header->ver_buffer_utterance;
break;
case RECOGNIZER_HEADER_RECOGNITION_MODE:
apt_string_copy(&recog_header->recognition_mode,&src_recog_header->recognition_mode,pool);
break;
case RECOGNIZER_HEADER_CANCEL_IF_QUEUE:
recog_header->cancel_if_queue = src_recog_header->cancel_if_queue;
break;
case RECOGNIZER_HEADER_HOTWORD_MAX_DURATION:
recog_header->hotword_max_duration = src_recog_header->hotword_max_duration;
break;
case RECOGNIZER_HEADER_HOTWORD_MIN_DURATION:
recog_header->hotword_min_duration = src_recog_header->hotword_min_duration;
break;
case RECOGNIZER_HEADER_INTERPRET_TEXT:
apt_string_copy(&recog_header->interpret_text,&src_recog_header->interpret_text,pool);
break;
case RECOGNIZER_HEADER_DTMF_BUFFER_TIME:
recog_header->dtmf_buffer_time = src_recog_header->dtmf_buffer_time;
break;
case RECOGNIZER_HEADER_CLEAR_DTMF_BUFFER:
recog_header->clear_dtmf_buffer = src_recog_header->clear_dtmf_buffer;
break;
case RECOGNIZER_HEADER_EARLY_NO_MATCH:
recog_header->early_no_match = src_recog_header->early_no_match;
break;
default:
status = FALSE;
}
return status;
}
static apt_bool_t mrcp_unirtsp_on_session_response(rtsp_client_t *rtsp_client, rtsp_client_session_t *rtsp_session, rtsp_message_t *request, rtsp_message_t *response)
{
apt_bool_t status = FALSE;
mrcp_unirtsp_agent_t *agent = rtsp_client_object_get(rtsp_client);
mrcp_unirtsp_session_t *session = rtsp_client_session_object_get(rtsp_session);
if(!agent || !session) {
return FALSE;
}
switch(request->start_line.common.request_line.method_id) {
case RTSP_METHOD_SETUP:
{
const apt_str_t *session_id;
const char *force_destination_ip = NULL;
mrcp_session_descriptor_t *descriptor;
if(session->rtsp_settings->force_destination == TRUE) {
force_destination_ip = session->rtsp_settings->server_ip;
}
descriptor = mrcp_descriptor_generate_by_rtsp_response(
request,
response,
force_destination_ip,
session->rtsp_settings->resource_map,
session->mrcp_session->pool,
session->home);
if(!descriptor) {
return FALSE;
}
session_id = rtsp_client_session_id_get(session->rtsp_session);
if(session_id) {
apt_string_copy(
&session->mrcp_session->id,
session_id,
session->mrcp_session->pool);
}
status = mrcp_session_answer(session->mrcp_session,descriptor);
break;
}
case RTSP_METHOD_TEARDOWN:
{
mrcp_session_descriptor_t *descriptor;
descriptor = mrcp_descriptor_generate_by_rtsp_response(
request,
response,
NULL,
session->rtsp_settings->resource_map,
session->mrcp_session->pool,
session->home);
if(!descriptor) {
return FALSE;
}
status = mrcp_session_answer(session->mrcp_session,descriptor);
break;
}
case RTSP_METHOD_ANNOUNCE:
{
mrcp_unirtsp_agent_t *agent = rtsp_client_object_get(rtsp_client);
const char *resource_name = mrcp_name_get_by_rtsp_name(
session->rtsp_settings->resource_map,
request->start_line.common.request_line.resource_name);
mrcp_unirtsp_on_announce_response(agent,session,response,resource_name);
break;
}
case RTSP_METHOD_DESCRIBE:
{
mrcp_unirtsp_agent_t *agent = rtsp_client_object_get(rtsp_client);
mrcp_unirtsp_on_resource_discover(agent,session,request,response);
break;
}
default:
break;
}
return status;
}
/** Get the next content part */
APT_DECLARE(apt_bool_t) apt_multipart_content_get(apt_multipart_content_t *multipart_content, apt_str_t *content_type, apt_str_t *content)
{
apt_str_t boundary;
apt_pair_t header;
apt_bool_t is_final = FALSE;
apt_text_stream_t *stream = &multipart_content->stream;
if(!content || !content_type) {
return FALSE;
}
apt_string_reset(content);
/* skip preamble */
apt_text_skip_to_char(stream,'-');
if(apt_text_is_eos(stream) == TRUE) {
return FALSE;
}
/* skip initial hyphens */
apt_text_chars_skip(stream,'-');
if(apt_text_is_eos(stream) == TRUE) {
return FALSE;
}
/* read line and the boundary */
if(apt_text_line_read(stream,&boundary) == FALSE) {
return FALSE;
}
/* remove optional trailing spaces */
while(boundary.length && boundary.buf[boundary.length-1] == APT_TOKEN_SP) boundary.length--;
/* check whether this is the final boundary */
if(boundary.length >= 2) {
if(boundary.buf[boundary.length-1] == '-' && boundary.buf[boundary.length-2] == '-') {
/* final boundary */
boundary.length -= 2;
is_final = TRUE;
}
}
/* compare boundaries */
if(apt_string_is_empty(&multipart_content->boundary) == TRUE) {
/* no boundary was specified from user space,
learn boundary from the content */
multipart_content->boundary = boundary;
}
else {
if(apt_string_compare(&multipart_content->boundary,&boundary) == FALSE) {
/* invalid boundary */
return FALSE;
}
}
if(is_final == TRUE) {
/* final boundary => return TRUE, content remains empty */
return TRUE;
}
/* read header fields */
do {
if(apt_text_header_read(stream,&header) == TRUE) {
if(header.name.length) {
if(apt_string_compare(&multipart_content->content_type_header,&header.name) == TRUE) {
apt_string_copy(content_type,&header.value,multipart_content->pool);
}
else if(apt_string_compare(&multipart_content->content_length_header,&header.name) == TRUE) {
if(header.value.buf) {
content->length = atol(header.value.buf);
if(content->length) {
content->buf = apr_palloc(multipart_content->pool,content->length+1);
content->buf[content->length] = '\0';
}
}
}
}
else {
/* empty header => exit */
break;
}
}
}
while(apt_text_is_eos(stream) == FALSE);
if(!content->length || content->length + stream->pos > stream->end) {
return FALSE;
}
/* read content */
memcpy(content->buf,stream->pos,content->length);
stream->pos += content->length;
return TRUE;
}
/** Set resource name to be used while parsing (MRCPv1 only) */
MRCP_DECLARE(void) mrcp_parser_resource_name_set(mrcp_parser_t *parser, const apt_str_t *resource_name)
{
if(resource_name) {
apt_string_copy(&parser->resource_name,resource_name,parser->pool);
}
}
