AST_COMPAT_STATIC int unload_module(void)
{
int res = 0;
apr_hash_index_t *hi;
/* First unregister the applications so no more calls arrive. */
for (hi = apr_hash_first(NULL, globals.apps); hi; hi = apr_hash_next(hi)) {
const void *key;
const char *name;
apr_hash_this(hi, &key, NULL, NULL);
name = (const char *) key;
res |= ast_unregister_application(name);
}
/* Unload the applications. */
unload_mrcpsynth_app();
unload_mrcprecog_app();
unload_synthandrecog_app();
/* Stop the MRCP client stack. */
if (globals.mrcp_client != NULL) {
if (!mrcp_client_shutdown(globals.mrcp_client))
ast_log(LOG_WARNING, "Unable to shutdown MRCP client stack processing\n");
else
ast_log(LOG_DEBUG, "MRCP client stack processing shutdown\n");
if (!mrcp_client_destroy(globals.mrcp_client))
ast_log(LOG_WARNING, "Unable to destroy MRCP client stack\n");
else
ast_log(LOG_DEBUG, "MRCP client stack destroyed\n");
globals.mrcp_client = NULL;
}
if (!apt_log_instance_destroy())
ast_log(LOG_WARNING, "Unable to destroy UniMRCP logger instance\n");
/* Destroy globals. */
globals_destroy();
if ((res == 0) && (apr_initialized != 0)) {
apr_terminate();
apr_initialized = 0;
}
return res;
}
/** Destroy ASR engine */
ASR_CLIENT_DECLARE(apt_bool_t) asr_engine_destroy(asr_engine_t *engine)
{
if(engine->mrcp_client) {
/* shutdown client stack */
mrcp_client_shutdown(engine->mrcp_client);
/* destroy client stack */
mrcp_client_destroy(engine->mrcp_client);
engine->mrcp_client = NULL;
engine->mrcp_app = NULL;
}
/* destroy singleton logger */
apt_log_instance_destroy();
/* destroy APR pool */
apr_pool_destroy(engine->pool);
return TRUE;
}
/** \brief Unload UniMRCP engine */
static apt_bool_t uni_engine_unload()
{
if(uni_engine.client) {
mrcp_client_destroy(uni_engine.client);
uni_engine.client = NULL;
}
/* Destroy singleton logger */
apt_log_instance_destroy();
if(uni_engine.pool) {
apr_pool_destroy(uni_engine.pool);
uni_engine.pool = NULL;
}
/* APR global termination */
apr_terminate();
return TRUE;
}
/** 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, 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;
}
AST_COMPAT_STATIC int load_module(void)
{
int res = 0;
apr_hash_index_t *hi;
if (apr_initialized == 0) {
if (apr_initialize() != APR_SUCCESS) {
ast_log(LOG_ERROR, "Unable to initialize APR\n");
apr_terminate();
apr_initialized = 0;
return AST_MODULE_LOAD_DECLINE;
} else {
ast_log(LOG_DEBUG, "APR initialized\n");
apr_initialized = 1;
}
}
/* Initialize globals. */
if (globals_init() != 0) {
ast_log(LOG_DEBUG, "Unable to initialize globals\n");
apr_terminate();
apr_initialized = 0;
return AST_MODULE_LOAD_DECLINE;
}
/* Load the configuration file mrcp.conf. */
#if AST_VERSION_AT_LEAST(1,6,0)
struct ast_flags config_flags = { 0 };
struct ast_config *cfg = ast_config_load(MRCP_CONFIG, config_flags);
#else
struct ast_config *cfg = ast_config_load(MRCP_CONFIG);
#endif
if (!cfg) {
ast_log(LOG_WARNING, "No such configuration file %s\n", MRCP_CONFIG);
globals_destroy();
apr_terminate();
apr_initialized = 0;
return AST_MODULE_LOAD_DECLINE;
}
if (load_mrcp_config(cfg) != 0) {
ast_log(LOG_DEBUG, "Unable to load configuration\n");
globals_destroy();
apr_terminate();
apr_initialized = 0;
return AST_MODULE_LOAD_DECLINE;
}
/* Link UniMRCP logs to Asterisk. */
ast_log(LOG_NOTICE, "UniMRCP log level = %s\n", globals.unimrcp_log_level);
apt_log_priority_e log_priority = apt_log_priority_translate(globals.unimrcp_log_level);
if (apt_log_instance_create(APT_LOG_OUTPUT_NONE, log_priority, globals.pool) == FALSE) {
/* Already created. */
apt_log_priority_set(log_priority);
}
apt_log_ext_handler_set(unimrcp_log);
/* Create the MRCP client. */
if ((globals.mrcp_client = mod_unimrcp_client_create(globals.pool)) == NULL) {
ast_log(LOG_ERROR, "Failed to create MRCP client\n");
if (!apt_log_instance_destroy())
ast_log(LOG_WARNING, "Unable to destroy UniMRCP logger instance\n");
globals_destroy();
apr_terminate();
apr_initialized = 0;
return AST_MODULE_LOAD_DECLINE;
}
/* Load the applications. */
load_mrcpsynth_app();
load_mrcprecog_app();
load_synthandrecog_app();
/* Start the client stack. */
if (!mrcp_client_start(globals.mrcp_client)) {
ast_log(LOG_ERROR, "Failed to start MRCP client stack processing\n");
if (!mrcp_client_destroy(globals.mrcp_client))
ast_log(LOG_WARNING, "Unable to destroy MRCP client stack\n");
else
ast_log(LOG_DEBUG, "MRCP client stack destroyed\n");
globals.mrcp_client = NULL;
if (!apt_log_instance_destroy())
ast_log(LOG_WARNING, "Unable to destroy UniMRCP logger instance\n");
globals_destroy();
apr_terminate();
apr_initialized = 0;
return AST_MODULE_LOAD_DECLINE;
}
/* Register the applications. */
for (hi = apr_hash_first(NULL, globals.apps); hi; hi = apr_hash_next(hi)) {
const void *key;
void *val;
const char *name;
ast_mrcp_application_t *application;
apr_hash_this(hi, &key, NULL, &val);
name = (const char *) key;
application = (ast_mrcp_application_t *) val;
#if AST_VERSION_AT_LEAST(1,6,2)
res |= ast_register_application_xml(name, application->exec);
#else
res |= ast_register_application(name, application->exec, application->synopsis, application->description);
#endif
}
return res;
}
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;
}
APT_DECLARE(void) apt_test_framework_destroy(apt_test_framework_t *framework)
{
apt_log(APT_LOG_MARK,APT_PRIO_NOTICE,"Destroy Test Framework");
apt_log_instance_destroy();
apr_pool_destroy(framework->pool);
}
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;
}