:right-sidebar: True

TypeFindFactory
===================================================================

.. currentmodule:: gi.repository.Gst





.. class:: TypeFindFactory(**properties: ~typing.Any)
   :no-contents-entry:


Superclasses: :class:`~gi.repository.Gst.PluginFeature`, :class:`~gi.repository.Gst.Object`, :class:`~gi.repository.GObject.InitiallyUnowned`, :class:`~gi.repository.GObject.Object`





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.


.. code-block:: C
    :dedent:

      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;
      };




Methods
-------

.. rst-class:: interim-class

.. class:: TypeFindFactory
   :no-index:


   .. method:: call_function(find: ~gi.repository.Gst.TypeFind) -> None

      Calls the :obj:`~gi.repository.Gst.TypeFindFunction` associated with this factory.






      :param find: a properly setup :obj:`~gi.repository.Gst.TypeFind` entry. The get_data
             and suggest_type members must be set.




   .. method:: get_caps() -> ~gi.repository.Gst.Caps | None

      Gets the :obj:`~gi.repository.Gst.Caps` associated with a typefind factory.









   .. method:: get_extensions() -> list[str] | None

      Gets the extensions associated with a :obj:`~gi.repository.Gst.TypeFindFactory`\. The returned
      array should not be changed. If you need to change stuff in it, you should
      copy it using :func:`~gi.repository.GLib.strdupv`.  This function may return :const:`None` to indicate
      a 0-length list.









   .. classmethod:: get_list() -> list[~gi.repository.Gst.TypeFindFactory]

      Gets the list of all registered typefind factories. You must free the
      list using :func:`~gi.repository.Gst.PluginFeature.list_free`.

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

      Free-function: gst_plugin_feature_list_free









   .. method:: has_function() -> bool

      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.