/** 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; 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 {
/** Run MPF test suite */ static apt_bool_t mpf_test_run(apt_test_suite_t *suite, int argc, const char * const *argv) { mpf_suite_agent_t *agent; mpf_codec_manager_t *codec_manager; mpf_rtp_config_t *rtp_config; mpf_rtp_settings_t *rtp_settings; mpf_engine_t *engine; apt_task_t *task; apt_task_vtable_t *vtable; apt_task_msg_pool_t *msg_pool; agent = apr_palloc(suite->pool,sizeof(mpf_suite_agent_t)); agent->dir_layout = apt_default_dir_layout_create(NULL,suite->pool); engine = mpf_engine_create("MPF-Engine",suite->pool); if(!engine) { apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Create MPF Engine"); return FALSE; } codec_manager = mpf_engine_codec_manager_create(suite->pool); if(!codec_manager) { apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Create Codec Manager"); return FALSE; } mpf_engine_codec_manager_register(engine,codec_manager); agent->engine = engine; rtp_config = mpf_rtp_config_alloc(suite->pool); apt_string_set(&rtp_config->ip,"127.0.0.1"); rtp_config->rtp_port_min = 5000; rtp_config->rtp_port_max = 6000; agent->rtp_config = rtp_config; rtp_settings = mpf_rtp_settings_alloc(suite->pool); rtp_settings->ptime = 20; rtp_settings->jb_config.adaptive = 1; rtp_settings->jb_config.time_skew_detection = 1; rtp_settings->jb_config.min_playout_delay = 0; rtp_settings->jb_config.initial_playout_delay = 50; rtp_settings->jb_config.max_playout_delay = 800; mpf_codec_manager_codec_list_load(codec_manager,&rtp_settings->codec_list,"PCMU",suite->pool); agent->rtp_settings = rtp_settings; agent->rtp_termination_factory = mpf_rtp_termination_factory_create(rtp_config,suite->pool); agent->file_termination_factory = mpf_file_termination_factory_create(suite->pool); agent->rx_session = NULL; agent->tx_session = NULL; msg_pool = apt_task_msg_pool_create_dynamic(sizeof(mpf_message_t),suite->pool); apt_log(APT_LOG_MARK,APT_PRIO_NOTICE,"Create Consumer Task"); agent->consumer_task = apt_consumer_task_create(agent,msg_pool,suite->pool); if(!agent->consumer_task) { apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Create Consumer Task"); return FALSE; } task = apt_consumer_task_base_get(agent->consumer_task); apt_task_name_set(task,"MPF-Tester"); vtable = apt_task_vtable_get(task); if(vtable) { vtable->process_msg = mpf_suite_task_msg_process; vtable->on_start_complete = mpf_suite_on_start_complete; vtable->on_terminate_complete = mpf_suite_on_terminate_complete; } apt_task_add(task,mpf_task_get(engine)); apr_thread_mutex_create(&agent->wait_object_mutex,APR_THREAD_MUTEX_UNNESTED,suite->pool); apr_thread_cond_create(&agent->wait_object,suite->pool); if(apt_task_start(task) == FALSE) { apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Start Task"); apt_task_destroy(task); return FALSE; } apr_thread_mutex_lock(agent->wait_object_mutex); apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Wait for Task to Complete"); apr_thread_cond_wait(agent->wait_object,agent->wait_object_mutex); apr_thread_mutex_unlock(agent->wait_object_mutex); apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Terminate Task [wait till complete]"); apt_task_terminate(task,TRUE); apt_log(APT_LOG_MARK,APT_PRIO_NOTICE,"Destroy Task"); apt_task_destroy(task); apr_thread_cond_destroy(agent->wait_object); apr_thread_mutex_destroy(agent->wait_object_mutex); return TRUE; }
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; }
/* Create an MRCP client. * * Some code and ideas borrowed from unimrcp-client.c * Please check $unimrcp_dir$/platforms/libunimrcp-client/src/unimrcp_client.c * when upgrading the UniMRCP library to ensure nothing new needs to be set up. */ mrcp_client_t *mod_unimrcp_client_create(apr_pool_t *mod_pool) { mrcp_client_t *client = NULL; apt_dir_layout_t *dir_layout = NULL; apr_pool_t *pool = NULL; mrcp_resource_factory_t *resource_factory = NULL; mpf_codec_manager_t *codec_manager = NULL; apr_size_t max_connection_count = 0; apt_bool_t offer_new_connection = FALSE; mrcp_connection_agent_t *shared_connection_agent = NULL; mpf_engine_t *shared_media_engine = NULL; if (!globals.profiles) { ast_log(LOG_ERROR, "Profiles hash is NULL\n"); return NULL; } /* Create the client. */ if ((dir_layout = apt_default_dir_layout_create("../", mod_pool)) == NULL) { ast_log(LOG_ERROR, "Unable to create directory layout\n"); return NULL; } if ((client = mrcp_client_create(dir_layout)) == NULL) { ast_log(LOG_ERROR, "Unable to create MRCP client stack\n"); return NULL; } if ((pool = mrcp_client_memory_pool_get(client)) == NULL) { ast_log(LOG_ERROR, "MRCP client pool is NULL\n"); return NULL; } mrcp_resource_loader_t *resource_loader = mrcp_resource_loader_create(FALSE, pool); if (resource_loader == NULL) { ast_log(LOG_ERROR, "Unable to create MRCP resource loader.\n"); return NULL; } apt_str_t resource_class_synth; apt_str_t resource_class_recog; apt_string_set(&resource_class_synth, "speechsynth"); apt_string_set(&resource_class_recog, "speechrecog"); mrcp_resource_load(resource_loader, &resource_class_synth); mrcp_resource_load(resource_loader, &resource_class_recog); resource_factory = mrcp_resource_factory_get(resource_loader); if (!mrcp_client_resource_factory_register(client, resource_factory)) ast_log(LOG_WARNING, "Unable to register MRCP client resource factory\n"); if ((codec_manager = mpf_engine_codec_manager_create(pool)) != NULL) { if (!mrcp_client_codec_manager_register(client, codec_manager)) ast_log(LOG_WARNING, "Unable to register MRCP client codec manager\n"); } /* Set up MRCPv2 connection agent that will be shared with all profiles. */ if ((globals.unimrcp_max_connection_count != NULL) && (strlen(globals.unimrcp_max_connection_count) > 0)) max_connection_count = atoi(globals.unimrcp_max_connection_count); if (max_connection_count <= 0) max_connection_count = DEFAULT_UNIMRCP_MAX_CONNECTION_COUNT; if (globals.unimrcp_offer_new_connection != NULL) { if (strcasecmp(globals.unimrcp_offer_new_connection, "true") == 0 || atoi(globals.unimrcp_offer_new_connection) == 1) offer_new_connection = TRUE; } else { offer_new_connection = DEFAULT_UNIMRCP_OFFER_NEW_CONNECTION; } if ((shared_connection_agent = mrcp_client_connection_agent_create("MRCPv2ConnectionAgent", max_connection_count, offer_new_connection, pool)) != NULL) { if (shared_connection_agent != NULL) { if (globals.unimrcp_rx_buffer_size != NULL) { apr_size_t rx_buffer_size = (apr_size_t)atol(globals.unimrcp_rx_buffer_size); if (rx_buffer_size > 0) { mrcp_client_connection_rx_size_set(shared_connection_agent, rx_buffer_size); } } if (globals.unimrcp_tx_buffer_size != NULL) { apr_size_t tx_buffer_size = (apr_size_t)atol(globals.unimrcp_tx_buffer_size); if (tx_buffer_size > 0) { mrcp_client_connection_tx_size_set(shared_connection_agent, tx_buffer_size); } } if (globals.unimrcp_request_timeout != NULL) { apr_size_t request_timeout = (apr_size_t)atol(globals.unimrcp_request_timeout); if (request_timeout > 0) { mrcp_client_connection_timeout_set(shared_connection_agent, request_timeout); } } } if (!mrcp_client_connection_agent_register(client, shared_connection_agent)) ast_log(LOG_WARNING, "Unable to register MRCP client connection agent\n"); } /* Set up the media engine that will be shared with all profiles. */ if ((shared_media_engine = mpf_engine_create("MediaEngine", pool)) != NULL) { unsigned long realtime_rate = 1; if (!mpf_engine_scheduler_rate_set(shared_media_engine, realtime_rate)) ast_log(LOG_WARNING, "Unable to set scheduler rate for MRCP client media engine\n"); if (!mrcp_client_media_engine_register(client, shared_media_engine)) ast_log(LOG_WARNING, "Unable to register MRCP client media engine\n"); } if (globals.profiles) { if(load_profiles(client, shared_connection_agent, shared_media_engine, pool) !=0) return NULL; } return client; }
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; }
/** \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; }
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; }