modules/codec/omxil/OMX_Types.h

   1 /*
   2  * Copyright (c) 2008 The Khronos Group Inc.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining
   5  * a copy of this software and associated documentation files (the
   6  * "Software"), to deal in the Software without restriction, including
   7  * without limitation the rights to use, copy, modify, merge, publish,
   8  * distribute, sublicense, and/or sell copies of the Software, and to
   9  * permit persons to whom the Software is furnished to do so, subject
  10  * to the following conditions:
  11  * The above copyright notice and this permission notice shall be included
  12  * in all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  15  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  16  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  17  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
  18  * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  19  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  20  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  21  *
  22  */
  23
  24 /** OMX_Types.h - OpenMax IL version 1.1.2
  25  *  The OMX_Types header file contains the primitive type definitions used by
  26  *  the core, the application and the component.  This file may need to be
  27  *  modified to be used on systems that do not have "char" set to 8 bits,
  28  *  "short" set to 16 bits and "long" set to 32 bits.
  29  */
  30
  31 #ifndef OMX_Types_h
  32 #define OMX_Types_h
  33
  34 #ifdef __cplusplus
  35 extern "C" {
  36 #endif /* __cplusplus */
  37
  38 /** The OMX_API and OMX_APIENTRY are platform specific definitions used
  39  *  to declare OMX function prototypes.  They are modified to meet the
  40  *  requirements for a particular platform */
  41 #ifdef __SYMBIAN32__
  42 #   ifdef __OMX_EXPORTS
  43 #       define OMX_API __declspec(dllexport)
  44 #   else
  45 #       ifdef _WIN32
  46 #           define OMX_API __declspec(dllexport)
  47 #       else
  48 #           define OMX_API __declspec(dllimport)
  49 #       endif
  50 #   endif
  51 #else
  52 #   ifdef _WIN32
  53 #      ifdef __OMX_EXPORTS
  54 #          define OMX_API __declspec(dllexport)
  55 #      else
  56 #          define OMX_API __declspec(dllimport)
  57 #      endif
  58 #   else
  59 #      ifdef __OMX_EXPORTS
  60 #          define OMX_API
  61 #      else
  62 #          define OMX_API extern
  63 #      endif
  64 #   endif
  65 #endif
  66
  67 #ifndef OMX_APIENTRY
  68 #define OMX_APIENTRY
  69 #endif
  70
  71 /** OMX_IN is used to identify inputs to an OMX function.  This designation
  72     will also be used in the case of a pointer that points to a parameter
  73     that is used as an output. */
  74 #ifndef OMX_IN
  75 #define OMX_IN
  76 #endif
  77
  78 /** OMX_OUT is used to identify outputs from an OMX function.  This
  79     designation will also be used in the case of a pointer that points
  80     to a parameter that is used as an input. */
  81 #ifndef OMX_OUT
  82 #define OMX_OUT
  83 #endif
  84
  85
  86 /** OMX_INOUT is used to identify parameters that may be either inputs or
  87     outputs from an OMX function at the same time.  This designation will
  88     also be used in the case of a pointer that  points to a parameter that
  89     is used both as an input and an output. */
  90 #ifndef OMX_INOUT
  91 #define OMX_INOUT
  92 #endif
  93
  94 /** OMX_ALL is used to as a wildcard to select all entities of the same type
  95  *  when specifying the index, or referring to a object by an index.  (i.e.
  96  *  use OMX_ALL to indicate all N channels). When used as a port index
  97  *  for a config or parameter this OMX_ALL denotes that the config or
  98  *  parameter applies to the entire component not just one port. */
  99 #define OMX_ALL 0xFFFFFFFF
 100
 101 /** In the following we define groups that help building doxygen documentation */
 102
 103 /** @defgroup core OpenMAX IL core
 104  * Functions and structure related to the OMX IL core
 105  */
 106
 107  /** @defgroup comp OpenMAX IL component
 108  * Functions and structure related to the OMX IL component
 109  */
 110
 111 /** @defgroup rpm Resource and Policy Management
 112  * Structures for resource and policy management of components
 113  */
 114
 115 /** @defgroup buf Buffer Management
 116  * Buffer handling functions and structures
 117  */
 118
 119 /** @defgroup tun Tunneling
 120  * @ingroup core comp
 121  * Structures and functions to manage tunnels among component ports
 122  */
 123
 124 /** @defgroup cp Content Pipes
 125  *  @ingroup core
 126  */
 127
 128  /** @defgroup metadata Metadata handling
 129   *
 130   */
 131
 132 /** OMX_U8 is an 8 bit unsigned quantity that is byte aligned */
 133 typedef unsigned char OMX_U8;
 134
 135 /** OMX_S8 is an 8 bit signed quantity that is byte aligned */
 136 typedef signed char OMX_S8;
 137
 138 /** OMX_U16 is a 16 bit unsigned quantity that is 16 bit word aligned */
 139 typedef unsigned short OMX_U16;
 140
 141 /** OMX_S16 is a 16 bit signed quantity that is 16 bit word aligned */
 142 typedef signed short OMX_S16;
 143
 144 /** OMX_U32 is a 32 bit unsigned quantity that is 32 bit word aligned */
 145 typedef unsigned long OMX_U32;
 146
 147 /** OMX_S32 is a 32 bit signed quantity that is 32 bit word aligned */
 148 typedef signed long OMX_S32;
 149
 150
 151 /* Users with compilers that cannot accept the "long long" designation should
 152    define the OMX_SKIP64BIT macro.  It should be noted that this may cause
 153    some components to fail to compile if the component was written to require
 154    64 bit integral types.  However, these components would NOT compile anyway
 155    since the compiler does not support the way the component was written.
 156 */
 157 #ifndef OMX_SKIP64BIT
 158 #ifdef __SYMBIAN32__
 159 /** OMX_U64 is a 64 bit unsigned quantity that is 64 bit word aligned */
 160 typedef unsigned long long OMX_U64;
 161
 162 /** OMX_S64 is a 64 bit signed quantity that is 64 bit word aligned */
 163 typedef signed long long OMX_S64;
 164
 165 #elif defined(_WIN32)
 166
 167 /** OMX_U64 is a 64 bit unsigned quantity that is 64 bit word aligned */
 168 typedef unsigned __int64  OMX_U64;
 169
 170 /** OMX_S64 is a 64 bit signed quantity that is 64 bit word aligned */
 171 typedef signed   __int64  OMX_S64;
 172
 173 #else /* _WIN32 */
 174
 175 /** OMX_U64 is a 64 bit unsigned quantity that is 64 bit word aligned */
 176 typedef unsigned long long OMX_U64;
 177
 178 /** OMX_S64 is a 64 bit signed quantity that is 64 bit word aligned */
 179 typedef signed long long OMX_S64;
 180
 181 #endif /* _WIN32 */
 182 #endif
 183
 184
 185 /** The OMX_BOOL type is intended to be used to represent a true or a false
 186     value when passing parameters to and from the OMX core and components.  The
 187     OMX_BOOL is a 32 bit quantity and is aligned on a 32 bit word boundary.
 188  */
 189 typedef enum OMX_BOOL {
 190     OMX_FALSE = 0,
 191     OMX_TRUE = !OMX_FALSE,
 192     OMX_BOOL_MAX = 0x7FFFFFFF
 193 } OMX_BOOL;
 194
 195 /** The OMX_PTR type is intended to be used to pass pointers between the OMX
 196     applications and the OMX Core and components.  This is a 32 bit pointer and
 197     is aligned on a 32 bit boundary.
 198  */
 199 typedef void* OMX_PTR;
 200
 201 /** The OMX_STRING type is intended to be used to pass "C" type strings between
 202     the application and the core and component.  The OMX_STRING type is a 32
 203     bit pointer to a zero terminated string.  The  pointer is word aligned and
 204     the string is byte aligned.
 205  */
 206 typedef char* OMX_STRING;
 207
 208 /** The OMX_BYTE type is intended to be used to pass arrays of bytes such as
 209     buffers between the application and the component and core.  The OMX_BYTE
 210     type is a 32 bit pointer to a zero terminated string.  The  pointer is word
 211     aligned and the string is byte aligned.
 212  */
 213 typedef unsigned char* OMX_BYTE;
 214
 215 /** OMX_UUIDTYPE is a very long unique identifier to uniquely identify
 216     at runtime.  This identifier should be generated by a component in a way
 217     that guarantees that every instance of the identifier running on the system
 218     is unique. */
 219 typedef unsigned char OMX_UUIDTYPE[128];
 220
 221 /** The OMX_DIRTYPE enumeration is used to indicate if a port is an input or
 222     an output port.  This enumeration is common across all component types.
 223  */
 224 typedef enum OMX_DIRTYPE
 225 {
 226     OMX_DirInput,              /**< Port is an input port */
 227     OMX_DirOutput,             /**< Port is an output port */
 228     OMX_DirMax = 0x7FFFFFFF
 229 } OMX_DIRTYPE;
 230
 231 /** The OMX_ENDIANTYPE enumeration is used to indicate the bit ordering
 232     for numerical data (i.e. big endian, or little endian).
 233  */
 234 typedef enum OMX_ENDIANTYPE
 235 {
 236     OMX_EndianBig, /**< big endian */
 237     OMX_EndianLittle, /**< little endian */
 238     OMX_EndianMax = 0x7FFFFFFF
 239 } OMX_ENDIANTYPE;
 240
 241
 242 /** The OMX_NUMERICALDATATYPE enumeration is used to indicate if data
 243     is signed or unsigned
 244  */
 245 typedef enum OMX_NUMERICALDATATYPE
 246 {
 247     OMX_NumericalDataSigned, /**< signed data */
 248     OMX_NumericalDataUnsigned, /**< unsigned data */
 249     OMX_NumercialDataMax = 0x7FFFFFFF
 250 } OMX_NUMERICALDATATYPE;
 251
 252
 253 /** Unsigned bounded value type */
 254 typedef struct OMX_BU32 {
 255     OMX_U32 nValue; /**< actual value */
 256     OMX_U32 nMin;   /**< minimum for value (i.e. nValue >= nMin) */
 257     OMX_U32 nMax;   /**< maximum for value (i.e. nValue <= nMax) */
 258 } OMX_BU32;
 259
 260
 261 /** Signed bounded value type */
 262 typedef struct OMX_BS32 {
 263     OMX_S32 nValue; /**< actual value */
 264     OMX_S32 nMin;   /**< minimum for value (i.e. nValue >= nMin) */
 265     OMX_S32 nMax;   /**< maximum for value (i.e. nValue <= nMax) */
 266 } OMX_BS32;
 267
 268
 269 /** Structure representing some time or duration in microseconds. This structure
 270   *  must be interpreted as a signed 64 bit value. The quantity is signed to accommodate
 271   *  negative deltas and preroll scenarios. The quantity is represented in microseconds
 272   *  to accomodate high resolution timestamps (e.g. DVD presentation timestamps based
 273   *  on a 90kHz clock) and to allow more accurate and synchronized delivery (e.g.
 274   *  individual audio samples delivered at 192 kHz). The quantity is 64 bit to
 275   *  accommodate a large dynamic range (signed 32 bit values would allow only for plus
 276   *  or minus 35 minutes).
 277   *
 278   *  Implementations with limited precision may convert the signed 64 bit value to
 279   *  a signed 32 bit value internally but risk loss of precision.
 280   */
 281 #ifndef OMX_SKIP64BIT
 282 typedef OMX_S64 OMX_TICKS;
 283 #else
 284 typedef struct OMX_TICKS
 285 {
 286     OMX_U32 nLowPart;    /** low bits of the signed 64 bit tick value */
 287     OMX_U32 nHighPart;   /** high bits of the signed 64 bit tick value */
 288 } OMX_TICKS;
 289 #endif
 290 #define OMX_TICKS_PER_SECOND 1000000
 291
 292 /** Define the public interface for the OMX Handle.  The core will not use
 293     this value internally, but the application should only use this value.
 294  */
 295 typedef void* OMX_HANDLETYPE;
 296
 297 typedef struct OMX_MARKTYPE
 298 {
 299     OMX_HANDLETYPE hMarkTargetComponent;   /**< The component that will
 300                                                 generate a mark event upon
 301                                                 processing the mark. */
 302     OMX_PTR pMarkData;   /**< Application specific data associated with
 303                               the mark sent on a mark event to disambiguate
 304                               this mark from others. */
 305 } OMX_MARKTYPE;
 306
 307
 308 /** OMX_NATIVE_DEVICETYPE is used to map a OMX video port to the
 309  *  platform & operating specific object used to reference the display
 310  *  or can be used by a audio port for native audio rendering */
 311 typedef void* OMX_NATIVE_DEVICETYPE;
 312
 313 /** OMX_NATIVE_WINDOWTYPE is used to map a OMX video port to the
 314  *  platform & operating specific object used to reference the window */
 315 typedef void* OMX_NATIVE_WINDOWTYPE;
 316
 317 /** The OMX_VERSIONTYPE union is used to specify the version for
 318     a structure or component.  For a component, the version is entirely
 319     specified by the component vendor.  Components doing the same function
 320     from different vendors may or may not have the same version.  For
 321     structures, the version shall be set by the entity that allocates the
 322     structure.  For structures specified in the OMX 1.1 specification, the
 323     value of the version shall be set to 1.1.0.0 in all cases.  Access to the
 324     OMX_VERSIONTYPE can be by a single 32 bit access (e.g. by nVersion) or
 325     by accessing one of the structure elements to, for example, check only
 326     the Major revision.
 327  */
 328 typedef union OMX_VERSIONTYPE
 329 {
 330     struct
 331     {
 332         OMX_U8 nVersionMajor;   /**< Major version accessor element */
 333         OMX_U8 nVersionMinor;   /**< Minor version accessor element */
 334         OMX_U8 nRevision;       /**< Revision version accessor element */
 335         OMX_U8 nStep;           /**< Step version accessor element */
 336     } s;
 337     OMX_U32 nVersion;           /**< 32 bit value to make accessing the
 338                                     version easily done in a single word
 339                                     size copy/compare operation */
 340 } OMX_VERSIONTYPE;
 341
 342 #ifdef __cplusplus
 343 }
 344 #endif /* __cplusplus */
 345
 346 #endif
 347 /* File EOF */