TypeFindFactory

These functions allow querying information about registered typefind functions. How to create and register these functions is described in the section <link linkend="gstreamer-Writing-typefind-functions"> "Writing typefind functions"</link>.

The following example shows how to write a very simple typefinder that identifies the given data. You can get quite a bit more complicated than that though.

typedef struct {
  guint8 *data;
  guint size;
  guint probability;
  GstCaps *data;
} MyTypeFind;
static void
my_peek (gpointer data, gint64 offset, guint size)
{
  MyTypeFind *find = (MyTypeFind *) data;
  if (offset >= 0 && offset + size <= find->size) {
    return find->data + offset;
  }
  return NULL;
}
static void
my_suggest (gpointer data, guint probability, GstCaps *caps)
{
  MyTypeFind *find = (MyTypeFind *) data;
  if (probability > find->probability) {
    find->probability = probability;
    gst_caps_replace (&find->caps, caps);
  }
}
static GstCaps *
find_type (guint8 *data, guint size)
{
  GList *walk, *type_list;
  MyTypeFind find = {data, size, 0, NULL};
  GstTypeFind gst_find = {my_peek, my_suggest, &find, };
  walk = type_list = gst_type_find_factory_get_list ();
  while (walk) {
    GstTypeFindFactory *factory = GST_TYPE_FIND_FACTORY (walk->data);
    walk = g_list_next (walk)
    gst_type_find_factory_call_function (factory, &gst_find);
  }
  g_list_free (type_list);
  return find.caps;
};

Members

Functions

callFunction
void callFunction(gst.type_find.TypeFind find)

Calls the #GstTypeFindFunction associated with this factory.

getCaps
gst.caps.Caps getCaps()

Gets the #GstCaps associated with a typefind factory.

getExtensions
string[] getExtensions()

Gets the extensions associated with a #GstTypeFindFactory. The returned array should not be changed. If you need to change stuff in it, you should copy it using glib.global.strdupv. This function may return null to indicate a 0-length list.

hasFunction
bool hasFunction()

Check whether the factory has a typefind function. Typefind factories without typefind functions are a last-effort fallback mechanism to e.g. assume a certain media type based on the file extension.

Static functions

getList
gst.type_find_factory.TypeFindFactory[] getList()

Gets the list of all registered typefind factories. You must free the list using gst.plugin_feature.PluginFeature.listFree.

Inherited Members

From PluginFeature

listCopy
gst.plugin_feature.PluginFeature[] listCopy(gst.plugin_feature.PluginFeature[] list)

Copies the list of features. Caller should call gst_plugin_feature_list_free when done with the list.

listDebug
void listDebug(gst.plugin_feature.PluginFeature[] list)

Debug the plugin feature names in list.

rankCompareFunc
int rankCompareFunc(const(void)* p1, const(void)* p2)

Compares the two given #GstPluginFeature instances. This function can be used as a #GCompareFunc when sorting by rank and then by name.

checkVersion
bool checkVersion(uint minMajor, uint minMinor, uint minMicro)

Checks whether the given plugin feature is at least the required version.

getPlugin
gst.plugin.Plugin getPlugin()

Get the plugin that provides this feature.

getPluginName
string getPluginName()

Get the name of the plugin that provides this feature.

getRank
uint getRank()

Gets the rank of a plugin feature.

load
gst.plugin_feature.PluginFeature load()

Loads the plugin containing feature if it's not already loaded. feature is unaffected; use the return value instead.

setRank
void setRank(uint rank)

Specifies a rank for a plugin feature, so that autoplugging uses the most appropriate feature.