## GstTypeFindFactory

GstTypeFindFactory — information about registered typefind functions

## Synopsis

    struct      GstTypeFindFactory;
    #define     GST_TYPE_TYPE_FIND_FACTORY
    GList*      gst_type_find_factory_get_list  (void);
    gchar**     gst_type_find_factory_get_extensions
                                                (const GstTypeFindFactory *factory);
    const GstCaps* gst_type_find_factory_get_caps
                                                (const GstTypeFindFactory *factory);
    void        gst_type_find_factory_call_function
                                                (const GstTypeFindFactory *factory,
                                                 GstTypeFind *find);

## Object Hierarchy

      GObject
       +----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 7. how to write a simple typefinder

      /* FIXME: compile this? ;) */
      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.

## Details

### struct GstTypeFindFactory

    struct GstTypeFindFactory;

Object that stores information about a typefind function

### GST_TYPE_TYPE_FIND_FACTORY

    #define GST_TYPE_TYPE_FIND_FACTORY                 (gst_type_find_factory_get_type())

### 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 g_list_free.

Returns : | the list of all registered typefind factories

### gst_type_find_factory_get_extensions ()

    gchar**     gst_type_find_factory_get_extensions
                                                (const GstTypeFindFactory *factory);

Gets the extensions associated with a typefind factory. The returned array should not be changed. If you need to change stuff in it, you should copy it using `g_stdupv()`. This function may return NULL to indicate a 0-length list.

`factory` : | a factory
Returns : | a NULL-terminated array of extensions associated with this factory

### gst_type_find_factory_get_caps ()

    const GstCaps* gst_type_find_factory_get_caps
                                                (const GstTypeFindFactory *factory);

Gets the caps associated with a typefind factory.

`factory` : | a factory
Returns : | the GstCaps associated with this factory

### gst_type_find_factory_call_function ()

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

Calls the typefinding function associated with this factory.

`factory` : | a factory
`find` : | a properly setup GstTypeFind entry. The get_data and suggest_type members must be set.

## See Also

Writing typefind functions