自学教程：C++ GST_PLUGIN_FEATURE函数代码示例

static const char *Gstreamer_FindMatch(const char *strcaps){    struct typeinfo data;    GList *list, *copy;    guint bestrank = 0;    GstElementFactory *bestfactory = NULL;    GstCaps *caps = gst_caps_from_string(strcaps);    TRACE("%s/n", strcaps);    data.caps = caps;    data.type = "Decoder";    copy = gst_registry_feature_filter(gst_registry_get(), match_element, 0, &data);    for (list = copy; list; list = list->next) {        GstElementFactory *factory = (GstElementFactory*)list->data;        guint rank;        rank = gst_plugin_feature_get_rank(GST_PLUGIN_FEATURE(factory));        if (rank > bestrank || !bestrank) {            bestrank = rank;            bestfactory = factory;        }    }    gst_caps_unref(caps);    g_list_free(copy);    if (!bestfactory) {        FIXME("Could not find plugin for %s/n", strcaps);        return NULL;    }    return gst_plugin_feature_get_name(GST_PLUGIN_FEATURE(bestfactory));}

static intprint_element_info (GstElementFactory * factory, gboolean print_names){  GstElement *element;  gint maxlevel = 0;  factory =      GST_ELEMENT_FACTORY (gst_plugin_feature_load (GST_PLUGIN_FEATURE          (factory)));  if (!factory) {    g_print ("element plugin couldn't be loaded/n");    return -1;  }  element = gst_element_factory_create (factory, NULL);  if (!element) {    g_print ("couldn't construct element for some reason/n");    return -1;  }  if (print_names)    _name = g_strdup_printf ("%s: ", GST_PLUGIN_FEATURE (factory)->name);  else    _name = NULL;  print_factory_details_info (factory);  if (GST_PLUGIN_FEATURE (factory)->plugin_name) {    GstPlugin *plugin;    plugin = gst_registry_find_plugin (gst_registry_get_default (),        GST_PLUGIN_FEATURE (factory)->plugin_name);    if (plugin) {      print_plugin_info (plugin);    }  }  print_hierarchy (G_OBJECT_TYPE (element), 0, &maxlevel);  print_interfaces (G_OBJECT_TYPE (element));  print_pad_templates_info (element, factory);  print_element_flag_info (element);  print_implementation_info (element);  print_clocking_info (element);  print_index_info (element);  print_uri_handler_info (element);  print_pad_info (element);  print_element_properties_info (element);  print_signal_info (element);  print_children_info (element);  gst_object_unref (element);  gst_object_unref (factory);  g_free (_name);  return 0;}

voidgstsharp_gst_index_factory_set_plugin (GstIndexFactory * factory,    GstPlugin * plugin){  if (!plugin)    return;  GST_PLUGIN_FEATURE (factory)->plugin_name = g_strdup (plugin->desc.name);  GST_PLUGIN_FEATURE (factory)->loaded = TRUE;}

static voidprint_factory_details_info (GstElementFactory * factory){  n_print ("Factory Details:/n");  n_print ("  Long name:/t%s/n", factory->details.longname);  n_print ("  Class:/t%s/n", factory->details.klass);  n_print ("  Description:/t%s/n", factory->details.description);  n_print ("  Author(s):/t%s/n", factory->details.author);  n_print ("  Rank:/t/t%s (%d)/n",      get_rank_name (GST_PLUGIN_FEATURE (factory)->rank),      GST_PLUGIN_FEATURE (factory)->rank);  n_print ("/n");}

/* * Method: get_features(feature_type_or_plugin_name) * feature_type_or_plugin_name: a feature type or plugin name. * * Gets a list of all plugin features of the given type in the pool. * * Valid features types are Gst::AutoplugFactory, Gst::ElementFactory, * Gst::IndexFactory, Gst::SchedulerFactory and Gst::TypeFactory. * * Returns: an array of Gst::PluginFeature objects. */static VALUErb_gst_registry_get_features(VALUE self, VALUE type_or_plugin_name){    GList *list, *node;    GType gtype;    VALUE arr;    if (RVAL2CBOOL(rb_obj_is_kind_of(type_or_plugin_name, rb_cString))) {        list = gst_registry_get_feature_list_by_plugin(RGST_REGISTRY(self),                                                       RVAL2CSTR(type_or_plugin_name));    } else {        gtype = CLASS2GTYPE(type_or_plugin_name);        if (!is_valid_pluginfeature_type(gtype))            rb_raise (rb_eArgError, "Invalid feature type.");        list = gst_registry_get_feature_list(RGST_REGISTRY(self), gtype);    }    arr = rb_ary_new();    for (node = list; node != NULL; node = g_list_next(node)) {        rb_ary_push(arr, instanciate_pluginfeature(GST_PLUGIN_FEATURE(node->data)));    }    g_list_free (list);    return arr;}

void test_registry(){    GList *g;    GstRegistry *registry;    //xmlfile = "test_registry";    std_log(LOG_FILENAME_LINE, "Test Started test_registry");    registry = gst_registry_get_default ();    for (g = registry->plugins; g; g = g->next) {        GstPlugin *plugin = GST_PLUGIN (g->data);        ASSERT_OBJECT_REFCOUNT (plugin, "plugin in registry", 1);        GST_DEBUG ("refcount %d %s", GST_OBJECT_REFCOUNT_VALUE (plugin),                   plugin->desc.name);    }    for (g = registry->features; g; g = g->next) {        GstPluginFeature *feature = GST_PLUGIN_FEATURE (g->data);        fail_if (GST_OBJECT_REFCOUNT_VALUE (feature) != 1,                 "Feature in registry should have refcount of 1");        GST_DEBUG ("refcount %d %s", GST_OBJECT_REFCOUNT_VALUE (feature),                   feature->name);    }    std_log(LOG_FILENAME_LINE, "Test Successful");    create_xml(0);}

/* Get the intersection of parser caps and available (sorted) decoders */static GstCaps *get_parser_caps_filter (GstDecodebin3 * dbin, GstCaps * caps){  GList *tmp;  GstCaps *filter_caps = gst_caps_new_empty ();  g_mutex_lock (&dbin->factories_lock);  gst_decode_bin_update_factories_list (dbin);  for (tmp = dbin->decoder_factories; tmp; tmp = tmp->next) {    GstElementFactory *factory = (GstElementFactory *) tmp->data;    GstCaps *tcaps, *intersection;    const GList *tmps;    GST_LOG ("Trying factory %s",        gst_plugin_feature_get_name (GST_PLUGIN_FEATURE (factory)));    for (tmps = gst_element_factory_get_static_pad_templates (factory); tmps;        tmps = tmps->next) {      GstStaticPadTemplate *st = (GstStaticPadTemplate *) tmps->data;      if (st->direction != GST_PAD_SINK || st->presence != GST_PAD_ALWAYS)        continue;      tcaps = gst_static_pad_template_get_caps (st);      intersection =          gst_caps_intersect_full (tcaps, caps, GST_CAPS_INTERSECT_FIRST);      filter_caps = gst_caps_merge (filter_caps, intersection);      gst_caps_unref (tcaps);    }  }  g_mutex_unlock (&dbin->factories_lock);  GST_DEBUG_OBJECT (dbin, "Got filter caps %" GST_PTR_FORMAT, filter_caps);  return filter_caps;}

static voidprint_plugin_automatic_install_info (GstPlugin * plugin){  GList *features, *l;  /* not interested in typefind factories, only element factories */  features = gst_registry_get_feature_list (gst_registry_get (),      GST_TYPE_ELEMENT_FACTORY);  for (l = features; l != NULL; l = l->next) {    GstPluginFeature *feature;    GstPlugin *feature_plugin;    feature = GST_PLUGIN_FEATURE (l->data);    /* only interested in the ones that are in the plugin we just loaded */    feature_plugin = gst_plugin_feature_get_plugin (feature);    if (feature_plugin == plugin) {      GstElementFactory *factory;      g_print ("element-%s/n", gst_plugin_feature_get_name (feature));      factory = GST_ELEMENT_FACTORY (feature);      print_plugin_automatic_install_info_protocols (factory);      print_plugin_automatic_install_info_codecs (factory);    }    if (feature_plugin)      gst_object_unref (feature_plugin);  }  g_list_foreach (features, (GFunc) gst_object_unref, NULL);  g_list_free (features);}

static gbooleancheck_parser_caps_filter (GstDecodebin3 * dbin, GstCaps * caps){  GList *tmp;  gboolean res = FALSE;  g_mutex_lock (&dbin->factories_lock);  gst_decode_bin_update_factories_list (dbin);  for (tmp = dbin->decoder_factories; tmp; tmp = tmp->next) {    GstElementFactory *factory = (GstElementFactory *) tmp->data;    GstCaps *tcaps;    const GList *tmps;    GST_LOG ("Trying factory %s",        gst_plugin_feature_get_name (GST_PLUGIN_FEATURE (factory)));    for (tmps = gst_element_factory_get_static_pad_templates (factory); tmps;        tmps = tmps->next) {      GstStaticPadTemplate *st = (GstStaticPadTemplate *) tmps->data;      if (st->direction != GST_PAD_SINK || st->presence != GST_PAD_ALWAYS)        continue;      tcaps = gst_static_pad_template_get_caps (st);      if (gst_caps_can_intersect (tcaps, caps)) {        res = TRUE;        gst_caps_unref (tcaps);        goto beach;      }      gst_caps_unref (tcaps);    }  }beach:  g_mutex_unlock (&dbin->factories_lock);  GST_DEBUG_OBJECT (dbin, "Can intersect : %d", res);  return res;}

static voidconference_element_added (FsElementAddedNotifier *notifier,    GstBin *bin,    GstElement *element,    gpointer user_data){  GstElementFactory *factory;  const gchar *name;  factory = gst_element_get_factory (element);  name = gst_plugin_feature_get_name (GST_PLUGIN_FEATURE (factory));  if (!tp_strdiff (name, "x264enc"))    {      /* Ensure that the encoder creates the baseline profile */      g_object_set (element,          "byte-stream", TRUE,          "bframes", 0,          "b-adapt", FALSE,          "cabac", FALSE,          "dct8x8", FALSE,          NULL);    }  else if (!tp_strdiff (name, "gstrtpbin"))    {      /* Lower the jitterbuffer latency to make it more suitable for video       * conferencing */      g_object_set (element, "latency", 100, NULL);    }}

static voidprint_factory_details_info (GstElementFactory * factory){  gchar **keys, **k;  GstRank rank;  char s[20];  rank = gst_plugin_feature_get_rank (GST_PLUGIN_FEATURE (factory));  n_print ("Factory Details:/n");  n_print ("  %-25s%s (%d)/n", "Rank", get_rank_name (s, rank), rank);  keys = gst_element_factory_get_metadata_keys (factory);  if (keys != NULL) {    for (k = keys; *k != NULL; ++k) {      const gchar *val;      gchar *key = *k;      val = gst_element_factory_get_metadata (factory, key);      key[0] = g_ascii_toupper (key[0]);      n_print ("  %-25s%s/n", key, val);    }    g_strfreev (keys);  }  n_print ("/n");}

intiterate_plugins_elements (GstElementFactory *factory, GHashTable *hashtable){    GstElement *element;    const GList *pads;    GstStaticPadTemplate *padtemplate;    const GstCaps * caps;    int i;    factory =        GST_ELEMENT_FACTORY (gst_plugin_feature_load (GST_PLUGIN_FEATURE                                                      (factory)));    if (!factory)     {        g_error ("element plugin couldn't be loaded");        return -1;    }    element = gst_element_factory_create (factory, NULL);    if (!element)     {        g_error ("couldn't construct element for some reason");        return -1;    }    if (factory->numpadtemplates)     {        pads = factory->staticpadtemplates;        while (pads)         {            padtemplate = (GstStaticPadTemplate *) (pads->data);            pads = g_list_next (pads);            if (padtemplate->direction == GST_PAD_SINK                 && padtemplate->presence == GST_PAD_ALWAYS                && padtemplate->static_caps.string) {                    caps = gst_static_caps_get (&padtemplate->static_caps);                    if (caps != NULL && !gst_caps_is_any (caps) && !gst_caps_is_empty (caps))                    {                        for (i = 0; i < gst_caps_get_size (caps); i++)                         {                            GstStructure *structure = gst_caps_get_structure (caps, i);                            const gchar *mime = gst_structure_get_name (structure);                            if (g_str_has_prefix (mime, "audio"))                            {                                g_hash_table_insert(hashtable, (gpointer)mime, (gpointer)&ONE);                            }                        }                    }                }        }    }    gst_object_unref (element);    gst_object_unref (factory);    return 0;    }

static GstElement * try_codecs(GList *codecs, const gchar *name_prefix){    GList *l;    gchar *element_name;    for (l = codecs; l; l = l->next) {        GstElementFactory *f = l->data;        GstElement *e;        element_name = g_strdup_printf("%s_%s_%u", name_prefix,                                       gst_plugin_feature_get_name(GST_PLUGIN_FEATURE(f)),                                       get_unique_id());        e = gst_element_factory_create(f, element_name);        g_free(element_name);        if (!e)            continue;        /* Try setting to READY. If this fails the codec does not work, for         * example because the hardware codec is currently busy         */        if (gst_element_set_state (e, GST_STATE_READY) != GST_STATE_CHANGE_SUCCESS) {            gst_element_set_state (e, GST_STATE_NULL);            gst_object_unref(e);            continue;        }        return e;    }    return NULL;}

static gintelement_factory_rank_compare_func (gconstpointer a, gconstpointer b){  gint rank_a = gst_plugin_feature_get_rank (GST_PLUGIN_FEATURE (a));  gint rank_b = gst_plugin_feature_get_rank (GST_PLUGIN_FEATURE (b));  /* make order chosen in the end more determinable */  if (rank_a == rank_b) {    const gchar *name_a = GST_PLUGIN_FEATURE_NAME (GST_PLUGIN_FEATURE (a));    const gchar *name_b = GST_PLUGIN_FEATURE_NAME (GST_PLUGIN_FEATURE (b));    return g_ascii_strcasecmp (name_a, name_b);  }  return rank_b - rank_a;}

static voidmutate_playbin (RBVisualizerPlugin *plugin, GstElement *playbin){	GstElement *current_vis_plugin;	GstElement *current_video_sink;	int playbin_flags;	if (playbin == plugin->playbin)		return;	rb_debug ("mutating playbin");	/* check no one has already set the playbin properties we're interested in */	g_object_get (playbin,		      "vis-plugin", &current_vis_plugin,		      "video-sink", &current_video_sink,		      "flags", &playbin_flags,		      NULL);	/* ignore fakesinks */	if (current_video_sink != NULL) {		const char *factoryname;		GstElementFactory *factory;		factory = gst_element_get_factory (current_video_sink);		factoryname = gst_plugin_feature_get_name (GST_PLUGIN_FEATURE (factory));		if (strcmp (factoryname, "fakesink") == 0) {			g_object_unref (current_video_sink);			current_video_sink = NULL;		}	}	if ((current_vis_plugin != NULL) || (current_video_sink != NULL)) {		g_warning ("sink and/or vis plugin already set on playbin");		if (current_vis_plugin)			g_object_unref (current_vis_plugin);		if (current_video_sink)			g_object_unref (current_video_sink);		return;	}	/* detach from old playbin (this should never really happen) */	if (plugin->playbin) {		g_object_unref (plugin->playbin);	}	/* attach to new playbin */	plugin->playbin = g_object_ref (playbin);	g_object_set (plugin->playbin, "video-sink", plugin->sink, NULL);	/* start visualizer if it's supposed to be running */	if (plugin->visualizer != NULL) {		playbin_flags |= PLAYBIN2_FLAG_VIS;		g_object_set (plugin->playbin,			      "flags", playbin_flags,			      "vis-plugin", plugin->visualizer,			      NULL);	}}

static const gchar *factory_name_from_element (GstElement *element){  GstElementFactory *factory = gst_element_get_factory (element);  if (factory)    return gst_plugin_feature_get_name (GST_PLUGIN_FEATURE (factory));  else    return NULL;}

static voidprint_factory_details_info (GstElementFactory * factory){  char s[20];  n_print ("Factory Details:/n");  n_print ("  Long name:/t%s/n", factory->details.longname);  n_print ("  Class:/t%s/n", factory->details.klass);  n_print ("  Description:/t%s/n", factory->details.description);  n_print ("  Author(s):/t%s/n", factory->details.author);  n_print ("  Rank:/t/t%s (%d)/n",      get_rank_name (s, GST_PLUGIN_FEATURE (factory)->rank),      GST_PLUGIN_FEATURE (factory)->rank);  if (factory->meta_data != NULL) {    gst_structure_foreach ((GstStructure *) factory->meta_data,        print_factory_details_meta_data, NULL);  }  n_print ("/n");}

static gintfind_composition_func (const GValue * velement){  GstElement *element = g_value_get_object (velement);  GstElementFactory *fac = gst_element_get_factory (element);  const gchar *name = gst_plugin_feature_get_name (GST_PLUGIN_FEATURE (fac));  if (g_strcmp0 (name, "gnlcomposition") == 0)    return 0;  return 1;}

gbooleanrb_gst_encoder_set_encoding_style (GstElement *encoder, const char *style){	GstElementFactory *factory;	char *group_name;	char **keys;	int i;	factory = gst_element_get_factory (encoder);	group_name = g_strdup_printf (ENCODER_STYLE_SETTINGS_PREFIX "%s-%s",				      gst_plugin_feature_get_name (GST_PLUGIN_FEATURE (factory)),				      style);	rb_debug ("applying settings from %s", group_name);	keys = g_key_file_get_keys (get_target_keyfile (), group_name, NULL, NULL);	if (keys == NULL) {		rb_debug ("nothing to apply");		g_free (group_name);		return FALSE;	}	for (i = 0; keys[i] != NULL; i++) {		GParamSpec *pspec;		GValue v = {0,};		char *value;		pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (encoder), keys[i]);		if (pspec == NULL) {			rb_debug ("couldn't find property %s", keys[i]);			continue;		}		value = g_key_file_get_string (get_target_keyfile (), group_name, keys[i], NULL);		if (value == NULL) {			rb_debug ("couldn't get value for property %s", keys[i]);			continue;		}		g_value_init (&v, pspec->value_type);		if (gst_value_deserialize (&v, value)) {			rb_debug ("applying value /"%s/" to property %s", value, keys[i]);			g_object_set_property (G_OBJECT (encoder), keys[i], &v);		} else {			rb_debug ("couldn't deserialize value /"%s/" for property %s", value, keys[i]);		}		g_value_unset (&v);	}	g_strfreev (keys);	g_free (group_name);	return TRUE;}

gbooleangst_mem_index_plugin_init (GstPlugin * plugin){  GstIndexFactory *factory;  factory = gst_index_factory_new ("memindex",      "A index that stores entries in memory", gst_mem_index_get_type ());  if (factory == NULL) {    g_warning ("failed to create memindex factory");    return FALSE;  }  GST_PLUGIN_FEATURE (factory)->plugin_name = plugin->desc.name;  GST_PLUGIN_FEATURE (factory)->loaded = TRUE;  gst_registry_add_feature (gst_registry_get_default (),      GST_PLUGIN_FEATURE (factory));  return TRUE;}

gbooleangst_file_index_plugin_init (GstPlugin * plugin){  GstIndexFactory *factory;  factory = gst_index_factory_new ("fileindex",      "A index that stores entries in file", gst_file_index_get_type ());  if (factory == NULL) {    return FALSE;  }  GST_PLUGIN_FEATURE (factory)->plugin_name = plugin->desc.name;  GST_PLUGIN_FEATURE (factory)->loaded = TRUE;  gst_registry_add_feature (gst_registry_get_default (),      GST_PLUGIN_FEATURE (factory));  GST_DEBUG_CATEGORY_INIT (DC, "GST_FILEINDEX", 0, NULL);  return TRUE;}

GstElement *_bp_equalizer_new (BansheePlayer *player){    GstElement *equalizer;        if (player->equalizer_status == BP_EQ_STATUS_DISABLED) {        return NULL;    }        if (player->equalizer_status == BP_EQ_STATUS_UNCHECKED ||         player->equalizer_status == BP_EQ_STATUS_USE_BUILTIN) {        equalizer = gst_element_factory_make ("banshee-equalizer", "banshee-equalizer");        if (equalizer != NULL) {            if (player->equalizer_status == BP_EQ_STATUS_UNCHECKED) {                player->equalizer_status = BP_EQ_STATUS_USE_BUILTIN;                bp_debug ("Using built-in equalizer element");            }                        return equalizer;        }    }        if (player->equalizer_status == BP_EQ_STATUS_UNCHECKED ||         player->equalizer_status == BP_EQ_STATUS_USE_SYSTEM) {        equalizer = gst_element_factory_make ("equalizer-10bands", "equalizer-10bands");        if (equalizer != NULL) {            GstElementFactory *efactory = NULL;            if (player->equalizer_status == BP_EQ_STATUS_USE_SYSTEM) {                return equalizer;            }                        efactory = gst_element_get_factory (equalizer);            if (gst_plugin_feature_check_version (GST_PLUGIN_FEATURE (efactory), 0, 10, 9)) {                bp_debug ("Using system (gst-plugins-good) equalizer element");                player->equalizer_status = BP_EQ_STATUS_USE_SYSTEM;                return equalizer;            }                        bp_debug ("Buggy system equalizer found. gst-plugins-good 0.10.9 or better "                "required, or build Banshee with the built-in equalizer.");            gst_object_unref (equalizer);        } else {            bp_debug ("No system equalizer found");        }    }        bp_debug ("No suitable equalizer element could be found, disabling EQ for this session");    player->equalizer_status = BP_EQ_STATUS_DISABLED;    return NULL;}

static gbooleanfilter_parsers (GstElementFactory * factory, gpointer user_data){  if (GST_IS_ELEMENT_FACTORY (factory) == FALSE)    return FALSE;  if (g_strrstr (gst_element_factory_get_klass (factory), "Parser")) {    if (gst_plugin_feature_get_rank (GST_PLUGIN_FEATURE (factory)) >=        GST_RANK_PRIMARY)      return TRUE;  }  return FALSE;}

static voiddebug_pipeline (GstDebugLevel level, const gchar *prefix, GList *pipeline){  GList *walk;  GString *str;  gboolean first = TRUE;  if (gst_debug_category_get_threshold (GST_CAT_DEFAULT) <  level)    return;  str = g_string_new (prefix);  for (walk = pipeline; walk; walk = g_list_next (walk))  {    GList *walk2;    gboolean first_alt = TRUE;    if (!first)      g_string_append (str, " ->");    first = FALSE;    for (walk2 = g_list_first (walk->data); walk2; walk2 = g_list_next (walk2))    {      if (first_alt)        g_string_append_printf (str, " %s",            gst_plugin_feature_get_name (GST_PLUGIN_FEATURE (walk2->data)));      else        g_string_append_printf (str, " | %s",            gst_plugin_feature_get_name (GST_PLUGIN_FEATURE (walk2->data)));      first_alt = FALSE;    }  }  GST_CAT_LEVEL_LOG (GST_CAT_DEFAULT, level, NULL, "%s", str->str);  g_string_free (str, TRUE);}

void GStreamerReader::ElementAddedCb(GstBin *aPlayBin,                                     GstElement *aElement,                                     gpointer aUserData){  GstElementFactory *factory = gst_element_get_factory(aElement);  if (!factory)    return;  const gchar *name = gst_plugin_feature_get_name(GST_PLUGIN_FEATURE(factory));  if (name && !strcmp(name, "uridecodebin")) {    g_signal_connect(G_OBJECT(aElement), "autoplug-sort",                     G_CALLBACK(GStreamerReader::ElementFilterCb), aUserData);  }}

static voidelement_added (FsElementAddedNotifier *notif, GstBin *bin, GstElement *element,    gpointer user_data){  GstElementFactory *fact = gst_element_get_factory (element);  if (!fact)    return;  if (strcmp (gst_plugin_feature_get_name (GST_PLUGIN_FEATURE (fact)),              "theoradec"))    return;  ts_fail_unless (decoder_count == 0);  decoder_count++;}

/*** * !reimp */QStringList Backend::availableMimeTypes() const{    QStringList availableMimeTypes;    if (!isValid())        return availableMimeTypes;    GstElementFactory *mpegFactory;    // Add mp3 as a separate mime type as people are likely to look for it.    if ((mpegFactory = gst_element_factory_find ("ffmpeg")) ||         (mpegFactory = gst_element_factory_find ("mad"))) {        availableMimeTypes << QLatin1String("audio/x-mp3");        gst_object_unref(GST_OBJECT(mpegFactory));    }    // Iterate over all audio and video decoders and extract mime types from sink caps    GList* factoryList = gst_registry_get_feature_list(gst_registry_get_default (), GST_TYPE_ELEMENT_FACTORY);    for (GList* iter = g_list_first(factoryList) ; iter != NULL ; iter = g_list_next(iter)) {        GstPluginFeature *feature = GST_PLUGIN_FEATURE(iter->data);        QString klass = gst_element_factory_get_klass(GST_ELEMENT_FACTORY(feature));        if (klass == QLatin1String("Codec/Decoder/Audio") ||             klass == QLatin1String("Codec/Decoder/Video")) {            const GList *static_templates;            GstElementFactory *factory = GST_ELEMENT_FACTORY(feature);            static_templates = gst_element_factory_get_static_pad_templates(factory);            for (; static_templates != NULL ; static_templates = static_templates->next) {                GstStaticPadTemplate *padTemplate = (GstStaticPadTemplate *) static_templates->data;                if (padTemplate && padTemplate->direction == GST_PAD_SINK) {                    GstCaps *caps = gst_static_pad_template_get_caps (padTemplate);                    if (caps) {                        const GstStructure* capsStruct = gst_caps_get_structure (caps, 0);                        QString mime = QString::fromUtf8(gst_structure_get_name (capsStruct));                        if (!availableMimeTypes.contains(mime))                              availableMimeTypes.append(mime);                    }                }            }        }    }    g_list_free(factoryList);    availableMimeTypes.sort();    return availableMimeTypes;}

EffectManager::EffectManager(Backend *backend)        : QObject(backend)        , m_backend(backend){    GList* factoryList = gst_registry_get_feature_list(gst_registry_get_default (), GST_TYPE_ELEMENT_FACTORY);    QString name, klass, description, author;    for (GList* iter = g_list_first(factoryList) ; iter != NULL ; iter = g_list_next(iter)) {        GstPluginFeature *feature = GST_PLUGIN_FEATURE(iter->data);        klass = gst_element_factory_get_klass(GST_ELEMENT_FACTORY(feature));        if ( klass == "Filter/Effect/Audio" ) {            name =  GST_PLUGIN_FEATURE_NAME(feature);            // These plugins simply make no sense to the frontend:            // "audiorate" Should be internal            // "volume" not needed            // "equalizer-nbands" not really useful at the moment            // These plugins simply don't work or have major stability issues:            // "iir" Does not seem to do much at the moment            // "audioinvert" Only works for some streams, should be invesigated            // "lpwsinc" Crashes for large values of filter kernel            // "name" Crashes for large values of filter kernel                        // Seems to be working, but not well tested:            // name == "rglimiter" Seems functional            // name == "rgvolume" Seems to be working            QString pluginString = qgetenv("PHONON_GST_ALL_EFFECTS");            bool acceptAll = pluginString.toInt();            if (acceptAll                 // Plugins that have been accepted so far                 || name == "audiopanorama"                  || name == "audioamplify"                  || name == "audiodynamic"                  || name == "equalizer-10bands"                  || name == "speed")                 {                    description = gst_element_factory_get_description (GST_ELEMENT_FACTORY(feature));                    author = gst_element_factory_get_author (GST_ELEMENT_FACTORY(feature));                    EffectInfo *effect = new EffectInfo(name, description, author);                    m_audioEffectList.append(effect);            }        }    }    g_list_free(factoryList);}