| /* GStreamer |
| * Copyright (C) 2009 Sebastian Dröge <sebastian.droege@collabora.co.uk> |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Library General Public |
| * License as published by the Free Software Foundation; either |
| * version 2 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Library General Public License for more details. |
| * |
| * You should have received a copy of the GNU Library General Public |
| * License along with this library; if not, write to the |
| * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, |
| * Boston, MA 02110-1301, USA. |
| */ |
| |
| #ifdef HAVE_CONFIG_H |
| #include "config.h" |
| #endif |
| |
| #include "gstfrei0r.h" |
| #include "gstfrei0rfilter.h" |
| #include "gstfrei0rsrc.h" |
| #include "gstfrei0rmixer.h" |
| |
| #include <string.h> |
| #include <gmodule.h> |
| |
| GST_DEBUG_CATEGORY (frei0r_debug); |
| #define GST_CAT_DEFAULT frei0r_debug |
| |
| static GstStaticCaps bgra8888_caps = GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE |
| ("BGRA")); |
| static GstStaticCaps rgba8888_caps = GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE |
| ("RGBA")); |
| static GstStaticCaps packed32_caps = GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE |
| ("{ BGRA, RGBA, ABGR, ARGB, BGRx, RGBx, xBGR, xRGB, AYUV }")); |
| |
| GstCaps * |
| gst_frei0r_caps_from_color_model (gint color_model) |
| { |
| switch (color_model) { |
| case F0R_COLOR_MODEL_BGRA8888: |
| return gst_static_caps_get (&bgra8888_caps); |
| case F0R_COLOR_MODEL_RGBA8888: |
| return gst_static_caps_get (&rgba8888_caps); |
| case F0R_COLOR_MODEL_PACKED32: |
| return gst_static_caps_get (&packed32_caps); |
| default: |
| break; |
| } |
| |
| return NULL; |
| } |
| |
| void |
| gst_frei0r_klass_install_properties (GObjectClass * gobject_class, |
| GstFrei0rFuncTable * ftable, GstFrei0rProperty * properties, |
| gint n_properties) |
| { |
| gint i, count = 1; |
| f0r_instance_t *instance = ftable->construct (640, 480); |
| |
| g_assert (instance); |
| |
| for (i = 0; i < n_properties; i++) { |
| f0r_param_info_t *param_info = &properties[i].info; |
| gchar *prop_name; |
| |
| ftable->get_param_info (param_info, i); |
| |
| if (!param_info->name) { |
| GST_ERROR ("Property %d of %s without a valid name", i, |
| g_type_name (G_TYPE_FROM_CLASS (gobject_class))); |
| continue; |
| } |
| |
| prop_name = g_ascii_strdown (param_info->name, -1); |
| g_strcanon (prop_name, G_CSET_A_2_Z G_CSET_a_2_z G_CSET_DIGITS "-+", '-'); |
| /* satisfy glib2 (argname[0] must be [A-Za-z]) */ |
| if (!((prop_name[0] >= 'a' && prop_name[0] <= 'z') || |
| (prop_name[0] >= 'A' && prop_name[0] <= 'Z'))) { |
| gchar *tempstr = prop_name; |
| |
| prop_name = g_strconcat ("param-", prop_name, NULL); |
| g_free (tempstr); |
| } |
| |
| properties[i].prop_id = count; |
| properties[i].prop_idx = i; |
| |
| ftable->get_param_value (instance, &properties[i].default_value, i); |
| if (param_info->type == F0R_PARAM_STRING) |
| properties[i].default_value.data.s = |
| g_strdup (properties[i].default_value.data.s); |
| |
| switch (param_info->type) { |
| case F0R_PARAM_BOOL: |
| g_object_class_install_property (gobject_class, count++, |
| g_param_spec_boolean (prop_name, param_info->name, |
| param_info->explanation, |
| properties[i].default_value.data.b ? TRUE : FALSE, |
| G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE)); |
| properties[i].n_prop_ids = 1; |
| break; |
| case F0R_PARAM_DOUBLE:{ |
| gdouble def = properties[i].default_value.data.d; |
| |
| /* If the default is NAN, +-INF we use 0.0 */ |
| if (!(def >= 0.0 && def <= 1.0)) |
| def = 0.0; |
| |
| g_object_class_install_property (gobject_class, count++, |
| g_param_spec_double (prop_name, param_info->name, |
| param_info->explanation, 0.0, 1.0, def, |
| G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE)); |
| properties[i].n_prop_ids = 1; |
| break; |
| } |
| case F0R_PARAM_STRING: |
| g_object_class_install_property (gobject_class, count++, |
| g_param_spec_string (prop_name, param_info->name, |
| param_info->explanation, properties[i].default_value.data.s, |
| G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE)); |
| properties[i].n_prop_ids = 1; |
| break; |
| case F0R_PARAM_COLOR:{ |
| gchar *prop_name_full; |
| gchar *prop_nick_full; |
| gdouble def; |
| |
| def = properties[i].default_value.data.color.r; |
| /* If the default is out of range we use 0.0 */ |
| if (!(def <= 1.0 && def >= 0.0)) |
| def = 0.0; |
| prop_name_full = g_strconcat (prop_name, "-r", NULL); |
| prop_nick_full = g_strconcat (param_info->name, " (R)", NULL); |
| g_object_class_install_property (gobject_class, count++, |
| g_param_spec_float (prop_name_full, prop_nick_full, |
| param_info->explanation, 0.0, 1.0, def, |
| G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE)); |
| g_free (prop_name_full); |
| g_free (prop_nick_full); |
| |
| def = properties[i].default_value.data.color.g; |
| /* If the default is out of range we use 0.0 */ |
| if (!(def <= 1.0 && def >= 0.0)) |
| def = 0.0; |
| prop_name_full = g_strconcat (prop_name, "-g", NULL); |
| prop_nick_full = g_strconcat (param_info->name, " (G)", NULL); |
| g_object_class_install_property (gobject_class, count++, |
| g_param_spec_float (prop_name_full, prop_nick_full, |
| param_info->explanation, 0.0, 1.0, def, |
| G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE)); |
| g_free (prop_name_full); |
| g_free (prop_nick_full); |
| |
| def = properties[i].default_value.data.color.b; |
| /* If the default is out of range we use 0.0 */ |
| if (!(def <= 1.0 && def >= 0.0)) |
| def = 0.0; |
| prop_name_full = g_strconcat (prop_name, "-b", NULL); |
| prop_nick_full = g_strconcat (param_info->name, " (B)", NULL); |
| g_object_class_install_property (gobject_class, count++, |
| g_param_spec_float (prop_name_full, prop_nick_full, |
| param_info->explanation, 0.0, 1.0, def, |
| G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE)); |
| g_free (prop_name_full); |
| g_free (prop_nick_full); |
| |
| properties[i].n_prop_ids = 3; |
| break; |
| } |
| case F0R_PARAM_POSITION:{ |
| gchar *prop_name_full; |
| gchar *prop_nick_full; |
| gdouble def; |
| |
| def = properties[i].default_value.data.position.x; |
| /* If the default is out of range we use 0.0 */ |
| if (!(def <= 1.0 && def >= 0.0)) |
| def = 0.0; |
| prop_name_full = g_strconcat (prop_name, "-x", NULL); |
| prop_nick_full = g_strconcat (param_info->name, " (X)", NULL); |
| g_object_class_install_property (gobject_class, count++, |
| g_param_spec_double (prop_name_full, prop_nick_full, |
| param_info->explanation, 0.0, 1.0, def, |
| G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE)); |
| g_free (prop_name_full); |
| g_free (prop_nick_full); |
| |
| def = properties[i].default_value.data.position.y; |
| /* If the default is out of range we use 0.0 */ |
| if (!(def <= 1.0 && def >= 0.0)) |
| def = 0.0; |
| prop_name_full = g_strconcat (prop_name, "-Y", NULL); |
| prop_nick_full = g_strconcat (param_info->name, " (Y)", NULL); |
| g_object_class_install_property (gobject_class, count++, |
| g_param_spec_double (prop_name_full, prop_nick_full, |
| param_info->explanation, 0.0, 1.0, def, |
| G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE)); |
| g_free (prop_name_full); |
| g_free (prop_nick_full); |
| |
| properties[i].n_prop_ids = 2; |
| break; |
| } |
| default: |
| g_assert_not_reached (); |
| break; |
| } |
| |
| g_free (prop_name); |
| } |
| |
| ftable->destruct (instance); |
| } |
| |
| GstFrei0rPropertyValue * |
| gst_frei0r_property_cache_init (GstFrei0rProperty * properties, |
| gint n_properties) |
| { |
| gint i; |
| GstFrei0rPropertyValue *ret = g_new0 (GstFrei0rPropertyValue, n_properties); |
| |
| for (i = 0; i < n_properties; i++) { |
| memcpy (&ret[i].data, &properties[i].default_value, |
| sizeof (GstFrei0rPropertyValue)); |
| |
| if (properties[i].info.type == F0R_PARAM_STRING) |
| ret[i].data.s = g_strdup (ret[i].data.s); |
| } |
| |
| return ret; |
| } |
| |
| void |
| gst_frei0r_property_cache_free (GstFrei0rProperty * properties, |
| GstFrei0rPropertyValue * property_cache, gint n_properties) |
| { |
| gint i; |
| |
| for (i = 0; i < n_properties; i++) { |
| if (properties[i].info.type == F0R_PARAM_STRING) |
| g_free (property_cache[i].data.s); |
| } |
| g_free (property_cache); |
| } |
| |
| f0r_instance_t * |
| gst_frei0r_instance_construct (GstFrei0rFuncTable * ftable, |
| GstFrei0rProperty * properties, gint n_properties, |
| GstFrei0rPropertyValue * property_cache, gint width, gint height) |
| { |
| f0r_instance_t *instance = ftable->construct (width, height); |
| gint i; |
| |
| for (i = 0; i < n_properties; i++) { |
| if (properties[i].info.type == F0R_PARAM_STRING) |
| ftable->set_param_value (instance, property_cache[i].data.s, i); |
| else |
| ftable->set_param_value (instance, &property_cache[i].data, i); |
| } |
| |
| return instance; |
| } |
| |
| gboolean |
| gst_frei0r_get_property (f0r_instance_t * instance, GstFrei0rFuncTable * ftable, |
| GstFrei0rProperty * properties, gint n_properties, |
| GstFrei0rPropertyValue * property_cache, guint prop_id, GValue * value) |
| { |
| gint i; |
| GstFrei0rProperty *prop = NULL; |
| |
| for (i = 0; i < n_properties; i++) { |
| if (properties[i].prop_id <= prop_id && |
| properties[i].prop_id + properties[i].n_prop_ids > prop_id) { |
| prop = &properties[i]; |
| break; |
| } |
| } |
| |
| if (!prop) |
| return FALSE; |
| |
| switch (prop->info.type) { |
| case F0R_PARAM_BOOL:{ |
| gdouble d; |
| |
| if (instance) |
| ftable->get_param_value (instance, &d, prop->prop_idx); |
| else |
| d = property_cache[prop->prop_idx].data.b; |
| |
| g_value_set_boolean (value, (d < 0.5) ? FALSE : TRUE); |
| break; |
| } |
| case F0R_PARAM_DOUBLE:{ |
| gdouble d; |
| |
| if (instance) |
| ftable->get_param_value (instance, &d, prop->prop_idx); |
| else |
| d = property_cache[prop->prop_idx].data.d; |
| |
| g_value_set_double (value, d); |
| break; |
| } |
| case F0R_PARAM_STRING:{ |
| const gchar *s; |
| |
| if (instance) |
| ftable->get_param_value (instance, &s, prop->prop_idx); |
| else |
| s = property_cache[prop->prop_idx].data.s; |
| g_value_set_string (value, s); |
| break; |
| } |
| case F0R_PARAM_COLOR:{ |
| f0r_param_color_t color; |
| |
| if (instance) |
| ftable->get_param_value (instance, &color, prop->prop_idx); |
| else |
| color = property_cache[prop->prop_idx].data.color; |
| |
| switch (prop_id - prop->prop_id) { |
| case 0: |
| g_value_set_float (value, color.r); |
| break; |
| case 1: |
| g_value_set_float (value, color.g); |
| break; |
| case 2: |
| g_value_set_float (value, color.b); |
| break; |
| } |
| break; |
| } |
| case F0R_PARAM_POSITION:{ |
| f0r_param_position_t position; |
| |
| if (instance) |
| ftable->get_param_value (instance, &position, prop->prop_idx); |
| else |
| position = property_cache[prop->prop_idx].data.position; |
| |
| switch (prop_id - prop->prop_id) { |
| case 0: |
| g_value_set_double (value, position.x); |
| break; |
| case 1: |
| g_value_set_double (value, position.y); |
| break; |
| } |
| break; |
| } |
| default: |
| g_assert_not_reached (); |
| break; |
| } |
| |
| return TRUE; |
| } |
| |
| gboolean |
| gst_frei0r_set_property (f0r_instance_t * instance, GstFrei0rFuncTable * ftable, |
| GstFrei0rProperty * properties, gint n_properties, |
| GstFrei0rPropertyValue * property_cache, guint prop_id, |
| const GValue * value) |
| { |
| GstFrei0rProperty *prop = NULL; |
| gint i; |
| |
| for (i = 0; i < n_properties; i++) { |
| if (properties[i].prop_id <= prop_id && |
| properties[i].prop_id + properties[i].n_prop_ids > prop_id) { |
| prop = &properties[i]; |
| break; |
| } |
| } |
| |
| if (!prop) |
| return FALSE; |
| |
| switch (prop->info.type) { |
| case F0R_PARAM_BOOL:{ |
| gboolean b = g_value_get_boolean (value); |
| gdouble d = b ? 1.0 : 0.0; |
| |
| if (instance) |
| ftable->set_param_value (instance, &d, prop->prop_idx); |
| property_cache[prop->prop_idx].data.b = d; |
| break; |
| } |
| case F0R_PARAM_DOUBLE:{ |
| gdouble d = g_value_get_double (value); |
| |
| if (instance) |
| ftable->set_param_value (instance, &d, prop->prop_idx); |
| property_cache[prop->prop_idx].data.d = d; |
| break; |
| } |
| case F0R_PARAM_STRING:{ |
| gchar *s = g_value_dup_string (value); |
| |
| /* Copies the string */ |
| if (instance) |
| ftable->set_param_value (instance, s, prop->prop_idx); |
| property_cache[prop->prop_idx].data.s = s; |
| break; |
| } |
| case F0R_PARAM_COLOR:{ |
| gfloat f = g_value_get_float (value); |
| f0r_param_color_t *color = &property_cache[prop->prop_idx].data.color; |
| |
| switch (prop_id - prop->prop_id) { |
| case 0: |
| color->r = f; |
| break; |
| case 1: |
| color->g = f; |
| break; |
| case 2: |
| color->b = f; |
| break; |
| default: |
| g_assert_not_reached (); |
| } |
| |
| if (instance) |
| ftable->set_param_value (instance, color, prop->prop_idx); |
| break; |
| } |
| case F0R_PARAM_POSITION:{ |
| gdouble d = g_value_get_double (value); |
| f0r_param_position_t *position = |
| &property_cache[prop->prop_idx].data.position; |
| |
| switch (prop_id - prop->prop_id) { |
| case 0: |
| position->x = d; |
| break; |
| case 1: |
| position->y = d; |
| break; |
| default: |
| g_assert_not_reached (); |
| } |
| if (instance) |
| ftable->set_param_value (instance, position, prop->prop_idx); |
| break; |
| } |
| default: |
| g_assert_not_reached (); |
| break; |
| } |
| |
| return TRUE; |
| } |
| |
| static gboolean |
| register_plugin (GstPlugin * plugin, const gchar * vendor, |
| const gchar * filename) |
| { |
| GModule *module; |
| GstFrei0rPluginRegisterReturn ret = GST_FREI0R_PLUGIN_REGISTER_RETURN_FAILED; |
| GstFrei0rFuncTable ftable = { NULL, }; |
| gint i; |
| f0r_plugin_info_t info = { NULL, }; |
| f0r_instance_t *instance = NULL; |
| |
| GST_DEBUG ("Registering plugin '%s'", filename); |
| |
| module = g_module_open (filename, G_MODULE_BIND_LAZY | G_MODULE_BIND_LOCAL); |
| if (!module) { |
| GST_WARNING ("Failed to load plugin"); |
| return FALSE; |
| } |
| |
| if (!g_module_symbol (module, "f0r_init", (gpointer *) & ftable.init)) { |
| GST_INFO ("No frei0r plugin"); |
| g_module_close (module); |
| return FALSE; |
| } |
| |
| if (!g_module_symbol (module, "f0r_deinit", (gpointer *) & ftable.deinit) || |
| !g_module_symbol (module, "f0r_construct", |
| (gpointer *) & ftable.construct) |
| || !g_module_symbol (module, "f0r_destruct", |
| (gpointer *) & ftable.destruct) |
| || !g_module_symbol (module, "f0r_get_plugin_info", |
| (gpointer *) & ftable.get_plugin_info) |
| || !g_module_symbol (module, "f0r_get_param_info", |
| (gpointer *) & ftable.get_param_info) |
| || !g_module_symbol (module, "f0r_set_param_value", |
| (gpointer *) & ftable.set_param_value) |
| || !g_module_symbol (module, "f0r_get_param_value", |
| (gpointer *) & ftable.get_param_value)) |
| goto invalid_frei0r_plugin; |
| |
| /* One of these must exist */ |
| g_module_symbol (module, "f0r_update", (gpointer *) & ftable.update); |
| g_module_symbol (module, "f0r_update2", (gpointer *) & ftable.update2); |
| |
| if (!ftable.init ()) { |
| GST_WARNING ("Failed to initialize plugin"); |
| g_module_close (module); |
| return FALSE; |
| } |
| |
| if (!ftable.update && !ftable.update2) |
| goto invalid_frei0r_plugin; |
| |
| ftable.get_plugin_info (&info); |
| |
| if (info.frei0r_version > 1) { |
| GST_WARNING ("Unsupported frei0r version %d", info.frei0r_version); |
| ftable.deinit (); |
| g_module_close (module); |
| return FALSE; |
| } |
| |
| if (info.color_model > F0R_COLOR_MODEL_PACKED32) { |
| GST_WARNING ("Unsupported color model %d", info.color_model); |
| ftable.deinit (); |
| g_module_close (module); |
| return FALSE; |
| } |
| |
| for (i = 0; i < info.num_params; i++) { |
| f0r_param_info_t pinfo = { NULL, }; |
| |
| ftable.get_param_info (&pinfo, i); |
| if (pinfo.type > F0R_PARAM_STRING) { |
| GST_WARNING ("Unsupported parameter type %d", pinfo.type); |
| ftable.deinit (); |
| g_module_close (module); |
| return FALSE; |
| } |
| } |
| |
| instance = ftable.construct (640, 480); |
| if (!instance) { |
| GST_WARNING ("Failed to instanciate plugin '%s'", info.name); |
| ftable.deinit (); |
| g_module_close (module); |
| return FALSE; |
| } |
| ftable.destruct (instance); |
| |
| switch (info.plugin_type) { |
| case F0R_PLUGIN_TYPE_FILTER: |
| ret = gst_frei0r_filter_register (plugin, vendor, &info, &ftable); |
| break; |
| case F0R_PLUGIN_TYPE_SOURCE: |
| ret = gst_frei0r_src_register (plugin, vendor, &info, &ftable); |
| break; |
| case F0R_PLUGIN_TYPE_MIXER2: |
| case F0R_PLUGIN_TYPE_MIXER3: |
| ret = gst_frei0r_mixer_register (plugin, vendor, &info, &ftable); |
| break; |
| default: |
| break; |
| } |
| |
| switch (ret) { |
| case GST_FREI0R_PLUGIN_REGISTER_RETURN_OK: |
| return TRUE; |
| case GST_FREI0R_PLUGIN_REGISTER_RETURN_FAILED: |
| GST_ERROR ("Failed to register frei0r plugin"); |
| ftable.deinit (); |
| g_module_close (module); |
| return FALSE; |
| case GST_FREI0R_PLUGIN_REGISTER_RETURN_ALREADY_REGISTERED: |
| GST_DEBUG ("frei0r plugin already registered"); |
| ftable.deinit (); |
| g_module_close (module); |
| return TRUE; |
| default: |
| g_return_val_if_reached (FALSE); |
| } |
| |
| g_return_val_if_reached (FALSE); |
| |
| invalid_frei0r_plugin: |
| GST_ERROR ("Invalid frei0r plugin"); |
| ftable.deinit (); |
| g_module_close (module); |
| |
| return FALSE; |
| } |
| |
| static gboolean |
| register_plugins (GstPlugin * plugin, GHashTable * plugin_names, |
| const gchar * path, const gchar * base_path) |
| { |
| GDir *dir; |
| gchar *filename; |
| const gchar *entry_name; |
| gboolean ret = TRUE; |
| |
| GST_DEBUG ("Scanning directory '%s' for frei0r plugins", path); |
| |
| dir = g_dir_open (path, 0, NULL); |
| if (!dir) |
| return FALSE; |
| |
| while ((entry_name = g_dir_read_name (dir))) { |
| gchar *tmp, *vendor = NULL; |
| gchar *hashtable_name; |
| |
| tmp = g_strdup (path + strlen (base_path)); |
| if (*tmp == G_DIR_SEPARATOR && *(tmp + 1)) |
| vendor = tmp + 1; |
| else if (*tmp) |
| vendor = tmp; |
| |
| if (vendor) |
| hashtable_name = g_strconcat (vendor, "-", entry_name, NULL); |
| else |
| hashtable_name = g_strdup (entry_name); |
| |
| if (g_hash_table_lookup_extended (plugin_names, hashtable_name, NULL, NULL)) { |
| g_free (hashtable_name); |
| continue; |
| } |
| |
| filename = g_build_filename (path, entry_name, NULL); |
| if ((g_str_has_suffix (filename, G_MODULE_SUFFIX) |
| #ifdef GST_EXTRA_MODULE_SUFFIX |
| || g_str_has_suffix (filename, GST_EXTRA_MODULE_SUFFIX) |
| #endif |
| ) && g_file_test (filename, G_FILE_TEST_IS_REGULAR)) { |
| gboolean this_ret; |
| |
| this_ret = register_plugin (plugin, vendor, filename); |
| if (this_ret) |
| g_hash_table_insert (plugin_names, g_strdup (hashtable_name), NULL); |
| |
| ret = ret && this_ret; |
| } else if (g_file_test (filename, G_FILE_TEST_IS_DIR)) { |
| ret = ret && register_plugins (plugin, plugin_names, filename, base_path); |
| } |
| g_free (filename); |
| g_free (hashtable_name); |
| g_free (tmp); |
| } |
| g_dir_close (dir); |
| |
| return ret; |
| } |
| |
| static gboolean |
| plugin_init (GstPlugin * plugin) |
| { |
| const gchar *homedir; |
| gchar *path, *libdir_path; |
| GHashTable *plugin_names; |
| const gchar *frei0r_path; |
| |
| GST_DEBUG_CATEGORY_INIT (frei0r_debug, "frei0r", 0, "frei0r"); |
| |
| gst_plugin_add_dependency_simple (plugin, |
| "FREI0R_PATH:HOME/.frei0r-1/lib", |
| LIBDIR "/frei0r-1:" |
| "/usr/lib/frei0r-1:/usr/local/lib/frei0r-1:" |
| "/usr/lib32/frei0r-1:/usr/local/lib32/frei0r-1:" |
| "/usr/lib64/frei0r-1:/usr/local/lib64/frei0r-1", |
| NULL, GST_PLUGIN_DEPENDENCY_FLAG_RECURSE); |
| |
| plugin_names = |
| g_hash_table_new_full ((GHashFunc) g_str_hash, (GEqualFunc) g_str_equal, |
| (GDestroyNotify) g_free, NULL); |
| |
| frei0r_path = g_getenv ("FREI0R_PATH"); |
| if (frei0r_path && *frei0r_path) { |
| gchar **p, **paths = g_strsplit (frei0r_path, ":", -1); |
| |
| for (p = paths; *p; p++) { |
| register_plugins (plugin, plugin_names, *p, *p); |
| } |
| |
| g_strfreev (paths); |
| } else { |
| #define register_plugins2(plugin, pn, p) register_plugins(plugin, pn, p, p) |
| homedir = g_get_home_dir (); |
| path = g_build_filename (homedir, ".frei0r-1", "lib", NULL); |
| libdir_path = g_build_filename (LIBDIR, "frei0r-1", NULL); |
| register_plugins2 (plugin, plugin_names, path); |
| g_free (path); |
| register_plugins2 (plugin, plugin_names, libdir_path); |
| g_free (libdir_path); |
| register_plugins2 (plugin, plugin_names, "/usr/local/lib/frei0r-1"); |
| register_plugins2 (plugin, plugin_names, "/usr/lib/frei0r-1"); |
| register_plugins2 (plugin, plugin_names, "/usr/local/lib32/frei0r-1"); |
| register_plugins2 (plugin, plugin_names, "/usr/lib32/frei0r-1"); |
| register_plugins2 (plugin, plugin_names, "/usr/local/lib64/frei0r-1"); |
| register_plugins2 (plugin, plugin_names, "/usr/lib64/frei0r-1"); |
| #undef register_plugins2 |
| } |
| |
| g_hash_table_unref (plugin_names); |
| |
| return TRUE; |
| } |
| |
| GST_PLUGIN_DEFINE (GST_VERSION_MAJOR, |
| GST_VERSION_MINOR, |
| frei0r, |
| "frei0r plugin library", |
| plugin_init, VERSION, "LGPL", GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN) |
