Classes | Modules | Defines | Typedefs | Enumerations

OpenMAX IL component

Classes

struct  OMX_PARAM_PORTDEFINITIONTYPE
struct  OMX_PARAM_U32TYPE
struct  OMX_COMPONENTTYPE
struct  OMX_PARAM_COMPONENTROLETYPE
struct  OMX_PORT_PARAM_TYPE

Modules

 Tunneling

Defines

#define OMX_GetComponentVersion(hComponent,pComponentName,pComponentVersion,pSpecVersion,pComponentUUID)
#define OMX_SendCommand(hComponent,Cmd,nParam,pCmdData)
#define OMX_GetParameter(hComponent,nParamIndex,pComponentParameterStructure)
#define OMX_SetParameter(hComponent,nParamIndex,pComponentParameterStructure)
#define OMX_GetConfig(hComponent,nConfigIndex,pComponentConfigStructure)
#define OMX_SetConfig(hComponent,nConfigIndex,pComponentConfigStructure)
#define OMX_GetExtensionIndex(hComponent,cParameterName,pIndexType)
#define OMX_GetState(hComponent,pState)

Typedefs

typedef enum OMX_PORTDOMAINTYPE OMX_PORTDOMAINTYPE
typedef struct
OMX_PARAM_PORTDEFINITIONTYPE 
OMX_PARAM_PORTDEFINITIONTYPE
typedef struct OMX_PARAM_U32TYPE OMX_PARAM_U32TYPE
typedef struct OMX_COMPONENTTYPE OMX_COMPONENTTYPE
typedef enum OMX_STATETYPE OMX_STATETYPE
typedef struct
OMX_PARAM_COMPONENTROLETYPE 
OMX_PARAM_COMPONENTROLETYPE
typedef struct OMX_PORT_PARAM_TYPE OMX_PORT_PARAM_TYPE
typedef enum OMX_EVENTTYPE OMX_EVENTTYPE

Enumerations

enum  OMX_PORTDOMAINTYPE {
  OMX_PortDomainAudio, OMX_PortDomainVideo, OMX_PortDomainImage, OMX_PortDomainOther,
  OMX_PortDomainKhronosExtensions = 0x6F000000, OMX_PortDomainVendorStartUnused = 0x7F000000, OMX_PortDomainMax = 0x7ffffff
}
enum  OMX_STATETYPE {
  OMX_StateInvalid, OMX_StateLoaded, OMX_StateIdle, OMX_StateExecuting,
  OMX_StatePause, OMX_StateWaitForResources, OMX_StateKhronosExtensions = 0x6F000000, OMX_StateVendorStartUnused = 0x7F000000,
  OMX_StateMax = 0X7FFFFFFF
}
enum  OMX_EVENTTYPE {
  OMX_EventCmdComplete, OMX_EventError, OMX_EventMark, OMX_EventPortSettingsChanged,
  OMX_EventBufferFlag, OMX_EventResourcesAcquired, OMX_EventComponentResumed, OMX_EventDynamicResourcesAvailable,
  OMX_EventPortFormatDetected, OMX_EventKhronosExtensions = 0x6F000000, OMX_EventVendorStartUnused = 0x7F000000, OMX_EventMax = 0x7FFFFFFF
}

Detailed Description

Functions and structure related to the OMX IL component


Define Documentation

#define OMX_GetComponentVersion (   hComponent,
  pComponentName,
  pComponentVersion,
  pSpecVersion,
  pComponentUUID 
)
Value:
((OMX_COMPONENTTYPE*)hComponent)->GetComponentVersion(  \
        hComponent,                                         \
        pComponentName,                                     \
        pComponentVersion,                                  \
        pSpecVersion,                                       \
        pComponentUUID)

GetComponentVersion will return information about the component. This is a blocking call. This macro will go directly from the application to the component (via a core macro). The component will return from this call within 5 msec.

Parameters:
[in] hComponent handle of component to execute the command
[out] pComponentName pointer to an empty string of length 128 bytes. The component will write its name into this string. The name will be terminated by a single zero byte. The name of a component will be 127 bytes or less to leave room for the trailing zero byte. An example of a valid component name is "OMX.ABC.ChannelMixer\0".
[out] pComponentVersion pointer to an OMX Version structure that the component will fill in. The component will fill in a value that indicates the component version. NOTE: the component version is NOT the same as the OMX Specification version (found in all structures). The component version is defined by the vendor of the component and its value is entirely up to the component vendor.
[out] pSpecVersion pointer to an OMX Version structure that the component will fill in. The SpecVersion is the version of the specification that the component was built against. Please note that this value may or may not match the structure's version. For example, if the component was built against the 2.0 specification, but the application (which creates the structure is built against the 1.0 specification the versions would be different.
[out] pComponentUUID pointer to the UUID of the component which will be filled in by the component. The UUID is a unique identifier that is set at RUN time for the component and is unique to each instantion of the component.
Returns:
OMX_ERRORTYPE If the command successfully executes, the return code will be OMX_ErrorNone. Otherwise the appropriate OMX error will be returned.
#define OMX_GetConfig (   hComponent,
  nConfigIndex,
  pComponentConfigStructure 
)
Value:
((OMX_COMPONENTTYPE*)hComponent)->GetConfig(            \
        hComponent,                                         \
        nConfigIndex,                                       \
        pComponentConfigStructure)

The OMX_GetConfig macro will get one of the configuration structures from a component. This macro can be invoked anytime after the component has been loaded. The nParamIndex call parameter is used to indicate which structure is being requested from the component. The application shall allocate the correct structure and shall fill in the structure size and version information before invoking this macro. If the component has not had this configuration parameter sent before, then the component should return a set of valid DEFAULT values for the component. This is a blocking call.

The component should return from this call within 5 msec.

Parameters:
[in] hComponent Handle of the component to be accessed. This is the component handle returned by the call to the OMX_GetHandle function.
[in] nIndex Index of the structure to be filled. This value is from the OMX_INDEXTYPE enumeration.
[in,out] pComponentConfigStructure pointer to application allocated structure to be filled by the component.
Returns:
OMX_ERRORTYPE If the command successfully executes, the return code will be OMX_ErrorNone. Otherwise the appropriate OMX error will be returned.
#define OMX_GetExtensionIndex (   hComponent,
  cParameterName,
  pIndexType 
)
Value:
((OMX_COMPONENTTYPE*)hComponent)->GetExtensionIndex(    \
        hComponent,                                         \
        cParameterName,                                     \
        pIndexType)

The OMX_GetExtensionIndex macro will invoke a component to translate a vendor specific configuration or parameter string into an OMX structure index. There is no requirement for the vendor to support this command for the indexes already found in the OMX_INDEXTYPE enumeration (this is done to save space in small components). The component shall support all vendor supplied extension indexes not found in the master OMX_INDEXTYPE enumeration. This is a blocking call.

The component should return from this call within 5 msec.

Parameters:
[in] hComponent Handle of the component to be accessed. This is the component handle returned by the call to the GetHandle function.
[in] cParameterName OMX_STRING that shall be less than 128 characters long including the trailing null byte. This is the string that will get translated by the component into a configuration index.
[out] pIndexType a pointer to a OMX_INDEXTYPE to receive the index value.
Returns:
OMX_ERRORTYPE If the command successfully executes, the return code will be OMX_ErrorNone. Otherwise the appropriate OMX error will be returned.
#define OMX_GetParameter (   hComponent,
  nParamIndex,
  pComponentParameterStructure 
)
Value:
((OMX_COMPONENTTYPE*)hComponent)->GetParameter(         \
        hComponent,                                         \
        nParamIndex,                                        \
        pComponentParameterStructure)

The OMX_GetParameter macro will get one of the current parameter settings from the component. This macro cannot only be invoked when the component is in the OMX_StateInvalid state. The nParamIndex parameter is used to indicate which structure is being requested from the component. The application shall allocate the correct structure and shall fill in the structure size and version information before invoking this macro. When the parameter applies to a port, the caller shall fill in the appropriate nPortIndex value indicating the port on which the parameter applies. If the component has not had any settings changed, then the component should return a set of valid DEFAULT parameters for the component. This is a blocking call.

The component should return from this call within 20 msec.

Parameters:
[in] hComponent Handle of the component to be accessed. This is the component handle returned by the call to the OMX_GetHandle function.
[in] nParamIndex Index of the structure to be filled. This value is from the OMX_INDEXTYPE enumeration.
[in,out] pComponentParameterStructure Pointer to application allocated structure to be filled by the component.
Returns:
OMX_ERRORTYPE If the command successfully executes, the return code will be OMX_ErrorNone. Otherwise the appropriate OMX error will be returned.
#define OMX_GetState (   hComponent,
  pState 
)
Value:
((OMX_COMPONENTTYPE*)hComponent)->GetState(             \
        hComponent,                                         \
        pState)

The OMX_GetState macro will invoke the component to get the current state of the component and place the state value into the location pointed to by pState.

The component should return from this call within 5 msec.

Parameters:
[in] hComponent Handle of the component to be accessed. This is the component handle returned by the call to the OMX_GetHandle function.
[out] pState pointer to the location to receive the state. The value returned is one of the OMX_STATETYPE members
Returns:
OMX_ERRORTYPE If the command successfully executes, the return code will be OMX_ErrorNone. Otherwise the appropriate OMX error will be returned.
#define OMX_SendCommand (   hComponent,
  Cmd,
  nParam,
  pCmdData 
)
Value:
((OMX_COMPONENTTYPE*)hComponent)->SendCommand(         \
         hComponent,                                        \
         Cmd,                                               \
         nParam,                                            \
         pCmdData)

Send a command to the component. This call is a non-blocking call. The component should check the parameters and then queue the command to the component thread to be executed. The component thread shall send the EventHandler() callback at the conclusion of the command. This macro will go directly from the application to the component (via a core macro). The component will return from this call within 5 msec.

When the command is "OMX_CommandStateSet" the component will queue a state transition to the new state idenfied in nParam.

When the command is "OMX_CommandFlush", to flush a port's buffer queues, the command will force the component to return all buffers NOT CURRENTLY BEING PROCESSED to the application, in the order in which the buffers were received.

When the command is "OMX_CommandPortDisable" or "OMX_CommandPortEnable", the component's port (given by the value of nParam) will be stopped or restarted.

When the command "OMX_CommandMarkBuffer" is used to mark a buffer, the pCmdData will point to a OMX_MARKTYPE structure containing the component handle of the component to examine the buffer chain for the mark. nParam1 contains the index of the port on which the buffer mark is applied.

Specification text for more details.

Parameters:
[in] hComponent handle of component to execute the command
[in] Cmd Command for the component to execute
[in] nParam Parameter for the command to be executed. When Cmd has the value OMX_CommandStateSet, value is a member of OMX_STATETYPE. When Cmd has the value OMX_CommandFlush, value of nParam indicates which port(s) to flush. -1 is used to flush all ports a single port index will only flush that port. When Cmd has the value "OMX_CommandPortDisable" or "OMX_CommandPortEnable", the component's port is given by the value of nParam. When Cmd has the value "OMX_CommandMarkBuffer" the components pot is given by the value of nParam.
[in] pCmdData Parameter pointing to the OMX_MARKTYPE structure when Cmd has the value "OMX_CommandMarkBuffer".
Returns:
OMX_ERRORTYPE If the command successfully executes, the return code will be OMX_ErrorNone. Otherwise the appropriate OMX error will be returned.
#define OMX_SetConfig (   hComponent,
  nConfigIndex,
  pComponentConfigStructure 
)
Value:
((OMX_COMPONENTTYPE*)hComponent)->SetConfig(            \
        hComponent,                                         \
        nConfigIndex,                                       \
        pComponentConfigStructure)

The OMX_SetConfig macro will send one of the configuration structures to a component. Each structure shall be sent one at a time, each in a separate invocation of the macro. This macro can be invoked anytime after the component has been loaded. The application shall allocate the correct structure and shall fill in the structure size and version information (as well as the actual data) before invoking this macro. The application is free to dispose of this structure after the call as the component is required to copy any data it shall retain. This is a blocking call.

The component should return from this call within 5 msec.

Parameters:
[in] hComponent Handle of the component to be accessed. This is the component handle returned by the call to the OMX_GetHandle function.
[in] nConfigIndex Index of the structure to be sent. This value is from the OMX_INDEXTYPE enumeration above.
[in] pComponentConfigStructure pointer to application allocated structure to be used for initialization by the component.
Returns:
OMX_ERRORTYPE If the command successfully executes, the return code will be OMX_ErrorNone. Otherwise the appropriate OMX error will be returned.
#define OMX_SetParameter (   hComponent,
  nParamIndex,
  pComponentParameterStructure 
)
Value:
((OMX_COMPONENTTYPE*)hComponent)->SetParameter(         \
        hComponent,                                         \
        nParamIndex,                                        \
        pComponentParameterStructure)

The OMX_SetParameter macro will send an initialization parameter structure to a component. Each structure shall be sent one at a time, in a separate invocation of the macro. This macro can only be invoked when the component is in the OMX_StateLoaded state, or the port is disabled (when the parameter applies to a port). The nParamIndex parameter is used to indicate which structure is being passed to the component. The application shall allocate the correct structure and shall fill in the structure size and version information (as well as the actual data) before invoking this macro. The application is free to dispose of this structure after the call as the component is required to copy any data it shall retain. This is a blocking call.

The component should return from this call within 20 msec.

Parameters:
[in] hComponent Handle of the component to be accessed. This is the component handle returned by the call to the OMX_GetHandle function.
[in] nIndex Index of the structure to be sent. This value is from the OMX_INDEXTYPE enumeration.
[in] pComponentParameterStructure pointer to application allocated structure to be used for initialization by the component.
Returns:
OMX_ERRORTYPE If the command successfully executes, the return code will be OMX_ErrorNone. Otherwise the appropriate OMX error will be returned.

Typedef Documentation

The OMX_HANDLETYPE structure defines the component handle. The component handle is used to access all of the component's public methods and also contains pointers to the component's private data area. The component handle is initialized by the OMX core (with help from the component) during the process of loading the component. After the component is successfully loaded, the application can safely access any of the component's public functions (although some may return an error because the state is inappropriate for the access).

OMX_Component.h - OpenMax IL version 1.1.2 The OMX_Component header file contains the definitions used to define the public interface of a component. This header file is intended to be used by both the application and the component.

The OMX_STATETYPE enumeration is used to indicate or change the component state. This enumeration reflects the current state of the component when used with the OMX_GetState macro or becomes the parameter in a state change command when used with the OMX_SendCommand macro.

The component will be in the Loaded state after the component is initially loaded into memory. In the Loaded state, the component is not allowed to allocate or hold resources other than to build it's internal parameter and configuration tables. The application will send one or more SetParameters/GetParameters and SetConfig/GetConfig commands to the component and the component will record each of these parameter and configuration changes for use later. When the application sends the Idle command, the component will acquire the resources needed for the specified configuration and will transition to the idle state if the allocation is successful. If the component cannot successfully transition to the idle state for any reason, the state of the component shall be fully rolled back to the Loaded state (e.g. all allocated resources shall be released). When the component receives the command to go to the Executing state, it shall begin processing buffers by sending all input buffers it holds to the application. While the component is in the Idle state, the application may also send the Pause command. If the component receives the pause command while in the Idle state, the component shall send all input buffers it holds to the application, but shall not begin processing buffers. This will allow the application to prefill buffers.


Enumeration Type Documentation

Enumerator:
OMX_EventCmdComplete 

component has sucessfully completed a command

OMX_EventError 

component has detected an error condition

OMX_EventMark 

component has detected a buffer mark

OMX_EventPortSettingsChanged 

component is reported a port settings change

OMX_EventBufferFlag 

component has detected an EOS

OMX_EventResourcesAcquired 

component has been granted resources and is automatically starting the state change from OMX_StateWaitForResources to OMX_StateIdle.

OMX_EventComponentResumed 

Component resumed due to reacquisition of resources

OMX_EventDynamicResourcesAvailable 

Component has acquired previously unavailable dynamic resources

OMX_EventPortFormatDetected 

Component has detected a supported format.

OMX_EventKhronosExtensions 

Reserved region for introducing Khronos Standard Extensions

OMX_EventVendorStartUnused 

Reserved region for introducing Vendor Extensions

OMX_EventMax 

OMX_Component.h - OpenMax IL version 1.1.2 The OMX_Component header file contains the definitions used to define the public interface of a component. This header file is intended to be used by both the application and the component.

Enumerator:
OMX_PortDomainAudio 
OMX_PortDomainVideo 
OMX_PortDomainImage 
OMX_PortDomainOther 
OMX_PortDomainKhronosExtensions 

Reserved region for introducing Khronos Standard Extensions

OMX_PortDomainVendorStartUnused 

Reserved region for introducing Vendor Extensions

OMX_PortDomainMax 

The OMX_STATETYPE enumeration is used to indicate or change the component state. This enumeration reflects the current state of the component when used with the OMX_GetState macro or becomes the parameter in a state change command when used with the OMX_SendCommand macro.

The component will be in the Loaded state after the component is initially loaded into memory. In the Loaded state, the component is not allowed to allocate or hold resources other than to build it's internal parameter and configuration tables. The application will send one or more SetParameters/GetParameters and SetConfig/GetConfig commands to the component and the component will record each of these parameter and configuration changes for use later. When the application sends the Idle command, the component will acquire the resources needed for the specified configuration and will transition to the idle state if the allocation is successful. If the component cannot successfully transition to the idle state for any reason, the state of the component shall be fully rolled back to the Loaded state (e.g. all allocated resources shall be released). When the component receives the command to go to the Executing state, it shall begin processing buffers by sending all input buffers it holds to the application. While the component is in the Idle state, the application may also send the Pause command. If the component receives the pause command while in the Idle state, the component shall send all input buffers it holds to the application, but shall not begin processing buffers. This will allow the application to prefill buffers.

Enumerator:
OMX_StateInvalid 

component has detected that it's internal data structures are corrupted to the point that it cannot determine it's state properly

OMX_StateLoaded 

component has been loaded but has not completed initialization. The OMX_SetParameter macro and the OMX_GetParameter macro are the only valid macros allowed to be sent to the component in this state.

OMX_StateIdle 

component initialization has been completed successfully and the component is ready to to start.

OMX_StateExecuting 

component has accepted the start command and is processing data (if data is available)

OMX_StatePause 

component has received pause command

OMX_StateWaitForResources 

component is waiting for resources, either after preemption or before it gets the resources requested. See specification for complete details.

OMX_StateKhronosExtensions 

Reserved region for introducing Khronos Standard Extensions

OMX_StateVendorStartUnused 

Reserved region for introducing Vendor Extensions

OMX_StateMax 
LIMOpenMAX Implementation API Reference - Generated by doxygen