## GstTypeFindFactory GstTypeFindFactory — Information about registered typefind functions |

## Synopsis

    #include <gst/gst.h>

                        GstTypeFindFactory;
    GList *             gst_type_find_factory_get_list      (void);
    const gchar * const * gst_type_find_factory_get_extensions
                                                            (GstTypeFindFactory *factory);
    GstCaps *           gst_type_find_factory_get_caps      (GstTypeFindFactory *factory);
    gboolean            gst_type_find_factory_has_function  (GstTypeFindFactory *factory);
    void                gst_type_find_factory_call_function (GstTypeFindFactory *factory,
                                                             GstTypeFind *find);

## Object Hierarchy

      GObject
       +----GInitiallyUnowned
             +----GstObject
                   +----GstPluginFeature
                         +----GstTypeFindFactory

## Description

These functions allow querying informations about registered typefind functions. How to create and register these functions is described in the section "Writing typefind functions".

Example 13. how to write a simple typefinder

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    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;
    };

The above 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.

Last reviewed on 2005-11-09 (0.9.4)

## Details

### GstTypeFindFactory

    typedef struct _GstTypeFindFactory GstTypeFindFactory;

Opaque object that stores information about a typefind function.

### gst_type_find_factory_get_list ()

    GList *             gst_type_find_factory_get_list      (void);

Gets the list of all registered typefind factories. You must free the list using `gst_plugin_feature_list_free()`.

The returned factories are sorted by highest rank first, and then by factory name.

Free-function: gst_plugin_feature_list_free

Returns : | the list of all registered GstTypeFindFactory. [transfer full][element-type Gst.TypeFindFactory]

### gst_type_find_factory_get_extensions ()

    const gchar * const * gst_type_find_factory_get_extensions
                                                            (GstTypeFindFactory *factory);

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 `g_strdupv()`. This function may return NULL to indicate a 0-length list.

`factory` : | A GstTypeFindFactory
Returns : | a NULL-terminated array of extensions associated with this factory. [transfer none][array zero-terminated=1][element-type utf8]

### gst_type_find_factory_get_caps ()

    GstCaps *           gst_type_find_factory_get_caps      (GstTypeFindFactory *factory);

Gets the GstCaps associated with a typefind factory.

`factory` : | A GstTypeFindFactory
Returns : | the GstCaps associated with this factory. [transfer none]

### gst_type_find_factory_has_function ()

    gboolean            gst_type_find_factory_has_function  (GstTypeFindFactory *factory);

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.

`factory` : | A GstTypeFindFactory
Returns : | TRUE if the factory has a typefind functions set, otherwise FALSE

### gst_type_find_factory_call_function ()

    void                gst_type_find_factory_call_function (GstTypeFindFactory *factory,
                                                             GstTypeFind *find);

Calls the GstTypeFindFunction associated with this factory.

`factory` : | A GstTypeFindFactory
`find` : | a properly setup GstTypeFind entry. The get_data and suggest_type members must be set. [transfer none]