omx/gstomx_util.h

   1 /*
   2  * Copyright (C) 2006-2007 Texas Instruments, Incorporated
   3  * Copyright (C) 2007-2009 Nokia Corporation.
   4  *
   5  * Author: Felipe Contreras <felipe.contreras@nokia.com>
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation
  10  * version 2.1 of the License.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  20  *
  21  */
  22
  23 #ifndef GSTOMX_UTIL_H
  24 #define GSTOMX_UTIL_H
  25
  26 #include <glib.h>
  27 #include <OMX_Core.h>
  28 #include <OMX_Component.h>
  29
  30 #include <async_queue.h>
  31 #include <sem.h>
  32
  33 /* Typedefs. */
  34
  35 typedef struct GOmxCore GOmxCore;
  36 typedef struct GOmxPort GOmxPort;
  37 typedef struct GOmxImp GOmxImp;
  38 typedef struct GOmxSymbolTable GOmxSymbolTable;
  39 typedef enum GOmxPortType GOmxPortType;
  40 typedef enum GOmxVendor GOmxVendor;
  41
  42 typedef void (*GOmxCb) (GOmxCore * core);
  43 typedef void (*GOmxPortCb) (GOmxPort * port);
  44
  45 /* Enums. */
  46
  47 enum GOmxPortType
  48 {
  49   GOMX_PORT_INPUT,
  50   GOMX_PORT_OUTPUT
  51 };
  52
  53 /* Add_component_vendor */
  54 enum GOmxVendor
  55 {
  56   GOMX_VENDOR_DEFAULT,
  57   GOMX_VENDOR_SLSI
  58 };
  59
  60 /* Structures. */
  61
  62 struct GOmxSymbolTable
  63 {
  64   OMX_ERRORTYPE (*init) (void);
  65   OMX_ERRORTYPE (*deinit) (void);
  66   OMX_ERRORTYPE (*get_handle) (OMX_HANDLETYPE * handle,
  67       OMX_STRING name, OMX_PTR data, OMX_CALLBACKTYPE * callbacks);
  68   OMX_ERRORTYPE (*free_handle) (OMX_HANDLETYPE handle);
  69 };
  70
  71 struct GOmxImp
  72 {
  73   guint client_count;
  74   void *dl_handle;
  75   GOmxSymbolTable sym_table;
  76   GMutex *mutex;
  77 };
  78
  79 struct GOmxCore
  80 {
  81   gpointer object;   /**< GStreamer element. */
  82
  83   OMX_HANDLETYPE omx_handle;
  84   OMX_ERRORTYPE omx_error;
  85
  86   OMX_STATETYPE omx_state;
  87   GCond *omx_state_condition;
  88   GMutex *omx_state_mutex;
  89
  90   GPtrArray *ports;
  91
  92   GSem *done_sem;
  93   GSem *flush_sem;
  94   GSem *port_sem;
  95
  96   GOmxCb settings_changed_cb;
  97   GOmxImp *imp;
  98
  99   gboolean done;
 100
 101   gchar *library_name;
 102   gchar *component_name;
 103   gchar *component_role;
 104   GOmxVendor component_vendor;    /* Add_component_vendor */
 105 };
 106
 107 struct GOmxPort
 108 {
 109   GOmxCore *core;
 110   GOmxPortType type;
 111
 112   guint num_buffers;
 113   gulong buffer_size;
 114   guint port_index;
 115   OMX_BUFFERHEADERTYPE **buffers;
 116
 117   GMutex *mutex;
 118   gboolean enabled;
 119   gboolean omx_allocate;   /**< Setup with OMX_AllocateBuffer rather than OMX_UseBuffer */
 120   AsyncQueue *queue;
 121 };
 122
 123 /* Functions. */
 124
 125 void g_omx_init (void);
 126 void g_omx_deinit (void);
 127
 128 GOmxCore *g_omx_core_new (void *object);
 129 void g_omx_core_free (GOmxCore * core);
 130 void g_omx_core_init (GOmxCore * core);
 131 void g_omx_core_prepare (GOmxCore * core);
 132 void g_omx_core_start (GOmxCore * core);
 133 void g_omx_core_pause (GOmxCore * core);
 134 void g_omx_core_stop (GOmxCore * core);
 135 void g_omx_core_unload (GOmxCore * core);
 136 void g_omx_core_set_done (GOmxCore * core);
 137 void g_omx_core_wait_for_done (GOmxCore * core);
 138 void g_omx_core_flush_start (GOmxCore * core);
 139 void g_omx_core_flush_stop (GOmxCore * core);
 140 GOmxPort *g_omx_core_new_port (GOmxCore * core, guint index);
 141
 142 GOmxPort *g_omx_port_new (GOmxCore * core, guint index);
 143 void g_omx_port_free (GOmxPort * port);
 144 void g_omx_port_setup (GOmxPort * port);
 145 void g_omx_port_push_buffer (GOmxPort * port,
 146     OMX_BUFFERHEADERTYPE * omx_buffer);
 147 OMX_BUFFERHEADERTYPE *g_omx_port_request_buffer (GOmxPort * port);
 148 void g_omx_port_release_buffer (GOmxPort * port,
 149     OMX_BUFFERHEADERTYPE * omx_buffer);
 150 void g_omx_port_resume (GOmxPort * port);
 151 void g_omx_port_pause (GOmxPort * port);
 152 void g_omx_port_flush (GOmxPort * port);
 153 void g_omx_port_enable (GOmxPort * port);
 154 void g_omx_port_disable (GOmxPort * port);
 155 void g_omx_port_finish (GOmxPort * port);
 156
 157 /* Utility Macros */
 158
 159 /**
 160  * Basically like GST_BOILERPLATE / GST_BOILERPLATE_FULL, but follows the
 161  * init fxn naming conventions used by gst-openmax.  It expects the following
 162  * functions to be defined in the same src file following this macro
 163  * <ul>
 164  *   <li> type_base_init(gpointer g_class)
 165  *   <li> type_class_init(gpointer g_class, gpointer class_data)
 166  *   <li> type_instance_init(GTypeInstance *instance, gpointer g_class)
 167  * </ul>
 168  */
 169 #define GSTOMX_BOILERPLATE_FULL(type, type_as_function, parent_type, parent_type_macro, additional_initializations) \
 170 static void type_base_init (gpointer g_class);                                \
 171 static void type_class_init (gpointer g_class, gpointer class_data);          \
 172 static void type_instance_init (GTypeInstance *instance, gpointer g_class);   \
 173 static parent_type ## Class *parent_class;                                    \
 174 static void type_class_init_trampoline (gpointer g_class, gpointer class_data)\
 175 {                                                                             \
 176     parent_class = g_type_class_ref (parent_type_macro);                      \
 177     type_class_init (g_class, class_data);                                    \
 178 }                                                                             \
 179 GType type_as_function ## _get_type (void)                                    \
 180 {                                                                             \
 181     /* The typedef for GType may be gulong or gsize, depending on the         \
 182      * system and whether the compiler is c++ or not. The g_once_init_*       \
 183      * functions always take a gsize * though ... */                          \
 184     static volatile gsize gonce_data = 0;                                     \
 185     if (g_once_init_enter (&gonce_data)) {                                    \
 186         GType _type;                                                          \
 187         GTypeInfo *type_info;                                                 \
 188         type_info = g_new0 (GTypeInfo, 1);                                    \
 189         type_info->class_size = sizeof (type ## Class);                       \
 190         type_info->base_init = type_base_init;                                \
 191         type_info->class_init = type_class_init_trampoline;                   \
 192         type_info->instance_size = sizeof (type);                             \
 193         type_info->instance_init = type_instance_init;                        \
 194         _type = g_type_register_static (parent_type_macro, #type, type_info, 0);\
 195         g_free (type_info);                                                   \
 196         additional_initializations (_type);                                   \
 197         g_once_init_leave (&gonce_data, (gsize) _type);                       \
 198     }                                                                         \
 199     return (GType) gonce_data;                                                \
 200 }
 201
 202 #define GSTOMX_BOILERPLATE(type,type_as_function,parent_type,parent_type_macro)    \
 203   GSTOMX_BOILERPLATE_FULL (type, type_as_function, parent_type, parent_type_macro, \
 204       __GST_DO_NOTHING)
 205
 206 #include <string.h>             /* for memset */
 207 #define G_OMX_INIT_PARAM(param) G_STMT_START {                                \
 208         memset (&(param), 0, sizeof ((param)));                               \
 209         (param).nSize = sizeof (param);                                       \
 210         (param).nVersion.s.nVersionMajor = 1;                                 \
 211         (param).nVersion.s.nVersionMinor = 1;                                 \
 212     } G_STMT_END
 213
 214
 215 #endif /* GSTOMX_UTIL_H */