void daemon_interface(void)
{
DEBUG_MSG("daemon_interface");
/* check if the plugin exists */
if (GBL_OPTIONS->plugin && search_plugin(GBL_OPTIONS->plugin) != ESUCCESS)
FATAL_ERROR("%s plugin can not be found !", GBL_OPTIONS->plugin);
/* build the list of active hosts */
build_hosts_list();
/* start the mitm attack */
mitm_start();
/* initialize the sniffing method */
EXECUTE(GBL_SNIFF->start);
/* if we have to activate a plugin */
if (GBL_OPTIONS->plugin && plugin_init(GBL_OPTIONS->plugin) != PLUGIN_RUNNING)
/* end the interface */
return;
/* discard the messages */
LOOP {
CANCELLATION_POINT();
sleep(1);
ui_msg_flush(MSG_ALL);
}
/* NOT REACHED */
}
void
sim_init_plugins(void)
{
plugin_init();
plugin_load_all();
plugin_print_all();
}
int l_plugin_load(lua_State* L)
{
char* error;
int argc = lua_gettop(L);
if (argc != 1)
return 0;
const char* plugin = lua_tostring(L,1);
if (0 != access(plugin, R_OK)) {
//printf("aura: Can't access plugin: %s\n", plugin);
return 0;
}
void* handle = dlopen(plugin, RTLD_LAZY|RTLD_GLOBAL);
if (!handle) {
printf("aura: Failed to load plugin: %s\n", dlerror());
return 0;
}
dlerror();
int (*plugin_init)(lua_State* L) = dlsym(handle, "aura_plugin_init");
if ((error = dlerror()) != NULL) {
fprintf(stderr, "%s\n", error);
return 0;
}
/* TODO: May be push handle as userdata to lua plugin array */
return plugin_init(L);
}
static gboolean
plugin_enable (MooPlugin *plugin)
{
MooEditWindowArray *windows;
guint i;
g_return_val_if_fail (MOO_IS_PLUGIN (plugin), FALSE);
if (moo_plugin_enabled (plugin))
return TRUE;
g_assert (!plugin->initialized);
plugin->params->enabled = TRUE;
if (!plugin_init (plugin))
{
plugin->params->enabled = FALSE;
return FALSE;
}
windows = moo_editor_get_windows (plugin_store->editor);
for (i = 0; i < windows->n_elms; ++i)
plugin_attach_win (plugin, windows->elms[i]);
moo_edit_window_array_free (windows);
return TRUE;
}
enc_context_p v4l2_init(const char *device_path) {
int fd = open(device_path, O_RDWR | O_NONBLOCK | O_CLOEXEC);
if (fd <= 0) {
PRINT("failed to open %s", device_path);
return NULL;
}
PRINT(" got %s", device_path);
enc_context_t *ctx = (enc_context_t *) calloc(1, sizeof(enc_context_t));
if (ctx == NULL)
goto failed_ctx;
ctx->fd = fd;
ctx->enc = plugin_init(ctx->fd);
if (!ctx->enc)
goto failed_plugin;
return ctx;
failed_ctx:
close(ctx->fd);
failed_plugin:
free(ctx);
return NULL;
}
/*
* callback function for a plugin
*/
static void curses_select_plugin(void *plugin)
{
/* prevent the selection when the list is empty */
if (plugin == NULL)
return;
/* print the message */
if (plugin_is_activated(plugin) == 0)
INSTANT_USER_MSG("Activating %s plugin...\n", plugin);
else
INSTANT_USER_MSG("Deactivating %s plugin...\n", plugin);
/*
* pay attention on this !
* if the plugin init does not return,
* we are blocked here. So it is encouraged
* to write plugins which spawn a thread
* and immediately return
*/
if (plugin_is_activated(plugin) == 1)
plugin_fini(plugin);
else
plugin_init(plugin);
/* refres the array for the list widget */
curses_plugins_update();
}
/*** screen_create() *****************************************************
* Your basic contructor type thingy... :)
************************************************************************
*/
int screen_create(void)
{
// Endast när det verkligen *är* en konstruktor... annars så segfault! :)
// if (screen.pixchar)
// free (screen.pixchar);
/* Initialize the keyboard and screen plugin */
plugin_init();
/* OLD (?) init of plugin...
* screen_plugin_init();
* keyboard_plugin_init();
*/
/* Check if the physical screen has been altered/resized. Some
* plugins need this to reallocate their own buffers and
* reinitialize them. Therefore we send pointers to the old
* size and hope the plugin does its own bit.
*/
screen_plugin_get_dim(&screen.max_row, &screen.max_col);
screen.pixchar = calloc(screen.max_col * screen.max_row, sizeof(char));
if (!screen.pixchar) {
perror("Failed allocating new buffer");
exit(1);
}
screen.dirty = 0;
screen.hpos = 0;
return 0;
}
static int
load_plugin(WsManPlugin *self, const char *p_name)
{
int retv = -1;
WsManPluginError err = plugin_init(self, p_name);
const char *plugin_err = dlerror();
message("Loading plugin: %s", p_name );
if( NULL == plugin_err )
plugin_err = "";
switch( err )
{
default:
debug( "Unable to load plugin %s. Error: %s", p_name, plugin_err );
break;
case PLUGIN_ERROR_NOTLOADED:
debug( "Unable to load plugin %s. Error: %s", p_name, plugin_err );
break;
case PLUGIN_ERROR_SYMBOLSNOTFOUND:
debug( "Plugin protocol %s unknown Error:%s", p_name, plugin_err );
break;
case PLUGIN_ERROR_INITFAILED:
debug("Unable to start plugin %s", p_name );
break;
case PLUGIN_ERROR_BADPARMS:
debug( "Bad parameters to plugin %s. Error: %s", p_name, plugin_err );
break;
case PLUGIN_ERROR_OK:
retv = 0 ;
break;
}
if( retv < 0 )
debug("Unable to load plugin %s.Error: %s", p_name, plugin_err);
return retv ;
}
void moloch_plugins_load(char **plugins) {
if (!config.pluginsDir)
return;
if (!plugins)
return;
if (!g_module_supported ()) {
LOG("ERROR - glib compiled without module support");
return;
}
moloch_add_can_quit((MolochCanQuitFunc)moloch_plugins_outstanding, "plugin outstanding");
int i;
for (i = 0; plugins[i]; i++) {
const char *name = plugins[i];
int d;
GModule *plugin = 0;
for (d = 0; config.pluginsDir[d]; d++) {
gchar *path = g_build_filename (config.pluginsDir[d], name, NULL);
if (!g_file_test(path, G_FILE_TEST_EXISTS)) {
g_free (path);
continue;
}
plugin = g_module_open (path, 0); /*G_MODULE_BIND_LAZY | G_MODULE_BIND_LOCAL);*/
if (!plugin) {
LOG("ERROR - Couldn't load plugin %s from '%s'\n%s", name, path, g_module_error());
g_free (path);
continue;
}
g_free (path);
break;
}
if (!plugin) {
LOG("WARNING - plugin '%s' not found", name);
continue;
}
MolochPluginInitFunc plugin_init;
if (!g_module_symbol(plugin, "moloch_plugin_init", (gpointer *)(char*)&plugin_init) || plugin_init == NULL) {
LOG("ERROR - Module %s doesn't have a moloch_plugin_init", name);
continue;
}
plugin_init();
}
}
void
weechat_init (int argc, char *argv[], void (*gui_init_cb)())
{
weechat_first_start_time = time (NULL); /* initialize start time */
gettimeofday (&weechat_current_start_timeval, NULL);
/* catch signals */
util_catch_signal (SIGINT, SIG_IGN); /* signal ignored */
util_catch_signal (SIGPIPE, SIG_IGN); /* signal ignored */
util_catch_signal (SIGSEGV, &debug_sigsegv); /* crash dump */
util_catch_signal (SIGHUP, &weechat_sighup); /* exit WeeChat */
util_catch_signal (SIGQUIT, &weechat_sigquit); /* exit WeeChat */
util_catch_signal (SIGTERM, &weechat_sigterm); /* exit WeeChat */
hdata_init (); /* initialize hdata */
hook_init (); /* initialize hooks */
debug_init (); /* hook signals for debug */
gui_color_init (); /* initialize colors */
gui_chat_init (); /* initialize chat */
command_init (); /* initialize WeeChat commands */
completion_init (); /* add core completion hooks */
gui_key_init (); /* init keys */
network_init_gcrypt (); /* init gcrypt */
if (!secure_init ()) /* init secured data options (sec.*)*/
weechat_shutdown (EXIT_FAILURE, 0);
if (!config_weechat_init ()) /* init WeeChat options (weechat.*) */
weechat_shutdown (EXIT_FAILURE, 0);
weechat_parse_args (argc, argv); /* parse command line args */
weechat_create_home_dir (); /* create WeeChat home directory */
log_init (); /* init log file */
plugin_api_init (); /* create some hooks (info,hdata,..)*/
secure_read (); /* read secured data options */
config_weechat_read (); /* read WeeChat options */
network_init_gnutls (); /* init GnuTLS */
if (gui_init_cb)
(*gui_init_cb) (); /* init WeeChat interface */
if (weechat_upgrading)
{
upgrade_weechat_load (); /* upgrade with session file */
weechat_upgrade_count++; /* increase /upgrade count */
}
weechat_startup_message (); /* display WeeChat startup message */
gui_chat_print_lines_waiting_buffer (NULL); /* display lines waiting */
weechat_term_check (); /* warning about wrong $TERM */
weechat_locale_check (); /* warning about wrong locale */
command_startup (0); /* command executed before plugins */
plugin_init (weechat_force_plugin_autoload, /* init plugin interface(s) */
argc, argv);
command_startup (1); /* commands executed after plugins */
if (!weechat_upgrading)
gui_layout_window_apply (gui_layout_current, -1);
if (weechat_upgrading)
upgrade_weechat_end (); /* remove .upgrade files + signal */
}
void moloch_plugins_init()
{
HASH_INIT(p_, plugins, moloch_string_hash, moloch_string_cmp);
if (!config.pluginsDir)
return;
if (!config.plugins)
return;
if (!g_module_supported ()) {
LOG("ERROR - glib compiled without module support");
return;
}
int i;
for (i = 0; config.plugins[i]; i++) {
const char *name = config.plugins[i];
int d;
GModule *plugin = 0;
for (d = 0; config.pluginsDir[d]; d++) {
gchar *path = g_build_filename (config.pluginsDir[d], name, NULL);
if (!g_file_test(path, G_FILE_TEST_EXISTS)) {
g_free (path);
continue;
}
plugin = g_module_open (path, 0); /*G_MODULE_BIND_LAZY | G_MODULE_BIND_LOCAL);*/
if (!plugin) {
LOG("ERROR - Couldn't load plugin %s from '%s'\n%s", name, path, g_module_error());
g_free (path);
continue;
}
g_free (path);
break;
}
if (!plugin)
continue;
MolochPluginInitFunc plugin_init;
if (!g_module_symbol(plugin, "moloch_plugin_init", (gpointer *)(char*)&plugin_init) || plugin_init == NULL) {
LOG("ERROR - Module %s doesn't have a moloch_plugin_init", name);
continue;
}
plugin_init();
}
}
static void init_dsp_plugin(void)
{
if (!(*g_settings.audio.dsp_plugin))
return;
rarch_dsp_info_t info = {0};
g_extern.audio_data.dsp_lib = dylib_load(g_settings.audio.dsp_plugin);
if (!g_extern.audio_data.dsp_lib)
{
RARCH_ERR("Failed to open DSP plugin: \"%s\" ...\n", g_settings.audio.dsp_plugin);
return;
}
const rarch_dsp_plugin_t* (RARCH_API_CALLTYPE *plugin_init)(void) =
(const rarch_dsp_plugin_t *(RARCH_API_CALLTYPE*)(void))dylib_proc(g_extern.audio_data.dsp_lib, "rarch_dsp_plugin_init");
if (!plugin_init)
{
RARCH_ERR("Failed to find symbol \"rarch_dsp_plugin_init\" in DSP plugin.\n");
goto error;
}
g_extern.audio_data.dsp_plugin = plugin_init();
if (!g_extern.audio_data.dsp_plugin)
{
RARCH_ERR("Failed to get a valid DSP plugin.\n");
goto error;
}
if (g_extern.audio_data.dsp_plugin->api_version != RARCH_DSP_API_VERSION)
{
RARCH_ERR("DSP plugin API mismatch. RetroArch: %d, Plugin: %d\n", RARCH_DSP_API_VERSION, g_extern.audio_data.dsp_plugin->api_version);
goto error;
}
RARCH_LOG("Loaded DSP plugin: \"%s\"\n", g_extern.audio_data.dsp_plugin->ident ? g_extern.audio_data.dsp_plugin->ident : "Unknown");
info.input_rate = g_settings.audio.in_rate;
g_extern.audio_data.dsp_handle = g_extern.audio_data.dsp_plugin->init(&info);
if (!g_extern.audio_data.dsp_handle)
{
RARCH_ERR("Failed to init DSP plugin.\n");
goto error;
}
return;
error:
if (g_extern.audio_data.dsp_lib)
dylib_close(g_extern.audio_data.dsp_lib);
g_extern.audio_data.dsp_plugin = NULL;
g_extern.audio_data.dsp_lib = NULL;
}
NTSTATUS pdb_init_plugin(PDB_CONTEXT *pdb_context, PDB_METHODS **pdb_method, const char *location)
{
void * dl_handle;
char *plugin_location, *plugin_name, *p;
pdb_init_function plugin_init;
int (*plugin_version)(void);
if (location == NULL) {
DEBUG(0, ("The plugin module needs an argument!\n"));
return NT_STATUS_UNSUCCESSFUL;
}
plugin_name = smb_xstrdup(location);
p = strchr(plugin_name, ':');
if (p) {
*p = 0;
plugin_location = p+1;
trim_char(plugin_location, ' ', ' ');
} else {
plugin_location = NULL;
}
trim_char(plugin_name, ' ', ' ');
DEBUG(5, ("Trying to load sam plugin %s\n", plugin_name));
dl_handle = sys_dlopen(plugin_name, RTLD_NOW );
if (!dl_handle) {
DEBUG(0, ("Failed to load sam plugin %s using sys_dlopen (%s)\n", plugin_name, sys_dlerror()));
return NT_STATUS_UNSUCCESSFUL;
}
plugin_version = sys_dlsym(dl_handle, "pdb_version");
if (!plugin_version) {
sys_dlclose(dl_handle);
DEBUG(0, ("Failed to find function 'pdb_version' using sys_dlsym in sam plugin %s (%s)\n", plugin_name, sys_dlerror()));
return NT_STATUS_UNSUCCESSFUL;
}
if (plugin_version() != PASSDB_INTERFACE_VERSION) {
sys_dlclose(dl_handle);
DEBUG(0, ("Wrong PASSDB_INTERFACE_VERSION! sam plugin has version %d and version %d is needed! Please update!\n",
plugin_version(),PASSDB_INTERFACE_VERSION));
return NT_STATUS_UNSUCCESSFUL;
}
plugin_init = sys_dlsym(dl_handle, "pdb_init");
if (!plugin_init) {
sys_dlclose(dl_handle);
DEBUG(0, ("Failed to find function 'pdb_init' using sys_dlsym in sam plugin %s (%s)\n", plugin_name, sys_dlerror()));
return NT_STATUS_UNSUCCESSFUL;
}
DEBUG(5, ("Starting sam plugin %s with location %s\n", plugin_name, plugin_location));
return plugin_init(pdb_context, pdb_method, plugin_location);
}
chassis_plugin *chassis_plugin_load(const gchar *name) {
int (*plugin_init)(chassis_plugin *p);
chassis_plugin *p = chassis_plugin_new();
p->module = g_module_open(name, G_MODULE_BIND_LOCAL);
if (!p->module) {
g_critical("loading module '%s' failed: %s", name, g_module_error());
chassis_plugin_free(p);
return NULL;
}
/* each module has to have a plugin_init function */
if (!g_module_symbol(p->module, "plugin_init", (gpointer) &plugin_init)) {
g_critical("module '%s' doesn't have a init-function: %s", name, g_module_error());
chassis_plugin_free(p);
return NULL;
}
if (0 != plugin_init(p)) {
g_critical("init-function for module '%s' failed", name);
chassis_plugin_free(p);
return NULL;
}
if (p->magic != CHASSIS_PLUGIN_MAGIC) {
g_critical("plugin '%s' doesn't match the current plugin interface (plugin is %lx, chassis is %lx)", name, p->magic, CHASSIS_PLUGIN_MAGIC);
chassis_plugin_free(p);
return NULL;
}
if (p->init) {
p->config = p->init();
}
/* if the plugins haven't set p->name provide our own name */
if (!p->name) p->name = g_strdup(name);
/* set dummy version number if the plugin doesn't provide a real one */
if (!p->version) {
g_critical("plugin '%s' doesn't set a version number, refusing to load this plugin", name);
chassis_plugin_free(p);
return NULL;
}
if (p->new_stats) {
p->stats = p->new_stats();
}
return p;
}
int plugin(struct soap *soap, struct soap_plugin *p, void *arg)
{ p->id = plugin_id;
p->data = (void*)malloc(sizeof(struct plugin_data));
/* optional: define fcopy() operation. When defined, fdelete() will be called for every copy of the plugin created with fcopy(), when NOT defined, fdelete() will only be called on the original non-copied plugin */
p->fcopy = NULL;
p->fdelete = plugin_delete;
if (p->data)
if (plugin_init(soap, (struct plugin_data*)p->data))
{ free(p->data); /* error: could not init */
return SOAP_EOM; /* return error */
}
return SOAP_OK;
}
int main(int argc, char **argv){
create_user_file();
signal(SIGINT, quit);
i18n_init();
plugin_init();
#ifndef UI_TEST
srv_init();
#endif
#ifndef IRC_TEST
ui_init(argc, argv);
#endif
quit();
return 0;
}
i32 mqtt_server_init(const struct mqtt_server_lib_cfg *lib_cfg,
const struct mqtt_server_app_cfg *app_cfg)
{
/* If mutex is specified, then the following set of callbacks
are invoked in the locked state - enumerated by 'locked' */
struct mqtt_server_msg_cbs pkts_cbs = {proc_connect_rx_locked,
proc_sub_msg_rx_locked,
proc_un_sub_msg_locked,
proc_pub_msg_rx_locked,
proc_notify_ack_locked,
on_cl_net_close_locked,
on_connack_send_locked
};
struct plugin_core_msg_cbs core_cbs = {proc_topic_enroll_locked,
proc_topic_cancel_locked,
proc_app_pub_send_locked
};
util_params_set(lib_cfg->debug_printf,
lib_cfg->mutex,
lib_cfg->mutex_lockin,
lib_cfg->mutex_unlock);
USR_INFO("Version: Server LIB %s, Common LIB %s.\n\r",
MQTT_SERVER_VERSTR, MQTT_COMMON_VERSTR);
topic_node_init();
cl_mgmt_init();
plugin_init(&core_cbs);
mqtt_server_lib_init(lib_cfg, &pkts_cbs);
return 0;
}
/*
* callback function for a plugin
*/
static void gtkui_select_plugin(void)
{
GtkTreeIter iter;
GtkTreeModel *model;
char *plugin = NULL;
model = GTK_TREE_MODEL (ls_plugins);
if (gtk_tree_selection_get_selected (GTK_TREE_SELECTION (selection), &model, &iter)) {
gtk_tree_model_get (model, &iter, 1, &plugin, -1);
} else
return; /* nothing is selected */
if(!plugin)
return; /* bad pointer from gtk_tree_model_get, shouldn't happen */
/* print the message */
if (plugin_is_activated(plugin) == 0)
INSTANT_USER_MSG("Activating %s plugin...\n", plugin);
else
INSTANT_USER_MSG("Deactivating %s plugin...\n", plugin);
/*
* pay attention on this !
* if the plugin init does not return,
* we are blocked here. So it is encouraged
* to write plugins which spawn a thread
* and immediately return
*/
if (plugin_is_activated(plugin) == 1)
plugin_fini(plugin);
else
plugin_init(plugin);
/* refresh the list to mark plugin active */
gtkui_create_plug_array();
}
int plugins_load(server *srv) {
plugin *p;
size_t i, j;
for (i = 0; i < srv->srvconf.modules->used; i++) {
data_string *d = (data_string *)srv->srvconf.modules->data[i];
char *module = d->value->ptr;
for (j = 0; j < i; j++) {
if (buffer_is_equal(d->value, ((data_string *) srv->srvconf.modules->data[j])->value)) {
log_error_write(srv, __FILE__, __LINE__, "sbs",
"Cannot load plugin", d->value,
"more than once, please fix your config (lighttpd may not accept such configs in future releases)");
continue;
}
}
for (j = 0; load_functions[j].name; ++j) {
if (0 == strcmp(load_functions[j].name, module)) {
p = plugin_init();
if ((*load_functions[j].plugin_init)(p)) {
log_error_write(srv, __FILE__, __LINE__, "ss", module, "plugin init failed" );
plugin_free(p);
return -1;
}
plugins_register(srv, p);
break;
}
}
if (!load_functions[j].name) {
log_error_write(srv, __FILE__, __LINE__, "ss", module, " plugin not found" );
return -1;
}
}
return 0;
}
int plugins_load(server *srv) {
plugin *p;
int (*init)(plugin *pl);
const char *error;
size_t i, j;
for (i = 0; i < srv->srvconf.modules->used; i++) {
data_string *d = (data_string *)srv->srvconf.modules->data[i];
char *modules = d->value->ptr;
for (j = 0; j < i; j++) {
if (buffer_is_equal(d->value, ((data_string *) srv->srvconf.modules->data[j])->value)) {
log_error_write(srv, __FILE__, __LINE__, "sbs", "Cannot load plugin", d->value, "more than once, please fix your config (we may not accept such configs in future releases");
continue;
}
}
buffer_copy_string_buffer(srv->tmp_buf, srv->srvconf.modules_dir);
buffer_append_string_len(srv->tmp_buf, CONST_STR_LEN("/"));
buffer_append_string(srv->tmp_buf, modules);
#if defined(__WIN32) || defined(__CYGWIN__)
buffer_append_string_len(srv->tmp_buf, CONST_STR_LEN(".dll"));
#else
buffer_append_string_len(srv->tmp_buf, CONST_STR_LEN(".so"));
#endif
p = plugin_init();
#ifdef __WIN32
if (NULL == (p->lib = LoadLibrary(srv->tmp_buf->ptr))) {
LPVOID lpMsgBuf;
FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM,
NULL,
GetLastError(),
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPTSTR) &lpMsgBuf,
0, NULL );
log_error_write(srv, __FILE__, __LINE__, "ssb", "LoadLibrary() failed",
lpMsgBuf, srv->tmp_buf);
plugin_free(p);
return -1;
}
#else
if (NULL == (p->lib = dlopen(srv->tmp_buf->ptr, RTLD_NOW|RTLD_GLOBAL))) {
log_error_write(srv, __FILE__, __LINE__, "sbs", "dlopen() failed for:",
srv->tmp_buf, dlerror());
plugin_free(p);
return -1;
}
#endif
buffer_reset(srv->tmp_buf);
buffer_copy_string(srv->tmp_buf, modules);
buffer_append_string_len(srv->tmp_buf, CONST_STR_LEN("_plugin_init"));
#ifdef __WIN32
init = GetProcAddress(p->lib, srv->tmp_buf->ptr);
if (init == NULL) {
LPVOID lpMsgBuf;
FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM,
NULL,
GetLastError(),
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPTSTR) &lpMsgBuf,
0, NULL );
log_error_write(srv, __FILE__, __LINE__, "sbs", "getprocaddress failed:", srv->tmp_buf, lpMsgBuf);
plugin_free(p);
return -1;
}
#else
#if 1
init = (int (*)(plugin *))(intptr_t)dlsym(p->lib, srv->tmp_buf->ptr);
#else
*(void **)(&init) = dlsym(p->lib, srv->tmp_buf->ptr);
#endif
if ((error = dlerror()) != NULL) {
log_error_write(srv, __FILE__, __LINE__, "s", error);
plugin_free(p);
return -1;
}
#endif
if ((*init)(p)) {
log_error_write(srv, __FILE__, __LINE__, "ss", modules, "plugin init failed" );
plugin_free(p);
return -1;
}
#if 0
log_error_write(srv, __FILE__, __LINE__, "ss", modules, "plugin loaded" );
#endif
plugins_register(srv, p);
}
return 0;
}
/**
* moo_plugin_register: (moo.lua 0) (moo.private 1)
*
* @id: (type const-utf8)
* @type:
* @info:
* @params: (allow-none) (default NULL)
**/
gboolean
moo_plugin_register (const char *id,
GType type,
const MooPluginInfo *info,
const MooPluginParams *params)
{
MooPluginClass *klass;
MooPlugin *plugin;
char *prefs_key;
MooEditWindowArray *windows;
guint i;
g_return_val_if_fail (id != NULL && id[0] != 0, FALSE);
g_return_val_if_fail (g_utf8_validate (id, -1, NULL), FALSE);
g_return_val_if_fail (g_type_is_a (type, MOO_TYPE_PLUGIN), FALSE);
klass = g_type_class_ref (type);
g_return_val_if_fail (klass != NULL, FALSE);
if (moo_plugin_registered (type))
{
g_warning ("plugin '%s' already registered",
g_type_name (type));
return FALSE;
}
if (!plugin_info_check (info))
{
g_warning ("invalid info in plugin '%s'",
g_type_name (type));
return FALSE;
}
plugin = MOO_PLUGIN (g_object_new (type, (const char*) NULL));
plugin->id = g_strdup (id);
plugin->info = moo_plugin_info_copy ((MooPluginInfo*) info);
plugin->params = params ? moo_plugin_params_copy ((MooPluginParams*) params) :
moo_plugin_params_new (TRUE, TRUE);
if (moo_plugin_lookup (moo_plugin_id (plugin)))
{
_moo_message ("plugin with id %s already registered",
moo_plugin_id (plugin));
g_object_unref (plugin);
return FALSE;
}
plugin->id_quark = make_id_quark (plugin);
prefs_key = make_prefs_key (plugin, PLUGIN_PREFS_ENABLED);
moo_prefs_new_key_bool (prefs_key, moo_plugin_enabled (plugin));
plugin->params->enabled = moo_prefs_get_bool (prefs_key);
g_free (prefs_key);
if (!plugin_init (plugin))
{
g_object_unref (plugin);
return FALSE;
}
plugin_store_add (plugin);
windows = moo_editor_get_windows (plugin_store->editor);
for (i = 0; i < windows->n_elms; ++i)
plugin_attach_win (plugin, windows->elms[i]);
moo_edit_window_array_free (windows);
return TRUE;
}
void plugins_init() {
GString* module_name = NULL;
GModule* module;
gchar* audio_output;
char** search_path;
gsize search_path_size;
char** plugins;
gsize plugins_size;
void (*plugin_init)();
void (*plugin_close)();
int i;
module_name = g_string_sized_new(80);
if (!module_name)
g_error("Can't allocate memory.");
search_path = config_get_string_list("plugins_search_path", &search_path_size);
/* Load audio plugin */
audio_output = config_get_string("audio_output");
g_string_printf(module_name, "libspop_audio_%s", audio_output);
module = plugin_open(module_name->str, search_path, search_path_size);
if (!module)
g_error("Can't load %s audio plugin: %s", audio_output, g_module_error());
if (!g_module_symbol(module, "audio_delivery", (void**) &g_audio_delivery_func))
g_error("Can't find symbol in audio plugin: %s", g_module_error());
/* Now load other plugins */
plugins = config_get_string_list("plugins", &plugins_size);
for (i=0; i < plugins_size; i++) {
g_strstrip(plugins[i]);
g_info("Loading plugin %s...", plugins[i]);
/* Load the module and the symbols (spop_<module>_init and spop_<module>_close) */
g_string_printf(module_name, "libspop_plugin_%s", plugins[i]);
module = plugin_open(module_name->str, search_path, search_path_size);
if (!module) {
g_warning("Can't load plugin \"%s\": %s", plugins[i], g_module_error());
continue;
}
g_string_printf(module_name, "spop_%s_init", plugins[i]);
if (!g_module_symbol(module, module_name->str, (void**) &plugin_init)) {
g_warning("Can't find symbol \"%s\" in module \"%s\": %s", module_name->str, plugins[i], g_module_error());
continue;
}
g_string_printf(module_name, "spop_%s_close", plugins[i]);
if (g_module_symbol(module, module_name->str, (void**) &plugin_close))
g_plugins_close_functions = g_list_prepend(g_plugins_close_functions, plugin_close);
else
g_info("Module \"%s\" does not have a \"%s\" symbol: %s", plugins[i], module_name->str, g_module_error());
/* Really init the plugin (hoping it will not blow up) */
plugin_init();
g_debug("Plugin %s loaded and initialized", plugins[i]);
}
g_string_free(module_name, TRUE);
g_strfreev(plugins);
g_strfreev(search_path);
}
int main(int argc, char *argv[])
{
GOptionContext *context;
GError *err = NULL;
guint signal;
#ifdef NEED_THREADS
if (g_thread_supported() == FALSE)
g_thread_init(NULL);
#endif
context = g_option_context_new(NULL);
g_option_context_add_main_entries(context, options, NULL);
if (g_option_context_parse(context, &argc, &argv, &err) == FALSE) {
if (err != NULL) {
g_printerr("%s\n", err->message);
g_error_free(err);
} else
g_printerr("An unknown error occurred\n");
exit(EXIT_FAILURE);
}
g_option_context_free(context);
if (option_detach == TRUE) {
if (daemon(0, 0)) {
perror("Can't start daemon");
exit(1);
}
}
__obex_log_init("obexd", option_debug, option_detach);
DBG("Entering main loop");
main_loop = g_main_loop_new(NULL, FALSE);
signal = setup_signalfd();
#ifdef NEED_THREADS
if (dbus_threads_init_default() == FALSE) {
fprintf(stderr, "Can't init usage of threads\n");
exit(EXIT_FAILURE);
}
#endif
if (manager_init() == FALSE) {
error("manager_init failed");
exit(EXIT_FAILURE);
}
if (option_root == NULL)
option_root = g_strdup(DEFAULT_ROOT_PATH);
if (option_root[0] != '/') {
char *old_root = option_root, *home = getenv("HOME");
if (home) {
option_root = g_strdup_printf("%s/%s", home, old_root);
g_free(old_root);
}
}
if (option_capability == NULL)
option_capability = g_strdup(DEFAULT_CAP_FILE);
plugin_init(option_plugin, option_noplugin);
if (obex_server_init() < 0) {
error("obex_server_init failed");
exit(EXIT_FAILURE);
}
if (!root_folder_setup(option_root, option_root_setup)) {
error("Unable to setup root folder %s", option_root);
exit(EXIT_FAILURE);
}
g_main_loop_run(main_loop);
g_source_remove(signal);
obex_server_exit();
plugin_cleanup();
manager_cleanup();
g_main_loop_unref(main_loop);
g_free(option_capability);
g_free(option_root);
__obex_log_cleanup();
return 0;
}
/**
* Load a plugin file.
*
* @param file [in] plugin file path
*
* @return TRUE on success, FALSE on failure.
*/
boolean
plugin_load_file(char *file)
{
PLUGIN_MODULE handle;
FUNC_INT func;
FUNC_VOID entfunc;
int ret, number, num;
char buf[256];
int buflen = 256;
PLUGIN_ENTRY *p;
int i;
if (global_plugin_list == NULL) plugin_init();
/* open file */
handle = dlopen(file, RTLD_LAZY);
if (!handle) {
jlog("ERROR: plugin_load: failed to open: %s\n", dlerror());
return(FALSE);
}
/* call initialization function */
func = dlsym(handle, "initialize");
if (func) {
ret = (*func)();
if (ret == -1) {
jlog("WARNING: plugin_load: %s: initialize() returns no, skip this file\n", file);
dlclose(handle);
return(FALSE);
}
}
/* call information function */
func = dlsym(handle, "get_plugin_info");
if (func == NULL) {
jlog("ERROR: plugin_load: %s: get_plugin_info(): %s\n", file, dlerror());
dlclose(handle);
return(FALSE);
}
number = 0;
ret = (*func)(number, buf, buflen);
if (ret == -1) {
jlog("ERROR: plugin_load: %s: get_plugin_info(0) returns error\n", file);
dlclose(handle);
return(FALSE);
}
buf[buflen-1] = '\0';
jlog("#%d [%s]\n", global_plugin_loaded_file_num, buf);
/* register plugin functions */
num = plugin_namelist_num();
for(i=0;i<num;i++) {
entfunc = dlsym(handle, plugin_function_namelist[i]);
if (entfunc) {
if (debug2_flag) {
jlog(" (%s)\n", plugin_function_namelist[i]);
}
p = (PLUGIN_ENTRY *)mymalloc(sizeof(PLUGIN_ENTRY));
p->id = i;
p->source_id = global_plugin_loaded_file_num;
p->func = entfunc;
p->next = global_plugin_list[i];
global_plugin_list[i] = p;
}
}
/* increment file counter */
global_plugin_loaded_file_num++;
return(TRUE);
}
int main(int argc, char* argv[])
{
char *path;
char cmd[256];
int udev = 0;
uev_t timer; /* Bootstrap timer, on timeout call finalize() */
uev_ctx_t loop;
/*
* finit/init/telinit client tool uses /dev/initctl pipe
* for compatibility but initctl client tool uses socket
*/
if (getpid() != 1)
return client(argc, argv);
/*
* Initalize event context.
*/
uev_init(&loop);
ctx = &loop;
/*
* Set PATH and SHELL early to something sane
*/
setenv("PATH", _PATH_STDPATH, 1);
setenv("SHELL", _PATH_BSHELL, 1);
/*
* Mount base file system, kernel is assumed to run devtmpfs for /dev
*/
chdir("/");
umask(0);
mount("none", "/proc", "proc", 0, NULL);
mount("none", "/sys", "sysfs", 0, NULL);
if (fisdir("/proc/bus/usb"))
mount("none", "/proc/bus/usb", "usbfs", 0, NULL);
/*
* Parse kernel command line (debug, rescue, splash, etc.)
* Also calls log_init() to set correct log level
*/
conf_parse_cmdline();
/* Set up canvas */
if (!rescue && !log_is_debug())
screen_init();
/*
* In case of emergency.
*/
emergency_shell();
/*
* Initial setup of signals, ignore all until we're up.
*/
sig_init();
/*
* Load plugins early, finit.conf may contain references to
* features implemented by plugins.
*/
plugin_init(&loop);
/*
* Hello world.
*/
banner();
/*
* Check file filesystems in /etc/fstab
*/
for (int pass = 1; pass < 10 && !rescue; pass++) {
if (fsck(pass))
break;
}
/*
* Initialize .conf system and load static /etc/finit.conf
* Also initializes global_rlimit[] for udevd, below.
*/
conf_init();
/*
* Some non-embedded systems without an initramfs may not have /dev mounted yet
* If they do, check if system has udevadm and perform cleanup from initramfs
*/
if (!fismnt("/dev"))
mount("udev", "/dev", "devtmpfs", MS_RELATIME, "size=10%,nr_inodes=61156,mode=755");
else if (whichp("udevadm"))
run_interactive("udevadm info --cleanup-db", "Cleaning up udev db");
/* Some systems use /dev/pts */
makedir("/dev/pts", 0755);
mount("devpts", "/dev/pts", "devpts", 0, "gid=5,mode=620");
/*
* Some systems rely on us to both create /dev/shm and, to mount
* a tmpfs there. Any system with dbus needs shared memory, so
* mount it, unless its already mounted, but not if listed in
* the /etc/fstab file already.
*/
makedir("/dev/shm", 0755);
if (!fismnt("/dev/shm") && !ismnt("/etc/fstab", "/dev/shm"))
mount("shm", "/dev/shm", "tmpfs", 0, NULL);
/*
* New tmpfs based /run for volatile runtime data
* For details, see http://lwn.net/Articles/436012/
*/
if (fisdir("/run") && !fismnt("/run"))
mount("tmpfs", "/run", "tmpfs", MS_NODEV, "mode=0755,size=10%");
umask(022);
/* Bootstrap conditions, needed for hooks */
cond_init();
/*
* Populate /dev and prepare for runtime events from kernel.
* Prefer udev if mdev is also available on the system.
*/
path = which("udevd");
if (!path)
path = which("/lib/systemd/systemd-udevd");
if (path) {
/* Desktop and server distros usually have a variant of udev */
udev = 1;
/* Register udevd as a monitored service */
snprintf(cmd, sizeof(cmd), "[S12345789] pid:udevd %s -- Device event managing daemon", path);
if (service_register(SVC_TYPE_SERVICE, cmd, global_rlimit, NULL)) {
_pe("Failed registering %s", path);
udev = 0;
} else {
snprintf(cmd, sizeof(cmd), ":1 [S] <svc%s> "
"udevadm trigger -c add -t devices "
"-- Requesting device events", path);
service_register(SVC_TYPE_RUN, cmd, global_rlimit, NULL);
snprintf(cmd, sizeof(cmd), ":2 [S] <svc%s> "
"udevadm trigger -c add -t subsystems "
"-- Requesting subsystem events", path);
service_register(SVC_TYPE_RUN, cmd, global_rlimit, NULL);
}
free(path);
} else {
path = which("mdev");
if (path) {
/* Embedded Linux systems usually have BusyBox mdev */
if (log_is_debug())
touch("/dev/mdev.log");
snprintf(cmd, sizeof(cmd), "%s -s", path);
free(path);
run_interactive(cmd, "Populating device tree");
}
}
/*
* Start built-in watchdog as soon as possible, if enabled
*/
wdogpid = watchdog(argv[0]);
/*
* Mount filesystems
*/
if (!rescue) {
#ifdef REMOUNT_ROOTFS
run("mount -n -o remount,rw /");
#endif
#ifdef SYSROOT
mount(SYSROOT, "/", NULL, MS_MOVE, NULL);
#endif
}
if (!rescue) {
_d("Root FS up, calling hooks ...");
plugin_run_hooks(HOOK_ROOTFS_UP);
umask(0);
if (run_interactive("mount -na", "Mounting filesystems"))
plugin_run_hooks(HOOK_MOUNT_ERROR);
_d("Calling extra mount hook, after mount -a ...");
plugin_run_hooks(HOOK_MOUNT_POST);
run("swapon -ea");
umask(0022);
}
/* Base FS up, enable standard SysV init signals */
sig_setup(&loop);
if (!rescue) {
_d("Base FS up, calling hooks ...");
plugin_run_hooks(HOOK_BASEFS_UP);
}
/*
* Set up inotify watcher for /etc/finit.d and read all .conf
* files to figure out how to bootstrap the system.
*/
conf_monitor(&loop);
/*
* Initalize state machine and start all bootstrap tasks
* NOTE: no network available!
*/
sm_init(&sm);
sm_step(&sm);
/* Debian has this little script to copy generated rules while the system was read-only */
if (udev && fexist("/lib/udev/udev-finish"))
run_interactive("/lib/udev/udev-finish", "Finalizing udev");
/* Start new initctl API responder */
api_init(&loop);
umask(022);
/*
* Wait for all SVC_TYPE_RUNTASK to have completed their work in
* [S], or timeout, before calling finalize()
*/
_d("Starting bootstrap finalize timer ...");
uev_timer_init(&loop, &timer, service_bootstrap_cb, finalize, 1000, 1000);
/*
* Enter main loop to monior /dev/initctl and services
*/
_d("Entering main loop ...");
return uev_run(&loop, 0);
}
void
engine_init (Ekiga::ServiceCorePtr service_core,
int argc,
char *argv [])
{
// FIRST we add a few things by hand
// (for speed and because that's less code)
Ekiga::ServicePtr notification_core(new Ekiga::NotificationCore);
service_core->add (notification_core);
boost::shared_ptr<Ekiga::AccountCore> account_core (new Ekiga::AccountCore);
boost::shared_ptr<Ekiga::ContactCore> contact_core (new Ekiga::ContactCore);
boost::shared_ptr<Ekiga::CallCore> call_core (new Ekiga::CallCore);
boost::shared_ptr<Ekiga::ChatCore> chat_core (new Ekiga::ChatCore);
boost::shared_ptr<Ekiga::VideoOutputCore> videooutput_core (new Ekiga::VideoOutputCore);
boost::shared_ptr<Ekiga::VideoInputCore> videoinput_core (new Ekiga::VideoInputCore (*service_core, videooutput_core));
boost::shared_ptr<Ekiga::AudioOutputCore> audiooutput_core (new Ekiga::AudioOutputCore (*service_core));
boost::shared_ptr<Ekiga::AudioInputCore> audioinput_core (new Ekiga::AudioInputCore(*service_core));
boost::shared_ptr<Ekiga::HalCore> hal_core (new Ekiga::HalCore);
boost::shared_ptr<Ekiga::FriendOrFoe> friend_or_foe (new Ekiga::FriendOrFoe);
boost::shared_ptr<Gmconf::PersonalDetails> details(new Gmconf::PersonalDetails);
boost::shared_ptr<Ekiga::PresenceCore> presence_core(new Ekiga::PresenceCore (details));
service_core->add (contact_core);
service_core->add (chat_core);
service_core->add (friend_or_foe);
service_core->add (videoinput_core);
service_core->add (videooutput_core);
service_core->add (audioinput_core);
service_core->add (audiooutput_core);
service_core->add (hal_core);
service_core->add (call_core);
service_core->add (account_core);
service_core->add (details);
service_core->add (presence_core);
if (!videoinput_mlogo_init (*service_core, &argc, &argv)) {
return;
}
if (!videooutput_clutter_gst_init (*service_core, &argc, &argv)) {
return;
}
// THEN we use the kickstart scheme
Ekiga::KickStart kickstart;
audioinput_null_init (kickstart);
audiooutput_null_init (kickstart);
videoinput_ptlib_init (kickstart);
audioinput_ptlib_init (kickstart);
audiooutput_ptlib_init (kickstart);
#ifdef HAVE_GUDEV
hal_gudev_init (kickstart);
#endif
#ifdef HAVE_DBUS
hal_dbus_init (kickstart);
#endif
opal_init (kickstart);
history_init (kickstart);
local_roster_init (kickstart);
local_roster_bridge_init (kickstart);
plugin_init (kickstart);
// FIXME: Some parts in the kickstart need the gui. The gui needs
// some parts in the kickstart. So we will kick a first time to
// get things not needing the gui up and running, then start the
// gui (which will hence find what it needs) and kick a second time
// to really make the engine go vroom. It would be nicer to either
// push the parts needed by the gui in the hand-crafted part of
// this initialization, or put the gui in the kickstart too.
kickstart.kick (*service_core, &argc, &argv);
// FIXME: can't we have a single function for the whole gui?
gtk_core_init (*service_core, &argc, &argv);
if (!gtk_frontend_init (*service_core, &argc, &argv)) {
return;
}
kickstart.kick (*service_core, &argc, &argv);
/* FIXME: everything that follows except the debug output shouldn't
be there, as that means we're doing the work of initializing
those in the correct order here instead of having the specific
code in question to do it itself
*/
videoinput_core->setup ("any");
audioinput_core->setup ();
audiooutput_core->setup ();
hal_core->videoinput_device_added.connect (boost::bind (&Ekiga::VideoInputCore::add_device, boost::ref (*videoinput_core), _1, _2, _3, _4));
hal_core->videoinput_device_removed.connect (boost::bind (&Ekiga::VideoInputCore::remove_device, boost::ref (*videoinput_core), _1, _2, _3, _4));
hal_core->audiooutput_device_added.connect (boost::bind (&Ekiga::AudioOutputCore::add_device, boost::ref (*audiooutput_core), _1, _2, _3));
hal_core->audiooutput_device_removed.connect (boost::bind (&Ekiga::AudioOutputCore::remove_device, boost::ref (*audiooutput_core), _1, _2, _3));
hal_core->audioinput_device_added.connect (boost::bind (&Ekiga::AudioInputCore::add_device, boost::ref (*audioinput_core), _1, _2, _3));
hal_core->audioinput_device_removed.connect (boost::bind (&Ekiga::AudioInputCore::remove_device, boost::ref (*audioinput_core), _1, _2, _3));
#if DEBUG_STARTUP
std::cout << "Here is what ekiga is made of for this run :" << std::endl;
service_core->dump (std::cout);
#endif
}
static int filter_pre_init( av_qsv_context* qsv, hb_filter_private_t * pv ){
mfxStatus sts = MFX_ERR_NONE;
int i=0;
if(!qsv) return 3;
av_qsv_space *prev_vpp = 0;
if(!qsv->vpp_space){
qsv->vpp_space = av_qsv_list_init(HAVE_THREADS);
// note some change as : when no size changes -> no VPP used
// impact on : prev_vpp
}
if(!pv->vpp_space){
for(i=0; i<av_qsv_list_count(qsv->vpp_space);i++){
av_qsv_space *qsv_vpp = av_qsv_list_item( qsv->vpp_space, i );
if(qsv_vpp->type == AV_QSV_VPP_USER){
pv->vpp_space = qsv_vpp;
break;
}
else
if(qsv_vpp->type == AV_QSV_VPP_DEFAULT){
prev_vpp = qsv_vpp;
}
}
}
if(!pv->vpp_space){
pv->vpp_space = calloc( 1, sizeof( av_qsv_space ));
pv->vpp_space->type = AV_QSV_VPP_USER;
av_qsv_list_add( qsv->vpp_space, pv->vpp_space );
av_qsv_add_context_usage(qsv,HAVE_THREADS);
}
else
if(pv->vpp_space->is_init_done ) return 1;
if(!qsv->dec_space || !qsv->dec_space->is_init_done) return 2;
av_qsv_space *qsv_vpp = pv->vpp_space;
AV_QSV_ZERO_MEMORY(qsv_vpp->m_mfxVideoParam);
if (prev_vpp)
{
memcpy( &qsv_vpp->m_mfxVideoParam.vpp, &prev_vpp->m_mfxVideoParam.vpp, sizeof(prev_vpp->m_mfxVideoParam.vpp));
}
else
{
AV_QSV_ZERO_MEMORY(qsv_vpp->m_mfxVideoParam);
// FrameRate is important for VPP to start with
if( qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.FrameRateExtN == 0 &&
qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.FrameRateExtD == 0 ){
qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.FrameRateExtN = pv->job->title->rate;
qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.FrameRateExtD = pv->job->title->rate_base;
}
qsv_vpp->m_mfxVideoParam.vpp.In.FourCC = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.FourCC;
qsv_vpp->m_mfxVideoParam.vpp.In.ChromaFormat = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.ChromaFormat;
qsv_vpp->m_mfxVideoParam.vpp.In.CropX = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.CropX;
qsv_vpp->m_mfxVideoParam.vpp.In.CropY = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.CropY;
qsv_vpp->m_mfxVideoParam.vpp.In.CropW = pv->job->title->width;
qsv_vpp->m_mfxVideoParam.vpp.In.CropH = pv->job->title->height;
qsv_vpp->m_mfxVideoParam.vpp.In.PicStruct = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.PicStruct;
qsv_vpp->m_mfxVideoParam.vpp.In.FrameRateExtN = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.FrameRateExtN;
qsv_vpp->m_mfxVideoParam.vpp.In.FrameRateExtD = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.FrameRateExtD;
qsv_vpp->m_mfxVideoParam.vpp.In.AspectRatioW = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.AspectRatioW;
qsv_vpp->m_mfxVideoParam.vpp.In.AspectRatioH = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.AspectRatioH;
qsv_vpp->m_mfxVideoParam.vpp.In.Width = AV_QSV_ALIGN16(pv->job->title->width);
qsv_vpp->m_mfxVideoParam.vpp.In.Height = (MFX_PICSTRUCT_PROGRESSIVE == qsv_vpp->m_mfxVideoParam.vpp.In.PicStruct)?
AV_QSV_ALIGN16(pv->job->title->height) : AV_QSV_ALIGN32(pv->job->title->height);
qsv_vpp->m_mfxVideoParam.vpp.Out.FourCC = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.FourCC;
qsv_vpp->m_mfxVideoParam.vpp.Out.ChromaFormat = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.ChromaFormat;
qsv_vpp->m_mfxVideoParam.vpp.Out.CropX = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.CropX;
qsv_vpp->m_mfxVideoParam.vpp.Out.CropY = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.CropY;
qsv_vpp->m_mfxVideoParam.vpp.Out.CropW = pv->job->title->width;
qsv_vpp->m_mfxVideoParam.vpp.Out.CropH = pv->job->title->height;
qsv_vpp->m_mfxVideoParam.vpp.Out.PicStruct = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.PicStruct;
qsv_vpp->m_mfxVideoParam.vpp.Out.FrameRateExtN = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.FrameRateExtN;
qsv_vpp->m_mfxVideoParam.vpp.Out.FrameRateExtD = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.FrameRateExtD;
qsv_vpp->m_mfxVideoParam.vpp.Out.AspectRatioW = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.AspectRatioW;
qsv_vpp->m_mfxVideoParam.vpp.Out.AspectRatioH = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.AspectRatioH;
qsv_vpp->m_mfxVideoParam.vpp.Out.Width = AV_QSV_ALIGN16(pv->job->title->width);
qsv_vpp->m_mfxVideoParam.vpp.Out.Height = (MFX_PICSTRUCT_PROGRESSIVE == qsv_vpp->m_mfxVideoParam.vpp.In.PicStruct)?
AV_QSV_ALIGN16(pv->job->title->height) : AV_QSV_ALIGN32(pv->job->title->height);
memset(&qsv_vpp->request, 0, sizeof(mfxFrameAllocRequest)*2);
}
qsv_vpp->m_mfxVideoParam.IOPattern = MFX_IOPATTERN_IN_OPAQUE_MEMORY | MFX_IOPATTERN_OUT_OPAQUE_MEMORY;
qsv_vpp->surface_num = FFMIN(prev_vpp ? prev_vpp->surface_num : qsv->dec_space->surface_num/2, AV_QSV_SURFACE_NUM);
for(i = 0; i < qsv_vpp->surface_num; i++){
qsv_vpp->p_surfaces[i] = av_mallocz( sizeof(mfxFrameSurface1) );
AV_QSV_CHECK_POINTER(qsv_vpp->p_surfaces[i], MFX_ERR_MEMORY_ALLOC);
memcpy(&(qsv_vpp->p_surfaces[i]->Info), &(qsv_vpp->m_mfxVideoParam.vpp.Out), sizeof(mfxFrameInfo));
}
qsv_vpp->sync_num = FFMIN(prev_vpp ? prev_vpp->sync_num : qsv->dec_space->sync_num, AV_QSV_SYNC_NUM);
for (i = 0; i < qsv_vpp->sync_num; i++){
qsv_vpp->p_syncp[i] = av_mallocz(sizeof(av_qsv_sync));
AV_QSV_CHECK_POINTER(qsv_vpp->p_syncp[i], MFX_ERR_MEMORY_ALLOC);
qsv_vpp->p_syncp[i]->p_sync = av_mallocz(sizeof(mfxSyncPoint));
AV_QSV_CHECK_POINTER(qsv_vpp->p_syncp[i]->p_sync, MFX_ERR_MEMORY_ALLOC);
}
memset(&qsv_vpp->ext_opaque_alloc, 0, sizeof(mfxExtOpaqueSurfaceAlloc));
qsv_vpp->m_mfxVideoParam.NumExtParam = qsv_vpp->p_ext_param_num = 1;
qsv_vpp->p_ext_params = av_mallocz(sizeof(mfxExtBuffer *)*qsv_vpp->p_ext_param_num);
AV_QSV_CHECK_POINTER(qsv_vpp->p_ext_params, MFX_ERR_MEMORY_ALLOC);
qsv_vpp->m_mfxVideoParam.ExtParam = qsv_vpp->p_ext_params;
qsv_vpp->ext_opaque_alloc.Header.BufferId = MFX_EXTBUFF_OPAQUE_SURFACE_ALLOCATION;
qsv_vpp->ext_opaque_alloc.Header.BufferSz = sizeof(mfxExtOpaqueSurfaceAlloc);
qsv_vpp->p_ext_params[0] = (mfxExtBuffer*)&qsv_vpp->ext_opaque_alloc;
if(prev_vpp){
qsv_vpp->ext_opaque_alloc.In.Surfaces = prev_vpp->p_surfaces;
qsv_vpp->ext_opaque_alloc.In.NumSurface = prev_vpp->surface_num;
}
else{
qsv_vpp->ext_opaque_alloc.In.Surfaces = qsv->dec_space->p_surfaces;
qsv_vpp->ext_opaque_alloc.In.NumSurface = qsv->dec_space->surface_num;
}
qsv_vpp->ext_opaque_alloc.In.Type = qsv->dec_space->request[0].Type;
qsv_vpp->ext_opaque_alloc.Out.Surfaces = qsv_vpp->p_surfaces;
qsv_vpp->ext_opaque_alloc.Out.NumSurface = qsv_vpp->surface_num;
qsv_vpp->ext_opaque_alloc.Out.Type = qsv->dec_space->request[0].Type;
pv->qsv_user = hb_list_init();
qsv_filter_t *plugin = av_mallocz( sizeof(qsv_filter_t) );
plugin->pv = pv;
plugin->plug.pthis = plugin;
plugin->plug.PluginInit = qsv_PluginInit;
plugin->plug.PluginClose = qsv_PluginClose;
plugin->plug.GetPluginParam = qsv_GetPluginParam;
plugin->plug.Submit = qsv_Submit;
plugin->plug.Execute = qsv_Execute;
plugin->plug.FreeResources = qsv_FreeResources;
hb_list_add(pv->qsv_user,plugin);
sts=MFXVideoUSER_Register(qsv->mfx_session,0,&plugin->plug);
AV_QSV_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
plugin_init(plugin,&qsv_vpp->m_mfxVideoParam);
qsv_vpp->is_init_done = 1;
return 0;
}
static int plugins_ralphasort(const void * a, const void * b) {
#else
static int plugins_ralphasort(const struct dirent ** a, const struct dirent ** b) {
#endif
return -alphasort(a, b);
}
int plugins_load(Protocol * proto, TCFBroadcastGroup * bcg) {
struct dirent ** files;
int file_count = -1;
int ret = 0;
file_count = scandir(plugins_path, &files, plugins_filter, plugins_ralphasort);
if (file_count < 0) {
trace(LOG_PLUGIN, "plugins error: failed opening plugins directory \"%s\"", plugins_path);
return -1;
}
while (file_count--) {
char * cur_plugin_path = NULL;
if (asprintf(&cur_plugin_path, "%s/%s", plugins_path, files[file_count]->d_name) == -1) {
trace(LOG_PLUGIN, "plugins error: `asprintf' failed for plugin \"%s\"", files[file_count]->d_name);
ret = -1;
goto delete_cur_entry;
}
if (plugin_init(cur_plugin_path, proto, bcg)) {
trace(LOG_PLUGIN, "plugins error: unable to start plugin \"%s\"", cur_plugin_path);
ret = -1;
/* Continue to load the rest of plugins */
}
/* cur_plugin_path and files were allocated by asprintf() and scandir(),
* and they should be released by free(), don't call loc_free() here. */
free(cur_plugin_path);
delete_cur_entry:
free(files[file_count]);
}
free(files);
return ret;
}
int plugin_init(const char * name, Protocol * proto, TCFBroadcastGroup * bcg) {
void * handle;
char * error;
InitFunc init;
/* Plugin loading: */
trace(LOG_PLUGIN, "loading plugin \"%s\"", name);
handle = dlopen(name, RTLD_LAZY);
if (!handle) {
trace(LOG_PLUGIN, "plugins error: \"%s\"", dlerror());
return -1;
}
/* Plugin initialization: */
init = (InitFunc)dlsym(handle, "tcf_init_plugin");
if ((error = dlerror()) != NULL) {
trace(LOG_PLUGIN, "plugins error: \"%s\"", error);
return -1;
}
trace(LOG_PLUGIN, "initializing plugin \"%s\"", name);
init(proto, bcg, NULL);
/* Handles table update: */
plugins_handles = (void **) loc_realloc(plugins_handles,
++plugins_count * sizeof(void *));
plugins_handles[plugins_count - 1] = handle;
return 0;
}
int
main (int argc, char *argv[])
{
weechat_first_start_time = time (NULL); /* initialize start time */
gettimeofday (&weechat_current_start_timeval, NULL);
setlocale (LC_ALL, ""); /* initialize gettext */
#ifdef ENABLE_NLS
bindtextdomain (PACKAGE, LOCALEDIR);
bind_textdomain_codeset (PACKAGE, "UTF-8");
textdomain (PACKAGE);
#endif
#ifdef HAVE_LANGINFO_CODESET
weechat_local_charset = strdup (nl_langinfo (CODESET));
#else
weechat_local_charset = strdup ("");
#endif
utf8_init ();
util_catch_signal (SIGINT, SIG_IGN); /* ignore SIGINT signal */
util_catch_signal (SIGQUIT, SIG_IGN); /* ignore SIGQUIT signal */
util_catch_signal (SIGPIPE, SIG_IGN); /* ignore SIGPIPE signal */
util_catch_signal (SIGSEGV,
&debug_sigsegv); /* crash dump for SIGSEGV signal */
hdata_init (); /* initialize hdata */
hook_init (); /* initialize hooks */
debug_init (); /* hook signals for debug */
gui_main_pre_init (&argc, &argv); /* pre-initialize interface */
command_init (); /* initialize WeeChat commands */
completion_init (); /* add core completion hooks */
gui_key_init (); /* init keys */
network_init_gcrypt (); /* init gcrypt */
if (!secure_init ()) /* init secured data options (sec.*)*/
weechat_shutdown (EXIT_FAILURE, 0);
if (!config_weechat_init ()) /* init WeeChat options (weechat.*) */
weechat_shutdown (EXIT_FAILURE, 0);
weechat_parse_args (argc, argv); /* parse command line args */
weechat_create_home_dir (); /* create WeeChat home directory */
log_init (); /* init log file */
plugin_api_init (); /* create some hooks (info,hdata,..)*/
secure_read (); /* read secured data options */
config_weechat_read (); /* read WeeChat options */
network_init_gnutls (); /* init GnuTLS */
gui_main_init (); /* init WeeChat interface */
if (weechat_upgrading)
{
upgrade_weechat_load (); /* upgrade with session file */
weechat_upgrade_count++; /* increase /upgrade count */
}
weechat_welcome_message (); /* display WeeChat welcome message */
gui_chat_print_lines_waiting_buffer (NULL); /* display lines waiting */
command_startup (0); /* command executed before plugins */
plugin_init (weechat_auto_load_plugins, /* init plugin interface(s) */
argc, argv);
command_startup (1); /* commands executed after plugins */
if (!weechat_upgrading)
gui_layout_window_apply (gui_layout_current, -1);
if (weechat_upgrading)
upgrade_weechat_end (); /* remove .upgrade files + signal */
gui_main_loop (); /* WeeChat main loop */
gui_layout_store_on_exit (); /* store layout */
plugin_end (); /* end plugin interface(s) */
if (CONFIG_BOOLEAN(config_look_save_config_on_exit))
(void) config_weechat_write (); /* save WeeChat config file */
(void) secure_write (); /* save secured data */
gui_main_end (1); /* shut down WeeChat GUI */
proxy_free_all (); /* free all proxies */
config_weechat_free (); /* free WeeChat options */
secure_free (); /* free secured data options */
config_file_free_all (); /* free all configuration files */
gui_key_end (); /* remove all keys */
unhook_all (); /* remove all hooks */
hdata_end (); /* end hdata */
secure_end (); /* end secured data */
string_end (); /* end string */
weechat_shutdown (EXIT_SUCCESS, 0); /* quit WeeChat (oh no, why?) */
return EXIT_SUCCESS; /* make C compiler happy */
}
void
weechat_init (int argc, char *argv[], void (*gui_init_cb)())
{
weechat_first_start_time = time (NULL); /* initialize start time */
gettimeofday (&weechat_current_start_timeval, NULL);
weechat_locale_ok = (setlocale (LC_ALL, "") != NULL); /* init gettext */
#ifdef ENABLE_NLS
bindtextdomain (PACKAGE, LOCALEDIR);
bind_textdomain_codeset (PACKAGE, "UTF-8");
textdomain (PACKAGE);
#endif
#ifdef HAVE_LANGINFO_CODESET
weechat_local_charset = strdup (nl_langinfo (CODESET));
#else
weechat_local_charset = strdup ("");
#endif
utf8_init ();
/* catch signals */
util_catch_signal (SIGINT, SIG_IGN); /* signal ignored */
util_catch_signal (SIGQUIT, SIG_IGN); /* signal ignored */
util_catch_signal (SIGPIPE, SIG_IGN); /* signal ignored */
util_catch_signal (SIGSEGV, &debug_sigsegv); /* crash dump */
util_catch_signal (SIGHUP, &weechat_sighup); /* exit WeeChat */
util_catch_signal (SIGQUIT, &weechat_sigquit); /* exit WeeChat */
util_catch_signal (SIGTERM, &weechat_sigterm); /* exit WeeChat */
hdata_init (); /* initialize hdata */
hook_init (); /* initialize hooks */
debug_init (); /* hook signals for debug */
gui_color_init (); /* initialize colors */
gui_chat_init (); /* initialize chat */
command_init (); /* initialize WeeChat commands */
completion_init (); /* add core completion hooks */
gui_key_init (); /* init keys */
network_init_gcrypt (); /* init gcrypt */
if (!secure_init ()) /* init secured data options (sec.*)*/
weechat_shutdown (EXIT_FAILURE, 0);
if (!config_weechat_init ()) /* init WeeChat options (weechat.*) */
weechat_shutdown (EXIT_FAILURE, 0);
weechat_parse_args (argc, argv); /* parse command line args */
weechat_create_home_dir (); /* create WeeChat home directory */
log_init (); /* init log file */
plugin_api_init (); /* create some hooks (info,hdata,..)*/
secure_read (); /* read secured data options */
config_weechat_read (); /* read WeeChat options */
network_init_gnutls (); /* init GnuTLS */
if (gui_init_cb)
(*gui_init_cb) (); /* init WeeChat interface */
if (weechat_upgrading)
{
upgrade_weechat_load (); /* upgrade with session file */
weechat_upgrade_count++; /* increase /upgrade count */
}
weechat_welcome_message (); /* display WeeChat welcome message */
gui_chat_print_lines_waiting_buffer (NULL); /* display lines waiting */
weechat_term_check (); /* warnings about $TERM (if wrong) */
weechat_locale_check (); /* warning about wrong locale */
command_startup (0); /* command executed before plugins */
plugin_init (weechat_auto_load_plugins, /* init plugin interface(s) */
argc, argv);
command_startup (1); /* commands executed after plugins */
if (!weechat_upgrading)
gui_layout_window_apply (gui_layout_current, -1);
if (weechat_upgrading)
upgrade_weechat_end (); /* remove .upgrade files + signal */
}