OpenMAXBellagio  0.9.3
OpenMAX IL component

Modules

 Tunneling
 

Data Structures

struct  OMX_PARAM_PORTDEFINITIONTYPE
 
struct  OMX_PARAM_U32TYPE
 
struct  OMX_COMPONENTTYPE
 
struct  OMX_PARAM_COMPONENTROLETYPE
 
struct  OMX_PORT_PARAM_TYPE
 

Macros

#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

Macro Definition Documentation

◆ OMX_GetComponentVersion

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

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]hComponenthandle of component to execute the command
[out]pComponentNamepointer 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]pComponentVersionpointer 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]pSpecVersionpointer 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]pComponentUUIDpointer 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.

Definition at line 684 of file OMX_Core.h.

◆ OMX_GetConfig

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

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]hComponentHandle of the component to be accessed. This is the component handle returned by the call to the OMX_GetHandle function.
[in]nIndexIndex of the structure to be filled. This value is from the OMX_INDEXTYPE enumeration.
[in,out]pComponentConfigStructurepointer 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.

Definition at line 861 of file OMX_Core.h.

◆ OMX_GetExtensionIndex

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

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]hComponentHandle of the component to be accessed. This is the component handle returned by the call to the GetHandle function.
[in]cParameterNameOMX_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]pIndexTypea 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.

Definition at line 931 of file OMX_Core.h.

◆ OMX_GetParameter

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

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]hComponentHandle of the component to be accessed. This is the component handle returned by the call to the OMX_GetHandle function.
[in]nParamIndexIndex of the structure to be filled. This value is from the OMX_INDEXTYPE enumeration.
[in,out]pComponentParameterStructurePointer 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.

Definition at line 786 of file OMX_Core.h.

◆ OMX_GetState

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

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]hComponentHandle of the component to be accessed. This is the component handle returned by the call to the OMX_GetHandle function.
[out]pStatepointer 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.

Definition at line 958 of file OMX_Core.h.

◆ OMX_SendCommand

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

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]hComponenthandle of component to execute the command
[in]CmdCommand for the component to execute
[in]nParamParameter 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]pCmdDataParameter 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.

Definition at line 745 of file OMX_Core.h.

◆ OMX_SetConfig

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

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]hComponentHandle of the component to be accessed. This is the component handle returned by the call to the OMX_GetHandle function.
[in]nConfigIndexIndex of the structure to be sent. This value is from the OMX_INDEXTYPE enumeration above.
[in]pComponentConfigStructurepointer 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.

Definition at line 897 of file OMX_Core.h.

◆ OMX_SetParameter

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

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]hComponentHandle of the component to be accessed. This is the component handle returned by the call to the OMX_GetHandle function.
[in]nIndexIndex of the structure to be sent. This value is from the OMX_INDEXTYPE enumeration.
[in]pComponentParameterStructurepointer 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.

Definition at line 825 of file OMX_Core.h.

Typedef Documentation

◆ OMX_COMPONENTTYPE

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_EVENTTYPE

◆ OMX_PARAM_COMPONENTROLETYPE

◆ OMX_PARAM_PORTDEFINITIONTYPE

◆ OMX_PARAM_U32TYPE

◆ OMX_PORT_PARAM_TYPE

◆ OMX_PORTDOMAINTYPE

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.

◆ OMX_STATETYPE

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

◆ OMX_EVENTTYPE

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 

Definition at line 479 of file OMX_Core.h.

◆ OMX_PORTDOMAINTYPE

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 

Definition at line 50 of file OMX_Component.h.

◆ OMX_STATETYPE

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 

Definition at line 92 of file OMX_Core.h.

OMX_COMPONENTTYPE
Definition: OMX_Component.h:308

Generated for OpenMAX Bellagio rel. 0.9.3 by  doxygen 1.5.1
SourceForge.net Logo