You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1440 lines
68 KiB
1440 lines
68 KiB
/*
|
|
* Copyright (c) 2008 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.
|
|
*
|
|
*/
|
|
|
|
/** OMX_Core.h - OpenMax IL version 1.1.2
|
|
* The OMX_Core header file contains the definitions used by both the
|
|
* application and the component to access common items.
|
|
*/
|
|
|
|
#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>
|
|
|
|
|
|
/** The OMX_COMMANDTYPE enumeration is used to specify the action in the
|
|
* OMX_SendCommand macro.
|
|
* @ingroup core
|
|
*/
|
|
typedef enum OMX_COMMANDTYPE
|
|
{
|
|
OMX_CommandStateSet, /**< Change the component state */
|
|
OMX_CommandFlush, /**< Flush the data queue(s) of a component */
|
|
OMX_CommandPortDisable, /**< Disable a port on a component. */
|
|
OMX_CommandPortEnable, /**< Enable a port on a component. */
|
|
OMX_CommandMarkBuffer, /**< Mark a component/buffer for observation */
|
|
OMX_CommandKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
|
OMX_CommandVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
|
|
OMX_CommandMax = 0X7FFFFFFF
|
|
} OMX_COMMANDTYPE;
|
|
|
|
|
|
|
|
/** 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.
|
|
*
|
|
* @ingroup comp
|
|
*/
|
|
|
|
typedef enum OMX_STATETYPE
|
|
{
|
|
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 = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
|
OMX_StateVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
|
|
OMX_StateMax = 0X7FFFFFFF
|
|
} OMX_STATETYPE;
|
|
|
|
/** The OMX_ERRORTYPE enumeration defines the standard OMX Errors. These
|
|
* errors should cover most of the common failure cases. However,
|
|
* vendors are free to add additional error messages of their own as
|
|
* long as they follow these rules:
|
|
* 1. Vendor error messages shall be in the range of 0x90000000 to
|
|
* 0x9000FFFF.
|
|
* 2. Vendor error messages shall be defined in a header file provided
|
|
* with the component. No error messages are allowed that are
|
|
* not defined.
|
|
*/
|
|
typedef enum OMX_ERRORTYPE
|
|
{
|
|
OMX_ErrorNone = 0,
|
|
|
|
/** There were insufficient resources to perform the requested operation */
|
|
OMX_ErrorInsufficientResources = (OMX_S32) 0x80001000,
|
|
|
|
/** There was an error, but the cause of the error could not be determined */
|
|
OMX_ErrorUndefined = (OMX_S32) 0x80001001,
|
|
|
|
/** The component name string was not valid */
|
|
OMX_ErrorInvalidComponentName = (OMX_S32) 0x80001002,
|
|
|
|
/** No component with the specified name string was found */
|
|
OMX_ErrorComponentNotFound = (OMX_S32) 0x80001003,
|
|
|
|
/** The component specified did not have a "OMX_ComponentInit" or
|
|
"OMX_ComponentDeInit entry point */
|
|
OMX_ErrorInvalidComponent = (OMX_S32) 0x80001004,
|
|
|
|
/** One or more parameters were not valid */
|
|
OMX_ErrorBadParameter = (OMX_S32) 0x80001005,
|
|
|
|
/** The requested function is not implemented */
|
|
OMX_ErrorNotImplemented = (OMX_S32) 0x80001006,
|
|
|
|
/** The buffer was emptied before the next buffer was ready */
|
|
OMX_ErrorUnderflow = (OMX_S32) 0x80001007,
|
|
|
|
/** The buffer was not available when it was needed */
|
|
OMX_ErrorOverflow = (OMX_S32) 0x80001008,
|
|
|
|
/** The hardware failed to respond as expected */
|
|
OMX_ErrorHardware = (OMX_S32) 0x80001009,
|
|
|
|
/** The component is in the state OMX_StateInvalid */
|
|
OMX_ErrorInvalidState = (OMX_S32) 0x8000100A,
|
|
|
|
/** Stream is found to be corrupt */
|
|
OMX_ErrorStreamCorrupt = (OMX_S32) 0x8000100B,
|
|
|
|
/** Ports being connected are not compatible */
|
|
OMX_ErrorPortsNotCompatible = (OMX_S32) 0x8000100C,
|
|
|
|
/** Resources allocated to an idle component have been
|
|
lost resulting in the component returning to the loaded state */
|
|
OMX_ErrorResourcesLost = (OMX_S32) 0x8000100D,
|
|
|
|
/** No more indicies can be enumerated */
|
|
OMX_ErrorNoMore = (OMX_S32) 0x8000100E,
|
|
|
|
/** The component detected a version mismatch */
|
|
OMX_ErrorVersionMismatch = (OMX_S32) 0x8000100F,
|
|
|
|
/** The component is not ready to return data at this time */
|
|
OMX_ErrorNotReady = (OMX_S32) 0x80001010,
|
|
|
|
/** There was a timeout that occurred */
|
|
OMX_ErrorTimeout = (OMX_S32) 0x80001011,
|
|
|
|
/** This error occurs when trying to transition into the state you are already in */
|
|
OMX_ErrorSameState = (OMX_S32) 0x80001012,
|
|
|
|
/** Resources allocated to an executing or paused component have been
|
|
preempted, causing the component to return to the idle state */
|
|
OMX_ErrorResourcesPreempted = (OMX_S32) 0x80001013,
|
|
|
|
/** A non-supplier port sends this error to the IL client (via the EventHandler callback)
|
|
during the allocation of buffers (on a transition from the LOADED to the IDLE state or
|
|
on a port restart) when it deems that it has waited an unusually long time for the supplier
|
|
to send it an allocated buffer via a UseBuffer call. */
|
|
OMX_ErrorPortUnresponsiveDuringAllocation = (OMX_S32) 0x80001014,
|
|
|
|
/** A non-supplier port sends this error to the IL client (via the EventHandler callback)
|
|
during the deallocation of buffers (on a transition from the IDLE to LOADED state or
|
|
on a port stop) when it deems that it has waited an unusually long time for the supplier
|
|
to request the deallocation of a buffer header via a FreeBuffer call. */
|
|
OMX_ErrorPortUnresponsiveDuringDeallocation = (OMX_S32) 0x80001015,
|
|
|
|
/** A supplier port sends this error to the IL client (via the EventHandler callback)
|
|
during the stopping of a port (either on a transition from the IDLE to LOADED
|
|
state or a port stop) when it deems that it has waited an unusually long time for
|
|
the non-supplier to return a buffer via an EmptyThisBuffer or FillThisBuffer call. */
|
|
OMX_ErrorPortUnresponsiveDuringStop = (OMX_S32) 0x80001016,
|
|
|
|
/** Attempting a state transtion that is not allowed */
|
|
OMX_ErrorIncorrectStateTransition = (OMX_S32) 0x80001017,
|
|
|
|
/* Attempting a command that is not allowed during the present state. */
|
|
OMX_ErrorIncorrectStateOperation = (OMX_S32) 0x80001018,
|
|
|
|
/** The values encapsulated in the parameter or config structure are not supported. */
|
|
OMX_ErrorUnsupportedSetting = (OMX_S32) 0x80001019,
|
|
|
|
/** The parameter or config indicated by the given index is not supported. */
|
|
OMX_ErrorUnsupportedIndex = (OMX_S32) 0x8000101A,
|
|
|
|
/** The port index supplied is incorrect. */
|
|
OMX_ErrorBadPortIndex = (OMX_S32) 0x8000101B,
|
|
|
|
/** The port has lost one or more of its buffers and it thus unpopulated. */
|
|
OMX_ErrorPortUnpopulated = (OMX_S32) 0x8000101C,
|
|
|
|
/** Component suspended due to temporary loss of resources */
|
|
OMX_ErrorComponentSuspended = (OMX_S32) 0x8000101D,
|
|
|
|
/** Component suspended due to an inability to acquire dynamic resources */
|
|
OMX_ErrorDynamicResourcesUnavailable = (OMX_S32) 0x8000101E,
|
|
|
|
/** When the macroblock error reporting is enabled the component returns new error
|
|
for every frame that has errors */
|
|
OMX_ErrorMbErrorsInFrame = (OMX_S32) 0x8000101F,
|
|
|
|
/** A component reports this error when it cannot parse or determine the format of an input stream. */
|
|
OMX_ErrorFormatNotDetected = (OMX_S32) 0x80001020,
|
|
|
|
/** The content open operation failed. */
|
|
OMX_ErrorContentPipeOpenFailed = (OMX_S32) 0x80001021,
|
|
|
|
/** The content creation operation failed. */
|
|
OMX_ErrorContentPipeCreationFailed = (OMX_S32) 0x80001022,
|
|
|
|
/** Separate table information is being used */
|
|
OMX_ErrorSeperateTablesUsed = (OMX_S32) 0x80001023,
|
|
|
|
/** Tunneling is unsupported by the component*/
|
|
OMX_ErrorTunnelingUnsupported = (OMX_S32) 0x80001024,
|
|
|
|
OMX_ErrorKhronosExtensions = (OMX_S32)0x8F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
|
OMX_ErrorVendorStartUnused = (OMX_S32)0x90000000, /**< Reserved region for introducing Vendor Extensions */
|
|
OMX_ErrorMax = 0x7FFFFFFF
|
|
} OMX_ERRORTYPE;
|
|
|
|
/** @ingroup core */
|
|
typedef OMX_ERRORTYPE (* OMX_COMPONENTINITTYPE)(OMX_IN OMX_HANDLETYPE hComponent);
|
|
|
|
/** @ingroup core */
|
|
typedef struct OMX_COMPONENTREGISTERTYPE
|
|
{
|
|
const char * pName; /* Component name, 128 byte limit (including '\0') applies */
|
|
OMX_COMPONENTINITTYPE pInitialize; /* Component instance initialization function */
|
|
} OMX_COMPONENTREGISTERTYPE;
|
|
|
|
/** @ingroup core */
|
|
extern OMX_COMPONENTREGISTERTYPE OMX_ComponentRegistered[];
|
|
|
|
/** @ingroup rpm */
|
|
typedef struct OMX_PRIORITYMGMTTYPE {
|
|
OMX_U32 nSize; /**< size of the structure in bytes */
|
|
OMX_VERSIONTYPE nVersion; /**< OMX specification version information */
|
|
OMX_U32 nGroupPriority; /**< Priority of the component group */
|
|
OMX_U32 nGroupID; /**< ID of the component group */
|
|
} OMX_PRIORITYMGMTTYPE;
|
|
|
|
/* Component name and Role names are limited to 128 characters including the terminating '\0'. */
|
|
#define OMX_MAX_STRINGNAME_SIZE 128
|
|
|
|
/** @ingroup comp */
|
|
typedef struct OMX_PARAM_COMPONENTROLETYPE {
|
|
OMX_U32 nSize; /**< size of the structure in bytes */
|
|
OMX_VERSIONTYPE nVersion; /**< OMX specification version information */
|
|
OMX_U8 cRole[OMX_MAX_STRINGNAME_SIZE]; /**< name of standard component which defines component role */
|
|
} OMX_PARAM_COMPONENTROLETYPE;
|
|
|
|
/** End of Stream Buffer Flag:
|
|
*
|
|
* A component sets EOS when it has no more data to emit on a particular
|
|
* output port. Thus an output port shall set EOS on the last buffer it
|
|
* emits. A component's determination of when an output port should
|
|
* cease sending data is implemenation specific.
|
|
* @ingroup buf
|
|
*/
|
|
|
|
#define OMX_BUFFERFLAG_EOS 0x00000001
|
|
|
|
/** Start Time Buffer Flag:
|
|
*
|
|
* The source of a stream (e.g. a demux component) sets the STARTTIME
|
|
* flag on the buffer that contains the starting timestamp for the
|
|
* stream. The starting timestamp corresponds to the first data that
|
|
* should be displayed at startup or after a seek.
|
|
* The first timestamp of the stream is not necessarily the start time.
|
|
* For instance, in the case of a seek to a particular video frame,
|
|
* the target frame may be an interframe. Thus the first buffer of
|
|
* the stream will be the intra-frame preceding the target frame and
|
|
* the starttime will occur with the target frame (with any other
|
|
* required frames required to reconstruct the target intervening).
|
|
*
|
|
* The STARTTIME flag is directly associated with the buffer's
|
|
* timestamp ' thus its association to buffer data and its
|
|
* propagation is identical to the timestamp's.
|
|
*
|
|
* When a Sync Component client receives a buffer with the
|
|
* STARTTIME flag it shall perform a SetConfig on its sync port
|
|
* using OMX_ConfigTimeClientStartTime and passing the buffer's
|
|
* timestamp.
|
|
*
|
|
* @ingroup buf
|
|
*/
|
|
|
|
#define OMX_BUFFERFLAG_STARTTIME 0x00000002
|
|
|
|
|
|
|
|
/** Decode Only Buffer Flag:
|
|
*
|
|
* The source of a stream (e.g. a demux component) sets the DECODEONLY
|
|
* flag on any buffer that should shall be decoded but should not be
|
|
* displayed. This flag is used, for instance, when a source seeks to
|
|
* a target interframe that requires the decode of frames preceding the
|
|
* target to facilitate the target's reconstruction. In this case the
|
|
* source would emit the frames preceding the target downstream
|
|
* but mark them as decode only.
|
|
*
|
|
* The DECODEONLY is associated with buffer data and propagated in a
|
|
* manner identical to the buffer timestamp.
|
|
*
|
|
* A component that renders data should ignore all buffers with
|
|
* the DECODEONLY flag set.
|
|
*
|
|
* @ingroup buf
|
|
*/
|
|
|
|
#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
|
|
|
|
/** Codec Config Buffer Flag:
|
|
* OMX_BUFFERFLAG_CODECCONFIG is an optional flag that is set by an
|
|
* output port when all bytes in the buffer form part or all of a set of
|
|
* codec specific configuration data. Examples include SPS/PPS nal units
|
|
* for OMX_VIDEO_CodingAVC or AudioSpecificConfig data for
|
|
* OMX_AUDIO_CodingAAC. Any component that for a given stream sets
|
|
* OMX_BUFFERFLAG_CODECCONFIG shall not mix codec configuration bytes
|
|
* with frame data in the same buffer, and shall send all buffers
|
|
* containing codec configuration bytes before any buffers containing
|
|
* frame data that those configurations bytes describe.
|
|
* If the stream format for a particular codec has a frame specific
|
|
* header at the start of each frame, for example OMX_AUDIO_CodingMP3 or
|
|
* OMX_AUDIO_CodingAAC in ADTS mode, then these shall be presented as
|
|
* normal without setting OMX_BUFFERFLAG_CODECCONFIG.
|
|
* @ingroup buf
|
|
*/
|
|
#define OMX_BUFFERFLAG_CODECCONFIG 0x00000080
|
|
|
|
/*
|
|
* OMX_BUFFERFLAG_READONLY: This flag is set when a component emitting the
|
|
* buffer on an output port or the IL client wishes to identify the buffer
|
|
* payload contents to be read-only. An IL client or an input port
|
|
* shall not alter the contents of the buffer. This flag shall only be
|
|
* cleared by the originator of the buffer when the buffer is returned.
|
|
* For tunneled ports, the usage of this flag shall be allowed only if the
|
|
* components negotiated a read-only tunnel
|
|
*/
|
|
#define OMX_BUFFERFLAG_READONLY 0x00000200
|
|
|
|
/** @ingroup buf */
|
|
typedef struct OMX_BUFFERHEADERTYPE
|
|
{
|
|
OMX_U32 nSize; /**< size of the structure in bytes */
|
|
OMX_VERSIONTYPE nVersion; /**< OMX specification version information */
|
|
OMX_U8* pBuffer; /**< Pointer to actual block of memory
|
|
that is acting as the buffer */
|
|
OMX_U32 nAllocLen; /**< size of the buffer allocated, in bytes */
|
|
OMX_U32 nFilledLen; /**< number of bytes currently in the
|
|
buffer */
|
|
OMX_U32 nOffset; /**< start offset of valid data in bytes from
|
|
the start of the buffer */
|
|
OMX_PTR pAppPrivate; /**< pointer to any data the application
|
|
wants to associate with this buffer */
|
|
OMX_PTR pPlatformPrivate; /**< pointer to any data the platform
|
|
wants to associate with this buffer */
|
|
OMX_PTR pInputPortPrivate; /**< pointer to any data the input port
|
|
wants to associate with this buffer */
|
|
OMX_PTR pOutputPortPrivate; /**< pointer to any data the output port
|
|
wants to associate with this buffer */
|
|
OMX_HANDLETYPE hMarkTargetComponent; /**< The component that will generate a
|
|
mark event upon processing this buffer. */
|
|
OMX_PTR pMarkData; /**< Application specific data associated with
|
|
the mark sent on a mark event to disambiguate
|
|
this mark from others. */
|
|
OMX_U32 nTickCount; /**< Optional entry that the component and
|
|
application can update with a tick count
|
|
when they access the component. This
|
|
value should be in microseconds. Since
|
|
this is a value relative to an arbitrary
|
|
starting point, this value cannot be used
|
|
to determine absolute time. This is an
|
|
optional entry and not all components
|
|
will update it.*/
|
|
OMX_TICKS nTimeStamp; /**< Timestamp corresponding to the sample
|
|
starting at the first logical sample
|
|
boundary in the buffer. Timestamps of
|
|
successive samples within the buffer may
|
|
be inferred by adding the duration of the
|
|
of the preceding buffer to the timestamp
|
|
of the preceding buffer.*/
|
|
OMX_U32 nFlags; /**< buffer specific flags */
|
|
OMX_U32 nOutputPortIndex; /**< The index of the output port (if any) using
|
|
this buffer */
|
|
OMX_U32 nInputPortIndex; /**< The index of the input port (if any) using
|
|
this buffer */
|
|
} OMX_BUFFERHEADERTYPE;
|
|
|
|
/** The OMX_EXTRADATATYPE enumeration is used to define the
|
|
* possible extra data payload types.
|
|
* NB: this enum is binary backwards compatible with the previous
|
|
* OMX_EXTRADATA_QUANT define. This should be replaced with
|
|
* OMX_ExtraDataQuantization.
|
|
*/
|
|
typedef enum OMX_EXTRADATATYPE
|
|
{
|
|
OMX_ExtraDataNone = 0, /**< Indicates that no more extra data sections follow */
|
|
OMX_ExtraDataQuantization, /**< The data payload contains quantization data */
|
|
OMX_ExtraDataKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
|
OMX_ExtraDataVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
|
|
OMX_ExtraDataMax = 0x7FFFFFFF
|
|
} OMX_EXTRADATATYPE;
|
|
|
|
|
|
typedef struct OMX_OTHER_EXTRADATATYPE {
|
|
OMX_U32 nSize;
|
|
OMX_VERSIONTYPE nVersion;
|
|
OMX_U32 nPortIndex;
|
|
OMX_EXTRADATATYPE eType; /* Extra Data type */
|
|
OMX_U32 nDataSize; /* Size of the supporting data to follow */
|
|
OMX_U8 data[1]; /* Supporting data hint */
|
|
} OMX_OTHER_EXTRADATATYPE;
|
|
|
|
/** @ingroup comp */
|
|
typedef struct OMX_PORT_PARAM_TYPE {
|
|
OMX_U32 nSize; /**< size of the structure in bytes */
|
|
OMX_VERSIONTYPE nVersion; /**< OMX specification version information */
|
|
OMX_U32 nPorts; /**< The number of ports for this component */
|
|
OMX_U32 nStartPortNumber; /** first port number for this type of port */
|
|
} OMX_PORT_PARAM_TYPE;
|
|
|
|
/** @ingroup comp */
|
|
typedef enum OMX_EVENTTYPE
|
|
{
|
|
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 = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
|
OMX_EventVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
|
|
OMX_EventMax = 0x7FFFFFFF
|
|
} OMX_EVENTTYPE;
|
|
|
|
typedef struct OMX_CALLBACKTYPE
|
|
{
|
|
/** The EventHandler method is used to notify the application when an
|
|
event of interest occurs. Events are defined in the OMX_EVENTTYPE
|
|
enumeration. Please see that enumeration for details of what will
|
|
be returned for each type of event. Callbacks should not return
|
|
an error to the component, so if an error occurs, the application
|
|
shall handle it internally. This is a blocking call.
|
|
|
|
The application should return from this call within 5 msec to avoid
|
|
blocking the component for an excessively long period of time.
|
|
|
|
@param hComponent
|
|
handle of the component to access. This is the component
|
|
handle returned by the call to the GetHandle function.
|
|
@param pAppData
|
|
pointer to an application defined value that was provided in the
|
|
pAppData parameter to the OMX_GetHandle method for the component.
|
|
This application defined value is provided so that the application
|
|
can have a component specific context when receiving the callback.
|
|
@param eEvent
|
|
Event that the component wants to notify the application about.
|
|
@param nData1
|
|
nData will be the OMX_ERRORTYPE for an error event and will be
|
|
an OMX_COMMANDTYPE for a command complete event and OMX_INDEXTYPE for a OMX_PortSettingsChanged event.
|
|
@param nData2
|
|
nData2 will hold further information related to the event. Can be OMX_STATETYPE for
|
|
a OMX_CommandStateSet command or port index for a OMX_PortSettingsChanged event.
|
|
Default value is 0 if not used. )
|
|
@param pEventData
|
|
Pointer to additional event-specific data (see spec for meaning).
|
|
*/
|
|
|
|
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);
|
|
|
|
/** The EmptyBufferDone method is used to return emptied buffers from an
|
|
input port back to the application for reuse. This is a blocking call
|
|
so the application should not attempt to refill the buffers during this
|
|
call, but should queue them and refill them in another thread. There
|
|
is no error return, so the application shall handle any errors generated
|
|
internally.
|
|
|
|
The application should return from this call within 5 msec.
|
|
|
|
@param hComponent
|
|
handle of the component to access. This is the component
|
|
handle returned by the call to the GetHandle function.
|
|
@param pAppData
|
|
pointer to an application defined value that was provided in the
|
|
pAppData parameter to the OMX_GetHandle method for the component.
|
|
This application defined value is provided so that the application
|
|
can have a component specific context when receiving the callback.
|
|
@param pBuffer
|
|
pointer to an OMX_BUFFERHEADERTYPE structure allocated with UseBuffer
|
|
or AllocateBuffer indicating the buffer that was emptied.
|
|
@ingroup buf
|
|
*/
|
|
OMX_ERRORTYPE (*EmptyBufferDone)(
|
|
OMX_IN OMX_HANDLETYPE hComponent,
|
|
OMX_IN OMX_PTR pAppData,
|
|
OMX_IN OMX_BUFFERHEADERTYPE* pBuffer);
|
|
|
|
/** The FillBufferDone method is used to return filled buffers from an
|
|
output port back to the application for emptying and then reuse.
|
|
This is a blocking call so the application should not attempt to
|
|
empty the buffers during this call, but should queue the buffers
|
|
and empty them in another thread. There is no error return, so
|
|
the application shall handle any errors generated internally. The
|
|
application shall also update the buffer header to indicate the
|
|
number of bytes placed into the buffer.
|
|
|
|
The application should return from this call within 5 msec.
|
|
|
|
@param hComponent
|
|
handle of the component to access. This is the component
|
|
handle returned by the call to the GetHandle function.
|
|
@param pAppData
|
|
pointer to an application defined value that was provided in the
|
|
pAppData parameter to the OMX_GetHandle method for the component.
|
|
This application defined value is provided so that the application
|
|
can have a component specific context when receiving the callback.
|
|
@param pBuffer
|
|
pointer to an OMX_BUFFERHEADERTYPE structure allocated with UseBuffer
|
|
or AllocateBuffer indicating the buffer that was filled.
|
|
@ingroup buf
|
|
*/
|
|
OMX_ERRORTYPE (*FillBufferDone)(
|
|
OMX_OUT OMX_HANDLETYPE hComponent,
|
|
OMX_OUT OMX_PTR pAppData,
|
|
OMX_OUT OMX_BUFFERHEADERTYPE* pBuffer);
|
|
|
|
} OMX_CALLBACKTYPE;
|
|
|
|
/** The OMX_BUFFERSUPPLIERTYPE enumeration is used to dictate port supplier
|
|
preference when tunneling between two ports.
|
|
@ingroup tun buf
|
|
*/
|
|
typedef enum OMX_BUFFERSUPPLIERTYPE
|
|
{
|
|
OMX_BufferSupplyUnspecified = 0x0, /**< port supplying the buffers is unspecified,
|
|
or don't care */
|
|
OMX_BufferSupplyInput, /**< input port supplies the buffers */
|
|
OMX_BufferSupplyOutput, /**< output port supplies the buffers */
|
|
OMX_BufferSupplyKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
|
OMX_BufferSupplyVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
|
|
OMX_BufferSupplyMax = 0x7FFFFFFF
|
|
} OMX_BUFFERSUPPLIERTYPE;
|
|
|
|
|
|
/** buffer supplier parameter
|
|
* @ingroup tun
|
|
*/
|
|
typedef struct OMX_PARAM_BUFFERSUPPLIERTYPE {
|
|
OMX_U32 nSize; /**< size of the structure in bytes */
|
|
OMX_VERSIONTYPE nVersion; /**< OMX specification version information */
|
|
OMX_U32 nPortIndex; /**< port that this structure applies to */
|
|
OMX_BUFFERSUPPLIERTYPE eBufferSupplier; /**< buffer supplier */
|
|
} OMX_PARAM_BUFFERSUPPLIERTYPE;
|
|
|
|
|
|
/**< indicates that buffers received by an input port of a tunnel
|
|
may not modify the data in the buffers
|
|
@ingroup tun
|
|
*/
|
|
#define OMX_PORTTUNNELFLAG_READONLY 0x00000001
|
|
|
|
|
|
/** The OMX_TUNNELSETUPTYPE structure is used to pass data from an output
|
|
port to an input port as part the two ComponentTunnelRequest calls
|
|
resulting from a OMX_SetupTunnel call from the IL Client.
|
|
@ingroup tun
|
|
*/
|
|
typedef struct OMX_TUNNELSETUPTYPE
|
|
{
|
|
OMX_U32 nTunnelFlags; /**< bit flags for tunneling */
|
|
OMX_BUFFERSUPPLIERTYPE eSupplier; /**< supplier preference */
|
|
} 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> */
|
|
|
|
/** 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.
|
|
@param [in] hComponent
|
|
handle of component to execute the command
|
|
@param [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".
|
|
@param [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.
|
|
@param [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.
|
|
@param [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.
|
|
@return OMX_ERRORTYPE
|
|
If the command successfully executes, the return code will be
|
|
OMX_ErrorNone. Otherwise the appropriate OMX error will be returned.
|
|
@ingroup comp
|
|
*/
|
|
#define OMX_GetComponentVersion( \
|
|
hComponent, \
|
|
pComponentName, \
|
|
pComponentVersion, \
|
|
pSpecVersion, \
|
|
pComponentUUID) \
|
|
((OMX_COMPONENTTYPE*)hComponent)->GetComponentVersion( \
|
|
hComponent, \
|
|
pComponentName, \
|
|
pComponentVersion, \
|
|
pSpecVersion, \
|
|
pComponentUUID) /* 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.
|
|
|
|
@param [in] hComponent
|
|
handle of component to execute the command
|
|
@param [in] Cmd
|
|
Command for the component to execute
|
|
@param [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.
|
|
@param [in] pCmdData
|
|
Parameter pointing to the OMX_MARKTYPE structure when Cmd has the value
|
|
"OMX_CommandMarkBuffer".
|
|
@return OMX_ERRORTYPE
|
|
If the command successfully executes, the return code will be
|
|
OMX_ErrorNone. Otherwise the appropriate OMX error will be returned.
|
|
@ingroup comp
|
|
*/
|
|
#define OMX_SendCommand( \
|
|
hComponent, \
|
|
Cmd, \
|
|
nParam, \
|
|
pCmdData) \
|
|
((OMX_COMPONENTTYPE*)hComponent)->SendCommand( \
|
|
hComponent, \
|
|
Cmd, \
|
|
nParam, \
|
|
pCmdData) /* 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.
|
|
|
|
@param [in] hComponent
|
|
Handle of the component to be accessed. This is the component
|
|
handle returned by the call to the OMX_GetHandle function.
|
|
@param [in] nParamIndex
|
|
Index of the structure to be filled. This value is from the
|
|
OMX_INDEXTYPE enumeration.
|
|
@param [in,out] pComponentParameterStructure
|
|
Pointer to application allocated structure to be filled by the
|
|
component.
|
|
@return OMX_ERRORTYPE
|
|
If the command successfully executes, the return code will be
|
|
OMX_ErrorNone. Otherwise the appropriate OMX error will be returned.
|
|
@ingroup comp
|
|
*/
|
|
#define OMX_GetParameter( \
|
|
hComponent, \
|
|
nParamIndex, \
|
|
pComponentParameterStructure) \
|
|
((OMX_COMPONENTTYPE*)hComponent)->GetParameter( \
|
|
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.
|
|
|
|
@param [in] hComponent
|
|
Handle of the component to be accessed. This is the component
|
|
handle returned by the call to the OMX_GetHandle function.
|
|
@param [in] nIndex
|
|
Index of the structure to be sent. This value is from the
|
|
OMX_INDEXTYPE enumeration.
|
|
@param [in] pComponentParameterStructure
|
|
pointer to application allocated structure to be used for
|
|
initialization by the component.
|
|
@return OMX_ERRORTYPE
|
|
If the command successfully executes, the return code will be
|
|
OMX_ErrorNone. Otherwise the appropriate OMX error will be returned.
|
|
@ingroup comp
|
|
*/
|
|
#define OMX_SetParameter( \
|
|
hComponent, \
|
|
nParamIndex, \
|
|
pComponentParameterStructure) \
|
|
((OMX_COMPONENTTYPE*)hComponent)->SetParameter( \
|
|
hComponent, \
|
|
nParamIndex, \
|
|
pComponentParameterStructure) /* 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.
|
|
|
|
@param [in] hComponent
|
|
Handle of the component to be accessed. This is the component
|
|
handle returned by the call to the OMX_GetHandle function.
|
|
@param [in] nIndex
|
|
Index of the structure to be filled. This value is from the
|
|
OMX_INDEXTYPE enumeration.
|
|
@param [in,out] pComponentConfigStructure
|
|
pointer to application allocated structure to be filled by the
|
|
component.
|
|
@return OMX_ERRORTYPE
|
|
If the command successfully executes, the return code will be
|
|
OMX_ErrorNone. Otherwise the appropriate OMX error will be returned.
|
|
@ingroup comp
|
|
*/
|
|
#define OMX_GetConfig( \
|
|
hComponent, \
|
|
nConfigIndex, \
|
|
pComponentConfigStructure) \
|
|
((OMX_COMPONENTTYPE*)hComponent)->GetConfig( \
|
|
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.
|
|
|
|
@param [in] hComponent
|
|
Handle of the component to be accessed. This is the component
|
|
handle returned by the call to the OMX_GetHandle function.
|
|
@param [in] nConfigIndex
|
|
Index of the structure to be sent. This value is from the
|
|
OMX_INDEXTYPE enumeration above.
|
|
@param [in] pComponentConfigStructure
|
|
pointer to application allocated structure to be used for
|
|
initialization by the component.
|
|
@return OMX_ERRORTYPE
|
|
If the command successfully executes, the return code will be
|
|
OMX_ErrorNone. Otherwise the appropriate OMX error will be returned.
|
|
@ingroup comp
|
|
*/
|
|
#define OMX_SetConfig( \
|
|
hComponent, \
|
|
nConfigIndex, \
|
|
pComponentConfigStructure) \
|
|
((OMX_COMPONENTTYPE*)hComponent)->SetConfig( \
|
|
hComponent, \
|
|
nConfigIndex, \
|
|
pComponentConfigStructure) /* 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.
|
|
|
|
@param [in] hComponent
|
|
Handle of the component to be accessed. This is the component
|
|
handle returned by the call to the GetHandle function.
|
|
@param [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.
|
|
@param [out] pIndexType
|
|
a pointer to a OMX_INDEXTYPE to receive the index value.
|
|
@return OMX_ERRORTYPE
|
|
If the command successfully executes, the return code will be
|
|
OMX_ErrorNone. Otherwise the appropriate OMX error will be returned.
|
|
@ingroup comp
|
|
*/
|
|
#define OMX_GetExtensionIndex( \
|
|
hComponent, \
|
|
cParameterName, \
|
|
pIndexType) \
|
|
((OMX_COMPONENTTYPE*)hComponent)->GetExtensionIndex( \
|
|
hComponent, \
|
|
cParameterName, \
|
|
pIndexType) /* 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.
|
|
|
|
@param [in] hComponent
|
|
Handle of the component to be accessed. This is the component
|
|
handle returned by the call to the OMX_GetHandle function.
|
|
@param [out] pState
|
|
pointer to the location to receive the state. The value returned
|
|
is one of the OMX_STATETYPE members
|
|
@return OMX_ERRORTYPE
|
|
If the command successfully executes, the return code will be
|
|
OMX_ErrorNone. Otherwise the appropriate OMX error will be returned.
|
|
@ingroup comp
|
|
*/
|
|
#define OMX_GetState( \
|
|
hComponent, \
|
|
pState) \
|
|
((OMX_COMPONENTTYPE*)hComponent)->GetState( \
|
|
hComponent, \
|
|
pState) /* Macro End */
|
|
|
|
|
|
/** The OMX_UseBuffer macro will request that the component use
|
|
a buffer (and allocate its own buffer header) already allocated
|
|
by another component, or by the IL Client. This is a blocking
|
|
call.
|
|
|
|
The component should return from this call within 20 msec.
|
|
|
|
@param [in] hComponent
|
|
Handle of the component to be accessed. This is the component
|
|
handle returned by the call to the OMX_GetHandle function.
|
|
@param [out] ppBuffer
|
|
pointer to an OMX_BUFFERHEADERTYPE structure used to receive the
|
|
pointer to the buffer header
|
|
@return OMX_ERRORTYPE
|
|
If the command successfully executes, the return code will be
|
|
OMX_ErrorNone. Otherwise the appropriate OMX error will be returned.
|
|
@ingroup comp buf
|
|
*/
|
|
|
|
#define OMX_UseBuffer( \
|
|
hComponent, \
|
|
ppBufferHdr, \
|
|
nPortIndex, \
|
|
pAppPrivate, \
|
|
nSizeBytes, \
|
|
pBuffer) \
|
|
((OMX_COMPONENTTYPE*)hComponent)->UseBuffer( \
|
|
hComponent, \
|
|
ppBufferHdr, \
|
|
nPortIndex, \
|
|
pAppPrivate, \
|
|
nSizeBytes, \
|
|
pBuffer)
|
|
|
|
|
|
/** The OMX_AllocateBuffer macro will request that the component allocate
|
|
a new buffer and buffer header. The component will allocate the
|
|
buffer and the buffer header and return a pointer to the buffer
|
|
header. This is a blocking call.
|
|
|
|
The component should return from this call within 5 msec.
|
|
|
|
@param [in] hComponent
|
|
Handle of the component to be accessed. This is the component
|
|
handle returned by the call to the OMX_GetHandle function.
|
|
@param [out] ppBuffer
|
|
pointer to an OMX_BUFFERHEADERTYPE structure used to receive
|
|
the pointer to the buffer header
|
|
@param [in] nPortIndex
|
|
nPortIndex is used to select the port on the component the buffer will
|
|
be used with. The port can be found by using the nPortIndex
|
|
value as an index into the Port Definition array of the component.
|
|
@param [in] pAppPrivate
|
|
pAppPrivate is used to initialize the pAppPrivate member of the
|
|
buffer header structure.
|
|
@param [in] nSizeBytes
|
|
size of the buffer to allocate. Used when bAllocateNew is true.
|
|
@return OMX_ERRORTYPE
|
|
If the command successfully executes, the return code will be
|
|
OMX_ErrorNone. Otherwise the appropriate OMX error will be returned.
|
|
@ingroup comp buf
|
|
*/
|
|
#define OMX_AllocateBuffer( \
|
|
hComponent, \
|
|
ppBuffer, \
|
|
nPortIndex, \
|
|
pAppPrivate, \
|
|
nSizeBytes) \
|
|
((OMX_COMPONENTTYPE*)hComponent)->AllocateBuffer( \
|
|
hComponent, \
|
|
ppBuffer, \
|
|
nPortIndex, \
|
|
pAppPrivate, \
|
|
nSizeBytes) /* Macro End */
|
|
|
|
|
|
/** The OMX_FreeBuffer macro will release a buffer header from the component
|
|
which was allocated using either OMX_AllocateBuffer or OMX_UseBuffer. If
|
|
the component allocated the buffer (see the OMX_UseBuffer macro) then
|
|
the component shall free the buffer and buffer header. This is a
|
|
blocking call.
|
|
|
|
The component should return from this call within 20 msec.
|
|
|
|
@param [in] hComponent
|
|
Handle of the component to be accessed. This is the component
|
|
handle returned by the call to the OMX_GetHandle function.
|
|
@param [in] nPortIndex
|
|
nPortIndex is used to select the port on the component the buffer will
|
|
be used with.
|
|
@param [in] pBuffer
|
|
pointer to an OMX_BUFFERHEADERTYPE structure allocated with UseBuffer
|
|
or AllocateBuffer.
|
|
@return OMX_ERRORTYPE
|
|
If the command successfully executes, the return code will be
|
|
OMX_ErrorNone. Otherwise the appropriate OMX error will be returned.
|
|
@ingroup comp buf
|
|
*/
|
|
#define OMX_FreeBuffer( \
|
|
hComponent, \
|
|
nPortIndex, \
|
|
pBuffer) \
|
|
((OMX_COMPONENTTYPE*)hComponent)->FreeBuffer( \
|
|
hComponent, \
|
|
nPortIndex, \
|
|
pBuffer) /* Macro End */
|
|
|
|
|
|
/** The OMX_EmptyThisBuffer macro will send a buffer full of data to an
|
|
input port of a component. The buffer will be emptied by the component
|
|
and returned to the application via the EmptyBufferDone call back.
|
|
This is a non-blocking call in that the component will record the buffer
|
|
and return immediately and then empty the buffer, later, at the proper
|
|
time. As expected, this macro may be invoked only while the component
|
|
is in the OMX_StateExecuting. If nPortIndex does not specify an input
|
|
port, the component shall return an error.
|
|
|
|
The component should return from this call within 5 msec.
|
|
|
|
@param [in] hComponent
|
|
Handle of the component to be accessed. This is the component
|
|
handle returned by the call to the OMX_GetHandle function.
|
|
@param [in] pBuffer
|
|
pointer to an OMX_BUFFERHEADERTYPE structure allocated with UseBuffer
|
|
or AllocateBuffer.
|
|
@return OMX_ERRORTYPE
|
|
If the command successfully executes, the return code will be
|
|
OMX_ErrorNone. Otherwise the appropriate OMX error will be returned.
|
|
@ingroup comp buf
|
|
*/
|
|
#define OMX_EmptyThisBuffer( \
|
|
hComponent, \
|
|
pBuffer) \
|
|
((OMX_COMPONENTTYPE*)hComponent)->EmptyThisBuffer( \
|
|
hComponent, \
|
|
pBuffer) /* Macro End */
|
|
|
|
|
|
/** The OMX_FillThisBuffer macro will send an empty buffer to an
|
|
output port of a component. The buffer will be filled by the component
|
|
and returned to the application via the FillBufferDone call back.
|
|
This is a non-blocking call in that the component will record the buffer
|
|
and return immediately and then fill the buffer, later, at the proper
|
|
time. As expected, this macro may be invoked only while the component
|
|
is in the OMX_ExecutingState. If nPortIndex does not specify an output
|
|
port, the component shall return an error.
|
|
|
|
The component should return from this call within 5 msec.
|
|
|
|
@param [in] hComponent
|
|
Handle of the component to be accessed. This is the component
|
|
handle returned by the call to the OMX_GetHandle function.
|
|
@param [in] pBuffer
|
|
pointer to an OMX_BUFFERHEADERTYPE structure allocated with UseBuffer
|
|
or AllocateBuffer.
|
|
@return OMX_ERRORTYPE
|
|
If the command successfully executes, the return code will be
|
|
OMX_ErrorNone. Otherwise the appropriate OMX error will be returned.
|
|
@ingroup comp buf
|
|
*/
|
|
#define OMX_FillThisBuffer( \
|
|
hComponent, \
|
|
pBuffer) \
|
|
((OMX_COMPONENTTYPE*)hComponent)->FillThisBuffer( \
|
|
hComponent, \
|
|
pBuffer) /* Macro End */
|
|
|
|
|
|
|
|
/** The OMX_UseEGLImage macro will request that the component use
|
|
a EGLImage provided by EGL (and allocate its own buffer header)
|
|
This is a blocking call.
|
|
|
|
The component should return from this call within 20 msec.
|
|
|
|
@param [in] hComponent
|
|
Handle of the component to be accessed. This is the component
|
|
handle returned by the call to the OMX_GetHandle function.
|
|
@param [out] ppBuffer
|
|
pointer to an OMX_BUFFERHEADERTYPE structure used to receive the
|
|
pointer to the buffer header. Note that the memory location used
|
|
for this buffer is NOT visible to the IL Client.
|
|
@param [in] nPortIndex
|
|
nPortIndex is used to select the port on the component the buffer will
|
|
be used with. The port can be found by using the nPortIndex
|
|
value as an index into the Port Definition array of the component.
|
|
@param [in] pAppPrivate
|
|
pAppPrivate is used to initialize the pAppPrivate member of the
|
|
buffer header structure.
|
|
@param [in] eglImage
|
|
eglImage contains the handle of the EGLImage to use as a buffer on the
|
|
specified port. The component is expected to validate properties of
|
|
the EGLImage against the configuration of the port to ensure the component
|
|
can use the EGLImage as a buffer.
|
|
@return OMX_ERRORTYPE
|
|
If the command successfully executes, the return code will be
|
|
OMX_ErrorNone. Otherwise the appropriate OMX error will be returned.
|
|
@ingroup comp buf
|
|
*/
|
|
#define OMX_UseEGLImage( \
|
|
hComponent, \
|
|
ppBufferHdr, \
|
|
nPortIndex, \
|
|
pAppPrivate, \
|
|
eglImage) \
|
|
((OMX_COMPONENTTYPE*)hComponent)->UseEGLImage( \
|
|
hComponent, \
|
|
ppBufferHdr, \
|
|
nPortIndex, \
|
|
pAppPrivate, \
|
|
eglImage)
|
|
|
|
/** The OMX_Init method is used to initialize the OMX core. It shall be the
|
|
first call made into OMX and it should only be executed one time without
|
|
an interviening OMX_Deinit call.
|
|
|
|
The core should return from this call within 20 msec.
|
|
|
|
@return OMX_ERRORTYPE
|
|
If the command successfully executes, the return code will be
|
|
OMX_ErrorNone. Otherwise the appropriate OMX error will be returned.
|
|
@ingroup core
|
|
*/
|
|
OMX_API OMX_ERRORTYPE OMX_APIENTRY OMX_Init(void);
|
|
|
|
|
|
/** The OMX_Deinit method is used to deinitialize the OMX core. It shall be
|
|
the last call made into OMX. In the event that the core determines that
|
|
thare are components loaded when this call is made, the core may return
|
|
with an error rather than try to unload the components.
|
|
|
|
The core should return from this call within 20 msec.
|
|
|
|
@return OMX_ERRORTYPE
|
|
If the command successfully executes, the return code will be
|
|
OMX_ErrorNone. Otherwise the appropriate OMX error will be returned.
|
|
@ingroup core
|
|
*/
|
|
OMX_API OMX_ERRORTYPE OMX_APIENTRY OMX_Deinit(void);
|
|
|
|
|
|
/** The OMX_ComponentNameEnum method will enumerate through all the names of
|
|
recognised valid components in the system. This function is provided
|
|
as a means to detect all the components in the system run-time. There is
|
|
no strict ordering to the enumeration order of component names, although
|
|
each name will only be enumerated once. If the OMX core supports run-time
|
|
installation of new components, it is only requried to detect newly
|
|
installed components when the first call to enumerate component names
|
|
is made (i.e. when nIndex is 0x0).
|
|
|
|
The core should return from this call in 20 msec.
|
|
|
|
@param [out] cComponentName
|
|
pointer to a null terminated string with the component name. The
|
|
names of the components are strings less than 127 bytes in length
|
|
plus the trailing null for a maximum size of 128 bytes. An example
|
|
of a valid component name is "OMX.TI.AUDIO.DSP.MIXER\0". Names are
|
|
assigned by the vendor, but shall start with "OMX." and then have
|
|
the Vendor designation next.
|
|
@param [in] nNameLength
|
|
number of characters in the cComponentName string. With all
|
|
component name strings restricted to less than 128 characters
|
|
(including the trailing null) it is recomended that the caller
|
|
provide a input string for the cComponentName of 128 characters.
|
|
@param [in] nIndex
|
|
number containing the enumeration index for the component.
|
|
Multiple calls to OMX_ComponentNameEnum with increasing values
|
|
of nIndex will enumerate through the component names in the
|
|
system until OMX_ErrorNoMore is returned. The value of nIndex
|
|
is 0 to (N-1), where N is the number of valid installed components
|
|
in the system.
|
|
@return OMX_ERRORTYPE
|
|
If the command successfully executes, the return code will be
|
|
OMX_ErrorNone. When the value of nIndex exceeds the number of
|
|
components in the system minus 1, OMX_ErrorNoMore will be
|
|
returned. Otherwise the appropriate OMX error will be returned.
|
|
@ingroup core
|
|
*/
|
|
OMX_API OMX_ERRORTYPE OMX_APIENTRY OMX_ComponentNameEnum(
|
|
OMX_OUT OMX_STRING cComponentName,
|
|
OMX_IN OMX_U32 nNameLength,
|
|
OMX_IN OMX_U32 nIndex);
|
|
|
|
|
|
/** The OMX_GetHandle method will locate the component specified by the
|
|
component name given, load that component into memory and then invoke
|
|
the component's methods to create an instance of the component.
|
|
|
|
The core should return from this call within 20 msec.
|
|
|
|
@param [out] pHandle
|
|
pointer to an OMX_HANDLETYPE pointer to be filled in by this method.
|
|
@param [in] cComponentName
|
|
pointer to a null terminated string with the component name. The
|
|
names of the components are strings less than 127 bytes in length
|
|
plus the trailing null for a maximum size of 128 bytes. An example
|
|
of a valid component name is "OMX.TI.AUDIO.DSP.MIXER\0". Names are
|
|
assigned by the vendor, but shall start with "OMX." and then have
|
|
the Vendor designation next.
|
|
@param [in] pAppData
|
|
pointer to an application defined value that will be returned
|
|
during callbacks so that the application can identify the source
|
|
of the callback.
|
|
@param [in] pCallBacks
|
|
pointer to a OMX_CALLBACKTYPE structure that will be passed to the
|
|
component to initialize it with.
|
|
@return OMX_ERRORTYPE
|
|
If the command successfully executes, the return code will be
|
|
OMX_ErrorNone. Otherwise the appropriate OMX error will be returned.
|
|
@ingroup core
|
|
*/
|
|
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);
|
|
|
|
|
|
/** The OMX_FreeHandle method will free a handle allocated by the OMX_GetHandle
|
|
method. If the component reference count goes to zero, the component will
|
|
be unloaded from memory.
|
|
|
|
The core should return from this call within 20 msec when the component is
|
|
in the OMX_StateLoaded state.
|
|
|
|
@param [in] hComponent
|
|
Handle of the component to be accessed. This is the component
|
|
handle returned by the call to the GetHandle function.
|
|
@return OMX_ERRORTYPE
|
|
If the command successfully executes, the return code will be
|
|
OMX_ErrorNone. Otherwise the appropriate OMX error will be returned.
|
|
@ingroup core
|
|
*/
|
|
OMX_API OMX_ERRORTYPE OMX_APIENTRY OMX_FreeHandle(
|
|
OMX_IN OMX_HANDLETYPE hComponent);
|
|
|
|
|
|
|
|
/** The OMX_SetupTunnel method will handle the necessary calls to the components
|
|
to setup the specified tunnel the two components. NOTE: This is
|
|
an actual method (not a #define macro). This method will make calls into
|
|
the component ComponentTunnelRequest method to do the actual tunnel
|
|
connection.
|
|
|
|
The ComponentTunnelRequest method on both components will be called.
|
|
This method shall not be called unless the component is in the
|
|
OMX_StateLoaded state except when the ports used for the tunnel are
|
|
disabled. In this case, the component may be in the OMX_StateExecuting,
|
|
OMX_StatePause, or OMX_StateIdle states.
|
|
|
|
The core should return from this call within 20 msec.
|
|
|
|
@param [in] hOutput
|
|
Handle of the component to be accessed. Also this is the handle
|
|
of the component whose port, specified in the nPortOutput parameter
|
|
will be used the source for the tunnel. This is the component handle
|
|
returned by the call to the OMX_GetHandle function. There is a
|
|
requirement that hOutput be the source for the data when
|
|
tunelling (i.e. nPortOutput is an output port). If 0x0, the component
|
|
specified in hInput will have it's port specified in nPortInput
|
|
setup for communication with the application / IL client.
|
|
@param [in] nPortOutput
|
|
nPortOutput is used to select the source port on component to be
|
|
used in the tunnel.
|
|
@param [in] hInput
|
|
This is the component to setup the tunnel with. This is the handle
|
|
of the component whose port, specified in the nPortInput parameter
|
|
will be used the destination for the tunnel. This is the component handle
|
|
returned by the call to the OMX_GetHandle function. There is a
|
|
requirement that hInput be the destination for the data when
|
|
tunelling (i.e. nPortInut is an input port). If 0x0, the component
|
|
specified in hOutput will have it's port specified in nPortPOutput
|
|
setup for communication with the application / IL client.
|
|
@param [in] nPortInput
|
|
nPortInput is used to select the destination port on component to be
|
|
used in the tunnel.
|
|
@return OMX_ERRORTYPE
|
|
If the command successfully executes, the return code will be
|
|
OMX_ErrorNone. Otherwise the appropriate OMX error will be returned.
|
|
When OMX_ErrorNotImplemented is returned, one or both components is
|
|
a non-interop component and does not support tunneling.
|
|
|
|
On failure, the ports of both components are setup for communication
|
|
with the application / IL Client.
|
|
@ingroup core tun
|
|
*/
|
|
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);
|
|
|
|
/** @ingroup cp */
|
|
OMX_API OMX_ERRORTYPE OMX_GetContentPipe(
|
|
OMX_OUT OMX_HANDLETYPE *hPipe,
|
|
OMX_IN OMX_STRING szURI);
|
|
|
|
/** The OMX_GetComponentsOfRole method will return the number of components that support the given
|
|
role and (if the compNames field is non-NULL) the names of those components. The call will fail if
|
|
an insufficiently sized array of names is supplied. To ensure the array is sufficiently sized the
|
|
client should:
|
|
* first call this function with the compNames field NULL to determine the number of component names
|
|
* second call this function with the compNames field pointing to an array of names allocated
|
|
according to the number returned by the first call.
|
|
|
|
The core should return from this call within 5 msec.
|
|
|
|
@param [in] role
|
|
This is generic standard component name consisting only of component class
|
|
name and the type within that class (e.g. 'audio_decoder.aac').
|
|
@param [inout] pNumComps
|
|
This is used both as input and output.
|
|
|
|
If compNames is NULL, the input is ignored and the output specifies how many components support
|
|
the given role.
|
|
|
|
If compNames is not NULL, on input it bounds the size of the input structure and
|
|
on output, it specifies the number of components string names listed within the compNames parameter.
|
|
@param [inout] compNames
|
|
If NULL this field is ignored. If non-NULL this points to an array of 128-byte strings which accepts
|
|
a list of the names of all physical components that implement the specified standard component name.
|
|
Each name is NULL terminated. numComps indicates the number of names.
|
|
@ingroup core
|
|
*/
|
|
OMX_API OMX_ERRORTYPE OMX_GetComponentsOfRole (
|
|
OMX_IN OMX_STRING role,
|
|
OMX_INOUT OMX_U32 *pNumComps,
|
|
OMX_INOUT OMX_U8 **compNames);
|
|
|
|
/** The OMX_GetRolesOfComponent method will return the number of roles supported by the given
|
|
component and (if the roles field is non-NULL) the names of those roles. The call will fail if
|
|
an insufficiently sized array of names is supplied. To ensure the array is sufficiently sized the
|
|
client should:
|
|
* first call this function with the roles field NULL to determine the number of role names
|
|
* second call this function with the roles field pointing to an array of names allocated
|
|
according to the number returned by the first call.
|
|
|
|
The core should return from this call within 5 msec.
|
|
|
|
@param [in] compName
|
|
This is the name of the component being queried about.
|
|
@param [inout] pNumRoles
|
|
This is used both as input and output.
|
|
|
|
If roles is NULL, the input is ignored and the output specifies how many roles the component supports.
|
|
|
|
If compNames is not NULL, on input it bounds the size of the input structure and
|
|
on output, it specifies the number of roles string names listed within the roles parameter.
|
|
@param [out] roles
|
|
If NULL this field is ignored. If non-NULL this points to an array of 128-byte strings
|
|
which accepts a list of the names of all standard components roles implemented on the
|
|
specified component name. numComps indicates the number of names.
|
|
@ingroup core
|
|
*/
|
|
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 */
|
|
|
|
|