---

xlv_plugin_mgr.h

Go to the documentation of this file.

/*
 * xlv_plugin_mgr.h
 *
 * Copyright (C) 2001 Guilhem Lavaux
 *
 * This file is part of XLV, a free middleware audio-video stream coder/decoder.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * XLV is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifndef _XLV_PLUGIN_MGR_H
#define _XLV_PLUGIN_MGR_H

#include <glib.h>

#define xlv_fourcc(a,b,c,d) ( ((guint32)(a)) | ((guint32)(b)) << 8 | ((guint32)(c)) << 16 | ((guint32)(d)) << 24)

#define XLV_STREAM_OK           0

#define XLV_STREAM_EOF          1

#define XLV_STREAM_ERRIO        2

#define XLV_STREAM_UNSUPPORTED  3

#define XLV_STREAM_INVAL        4

#define XLV_STREAM_NOMEM        5

#define XLV_PLUGIN_NONE           0

#define XLV_PLUGIN_AUDIO_RENDERER 1

#define XLV_PLUGIN_VIDEO_RENDERER 2

#define XLV_PLUGIN_AUDIO_CODEC    3

#define XLV_PLUGIN_VIDEO_CODEC    4

#define XLV_PLUGIN_INPUT_STREAM   5

#define XLV_PLUGIN_SYSTEM         6

#define XLV_PLUGIN_SYSENC         7

#define XLV_PLUGIN_GLUE           8
/* @} */

#define XLV_PLUGIN_GET_CAPS         0

#define XLV_PLUGIN_GET_OPTIONS_LIST 1

#define XLV_PLUGIN_GET_OPTION       2

#define XLV_PLUGIN_SET_OPTION       3

#define XLV_PLUGIN_OPTION_UINT8       0

#define XLV_PLUGIN_OPTION_UINT16      1

#define XLV_PLUGIN_OPTION_UINT32      2

#define XLV_PLUGIN_OPTION_STRING      3

#define XLV_PLUGIN_OPTION_CHOOSEONE    4

#define XLV_PLUGIN_OPTION_CHOOSEMULTI  5

#define XLV_PLUGIN_OPTION_GROUP       6

#define XLV_PLUGIN_OPTION_BOOL        7

typedef struct _XLV_PluginGetOption {
    const gchar *m_option_name;
    guint8 m_option_type;
    guint16 m_option_id;

    /* @brief This is a subtree: it is needed if this option is a container */
    struct _XLV_PluginOptionsList *m_option_subtree;
} XLV_PluginGetOption;

typedef struct _XLV_PluginOption {
    guint16 m_option_id;
    union {
        guint8 u8;
        guint16 u16;
        guint32 u32;
        gchar *string;
    } data;
} XLV_PluginOption;

typedef struct _XLV_PluginOptionsList {
    guint16 m_options_len;
    XLV_PluginGetOption *m_options;
} XLV_PluginOptionsList;

#define XLV_STREAM_RESET           10

#define XLV_STREAM_SEEK            11

#define XLV_STREAM_SKIP            12

#define XLV_STREAM_TELL            13

#define XLV_STREAM_SIZE            14

#define XLV_STREAM_ENABLE_CACHE    15

#define XLV_STREAM_DISABLE_CACHE   16

typedef struct _XLV_Data {
    gpointer m_data;
    guint32 m_length;
    gboolean m_flags;
} XLV_Data;

#define XLV_DATA_UNKNOWN   0x0000

#define XLV_DATA_KEY_FRAME 0x0001

#define XLV_DATA_TIMESTAMP 0x0002

#define XLV_DATA_NO_DATA   0x0004

#define XLV_DATA_NULL_DATA 0x0008

#define XLV_PLUGIN_PREALLOC_CAPABLE 0x01

#define XLV_PLUGIN_WRITABLE         0x02

#define XLV_PLUGIN_READABLE         0x04

#define XLV_PLUGIN_DECODER          0x08

#define XLV_PLUGIN_ENCODER          0x10

#define XLV_PLUGIN_CONFIGURABLE     0x20

#define XLV_PLUGIN_SEEKABLE         0x40

#define XLV_PLUGIN_CODEC_CONFIG     0x80

/* Adaptor specific */
#define XLV_ADAPTOR_SET_REQUIRED   500

#define XLV_READ_ONLY  0

#define XLV_WRITE_ONLY 1

#define XLV_RDWR       2

typedef struct _XLV_GUID {
        guint32 m_v1;
        guint16 m_v2;
        guint16 m_v3;
        guint8 m_v4[8];
} XLV_GUID;

#define XLV_NULL_GUID {0, 0, 0, {0,0,0,0, 0,0,0,0}}

typedef struct _XLV_Stream XLV_Stream;

#ifdef XLV_INTERNAL 

struct _XLV_PluginMgr {
    GList *m_plugins;
    GList *m_modules;
    guint m_last_id;
    gboolean m_can_load;
    GList *m_paths;
    GAllocator *m_allocator;
    GHashTable *m_namehash;
};
#endif

typedef struct _XLV_PluginMgr XLV_PluginMgr;

/* Plugin structures/descriptions */

typedef struct _XLV_PluginStream XLV_PluginStream;

struct _XLV_PluginStream {
    guint m_error;
    guint8 m_mode;
};

typedef struct _XLV_Plugin XLV_Plugin;
typedef struct _XLV_Module XLV_Module;

typedef XLV_PluginStream *(*XLV_OpenPlugin) (XLV_Stream * in_stream,
                                             gpointer plugdata);
typedef XLV_PluginStream *(*XLV_OpenStream) (const gchar * name, guint mode,
                                             gpointer plugdata);
typedef void (*XLV_ClosePlugin) (XLV_PluginStream * stream);
typedef gint (*XLV_Ioctl) (XLV_PluginStream * stream, guint cmd,
                           gpointer param);
typedef guint32 (*XLV_ReadData) (XLV_PluginStream * stream, gpointer data,
                                 guint32 len);
typedef guint32 (*XLV_WriteData) (XLV_PluginStream * stream, gpointer data,
                                  guint32 len);
typedef void (*XLV_ReleasePlugin) (XLV_Plugin * plug);

typedef gboolean (*XLV_PluginInitializer) (XLV_PluginMgr * mgr,
                                           XLV_Module * module);

struct _XLV_Plugin {
    const gchar *m_name;
    const gchar *m_idname;
    guint16 m_version;
    guint16 m_type;
    gpointer m_plugdata;

    XLV_OpenPlugin f_open;
    XLV_OpenStream f_openStream;
    XLV_ClosePlugin f_close;
    XLV_Ioctl f_ioctl;
    XLV_ReadData f_readData;
    XLV_WriteData f_writeData;
    XLV_ReleasePlugin f_release;

    guint16 m_interface_release;

    XLV_GUID m_plugin_guid;

    XLV_PluginMgr *m_manager;
    guint16 m_refcounter;
};


struct _XLV_Stream {
    XLV_Plugin *m_plugin;
    XLV_PluginStream *m_stream;
};

typedef struct _XLV_StreamBuilder {
    guint8 m_id;
    XLV_Stream *m_stream;
} XLV_StreamBuilder;

#ifdef XLV_INTERNAL
#include <gmodule.h>

struct _XLV_Module {
    GModule *m_module;
    gchar *m_module_name;
    gchar *m_module_path;
    GList *m_plugins;
    XLV_PluginMgr *m_plugin_mgr;
    GList *m_depends;

    guint16 m_opened_plugins;
    gboolean m_loaded:1;
    gboolean m_recall:1;
};

typedef struct _XLV_PluginInternal {
    XLV_Plugin m_plugin_desc;
    guint m_id;
    XLV_Module *m_module;
    GList *m_depends_on;
    gboolean m_valid:1;
    gboolean m_free_idname:1;
    gboolean m_pre_valid:1;
    gboolean m_unload_locked:1;
} XLV_PluginInternal;
#endif

#define XLV_CLOSE(s) ((s)->m_plugin->f_close((s)->m_stream))
#define XLV_IOCTL(s, cmd, len) ( ((s)->m_plugin->f_ioctl != NULL) ? ((s)->m_plugin->f_ioctl((s)->m_stream, cmd, len)) : -1 )
#define XLV_READ(s, b, len)  xlv_read((s), (b), (len))
#define XLV_WRITE(s, b, len) xlv_write((s), (b), (len))

#define xlv_plugin_add(mgr, plug) xlv_plugin_package_add(mgr, NULL, plug)

/* Interfaces */

#ifdef __cplusplus
extern "C" {
#endif

    XLV_PluginMgr *xlv_plugin_mgr_new ();
    void xlv_plugin_mgr_cleanup (XLV_PluginMgr * mgr);

    void xlv_plugin_add_path (XLV_PluginMgr * mgr, const gchar * path);
    void xlv_plugin_load_all (XLV_PluginMgr * mgr, gboolean with_registered);

    gint xlv_plugin_load (XLV_PluginMgr * mgr, const gchar * name);

    gboolean xlv_plugin_load_registered (XLV_Plugin * plugin);

    void xlv_plugin_invalidate (XLV_Plugin * plugin);

    gboolean xlv_plugin_unregister (XLV_Plugin * plugin);

    gint xlv_plugin_package_add (XLV_PluginMgr * mgr, XLV_Module * module,
                                 XLV_Plugin * plugin);

    gint xlv_plugin_add_module (XLV_PluginMgr * mgr, const gchar * module,
                                const gchar * idname, guint32 plugin_type);


    gboolean xlv_plugin_add_dep (XLV_Plugin * plugin, XLV_Plugin * dep);

    gboolean xlv_plugin_add_named_dep (XLV_Plugin * plugin, const gchar *dep);

    guint xlv_get_number_of_plugins (XLV_PluginMgr * mgr);

    XLV_Plugin *xlv_plugin_get_from_id (XLV_PluginMgr * mgr, guint id);

    XLV_Plugin *xlv_plugin_get_from_idname (XLV_PluginMgr * mgr,
                                            const gchar * idname);

    XLV_Plugin *xlv_plugin_get_from_guid (XLV_PluginMgr * mgr, XLV_GUID *guid);

    GList *xlv_plugin_iterate (XLV_PluginMgr * mgr);

    void xlv_plugin_set_unused (XLV_Plugin * plugin);

    gboolean xlv_plugin_is_loaded (XLV_Plugin * plugin);


#ifdef __cplusplus
}
#endif

static inline XLV_Stream *
xlv_open (XLV_Plugin * plug, XLV_Stream * in)
{
    XLV_PluginStream *ps;
    XLV_Stream *s;

    g_assert (plug != NULL);

    if (!plug->f_open) {
        if (!xlv_plugin_load_registered (plug))
            return (XLV_Stream *) NULL;
        if (!plug->f_open)
            return (XLV_Stream *) NULL;
    }

    ps = plug->f_open (in, plug->m_plugdata);
    if (!ps)
        return (XLV_Stream *) NULL;
    s = g_new (XLV_Stream, 1);
    s->m_plugin = plug;
    plug->m_refcounter++;
    s->m_stream = ps;
    return s;
}

static inline XLV_Stream *
xlv_open_stream (XLV_Plugin * plug, const gchar * name, guint mode)
{
    XLV_PluginStream *ps;
    XLV_Stream *s;

    g_assert (plug != NULL);

    if (!plug->f_openStream) {
        if (!xlv_plugin_load_registered (plug))
            return (XLV_Stream *) NULL;
        if (!plug->f_openStream)
            return (XLV_Stream *) NULL;
    }

    ps = plug->f_openStream (name, mode, plug->m_plugdata);
    if (!ps)
        return (XLV_Stream *) NULL;
    s = g_new (XLV_Stream, 1);
    s->m_plugin = plug;
    plug->m_refcounter++;
    s->m_stream = ps;
    return s;
}

static inline void
xlv_close (XLV_Stream * s)
{
    g_assert (s != NULL);
    g_assert (s->m_plugin->m_refcounter != 0);

    s->m_plugin->m_refcounter--;

    if (s->m_plugin->f_close)
        s->m_plugin->f_close (s->m_stream);

    if (s->m_plugin->m_manager && s->m_plugin->m_refcounter == 0)
        xlv_plugin_set_unused (s->m_plugin);

    g_free (s);
}

static inline guint32
xlv_read (XLV_Stream * s, gpointer data, guint32 len)
{
    g_assert (s != NULL);

    if (s->m_plugin->f_readData)
        return s->m_plugin->f_readData (s->m_stream, data, len);
    else
        return 0;
}

static inline guint32
xlv_write (XLV_Stream * s, gpointer data, guint32 len)
{
    g_assert(s != NULL);
    
    if (s->m_plugin->f_writeData)
            return (s->m_plugin->f_writeData(s->m_stream, data, len));
    else
            return 0;
}

#endif

---