GstTypeFindFactory

GstTypeFindFactory — information about registered typefind functions

Synopsis


#include <gst/gst.h>


struct      GstTypeFindFactory;
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_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