static void
print_interfaces (GType type)
{
guint n_ifaces;
GType *iface, *ifaces = g_type_interfaces (type, &n_ifaces);
if (ifaces) {
if (n_ifaces) {
if (_name)
g_print ("%s", _name);
g_print (_("Implemented Interfaces:\n"));
iface = ifaces;
while (*iface) {
if (_name)
g_print ("%s", _name);
g_print (" %s\n", g_type_name (*iface));
iface++;
}
if (_name)
g_print ("%s", _name);
g_print ("\n");
}
g_free (ifaces);
}
}
static void
each_cinfo(gpointer instance, ClassInfoCallbackFunc func, gpointer user_data)
{
const GType gtype = G_TYPE_FROM_INSTANCE(instance);
GType* interfaces;
guint n_interfaces = 0;
interfaces = g_type_interfaces(gtype, &n_interfaces);
{
guint i;
for (i = 0; i < n_interfaces; i++) {
const RGObjClassInfo *info;
info = GTYPE2CINFO_NO_CREATE(interfaces[i]);
if (info)
func(instance, info, user_data);
}
}
g_free(interfaces);
{
GType type;
for (type = gtype; type != G_TYPE_INVALID; type = g_type_parent(type)) {
const RGObjClassInfo *info;
info = GTYPE2CINFO_NO_CREATE(type);
if (info)
func(instance, info, user_data);
}
}
}
static JSBool
fundamental_instance_new_resolve_interface(JSContext *context,
JS::HandleObject obj,
JS::MutableHandleObject objp,
Fundamental *proto_priv,
char *name)
{
GIFunctionInfo *method_info;
JSBool ret;
GType *interfaces;
guint n_interfaces;
guint i;
ret = JS_TRUE;
interfaces = g_type_interfaces(proto_priv->gtype, &n_interfaces);
for (i = 0; i < n_interfaces; i++) {
GIBaseInfo *base_info;
GIInterfaceInfo *iface_info;
base_info = g_irepository_find_by_gtype(g_irepository_get_default(),
interfaces[i]);
if (base_info == NULL)
continue;
/* An interface GType ought to have interface introspection info */
g_assert(g_base_info_get_type(base_info) == GI_INFO_TYPE_INTERFACE);
iface_info = (GIInterfaceInfo *) base_info;
method_info = g_interface_info_find_method(iface_info, name);
g_base_info_unref(base_info);
if (method_info != NULL) {
if (g_function_info_get_flags (method_info) & GI_FUNCTION_IS_METHOD) {
if (gjs_define_function(context, obj,
proto_priv->gtype,
(GICallableInfo *) method_info)) {
objp.set(obj);
} else {
ret = JS_FALSE;
}
}
g_base_info_unref((GIBaseInfo *) method_info);
}
}
g_free(interfaces);
return ret;
}
static PyObject *
_wrap_g_type_wrapper__get_interfaces(PyGTypeWrapper *self, void *closure)
{
guint n_interfaces, i;
GType *interfaces;
PyObject *retval;
interfaces = g_type_interfaces(self->type, &n_interfaces);
retval = PyList_New(n_interfaces);
for (i = 0; i < n_interfaces; i++)
PyList_SetItem(retval, i, pyg_type_wrapper_new(interfaces[i]));
g_free(interfaces);
return retval;
}
static VALUE
rg_interfaces(VALUE self)
{
guint n_interfaces;
GType* types;
VALUE result;
guint i;
types = g_type_interfaces(rbgobj_gtype_get(self), &n_interfaces);
result = rb_ary_new2(n_interfaces);
for (i = 0; i < n_interfaces; i++)
rb_ary_store(result, i, rbgobj_gtype_new(types[i]));
g_free(types);
return result;
}
USER_OBJECT_
R_internal_getInterfaces(GType type)
{
SEXP list;
GType *interfaces;
guint n, i;
interfaces = g_type_interfaces(type, &n);
PROTECT(list = NEW_CHARACTER(n));
for(i = 0; i < n; i++)
SET_STRING_ELT(list, i, COPY_TO_USER_STRING(g_type_name(interfaces[i])));
g_free(interfaces);
UNPROTECT(1);
return(list);
}
static const RGObjClassInfo *
rbgobj_lookup_class_by_gtype_without_lock(GType gtype, VALUE parent,
gboolean create_class)
{
GType fundamental_type;
RGObjClassInfo* cinfo;
RGObjClassInfoDynamic* cinfod;
void* gclass = NULL;
VALUE c;
if (gtype == G_TYPE_INVALID)
return NULL;
cinfo = g_hash_table_lookup(gtype_to_cinfo, GUINT_TO_POINTER(gtype));
if (cinfo)
return cinfo;
if (!create_class)
return NULL;
c = Data_Make_Struct(rb_cData, RGObjClassInfo, cinfo_mark, NULL, cinfo);
cinfo->gtype = gtype;
cinfo->mark = NULL;
cinfo->free = NULL;
cinfo->flags = 0;
fundamental_type = G_TYPE_FUNDAMENTAL(gtype);
switch (fundamental_type) {
case G_TYPE_POINTER:
case G_TYPE_BOXED:
case G_TYPE_PARAM:
case G_TYPE_OBJECT:
case G_TYPE_ENUM:
case G_TYPE_FLAGS:
if (NIL_P(parent)) parent = get_superclass(gtype);
cinfo->klass = rb_funcall(rb_cClass, id_new, 1, parent);
break;
case G_TYPE_INTERFACE:
cinfo->klass = rb_module_new();
break;
default:
if (NIL_P(parent)) parent = get_superclass(gtype);
if (NIL_P(parent)) {
fprintf(stderr,
"%s: %s's fundamental type %s isn't supported\n",
"rbgobj_lookup_class_by_gtype",
g_type_name(gtype),
g_type_name(fundamental_type));
return NULL;
}
cinfo->klass = rb_funcall(rb_cClass, id_new, 1, parent);
}
cinfod = (RGObjClassInfoDynamic *)g_hash_table_lookup(dynamic_gtype_list,
g_type_name(gtype));
if (cinfod) {
cinfo->mark = cinfod->mark;
cinfo->free = cinfod->free;
rb_define_const(cinfod->module, cinfod->name, cinfo->klass);
}
rb_hash_aset(klass_to_cinfo, cinfo->klass, c);
g_hash_table_insert(gtype_to_cinfo, GUINT_TO_POINTER(gtype), cinfo);
if (G_TYPE_IS_CLASSED(gtype))
gclass = g_type_class_ref(gtype);
if (G_TYPE_IS_INSTANTIATABLE(gtype) || G_TYPE_IS_INTERFACE(gtype))
rbgobj_define_action_methods(cinfo->klass);
if (G_TYPE_IS_INSTANTIATABLE(gtype)) {
GType* interfaces = NULL;
guint n_interfaces = 0;
guint i;
interfaces = g_type_interfaces(gtype, &n_interfaces);
for (i = 0; i < n_interfaces; i++) {
const RGObjClassInfo *iface_cinfo;
iface_cinfo =
rbgobj_lookup_class_by_gtype_without_lock(interfaces[i],
Qnil,
TRUE);
rb_include_module(cinfo->klass, iface_cinfo->klass);
}
g_free(interfaces);
}
if (!rbgobj_convert_type_init_hook(gtype, cinfo->klass)) {
switch (fundamental_type) {
case G_TYPE_OBJECT:
rbgobj_init_object_class(cinfo->klass);
break;
case G_TYPE_ENUM:
rbgobj_init_enum_class(cinfo->klass);
break;
case G_TYPE_FLAGS:
rbgobj_init_flags_class(cinfo->klass);
break;
case G_TYPE_INTERFACE:
rbgobj_init_interface(cinfo->klass);
break;
default:
rbgobj_convert_type_init_hook(fundamental_type, cinfo->klass);
break;
}
}
if (gclass)
g_type_class_unref(gclass);
return cinfo;
}
/**
* gst_element_register:
* @plugin: (allow-none): #GstPlugin to register the element with, or NULL for
* a static element (note that passing NULL only works in GStreamer 0.10.13
* and later)
* @name: name of elements of this type
* @rank: rank of element (higher rank means more importance when autoplugging)
* @type: GType of element to register
*
* Create a new elementfactory capable of instantiating objects of the
* @type and add the factory to @plugin.
*
* Returns: TRUE, if the registering succeeded, FALSE on error
*/
gboolean
gst_element_register (GstPlugin * plugin, const gchar * name, guint rank,
GType type)
{
GstPluginFeature *existing_feature;
GstRegistry *registry;
GstElementFactory *factory;
GType *interfaces;
guint n_interfaces, i;
GstElementClass *klass;
GList *item;
g_return_val_if_fail (name != NULL, FALSE);
g_return_val_if_fail (g_type_is_a (type, GST_TYPE_ELEMENT), FALSE);
registry = gst_registry_get_default ();
/* check if feature already exists, if it exists there is no need to update it
* when the registry is getting updated, outdated plugins and all their
* features are removed and readded.
*/
existing_feature = gst_registry_lookup_feature (registry, name);
if (existing_feature) {
GST_DEBUG_OBJECT (registry, "update existing feature %p (%s)",
existing_feature, name);
factory = GST_ELEMENT_FACTORY_CAST (existing_feature);
factory->type = type;
existing_feature->loaded = TRUE;
g_type_set_qdata (type, _gst_elementclass_factory, factory);
gst_object_unref (existing_feature);
return TRUE;
}
factory =
GST_ELEMENT_FACTORY_CAST (g_object_newv (GST_TYPE_ELEMENT_FACTORY, 0,
NULL));
gst_plugin_feature_set_name (GST_PLUGIN_FEATURE_CAST (factory), name);
GST_LOG_OBJECT (factory, "Created new elementfactory for type %s",
g_type_name (type));
/* provide info needed during class structure setup */
g_type_set_qdata (type, _gst_elementclass_factory, factory);
klass = GST_ELEMENT_CLASS (g_type_class_ref (type));
if ((klass->details.longname == NULL) ||
(klass->details.klass == NULL) || (klass->details.author == NULL))
goto detailserror;
factory->type = type;
__gst_element_details_copy (&factory->details, &klass->details);
if (klass->meta_data) {
factory->meta_data = gst_structure_copy ((GstStructure *) klass->meta_data);
} else {
factory->meta_data = NULL;
}
for (item = klass->padtemplates; item; item = item->next) {
GstPadTemplate *templ = item->data;
GstStaticPadTemplate *newt;
gchar *caps_string = gst_caps_to_string (templ->caps);
newt = g_slice_new (GstStaticPadTemplate);
newt->name_template = g_intern_string (templ->name_template);
newt->direction = templ->direction;
newt->presence = templ->presence;
newt->static_caps.caps.refcount = 0;
newt->static_caps.string = g_intern_string (caps_string);
factory->staticpadtemplates =
g_list_append (factory->staticpadtemplates, newt);
g_free (caps_string);
}
factory->numpadtemplates = klass->numpadtemplates;
/* special stuff for URI handling */
if (g_type_is_a (type, GST_TYPE_URI_HANDLER)) {
GstURIHandlerInterface *iface = (GstURIHandlerInterface *)
g_type_interface_peek (klass, GST_TYPE_URI_HANDLER);
if (!iface || (!iface->get_type && !iface->get_type_full) ||
(!iface->get_protocols && !iface->get_protocols_full))
goto urierror;
if (iface->get_type)
factory->uri_type = iface->get_type ();
else if (iface->get_type_full)
factory->uri_type = iface->get_type_full (factory->type);
if (!GST_URI_TYPE_IS_VALID (factory->uri_type))
goto urierror;
if (iface->get_protocols)
factory->uri_protocols = g_strdupv (iface->get_protocols ());
else if (iface->get_protocols_full)
factory->uri_protocols = iface->get_protocols_full (factory->type);
if (!factory->uri_protocols)
goto urierror;
}
interfaces = g_type_interfaces (type, &n_interfaces);
for (i = 0; i < n_interfaces; i++) {
__gst_element_factory_add_interface (factory, g_type_name (interfaces[i]));
}
g_free (interfaces);
if (plugin && plugin->desc.name) {
GST_PLUGIN_FEATURE_CAST (factory)->plugin_name = plugin->desc.name;
GST_PLUGIN_FEATURE_CAST (factory)->plugin = plugin;
g_object_add_weak_pointer ((GObject *) plugin,
(gpointer *) & GST_PLUGIN_FEATURE_CAST (factory)->plugin);
} else {
GST_PLUGIN_FEATURE_CAST (factory)->plugin_name = "NULL";
GST_PLUGIN_FEATURE_CAST (factory)->plugin = NULL;
}
gst_plugin_feature_set_rank (GST_PLUGIN_FEATURE_CAST (factory), rank);
GST_PLUGIN_FEATURE_CAST (factory)->loaded = TRUE;
gst_registry_add_feature (registry, GST_PLUGIN_FEATURE_CAST (factory));
return TRUE;
/* ERRORS */
urierror:
{
GST_WARNING_OBJECT (factory, "error with uri handler!");
gst_element_factory_cleanup (factory);
return FALSE;
}
detailserror:
{
GST_WARNING_OBJECT (factory,
"The GstElementDetails don't seem to have been set properly");
gst_element_factory_cleanup (factory);
return FALSE;
}
}
