/** Create MRCP client instance */ MRCP_DECLARE(mrcp_client_t*) mrcp_client_create(apt_dir_layout_t *dir_layout) { mrcp_client_t *client; apr_pool_t *pool; apt_task_t *task; apt_task_vtable_t *vtable; apt_task_msg_pool_t *msg_pool; pool = apt_pool_create(); if(!pool) { return NULL; } apt_log(APT_LOG_MARK,APT_PRIO_NOTICE,"Create "CLIENT_TASK_NAME); client = apr_palloc(pool,sizeof(mrcp_client_t)); client->pool = pool; client->dir_layout = dir_layout; client->resource_factory = NULL; client->media_engine_table = NULL; client->rtp_factory_table = NULL; client->sig_agent_table = NULL; client->sig_settings_table = NULL; client->cnt_agent_table = NULL; client->rtp_settings_table = NULL; client->profile_table = NULL; client->app_table = NULL; client->session_table = NULL; client->cnt_msg_pool = NULL; msg_pool = apt_task_msg_pool_create_dynamic(0,pool); client->task = apt_consumer_task_create(client,msg_pool,pool); if(!client->task) { apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Create Client Task"); return NULL; } task = apt_consumer_task_base_get(client->task); apt_task_name_set(task,CLIENT_TASK_NAME); vtable = apt_task_vtable_get(task); if(vtable) { vtable->process_msg = mrcp_client_msg_process; vtable->on_start_complete = mrcp_client_on_start_complete; vtable->on_terminate_complete = mrcp_client_on_terminate_complete; } client->media_engine_table = apr_hash_make(client->pool); client->rtp_factory_table = apr_hash_make(client->pool); client->sig_agent_table = apr_hash_make(client->pool); client->sig_settings_table = apr_hash_make(client->pool); client->cnt_agent_table = apr_hash_make(client->pool); client->rtp_settings_table = apr_hash_make(client->pool); client->profile_table = apr_hash_make(client->pool); client->app_table = apr_hash_make(client->pool); client->session_table = apr_hash_make(client->pool); client->on_start_complete = NULL; client->sync_start_object = NULL; client->sync_start_mutex = NULL; return client; }
mrcp_connection_t* mrcp_connection_create() { mrcp_connection_t *connection; apr_pool_t *pool = apt_pool_create(); if(!pool) { return NULL; } connection = apr_palloc(pool,sizeof(mrcp_connection_t)); connection->pool = pool; apt_string_reset(&connection->remote_ip); connection->l_sockaddr = NULL; connection->r_sockaddr = NULL; connection->sock = NULL; connection->id = NULL; connection->verbose = TRUE; connection->access_count = 0; connection->it = NULL; connection->channel_table = apr_hash_make(pool); connection->parser = NULL; connection->generator = NULL; connection->rx_buffer = NULL; connection->rx_buffer_size = 0; connection->tx_buffer = NULL; connection->tx_buffer_size = 0; return connection; }
/* Accept RTSP connection */ static apt_bool_t rtsp_server_connection_accept(rtsp_server_t *server) { rtsp_server_connection_t *rtsp_connection; char *local_ip = NULL; char *remote_ip = NULL; apr_sockaddr_t *l_sockaddr = NULL; apr_sockaddr_t *r_sockaddr = NULL; apr_pool_t *pool = apt_pool_create(); if(!pool) { return FALSE; } rtsp_connection = apr_palloc(pool,sizeof(rtsp_server_connection_t)); rtsp_connection->pool = pool; rtsp_connection->sock = NULL; rtsp_connection->client_ip = NULL; APR_RING_ELEM_INIT(rtsp_connection,link); if(apr_socket_accept(&rtsp_connection->sock,server->listen_sock,rtsp_connection->pool) != APR_SUCCESS) { apt_log(RTSP_LOG_MARK,APT_PRIO_WARNING,"Failed to Accept RTSP Connection"); apr_pool_destroy(pool); return FALSE; } if(apr_socket_addr_get(&l_sockaddr,APR_LOCAL,rtsp_connection->sock) != APR_SUCCESS || apr_socket_addr_get(&r_sockaddr,APR_REMOTE,rtsp_connection->sock) != APR_SUCCESS) { apt_log(RTSP_LOG_MARK,APT_PRIO_WARNING,"Failed to Get RTSP Socket Address"); apr_pool_destroy(pool); return FALSE; } apr_sockaddr_ip_get(&local_ip,l_sockaddr); apr_sockaddr_ip_get(&remote_ip,r_sockaddr); rtsp_connection->client_ip = remote_ip; rtsp_connection->id = apr_psprintf(pool,"%s:%hu <-> %s:%hu", local_ip,l_sockaddr->port, remote_ip,r_sockaddr->port); memset(&rtsp_connection->sock_pfd,0,sizeof(apr_pollfd_t)); rtsp_connection->sock_pfd.desc_type = APR_POLL_SOCKET; rtsp_connection->sock_pfd.reqevents = APR_POLLIN; rtsp_connection->sock_pfd.desc.s = rtsp_connection->sock; rtsp_connection->sock_pfd.client_data = rtsp_connection; if(apt_poller_task_descriptor_add(server->task,&rtsp_connection->sock_pfd) != TRUE) { apt_log(RTSP_LOG_MARK,APT_PRIO_WARNING,"Failed to Add to Pollset %s",rtsp_connection->id); apr_socket_close(rtsp_connection->sock); apr_pool_destroy(pool); return FALSE; } apt_log(RTSP_LOG_MARK,APT_PRIO_NOTICE,"Accepted TCP Connection %s",rtsp_connection->id); rtsp_connection->session_table = apr_hash_make(rtsp_connection->pool); apt_text_stream_init(&rtsp_connection->rx_stream,rtsp_connection->rx_buffer,sizeof(rtsp_connection->rx_buffer)-1); apt_text_stream_init(&rtsp_connection->tx_stream,rtsp_connection->tx_buffer,sizeof(rtsp_connection->tx_buffer)-1); rtsp_connection->parser = rtsp_parser_create(rtsp_connection->pool); rtsp_connection->generator = rtsp_generator_create(rtsp_connection->pool); rtsp_connection->server = server; APR_RING_INSERT_TAIL(&server->connection_list,rtsp_connection,rtsp_server_connection_t,link); return TRUE; }
static apt_bool_t mrcp_server_agent_connection_accept(mrcp_connection_agent_t *agent) { char *local_ip = NULL; char *remote_ip = NULL; apr_socket_t *sock; apr_pool_t *pool; mrcp_connection_t *connection; if(!agent->null_connection) { pool = apt_pool_create(); if(apr_socket_accept(&sock,agent->listen_sock,pool) != APR_SUCCESS) { return FALSE; } apt_log(APT_LOG_MARK,APT_PRIO_NOTICE,"Rejected TCP/MRCPv2 Connection"); apr_socket_close(sock); apr_pool_destroy(pool); return FALSE; } pool = agent->null_connection->pool; if(apr_socket_accept(&sock,agent->listen_sock,pool) != APR_SUCCESS) { return FALSE; } connection = mrcp_connection_create(); connection->sock = sock; if(apr_socket_addr_get(&connection->r_sockaddr,APR_REMOTE,sock) != APR_SUCCESS || apr_socket_addr_get(&connection->l_sockaddr,APR_LOCAL,sock) != APR_SUCCESS) { apr_socket_close(sock); mrcp_connection_destroy(connection); return FALSE; } apr_sockaddr_ip_get(&local_ip,connection->l_sockaddr); apr_sockaddr_ip_get(&remote_ip,connection->r_sockaddr); apt_string_set(&connection->remote_ip,remote_ip); connection->id = apr_psprintf(connection->pool,"%s:%hu <-> %s:%hu", local_ip,connection->l_sockaddr->port, remote_ip,connection->r_sockaddr->port); memset(&connection->sock_pfd,0,sizeof(apr_pollfd_t)); connection->sock_pfd.desc_type = APR_POLL_SOCKET; connection->sock_pfd.reqevents = APR_POLLIN; connection->sock_pfd.desc.s = connection->sock; connection->sock_pfd.client_data = connection; if(apt_pollset_add(agent->pollset, &connection->sock_pfd) != TRUE) { apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Add to Pollset"); apr_socket_close(sock); mrcp_connection_destroy(connection); return FALSE; } apt_log(APT_LOG_MARK,APT_PRIO_NOTICE,"Accepted TCP/MRCPv2 Connection %s",connection->id); connection->agent = agent; connection->it = apt_list_push_back(agent->connection_list,connection,connection->pool); connection->parser = mrcp_parser_create(agent->resource_factory,connection->pool); connection->generator = mrcp_generator_create(agent->resource_factory,connection->pool); return TRUE; }
/* Create RTSP connection */ static apt_bool_t rtsp_client_connection_create(rtsp_client_t *client, rtsp_client_session_t *session) { rtsp_client_connection_t *rtsp_connection; apr_pool_t *pool = apt_pool_create(); if(!pool) { return FALSE; } rtsp_connection = apr_palloc(pool,sizeof(rtsp_client_connection_t)); rtsp_connection->pool = pool; rtsp_connection->sock = NULL; APR_RING_ELEM_INIT(rtsp_connection,link); if(rtsp_client_connect(client,rtsp_connection,session->server_ip.buf,session->server_port) == FALSE) { apt_log(RTSP_LOG_MARK,APT_PRIO_WARNING,"Failed to Connect to RTSP Server %s:%hu", session->server_ip.buf,session->server_port); apr_pool_destroy(pool); return FALSE; } rtsp_connection->handle_table = apr_hash_make(pool); rtsp_connection->session_table = apr_hash_make(pool); rtsp_connection->inprogress_request_queue = apt_list_create(pool); apt_text_stream_init(&rtsp_connection->rx_stream,rtsp_connection->rx_buffer,sizeof(rtsp_connection->rx_buffer)-1); apt_text_stream_init(&rtsp_connection->tx_stream,rtsp_connection->tx_buffer,sizeof(rtsp_connection->tx_buffer)-1); rtsp_connection->parser = rtsp_parser_create(pool); rtsp_connection->generator = rtsp_generator_create(pool); rtsp_connection->last_cseq = 0; rtsp_connection->client = client; APR_RING_INSERT_TAIL(&client->connection_list,rtsp_connection,rtsp_client_connection_t,link); session->connection = rtsp_connection; return TRUE; }
/** 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; }
/** Start execution of MPF test suite scenario */ static void mpf_suite_on_start_complete(apt_task_t *task) { mpf_suite_session_t *session; apt_task_t *consumer_task; mpf_suite_engine_t *suite_engine; mpf_task_msg_t *task_msg = NULL; void *descriptor; apr_pool_t *pool = NULL; consumer_task = apt_task_object_get(task); suite_engine = apt_task_object_get(consumer_task); apt_log(APT_LOG_MARK,APT_PRIO_INFO,"On MPF Suite Start"); pool = apt_pool_create(); session = apr_palloc(pool,sizeof(mpf_suite_session_t)); session->pool = pool; session->context = NULL; session->termination1 = NULL; session->termination2 = NULL; session->rtp_mode = TRUE; apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Create MPF Context"); session->context = mpf_engine_context_create(suite_engine->engine,session,2,pool); apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Create Termination [1]"); session->termination1 = mpf_termination_create(suite_engine->file_termination_factory,session,session->pool); apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Add Termination [1]"); descriptor = mpf_file_reader_descriptor_create(session); mpf_engine_termination_message_add( suite_engine->engine, MPF_ADD_TERMINATION,session->context,session->termination1,descriptor, &task_msg); apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Create Termination [2]"); if(session->rtp_mode == TRUE) { session->termination2 = mpf_termination_create(suite_engine->rtp_termination_factory,session,session->pool); } else { session->termination2 = mpf_termination_create(suite_engine->file_termination_factory,session,session->pool); } apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Add Termination [2]"); descriptor = NULL; if(session->rtp_mode == TRUE) { descriptor = mpf_rtp_local_descriptor_create(session); } else { descriptor = mpf_file_writer_descriptor_create(session); } mpf_engine_termination_message_add( suite_engine->engine, MPF_ADD_TERMINATION,session->context,session->termination2,descriptor, &task_msg); mpf_engine_message_send(suite_engine->engine,&task_msg); }
/* Create the audio queue. */ int audio_queue_create(audio_queue_t **audio_queue, const char *name) { int status = 0; audio_queue_t *laudio_queue = NULL; char *lname = ""; apr_pool_t *pool; if (audio_queue == NULL) return -1; else *audio_queue = NULL; if ((pool = apt_pool_create()) == NULL) return -1; if ((name == NULL) || (strlen(name) == 0)) lname = ""; else lname = apr_pstrdup(pool, name); if (lname == NULL) lname = ""; if ((laudio_queue = (audio_queue_t *)apr_palloc(pool, sizeof(audio_queue_t))) == NULL) { ast_log(LOG_ERROR, "(%s) Unable to create audio queue\n", lname); return -1; } else { laudio_queue->buffer = NULL; laudio_queue->cond = NULL; laudio_queue->mutex = NULL; laudio_queue->name = lname; laudio_queue->pool = pool; laudio_queue->read_bytes = 0; laudio_queue->waiting = 0; laudio_queue->write_bytes = 0; if (audio_buffer_create(&laudio_queue->buffer, AUDIO_QUEUE_SIZE) != 0) { ast_log(LOG_ERROR, "(%s) Unable to create audio queue buffer\n", laudio_queue->name); status = -1; } else if (apr_thread_mutex_create(&laudio_queue->mutex, APR_THREAD_MUTEX_UNNESTED, pool) != APR_SUCCESS) { ast_log(LOG_ERROR, "(%s) Unable to create audio queue mutex\n", laudio_queue->name); status = -1; } else if (apr_thread_cond_create(&laudio_queue->cond, pool) != APR_SUCCESS) { ast_log(LOG_ERROR, "(%s) Unable to create audio queue condition variable\n", laudio_queue->name); status = -1; } else { *audio_queue = laudio_queue; ast_log(LOG_DEBUG, "(%s) Audio queue created\n", laudio_queue->name); } } if (status != 0) audio_queue_destroy(laudio_queue); return status; }
APT_DECLARE(apt_test_framework_t*) apt_test_framework_create() { apt_test_framework_t *framework; apr_pool_t* pool = apt_pool_create(); framework = apr_palloc(pool,sizeof(apt_test_framework_t)); framework->pool = pool; framework->suites = apt_list_create(pool); apt_log_instance_create(APT_LOG_OUTPUT_CONSOLE,APT_PRIO_INFO,pool); apt_log(APT_LOG_MARK,APT_PRIO_NOTICE,"Create Test Framework"); return framework; }
int main(int argc, char *argv[]) { apr_pool_t *pool = NULL; apt_str_table_item_t table[100]; size_t count; FILE *file_in, *file_out; /* one time apr global initialization */ if(apr_initialize() != APR_SUCCESS) { return 0; } pool = apt_pool_create(); if(argc < 2) { printf("usage: stringtablegen stringtable.in [stringtable.out]\n"); return 0; } file_in = fopen(argv[1], "rb"); if(file_in == NULL) { printf("cannot open file %s\n", argv[1]); return 0; } if(argc > 2) { file_out = fopen(argv[2], "wb"); } else { file_out = stdout; } /* read items (strings) from the file */ count = string_table_read(table,100,file_in,pool); /* generate string table */ string_table_key_generate(table,count); /* dump string table to the file */ string_table_write(table,count,file_out); fclose(file_in); if(file_out != stdout) { fclose(file_out); } apr_pool_destroy(pool); /* final apr global termination */ apr_terminate(); return 0; }
int globals_init(void) { /* Set values to NULL. */ globals_null(); /* Create an APR pool. */ if ((globals.pool = apt_pool_create()) == NULL) { ast_log(LOG_ERROR, "Unable to create global memory pool\n"); return -1; } /* Create globals mutex and hash map for profiles. */ if ((apr_thread_mutex_create(&globals.mutex, APR_THREAD_MUTEX_UNNESTED, globals.pool) != APR_SUCCESS) || (globals.mutex == NULL)) { ast_log(LOG_ERROR, "Unable to create global mutex\n"); apr_pool_destroy(globals.pool); globals.pool = NULL; globals.mutex = NULL; return -1; } /* Create a hash for the profiles. */ if ((globals.profiles = apr_hash_make(globals.pool)) == NULL) { ast_log(LOG_ERROR, "Unable to create profiles hash\n"); apr_thread_mutex_destroy(globals.mutex); apr_pool_destroy(globals.pool); globals.pool = NULL; globals.mutex = NULL; return -1; } /* Create a hash for the applications. */ if ((globals.apps = apr_hash_make(globals.pool)) == NULL) { ast_log(LOG_ERROR, "Unable to create applications hash\n"); apr_thread_mutex_destroy(globals.mutex); apr_pool_destroy(globals.pool); globals.pool = NULL; globals.mutex = NULL; return -1; } /* Set the default values. */ globals_default(); return 0; }
MRCP_DECLARE(mrcp_session_t*) mrcp_session_create(apr_size_t padding) { mrcp_session_t *session; apr_pool_t *pool = apt_pool_create(); if(!pool) { return NULL; } session = apr_palloc(pool,sizeof(mrcp_session_t)+padding); session->pool = pool; session->obj = NULL; session->signaling_agent = NULL; session->request_vtable = NULL; session->response_vtable = NULL; session->event_vtable = NULL; apt_string_reset(&session->id); session->last_request_id = 0; return session; }
/* Create RTSP session */ static rtsp_server_session_t* rtsp_server_session_create(rtsp_server_t *server) { rtsp_server_session_t *session; apr_pool_t *pool = apt_pool_create(); session = apr_palloc(pool,sizeof(rtsp_server_session_t)); session->pool = pool; session->obj = NULL; session->last_cseq = 0; session->active_request = NULL; session->request_queue = apt_list_create(pool); session->resource_table = apr_hash_make(pool); session->terminating = FALSE; apt_unique_id_generate(&session->id,RTSP_SESSION_ID_HEX_STRING_LENGTH,pool); apt_log(RTSP_LOG_MARK,APT_PRIO_NOTICE,"Create RTSP Session " APT_SID_FMT,session->id.buf); if(server->vtable->create_session(server,session) != TRUE) { apr_pool_destroy(pool); return NULL; } return session; }
static mpf_suite_session_t* mpf_suite_tx_session_create(const mpf_suite_agent_t *agent) { mpf_task_msg_t *task_msg = NULL; void *descriptor; apr_pool_t *pool; mpf_suite_session_t *session; pool = apt_pool_create(); session = apr_palloc(pool,sizeof(mpf_suite_session_t)); session->pool = pool; session->context = NULL; session->file_termination = NULL; session->rtp_termination = NULL; apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Create MPF Context [Tx]"); session->context = mpf_engine_context_create(agent->engine,NULL,session,2,pool); apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Create Termination [File Reader]"); session->file_termination = mpf_termination_create(agent->file_termination_factory,session,session->pool); apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Add Termination [File Reader]"); descriptor = mpf_file_reader_descriptor_create(agent,session); mpf_engine_termination_message_add( agent->engine, MPF_ADD_TERMINATION,session->context,session->file_termination,descriptor, &task_msg); apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Create Termination [RTP Tx]"); session->rtp_termination = mpf_termination_create(agent->rtp_termination_factory,session,session->pool); apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Add Termination [RTP Tx]"); descriptor = mpf_rtp_tx_local_descriptor_create(agent,session); mpf_engine_termination_message_add( agent->engine, MPF_ADD_TERMINATION,session->context,session->rtp_termination,descriptor, &task_msg); mpf_engine_message_send(agent->engine,&task_msg); return session; }
static int audio_buffer_create(audio_buffer_t **buffer, apr_size_t max_len) { apr_pool_t *pool; audio_buffer_t *new_buffer; if (buffer == NULL) return -1; else *buffer = NULL; if ((pool = apt_pool_create()) == NULL) return -1; if ((max_len > 0) && ((new_buffer = apr_palloc(pool, sizeof(audio_buffer_t))) != NULL) && ((new_buffer->data = apr_palloc(pool, max_len)) != NULL)) { new_buffer->datalen = max_len; new_buffer->pool = pool; new_buffer->used = 0; *buffer = new_buffer; return 0; } apr_pool_destroy(pool); return -1; }
/** Create ASR engine */ ASR_CLIENT_DECLARE(asr_engine_t*) asr_engine_create( const char *root_dir_path, apt_log_priority_e log_priority, apt_log_output_e log_output) { apr_pool_t *pool = NULL; apt_dir_layout_t *dir_layout; asr_engine_t *engine; mrcp_client_t *mrcp_client; mrcp_application_t *mrcp_app; /* create APR pool */ pool = apt_pool_create(); if(!pool) { return NULL; } /* create the structure of default directories layout */ dir_layout = apt_default_dir_layout_create(root_dir_path,pool); /* create singleton logger */ apt_log_instance_create(log_output,log_priority,pool); if((log_output & APT_LOG_OUTPUT_FILE) == APT_LOG_OUTPUT_FILE) { /* open the log file */ apt_log_file_open(dir_layout->log_dir_path,"unimrcpclient",MAX_LOG_FILE_SIZE,MAX_LOG_FILE_COUNT,FALSE,pool); } engine = apr_palloc(pool,sizeof(asr_engine_t)); engine->pool = pool; engine->mrcp_client = NULL; engine->mrcp_app = NULL; /* create UniMRCP client stack */ mrcp_client = unimrcp_client_create(dir_layout); if(!mrcp_client) { apt_log_instance_destroy(); apr_pool_destroy(pool); return NULL; } /* create an application */ mrcp_app = mrcp_application_create( app_message_handler, engine, pool); if(!mrcp_app) { mrcp_client_destroy(mrcp_client); apt_log_instance_destroy(); apr_pool_destroy(pool); return NULL; } /* register application in client stack */ mrcp_client_application_register(mrcp_client,mrcp_app,"ASRAPP"); /* start client stack */ if(mrcp_client_start(mrcp_client) != TRUE) { mrcp_client_destroy(mrcp_client); apt_log_instance_destroy(); apr_pool_destroy(pool); return NULL; } engine->mrcp_client = mrcp_client; engine->mrcp_app = mrcp_app; return engine; }
int main(int argc, const char * const *argv) { apr_pool_t *pool = NULL; client_options_t options; apt_dir_layout_t *dir_layout; const char *log_conf_path; demo_framework_t *framework; /* APR global initialization */ if(apr_initialize() != APR_SUCCESS) { apr_terminate(); return 0; } /* create APR pool */ pool = apt_pool_create(); if(!pool) { apr_terminate(); return 0; } /* set the default options */ options.root_dir_path = "../"; options.log_priority = NULL; options.log_output = NULL; /* load options */ if(demo_framework_options_load(&options,argc,argv,pool) != TRUE) { apr_pool_destroy(pool); apr_terminate(); return 0; } /* create the structure of default directories layout */ dir_layout = apt_default_dir_layout_create(options.root_dir_path,pool); /* get path to logger configuration file */ log_conf_path = apt_confdir_filepath_get(dir_layout,"logger.xml",pool); /* create and load singleton logger */ apt_log_instance_load(log_conf_path,pool); if(options.log_priority) { /* override the log priority, if specified in command line */ apt_log_priority_set(atoi(options.log_priority)); } if(options.log_output) { /* override the log output mode, if specified in command line */ apt_log_output_mode_set(atoi(options.log_output)); } if(apt_log_output_mode_check(APT_LOG_OUTPUT_FILE) == TRUE) { /* open the log file */ apt_log_file_open(dir_layout->log_dir_path,"unimrcpclient",MAX_LOG_FILE_SIZE,MAX_LOG_FILE_COUNT,pool); } /* create demo framework */ framework = demo_framework_create(dir_layout); if(framework) { /* run command line */ demo_framework_cmdline_run(framework); /* destroy demo framework */ demo_framework_destroy(framework); } /* destroy singleton logger */ apt_log_instance_destroy(); /* destroy APR pool */ apr_pool_destroy(pool); /* APR global termination */ apr_terminate(); return 0; }
/** \brief Load UniMRCP engine */ static apt_bool_t uni_engine_load() { apr_pool_t *pool; apt_dir_layout_t *dir_layout; /* APR global initialization */ if(apr_initialize() != APR_SUCCESS) { ast_log(LOG_ERROR, "Failed to initialize APR\n"); return FALSE; } uni_engine.pool = NULL; uni_engine.client = NULL; uni_engine.application = NULL; uni_engine.profile = NULL; uni_engine.log_level = APT_PRIO_INFO; uni_engine.log_output = APT_LOG_OUTPUT_CONSOLE | APT_LOG_OUTPUT_FILE; uni_engine.grammars = NULL; pool = apt_pool_create(); if(!pool) { ast_log(LOG_ERROR, "Failed to create APR pool\n"); uni_engine_unload(); return FALSE; } uni_engine.pool = pool; uni_engine.v2_properties = NULL; uni_engine.v1_properties = NULL; /* Load engine configuration */ uni_engine_config_load(pool); if(!uni_engine.profile) { uni_engine.profile = "uni2"; } dir_layout = apt_default_dir_layout_create(UNIMRCP_DIR_LOCATION,pool); /* Create singleton logger */ apt_log_instance_create(uni_engine.log_output, uni_engine.log_level, pool); /* Open the log file */ apt_log_file_open(dir_layout->log_dir_path,"astuni",MAX_LOG_FILE_SIZE,MAX_LOG_FILE_COUNT,TRUE,pool); uni_engine.client = unimrcp_client_create(dir_layout); if(uni_engine.client) { uni_engine.application = mrcp_application_create( uni_message_handler, &uni_engine, pool); if(uni_engine.application) { mrcp_client_application_register( uni_engine.client, uni_engine.application, "ASTMRCP"); } } if(!uni_engine.client || !uni_engine.application) { ast_log(LOG_ERROR, "Failed to initialize client stack\n"); uni_engine_unload(); return FALSE; } return TRUE; }
int main(int argc, const char * const *argv) { apr_pool_t *pool; server_options_t options; const char *log_conf_path; apt_dir_layout_t *dir_layout = NULL; /* APR global initialization */ if(apr_initialize() != APR_SUCCESS) { apr_terminate(); return 0; } /* create APR pool */ pool = apt_pool_create(); if(!pool) { apr_terminate(); return 0; } /* load options */ if(options_load(&options,argc,argv,pool) != TRUE) { apr_pool_destroy(pool); apr_terminate(); return 0; } if(options.dir_layout_conf) { /* create and load directories layout from the configuration file */ dir_layout = apt_dir_layout_create(pool); if(dir_layout) apt_dir_layout_load(dir_layout,options.dir_layout_conf,pool); } else { /* create default directories layout */ dir_layout = apt_default_dir_layout_create(options.root_dir_path,pool); } if(!dir_layout) { printf("Failed to Create Directories Layout\n"); apr_pool_destroy(pool); apr_terminate(); return 0; } /* get path to logger configuration file */ log_conf_path = apt_confdir_filepath_get(dir_layout,"logger.xml",pool); /* create and load singleton logger */ apt_log_instance_load(log_conf_path,pool); if(options.log_priority) { /* override the log priority, if specified in command line */ apt_log_priority_set(atoi(options.log_priority)); } if(options.log_output) { /* override the log output mode, if specified in command line */ apt_log_output_mode_set(atoi(options.log_output)); } if(apt_log_output_mode_check(APT_LOG_OUTPUT_FILE) == TRUE) { /* open the log file */ const char *log_dir_path = apt_dir_layout_path_get(dir_layout,APT_LAYOUT_LOG_DIR); apt_log_file_open(log_dir_path,"unimrcpserver",MAX_LOG_FILE_SIZE,MAX_LOG_FILE_COUNT,TRUE,pool); } if(options.foreground == TRUE) { /* run command line */ uni_cmdline_run(dir_layout,pool); } #ifdef WIN32 else { /* run as windows service */ uni_service_run(options.svcname,dir_layout,pool); } #else else {
int main(int argc, char const* argv[]) { apr_pool_t* pool = NULL; apr_pool_t* spool = NULL; int i; struct iovec cattext[101]; static char const SP = ' '; char const* outfile; apr_status_t status; apt_dir_layout_t* dirLayout = NULL; mrcp_client_t* client = NULL; mrcp_application_t* app = NULL; mrcp_session_t* sess = NULL; mpf_stream_capabilities_t* caps = NULL; mpf_termination_t* term = NULL; mrcp_channel_t* chan = NULL; struct stat info; if (argc < 2) { puts("Usage:"); printf("\t%s \"This is a synthetic voice.\"", argv[0]); exit(1); } /* Just detect various directory layout constellations */ if (stat(ROOT_DIR, &info)) ROOT_DIR = ROOT_DIR2; if (stat(ROOT_DIR, &info)) ROOT_DIR = ROOT_DIR3; /* Initialize platform first */ if (apr_initialize() != APR_SUCCESS) FAIL("Cannot initialize APR platform"); pool = apt_pool_create(); if (!pool) FAIL("Not enough memory"); for (i = 0; (i < argc - 2) && (i < 50); i += 2) { cattext[2 * i].iov_base = (void*) argv[i + 1]; cattext[2 * i].iov_len = strlen(argv[i + 1]); cattext[2 * i + 1].iov_base = (void*) &SP; cattext[2 * i + 1].iov_len = 1; } cattext[2 * i].iov_base = (void*) argv[i + 1]; cattext[2 * i].iov_len = strlen(argv[i + 1]); text = apr_pstrcatv(pool, cattext, 2 * i + 1, NULL); if (!text) FAIL("Not enough memory"); outfile = apr_pstrcat(pool, ROOT_DIR, "/data/", PCM_OUT_FILE, NULL); printf("This is a sample C UniMRCP client synthesizer scenario.\n"); printf("Use client configuration from %s/conf/unimrcpclient.xml\n", ROOT_DIR); printf("Use profile %s\n", MRCP_PROFILE); printf("Synthesize text: `%s'\n", text); printf("Write output to file: %s\n", outfile); printf("\n"); printf("Press enter to start the session...\n"); (void) getchar(); apt_log_instance_create(APT_LOG_OUTPUT_NONE, APT_PRIO_DEBUG, pool); apt_log_ext_handler_set(UniSynth_logger); dirLayout = apt_default_dir_layout_create(ROOT_DIR, pool); /* Create and start the client in a root dir */ client = unimrcp_client_create(dirLayout); if (!client) FAIL("Cannot create UniMRCP client"); app = mrcp_application_create(UniSynthAppMsgHandler, NULL, mrcp_client_memory_pool_get(client)); if (!app) FAIL("Cannot create MRCP application"); if (!mrcp_client_application_register(client, app, "Sample C app")) FAIL("Cannot register MRCP application"); if (!mrcp_client_start(client)) FAIL("Cannot start MRCP client"); /* Create a session using MRCP profile MRCP_PROFILE */ sess = mrcp_application_session_create(app, MRCP_PROFILE, NULL); if (!sess) FAIL("Cannot create session"); spool = mrcp_application_session_pool_get(sess); /* Create audio termination with capabilities */ caps = mpf_stream_capabilities_create(STREAM_DIRECTION_SEND, spool); if (!caps) FAIL("Error creating capabilities"); if (!mpf_codec_capabilities_add(&caps->codecs, MPF_SAMPLE_RATE_8000, "LPCM")) FAIL("Error adding codec capabilities"); term = mrcp_application_audio_termination_create(sess, &stream_vtable, caps, NULL); if (!term) FAIL("Cannot create audio termination"); /* Add signaling channel (and start processing in OnAdd method */ f = fopen(outfile, "wb"); if (!f) FAIL("Cannot open output file"); status = apr_thread_mutex_create(&mutex, APR_THREAD_MUTEX_DEFAULT, pool); if (status != APR_SUCCESS) FAIL("Cannot create mutex"); status = apr_thread_cond_create(&cond, pool); if (status != APR_SUCCESS) FAIL("Cannot create condition variable"); chan = mrcp_application_channel_create(sess, MRCP_SYNTHESIZER_RESOURCE, term, NULL, NULL); if (!chan) FAIL("Cannot create channel"); if (!mrcp_application_channel_add(sess, chan)) FAIL("Cannot add channel"); /* Now wait until the processing finishes */ apr_thread_mutex_lock(mutex); while (err < 0) apr_thread_cond_wait(cond, mutex); apr_thread_mutex_unlock(mutex); cleanup: if (sess) mrcp_application_session_terminate(sess); if (f) fclose(f); if (client) mrcp_client_shutdown(client); if (app) mrcp_application_destroy(app); if (client) mrcp_client_destroy(client); apt_log_instance_destroy(); if (pool) apr_pool_destroy(pool); apr_terminate(); puts("Program finished, memory released. Press any key to exit."); (void) getchar(); return err; }
int main(int argc, const char * const *argv) { apr_pool_t *pool; apr_status_t rv; apr_getopt_t *opt; static const apr_getopt_option_t opt_option[] = { /* long-option, short-option, has-arg flag, description */ { "register", 'r', TRUE, "register service" }, /* -r or --register arg */ { "unregister", 'u', FALSE, "unregister service" },/* -u or --unregister */ { "start", 's', FALSE, "start service" }, /* -s or --start */ { "stop", 't', FALSE, "stop service" }, /* -t or --stop */ { "help", 'h', FALSE, "show help" }, /* -h or --help */ { NULL, 0, 0, NULL }, /* end */ }; /* APR global initialization */ if(apr_initialize() != APR_SUCCESS) { apr_terminate(); return 0; } /* create APR pool */ pool = apt_pool_create(); if(!pool) { apr_terminate(); return 0; } rv = apr_getopt_init(&opt, pool , argc, argv); if(rv == APR_SUCCESS) { int optch; const char *optarg; while((rv = apr_getopt_long(opt, opt_option, &optch, &optarg)) == APR_SUCCESS) { switch(optch) { case 'r': uni_service_register(optarg,pool); break; case 'u': uni_service_unregister(); break; case 's': uni_service_start(); break; case 't': uni_service_stop(); break; case 'h': usage(); break; } } if(rv != APR_EOF) { usage(); } } /* destroy APR pool */ apr_pool_destroy(pool); /* APR global termination */ apr_terminate(); return 0; }
/** \brief Load UniMRCP engine */ static apt_bool_t uni_engine_load() { apr_pool_t *pool; apt_dir_layout_t *dir_layout; /* APR global initialization */ if(apr_initialize() != APR_SUCCESS) { ast_log(LOG_ERROR, "Failed to initialize APR\n"); return FALSE; } uni_engine.pool = NULL; uni_engine.client = NULL; uni_engine.application = NULL; uni_engine.profile = NULL; uni_engine.log_level = APT_PRIO_INFO; uni_engine.log_output = APT_LOG_OUTPUT_CONSOLE | APT_LOG_OUTPUT_FILE; uni_engine.grammars = NULL; uni_engine.v2_properties = NULL; uni_engine.v1_properties = NULL; uni_engine.mutex = NULL; uni_engine.current_speech_index = 0; pool = apt_pool_create(); if(!pool) { ast_log(LOG_ERROR, "Failed to create APR pool\n"); uni_engine_unload(); return FALSE; } uni_engine.pool = pool; if(apr_thread_mutex_create(&uni_engine.mutex, APR_THREAD_MUTEX_DEFAULT, pool) != APR_SUCCESS) { ast_log(LOG_ERROR, "Failed to create engine mutex\n"); uni_engine_unload(); return FALSE; } /* Load engine configuration */ uni_engine_config_load(pool); if(!uni_engine.profile) { uni_engine.profile = "uni2"; } dir_layout = apt_default_dir_layout_create(UNIMRCP_DIR_LOCATION,pool); /* Create singleton logger */ apt_log_instance_create(uni_engine.log_output, uni_engine.log_level, pool); if(apt_log_output_mode_check(APT_LOG_OUTPUT_FILE) == TRUE) { #ifdef OPAQUE_DIR_LAYOUT const char *log_dir_path = apt_dir_layout_path_get(dir_layout,APT_LAYOUT_LOG_DIR); #else const char *log_dir_path = dir_layout->log_dir_path; #endif /* Open the log file */ apt_log_file_open(log_dir_path,"astuni",MAX_LOG_FILE_SIZE,MAX_LOG_FILE_COUNT,TRUE,pool); } uni_engine.client = unimrcp_client_create(dir_layout); if(uni_engine.client) { uni_engine.application = mrcp_application_create( uni_message_handler, &uni_engine, pool); if(uni_engine.application) { mrcp_client_application_register( uni_engine.client, uni_engine.application, "ASTMRCP"); } } if(!uni_engine.client || !uni_engine.application) { ast_log(LOG_ERROR, "Failed to initialize MRCP client\n"); uni_engine_unload(); return FALSE; } return TRUE; }
/** Create MRCP server instance */ MRCP_DECLARE(mrcp_server_t*) mrcp_server_create(apt_dir_layout_t *dir_layout) { mrcp_server_t *server; apr_pool_t *pool; apt_task_t *task; apt_task_vtable_t *vtable; apt_task_msg_pool_t *msg_pool; pool = apt_pool_create(); if(!pool) { return NULL; } apt_log(APT_LOG_MARK,APT_PRIO_NOTICE,"Create "SERVER_TASK_NAME); server = apr_palloc(pool,sizeof(mrcp_server_t)); server->pool = pool; server->dir_layout = dir_layout; server->resource_factory = NULL; server->engine_factory = NULL; server->engine_loader = NULL; server->media_engine_table = NULL; server->rtp_factory_table = NULL; server->sig_agent_table = NULL; server->cnt_agent_table = NULL; server->rtp_settings_table = NULL; server->profile_table = NULL; server->session_table = NULL; server->connection_msg_pool = NULL; server->engine_msg_pool = NULL; msg_pool = apt_task_msg_pool_create_dynamic(0,pool); server->task = apt_consumer_task_create(server,msg_pool,pool); if(!server->task) { apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Create Server Task"); return NULL; } task = apt_consumer_task_base_get(server->task); apt_task_name_set(task,SERVER_TASK_NAME); vtable = apt_task_vtable_get(task); if(vtable) { vtable->process_msg = mrcp_server_msg_process; vtable->on_start_request = mrcp_server_on_start_request; vtable->on_terminate_request = mrcp_server_on_terminate_request; vtable->on_start_complete = mrcp_server_on_start_complete; vtable->on_terminate_complete = mrcp_server_on_terminate_complete; } server->engine_factory = mrcp_engine_factory_create(server->pool); server->engine_loader = mrcp_engine_loader_create(server->pool); server->media_engine_table = apr_hash_make(server->pool); server->rtp_factory_table = apr_hash_make(server->pool); server->rtp_settings_table = apr_hash_make(server->pool); server->sig_agent_table = apr_hash_make(server->pool); server->cnt_agent_table = apr_hash_make(server->pool); server->profile_table = apr_hash_make(server->pool); server->session_table = apr_hash_make(server->pool); return server; }
int main(int argc, const char * const *argv) { apr_pool_t *pool; apr_status_t rv; apr_getopt_t *opt; apt_bool_t ret = TRUE; uni_service_register_e reg = USR_NONE; uni_service_control_e control = USC_NONE; const char *root_dir = ".."; const char *name = NULL; apt_bool_t autostart = FALSE; unsigned long recover = 0; int log_priority = -1; const char *disp_name = NULL; const char *description = NULL; static const apr_getopt_option_t opt_option[] = { /* long-option, short-option, has-arg flag, description */ { "register", 'r', TRUE, "register service" }, /* -r or --register arg */ { "unregister", 'u', FALSE, "unregister service" }, /* -u or --unregister */ { "start", 's', FALSE, "start service" }, /* -s or --start */ { "stop", 't', FALSE, "stop service" }, /* -t or --stop */ { "name", 'n', TRUE, "service name" }, /* -n or --name arg */ { "autostart", 'a', FALSE, "start automatically" },/* -a or --autostart */ { "fail-restart",'f', TRUE, "restart if fails" }, /* -f or --fail-restart arg */ { "log-prio", 'l', TRUE, "log priority" }, /* -l arg or --log-prio arg */ { "disp-name", 'p', TRUE, "display name" }, /* -p arg or --disp-name arg */ { "description", 'c', TRUE, "description" }, /* -c arg or --description arg */ { "help", 'h', FALSE, "show help" }, /* -h or --help */ { NULL, 0, 0, NULL }, /* end */ }; /* APR global initialization */ if(apr_initialize() != APR_SUCCESS) { apr_terminate(); return 1; } /* create APR pool */ pool = apt_pool_create(); if(!pool) { apr_terminate(); return 1; } rv = apr_getopt_init(&opt, pool , argc, argv); if(rv == APR_SUCCESS) { int optch; const char *optarg; while((rv = apr_getopt_long(opt, opt_option, &optch, &optarg)) == APR_SUCCESS) { switch(optch) { case 'r': if ((reg == USR_NONE) || (reg == USR_REGISTER)) { reg = USR_REGISTER; root_dir = optarg; } else { puts("Incosistent arguments"); ret = FALSE; } break; case 'u': if ((reg == USR_NONE) || (reg == USR_UNREGISTER)) reg = USR_UNREGISTER; else { puts("Incosistent arguments"); ret = FALSE; } break; case 's': if ((control == USC_NONE) || (control == USC_START)) control = USC_START; else { puts("Incosistent arguments"); ret = FALSE; } break; case 't': if ((control == USC_NONE) || (control == USC_STOP)) control = USC_STOP; else { puts("Incosistent arguments"); ret = FALSE; } break; case 'n': name = optarg; break; case 'a': autostart = TRUE; break; case 'f': if (sscanf(optarg, "%lu", &recover) != 1) { puts("Invalid value for param --fail-restart"); ret = FALSE; } break; case 'l': if ((sscanf(optarg, "%d", &log_priority) != 1) || (log_priority < 0) || (log_priority > 7)) { puts("Invalid value for param --log-prio"); ret = FALSE; } break; case 'p': disp_name = optarg; break; case 'c': description = optarg; break; case 'h': usage(); break; } if (!ret) break; } if (ret && (((reg == USR_REGISTER) && (control == USC_STOP)) || ((reg == USR_UNREGISTER) && (control == USC_START)))) { ret = FALSE; puts("Inconsistent arguments"); } if((rv != APR_EOF) || !ret || (!reg && !control)) { ret = FALSE; usage(); } } while (ret) { /* No problem so far */ if (reg == USR_REGISTER) ret = uni_service_register(root_dir, pool, name, autostart, recover, log_priority, disp_name, description); if (!ret) break; if (control == USC_START) ret = uni_service_start(name); if (!ret) break; if (control == USC_STOP) ret = uni_service_stop(name); /* Do not break here, stop failure should not matter before unregistration */ if (reg == USR_UNREGISTER) ret = uni_service_unregister(name); break; } /* destroy APR pool */ apr_pool_destroy(pool); /* APR global termination */ apr_terminate(); return ret ? 0 : 1; }
bool UmcConsole::Run(int argc, const char * const *argv) { apr_pool_t* pool = NULL; apt_dir_layout_t* pDirLayout = NULL; const char *logConfPath; /* APR global initialization */ if(apr_initialize() != APR_SUCCESS) { apr_terminate(); return false; } /* create APR pool */ pool = apt_pool_create(); if(!pool) { apr_terminate(); return false; } /* load options */ if(!LoadOptions(argc,argv,pool)) { apr_pool_destroy(pool); apr_terminate(); return false; } if(m_Options.m_DirLayoutConf) { /* create and load directories layout from the configuration file */ pDirLayout = apt_dir_layout_create(pool); if(pDirLayout) apt_dir_layout_load(pDirLayout,m_Options.m_DirLayoutConf,pool); } else { /* create default directories layout */ pDirLayout = apt_default_dir_layout_create(m_Options.m_RootDirPath,pool); } if(!pDirLayout) { printf("Failed to Create Directories Layout\n"); apr_pool_destroy(pool); apr_terminate(); return false; } /* get path to logger configuration file */ logConfPath = apt_confdir_filepath_get(pDirLayout,"logger.xml",pool); /* create and load singleton logger */ apt_log_instance_load(logConfPath,pool); if(m_Options.m_LogPriority) { /* override the log priority, if specified in command line */ apt_log_priority_set((apt_log_priority_e)atoi(m_Options.m_LogPriority)); } if(m_Options.m_LogOutput) { /* override the log output mode, if specified in command line */ apt_log_output_mode_set((apt_log_output_e)atoi(m_Options.m_LogOutput)); } if(apt_log_output_mode_check(APT_LOG_OUTPUT_FILE) == TRUE) { /* open the log file */ const char *logDirPath = apt_dir_layout_path_get(pDirLayout,APT_LAYOUT_LOG_DIR); apt_log_file_open(logDirPath,"unimrcpclient",MAX_LOG_FILE_SIZE,MAX_LOG_FILE_COUNT,FALSE,pool); } /* create demo framework */ if(m_pFramework->Create(pDirLayout,pool)) { /* run command line */ RunCmdLine(); /* destroy demo framework */ m_pFramework->Destroy(); } /* destroy singleton logger */ apt_log_instance_destroy(); /* destroy APR pool */ apr_pool_destroy(pool); /* APR global termination */ apr_terminate(); return true; }