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

/* NB: try to mirror decodebin behavior */static gbooleanswfdec_gst_feature_filter (GstPluginFeature *feature, gpointer caps, const gchar* klassname, gboolean autoplugonly){  const GList *walk;  const gchar *klass;  /* we only care about element factories */  if (!GST_IS_ELEMENT_FACTORY (feature))    return FALSE;  /* only decoders are interesting */  klass = gst_element_factory_get_klass (GST_ELEMENT_FACTORY (feature));  if (strstr (klass, klassname) == NULL)    return FALSE;  /* only select elements with autoplugging rank */  if (autoplugonly && gst_plugin_feature_get_rank (feature) < GST_RANK_MARGINAL)    return FALSE;  /* only care about the right sink caps */  for (walk = gst_element_factory_get_static_pad_templates (GST_ELEMENT_FACTORY (feature));       walk; walk = walk->next) {    GstStaticPadTemplate *template = walk->data;

/** * gst_element_factory_get_author: * @factory: a #GstElementFactory * * Gets the author for this factory. * * Returns: the author */const gchar *gst_element_factory_get_author (GstElementFactory * factory){  g_return_val_if_fail (GST_IS_ELEMENT_FACTORY (factory), NULL);  return factory->details.author;}

static gbooleancb_feature_filter (GstPluginFeature *feature,		   gpointer          data){  const gchar *klass;  guint rank;  /* we only care about element factories */  if (!GST_IS_ELEMENT_FACTORY (feature))    return FALSE;  /* only parsers, demuxers and decoders */  klass = gst_element_factory_get_klass (GST_ELEMENT_FACTORY (feature));  if (g_strrstr (klass, "Demux") == NULL &&      g_strrstr (klass, "Decoder") == NULL &&      g_strrstr (klass, "Parse") == NULL)    return FALSE;  /* only select elements with autoplugging rank */  rank = gst_plugin_feature_get_rank (feature);  if (rank < GST_RANK_MARGINAL)    return FALSE;  return TRUE;}

/** * gst_element_factory_get_uri_type: * @factory: a #GstElementFactory * * Gets the type of URIs the element supports or #GST_URI_UNKNOWN if none. * * Returns: type of URIs this element supports */gintgst_element_factory_get_uri_type (GstElementFactory * factory){  g_return_val_if_fail (GST_IS_ELEMENT_FACTORY (factory), GST_URI_UNKNOWN);  return factory->uri_type;}

/** * gst_element_factory_get_description: * @factory: a #GstElementFactory * * Gets the description for this factory. * * Returns: the description */const gchar *gst_element_factory_get_description (GstElementFactory * factory){  g_return_val_if_fail (GST_IS_ELEMENT_FACTORY (factory), NULL);  return factory->details.description;}

/** * gst_element_factory_get_num_pad_templates: * @factory: a #GstElementFactory * * Gets the number of pad_templates in this factory. * * Returns: the number of pad_templates */guintgst_element_factory_get_num_pad_templates (GstElementFactory * factory){  g_return_val_if_fail (GST_IS_ELEMENT_FACTORY (factory), 0);  return factory->numpadtemplates;}

static gboolean match_element(GstPluginFeature *feature, gpointer gdata){    struct typeinfo *data = (struct typeinfo*)gdata;    GstElementFactory *factory;    const GList *list;    if (!GST_IS_ELEMENT_FACTORY(feature))        return FALSE;    factory = GST_ELEMENT_FACTORY(feature);    if (!strstr(gst_element_factory_get_klass(factory), data->type))        return FALSE;    for (list = gst_element_factory_get_static_pad_templates(factory); list; list = list->next) {        GstStaticPadTemplate *pad = (GstStaticPadTemplate*)list->data;        GstCaps *caps;        gboolean ret;        if (pad->direction != GST_PAD_SINK)            continue;        caps = gst_static_caps_get(&pad->static_caps);        ret = gst_caps_is_always_compatible(caps, data->caps);        gst_caps_unref(caps);        if (ret)            return TRUE;    }    return FALSE;}

/** * gst_element_factory_get_element_type: * @factory: factory to get managed #GType from * * Get the #GType for elements managed by this factory. The type can * only be retrieved if the element factory is loaded, which can be * assured with gst_plugin_feature_load(). * * Returns: the #GType for elements managed by this factory or 0 if * the factory is not loaded. */GTypegst_element_factory_get_element_type (GstElementFactory * factory){  g_return_val_if_fail (GST_IS_ELEMENT_FACTORY (factory), 0);  return factory->type;}

/** * gst_element_factory_get_static_pad_templates: * @factory: a #GstElementFactory * * Gets the #GList of #GstStaticPadTemplate for this factory. * * Returns: (transfer none) (element-type Gst.StaticPadTemplate): the *     static pad templates */const GList *gst_element_factory_get_static_pad_templates (GstElementFactory * factory){  g_return_val_if_fail (GST_IS_ELEMENT_FACTORY (factory), NULL);  return factory->staticpadtemplates;}

static voidsetup (void){  GList *features, *f;  GList *plugins, *p;  gchar **ignorelist = NULL;  const gchar *STATE_IGNORE_ELEMENTS = NULL;  GstRegistry *def;  GST_DEBUG ("getting elements for package %s", PACKAGE);  STATE_IGNORE_ELEMENTS = g_getenv ("GST_STATE_IGNORE_ELEMENTS");  if (!g_getenv ("GST_NO_STATE_IGNORE_ELEMENTS") && STATE_IGNORE_ELEMENTS) {    GST_DEBUG ("Will ignore element factories: '%s'", STATE_IGNORE_ELEMENTS);    ignorelist = g_strsplit (STATE_IGNORE_ELEMENTS, " ", 0);  }  def = gst_registry_get ();  plugins = gst_registry_get_plugin_list (def);  for (p = plugins; p; p = p->next) {    GstPlugin *plugin = p->data;    if (strcmp (gst_plugin_get_source (plugin), PACKAGE) != 0)      continue;    features =        gst_registry_get_feature_list_by_plugin (def,        gst_plugin_get_name (plugin));    for (f = features; f; f = f->next) {      GstPluginFeature *feature = f->data;      const gchar *name = gst_plugin_feature_get_name (feature);      gboolean ignore = FALSE;      if (!GST_IS_ELEMENT_FACTORY (feature))        continue;      if (ignorelist) {        gchar **s;        for (s = ignorelist; s && *s; ++s) {          if (g_str_has_prefix (name, *s)) {            GST_DEBUG ("ignoring element %s", name);            ignore = TRUE;          }        }        if (ignore)          continue;      }      GST_DEBUG ("adding element %s", name);      elements = g_list_prepend (elements, (gpointer) g_strdup (name));    }    gst_plugin_feature_list_free (features);  }  gst_plugin_list_free (plugins);  g_strfreev (ignorelist);}

/* Return TRUE if this is a Visualization element */static gboolean filter_vis_features(GstPluginFeature *feature, gpointer data) {  GstElementFactory *factory;  if (!GST_IS_ELEMENT_FACTORY(feature))    return FALSE;  factory = GST_ELEMENT_FACTORY(feature);  if (!g_strrstr(gst_element_factory_get_klass(factory), "Visualization"))    return FALSE;  return TRUE;}

/** * __gst_element_factory_add_interface: * @elementfactory: The elementfactory to add the interface to * @interfacename: Name of the interface * * Adds the given interfacename to the list of implemented interfaces of the * element. */void__gst_element_factory_add_interface (GstElementFactory * elementfactory,    const gchar * interfacename){  g_return_if_fail (GST_IS_ELEMENT_FACTORY (elementfactory));  g_return_if_fail (interfacename != NULL);  g_return_if_fail (interfacename[0] != '/0');  /* no empty string */  elementfactory->interfaces =      g_list_prepend (elementfactory->interfaces,      (gpointer) g_intern_string (interfacename));}

static gbooleanelement_filter (GstPluginFeature * feature, FilterData * data){  gboolean res;  /* we only care about element factories */  if (!GST_IS_ELEMENT_FACTORY (feature))    return FALSE;  res = gst_factory_list_is_type (GST_ELEMENT_FACTORY (feature), data->type);  return res;}

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 gbooleanelement_filter (GstPluginFeature * feature, FilterData * data){  gboolean res;  /* we only care about element factories */  if (G_UNLIKELY (!GST_IS_ELEMENT_FACTORY (feature)))    return FALSE;  res = (gst_plugin_feature_get_rank (feature) >= data->minrank) &&      gst_element_factory_list_is_type (GST_ELEMENT_FACTORY_CAST (feature),      data->type);  return res;}

/** * gst_element_factory_has_interface: * @factory: a #GstElementFactory * @interfacename: an interface name * * Check if @factory implements the interface with name @interfacename. * * Returns: #TRUE when @factory implement the interface. * * Since: 0.10.14 */gbooleangst_element_factory_has_interface (GstElementFactory * factory,    const gchar * interfacename){  GList *walk;  g_return_val_if_fail (GST_IS_ELEMENT_FACTORY (factory), FALSE);  for (walk = factory->interfaces; walk; walk = g_list_next (walk)) {    gchar *iname = (gchar *) walk->data;    if (!strcmp (iname, interfacename))      return TRUE;  }  return FALSE;}

static gboolean FactoryFilter(GstPluginFeature *aFeature, gpointer){  if (!GST_IS_ELEMENT_FACTORY(aFeature)) {    return FALSE;  }  // TODO _get_klass doesn't exist in 1.0  const gchar *className =    gst_element_factory_get_klass(GST_ELEMENT_FACTORY_CAST(aFeature));  if (!strstr(className, "Decoder") && !strstr(className, "Demux")) {    return FALSE;  }  return gst_plugin_feature_get_rank(aFeature) >= GST_RANK_MARGINAL;}

voiditerate_plugins (GHashTable *hashtable){    GList *plugins, *orig_plugins;    orig_plugins = plugins = gst_default_registry_get_plugin_list ();    while (plugins)     {        GList *features, *orig_features;        GstPlugin *plugin;        plugin = (GstPlugin *) (plugins->data);        plugins = g_list_next (plugins);        if (plugin->flags & GST_PLUGIN_FLAG_BLACKLISTED)         {            continue;        }        orig_features = features =            gst_registry_get_feature_list_by_plugin (gst_registry_get_default (),                                                     plugin->desc.name);        while (features)         {            GstPluginFeature *feature;            if (G_UNLIKELY (features->data == NULL))                goto next;            feature = GST_PLUGIN_FEATURE (features->data);            if (GST_IS_ELEMENT_FACTORY (feature))             {                GstElementFactory *factory;                factory = GST_ELEMENT_FACTORY (feature);                iterate_plugins_elements (factory, hashtable);            }            next:                features = g_list_next (features);        }        gst_plugin_feature_list_free (orig_features);    }    gst_plugin_list_free (orig_plugins);}

static gboolean FactoryFilter(GstPluginFeature *aFeature, gpointer){  if (!GST_IS_ELEMENT_FACTORY(aFeature)) {    return FALSE;  }  const gchar *className =    gst_element_factory_get_klass(GST_ELEMENT_FACTORY_CAST(aFeature));  if (!strstr(className, "Decoder") && !strstr(className, "Demux") &&      !strstr(className, "Parser")) {    return FALSE;  }  return    gst_plugin_feature_get_rank(aFeature) >= GST_RANK_MARGINAL &&    !GStreamerFormatHelper::IsPluginFeatureBlacklisted(aFeature);}

static gboolean FactoryFilter(GstPluginFeature *aFeature, gpointer){  if (!GST_IS_ELEMENT_FACTORY(aFeature)) {    return FALSE;  }  const gchar *className =    gst_element_factory_get_klass(GST_ELEMENT_FACTORY_CAST(aFeature));  // NB: We skip filtering parsers here, because adding them to  // the list can give false decoder positives to canPlayType().  if (!strstr(className, "Decoder") && !strstr(className, "Demux")) {    return FALSE;  }  return    gst_plugin_feature_get_rank(aFeature) >= GST_RANK_MARGINAL &&    !GStreamerFormatHelper::IsPluginFeatureBlocked(aFeature);}

static gbooleangst_auto_video_convert_element_filter (GstPluginFeature * feature,    GstAutoVideoConvert * autovideoconvert){  const gchar *klass;  /* we only care about element factories */  if (G_UNLIKELY (!GST_IS_ELEMENT_FACTORY (feature)))    return FALSE;  klass = gst_element_factory_get_metadata (GST_ELEMENT_FACTORY_CAST (feature),      GST_ELEMENT_METADATA_KLASS);  /* only select color space converter */  if (strstr (klass, "Filter") &&      strstr (klass, "Converter") && strstr (klass, "Video")) {    GST_DEBUG_OBJECT (autovideoconvert,        "gst_auto_video_convert_element_filter found %s/n",        gst_plugin_feature_get_name (GST_PLUGIN_FEATURE_CAST (feature)));    return TRUE;  }  return FALSE;}

static gbooleangst_rtsp_ext_list_filter (GstPluginFeature * feature, gpointer user_data){  GstElementFactory *factory;  guint rank;  /* we only care about element factories */  if (!GST_IS_ELEMENT_FACTORY (feature))    return FALSE;  factory = GST_ELEMENT_FACTORY (feature);  if (!gst_element_factory_has_interface (factory, "GstRTSPExtension"))    return FALSE;  /* only select elements with autoplugging rank */  rank = gst_plugin_feature_get_rank (feature);  if (rank < GST_RANK_MARGINAL)    return FALSE;  return TRUE;}

static gbooleangst_auto_video_src_factory_filter (GstPluginFeature * feature, gpointer data){  guint rank;  const gchar *klass;  /* we only care about element factories */  if (!GST_IS_ELEMENT_FACTORY (feature))    return FALSE;  /* video sources */  klass = gst_element_factory_get_klass (GST_ELEMENT_FACTORY (feature));  if (!(strstr (klass, "Source") && strstr (klass, "Video")))    return FALSE;  /* only select elements with autoplugging rank */  rank = gst_plugin_feature_get_rank (feature);  if (rank < GST_RANK_MARGINAL)    return FALSE;  return TRUE;}

/** * gst_element_factory_get_documentation_uri: * @factory: a #GstElementFactory * * Gets documentation uri for this factory if set. * * Since: 0.10.31 * * Returns: the documentation uri */const gchar *gst_element_factory_get_documentation_uri (GstElementFactory * factory){  g_return_val_if_fail (GST_IS_ELEMENT_FACTORY (factory), NULL);  return gst_element_factory_get_meta_data (factory, "doc-uri");}

static voidprint_all_uri_handlers (void){  GList *plugins, *p, *features, *f;  plugins = gst_registry_get_plugin_list (gst_registry_get ());  for (p = plugins; p; p = p->next) {    GstPlugin *plugin = (GstPlugin *) (p->data);    features =        gst_registry_get_feature_list_by_plugin (gst_registry_get (),        gst_plugin_get_name (plugin));    for (f = features; f; f = f->next) {      GstPluginFeature *feature = GST_PLUGIN_FEATURE (f->data);      if (GST_IS_ELEMENT_FACTORY (feature)) {        GstElementFactory *factory;        GstElement *element;        factory = GST_ELEMENT_FACTORY (gst_plugin_feature_load (feature));        if (!factory) {          g_print ("element plugin %s couldn't be loaded/n",              gst_plugin_get_name (plugin));          continue;        }        element = gst_element_factory_create (factory, NULL);        if (!element) {          g_print ("couldn't construct element for %s for some reason/n",              GST_OBJECT_NAME (factory));          gst_object_unref (factory);          continue;        }        if (GST_IS_URI_HANDLER (element)) {          const gchar *const *uri_protocols;          const gchar *dir;          gchar *joined;          switch (gst_uri_handler_get_uri_type (GST_URI_HANDLER (element))) {            case GST_URI_SRC:              dir = "read";              break;            case GST_URI_SINK:              dir = "write";              break;            default:              dir = "unknown";              break;          }          uri_protocols =              gst_uri_handler_get_protocols (GST_URI_HANDLER (element));          joined = g_strjoinv (", ", (gchar **) uri_protocols);          g_print ("%s (%s, rank %u): %s/n",              gst_plugin_feature_get_name (GST_PLUGIN_FEATURE (factory)), dir,              gst_plugin_feature_get_rank (GST_PLUGIN_FEATURE (factory)),              joined);          g_free (joined);        }        gst_object_unref (element);        gst_object_unref (factory);      }    }    gst_plugin_feature_list_free (features);  }  gst_plugin_list_free (plugins);}

static voidprint_plugin_features (GstPlugin * plugin){  GList *features, *origlist;  gint num_features = 0;  gint num_elements = 0;  gint num_tracers = 0;  gint num_typefinders = 0;  gint num_devproviders = 0;  gint num_other = 0;  origlist = features =      gst_registry_get_feature_list_by_plugin (gst_registry_get (),      gst_plugin_get_name (plugin));  while (features) {    GstPluginFeature *feature;    feature = GST_PLUGIN_FEATURE (features->data);    if (GST_IS_ELEMENT_FACTORY (feature)) {      GstElementFactory *factory;      factory = GST_ELEMENT_FACTORY (feature);      n_print ("  %s: %s/n", GST_OBJECT_NAME (factory),          gst_element_factory_get_metadata (factory,              GST_ELEMENT_METADATA_LONGNAME));      num_elements++;    } else if (GST_IS_TYPE_FIND_FACTORY (feature)) {      GstTypeFindFactory *factory;      const gchar *const *extensions;      factory = GST_TYPE_FIND_FACTORY (feature);      extensions = gst_type_find_factory_get_extensions (factory);      if (extensions) {        guint i = 0;        g_print ("  %s: %s: ", gst_plugin_get_name (plugin),            gst_plugin_feature_get_name (feature));        while (extensions[i]) {          g_print ("%s%s", i > 0 ? ", " : "", extensions[i]);          i++;        }        g_print ("/n");      } else        g_print ("  %s: %s: no extensions/n", gst_plugin_get_name (plugin),            gst_plugin_feature_get_name (feature));      num_typefinders++;    } else if (GST_IS_DEVICE_PROVIDER_FACTORY (feature)) {      GstDeviceProviderFactory *factory;      factory = GST_DEVICE_PROVIDER_FACTORY (feature);      n_print ("  %s: %s/n", GST_OBJECT_NAME (factory),          gst_device_provider_factory_get_metadata (factory,              GST_ELEMENT_METADATA_LONGNAME));      num_devproviders++;    } else if (GST_IS_TRACER_FACTORY (feature)) {      n_print ("  %s (%s)/n", gst_object_get_name (GST_OBJECT (feature)),          g_type_name (G_OBJECT_TYPE (feature)));      num_tracers++;    } else if (feature) {      n_print ("  %s (%s)/n", gst_object_get_name (GST_OBJECT (feature)),          g_type_name (G_OBJECT_TYPE (feature)));      num_other++;    }    num_features++;    features = g_list_next (features);  }  gst_plugin_feature_list_free (origlist);  n_print ("/n");  n_print ("  %d features:/n", num_features);  if (num_elements > 0)    n_print ("  +-- %d elements/n", num_elements);  if (num_typefinders > 0)    n_print ("  +-- %d typefinders/n", num_typefinders);  if (num_devproviders > 0)    n_print ("  +-- %d device providers/n", num_devproviders);  if (num_tracers > 0)    n_print ("  +-- %d tracers/n", num_tracers);  if (num_other > 0)    n_print ("  +-- %d other objects/n", num_other);  n_print ("/n");}

static voidprint_element_list (gboolean print_all){  int plugincount = 0, featurecount = 0, blacklistcount = 0;  GList *plugins, *orig_plugins;  orig_plugins = plugins = gst_registry_get_plugin_list (gst_registry_get ());  while (plugins) {    GList *features, *orig_features;    GstPlugin *plugin;    plugin = (GstPlugin *) (plugins->data);    plugins = g_list_next (plugins);    plugincount++;    if (GST_OBJECT_FLAG_IS_SET (plugin, GST_PLUGIN_FLAG_BLACKLISTED)) {      blacklistcount++;      continue;    }    orig_features = features =        gst_registry_get_feature_list_by_plugin (gst_registry_get (),        gst_plugin_get_name (plugin));    while (features) {      GstPluginFeature *feature;      if (G_UNLIKELY (features->data == NULL))        goto next;      feature = GST_PLUGIN_FEATURE (features->data);      featurecount++;      if (GST_IS_ELEMENT_FACTORY (feature)) {        GstElementFactory *factory;        factory = GST_ELEMENT_FACTORY (feature);        if (print_all)          print_element_info (factory, TRUE);        else          g_print ("%s:  %s: %s/n", gst_plugin_get_name (plugin),              GST_OBJECT_NAME (factory),              gst_element_factory_get_metadata (factory,                  GST_ELEMENT_METADATA_LONGNAME));      } else if (GST_IS_TYPE_FIND_FACTORY (feature)) {        GstTypeFindFactory *factory;        const gchar *const *extensions;        factory = GST_TYPE_FIND_FACTORY (feature);        if (!print_all)          g_print ("%s: %s: ", gst_plugin_get_name (plugin),              gst_plugin_feature_get_name (feature));        extensions = gst_type_find_factory_get_extensions (factory);        if (extensions != NULL) {          guint i = 0;          while (extensions[i]) {            if (!print_all)              g_print ("%s%s", i > 0 ? ", " : "", extensions[i]);            i++;          }          if (!print_all)            g_print ("/n");        } else {          if (!print_all)            g_print ("no extensions/n");        }      } else {        if (!print_all)          n_print ("%s:  %s (%s)/n", gst_plugin_get_name (plugin),              GST_OBJECT_NAME (feature), g_type_name (G_OBJECT_TYPE (feature)));      }    next:      features = g_list_next (features);    }    gst_plugin_feature_list_free (orig_features);  }  gst_plugin_list_free (orig_plugins);  g_print ("/n");  g_print (_("Total count: "));  g_print (ngettext ("%d plugin", "%d plugins", plugincount), plugincount);  if (blacklistcount) {    g_print (" (");    g_print (ngettext ("%d blacklist entry", "%d blacklist entries",            blacklistcount), blacklistcount);    g_print (" not shown)");  }  g_print (", ");  g_print (ngettext ("%d feature", "%d features", featurecount), featurecount);  g_print ("/n");}

static gbooleanrsndec_factory_filter (GstPluginFeature * feature, RsnDecFactoryFilterCtx * ctx){  GstElementFactory *factory;  guint rank;  const gchar *klass;  const GList *templates;  GList *walk;  gboolean can_sink = FALSE;  /* we only care about element factories */  if (!GST_IS_ELEMENT_FACTORY (feature))    return FALSE;  factory = GST_ELEMENT_FACTORY (feature);  klass = gst_element_factory_get_klass (factory);  /* only decoders can play */  if (strstr (klass, "Decoder") == NULL)    return FALSE;  /* only select elements with autoplugging rank */  rank = gst_plugin_feature_get_rank (feature);  if (rank < GST_RANK_MARGINAL)    return FALSE;  /* See if the element has a sink pad that can possibly sink this caps */  /* get the templates from the element factory */  templates = gst_element_factory_get_static_pad_templates (factory);  for (walk = (GList *) templates; walk && !can_sink; walk = g_list_next (walk)) {    GstStaticPadTemplate *templ = walk->data;    /* we only care about the sink templates */    if (templ->direction == GST_PAD_SINK) {      GstCaps *intersect;      GstCaps *tmpl_caps;      /* try to intersect the caps with the caps of the template */      tmpl_caps = gst_static_caps_get (&templ->static_caps);      intersect = gst_caps_intersect (ctx->desired_caps, tmpl_caps);      gst_caps_unref (tmpl_caps);      /* check if the intersection is empty */      if (!gst_caps_is_empty (intersect)) {        /* non empty intersection, we can use this element */        can_sink = TRUE;        ctx->decoder_caps = gst_caps_merge (ctx->decoder_caps, intersect);      } else        gst_caps_unref (intersect);    }  }  if (can_sink) {    GST_DEBUG ("Found decoder element %s (%s)",        gst_element_factory_get_longname (factory),        gst_plugin_feature_get_name (feature));  }  return can_sink;}

/** * gst_element_factory_get_icon_name: * @factory: a #GstElementFactory * * Gets icon name for this factory if set. * * Since: 0.10.31 * * Returns: the icon name */const gchar *gst_element_factory_get_icon_name (GstElementFactory * factory){  g_return_val_if_fail (GST_IS_ELEMENT_FACTORY (factory), NULL);  return gst_element_factory_get_meta_data (factory, "icon-name");}