gst/gsttypefindfactory.c

   1 /* GStreamer
   2  * Copyright (C) 2003 Benjamin Otte <in7y118@public.uni-hamburg.de>
   3  *
   4  * gsttypefindfactory.c: typefinding subsystem
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public
  17  * License along with this library; if not, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  */
  21
  22 /**
  23  * SECTION:gsttypefindfactory
  24  * @short_description: Information about registered typefind functions
  25  *
  26  * These functions allow querying informations about registered typefind
  27  * functions. How to create and register these functions is described in
  28  * the section <link linkend="gstreamer-Writing-typefind-functions">
  29  * "Writing typefind functions"</link>.
  30  *
  31  * <example>
  32  *   <title>how to write a simple typefinder</title>
  33  *   <programlisting>
  34  *   typedef struct {
  35  *     guint8 *data;
  36  *     guint size;
  37  *     guint probability;
  38  *     GstCaps *data;
  39  *   } MyTypeFind;
  40  *   static void
  41  *   my_peek (gpointer data, gint64 offset, guint size)
  42  *   {
  43  *     MyTypeFind *find = (MyTypeFind *) data;
  44  *     if (offset &gt;= 0 &amp;&amp; offset + size &lt;= find->size) {
  45  *       return find->data + offset;
  46  *     }
  47  *     return NULL;
  48  *   }
  49  *   static void
  50  *   my_suggest (gpointer data, guint probability, GstCaps *caps)
  51  *   {
  52  *     MyTypeFind *find = (MyTypeFind *) data;
  53  *     if (probability &gt; find->probability) {
  54  *       find->probability = probability;
  55  *       gst_caps_replace (&amp;find->caps, caps);
  56  *     }
  57  *   }
  58  *   static GstCaps *
  59  *   find_type (guint8 *data, guint size)
  60  *   {
  61  *     GList *walk, *type_list;
  62  *     MyTypeFind find = {data, size, 0, NULL};
  63  *     GstTypeFind gst_find = {my_peek, my_suggest, &amp;find, };
  64  *     walk = type_list = gst_type_find_factory_get_list ();
  65  *     while (walk) {
  66  *       GstTypeFindFactory *factory = GST_TYPE_FIND_FACTORY (walk->data);
  67  *       walk = g_list_next (walk)
  68  *       gst_type_find_factory_call_function (factory, &amp;gst_find);
  69  *     }
  70  *     g_list_free (type_list);
  71  *     return find.caps;
  72  *   };
  73  *   </programlisting>
  74  * </example>
  75  *
  76  * The above example shows how to write a very simple typefinder that
  77  * identifies the given data. You can get quite a bit more complicated than
  78  * that though.
  79  *
  80  * Last reviewed on 2005-11-09 (0.9.4)
  81  */
  82
  83 #include "gst_private.h"
  84 #include "gstinfo.h"
  85 #include "gsttypefind.h"
  86 #include "gsttypefindfactory.h"
  87 #include "gstregistry.h"
  88
  89 GST_DEBUG_CATEGORY (type_find_debug);
  90 #define GST_CAT_DEFAULT type_find_debug
  91
  92 static void gst_type_find_factory_class_init (gpointer g_class,
  93     gpointer class_data);
  94 static void gst_type_find_factory_init (GTypeInstance * instance,
  95     gpointer g_class);
  96 static void gst_type_find_factory_dispose (GObject * object);
  97
  98 static GstPluginFeatureClass *parent_class = NULL;
  99
 100 GType
 101 gst_type_find_factory_get_type (void)
 102 {
 103   static GType typefind_type = 0;
 104
 105   if (G_UNLIKELY (typefind_type == 0)) {
 106     static const GTypeInfo typefind_info = {
 107       sizeof (GstTypeFindFactoryClass),
 108       NULL,
 109       NULL,
 110       gst_type_find_factory_class_init,
 111       NULL,
 112       NULL,
 113       sizeof (GstTypeFindFactory),
 114       0,
 115       gst_type_find_factory_init,
 116       NULL
 117     };
 118
 119     typefind_type = g_type_register_static (GST_TYPE_PLUGIN_FEATURE,
 120         "GstTypeFindFactory", &typefind_info, 0);
 121     GST_DEBUG_CATEGORY_INIT (type_find_debug, "GST_TYPEFIND",
 122         GST_DEBUG_FG_GREEN, "typefinding subsystem");
 123   }
 124
 125   return typefind_type;
 126 }
 127
 128 static void
 129 gst_type_find_factory_class_init (gpointer g_class, gpointer class_data)
 130 {
 131   GObjectClass *object_class = G_OBJECT_CLASS (g_class);
 132
 133   parent_class = g_type_class_peek_parent (g_class);
 134
 135   object_class->dispose = gst_type_find_factory_dispose;
 136 }
 137
 138 static void
 139 gst_type_find_factory_init (GTypeInstance * instance, gpointer g_class)
 140 {
 141   GstTypeFindFactory *factory = GST_TYPE_FIND_FACTORY (instance);
 142
 143   factory->user_data = factory;
 144   factory->user_data_notify = NULL;
 145 }
 146
 147 static void
 148 gst_type_find_factory_dispose (GObject * object)
 149 {
 150   GstTypeFindFactory *factory = GST_TYPE_FIND_FACTORY (object);
 151
 152   if (factory->caps) {
 153     gst_caps_unref (factory->caps);
 154     factory->caps = NULL;
 155   }
 156   if (factory->extensions) {
 157     g_strfreev (factory->extensions);
 158     factory->extensions = NULL;
 159   }
 160   if (factory->user_data_notify && factory->user_data) {
 161     factory->user_data_notify (factory->user_data);
 162     factory->user_data = NULL;
 163   }
 164
 165   G_OBJECT_CLASS (parent_class)->dispose (object);
 166 }
 167
 168 /**
 169  * gst_type_find_factory_get_list:
 170  *
 171  * Gets the list of all registered typefind factories. You must free the
 172  * list using gst_plugin_feature_list_free.
 173  *
 174  * Returns: the list of all registered #GstTypeFindFactory.
 175  */
 176 GList *
 177 gst_type_find_factory_get_list (void)
 178 {
 179   return gst_registry_get_feature_list (gst_registry_get_default (),
 180       GST_TYPE_TYPE_FIND_FACTORY);
 181 }
 182
 183 /**
 184  * gst_type_find_factory_get_caps:
 185  * @factory: A #GstTypeFindFactory
 186  *
 187  * Gets the #GstCaps associated with a typefind factory.
 188  *
 189  * Returns: The #GstCaps associated with this factory
 190  */
 191 GstCaps *
 192 gst_type_find_factory_get_caps (GstTypeFindFactory * factory)
 193 {
 194   g_return_val_if_fail (GST_IS_TYPE_FIND_FACTORY (factory), NULL);
 195
 196   return factory->caps;
 197 }
 198
 199 /**
 200  * gst_type_find_factory_get_extensions:
 201  * @factory: A #GstTypeFindFactory
 202  *
 203  * Gets the extensions associated with a #GstTypeFindFactory. The returned
 204  * array should not be changed. If you need to change stuff in it, you should
 205  * copy it using g_stdupv().  This function may return NULL to indicate
 206  * a 0-length list.
 207  *
 208  * Returns: a NULL-terminated array of extensions associated with this factory
 209  */
 210 gchar **
 211 gst_type_find_factory_get_extensions (GstTypeFindFactory * factory)
 212 {
 213   g_return_val_if_fail (GST_IS_TYPE_FIND_FACTORY (factory), NULL);
 214
 215   return factory->extensions;
 216 }
 217
 218 /**
 219  * gst_type_find_factory_call_function:
 220  * @factory: A #GstTypeFindFactory
 221  * @find: A properly setup #GstTypeFind entry. The get_data and suggest_type
 222  *        members must be set.
 223  *
 224  * Calls the #GstTypeFindFunction associated with this factory.
 225  */
 226 void
 227 gst_type_find_factory_call_function (GstTypeFindFactory * factory,
 228     GstTypeFind * find)
 229 {
 230   GstTypeFindFactory *new_factory;
 231
 232   g_return_if_fail (GST_IS_TYPE_FIND_FACTORY (factory));
 233   g_return_if_fail (find != NULL);
 234   g_return_if_fail (find->peek != NULL);
 235   g_return_if_fail (find->suggest != NULL);
 236
 237   new_factory =
 238       GST_TYPE_FIND_FACTORY (gst_plugin_feature_load (GST_PLUGIN_FEATURE
 239           (factory)));
 240   if (new_factory) {
 241     if (new_factory->function)
 242       new_factory->function (find, new_factory->user_data);
 243     gst_object_unref (new_factory);
 244   }
 245 }