OMX_Core.h

Go to the documentation of this file.

/*
 * Copyright (c) 2007 The Khronos Group Inc. 
 * 
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject
 * to the following conditions: 
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software. 
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
 *
 */

#ifndef OMX_Core_h
#define OMX_Core_h

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */


/* Each OMX header shall include all required header files to allow the
 *  header to compile without errors.  The includes below are required
 *  for this header file to compile successfully 
 */

#include <OMX_Index.h>


typedef enum OMX_COMMANDTYPE
{
    OMX_CommandStateSet,    
    OMX_CommandFlush,       
    OMX_CommandPortDisable, 
    OMX_CommandPortEnable,  
    OMX_CommandMarkBuffer,  
    OMX_CommandMax = 0X7FFFFFFF
} OMX_COMMANDTYPE;



typedef enum OMX_STATETYPE
{
    OMX_StateInvalid,      
    OMX_StateLoaded,      
    OMX_StateIdle,        
    OMX_StateExecuting,   
    OMX_StatePause,       
    OMX_StateWaitForResources, 
    OMX_StateMax = 0X7FFFFFFF
} OMX_STATETYPE;

typedef enum OMX_ERRORTYPE
{
  OMX_ErrorNone = 0,

  OMX_ErrorInsufficientResources = 0x80001000,

  OMX_ErrorUndefined = 0x80001001,

  OMX_ErrorInvalidComponentName = 0x80001002,

  OMX_ErrorComponentNotFound = 0x80001003,

  OMX_ErrorInvalidComponent = 0x80001004,

  OMX_ErrorBadParameter = 0x80001005,

  OMX_ErrorNotImplemented = 0x80001006,

  OMX_ErrorUnderflow = 0x80001007,

  OMX_ErrorOverflow = 0x80001008,

  OMX_ErrorHardware = 0x80001009,

  OMX_ErrorInvalidState = 0x8000100A,

  OMX_ErrorStreamCorrupt = 0x8000100B,

  OMX_ErrorPortsNotCompatible = 0x8000100C,

  OMX_ErrorResourcesLost = 0x8000100D,

  OMX_ErrorNoMore = 0x8000100E,

  OMX_ErrorVersionMismatch = 0x8000100F,

  OMX_ErrorNotReady = 0x80001010,

  OMX_ErrorTimeout = 0x80001011,

  OMX_ErrorSameState = 0x80001012,

  OMX_ErrorResourcesPreempted = 0x80001013, 

  OMX_ErrorPortUnresponsiveDuringAllocation = 0x80001014,

  OMX_ErrorPortUnresponsiveDuringDeallocation = 0x80001015,

  OMX_ErrorPortUnresponsiveDuringStop = 0x80001016,

  OMX_ErrorIncorrectStateTransition = 0x80001017,

  /* Attempting a command that is not allowed during the present state. */
  OMX_ErrorIncorrectStateOperation = 0x80001018, 

  OMX_ErrorUnsupportedSetting = 0x80001019,

  OMX_ErrorUnsupportedIndex = 0x8000101A,

  OMX_ErrorBadPortIndex = 0x8000101B,

  OMX_ErrorPortUnpopulated = 0x8000101C,

  OMX_ErrorComponentSuspended = 0x8000101D,

  OMX_ErrorDynamicResourcesUnavailable = 0x8000101E,

  OMX_ErrorMbErrorsInFrame = 0x8000101F,

  OMX_ErrorFormatNotDetected = 0x80001020, 

  OMX_ErrorContentPipeOpenFailed = 0x80001021,

  OMX_ErrorContentPipeCreationFailed = 0x80001022,

  OMX_ErrorSeperateTablesUsed = 0x80001023,

  OMX_ErrorTunnelingUnsupported = 0x80001024,

  OMX_ErrorMax = 0x7FFFFFFF,
} OMX_ERRORTYPE;

typedef OMX_ERRORTYPE (* OMX_COMPONENTINITTYPE)(OMX_IN  OMX_HANDLETYPE hComponent);

typedef struct OMX_COMPONENTREGISTERTYPE
{
  const char          * pName;       /* Component name, 128 byte limit (including '\0') applies */
  OMX_COMPONENTINITTYPE pInitialize; /* Component instance initialization function */
} OMX_COMPONENTREGISTERTYPE;

extern OMX_COMPONENTREGISTERTYPE OMX_ComponentRegistered[];

typedef struct OMX_PRIORITYMGMTTYPE {
 OMX_U32 nSize;             
 OMX_VERSIONTYPE nVersion;  
 OMX_U32 nGroupPriority;            
 OMX_U32 nGroupID;                  
} OMX_PRIORITYMGMTTYPE;

/* Component name and Role names are limited to 128 characters including the terminating '\0'. */
#define OMX_MAX_STRINGNAME_SIZE 128

typedef struct OMX_PARAM_COMPONENTROLETYPE {
    OMX_U32 nSize;              
    OMX_VERSIONTYPE nVersion;   
    OMX_U8 cRole[OMX_MAX_STRINGNAME_SIZE];  
} OMX_PARAM_COMPONENTROLETYPE;

#define OMX_BUFFERFLAG_EOS 0x00000001 

#define OMX_BUFFERFLAG_STARTTIME 0x00000002

 

#define OMX_BUFFERFLAG_DECODEONLY 0x00000004


/* Data Corrupt Flag: This flag is set when the IL client believes the data in the associated buffer is corrupt 
 * @ingroup buf
 */

#define OMX_BUFFERFLAG_DATACORRUPT 0x00000008

/* End of Frame: The buffer contains exactly one end of frame and no data
 *  occurs after the end of frame. This flag is an optional hint. The absence
 *  of this flag does not imply the absence of an end of frame within the buffer. 
 * @ingroup buf
*/
#define OMX_BUFFERFLAG_ENDOFFRAME 0x00000010

/* Sync Frame Flag: This flag is set when the buffer content contains a coded sync frame ' 
 *  a frame that has no dependency on any other frame information 
 *  @ingroup buf
 */
#define OMX_BUFFERFLAG_SYNCFRAME 0x00000020

/* Extra data present flag: there is extra data appended to the data stream
 * residing in the buffer 
 * @ingroup buf  
 */
#define OMX_BUFFERFLAG_EXTRADATA 0x00000040

typedef struct OMX_BUFFERHEADERTYPE
{
    OMX_U32 nSize;              
    OMX_VERSIONTYPE nVersion;   
    OMX_U8* pBuffer;            
    OMX_U32 nAllocLen;          
    OMX_U32 nFilledLen;         
    OMX_U32 nOffset;            
    OMX_PTR pAppPrivate;        
    OMX_PTR pPlatformPrivate;   
    OMX_PTR pInputPortPrivate;  
    OMX_PTR pOutputPortPrivate; 
    OMX_HANDLETYPE hMarkTargetComponent; 
    OMX_PTR pMarkData;          
    OMX_U32 nTickCount;         
 OMX_TICKS nTimeStamp;          
  OMX_U32     nFlags;           
  OMX_U32 nOutputPortIndex;     
  OMX_U32 nInputPortIndex;      
} OMX_BUFFERHEADERTYPE;

/* Extra Data flags */

/* Quant Data Flag: This flag is set when the extra data is appended to the buffer containing quantization information */
#define OMX_EXTRADATAFLAG_QUANT 0x00000001

typedef struct OMX_OTHER_EXTRADATATYPE  {
    OMX_U32 nSize;
    OMX_VERSIONTYPE nVersion;               
    OMX_U32 nPortIndex;
    OMX_U32 nFlags;       /* Extra Data flags */
    OMX_U32 nDataSize;   /* Size of the supporting data to follow */
    OMX_U8  data[1];     /* Supporting data hint  */
} OMX_OTHER_EXTRADATATYPE;

typedef struct OMX_PORT_PARAM_TYPE {
    OMX_U32 nSize;              
    OMX_VERSIONTYPE nVersion;   
    OMX_U32 nPorts;             
    OMX_U32 nStartPortNumber;   
} OMX_PORT_PARAM_TYPE; 

typedef enum OMX_EVENTTYPE
{
    OMX_EventCmdComplete,         
    OMX_EventError,               
    OMX_EventMark,                
    OMX_EventPortSettingsChanged, 
    OMX_EventBufferFlag,          
    OMX_EventResourcesAcquired,   
   OMX_EventComponentResumed,     
   OMX_EventDynamicResourcesAvailable, 
   OMX_EventPortFormatDetected,      
   OMX_EventMax = 0x7FFFFFFF
} OMX_EVENTTYPE;

typedef struct OMX_CALLBACKTYPE
{
   OMX_ERRORTYPE (*EventHandler)(
        OMX_IN OMX_HANDLETYPE hComponent,
        OMX_IN OMX_PTR pAppData,
        OMX_IN OMX_EVENTTYPE eEvent,
        OMX_IN OMX_U32 nData1,
        OMX_IN OMX_U32 nData2,
        OMX_IN OMX_PTR pEventData);

    OMX_ERRORTYPE (*EmptyBufferDone)(
        OMX_IN OMX_HANDLETYPE hComponent,
        OMX_IN OMX_PTR pAppData,
        OMX_IN OMX_BUFFERHEADERTYPE* pBuffer);

    OMX_ERRORTYPE (*FillBufferDone)(
        OMX_OUT OMX_HANDLETYPE hComponent,
        OMX_OUT OMX_PTR pAppData,
        OMX_OUT OMX_BUFFERHEADERTYPE* pBuffer);

} OMX_CALLBACKTYPE;

typedef enum OMX_BUFFERSUPPLIERTYPE
{
    OMX_BufferSupplyUnspecified = 0x0, 
    OMX_BufferSupplyInput,             
    OMX_BufferSupplyOutput,            
    OMX_BufferSupplyMax = 0x7FFFFFFF
} OMX_BUFFERSUPPLIERTYPE;


typedef struct OMX_PARAM_BUFFERSUPPLIERTYPE {
    OMX_U32 nSize; 
    OMX_VERSIONTYPE nVersion; 
    OMX_U32 nPortIndex; 
    OMX_BUFFERSUPPLIERTYPE eBufferSupplier; 
} OMX_PARAM_BUFFERSUPPLIERTYPE;


#define OMX_PORTTUNNELFLAG_READONLY 0x00000001 


typedef struct OMX_TUNNELSETUPTYPE
{
    OMX_U32 nTunnelFlags;             
    OMX_BUFFERSUPPLIERTYPE eSupplier; 
} OMX_TUNNELSETUPTYPE; 

/* OMX Component headers is included to enable the core to use
   macros for functions into the component for OMX release 1.0.  
   Developers should not access any structures or data from within
   the component header directly */
/* TO BE REMOVED - #include <OMX_Component.h> */

#define OMX_GetComponentVersion(                            \
        hComponent,                                         \
        pComponentName,                                     \
        pComponentVersion,                                  \
        pSpecVersion,                                       \
        pComponentUUID)                                     \
    ((OMX_COMPONENTTYPE*)hComponent)->GetComponentVersion(  \
        hComponent,                                         \
        pComponentName,                                     \
        pComponentVersion,                                  \
        pSpecVersion,                                       \
        pComponentUUID)                 /* Macro End */


#define OMX_SendCommand(                                    \
         hComponent,                                        \
         Cmd,                                               \
         nParam,                                            \
         pCmdData)                                          \
     ((OMX_COMPONENTTYPE*)hComponent)->SendCommand(         \
         hComponent,                                        \
         Cmd,                                               \
         nParam,                                            \
         pCmdData)                          /* Macro End */


#define OMX_GetParameter(                                   \
        hComponent,                                         \
        nParamIndex,                                        \
        pComponentParameterStructure)                        \
    ((OMX_COMPONENTTYPE*)hComponent)->GetParameter(         \
        hComponent,                                         \
        nParamIndex,                                        \
        pComponentParameterStructure)    /* Macro End */


#define OMX_SetParameter(                                   \
        hComponent,                                         \
        nParamIndex,                                        \
        pComponentParameterStructure)                        \
    ((OMX_COMPONENTTYPE*)hComponent)->SetParameter(         \
        hComponent,                                         \
        nParamIndex,                                        \
        pComponentParameterStructure)    /* Macro End */


#define OMX_GetConfig(                                      \
        hComponent,                                         \
        nConfigIndex,                                       \
        pComponentConfigStructure)                           \
    ((OMX_COMPONENTTYPE*)hComponent)->GetConfig(            \
        hComponent,                                         \
        nConfigIndex,                                       \
        pComponentConfigStructure)       /* Macro End */


#define OMX_SetConfig(                                      \
        hComponent,                                         \
        nConfigIndex,                                       \
        pComponentConfigStructure)                           \
    ((OMX_COMPONENTTYPE*)hComponent)->SetConfig(            \
        hComponent,                                         \
        nConfigIndex,                                       \
        pComponentConfigStructure)       /* Macro End */


#define OMX_GetExtensionIndex(                              \
        hComponent,                                         \
        cParameterName,                                     \
        pIndexType)                                         \
    ((OMX_COMPONENTTYPE*)hComponent)->GetExtensionIndex(    \
        hComponent,                                         \
        cParameterName,                                     \
        pIndexType)                     /* Macro End */


#define OMX_GetState(                                       \
        hComponent,                                         \
        pState)                                             \
    ((OMX_COMPONENTTYPE*)hComponent)->GetState(             \
        hComponent,                                         \
        pState)                         /* Macro End */


#define OMX_UseBuffer(                                      \
           hComponent,                                      \
           ppBufferHdr,                                     \
           nPortIndex,                                      \
           pAppPrivate,                                     \
           nSizeBytes,                                      \
           pBuffer)                                         \
    ((OMX_COMPONENTTYPE*)hComponent)->UseBuffer(            \
           hComponent,                                      \
           ppBufferHdr,                                     \
           nPortIndex,                                      \
           pAppPrivate,                                     \
           nSizeBytes,                                      \
           pBuffer)


#define OMX_AllocateBuffer(                                 \
        hComponent,                                         \
        ppBuffer,                                           \
        nPortIndex,                                         \
        pAppPrivate,                                        \
        nSizeBytes)                                         \
    ((OMX_COMPONENTTYPE*)hComponent)->AllocateBuffer(       \
        hComponent,                                         \
        ppBuffer,                                           \
        nPortIndex,                                         \
        pAppPrivate,                                        \
        nSizeBytes)                     /* Macro End */


#define OMX_FreeBuffer(                                     \
        hComponent,                                         \
        nPortIndex,                                         \
        pBuffer)                                            \
    ((OMX_COMPONENTTYPE*)hComponent)->FreeBuffer(           \
        hComponent,                                         \
        nPortIndex,                                         \
        pBuffer)                        /* Macro End */


#define OMX_EmptyThisBuffer(                                \
        hComponent,                                         \
        pBuffer)                                            \
    ((OMX_COMPONENTTYPE*)hComponent)->EmptyThisBuffer(      \
        hComponent,                                         \
        pBuffer)                        /* Macro End */


#define OMX_FillThisBuffer(                                 \
        hComponent,                                         \
        pBuffer)                                            \
    ((OMX_COMPONENTTYPE*)hComponent)->FillThisBuffer(       \
        hComponent,                                         \
        pBuffer)                        /* Macro End */



#define OMX_UseEGLImage(                                    \
           hComponent,                                      \
           ppBufferHdr,                                     \
           nPortIndex,                                      \
           pAppPrivate,                                     \
           eglImage)                                        \
    ((OMX_COMPONENTTYPE*)hComponent)->UseEGLImage(          \
           hComponent,                                      \
           ppBufferHdr,                                     \
           nPortIndex,                                      \
           pAppPrivate,                                     \
           eglImage)

OMX_API OMX_ERRORTYPE OMX_APIENTRY OMX_Init(void);


OMX_API OMX_ERRORTYPE OMX_APIENTRY OMX_Deinit(void);


OMX_API OMX_ERRORTYPE OMX_APIENTRY OMX_ComponentNameEnum(
    OMX_OUT OMX_STRING cComponentName,
    OMX_IN  OMX_U32 nNameLength,
    OMX_IN  OMX_U32 nIndex);


OMX_API OMX_ERRORTYPE OMX_APIENTRY OMX_GetHandle(
    OMX_OUT OMX_HANDLETYPE* pHandle, 
    OMX_IN  OMX_STRING cComponentName,
    OMX_IN  OMX_PTR pAppData,
    OMX_IN  OMX_CALLBACKTYPE* pCallBacks);


OMX_API OMX_ERRORTYPE OMX_APIENTRY OMX_FreeHandle(
    OMX_IN  OMX_HANDLETYPE hComponent);



OMX_API OMX_ERRORTYPE OMX_APIENTRY OMX_SetupTunnel(
    OMX_IN  OMX_HANDLETYPE hOutput,
    OMX_IN  OMX_U32 nPortOutput,
    OMX_IN  OMX_HANDLETYPE hInput,
    OMX_IN  OMX_U32 nPortInput);
    
OMX_API OMX_ERRORTYPE   OMX_GetContentPipe(
    OMX_OUT OMX_HANDLETYPE *hPipe,
    OMX_IN OMX_STRING szURI);

OMX_API OMX_ERRORTYPE OMX_GetComponentsOfRole ( 
    OMX_IN      OMX_STRING role,
    OMX_INOUT   OMX_U32 *pNumComps,
    OMX_INOUT   OMX_U8  **compNames);

OMX_API OMX_ERRORTYPE OMX_GetRolesOfComponent ( 
    OMX_IN      OMX_STRING compName, 
    OMX_INOUT   OMX_U32 *pNumRoles,
    OMX_OUT     OMX_U8 **roles);

#ifdef __cplusplus
}
#endif /* __cplusplus */

#endif
/* File EOF */

---

Generated for OpenMAX Bellagio rel. 0.3.5-svn by  1.5.1