am c931ca1e: am 1d5d637d: Merge "implement asString() for OMX enumerations used by framework" into lmp-mr1-dev
* commit 'c931ca1eec00218e70c039e965c8152daa1f4d0a': implement asString() for OMX enumerations used by framework
This commit is contained in:
Lajos Molnar
Android Git Automerger
commit
cc7432254e
|
|
@ -0,0 +1,943 @@
|
|||
/*
|
||||
* Copyright 2014 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
/* NOTE: This file contains several sections for individual OMX include files.
|
||||
Each section has its own include guard. This file should be included AFTER
|
||||
the OMX include files. */
|
||||
|
||||
#ifdef OMX_Audio_h
|
||||
/* asString definitions if media/openmax/OMX_Audio.h was included */
|
||||
|
||||
#ifndef AS_STRING_FOR_OMX_AUDIO_H
|
||||
#define AS_STRING_FOR_OMX_AUDIO_H
|
||||
|
||||
inline static const char *asString(OMX_AUDIO_CODINGTYPE i, const char *def = "??") {
|
||||
switch (i) {
|
||||
case OMX_AUDIO_CodingUnused: return "Unused"; // unused
|
||||
case OMX_AUDIO_CodingAutoDetect: return "AutoDetect"; // unused
|
||||
case OMX_AUDIO_CodingPCM: return "PCM";
|
||||
case OMX_AUDIO_CodingADPCM: return "ADPCM"; // unused
|
||||
case OMX_AUDIO_CodingAMR: return "AMR";
|
||||
case OMX_AUDIO_CodingGSMFR: return "GSMFR";
|
||||
case OMX_AUDIO_CodingGSMEFR: return "GSMEFR"; // unused
|
||||
case OMX_AUDIO_CodingGSMHR: return "GSMHR"; // unused
|
||||
case OMX_AUDIO_CodingPDCFR: return "PDCFR"; // unused
|
||||
case OMX_AUDIO_CodingPDCEFR: return "PDCEFR"; // unused
|
||||
case OMX_AUDIO_CodingPDCHR: return "PDCHR"; // unused
|
||||
case OMX_AUDIO_CodingTDMAFR: return "TDMAFR"; // unused
|
||||
case OMX_AUDIO_CodingTDMAEFR: return "TDMAEFR"; // unused
|
||||
case OMX_AUDIO_CodingQCELP8: return "QCELP8"; // unused
|
||||
case OMX_AUDIO_CodingQCELP13: return "QCELP13"; // unused
|
||||
case OMX_AUDIO_CodingEVRC: return "EVRC"; // unused
|
||||
case OMX_AUDIO_CodingSMV: return "SMV"; // unused
|
||||
case OMX_AUDIO_CodingG711: return "G711";
|
||||
case OMX_AUDIO_CodingG723: return "G723"; // unused
|
||||
case OMX_AUDIO_CodingG726: return "G726"; // unused
|
||||
case OMX_AUDIO_CodingG729: return "G729"; // unused
|
||||
case OMX_AUDIO_CodingAAC: return "AAC";
|
||||
case OMX_AUDIO_CodingMP3: return "MP3";
|
||||
case OMX_AUDIO_CodingSBC: return "SBC"; // unused
|
||||
case OMX_AUDIO_CodingVORBIS: return "VORBIS";
|
||||
case OMX_AUDIO_CodingWMA: return "WMA"; // unused
|
||||
case OMX_AUDIO_CodingRA: return "RA"; // unused
|
||||
case OMX_AUDIO_CodingMIDI: return "MIDI"; // unused
|
||||
case OMX_AUDIO_CodingFLAC: return "FLAC";
|
||||
default: return def;
|
||||
}
|
||||
}
|
||||
|
||||
inline static const char *asString(OMX_AUDIO_PCMMODETYPE i, const char *def = "??") {
|
||||
switch (i) {
|
||||
case OMX_AUDIO_PCMModeLinear: return "Linear";
|
||||
case OMX_AUDIO_PCMModeALaw: return "ALaw";
|
||||
case OMX_AUDIO_PCMModeMULaw: return "MULaw";
|
||||
default: return def;
|
||||
}
|
||||
}
|
||||
|
||||
inline static const char *asString(OMX_AUDIO_CHANNELTYPE i, const char *def = "??") {
|
||||
switch (i) {
|
||||
case OMX_AUDIO_ChannelNone: return "None"; // unused
|
||||
case OMX_AUDIO_ChannelLF: return "LF";
|
||||
case OMX_AUDIO_ChannelRF: return "RF";
|
||||
case OMX_AUDIO_ChannelCF: return "CF";
|
||||
case OMX_AUDIO_ChannelLS: return "LS";
|
||||
case OMX_AUDIO_ChannelRS: return "RS";
|
||||
case OMX_AUDIO_ChannelLFE: return "LFE";
|
||||
case OMX_AUDIO_ChannelCS: return "CS";
|
||||
case OMX_AUDIO_ChannelLR: return "LR";
|
||||
case OMX_AUDIO_ChannelRR: return "RR";
|
||||
default: return def;
|
||||
}
|
||||
}
|
||||
|
||||
inline static const char *asString(OMX_AUDIO_CHANNELMODETYPE i, const char *def = "??") {
|
||||
switch (i) {
|
||||
case OMX_AUDIO_ChannelModeStereo: return "Stereo";
|
||||
// case OMX_AUDIO_ChannelModeJointStereo: return "JointStereo";
|
||||
// case OMX_AUDIO_ChannelModeDual: return "Dual";
|
||||
case OMX_AUDIO_ChannelModeMono: return "Mono";
|
||||
default: return def;
|
||||
}
|
||||
}
|
||||
|
||||
inline static const char *asString(OMX_AUDIO_AACSTREAMFORMATTYPE i, const char *def = "??") {
|
||||
switch (i) {
|
||||
// case OMX_AUDIO_AACStreamFormatMP2ADTS: return "MP2ADTS";
|
||||
case OMX_AUDIO_AACStreamFormatMP4ADTS: return "MP4ADTS";
|
||||
// case OMX_AUDIO_AACStreamFormatMP4LOAS: return "MP4LOAS";
|
||||
// case OMX_AUDIO_AACStreamFormatMP4LATM: return "MP4LATM";
|
||||
// case OMX_AUDIO_AACStreamFormatADIF: return "ADIF";
|
||||
case OMX_AUDIO_AACStreamFormatMP4FF: return "MP4FF";
|
||||
// case OMX_AUDIO_AACStreamFormatRAW: return "RAW";
|
||||
default: return def;
|
||||
}
|
||||
}
|
||||
|
||||
inline static const char *asString(OMX_AUDIO_AMRFRAMEFORMATTYPE i, const char *def = "??") {
|
||||
switch (i) {
|
||||
// case OMX_AUDIO_AMRFrameFormatConformance: return "Conformance";
|
||||
// case OMX_AUDIO_AMRFrameFormatIF1: return "IF1";
|
||||
// case OMX_AUDIO_AMRFrameFormatIF2: return "IF2";
|
||||
case OMX_AUDIO_AMRFrameFormatFSF: return "FSF";
|
||||
// case OMX_AUDIO_AMRFrameFormatRTPPayload: return "RTPPayload";
|
||||
// case OMX_AUDIO_AMRFrameFormatITU: return "ITU";
|
||||
default: return def;
|
||||
}
|
||||
}
|
||||
|
||||
inline static const char *asString(OMX_AUDIO_AMRBANDMODETYPE i, const char *def = "??") {
|
||||
switch (i) {
|
||||
case OMX_AUDIO_AMRBandModeUnused: return "Unused";
|
||||
case OMX_AUDIO_AMRBandModeNB0: return "NB0";
|
||||
case OMX_AUDIO_AMRBandModeNB1: return "NB1";
|
||||
case OMX_AUDIO_AMRBandModeNB2: return "NB2";
|
||||
case OMX_AUDIO_AMRBandModeNB3: return "NB3";
|
||||
case OMX_AUDIO_AMRBandModeNB4: return "NB4";
|
||||
case OMX_AUDIO_AMRBandModeNB5: return "NB5";
|
||||
case OMX_AUDIO_AMRBandModeNB6: return "NB6";
|
||||
case OMX_AUDIO_AMRBandModeNB7: return "NB7";
|
||||
case OMX_AUDIO_AMRBandModeWB0: return "WB0";
|
||||
case OMX_AUDIO_AMRBandModeWB1: return "WB1";
|
||||
case OMX_AUDIO_AMRBandModeWB2: return "WB2";
|
||||
case OMX_AUDIO_AMRBandModeWB3: return "WB3";
|
||||
case OMX_AUDIO_AMRBandModeWB4: return "WB4";
|
||||
case OMX_AUDIO_AMRBandModeWB5: return "WB5";
|
||||
case OMX_AUDIO_AMRBandModeWB6: return "WB6";
|
||||
case OMX_AUDIO_AMRBandModeWB7: return "WB7";
|
||||
case OMX_AUDIO_AMRBandModeWB8: return "WB8";
|
||||
default: return def;
|
||||
}
|
||||
}
|
||||
|
||||
inline static const char *asString(OMX_AUDIO_AMRDTXMODETYPE i, const char *def = "??") {
|
||||
switch (i) {
|
||||
case OMX_AUDIO_AMRDTXModeOff: return "ModeOff";
|
||||
// case OMX_AUDIO_AMRDTXModeOnVAD1: return "ModeOnVAD1";
|
||||
// case OMX_AUDIO_AMRDTXModeOnVAD2: return "ModeOnVAD2";
|
||||
// case OMX_AUDIO_AMRDTXModeOnAuto: return "ModeOnAuto";
|
||||
// case OMX_AUDIO_AMRDTXasEFR: return "asEFR";
|
||||
default: return def;
|
||||
}
|
||||
}
|
||||
|
||||
#endif // AS_STRING_FOR_OMX_AUDIO_H
|
||||
|
||||
#endif // OMX_Audio_h
|
||||
|
||||
#ifdef OMX_AudioExt_h
|
||||
/* asString definitions if media/openmax/OMX_AudioExt.h was included */
|
||||
|
||||
#ifndef AS_STRING_FOR_OMX_AUDIOEXT_H
|
||||
#define AS_STRING_FOR_OMX_AUDIOEXT_H
|
||||
|
||||
inline static const char *asString(OMX_AUDIO_CODINGEXTTYPE i, const char *def = "??") {
|
||||
switch (i) {
|
||||
case OMX_AUDIO_CodingAndroidAC3: return "AndroidAC3";
|
||||
case OMX_AUDIO_CodingAndroidOPUS: return "AndroidOPUS";
|
||||
default: return asString((OMX_AUDIO_CODINGTYPE)i, def);
|
||||
}
|
||||
}
|
||||
|
||||
#endif // AS_STRING_FOR_OMX_AUDIOEXT_H
|
||||
|
||||
#endif // OMX_AudioExt_h
|
||||
|
||||
#ifdef OMX_Component_h
|
||||
/* asString definitions if media/openmax/OMX_Component.h was included */
|
||||
|
||||
#ifndef AS_STRING_FOR_OMX_COMPONENT_H
|
||||
#define AS_STRING_FOR_OMX_COMPONENT_H
|
||||
|
||||
inline static const char *asString(OMX_PORTDOMAINTYPE i, const char *def = "??") {
|
||||
switch (i) {
|
||||
case OMX_PortDomainAudio: return "Audio";
|
||||
case OMX_PortDomainVideo: return "Video";
|
||||
case OMX_PortDomainImage: return "Image";
|
||||
// case OMX_PortDomainOther: return "Other";
|
||||
default: return def;
|
||||
}
|
||||
}
|
||||
|
||||
#endif // AS_STRING_FOR_OMX_COMPONENT_H
|
||||
|
||||
#endif // OMX_Component_h
|
||||
|
||||
#ifdef OMX_Core_h
|
||||
/* asString definitions if media/openmax/OMX_Core.h was included */
|
||||
|
||||
#ifndef AS_STRING_FOR_OMX_CORE_H
|
||||
#define AS_STRING_FOR_OMX_CORE_H
|
||||
|
||||
inline static const char *asString(OMX_COMMANDTYPE i, const char *def = "??") {
|
||||
switch (i) {
|
||||
case OMX_CommandStateSet: return "StateSet";
|
||||
case OMX_CommandFlush: return "Flush";
|
||||
case OMX_CommandPortDisable: return "PortDisable";
|
||||
case OMX_CommandPortEnable: return "PortEnable";
|
||||
// case OMX_CommandMarkBuffer: return "MarkBuffer";
|
||||
default: return def;
|
||||
}
|
||||
}
|
||||
|
||||
inline static const char *asString(OMX_STATETYPE i, const char *def = "??") {
|
||||
switch (i) {
|
||||
case OMX_StateInvalid: return "Invalid";
|
||||
case OMX_StateLoaded: return "Loaded";
|
||||
case OMX_StateIdle: return "Idle";
|
||||
case OMX_StateExecuting: return "Executing";
|
||||
// case OMX_StatePause: return "Pause";
|
||||
// case OMX_StateWaitForResources: return "WaitForResources";
|
||||
default: return def;
|
||||
}
|
||||
}
|
||||
|
||||
inline static const char *asString(OMX_ERRORTYPE i, const char *def = "??") {
|
||||
switch (i) {
|
||||
case OMX_ErrorNone: return "None";
|
||||
case OMX_ErrorInsufficientResources: return "InsufficientResources";
|
||||
case OMX_ErrorUndefined: return "Undefined";
|
||||
case OMX_ErrorInvalidComponentName: return "InvalidComponentName";
|
||||
case OMX_ErrorComponentNotFound: return "ComponentNotFound";
|
||||
case OMX_ErrorInvalidComponent: return "InvalidComponent"; // unused
|
||||
case OMX_ErrorBadParameter: return "BadParameter";
|
||||
case OMX_ErrorNotImplemented: return "NotImplemented";
|
||||
case OMX_ErrorUnderflow: return "Underflow"; // unused
|
||||
case OMX_ErrorOverflow: return "Overflow"; // unused
|
||||
case OMX_ErrorHardware: return "Hardware"; // unused
|
||||
case OMX_ErrorInvalidState: return "InvalidState";
|
||||
case OMX_ErrorStreamCorrupt: return "StreamCorrupt";
|
||||
case OMX_ErrorPortsNotCompatible: return "PortsNotCompatible"; // unused
|
||||
case OMX_ErrorResourcesLost: return "ResourcesLost";
|
||||
case OMX_ErrorNoMore: return "NoMore";
|
||||
case OMX_ErrorVersionMismatch: return "VersionMismatch"; // unused
|
||||
case OMX_ErrorNotReady: return "NotReady"; // unused
|
||||
case OMX_ErrorTimeout: return "Timeout"; // unused
|
||||
case OMX_ErrorSameState: return "SameState"; // unused
|
||||
case OMX_ErrorResourcesPreempted: return "ResourcesPreempted"; // unused
|
||||
case OMX_ErrorPortUnresponsiveDuringAllocation:
|
||||
return "PortUnresponsiveDuringAllocation"; // unused
|
||||
case OMX_ErrorPortUnresponsiveDuringDeallocation:
|
||||
return "PortUnresponsiveDuringDeallocation"; // unused
|
||||
case OMX_ErrorPortUnresponsiveDuringStop:
|
||||
return "PortUnresponsiveDuringStop"; // unused
|
||||
case OMX_ErrorIncorrectStateTransition:
|
||||
return "IncorrectStateTransition"; // unused
|
||||
case OMX_ErrorIncorrectStateOperation:
|
||||
return "IncorrectStateOperation"; // unused
|
||||
case OMX_ErrorUnsupportedSetting: return "UnsupportedSetting";
|
||||
case OMX_ErrorUnsupportedIndex: return "UnsupportedIndex";
|
||||
case OMX_ErrorBadPortIndex: return "BadPortIndex";
|
||||
case OMX_ErrorPortUnpopulated: return "PortUnpopulated"; // unused
|
||||
case OMX_ErrorComponentSuspended: return "ComponentSuspended"; // unused
|
||||
case OMX_ErrorDynamicResourcesUnavailable:
|
||||
return "DynamicResourcesUnavailable"; // unused
|
||||
case OMX_ErrorMbErrorsInFrame: return "MbErrorsInFrame"; // unused
|
||||
case OMX_ErrorFormatNotDetected: return "FormatNotDetected"; // unused
|
||||
case OMX_ErrorContentPipeOpenFailed: return "ContentPipeOpenFailed"; // unused
|
||||
case OMX_ErrorContentPipeCreationFailed:
|
||||
return "ContentPipeCreationFailed"; // unused
|
||||
case OMX_ErrorSeperateTablesUsed: return "SeperateTablesUsed"; // unused
|
||||
case OMX_ErrorTunnelingUnsupported: return "TunnelingUnsupported"; // unused
|
||||
default: return def;
|
||||
}
|
||||
}
|
||||
|
||||
inline static const char *asString(OMX_EVENTTYPE i, const char *def = "??") {
|
||||
switch (i) {
|
||||
case OMX_EventCmdComplete: return "CmdComplete";
|
||||
case OMX_EventError: return "Error";
|
||||
// case OMX_EventMark: return "Mark";
|
||||
case OMX_EventPortSettingsChanged: return "PortSettingsChanged";
|
||||
case OMX_EventBufferFlag: return "BufferFlag";
|
||||
// case OMX_EventResourcesAcquired: return "ResourcesAcquired";
|
||||
// case OMX_EventComponentResumed: return "ComponentResumed";
|
||||
// case OMX_EventDynamicResourcesAvailable: return "DynamicResourcesAvailable";
|
||||
// case OMX_EventPortFormatDetected: return "PortFormatDetected";
|
||||
default: return def;
|
||||
}
|
||||
}
|
||||
|
||||
#endif // AS_STRING_FOR_OMX_CORE_H
|
||||
|
||||
#endif // OMX_Core_h
|
||||
|
||||
#ifdef OMX_Image_h
|
||||
/* asString definitions if media/openmax/OMX_Image.h was included */
|
||||
|
||||
#ifndef AS_STRING_FOR_OMX_IMAGE_H
|
||||
#define AS_STRING_FOR_OMX_IMAGE_H
|
||||
|
||||
inline static const char *asString(OMX_IMAGE_CODINGTYPE i, const char *def = "??") {
|
||||
switch (i) {
|
||||
case OMX_IMAGE_CodingUnused: return "Unused";
|
||||
case OMX_IMAGE_CodingAutoDetect: return "AutoDetect"; // unused
|
||||
case OMX_IMAGE_CodingJPEG: return "JPEG";
|
||||
case OMX_IMAGE_CodingJPEG2K: return "JPEG2K"; // unused
|
||||
case OMX_IMAGE_CodingEXIF: return "EXIF"; // unused
|
||||
case OMX_IMAGE_CodingTIFF: return "TIFF"; // unused
|
||||
case OMX_IMAGE_CodingGIF: return "GIF"; // unused
|
||||
case OMX_IMAGE_CodingPNG: return "PNG"; // unused
|
||||
case OMX_IMAGE_CodingLZW: return "LZW"; // unused
|
||||
case OMX_IMAGE_CodingBMP: return "BMP"; // unused
|
||||
default: return def;
|
||||
}
|
||||
}
|
||||
|
||||
#endif // AS_STRING_FOR_OMX_IMAGE_H
|
||||
|
||||
#endif // OMX_Image_h
|
||||
|
||||
#ifdef OMX_Index_h
|
||||
/* asString definitions if media/openmax/OMX_Index.h was included */
|
||||
|
||||
#ifndef AS_STRING_FOR_OMX_INDEX_H
|
||||
#define AS_STRING_FOR_OMX_INDEX_H
|
||||
|
||||
inline static const char *asString(OMX_INDEXTYPE i, const char *def = "??") {
|
||||
switch (i) {
|
||||
// case OMX_IndexParamPriorityMgmt: return "ParamPriorityMgmt";
|
||||
// case OMX_IndexParamAudioInit: return "ParamAudioInit";
|
||||
// case OMX_IndexParamImageInit: return "ParamImageInit";
|
||||
// case OMX_IndexParamVideoInit: return "ParamVideoInit";
|
||||
// case OMX_IndexParamOtherInit: return "ParamOtherInit";
|
||||
// case OMX_IndexParamNumAvailableStreams: return "ParamNumAvailableStreams";
|
||||
// case OMX_IndexParamActiveStream: return "ParamActiveStream";
|
||||
// case OMX_IndexParamSuspensionPolicy: return "ParamSuspensionPolicy";
|
||||
// case OMX_IndexParamComponentSuspended: return "ParamComponentSuspended";
|
||||
// case OMX_IndexConfigCapturing: return "ConfigCapturing";
|
||||
// case OMX_IndexConfigCaptureMode: return "ConfigCaptureMode";
|
||||
// case OMX_IndexAutoPauseAfterCapture: return "AutoPauseAfterCapture";
|
||||
// case OMX_IndexParamContentURI: return "ParamContentURI";
|
||||
// case OMX_IndexParamCustomContentPipe: return "ParamCustomContentPipe";
|
||||
// case OMX_IndexParamDisableResourceConcealment:
|
||||
// return "ParamDisableResourceConcealment";
|
||||
// case OMX_IndexConfigMetadataItemCount: return "ConfigMetadataItemCount";
|
||||
// case OMX_IndexConfigContainerNodeCount: return "ConfigContainerNodeCount";
|
||||
// case OMX_IndexConfigMetadataItem: return "ConfigMetadataItem";
|
||||
// case OMX_IndexConfigCounterNodeID: return "ConfigCounterNodeID";
|
||||
// case OMX_IndexParamMetadataFilterType: return "ParamMetadataFilterType";
|
||||
// case OMX_IndexParamMetadataKeyFilter: return "ParamMetadataKeyFilter";
|
||||
// case OMX_IndexConfigPriorityMgmt: return "ConfigPriorityMgmt";
|
||||
case OMX_IndexParamStandardComponentRole: return "ParamStandardComponentRole";
|
||||
case OMX_IndexParamPortDefinition: return "ParamPortDefinition";
|
||||
// case OMX_IndexParamCompBufferSupplier: return "ParamCompBufferSupplier";
|
||||
case OMX_IndexParamAudioPortFormat: return "ParamAudioPortFormat";
|
||||
case OMX_IndexParamAudioPcm: return "ParamAudioPcm";
|
||||
case OMX_IndexParamAudioAac: return "ParamAudioAac";
|
||||
// case OMX_IndexParamAudioRa: return "ParamAudioRa";
|
||||
case OMX_IndexParamAudioMp3: return "ParamAudioMp3";
|
||||
// case OMX_IndexParamAudioAdpcm: return "ParamAudioAdpcm";
|
||||
// case OMX_IndexParamAudioG723: return "ParamAudioG723";
|
||||
// case OMX_IndexParamAudioG729: return "ParamAudioG729";
|
||||
case OMX_IndexParamAudioAmr: return "ParamAudioAmr";
|
||||
// case OMX_IndexParamAudioWma: return "ParamAudioWma";
|
||||
// case OMX_IndexParamAudioSbc: return "ParamAudioSbc";
|
||||
// case OMX_IndexParamAudioMidi: return "ParamAudioMidi";
|
||||
// case OMX_IndexParamAudioGsm_FR: return "ParamAudioGsm_FR";
|
||||
// case OMX_IndexParamAudioMidiLoadUserSound: return "ParamAudioMidiLoadUserSound";
|
||||
// case OMX_IndexParamAudioG726: return "ParamAudioG726";
|
||||
// case OMX_IndexParamAudioGsm_EFR: return "ParamAudioGsm_EFR";
|
||||
// case OMX_IndexParamAudioGsm_HR: return "ParamAudioGsm_HR";
|
||||
// case OMX_IndexParamAudioPdc_FR: return "ParamAudioPdc_FR";
|
||||
// case OMX_IndexParamAudioPdc_EFR: return "ParamAudioPdc_EFR";
|
||||
// case OMX_IndexParamAudioPdc_HR: return "ParamAudioPdc_HR";
|
||||
// case OMX_IndexParamAudioTdma_FR: return "ParamAudioTdma_FR";
|
||||
// case OMX_IndexParamAudioTdma_EFR: return "ParamAudioTdma_EFR";
|
||||
// case OMX_IndexParamAudioQcelp8: return "ParamAudioQcelp8";
|
||||
// case OMX_IndexParamAudioQcelp13: return "ParamAudioQcelp13";
|
||||
// case OMX_IndexParamAudioEvrc: return "ParamAudioEvrc";
|
||||
// case OMX_IndexParamAudioSmv: return "ParamAudioSmv";
|
||||
case OMX_IndexParamAudioVorbis: return "ParamAudioVorbis";
|
||||
case OMX_IndexParamAudioFlac: return "ParamAudioFlac";
|
||||
// case OMX_IndexConfigAudioMidiImmediateEvent: return "ConfigAudioMidiImmediateEvent";
|
||||
// case OMX_IndexConfigAudioMidiControl: return "ConfigAudioMidiControl";
|
||||
// case OMX_IndexConfigAudioMidiSoundBankProgram:
|
||||
// return "ConfigAudioMidiSoundBankProgram";
|
||||
// case OMX_IndexConfigAudioMidiStatus: return "ConfigAudioMidiStatus";
|
||||
// case OMX_IndexConfigAudioMidiMetaEvent: return "ConfigAudioMidiMetaEvent";
|
||||
// case OMX_IndexConfigAudioMidiMetaEventData: return "ConfigAudioMidiMetaEventData";
|
||||
// case OMX_IndexConfigAudioVolume: return "ConfigAudioVolume";
|
||||
// case OMX_IndexConfigAudioBalance: return "ConfigAudioBalance";
|
||||
// case OMX_IndexConfigAudioChannelMute: return "ConfigAudioChannelMute";
|
||||
// case OMX_IndexConfigAudioMute: return "ConfigAudioMute";
|
||||
// case OMX_IndexConfigAudioLoudness: return "ConfigAudioLoudness";
|
||||
// case OMX_IndexConfigAudioEchoCancelation: return "ConfigAudioEchoCancelation";
|
||||
// case OMX_IndexConfigAudioNoiseReduction: return "ConfigAudioNoiseReduction";
|
||||
// case OMX_IndexConfigAudioBass: return "ConfigAudioBass";
|
||||
// case OMX_IndexConfigAudioTreble: return "ConfigAudioTreble";
|
||||
// case OMX_IndexConfigAudioStereoWidening: return "ConfigAudioStereoWidening";
|
||||
// case OMX_IndexConfigAudioChorus: return "ConfigAudioChorus";
|
||||
// case OMX_IndexConfigAudioEqualizer: return "ConfigAudioEqualizer";
|
||||
// case OMX_IndexConfigAudioReverberation: return "ConfigAudioReverberation";
|
||||
// case OMX_IndexConfigAudioChannelVolume: return "ConfigAudioChannelVolume";
|
||||
// case OMX_IndexParamImagePortFormat: return "ParamImagePortFormat";
|
||||
// case OMX_IndexParamFlashControl: return "ParamFlashControl";
|
||||
// case OMX_IndexConfigFocusControl: return "ConfigFocusControl";
|
||||
// case OMX_IndexParamQFactor: return "ParamQFactor";
|
||||
// case OMX_IndexParamQuantizationTable: return "ParamQuantizationTable";
|
||||
// case OMX_IndexParamHuffmanTable: return "ParamHuffmanTable";
|
||||
// case OMX_IndexConfigFlashControl: return "ConfigFlashControl";
|
||||
case OMX_IndexParamVideoPortFormat: return "ParamVideoPortFormat";
|
||||
// case OMX_IndexParamVideoQuantization: return "ParamVideoQuantization";
|
||||
// case OMX_IndexParamVideoFastUpdate: return "ParamVideoFastUpdate";
|
||||
case OMX_IndexParamVideoBitrate: return "ParamVideoBitrate";
|
||||
// case OMX_IndexParamVideoMotionVector: return "ParamVideoMotionVector";
|
||||
case OMX_IndexParamVideoIntraRefresh: return "ParamVideoIntraRefresh";
|
||||
case OMX_IndexParamVideoErrorCorrection: return "ParamVideoErrorCorrection";
|
||||
// case OMX_IndexParamVideoVBSMC: return "ParamVideoVBSMC";
|
||||
// case OMX_IndexParamVideoMpeg2: return "ParamVideoMpeg2";
|
||||
case OMX_IndexParamVideoMpeg4: return "ParamVideoMpeg4";
|
||||
// case OMX_IndexParamVideoWmv: return "ParamVideoWmv";
|
||||
// case OMX_IndexParamVideoRv: return "ParamVideoRv";
|
||||
case OMX_IndexParamVideoAvc: return "ParamVideoAvc";
|
||||
case OMX_IndexParamVideoH263: return "ParamVideoH263";
|
||||
case OMX_IndexParamVideoProfileLevelQuerySupported:
|
||||
return "ParamVideoProfileLevelQuerySupported";
|
||||
case OMX_IndexParamVideoProfileLevelCurrent: return "ParamVideoProfileLevelCurrent";
|
||||
case OMX_IndexConfigVideoBitrate: return "ConfigVideoBitrate";
|
||||
// case OMX_IndexConfigVideoFramerate: return "ConfigVideoFramerate";
|
||||
case OMX_IndexConfigVideoIntraVOPRefresh: return "ConfigVideoIntraVOPRefresh";
|
||||
// case OMX_IndexConfigVideoIntraMBRefresh: return "ConfigVideoIntraMBRefresh";
|
||||
// case OMX_IndexConfigVideoMBErrorReporting: return "ConfigVideoMBErrorReporting";
|
||||
// case OMX_IndexParamVideoMacroblocksPerFrame: return "ParamVideoMacroblocksPerFrame";
|
||||
// case OMX_IndexConfigVideoMacroBlockErrorMap: return "ConfigVideoMacroBlockErrorMap";
|
||||
// case OMX_IndexParamVideoSliceFMO: return "ParamVideoSliceFMO";
|
||||
// case OMX_IndexConfigVideoAVCIntraPeriod: return "ConfigVideoAVCIntraPeriod";
|
||||
// case OMX_IndexConfigVideoNalSize: return "ConfigVideoNalSize";
|
||||
// case OMX_IndexParamCommonDeblocking: return "ParamCommonDeblocking";
|
||||
// case OMX_IndexParamCommonSensorMode: return "ParamCommonSensorMode";
|
||||
// case OMX_IndexParamCommonInterleave: return "ParamCommonInterleave";
|
||||
// case OMX_IndexConfigCommonColorFormatConversion:
|
||||
// return "ConfigCommonColorFormatConversion";
|
||||
case OMX_IndexConfigCommonScale: return "ConfigCommonScale";
|
||||
// case OMX_IndexConfigCommonImageFilter: return "ConfigCommonImageFilter";
|
||||
// case OMX_IndexConfigCommonColorEnhancement: return "ConfigCommonColorEnhancement";
|
||||
// case OMX_IndexConfigCommonColorKey: return "ConfigCommonColorKey";
|
||||
// case OMX_IndexConfigCommonColorBlend: return "ConfigCommonColorBlend";
|
||||
// case OMX_IndexConfigCommonFrameStabilisation: return "ConfigCommonFrameStabilisation";
|
||||
// case OMX_IndexConfigCommonRotate: return "ConfigCommonRotate";
|
||||
// case OMX_IndexConfigCommonMirror: return "ConfigCommonMirror";
|
||||
// case OMX_IndexConfigCommonOutputPosition: return "ConfigCommonOutputPosition";
|
||||
case OMX_IndexConfigCommonInputCrop: return "ConfigCommonInputCrop";
|
||||
case OMX_IndexConfigCommonOutputCrop: return "ConfigCommonOutputCrop";
|
||||
// case OMX_IndexConfigCommonDigitalZoom: return "ConfigCommonDigitalZoom";
|
||||
// case OMX_IndexConfigCommonOpticalZoom: return "ConfigCommonOpticalZoom";
|
||||
// case OMX_IndexConfigCommonWhiteBalance: return "ConfigCommonWhiteBalance";
|
||||
// case OMX_IndexConfigCommonExposure: return "ConfigCommonExposure";
|
||||
// case OMX_IndexConfigCommonContrast: return "ConfigCommonContrast";
|
||||
// case OMX_IndexConfigCommonBrightness: return "ConfigCommonBrightness";
|
||||
// case OMX_IndexConfigCommonBacklight: return "ConfigCommonBacklight";
|
||||
// case OMX_IndexConfigCommonGamma: return "ConfigCommonGamma";
|
||||
// case OMX_IndexConfigCommonSaturation: return "ConfigCommonSaturation";
|
||||
// case OMX_IndexConfigCommonLightness: return "ConfigCommonLightness";
|
||||
// case OMX_IndexConfigCommonExclusionRect: return "ConfigCommonExclusionRect";
|
||||
// case OMX_IndexConfigCommonDithering: return "ConfigCommonDithering";
|
||||
// case OMX_IndexConfigCommonPlaneBlend: return "ConfigCommonPlaneBlend";
|
||||
// case OMX_IndexConfigCommonExposureValue: return "ConfigCommonExposureValue";
|
||||
// case OMX_IndexConfigCommonOutputSize: return "ConfigCommonOutputSize";
|
||||
// case OMX_IndexParamCommonExtraQuantData: return "ParamCommonExtraQuantData";
|
||||
// case OMX_IndexConfigCommonFocusRegion: return "ConfigCommonFocusRegion";
|
||||
// case OMX_IndexConfigCommonFocusStatus: return "ConfigCommonFocusStatus";
|
||||
// case OMX_IndexConfigCommonTransitionEffect: return "ConfigCommonTransitionEffect";
|
||||
// case OMX_IndexParamOtherPortFormat: return "ParamOtherPortFormat";
|
||||
// case OMX_IndexConfigOtherPower: return "ConfigOtherPower";
|
||||
// case OMX_IndexConfigOtherStats: return "ConfigOtherStats";
|
||||
// case OMX_IndexConfigTimeScale: return "ConfigTimeScale";
|
||||
// case OMX_IndexConfigTimeClockState: return "ConfigTimeClockState";
|
||||
// case OMX_IndexConfigTimeActiveRefClock: return "ConfigTimeActiveRefClock";
|
||||
// case OMX_IndexConfigTimeCurrentMediaTime: return "ConfigTimeCurrentMediaTime";
|
||||
// case OMX_IndexConfigTimeCurrentWallTime: return "ConfigTimeCurrentWallTime";
|
||||
// case OMX_IndexConfigTimeCurrentAudioReference:
|
||||
// return "ConfigTimeCurrentAudioReference";
|
||||
// case OMX_IndexConfigTimeCurrentVideoReference:
|
||||
// return "ConfigTimeCurrentVideoReference";
|
||||
// case OMX_IndexConfigTimeMediaTimeRequest: return "ConfigTimeMediaTimeRequest";
|
||||
// case OMX_IndexConfigTimeClientStartTime: return "ConfigTimeClientStartTime";
|
||||
// case OMX_IndexConfigTimePosition: return "ConfigTimePosition";
|
||||
// case OMX_IndexConfigTimeSeekMode: return "ConfigTimeSeekMode";
|
||||
default: return def;
|
||||
}
|
||||
}
|
||||
|
||||
#endif // AS_STRING_FOR_OMX_INDEX_H
|
||||
|
||||
#endif // OMX_Index_h
|
||||
|
||||
#ifdef OMX_IndexExt_h
|
||||
/* asString definitions if media/openmax/OMX_IndexExt.h was included */
|
||||
|
||||
#ifndef AS_STRING_FOR_OMX_INDEXEXT_H
|
||||
#define AS_STRING_FOR_OMX_INDEXEXT_H
|
||||
|
||||
inline static const char *asString(OMX_INDEXEXTTYPE i, const char *def = "??") {
|
||||
switch (i) {
|
||||
// case OMX_IndexConfigCallbackRequest: return "ConfigCallbackRequest";
|
||||
// case OMX_IndexConfigCommitMode: return "ConfigCommitMode";
|
||||
// case OMX_IndexConfigCommit: return "ConfigCommit";
|
||||
case OMX_IndexParamAudioAndroidAc3: return "ParamAudioAndroidAc3";
|
||||
case OMX_IndexParamAudioAndroidOpus: return "ParamAudioAndroidOpus";
|
||||
case OMX_IndexParamAudioAndroidAacPresentation: return "ParamAudioAndroidAacPresentation";
|
||||
// case OMX_IndexParamNalStreamFormatSupported: return "ParamNalStreamFormatSupported";
|
||||
// case OMX_IndexParamNalStreamFormat: return "ParamNalStreamFormat";
|
||||
// case OMX_IndexParamNalStreamFormatSelect: return "ParamNalStreamFormatSelect";
|
||||
case OMX_IndexParamVideoVp8: return "ParamVideoVp8";
|
||||
// case OMX_IndexConfigVideoVp8ReferenceFrame: return "ConfigVideoVp8ReferenceFrame";
|
||||
// case OMX_IndexConfigVideoVp8ReferenceFrameType: return "ConfigVideoVp8ReferenceFrameType";
|
||||
case OMX_IndexParamVideoAndroidVp8Encoder: return "ParamVideoAndroidVp8Encoder";
|
||||
case OMX_IndexParamVideoHevc: return "ParamVideoHevc";
|
||||
// case OMX_IndexParamSliceSegments: return "ParamSliceSegments";
|
||||
case OMX_IndexConfigAutoFramerateConversion: return "ConfigAutoFramerateConversion";
|
||||
default: return asString((OMX_INDEXTYPE)i, def);
|
||||
}
|
||||
}
|
||||
|
||||
#endif // AS_STRING_FOR_OMX_INDEXEXT_H
|
||||
|
||||
#endif // OMX_IndexExt_h
|
||||
|
||||
#ifdef OMX_IVCommon_h
|
||||
/* asString definitions if media/openmax/OMX_IVCommon.h was included */
|
||||
|
||||
#ifndef AS_STRING_FOR_OMX_IVCOMMON_H
|
||||
#define AS_STRING_FOR_OMX_IVCOMMON_H
|
||||
|
||||
inline static const char *asString(OMX_COLOR_FORMATTYPE i, const char *def = "??") {
|
||||
switch (i) {
|
||||
case OMX_COLOR_FormatUnused:
|
||||
return "COLOR_FormatUnused";
|
||||
case OMX_COLOR_FormatMonochrome:
|
||||
return "COLOR_FormatMonochrome";
|
||||
case OMX_COLOR_Format8bitRGB332:
|
||||
return "COLOR_Format8bitRGB332";
|
||||
case OMX_COLOR_Format12bitRGB444:
|
||||
return "COLOR_Format12bitRGB444";
|
||||
case OMX_COLOR_Format16bitARGB4444:
|
||||
return "COLOR_Format16bitARGB4444";
|
||||
case OMX_COLOR_Format16bitARGB1555:
|
||||
return "COLOR_Format16bitARGB1555";
|
||||
case OMX_COLOR_Format16bitRGB565:
|
||||
return "COLOR_Format16bitRGB565";
|
||||
case OMX_COLOR_Format16bitBGR565:
|
||||
return "COLOR_Format16bitBGR565";
|
||||
case OMX_COLOR_Format18bitRGB666:
|
||||
return "COLOR_Format18bitRGB666";
|
||||
case OMX_COLOR_Format18bitARGB1665:
|
||||
return "COLOR_Format18bitARGB1665";
|
||||
case OMX_COLOR_Format19bitARGB1666:
|
||||
return "COLOR_Format19bitARGB1666";
|
||||
case OMX_COLOR_Format24bitRGB888:
|
||||
return "COLOR_Format24bitRGB888";
|
||||
case OMX_COLOR_Format24bitBGR888:
|
||||
return "COLOR_Format24bitBGR888";
|
||||
case OMX_COLOR_Format24bitARGB1887:
|
||||
return "COLOR_Format24bitARGB1887";
|
||||
case OMX_COLOR_Format25bitARGB1888:
|
||||
return "COLOR_Format25bitARGB1888";
|
||||
case OMX_COLOR_Format32bitBGRA8888:
|
||||
return "COLOR_Format32bitBGRA8888";
|
||||
case OMX_COLOR_Format32bitARGB8888:
|
||||
return "COLOR_Format32bitARGB8888";
|
||||
case OMX_COLOR_FormatYUV411Planar:
|
||||
return "COLOR_FormatYUV411Planar";
|
||||
case OMX_COLOR_FormatYUV411PackedPlanar:
|
||||
return "COLOR_FormatYUV411PackedPlanar";
|
||||
case OMX_COLOR_FormatYUV420Planar:
|
||||
return "COLOR_FormatYUV420Planar";
|
||||
case OMX_COLOR_FormatYUV420PackedPlanar:
|
||||
return "COLOR_FormatYUV420PackedPlanar";
|
||||
case OMX_COLOR_FormatYUV420SemiPlanar:
|
||||
return "COLOR_FormatYUV420SemiPlanar";
|
||||
case OMX_COLOR_FormatYUV422Planar:
|
||||
return "COLOR_FormatYUV422Planar";
|
||||
case OMX_COLOR_FormatYUV422PackedPlanar:
|
||||
return "COLOR_FormatYUV422PackedPlanar";
|
||||
case OMX_COLOR_FormatYUV422SemiPlanar:
|
||||
return "COLOR_FormatYUV422SemiPlanar";
|
||||
case OMX_COLOR_FormatYCbYCr:
|
||||
return "COLOR_FormatYCbYCr";
|
||||
case OMX_COLOR_FormatYCrYCb:
|
||||
return "COLOR_FormatYCrYCb";
|
||||
case OMX_COLOR_FormatCbYCrY:
|
||||
return "COLOR_FormatCbYCrY";
|
||||
case OMX_COLOR_FormatCrYCbY:
|
||||
return "COLOR_FormatCrYCbY";
|
||||
case OMX_COLOR_FormatYUV444Interleaved:
|
||||
return "COLOR_FormatYUV444Interleaved";
|
||||
case OMX_COLOR_FormatRawBayer8bit:
|
||||
return "COLOR_FormatRawBayer8bit";
|
||||
case OMX_COLOR_FormatRawBayer10bit:
|
||||
return "COLOR_FormatRawBayer10bit";
|
||||
case OMX_COLOR_FormatRawBayer8bitcompressed:
|
||||
return "COLOR_FormatRawBayer8bitcompressed";
|
||||
case OMX_COLOR_FormatL2:
|
||||
return "COLOR_FormatL2";
|
||||
case OMX_COLOR_FormatL4:
|
||||
return "COLOR_FormatL4";
|
||||
case OMX_COLOR_FormatL8:
|
||||
return "COLOR_FormatL8";
|
||||
case OMX_COLOR_FormatL16:
|
||||
return "COLOR_FormatL16";
|
||||
case OMX_COLOR_FormatL24:
|
||||
return "COLOR_FormatL24";
|
||||
case OMX_COLOR_FormatL32:
|
||||
return "COLOR_FormatL32";
|
||||
case OMX_COLOR_FormatYUV420PackedSemiPlanar:
|
||||
return "COLOR_FormatYUV420PackedSemiPlanar";
|
||||
case OMX_COLOR_FormatYUV422PackedSemiPlanar:
|
||||
return "COLOR_FormatYUV422PackedSemiPlanar";
|
||||
case OMX_COLOR_Format18BitBGR666:
|
||||
return "COLOR_Format18BitBGR666";
|
||||
case OMX_COLOR_Format24BitARGB6666:
|
||||
return "COLOR_Format24BitARGB6666";
|
||||
case OMX_COLOR_Format24BitABGR6666:
|
||||
return "COLOR_Format24BitABGR6666";
|
||||
case OMX_COLOR_FormatAndroidOpaque:
|
||||
return "COLOR_FormatAndroidOpaque";
|
||||
case OMX_COLOR_FormatYUV420Flexible:
|
||||
return "COLOR_FormatYUV420Flexible";
|
||||
case OMX_TI_COLOR_FormatYUV420PackedSemiPlanar:
|
||||
return "TI_COLOR_FormatYUV420PackedSemiPlanar";
|
||||
case OMX_QCOM_COLOR_FormatYVU420SemiPlanar:
|
||||
return "QCOM_COLOR_FormatYVU420SemiPlanar";
|
||||
// case OMX_QCOM_COLOR_FormatYUV420PackedSemiPlanar64x32Tile2m8ka:
|
||||
// return "QCOM_COLOR_FormatYUV420PackedSemiPlanar64x32Tile2m8ka";
|
||||
// case OMX_SEC_COLOR_FormatNV12Tiled:
|
||||
// return "SEC_COLOR_FormatNV12Tiled";
|
||||
// case OMX_QCOM_COLOR_FormatYUV420PackedSemiPlanar32m:
|
||||
// return "QCOM_COLOR_FormatYUV420PackedSemiPlanar32m";
|
||||
default:
|
||||
return def;
|
||||
}
|
||||
}
|
||||
|
||||
#endif // AS_STRING_FOR_OMX_IVCOMMON_H
|
||||
|
||||
#endif // OMX_IVCommon_h
|
||||
|
||||
#ifdef OMX_Types_h
|
||||
/* asString definitions if media/openmax/OMX_Types.h was included */
|
||||
|
||||
#ifndef AS_STRING_FOR_OMX_TYPES_H
|
||||
#define AS_STRING_FOR_OMX_TYPES_H
|
||||
|
||||
inline static const char *asString(OMX_BOOL i, const char *def = "??") {
|
||||
switch (i) {
|
||||
case OMX_FALSE: return "FALSE";
|
||||
case OMX_TRUE: return "TRUE";
|
||||
default: return def;
|
||||
}
|
||||
}
|
||||
|
||||
inline static const char *asString(OMX_DIRTYPE i, const char *def = "??") {
|
||||
switch (i) {
|
||||
case OMX_DirInput: return "Input";
|
||||
case OMX_DirOutput: return "Output";
|
||||
default: return def;
|
||||
}
|
||||
}
|
||||
|
||||
inline static const char *asString(OMX_ENDIANTYPE i, const char *def = "??") {
|
||||
switch (i) {
|
||||
case OMX_EndianBig: return "Big";
|
||||
// case OMX_EndianLittle: return "Little";
|
||||
default: return def;
|
||||
}
|
||||
}
|
||||
|
||||
inline static const char *asString(OMX_NUMERICALDATATYPE i, const char *def = "??") {
|
||||
switch (i) {
|
||||
case OMX_NumericalDataSigned: return "Signed";
|
||||
// case OMX_NumericalDataUnsigned: return "Unsigned";
|
||||
default: return def;
|
||||
}
|
||||
}
|
||||
|
||||
#endif // AS_STRING_FOR_OMX_TYPES_H
|
||||
|
||||
#endif // OMX_Types_h
|
||||
|
||||
#ifdef OMX_Video_h
|
||||
/* asString definitions if media/openmax/OMX_Video.h was included */
|
||||
|
||||
#ifndef AS_STRING_FOR_OMX_VIDEO_H
|
||||
#define AS_STRING_FOR_OMX_VIDEO_H
|
||||
|
||||
inline static const char *asString(OMX_VIDEO_CODINGTYPE i, const char *def = "??") {
|
||||
switch (i) {
|
||||
case OMX_VIDEO_CodingUnused: return "Unused";
|
||||
case OMX_VIDEO_CodingAutoDetect: return "AutoDetect"; // unused
|
||||
case OMX_VIDEO_CodingMPEG2: return "MPEG2";
|
||||
case OMX_VIDEO_CodingH263: return "H263";
|
||||
case OMX_VIDEO_CodingMPEG4: return "MPEG4";
|
||||
case OMX_VIDEO_CodingWMV: return "WMV"; // unused
|
||||
case OMX_VIDEO_CodingRV: return "RV"; // unused
|
||||
case OMX_VIDEO_CodingAVC: return "AVC";
|
||||
case OMX_VIDEO_CodingMJPEG: return "MJPEG"; // unused
|
||||
case OMX_VIDEO_CodingVP8: return "VP8";
|
||||
case OMX_VIDEO_CodingVP9: return "VP9";
|
||||
case OMX_VIDEO_CodingHEVC: return "HEVC";
|
||||
default: return def;
|
||||
}
|
||||
}
|
||||
|
||||
inline static const char *asString(OMX_VIDEO_CONTROLRATETYPE i, const char *def = "??") {
|
||||
switch (i) {
|
||||
// case OMX_Video_ControlRateDisable: return "Disable";
|
||||
case OMX_Video_ControlRateVariable: return "Variable";
|
||||
case OMX_Video_ControlRateConstant: return "Constant";
|
||||
// case OMX_Video_ControlRateVariableSkipFrames: return "VariableSkipFrames";
|
||||
// case OMX_Video_ControlRateConstantSkipFrames: return "ConstantSkipFrames";
|
||||
default: return def;
|
||||
}
|
||||
}
|
||||
|
||||
inline static const char *asString(OMX_VIDEO_INTRAREFRESHTYPE i, const char *def = "??") {
|
||||
switch (i) {
|
||||
case OMX_VIDEO_IntraRefreshCyclic: return "Cyclic";
|
||||
case OMX_VIDEO_IntraRefreshAdaptive: return "Adaptive";
|
||||
case OMX_VIDEO_IntraRefreshBoth: return "Both";
|
||||
default: return def;
|
||||
}
|
||||
}
|
||||
|
||||
inline static const char *asString(OMX_VIDEO_H263PROFILETYPE i, const char *def = "??") {
|
||||
switch (i) {
|
||||
case OMX_VIDEO_H263ProfileBaseline: return "Baseline";
|
||||
case OMX_VIDEO_H263ProfileH320Coding: return "H320Coding";
|
||||
case OMX_VIDEO_H263ProfileBackwardCompatible: return "BackwardCompatible";
|
||||
case OMX_VIDEO_H263ProfileISWV2: return "ISWV2";
|
||||
case OMX_VIDEO_H263ProfileISWV3: return "ISWV3";
|
||||
case OMX_VIDEO_H263ProfileHighCompression: return "HighCompression";
|
||||
case OMX_VIDEO_H263ProfileInternet: return "Internet";
|
||||
case OMX_VIDEO_H263ProfileInterlace: return "Interlace";
|
||||
case OMX_VIDEO_H263ProfileHighLatency: return "HighLatency";
|
||||
default: return def;
|
||||
}
|
||||
}
|
||||
|
||||
inline static const char *asString(OMX_VIDEO_H263LEVELTYPE i, const char *def = "??") {
|
||||
switch (i) {
|
||||
case OMX_VIDEO_H263Level10: return "Level10";
|
||||
case OMX_VIDEO_H263Level20: return "Level20";
|
||||
case OMX_VIDEO_H263Level30: return "Level30";
|
||||
case OMX_VIDEO_H263Level40: return "Level40";
|
||||
case OMX_VIDEO_H263Level45: return "Level45";
|
||||
case OMX_VIDEO_H263Level50: return "Level50";
|
||||
case OMX_VIDEO_H263Level60: return "Level60";
|
||||
case OMX_VIDEO_H263Level70: return "Level70";
|
||||
default: return def;
|
||||
}
|
||||
}
|
||||
|
||||
inline static const char *asString(OMX_VIDEO_PICTURETYPE i, const char *def = "??") {
|
||||
switch (i) {
|
||||
case OMX_VIDEO_PictureTypeI: return "I";
|
||||
case OMX_VIDEO_PictureTypeP: return "P";
|
||||
case OMX_VIDEO_PictureTypeB: return "B";
|
||||
// case OMX_VIDEO_PictureTypeSI: return "SI";
|
||||
// case OMX_VIDEO_PictureTypeSP: return "SP";
|
||||
// case OMX_VIDEO_PictureTypeEI: return "EI";
|
||||
// case OMX_VIDEO_PictureTypeEP: return "EP";
|
||||
// case OMX_VIDEO_PictureTypeS: return "S";
|
||||
default: return def;
|
||||
}
|
||||
}
|
||||
|
||||
inline static const char *asString(OMX_VIDEO_MPEG4PROFILETYPE i, const char *def = "??") {
|
||||
switch (i) {
|
||||
case OMX_VIDEO_MPEG4ProfileSimple: return "Simple";
|
||||
case OMX_VIDEO_MPEG4ProfileSimpleScalable: return "SimpleScalable";
|
||||
case OMX_VIDEO_MPEG4ProfileCore: return "Core";
|
||||
case OMX_VIDEO_MPEG4ProfileMain: return "Main";
|
||||
case OMX_VIDEO_MPEG4ProfileNbit: return "Nbit";
|
||||
case OMX_VIDEO_MPEG4ProfileScalableTexture: return "ScalableTexture";
|
||||
case OMX_VIDEO_MPEG4ProfileSimpleFace: return "SimpleFace";
|
||||
case OMX_VIDEO_MPEG4ProfileSimpleFBA: return "SimpleFBA";
|
||||
case OMX_VIDEO_MPEG4ProfileBasicAnimated: return "BasicAnimated";
|
||||
case OMX_VIDEO_MPEG4ProfileHybrid: return "Hybrid";
|
||||
case OMX_VIDEO_MPEG4ProfileAdvancedRealTime: return "AdvancedRealTime";
|
||||
case OMX_VIDEO_MPEG4ProfileCoreScalable: return "CoreScalable";
|
||||
case OMX_VIDEO_MPEG4ProfileAdvancedCoding: return "AdvancedCoding";
|
||||
case OMX_VIDEO_MPEG4ProfileAdvancedCore: return "AdvancedCore";
|
||||
case OMX_VIDEO_MPEG4ProfileAdvancedScalable: return "AdvancedScalable";
|
||||
case OMX_VIDEO_MPEG4ProfileAdvancedSimple: return "AdvancedSimple";
|
||||
default: return def;
|
||||
}
|
||||
}
|
||||
|
||||
inline static const char *asString(OMX_VIDEO_MPEG4LEVELTYPE i, const char *def = "??") {
|
||||
switch (i) {
|
||||
case OMX_VIDEO_MPEG4Level0: return "Level0";
|
||||
case OMX_VIDEO_MPEG4Level0b: return "Level0b";
|
||||
case OMX_VIDEO_MPEG4Level1: return "Level1";
|
||||
case OMX_VIDEO_MPEG4Level2: return "Level2";
|
||||
case OMX_VIDEO_MPEG4Level3: return "Level3";
|
||||
case OMX_VIDEO_MPEG4Level4: return "Level4";
|
||||
case OMX_VIDEO_MPEG4Level4a: return "Level4a";
|
||||
case OMX_VIDEO_MPEG4Level5: return "Level5";
|
||||
default: return def;
|
||||
}
|
||||
}
|
||||
|
||||
inline static const char *asString(OMX_VIDEO_AVCPROFILETYPE i, const char *def = "??") {
|
||||
switch (i) {
|
||||
case OMX_VIDEO_AVCProfileBaseline: return "Baseline";
|
||||
case OMX_VIDEO_AVCProfileMain: return "Main";
|
||||
case OMX_VIDEO_AVCProfileExtended: return "Extended";
|
||||
case OMX_VIDEO_AVCProfileHigh: return "High";
|
||||
case OMX_VIDEO_AVCProfileHigh10: return "High10";
|
||||
case OMX_VIDEO_AVCProfileHigh422: return "High422";
|
||||
case OMX_VIDEO_AVCProfileHigh444: return "High444";
|
||||
default: return def;
|
||||
}
|
||||
}
|
||||
|
||||
inline static const char *asString(OMX_VIDEO_AVCLEVELTYPE i, const char *def = "??") {
|
||||
switch (i) {
|
||||
case OMX_VIDEO_AVCLevel1: return "Level1";
|
||||
case OMX_VIDEO_AVCLevel1b: return "Level1b";
|
||||
case OMX_VIDEO_AVCLevel11: return "Level11";
|
||||
case OMX_VIDEO_AVCLevel12: return "Level12";
|
||||
case OMX_VIDEO_AVCLevel13: return "Level13";
|
||||
case OMX_VIDEO_AVCLevel2: return "Level2";
|
||||
case OMX_VIDEO_AVCLevel21: return "Level21";
|
||||
case OMX_VIDEO_AVCLevel22: return "Level22";
|
||||
case OMX_VIDEO_AVCLevel3: return "Level3";
|
||||
case OMX_VIDEO_AVCLevel31: return "Level31";
|
||||
case OMX_VIDEO_AVCLevel32: return "Level32";
|
||||
case OMX_VIDEO_AVCLevel4: return "Level4";
|
||||
case OMX_VIDEO_AVCLevel41: return "Level41";
|
||||
case OMX_VIDEO_AVCLevel42: return "Level42";
|
||||
case OMX_VIDEO_AVCLevel5: return "Level5";
|
||||
case OMX_VIDEO_AVCLevel51: return "Level51";
|
||||
case OMX_VIDEO_AVCLevel52: return "Level52";
|
||||
default: return def;
|
||||
}
|
||||
}
|
||||
|
||||
inline static const char *asString(OMX_VIDEO_AVCLOOPFILTERTYPE i, const char *def = "??") {
|
||||
switch (i) {
|
||||
case OMX_VIDEO_AVCLoopFilterEnable: return "Enable";
|
||||
// case OMX_VIDEO_AVCLoopFilterDisable: return "Disable";
|
||||
// case OMX_VIDEO_AVCLoopFilterDisableSliceBoundary: return "DisableSliceBoundary";
|
||||
default: return def;
|
||||
}
|
||||
}
|
||||
|
||||
#endif // AS_STRING_FOR_OMX_VIDEO_H
|
||||
|
||||
#endif // OMX_Video_h
|
||||
|
||||
#ifdef OMX_VideoExt_h
|
||||
/* asString definitions if media/openmax/OMX_VideoExt.h was included */
|
||||
|
||||
#ifndef AS_STRING_FOR_OMX_VIDEOEXT_H
|
||||
#define AS_STRING_FOR_OMX_VIDEOEXT_H
|
||||
|
||||
inline static const char *asString(OMX_VIDEO_VP8PROFILETYPE i, const char *def = "!!") {
|
||||
switch (i) {
|
||||
case OMX_VIDEO_VP8ProfileMain: return "Main";
|
||||
case OMX_VIDEO_VP8ProfileUnknown: return "Unknown"; // unused
|
||||
default: return def;
|
||||
}
|
||||
}
|
||||
|
||||
inline static const char *asString(OMX_VIDEO_VP8LEVELTYPE i, const char *def = "!!") {
|
||||
switch (i) {
|
||||
case OMX_VIDEO_VP8Level_Version0: return "_Version0";
|
||||
case OMX_VIDEO_VP8Level_Version1: return "_Version1";
|
||||
case OMX_VIDEO_VP8Level_Version2: return "_Version2";
|
||||
case OMX_VIDEO_VP8Level_Version3: return "_Version3";
|
||||
case OMX_VIDEO_VP8LevelUnknown: return "Unknown"; // unused
|
||||
default: return def;
|
||||
}
|
||||
}
|
||||
|
||||
inline static const char *asString(
|
||||
OMX_VIDEO_ANDROID_VPXTEMPORALLAYERPATTERNTYPE i, const char *def = "??") {
|
||||
switch (i) {
|
||||
case OMX_VIDEO_VPXTemporalLayerPatternNone: return "VPXTemporalLayerPatternNone";
|
||||
case OMX_VIDEO_VPXTemporalLayerPatternWebRTC: return "VPXTemporalLayerPatternWebRTC";
|
||||
default: return def;
|
||||
}
|
||||
}
|
||||
|
||||
inline static const char *asString(OMX_VIDEO_HEVCPROFILETYPE i, const char *def = "!!") {
|
||||
switch (i) {
|
||||
case OMX_VIDEO_HEVCProfileUnknown: return "Unknown"; // unused
|
||||
case OMX_VIDEO_HEVCProfileMain: return "Main";
|
||||
case OMX_VIDEO_HEVCProfileMain10: return "Main10";
|
||||
default: return def;
|
||||
}
|
||||
}
|
||||
|
||||
inline static const char *asString(OMX_VIDEO_HEVCLEVELTYPE i, const char *def = "!!") {
|
||||
switch (i) {
|
||||
case OMX_VIDEO_HEVCLevelUnknown: return "LevelUnknown"; // unused
|
||||
case OMX_VIDEO_HEVCMainTierLevel1: return "MainTierLevel1";
|
||||
case OMX_VIDEO_HEVCHighTierLevel1: return "HighTierLevel1";
|
||||
case OMX_VIDEO_HEVCMainTierLevel2: return "MainTierLevel2";
|
||||
case OMX_VIDEO_HEVCHighTierLevel2: return "HighTierLevel2";
|
||||
case OMX_VIDEO_HEVCMainTierLevel21: return "MainTierLevel21";
|
||||
case OMX_VIDEO_HEVCHighTierLevel21: return "HighTierLevel21";
|
||||
case OMX_VIDEO_HEVCMainTierLevel3: return "MainTierLevel3";
|
||||
case OMX_VIDEO_HEVCHighTierLevel3: return "HighTierLevel3";
|
||||
case OMX_VIDEO_HEVCMainTierLevel31: return "MainTierLevel31";
|
||||
case OMX_VIDEO_HEVCHighTierLevel31: return "HighTierLevel31";
|
||||
case OMX_VIDEO_HEVCMainTierLevel4: return "MainTierLevel4";
|
||||
case OMX_VIDEO_HEVCHighTierLevel4: return "HighTierLevel4";
|
||||
case OMX_VIDEO_HEVCMainTierLevel41: return "MainTierLevel41";
|
||||
case OMX_VIDEO_HEVCHighTierLevel41: return "HighTierLevel41";
|
||||
case OMX_VIDEO_HEVCMainTierLevel5: return "MainTierLevel5";
|
||||
case OMX_VIDEO_HEVCHighTierLevel5: return "HighTierLevel5";
|
||||
case OMX_VIDEO_HEVCMainTierLevel51: return "MainTierLevel51";
|
||||
case OMX_VIDEO_HEVCHighTierLevel51: return "HighTierLevel51";
|
||||
case OMX_VIDEO_HEVCMainTierLevel52: return "MainTierLevel52";
|
||||
case OMX_VIDEO_HEVCHighTierLevel52: return "HighTierLevel52";
|
||||
case OMX_VIDEO_HEVCMainTierLevel6: return "MainTierLevel6";
|
||||
case OMX_VIDEO_HEVCHighTierLevel6: return "HighTierLevel6";
|
||||
case OMX_VIDEO_HEVCMainTierLevel61: return "MainTierLevel61";
|
||||
case OMX_VIDEO_HEVCHighTierLevel61: return "HighTierLevel61";
|
||||
case OMX_VIDEO_HEVCMainTierLevel62: return "MainTierLevel62";
|
||||
case OMX_VIDEO_HEVCHighTierLevel62: return "HighTierLevel62";
|
||||
default: return def;
|
||||
}
|
||||
}
|
||||
|
||||
#endif // AS_STRING_FOR_OMX_VIDEOEXT_H
|
||||
|
||||
#endif // OMX_VideoExt_h
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -16,25 +16,25 @@
|
|||
* -------------------------------------------------------------------
|
||||
*/
|
||||
/*
|
||||
* Copyright (c) 2008 The Khronos Group Inc.
|
||||
*
|
||||
* 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:
|
||||
* to the following conditions:
|
||||
* The above copyright notice and this permission notice shall be included
|
||||
* in all copies or substantial portions of the Software.
|
||||
*
|
||||
* 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.
|
||||
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
*/
|
||||
|
||||
|
|
@ -55,7 +55,7 @@ extern "C" {
|
|||
|
||||
/* Each OMX header must 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
|
||||
* for this header file to compile successfully
|
||||
*/
|
||||
|
||||
#include <OMX_Audio.h>
|
||||
|
|
@ -64,12 +64,12 @@ extern "C" {
|
|||
#include <OMX_Other.h>
|
||||
|
||||
/** @ingroup comp */
|
||||
typedef enum OMX_PORTDOMAINTYPE {
|
||||
OMX_PortDomainAudio,
|
||||
OMX_PortDomainVideo,
|
||||
OMX_PortDomainImage,
|
||||
typedef enum OMX_PORTDOMAINTYPE {
|
||||
OMX_PortDomainAudio,
|
||||
OMX_PortDomainVideo,
|
||||
OMX_PortDomainImage,
|
||||
OMX_PortDomainOther,
|
||||
OMX_PortDomainKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
||||
OMX_PortDomainKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
||||
OMX_PortDomainVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
|
||||
OMX_PortDomainMax = 0x7ffffff
|
||||
} OMX_PORTDOMAINTYPE;
|
||||
|
|
@ -88,7 +88,7 @@ typedef struct OMX_PARAM_PORTDEFINITIONTYPE {
|
|||
When disabled a port is unpopulated. A disabled port
|
||||
is not populated with buffers on a transition to IDLE. */
|
||||
OMX_BOOL bPopulated; /**< Port is populated with all of its buffers as indicated by
|
||||
nBufferCountActual. A disabled port is always unpopulated.
|
||||
nBufferCountActual. A disabled port is always unpopulated.
|
||||
An enabled port is populated on a transition to OMX_StateIdle
|
||||
and unpopulated on a transition to loaded. */
|
||||
OMX_PORTDOMAINTYPE eDomain; /**< Domain of the port. Determines the contents of metadata below. */
|
||||
|
|
@ -103,26 +103,26 @@ typedef struct OMX_PARAM_PORTDEFINITIONTYPE {
|
|||
} OMX_PARAM_PORTDEFINITIONTYPE;
|
||||
|
||||
/** @ingroup comp */
|
||||
typedef struct OMX_PARAM_U32TYPE {
|
||||
OMX_U32 nSize; /**< Size of this structure, in Bytes */
|
||||
OMX_VERSIONTYPE nVersion; /**< OMX specification version information */
|
||||
OMX_U32 nPortIndex; /**< port that this structure applies to */
|
||||
typedef struct OMX_PARAM_U32TYPE {
|
||||
OMX_U32 nSize; /**< Size of this structure, in Bytes */
|
||||
OMX_VERSIONTYPE nVersion; /**< OMX specification version information */
|
||||
OMX_U32 nPortIndex; /**< port that this structure applies to */
|
||||
OMX_U32 nU32; /**< U32 value */
|
||||
} OMX_PARAM_U32TYPE;
|
||||
|
||||
/** @ingroup rpm */
|
||||
typedef enum OMX_SUSPENSIONPOLICYTYPE {
|
||||
OMX_SuspensionDisabled, /**< No suspension; v1.0 behavior */
|
||||
OMX_SuspensionEnabled, /**< Suspension allowed */
|
||||
OMX_SuspensionPolicyKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
||||
OMX_SuspensionEnabled, /**< Suspension allowed */
|
||||
OMX_SuspensionPolicyKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
||||
OMX_SuspensionPolicyStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
|
||||
OMX_SuspensionPolicyMax = 0x7fffffff
|
||||
} OMX_SUSPENSIONPOLICYTYPE;
|
||||
|
||||
/** @ingroup rpm */
|
||||
typedef struct OMX_PARAM_SUSPENSIONPOLICYTYPE {
|
||||
OMX_U32 nSize;
|
||||
OMX_VERSIONTYPE nVersion;
|
||||
OMX_U32 nSize;
|
||||
OMX_VERSIONTYPE nVersion;
|
||||
OMX_SUSPENSIONPOLICYTYPE ePolicy;
|
||||
} OMX_PARAM_SUSPENSIONPOLICYTYPE;
|
||||
|
||||
|
|
@ -130,22 +130,22 @@ typedef struct OMX_PARAM_SUSPENSIONPOLICYTYPE {
|
|||
typedef enum OMX_SUSPENSIONTYPE {
|
||||
OMX_NotSuspended, /**< component is not suspended */
|
||||
OMX_Suspended, /**< component is suspended */
|
||||
OMX_SuspensionKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
||||
OMX_SuspensionKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
||||
OMX_SuspensionVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
|
||||
OMX_SuspendMax = 0x7FFFFFFF
|
||||
} OMX_SUSPENSIONTYPE;
|
||||
|
||||
/** @ingroup rpm */
|
||||
typedef struct OMX_PARAM_SUSPENSIONTYPE {
|
||||
OMX_U32 nSize;
|
||||
OMX_VERSIONTYPE nVersion;
|
||||
OMX_SUSPENSIONTYPE eType;
|
||||
OMX_U32 nSize;
|
||||
OMX_VERSIONTYPE nVersion;
|
||||
OMX_SUSPENSIONTYPE eType;
|
||||
} OMX_PARAM_SUSPENSIONTYPE ;
|
||||
|
||||
typedef struct OMX_CONFIG_BOOLEANTYPE {
|
||||
OMX_U32 nSize;
|
||||
OMX_VERSIONTYPE nVersion;
|
||||
OMX_BOOL bEnabled;
|
||||
OMX_BOOL bEnabled;
|
||||
} OMX_CONFIG_BOOLEANTYPE;
|
||||
|
||||
/* Parameter specifying the content uri to use. */
|
||||
|
|
@ -171,9 +171,9 @@ typedef struct OMX_PARAM_CONTENTPIPETYPE
|
|||
typedef struct OMX_RESOURCECONCEALMENTTYPE {
|
||||
OMX_U32 nSize; /**< size of the structure in bytes */
|
||||
OMX_VERSIONTYPE nVersion; /**< OMX specification version information */
|
||||
OMX_BOOL bResourceConcealmentForbidden; /**< disallow the use of resource concealment
|
||||
methods (like degrading algorithm quality to
|
||||
lower resource consumption or functional bypass)
|
||||
OMX_BOOL bResourceConcealmentForbidden; /**< disallow the use of resource concealment
|
||||
methods (like degrading algorithm quality to
|
||||
lower resource consumption or functional bypass)
|
||||
on a component as a resolution to resource conflicts. */
|
||||
} OMX_RESOURCECONCEALMENTTYPE;
|
||||
|
||||
|
|
@ -188,7 +188,7 @@ typedef enum OMX_METADATACHARSETTYPE {
|
|||
OMX_MetadataCharsetJavaConformantUTF8,
|
||||
OMX_MetadataCharsetUTF7,
|
||||
OMX_MetadataCharsetImapUTF7,
|
||||
OMX_MetadataCharsetUTF16LE,
|
||||
OMX_MetadataCharsetUTF16LE,
|
||||
OMX_MetadataCharsetUTF16BE,
|
||||
OMX_MetadataCharsetGB12345,
|
||||
OMX_MetadataCharsetHZGB2312,
|
||||
|
|
@ -214,7 +214,7 @@ typedef enum OMX_METADATACHARSETTYPE {
|
|||
OMX_MetadataCharsetISO2022JP1,
|
||||
OMX_MetadataCharsetISOEUCJP,
|
||||
OMX_MetadataCharsetSMS7Bit,
|
||||
OMX_MetadataCharsetKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
||||
OMX_MetadataCharsetKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
||||
OMX_MetadataCharsetVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
|
||||
OMX_MetadataCharsetTypeMax= 0x7FFFFFFF
|
||||
} OMX_METADATACHARSETTYPE;
|
||||
|
|
@ -226,7 +226,7 @@ typedef enum OMX_METADATASCOPETYPE
|
|||
OMX_MetadataScopeTopLevel,
|
||||
OMX_MetadataScopePortLevel,
|
||||
OMX_MetadataScopeNodeLevel,
|
||||
OMX_MetadataScopeKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
||||
OMX_MetadataScopeKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
||||
OMX_MetadataScopeVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
|
||||
OMX_MetadataScopeTypeMax = 0x7fffffff
|
||||
} OMX_METADATASCOPETYPE;
|
||||
|
|
@ -237,7 +237,7 @@ typedef enum OMX_METADATASEARCHMODETYPE
|
|||
OMX_MetadataSearchValueSizeByIndex,
|
||||
OMX_MetadataSearchItemByIndex,
|
||||
OMX_MetadataSearchNextItemByKey,
|
||||
OMX_MetadataSearchKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
||||
OMX_MetadataSearchKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
||||
OMX_MetadataSearchVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
|
||||
OMX_MetadataSearchTypeMax = 0x7fffffff
|
||||
} OMX_METADATASEARCHMODETYPE;
|
||||
|
|
@ -258,7 +258,7 @@ typedef struct OMX_CONFIG_METADATAITEMTYPE
|
|||
OMX_VERSIONTYPE nVersion;
|
||||
OMX_METADATASCOPETYPE eScopeMode;
|
||||
OMX_U32 nScopeSpecifier;
|
||||
OMX_U32 nMetadataItemIndex;
|
||||
OMX_U32 nMetadataItemIndex;
|
||||
OMX_METADATASEARCHMODETYPE eSearchMode;
|
||||
OMX_METADATACHARSETTYPE eKeyCharset;
|
||||
OMX_U8 nKeySizeUsed;
|
||||
|
|
@ -287,30 +287,30 @@ typedef struct OMX_CONFIG_CONTAINERNODEIDTYPE
|
|||
OMX_VERSIONTYPE nVersion;
|
||||
OMX_BOOL bAllKeys;
|
||||
OMX_U32 nParentNodeID;
|
||||
OMX_U32 nNodeIndex;
|
||||
OMX_U32 nNodeID;
|
||||
OMX_U32 nNodeIndex;
|
||||
OMX_U32 nNodeID;
|
||||
OMX_STRING cNodeName;
|
||||
OMX_BOOL bIsLeafType;
|
||||
} OMX_CONFIG_CONTAINERNODEIDTYPE;
|
||||
|
||||
/** @ingroup metadata */
|
||||
typedef struct OMX_PARAM_METADATAFILTERTYPE
|
||||
{
|
||||
OMX_U32 nSize;
|
||||
OMX_VERSIONTYPE nVersion;
|
||||
OMX_BOOL bAllKeys; /* if true then this structure refers to all keys and
|
||||
typedef struct OMX_PARAM_METADATAFILTERTYPE
|
||||
{
|
||||
OMX_U32 nSize;
|
||||
OMX_VERSIONTYPE nVersion;
|
||||
OMX_BOOL bAllKeys; /* if true then this structure refers to all keys and
|
||||
* the three key fields below are ignored */
|
||||
OMX_METADATACHARSETTYPE eKeyCharset;
|
||||
OMX_U32 nKeySizeUsed;
|
||||
OMX_U8 nKey [128];
|
||||
OMX_U32 nKeySizeUsed;
|
||||
OMX_U8 nKey [128];
|
||||
OMX_U32 nLanguageCountrySizeUsed;
|
||||
OMX_U8 nLanguageCountry[128];
|
||||
OMX_BOOL bEnabled; /* if true then key is part of filter (e.g.
|
||||
OMX_BOOL bEnabled; /* if true then key is part of filter (e.g.
|
||||
* retained for query later). If false then
|
||||
* key is not part of filter */
|
||||
} OMX_PARAM_METADATAFILTERTYPE;
|
||||
} OMX_PARAM_METADATAFILTERTYPE;
|
||||
|
||||
/** The OMX_HANDLETYPE structure defines the component handle. The component
|
||||
/** 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)
|
||||
|
|
@ -318,7 +318,7 @@ typedef struct OMX_PARAM_METADATAFILTERTYPE
|
|||
* 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).
|
||||
*
|
||||
*
|
||||
* @ingroup comp
|
||||
*/
|
||||
typedef struct OMX_COMPONENTTYPE
|
||||
|
|
@ -329,26 +329,26 @@ typedef struct OMX_COMPONENTTYPE
|
|||
function will fill in this value. */
|
||||
OMX_U32 nSize;
|
||||
|
||||
/** nVersion is the version of the OMX specification that the structure
|
||||
is built against. It is the responsibility of the creator of this
|
||||
structure to initialize this value and every user of this structure
|
||||
should verify that it knows how to use the exact version of
|
||||
/** nVersion is the version of the OMX specification that the structure
|
||||
is built against. It is the responsibility of the creator of this
|
||||
structure to initialize this value and every user of this structure
|
||||
should verify that it knows how to use the exact version of
|
||||
this structure found herein. */
|
||||
OMX_VERSIONTYPE nVersion;
|
||||
|
||||
/** pComponentPrivate is a pointer to the component private data area.
|
||||
This member is allocated and initialized by the component when the
|
||||
component is first loaded. The application should not access this
|
||||
/** pComponentPrivate is a pointer to the component private data area.
|
||||
This member is allocated and initialized by the component when the
|
||||
component is first loaded. The application should not access this
|
||||
data area. */
|
||||
OMX_PTR pComponentPrivate;
|
||||
|
||||
/** pApplicationPrivate is a pointer that is a parameter to the
|
||||
OMX_GetHandle method, and contains an application private value
|
||||
provided by the IL client. This application private data is
|
||||
/** pApplicationPrivate is a pointer that is a parameter to the
|
||||
OMX_GetHandle method, and contains an application private value
|
||||
provided by the IL client. This application private data is
|
||||
returned to the IL Client by OMX in all callbacks */
|
||||
OMX_PTR pApplicationPrivate;
|
||||
|
||||
/** refer to OMX_GetComponentVersion in OMX_core.h or the OMX IL
|
||||
/** refer to OMX_GetComponentVersion in OMX_core.h or the OMX IL
|
||||
specification for details on the GetComponentVersion method.
|
||||
*/
|
||||
OMX_ERRORTYPE (*GetComponentVersion)(
|
||||
|
|
@ -358,7 +358,7 @@ typedef struct OMX_COMPONENTTYPE
|
|||
OMX_OUT OMX_VERSIONTYPE* pSpecVersion,
|
||||
OMX_OUT OMX_UUIDTYPE* pComponentUUID);
|
||||
|
||||
/** refer to OMX_SendCommand in OMX_core.h or the OMX IL
|
||||
/** refer to OMX_SendCommand in OMX_core.h or the OMX IL
|
||||
specification for details on the SendCommand method.
|
||||
*/
|
||||
OMX_ERRORTYPE (*SendCommand)(
|
||||
|
|
@ -367,43 +367,43 @@ typedef struct OMX_COMPONENTTYPE
|
|||
OMX_IN OMX_U32 nParam1,
|
||||
OMX_IN OMX_PTR pCmdData);
|
||||
|
||||
/** refer to OMX_GetParameter in OMX_core.h or the OMX IL
|
||||
/** refer to OMX_GetParameter in OMX_core.h or the OMX IL
|
||||
specification for details on the GetParameter method.
|
||||
*/
|
||||
OMX_ERRORTYPE (*GetParameter)(
|
||||
OMX_IN OMX_HANDLETYPE hComponent,
|
||||
OMX_IN OMX_INDEXTYPE nParamIndex,
|
||||
OMX_IN OMX_HANDLETYPE hComponent,
|
||||
OMX_IN OMX_INDEXTYPE nParamIndex,
|
||||
OMX_INOUT OMX_PTR pComponentParameterStructure);
|
||||
|
||||
|
||||
/** refer to OMX_SetParameter in OMX_core.h or the OMX IL
|
||||
/** refer to OMX_SetParameter in OMX_core.h or the OMX IL
|
||||
specification for details on the SetParameter method.
|
||||
*/
|
||||
OMX_ERRORTYPE (*SetParameter)(
|
||||
OMX_IN OMX_HANDLETYPE hComponent,
|
||||
OMX_IN OMX_HANDLETYPE hComponent,
|
||||
OMX_IN OMX_INDEXTYPE nIndex,
|
||||
OMX_IN OMX_PTR pComponentParameterStructure);
|
||||
|
||||
|
||||
/** refer to OMX_GetConfig in OMX_core.h or the OMX IL
|
||||
/** refer to OMX_GetConfig in OMX_core.h or the OMX IL
|
||||
specification for details on the GetConfig method.
|
||||
*/
|
||||
OMX_ERRORTYPE (*GetConfig)(
|
||||
OMX_IN OMX_HANDLETYPE hComponent,
|
||||
OMX_IN OMX_INDEXTYPE nIndex,
|
||||
OMX_IN OMX_INDEXTYPE nIndex,
|
||||
OMX_INOUT OMX_PTR pComponentConfigStructure);
|
||||
|
||||
|
||||
/** refer to OMX_SetConfig in OMX_core.h or the OMX IL
|
||||
/** refer to OMX_SetConfig in OMX_core.h or the OMX IL
|
||||
specification for details on the SetConfig method.
|
||||
*/
|
||||
OMX_ERRORTYPE (*SetConfig)(
|
||||
OMX_IN OMX_HANDLETYPE hComponent,
|
||||
OMX_IN OMX_INDEXTYPE nIndex,
|
||||
OMX_IN OMX_INDEXTYPE nIndex,
|
||||
OMX_IN OMX_PTR pComponentConfigStructure);
|
||||
|
||||
|
||||
/** refer to OMX_GetExtensionIndex in OMX_core.h or the OMX IL
|
||||
/** refer to OMX_GetExtensionIndex in OMX_core.h or the OMX IL
|
||||
specification for details on the GetExtensionIndex method.
|
||||
*/
|
||||
OMX_ERRORTYPE (*GetExtensionIndex)(
|
||||
|
|
@ -412,50 +412,50 @@ typedef struct OMX_COMPONENTTYPE
|
|||
OMX_OUT OMX_INDEXTYPE* pIndexType);
|
||||
|
||||
|
||||
/** refer to OMX_GetState in OMX_core.h or the OMX IL
|
||||
/** refer to OMX_GetState in OMX_core.h or the OMX IL
|
||||
specification for details on the GetState method.
|
||||
*/
|
||||
OMX_ERRORTYPE (*GetState)(
|
||||
OMX_IN OMX_HANDLETYPE hComponent,
|
||||
OMX_OUT OMX_STATETYPE* pState);
|
||||
|
||||
|
||||
|
||||
/** The ComponentTunnelRequest method will interact with another OMX
|
||||
component to determine if tunneling is possible and to setup the
|
||||
tunneling. The return codes for this method can be used to
|
||||
tunneling. The return codes for this method can be used to
|
||||
determine if tunneling is not possible, or if tunneling is not
|
||||
supported.
|
||||
|
||||
Base profile components (i.e. non-interop) do not support this
|
||||
method and should return OMX_ErrorNotImplemented
|
||||
supported.
|
||||
|
||||
The interop profile component MUST support tunneling to another
|
||||
interop profile component with a compatible port parameters.
|
||||
Base profile components (i.e. non-interop) do not support this
|
||||
method and should return OMX_ErrorNotImplemented
|
||||
|
||||
The interop profile component MUST support tunneling to another
|
||||
interop profile component with a compatible port parameters.
|
||||
A component may also support proprietary communication.
|
||||
|
||||
If proprietary communication is supported the negotiation of
|
||||
proprietary communication is done outside of OMX in a vendor
|
||||
specific way. It is only required that the proper result be
|
||||
returned and the details of how the setup is done is left
|
||||
to the component implementation.
|
||||
|
||||
|
||||
If proprietary communication is supported the negotiation of
|
||||
proprietary communication is done outside of OMX in a vendor
|
||||
specific way. It is only required that the proper result be
|
||||
returned and the details of how the setup is done is left
|
||||
to the component implementation.
|
||||
|
||||
When this method is invoked when nPort in an output port, the
|
||||
component will:
|
||||
1. Populate the pTunnelSetup structure with the output port's
|
||||
1. Populate the pTunnelSetup structure with the output port's
|
||||
requirements and constraints for the tunnel.
|
||||
|
||||
When this method is invoked when nPort in an input port, the
|
||||
component will:
|
||||
1. Query the necessary parameters from the output port to
|
||||
1. Query the necessary parameters from the output port to
|
||||
determine if the ports are compatible for tunneling
|
||||
2. If the ports are compatible, the component should store
|
||||
the tunnel step provided by the output port
|
||||
3. Determine which port (either input or output) is the buffer
|
||||
supplier, and call OMX_SetParameter on the output port to
|
||||
indicate this selection.
|
||||
|
||||
|
||||
The component will return from this call within 5 msec.
|
||||
|
||||
|
||||
@param [in] hComp
|
||||
Handle of the component to be accessed. This is the component
|
||||
handle returned by the call to the OMX_GetHandle method.
|
||||
|
|
@ -463,7 +463,7 @@ typedef struct OMX_COMPONENTTYPE
|
|||
nPort is used to select the port on the component to be used
|
||||
for tunneling.
|
||||
@param [in] hTunneledComp
|
||||
Handle of the component to tunnel with. This is the component
|
||||
Handle of the component to tunnel with. This is the component
|
||||
handle returned by the call to the OMX_GetHandle method. When
|
||||
this parameter is 0x0 the component should setup the port for
|
||||
communication with the application / IL Client.
|
||||
|
|
@ -486,9 +486,9 @@ typedef struct OMX_COMPONENTTYPE
|
|||
OMX_IN OMX_U32 nPort,
|
||||
OMX_IN OMX_HANDLETYPE hTunneledComp,
|
||||
OMX_IN OMX_U32 nTunneledPort,
|
||||
OMX_INOUT OMX_TUNNELSETUPTYPE* pTunnelSetup);
|
||||
OMX_INOUT OMX_TUNNELSETUPTYPE* pTunnelSetup);
|
||||
|
||||
/** refer to OMX_UseBuffer in OMX_core.h or the OMX IL
|
||||
/** refer to OMX_UseBuffer in OMX_core.h or the OMX IL
|
||||
specification for details on the UseBuffer method.
|
||||
@ingroup buf
|
||||
*/
|
||||
|
|
@ -500,7 +500,7 @@ typedef struct OMX_COMPONENTTYPE
|
|||
OMX_IN OMX_U32 nSizeBytes,
|
||||
OMX_IN OMX_U8* pBuffer);
|
||||
|
||||
/** refer to OMX_AllocateBuffer in OMX_core.h or the OMX IL
|
||||
/** refer to OMX_AllocateBuffer in OMX_core.h or the OMX IL
|
||||
specification for details on the AllocateBuffer method.
|
||||
@ingroup buf
|
||||
*/
|
||||
|
|
@ -511,7 +511,7 @@ typedef struct OMX_COMPONENTTYPE
|
|||
OMX_IN OMX_PTR pAppPrivate,
|
||||
OMX_IN OMX_U32 nSizeBytes);
|
||||
|
||||
/** refer to OMX_FreeBuffer in OMX_core.h or the OMX IL
|
||||
/** refer to OMX_FreeBuffer in OMX_core.h or the OMX IL
|
||||
specification for details on the FreeBuffer method.
|
||||
@ingroup buf
|
||||
*/
|
||||
|
|
@ -520,7 +520,7 @@ typedef struct OMX_COMPONENTTYPE
|
|||
OMX_IN OMX_U32 nPortIndex,
|
||||
OMX_IN OMX_BUFFERHEADERTYPE* pBuffer);
|
||||
|
||||
/** refer to OMX_EmptyThisBuffer in OMX_core.h or the OMX IL
|
||||
/** refer to OMX_EmptyThisBuffer in OMX_core.h or the OMX IL
|
||||
specification for details on the EmptyThisBuffer method.
|
||||
@ingroup buf
|
||||
*/
|
||||
|
|
@ -528,7 +528,7 @@ typedef struct OMX_COMPONENTTYPE
|
|||
OMX_IN OMX_HANDLETYPE hComponent,
|
||||
OMX_IN OMX_BUFFERHEADERTYPE* pBuffer);
|
||||
|
||||
/** refer to OMX_FillThisBuffer in OMX_core.h or the OMX IL
|
||||
/** refer to OMX_FillThisBuffer in OMX_core.h or the OMX IL
|
||||
specification for details on the FillThisBuffer method.
|
||||
@ingroup buf
|
||||
*/
|
||||
|
|
@ -543,10 +543,10 @@ typedef struct OMX_COMPONENTTYPE
|
|||
Handle of the component to be accessed. This is the component
|
||||
handle returned by the call to the GetHandle function.
|
||||
@param [in] pCallbacks
|
||||
pointer to an OMX_CALLBACKTYPE structure used to provide the
|
||||
pointer to an OMX_CALLBACKTYPE structure used to provide the
|
||||
callback information to the component
|
||||
@param [in] pAppData
|
||||
pointer to an application defined value. It is anticipated that
|
||||
pointer to an application defined value. It is anticipated that
|
||||
the application will pass a pointer to a data structure or a "this
|
||||
pointer" in this area to allow the callback (in the application)
|
||||
to determine the context of the call
|
||||
|
|
@ -556,7 +556,7 @@ typedef struct OMX_COMPONENTTYPE
|
|||
*/
|
||||
OMX_ERRORTYPE (*SetCallbacks)(
|
||||
OMX_IN OMX_HANDLETYPE hComponent,
|
||||
OMX_IN OMX_CALLBACKTYPE* pCallbacks,
|
||||
OMX_IN OMX_CALLBACKTYPE* pCallbacks,
|
||||
OMX_IN OMX_PTR pAppData);
|
||||
|
||||
/** ComponentDeInit method is used to deinitialize the component
|
||||
|
|
@ -583,8 +583,8 @@ typedef struct OMX_COMPONENTTYPE
|
|||
|
||||
OMX_ERRORTYPE (*ComponentRoleEnum)(
|
||||
OMX_IN OMX_HANDLETYPE hComponent,
|
||||
OMX_OUT OMX_U8 *cRole,
|
||||
OMX_IN OMX_U32 nIndex);
|
||||
OMX_OUT OMX_U8 *cRole,
|
||||
OMX_IN OMX_U32 nIndex);
|
||||
|
||||
} OMX_COMPONENTTYPE;
|
||||
|
||||
|
|
|
|||
|
|
@ -16,25 +16,25 @@
|
|||
* -------------------------------------------------------------------
|
||||
*/
|
||||
/*
|
||||
* Copyright (c) 2008 The Khronos Group Inc.
|
||||
*
|
||||
* 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:
|
||||
* to the following conditions:
|
||||
* The above copyright notice and this permission notice shall be included
|
||||
* in all copies or substantial portions of the Software.
|
||||
*
|
||||
* 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.
|
||||
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
*/
|
||||
|
||||
|
|
@ -81,83 +81,83 @@
|
|||
|
||||
/** Map types from OMX standard types only here so interface is as generic as possible. */
|
||||
typedef OMX_U32 CPresult;
|
||||
typedef char * CPstring;
|
||||
typedef char * CPstring;
|
||||
typedef void * CPhandle;
|
||||
typedef OMX_U32 CPuint;
|
||||
typedef OMX_S32 CPint;
|
||||
typedef char CPbyte;
|
||||
typedef OMX_S32 CPint;
|
||||
typedef char CPbyte;
|
||||
typedef OMX_BOOL CPbool;
|
||||
|
||||
/** enumeration of origin types used in the CP_PIPETYPE's Seek function
|
||||
/** enumeration of origin types used in the CP_PIPETYPE's Seek function
|
||||
* @ingroup cp
|
||||
*/
|
||||
typedef enum CP_ORIGINTYPE {
|
||||
CP_OriginBegin,
|
||||
CP_OriginCur,
|
||||
CP_OriginEnd,
|
||||
CP_OriginKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
||||
CP_OriginBegin,
|
||||
CP_OriginCur,
|
||||
CP_OriginEnd,
|
||||
CP_OriginKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
||||
CP_OriginVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
|
||||
CP_OriginMax = 0X7FFFFFFF
|
||||
} CP_ORIGINTYPE;
|
||||
|
||||
/** enumeration of contact access types used in the CP_PIPETYPE's Open function
|
||||
/** enumeration of contact access types used in the CP_PIPETYPE's Open function
|
||||
* @ingroup cp
|
||||
*/
|
||||
typedef enum CP_ACCESSTYPE {
|
||||
CP_AccessRead,
|
||||
CP_AccessWrite,
|
||||
CP_AccessReadWrite ,
|
||||
CP_AccessKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
||||
CP_AccessRead,
|
||||
CP_AccessWrite,
|
||||
CP_AccessReadWrite,
|
||||
CP_AccessKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
||||
CP_AccessVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
|
||||
CP_AccessMax = 0X7FFFFFFF
|
||||
} CP_ACCESSTYPE;
|
||||
|
||||
/** enumeration of results returned by the CP_PIPETYPE's CheckAvailableBytes function
|
||||
/** enumeration of results returned by the CP_PIPETYPE's CheckAvailableBytes function
|
||||
* @ingroup cp
|
||||
*/
|
||||
typedef enum CP_CHECKBYTESRESULTTYPE
|
||||
{
|
||||
CP_CheckBytesOk, /**< There are at least the request number
|
||||
CP_CheckBytesOk, /**< There are at least the request number
|
||||
of bytes available */
|
||||
CP_CheckBytesNotReady, /**< The pipe is still retrieving bytes
|
||||
and presently lacks sufficient bytes.
|
||||
Client will be called when they are
|
||||
CP_CheckBytesNotReady, /**< The pipe is still retrieving bytes
|
||||
and presently lacks sufficient bytes.
|
||||
Client will be called when they are
|
||||
sufficient bytes are available. */
|
||||
CP_CheckBytesInsufficientBytes , /**< The pipe has retrieved all bytes
|
||||
but those available are less than those
|
||||
CP_CheckBytesInsufficientBytes, /**< The pipe has retrieved all bytes
|
||||
but those available are less than those
|
||||
requested */
|
||||
CP_CheckBytesAtEndOfStream, /**< The pipe has reached the end of stream
|
||||
and no more bytes are available. */
|
||||
CP_CheckBytesOutOfBuffers, /**< All read/write buffers are currently in use. */
|
||||
CP_CheckBytesKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
||||
CP_CheckBytesKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
||||
CP_CheckBytesVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
|
||||
CP_CheckBytesMax = 0X7FFFFFFF
|
||||
} CP_CHECKBYTESRESULTTYPE;
|
||||
|
||||
/** enumeration of content pipe events sent to the client callback.
|
||||
/** enumeration of content pipe events sent to the client callback.
|
||||
* @ingroup cp
|
||||
*/
|
||||
typedef enum CP_EVENTTYPE{
|
||||
CP_BytesAvailable, /** bytes requested in a CheckAvailableBytes call are now available*/
|
||||
CP_Overflow, /** enumeration of content pipe events sent to the client callback*/
|
||||
CP_PipeDisconnected , /** enumeration of content pipe events sent to the client callback*/
|
||||
CP_EventKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
||||
CP_BytesAvailable, /** bytes requested in a CheckAvailableBytes call are now available*/
|
||||
CP_Overflow, /** enumeration of content pipe events sent to the client callback*/
|
||||
CP_PipeDisconnected, /** enumeration of content pipe events sent to the client callback*/
|
||||
CP_EventKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
||||
CP_EventVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
|
||||
CP_EventMax = 0X7FFFFFFF
|
||||
} CP_EVENTTYPE;
|
||||
|
||||
/** content pipe definition
|
||||
/** content pipe definition
|
||||
* @ingroup cp
|
||||
*/
|
||||
typedef struct CP_PIPETYPE
|
||||
{
|
||||
/** Open a content stream for reading or writing. */
|
||||
/** Open a content stream for reading or writing. */
|
||||
CPresult (*Open)( CPhandle* hContent, CPstring szURI, CP_ACCESSTYPE eAccess );
|
||||
|
||||
/** Close a content stream. */
|
||||
/** Close a content stream. */
|
||||
CPresult (*Close)( CPhandle hContent );
|
||||
|
||||
/** Create a content source and open it for writing. */
|
||||
/** Create a content source and open it for writing. */
|
||||
CPresult (*Create)( CPhandle *hContent, CPstring szURI );
|
||||
|
||||
/** Check the that specified number of bytes are available for reading or writing (depending on access type).*/
|
||||
|
|
@ -171,19 +171,19 @@ typedef struct CP_PIPETYPE
|
|||
|
||||
/** Retrieve data of the specified size from the content stream (advance content pointer by size of data).
|
||||
Note: pipe client provides pointer. This function is appropriate for small high frequency reads. */
|
||||
CPresult (*Read)( CPhandle hContent, CPbyte *pData, CPuint nSize);
|
||||
CPresult (*Read)( CPhandle hContent, CPbyte *pData, CPuint nSize);
|
||||
|
||||
/** Retrieve a buffer allocated by the pipe that contains the requested number of bytes.
|
||||
/** Retrieve a buffer allocated by the pipe that contains the requested number of bytes.
|
||||
Buffer contains the next block of bytes, as specified by nSize, of the content. nSize also
|
||||
returns the size of the block actually read. Content pointer advances the by the returned size.
|
||||
Note: pipe provides pointer. This function is appropriate for large reads. The client must call
|
||||
ReleaseReadBuffer when done with buffer.
|
||||
returns the size of the block actually read. Content pointer advances the by the returned size.
|
||||
Note: pipe provides pointer. This function is appropriate for large reads. The client must call
|
||||
ReleaseReadBuffer when done with buffer.
|
||||
|
||||
In some cases the requested block may not reside in contiguous memory within the
|
||||
pipe implementation. For instance if the pipe leverages a circular buffer then the requested
|
||||
block may straddle the boundary of the circular buffer. By default a pipe implementation
|
||||
pipe implementation. For instance if the pipe leverages a circular buffer then the requested
|
||||
block may straddle the boundary of the circular buffer. By default a pipe implementation
|
||||
performs a copy in this case to provide the block to the pipe client in one contiguous buffer.
|
||||
If, however, the client sets bForbidCopy, then the pipe returns only those bytes preceding the memory
|
||||
If, however, the client sets bForbidCopy, then the pipe returns only those bytes preceding the memory
|
||||
boundary. Here the client may retrieve the data in segments over successive calls. */
|
||||
CPresult (*ReadBuffer)( CPhandle hContent, CPbyte **ppBuffer, CPuint *nSize, CPbool bForbidCopy);
|
||||
|
||||
|
|
@ -192,14 +192,14 @@ typedef struct CP_PIPETYPE
|
|||
|
||||
/** Write data of the specified size to the content (advance content pointer by size of data).
|
||||
Note: pipe client provides pointer. This function is appropriate for small high frequency writes. */
|
||||
CPresult (*Write)( CPhandle hContent, CPbyte *data, CPuint nSize);
|
||||
CPresult (*Write)( CPhandle hContent, CPbyte *data, CPuint nSize);
|
||||
|
||||
/** Retrieve a buffer allocated by the pipe used to write data to the content.
|
||||
/** Retrieve a buffer allocated by the pipe used to write data to the content.
|
||||
Client will fill buffer with output data. Note: pipe provides pointer. This function is appropriate
|
||||
for large writes. The client must call WriteBuffer when done it has filled the buffer with data.*/
|
||||
CPresult (*GetWriteBuffer)( CPhandle hContent, CPbyte **ppBuffer, CPuint nSize);
|
||||
|
||||
/** Deliver a buffer obtained via GetWriteBuffer to the pipe. Pipe will write the
|
||||
/** Deliver a buffer obtained via GetWriteBuffer to the pipe. Pipe will write the
|
||||
the contents of the buffer to content and advance content pointer by the size of the buffer */
|
||||
CPresult (*WriteBuffer)( CPhandle hContent, CPbyte *pBuffer, CPuint nFilledSize);
|
||||
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -846,7 +846,7 @@ typedef struct OMX_CONFIG_CAPTUREMODETYPE {
|
|||
typedef enum OMX_METERINGTYPE {
|
||||
|
||||
OMX_MeteringModeAverage, /**< Center-weighted average metering. */
|
||||
OMX_MeteringModeSpot, /**< Spot (partial) metering. */
|
||||
OMX_MeteringModeSpot, /**< Spot (partial) metering. */
|
||||
OMX_MeteringModeMatrix, /**< Matrix or evaluative metering. */
|
||||
|
||||
OMX_MeteringKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
||||
|
|
@ -861,11 +861,11 @@ typedef struct OMX_CONFIG_EXPOSUREVALUETYPE {
|
|||
OMX_METERINGTYPE eMetering;
|
||||
OMX_S32 xEVCompensation; /**< Fixed point value stored as Q16 */
|
||||
OMX_U32 nApertureFNumber; /**< e.g. nApertureFNumber = 2 implies "f/2" - Q16 format */
|
||||
OMX_BOOL bAutoAperture; /**< Whether aperture number is defined automatically */
|
||||
OMX_BOOL bAutoAperture; /**< Whether aperture number is defined automatically */
|
||||
OMX_U32 nShutterSpeedMsec; /**< Shutterspeed in milliseconds */
|
||||
OMX_BOOL bAutoShutterSpeed; /**< Whether shutter speed is defined automatically */
|
||||
OMX_BOOL bAutoShutterSpeed; /**< Whether shutter speed is defined automatically */
|
||||
OMX_U32 nSensitivity; /**< e.g. nSensitivity = 100 implies "ISO 100" */
|
||||
OMX_BOOL bAutoSensitivity; /**< Whether sensitivity is defined automatically */
|
||||
OMX_BOOL bAutoSensitivity; /**< Whether sensitivity is defined automatically */
|
||||
} OMX_CONFIG_EXPOSUREVALUETYPE;
|
||||
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -16,30 +16,30 @@
|
|||
* -------------------------------------------------------------------
|
||||
*/
|
||||
/**
|
||||
* Copyright (c) 2008 The Khronos Group Inc.
|
||||
*
|
||||
* 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:
|
||||
* to the following conditions:
|
||||
* The above copyright notice and this permission notice shall be included
|
||||
* in all copies or substantial portions of the Software.
|
||||
*
|
||||
* 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.
|
||||
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*/
|
||||
|
||||
/**
|
||||
/**
|
||||
* @file OMX_Image.h - OpenMax IL version 1.1.2
|
||||
* The structures needed by Image components to exchange parameters and
|
||||
* The structures needed by Image components to exchange parameters and
|
||||
* configuration data with the components.
|
||||
*/
|
||||
#ifndef OMX_Image_h
|
||||
|
|
@ -51,9 +51,9 @@ extern "C" {
|
|||
|
||||
|
||||
/**
|
||||
* Each OMX header must 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
|
||||
* Each OMX header must 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_IVCommon.h>
|
||||
|
|
@ -64,8 +64,8 @@ extern "C" {
|
|||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* Enumeration used to define the possible image compression coding.
|
||||
/**
|
||||
* Enumeration used to define the possible image compression coding.
|
||||
*/
|
||||
typedef enum OMX_IMAGE_CODINGTYPE {
|
||||
OMX_IMAGE_CodingUnused, /**< Value when format is N/A */
|
||||
|
|
@ -78,59 +78,59 @@ typedef enum OMX_IMAGE_CODINGTYPE {
|
|||
OMX_IMAGE_CodingPNG, /**< PNG image format */
|
||||
OMX_IMAGE_CodingLZW, /**< LZW image format */
|
||||
OMX_IMAGE_CodingBMP, /**< Windows Bitmap format */
|
||||
OMX_IMAGE_CodingKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
||||
OMX_IMAGE_CodingKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
||||
OMX_IMAGE_CodingVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
|
||||
OMX_IMAGE_CodingMax = 0x7FFFFFFF
|
||||
} OMX_IMAGE_CODINGTYPE;
|
||||
|
||||
|
||||
/**
|
||||
* Data structure used to define an image path. The number of image paths
|
||||
* for input and output will vary by type of the image component.
|
||||
*
|
||||
* Data structure used to define an image path. The number of image paths
|
||||
* for input and output will vary by type of the image component.
|
||||
*
|
||||
* Input (aka Source) : Zero Inputs, one Output,
|
||||
* Splitter : One Input, 2 or more Outputs,
|
||||
* Processing Element : One Input, one output,
|
||||
* Mixer : 2 or more inputs, one output,
|
||||
* Output (aka Sink) : One Input, zero outputs.
|
||||
*
|
||||
* The PortDefinition structure is used to define all of the parameters
|
||||
* necessary for the compliant component to setup an input or an output
|
||||
* image path. If additional vendor specific data is required, it should
|
||||
* be transmitted to the component using the CustomCommand function.
|
||||
* Compliant components will prepopulate this structure with optimal
|
||||
*
|
||||
* The PortDefinition structure is used to define all of the parameters
|
||||
* necessary for the compliant component to setup an input or an output
|
||||
* image path. If additional vendor specific data is required, it should
|
||||
* be transmitted to the component using the CustomCommand function.
|
||||
* Compliant components will prepopulate this structure with optimal
|
||||
* values during the OMX_GetParameter() command.
|
||||
*
|
||||
* STRUCT MEMBERS:
|
||||
* cMIMEType : MIME type of data for the port
|
||||
* pNativeRender : Platform specific reference for a display if a
|
||||
* pNativeRender : Platform specific reference for a display if a
|
||||
* sync, otherwise this field is 0
|
||||
* nFrameWidth : Width of frame to be used on port if
|
||||
* uncompressed format is used. Use 0 for
|
||||
* nFrameWidth : Width of frame to be used on port if
|
||||
* uncompressed format is used. Use 0 for
|
||||
* unknown, don't care or variable
|
||||
* nFrameHeight : Height of frame to be used on port if
|
||||
* uncompressed format is used. Use 0 for
|
||||
* nFrameHeight : Height of frame to be used on port if
|
||||
* uncompressed format is used. Use 0 for
|
||||
* unknown, don't care or variable
|
||||
* nStride : Number of bytes per span of an image (i.e.
|
||||
* nStride : Number of bytes per span of an image (i.e.
|
||||
* indicates the number of bytes to get from
|
||||
* span N to span N+1, where negative stride
|
||||
* span N to span N+1, where negative stride
|
||||
* indicates the image is bottom up
|
||||
* nSliceHeight : Height used when encoding in slices
|
||||
* bFlagErrorConcealment : Turns on error concealment if it is supported by
|
||||
* bFlagErrorConcealment : Turns on error concealment if it is supported by
|
||||
* the OMX component
|
||||
* eCompressionFormat : Compression format used in this instance of
|
||||
* the component. When OMX_IMAGE_CodingUnused is
|
||||
* eCompressionFormat : Compression format used in this instance of
|
||||
* the component. When OMX_IMAGE_CodingUnused is
|
||||
* specified, eColorFormat is valid
|
||||
* eColorFormat : Decompressed format used by this component
|
||||
* pNativeWindow : Platform specific reference for a window object if a
|
||||
* display sink , otherwise this field is 0x0.
|
||||
* pNativeWindow : Platform specific reference for a window object if a
|
||||
* display sink , otherwise this field is 0x0.
|
||||
*/
|
||||
typedef struct OMX_IMAGE_PORTDEFINITIONTYPE {
|
||||
OMX_STRING cMIMEType;
|
||||
OMX_NATIVE_DEVICETYPE pNativeRender;
|
||||
OMX_U32 nFrameWidth;
|
||||
OMX_U32 nFrameWidth;
|
||||
OMX_U32 nFrameHeight;
|
||||
OMX_S32 nStride;
|
||||
OMX_S32 nStride;
|
||||
OMX_U32 nSliceHeight;
|
||||
OMX_BOOL bFlagErrorConcealment;
|
||||
OMX_IMAGE_CODINGTYPE eCompressionFormat;
|
||||
|
|
@ -139,18 +139,18 @@ typedef struct OMX_IMAGE_PORTDEFINITIONTYPE {
|
|||
} OMX_IMAGE_PORTDEFINITIONTYPE;
|
||||
|
||||
|
||||
/**
|
||||
* Port format parameter. This structure is used to enumerate the various
|
||||
/**
|
||||
* Port format parameter. This structure is used to enumerate the various
|
||||
* data input/output format supported by the port.
|
||||
*
|
||||
*
|
||||
* STRUCT MEMBERS:
|
||||
* nSize : Size of the structure in bytes
|
||||
* nVersion : OMX specification version information
|
||||
* nPortIndex : Indicates which port to set
|
||||
* nIndex : Indicates the enumeration index for the format from
|
||||
* nIndex : Indicates the enumeration index for the format from
|
||||
* 0x0 to N-1
|
||||
* eCompressionFormat : Compression format used in this instance of the
|
||||
* component. When OMX_IMAGE_CodingUnused is specified,
|
||||
* eCompressionFormat : Compression format used in this instance of the
|
||||
* component. When OMX_IMAGE_CodingUnused is specified,
|
||||
* eColorFormat is valid
|
||||
* eColorFormat : Decompressed format used by this component
|
||||
*/
|
||||
|
|
@ -164,8 +164,8 @@ typedef struct OMX_IMAGE_PARAM_PORTFORMATTYPE {
|
|||
} OMX_IMAGE_PARAM_PORTFORMATTYPE;
|
||||
|
||||
|
||||
/**
|
||||
* Flash control type
|
||||
/**
|
||||
* Flash control type
|
||||
*
|
||||
* ENUMS
|
||||
* Torch : Flash forced constantly on
|
||||
|
|
@ -177,14 +177,14 @@ typedef enum OMX_IMAGE_FLASHCONTROLTYPE {
|
|||
OMX_IMAGE_FlashControlRedEyeReduction,
|
||||
OMX_IMAGE_FlashControlFillin,
|
||||
OMX_IMAGE_FlashControlTorch,
|
||||
OMX_IMAGE_FlashControlKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
||||
OMX_IMAGE_FlashControlKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
||||
OMX_IMAGE_FlashControlVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
|
||||
OMX_IMAGE_FlashControlMax = 0x7FFFFFFF
|
||||
} OMX_IMAGE_FLASHCONTROLTYPE;
|
||||
|
||||
|
||||
/**
|
||||
* Flash control configuration
|
||||
/**
|
||||
* Flash control configuration
|
||||
*
|
||||
* STRUCT MEMBERS:
|
||||
* nSize : Size of the structure in bytes
|
||||
|
|
@ -200,29 +200,29 @@ typedef struct OMX_IMAGE_PARAM_FLASHCONTROLTYPE {
|
|||
} OMX_IMAGE_PARAM_FLASHCONTROLTYPE;
|
||||
|
||||
|
||||
/**
|
||||
* Focus control type
|
||||
/**
|
||||
* Focus control type
|
||||
*/
|
||||
typedef enum OMX_IMAGE_FOCUSCONTROLTYPE {
|
||||
OMX_IMAGE_FocusControlOn = 0,
|
||||
OMX_IMAGE_FocusControlOff,
|
||||
OMX_IMAGE_FocusControlAuto,
|
||||
OMX_IMAGE_FocusControlAutoLock,
|
||||
OMX_IMAGE_FocusControlKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
||||
OMX_IMAGE_FocusControlKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
||||
OMX_IMAGE_FocusControlVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
|
||||
OMX_IMAGE_FocusControlMax = 0x7FFFFFFF
|
||||
} OMX_IMAGE_FOCUSCONTROLTYPE;
|
||||
|
||||
|
||||
/**
|
||||
* Focus control configuration
|
||||
|
||||
/**
|
||||
* Focus control configuration
|
||||
*
|
||||
* STRUCT MEMBERS:
|
||||
* nSize : Size of the structure in bytes
|
||||
* nVersion : OMX specification version information
|
||||
* nPortIndex : Port that this structure applies to
|
||||
* eFocusControl : Focus control
|
||||
* nFocusSteps : Focus can take on values from 0 mm to infinity.
|
||||
* nFocusSteps : Focus can take on values from 0 mm to infinity.
|
||||
* Interest is only in number of steps over this range.
|
||||
* nFocusStepIndex : Current focus step index
|
||||
*/
|
||||
|
|
@ -236,30 +236,30 @@ typedef struct OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE {
|
|||
} OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE;
|
||||
|
||||
|
||||
/**
|
||||
/**
|
||||
* Q Factor for JPEG compression, which controls the tradeoff between image
|
||||
* quality and size. Q Factor provides a more simple means of controlling
|
||||
* JPEG compression quality, without directly programming Quantization
|
||||
* tables for chroma and luma
|
||||
* tables for chroma and luma
|
||||
*
|
||||
* STRUCT MEMBERS:
|
||||
* nSize : Size of the structure in bytes
|
||||
* nVersion : OMX specification version information
|
||||
* nPortIndex : Port that this structure applies to
|
||||
* nQFactor : JPEG Q factor value in the range of 1-100. A factor of 1
|
||||
* produces the smallest, worst quality images, and a factor
|
||||
* of 100 produces the largest, best quality images. A
|
||||
* typical default is 75 for small good quality images
|
||||
* nSize : Size of the structure in bytes
|
||||
* nVersion : OMX specification version information
|
||||
* nPortIndex : Port that this structure applies to
|
||||
* nQFactor : JPEG Q factor value in the range of 1-100. A factor of 1
|
||||
* produces the smallest, worst quality images, and a factor
|
||||
* of 100 produces the largest, best quality images. A
|
||||
* typical default is 75 for small good quality images
|
||||
*/
|
||||
typedef struct OMX_IMAGE_PARAM_QFACTORTYPE {
|
||||
OMX_U32 nSize;
|
||||
OMX_VERSIONTYPE nVersion;
|
||||
OMX_U32 nPortIndex;
|
||||
OMX_U32 nQFactor;
|
||||
OMX_U32 nSize;
|
||||
OMX_VERSIONTYPE nVersion;
|
||||
OMX_U32 nPortIndex;
|
||||
OMX_U32 nQFactor;
|
||||
} OMX_IMAGE_PARAM_QFACTORTYPE;
|
||||
|
||||
/**
|
||||
* Quantization table type
|
||||
/**
|
||||
* Quantization table type
|
||||
*/
|
||||
|
||||
typedef enum OMX_IMAGE_QUANTIZATIONTABLETYPE {
|
||||
|
|
@ -267,27 +267,27 @@ typedef enum OMX_IMAGE_QUANTIZATIONTABLETYPE {
|
|||
OMX_IMAGE_QuantizationTableChroma,
|
||||
OMX_IMAGE_QuantizationTableChromaCb,
|
||||
OMX_IMAGE_QuantizationTableChromaCr,
|
||||
OMX_IMAGE_QuantizationTableKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
||||
OMX_IMAGE_QuantizationTableKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
||||
OMX_IMAGE_QuantizationTableVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
|
||||
OMX_IMAGE_QuantizationTableMax = 0x7FFFFFFF
|
||||
} OMX_IMAGE_QUANTIZATIONTABLETYPE;
|
||||
|
||||
/**
|
||||
/**
|
||||
* JPEG quantization tables are used to determine DCT compression for
|
||||
* YUV data, as an alternative to specifying Q factor, providing exact
|
||||
* control of compression
|
||||
* YUV data, as an alternative to specifying Q factor, providing exact
|
||||
* control of compression
|
||||
*
|
||||
* STRUCT MEMBERS:
|
||||
* nSize : Size of the structure in bytes
|
||||
* nVersion : OMX specification version information
|
||||
* nVersion : OMX specification version information
|
||||
* nPortIndex : Port that this structure applies to
|
||||
* eQuantizationTable : Quantization table type
|
||||
* nQuantizationMatrix[64] : JPEG quantization table of coefficients stored
|
||||
* in increasing columns then by rows of data (i.e.
|
||||
* row 1, ... row 8). Quantization values are in
|
||||
* nQuantizationMatrix[64] : JPEG quantization table of coefficients stored
|
||||
* in increasing columns then by rows of data (i.e.
|
||||
* row 1, ... row 8). Quantization values are in
|
||||
* the range 0-255 and stored in linear order
|
||||
* (i.e. the component will zig-zag the
|
||||
* quantization table data if required internally)
|
||||
* (i.e. the component will zig-zag the
|
||||
* quantization table data if required internally)
|
||||
*/
|
||||
typedef struct OMX_IMAGE_PARAM_QUANTIZATIONTABLETYPE {
|
||||
OMX_U32 nSize;
|
||||
|
|
@ -298,9 +298,9 @@ typedef struct OMX_IMAGE_PARAM_QUANTIZATIONTABLETYPE {
|
|||
} OMX_IMAGE_PARAM_QUANTIZATIONTABLETYPE;
|
||||
|
||||
|
||||
/**
|
||||
* Huffman table type, the same Huffman table is applied for chroma and
|
||||
* luma component
|
||||
/**
|
||||
* Huffman table type, the same Huffman table is applied for chroma and
|
||||
* luma component
|
||||
*/
|
||||
typedef enum OMX_IMAGE_HUFFMANTABLETYPE {
|
||||
OMX_IMAGE_HuffmanTableAC = 0,
|
||||
|
|
@ -309,23 +309,23 @@ typedef enum OMX_IMAGE_HUFFMANTABLETYPE {
|
|||
OMX_IMAGE_HuffmanTableACChroma,
|
||||
OMX_IMAGE_HuffmanTableDCLuma,
|
||||
OMX_IMAGE_HuffmanTableDCChroma,
|
||||
OMX_IMAGE_HuffmanTableKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
||||
OMX_IMAGE_HuffmanTableKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
||||
OMX_IMAGE_HuffmanTableVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
|
||||
OMX_IMAGE_HuffmanTableMax = 0x7FFFFFFF
|
||||
} OMX_IMAGE_HUFFMANTABLETYPE;
|
||||
|
||||
/**
|
||||
* JPEG Huffman table
|
||||
/**
|
||||
* JPEG Huffman table
|
||||
*
|
||||
* STRUCT MEMBERS:
|
||||
* nSize : Size of the structure in bytes
|
||||
* nVersion : OMX specification version information
|
||||
* nPortIndex : Port that this structure applies to
|
||||
* eHuffmanTable : Huffman table type
|
||||
* nNumberOfHuffmanCodeOfLength[16] : 0-16, number of Huffman codes of each
|
||||
* nNumberOfHuffmanCodeOfLength[16] : 0-16, number of Huffman codes of each
|
||||
* possible length
|
||||
* nHuffmanTable[256] : 0-255, the size used for AC and DC
|
||||
* HuffmanTable are 16 and 162
|
||||
* nHuffmanTable[256] : 0-255, the size used for AC and DC
|
||||
* HuffmanTable are 16 and 162
|
||||
*/
|
||||
typedef struct OMX_IMAGE_PARAM_HUFFMANTTABLETYPE {
|
||||
OMX_U32 nSize;
|
||||
|
|
|
|||
|
|
@ -16,25 +16,25 @@
|
|||
* -------------------------------------------------------------------
|
||||
*/
|
||||
/*
|
||||
* Copyright (c) 2008 The Khronos Group Inc.
|
||||
*
|
||||
* 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:
|
||||
* to the following conditions:
|
||||
* The above copyright notice and this permission notice shall be included
|
||||
* in all copies or substantial portions of the Software.
|
||||
*
|
||||
* 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.
|
||||
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
*/
|
||||
|
||||
|
|
@ -51,25 +51,23 @@
|
|||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
|
||||
|
||||
/* Each OMX header must 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
|
||||
* for this header file to compile successfully
|
||||
*/
|
||||
#include <OMX_Types.h>
|
||||
|
||||
|
||||
/** The OMX_INDEXTYPE enumeration is used to select a structure when either
|
||||
* getting or setting parameters and/or configuration data. Each entry in
|
||||
* this enumeration maps to an OMX specified structure. When the
|
||||
* getting or setting parameters and/or configuration data. Each entry in
|
||||
* this enumeration maps to an OMX specified structure. When the
|
||||
* OMX_GetParameter, OMX_SetParameter, OMX_GetConfig or OMX_SetConfig methods
|
||||
* are used, the second parameter will always be an entry from this enumeration
|
||||
* and the third entry will be the structure shown in the comments for the entry.
|
||||
* For example, if the application is initializing a cropping function, the
|
||||
* OMX_SetConfig command would have OMX_IndexConfigCommonInputCrop as the second parameter
|
||||
* and would send a pointer to an initialized OMX_RECTTYPE structure as the
|
||||
* For example, if the application is initializing a cropping function, the
|
||||
* OMX_SetConfig command would have OMX_IndexConfigCommonInputCrop as the second parameter
|
||||
* and would send a pointer to an initialized OMX_RECTTYPE structure as the
|
||||
* third parameter.
|
||||
*
|
||||
*
|
||||
* The enumeration entries named with the OMX_Config prefix are sent using
|
||||
* the OMX_SetConfig command and the enumeration entries named with the
|
||||
* OMX_PARAM_ prefix are sent using the OMX_SetParameter command.
|
||||
|
|
@ -86,11 +84,11 @@ typedef enum OMX_INDEXTYPE {
|
|||
OMX_IndexParamActiveStream, /**< reference: OMX_PARAM_U32TYPE */
|
||||
OMX_IndexParamSuspensionPolicy, /**< reference: OMX_PARAM_SUSPENSIONPOLICYTYPE */
|
||||
OMX_IndexParamComponentSuspended, /**< reference: OMX_PARAM_SUSPENSIONTYPE */
|
||||
OMX_IndexConfigCapturing, /**< reference: OMX_CONFIG_BOOLEANTYPE */
|
||||
OMX_IndexConfigCaptureMode, /**< reference: OMX_CONFIG_CAPTUREMODETYPE */
|
||||
OMX_IndexAutoPauseAfterCapture, /**< reference: OMX_CONFIG_BOOLEANTYPE */
|
||||
OMX_IndexConfigCapturing, /**< reference: OMX_CONFIG_BOOLEANTYPE */
|
||||
OMX_IndexConfigCaptureMode, /**< reference: OMX_CONFIG_CAPTUREMODETYPE */
|
||||
OMX_IndexAutoPauseAfterCapture, /**< reference: OMX_CONFIG_BOOLEANTYPE */
|
||||
OMX_IndexParamContentURI, /**< reference: OMX_PARAM_CONTENTURITYPE */
|
||||
OMX_IndexParamCustomContentPipe, /**< reference: OMX_PARAM_CONTENTPIPETYPE */
|
||||
OMX_IndexParamCustomContentPipe, /**< reference: OMX_PARAM_CONTENTPIPETYPE */
|
||||
OMX_IndexParamDisableResourceConcealment, /**< reference: OMX_RESOURCECONCEALMENTTYPE */
|
||||
OMX_IndexConfigMetadataItemCount, /**< reference: OMX_CONFIG_METADATAITEMCOUNTTYPE */
|
||||
OMX_IndexConfigContainerNodeCount, /**< reference: OMX_CONFIG_CONTAINERNODECOUNTTYPE */
|
||||
|
|
@ -103,7 +101,7 @@ typedef enum OMX_INDEXTYPE {
|
|||
|
||||
OMX_IndexPortStartUnused = 0x02000000,
|
||||
OMX_IndexParamPortDefinition, /**< reference: OMX_PARAM_PORTDEFINITIONTYPE */
|
||||
OMX_IndexParamCompBufferSupplier, /**< reference: OMX_PARAM_BUFFERSUPPLIERTYPE */
|
||||
OMX_IndexParamCompBufferSupplier, /**< reference: OMX_PARAM_BUFFERSUPPLIERTYPE */
|
||||
OMX_IndexReservedStartUnused = 0x03000000,
|
||||
|
||||
/* Audio parameters and configurations */
|
||||
|
|
@ -256,10 +254,10 @@ typedef enum OMX_INDEXTYPE {
|
|||
OMX_IndexConfigTimeSeekMode, /**< reference: OMX_TIME_CONFIG_SEEKMODETYPE */
|
||||
|
||||
|
||||
OMX_IndexKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
||||
OMX_IndexKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
||||
/* Vendor specific area */
|
||||
OMX_IndexVendorStartUnused = 0x7F000000,
|
||||
/* Vendor specific structures should be in the range of 0x7F000000
|
||||
/* Vendor specific structures should be in the range of 0x7F000000
|
||||
to 0x7FFFFFFE. This range is not broken out by vendor, so
|
||||
private indexes are not guaranteed unique and therefore should
|
||||
only be sent to the appropriate component. */
|
||||
|
|
|
|||
|
|
@ -16,25 +16,25 @@
|
|||
* -------------------------------------------------------------------
|
||||
*/
|
||||
/*
|
||||
* Copyright (c) 2008 The Khronos Group Inc.
|
||||
*
|
||||
* 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:
|
||||
* to the following conditions:
|
||||
* The above copyright notice and this permission notice shall be included
|
||||
* in all copies or substantial portions of the Software.
|
||||
*
|
||||
* 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.
|
||||
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
*/
|
||||
|
||||
|
|
@ -53,46 +53,46 @@ extern "C" {
|
|||
|
||||
/* Each OMX header must 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
|
||||
* for this header file to compile successfully
|
||||
*/
|
||||
|
||||
#include <OMX_Core.h>
|
||||
|
||||
|
||||
/**
|
||||
/**
|
||||
* Enumeration of possible data types which match to multiple domains or no
|
||||
* domain at all. For types which are vendor specific, a value above
|
||||
* OMX_OTHER_VENDORTSTART should be used.
|
||||
*/
|
||||
typedef enum OMX_OTHER_FORMATTYPE {
|
||||
OMX_OTHER_FormatTime = 0, /**< Transmission of various timestamps, elapsed time,
|
||||
OMX_OTHER_FormatTime = 0, /**< Transmission of various timestamps, elapsed time,
|
||||
time deltas, etc */
|
||||
OMX_OTHER_FormatPower, /**< Perhaps used for enabling/disabling power
|
||||
OMX_OTHER_FormatPower, /**< Perhaps used for enabling/disabling power
|
||||
management, setting clocks? */
|
||||
OMX_OTHER_FormatStats, /**< Could be things such as frame rate, frames
|
||||
OMX_OTHER_FormatStats, /**< Could be things such as frame rate, frames
|
||||
dropped, etc */
|
||||
OMX_OTHER_FormatBinary, /**< Arbitrary binary data */
|
||||
OMX_OTHER_FormatVendorReserved = 1000, /**< Starting value for vendor specific
|
||||
OMX_OTHER_FormatVendorReserved = 1000, /**< Starting value for vendor specific
|
||||
formats */
|
||||
|
||||
OMX_OTHER_FormatKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
||||
OMX_OTHER_FormatKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
||||
OMX_OTHER_FormatVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
|
||||
OMX_OTHER_FormatMax = 0x7FFFFFFF
|
||||
} OMX_OTHER_FORMATTYPE;
|
||||
|
||||
/**
|
||||
/**
|
||||
* Enumeration of seek modes.
|
||||
*/
|
||||
typedef enum OMX_TIME_SEEKMODETYPE {
|
||||
OMX_TIME_SeekModeFast = 0, /**< Prefer seeking to an approximation
|
||||
* of the requested seek position over
|
||||
* of the requested seek position over
|
||||
* the actual seek position if it
|
||||
* results in a faster seek. */
|
||||
OMX_TIME_SeekModeAccurate, /**< Prefer seeking to the actual seek
|
||||
OMX_TIME_SeekModeAccurate, /**< Prefer seeking to the actual seek
|
||||
* position over an approximation
|
||||
* of the requested seek position even
|
||||
* if it results in a slower seek. */
|
||||
OMX_TIME_SeekModeKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
||||
OMX_TIME_SeekModeKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
||||
OMX_TIME_SeekModeVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
|
||||
OMX_TIME_SeekModeMax = 0x7FFFFFFF
|
||||
} OMX_TIME_SEEKMODETYPE;
|
||||
|
|
@ -104,42 +104,42 @@ typedef struct OMX_TIME_CONFIG_SEEKMODETYPE {
|
|||
OMX_TIME_SEEKMODETYPE eType; /**< The seek mode */
|
||||
} OMX_TIME_CONFIG_SEEKMODETYPE;
|
||||
|
||||
/** Structure representing a time stamp used with the following configs
|
||||
/** Structure representing a time stamp used with the following configs
|
||||
* on the Clock Component (CC):
|
||||
*
|
||||
* OMX_IndexConfigTimeCurrentWallTime: query of the CC’s current wall
|
||||
*
|
||||
* OMX_IndexConfigTimeCurrentWallTime: query of the CC's current wall
|
||||
* time
|
||||
* OMX_IndexConfigTimeCurrentMediaTime: query of the CC’s current media
|
||||
* OMX_IndexConfigTimeCurrentMediaTime: query of the CC's current media
|
||||
* time
|
||||
* OMX_IndexConfigTimeCurrentAudioReference and
|
||||
* OMX_IndexConfigTimeCurrentVideoReference: audio/video reference
|
||||
* OMX_IndexConfigTimeCurrentAudioReference and
|
||||
* OMX_IndexConfigTimeCurrentVideoReference: audio/video reference
|
||||
* clock sending SC its reference time
|
||||
* OMX_IndexConfigTimeClientStartTime: a Clock Component client sends
|
||||
* this structure to the Clock Component via a SetConfig on its
|
||||
* OMX_IndexConfigTimeClientStartTime: a Clock Component client sends
|
||||
* this structure to the Clock Component via a SetConfig on its
|
||||
* client port when it receives a buffer with
|
||||
* OMX_BUFFERFLAG_STARTTIME set. It must use the timestamp
|
||||
* specified by that buffer for nStartTimestamp.
|
||||
* specified by that buffer for nStartTimestamp.
|
||||
*
|
||||
* It’s also used with the following config on components in general:
|
||||
* It's also used with the following config on components in general:
|
||||
*
|
||||
* OMX_IndexConfigTimePosition: IL client querying component position
|
||||
* OMX_IndexConfigTimePosition: IL client querying component position
|
||||
* (GetConfig) or commanding a component to seek to the given location
|
||||
* (SetConfig)
|
||||
*/
|
||||
*/
|
||||
typedef struct OMX_TIME_CONFIG_TIMESTAMPTYPE {
|
||||
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_TICKS nTimestamp; /**< timestamp .*/
|
||||
} OMX_TIME_CONFIG_TIMESTAMPTYPE;
|
||||
OMX_U32 nPortIndex; /**< port that this structure applies to */
|
||||
OMX_TICKS nTimestamp; /**< timestamp .*/
|
||||
} OMX_TIME_CONFIG_TIMESTAMPTYPE;
|
||||
|
||||
/** Enumeration of possible reference clocks to the media time. */
|
||||
typedef enum OMX_TIME_UPDATETYPE {
|
||||
OMX_TIME_UpdateRequestFulfillment, /**< Update is the fulfillment of a media time request. */
|
||||
OMX_TIME_UpdateScaleChanged, /**< Update was generated because the scale chagned. */
|
||||
OMX_TIME_UpdateScaleChanged, /**< Update was generated because the scale chagned. */
|
||||
OMX_TIME_UpdateClockStateChanged, /**< Update was generated because the clock state changed. */
|
||||
OMX_TIME_UpdateKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
||||
OMX_TIME_UpdateKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
||||
OMX_TIME_UpdateVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
|
||||
OMX_TIME_UpdateMax = 0x7FFFFFFF
|
||||
} OMX_TIME_UPDATETYPE;
|
||||
|
|
@ -147,9 +147,9 @@ typedef enum OMX_TIME_UPDATETYPE {
|
|||
/** Enumeration of possible reference clocks to the media time. */
|
||||
typedef enum OMX_TIME_REFCLOCKTYPE {
|
||||
OMX_TIME_RefClockNone, /**< Use no references. */
|
||||
OMX_TIME_RefClockAudio, /**< Use references sent through OMX_IndexConfigTimeCurrentAudioReference */
|
||||
OMX_TIME_RefClockAudio, /**< Use references sent through OMX_IndexConfigTimeCurrentAudioReference */
|
||||
OMX_TIME_RefClockVideo, /**< Use references sent through OMX_IndexConfigTimeCurrentVideoReference */
|
||||
OMX_TIME_RefClockKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
||||
OMX_TIME_RefClockKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
||||
OMX_TIME_RefClockVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
|
||||
OMX_TIME_RefClockMax = 0x7FFFFFFF
|
||||
} OMX_TIME_REFCLOCKTYPE;
|
||||
|
|
@ -157,11 +157,11 @@ typedef enum OMX_TIME_REFCLOCKTYPE {
|
|||
/** Enumeration of clock states. */
|
||||
typedef enum OMX_TIME_CLOCKSTATE {
|
||||
OMX_TIME_ClockStateRunning, /**< Clock running. */
|
||||
OMX_TIME_ClockStateWaitingForStartTime, /**< Clock waiting until the
|
||||
OMX_TIME_ClockStateWaitingForStartTime, /**< Clock waiting until the
|
||||
* prescribed clients emit their
|
||||
* start time. */
|
||||
OMX_TIME_ClockStateStopped, /**< Clock stopped. */
|
||||
OMX_TIME_ClockStateKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
||||
OMX_TIME_ClockStateKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
|
||||
OMX_TIME_ClockStateVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
|
||||
OMX_TIME_ClockStateMax = 0x7FFFFFFF
|
||||
} OMX_TIME_CLOCKSTATE;
|
||||
|
|
@ -171,18 +171,18 @@ typedef enum OMX_TIME_CLOCKSTATE {
|
|||
* A client component sends this structure to the Clock Component via a SetConfig
|
||||
* on its client port to specify a media timestamp the Clock Component
|
||||
* should emit. The Clock Component should fulfill the request by sending a
|
||||
* OMX_TIME_MEDIATIMETYPE when its media clock matches the requested
|
||||
* OMX_TIME_MEDIATIMETYPE when its media clock matches the requested
|
||||
* timestamp.
|
||||
*
|
||||
* The client may require a media time request be fulfilled slightly
|
||||
* earlier than the media time specified. In this case the client specifies
|
||||
* an offset which is equal to the difference between wall time corresponding
|
||||
* to the requested media time and the wall time when it will be
|
||||
* fulfilled.
|
||||
* earlier than the media time specified. In this case the client specifies
|
||||
* an offset which is equal to the difference between wall time corresponding
|
||||
* to the requested media time and the wall time when it will be
|
||||
* fulfilled.
|
||||
*
|
||||
* A client component may uses these requests and the OMX_TIME_MEDIATIMETYPE to
|
||||
* time events according to timestamps. If a client must perform an operation O at
|
||||
* a time T (e.g. deliver a video frame at its corresponding timestamp), it makes a
|
||||
* a time T (e.g. deliver a video frame at its corresponding timestamp), it makes a
|
||||
* media time request at T (perhaps specifying an offset to ensure the request fulfillment
|
||||
* is a little early). When the clock component passes the resulting OMX_TIME_MEDIATIMETYPE
|
||||
* structure back to the client component, the client may perform operation O (perhaps having
|
||||
|
|
@ -193,52 +193,52 @@ typedef struct OMX_TIME_CONFIG_MEDIATIMEREQUESTTYPE {
|
|||
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_PTR pClientPrivate; /**< Client private data to disabiguate this media time
|
||||
* from others (e.g. the number of the frame to deliver).
|
||||
* Duplicated in the media time structure that fulfills
|
||||
* this request. A value of zero is reserved for time scale
|
||||
OMX_PTR pClientPrivate; /**< Client private data to disabiguate this media time
|
||||
* from others (e.g. the number of the frame to deliver).
|
||||
* Duplicated in the media time structure that fulfills
|
||||
* this request. A value of zero is reserved for time scale
|
||||
* updates. */
|
||||
OMX_TICKS nMediaTimestamp; /**< Media timestamp requested.*/
|
||||
OMX_TICKS nMediaTimestamp; /**< Media timestamp requested.*/
|
||||
OMX_TICKS nOffset; /**< Amount of wall clock time by which this
|
||||
* request should be fulfilled early */
|
||||
} OMX_TIME_CONFIG_MEDIATIMEREQUESTTYPE;
|
||||
|
||||
/**< Structure sent from the clock component client either when fulfilling
|
||||
* a media time request or when the time scale has changed.
|
||||
/**< Structure sent from the clock component client either when fulfilling
|
||||
* a media time request or when the time scale has changed.
|
||||
*
|
||||
* In the former case the Clock Component fills this structure and times its emission
|
||||
* to a client component (via the client port) according to the corresponding media
|
||||
* In the former case the Clock Component fills this structure and times its emission
|
||||
* to a client component (via the client port) according to the corresponding media
|
||||
* time request sent by the client. The Clock Component should time the emission to occur
|
||||
* when the requested timestamp matches the Clock Component's media time but also the
|
||||
* prescribed offset early.
|
||||
* when the requested timestamp matches the Clock Component's media time but also the
|
||||
* prescribed offset early.
|
||||
*
|
||||
* Upon scale changes the clock component clears the nClientPrivate data, sends the current
|
||||
* media time and sets the nScale to the new scale via the client port. It emits a
|
||||
* OMX_TIME_MEDIATIMETYPE to all clients independent of any requests. This allows clients to
|
||||
* alter processing to accomodate scaling. For instance a video component might skip inter-frames
|
||||
* in the case of extreme fastforward. Likewise an audio component might add or remove samples
|
||||
* from an audio frame to scale audio data.
|
||||
* media time and sets the nScale to the new scale via the client port. It emits a
|
||||
* OMX_TIME_MEDIATIMETYPE to all clients independent of any requests. This allows clients to
|
||||
* alter processing to accomodate scaling. For instance a video component might skip inter-frames
|
||||
* in the case of extreme fastforward. Likewise an audio component might add or remove samples
|
||||
* from an audio frame to scale audio data.
|
||||
*
|
||||
* It is expected that some clock components may not be able to fulfill requests
|
||||
* at exactly the prescribed time. This is acceptable so long as the request is
|
||||
* fulfilled at least as early as described and not later. This structure provides
|
||||
* at exactly the prescribed time. This is acceptable so long as the request is
|
||||
* fulfilled at least as early as described and not later. This structure provides
|
||||
* fields the client may use to wait for the remaining time.
|
||||
*
|
||||
* The client may use either the nOffset or nWallTimeAtMedia fields to determine the
|
||||
* The client may use either the nOffset or nWallTimeAtMedia fields to determine the
|
||||
* wall time until the nMediaTimestamp actually occurs. In the latter case the
|
||||
* client can get a more accurate value for offset by getting the current wall
|
||||
* from the cloc component and subtracting it from nWallTimeAtMedia.
|
||||
* from the cloc component and subtracting it from nWallTimeAtMedia.
|
||||
*/
|
||||
|
||||
typedef struct OMX_TIME_MEDIATIMETYPE {
|
||||
OMX_U32 nSize; /**< size of the structure in bytes */
|
||||
OMX_VERSIONTYPE nVersion; /**< OMX specification version information */
|
||||
OMX_U32 nClientPrivate; /**< Client private data to disabiguate this media time
|
||||
* from others. Copied from the media time request.
|
||||
OMX_U32 nClientPrivate; /**< Client private data to disabiguate this media time
|
||||
* from others. Copied from the media time request.
|
||||
* A value of zero is reserved for time scale updates. */
|
||||
OMX_TIME_UPDATETYPE eUpdateType; /**< Reason for the update */
|
||||
OMX_TICKS nMediaTimestamp; /**< Media time requested. If no media time was
|
||||
* requested then this is the current media time. */
|
||||
OMX_TICKS nMediaTimestamp; /**< Media time requested. If no media time was
|
||||
* requested then this is the current media time. */
|
||||
OMX_TICKS nOffset; /**< Amount of wall clock time by which this
|
||||
* request was actually fulfilled early */
|
||||
|
||||
|
|
@ -250,21 +250,21 @@ typedef struct OMX_TIME_MEDIATIMETYPE {
|
|||
OMX_S32 xScale; /**< Current media time scale in Q16 format. */
|
||||
OMX_TIME_CLOCKSTATE eState; /* Seeking Change. Added 7/12.*/
|
||||
/**< State of the media time. */
|
||||
} OMX_TIME_MEDIATIMETYPE;
|
||||
} OMX_TIME_MEDIATIMETYPE;
|
||||
|
||||
/** Structure representing the current media time scale factor. Applicable only to clock
|
||||
/** Structure representing the current media time scale factor. Applicable only to clock
|
||||
* component, other components see scale changes via OMX_TIME_MEDIATIMETYPE buffers sent via
|
||||
* the clock component client ports. Upon recieving this config the clock component changes
|
||||
* the rate by which the media time increases or decreases effectively implementing trick modes.
|
||||
*/
|
||||
* the clock component client ports. Upon recieving this config the clock component changes
|
||||
* the rate by which the media time increases or decreases effectively implementing trick modes.
|
||||
*/
|
||||
typedef struct OMX_TIME_CONFIG_SCALETYPE {
|
||||
OMX_U32 nSize; /**< size of the structure in bytes */
|
||||
OMX_VERSIONTYPE nVersion; /**< OMX specification version information */
|
||||
OMX_S32 xScale; /**< This is a value in Q16 format which is used for
|
||||
* scaling the media time */
|
||||
} OMX_TIME_CONFIG_SCALETYPE;
|
||||
|
||||
/** Bits used to identify a clock port. Used in OMX_TIME_CONFIG_CLOCKSTATETYPE’s nWaitMask field */
|
||||
|
||||
/** Bits used to identify a clock port. Used in OMX_TIME_CONFIG_CLOCKSTATETYPE's nWaitMask field */
|
||||
#define OMX_CLOCKPORT0 0x00000001
|
||||
#define OMX_CLOCKPORT1 0x00000002
|
||||
#define OMX_CLOCKPORT2 0x00000004
|
||||
|
|
@ -274,38 +274,38 @@ typedef struct OMX_TIME_CONFIG_SCALETYPE {
|
|||
#define OMX_CLOCKPORT6 0x00000040
|
||||
#define OMX_CLOCKPORT7 0x00000080
|
||||
|
||||
/** Structure representing the current mode of the media clock.
|
||||
* IL Client uses this config to change or query the mode of the
|
||||
/** Structure representing the current mode of the media clock.
|
||||
* IL Client uses this config to change or query the mode of the
|
||||
* media clock of the clock component. Applicable only to clock
|
||||
* component.
|
||||
*
|
||||
* component.
|
||||
*
|
||||
* On a SetConfig if eState is OMX_TIME_ClockStateRunning media time
|
||||
* starts immediately at the prescribed start time. If
|
||||
* OMX_TIME_ClockStateWaitingForStartTime the Clock Component ignores
|
||||
* the given nStartTime and waits for all clients specified in the
|
||||
* nWaitMask to send starttimes (via
|
||||
* OMX_IndexConfigTimeClientStartTime). The Clock Component then starts
|
||||
* the media clock using the earliest start time supplied. */
|
||||
* the given nStartTime and waits for all clients specified in the
|
||||
* nWaitMask to send starttimes (via
|
||||
* OMX_IndexConfigTimeClientStartTime). The Clock Component then starts
|
||||
* the media clock using the earliest start time supplied. */
|
||||
typedef struct OMX_TIME_CONFIG_CLOCKSTATETYPE {
|
||||
OMX_U32 nSize; /**< size of the structure in bytes */
|
||||
OMX_VERSIONTYPE nVersion; /**< OMX specification version
|
||||
OMX_VERSIONTYPE nVersion; /**< OMX specification version
|
||||
* information */
|
||||
OMX_TIME_CLOCKSTATE eState; /**< State of the media time. */
|
||||
OMX_TICKS nStartTime; /**< Start time of the media time. */
|
||||
OMX_TICKS nOffset; /**< Time to offset the media time by
|
||||
OMX_TICKS nOffset; /**< Time to offset the media time by
|
||||
* (e.g. preroll). Media time will be
|
||||
* reported to be nOffset ticks earlier.
|
||||
* reported to be nOffset ticks earlier.
|
||||
*/
|
||||
OMX_U32 nWaitMask; /**< Mask of OMX_CLOCKPORT values. */
|
||||
} OMX_TIME_CONFIG_CLOCKSTATETYPE;
|
||||
|
||||
/** Structure representing the reference clock currently being used to
|
||||
* compute media time. IL client uses this config to change or query the
|
||||
* compute media time. IL client uses this config to change or query the
|
||||
* clock component's active reference clock */
|
||||
typedef struct OMX_TIME_CONFIG_ACTIVEREFCLOCKTYPE {
|
||||
OMX_U32 nSize; /**< size of the structure in bytes */
|
||||
OMX_VERSIONTYPE nVersion; /**< OMX specification version information */
|
||||
OMX_TIME_REFCLOCKTYPE eClock; /**< Reference clock used to compute media time */
|
||||
OMX_TIME_REFCLOCKTYPE eClock; /**< Reference clock used to compute media time */
|
||||
} OMX_TIME_CONFIG_ACTIVEREFCLOCKTYPE;
|
||||
|
||||
/** Descriptor for setting specifics of power type.
|
||||
|
|
@ -327,8 +327,8 @@ typedef struct OMX_OTHER_CONFIG_STATSTYPE {
|
|||
|
||||
|
||||
/**
|
||||
* The PortDefinition structure is used to define all of the parameters
|
||||
* necessary for the compliant component to setup an input or an output other
|
||||
* The PortDefinition structure is used to define all of the parameters
|
||||
* necessary for the compliant component to setup an input or an output other
|
||||
* path.
|
||||
*/
|
||||
typedef struct OMX_OTHER_PORTDEFINITIONTYPE {
|
||||
|
|
@ -344,7 +344,7 @@ typedef struct OMX_OTHER_PARAM_PORTFORMATTYPE {
|
|||
OMX_U32 nPortIndex; /**< Indicates which port to set */
|
||||
OMX_U32 nIndex; /**< Indicates the enumeration index for the format from 0x0 to N-1 */
|
||||
OMX_OTHER_FORMATTYPE eFormat; /**< Type of data expected for this channel */
|
||||
} OMX_OTHER_PARAM_PORTFORMATTYPE;
|
||||
} OMX_OTHER_PARAM_PORTFORMATTYPE;
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
|
|
|||
|
|
@ -16,32 +16,32 @@
|
|||
* -------------------------------------------------------------------
|
||||
*/
|
||||
/*
|
||||
* Copyright (c) 2008 The Khronos Group Inc.
|
||||
*
|
||||
* 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:
|
||||
* to the following conditions:
|
||||
* The above copyright notice and this permission notice shall be included
|
||||
* in all copies or substantial portions of the Software.
|
||||
*
|
||||
* 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.
|
||||
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
*/
|
||||
|
||||
/** OMX_Types.h - OpenMax IL version 1.1.2
|
||||
* The OMX_Types header file contains the primitive type definitions used by
|
||||
* The OMX_Types header file contains the primitive type definitions used by
|
||||
* the core, the application and the component. This file may need to be
|
||||
* modified to be used on systems that do not have "char" set to 8 bits,
|
||||
* modified to be used on systems that do not have "char" set to 8 bits,
|
||||
* "short" set to 16 bits and "long" set to 32 bits.
|
||||
*/
|
||||
|
||||
|
|
@ -57,12 +57,12 @@ extern "C" {
|
|||
/** The OMX_API and OMX_APIENTRY are platform specific definitions used
|
||||
* to declare OMX function prototypes. They are modified to meet the
|
||||
* requirements for a particular platform */
|
||||
#ifdef __SYMBIAN32__
|
||||
#ifdef __SYMBIAN32__
|
||||
# ifdef __OMX_EXPORTS
|
||||
# define OMX_API __declspec(dllexport)
|
||||
# else
|
||||
# ifdef _WIN32
|
||||
# define OMX_API __declspec(dllexport)
|
||||
# define OMX_API __declspec(dllexport)
|
||||
# else
|
||||
# define OMX_API __declspec(dllimport)
|
||||
# endif
|
||||
|
|
@ -85,18 +85,18 @@ extern "C" {
|
|||
#endif
|
||||
|
||||
#ifndef OMX_APIENTRY
|
||||
#define OMX_APIENTRY
|
||||
#endif
|
||||
#define OMX_APIENTRY
|
||||
#endif
|
||||
|
||||
/** OMX_IN is used to identify inputs to an OMX function. This designation
|
||||
will also be used in the case of a pointer that points to a parameter
|
||||
/** OMX_IN is used to identify inputs to an OMX function. This designation
|
||||
will also be used in the case of a pointer that points to a parameter
|
||||
that is used as an output. */
|
||||
#ifndef OMX_IN
|
||||
#define OMX_IN
|
||||
#endif
|
||||
|
||||
/** OMX_OUT is used to identify outputs from an OMX function. This
|
||||
designation will also be used in the case of a pointer that points
|
||||
/** OMX_OUT is used to identify outputs from an OMX function. This
|
||||
designation will also be used in the case of a pointer that points
|
||||
to a parameter that is used as an input. */
|
||||
#ifndef OMX_OUT
|
||||
#define OMX_OUT
|
||||
|
|
@ -104,8 +104,8 @@ extern "C" {
|
|||
|
||||
|
||||
/** OMX_INOUT is used to identify parameters that may be either inputs or
|
||||
outputs from an OMX function at the same time. This designation will
|
||||
also be used in the case of a pointer that points to a parameter that
|
||||
outputs from an OMX function at the same time. This designation will
|
||||
also be used in the case of a pointer that points to a parameter that
|
||||
is used both as an input and an output. */
|
||||
#ifndef OMX_INOUT
|
||||
#define OMX_INOUT
|
||||
|
|
@ -123,31 +123,31 @@ extern "C" {
|
|||
/** @defgroup core OpenMAX IL core
|
||||
* Functions and structure related to the OMX IL core
|
||||
*/
|
||||
|
||||
|
||||
/** @defgroup comp OpenMAX IL component
|
||||
* Functions and structure related to the OMX IL component
|
||||
*/
|
||||
|
||||
/** @defgroup rpm Resource and Policy Management
|
||||
|
||||
/** @defgroup rpm Resource and Policy Management
|
||||
* Structures for resource and policy management of components
|
||||
*/
|
||||
|
||||
/** @defgroup buf Buffer Management
|
||||
* Buffer handling functions and structures
|
||||
*/
|
||||
|
||||
|
||||
/** @defgroup tun Tunneling
|
||||
* @ingroup core comp
|
||||
* Structures and functions to manage tunnels among component ports
|
||||
*/
|
||||
|
||||
|
||||
/** @defgroup cp Content Pipes
|
||||
* @ingroup core
|
||||
*/
|
||||
|
||||
|
||||
/** @defgroup metadata Metadata handling
|
||||
*
|
||||
*/
|
||||
*
|
||||
*/
|
||||
|
||||
/** OMX_U8 is an 8 bit unsigned quantity that is byte aligned */
|
||||
typedef unsigned char OMX_U8;
|
||||
|
|
@ -169,7 +169,7 @@ typedef int32_t OMX_S32;
|
|||
|
||||
|
||||
/* Users with compilers that cannot accept the "long long" designation should
|
||||
define the OMX_SKIP64BIT macro. It should be noted that this may cause
|
||||
define the OMX_SKIP64BIT macro. It should be noted that this may cause
|
||||
some components to fail to compile if the component was written to require
|
||||
64 bit integral types. However, these components would NOT compile anyway
|
||||
since the compiler does not support the way the component was written.
|
||||
|
|
@ -184,7 +184,7 @@ typedef signed long long OMX_S64;
|
|||
|
||||
#elif defined(WIN32)
|
||||
|
||||
/** OMX_U64 is a 64 bit unsigned quantity that is 64 bit word aligned */
|
||||
/** OMX_U64 is a 64 bit unsigned quantity that is 64 bit word aligned */
|
||||
typedef unsigned __int64 OMX_U64;
|
||||
|
||||
/** OMX_S64 is a 64 bit signed quantity that is 64 bit word aligned */
|
||||
|
|
@ -202,7 +202,7 @@ typedef signed long long OMX_S64;
|
|||
#endif
|
||||
|
||||
|
||||
/** The OMX_BOOL type is intended to be used to represent a true or a false
|
||||
/** The OMX_BOOL type is intended to be used to represent a true or a false
|
||||
value when passing parameters to and from the OMX core and components. The
|
||||
OMX_BOOL is a 32 bit quantity and is aligned on a 32 bit word boundary.
|
||||
*/
|
||||
|
|
@ -210,7 +210,7 @@ typedef enum OMX_BOOL {
|
|||
OMX_FALSE = 0,
|
||||
OMX_TRUE = !OMX_FALSE,
|
||||
OMX_BOOL_MAX = 0x7FFFFFFF
|
||||
} OMX_BOOL;
|
||||
} OMX_BOOL;
|
||||
|
||||
/*
|
||||
* Temporary Android 64 bit modification
|
||||
|
|
@ -237,14 +237,14 @@ typedef OMX_PTR OMX_BYTE;
|
|||
typedef void* OMX_PTR;
|
||||
|
||||
/** The OMX_STRING type is intended to be used to pass "C" type strings between
|
||||
the application and the core and component. The OMX_STRING type is a 32
|
||||
bit pointer to a zero terminated string. The pointer is word aligned and
|
||||
the string is byte aligned.
|
||||
the application and the core and component. The OMX_STRING type is a 32
|
||||
bit pointer to a zero terminated string. The pointer is word aligned and
|
||||
the string is byte aligned.
|
||||
*/
|
||||
typedef char* OMX_STRING;
|
||||
|
||||
/** The OMX_BYTE type is intended to be used to pass arrays of bytes such as
|
||||
buffers between the application and the component and core. The OMX_BYTE
|
||||
buffers between the application and the component and core. The OMX_BYTE
|
||||
type is a 32 bit pointer to a zero terminated string. The pointer is word
|
||||
aligned and the string is byte aligned.
|
||||
*/
|
||||
|
|
@ -259,7 +259,7 @@ typedef unsigned char* OMX_BYTE;
|
|||
typedef unsigned char OMX_UUIDTYPE[128];
|
||||
|
||||
/** The OMX_DIRTYPE enumeration is used to indicate if a port is an input or
|
||||
an output port. This enumeration is common across all component types.
|
||||
an output port. This enumeration is common across all component types.
|
||||
*/
|
||||
typedef enum OMX_DIRTYPE
|
||||
{
|
||||
|
|
@ -268,8 +268,8 @@ typedef enum OMX_DIRTYPE
|
|||
OMX_DirMax = 0x7FFFFFFF
|
||||
} OMX_DIRTYPE;
|
||||
|
||||
/** The OMX_ENDIANTYPE enumeration is used to indicate the bit ordering
|
||||
for numerical data (i.e. big endian, or little endian).
|
||||
/** The OMX_ENDIANTYPE enumeration is used to indicate the bit ordering
|
||||
for numerical data (i.e. big endian, or little endian).
|
||||
*/
|
||||
typedef enum OMX_ENDIANTYPE
|
||||
{
|
||||
|
|
@ -279,7 +279,7 @@ typedef enum OMX_ENDIANTYPE
|
|||
} OMX_ENDIANTYPE;
|
||||
|
||||
|
||||
/** The OMX_NUMERICALDATATYPE enumeration is used to indicate if data
|
||||
/** The OMX_NUMERICALDATATYPE enumeration is used to indicate if data
|
||||
is signed or unsigned
|
||||
*/
|
||||
typedef enum OMX_NUMERICALDATATYPE
|
||||
|
|
@ -307,16 +307,16 @@ typedef struct OMX_BS32 {
|
|||
|
||||
|
||||
/** Structure representing some time or duration in microseconds. This structure
|
||||
* must be interpreted as a signed 64 bit value. The quantity is signed to accommodate
|
||||
* negative deltas and preroll scenarios. The quantity is represented in microseconds
|
||||
* must be interpreted as a signed 64 bit value. The quantity is signed to accommodate
|
||||
* negative deltas and preroll scenarios. The quantity is represented in microseconds
|
||||
* to accomodate high resolution timestamps (e.g. DVD presentation timestamps based
|
||||
* on a 90kHz clock) and to allow more accurate and synchronized delivery (e.g.
|
||||
* individual audio samples delivered at 192 kHz). The quantity is 64 bit to
|
||||
* on a 90kHz clock) and to allow more accurate and synchronized delivery (e.g.
|
||||
* individual audio samples delivered at 192 kHz). The quantity is 64 bit to
|
||||
* accommodate a large dynamic range (signed 32 bit values would allow only for plus
|
||||
* or minus 35 minutes).
|
||||
*
|
||||
* Implementations with limited precision may convert the signed 64 bit value to
|
||||
* a signed 32 bit value internally but risk loss of precision.
|
||||
* Implementations with limited precision may convert the signed 64 bit value to
|
||||
* a signed 32 bit value internally but risk loss of precision.
|
||||
*/
|
||||
#ifndef OMX_SKIP64BIT
|
||||
typedef OMX_S64 OMX_TICKS;
|
||||
|
|
@ -336,17 +336,17 @@ typedef OMX_PTR OMX_HANDLETYPE;
|
|||
|
||||
typedef struct OMX_MARKTYPE
|
||||
{
|
||||
OMX_HANDLETYPE hMarkTargetComponent; /**< The component that will
|
||||
generate a mark event upon
|
||||
OMX_HANDLETYPE hMarkTargetComponent; /**< The component that will
|
||||
generate a mark event upon
|
||||
processing the mark. */
|
||||
OMX_PTR pMarkData; /**< Application specific data associated with
|
||||
the mark sent on a mark event to disambiguate
|
||||
OMX_PTR pMarkData; /**< Application specific data associated with
|
||||
the mark sent on a mark event to disambiguate
|
||||
this mark from others. */
|
||||
} OMX_MARKTYPE;
|
||||
|
||||
|
||||
/** OMX_NATIVE_DEVICETYPE is used to map a OMX video port to the
|
||||
* platform & operating specific object used to reference the display
|
||||
* platform & operating specific object used to reference the display
|
||||
* or can be used by a audio port for native audio rendering */
|
||||
typedef OMX_PTR OMX_NATIVE_DEVICETYPE;
|
||||
|
||||
|
|
@ -357,7 +357,7 @@ typedef OMX_PTR OMX_NATIVE_WINDOWTYPE;
|
|||
/** The OMX_VERSIONTYPE union is used to specify the version for
|
||||
a structure or component. For a component, the version is entirely
|
||||
specified by the component vendor. Components doing the same function
|
||||
from different vendors may or may not have the same version. For
|
||||
from different vendors may or may not have the same version. For
|
||||
structures, the version shall be set by the entity that allocates the
|
||||
structure. For structures specified in the OMX 1.1 specification, the
|
||||
value of the version shall be set to 1.1.0.0 in all cases. Access to the
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue