Browse Source

visionfive2: ffmpeg: Add ffmpeg recipe
This is the original ffmpeg recipe from openembeded-core with libsdl2 & omx added.
OMX folder is added via a patch together with other Debian patches.

Signed-off-by: weiheng.cheng <weiheng.cheng@starfivetech.com>

weiheng.cheng 11 months ago
parent
commit
ae2bfebccc
29 changed files with 12300 additions and 0 deletions
  1. 1 0
      conf/layer.conf
  2. 7770 0
      recipes-multimedia/ffmpeg/ffmpeg/0001-Add-sf-extra-folder.patch
  3. 34 0
      recipes-multimedia/ffmpeg/ffmpeg/0001-hwcontext_vulkan-remove-optional-encode-decode-exten.patch
  4. 43 0
      recipes-multimedia/ffmpeg/ffmpeg/0001-swscale-x86-yuv2rgb-Fix-build-without-SSSE3.patch
  5. 36 0
      recipes-multimedia/ffmpeg/ffmpeg/0002-avcodec-vaapi_h264-skip-decode-if-pic-has-no-slices.patch
  6. 72 0
      recipes-multimedia/ffmpeg/ffmpeg/0003-libavutil-Fix-mips-build.patch
  7. 47 0
      recipes-multimedia/ffmpeg/ffmpeg/0004-configure-add-extralibs-to-extralibs_xxx.patch
  8. 940 0
      recipes-multimedia/ffmpeg/ffmpeg/0005-avcodec-add-omx-decoder-support.patch
  9. 199 0
      recipes-multimedia/ffmpeg/ffmpeg/0006-add-hevc-decoder-and-encoder-support.patch
  10. 307 0
      recipes-multimedia/ffmpeg/ffmpeg/0007-avcoder-fix-decoder-bug.patch
  11. 83 0
      recipes-multimedia/ffmpeg/ffmpeg/0008-fix-omx-decoder-setting-pix-fmt-bug.patch
  12. 209 0
      recipes-multimedia/ffmpeg/ffmpeg/0009-ffmpeg-add-mjpeg-decoder-support-and-fix-some-bug.patch
  13. 48 0
      recipes-multimedia/ffmpeg/ffmpeg/0010-ffmpeg-support-to-change-gop.patch
  14. 59 0
      recipes-multimedia/ffmpeg/ffmpeg/0011-ffmpeg-add-delay-for-decoding.patch
  15. 120 0
      recipes-multimedia/ffmpeg/ffmpeg/0012-ffmpeg-add-omx_pix_fmt.patch
  16. 433 0
      recipes-multimedia/ffmpeg/ffmpeg/0013-ffmpeg-replace-the-indent-with-space.patch
  17. 159 0
      recipes-multimedia/ffmpeg/ffmpeg/0014-ffmpeg-add-pixel-foramt.patch
  18. 52 0
      recipes-multimedia/ffmpeg/ffmpeg/0015-ffmpeg-remove-delay.patch
  19. 209 0
      recipes-multimedia/ffmpeg/ffmpeg/0016-FFmpeg-omx-add-scale-option-for-omx.patch
  20. 265 0
      recipes-multimedia/ffmpeg/ffmpeg/0017-FFmpeg-omxdec-add-mirror-rotation-and-crop-option.patch
  21. 35 0
      recipes-multimedia/ffmpeg/ffmpeg/0018-FFmpeg-omx-gop-parameter-of-hevc-encoder.patch
  22. 34 0
      recipes-multimedia/ffmpeg/ffmpeg/0019-FFmpeg-omcdec-fix-mjpeg_omx-decoder-scale-option-bug.patch
  23. 63 0
      recipes-multimedia/ffmpeg/ffmpeg/0020-FFmpeg-omxdec-modify-the-range-of-width-and-height-o.patch
  24. 238 0
      recipes-multimedia/ffmpeg/ffmpeg/0021-FFmpeg-omxdec-set-pts-of-avframe-and-fix-some-compil.patch
  25. 142 0
      recipes-multimedia/ffmpeg/ffmpeg/0022-FFmpeg-enable-internal-optimize.patch
  26. 191 0
      recipes-multimedia/ffmpeg/ffmpeg/0023-FFmpeg_upstream_AVCodec_struct_to_FFCodec.patch
  27. 257 0
      recipes-multimedia/ffmpeg/ffmpeg/0024-FFmpeg-optimize-copy-for-omxdec.patch
  28. 42 0
      recipes-multimedia/ffmpeg/ffmpeg/0025-FFmpeg-fix-pts-incorrect.patch
  29. 212 0
      recipes-multimedia/ffmpeg/ffmpeg_5.1.2.bb

+ 1 - 0
conf/layer.conf

@@ -17,3 +17,4 @@ LAYERVERSION_meta-starfive = "1"
 LAYERSERIES_COMPAT_meta-starfive = "kirkstone"
 
 PACKAGE_CLASSES = "package_ipk"
+LICENSE_FLAGS_ACCEPTED += "commercial_ffmpeg"

+ 7770 - 0
recipes-multimedia/ffmpeg/ffmpeg/0001-Add-sf-extra-folder.patch

@@ -0,0 +1,7770 @@
+From 7b27b6134f9a2ca4730a6081af8b5331c7a64f63 Mon Sep 17 00:00:00 2001
+From: Clement <clement@starfivetech.com>
+Date: Thu, 8 Jun 2023 01:33:10 -0400
+Subject: [PATCH 1/1] Add sf-extra folder
+
+Signed-off-by: Clement <clement@starfivetech.com>
+---
+ sf-extra/omx-il/OMX_Audio.h        | 1310 +++++++++++++++++++++++++
+ sf-extra/omx-il/OMX_Component.h    |  569 +++++++++++
+ sf-extra/omx-il/OMX_ComponentExt.h |   61 ++
+ sf-extra/omx-il/OMX_ContentPipe.h  |  193 ++++
+ sf-extra/omx-il/OMX_Core.h         | 1422 ++++++++++++++++++++++++++++
+ sf-extra/omx-il/OMX_CoreExt.h      |   73 ++
+ sf-extra/omx-il/OMX_IVCommon.h     |  993 +++++++++++++++++++
+ sf-extra/omx-il/OMX_Image.h        |  328 +++++++
+ sf-extra/omx-il/OMX_ImageExt.h     |   55 ++
+ sf-extra/omx-il/OMX_Index.h        |  260 +++++
+ sf-extra/omx-il/OMX_IndexExt.h     |  105 ++
+ sf-extra/omx-il/OMX_Other.h        |  366 +++++++
+ sf-extra/omx-il/OMX_Types.h        |  361 +++++++
+ sf-extra/omx-il/OMX_Video.h        | 1141 ++++++++++++++++++++++
+ sf-extra/omx-il/OMX_VideoExt.h     |  401 ++++++++
+ 15 files changed, 7638 insertions(+)
+ create mode 100644 sf-extra/omx-il/OMX_Audio.h
+ create mode 100644 sf-extra/omx-il/OMX_Component.h
+ create mode 100644 sf-extra/omx-il/OMX_ComponentExt.h
+ create mode 100644 sf-extra/omx-il/OMX_ContentPipe.h
+ create mode 100644 sf-extra/omx-il/OMX_Core.h
+ create mode 100644 sf-extra/omx-il/OMX_CoreExt.h
+ create mode 100644 sf-extra/omx-il/OMX_IVCommon.h
+ create mode 100644 sf-extra/omx-il/OMX_Image.h
+ create mode 100644 sf-extra/omx-il/OMX_ImageExt.h
+ create mode 100644 sf-extra/omx-il/OMX_Index.h
+ create mode 100644 sf-extra/omx-il/OMX_IndexExt.h
+ create mode 100644 sf-extra/omx-il/OMX_Other.h
+ create mode 100644 sf-extra/omx-il/OMX_Types.h
+ create mode 100644 sf-extra/omx-il/OMX_Video.h
+ create mode 100644 sf-extra/omx-il/OMX_VideoExt.h
+
+diff --git a/sf-extra/omx-il/OMX_Audio.h b/sf-extra/omx-il/OMX_Audio.h
+new file mode 100644
+index 00000000..72053193
+--- /dev/null
++++ b/sf-extra/omx-il/OMX_Audio.h
+@@ -0,0 +1,1310 @@
++/*
++ * Copyright (c) 2008 The Khronos Group Inc.
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining
++ * a copy of this software and associated documentation files (the
++ * "Software"), to deal in the Software without restriction, including
++ * without limitation the rights to use, copy, modify, merge, publish,
++ * distribute, sublicense, and/or sell copies of the Software, and to
++ * permit persons to whom the Software is furnished to do so, subject
++ * to the following conditions:
++ * The above copyright notice and this permission notice shall be included
++ * in all copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
++ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
++ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
++ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
++ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
++ *
++ */
++
++/** @file OMX_Audio.h - OpenMax IL version 1.1.2
++ *  The structures needed by Audio components to exchange
++ *  parameters and configuration data with the componenmilts.
++ */
++
++#ifndef OMX_Audio_h
++#define OMX_Audio_h
++
++#ifdef __cplusplus
++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
++ */
++
++#include <OMX_Core.h>
++
++/** @defgroup midi MIDI
++ * @ingroup audio
++ */
++
++/** @defgroup effects Audio effects
++ * @ingroup audio
++ */
++
++/** @defgroup audio OpenMAX IL Audio Domain
++ * Structures for OpenMAX IL Audio domain
++ * @{
++ */
++
++/** Enumeration used to define the possible audio codings.
++ *  If "OMX_AUDIO_CodingUnused" is selected, the coding selection must
++ *  be done in a vendor specific way.  Since this is for an audio
++ *  processing element this enum is relevant.  However, for another
++ *  type of component other enums would be in this area.
++ */
++typedef enum OMX_AUDIO_CODINGTYPE {
++    OMX_AUDIO_CodingUnused = 0,  /**< Placeholder value when coding is N/A  */
++    OMX_AUDIO_CodingAutoDetect,  /**< auto detection of audio format */
++    OMX_AUDIO_CodingPCM,         /**< Any variant of PCM coding */
++    OMX_AUDIO_CodingADPCM,       /**< Any variant of ADPCM encoded data */
++    OMX_AUDIO_CodingAMR,         /**< Any variant of AMR encoded data */
++    OMX_AUDIO_CodingGSMFR,       /**< Any variant of GSM fullrate (i.e. GSM610) */
++    OMX_AUDIO_CodingGSMEFR,      /**< Any variant of GSM Enhanced Fullrate encoded data*/
++    OMX_AUDIO_CodingGSMHR,       /**< Any variant of GSM Halfrate encoded data */
++    OMX_AUDIO_CodingPDCFR,       /**< Any variant of PDC Fullrate encoded data */
++    OMX_AUDIO_CodingPDCEFR,      /**< Any variant of PDC Enhanced Fullrate encoded data */
++    OMX_AUDIO_CodingPDCHR,       /**< Any variant of PDC Halfrate encoded data */
++    OMX_AUDIO_CodingTDMAFR,      /**< Any variant of TDMA Fullrate encoded data (TIA/EIA-136-420) */
++    OMX_AUDIO_CodingTDMAEFR,     /**< Any variant of TDMA Enhanced Fullrate encoded data (TIA/EIA-136-410) */
++    OMX_AUDIO_CodingQCELP8,      /**< Any variant of QCELP 8kbps encoded data */
++    OMX_AUDIO_CodingQCELP13,     /**< Any variant of QCELP 13kbps encoded data */
++    OMX_AUDIO_CodingEVRC,        /**< Any variant of EVRC encoded data */
++    OMX_AUDIO_CodingSMV,         /**< Any variant of SMV encoded data */
++    OMX_AUDIO_CodingG711,        /**< Any variant of G.711 encoded data */
++    OMX_AUDIO_CodingG723,        /**< Any variant of G.723 dot 1 encoded data */
++    OMX_AUDIO_CodingG726,        /**< Any variant of G.726 encoded data */
++    OMX_AUDIO_CodingG729,        /**< Any variant of G.729 encoded data */
++    OMX_AUDIO_CodingAAC,         /**< Any variant of AAC encoded data */
++    OMX_AUDIO_CodingMP3,         /**< Any variant of MP3 encoded data */
++    OMX_AUDIO_CodingSBC,         /**< Any variant of SBC encoded data */
++    OMX_AUDIO_CodingVORBIS,      /**< Any variant of VORBIS encoded data */
++    OMX_AUDIO_CodingWMA,         /**< Any variant of WMA encoded data */
++    OMX_AUDIO_CodingRA,          /**< Any variant of RA encoded data */
++    OMX_AUDIO_CodingMIDI,        /**< Any variant of MIDI encoded data */
++    OMX_AUDIO_CodingKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_AUDIO_CodingVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_AUDIO_CodingMax = 0x7FFFFFFF
++} OMX_AUDIO_CODINGTYPE;
++
++
++/** The PortDefinition structure is used to define all of the parameters
++ *  necessary for the compliant component to setup an input or an output audio
++ *  path.  If additional information is needed to define the parameters of the
++ *  port (such as frequency), additional structures must be sent such as the
++ *  OMX_AUDIO_PARAM_PCMMODETYPE structure to supply the extra parameters for the port.
++ */
++typedef struct OMX_AUDIO_PORTDEFINITIONTYPE {
++    OMX_STRING cMIMEType;            /**< MIME type of data for the port */
++    OMX_NATIVE_DEVICETYPE pNativeRender; /** < platform specific reference
++                                               for an output device,
++                                               otherwise this field is 0 */
++    OMX_BOOL bFlagErrorConcealment;  /**< Turns on error concealment if it is
++                                          supported by the OMX component */
++    OMX_AUDIO_CODINGTYPE eEncoding;  /**< Type of data expected for this
++                                          port (e.g. PCM, AMR, MP3, etc) */
++} OMX_AUDIO_PORTDEFINITIONTYPE;
++
++
++/**  Port format parameter.  This structure is used to enumerate
++  *  the various data input/output format supported by the port.
++  */
++typedef struct OMX_AUDIO_PARAM_PORTFORMATTYPE {
++    OMX_U32 nSize;                  /**< size of the structure in bytes */
++    OMX_VERSIONTYPE nVersion;       /**< OMX specification version information */
++    OMX_U32 nPortIndex;             /**< Indicates which port to set */
++    OMX_U32 nIndex;                 /**< Indicates the enumeration index for the format from 0x0 to N-1 */
++    OMX_AUDIO_CODINGTYPE eEncoding; /**< Type of data expected for this port (e.g. PCM, AMR, MP3, etc) */
++} OMX_AUDIO_PARAM_PORTFORMATTYPE;
++
++
++/** PCM mode type  */
++typedef enum OMX_AUDIO_PCMMODETYPE {
++    OMX_AUDIO_PCMModeLinear = 0,  /**< Linear PCM encoded data */
++    OMX_AUDIO_PCMModeALaw,        /**< A law PCM encoded data (G.711) */
++    OMX_AUDIO_PCMModeMULaw,       /**< Mu law PCM encoded data (G.711)  */
++    OMX_AUDIO_PCMModeKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_AUDIO_PCMModeVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_AUDIO_PCMModeMax = 0x7FFFFFFF
++} OMX_AUDIO_PCMMODETYPE;
++
++
++typedef enum OMX_AUDIO_CHANNELTYPE {
++    OMX_AUDIO_ChannelNone = 0x0,    /**< Unused or empty */
++    OMX_AUDIO_ChannelLF   = 0x1,    /**< Left front */
++    OMX_AUDIO_ChannelRF   = 0x2,    /**< Right front */
++    OMX_AUDIO_ChannelCF   = 0x3,    /**< Center front */
++    OMX_AUDIO_ChannelLS   = 0x4,    /**< Left surround */
++    OMX_AUDIO_ChannelRS   = 0x5,    /**< Right surround */
++    OMX_AUDIO_ChannelLFE  = 0x6,    /**< Low frequency effects */
++    OMX_AUDIO_ChannelCS   = 0x7,    /**< Back surround */
++    OMX_AUDIO_ChannelLR   = 0x8,    /**< Left rear. */
++    OMX_AUDIO_ChannelRR   = 0x9,    /**< Right rear. */
++    OMX_AUDIO_ChannelKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_AUDIO_ChannelVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_AUDIO_ChannelMax  = 0x7FFFFFFF
++} OMX_AUDIO_CHANNELTYPE;
++
++#define OMX_AUDIO_MAXCHANNELS 16  /**< maximum number distinct audio channels that a buffer may contain */
++#define OMX_MIN_PCMPAYLOAD_MSEC 5 /**< Minimum audio buffer payload size for uncompressed (PCM) audio */
++
++/** PCM format description */
++typedef struct OMX_AUDIO_PARAM_PCMMODETYPE {
++    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 nChannels;                /**< Number of channels (e.g. 2 for stereo) */
++    OMX_NUMERICALDATATYPE eNumData;   /**< indicates PCM data as signed or unsigned */
++    OMX_ENDIANTYPE eEndian;           /**< indicates PCM data as little or big endian */
++    OMX_BOOL bInterleaved;            /**< True for normal interleaved data; false for
++                                           non-interleaved data (e.g. block data) */
++    OMX_U32 nBitPerSample;            /**< Bit per sample */
++    OMX_U32 nSamplingRate;            /**< Sampling rate of the source data.  Use 0 for
++                                           variable or unknown sampling rate. */
++    OMX_AUDIO_PCMMODETYPE ePCMMode;   /**< PCM mode enumeration */
++    OMX_AUDIO_CHANNELTYPE eChannelMapping[OMX_AUDIO_MAXCHANNELS]; /**< Slot i contains channel defined by eChannelMap[i] */
++
++} OMX_AUDIO_PARAM_PCMMODETYPE;
++
++
++/** Audio channel mode.  This is used by both AAC and MP3, although the names are more appropriate
++ * for the MP3.  For example, JointStereo for MP3 is CouplingChannels for AAC.
++ */
++typedef enum OMX_AUDIO_CHANNELMODETYPE {
++    OMX_AUDIO_ChannelModeStereo = 0,  /**< 2 channels, the bitrate allocation between those
++                                          two channels changes accordingly to each channel information */
++    OMX_AUDIO_ChannelModeJointStereo, /**< mode that takes advantage of what is common between
++                                           2 channels for higher compression gain */
++    OMX_AUDIO_ChannelModeDual,        /**< 2 mono-channels, each channel is encoded with half
++                                           the bitrate of the overall bitrate */
++    OMX_AUDIO_ChannelModeMono,        /**< Mono channel mode */
++    OMX_AUDIO_ChannelModeKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_AUDIO_ChannelModeVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_AUDIO_ChannelModeMax = 0x7FFFFFFF
++} OMX_AUDIO_CHANNELMODETYPE;
++
++
++typedef enum OMX_AUDIO_MP3STREAMFORMATTYPE {
++    OMX_AUDIO_MP3StreamFormatMP1Layer3 = 0, /**< MP3 Audio MPEG 1 Layer 3 Stream format */
++    OMX_AUDIO_MP3StreamFormatMP2Layer3,     /**< MP3 Audio MPEG 2 Layer 3 Stream format */
++    OMX_AUDIO_MP3StreamFormatMP2_5Layer3,   /**< MP3 Audio MPEG2.5 Layer 3 Stream format */
++    OMX_AUDIO_MP3StreamFormatKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_AUDIO_MP3StreamFormatVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_AUDIO_MP3StreamFormatMax = 0x7FFFFFFF
++} OMX_AUDIO_MP3STREAMFORMATTYPE;
++
++/** MP3 params */
++typedef struct OMX_AUDIO_PARAM_MP3TYPE {
++    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_U32 nChannels;             /**< Number of channels */
++    OMX_U32 nBitRate;              /**< Bit rate of the input data.  Use 0 for variable
++                                        rate or unknown bit rates */
++    OMX_U32 nSampleRate;           /**< Sampling rate of the source data.  Use 0 for
++                                        variable or unknown sampling rate. */
++    OMX_U32 nAudioBandWidth;       /**< Audio band width (in Hz) to which an encoder should
++                                        limit the audio signal. Use 0 to let encoder decide */
++    OMX_AUDIO_CHANNELMODETYPE eChannelMode;   /**< Channel mode enumeration */
++    OMX_AUDIO_MP3STREAMFORMATTYPE eFormat;  /**< MP3 stream format */
++} OMX_AUDIO_PARAM_MP3TYPE;
++
++
++typedef enum OMX_AUDIO_AACSTREAMFORMATTYPE {
++    OMX_AUDIO_AACStreamFormatMP2ADTS = 0, /**< AAC Audio Data Transport Stream 2 format */
++    OMX_AUDIO_AACStreamFormatMP4ADTS,     /**< AAC Audio Data Transport Stream 4 format */
++    OMX_AUDIO_AACStreamFormatMP4LOAS,     /**< AAC Low Overhead Audio Stream format */
++    OMX_AUDIO_AACStreamFormatMP4LATM,     /**< AAC Low overhead Audio Transport Multiplex */
++    OMX_AUDIO_AACStreamFormatADIF,        /**< AAC Audio Data Interchange Format */
++    OMX_AUDIO_AACStreamFormatMP4FF,       /**< AAC inside MPEG-4/ISO File Format */
++    OMX_AUDIO_AACStreamFormatRAW,         /**< AAC Raw Format */
++    OMX_AUDIO_AACStreamFormatKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_AUDIO_AACStreamFormatVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_AUDIO_AACStreamFormatMax = 0x7FFFFFFF
++} OMX_AUDIO_AACSTREAMFORMATTYPE;
++
++
++/** AAC mode type.  Note that the term profile is used with the MPEG-2
++ * standard and the term object type and profile is used with MPEG-4 */
++typedef enum OMX_AUDIO_AACPROFILETYPE {
++    OMX_AUDIO_AACObjectNull = 0,      /**< Null, not used */
++    OMX_AUDIO_AACObjectMain = 1,      /**< AAC Main object */
++    OMX_AUDIO_AACObjectLC,            /**< AAC Low Complexity object (AAC profile) */
++    OMX_AUDIO_AACObjectSSR,           /**< AAC Scalable Sample Rate object */
++    OMX_AUDIO_AACObjectLTP,           /**< AAC Long Term Prediction object */
++    OMX_AUDIO_AACObjectHE,            /**< AAC High Efficiency (object type SBR, HE-AAC profile) */
++    OMX_AUDIO_AACObjectScalable,      /**< AAC Scalable object */
++    OMX_AUDIO_AACObjectERLC = 17,     /**< ER AAC Low Complexity object (Error Resilient AAC-LC) */
++    OMX_AUDIO_AACObjectLD = 23,       /**< AAC Low Delay object (Error Resilient) */
++    OMX_AUDIO_AACObjectHE_PS = 29,    /**< AAC High Efficiency with Parametric Stereo coding (HE-AAC v2, object type PS) */
++    OMX_AUDIO_AACObjectKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_AUDIO_AACObjectVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_AUDIO_AACObjectMax = 0x7FFFFFFF
++} OMX_AUDIO_AACPROFILETYPE;
++
++
++/** AAC tool usage (for nAACtools in OMX_AUDIO_PARAM_AACPROFILETYPE).
++ * Required for encoder configuration and optional as decoder info output.
++ * For MP3, OMX_AUDIO_CHANNELMODETYPE is sufficient. */
++#define OMX_AUDIO_AACToolNone 0x00000000 /**< no AAC tools allowed (encoder config) or active (decoder info output) */
++#define OMX_AUDIO_AACToolMS   0x00000001 /**< MS: Mid/side joint coding tool allowed or active */
++#define OMX_AUDIO_AACToolIS   0x00000002 /**< IS: Intensity stereo tool allowed or active */
++#define OMX_AUDIO_AACToolTNS  0x00000004 /**< TNS: Temporal Noise Shaping tool allowed or active */
++#define OMX_AUDIO_AACToolPNS  0x00000008 /**< PNS: MPEG-4 Perceptual Noise substitution tool allowed or active */
++#define OMX_AUDIO_AACToolLTP  0x00000010 /**< LTP: MPEG-4 Long Term Prediction tool allowed or active */
++#define OMX_AUDIO_AACToolAll  0x7FFFFFFF /**< all AAC tools allowed or active (*/
++
++/** MPEG-4 AAC error resilience (ER) tool usage (for nAACERtools in OMX_AUDIO_PARAM_AACPROFILETYPE).
++ * Required for ER encoder configuration and optional as decoder info output */
++#define OMX_AUDIO_AACERNone  0x00000000  /**< no AAC ER tools allowed/used */
++#define OMX_AUDIO_AACERVCB11 0x00000001  /**< VCB11: Virtual Code Books for AAC section data */
++#define OMX_AUDIO_AACERRVLC  0x00000002  /**< RVLC: Reversible Variable Length Coding */
++#define OMX_AUDIO_AACERHCR   0x00000004  /**< HCR: Huffman Codeword Reordering */
++#define OMX_AUDIO_AACERAll   0x7FFFFFFF  /**< all AAC ER tools allowed/used */
++
++
++/** AAC params */
++typedef struct OMX_AUDIO_PARAM_AACPROFILETYPE {
++    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 nChannels;             /**< Number of channels */
++    OMX_U32 nSampleRate;           /**< Sampling rate of the source data.  Use 0 for
++                                        variable or unknown sampling rate. */
++    OMX_U32 nBitRate;              /**< Bit rate of the input data.  Use 0 for variable
++                                        rate or unknown bit rates */
++    OMX_U32 nAudioBandWidth;       /**< Audio band width (in Hz) to which an encoder should
++                                        limit the audio signal. Use 0 to let encoder decide */
++    OMX_U32 nFrameLength;          /**< Frame length (in audio samples per channel) of the codec.
++                                        Can be 1024 or 960 (AAC-LC), 2048 (HE-AAC), 480 or 512 (AAC-LD).
++                                        Use 0 to let encoder decide */
++    OMX_U32 nAACtools;             /**< AAC tool usage */
++    OMX_U32 nAACERtools;           /**< MPEG-4 AAC error resilience tool usage */
++    OMX_AUDIO_AACPROFILETYPE eAACProfile;   /**< AAC profile enumeration */
++    OMX_AUDIO_AACSTREAMFORMATTYPE eAACStreamFormat; /**< AAC stream format enumeration */
++    OMX_AUDIO_CHANNELMODETYPE eChannelMode;   /**< Channel mode enumeration */
++} OMX_AUDIO_PARAM_AACPROFILETYPE;
++
++
++/** VORBIS params */
++typedef struct OMX_AUDIO_PARAM_VORBISTYPE {
++    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_U32 nChannels;        /**< Number of channels */
++    OMX_U32 nBitRate;         /**< Bit rate of the encoded data data.  Use 0 for variable
++                                   rate or unknown bit rates. Encoding is set to the
++                                   bitrate closest to specified  value (in bps) */
++    OMX_U32 nMinBitRate;      /**< Sets minimum bitrate (in bps). */
++    OMX_U32 nMaxBitRate;      /**< Sets maximum bitrate (in bps). */
++
++    OMX_U32 nSampleRate;      /**< Sampling rate of the source data.  Use 0 for
++                                   variable or unknown sampling rate. */
++    OMX_U32 nAudioBandWidth;  /**< Audio band width (in Hz) to which an encoder should
++                                   limit the audio signal. Use 0 to let encoder decide */
++    OMX_S32 nQuality;         /**< Sets encoding quality to n, between -1 (low) and 10 (high).
++                                   In the default mode of operation, teh quality level is 3.
++                                   Normal quality range is 0 - 10. */
++    OMX_BOOL bManaged;        /**< Set  bitrate  management  mode. This turns off the
++                                   normal VBR encoding, but allows hard or soft bitrate
++                                   constraints to be enforced by the encoder. This mode can
++                                   be slower, and may also be lower quality. It is
++                                   primarily useful for streaming. */
++    OMX_BOOL bDownmix;        /**< Downmix input from stereo to mono (has no effect on
++                                   non-stereo streams). Useful for lower-bitrate encoding. */
++} OMX_AUDIO_PARAM_VORBISTYPE;
++
++
++/** WMA Version */
++typedef enum OMX_AUDIO_WMAFORMATTYPE {
++    OMX_AUDIO_WMAFormatUnused = 0, /**< format unused or unknown */
++    OMX_AUDIO_WMAFormat7,          /**< Windows Media Audio format 7 */
++    OMX_AUDIO_WMAFormat8,          /**< Windows Media Audio format 8 */
++    OMX_AUDIO_WMAFormat9,          /**< Windows Media Audio format 9 */
++    OMX_AUDIO_WMAFormatKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_AUDIO_WMAFormatVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_AUDIO_WMAFormatMax = 0x7FFFFFFF
++} OMX_AUDIO_WMAFORMATTYPE;
++
++
++/** WMA Profile */
++typedef enum OMX_AUDIO_WMAPROFILETYPE {
++    OMX_AUDIO_WMAProfileUnused = 0,  /**< profile unused or unknown */
++    OMX_AUDIO_WMAProfileL1,          /**< Windows Media audio version 9 profile L1 */
++    OMX_AUDIO_WMAProfileL2,          /**< Windows Media audio version 9 profile L2 */
++    OMX_AUDIO_WMAProfileL3,          /**< Windows Media audio version 9 profile L3 */
++    OMX_AUDIO_WMAProfileKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_AUDIO_WMAProfileVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_AUDIO_WMAProfileMax = 0x7FFFFFFF
++} OMX_AUDIO_WMAPROFILETYPE;
++
++
++/** WMA params */
++typedef struct OMX_AUDIO_PARAM_WMATYPE {
++    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_U16 nChannels;        /**< Number of channels */
++    OMX_U32 nBitRate;         /**< Bit rate of the input data.  Use 0 for variable
++                                   rate or unknown bit rates */
++    OMX_AUDIO_WMAFORMATTYPE eFormat; /**< Version of WMA stream / data */
++    OMX_AUDIO_WMAPROFILETYPE eProfile;  /**< Profile of WMA stream / data */
++    OMX_U32 nSamplingRate;    /**< Sampling rate of the source data */
++    OMX_U16 nBlockAlign;      /**< is the block alignment, or block size, in bytes of the audio codec */
++    OMX_U16 nEncodeOptions;   /**< WMA Type-specific data */
++    OMX_U32 nSuperBlockAlign; /**< WMA Type-specific data */
++} OMX_AUDIO_PARAM_WMATYPE;
++
++/**
++ * RealAudio format
++ */
++typedef enum OMX_AUDIO_RAFORMATTYPE {
++    OMX_AUDIO_RAFormatUnused = 0, /**< Format unused or unknown */
++    OMX_AUDIO_RA8,                /**< RealAudio 8 codec */
++    OMX_AUDIO_RA9,                /**< RealAudio 9 codec */
++    OMX_AUDIO_RA10_AAC,           /**< MPEG-4 AAC codec for bitrates of more than 128kbps */
++    OMX_AUDIO_RA10_CODEC,         /**< RealAudio codec for bitrates less than 128 kbps */
++    OMX_AUDIO_RA10_LOSSLESS,      /**< RealAudio Lossless */
++    OMX_AUDIO_RA10_MULTICHANNEL,  /**< RealAudio Multichannel */
++    OMX_AUDIO_RA10_VOICE,         /**< RealAudio Voice for bitrates below 15 kbps */
++    OMX_AUDIO_RAFormatKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_AUDIO_RAFormatVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_VIDEO_RAFormatMax = 0x7FFFFFFF
++} OMX_AUDIO_RAFORMATTYPE;
++
++/** RA (Real Audio) params */
++typedef struct OMX_AUDIO_PARAM_RATYPE {
++    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 nChannels;          /**< Number of channels */
++    OMX_U32 nSamplingRate;      /**< is the sampling rate of the source data */
++    OMX_U32 nBitsPerFrame;      /**< is the value for bits per frame  */
++    OMX_U32 nSamplePerFrame;    /**< is the value for samples per frame */
++    OMX_U32 nCouplingQuantBits; /**< is the number of coupling quantization bits in the stream */
++    OMX_U32 nCouplingStartRegion;   /**< is the coupling start region in the stream  */
++    OMX_U32 nNumRegions;        /**< is the number of regions value */
++    OMX_AUDIO_RAFORMATTYPE eFormat; /**< is the RealAudio audio format */
++} OMX_AUDIO_PARAM_RATYPE;
++
++
++/** SBC Allocation Method Type */
++typedef enum OMX_AUDIO_SBCALLOCMETHODTYPE {
++    OMX_AUDIO_SBCAllocMethodLoudness, /**< Loudness allocation method */
++    OMX_AUDIO_SBCAllocMethodSNR,      /**< SNR allocation method */
++    OMX_AUDIO_SBCAllocMethodKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_AUDIO_SBCAllocMethodVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_AUDIO_SBCAllocMethodMax = 0x7FFFFFFF
++} OMX_AUDIO_SBCALLOCMETHODTYPE;
++
++
++/** SBC params */
++typedef struct OMX_AUDIO_PARAM_SBCTYPE {
++    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_U32 nChannels;         /**< Number of channels */
++    OMX_U32 nBitRate;          /**< Bit rate of the input data.  Use 0 for variable
++                                    rate or unknown bit rates */
++    OMX_U32 nSampleRate;       /**< Sampling rate of the source data.  Use 0 for
++                                    variable or unknown sampling rate. */
++    OMX_U32 nBlocks;           /**< Number of blocks */
++    OMX_U32 nSubbands;         /**< Number of subbands */
++    OMX_U32 nBitPool;          /**< Bitpool value */
++    OMX_BOOL bEnableBitrate;   /**< Use bitrate value instead of bitpool */
++    OMX_AUDIO_CHANNELMODETYPE eChannelMode; /**< Channel mode enumeration */
++    OMX_AUDIO_SBCALLOCMETHODTYPE eSBCAllocType;   /**< SBC Allocation method type */
++} OMX_AUDIO_PARAM_SBCTYPE;
++
++
++/** ADPCM stream format parameters */
++typedef struct OMX_AUDIO_PARAM_ADPCMTYPE {
++    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_U32 nChannels;          /**< Number of channels in the data stream (not
++                                     necessarily the same as the number of channels
++                                     to be rendered. */
++    OMX_U32 nBitsPerSample;     /**< Number of bits in each sample */
++    OMX_U32 nSampleRate;        /**< Sampling rate of the source data.  Use 0 for
++                                    variable or unknown sampling rate. */
++} OMX_AUDIO_PARAM_ADPCMTYPE;
++
++
++/** G723 rate */
++typedef enum OMX_AUDIO_G723RATE {
++    OMX_AUDIO_G723ModeUnused = 0,  /**< AMRNB Mode unused / unknown */
++    OMX_AUDIO_G723ModeLow,         /**< 5300 bps */
++    OMX_AUDIO_G723ModeHigh,        /**< 6300 bps */
++    OMX_AUDIO_G723ModeKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_AUDIO_G723ModeVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_AUDIO_G723ModeMax = 0x7FFFFFFF
++} OMX_AUDIO_G723RATE;
++
++
++/** G723 - Sample rate must be 8 KHz */
++typedef struct OMX_AUDIO_PARAM_G723TYPE {
++    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_U32 nChannels;            /**< Number of channels in the data stream (not
++                                       necessarily the same as the number of channels
++                                       to be rendered. */
++    OMX_BOOL bDTX;                /**< Enable Discontinuous Transmisssion */
++    OMX_AUDIO_G723RATE eBitRate;  /**< todo: Should this be moved to a config? */
++    OMX_BOOL bHiPassFilter;       /**< Enable High Pass Filter */
++    OMX_BOOL bPostFilter;         /**< Enable Post Filter */
++} OMX_AUDIO_PARAM_G723TYPE;
++
++
++/** ITU G726 (ADPCM) rate */
++typedef enum OMX_AUDIO_G726MODE {
++    OMX_AUDIO_G726ModeUnused = 0,  /**< G726 Mode unused / unknown */
++    OMX_AUDIO_G726Mode16,          /**< 16 kbps */
++    OMX_AUDIO_G726Mode24,          /**< 24 kbps */
++    OMX_AUDIO_G726Mode32,          /**< 32 kbps, most common rate, also G721 */
++    OMX_AUDIO_G726Mode40,          /**< 40 kbps */
++    OMX_AUDIO_G726ModeKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_AUDIO_G726ModeVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_AUDIO_G726ModeMax = 0x7FFFFFFF
++} OMX_AUDIO_G726MODE;
++
++
++/** G.726 stream format parameters - must be at 8KHz */
++typedef struct OMX_AUDIO_PARAM_G726TYPE {
++    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_U32 nChannels;          /**< Number of channels in the data stream (not
++                                     necessarily the same as the number of channels
++                                     to be rendered. */
++    OMX_AUDIO_G726MODE eG726Mode;
++} OMX_AUDIO_PARAM_G726TYPE;
++
++
++/** G729 coder type */
++typedef enum OMX_AUDIO_G729TYPE {
++    OMX_AUDIO_G729 = 0,           /**< ITU G.729  encoded data */
++    OMX_AUDIO_G729A,              /**< ITU G.729 annex A  encoded data */
++    OMX_AUDIO_G729B,              /**< ITU G.729 with annex B encoded data */
++    OMX_AUDIO_G729AB,             /**< ITU G.729 annexes A and B encoded data */
++    OMX_AUDIO_G729KhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_AUDIO_G729VendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_AUDIO_G729Max = 0x7FFFFFFF
++} OMX_AUDIO_G729TYPE;
++
++
++/** G729 stream format parameters - fixed 6KHz sample rate */
++typedef struct OMX_AUDIO_PARAM_G729TYPE {
++    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_U32 nChannels;        /**< Number of channels in the data stream (not
++                                   necessarily the same as the number of channels
++                                   to be rendered. */
++    OMX_BOOL bDTX;            /**< Enable Discontinuous Transmisssion */
++    OMX_AUDIO_G729TYPE eBitType;
++} OMX_AUDIO_PARAM_G729TYPE;
++
++
++/** AMR Frame format */
++typedef enum OMX_AUDIO_AMRFRAMEFORMATTYPE {
++    OMX_AUDIO_AMRFrameFormatConformance = 0,  /**< Frame Format is AMR Conformance
++                                                   (Standard) Format */
++    OMX_AUDIO_AMRFrameFormatIF1,              /**< Frame Format is AMR Interface
++                                                   Format 1 */
++    OMX_AUDIO_AMRFrameFormatIF2,              /**< Frame Format is AMR Interface
++                                                   Format 2*/
++    OMX_AUDIO_AMRFrameFormatFSF,              /**< Frame Format is AMR File Storage
++                                                   Format */
++    OMX_AUDIO_AMRFrameFormatRTPPayload,       /**< Frame Format is AMR Real-Time
++                                                   Transport Protocol Payload Format */
++    OMX_AUDIO_AMRFrameFormatITU,              /**< Frame Format is ITU Format (added at Motorola request) */
++    OMX_AUDIO_AMRFrameFormatKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_AUDIO_AMRFrameFormatVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_AUDIO_AMRFrameFormatMax = 0x7FFFFFFF
++} OMX_AUDIO_AMRFRAMEFORMATTYPE;
++
++
++/** AMR band mode */
++typedef enum OMX_AUDIO_AMRBANDMODETYPE {
++    OMX_AUDIO_AMRBandModeUnused = 0,          /**< AMRNB Mode unused / unknown */
++    OMX_AUDIO_AMRBandModeNB0,                 /**< AMRNB Mode 0 =  4750 bps */
++    OMX_AUDIO_AMRBandModeNB1,                 /**< AMRNB Mode 1 =  5150 bps */
++    OMX_AUDIO_AMRBandModeNB2,                 /**< AMRNB Mode 2 =  5900 bps */
++    OMX_AUDIO_AMRBandModeNB3,                 /**< AMRNB Mode 3 =  6700 bps */
++    OMX_AUDIO_AMRBandModeNB4,                 /**< AMRNB Mode 4 =  7400 bps */
++    OMX_AUDIO_AMRBandModeNB5,                 /**< AMRNB Mode 5 =  7950 bps */
++    OMX_AUDIO_AMRBandModeNB6,                 /**< AMRNB Mode 6 = 10200 bps */
++    OMX_AUDIO_AMRBandModeNB7,                 /**< AMRNB Mode 7 = 12200 bps */
++    OMX_AUDIO_AMRBandModeWB0,                 /**< AMRWB Mode 0 =  6600 bps */
++    OMX_AUDIO_AMRBandModeWB1,                 /**< AMRWB Mode 1 =  8850 bps */
++    OMX_AUDIO_AMRBandModeWB2,                 /**< AMRWB Mode 2 = 12650 bps */
++    OMX_AUDIO_AMRBandModeWB3,                 /**< AMRWB Mode 3 = 14250 bps */
++    OMX_AUDIO_AMRBandModeWB4,                 /**< AMRWB Mode 4 = 15850 bps */
++    OMX_AUDIO_AMRBandModeWB5,                 /**< AMRWB Mode 5 = 18250 bps */
++    OMX_AUDIO_AMRBandModeWB6,                 /**< AMRWB Mode 6 = 19850 bps */
++    OMX_AUDIO_AMRBandModeWB7,                 /**< AMRWB Mode 7 = 23050 bps */
++    OMX_AUDIO_AMRBandModeWB8,                 /**< AMRWB Mode 8 = 23850 bps */
++    OMX_AUDIO_AMRBandModeKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_AUDIO_AMRBandModeVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_AUDIO_AMRBandModeMax = 0x7FFFFFFF
++} OMX_AUDIO_AMRBANDMODETYPE;
++
++
++/** AMR Discontinuous Transmission mode */
++typedef enum OMX_AUDIO_AMRDTXMODETYPE {
++    OMX_AUDIO_AMRDTXModeOff = 0,        /**< AMR Discontinuous Transmission Mode is disabled */
++    OMX_AUDIO_AMRDTXModeOnVAD1,         /**< AMR Discontinuous Transmission Mode using
++                                             Voice Activity Detector 1 (VAD1) is enabled */
++    OMX_AUDIO_AMRDTXModeOnVAD2,         /**< AMR Discontinuous Transmission Mode using
++                                             Voice Activity Detector 2 (VAD2) is enabled */
++    OMX_AUDIO_AMRDTXModeOnAuto,         /**< The codec will automatically select between
++                                             Off, VAD1 or VAD2 modes */
++
++    OMX_AUDIO_AMRDTXasEFR,             /**< DTX as EFR instead of AMR standard (3GPP 26.101, frame type =8,9,10) */
++
++    OMX_AUDIO_AMRDTXModeKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_AUDIO_AMRDTXModeVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_AUDIO_AMRDTXModeMax = 0x7FFFFFFF
++} OMX_AUDIO_AMRDTXMODETYPE;
++
++
++/** AMR params */
++typedef struct OMX_AUDIO_PARAM_AMRTYPE {
++    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_U32 nChannels;                      /**< Number of channels */
++    OMX_U32 nBitRate;                       /**< Bit rate read only field */
++    OMX_AUDIO_AMRBANDMODETYPE eAMRBandMode; /**< AMR Band Mode enumeration */
++    OMX_AUDIO_AMRDTXMODETYPE  eAMRDTXMode;  /**< AMR DTX Mode enumeration */
++    OMX_AUDIO_AMRFRAMEFORMATTYPE eAMRFrameFormat; /**< AMR frame format enumeration */
++} OMX_AUDIO_PARAM_AMRTYPE;
++
++
++/** GSM_FR (ETSI 06.10, 3GPP 46.010) stream format parameters */
++typedef struct OMX_AUDIO_PARAM_GSMFRTYPE {
++    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_BOOL bDTX;            /**< Enable Discontinuous Transmisssion */
++    OMX_BOOL bHiPassFilter;   /**< Enable High Pass Filter */
++} OMX_AUDIO_PARAM_GSMFRTYPE;
++
++
++/** GSM-HR (ETSI 06.20, 3GPP 46.020) stream format parameters */
++typedef struct OMX_AUDIO_PARAM_GSMHRTYPE {
++    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_BOOL bDTX;            /**< Enable Discontinuous Transmisssion */
++    OMX_BOOL bHiPassFilter;   /**< Enable High Pass Filter */
++} OMX_AUDIO_PARAM_GSMHRTYPE;
++
++
++/** GSM-EFR (ETSI 06.60, 3GPP 46.060) stream format parameters */
++typedef struct OMX_AUDIO_PARAM_GSMEFRTYPE {
++    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_BOOL bDTX;            /**< Enable Discontinuous Transmisssion */
++    OMX_BOOL bHiPassFilter;   /**< Enable High Pass Filter */
++} OMX_AUDIO_PARAM_GSMEFRTYPE;
++
++
++/** TDMA FR (TIA/EIA-136-420, VSELP 7.95kbps coder) stream format parameters */
++typedef struct OMX_AUDIO_PARAM_TDMAFRTYPE {
++    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_U32 nChannels;            /**< Number of channels in the data stream (not
++                                       necessarily the same as the number of channels
++                                       to be rendered. */
++    OMX_BOOL bDTX;                /**< Enable Discontinuous Transmisssion */
++    OMX_BOOL bHiPassFilter;       /**< Enable High Pass Filter */
++} OMX_AUDIO_PARAM_TDMAFRTYPE;
++
++
++/** TDMA EFR (TIA/EIA-136-410, ACELP 7.4kbps coder) stream format parameters */
++typedef struct OMX_AUDIO_PARAM_TDMAEFRTYPE {
++    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_U32 nChannels;            /**< Number of channels in the data stream (not
++                                       necessarily the same as the number of channels
++                                       to be rendered. */
++    OMX_BOOL bDTX;                /**< Enable Discontinuous Transmisssion */
++    OMX_BOOL bHiPassFilter;       /**< Enable High Pass Filter */
++} OMX_AUDIO_PARAM_TDMAEFRTYPE;
++
++
++/** PDC FR ( RCR-27, VSELP 6.7kbps coder) stream format parameters */
++typedef struct OMX_AUDIO_PARAM_PDCFRTYPE {
++    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_U32 nChannels;            /**< Number of channels in the data stream (not
++                                       necessarily the same as the number of channels
++                                       to be rendered. */
++    OMX_BOOL bDTX;                /**< Enable Discontinuous Transmisssion */
++    OMX_BOOL bHiPassFilter;       /**< Enable High Pass Filter */
++} OMX_AUDIO_PARAM_PDCFRTYPE;
++
++
++/** PDC EFR ( RCR-27, ACELP 6.7kbps coder) stream format parameters */
++typedef struct OMX_AUDIO_PARAM_PDCEFRTYPE {
++    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_U32 nChannels;            /**< Number of channels in the data stream (not
++                                       necessarily the same as the number of channels
++                                       to be rendered. */
++    OMX_BOOL bDTX;                /**< Enable Discontinuous Transmisssion */
++    OMX_BOOL bHiPassFilter;       /**< Enable High Pass Filter */
++} OMX_AUDIO_PARAM_PDCEFRTYPE;
++
++/** PDC HR ( RCR-27, PSI-CELP 3.45kbps coder) stream format parameters */
++typedef struct OMX_AUDIO_PARAM_PDCHRTYPE {
++    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_U32 nChannels;            /**< Number of channels in the data stream (not
++                                       necessarily the same as the number of channels
++                                       to be rendered. */
++    OMX_BOOL bDTX;                /**< Enable Discontinuous Transmisssion */
++    OMX_BOOL bHiPassFilter;       /**< Enable High Pass Filter */
++} OMX_AUDIO_PARAM_PDCHRTYPE;
++
++
++/** CDMA Rate types */
++typedef enum OMX_AUDIO_CDMARATETYPE {
++    OMX_AUDIO_CDMARateBlank = 0,          /**< CDMA encoded frame is blank */
++    OMX_AUDIO_CDMARateFull,               /**< CDMA encoded frame in full rate */
++    OMX_AUDIO_CDMARateHalf,               /**< CDMA encoded frame in half rate */
++    OMX_AUDIO_CDMARateQuarter,            /**< CDMA encoded frame in quarter rate */
++    OMX_AUDIO_CDMARateEighth,             /**< CDMA encoded frame in eighth rate (DTX)*/
++    OMX_AUDIO_CDMARateErasure,            /**< CDMA erasure frame */
++    OMX_AUDIO_CDMARateKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_AUDIO_CDMARateVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_AUDIO_CDMARateMax = 0x7FFFFFFF
++} OMX_AUDIO_CDMARATETYPE;
++
++
++/** QCELP8 (TIA/EIA-96, up to 8kbps coder) stream format parameters */
++typedef struct OMX_AUDIO_PARAM_QCELP8TYPE {
++    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_U32 nChannels;            /**< Number of channels in the data stream (not
++                                       necessarily the same as the number of channels
++                                       to be rendered. */
++    OMX_U32 nBitRate;             /**< Bit rate of the input data.  Use 0 for variable
++                                       rate or unknown bit rates */
++    OMX_AUDIO_CDMARATETYPE eCDMARate; /**< Frame rate */
++    OMX_U32 nMinBitRate;          /**< minmal rate for the encoder = 1,2,3,4, default = 1 */
++    OMX_U32 nMaxBitRate;          /**< maximal rate for the encoder = 1,2,3,4, default = 4 */
++} OMX_AUDIO_PARAM_QCELP8TYPE;
++
++
++/** QCELP13 ( CDMA, EIA/TIA-733, 13.3kbps coder) stream format parameters */
++typedef struct OMX_AUDIO_PARAM_QCELP13TYPE {
++    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_U32 nChannels;            /**< Number of channels in the data stream (not
++                                       necessarily the same as the number of channels
++                                       to be rendered. */
++    OMX_AUDIO_CDMARATETYPE eCDMARate; /**< Frame rate */
++    OMX_U32 nMinBitRate;          /**< minmal rate for the encoder = 1,2,3,4, default = 1 */
++    OMX_U32 nMaxBitRate;          /**< maximal rate for the encoder = 1,2,3,4, default = 4 */
++} OMX_AUDIO_PARAM_QCELP13TYPE;
++
++
++/** EVRC ( CDMA, EIA/TIA-127, RCELP up to 8.55kbps coder) stream format parameters */
++typedef struct OMX_AUDIO_PARAM_EVRCTYPE {
++    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_U32 nChannels;            /**< Number of channels in the data stream (not
++                                       necessarily the same as the number of channels
++                                       to be rendered. */
++    OMX_AUDIO_CDMARATETYPE eCDMARate; /**< actual Frame rate */
++    OMX_BOOL bRATE_REDUCon;       /**< RATE_REDUCtion is requested for this frame */
++    OMX_U32 nMinBitRate;          /**< minmal rate for the encoder = 1,2,3,4, default = 1 */
++    OMX_U32 nMaxBitRate;          /**< maximal rate for the encoder = 1,2,3,4, default = 4 */
++    OMX_BOOL bHiPassFilter;       /**< Enable encoder's High Pass Filter */
++    OMX_BOOL bNoiseSuppressor;    /**< Enable encoder's noise suppressor pre-processing */
++    OMX_BOOL bPostFilter;         /**< Enable decoder's post Filter */
++} OMX_AUDIO_PARAM_EVRCTYPE;
++
++
++/** SMV ( up to 8.55kbps coder) stream format parameters */
++typedef struct OMX_AUDIO_PARAM_SMVTYPE {
++    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_U32 nChannels;            /**< Number of channels in the data stream (not
++                                       necessarily the same as the number of channels
++                                       to be rendered. */
++    OMX_AUDIO_CDMARATETYPE eCDMARate; /**< Frame rate */
++    OMX_BOOL bRATE_REDUCon;           /**< RATE_REDUCtion is requested for this frame */
++    OMX_U32 nMinBitRate;          /**< minmal rate for the encoder = 1,2,3,4, default = 1 ??*/
++    OMX_U32 nMaxBitRate;          /**< maximal rate for the encoder = 1,2,3,4, default = 4 ??*/
++    OMX_BOOL bHiPassFilter;       /**< Enable encoder's High Pass Filter ??*/
++    OMX_BOOL bNoiseSuppressor;    /**< Enable encoder's noise suppressor pre-processing */
++    OMX_BOOL bPostFilter;         /**< Enable decoder's post Filter ??*/
++} OMX_AUDIO_PARAM_SMVTYPE;
++
++
++/** MIDI Format
++ * @ingroup midi
++ */
++typedef enum OMX_AUDIO_MIDIFORMATTYPE {
++    OMX_AUDIO_MIDIFormatUnknown = 0, /**< MIDI Format unknown or don't care */
++    OMX_AUDIO_MIDIFormatSMF0,        /**< Standard MIDI File Type 0 */
++    OMX_AUDIO_MIDIFormatSMF1,        /**< Standard MIDI File Type 1 */
++    OMX_AUDIO_MIDIFormatSMF2,        /**< Standard MIDI File Type 2 */
++    OMX_AUDIO_MIDIFormatSPMIDI,      /**< SP-MIDI */
++    OMX_AUDIO_MIDIFormatXMF0,        /**< eXtensible Music Format type 0 */
++    OMX_AUDIO_MIDIFormatXMF1,        /**< eXtensible Music Format type 1 */
++    OMX_AUDIO_MIDIFormatMobileXMF,   /**< Mobile XMF (eXtensible Music Format type 2) */
++    OMX_AUDIO_MIDIFormatKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_AUDIO_MIDIFormatVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_AUDIO_MIDIFormatMax = 0x7FFFFFFF
++} OMX_AUDIO_MIDIFORMATTYPE;
++
++
++/** MIDI params
++ * @ingroup midi
++ */
++typedef struct OMX_AUDIO_PARAM_MIDITYPE {
++    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_U32 nFileSize;             /**< size of the MIDI file in bytes, where the entire
++                                        MIDI file passed in, otherwise if 0x0, the MIDI data
++                                        is merged and streamed (instead of passed as an
++                                        entire MIDI file) */
++    OMX_BU32 sMaxPolyphony;        /**< Specifies the maximum simultaneous polyphonic
++                                        voices. A value of zero indicates that the default
++                                        polyphony of the device is used  */
++    OMX_BOOL bLoadDefaultSound;    /**< Whether to load default sound
++                                        bank at initialization */
++    OMX_AUDIO_MIDIFORMATTYPE eMidiFormat; /**< Version of the MIDI file */
++} OMX_AUDIO_PARAM_MIDITYPE;
++
++
++/** Type of the MIDI sound bank
++ * @ingroup midi
++ */
++typedef enum OMX_AUDIO_MIDISOUNDBANKTYPE {
++    OMX_AUDIO_MIDISoundBankUnused = 0,           /**< unused/unknown soundbank type */
++    OMX_AUDIO_MIDISoundBankDLS1,                 /**< DLS version 1 */
++    OMX_AUDIO_MIDISoundBankDLS2,                 /**< DLS version 2 */
++    OMX_AUDIO_MIDISoundBankMobileDLSBase,        /**< Mobile DLS, using the base functionality */
++    OMX_AUDIO_MIDISoundBankMobileDLSPlusOptions, /**< Mobile DLS, using the specification-defined optional feature set */
++    OMX_AUDIO_MIDISoundBankKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_AUDIO_MIDISoundBankVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_AUDIO_MIDISoundBankMax = 0x7FFFFFFF
++} OMX_AUDIO_MIDISOUNDBANKTYPE;
++
++
++/** Bank Layout describes how bank MSB & LSB are used in the DLS instrument definitions sound bank
++ * @ingroup midi
++ */
++typedef enum OMX_AUDIO_MIDISOUNDBANKLAYOUTTYPE {
++    OMX_AUDIO_MIDISoundBankLayoutUnused = 0,   /**< unused/unknown soundbank type */
++    OMX_AUDIO_MIDISoundBankLayoutGM,           /**< GS layout (based on bank MSB 0x00) */
++    OMX_AUDIO_MIDISoundBankLayoutGM2,          /**< General MIDI 2 layout (using MSB 0x78/0x79, LSB 0x00) */
++    OMX_AUDIO_MIDISoundBankLayoutUser,         /**< Does not conform to any bank numbering standards */
++    OMX_AUDIO_MIDISoundBankLayoutKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_AUDIO_MIDISoundBankLayoutVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_AUDIO_MIDISoundBankLayoutMax = 0x7FFFFFFF
++} OMX_AUDIO_MIDISOUNDBANKLAYOUTTYPE;
++
++
++/** MIDI params to load/unload user soundbank
++ * @ingroup midi
++ */
++typedef struct OMX_AUDIO_PARAM_MIDILOADUSERSOUNDTYPE {
++    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_U32 nDLSIndex;        /**< DLS file index to be loaded */
++    OMX_U32 nDLSSize;         /**< Size in bytes */
++    OMX_PTR pDLSData;         /**< Pointer to DLS file data */
++    OMX_AUDIO_MIDISOUNDBANKTYPE eMidiSoundBank;   /**< Midi sound bank type enumeration */
++    OMX_AUDIO_MIDISOUNDBANKLAYOUTTYPE eMidiSoundBankLayout; /**< Midi sound bank layout enumeration */
++} OMX_AUDIO_PARAM_MIDILOADUSERSOUNDTYPE;
++
++
++/** Structure for Live MIDI events and MIP messages.
++ * (MIP = Maximum Instantaneous Polyphony; part of the SP-MIDI standard.)
++ * @ingroup midi
++ */
++typedef struct OMX_AUDIO_CONFIG_MIDIIMMEDIATEEVENTTYPE {
++    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_U32 nMidiEventSize;   /**< Size of immediate MIDI events or MIP message in bytes  */
++    OMX_U8 nMidiEvents[1];    /**< MIDI event array to be rendered immediately, or an
++                                   array for the MIP message buffer, where the size is
++                                   indicated by nMidiEventSize */
++} OMX_AUDIO_CONFIG_MIDIIMMEDIATEEVENTTYPE;
++
++
++/** MIDI sound bank/ program pair in a given channel
++ * @ingroup midi
++ */
++typedef struct OMX_AUDIO_CONFIG_MIDISOUNDBANKPROGRAMTYPE {
++    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_U32 nChannel;           /**< Valid channel values range from 1 to 16 */
++    OMX_U16 nIDProgram;         /**< Valid program ID range is 1 to 128 */
++    OMX_U16 nIDSoundBank;       /**< Sound bank ID */
++    OMX_U32 nUserSoundBankIndex;/**< User soundbank index, easier to access soundbanks
++                                     by index if multiple banks are present */
++} OMX_AUDIO_CONFIG_MIDISOUNDBANKPROGRAMTYPE;
++
++
++/** MIDI control
++ * @ingroup midi
++ */
++typedef struct OMX_AUDIO_CONFIG_MIDICONTROLTYPE {
++    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_BS32 sPitchTransposition; /**< Pitch transposition in semitones, stored as Q22.10
++                                       format based on JAVA MMAPI (JSR-135) requirement */
++    OMX_BU32 sPlayBackRate;       /**< Relative playback rate, stored as Q14.17 fixed-point
++                                       number based on JSR-135 requirement */
++    OMX_BU32 sTempo ;             /**< Tempo in beats per minute (BPM), stored as Q22.10
++                                       fixed-point number based on JSR-135 requirement */
++    OMX_U32 nMaxPolyphony;        /**< Specifies the maximum simultaneous polyphonic
++                                       voices. A value of zero indicates that the default
++                                       polyphony of the device is used  */
++    OMX_U32 nNumRepeat;           /**< Number of times to repeat playback */
++    OMX_U32 nStopTime;            /**< Time in milliseconds to indicate when playback
++                                       will stop automatically.  Set to zero if not used */
++    OMX_U16 nChannelMuteMask;     /**< 16 bit mask for channel mute status */
++    OMX_U16 nChannelSoloMask;     /**< 16 bit mask for channel solo status */
++    OMX_U32 nTrack0031MuteMask;   /**< 32 bit mask for track mute status. Note: This is for tracks 0-31 */
++    OMX_U32 nTrack3263MuteMask;   /**< 32 bit mask for track mute status. Note: This is for tracks 32-63 */
++    OMX_U32 nTrack0031SoloMask;   /**< 32 bit mask for track solo status. Note: This is for tracks 0-31 */
++    OMX_U32 nTrack3263SoloMask;   /**< 32 bit mask for track solo status. Note: This is for tracks 32-63 */
++
++} OMX_AUDIO_CONFIG_MIDICONTROLTYPE;
++
++
++/** MIDI Playback States
++ * @ingroup midi
++ */
++typedef enum OMX_AUDIO_MIDIPLAYBACKSTATETYPE {
++    OMX_AUDIO_MIDIPlayBackStateUnknown = 0,      /**< Unknown state or state does not map to
++                                                    other defined states */
++    OMX_AUDIO_MIDIPlayBackStateClosedEngaged,    /**< No MIDI resource is currently open.
++                                                    The MIDI engine is currently processing
++                                                    MIDI events. */
++    OMX_AUDIO_MIDIPlayBackStateParsing,          /**< A MIDI resource is open and is being
++                                                    primed. The MIDI engine is currently
++                                                    processing MIDI events. */
++    OMX_AUDIO_MIDIPlayBackStateOpenEngaged,      /**< A MIDI resource is open and primed but
++                                                    not playing. The MIDI engine is currently
++                                                    processing MIDI events. The transition to
++                                                    this state is only possible from the
++                                                    OMX_AUDIO_MIDIPlayBackStatePlaying state,
++                                                    when the 'playback head' reaches the end
++                                                    of media data or the playback stops due
++                                                    to stop time set.*/
++    OMX_AUDIO_MIDIPlayBackStatePlaying,          /**< A MIDI resource is open and currently
++                                                    playing. The MIDI engine is currently
++                                                    processing MIDI events.*/
++    OMX_AUDIO_MIDIPlayBackStatePlayingPartially, /**< Best-effort playback due to SP-MIDI/DLS
++                                                    resource constraints */
++    OMX_AUDIO_MIDIPlayBackStatePlayingSilently,  /**< Due to system resource constraints and
++                                                    SP-MIDI content constraints, there is
++                                                    no audible MIDI content during playback
++                                                    currently. The situation may change if
++                                                    resources are freed later.*/
++    OMX_AUDIO_MIDIPlayBackStateKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_AUDIO_MIDIPlayBackStateVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_AUDIO_MIDIPlayBackStateMax = 0x7FFFFFFF
++} OMX_AUDIO_MIDIPLAYBACKSTATETYPE;
++
++
++/** MIDI status
++ * @ingroup midi
++ */
++typedef struct OMX_AUDIO_CONFIG_MIDISTATUSTYPE {
++    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_U16 nNumTracks;         /**< Number of MIDI tracks in the file, read only field.
++                                     NOTE: May not return a meaningful value until the entire
++                                     file is parsed and buffered.  */
++    OMX_U32 nDuration;          /**< The length of the currently open MIDI resource
++                                     in milliseconds. NOTE: May not return a meaningful value
++                                     until the entire file is parsed and buffered.  */
++    OMX_U32 nPosition;          /**< Current Position of the MIDI resource being played
++                                     in milliseconds */
++    OMX_BOOL bVibra;            /**< Does Vibra track exist? NOTE: May not return a meaningful
++                                     value until the entire file is parsed and buffered. */
++    OMX_U32 nNumMetaEvents;     /**< Total number of MIDI Meta Events in the currently
++                                     open MIDI resource. NOTE: May not return a meaningful value
++                                     until the entire file is parsed and buffered.  */
++    OMX_U32 nNumActiveVoices;   /**< Number of active voices in the currently playing
++                                     MIDI resource. NOTE: May not return a meaningful value until
++                                     the entire file is parsed and buffered. */
++    OMX_AUDIO_MIDIPLAYBACKSTATETYPE eMIDIPlayBackState;  /**< MIDI playback state enumeration, read only field */
++} OMX_AUDIO_CONFIG_MIDISTATUSTYPE;
++
++
++/** MIDI Meta Event structure one per Meta Event.
++ *  MIDI Meta Events are like audio metadata, except that they are interspersed
++ *  with the MIDI content throughout the file and are not localized in the header.
++ *  As such, it is necessary to retrieve information about these Meta Events from
++ *  the engine, as it encounters these Meta Events within the MIDI content.
++ *  For example, SMF files can have up to 14 types of MIDI Meta Events (copyright,
++ *  author, default tempo, etc.) scattered throughout the file.
++ *  @ingroup midi
++ */
++typedef struct OMX_AUDIO_CONFIG_MIDIMETAEVENTTYPE {
++    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_U32 nIndex;           /**< Index of Meta Event */
++    OMX_U8 nMetaEventType;    /**< Meta Event Type, 7bits (i.e. 0 - 127) */
++    OMX_U32 nMetaEventSize;   /**< size of the Meta Event in bytes */
++    OMX_U32 nTrack;           /**< track number for the meta event */
++    OMX_U32 nPosition;        /**< Position of the meta-event in milliseconds */
++} OMX_AUDIO_CONFIG_MIDIMETAEVENTTYPE;
++
++
++/** MIDI Meta Event Data structure - one per Meta Event.
++ * @ingroup midi
++ */
++typedef struct OMX_AUDIO_CONFIG_MIDIMETAEVENTDATATYPE {
++    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_U32 nIndex;           /**< Index of Meta Event */
++    OMX_U32 nMetaEventSize;   /**< size of the Meta Event in bytes */
++    OMX_U8 nData[1];          /**< array of one or more bytes of meta data
++                                   as indicated by the nMetaEventSize field */
++} OMX_AUDIO_CONFIG__MIDIMETAEVENTDATATYPE;
++
++
++/** Audio Volume adjustment for a port */
++typedef struct OMX_AUDIO_CONFIG_VOLUMETYPE {
++    OMX_U32 nSize;              /**< size of the structure in bytes */
++    OMX_VERSIONTYPE nVersion;   /**< OMX specification version information */
++    OMX_U32 nPortIndex;         /**< Port index indicating which port to
++                                     set.  Select the input port to set
++                                     just that port's volume.  Select the
++                                     output port to adjust the master
++                                     volume. */
++    OMX_BOOL bLinear;           /**< Is the volume to be set in linear (0.100)
++                                     or logarithmic scale (mB) */
++    OMX_BS32 sVolume;           /**< Volume linear setting in the 0..100 range, OR
++                                     Volume logarithmic setting for this port.  The values
++                                     for volume are in mB (millibels = 1/100 dB) relative
++                                     to a gain of 1 (e.g. the output is the same as the
++                                     input level).  Values are in mB from nMax
++                                     (maximum volume) to nMin mB (typically negative).
++                                     Since the volume is "voltage"
++                                     and not a "power", it takes a setting of
++                                     -600 mB to decrease the volume by 1/2.  If
++                                     a component cannot accurately set the
++                                     volume to the requested value, it must
++                                     set the volume to the closest value BELOW
++                                     the requested value.  When getting the
++                                     volume setting, the current actual volume
++                                     must be returned. */
++} OMX_AUDIO_CONFIG_VOLUMETYPE;
++
++
++/** Audio Volume adjustment for a channel */
++typedef struct OMX_AUDIO_CONFIG_CHANNELVOLUMETYPE {
++    OMX_U32 nSize;              /**< size of the structure in bytes */
++    OMX_VERSIONTYPE nVersion;   /**< OMX specification version information */
++    OMX_U32 nPortIndex;         /**< Port index indicating which port to
++                                     set.  Select the input port to set
++                                     just that port's volume.  Select the
++                                     output port to adjust the master
++                                     volume. */
++    OMX_U32 nChannel;           /**< channel to select from 0 to N-1,
++                                     using OMX_ALL to apply volume settings
++                                     to all channels */
++    OMX_BOOL bLinear;           /**< Is the volume to be set in linear (0.100) or
++                                     logarithmic scale (mB) */
++    OMX_BS32 sVolume;           /**< Volume linear setting in the 0..100 range, OR
++                                     Volume logarithmic setting for this port.
++                                     The values for volume are in mB
++                                     (millibels = 1/100 dB) relative to a gain
++                                     of 1 (e.g. the output is the same as the
++                                     input level).  Values are in mB from nMax
++                                     (maximum volume) to nMin mB (typically negative).
++                                     Since the volume is "voltage"
++                                     and not a "power", it takes a setting of
++                                     -600 mB to decrease the volume by 1/2.  If
++                                     a component cannot accurately set the
++                                     volume to the requested value, it must
++                                     set the volume to the closest value BELOW
++                                     the requested value.  When getting the
++                                     volume setting, the current actual volume
++                                     must be returned. */
++    OMX_BOOL bIsMIDI;           /**< TRUE if nChannel refers to a MIDI channel,
++                                     FALSE otherwise */
++} OMX_AUDIO_CONFIG_CHANNELVOLUMETYPE;
++
++
++/** Audio balance setting */
++typedef struct OMX_AUDIO_CONFIG_BALANCETYPE {
++    OMX_U32 nSize;              /**< size of the structure in bytes */
++    OMX_VERSIONTYPE nVersion;   /**< OMX specification version information */
++    OMX_U32 nPortIndex;         /**< Port index indicating which port to
++                                     set.  Select the input port to set
++                                     just that port's balance.  Select the
++                                     output port to adjust the master
++                                     balance. */
++    OMX_S32 nBalance;           /**< balance setting for this port
++                                     (-100 to 100, where -100 indicates
++                                     all left, and no right */
++} OMX_AUDIO_CONFIG_BALANCETYPE;
++
++
++/** Audio Port mute */
++typedef struct OMX_AUDIO_CONFIG_MUTETYPE {
++    OMX_U32 nSize;              /**< size of the structure in bytes */
++    OMX_VERSIONTYPE nVersion;   /**< OMX specification version information */
++    OMX_U32 nPortIndex;         /**< Port index indicating which port to
++                                     set.  Select the input port to set
++                                     just that port's mute.  Select the
++                                     output port to adjust the master
++                                     mute. */
++    OMX_BOOL bMute;             /**< Mute setting for this port */
++} OMX_AUDIO_CONFIG_MUTETYPE;
++
++
++/** Audio Channel mute */
++typedef struct OMX_AUDIO_CONFIG_CHANNELMUTETYPE {
++    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_U32 nChannel;           /**< channel to select from 0 to N-1,
++                                     using OMX_ALL to apply mute settings
++                                     to all channels */
++    OMX_BOOL bMute;             /**< Mute setting for this channel */
++    OMX_BOOL bIsMIDI;           /**< TRUE if nChannel refers to a MIDI channel,
++                                     FALSE otherwise */
++} OMX_AUDIO_CONFIG_CHANNELMUTETYPE;
++
++
++
++/** Enable / Disable for loudness control, which boosts bass and to a
++ *  smaller extent high end frequencies to compensate for hearing
++ *  ability at the extreme ends of the audio spectrum
++ */
++typedef struct OMX_AUDIO_CONFIG_LOUDNESSTYPE {
++    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_BOOL bLoudness;        /**< Enable/disable for loudness */
++} OMX_AUDIO_CONFIG_LOUDNESSTYPE;
++
++
++/** Enable / Disable for bass, which controls low frequencies
++ */
++typedef struct OMX_AUDIO_CONFIG_BASSTYPE {
++    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_BOOL bEnable;          /**< Enable/disable for bass control */
++    OMX_S32 nBass;             /**< bass setting for the port, as a
++                                    continuous value from -100 to 100
++                                    (0 means no change in bass level)*/
++} OMX_AUDIO_CONFIG_BASSTYPE;
++
++
++/** Enable / Disable for treble, which controls high frequencies tones
++ */
++typedef struct OMX_AUDIO_CONFIG_TREBLETYPE {
++    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_BOOL bEnable;          /**< Enable/disable for treble control */
++    OMX_S32  nTreble;          /**< treble setting for the port, as a
++                                    continuous value from -100 to 100
++                                    (0 means no change in treble level) */
++} OMX_AUDIO_CONFIG_TREBLETYPE;
++
++
++/** An equalizer is typically used for two reasons: to compensate for an
++ *  sub-optimal frequency response of a system to make it sound more natural
++ *  or to create intentionally some unnatural coloring to the sound to create
++ *  an effect.
++ *  @ingroup effects
++ */
++typedef struct OMX_AUDIO_CONFIG_EQUALIZERTYPE {
++    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_BOOL bEnable;          /**< Enable/disable for equalizer */
++    OMX_BU32 sBandIndex;       /**< Band number to be set.  Upper Limit is
++                                    N-1, where N is the number of bands, lower limit is 0 */
++    OMX_BU32 sCenterFreq;      /**< Center frequecies in Hz.  This is a
++                                    read only element and is used to determine
++                                    the lower, center and upper frequency of
++                                    this band.  */
++    OMX_BS32 sBandLevel;       /**< band level in millibels */
++} OMX_AUDIO_CONFIG_EQUALIZERTYPE;
++
++
++/** Stereo widening mode type
++ * @ingroup effects
++ */
++typedef enum OMX_AUDIO_STEREOWIDENINGTYPE {
++    OMX_AUDIO_StereoWideningHeadphones,    /**< Stereo widening for loudspeakers */
++    OMX_AUDIO_StereoWideningLoudspeakers,  /**< Stereo widening for closely spaced loudspeakers */
++    OMX_AUDIO_StereoWideningKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_AUDIO_StereoWideningVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_AUDIO_StereoWideningMax = 0x7FFFFFFF
++} OMX_AUDIO_STEREOWIDENINGTYPE;
++
++
++/** Control for stereo widening, which is a special 2-channel
++ *  case of the audio virtualizer effect. For example, for 5.1-channel
++ *  output, it translates to virtual surround sound.
++ * @ingroup effects
++ */
++typedef struct OMX_AUDIO_CONFIG_STEREOWIDENINGTYPE {
++    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_BOOL bEnable;          /**< Enable/disable for stereo widening control */
++    OMX_AUDIO_STEREOWIDENINGTYPE eWideningType; /**< Stereo widening algorithm type */
++    OMX_U32  nStereoWidening;  /**< stereo widening setting for the port,
++                                    as a continuous value from 0 to 100  */
++} OMX_AUDIO_CONFIG_STEREOWIDENINGTYPE;
++
++
++/** The chorus effect (or ``choralizer'') is any signal processor which makes
++ *  one sound source (such as a voice) sound like many such sources singing
++ *  (or playing) in unison. Since performance in unison is never exact, chorus
++ *  effects simulate this by making independently modified copies of the input
++ *  signal. Modifications may include (1) delay, (2) frequency shift, and
++ *  (3) amplitude modulation.
++ * @ingroup effects
++ */
++typedef struct OMX_AUDIO_CONFIG_CHORUSTYPE {
++    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_BOOL bEnable;          /**< Enable/disable for chorus */
++    OMX_BU32 sDelay;           /**< average delay in milliseconds */
++    OMX_BU32 sModulationRate;  /**< rate of modulation in millihertz */
++    OMX_U32 nModulationDepth;  /**< depth of modulation as a percentage of
++                                    delay (i.e. 0 to 100) */
++    OMX_BU32 nFeedback;        /**< Feedback from chorus output to input in percentage */
++} OMX_AUDIO_CONFIG_CHORUSTYPE;
++
++
++/** Reverberation is part of the reflected sound that follows the early
++ *  reflections. In a typical room, this consists of a dense succession of
++ *  echoes whose energy decays exponentially. The reverberation effect structure
++ *  as defined here includes both (early) reflections as well as (late) reverberations.
++ * @ingroup effects
++ */
++typedef struct OMX_AUDIO_CONFIG_REVERBERATIONTYPE {
++    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_BOOL bEnable;             /**< Enable/disable for reverberation control */
++    OMX_BS32 sRoomLevel;          /**< Intensity level for the whole room effect
++                                       (i.e. both early reflections and late
++                                       reverberation) in millibels */
++    OMX_BS32 sRoomHighFreqLevel;  /**< Attenuation at high frequencies
++                                       relative to the intensity at low
++                                       frequencies in millibels */
++    OMX_BS32 sReflectionsLevel;   /**< Intensity level of early reflections
++                                       (relative to room value), in millibels */
++    OMX_BU32 sReflectionsDelay;   /**< Delay time of the first reflection relative
++                                       to the direct path, in milliseconds */
++    OMX_BS32 sReverbLevel;        /**< Intensity level of late reverberation
++                                       relative to room level, in millibels */
++    OMX_BU32 sReverbDelay;        /**< Time delay from the first early reflection
++                                       to the beginning of the late reverberation
++                                       section, in milliseconds */
++    OMX_BU32 sDecayTime;          /**< Late reverberation decay time at low
++                                       frequencies, in milliseconds */
++    OMX_BU32 nDecayHighFreqRatio; /**< Ratio of high frequency decay time relative
++                                       to low frequency decay time in percent  */
++    OMX_U32 nDensity;             /**< Modal density in the late reverberation decay,
++                                       in percent (i.e. 0 - 100) */
++    OMX_U32 nDiffusion;           /**< Echo density in the late reverberation decay,
++                                       in percent (i.e. 0 - 100) */
++    OMX_BU32 sReferenceHighFreq;  /**< Reference high frequency in Hertz. This is
++                                       the frequency used as the reference for all
++                                       the high-frequency settings above */
++
++} OMX_AUDIO_CONFIG_REVERBERATIONTYPE;
++
++
++/** Possible settings for the Echo Cancelation structure to use
++ * @ingroup effects
++ */
++typedef enum OMX_AUDIO_ECHOCANTYPE {
++    OMX_AUDIO_EchoCanOff = 0,    /**< Echo Cancellation is disabled */
++    OMX_AUDIO_EchoCanNormal,     /**< Echo Cancellation normal operation -
++                                     echo from plastics and face */
++    OMX_AUDIO_EchoCanHFree,      /**< Echo Cancellation optimized for
++                                     Hands Free operation */
++    OMX_AUDIO_EchoCanCarKit,    /**< Echo Cancellation optimized for
++                                     Car Kit (longer echo) */
++    OMX_AUDIO_EchoCanKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_AUDIO_EchoCanVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_AUDIO_EchoCanMax = 0x7FFFFFFF
++} OMX_AUDIO_ECHOCANTYPE;
++
++
++/** Enable / Disable for echo cancelation, which removes undesired echo's
++ *  from the audio
++ * @ingroup effects
++ */
++typedef struct OMX_AUDIO_CONFIG_ECHOCANCELATIONTYPE {
++    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_AUDIO_ECHOCANTYPE eEchoCancelation; /**< Echo cancelation settings */
++} OMX_AUDIO_CONFIG_ECHOCANCELATIONTYPE;
++
++
++/** Enable / Disable for noise reduction, which undesired noise from
++ * the audio
++ * @ingroup effects
++ */
++typedef struct OMX_AUDIO_CONFIG_NOISEREDUCTIONTYPE {
++    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_BOOL bNoiseReduction;  /**< Enable/disable for noise reduction */
++} OMX_AUDIO_CONFIG_NOISEREDUCTIONTYPE;
++
++/** @} */
++
++#ifdef __cplusplus
++}
++#endif /* __cplusplus */
++
++#endif
++/* File EOF */
++
+diff --git a/sf-extra/omx-il/OMX_Component.h b/sf-extra/omx-il/OMX_Component.h
+new file mode 100644
+index 00000000..56fd37e9
+--- /dev/null
++++ b/sf-extra/omx-il/OMX_Component.h
+@@ -0,0 +1,569 @@
++/*
++ * Copyright (c) 2008 The Khronos Group Inc.
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining
++ * a copy of this software and associated documentation files (the
++ * "Software"), to deal in the Software without restriction, including
++ * without limitation the rights to use, copy, modify, merge, publish,
++ * distribute, sublicense, and/or sell copies of the Software, and to
++ * permit persons to whom the Software is furnished to do so, subject
++ * to the following conditions:
++ * The above copyright notice and this permission notice shall be included
++ * in all copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
++ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
++ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
++ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
++ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
++ *
++ */
++
++/** OMX_Component.h - OpenMax IL version 1.1.2
++ *  The OMX_Component header file contains the definitions used to define
++ *  the public interface of a component.  This header file is intended to
++ *  be used by both the application and the component.
++ */
++
++#ifndef OMX_Component_h
++#define OMX_Component_h
++
++#ifdef __cplusplus
++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
++ */
++
++#include <OMX_Audio.h>
++#include <OMX_Video.h>
++#include <OMX_Image.h>
++#include <OMX_Other.h>
++
++/** @ingroup comp */
++typedef enum OMX_PORTDOMAINTYPE {
++    OMX_PortDomainAudio,
++    OMX_PortDomainVideo,
++    OMX_PortDomainImage,
++    OMX_PortDomainOther,
++    OMX_PortDomainKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_PortDomainVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_PortDomainMax = 0x7ffffff
++} OMX_PORTDOMAINTYPE;
++
++/** @ingroup comp */
++typedef struct OMX_PARAM_PORTDEFINITIONTYPE {
++    OMX_U32 nSize;                 /**< Size of the structure in bytes */
++    OMX_VERSIONTYPE nVersion;      /**< OMX specification version information */
++    OMX_U32 nPortIndex;            /**< Port number the structure applies to */
++    OMX_DIRTYPE eDir;              /**< Direction (input or output) of this port */
++    OMX_U32 nBufferCountActual;    /**< The actual number of buffers allocated on this port */
++    OMX_U32 nBufferCountMin;       /**< The minimum number of buffers this port requires */
++    OMX_U32 nBufferSize;           /**< Size, in bytes, for buffers to be used for this channel */
++    OMX_BOOL bEnabled;             /**< Ports default to enabled and are enabled/disabled by
++                                        OMX_CommandPortEnable/OMX_CommandPortDisable.
++                                        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.
++                                        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. */
++    union {
++        OMX_AUDIO_PORTDEFINITIONTYPE audio;
++        OMX_VIDEO_PORTDEFINITIONTYPE video;
++        OMX_IMAGE_PORTDEFINITIONTYPE image;
++        OMX_OTHER_PORTDEFINITIONTYPE other;
++    } format;
++    OMX_BOOL bBuffersContiguous;
++    OMX_U32 nBufferAlignment;
++} 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 */
++    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_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_SUSPENSIONPOLICYTYPE ePolicy;
++} OMX_PARAM_SUSPENSIONPOLICYTYPE;
++
++/** @ingroup rpm */
++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_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_PARAM_SUSPENSIONTYPE ;
++
++typedef struct OMX_CONFIG_BOOLEANTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_BOOL bEnabled;
++} OMX_CONFIG_BOOLEANTYPE;
++
++/* Parameter specifying the content uri to use. */
++/** @ingroup cp */
++typedef struct OMX_PARAM_CONTENTURITYPE {
++    OMX_U32 nSize;                      /**< size of the structure in bytes, including
++                                             actual URI name */
++    OMX_VERSIONTYPE nVersion;           /**< OMX specification version information */
++    OMX_U8 contentURI[1];               /**< The URI name */
++} OMX_PARAM_CONTENTURITYPE;
++
++/* Parameter specifying the pipe to use. */
++/** @ingroup cp */
++typedef struct OMX_PARAM_CONTENTPIPETYPE {
++    OMX_U32 nSize;              /**< size of the structure in bytes */
++    OMX_VERSIONTYPE nVersion;   /**< OMX specification version information */
++    OMX_HANDLETYPE hPipe;       /**< The pipe handle*/
++} OMX_PARAM_CONTENTPIPETYPE;
++
++/** @ingroup rpm */
++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)
++                                            on a component as a resolution to resource conflicts. */
++} OMX_RESOURCECONCEALMENTTYPE;
++
++
++/** @ingroup metadata */
++typedef enum OMX_METADATACHARSETTYPE {
++    OMX_MetadataCharsetUnknown = 0,
++    OMX_MetadataCharsetASCII,
++    OMX_MetadataCharsetBinary,
++    OMX_MetadataCharsetCodePage1252,
++    OMX_MetadataCharsetUTF8,
++    OMX_MetadataCharsetJavaConformantUTF8,
++    OMX_MetadataCharsetUTF7,
++    OMX_MetadataCharsetImapUTF7,
++    OMX_MetadataCharsetUTF16LE,
++    OMX_MetadataCharsetUTF16BE,
++    OMX_MetadataCharsetGB12345,
++    OMX_MetadataCharsetHZGB2312,
++    OMX_MetadataCharsetGB2312,
++    OMX_MetadataCharsetGB18030,
++    OMX_MetadataCharsetGBK,
++    OMX_MetadataCharsetBig5,
++    OMX_MetadataCharsetISO88591,
++    OMX_MetadataCharsetISO88592,
++    OMX_MetadataCharsetISO88593,
++    OMX_MetadataCharsetISO88594,
++    OMX_MetadataCharsetISO88595,
++    OMX_MetadataCharsetISO88596,
++    OMX_MetadataCharsetISO88597,
++    OMX_MetadataCharsetISO88598,
++    OMX_MetadataCharsetISO88599,
++    OMX_MetadataCharsetISO885910,
++    OMX_MetadataCharsetISO885913,
++    OMX_MetadataCharsetISO885914,
++    OMX_MetadataCharsetISO885915,
++    OMX_MetadataCharsetShiftJIS,
++    OMX_MetadataCharsetISO2022JP,
++    OMX_MetadataCharsetISO2022JP1,
++    OMX_MetadataCharsetISOEUCJP,
++    OMX_MetadataCharsetSMS7Bit,
++    OMX_MetadataCharsetKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_MetadataCharsetVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_MetadataCharsetTypeMax = 0x7FFFFFFF
++} OMX_METADATACHARSETTYPE;
++
++/** @ingroup metadata */
++typedef enum OMX_METADATASCOPETYPE {
++    OMX_MetadataScopeAllLevels,
++    OMX_MetadataScopeTopLevel,
++    OMX_MetadataScopePortLevel,
++    OMX_MetadataScopeNodeLevel,
++    OMX_MetadataScopeKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_MetadataScopeVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_MetadataScopeTypeMax = 0x7fffffff
++} OMX_METADATASCOPETYPE;
++
++/** @ingroup metadata */
++typedef enum OMX_METADATASEARCHMODETYPE {
++    OMX_MetadataSearchValueSizeByIndex,
++    OMX_MetadataSearchItemByIndex,
++    OMX_MetadataSearchNextItemByKey,
++    OMX_MetadataSearchKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_MetadataSearchVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_MetadataSearchTypeMax = 0x7fffffff
++} OMX_METADATASEARCHMODETYPE;
++/** @ingroup metadata */
++typedef struct OMX_CONFIG_METADATAITEMCOUNTTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_METADATASCOPETYPE eScopeMode;
++    OMX_U32 nScopeSpecifier;
++    OMX_U32 nMetadataItemCount;
++} OMX_CONFIG_METADATAITEMCOUNTTYPE;
++
++/** @ingroup metadata */
++typedef struct OMX_CONFIG_METADATAITEMTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_METADATASCOPETYPE eScopeMode;
++    OMX_U32 nScopeSpecifier;
++    OMX_U32 nMetadataItemIndex;
++    OMX_METADATASEARCHMODETYPE eSearchMode;
++    OMX_METADATACHARSETTYPE eKeyCharset;
++    OMX_U8 nKeySizeUsed;
++    OMX_U8 nKey[128];
++    OMX_METADATACHARSETTYPE eValueCharset;
++    OMX_STRING sLanguageCountry;
++    OMX_U32 nValueMaxSize;
++    OMX_U32 nValueSizeUsed;
++    OMX_U8 nValue[1];
++} OMX_CONFIG_METADATAITEMTYPE;
++
++/* @ingroup metadata */
++typedef struct OMX_CONFIG_CONTAINERNODECOUNTTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_BOOL bAllKeys;
++    OMX_U32 nParentNodeID;
++    OMX_U32 nNumNodes;
++} OMX_CONFIG_CONTAINERNODECOUNTTYPE;
++
++/** @ingroup metadata */
++typedef struct OMX_CONFIG_CONTAINERNODEIDTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_BOOL bAllKeys;
++    OMX_U32 nParentNodeID;
++    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
++                         * the three key fields below are ignored */
++    OMX_METADATACHARSETTYPE eKeyCharset;
++    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.
++                         * retained for query later). If false then
++                         * key is not part of filter */
++} OMX_PARAM_METADATAFILTERTYPE;
++
++/** The OMX_HANDLETYPE structure defines the component handle.  The component
++ *  handle is used to access all of the component's public methods and also
++ *  contains pointers to the component's private data area.  The component
++ *  handle is initialized by the OMX core (with help from the component)
++ *  during the process of loading the component.  After the component is
++ *  successfully loaded, the application can safely access any of the
++ *  component's public functions (although some may return an error because
++ *  the state is inappropriate for the access).
++ *
++ *  @ingroup comp
++ */
++typedef struct OMX_COMPONENTTYPE {
++    /** The size of this structure, in bytes.  It is the responsibility
++        of the allocator of this structure to fill in this value.  Since
++        this structure is allocated by the GetHandle function, this
++        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
++        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
++        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
++        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
++        specification for details on the GetComponentVersion method.
++     */
++    OMX_ERRORTYPE (*GetComponentVersion)(
++        OMX_IN  OMX_HANDLETYPE hComponent,
++        OMX_OUT OMX_STRING pComponentName,
++        OMX_OUT OMX_VERSIONTYPE* pComponentVersion,
++        OMX_OUT OMX_VERSIONTYPE* pSpecVersion,
++        OMX_OUT OMX_UUIDTYPE* pComponentUUID);
++
++    /** refer to OMX_SendCommand in OMX_core.h or the OMX IL
++        specification for details on the SendCommand method.
++     */
++    OMX_ERRORTYPE (*SendCommand)(
++        OMX_IN  OMX_HANDLETYPE hComponent,
++        OMX_IN  OMX_COMMANDTYPE Cmd,
++        OMX_IN  OMX_U32 nParam1,
++        OMX_IN  OMX_PTR pCmdData);
++
++    /** 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_INOUT OMX_PTR pComponentParameterStructure);
++
++
++    /** 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_INDEXTYPE nIndex,
++        OMX_IN  OMX_PTR pComponentParameterStructure);
++
++
++    /** 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_INOUT OMX_PTR pComponentConfigStructure);
++
++
++    /** 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_PTR pComponentConfigStructure);
++
++
++    /** refer to OMX_GetExtensionIndex in OMX_core.h or the OMX IL
++        specification for details on the GetExtensionIndex method.
++     */
++    OMX_ERRORTYPE (*GetExtensionIndex)(
++        OMX_IN  OMX_HANDLETYPE hComponent,
++        OMX_IN  OMX_STRING cParameterName,
++        OMX_OUT OMX_INDEXTYPE* pIndexType);
++
++
++    /** 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
++        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
++
++        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.
++
++        When this method is invoked when nPort in an output port, the
++        component will:
++        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
++            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.
++        @param [in] nPort
++            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 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.
++        @param [in] nPortOutput
++            nPortOutput is used indicate the port the component should
++            tunnel with.
++        @param [in] pTunnelSetup
++            Pointer to the tunnel setup structure.  When nPort is an output port
++            the component should populate the fields of this structure.  When
++            When nPort is an input port the component should review the setup
++            provided by the component with the output port.
++        @return OMX_ERRORTYPE
++            If the command successfully executes, the return code will be
++            OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
++        @ingroup tun
++    */
++
++    OMX_ERRORTYPE (*ComponentTunnelRequest)(
++        OMX_IN  OMX_HANDLETYPE hComp,
++        OMX_IN  OMX_U32 nPort,
++        OMX_IN  OMX_HANDLETYPE hTunneledComp,
++        OMX_IN  OMX_U32 nTunneledPort,
++        OMX_INOUT  OMX_TUNNELSETUPTYPE* pTunnelSetup);
++
++    /** refer to OMX_UseBuffer in OMX_core.h or the OMX IL
++        specification for details on the UseBuffer method.
++        @ingroup buf
++     */
++    OMX_ERRORTYPE (*UseBuffer)(
++        OMX_IN OMX_HANDLETYPE hComponent,
++        OMX_INOUT OMX_BUFFERHEADERTYPE** ppBufferHdr,
++        OMX_IN OMX_U32 nPortIndex,
++        OMX_IN OMX_PTR pAppPrivate,
++        OMX_IN OMX_U32 nSizeBytes,
++        OMX_IN OMX_U8* pBuffer);
++
++    /** refer to OMX_AllocateBuffer in OMX_core.h or the OMX IL
++        specification for details on the AllocateBuffer method.
++        @ingroup buf
++     */
++    OMX_ERRORTYPE (*AllocateBuffer)(
++        OMX_IN OMX_HANDLETYPE hComponent,
++        OMX_INOUT OMX_BUFFERHEADERTYPE** ppBuffer,
++        OMX_IN OMX_U32 nPortIndex,
++        OMX_IN OMX_PTR pAppPrivate,
++        OMX_IN OMX_U32 nSizeBytes);
++
++    /** refer to OMX_FreeBuffer in OMX_core.h or the OMX IL
++        specification for details on the FreeBuffer method.
++        @ingroup buf
++     */
++    OMX_ERRORTYPE (*FreeBuffer)(
++        OMX_IN  OMX_HANDLETYPE hComponent,
++        OMX_IN  OMX_U32 nPortIndex,
++        OMX_IN  OMX_BUFFERHEADERTYPE* pBuffer);
++
++    /** refer to OMX_EmptyThisBuffer in OMX_core.h or the OMX IL
++        specification for details on the EmptyThisBuffer method.
++        @ingroup buf
++     */
++    OMX_ERRORTYPE (*EmptyThisBuffer)(
++        OMX_IN  OMX_HANDLETYPE hComponent,
++        OMX_IN  OMX_BUFFERHEADERTYPE* pBuffer);
++
++    /** refer to OMX_FillThisBuffer in OMX_core.h or the OMX IL
++        specification for details on the FillThisBuffer method.
++        @ingroup buf
++     */
++    OMX_ERRORTYPE (*FillThisBuffer)(
++        OMX_IN  OMX_HANDLETYPE hComponent,
++        OMX_IN  OMX_BUFFERHEADERTYPE* pBuffer);
++
++    /** The SetCallbacks method is used by the core to specify the callback
++        structure from the application to the component.  This is a blocking
++        call.  The component will return from this call within 5 msec.
++        @param [in] hComponent
++            Handle of the component to be accessed.  This is the component
++            handle returned by the call to the GetHandle function.
++        @param [in] pCallbacks
++            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
++            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
++        @return OMX_ERRORTYPE
++            If the command successfully executes, the return code will be
++            OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
++     */
++    OMX_ERRORTYPE (*SetCallbacks)(
++        OMX_IN  OMX_HANDLETYPE hComponent,
++        OMX_IN  OMX_CALLBACKTYPE* pCallbacks,
++        OMX_IN  OMX_PTR pAppData);
++
++    /** ComponentDeInit method is used to deinitialize the component
++        providing a means to free any resources allocated at component
++        initialization.  NOTE:  After this call the component handle is
++        not valid for further use.
++        @param [in] hComponent
++            Handle of the component to be accessed.  This is the component
++            handle returned by the call to the GetHandle function.
++        @return OMX_ERRORTYPE
++            If the command successfully executes, the return code will be
++            OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
++     */
++    OMX_ERRORTYPE (*ComponentDeInit)(
++        OMX_IN  OMX_HANDLETYPE hComponent);
++
++    /** @ingroup buf */
++    OMX_ERRORTYPE (*UseEGLImage)(
++        OMX_IN OMX_HANDLETYPE hComponent,
++        OMX_INOUT OMX_BUFFERHEADERTYPE** ppBufferHdr,
++        OMX_IN OMX_U32 nPortIndex,
++        OMX_IN OMX_PTR pAppPrivate,
++        OMX_IN void* eglImage);
++
++    OMX_ERRORTYPE (*ComponentRoleEnum)(
++        OMX_IN OMX_HANDLETYPE hComponent,
++        OMX_OUT OMX_U8 *cRole,
++        OMX_IN OMX_U32 nIndex);
++
++} OMX_COMPONENTTYPE;
++
++#ifdef __cplusplus
++}
++#endif /* __cplusplus */
++
++#endif
++/* File EOF */
+diff --git a/sf-extra/omx-il/OMX_ComponentExt.h b/sf-extra/omx-il/OMX_ComponentExt.h
+new file mode 100644
+index 00000000..24ec20c5
+--- /dev/null
++++ b/sf-extra/omx-il/OMX_ComponentExt.h
+@@ -0,0 +1,61 @@
++/*
++ * Copyright (c) 2016 The Khronos Group Inc.
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining
++ * a copy of this software and associated documentation files (the
++ * "Software"), to deal in the Software without restriction, including
++ * without limitation the rights to use, copy, modify, merge, publish,
++ * distribute, sublicense, and/or sell copies of the Software, and to
++ * permit persons to whom the Software is furnished to do so, subject
++ * to the following conditions:
++ * The above copyright notice and this permission notice shall be included
++ * in all copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
++ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
++ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
++ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
++ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
++ *
++ */
++
++/** OMX_ComponentExt.h - OpenMax IL version 1.1.2
++ * The OMX_ComponentExt header file contains extensions to the definitions used
++ * by both the application and the component to access common items.
++ */
++
++#ifndef OMX_ComponentExt_h
++#define OMX_ComponentExt_h
++
++#ifdef __cplusplus
++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 
++ */
++#include <OMX_Types.h>
++
++
++/** Set/query the commit mode */
++typedef struct OMX_CONFIG_COMMITMODETYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_BOOL bDeferred;
++} OMX_CONFIG_COMMITMODETYPE;
++
++/** Explicit commit */
++typedef struct OMX_CONFIG_COMMITTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++} OMX_CONFIG_COMMITTYPE;
++
++
++#ifdef __cplusplus
++}
++#endif /* __cplusplus */
++
++#endif /* OMX_ComponentExt_h */
+diff --git a/sf-extra/omx-il/OMX_ContentPipe.h b/sf-extra/omx-il/OMX_ContentPipe.h
+new file mode 100644
+index 00000000..843cb7a4
+--- /dev/null
++++ b/sf-extra/omx-il/OMX_ContentPipe.h
+@@ -0,0 +1,193 @@
++/*
++ * Copyright (c) 2008 The Khronos Group Inc.
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining
++ * a copy of this software and associated documentation files (the
++ * "Software"), to deal in the Software without restriction, including
++ * without limitation the rights to use, copy, modify, merge, publish,
++ * distribute, sublicense, and/or sell copies of the Software, and to
++ * permit persons to whom the Software is furnished to do so, subject
++ * to the following conditions:
++ * The above copyright notice and this permission notice shall be included
++ * in all copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
++ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
++ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
++ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
++ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
++ *
++ */
++
++/** OMX_ContentPipe.h - OpenMax IL version 1.1.2
++ *  The OMX_ContentPipe header file contains the definitions used to define
++ *  the public interface for content piples.  This header file is intended to
++ *  be used by the component.
++ */
++
++#ifndef OMX_CONTENTPIPE_H
++#define OMX_CONTENTPIPE_H
++
++#ifndef KD_EACCES
++/* OpenKODE error codes. CPResult values may be zero (indicating success
++   or one of the following values) */
++#define KD_EACCES (1)
++#define KD_EADDRINUSE (2)
++#define KD_EAGAIN (5)
++#define KD_EBADF (7)
++#define KD_EBUSY (8)
++#define KD_ECONNREFUSED (9)
++#define KD_ECONNRESET (10)
++#define KD_EDEADLK (11)
++#define KD_EDESTADDRREQ (12)
++#define KD_ERANGE (35)
++#define KD_EEXIST (13)
++#define KD_EFBIG (14)
++#define KD_EHOSTUNREACH (15)
++#define KD_EINVAL (17)
++#define KD_EIO (18)
++#define KD_EISCONN (20)
++#define KD_EISDIR (21)
++#define KD_EMFILE (22)
++#define KD_ENAMETOOLONG (23)
++#define KD_ENOENT (24)
++#define KD_ENOMEM (25)
++#define KD_ENOSPC (26)
++#define KD_ENOSYS (27)
++#define KD_ENOTCONN (28)
++#define KD_EPERM (33)
++#define KD_ETIMEDOUT (36)
++#define KD_EILSEQ (19)
++#endif
++
++/** Map types from OMX standard types only here so interface is as generic as possible. */
++typedef OMX_U32    CPresult;
++typedef char *     CPstring;
++typedef void *     CPhandle;
++typedef OMX_U32    CPuint;
++typedef OMX_S32    CPint;
++typedef char       CPbyte;
++typedef OMX_BOOL   CPbool;
++
++/** 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_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
++ * @ingroup cp
++ */
++typedef enum CP_ACCESSTYPE {
++    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
++ * @ingroup cp
++ */
++typedef enum CP_CHECKBYTESRESULTTYPE {
++    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
++                                              sufficient bytes are available. */
++    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_CheckBytesVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    CP_CheckBytesMax = 0X7FFFFFFF
++} CP_CHECKBYTESRESULTTYPE;
++
++/** 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_EventVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    CP_EventMax = 0X7FFFFFFF
++} CP_EVENTTYPE;
++
++/** content pipe definition
++ * @ingroup cp
++ */
++typedef struct CP_PIPETYPE {
++    /** Open a content stream for reading or writing. */
++    CPresult (*Open)( CPhandle* hContent, CPstring szURI, CP_ACCESSTYPE eAccess );
++
++    /** Close a content stream. */
++    CPresult (*Close)( CPhandle hContent );
++
++    /** 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).*/
++    CPresult (*CheckAvailableBytes)( CPhandle hContent, CPuint nBytesRequested, CP_CHECKBYTESRESULTTYPE *eResult );
++
++    /** Seek to certain position in the content relative to the specified origin. */
++    CPresult (*SetPosition)( CPhandle  hContent, CPint nOffset, CP_ORIGINTYPE eOrigin);
++
++    /** Retrieve the current position relative to the start of the content. */
++    CPresult (*GetPosition)( CPhandle hContent, CPuint *pPosition);
++
++    /** 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);
++
++    /** 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.
++
++       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
++       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
++       boundary. Here the client may retrieve the data in segments over successive calls. */
++    CPresult (*ReadBuffer)( CPhandle hContent, CPbyte **ppBuffer, CPuint *nSize, CPbool bForbidCopy);
++
++    /** Release a buffer obtained by ReadBuffer back to the pipe. */
++    CPresult (*ReleaseReadBuffer)(CPhandle hContent, CPbyte *pBuffer);
++
++    /** 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);
++
++    /** 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
++       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);
++
++    /** Register a per-handle client callback with the content pipe. */
++    CPresult (*RegisterCallback)( CPhandle hContent, CPresult (*ClientCallback)(CP_EVENTTYPE eEvent, CPuint iParam));
++
++} CP_PIPETYPE;
++
++#endif
++
+diff --git a/sf-extra/omx-il/OMX_Core.h b/sf-extra/omx-il/OMX_Core.h
+new file mode 100644
+index 00000000..c8f3c4b3
+--- /dev/null
++++ b/sf-extra/omx-il/OMX_Core.h
+@@ -0,0 +1,1422 @@
++/*
++ * Copyright (c) 2008 The Khronos Group Inc.
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining
++ * a copy of this software and associated documentation files (the
++ * "Software"), to deal in the Software without restriction, including
++ * without limitation the rights to use, copy, modify, merge, publish,
++ * distribute, sublicense, and/or sell copies of the Software, and to
++ * permit persons to whom the Software is furnished to do so, subject
++ * to the following conditions:
++ * The above copyright notice and this permission notice shall be included
++ * in all copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
++ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
++ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
++ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
++ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
++ *
++ */
++
++/** OMX_Core.h - OpenMax IL version 1.1.2
++ *  The OMX_Core header file contains the definitions used by both the
++ *  application and the component to access common items.
++ */
++
++#ifndef OMX_Core_h
++#define OMX_Core_h
++
++#ifdef __cplusplus
++extern "C" {
++#endif /* __cplusplus */
++
++
++/* Each OMX header shall include all required header files to allow the
++ *  header to compile without errors.  The includes below are required
++ *  for this header file to compile successfully
++ */
++
++#include <OMX_Index.h>
++
++
++/** The OMX_COMMANDTYPE enumeration is used to specify the action in the
++ *  OMX_SendCommand macro.
++ *  @ingroup core
++ */
++typedef enum OMX_COMMANDTYPE
++{
++    OMX_CommandStateSet,    /**< Change the component state */
++    OMX_CommandFlush,       /**< Flush the data queue(s) of a component */
++    OMX_CommandPortDisable, /**< Disable a port on a component. */
++    OMX_CommandPortEnable,  /**< Enable a port on a component. */
++    OMX_CommandMarkBuffer,  /**< Mark a component/buffer for observation */
++    OMX_CommandKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_CommandVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_CommandMax = 0X7FFFFFFF
++} OMX_COMMANDTYPE;
++
++
++
++/** The OMX_STATETYPE enumeration is used to indicate or change the component
++ *  state.  This enumeration reflects the current state of the component when
++ *  used with the OMX_GetState macro or becomes the parameter in a state change
++ *  command when used with the OMX_SendCommand macro.
++ *
++ *  The component will be in the Loaded state after the component is initially
++ *  loaded into memory.  In the Loaded state, the component is not allowed to
++ *  allocate or hold resources other than to build it's internal parameter
++ *  and configuration tables.  The application will send one or more
++ *  SetParameters/GetParameters and SetConfig/GetConfig commands to the
++ *  component and the component will record each of these parameter and
++ *  configuration changes for use later.  When the application sends the
++ *  Idle command, the component will acquire the resources needed for the
++ *  specified configuration and will transition to the idle state if the
++ *  allocation is successful.  If the component cannot successfully
++ *  transition to the idle state for any reason, the state of the component
++ *  shall be fully rolled back to the Loaded state (e.g. all allocated
++ *  resources shall be released).  When the component receives the command
++ *  to go to the Executing state, it shall begin processing buffers by
++ *  sending all input buffers it holds to the application.  While
++ *  the component is in the Idle state, the application may also send the
++ *  Pause command.  If the component receives the pause command while in the
++ *  Idle state, the component shall send all input buffers it holds to the
++ *  application, but shall not begin processing buffers.  This will allow the
++ *  application to prefill buffers.
++ *
++ *  @ingroup comp
++ */
++
++typedef enum OMX_STATETYPE {
++    OMX_StateInvalid,      /**< component has detected that it's internal data
++                                structures are corrupted to the point that
++                                it cannot determine it's state properly */
++    OMX_StateLoaded,      /**< component has been loaded but has not completed
++                                initialization.  The OMX_SetParameter macro
++                                and the OMX_GetParameter macro are the only
++                                valid macros allowed to be sent to the
++                                component in this state. */
++    OMX_StateIdle,        /**< component initialization has been completed
++                                successfully and the component is ready to
++                                to start. */
++    OMX_StateExecuting,   /**< component has accepted the start command and
++                                is processing data (if data is available) */
++    OMX_StatePause,       /**< component has received pause command */
++    OMX_StateWaitForResources, /**< component is waiting for resources, either after
++                                preemption or before it gets the resources requested.
++                                See specification for complete details. */
++    OMX_StateKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_StateVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_StateMax = 0X7FFFFFFF
++} OMX_STATETYPE;
++
++/** The OMX_ERRORTYPE enumeration defines the standard OMX Errors.  These
++ *  errors should cover most of the common failure cases.  However,
++ *  vendors are free to add additional error messages of their own as
++ *  long as they follow these rules:
++ *  1.  Vendor error messages shall be in the range of 0x90000000 to
++ *      0x9000FFFF.
++ *  2.  Vendor error messages shall be defined in a header file provided
++ *      with the component.  No error messages are allowed that are
++ *      not defined.
++ */
++typedef enum OMX_ERRORTYPE {
++    OMX_ErrorNone = 0,
++
++    /** There were insufficient resources to perform the requested operation */
++    OMX_ErrorInsufficientResources = (OMX_S32) 0x80001000,
++
++    /** There was an error, but the cause of the error could not be determined */
++    OMX_ErrorUndefined = (OMX_S32) 0x80001001,
++
++    /** The component name string was not valid */
++    OMX_ErrorInvalidComponentName = (OMX_S32) 0x80001002,
++
++    /** No component with the specified name string was found */
++    OMX_ErrorComponentNotFound = (OMX_S32) 0x80001003,
++
++    /** The component specified did not have a "OMX_ComponentInit" or
++        "OMX_ComponentDeInit entry point */
++    OMX_ErrorInvalidComponent = (OMX_S32) 0x80001004,
++
++    /** One or more parameters were not valid */
++    OMX_ErrorBadParameter = (OMX_S32) 0x80001005,
++
++    /** The requested function is not implemented */
++    OMX_ErrorNotImplemented = (OMX_S32) 0x80001006,
++
++    /** The buffer was emptied before the next buffer was ready */
++    OMX_ErrorUnderflow = (OMX_S32) 0x80001007,
++
++    /** The buffer was not available when it was needed */
++    OMX_ErrorOverflow = (OMX_S32) 0x80001008,
++
++    /** The hardware failed to respond as expected */
++    OMX_ErrorHardware = (OMX_S32) 0x80001009,
++
++    /** The component is in the state OMX_StateInvalid */
++    OMX_ErrorInvalidState = (OMX_S32) 0x8000100A,
++
++    /** Stream is found to be corrupt */
++    OMX_ErrorStreamCorrupt = (OMX_S32) 0x8000100B,
++
++    /** Ports being connected are not compatible */
++    OMX_ErrorPortsNotCompatible = (OMX_S32) 0x8000100C,
++
++    /** Resources allocated to an idle component have been
++        lost resulting in the component returning to the loaded state */
++    OMX_ErrorResourcesLost = (OMX_S32) 0x8000100D,
++
++    /** No more indicies can be enumerated */
++    OMX_ErrorNoMore = (OMX_S32) 0x8000100E,
++
++    /** The component detected a version mismatch */
++    OMX_ErrorVersionMismatch = (OMX_S32) 0x8000100F,
++
++    /** The component is not ready to return data at this time */
++    OMX_ErrorNotReady = (OMX_S32) 0x80001010,
++
++    /** There was a timeout that occurred */
++    OMX_ErrorTimeout = (OMX_S32) 0x80001011,
++
++    /** This error occurs when trying to transition into the state you are already in */
++    OMX_ErrorSameState = (OMX_S32) 0x80001012,
++
++    /** Resources allocated to an executing or paused component have been
++        preempted, causing the component to return to the idle state */
++    OMX_ErrorResourcesPreempted = (OMX_S32) 0x80001013,
++
++    /** A non-supplier port sends this error to the IL client (via the EventHandler callback)
++        during the allocation of buffers (on a transition from the LOADED to the IDLE state or
++        on a port restart) when it deems that it has waited an unusually long time for the supplier
++        to send it an allocated buffer via a UseBuffer call. */
++    OMX_ErrorPortUnresponsiveDuringAllocation = (OMX_S32) 0x80001014,
++
++    /** A non-supplier port sends this error to the IL client (via the EventHandler callback)
++        during the deallocation of buffers (on a transition from the IDLE to LOADED state or
++        on a port stop) when it deems that it has waited an unusually long time for the supplier
++        to request the deallocation of a buffer header via a FreeBuffer call. */
++    OMX_ErrorPortUnresponsiveDuringDeallocation = (OMX_S32) 0x80001015,
++
++    /** A supplier port sends this error to the IL client (via the EventHandler callback)
++        during the stopping of a port (either on a transition from the IDLE to LOADED
++        state or a port stop) when it deems that it has waited an unusually long time for
++        the non-supplier to return a buffer via an EmptyThisBuffer or FillThisBuffer call. */
++    OMX_ErrorPortUnresponsiveDuringStop = (OMX_S32) 0x80001016,
++
++    /** Attempting a state transtion that is not allowed */
++    OMX_ErrorIncorrectStateTransition = (OMX_S32) 0x80001017,
++
++    /* Attempting a command that is not allowed during the present state. */
++    OMX_ErrorIncorrectStateOperation = (OMX_S32) 0x80001018,
++
++    /** The values encapsulated in the parameter or config structure are not supported. */
++    OMX_ErrorUnsupportedSetting = (OMX_S32) 0x80001019,
++
++    /** The parameter or config indicated by the given index is not supported. */
++    OMX_ErrorUnsupportedIndex = (OMX_S32) 0x8000101A,
++
++    /** The port index supplied is incorrect. */
++    OMX_ErrorBadPortIndex = (OMX_S32) 0x8000101B,
++
++    /** The port has lost one or more of its buffers and it thus unpopulated. */
++    OMX_ErrorPortUnpopulated = (OMX_S32) 0x8000101C,
++
++    /** Component suspended due to temporary loss of resources */
++    OMX_ErrorComponentSuspended = (OMX_S32) 0x8000101D,
++
++    /** Component suspended due to an inability to acquire dynamic resources */
++    OMX_ErrorDynamicResourcesUnavailable = (OMX_S32) 0x8000101E,
++
++    /** When the macroblock error reporting is enabled the component returns new error
++    for every frame that has errors */
++    OMX_ErrorMbErrorsInFrame = (OMX_S32) 0x8000101F,
++
++    /** A component reports this error when it cannot parse or determine the format of an input stream. */
++    OMX_ErrorFormatNotDetected = (OMX_S32) 0x80001020,
++
++    /** The content open operation failed. */
++    OMX_ErrorContentPipeOpenFailed = (OMX_S32) 0x80001021,
++
++    /** The content creation operation failed. */
++    OMX_ErrorContentPipeCreationFailed = (OMX_S32) 0x80001022,
++
++    /** Separate table information is being used */
++    OMX_ErrorSeperateTablesUsed = (OMX_S32) 0x80001023,
++
++    /** Tunneling is unsupported by the component*/
++    OMX_ErrorTunnelingUnsupported = (OMX_S32) 0x80001024,
++
++    OMX_ErrorKhronosExtensions = (OMX_S32)0x8F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_ErrorVendorStartUnused = (OMX_S32)0x90000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_ErrorMax = 0x7FFFFFFF
++} OMX_ERRORTYPE;
++
++/** @ingroup core */
++typedef OMX_ERRORTYPE (* OMX_COMPONENTINITTYPE)(OMX_IN  OMX_HANDLETYPE hComponent);
++
++/** @ingroup core */
++typedef struct OMX_COMPONENTREGISTERTYPE {
++    const char          * pName;       /* Component name, 128 byte limit (including '\0') applies */
++    OMX_COMPONENTINITTYPE pInitialize; /* Component instance initialization function */
++} OMX_COMPONENTREGISTERTYPE;
++
++/** @ingroup core */
++extern OMX_COMPONENTREGISTERTYPE OMX_ComponentRegistered[];
++
++/** @ingroup rpm */
++typedef struct OMX_PRIORITYMGMTTYPE {
++    OMX_U32 nSize;             /**< size of the structure in bytes */
++    OMX_VERSIONTYPE nVersion;  /**< OMX specification version information */
++    OMX_U32 nGroupPriority;            /**< Priority of the component group */
++    OMX_U32 nGroupID;                  /**< ID of the component group */
++} OMX_PRIORITYMGMTTYPE;
++
++/* Component name and Role names are limited to 128 characters including the terminating '\0'. */
++#define OMX_MAX_STRINGNAME_SIZE 128
++
++/** @ingroup comp */
++typedef struct OMX_PARAM_COMPONENTROLETYPE {
++    OMX_U32 nSize;              /**< size of the structure in bytes */
++    OMX_VERSIONTYPE nVersion;   /**< OMX specification version information */
++    OMX_U8 cRole[OMX_MAX_STRINGNAME_SIZE];  /**< name of standard component which defines component role */
++} OMX_PARAM_COMPONENTROLETYPE;
++
++/** End of Stream Buffer Flag:
++  *
++  * A component sets EOS when it has no more data to emit on a particular
++  * output port. Thus an output port shall set EOS on the last buffer it
++  * emits. A component's determination of when an output port should
++  * cease sending data is implemenation specific.
++  * @ingroup buf
++  */
++
++#define OMX_BUFFERFLAG_EOS 0x00000001
++
++/** Start Time Buffer Flag:
++ *
++ * The source of a stream (e.g. a demux component) sets the STARTTIME
++ * flag on the buffer that contains the starting timestamp for the
++ * stream. The starting timestamp corresponds to the first data that
++ * should be displayed at startup or after a seek.
++ * The first timestamp of the stream is not necessarily the start time.
++ * For instance, in the case of a seek to a particular video frame,
++ * the target frame may be an interframe. Thus the first buffer of
++ * the stream will be the intra-frame preceding the target frame and
++ * the starttime will occur with the target frame (with any other
++ * required frames required to reconstruct the target intervening).
++ *
++ * The STARTTIME flag is directly associated with the buffer's
++ * timestamp ' thus its association to buffer data and its
++ * propagation is identical to the timestamp's.
++ *
++ * When a Sync Component client receives a buffer with the
++ * STARTTIME flag it shall perform a SetConfig on its sync port
++ * using OMX_ConfigTimeClientStartTime and passing the buffer's
++ * timestamp.
++ *
++ * @ingroup buf
++ */
++
++#define OMX_BUFFERFLAG_STARTTIME 0x00000002
++
++
++
++/** Decode Only Buffer Flag:
++ *
++ * The source of a stream (e.g. a demux component) sets the DECODEONLY
++ * flag on any buffer that should shall be decoded but should not be
++ * displayed. This flag is used, for instance, when a source seeks to
++ * a target interframe that requires the decode of frames preceding the
++ * target to facilitate the target's reconstruction. In this case the
++ * source would emit the frames preceding the target downstream
++ * but mark them as decode only.
++ *
++ * The DECODEONLY is associated with buffer data and propagated in a
++ * manner identical to the buffer timestamp.
++ *
++ * A component that renders data should ignore all buffers with
++ * the DECODEONLY flag set.
++ *
++ * @ingroup buf
++ */
++
++#define OMX_BUFFERFLAG_DECODEONLY 0x00000004
++
++
++/* Data Corrupt Flag: This flag is set when the IL client believes the data in the associated buffer is corrupt
++ * @ingroup buf
++ */
++
++#define OMX_BUFFERFLAG_DATACORRUPT 0x00000008
++
++/* End of Frame: The buffer contains exactly one end of frame and no data
++ *  occurs after the end of frame. This flag is an optional hint. The absence
++ *  of this flag does not imply the absence of an end of frame within the buffer.
++ * @ingroup buf
++*/
++#define OMX_BUFFERFLAG_ENDOFFRAME 0x00000010
++
++/* Sync Frame Flag: This flag is set when the buffer content contains a coded sync frame '
++ *  a frame that has no dependency on any other frame information
++ *  @ingroup buf
++ */
++#define OMX_BUFFERFLAG_SYNCFRAME 0x00000020
++
++/* Extra data present flag: there is extra data appended to the data stream
++ * residing in the buffer
++ * @ingroup buf
++ */
++#define OMX_BUFFERFLAG_EXTRADATA 0x00000040
++
++/** Codec Config Buffer Flag:
++* OMX_BUFFERFLAG_CODECCONFIG is an optional flag that is set by an
++* output port when all bytes in the buffer form part or all of a set of
++* codec specific configuration data.  Examples include SPS/PPS nal units
++* for OMX_VIDEO_CodingAVC or AudioSpecificConfig data for
++* OMX_AUDIO_CodingAAC.  Any component that for a given stream sets
++* OMX_BUFFERFLAG_CODECCONFIG shall not mix codec configuration bytes
++* with frame data in the same buffer, and shall send all buffers
++* containing codec configuration bytes before any buffers containing
++* frame data that those configurations bytes describe.
++* If the stream format for a particular codec has a frame specific
++* header at the start of each frame, for example OMX_AUDIO_CodingMP3 or
++* OMX_AUDIO_CodingAAC in ADTS mode, then these shall be presented as
++* normal without setting OMX_BUFFERFLAG_CODECCONFIG.
++ * @ingroup buf
++ */
++#define OMX_BUFFERFLAG_CODECCONFIG 0x00000080
++
++
++
++/** @ingroup buf */
++typedef struct OMX_BUFFERHEADERTYPE {
++    OMX_U32 nSize;              /**< size of the structure in bytes */
++    OMX_VERSIONTYPE nVersion;   /**< OMX specification version information */
++    OMX_U8* pBuffer;            /**< Pointer to actual block of memory
++                                     that is acting as the buffer */
++    OMX_U32 nAllocLen;          /**< size of the buffer allocated, in bytes */
++    OMX_U32 nFilledLen;         /**< number of bytes currently in the
++                                     buffer */
++    OMX_U32 nOffset;            /**< start offset of valid data in bytes from
++                                     the start of the buffer */
++    OMX_PTR pAppPrivate;        /**< pointer to any data the application
++                                     wants to associate with this buffer */
++    OMX_PTR pPlatformPrivate;   /**< pointer to any data the platform
++                                     wants to associate with this buffer */
++    OMX_PTR pInputPortPrivate;  /**< pointer to any data the input port
++                                     wants to associate with this buffer */
++    OMX_PTR pOutputPortPrivate; /**< pointer to any data the output port
++                                     wants to associate with this buffer */
++    OMX_HANDLETYPE hMarkTargetComponent; /**< The component that will generate a
++                                              mark event upon processing this buffer. */
++    OMX_PTR pMarkData;          /**< Application specific data associated with
++                                     the mark sent on a mark event to disambiguate
++                                     this mark from others. */
++    OMX_U32 nTickCount;         /**< Optional entry that the component and
++                                     application can update with a tick count
++                                     when they access the component.  This
++                                     value should be in microseconds.  Since
++                                     this is a value relative to an arbitrary
++                                     starting point, this value cannot be used
++                                     to determine absolute time.  This is an
++                                     optional entry and not all components
++                                     will update it.*/
++    OMX_TICKS nTimeStamp;          /**< Timestamp corresponding to the sample
++                                     starting at the first logical sample
++                                     boundary in the buffer. Timestamps of
++                                     successive samples within the buffer may
++                                     be inferred by adding the duration of the
++                                     of the preceding buffer to the timestamp
++                                     of the preceding buffer.*/
++    OMX_U32     nFlags;           /**< buffer specific flags */
++    OMX_U32 nOutputPortIndex;     /**< The index of the output port (if any) using
++                                     this buffer */
++    OMX_U32 nInputPortIndex;      /**< The index of the input port (if any) using
++                                     this buffer */
++} OMX_BUFFERHEADERTYPE;
++
++/** The OMX_EXTRADATATYPE enumeration is used to define the
++ * possible extra data payload types.
++ * NB: this enum is binary backwards compatible with the previous
++ * OMX_EXTRADATA_QUANT define.  This should be replaced with
++ * OMX_ExtraDataQuantization.
++ */
++typedef enum OMX_EXTRADATATYPE {
++    OMX_ExtraDataNone = 0,                       /**< Indicates that no more extra data sections follow */
++    OMX_ExtraDataQuantization,                   /**< The data payload contains quantization data */
++    OMX_ExtraDataKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_ExtraDataVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_ExtraDataMax = 0x7FFFFFFF
++} OMX_EXTRADATATYPE;
++
++
++typedef struct OMX_OTHER_EXTRADATATYPE  {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_EXTRADATATYPE eType;       /* Extra Data type */
++    OMX_U32 nDataSize;   /* Size of the supporting data to follow */
++    OMX_U8  data[1];     /* Supporting data hint  */
++} OMX_OTHER_EXTRADATATYPE;
++
++/** @ingroup comp */
++typedef struct OMX_PORT_PARAM_TYPE {
++    OMX_U32 nSize;              /**< size of the structure in bytes */
++    OMX_VERSIONTYPE nVersion;   /**< OMX specification version information */
++    OMX_U32 nPorts;             /**< The number of ports for this component */
++    OMX_U32 nStartPortNumber;   /** first port number for this type of port */
++} OMX_PORT_PARAM_TYPE;
++
++/** @ingroup comp */
++typedef enum OMX_EVENTTYPE {
++    OMX_EventCmdComplete,         /**< component has sucessfully completed a command */
++    OMX_EventError,               /**< component has detected an error condition */
++    OMX_EventMark,                /**< component has detected a buffer mark */
++    OMX_EventPortSettingsChanged, /**< component is reported a port settings change */
++    OMX_EventBufferFlag,          /**< component has detected an EOS */
++    OMX_EventResourcesAcquired,   /**< component has been granted resources and is
++                                       automatically starting the state change from
++                                       OMX_StateWaitForResources to OMX_StateIdle. */
++    OMX_EventComponentResumed,     /**< Component resumed due to reacquisition of resources */
++    OMX_EventDynamicResourcesAvailable, /**< Component has acquired previously unavailable dynamic resources */
++    OMX_EventPortFormatDetected,      /**< Component has detected a supported format. */
++    OMX_EventKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_EventVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_EventMax = 0x7FFFFFFF
++} OMX_EVENTTYPE;
++
++typedef struct OMX_CALLBACKTYPE {
++    /** The EventHandler method is used to notify the application when an
++        event of interest occurs.  Events are defined in the OMX_EVENTTYPE
++        enumeration.  Please see that enumeration for details of what will
++        be returned for each type of event. Callbacks should not return
++        an error to the component, so if an error occurs, the application
++        shall handle it internally.  This is a blocking call.
++
++        The application should return from this call within 5 msec to avoid
++        blocking the component for an excessively long period of time.
++
++        @param hComponent
++            handle of the component to access.  This is the component
++            handle returned by the call to the GetHandle function.
++        @param pAppData
++            pointer to an application defined value that was provided in the
++            pAppData parameter to the OMX_GetHandle method for the component.
++            This application defined value is provided so that the application
++            can have a component specific context when receiving the callback.
++        @param eEvent
++            Event that the component wants to notify the application about.
++        @param nData1
++            nData will be the OMX_ERRORTYPE for an error event and will be
++            an OMX_COMMANDTYPE for a command complete event and OMX_INDEXTYPE for a OMX_PortSettingsChanged event.
++         @param nData2
++            nData2 will hold further information related to the event. Can be OMX_STATETYPE for
++            a OMX_CommandStateSet command or port index for a OMX_PortSettingsChanged event.
++            Default value is 0 if not used. )
++        @param pEventData
++            Pointer to additional event-specific data (see spec for meaning).
++      */
++
++    OMX_ERRORTYPE (*EventHandler)(
++        OMX_IN OMX_HANDLETYPE hComponent,
++        OMX_IN OMX_PTR pAppData,
++        OMX_IN OMX_EVENTTYPE eEvent,
++        OMX_IN OMX_U32 nData1,
++        OMX_IN OMX_U32 nData2,
++        OMX_IN OMX_PTR pEventData);
++
++    /** The EmptyBufferDone method is used to return emptied buffers from an
++        input port back to the application for reuse.  This is a blocking call
++        so the application should not attempt to refill the buffers during this
++        call, but should queue them and refill them in another thread.  There
++        is no error return, so the application shall handle any errors generated
++        internally.
++
++        The application should return from this call within 5 msec.
++
++        @param hComponent
++            handle of the component to access.  This is the component
++            handle returned by the call to the GetHandle function.
++        @param pAppData
++            pointer to an application defined value that was provided in the
++            pAppData parameter to the OMX_GetHandle method for the component.
++            This application defined value is provided so that the application
++            can have a component specific context when receiving the callback.
++        @param pBuffer
++            pointer to an OMX_BUFFERHEADERTYPE structure allocated with UseBuffer
++            or AllocateBuffer indicating the buffer that was emptied.
++        @ingroup buf
++     */
++    OMX_ERRORTYPE (*EmptyBufferDone)(
++        OMX_IN OMX_HANDLETYPE hComponent,
++        OMX_IN OMX_PTR pAppData,
++        OMX_IN OMX_BUFFERHEADERTYPE* pBuffer);
++
++    /** The FillBufferDone method is used to return filled buffers from an
++        output port back to the application for emptying and then reuse.
++        This is a blocking call so the application should not attempt to
++        empty the buffers during this call, but should queue the buffers
++        and empty them in another thread.  There is no error return, so
++        the application shall handle any errors generated internally.  The
++        application shall also update the buffer header to indicate the
++        number of bytes placed into the buffer.
++
++        The application should return from this call within 5 msec.
++
++        @param hComponent
++            handle of the component to access.  This is the component
++            handle returned by the call to the GetHandle function.
++        @param pAppData
++            pointer to an application defined value that was provided in the
++            pAppData parameter to the OMX_GetHandle method for the component.
++            This application defined value is provided so that the application
++            can have a component specific context when receiving the callback.
++        @param pBuffer
++            pointer to an OMX_BUFFERHEADERTYPE structure allocated with UseBuffer
++            or AllocateBuffer indicating the buffer that was filled.
++        @ingroup buf
++     */
++    OMX_ERRORTYPE (*FillBufferDone)(
++        OMX_OUT OMX_HANDLETYPE hComponent,
++        OMX_OUT OMX_PTR pAppData,
++        OMX_OUT OMX_BUFFERHEADERTYPE* pBuffer);
++
++} OMX_CALLBACKTYPE;
++
++/** The OMX_BUFFERSUPPLIERTYPE enumeration is used to dictate port supplier
++    preference when tunneling between two ports.
++    @ingroup tun buf
++*/
++typedef enum OMX_BUFFERSUPPLIERTYPE {
++    OMX_BufferSupplyUnspecified = 0x0, /**< port supplying the buffers is unspecified,
++                                              or don't care */
++    OMX_BufferSupplyInput,             /**< input port supplies the buffers */
++    OMX_BufferSupplyOutput,            /**< output port supplies the buffers */
++    OMX_BufferSupplyKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_BufferSupplyVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_BufferSupplyMax = 0x7FFFFFFF
++} OMX_BUFFERSUPPLIERTYPE;
++
++
++/** buffer supplier parameter
++ * @ingroup tun
++ */
++typedef struct OMX_PARAM_BUFFERSUPPLIERTYPE {
++    OMX_U32 nSize; /**< size of the structure in bytes */
++    OMX_VERSIONTYPE nVersion; /**< OMX specification version information */
++    OMX_U32 nPortIndex; /**< port that this structure applies to */
++    OMX_BUFFERSUPPLIERTYPE eBufferSupplier; /**< buffer supplier */
++} OMX_PARAM_BUFFERSUPPLIERTYPE;
++
++
++/**< indicates that buffers received by an input port of a tunnel
++     may not modify the data in the buffers
++     @ingroup tun
++ */
++#define OMX_PORTTUNNELFLAG_READONLY 0x00000001
++
++
++/** The OMX_TUNNELSETUPTYPE structure is used to pass data from an output
++    port to an input port as part the two ComponentTunnelRequest calls
++    resulting from a OMX_SetupTunnel call from the IL Client.
++    @ingroup tun
++ */
++typedef struct OMX_TUNNELSETUPTYPE {
++    OMX_U32 nTunnelFlags;             /**< bit flags for tunneling */
++    OMX_BUFFERSUPPLIERTYPE eSupplier; /**< supplier preference */
++} OMX_TUNNELSETUPTYPE;
++
++/* OMX Component headers is included to enable the core to use
++   macros for functions into the component for OMX release 1.0.
++   Developers should not access any structures or data from within
++   the component header directly */
++/* TO BE REMOVED - #include <OMX_Component.h> */
++
++/** GetComponentVersion will return information about the component.
++    This is a blocking call.  This macro will go directly from the
++    application to the component (via a core macro).  The
++    component will return from this call within 5 msec.
++    @param [in] hComponent
++        handle of component to execute the command
++    @param [out] pComponentName
++        pointer to an empty string of length 128 bytes.  The component
++        will write its name into this string.  The name will be
++        terminated by a single zero byte.  The name of a component will
++        be 127 bytes or less to leave room for the trailing zero byte.
++        An example of a valid component name is "OMX.ABC.ChannelMixer\0".
++    @param [out] pComponentVersion
++        pointer to an OMX Version structure that the component will fill
++        in.  The component will fill in a value that indicates the
++        component version.  NOTE: the component version is NOT the same
++        as the OMX Specification version (found in all structures).  The
++        component version is defined by the vendor of the component and
++        its value is entirely up to the component vendor.
++    @param [out] pSpecVersion
++        pointer to an OMX Version structure that the component will fill
++        in.  The SpecVersion is the version of the specification that the
++        component was built against.  Please note that this value may or
++        may not match the structure's version.  For example, if the
++        component was built against the 2.0 specification, but the
++        application (which creates the structure is built against the
++        1.0 specification the versions would be different.
++    @param [out] pComponentUUID
++        pointer to the UUID of the component which will be filled in by
++        the component.  The UUID is a unique identifier that is set at
++        RUN time for the component and is unique to each instantion of
++        the component.
++    @return OMX_ERRORTYPE
++        If the command successfully executes, the return code will be
++        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
++    @ingroup comp
++ */
++#define OMX_GetComponentVersion(                            \
++        hComponent,                                         \
++        pComponentName,                                     \
++        pComponentVersion,                                  \
++        pSpecVersion,                                       \
++        pComponentUUID)                                     \
++    ((OMX_COMPONENTTYPE*)hComponent)->GetComponentVersion(  \
++        hComponent,                                         \
++        pComponentName,                                     \
++        pComponentVersion,                                  \
++        pSpecVersion,                                       \
++        pComponentUUID)                 /* Macro End */
++
++
++/** Send a command to the component.  This call is a non-blocking call.
++    The component should check the parameters and then queue the command
++    to the component thread to be executed.  The component thread shall
++    send the EventHandler() callback at the conclusion of the command.
++    This macro will go directly from the application to the component (via
++    a core macro).  The component will return from this call within 5 msec.
++
++    When the command is "OMX_CommandStateSet" the component will queue a
++    state transition to the new state idenfied in nParam.
++
++    When the command is "OMX_CommandFlush", to flush a port's buffer queues,
++    the command will force the component to return all buffers NOT CURRENTLY
++    BEING PROCESSED to the application, in the order in which the buffers
++    were received.
++
++    When the command is "OMX_CommandPortDisable" or
++    "OMX_CommandPortEnable", the component's port (given by the value of
++    nParam) will be stopped or restarted.
++
++    When the command "OMX_CommandMarkBuffer" is used to mark a buffer, the
++    pCmdData will point to a OMX_MARKTYPE structure containing the component
++    handle of the component to examine the buffer chain for the mark.  nParam1
++    contains the index of the port on which the buffer mark is applied.
++
++    Specification text for more details.
++
++    @param [in] hComponent
++        handle of component to execute the command
++    @param [in] Cmd
++        Command for the component to execute
++    @param [in] nParam
++        Parameter for the command to be executed.  When Cmd has the value
++        OMX_CommandStateSet, value is a member of OMX_STATETYPE.  When Cmd has
++        the value OMX_CommandFlush, value of nParam indicates which port(s)
++        to flush. -1 is used to flush all ports a single port index will
++        only flush that port.  When Cmd has the value "OMX_CommandPortDisable"
++        or "OMX_CommandPortEnable", the component's port is given by
++        the value of nParam.  When Cmd has the value "OMX_CommandMarkBuffer"
++        the components pot is given by the value of nParam.
++    @param [in] pCmdData
++        Parameter pointing to the OMX_MARKTYPE structure when Cmd has the value
++        "OMX_CommandMarkBuffer".
++    @return OMX_ERRORTYPE
++        If the command successfully executes, the return code will be
++        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
++    @ingroup comp
++ */
++#define OMX_SendCommand(                                    \
++         hComponent,                                        \
++         Cmd,                                               \
++         nParam,                                            \
++         pCmdData)                                          \
++     ((OMX_COMPONENTTYPE*)hComponent)->SendCommand(         \
++         hComponent,                                        \
++         Cmd,                                               \
++         nParam,                                            \
++         pCmdData)                          /* Macro End */
++
++
++/** The OMX_GetParameter macro will get one of the current parameter
++    settings from the component.  This macro cannot only be invoked when
++    the component is in the OMX_StateInvalid state.  The nParamIndex
++    parameter is used to indicate which structure is being requested from
++    the component.  The application shall allocate the correct structure
++    and shall fill in the structure size and version information before
++    invoking this macro.  When the parameter applies to a port, the
++    caller shall fill in the appropriate nPortIndex value indicating the
++    port on which the parameter applies. If the component has not had
++    any settings changed, then the component should return a set of
++    valid DEFAULT  parameters for the component.  This is a blocking
++    call.
++
++    The component should return from this call within 20 msec.
++
++    @param [in] hComponent
++        Handle of the component to be accessed.  This is the component
++        handle returned by the call to the OMX_GetHandle function.
++    @param [in] nParamIndex
++        Index of the structure to be filled.  This value is from the
++        OMX_INDEXTYPE enumeration.
++    @param [in,out] pComponentParameterStructure
++        Pointer to application allocated structure to be filled by the
++        component.
++    @return OMX_ERRORTYPE
++        If the command successfully executes, the return code will be
++        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
++    @ingroup comp
++ */
++#define OMX_GetParameter(                                   \
++        hComponent,                                         \
++        nParamIndex,                                        \
++        pComponentParameterStructure)                        \
++    ((OMX_COMPONENTTYPE*)hComponent)->GetParameter(         \
++        hComponent,                                         \
++        nParamIndex,                                        \
++        pComponentParameterStructure)    /* Macro End */
++
++
++/** The OMX_SetParameter macro will send an initialization parameter
++    structure to a component.  Each structure shall be sent one at a time,
++    in a separate invocation of the macro.  This macro can only be
++    invoked when the component is in the OMX_StateLoaded state, or the
++    port is disabled (when the parameter applies to a port). The
++    nParamIndex parameter is used to indicate which structure is being
++    passed to the component.  The application shall allocate the
++    correct structure and shall fill in the structure size and version
++    information (as well as the actual data) before invoking this macro.
++    The application is free to dispose of this structure after the call
++    as the component is required to copy any data it shall retain.  This
++    is a blocking call.
++
++    The component should return from this call within 20 msec.
++
++    @param [in] hComponent
++        Handle of the component to be accessed.  This is the component
++        handle returned by the call to the OMX_GetHandle function.
++    @param [in] nIndex
++        Index of the structure to be sent.  This value is from the
++        OMX_INDEXTYPE enumeration.
++    @param [in] pComponentParameterStructure
++        pointer to application allocated structure to be used for
++        initialization by the component.
++    @return OMX_ERRORTYPE
++        If the command successfully executes, the return code will be
++        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
++    @ingroup comp
++ */
++#define OMX_SetParameter(                                   \
++        hComponent,                                         \
++        nParamIndex,                                        \
++        pComponentParameterStructure)                        \
++    ((OMX_COMPONENTTYPE*)hComponent)->SetParameter(         \
++        hComponent,                                         \
++        nParamIndex,                                        \
++        pComponentParameterStructure)    /* Macro End */
++
++
++/** The OMX_GetConfig macro will get one of the configuration structures
++    from a component.  This macro can be invoked anytime after the
++    component has been loaded.  The nParamIndex call parameter is used to
++    indicate which structure is being requested from the component.  The
++    application shall allocate the correct structure and shall fill in the
++    structure size and version information before invoking this macro.
++    If the component has not had this configuration parameter sent before,
++    then the component should return a set of valid DEFAULT values for the
++    component.  This is a blocking call.
++
++    The component should return from this call within 5 msec.
++
++    @param [in] hComponent
++        Handle of the component to be accessed.  This is the component
++        handle returned by the call to the OMX_GetHandle function.
++    @param [in] nIndex
++        Index of the structure to be filled.  This value is from the
++        OMX_INDEXTYPE enumeration.
++    @param [in,out] pComponentConfigStructure
++        pointer to application allocated structure to be filled by the
++        component.
++    @return OMX_ERRORTYPE
++        If the command successfully executes, the return code will be
++        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
++    @ingroup comp
++*/
++#define OMX_GetConfig(                                      \
++        hComponent,                                         \
++        nConfigIndex,                                       \
++        pComponentConfigStructure)                           \
++    ((OMX_COMPONENTTYPE*)hComponent)->GetConfig(            \
++        hComponent,                                         \
++        nConfigIndex,                                       \
++        pComponentConfigStructure)       /* Macro End */
++
++
++/** The OMX_SetConfig macro will send one of the configuration
++    structures to a component.  Each structure shall be sent one at a time,
++    each in a separate invocation of the macro.  This macro can be invoked
++    anytime after the component has been loaded.  The application shall
++    allocate the correct structure and shall fill in the structure size
++    and version information (as well as the actual data) before invoking
++    this macro.  The application is free to dispose of this structure after
++    the call as the component is required to copy any data it shall retain.
++    This is a blocking call.
++
++    The component should return from this call within 5 msec.
++
++    @param [in] hComponent
++        Handle of the component to be accessed.  This is the component
++        handle returned by the call to the OMX_GetHandle function.
++    @param [in] nConfigIndex
++        Index of the structure to be sent.  This value is from the
++        OMX_INDEXTYPE enumeration above.
++    @param [in] pComponentConfigStructure
++        pointer to application allocated structure to be used for
++        initialization by the component.
++    @return OMX_ERRORTYPE
++        If the command successfully executes, the return code will be
++        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
++    @ingroup comp
++ */
++#define OMX_SetConfig(                                      \
++        hComponent,                                         \
++        nConfigIndex,                                       \
++        pComponentConfigStructure)                           \
++    ((OMX_COMPONENTTYPE*)hComponent)->SetConfig(            \
++        hComponent,                                         \
++        nConfigIndex,                                       \
++        pComponentConfigStructure)       /* Macro End */
++
++
++/** The OMX_GetExtensionIndex macro will invoke a component to translate
++    a vendor specific configuration or parameter string into an OMX
++    structure index.  There is no requirement for the vendor to support
++    this command for the indexes already found in the OMX_INDEXTYPE
++    enumeration (this is done to save space in small components).  The
++    component shall support all vendor supplied extension indexes not found
++    in the master OMX_INDEXTYPE enumeration.  This is a blocking call.
++
++    The component should return from this call within 5 msec.
++
++    @param [in] hComponent
++        Handle of the component to be accessed.  This is the component
++        handle returned by the call to the GetHandle function.
++    @param [in] cParameterName
++        OMX_STRING that shall be less than 128 characters long including
++        the trailing null byte.  This is the string that will get
++        translated by the component into a configuration index.
++    @param [out] pIndexType
++        a pointer to a OMX_INDEXTYPE to receive the index value.
++    @return OMX_ERRORTYPE
++        If the command successfully executes, the return code will be
++        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
++    @ingroup comp
++ */
++#define OMX_GetExtensionIndex(                              \
++        hComponent,                                         \
++        cParameterName,                                     \
++        pIndexType)                                         \
++    ((OMX_COMPONENTTYPE*)hComponent)->GetExtensionIndex(    \
++        hComponent,                                         \
++        cParameterName,                                     \
++        pIndexType)                     /* Macro End */
++
++
++/** The OMX_GetState macro will invoke the component to get the current
++    state of the component and place the state value into the location
++    pointed to by pState.
++
++    The component should return from this call within 5 msec.
++
++    @param [in] hComponent
++        Handle of the component to be accessed.  This is the component
++        handle returned by the call to the OMX_GetHandle function.
++    @param [out] pState
++        pointer to the location to receive the state.  The value returned
++        is one of the OMX_STATETYPE members
++    @return OMX_ERRORTYPE
++        If the command successfully executes, the return code will be
++        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
++    @ingroup comp
++ */
++#define OMX_GetState(                                       \
++        hComponent,                                         \
++        pState)                                             \
++    ((OMX_COMPONENTTYPE*)hComponent)->GetState(             \
++        hComponent,                                         \
++        pState)                         /* Macro End */
++
++
++/** The OMX_UseBuffer macro will request that the component use
++    a buffer (and allocate its own buffer header) already allocated
++    by another component, or by the IL Client. This is a blocking
++    call.
++
++    The component should return from this call within 20 msec.
++
++    @param [in] hComponent
++        Handle of the component to be accessed.  This is the component
++        handle returned by the call to the OMX_GetHandle function.
++    @param [out] ppBuffer
++        pointer to an OMX_BUFFERHEADERTYPE structure used to receive the
++        pointer to the buffer header
++    @return OMX_ERRORTYPE
++        If the command successfully executes, the return code will be
++        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
++    @ingroup comp buf
++ */
++
++#define OMX_UseBuffer(                                      \
++           hComponent,                                      \
++           ppBufferHdr,                                     \
++           nPortIndex,                                      \
++           pAppPrivate,                                     \
++           nSizeBytes,                                      \
++           pBuffer)                                         \
++    ((OMX_COMPONENTTYPE*)hComponent)->UseBuffer(            \
++           hComponent,                                      \
++           ppBufferHdr,                                     \
++           nPortIndex,                                      \
++           pAppPrivate,                                     \
++           nSizeBytes,                                      \
++           pBuffer)
++
++
++/** The OMX_AllocateBuffer macro will request that the component allocate
++    a new buffer and buffer header.  The component will allocate the
++    buffer and the buffer header and return a pointer to the buffer
++    header.  This is a blocking call.
++
++    The component should return from this call within 5 msec.
++
++    @param [in] hComponent
++        Handle of the component to be accessed.  This is the component
++        handle returned by the call to the OMX_GetHandle function.
++    @param [out] ppBuffer
++        pointer to an OMX_BUFFERHEADERTYPE structure used to receive
++        the pointer to the buffer header
++    @param [in] nPortIndex
++        nPortIndex is used to select the port on the component the buffer will
++        be used with.  The port can be found by using the nPortIndex
++        value as an index into the Port Definition array of the component.
++    @param [in] pAppPrivate
++        pAppPrivate is used to initialize the pAppPrivate member of the
++        buffer header structure.
++    @param [in] nSizeBytes
++        size of the buffer to allocate.  Used when bAllocateNew is true.
++    @return OMX_ERRORTYPE
++        If the command successfully executes, the return code will be
++        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
++    @ingroup comp buf
++ */
++#define OMX_AllocateBuffer(                                 \
++        hComponent,                                         \
++        ppBuffer,                                           \
++        nPortIndex,                                         \
++        pAppPrivate,                                        \
++        nSizeBytes)                                         \
++    ((OMX_COMPONENTTYPE*)hComponent)->AllocateBuffer(       \
++        hComponent,                                         \
++        ppBuffer,                                           \
++        nPortIndex,                                         \
++        pAppPrivate,                                        \
++        nSizeBytes)                     /* Macro End */
++
++
++/** The OMX_FreeBuffer macro will release a buffer header from the component
++    which was allocated using either OMX_AllocateBuffer or OMX_UseBuffer. If
++    the component allocated the buffer (see the OMX_UseBuffer macro) then
++    the component shall free the buffer and buffer header. This is a
++    blocking call.
++
++    The component should return from this call within 20 msec.
++
++    @param [in] hComponent
++        Handle of the component to be accessed.  This is the component
++        handle returned by the call to the OMX_GetHandle function.
++    @param [in] nPortIndex
++        nPortIndex is used to select the port on the component the buffer will
++        be used with.
++    @param [in] pBuffer
++        pointer to an OMX_BUFFERHEADERTYPE structure allocated with UseBuffer
++        or AllocateBuffer.
++    @return OMX_ERRORTYPE
++        If the command successfully executes, the return code will be
++        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
++    @ingroup comp buf
++ */
++#define OMX_FreeBuffer(                                     \
++        hComponent,                                         \
++        nPortIndex,                                         \
++        pBuffer)                                            \
++    ((OMX_COMPONENTTYPE*)hComponent)->FreeBuffer(           \
++        hComponent,                                         \
++        nPortIndex,                                         \
++        pBuffer)                        /* Macro End */
++
++
++/** The OMX_EmptyThisBuffer macro will send a buffer full of data to an
++    input port of a component.  The buffer will be emptied by the component
++    and returned to the application via the EmptyBufferDone call back.
++    This is a non-blocking call in that the component will record the buffer
++    and return immediately and then empty the buffer, later, at the proper
++    time.  As expected, this macro may be invoked only while the component
++    is in the OMX_StateExecuting.  If nPortIndex does not specify an input
++    port, the component shall return an error.
++
++    The component should return from this call within 5 msec.
++
++    @param [in] hComponent
++        Handle of the component to be accessed.  This is the component
++        handle returned by the call to the OMX_GetHandle function.
++    @param [in] pBuffer
++        pointer to an OMX_BUFFERHEADERTYPE structure allocated with UseBuffer
++        or AllocateBuffer.
++    @return OMX_ERRORTYPE
++        If the command successfully executes, the return code will be
++        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
++    @ingroup comp buf
++ */
++#define OMX_EmptyThisBuffer(                                \
++        hComponent,                                         \
++        pBuffer)                                            \
++    ((OMX_COMPONENTTYPE*)hComponent)->EmptyThisBuffer(      \
++        hComponent,                                         \
++        pBuffer)                        /* Macro End */
++
++
++/** The OMX_FillThisBuffer macro will send an empty buffer to an
++    output port of a component.  The buffer will be filled by the component
++    and returned to the application via the FillBufferDone call back.
++    This is a non-blocking call in that the component will record the buffer
++    and return immediately and then fill the buffer, later, at the proper
++    time.  As expected, this macro may be invoked only while the component
++    is in the OMX_ExecutingState.  If nPortIndex does not specify an output
++    port, the component shall return an error.
++
++    The component should return from this call within 5 msec.
++
++    @param [in] hComponent
++        Handle of the component to be accessed.  This is the component
++        handle returned by the call to the OMX_GetHandle function.
++    @param [in] pBuffer
++        pointer to an OMX_BUFFERHEADERTYPE structure allocated with UseBuffer
++        or AllocateBuffer.
++    @return OMX_ERRORTYPE
++        If the command successfully executes, the return code will be
++        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
++    @ingroup comp buf
++ */
++#define OMX_FillThisBuffer(                                 \
++        hComponent,                                         \
++        pBuffer)                                            \
++    ((OMX_COMPONENTTYPE*)hComponent)->FillThisBuffer(       \
++        hComponent,                                         \
++        pBuffer)                        /* Macro End */
++
++
++
++/** The OMX_UseEGLImage macro will request that the component use
++    a EGLImage provided by EGL (and allocate its own buffer header)
++    This is a blocking call.
++
++    The component should return from this call within 20 msec.
++
++    @param [in] hComponent
++        Handle of the component to be accessed.  This is the component
++        handle returned by the call to the OMX_GetHandle function.
++    @param [out] ppBuffer
++        pointer to an OMX_BUFFERHEADERTYPE structure used to receive the
++        pointer to the buffer header.  Note that the memory location used
++        for this buffer is NOT visible to the IL Client.
++    @param [in] nPortIndex
++        nPortIndex is used to select the port on the component the buffer will
++        be used with.  The port can be found by using the nPortIndex
++        value as an index into the Port Definition array of the component.
++    @param [in] pAppPrivate
++        pAppPrivate is used to initialize the pAppPrivate member of the
++        buffer header structure.
++    @param [in] eglImage
++        eglImage contains the handle of the EGLImage to use as a buffer on the
++        specified port.  The component is expected to validate properties of
++        the EGLImage against the configuration of the port to ensure the component
++        can use the EGLImage as a buffer.
++    @return OMX_ERRORTYPE
++        If the command successfully executes, the return code will be
++        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
++    @ingroup comp buf
++ */
++#define OMX_UseEGLImage(                                    \
++           hComponent,                                      \
++           ppBufferHdr,                                     \
++           nPortIndex,                                      \
++           pAppPrivate,                                     \
++           eglImage)                                        \
++    ((OMX_COMPONENTTYPE*)hComponent)->UseEGLImage(          \
++           hComponent,                                      \
++           ppBufferHdr,                                     \
++           nPortIndex,                                      \
++           pAppPrivate,                                     \
++           eglImage)
++
++/** The OMX_Init method is used to initialize the OMX core.  It shall be the
++    first call made into OMX and it should only be executed one time without
++    an interviening OMX_Deinit call.
++
++    The core should return from this call within 20 msec.
++
++    @return OMX_ERRORTYPE
++        If the command successfully executes, the return code will be
++        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
++    @ingroup core
++ */
++OMX_API OMX_ERRORTYPE OMX_APIENTRY OMX_Init(void);
++
++
++/** The OMX_Deinit method is used to deinitialize the OMX core.  It shall be
++    the last call made into OMX. In the event that the core determines that
++    thare are components loaded when this call is made, the core may return
++    with an error rather than try to unload the components.
++
++    The core should return from this call within 20 msec.
++
++    @return OMX_ERRORTYPE
++        If the command successfully executes, the return code will be
++        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
++    @ingroup core
++ */
++OMX_API OMX_ERRORTYPE OMX_APIENTRY OMX_Deinit(void);
++
++
++/** The OMX_ComponentNameEnum method will enumerate through all the names of
++    recognised valid components in the system. This function is provided
++    as a means to detect all the components in the system run-time. There is
++    no strict ordering to the enumeration order of component names, although
++    each name will only be enumerated once.  If the OMX core supports run-time
++    installation of new components, it is only requried to detect newly
++    installed components when the first call to enumerate component names
++    is made (i.e. when nIndex is 0x0).
++
++    The core should return from this call in 20 msec.
++
++    @param [out] cComponentName
++        pointer to a null terminated string with the component name.  The
++        names of the components are strings less than 127 bytes in length
++        plus the trailing null for a maximum size of 128 bytes.  An example
++        of a valid component name is "OMX.TI.AUDIO.DSP.MIXER\0".  Names are
++        assigned by the vendor, but shall start with "OMX." and then have
++        the Vendor designation next.
++    @param [in] nNameLength
++        number of characters in the cComponentName string.  With all
++        component name strings restricted to less than 128 characters
++        (including the trailing null) it is recomended that the caller
++        provide a input string for the cComponentName of 128 characters.
++    @param [in] nIndex
++        number containing the enumeration index for the component.
++        Multiple calls to OMX_ComponentNameEnum with increasing values
++        of nIndex will enumerate through the component names in the
++        system until OMX_ErrorNoMore is returned.  The value of nIndex
++        is 0 to (N-1), where N is the number of valid installed components
++        in the system.
++    @return OMX_ERRORTYPE
++        If the command successfully executes, the return code will be
++        OMX_ErrorNone.  When the value of nIndex exceeds the number of
++        components in the system minus 1, OMX_ErrorNoMore will be
++        returned. Otherwise the appropriate OMX error will be returned.
++    @ingroup core
++ */
++OMX_API OMX_ERRORTYPE OMX_APIENTRY OMX_ComponentNameEnum(
++    OMX_OUT OMX_STRING cComponentName,
++    OMX_IN  OMX_U32 nNameLength,
++    OMX_IN  OMX_U32 nIndex);
++
++
++/** The OMX_GetHandle method will locate the component specified by the
++    component name given, load that component into memory and then invoke
++    the component's methods to create an instance of the component.
++
++    The core should return from this call within 20 msec.
++
++    @param [out] pHandle
++        pointer to an OMX_HANDLETYPE pointer to be filled in by this method.
++    @param [in] cComponentName
++        pointer to a null terminated string with the component name.  The
++        names of the components are strings less than 127 bytes in length
++        plus the trailing null for a maximum size of 128 bytes.  An example
++        of a valid component name is "OMX.TI.AUDIO.DSP.MIXER\0".  Names are
++        assigned by the vendor, but shall start with "OMX." and then have
++        the Vendor designation next.
++    @param [in] pAppData
++        pointer to an application defined value that will be returned
++        during callbacks so that the application can identify the source
++        of the callback.
++    @param [in] pCallBacks
++        pointer to a OMX_CALLBACKTYPE structure that will be passed to the
++        component to initialize it with.
++    @return OMX_ERRORTYPE
++        If the command successfully executes, the return code will be
++        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
++    @ingroup core
++ */
++OMX_API OMX_ERRORTYPE OMX_APIENTRY OMX_GetHandle(
++    OMX_OUT OMX_HANDLETYPE* pHandle,
++    OMX_IN  OMX_STRING cComponentName,
++    OMX_IN  OMX_PTR pAppData,
++    OMX_IN  OMX_CALLBACKTYPE* pCallBacks);
++
++
++/** The OMX_FreeHandle method will free a handle allocated by the OMX_GetHandle
++    method.  If the component reference count goes to zero, the component will
++    be unloaded from memory.
++
++    The core should return from this call within 20 msec when the component is
++    in the OMX_StateLoaded state.
++
++    @param [in] hComponent
++        Handle of the component to be accessed.  This is the component
++        handle returned by the call to the GetHandle function.
++    @return OMX_ERRORTYPE
++        If the command successfully executes, the return code will be
++        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
++    @ingroup core
++ */
++OMX_API OMX_ERRORTYPE OMX_APIENTRY OMX_FreeHandle(
++    OMX_IN  OMX_HANDLETYPE hComponent);
++
++
++
++/** The OMX_SetupTunnel method will handle the necessary calls to the components
++    to setup the specified tunnel the two components.  NOTE: This is
++    an actual method (not a #define macro).  This method will make calls into
++    the component ComponentTunnelRequest method to do the actual tunnel
++    connection.
++
++    The ComponentTunnelRequest method on both components will be called.
++    This method shall not be called unless the component is in the
++    OMX_StateLoaded state except when the ports used for the tunnel are
++    disabled. In this case, the component may be in the OMX_StateExecuting,
++    OMX_StatePause, or OMX_StateIdle states.
++
++    The core should return from this call within 20 msec.
++
++    @param [in] hOutput
++        Handle of the component to be accessed.  Also this is the handle
++        of the component whose port, specified in the nPortOutput parameter
++        will be used the source for the tunnel. This is the component handle
++        returned by the call to the OMX_GetHandle function.  There is a
++        requirement that hOutput be the source for the data when
++        tunelling (i.e. nPortOutput is an output port).  If 0x0, the component
++        specified in hInput will have it's port specified in nPortInput
++        setup for communication with the application / IL client.
++    @param [in] nPortOutput
++        nPortOutput is used to select the source port on component to be
++        used in the tunnel.
++    @param [in] hInput
++        This is the component to setup the tunnel with. This is the handle
++        of the component whose port, specified in the nPortInput parameter
++        will be used the destination for the tunnel. This is the component handle
++        returned by the call to the OMX_GetHandle function.  There is a
++        requirement that hInput be the destination for the data when
++        tunelling (i.e. nPortInut is an input port).   If 0x0, the component
++        specified in hOutput will have it's port specified in nPortPOutput
++        setup for communication with the application / IL client.
++    @param [in] nPortInput
++        nPortInput is used to select the destination port on component to be
++        used in the tunnel.
++    @return OMX_ERRORTYPE
++        If the command successfully executes, the return code will be
++        OMX_ErrorNone.  Otherwise the appropriate OMX error will be returned.
++        When OMX_ErrorNotImplemented is returned, one or both components is
++        a non-interop component and does not support tunneling.
++
++        On failure, the ports of both components are setup for communication
++        with the application / IL Client.
++    @ingroup core tun
++ */
++OMX_API OMX_ERRORTYPE OMX_APIENTRY OMX_SetupTunnel(
++    OMX_IN  OMX_HANDLETYPE hOutput,
++    OMX_IN  OMX_U32 nPortOutput,
++    OMX_IN  OMX_HANDLETYPE hInput,
++    OMX_IN  OMX_U32 nPortInput);
++
++/** @ingroup cp */
++OMX_API OMX_ERRORTYPE   OMX_GetContentPipe(
++    OMX_OUT OMX_HANDLETYPE *hPipe,
++    OMX_IN OMX_STRING szURI);
++
++/** The OMX_GetComponentsOfRole method will return the number of components that support the given
++    role and (if the compNames field is non-NULL) the names of those components. The call will fail if
++    an insufficiently sized array of names is supplied. To ensure the array is sufficiently sized the
++    client should:
++        * first call this function with the compNames field NULL to determine the number of component names
++        * second call this function with the compNames field pointing to an array of names allocated
++          according to the number returned by the first call.
++
++    The core should return from this call within 5 msec.
++
++    @param [in] role
++        This is generic standard component name consisting only of component class
++        name and the type within that class (e.g. 'audio_decoder.aac').
++    @param [inout] pNumComps
++        This is used both as input and output.
++
++        If compNames is NULL, the input is ignored and the output specifies how many components support
++        the given role.
++
++        If compNames is not NULL, on input it bounds the size of the input structure and
++        on output, it specifies the number of components string names listed within the compNames parameter.
++    @param [inout] compNames
++        If NULL this field is ignored. If non-NULL this points to an array of 128-byte strings which accepts
++        a list of the names of all physical components that implement the specified standard component name.
++        Each name is NULL terminated. numComps indicates the number of names.
++    @ingroup core
++ */
++OMX_API OMX_ERRORTYPE OMX_GetComponentsOfRole (
++    OMX_IN      OMX_STRING role,
++    OMX_INOUT   OMX_U32 *pNumComps,
++    OMX_INOUT   OMX_U8  **compNames);
++
++/** The OMX_GetRolesOfComponent method will return the number of roles supported by the given
++    component and (if the roles field is non-NULL) the names of those roles. The call will fail if
++    an insufficiently sized array of names is supplied. To ensure the array is sufficiently sized the
++    client should:
++        * first call this function with the roles field NULL to determine the number of role names
++        * second call this function with the roles field pointing to an array of names allocated
++          according to the number returned by the first call.
++
++    The core should return from this call within 5 msec.
++
++    @param [in] compName
++        This is the name of the component being queried about.
++    @param [inout] pNumRoles
++        This is used both as input and output.
++
++        If roles is NULL, the input is ignored and the output specifies how many roles the component supports.
++
++        If compNames is not NULL, on input it bounds the size of the input structure and
++        on output, it specifies the number of roles string names listed within the roles parameter.
++    @param [out] roles
++        If NULL this field is ignored. If non-NULL this points to an array of 128-byte strings
++        which accepts a list of the names of all standard components roles implemented on the
++        specified component name. numComps indicates the number of names.
++    @ingroup core
++ */
++OMX_API OMX_ERRORTYPE OMX_GetRolesOfComponent (
++    OMX_IN      OMX_STRING compName,
++    OMX_INOUT   OMX_U32 *pNumRoles,
++    OMX_OUT     OMX_U8 **roles);
++
++#ifdef __cplusplus
++}
++#endif /* __cplusplus */
++
++#endif
++/* File EOF */
++
+diff --git a/sf-extra/omx-il/OMX_CoreExt.h b/sf-extra/omx-il/OMX_CoreExt.h
+new file mode 100644
+index 00000000..e2e21cc0
+--- /dev/null
++++ b/sf-extra/omx-il/OMX_CoreExt.h
+@@ -0,0 +1,73 @@
++/*
++ * Copyright (c) 2016 The Khronos Group Inc.
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining
++ * a copy of this software and associated documentation files (the
++ * "Software"), to deal in the Software without restriction, including
++ * without limitation the rights to use, copy, modify, merge, publish,
++ * distribute, sublicense, and/or sell copies of the Software, and to
++ * permit persons to whom the Software is furnished to do so, subject
++ * to the following conditions:
++ * The above copyright notice and this permission notice shall be included
++ * in all copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
++ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
++ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
++ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
++ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
++ *
++ */
++
++/** OMX_CoreExt.h - OpenMax IL version 1.1.2
++ * The OMX_CoreExt header file contains extensions to the definitions used
++ * by both the application and the component to access common items.
++ */
++
++#ifndef OMX_CoreExt_h
++#define OMX_CoreExt_h
++
++#ifdef __cplusplus
++extern "C" {
++#endif /* __cplusplus */
++
++/* Each OMX header shall include all required header files to allow the
++ * header to compile without errors.  The includes below are required
++ * for this header file to compile successfully
++ */
++#include <OMX_Core.h>
++
++/** Extensions to the standard IL errors. */ 
++typedef enum OMX_ERROREXTTYPE 
++{
++    OMX_ErrorInvalidMode = (OMX_S32) (OMX_ErrorKhronosExtensions + 0x00000001),
++    OMX_ErrorExtMax = 0x7FFFFFFF
++} OMX_ERROREXTTYPE;
++
++
++/** Event type extensions. */
++typedef enum OMX_EVENTEXTTYPE
++{
++    OMX_EventIndexSettingChanged = OMX_EventKhronosExtensions, /**< component signals the IL client of a change
++                                                                    in a param, config, or extension */
++    OMX_EventExtMax = 0x7FFFFFFF
++} OMX_EVENTEXTTYPE;
++
++
++/** Enable or disable a callback event. */
++typedef struct OMX_CONFIG_CALLBACKREQUESTTYPE {
++    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_INDEXTYPE nIndex;       /**< the index the callback is requested for */
++    OMX_BOOL bEnable;           /**< enable (OMX_TRUE) or disable (OMX_FALSE) the callback */
++} OMX_CONFIG_CALLBACKREQUESTTYPE;
++
++#ifdef __cplusplus
++}
++#endif /* __cplusplus */
++
++#endif /* OMX_CoreExt_h */
++/* File EOF */
+diff --git a/sf-extra/omx-il/OMX_IVCommon.h b/sf-extra/omx-il/OMX_IVCommon.h
+new file mode 100644
+index 00000000..9aad7e96
+--- /dev/null
++++ b/sf-extra/omx-il/OMX_IVCommon.h
+@@ -0,0 +1,993 @@
++/**
++ * Copyright (c) 2008 The Khronos Group Inc.
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining
++ * a copy of this software and associated documentation files (the
++ * "Software"), to deal in the Software without restriction, including
++ * without limitation the rights to use, copy, modify, merge, publish,
++ * distribute, sublicense, and/or sell copies of the Software, and to
++ * permit persons to whom the Software is furnished to do so, subject
++ * to the following conditions:
++ * The above copyright notice and this permission notice shall be included
++ * in all copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
++ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
++ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
++ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
++ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
++ *
++ */
++
++/**
++ * @file OMX_IVCommon.h - OpenMax IL version 1.1.2
++ *  The structures needed by Video and Image components to exchange
++ *  parameters and configuration data with the components.
++ */
++#ifndef OMX_IVCommon_h
++#define OMX_IVCommon_h
++
++#ifdef __cplusplus
++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
++ */
++
++#include <OMX_Core.h>
++
++/** @defgroup iv OpenMAX IL Imaging and Video Domain
++ * Common structures for OpenMAX IL Imaging and Video domains
++ * @{
++ */
++
++
++/**
++ * Enumeration defining possible uncompressed image/video formats.
++ *
++ * ENUMS:
++ *  Unused                 : Placeholder value when format is N/A
++ *  Monochrome             : black and white
++ *  8bitRGB332             : Red 7:5, Green 4:2, Blue 1:0
++ *  12bitRGB444            : Red 11:8, Green 7:4, Blue 3:0
++ *  16bitARGB4444          : Alpha 15:12, Red 11:8, Green 7:4, Blue 3:0
++ *  16bitARGB1555          : Alpha 15, Red 14:10, Green 9:5, Blue 4:0
++ *  16bitRGB565            : Red 15:11, Green 10:5, Blue 4:0
++ *  16bitBGR565            : Blue 15:11, Green 10:5, Red 4:0
++ *  18bitRGB666            : Red 17:12, Green 11:6, Blue 5:0
++ *  18bitARGB1665          : Alpha 17, Red 16:11, Green 10:5, Blue 4:0
++ *  19bitARGB1666          : Alpha 18, Red 17:12, Green 11:6, Blue 5:0
++ *  24bitRGB888            : Red 24:16, Green 15:8, Blue 7:0
++ *  24bitBGR888            : Blue 24:16, Green 15:8, Red 7:0
++ *  24bitARGB1887          : Alpha 23, Red 22:15, Green 14:7, Blue 6:0
++ *  25bitARGB1888          : Alpha 24, Red 23:16, Green 15:8, Blue 7:0
++ *  32bitBGRA8888          : Blue 31:24, Green 23:16, Red 15:8, Alpha 7:0
++ *  32bitARGB8888          : Alpha 31:24, Red 23:16, Green 15:8, Blue 7:0
++ *  YUV411Planar           : U,Y are subsampled by a factor of 4 horizontally
++ *  YUV411PackedPlanar     : packed per payload in planar slices
++ *  YUV420Planar           : Three arrays Y,U,V.
++ *  YUV420PackedPlanar     : packed per payload in planar slices
++ *  YUV420SemiPlanar       : Two arrays, one is all Y, the other is U and V
++ *  YUV422Planar           : Three arrays Y,U,V.
++ *  YUV422PackedPlanar     : packed per payload in planar slices
++ *  YUV422SemiPlanar       : Two arrays, one is all Y, the other is U and V
++ *  YCbYCr                 : Organized as 16bit YUYV (i.e. YCbYCr)
++ *  YCrYCb                 : Organized as 16bit YVYU (i.e. YCrYCb)
++ *  CbYCrY                 : Organized as 16bit UYVY (i.e. CbYCrY)
++ *  CrYCbY                 : Organized as 16bit VYUY (i.e. CrYCbY)
++ *  YUV444Interleaved      : Each pixel contains equal parts YUV
++ *  RawBayer8bit           : SMIA camera output format
++ *  RawBayer10bit          : SMIA camera output format
++ *  RawBayer8bitcompressed : SMIA camera output format
++ */
++typedef enum OMX_COLOR_FORMATTYPE {
++    OMX_COLOR_FormatUnused,
++    OMX_COLOR_FormatMonochrome,
++    OMX_COLOR_Format8bitRGB332,
++    OMX_COLOR_Format12bitRGB444,
++    OMX_COLOR_Format16bitARGB4444,
++    OMX_COLOR_Format16bitARGB1555,
++    OMX_COLOR_Format16bitRGB565,
++    OMX_COLOR_Format16bitBGR565,
++    OMX_COLOR_Format18bitRGB666,
++    OMX_COLOR_Format18bitARGB1665,
++    OMX_COLOR_Format19bitARGB1666,
++    OMX_COLOR_Format24bitRGB888,
++    OMX_COLOR_Format24bitBGR888,
++    OMX_COLOR_Format24bitARGB1887,
++    OMX_COLOR_Format25bitARGB1888,
++    OMX_COLOR_Format32bitBGRA8888,
++    OMX_COLOR_Format32bitARGB8888,
++    OMX_COLOR_FormatYUV411Planar,
++    OMX_COLOR_FormatYUV411PackedPlanar,
++    OMX_COLOR_FormatYUV420Planar,
++    OMX_COLOR_FormatYUV420PackedPlanar,
++    OMX_COLOR_FormatYUV420SemiPlanar,
++    OMX_COLOR_FormatYUV422Planar,
++    OMX_COLOR_FormatYUV422PackedPlanar,
++    OMX_COLOR_FormatYUV422SemiPlanar,
++    OMX_COLOR_FormatYCbYCr,
++    OMX_COLOR_FormatYCrYCb,
++    OMX_COLOR_FormatCbYCrY,
++    OMX_COLOR_FormatCrYCbY,
++    OMX_COLOR_FormatYUV444Interleaved,
++    OMX_COLOR_FormatRawBayer8bit,
++    OMX_COLOR_FormatRawBayer10bit,
++    OMX_COLOR_FormatRawBayer8bitcompressed,
++    OMX_COLOR_FormatL2,
++    OMX_COLOR_FormatL4,
++    OMX_COLOR_FormatL8,
++    OMX_COLOR_FormatL16,
++    OMX_COLOR_FormatL24,
++    OMX_COLOR_FormatL32,
++    OMX_COLOR_FormatYUV420PackedSemiPlanar,
++    OMX_COLOR_FormatYUV422PackedSemiPlanar,
++    OMX_COLOR_Format18BitBGR666,
++    OMX_COLOR_Format24BitARGB6666,
++    OMX_COLOR_Format24BitABGR6666,
++    OMX_COLOR_FormatKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_COLOR_FormatVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++
++    /* Starfive extensions */
++    /* I420 */
++    OMX_COLOR_FormatYUV420Planar_P10_16BIT_MSB,
++    OMX_COLOR_FormatYUV420Planar_P10_16BIT_LSB,
++    OMX_COLOR_FormatYUV420Planar_P12_16BIT_MSB,
++    OMX_COLOR_FormatYUV420Planar_P12_16BIT_LSB,
++    /* NV12 */
++    OMX_COLOR_FormatYUV420SemiPlanar_P10_16BIT_MSB,
++    OMX_COLOR_FormatYUV420SemiPlanar_P10_16BIT_LSB,
++    OMX_COLOR_FormatYUV420SemiPlanar_P12_16BIT_MSB,
++    OMX_COLOR_FormatYUV420SemiPlanar_P12_16BIT_LSB,
++    /* NV21 */
++    OMX_COLOR_FormatYVU420SemiPlanar,
++    OMX_COLOR_FormatYVU420SemiPlanar_P10_16BIT_MSB,
++    OMX_COLOR_FormatYVU420SemiPlanar_P10_16BIT_LSB,
++    OMX_COLOR_FormatYVU420SemiPlanar_P12_16BIT_MSB,
++    OMX_COLOR_FormatYVU420SemiPlanar_P12_16BIT_LSB,
++    /* I422 */
++    OMX_COLOR_FormatYUV422Planar_P10_16BIT_MSB,
++    OMX_COLOR_FormatYUV422Planar_P10_16BIT_LSB,
++    OMX_COLOR_FormatYUV422Planar_P12_16BIT_MSB,
++    OMX_COLOR_FormatYUV422Planar_P12_16BIT_LSB,
++    /* NV16 */
++    OMX_COLOR_FormatYUV422SemiPlanar_P10_16BIT_MSB,
++    OMX_COLOR_FormatYUV422SemiPlanar_P10_16BIT_LSB,
++    OMX_COLOR_FormatYUV422SemiPlanar_P12_16BIT_MSB,
++    OMX_COLOR_FormatYUV422SemiPlanar_P12_16BIT_LSB,
++    /* NV61 */
++    OMX_COLOR_FormatYVU422SemiPlanar,
++    OMX_COLOR_FormatYVU422SemiPlanar_P10_16BIT_MSB,
++    OMX_COLOR_FormatYVU422SemiPlanar_P10_16BIT_LSB,
++    OMX_COLOR_FormatYVU422SemiPlanar_P12_16BIT_MSB,
++    OMX_COLOR_FormatYVU422SemiPlanar_P12_16BIT_LSB,
++    /* YUYV */
++    OMX_COLOR_FormatYCbYCr_P10_16BIT_MSB,
++    OMX_COLOR_FormatYCbYCr_P10_16BIT_LSB,
++    OMX_COLOR_FormatYCbYCr_P12_16BIT_MSB,
++    OMX_COLOR_FormatYCbYCr_P12_16BIT_LSB,
++    /* YVYU */
++    OMX_COLOR_FormatYCrYCb_P10_16BIT_MSB,
++    OMX_COLOR_FormatYCrYCb_P10_16BIT_LSB,
++    OMX_COLOR_FormatYCrYCb_P12_16BIT_MSB,
++    OMX_COLOR_FormatYCrYCb_P12_16BIT_LSB,
++    /* UYVY */
++    OMX_COLOR_FormatCbYCrY_P10_16BIT_MSB,
++    OMX_COLOR_FormatCbYCrY_P10_16BIT_LSB,
++    OMX_COLOR_FormatCbYCrY_P12_16BIT_MSB,
++    OMX_COLOR_FormatCbYCrY_P12_16BIT_LSB,
++    /* VYUY */
++    OMX_COLOR_FormatCrYCbY_P10_16BIT_MSB,
++    OMX_COLOR_FormatCrYCbY_P10_16BIT_LSB,
++    OMX_COLOR_FormatCrYCbY_P12_16BIT_MSB,
++    OMX_COLOR_FormatCrYCbY_P12_16BIT_LSB,
++    /* I444 */
++    OMX_COLOR_FormatYUV444Planar,
++    OMX_COLOR_FormatYUV444Planar_P10_16BIT_MSB,
++    OMX_COLOR_FormatYUV444Planar_P10_16BIT_LSB,
++    OMX_COLOR_FormatYUV444Planar_P12_16BIT_MSB,
++    OMX_COLOR_FormatYUV444Planar_P12_16BIT_LSB,
++    /* YUV444PACKED */
++    OMX_COLOR_FormatYUV444Interleaved_P10_16BIT_MSB,
++    OMX_COLOR_FormatYUV444Interleaved_P10_16BIT_LSB,
++    OMX_COLOR_FormatYUV444Interleaved_P12_16BIT_MSB,
++    OMX_COLOR_FormatYUV444Interleaved_P12_16BIT_LSB,
++    /* YUV400 */
++    OMX_COLOR_FormatYUV400,
++    OMX_COLOR_FormatYUV400_P10_16BIT_MSB,
++    OMX_COLOR_FormatYUV400_P10_16BIT_LSB,
++    OMX_COLOR_FormatYUV400_P12_16BIT_MSB,
++    OMX_COLOR_FormatYUV400_P12_16BIT_LSB,
++    /* Starfive extensions end */
++
++    OMX_COLOR_FormatMax = 0x7FFFFFFF
++} OMX_COLOR_FORMATTYPE;
++
++
++/**
++ * Defines the matrix for conversion from RGB to YUV or vice versa.
++ * iColorMatrix should be initialized with the fixed point values
++ * used in converting between formats.
++ */
++typedef struct OMX_CONFIG_COLORCONVERSIONTYPE {
++    OMX_U32 nSize;              /**< Size of the structure in bytes */
++    OMX_VERSIONTYPE nVersion;   /**< OMX specification version info */
++    OMX_U32 nPortIndex;         /**< Port that this struct applies to */
++    OMX_S32 xColorMatrix[3][3]; /**< Stored in signed Q16 format */
++    OMX_S32 xColorOffset[4];    /**< Stored in signed Q16 format */
++} OMX_CONFIG_COLORCONVERSIONTYPE;
++
++
++/**
++ * Structure defining percent to scale each frame dimension.  For example:
++ * To make the width 50% larger, use fWidth = 1.5 and to make the width
++ * 1/2 the original size, use fWidth = 0.5
++ */
++typedef struct OMX_CONFIG_SCALEFACTORTYPE {
++    OMX_U32 nSize;            /**< Size of the structure in bytes */
++    OMX_VERSIONTYPE nVersion; /**< OMX specification version info */
++    OMX_U32 nPortIndex;       /**< Port that this struct applies to */
++    OMX_S32 xWidth;           /**< Fixed point value stored as Q16 */
++    OMX_S32 xHeight;          /**< Fixed point value stored as Q16 */
++} OMX_CONFIG_SCALEFACTORTYPE;
++
++
++/**
++ * Enumeration of possible image filter types
++ */
++typedef enum OMX_IMAGEFILTERTYPE {
++    OMX_ImageFilterNone,
++    OMX_ImageFilterNoise,
++    OMX_ImageFilterEmboss,
++    OMX_ImageFilterNegative,
++    OMX_ImageFilterSketch,
++    OMX_ImageFilterOilPaint,
++    OMX_ImageFilterHatch,
++    OMX_ImageFilterGpen,
++    OMX_ImageFilterAntialias,
++    OMX_ImageFilterDeRing,
++    OMX_ImageFilterSolarize,
++    OMX_ImageFilterKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_ImageFilterVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_ImageFilterMax = 0x7FFFFFFF
++} OMX_IMAGEFILTERTYPE;
++
++
++/**
++ * Image filter configuration
++ *
++ * STRUCT MEMBERS:
++ *  nSize        : Size of the structure in bytes
++ *  nVersion     : OMX specification version information
++ *  nPortIndex   : Port that this structure applies to
++ *  eImageFilter : Image filter type enumeration
++ */
++typedef struct OMX_CONFIG_IMAGEFILTERTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_IMAGEFILTERTYPE eImageFilter;
++} OMX_CONFIG_IMAGEFILTERTYPE;
++
++
++/**
++ * Customized U and V for color enhancement
++ *
++ * STRUCT MEMBERS:
++ *  nSize             : Size of the structure in bytes
++ *  nVersion          : OMX specification version information
++ *  nPortIndex        : Port that this structure applies to
++ *  bColorEnhancement : Enable/disable color enhancement
++ *  nCustomizedU      : Practical values: 16-240, range: 0-255, value set for
++ *                      U component
++ *  nCustomizedV      : Practical values: 16-240, range: 0-255, value set for
++ *                      V component
++ */
++typedef struct OMX_CONFIG_COLORENHANCEMENTTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_BOOL bColorEnhancement;
++    OMX_U8 nCustomizedU;
++    OMX_U8 nCustomizedV;
++} OMX_CONFIG_COLORENHANCEMENTTYPE;
++
++
++/**
++ * Define color key and color key mask
++ *
++ * STRUCT MEMBERS:
++ *  nSize      : Size of the structure in bytes
++ *  nVersion   : OMX specification version information
++ *  nPortIndex : Port that this structure applies to
++ *  nARGBColor : 32bit Alpha, Red, Green, Blue Color
++ *  nARGBMask  : 32bit Mask for Alpha, Red, Green, Blue channels
++ */
++typedef struct OMX_CONFIG_COLORKEYTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_U32 nARGBColor;
++    OMX_U32 nARGBMask;
++} OMX_CONFIG_COLORKEYTYPE;
++
++
++/**
++ * List of color blend types for pre/post processing
++ *
++ * ENUMS:
++ *  None          : No color blending present
++ *  AlphaConstant : Function is (alpha_constant * src) +
++ *                  (1 - alpha_constant) * dst)
++ *  AlphaPerPixel : Function is (alpha * src) + (1 - alpha) * dst)
++ *  Alternate     : Function is alternating pixels from src and dst
++ *  And           : Function is (src & dst)
++ *  Or            : Function is (src | dst)
++ *  Invert        : Function is ~src
++ */
++typedef enum OMX_COLORBLENDTYPE {
++    OMX_ColorBlendNone,
++    OMX_ColorBlendAlphaConstant,
++    OMX_ColorBlendAlphaPerPixel,
++    OMX_ColorBlendAlternate,
++    OMX_ColorBlendAnd,
++    OMX_ColorBlendOr,
++    OMX_ColorBlendInvert,
++    OMX_ColorBlendKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_ColorBlendVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_ColorBlendMax = 0x7FFFFFFF
++} OMX_COLORBLENDTYPE;
++
++
++/**
++ * Color blend configuration
++ *
++ * STRUCT MEMBERS:
++ *  nSize             : Size of the structure in bytes
++ *  nVersion          : OMX specification version information
++ *  nPortIndex        : Port that this structure applies to
++ *  nRGBAlphaConstant : Constant global alpha values when global alpha is used
++ *  eColorBlend       : Color blend type enumeration
++ */
++typedef struct OMX_CONFIG_COLORBLENDTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_U32 nRGBAlphaConstant;
++    OMX_COLORBLENDTYPE  eColorBlend;
++} OMX_CONFIG_COLORBLENDTYPE;
++
++
++/**
++ * Hold frame dimension
++ *
++ * STRUCT MEMBERS:
++ *  nSize      : Size of the structure in bytes
++ *  nVersion   : OMX specification version information
++ *  nPortIndex : Port that this structure applies to
++ *  nWidth     : Frame width in pixels
++ *  nHeight    : Frame height in pixels
++ */
++typedef struct OMX_FRAMESIZETYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_U32 nWidth;
++    OMX_U32 nHeight;
++} OMX_FRAMESIZETYPE;
++
++
++/**
++ * Rotation configuration
++ *
++ * STRUCT MEMBERS:
++ *  nSize      : Size of the structure in bytes
++ *  nVersion   : OMX specification version information
++ *  nPortIndex : Port that this structure applies to
++ *  nRotation  : +/- integer rotation value
++ */
++typedef struct OMX_CONFIG_ROTATIONTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_S32 nRotation;
++} OMX_CONFIG_ROTATIONTYPE;
++
++
++/**
++ * Possible mirroring directions for pre/post processing
++ *
++ * ENUMS:
++ *  None       : No mirroring
++ *  Vertical   : Vertical mirroring, flip on X axis
++ *  Horizontal : Horizontal mirroring, flip on Y axis
++ *  Both       : Both vertical and horizontal mirroring
++ */
++typedef enum OMX_MIRRORTYPE {
++    OMX_MirrorNone = 0,
++    OMX_MirrorVertical,
++    OMX_MirrorHorizontal,
++    OMX_MirrorBoth,
++    OMX_MirrorKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_MirrorVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_MirrorMax = 0x7FFFFFFF
++} OMX_MIRRORTYPE;
++
++
++/**
++ * Mirroring configuration
++ *
++ * STRUCT MEMBERS:
++ *  nSize      : Size of the structure in bytes
++ *  nVersion   : OMX specification version information
++ *  nPortIndex : Port that this structure applies to
++ *  eMirror    : Mirror type enumeration
++ */
++typedef struct OMX_CONFIG_MIRRORTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_MIRRORTYPE  eMirror;
++} OMX_CONFIG_MIRRORTYPE;
++
++
++/**
++ * Position information only
++ *
++ * STRUCT MEMBERS:
++ *  nSize      : Size of the structure in bytes
++ *  nVersion   : OMX specification version information
++ *  nPortIndex : Port that this structure applies to
++ *  nX         : X coordinate for the point
++ *  nY         : Y coordinate for the point
++ */
++typedef struct OMX_CONFIG_POINTTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_S32 nX;
++    OMX_S32 nY;
++} OMX_CONFIG_POINTTYPE;
++
++
++/**
++ * Frame size plus position
++ *
++ * STRUCT MEMBERS:
++ *  nSize      : Size of the structure in bytes
++ *  nVersion   : OMX specification version information
++ *  nPortIndex : Port that this structure applies to
++ *  nLeft      : X Coordinate of the top left corner of the rectangle
++ *  nTop       : Y Coordinate of the top left corner of the rectangle
++ *  nWidth     : Width of the rectangle
++ *  nHeight    : Height of the rectangle
++ */
++typedef struct OMX_CONFIG_RECTTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_S32 nLeft;
++    OMX_S32 nTop;
++    OMX_U32 nWidth;
++    OMX_U32 nHeight;
++} OMX_CONFIG_RECTTYPE;
++
++
++/**
++ * Deblocking state; it is required to be set up before starting the codec
++ *
++ * STRUCT MEMBERS:
++ *  nSize       : Size of the structure in bytes
++ *  nVersion    : OMX specification version information
++ *  nPortIndex  : Port that this structure applies to
++ *  bDeblocking : Enable/disable deblocking mode
++ */
++typedef struct OMX_PARAM_DEBLOCKINGTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_BOOL bDeblocking;
++} OMX_PARAM_DEBLOCKINGTYPE;
++
++
++/**
++ * Stabilization state
++ *
++ * STRUCT MEMBERS:
++ *  nSize      : Size of the structure in bytes
++ *  nVersion   : OMX specification version information
++ *  nPortIndex : Port that this structure applies to
++ *  bStab      : Enable/disable frame stabilization state
++ */
++typedef struct OMX_CONFIG_FRAMESTABTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_BOOL bStab;
++} OMX_CONFIG_FRAMESTABTYPE;
++
++
++/**
++ * White Balance control type
++ *
++ * STRUCT MEMBERS:
++ *  SunLight : Referenced in JSR-234
++ *  Flash    : Optimal for device's integrated flash
++ */
++typedef enum OMX_WHITEBALCONTROLTYPE {
++    OMX_WhiteBalControlOff = 0,
++    OMX_WhiteBalControlAuto,
++    OMX_WhiteBalControlSunLight,
++    OMX_WhiteBalControlCloudy,
++    OMX_WhiteBalControlShade,
++    OMX_WhiteBalControlTungsten,
++    OMX_WhiteBalControlFluorescent,
++    OMX_WhiteBalControlIncandescent,
++    OMX_WhiteBalControlFlash,
++    OMX_WhiteBalControlHorizon,
++    OMX_WhiteBalControlKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_WhiteBalControlVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_WhiteBalControlMax = 0x7FFFFFFF
++} OMX_WHITEBALCONTROLTYPE;
++
++
++/**
++ * White Balance control configuration
++ *
++ * STRUCT MEMBERS:
++ *  nSize            : Size of the structure in bytes
++ *  nVersion         : OMX specification version information
++ *  nPortIndex       : Port that this structure applies to
++ *  eWhiteBalControl : White balance enumeration
++ */
++typedef struct OMX_CONFIG_WHITEBALCONTROLTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_WHITEBALCONTROLTYPE eWhiteBalControl;
++} OMX_CONFIG_WHITEBALCONTROLTYPE;
++
++
++/**
++ * Exposure control type
++ */
++typedef enum OMX_EXPOSURECONTROLTYPE {
++    OMX_ExposureControlOff = 0,
++    OMX_ExposureControlAuto,
++    OMX_ExposureControlNight,
++    OMX_ExposureControlBackLight,
++    OMX_ExposureControlSpotLight,
++    OMX_ExposureControlSports,
++    OMX_ExposureControlSnow,
++    OMX_ExposureControlBeach,
++    OMX_ExposureControlLargeAperture,
++    OMX_ExposureControlSmallApperture,
++    OMX_ExposureControlKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_ExposureControlVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_ExposureControlMax = 0x7FFFFFFF
++} OMX_EXPOSURECONTROLTYPE;
++
++
++/**
++ * White Balance control configuration
++ *
++ * STRUCT MEMBERS:
++ *  nSize            : Size of the structure in bytes
++ *  nVersion         : OMX specification version information
++ *  nPortIndex       : Port that this structure applies to
++ *  eExposureControl : Exposure control enumeration
++ */
++typedef struct OMX_CONFIG_EXPOSURECONTROLTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_EXPOSURECONTROLTYPE eExposureControl;
++} OMX_CONFIG_EXPOSURECONTROLTYPE;
++
++
++/**
++ * Defines sensor supported mode.
++ *
++ * STRUCT MEMBERS:
++ *  nSize      : Size of the structure in bytes
++ *  nVersion   : OMX specification version information
++ *  nPortIndex : Port that this structure applies to
++ *  nFrameRate : Single shot mode is indicated by a 0
++ *  bOneShot   : Enable for single shot, disable for streaming
++ *  sFrameSize : Framesize
++ */
++typedef struct OMX_PARAM_SENSORMODETYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_U32 nFrameRate;
++    OMX_BOOL bOneShot;
++    OMX_FRAMESIZETYPE sFrameSize;
++} OMX_PARAM_SENSORMODETYPE;
++
++
++/**
++ * Defines contrast level
++ *
++ * STRUCT MEMBERS:
++ *  nSize      : Size of the structure in bytes
++ *  nVersion   : OMX specification version information
++ *  nPortIndex : Port that this structure applies to
++ *  nContrast  : Values allowed for contrast -100 to 100, zero means no change
++ */
++typedef struct OMX_CONFIG_CONTRASTTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_S32 nContrast;
++} OMX_CONFIG_CONTRASTTYPE;
++
++
++/**
++ * Defines brightness level
++ *
++ * STRUCT MEMBERS:
++ *  nSize       : Size of the structure in bytes
++ *  nVersion    : OMX specification version information
++ *  nPortIndex  : Port that this structure applies to
++ *  nBrightness : 0-100%
++ */
++typedef struct OMX_CONFIG_BRIGHTNESSTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_U32 nBrightness;
++} OMX_CONFIG_BRIGHTNESSTYPE;
++
++
++/**
++ * Defines backlight level configuration for a video sink, e.g. LCD panel
++ *
++ * STRUCT MEMBERS:
++ *  nSize      : Size of the structure in bytes
++ *  nVersion   : OMX specification version information
++ *  nPortIndex : Port that this structure applies to
++ *  nBacklight : Values allowed for backlight 0-100%
++ *  nTimeout   : Number of milliseconds before backlight automatically turns
++ *               off.  A value of 0x0 disables backight timeout
++ */
++typedef struct OMX_CONFIG_BACKLIGHTTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_U32 nBacklight;
++    OMX_U32 nTimeout;
++} OMX_CONFIG_BACKLIGHTTYPE;
++
++
++/**
++ * Defines setting for Gamma
++ *
++ * STRUCT MEMBERS:
++ *  nSize      : Size of the structure in bytes
++ *  nVersion   : OMX specification version information
++ *  nPortIndex : Port that this structure applies to
++ *  nGamma     : Values allowed for gamma -100 to 100, zero means no change
++ */
++typedef struct OMX_CONFIG_GAMMATYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_S32 nGamma;
++} OMX_CONFIG_GAMMATYPE;
++
++
++/**
++ * Define for setting saturation
++ *
++ * STRUCT MEMBERS:
++ *  nSize       : Size of the structure in bytes
++ *  nVersion    : OMX specification version information
++ *  nPortIndex  : Port that this structure applies to
++ *  nSaturation : Values allowed for saturation -100 to 100, zero means
++ *                no change
++ */
++typedef struct OMX_CONFIG_SATURATIONTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_S32 nSaturation;
++} OMX_CONFIG_SATURATIONTYPE;
++
++
++/**
++ * Define for setting Lightness
++ *
++ * STRUCT MEMBERS:
++ *  nSize      : Size of the structure in bytes
++ *  nVersion   : OMX specification version information
++ *  nPortIndex : Port that this structure applies to
++ *  nLightness : Values allowed for lightness -100 to 100, zero means no
++ *               change
++ */
++typedef struct OMX_CONFIG_LIGHTNESSTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_S32 nLightness;
++} OMX_CONFIG_LIGHTNESSTYPE;
++
++
++/**
++ * Plane blend configuration
++ *
++ * STRUCT MEMBERS:
++ *  nSize      : Size of the structure in bytes
++ *  nVersion   : OMX specification version information
++ *  nPortIndex : Index of input port associated with the plane.
++ *  nDepth     : Depth of the plane in relation to the screen. Higher
++ *               numbered depths are "behind" lower number depths.
++ *               This number defaults to the Port Index number.
++ *  nAlpha     : Transparency blending component for the entire plane.
++ *               See blending modes for more detail.
++ */
++typedef struct OMX_CONFIG_PLANEBLENDTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_U32 nDepth;
++    OMX_U32 nAlpha;
++} OMX_CONFIG_PLANEBLENDTYPE;
++
++
++/**
++ * Define interlace type
++ *
++ * STRUCT MEMBERS:
++ *  nSize                 : Size of the structure in bytes
++ *  nVersion              : OMX specification version information
++ *  nPortIndex            : Port that this structure applies to
++ *  bEnable               : Enable control variable for this functionality
++ *                          (see below)
++ *  nInterleavePortIndex  : Index of input or output port associated with
++ *                          the interleaved plane.
++ *  pPlanarPortIndexes[4] : Index of input or output planar ports.
++ */
++typedef struct OMX_PARAM_INTERLEAVETYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_BOOL bEnable;
++    OMX_U32 nInterleavePortIndex;
++} OMX_PARAM_INTERLEAVETYPE;
++
++
++/**
++ * Defines the picture effect used for an input picture
++ */
++typedef enum OMX_TRANSITIONEFFECTTYPE {
++    OMX_EffectNone,
++    OMX_EffectFadeFromBlack,
++    OMX_EffectFadeToBlack,
++    OMX_EffectUnspecifiedThroughConstantColor,
++    OMX_EffectDissolve,
++    OMX_EffectWipe,
++    OMX_EffectUnspecifiedMixOfTwoScenes,
++    OMX_EffectKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_EffectVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_EffectMax = 0x7FFFFFFF
++} OMX_TRANSITIONEFFECTTYPE;
++
++
++/**
++ * Structure used to configure current transition effect
++ *
++ * STRUCT MEMBERS:
++ * nSize      : Size of the structure in bytes
++ * nVersion   : OMX specification version information
++ * nPortIndex : Port that this structure applies to
++ * eEffect    : Effect to enable
++ */
++typedef struct OMX_CONFIG_TRANSITIONEFFECTTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_TRANSITIONEFFECTTYPE eEffect;
++} OMX_CONFIG_TRANSITIONEFFECTTYPE;
++
++
++/**
++ * Defines possible data unit types for encoded video data. The data unit
++ * types are used both for encoded video input for playback as well as
++ * encoded video output from recording.
++ */
++typedef enum OMX_DATAUNITTYPE {
++    OMX_DataUnitCodedPicture,
++    OMX_DataUnitVideoSegment,
++    OMX_DataUnitSeveralSegments,
++    OMX_DataUnitArbitraryStreamSection,
++    OMX_DataUnitKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_DataUnitVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_DataUnitMax = 0x7FFFFFFF
++} OMX_DATAUNITTYPE;
++
++
++/**
++ * Defines possible encapsulation types for coded video data unit. The
++ * encapsulation information is used both for encoded video input for
++ * playback as well as encoded video output from recording.
++ */
++typedef enum OMX_DATAUNITENCAPSULATIONTYPE {
++    OMX_DataEncapsulationElementaryStream,
++    OMX_DataEncapsulationGenericPayload,
++    OMX_DataEncapsulationRtpPayload,
++    OMX_DataEncapsulationKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_DataEncapsulationVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_DataEncapsulationMax = 0x7FFFFFFF
++} OMX_DATAUNITENCAPSULATIONTYPE;
++
++
++/**
++ * Structure used to configure the type of being decoded/encoded
++ */
++typedef struct OMX_PARAM_DATAUNITTYPE {
++    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_DATAUNITTYPE eUnitType;
++    OMX_DATAUNITENCAPSULATIONTYPE eEncapsulationType;
++} OMX_PARAM_DATAUNITTYPE;
++
++
++/**
++ * Defines dither types
++ */
++typedef enum OMX_DITHERTYPE {
++    OMX_DitherNone,
++    OMX_DitherOrdered,
++    OMX_DitherErrorDiffusion,
++    OMX_DitherOther,
++    OMX_DitherKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_DitherVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_DitherMax = 0x7FFFFFFF
++} OMX_DITHERTYPE;
++
++
++/**
++ * Structure used to configure current type of dithering
++ */
++typedef struct OMX_CONFIG_DITHERTYPE {
++    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_DITHERTYPE eDither;   /**< Type of dithering to use */
++} OMX_CONFIG_DITHERTYPE;
++
++typedef struct OMX_CONFIG_CAPTUREMODETYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;     /**< Port that this structure applies to */
++    OMX_BOOL bContinuous;   /**< If true then ignore frame rate and emit capture
++                             *   data as fast as possible (otherwise obey port's frame rate). */
++    OMX_BOOL bFrameLimited; /**< If true then terminate capture after the port emits the
++                             *   specified number of frames (otherwise the port does not
++                             *   terminate the capture until instructed to do so by the client).
++                             *   Even if set, the client may manually terminate the capture prior
++                             *   to reaching the limit. */
++    OMX_U32 nFrameLimit;      /**< Limit on number of frames emitted during a capture (only
++                               *   valid if bFrameLimited is set). */
++} OMX_CONFIG_CAPTUREMODETYPE;
++
++typedef enum OMX_METERINGTYPE {
++
++    OMX_MeteringModeAverage,     /**< Center-weighted average metering. */
++    OMX_MeteringModeSpot,         /**< Spot (partial) metering. */
++    OMX_MeteringModeMatrix,      /**< Matrix or evaluative metering. */
++
++    OMX_MeteringKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_MeteringVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_EVModeMax = 0x7fffffff
++} OMX_METERINGTYPE;
++
++typedef struct OMX_CONFIG_EXPOSUREVALUETYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    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_U32 nShutterSpeedMsec;    /**< Shutterspeed in milliseconds */
++    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_CONFIG_EXPOSUREVALUETYPE;
++
++/**
++ * Focus region configuration
++ *
++ * STRUCT MEMBERS:
++ *  nSize           : Size of the structure in bytes
++ *  nVersion        : OMX specification version information
++ *  nPortIndex      : Port that this structure applies to
++ *  bCenter         : Use center region as focus region of interest
++ *  bLeft           : Use left region as focus region of interest
++ *  bRight          : Use right region as focus region of interest
++ *  bTop            : Use top region as focus region of interest
++ *  bBottom         : Use bottom region as focus region of interest
++ *  bTopLeft        : Use top left region as focus region of interest
++ *  bTopRight       : Use top right region as focus region of interest
++ *  bBottomLeft     : Use bottom left region as focus region of interest
++ *  bBottomRight    : Use bottom right region as focus region of interest
++ */
++typedef struct OMX_CONFIG_FOCUSREGIONTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_BOOL bCenter;
++    OMX_BOOL bLeft;
++    OMX_BOOL bRight;
++    OMX_BOOL bTop;
++    OMX_BOOL bBottom;
++    OMX_BOOL bTopLeft;
++    OMX_BOOL bTopRight;
++    OMX_BOOL bBottomLeft;
++    OMX_BOOL bBottomRight;
++} OMX_CONFIG_FOCUSREGIONTYPE;
++
++/**
++ * Focus Status type
++ */
++typedef enum OMX_FOCUSSTATUSTYPE {
++    OMX_FocusStatusOff = 0,
++    OMX_FocusStatusRequest,
++    OMX_FocusStatusReached,
++    OMX_FocusStatusUnableToReach,
++    OMX_FocusStatusLost,
++    OMX_FocusStatusKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_FocusStatusVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_FocusStatusMax = 0x7FFFFFFF
++} OMX_FOCUSSTATUSTYPE;
++
++/**
++ * Focus status configuration
++ *
++ * STRUCT MEMBERS:
++ *  nSize               : Size of the structure in bytes
++ *  nVersion            : OMX specification version information
++ *  nPortIndex          : Port that this structure applies to
++ *  eFocusStatus        : Specifies the focus status
++ *  bCenterStatus       : Use center region as focus region of interest
++ *  bLeftStatus         : Use left region as focus region of interest
++ *  bRightStatus        : Use right region as focus region of interest
++ *  bTopStatus          : Use top region as focus region of interest
++ *  bBottomStatus       : Use bottom region as focus region of interest
++ *  bTopLeftStatus      : Use top left region as focus region of interest
++ *  bTopRightStatus     : Use top right region as focus region of interest
++ *  bBottomLeftStatus   : Use bottom left region as focus region of interest
++ *  bBottomRightStatus  : Use bottom right region as focus region of interest
++ */
++typedef struct OMX_PARAM_FOCUSSTATUSTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_FOCUSSTATUSTYPE eFocusStatus;
++    OMX_BOOL bCenterStatus;
++    OMX_BOOL bLeftStatus;
++    OMX_BOOL bRightStatus;
++    OMX_BOOL bTopStatus;
++    OMX_BOOL bBottomStatus;
++    OMX_BOOL bTopLeftStatus;
++    OMX_BOOL bTopRightStatus;
++    OMX_BOOL bBottomLeftStatus;
++    OMX_BOOL bBottomRightStatus;
++} OMX_PARAM_FOCUSSTATUSTYPE;
++
++/** @} */
++
++#ifdef __cplusplus
++}
++#endif /* __cplusplus */
++
++#endif
++/* File EOF */
+diff --git a/sf-extra/omx-il/OMX_Image.h b/sf-extra/omx-il/OMX_Image.h
+new file mode 100644
+index 00000000..ca648825
+--- /dev/null
++++ b/sf-extra/omx-il/OMX_Image.h
+@@ -0,0 +1,328 @@
++/**
++ * Copyright (c) 2008 The Khronos Group Inc.
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining
++ * a copy of this software and associated documentation files (the
++ * "Software"), to deal in the Software without restriction, including
++ * without limitation the rights to use, copy, modify, merge, publish,
++ * distribute, sublicense, and/or sell copies of the Software, and to
++ * permit persons to whom the Software is furnished to do so, subject
++ * to the following conditions:
++ * The above copyright notice and this permission notice shall be included
++ * in all copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
++ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
++ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
++ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
++ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
++ */
++
++/**
++ * @file OMX_Image.h - OpenMax IL version 1.1.2
++ * The structures needed by Image components to exchange parameters and
++ * configuration data with the components.
++ */
++#ifndef OMX_Image_h
++#define OMX_Image_h
++
++#ifdef __cplusplus
++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
++ */
++
++#include <OMX_IVCommon.h>
++
++/** @defgroup imaging OpenMAX IL Imaging Domain
++ * @ingroup iv
++ * Structures for OpenMAX IL Imaging domain
++ * @{
++ */
++
++/**
++ * Enumeration used to define the possible image compression coding.
++ */
++typedef enum OMX_IMAGE_CODINGTYPE {
++    OMX_IMAGE_CodingUnused,      /**< Value when format is N/A */
++    OMX_IMAGE_CodingAutoDetect,  /**< Auto detection of image format */
++    OMX_IMAGE_CodingJPEG,        /**< JPEG/JFIF image format */
++    OMX_IMAGE_CodingJPEG2K,      /**< JPEG 2000 image format */
++    OMX_IMAGE_CodingEXIF,        /**< EXIF image format */
++    OMX_IMAGE_CodingTIFF,        /**< TIFF image format */
++    OMX_IMAGE_CodingGIF,         /**< Graphics image format */
++    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_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.
++ *
++ *  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
++ * 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
++ *                          sync, otherwise this field is 0
++ *  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
++ *                          unknown, don't care or variable
++ *  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
++ *                          indicates the image is bottom up
++ *  nSliceHeight          : Height used when encoding in slices
++ *  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
++ *                          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.
++ */
++typedef struct OMX_IMAGE_PORTDEFINITIONTYPE {
++    OMX_STRING cMIMEType;
++    OMX_NATIVE_DEVICETYPE pNativeRender;
++    OMX_U32 nFrameWidth;
++    OMX_U32 nFrameHeight;
++    OMX_S32 nStride;
++    OMX_U32 nSliceHeight;
++    OMX_BOOL bFlagErrorConcealment;
++    OMX_IMAGE_CODINGTYPE eCompressionFormat;
++    OMX_COLOR_FORMATTYPE eColorFormat;
++    OMX_NATIVE_WINDOWTYPE pNativeWindow;
++} OMX_IMAGE_PORTDEFINITIONTYPE;
++
++
++/**
++ * 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
++ *                       0x0 to N-1
++ *  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
++ */
++typedef struct OMX_IMAGE_PARAM_PORTFORMATTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_U32 nIndex;
++    OMX_IMAGE_CODINGTYPE eCompressionFormat;
++    OMX_COLOR_FORMATTYPE eColorFormat;
++} OMX_IMAGE_PARAM_PORTFORMATTYPE;
++
++
++/**
++ * Flash control type
++ *
++ * ENUMS
++ *  Torch : Flash forced constantly on
++ */
++typedef enum OMX_IMAGE_FLASHCONTROLTYPE {
++    OMX_IMAGE_FlashControlOn = 0,
++    OMX_IMAGE_FlashControlOff,
++    OMX_IMAGE_FlashControlAuto,
++    OMX_IMAGE_FlashControlRedEyeReduction,
++    OMX_IMAGE_FlashControlFillin,
++    OMX_IMAGE_FlashControlTorch,
++    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
++ *
++ * STRUCT MEMBERS:
++ *  nSize         : Size of the structure in bytes
++ *  nVersion      : OMX specification version information
++ *  nPortIndex    : Port that this structure applies to
++ *  eFlashControl : Flash control type
++ */
++typedef struct OMX_IMAGE_PARAM_FLASHCONTROLTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_IMAGE_FLASHCONTROLTYPE eFlashControl;
++} OMX_IMAGE_PARAM_FLASHCONTROLTYPE;
++
++
++/**
++ * 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_FocusControlVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_IMAGE_FocusControlMax = 0x7FFFFFFF
++} OMX_IMAGE_FOCUSCONTROLTYPE;
++
++
++/**
++ * 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.
++ *                    Interest is only in number of steps over this range.
++ *  nFocusStepIndex : Current focus step index
++ */
++typedef struct OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_IMAGE_FOCUSCONTROLTYPE eFocusControl;
++    OMX_U32 nFocusSteps;
++    OMX_U32 nFocusStepIndex;
++} 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
++ *
++ * 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
++ */
++typedef struct OMX_IMAGE_PARAM_QFACTORTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_U32 nQFactor;
++} OMX_IMAGE_PARAM_QFACTORTYPE;
++
++/**
++ * Quantization table type
++ */
++
++typedef enum OMX_IMAGE_QUANTIZATIONTABLETYPE {
++    OMX_IMAGE_QuantizationTableLuma = 0,
++    OMX_IMAGE_QuantizationTableChroma,
++    OMX_IMAGE_QuantizationTableChromaCb,
++    OMX_IMAGE_QuantizationTableChromaCr,
++    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
++ *
++ * STRUCT MEMBERS:
++ *  nSize                   : Size of the structure in bytes
++ *  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
++ *                            the range 0-255 and stored in linear order
++ *                            (i.e. the component will zig-zag the
++ *                            quantization table data if required internally)
++ */
++typedef struct OMX_IMAGE_PARAM_QUANTIZATIONTABLETYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_IMAGE_QUANTIZATIONTABLETYPE eQuantizationTable;
++    OMX_U8 nQuantizationMatrix[64];
++} OMX_IMAGE_PARAM_QUANTIZATIONTABLETYPE;
++
++
++/**
++ * Huffman table type, the same Huffman table is applied for chroma and
++ * luma component
++ */
++typedef enum OMX_IMAGE_HUFFMANTABLETYPE {
++    OMX_IMAGE_HuffmanTableAC = 0,
++    OMX_IMAGE_HuffmanTableDC,
++    OMX_IMAGE_HuffmanTableACLuma,
++    OMX_IMAGE_HuffmanTableACChroma,
++    OMX_IMAGE_HuffmanTableDCLuma,
++    OMX_IMAGE_HuffmanTableDCChroma,
++    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
++ *
++ * 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
++ *                                     possible length
++ *  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;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_IMAGE_HUFFMANTABLETYPE eHuffmanTable;
++    OMX_U8 nNumberOfHuffmanCodeOfLength[16];
++    OMX_U8 nHuffmanTable[256];
++} OMX_IMAGE_PARAM_HUFFMANTTABLETYPE;
++
++/** @} */
++#ifdef __cplusplus
++}
++#endif /* __cplusplus */
++
++#endif
++/* File EOF */
+diff --git a/sf-extra/omx-il/OMX_ImageExt.h b/sf-extra/omx-il/OMX_ImageExt.h
+new file mode 100644
+index 00000000..e7cae029
+--- /dev/null
++++ b/sf-extra/omx-il/OMX_ImageExt.h
+@@ -0,0 +1,55 @@
++/*
++ * Copyright (c) 2016 The Khronos Group Inc.
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining
++ * a copy of this software and associated documentation files (the
++ * "Software"), to deal in the Software without restriction, including
++ * without limitation the rights to use, copy, modify, merge, publish,
++ * distribute, sublicense, and/or sell copies of the Software, and to
++ * permit persons to whom the Software is furnished to do so, subject
++ * to the following conditions:
++ * The above copyright notice and this permission notice shall be included
++ * in all copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
++ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
++ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
++ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
++ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
++ *
++ */
++
++/** OMX_ImageExt.h - OpenMax IL version 1.1.2
++ * The OMX_ImageExt header file contains extensions to the
++ * definitions used by both the application and the component to
++ * access image items.
++ */
++
++#ifndef OMX_ImageExt_h
++#define OMX_ImageExt_h
++
++#ifdef __cplusplus
++extern "C" {
++#endif /* __cplusplus */
++
++/* Each OMX header shall include all required header files to allow the
++ * header to compile without errors.  The includes below are required
++ * for this header file to compile successfully
++ */
++#include <OMX_Core.h>
++
++/** Enum for standard image codingtype extensions */
++typedef enum OMX_IMAGE_CODINGEXTTYPE {
++    OMX_IMAGE_CodingExtUnused = OMX_IMAGE_CodingKhronosExtensions,
++    OMX_IMAGE_CodingWEBP,         /**< WebP image format */
++} OMX_IMAGE_CODINGEXTTYPE;
++
++
++#ifdef __cplusplus
++}
++#endif /* __cplusplus */
++
++#endif /* OMX_ImageExt_h */
++/* File EOF */
+diff --git a/sf-extra/omx-il/OMX_Index.h b/sf-extra/omx-il/OMX_Index.h
+new file mode 100644
+index 00000000..20a109cf
+--- /dev/null
++++ b/sf-extra/omx-il/OMX_Index.h
+@@ -0,0 +1,260 @@
++/*
++ * Copyright (c) 2008 The Khronos Group Inc.
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining
++ * a copy of this software and associated documentation files (the
++ * "Software"), to deal in the Software without restriction, including
++ * without limitation the rights to use, copy, modify, merge, publish,
++ * distribute, sublicense, and/or sell copies of the Software, and to
++ * permit persons to whom the Software is furnished to do so, subject
++ * to the following conditions:
++ * The above copyright notice and this permission notice shall be included
++ * in all copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
++ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
++ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
++ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
++ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
++ *
++ */
++
++/** @file OMX_Index.h - OpenMax IL version 1.1.2
++ *  The OMX_Index header file contains the definitions for both applications
++ *  and components .
++ */
++
++
++#ifndef OMX_Index_h
++#define OMX_Index_h
++
++#ifdef __cplusplus
++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
++ */
++#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
++ *  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
++ *  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.
++ */
++typedef enum OMX_INDEXTYPE {
++
++    OMX_IndexComponentStartUnused = 0x01000000,
++    OMX_IndexParamPriorityMgmt,             /**< reference: OMX_PRIORITYMGMTTYPE */
++    OMX_IndexParamAudioInit,                /**< reference: OMX_PORT_PARAM_TYPE */
++    OMX_IndexParamImageInit,                /**< reference: OMX_PORT_PARAM_TYPE */
++    OMX_IndexParamVideoInit,                /**< reference: OMX_PORT_PARAM_TYPE */
++    OMX_IndexParamOtherInit,                /**< reference: OMX_PORT_PARAM_TYPE */
++    OMX_IndexParamNumAvailableStreams,      /**< reference: OMX_PARAM_U32TYPE */
++    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_IndexParamContentURI,               /**< reference: OMX_PARAM_CONTENTURITYPE */
++    OMX_IndexParamCustomContentPipe,        /**< reference: OMX_PARAM_CONTENTPIPETYPE */
++    OMX_IndexParamDisableResourceConcealment, /**< reference: OMX_RESOURCECONCEALMENTTYPE */
++    OMX_IndexConfigMetadataItemCount,       /**< reference: OMX_CONFIG_METADATAITEMCOUNTTYPE */
++    OMX_IndexConfigContainerNodeCount,      /**< reference: OMX_CONFIG_CONTAINERNODECOUNTTYPE */
++    OMX_IndexConfigMetadataItem,            /**< reference: OMX_CONFIG_METADATAITEMTYPE */
++    OMX_IndexConfigCounterNodeID,           /**< reference: OMX_CONFIG_CONTAINERNODEIDTYPE */
++    OMX_IndexParamMetadataFilterType,       /**< reference: OMX_PARAM_METADATAFILTERTYPE */
++    OMX_IndexParamMetadataKeyFilter,        /**< reference: OMX_PARAM_METADATAFILTERTYPE */
++    OMX_IndexConfigPriorityMgmt,            /**< reference: OMX_PRIORITYMGMTTYPE */
++    OMX_IndexParamStandardComponentRole,    /**< reference: OMX_PARAM_COMPONENTROLETYPE */
++
++    OMX_IndexPortStartUnused = 0x02000000,
++    OMX_IndexParamPortDefinition,           /**< reference: OMX_PARAM_PORTDEFINITIONTYPE */
++    OMX_IndexParamCompBufferSupplier,       /**< reference: OMX_PARAM_BUFFERSUPPLIERTYPE */
++    OMX_IndexReservedStartUnused = 0x03000000,
++
++    /* Audio parameters and configurations */
++    OMX_IndexAudioStartUnused = 0x04000000,
++    OMX_IndexParamAudioPortFormat,          /**< reference: OMX_AUDIO_PARAM_PORTFORMATTYPE */
++    OMX_IndexParamAudioPcm,                 /**< reference: OMX_AUDIO_PARAM_PCMMODETYPE */
++    OMX_IndexParamAudioAac,                 /**< reference: OMX_AUDIO_PARAM_AACPROFILETYPE */
++    OMX_IndexParamAudioRa,                  /**< reference: OMX_AUDIO_PARAM_RATYPE */
++    OMX_IndexParamAudioMp3,                 /**< reference: OMX_AUDIO_PARAM_MP3TYPE */
++    OMX_IndexParamAudioAdpcm,               /**< reference: OMX_AUDIO_PARAM_ADPCMTYPE */
++    OMX_IndexParamAudioG723,                /**< reference: OMX_AUDIO_PARAM_G723TYPE */
++    OMX_IndexParamAudioG729,                /**< reference: OMX_AUDIO_PARAM_G729TYPE */
++    OMX_IndexParamAudioAmr,                 /**< reference: OMX_AUDIO_PARAM_AMRTYPE */
++    OMX_IndexParamAudioWma,                 /**< reference: OMX_AUDIO_PARAM_WMATYPE */
++    OMX_IndexParamAudioSbc,                 /**< reference: OMX_AUDIO_PARAM_SBCTYPE */
++    OMX_IndexParamAudioMidi,                /**< reference: OMX_AUDIO_PARAM_MIDITYPE */
++    OMX_IndexParamAudioGsm_FR,              /**< reference: OMX_AUDIO_PARAM_GSMFRTYPE */
++    OMX_IndexParamAudioMidiLoadUserSound,   /**< reference: OMX_AUDIO_PARAM_MIDILOADUSERSOUNDTYPE */
++    OMX_IndexParamAudioG726,                /**< reference: OMX_AUDIO_PARAM_G726TYPE */
++    OMX_IndexParamAudioGsm_EFR,             /**< reference: OMX_AUDIO_PARAM_GSMEFRTYPE */
++    OMX_IndexParamAudioGsm_HR,              /**< reference: OMX_AUDIO_PARAM_GSMHRTYPE */
++    OMX_IndexParamAudioPdc_FR,              /**< reference: OMX_AUDIO_PARAM_PDCFRTYPE */
++    OMX_IndexParamAudioPdc_EFR,             /**< reference: OMX_AUDIO_PARAM_PDCEFRTYPE */
++    OMX_IndexParamAudioPdc_HR,              /**< reference: OMX_AUDIO_PARAM_PDCHRTYPE */
++    OMX_IndexParamAudioTdma_FR,             /**< reference: OMX_AUDIO_PARAM_TDMAFRTYPE */
++    OMX_IndexParamAudioTdma_EFR,            /**< reference: OMX_AUDIO_PARAM_TDMAEFRTYPE */
++    OMX_IndexParamAudioQcelp8,              /**< reference: OMX_AUDIO_PARAM_QCELP8TYPE */
++    OMX_IndexParamAudioQcelp13,             /**< reference: OMX_AUDIO_PARAM_QCELP13TYPE */
++    OMX_IndexParamAudioEvrc,                /**< reference: OMX_AUDIO_PARAM_EVRCTYPE */
++    OMX_IndexParamAudioSmv,                 /**< reference: OMX_AUDIO_PARAM_SMVTYPE */
++    OMX_IndexParamAudioVorbis,              /**< reference: OMX_AUDIO_PARAM_VORBISTYPE */
++
++    OMX_IndexConfigAudioMidiImmediateEvent, /**< reference: OMX_AUDIO_CONFIG_MIDIIMMEDIATEEVENTTYPE */
++    OMX_IndexConfigAudioMidiControl,        /**< reference: OMX_AUDIO_CONFIG_MIDICONTROLTYPE */
++    OMX_IndexConfigAudioMidiSoundBankProgram, /**< reference: OMX_AUDIO_CONFIG_MIDISOUNDBANKPROGRAMTYPE */
++    OMX_IndexConfigAudioMidiStatus,         /**< reference: OMX_AUDIO_CONFIG_MIDISTATUSTYPE */
++    OMX_IndexConfigAudioMidiMetaEvent,      /**< reference: OMX_AUDIO_CONFIG_MIDIMETAEVENTTYPE */
++    OMX_IndexConfigAudioMidiMetaEventData,  /**< reference: OMX_AUDIO_CONFIG_MIDIMETAEVENTDATATYPE */
++    OMX_IndexConfigAudioVolume,             /**< reference: OMX_AUDIO_CONFIG_VOLUMETYPE */
++    OMX_IndexConfigAudioBalance,            /**< reference: OMX_AUDIO_CONFIG_BALANCETYPE */
++    OMX_IndexConfigAudioChannelMute,        /**< reference: OMX_AUDIO_CONFIG_CHANNELMUTETYPE */
++    OMX_IndexConfigAudioMute,               /**< reference: OMX_AUDIO_CONFIG_MUTETYPE */
++    OMX_IndexConfigAudioLoudness,           /**< reference: OMX_AUDIO_CONFIG_LOUDNESSTYPE */
++    OMX_IndexConfigAudioEchoCancelation,    /**< reference: OMX_AUDIO_CONFIG_ECHOCANCELATIONTYPE */
++    OMX_IndexConfigAudioNoiseReduction,     /**< reference: OMX_AUDIO_CONFIG_NOISEREDUCTIONTYPE */
++    OMX_IndexConfigAudioBass,               /**< reference: OMX_AUDIO_CONFIG_BASSTYPE */
++    OMX_IndexConfigAudioTreble,             /**< reference: OMX_AUDIO_CONFIG_TREBLETYPE */
++    OMX_IndexConfigAudioStereoWidening,     /**< reference: OMX_AUDIO_CONFIG_STEREOWIDENINGTYPE */
++    OMX_IndexConfigAudioChorus,             /**< reference: OMX_AUDIO_CONFIG_CHORUSTYPE */
++    OMX_IndexConfigAudioEqualizer,          /**< reference: OMX_AUDIO_CONFIG_EQUALIZERTYPE */
++    OMX_IndexConfigAudioReverberation,      /**< reference: OMX_AUDIO_CONFIG_REVERBERATIONTYPE */
++    OMX_IndexConfigAudioChannelVolume,      /**< reference: OMX_AUDIO_CONFIG_CHANNELVOLUMETYPE */
++
++    /* Image specific parameters and configurations */
++    OMX_IndexImageStartUnused = 0x05000000,
++    OMX_IndexParamImagePortFormat,          /**< reference: OMX_IMAGE_PARAM_PORTFORMATTYPE */
++    OMX_IndexParamFlashControl,             /**< reference: OMX_IMAGE_PARAM_FLASHCONTROLTYPE */
++    OMX_IndexConfigFocusControl,            /**< reference: OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE */
++    OMX_IndexParamQFactor,                  /**< reference: OMX_IMAGE_PARAM_QFACTORTYPE */
++    OMX_IndexParamQuantizationTable,        /**< reference: OMX_IMAGE_PARAM_QUANTIZATIONTABLETYPE */
++    OMX_IndexParamHuffmanTable,             /**< reference: OMX_IMAGE_PARAM_HUFFMANTTABLETYPE */
++    OMX_IndexConfigFlashControl,            /**< reference: OMX_IMAGE_PARAM_FLASHCONTROLTYPE */
++
++    /* Video specific parameters and configurations */
++    OMX_IndexVideoStartUnused = 0x06000000,
++    OMX_IndexParamVideoPortFormat,          /**< reference: OMX_VIDEO_PARAM_PORTFORMATTYPE */
++    OMX_IndexParamVideoQuantization,        /**< reference: OMX_VIDEO_PARAM_QUANTIZATIONTYPE */
++    OMX_IndexParamVideoFastUpdate,          /**< reference: OMX_VIDEO_PARAM_VIDEOFASTUPDATETYPE */
++    OMX_IndexParamVideoBitrate,             /**< reference: OMX_VIDEO_PARAM_BITRATETYPE */
++    OMX_IndexParamVideoMotionVector,        /**< reference: OMX_VIDEO_PARAM_MOTIONVECTORTYPE */
++    OMX_IndexParamVideoIntraRefresh,        /**< reference: OMX_VIDEO_PARAM_INTRAREFRESHTYPE */
++    OMX_IndexParamVideoErrorCorrection,     /**< reference: OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE */
++    OMX_IndexParamVideoVBSMC,               /**< reference: OMX_VIDEO_PARAM_VBSMCTYPE */
++    OMX_IndexParamVideoMpeg2,               /**< reference: OMX_VIDEO_PARAM_MPEG2TYPE */
++    OMX_IndexParamVideoMpeg4,               /**< reference: OMX_VIDEO_PARAM_MPEG4TYPE */
++    OMX_IndexParamVideoWmv,                 /**< reference: OMX_VIDEO_PARAM_WMVTYPE */
++    OMX_IndexParamVideoRv,                  /**< reference: OMX_VIDEO_PARAM_RVTYPE */
++    OMX_IndexParamVideoAvc,                 /**< reference: OMX_VIDEO_PARAM_AVCTYPE */
++    OMX_IndexParamVideoH263,                /**< reference: OMX_VIDEO_PARAM_H263TYPE */
++    OMX_IndexParamVideoProfileLevelQuerySupported, /**< reference: OMX_VIDEO_PARAM_PROFILELEVELTYPE */
++    OMX_IndexParamVideoProfileLevelCurrent, /**< reference: OMX_VIDEO_PARAM_PROFILELEVELTYPE */
++    OMX_IndexConfigVideoBitrate,            /**< reference: OMX_VIDEO_CONFIG_BITRATETYPE */
++    OMX_IndexConfigVideoFramerate,          /**< reference: OMX_CONFIG_FRAMERATETYPE */
++    OMX_IndexConfigVideoIntraVOPRefresh,    /**< reference: OMX_CONFIG_INTRAREFRESHVOPTYPE */
++    OMX_IndexConfigVideoIntraMBRefresh,     /**< reference: OMX_CONFIG_MACROBLOCKERRORMAPTYPE */
++    OMX_IndexConfigVideoMBErrorReporting,   /**< reference: OMX_CONFIG_MBERRORREPORTINGTYPE */
++    OMX_IndexParamVideoMacroblocksPerFrame, /**< reference: OMX_PARAM_MACROBLOCKSTYPE */
++    OMX_IndexConfigVideoMacroBlockErrorMap, /**< reference: OMX_CONFIG_MACROBLOCKERRORMAPTYPE */
++    OMX_IndexParamVideoSliceFMO,            /**< reference: OMX_VIDEO_PARAM_AVCSLICEFMO */
++    OMX_IndexConfigVideoAVCIntraPeriod,     /**< reference: OMX_VIDEO_CONFIG_AVCINTRAPERIOD */
++    OMX_IndexConfigVideoNalSize,            /**< reference: OMX_VIDEO_CONFIG_NALSIZE */
++
++    /* Image & Video common Configurations */
++    OMX_IndexCommonStartUnused = 0x07000000,
++    OMX_IndexParamCommonDeblocking,         /**< reference: OMX_PARAM_DEBLOCKINGTYPE */
++    OMX_IndexParamCommonSensorMode,         /**< reference: OMX_PARAM_SENSORMODETYPE */
++    OMX_IndexParamCommonInterleave,         /**< reference: OMX_PARAM_INTERLEAVETYPE */
++    OMX_IndexConfigCommonColorFormatConversion, /**< reference: OMX_CONFIG_COLORCONVERSIONTYPE */
++    OMX_IndexConfigCommonScale,             /**< reference: OMX_CONFIG_SCALEFACTORTYPE */
++    OMX_IndexConfigCommonImageFilter,       /**< reference: OMX_CONFIG_IMAGEFILTERTYPE */
++    OMX_IndexConfigCommonColorEnhancement,  /**< reference: OMX_CONFIG_COLORENHANCEMENTTYPE */
++    OMX_IndexConfigCommonColorKey,          /**< reference: OMX_CONFIG_COLORKEYTYPE */
++    OMX_IndexConfigCommonColorBlend,        /**< reference: OMX_CONFIG_COLORBLENDTYPE */
++    OMX_IndexConfigCommonFrameStabilisation,/**< reference: OMX_CONFIG_FRAMESTABTYPE */
++    OMX_IndexConfigCommonRotate,            /**< reference: OMX_CONFIG_ROTATIONTYPE */
++    OMX_IndexConfigCommonMirror,            /**< reference: OMX_CONFIG_MIRRORTYPE */
++    OMX_IndexConfigCommonOutputPosition,    /**< reference: OMX_CONFIG_POINTTYPE */
++    OMX_IndexConfigCommonInputCrop,         /**< reference: OMX_CONFIG_RECTTYPE */
++    OMX_IndexConfigCommonOutputCrop,        /**< reference: OMX_CONFIG_RECTTYPE */
++    OMX_IndexConfigCommonDigitalZoom,       /**< reference: OMX_CONFIG_SCALEFACTORTYPE */
++    OMX_IndexConfigCommonOpticalZoom,       /**< reference: OMX_CONFIG_SCALEFACTORTYPE*/
++    OMX_IndexConfigCommonWhiteBalance,      /**< reference: OMX_CONFIG_WHITEBALCONTROLTYPE */
++    OMX_IndexConfigCommonExposure,          /**< reference: OMX_CONFIG_EXPOSURECONTROLTYPE */
++    OMX_IndexConfigCommonContrast,          /**< reference: OMX_CONFIG_CONTRASTTYPE */
++    OMX_IndexConfigCommonBrightness,        /**< reference: OMX_CONFIG_BRIGHTNESSTYPE */
++    OMX_IndexConfigCommonBacklight,         /**< reference: OMX_CONFIG_BACKLIGHTTYPE */
++    OMX_IndexConfigCommonGamma,             /**< reference: OMX_CONFIG_GAMMATYPE */
++    OMX_IndexConfigCommonSaturation,        /**< reference: OMX_CONFIG_SATURATIONTYPE */
++    OMX_IndexConfigCommonLightness,         /**< reference: OMX_CONFIG_LIGHTNESSTYPE */
++    OMX_IndexConfigCommonExclusionRect,     /**< reference: OMX_CONFIG_RECTTYPE */
++    OMX_IndexConfigCommonDithering,         /**< reference: OMX_CONFIG_DITHERTYPE */
++    OMX_IndexConfigCommonPlaneBlend,        /**< reference: OMX_CONFIG_PLANEBLENDTYPE */
++    OMX_IndexConfigCommonExposureValue,     /**< reference: OMX_CONFIG_EXPOSUREVALUETYPE */
++    OMX_IndexConfigCommonOutputSize,        /**< reference: OMX_FRAMESIZETYPE */
++    OMX_IndexParamCommonExtraQuantData,     /**< reference: OMX_OTHER_EXTRADATATYPE */
++    OMX_IndexConfigCommonFocusRegion,       /**< reference: OMX_CONFIG_FOCUSREGIONTYPE */
++    OMX_IndexConfigCommonFocusStatus,       /**< reference: OMX_PARAM_FOCUSSTATUSTYPE */
++    OMX_IndexConfigCommonTransitionEffect,  /**< reference: OMX_CONFIG_TRANSITIONEFFECTTYPE */
++
++    /* Reserved Configuration range */
++    OMX_IndexOtherStartUnused = 0x08000000,
++    OMX_IndexParamOtherPortFormat,          /**< reference: OMX_OTHER_PARAM_PORTFORMATTYPE */
++    OMX_IndexConfigOtherPower,              /**< reference: OMX_OTHER_CONFIG_POWERTYPE */
++    OMX_IndexConfigOtherStats,              /**< reference: OMX_OTHER_CONFIG_STATSTYPE */
++
++
++    /* Reserved Time range */
++    OMX_IndexTimeStartUnused = 0x09000000,
++    OMX_IndexConfigTimeScale,               /**< reference: OMX_TIME_CONFIG_SCALETYPE */
++    OMX_IndexConfigTimeClockState,          /**< reference: OMX_TIME_CONFIG_CLOCKSTATETYPE */
++    OMX_IndexConfigTimeActiveRefClock,      /**< reference: OMX_TIME_CONFIG_ACTIVEREFCLOCKTYPE */
++    OMX_IndexConfigTimeCurrentMediaTime,    /**< reference: OMX_TIME_CONFIG_TIMESTAMPTYPE (read only) */
++    OMX_IndexConfigTimeCurrentWallTime,     /**< reference: OMX_TIME_CONFIG_TIMESTAMPTYPE (read only) */
++    OMX_IndexConfigTimeCurrentAudioReference, /**< reference: OMX_TIME_CONFIG_TIMESTAMPTYPE (write only) */
++    OMX_IndexConfigTimeCurrentVideoReference, /**< reference: OMX_TIME_CONFIG_TIMESTAMPTYPE (write only) */
++    OMX_IndexConfigTimeMediaTimeRequest,    /**< reference: OMX_TIME_CONFIG_MEDIATIMEREQUESTTYPE (write only) */
++    OMX_IndexConfigTimeClientStartTime,     /**<reference:  OMX_TIME_CONFIG_TIMESTAMPTYPE (write only) */
++    OMX_IndexConfigTimePosition,            /**< reference: OMX_TIME_CONFIG_TIMESTAMPTYPE */
++    OMX_IndexConfigTimeSeekMode,            /**< reference: OMX_TIME_CONFIG_SEEKMODETYPE */
++
++
++    OMX_IndexKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    /* Vendor specific area */
++    OMX_IndexRockchipExtensions = 0x70000000, /**< Reserved region for introducing Rockchip Standard Extensions */
++    OMX_IndexParamVideoHDRRockchipExtensions,  /**< reference: OMX_EXTENSION_VIDEO_PARAM_HDR */
++    OMX_IndexVendorStartUnused = 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. */
++
++    OMX_IndexMax = 0x7FFFFFFF
++
++} OMX_INDEXTYPE;
++
++#ifdef __cplusplus
++}
++#endif /* __cplusplus */
++
++#endif
++/* File EOF */
+diff --git a/sf-extra/omx-il/OMX_IndexExt.h b/sf-extra/omx-il/OMX_IndexExt.h
+new file mode 100644
+index 00000000..b688d1d9
+--- /dev/null
++++ b/sf-extra/omx-il/OMX_IndexExt.h
+@@ -0,0 +1,105 @@
++/*
++ * Copyright (c) 2010 The Khronos Group Inc.
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining
++ * a copy of this software and associated documentation files (the
++ * "Software"), to deal in the Software without restriction, including
++ * without limitation the rights to use, copy, modify, merge, publish,
++ * distribute, sublicense, and/or sell copies of the Software, and to
++ * permit persons to whom the Software is furnished to do so, subject
++ * to the following conditions:
++ * The above copyright notice and this permission notice shall be included
++ * in all copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
++ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
++ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
++ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
++ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
++ *
++ */
++
++/** @file OMX_IndexExt.h - OpenMax IL version 1.1.2
++ * The OMX_IndexExt header file contains extensions to the definitions
++ * for both applications and components .
++ */
++
++#ifndef OMX_IndexExt_h
++#define OMX_IndexExt_h
++
++#ifdef __cplusplus
++extern "C" {
++#endif /* __cplusplus */
++
++/* Each OMX header shall include all required header files to allow the
++ * header to compile without errors.  The includes below are required
++ * for this header file to compile successfully
++ */
++#include <OMX_Index.h>
++
++
++/** Khronos standard extension indices.
++
++This enum lists the current Khronos extension indices to OpenMAX IL.
++*/
++typedef enum OMX_INDEXEXTTYPE {
++
++    /* Component parameters and configurations */
++    OMX_IndexExtComponentStartUnused = OMX_IndexKhronosExtensions + 0x00100000,
++    OMX_IndexConfigCallbackRequest,                 /**< reference: OMX_CONFIG_CALLBACKREQUESTTYPE */
++    OMX_IndexConfigCommitMode,                      /**< reference: OMX_CONFIG_COMMITMODETYPE */
++    OMX_IndexConfigCommit,                          /**< reference: OMX_CONFIG_COMMITTYPE */
++
++    /* Port parameters and configurations */
++    OMX_IndexExtPortStartUnused = OMX_IndexKhronosExtensions + 0x00200000,
++
++    /* Audio parameters and configurations */
++    OMX_IndexExtAudioStartUnused = OMX_IndexKhronosExtensions + 0x00400000,
++    OMX_IndexParamAudioAndroidAc3,                  /**< reference: OMX_AUDIO_PARAM_ANDROID_AC3TYPE */
++    OMX_IndexParamAudioAndroidOpus,                 /**< reference: OMX_AUDIO_PARAM_ANDROID_OPUSTYPE */
++    OMX_IndexParamAudioAndroidAacPresentation,      /**< reference: OMX_AUDIO_PARAM_ANDROID_AACPRESENTATIONTYPE */
++    OMX_IndexParamAudioAndroidEac3,                 /**< reference: OMX_AUDIO_PARAM_ANDROID_EAC3TYPE */
++    OMX_IndexParamAudioProfileQuerySupported,       /**< reference: OMX_AUDIO_PARAM_ANDROID_PROFILETYPE */
++
++    /* Image parameters and configurations */
++    OMX_IndexExtImageStartUnused = OMX_IndexKhronosExtensions + 0x00500000,
++
++    /* Video parameters and configurations */
++    OMX_IndexExtVideoStartUnused = OMX_IndexKhronosExtensions + 0x00600000,
++    OMX_IndexParamNalStreamFormatSupported,         /**< reference: OMX_NALSTREAMFORMATTYPE */
++    OMX_IndexParamNalStreamFormat,                  /**< reference: OMX_NALSTREAMFORMATTYPE */
++    OMX_IndexParamNalStreamFormatSelect,            /**< reference: OMX_NALSTREAMFORMATTYPE */
++    OMX_IndexParamVideoVp8,                         /**< reference: OMX_VIDEO_PARAM_VP8TYPE */
++    OMX_IndexConfigVideoVp8ReferenceFrame,          /**< reference: OMX_VIDEO_VP8REFERENCEFRAMETYPE */
++    OMX_IndexConfigVideoVp8ReferenceFrameType,      /**< reference: OMX_VIDEO_VP8REFERENCEFRAMEINFOTYPE */
++    OMX_IndexParamVideoAndroidVp8Encoder,           /**< reference: OMX_VIDEO_PARAM_ANDROID_VP8ENCODERTYPE */
++    OMX_IndexParamVideoHevc,                        /**< reference: OMX_VIDEO_PARAM_HEVCTYPE */
++    OMX_IndexParamSliceSegments,                    /**< reference: OMX_VIDEO_SLICESEGMENTSTYPE */
++    OMX_IndexConfigAndroidIntraRefresh,             /**< reference: OMX_VIDEO_CONFIG_ANDROID_INTRAREFRESHTYPE */
++    OMX_IndexParamAndroidVideoTemporalLayering,     /**< reference: OMX_VIDEO_PARAM_ANDROID_TEMPORALLAYERINGTYPE */
++    OMX_IndexConfigAndroidVideoTemporalLayering,    /**< reference: OMX_VIDEO_CONFIG_ANDROID_TEMPORALLAYERINGTYPE */
++
++    /* Image & Video common configurations */
++    OMX_IndexExtCommonStartUnused = OMX_IndexKhronosExtensions + 0x00700000,
++
++    /* Other configurations */
++    OMX_IndexExtOtherStartUnused = OMX_IndexKhronosExtensions + 0x00800000,
++    OMX_IndexConfigAutoFramerateConversion,         /**< reference: OMX_CONFIG_BOOLEANTYPE */
++    OMX_IndexConfigPriority,                        /**< reference: OMX_PARAM_U32TYPE */
++    OMX_IndexConfigOperatingRate,                   /**< reference: OMX_PARAM_U32TYPE in Q16 format for video and in Hz for audio */
++    OMX_IndexParamConsumerUsageBits,                /**< reference: OMX_PARAM_U32TYPE */
++
++    /* Time configurations */
++    OMX_IndexExtTimeStartUnused = OMX_IndexKhronosExtensions + 0x00900000,
++
++    OMX_IndexExtMax = 0x7FFFFFFF
++} OMX_INDEXEXTTYPE;
++
++#ifdef __cplusplus
++}
++#endif /* __cplusplus */
++
++#endif /* OMX_IndexExt_h */
++/* File EOF */
+diff --git a/sf-extra/omx-il/OMX_Other.h b/sf-extra/omx-il/OMX_Other.h
+new file mode 100644
+index 00000000..8aa67b7e
+--- /dev/null
++++ b/sf-extra/omx-il/OMX_Other.h
+@@ -0,0 +1,366 @@
++/*
++ * Copyright (c) 2008 The Khronos Group Inc.
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining
++ * a copy of this software and associated documentation files (the
++ * "Software"), to deal in the Software without restriction, including
++ * without limitation the rights to use, copy, modify, merge, publish,
++ * distribute, sublicense, and/or sell copies of the Software, and to
++ * permit persons to whom the Software is furnished to do so, subject
++ * to the following conditions:
++ * The above copyright notice and this permission notice shall be included
++ * in all copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
++ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
++ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
++ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
++ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
++ *
++ */
++
++/** @file OMX_Other.h - OpenMax IL version 1.1.2
++ *  The structures needed by Other components to exchange
++ *  parameters and configuration data with the components.
++ */
++
++#ifndef OMX_Other_h
++#define OMX_Other_h
++
++#ifdef __cplusplus
++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
++ */
++
++#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,
++                                   time deltas, etc */
++                           OMX_OTHER_FormatPower,    /**< Perhaps used for enabling/disabling power
++                                   management, setting clocks? */
++                           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
++                                                formats */
++
++                                                            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
++                                * the actual seek position if it
++                                * results in a faster 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_SeekModeVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_TIME_SeekModeMax = 0x7FFFFFFF
++} OMX_TIME_SEEKMODETYPE;
++
++/* Structure representing the seekmode of the component */
++typedef struct OMX_TIME_CONFIG_SEEKMODETYPE {
++    OMX_U32 nSize;                  /**< size of the structure in bytes */
++    OMX_VERSIONTYPE nVersion;       /**< OMX specification version information */
++    OMX_TIME_SEEKMODETYPE eType;    /**< The seek mode */
++} OMX_TIME_CONFIG_SEEKMODETYPE;
++
++/**
++ * colorspace 
++ */
++typedef enum OMX_ROCKCHIP_EXT_COLORSPACE {
++    OMX_RK_EXT_ColorspaceBT709 = 1,
++    OMX_RK_EXT_ColorspaceBT2020,
++    OMX_RK_EXT_ColorspaceMax = 0x7FFFFFFF
++} OMX_RK_EXT_COLORSPACE;
++
++/**
++ * dynamic range
++ */
++typedef enum OMX_ROCKCHIP_EXT_DYNCRANGE {
++    OMX_RK_EXT_DyncrangeSDR = 0,
++    OMX_RK_EXT_DyncrangeHDR10,
++    OMX_RK_EXT_DyncrangeHDRHLG,
++    OMX_RK_EXT_DyncrangeHDRDOLBY,
++    OMX_RK_EXT_DyncrangeMax = 0x7FFFFFFF
++} OMX_RK_EXT_DYNCRANGE;
++
++
++/* Structure Rockchip extension HDR param of the component */
++ typedef struct OMX_EXTENSION_VIDEO_PARAM_HDR {
++    OMX_U32 nSize;                  /**< size of the structure in bytes */
++    OMX_VERSIONTYPE nVersion;       /**< OMX specification version information */
++    OMX_RK_EXT_COLORSPACE eColorSpace;    /**< Color space */
++    OMX_RK_EXT_DYNCRANGE eDyncRange;    /**< dynamic range */
++} OMX_EXTENSION_VIDEO_PARAM_HDR;
++
++/** Structure representing a time stamp used with the following configs
++ * on the Clock Component (CC):
++ *
++ * OMX_IndexConfigTimeCurrentWallTime: query of the CC’s current wall
++ *     time
++ * OMX_IndexConfigTimeCurrentMediaTime: query of the CC’s current media
++ *     time
++ * 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
++ *     client port when it receives a buffer with
++ *     OMX_BUFFERFLAG_STARTTIME set. It must use the timestamp
++ *     specified by that buffer for nStartTimestamp.
++ *
++ * It’s also used with the following config on components in general:
++ *
++ * 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;
++
++/** 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_UpdateClockStateChanged,     /**< Update was generated because the clock state changed. */
++    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;
++
++/** 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_RefClockVideo,   /**< Use references sent through OMX_IndexConfigTimeCurrentVideoReference */
++    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;
++
++/** Enumeration of clock states. */
++typedef enum OMX_TIME_CLOCKSTATE {
++    OMX_TIME_ClockStateRunning,             /**< Clock running. */
++    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_ClockStateVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_TIME_ClockStateMax = 0x7FFFFFFF
++} OMX_TIME_CLOCKSTATE;
++
++/** Structure representing a media time request to the clock component.
++ *
++ *  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
++ *  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.
++ *
++ *  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
++ *  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
++ *  to wait a slight amount more time itself as specified by the return values).
++ */
++
++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
++                                 *   updates. */
++    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.
++ *
++ *   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.
++ *
++ *   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.
++ *
++ *   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
++ *   fields the client may use to wait for the remaining time.
++ *
++ *   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.
++ */
++
++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.
++                                     *   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 nOffset;              /**< Amount of wall clock time by which this
++                                     *   request was actually fulfilled early */
++
++    OMX_TICKS nWallTimeAtMediaTime; /**< Wall time corresponding to nMediaTimeStamp.
++                                     *   A client may compare this value to current
++                                     *   media time obtained from the Clock Component to determine
++                                     *   the wall time until the media timestamp is really
++                                     *   current. */
++    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;
++
++/** 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.
++ */
++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 */
++#define OMX_CLOCKPORT0 0x00000001
++#define OMX_CLOCKPORT1 0x00000002
++#define OMX_CLOCKPORT2 0x00000004
++#define OMX_CLOCKPORT3 0x00000008
++#define OMX_CLOCKPORT4 0x00000010
++#define OMX_CLOCKPORT5 0x00000020
++#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
++ *  media clock of the clock component. Applicable only to clock
++ *  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. */
++typedef struct OMX_TIME_CONFIG_CLOCKSTATETYPE {
++    OMX_U32 nSize;              /**< size of the structure in bytes */
++    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
++                                 * (e.g. preroll). Media time will be
++                                 * 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
++ *  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_CONFIG_ACTIVEREFCLOCKTYPE;
++
++/** Descriptor for setting specifics of power type.
++ *  Note: this structure is listed for backwards compatibility. */
++typedef struct OMX_OTHER_CONFIG_POWERTYPE {
++    OMX_U32 nSize;            /**< size of the structure in bytes */
++    OMX_VERSIONTYPE nVersion; /**< OMX specification version information */
++    OMX_BOOL bEnablePM;       /**< Flag to enable Power Management */
++} OMX_OTHER_CONFIG_POWERTYPE;
++
++
++/** Descriptor for setting specifics of stats type.
++ *  Note: this structure is listed for backwards compatibility. */
++typedef struct OMX_OTHER_CONFIG_STATSTYPE {
++    OMX_U32 nSize;            /**< size of the structure in bytes */
++    OMX_VERSIONTYPE nVersion; /**< OMX specification version information */
++    /* what goes here */
++} 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
++ * path.
++ */
++typedef struct OMX_OTHER_PORTDEFINITIONTYPE {
++    OMX_OTHER_FORMATTYPE eFormat;  /**< Type of data expected for this channel */
++} OMX_OTHER_PORTDEFINITIONTYPE;
++
++/**  Port format parameter.  This structure is used to enumerate
++  *  the various data input/output format supported by the port.
++  */
++typedef struct OMX_OTHER_PARAM_PORTFORMATTYPE {
++    OMX_U32 nSize; /**< size of the structure in bytes */
++    OMX_VERSIONTYPE nVersion; /**< OMX specification version information */
++    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;
++
++#ifdef __cplusplus
++}
++#endif /* __cplusplus */
++
++#endif
++/* File EOF */
+diff --git a/sf-extra/omx-il/OMX_Types.h b/sf-extra/omx-il/OMX_Types.h
+new file mode 100644
+index 00000000..527ba235
+--- /dev/null
++++ b/sf-extra/omx-il/OMX_Types.h
+@@ -0,0 +1,361 @@
++/*
++ * Copyright (c) 2016 The Khronos Group Inc.
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining
++ * a copy of this software and associated documentation files (the
++ * "Software"), to deal in the Software without restriction, including
++ * without limitation the rights to use, copy, modify, merge, publish,
++ * distribute, sublicense, and/or sell copies of the Software, and to
++ * permit persons to whom the Software is furnished to do so, subject
++ * to the following conditions:
++ * The above copyright notice and this permission notice shall be included
++ * in all copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
++ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
++ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
++ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
++ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
++ *
++ */
++
++/** OMX_Types.h - OpenMax IL version 1.1.2
++ *  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,
++ *  "short" set to 16 bits and "long" set to 32 bits.
++ */
++
++#ifndef OMX_Types_h
++#define OMX_Types_h
++
++#include <stdint.h>
++
++#ifdef __cplusplus
++extern "C" {
++#endif /* __cplusplus */
++
++/** 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 __OMX_EXPORTS
++#       define OMX_API __declspec(dllexport)
++#   else
++#       ifdef _WIN32
++#           define OMX_API __declspec(dllexport)
++#       else
++#           define OMX_API __declspec(dllimport)
++#       endif
++#   endif
++#else
++#   ifdef _WIN32
++#      ifdef __OMX_EXPORTS
++#          define OMX_API __declspec(dllexport)
++#      else
++#          define OMX_API __declspec(dllimport)
++#      endif
++#   else
++#      ifdef __OMX_EXPORTS
++#          define OMX_API
++#      else
++#          define OMX_API extern
++#      endif
++#   endif
++#endif
++
++#ifndef OMX_APIENTRY
++#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
++    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
++    to a parameter that is used as an input. */
++#ifndef OMX_OUT
++#define OMX_OUT
++#endif
++
++
++/** 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
++    is used both as an input and an output. */
++#ifndef OMX_INOUT
++#define OMX_INOUT
++#endif
++
++/** OMX_ALL is used to as a wildcard to select all entities of the same type
++ *  when specifying the index, or referring to a object by an index.  (i.e.
++ *  use OMX_ALL to indicate all N channels). When used as a port index
++ *  for a config or parameter this OMX_ALL denotes that the config or
++ *  parameter applies to the entire component not just one port. */
++#define OMX_ALL 0xFFFFFFFF
++
++/** In the following we define groups that help building doxygen documentation */
++
++/** @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
++ * 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 uint8_t OMX_U8;
++
++/** OMX_S8 is an 8 bit signed quantity that is byte aligned */
++typedef int8_t OMX_S8;
++
++/** OMX_U16 is a 16 bit unsigned quantity that is 16 bit word aligned */
++typedef uint16_t OMX_U16;
++
++/** OMX_S16 is a 16 bit signed quantity that is 16 bit word aligned */
++typedef int16_t OMX_S16;
++
++/** OMX_U32 is a 32 bit unsigned quantity that is 32 bit word aligned */
++typedef uint32_t OMX_U32;
++
++/** OMX_S32 is a 32 bit signed quantity that is 32 bit word aligned */
++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
++   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.
++*/
++#ifndef OMX_SKIP64BIT
++#ifdef __SYMBIAN32__
++/** OMX_U64 is a 64 bit unsigned quantity that is 64 bit word aligned */
++typedef unsigned long long OMX_U64;
++
++/** OMX_S64 is a 64 bit signed quantity that is 64 bit word aligned */
++typedef signed long long OMX_S64;
++
++#elif defined(WIN32)
++
++/** 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 */
++typedef signed   __int64  OMX_S64;
++
++#else /* WIN32 */
++
++/** OMX_U64 is a 64 bit unsigned quantity that is 64 bit word aligned */
++typedef uint64_t OMX_U64;
++
++/** OMX_S64 is a 64 bit signed quantity that is 64 bit word aligned */
++typedef int64_t OMX_S64;
++
++#endif /* WIN32 */
++#endif
++
++
++/** 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.
++ */
++typedef enum OMX_BOOL {
++    OMX_FALSE = 0,
++    OMX_TRUE = !OMX_FALSE,
++    OMX_BOOL_MAX = 0x7FFFFFFF
++} OMX_BOOL;
++
++/** The OMX_PTR type is intended to be used to pass pointers between the OMX
++    applications and the OMX Core and components.  This is a 32 bit pointer and
++    is aligned on a 32 bit boundary.
++ */
++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.
++ */
++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
++    type is a 32 bit pointer to a zero terminated string.  The  pointer is word
++    aligned and the string is byte aligned.
++ */
++typedef unsigned char* OMX_BYTE;
++
++/** OMX_UUIDTYPE is a very long unique identifier to uniquely identify
++    at runtime.  This identifier should be generated by a component in a way
++    that guarantees that every instance of the identifier running on the system
++    is unique. */
++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.
++ */
++typedef enum OMX_DIRTYPE
++{
++    OMX_DirInput,              /**< Port is an input port */
++    OMX_DirOutput,             /**< Port is an output port */
++    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).
++ */
++typedef enum OMX_ENDIANTYPE
++{
++    OMX_EndianBig, /**< big endian */
++    OMX_EndianLittle, /**< little endian */
++    OMX_EndianMax = 0x7FFFFFFF
++} OMX_ENDIANTYPE;
++
++
++/** The OMX_NUMERICALDATATYPE enumeration is used to indicate if data
++    is signed or unsigned
++ */
++typedef enum OMX_NUMERICALDATATYPE
++{
++    OMX_NumericalDataSigned, /**< signed data */
++    OMX_NumericalDataUnsigned, /**< unsigned data */
++    OMX_NumercialDataMax = 0x7FFFFFFF
++} OMX_NUMERICALDATATYPE;
++
++
++/** Unsigned bounded value type */
++typedef struct OMX_BU32 {
++    OMX_U32 nValue; /**< actual value */
++    OMX_U32 nMin;   /**< minimum for value (i.e. nValue >= nMin) */
++    OMX_U32 nMax;   /**< maximum for value (i.e. nValue <= nMax) */
++} OMX_BU32;
++
++
++/** Signed bounded value type */
++typedef struct OMX_BS32 {
++    OMX_S32 nValue; /**< actual value */
++    OMX_S32 nMin;   /**< minimum for value (i.e. nValue >= nMin) */
++    OMX_S32 nMax;   /**< maximum for value (i.e. nValue <= nMax) */
++} 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
++  *  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
++  *  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.
++  */
++#ifndef OMX_SKIP64BIT
++typedef OMX_S64 OMX_TICKS;
++#else
++typedef struct OMX_TICKS
++{
++    OMX_U32 nLowPart;    /** low bits of the signed 64 bit tick value */
++    OMX_U32 nHighPart;   /** high bits of the signed 64 bit tick value */
++} OMX_TICKS;
++#endif
++#define OMX_TICKS_PER_SECOND 1000000
++
++/** Define the public interface for the OMX Handle.  The core will not use
++    this value internally, but the application should only use this value.
++ */
++typedef void* OMX_HANDLETYPE;
++
++typedef struct OMX_MARKTYPE
++{
++    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
++                              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
++ *  or can be used by a audio port for native audio rendering */
++typedef void* OMX_NATIVE_DEVICETYPE;
++
++/** OMX_NATIVE_WINDOWTYPE is used to map a OMX video port to the
++ *  platform & operating specific object used to reference the window */
++typedef void* OMX_NATIVE_WINDOWTYPE;
++
++
++/** Define the OMX IL version that corresponds to this set of header files.
++ *  We also define a combined version that can be used to write or compare
++ *  values of the 32bit nVersion field, assuming a little endian architecture */
++#define OMX_VERSION_MAJOR 1
++#define OMX_VERSION_MINOR 1
++#define OMX_VERSION_REVISION 2
++#define OMX_VERSION_STEP 0
++
++#define OMX_VERSION ((OMX_VERSION_STEP<<24) | (OMX_VERSION_REVISION<<16) | (OMX_VERSION_MINOR<<8) | OMX_VERSION_MAJOR)
++
++
++/** 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
++    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
++    OMX_VERSIONTYPE can be by a single 32 bit access (e.g. by nVersion) or
++    by accessing one of the structure elements to, for example, check only
++    the Major revision.
++ */
++typedef union OMX_VERSIONTYPE
++{
++    struct
++    {
++        OMX_U8 nVersionMajor;   /**< Major version accessor element */
++        OMX_U8 nVersionMinor;   /**< Minor version accessor element */
++        OMX_U8 nRevision;       /**< Revision version accessor element */
++        OMX_U8 nStep;           /**< Step version accessor element */
++    } s;
++    OMX_U32 nVersion;           /**< 32 bit value to make accessing the
++                                    version easily done in a single word
++                                    size copy/compare operation */
++} OMX_VERSIONTYPE;
++
++#ifdef __cplusplus
++}
++#endif /* __cplusplus */
++
++#endif
++/* File EOF */
+diff --git a/sf-extra/omx-il/OMX_Video.h b/sf-extra/omx-il/OMX_Video.h
+new file mode 100644
+index 00000000..6fa26266
+--- /dev/null
++++ b/sf-extra/omx-il/OMX_Video.h
+@@ -0,0 +1,1141 @@
++/**
++ * Copyright (c) 2008 The Khronos Group Inc.
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining
++ * a copy of this software and associated documentation files (the
++ * "Software"), to deal in the Software without restriction, including
++ * without limitation the rights to use, copy, modify, merge, publish,
++ * distribute, sublicense, and/or sell copies of the Software, and to
++ * permit persons to whom the Software is furnished to do so, subject
++ * to the following conditions:
++ * The above copyright notice and this permission notice shall be included
++ * in all copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
++ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
++ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
++ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
++ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
++ *
++ */
++
++/**
++ *  @file OMX_Video.h - OpenMax IL version 1.1.2
++ *  The structures is needed by Video components to exchange parameters
++ *  and configuration data with OMX components.
++ */
++#ifndef OMX_Video_h
++#define OMX_Video_h
++
++/** @defgroup video OpenMAX IL Video Domain
++ * @ingroup iv
++ * Structures for OpenMAX IL Video domain
++ * @{
++ */
++
++#ifdef __cplusplus
++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
++ */
++
++#include <OMX_IVCommon.h>
++
++
++/**
++ * Enumeration used to define the possible video compression codings.
++ * NOTE:  This essentially refers to file extensions. If the coding is
++ *        being used to specify the ENCODE type, then additional work
++ *        must be done to configure the exact flavor of the compression
++ *        to be used.  For decode cases where the user application can
++ *        not differentiate between MPEG-4 and H.264 bit streams, it is
++ *        up to the codec to handle this.
++ */
++typedef enum OMX_VIDEO_CODINGTYPE {
++    OMX_VIDEO_CodingUnused,     /**< Value when coding is N/A */
++    OMX_VIDEO_CodingAutoDetect, /**< Autodetection of coding type */
++    OMX_VIDEO_CodingMPEG2,      /**< AKA: H.262 */
++    OMX_VIDEO_CodingH263,       /**< H.263 */
++    OMX_VIDEO_CodingMPEG4,      /**< MPEG-4 */
++    OMX_VIDEO_CodingWMV,        /**< all versions of Windows Media Video */
++    OMX_VIDEO_CodingRV,         /**< all versions of Real Video */
++    OMX_VIDEO_CodingAVC,        /**< H.264/AVC */
++    OMX_VIDEO_CodingMJPEG,      /**< Motion JPEG */
++    OMX_VIDEO_CodingVP8,        /**< Google VP8, formerly known as On2 VP8 */
++    OMX_VIDEO_CodingVP9,        /**< Google VP9 */
++    OMX_VIDEO_CodingHEVC,       /**< ITU H.265/HEVC */
++    OMX_VIDEO_CodingKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_VIDEO_CodingVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_VIDEO_CodingMax = 0x7FFFFFFF
++} OMX_VIDEO_CODINGTYPE;
++
++
++/**
++ * Data structure used to define a video path.  The number of Video paths for
++ * input and output will vary by type of the Video 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 video
++ * 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
++ * GetDefaultInitParams command.
++ *
++ * STRUCT MEMBERS:
++ *  cMIMEType             : MIME type of data for the port
++ *  pNativeRender         : Platform specific reference for a display if a
++ *                          sync, otherwise this field is 0
++ *  nFrameWidth           : Width of frame to be used on channel if
++ *                          uncompressed format is used.  Use 0 for unknown,
++ *                          don't care or variable
++ *  nFrameHeight          : Height of frame to be used on channel 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. indicates the number of bytes to get
++ *                          from span N to span N+1, where negative stride
++ *                          indicates the image is bottom up
++ *  nSliceHeight          : Height used when encoding in slices
++ *  nBitrate              : Bit rate of frame to be used on channel if
++ *                          compressed format is used. Use 0 for unknown,
++ *                          don't care or variable
++ *  xFramerate            : Frame rate to be used on channel if uncompressed
++ *                          format is used. Use 0 for unknown, don't care or
++ *                          variable.  Units are Q16 frames per second.
++ *  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_VIDEO_CodingUnused is
++ *                          specified, eColorFormat is used
++ *  eColorFormat : Decompressed format used by this component
++ *  pNativeWindow : Platform specific reference for a window object if a
++ *                          display sink , otherwise this field is 0x0.
++ */
++typedef struct OMX_VIDEO_PORTDEFINITIONTYPE {
++    OMX_STRING cMIMEType;
++    OMX_NATIVE_DEVICETYPE pNativeRender;
++    OMX_U32 nFrameWidth;
++    OMX_U32 nFrameHeight;
++    OMX_S32 nStride;
++    OMX_U32 nSliceHeight;
++    OMX_U32 nBitrate;
++    OMX_U32 xFramerate;
++    OMX_BOOL bFlagErrorConcealment;
++    OMX_VIDEO_CODINGTYPE eCompressionFormat;
++    OMX_COLOR_FORMATTYPE eColorFormat;
++    OMX_NATIVE_WINDOWTYPE pNativeWindow;
++} OMX_VIDEO_PORTDEFINITIONTYPE;
++
++/**
++ * 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
++ *                       0x0 to N-1
++ *  eCompressionFormat : Compression format used in this instance of the
++ *                       component. When OMX_VIDEO_CodingUnused is specified,
++ *                       eColorFormat is used
++ *  eColorFormat       : Decompressed format used by this component
++ *  xFrameRate         : Indicates the video frame rate in Q16 format
++ */
++typedef struct OMX_VIDEO_PARAM_PORTFORMATTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_U32 nIndex;
++    OMX_VIDEO_CODINGTYPE eCompressionFormat;
++    OMX_COLOR_FORMATTYPE eColorFormat;
++    OMX_U32 xFramerate;
++} OMX_VIDEO_PARAM_PORTFORMATTYPE;
++
++
++/**
++ * This is a structure for configuring video compression quantization
++ * parameter values.  Codecs may support different QP values for different
++ * frame types.
++ *
++ * STRUCT MEMBERS:
++ *  nSize      : Size of the structure in bytes
++ *  nVersion   : OMX specification version info
++ *  nPortIndex : Port that this structure applies to
++ *  nQpI       : QP value to use for index frames
++ *  nQpP       : QP value to use for P frames
++ *  nQpB       : QP values to use for bidirectional frames
++ */
++typedef struct OMX_VIDEO_PARAM_QUANTIZATIONTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_U32 nQpI;
++    OMX_U32 nQpP;
++    OMX_U32 nQpB;
++} OMX_VIDEO_PARAM_QUANTIZATIONTYPE;
++
++
++/**
++ * Structure for configuration of video fast update parameters.
++ *
++ * STRUCT MEMBERS:
++ *  nSize      : Size of the structure in bytes
++ *  nVersion   : OMX specification version info
++ *  nPortIndex : Port that this structure applies to
++ *  bEnableVFU : Enable/Disable video fast update
++ *  nFirstGOB  : Specifies the number of the first macroblock row
++ *  nFirstMB   : specifies the first MB relative to the specified first GOB
++ *  nNumMBs    : Specifies the number of MBs to be refreshed from nFirstGOB
++ *               and nFirstMB
++ */
++typedef struct OMX_VIDEO_PARAM_VIDEOFASTUPDATETYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_BOOL bEnableVFU;
++    OMX_U32 nFirstGOB;
++    OMX_U32 nFirstMB;
++    OMX_U32 nNumMBs;
++} OMX_VIDEO_PARAM_VIDEOFASTUPDATETYPE;
++
++
++/**
++ * Enumeration of possible bitrate control types
++ */
++typedef enum OMX_VIDEO_CONTROLRATETYPE {
++    OMX_Video_ControlRateDisable,
++    OMX_Video_ControlRateVariable,
++    OMX_Video_ControlRateConstant,
++    OMX_Video_ControlRateVariableSkipFrames,
++    OMX_Video_ControlRateConstantSkipFrames,
++    OMX_Video_ControlRateKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_Video_ControlRateVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_Video_ControlRateMax = 0x7FFFFFFF
++} OMX_VIDEO_CONTROLRATETYPE;
++
++
++/**
++ * Structure for configuring bitrate mode of a codec.
++ *
++ * STRUCT MEMBERS:
++ *  nSize          : Size of the struct in bytes
++ *  nVersion       : OMX spec version info
++ *  nPortIndex     : Port that this struct applies to
++ *  eControlRate   : Control rate type enum
++ *  nTargetBitrate : Target bitrate to encode with
++ */
++typedef struct OMX_VIDEO_PARAM_BITRATETYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_VIDEO_CONTROLRATETYPE eControlRate;
++    OMX_U32 nTargetBitrate;
++} OMX_VIDEO_PARAM_BITRATETYPE;
++
++
++/**
++ * Enumeration of possible motion vector (MV) types
++ */
++typedef enum OMX_VIDEO_MOTIONVECTORTYPE {
++    OMX_Video_MotionVectorPixel,
++    OMX_Video_MotionVectorHalfPel,
++    OMX_Video_MotionVectorQuarterPel,
++    OMX_Video_MotionVectorEighthPel,
++    OMX_Video_MotionVectorKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_Video_MotionVectorVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_Video_MotionVectorMax = 0x7FFFFFFF
++} OMX_VIDEO_MOTIONVECTORTYPE;
++
++
++/**
++ * Structure for configuring the number of motion vectors used as well
++ * as their accuracy.
++ *
++ * STRUCT MEMBERS:
++ *  nSize            : Size of the struct in bytes
++ *  nVersion         : OMX spec version info
++ *  nPortIndex       : port that this structure applies to
++ *  eAccuracy        : Enumerated MV accuracy
++ *  bUnrestrictedMVs : Allow unrestricted MVs
++ *  bFourMV          : Allow use of 4 MVs
++ *  sXSearchRange    : Search range in horizontal direction for MVs
++ *  sYSearchRange    : Search range in vertical direction for MVs
++ */
++typedef struct OMX_VIDEO_PARAM_MOTIONVECTORTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_VIDEO_MOTIONVECTORTYPE eAccuracy;
++    OMX_BOOL bUnrestrictedMVs;
++    OMX_BOOL bFourMV;
++    OMX_S32 sXSearchRange;
++    OMX_S32 sYSearchRange;
++} OMX_VIDEO_PARAM_MOTIONVECTORTYPE;
++
++
++/**
++ * Enumeration of possible methods to use for Intra Refresh
++ */
++typedef enum OMX_VIDEO_INTRAREFRESHTYPE {
++    OMX_VIDEO_IntraRefreshCyclic,
++    OMX_VIDEO_IntraRefreshAdaptive,
++    OMX_VIDEO_IntraRefreshBoth,
++    OMX_VIDEO_IntraRefreshKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_VIDEO_IntraRefreshVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_VIDEO_IntraRefreshMax = 0x7FFFFFFF
++} OMX_VIDEO_INTRAREFRESHTYPE;
++
++
++/**
++ * Structure for configuring intra refresh mode
++ *
++ * STRUCT MEMBERS:
++ *  nSize        : Size of the structure in bytes
++ *  nVersion     : OMX specification version information
++ *  nPortIndex   : Port that this structure applies to
++ *  eRefreshMode : Cyclic, Adaptive, or Both
++ *  nAirMBs      : Number of intra macroblocks to refresh in a frame when
++ *                 AIR is enabled
++ *  nAirRef      : Number of times a motion marked macroblock has to be
++ *                 intra coded
++ *  nCirMBs      : Number of consecutive macroblocks to be coded as "intra"
++ *                 when CIR is enabled
++ */
++typedef struct OMX_VIDEO_PARAM_INTRAREFRESHTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_VIDEO_INTRAREFRESHTYPE eRefreshMode;
++    OMX_U32 nAirMBs;
++    OMX_U32 nAirRef;
++    OMX_U32 nCirMBs;
++} OMX_VIDEO_PARAM_INTRAREFRESHTYPE;
++
++
++/**
++ * Structure for enabling various error correction methods for video
++ * compression.
++ *
++ * STRUCT MEMBERS:
++ *  nSize                   : Size of the structure in bytes
++ *  nVersion                : OMX specification version information
++ *  nPortIndex              : Port that this structure applies to
++ *  bEnableHEC              : Enable/disable header extension codes (HEC)
++ *  bEnableResync           : Enable/disable resynchronization markers
++ *  nResynchMarkerSpacing   : Resynch markers interval (in bits) to be
++ *                            applied in the stream
++ *  bEnableDataPartitioning : Enable/disable data partitioning
++ *  bEnableRVLC             : Enable/disable reversible variable length
++ *                            coding
++ */
++typedef struct OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_BOOL bEnableHEC;
++    OMX_BOOL bEnableResync;
++    OMX_U32  nResynchMarkerSpacing;
++    OMX_BOOL bEnableDataPartitioning;
++    OMX_BOOL bEnableRVLC;
++} OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE;
++
++
++/**
++ * Configuration of variable block-size motion compensation (VBSMC)
++ *
++ * STRUCT MEMBERS:
++ *  nSize      : Size of the structure in bytes
++ *  nVersion   : OMX specification version information
++ *  nPortIndex : Port that this structure applies to
++ *  b16x16     : Enable inter block search 16x16
++ *  b16x8      : Enable inter block search 16x8
++ *  b8x16      : Enable inter block search 8x16
++ *  b8x8       : Enable inter block search 8x8
++ *  b8x4       : Enable inter block search 8x4
++ *  b4x8       : Enable inter block search 4x8
++ *  b4x4       : Enable inter block search 4x4
++ */
++typedef struct OMX_VIDEO_PARAM_VBSMCTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_BOOL b16x16;
++    OMX_BOOL b16x8;
++    OMX_BOOL b8x16;
++    OMX_BOOL b8x8;
++    OMX_BOOL b8x4;
++    OMX_BOOL b4x8;
++    OMX_BOOL b4x4;
++} OMX_VIDEO_PARAM_VBSMCTYPE;
++
++
++/**
++ * H.263 profile types, each profile indicates support for various
++ * performance bounds and different annexes.
++ *
++ * ENUMS:
++ *  Baseline           : Baseline Profile: H.263 (V1), no optional modes
++ *  H320 Coding        : H.320 Coding Efficiency Backward Compatibility
++ *                       Profile: H.263+ (V2), includes annexes I, J, L.4
++ *                       and T
++ *  BackwardCompatible : Backward Compatibility Profile: H.263 (V1),
++ *                       includes annex F
++ *  ISWV2              : Interactive Streaming Wireless Profile: H.263+
++ *                       (V2), includes annexes I, J, K and T
++ *  ISWV3              : Interactive Streaming Wireless Profile: H.263++
++ *                       (V3), includes profile 3 and annexes V and W.6.3.8
++ *  HighCompression    : Conversational High Compression Profile: H.263++
++ *                       (V3), includes profiles 1 & 2 and annexes D and U
++ *  Internet           : Conversational Internet Profile: H.263++ (V3),
++ *                       includes profile 5 and annex K
++ *  Interlace          : Conversational Interlace Profile: H.263++ (V3),
++ *                       includes profile 5 and annex W.6.3.11
++ *  HighLatency        : High Latency Profile: H.263++ (V3), includes
++ *                       profile 6 and annexes O.1 and P.5
++ */
++typedef enum OMX_VIDEO_H263PROFILETYPE {
++    OMX_VIDEO_H263ProfileBaseline            = 0x01,
++    OMX_VIDEO_H263ProfileH320Coding          = 0x02,
++    OMX_VIDEO_H263ProfileBackwardCompatible  = 0x04,
++    OMX_VIDEO_H263ProfileISWV2               = 0x08,
++    OMX_VIDEO_H263ProfileISWV3               = 0x10,
++    OMX_VIDEO_H263ProfileHighCompression     = 0x20,
++    OMX_VIDEO_H263ProfileInternet            = 0x40,
++    OMX_VIDEO_H263ProfileInterlace           = 0x80,
++    OMX_VIDEO_H263ProfileHighLatency         = 0x100,
++    OMX_VIDEO_H263ProfileKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_VIDEO_H263ProfileVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_VIDEO_H263ProfileMax                 = 0x7FFFFFFF
++} OMX_VIDEO_H263PROFILETYPE;
++
++
++/**
++ * H.263 level types, each level indicates support for various frame sizes,
++ * bit rates, decoder frame rates.
++ */
++typedef enum OMX_VIDEO_H263LEVELTYPE {
++    OMX_VIDEO_H263Level10  = 0x01,
++    OMX_VIDEO_H263Level20  = 0x02,
++    OMX_VIDEO_H263Level30  = 0x04,
++    OMX_VIDEO_H263Level40  = 0x08,
++    OMX_VIDEO_H263Level45  = 0x10,
++    OMX_VIDEO_H263Level50  = 0x20,
++    OMX_VIDEO_H263Level60  = 0x40,
++    OMX_VIDEO_H263Level70  = 0x80,
++    OMX_VIDEO_H263LevelKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_VIDEO_H263LevelVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_VIDEO_H263LevelMax = 0x7FFFFFFF
++} OMX_VIDEO_H263LEVELTYPE;
++
++
++/**
++ * Specifies the picture type. These values should be OR'd to signal all
++ * pictures types which are allowed.
++ *
++ * ENUMS:
++ *  Generic Picture Types:          I, P and B
++ *  H.263 Specific Picture Types:   SI and SP
++ *  H.264 Specific Picture Types:   EI and EP
++ *  MPEG-4 Specific Picture Types:  S
++ */
++typedef enum OMX_VIDEO_PICTURETYPE {
++    OMX_VIDEO_PictureTypeI   = 0x01,
++    OMX_VIDEO_PictureTypeP   = 0x02,
++    OMX_VIDEO_PictureTypeB   = 0x04,
++    OMX_VIDEO_PictureTypeSI  = 0x08,
++    OMX_VIDEO_PictureTypeSP  = 0x10,
++    OMX_VIDEO_PictureTypeEI  = 0x11,
++    OMX_VIDEO_PictureTypeEP  = 0x12,
++    OMX_VIDEO_PictureTypeS   = 0x14,
++    OMX_VIDEO_PictureTypeKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_VIDEO_PictureTypeVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_VIDEO_PictureTypeMax = 0x7FFFFFFF
++} OMX_VIDEO_PICTURETYPE;
++
++
++/**
++ * H.263 Params
++ *
++ * STRUCT MEMBERS:
++ *  nSize                    : Size of the structure in bytes
++ *  nVersion                 : OMX specification version information
++ *  nPortIndex               : Port that this structure applies to
++ *  nPFrames                 : Number of P frames between each I frame
++ *  nBFrames                 : Number of B frames between each I frame
++ *  eProfile                 : H.263 profile(s) to use
++ *  eLevel                   : H.263 level(s) to use
++ *  bPLUSPTYPEAllowed        : Indicating that it is allowed to use PLUSPTYPE
++ *                             (specified in the 1998 version of H.263) to
++ *                             indicate custom picture sizes or clock
++ *                             frequencies
++ *  nAllowedPictureTypes     : Specifies the picture types allowed in the
++ *                             bitstream
++ *  bForceRoundingTypeToZero : value of the RTYPE bit (bit 6 of MPPTYPE) is
++ *                             not constrained. It is recommended to change
++ *                             the value of the RTYPE bit for each reference
++ *                             picture in error-free communication
++ *  nPictureHeaderRepetition : Specifies the frequency of picture header
++ *                             repetition
++ *  nGOBHeaderInterval       : Specifies the interval of non-empty GOB
++ *                             headers in units of GOBs
++ */
++typedef struct OMX_VIDEO_PARAM_H263TYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_U32 nPFrames;
++    OMX_U32 nBFrames;
++    OMX_VIDEO_H263PROFILETYPE eProfile;
++    OMX_VIDEO_H263LEVELTYPE eLevel;
++    OMX_BOOL bPLUSPTYPEAllowed;
++    OMX_U32 nAllowedPictureTypes;
++    OMX_BOOL bForceRoundingTypeToZero;
++    OMX_U32 nPictureHeaderRepetition;
++    OMX_U32 nGOBHeaderInterval;
++} OMX_VIDEO_PARAM_H263TYPE;
++
++
++/**
++ * MPEG-2 profile types, each profile indicates support for various
++ * performance bounds and different annexes.
++ */
++typedef enum OMX_VIDEO_MPEG2PROFILETYPE {
++    OMX_VIDEO_MPEG2ProfileSimple = 0,  /**< Simple Profile */
++    OMX_VIDEO_MPEG2ProfileMain,        /**< Main Profile */
++    OMX_VIDEO_MPEG2Profile422,         /**< 4:2:2 Profile */
++    OMX_VIDEO_MPEG2ProfileSNR,         /**< SNR Profile */
++    OMX_VIDEO_MPEG2ProfileSpatial,     /**< Spatial Profile */
++    OMX_VIDEO_MPEG2ProfileHigh,        /**< High Profile */
++    OMX_VIDEO_MPEG2ProfileKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_VIDEO_MPEG2ProfileVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_VIDEO_MPEG2ProfileMax = 0x7FFFFFFF
++} OMX_VIDEO_MPEG2PROFILETYPE;
++
++
++/**
++ * MPEG-2 level types, each level indicates support for various frame
++ * sizes, bit rates, decoder frame rates.  No need
++ */
++typedef enum OMX_VIDEO_MPEG2LEVELTYPE {
++    OMX_VIDEO_MPEG2LevelLL = 0,  /**< Low Level */
++    OMX_VIDEO_MPEG2LevelML,      /**< Main Level */
++    OMX_VIDEO_MPEG2LevelH14,     /**< High 1440 */
++    OMX_VIDEO_MPEG2LevelHL,      /**< High Level */
++    OMX_VIDEO_MPEG2LevelKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_VIDEO_MPEG2LevelVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_VIDEO_MPEG2LevelMax = 0x7FFFFFFF
++} OMX_VIDEO_MPEG2LEVELTYPE;
++
++
++/**
++ * MPEG-2 params
++ *
++ * STRUCT MEMBERS:
++ *  nSize      : Size of the structure in bytes
++ *  nVersion   : OMX specification version information
++ *  nPortIndex : Port that this structure applies to
++ *  nPFrames   : Number of P frames between each I frame
++ *  nBFrames   : Number of B frames between each I frame
++ *  eProfile   : MPEG-2 profile(s) to use
++ *  eLevel     : MPEG-2 levels(s) to use
++ */
++typedef struct OMX_VIDEO_PARAM_MPEG2TYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_U32 nPFrames;
++    OMX_U32 nBFrames;
++    OMX_VIDEO_MPEG2PROFILETYPE eProfile;
++    OMX_VIDEO_MPEG2LEVELTYPE eLevel;
++} OMX_VIDEO_PARAM_MPEG2TYPE;
++
++
++/**
++ * MPEG-4 profile types, each profile indicates support for various
++ * performance bounds and different annexes.
++ *
++ * ENUMS:
++ *  - Simple Profile, Levels 1-3
++ *  - Simple Scalable Profile, Levels 1-2
++ *  - Core Profile, Levels 1-2
++ *  - Main Profile, Levels 2-4
++ *  - N-bit Profile, Level 2
++ *  - Scalable Texture Profile, Level 1
++ *  - Simple Face Animation Profile, Levels 1-2
++ *  - Simple Face and Body Animation (FBA) Profile, Levels 1-2
++ *  - Basic Animated Texture Profile, Levels 1-2
++ *  - Hybrid Profile, Levels 1-2
++ *  - Advanced Real Time Simple Profiles, Levels 1-4
++ *  - Core Scalable Profile, Levels 1-3
++ *  - Advanced Coding Efficiency Profile, Levels 1-4
++ *  - Advanced Core Profile, Levels 1-2
++ *  - Advanced Scalable Texture, Levels 2-3
++ */
++typedef enum OMX_VIDEO_MPEG4PROFILETYPE {
++    OMX_VIDEO_MPEG4ProfileSimple           = 0x01,
++    OMX_VIDEO_MPEG4ProfileSimpleScalable   = 0x02,
++    OMX_VIDEO_MPEG4ProfileCore             = 0x04,
++    OMX_VIDEO_MPEG4ProfileMain             = 0x08,
++    OMX_VIDEO_MPEG4ProfileNbit             = 0x10,
++    OMX_VIDEO_MPEG4ProfileScalableTexture  = 0x20,
++    OMX_VIDEO_MPEG4ProfileSimpleFace       = 0x40,
++    OMX_VIDEO_MPEG4ProfileSimpleFBA        = 0x80,
++    OMX_VIDEO_MPEG4ProfileBasicAnimated    = 0x100,
++    OMX_VIDEO_MPEG4ProfileHybrid           = 0x200,
++    OMX_VIDEO_MPEG4ProfileAdvancedRealTime = 0x400,
++    OMX_VIDEO_MPEG4ProfileCoreScalable     = 0x800,
++    OMX_VIDEO_MPEG4ProfileAdvancedCoding   = 0x1000,
++    OMX_VIDEO_MPEG4ProfileAdvancedCore     = 0x2000,
++    OMX_VIDEO_MPEG4ProfileAdvancedScalable = 0x4000,
++    OMX_VIDEO_MPEG4ProfileAdvancedSimple   = 0x8000,
++    OMX_VIDEO_MPEG4ProfileKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_VIDEO_MPEG4ProfileVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_VIDEO_MPEG4ProfileMax              = 0x7FFFFFFF
++} OMX_VIDEO_MPEG4PROFILETYPE;
++
++
++/**
++ * MPEG-4 level types, each level indicates support for various frame
++ * sizes, bit rates, decoder frame rates.  No need
++ */
++typedef enum OMX_VIDEO_MPEG4LEVELTYPE {
++    OMX_VIDEO_MPEG4Level0  = 0x01,   /**< Level 0 */
++    OMX_VIDEO_MPEG4Level0b = 0x02,   /**< Level 0b */
++    OMX_VIDEO_MPEG4Level1  = 0x04,   /**< Level 1 */
++    OMX_VIDEO_MPEG4Level2  = 0x08,   /**< Level 2 */
++    OMX_VIDEO_MPEG4Level3  = 0x10,   /**< Level 3 */
++    OMX_VIDEO_MPEG4Level4  = 0x20,   /**< Level 4 */
++    OMX_VIDEO_MPEG4Level4a = 0x40,   /**< Level 4a */
++    OMX_VIDEO_MPEG4Level5  = 0x80,   /**< Level 5 */
++    OMX_VIDEO_MPEG4LevelKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_VIDEO_MPEG4LevelVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_VIDEO_MPEG4LevelMax = 0x7FFFFFFF
++} OMX_VIDEO_MPEG4LEVELTYPE;
++
++
++/**
++ * MPEG-4 configuration.  This structure handles configuration options
++ * which are specific to MPEG4 algorithms
++ *
++ * STRUCT MEMBERS:
++ *  nSize                : Size of the structure in bytes
++ *  nVersion             : OMX specification version information
++ *  nPortIndex           : Port that this structure applies to
++ *  nSliceHeaderSpacing  : Number of macroblocks between slice header (H263+
++ *                         Annex K). Put zero if not used
++ *  bSVH                 : Enable Short Video Header mode
++ *  bGov                 : Flag to enable GOV
++ *  nPFrames             : Number of P frames between each I frame (also called
++ *                         GOV period)
++ *  nBFrames             : Number of B frames between each I frame
++ *  nIDCVLCThreshold     : Value of intra DC VLC threshold
++ *  bACPred              : Flag to use ac prediction
++ *  nMaxPacketSize       : Maximum size of packet in bytes.
++ *  nTimeIncRes          : Used to pass VOP time increment resolution for MPEG4.
++ *                         Interpreted as described in MPEG4 standard.
++ *  eProfile             : MPEG-4 profile(s) to use.
++ *  eLevel               : MPEG-4 level(s) to use.
++ *  nAllowedPictureTypes : Specifies the picture types allowed in the bitstream
++ *  nHeaderExtension     : Specifies the number of consecutive video packet
++ *                         headers within a VOP
++ *  bReversibleVLC       : Specifies whether reversible variable length coding
++ *                         is in use
++ */
++typedef struct OMX_VIDEO_PARAM_MPEG4TYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_U32 nSliceHeaderSpacing;
++    OMX_BOOL bSVH;
++    OMX_BOOL bGov;
++    OMX_U32 nPFrames;
++    OMX_U32 nBFrames;
++    OMX_U32 nIDCVLCThreshold;
++    OMX_BOOL bACPred;
++    OMX_U32 nMaxPacketSize;
++    OMX_U32 nTimeIncRes;
++    OMX_VIDEO_MPEG4PROFILETYPE eProfile;
++    OMX_VIDEO_MPEG4LEVELTYPE eLevel;
++    OMX_U32 nAllowedPictureTypes;
++    OMX_U32 nHeaderExtension;
++    OMX_BOOL bReversibleVLC;
++} OMX_VIDEO_PARAM_MPEG4TYPE;
++
++
++/**
++ * WMV Versions
++ */
++typedef enum OMX_VIDEO_WMVFORMATTYPE {
++    OMX_VIDEO_WMVFormatUnused = 0x01,   /**< Format unused or unknown */
++    OMX_VIDEO_WMVFormat7      = 0x02,   /**< Windows Media Video format 7 */
++    OMX_VIDEO_WMVFormat8      = 0x04,   /**< Windows Media Video format 8 */
++    OMX_VIDEO_WMVFormat9      = 0x08,   /**< Windows Media Video format 9 */
++    OMX_VIDEO_WMFFormatKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_VIDEO_WMFFormatVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_VIDEO_WMVFormatMax    = 0x7FFFFFFF
++} OMX_VIDEO_WMVFORMATTYPE;
++
++
++/**
++ * WMV Params
++ *
++ * STRUCT MEMBERS:
++ *  nSize      : Size of the structure in bytes
++ *  nVersion   : OMX specification version information
++ *  nPortIndex : Port that this structure applies to
++ *  eFormat    : Version of WMV stream / data
++ */
++typedef struct OMX_VIDEO_PARAM_WMVTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_VIDEO_WMVFORMATTYPE eFormat;
++} OMX_VIDEO_PARAM_WMVTYPE;
++
++
++/**
++ * Real Video Version
++ */
++typedef enum OMX_VIDEO_RVFORMATTYPE {
++    OMX_VIDEO_RVFormatUnused = 0, /**< Format unused or unknown */
++    OMX_VIDEO_RVFormat8,          /**< Real Video format 8 */
++    OMX_VIDEO_RVFormat9,          /**< Real Video format 9 */
++    OMX_VIDEO_RVFormatG2,         /**< Real Video Format G2 */
++    OMX_VIDEO_RVFormatKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_VIDEO_RVFormatVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_VIDEO_RVFormatMax = 0x7FFFFFFF
++} OMX_VIDEO_RVFORMATTYPE;
++
++
++/**
++ * Real Video Params
++ *
++ * STUCT MEMBERS:
++ *  nSize              : Size of the structure in bytes
++ *  nVersion           : OMX specification version information
++ *  nPortIndex         : Port that this structure applies to
++ *  eFormat            : Version of RV stream / data
++ *  nBitsPerPixel      : Bits per pixel coded in the frame
++ *  nPaddedWidth       : Padded width in pixel of a video frame
++ *  nPaddedHeight      : Padded Height in pixels of a video frame
++ *  nFrameRate         : Rate of video in frames per second
++ *  nBitstreamFlags    : Flags which internal information about the bitstream
++ *  nBitstreamVersion  : Bitstream version
++ *  nMaxEncodeFrameSize: Max encoded frame size
++ *  bEnablePostFilter  : Turn on/off post filter
++ *  bEnableTemporalInterpolation : Turn on/off temporal interpolation
++ *  bEnableLatencyMode : When enabled, the decoder does not display a decoded
++ *                       frame until it has detected that no enhancement layer
++ *                       frames or dependent B frames will be coming. This
++ *                       detection usually occurs when a subsequent non-B
++ *                       frame is encountered
++ */
++typedef struct OMX_VIDEO_PARAM_RVTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_VIDEO_RVFORMATTYPE eFormat;
++    OMX_U16 nBitsPerPixel;
++    OMX_U16 nPaddedWidth;
++    OMX_U16 nPaddedHeight;
++    OMX_U32 nFrameRate;
++    OMX_U32 nBitstreamFlags;
++    OMX_U32 nBitstreamVersion;
++    OMX_U32 nMaxEncodeFrameSize;
++    OMX_BOOL bEnablePostFilter;
++    OMX_BOOL bEnableTemporalInterpolation;
++    OMX_BOOL bEnableLatencyMode;
++} OMX_VIDEO_PARAM_RVTYPE;
++
++
++/**
++ * AVC profile types, each profile indicates support for various
++ * performance bounds and different annexes.
++ */
++typedef enum OMX_VIDEO_AVCPROFILETYPE {
++    OMX_VIDEO_AVCProfileBaseline = 0x01,   /**< Baseline profile */
++    OMX_VIDEO_AVCProfileMain     = 0x02,   /**< Main profile */
++    OMX_VIDEO_AVCProfileExtended = 0x04,   /**< Extended profile */
++    OMX_VIDEO_AVCProfileHigh     = 0x08,   /**< High profile */
++    OMX_VIDEO_AVCProfileHigh10   = 0x10,   /**< High 10 profile */
++    OMX_VIDEO_AVCProfileHigh422  = 0x20,   /**< High 4:2:2 profile */
++    OMX_VIDEO_AVCProfileHigh444  = 0x40,   /**< High 4:4:4 profile */
++    OMX_VIDEO_AVCProfileKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_VIDEO_AVCProfileVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_VIDEO_AVCProfileMax      = 0x7FFFFFFF
++} OMX_VIDEO_AVCPROFILETYPE;
++
++
++/**
++ * AVC level types, each level indicates support for various frame sizes,
++ * bit rates, decoder frame rates.  No need
++ */
++typedef enum OMX_VIDEO_AVCLEVELTYPE {
++    OMX_VIDEO_AVCLevel1   = 0x01,     /**< Level 1 */
++    OMX_VIDEO_AVCLevel1b  = 0x02,     /**< Level 1b */
++    OMX_VIDEO_AVCLevel11  = 0x04,     /**< Level 1.1 */
++    OMX_VIDEO_AVCLevel12  = 0x08,     /**< Level 1.2 */
++    OMX_VIDEO_AVCLevel13  = 0x10,     /**< Level 1.3 */
++    OMX_VIDEO_AVCLevel2   = 0x20,     /**< Level 2 */
++    OMX_VIDEO_AVCLevel21  = 0x40,     /**< Level 2.1 */
++    OMX_VIDEO_AVCLevel22  = 0x80,     /**< Level 2.2 */
++    OMX_VIDEO_AVCLevel3   = 0x100,    /**< Level 3 */
++    OMX_VIDEO_AVCLevel31  = 0x200,    /**< Level 3.1 */
++    OMX_VIDEO_AVCLevel32  = 0x400,    /**< Level 3.2 */
++    OMX_VIDEO_AVCLevel4   = 0x800,    /**< Level 4 */
++    OMX_VIDEO_AVCLevel41  = 0x1000,   /**< Level 4.1 */
++    OMX_VIDEO_AVCLevel42  = 0x2000,   /**< Level 4.2 */
++    OMX_VIDEO_AVCLevel5   = 0x4000,   /**< Level 5 */
++    OMX_VIDEO_AVCLevel51  = 0x8000,   /**< Level 5.1 */
++    OMX_VIDEO_AVCLevel52  = 0x10000,  /**< Level 5.2 */
++    OMX_VIDEO_AVCLevelKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_VIDEO_AVCLevelVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_VIDEO_AVCLevelMax = 0x7FFFFFFF
++} OMX_VIDEO_AVCLEVELTYPE;
++
++
++/**
++ * AVC loop filter modes
++ *
++ * OMX_VIDEO_AVCLoopFilterEnable               : Enable
++ * OMX_VIDEO_AVCLoopFilterDisable              : Disable
++ * OMX_VIDEO_AVCLoopFilterDisableSliceBoundary : Disabled on slice boundaries
++ */
++typedef enum OMX_VIDEO_AVCLOOPFILTERTYPE {
++    OMX_VIDEO_AVCLoopFilterEnable = 0,
++    OMX_VIDEO_AVCLoopFilterDisable,
++    OMX_VIDEO_AVCLoopFilterDisableSliceBoundary,
++    OMX_VIDEO_AVCLoopFilterKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_VIDEO_AVCLoopFilterVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_VIDEO_AVCLoopFilterMax = 0x7FFFFFFF
++} OMX_VIDEO_AVCLOOPFILTERTYPE;
++
++
++/**
++ * AVC params
++ *
++ * STRUCT MEMBERS:
++ *  nSize                     : Size of the structure in bytes
++ *  nVersion                  : OMX specification version information
++ *  nPortIndex                : Port that this structure applies to
++ *  nSliceHeaderSpacing       : Number of macroblocks between slice header, put
++ *                              zero if not used
++ *  nPFrames                  : Number of P frames between each I frame
++ *  nBFrames                  : Number of B frames between each I frame
++ *  bUseHadamard              : Enable/disable Hadamard transform
++ *  nRefFrames                : Max number of reference frames to use for inter
++ *                              motion search (1-16)
++ *  nRefIdxTrailing           : Pic param set ref frame index (index into ref
++ *                              frame buffer of trailing frames list), B frame
++ *                              support
++ *  nRefIdxForward            : Pic param set ref frame index (index into ref
++ *                              frame buffer of forward frames list), B frame
++ *                              support
++ *  bEnableUEP                : Enable/disable unequal error protection. This
++ *                              is only valid of data partitioning is enabled.
++ *  bEnableFMO                : Enable/disable flexible macroblock ordering
++ *  bEnableASO                : Enable/disable arbitrary slice ordering
++ *  bEnableRS                 : Enable/disable sending of redundant slices
++ *  eProfile                  : AVC profile(s) to use
++ *  eLevel                    : AVC level(s) to use
++ *  nAllowedPictureTypes      : Specifies the picture types allowed in the
++ *                              bitstream
++ *  bFrameMBsOnly             : specifies that every coded picture of the
++ *                              coded video sequence is a coded frame
++ *                              containing only frame macroblocks
++ *  bMBAFF                    : Enable/disable switching between frame and
++ *                              field macroblocks within a picture
++ *  bEntropyCodingCABAC       : Entropy decoding method to be applied for the
++ *                              syntax elements for which two descriptors appear
++ *                              in the syntax tables
++ *  bWeightedPPrediction      : Enable/disable weighted prediction shall not
++ *                              be applied to P and SP slices
++ *  nWeightedBipredicitonMode : Default weighted prediction is applied to B
++ *                              slices
++ *  bconstIpred               : Enable/disable intra prediction
++ *  bDirect8x8Inference       : Specifies the method used in the derivation
++ *                              process for luma motion vectors for B_Skip,
++ *                              B_Direct_16x16 and B_Direct_8x8 as specified
++ *                              in subclause 8.4.1.2 of the AVC spec
++ *  bDirectSpatialTemporal    : Flag indicating spatial or temporal direct
++ *                              mode used in B slice coding (related to
++ *                              bDirect8x8Inference) . Spatial direct mode is
++ *                              more common and should be the default.
++ *  nCabacInitIdx             : Index used to init CABAC contexts
++ *  eLoopFilterMode           : Enable/disable loop filter
++ */
++typedef struct OMX_VIDEO_PARAM_AVCTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_U32 nSliceHeaderSpacing;
++    OMX_U32 nPFrames;
++    OMX_U32 nBFrames;
++    OMX_BOOL bUseHadamard;
++    OMX_U32 nRefFrames;
++    OMX_U32 nRefIdx10ActiveMinus1;
++    OMX_U32 nRefIdx11ActiveMinus1;
++    OMX_BOOL bEnableUEP;
++    OMX_BOOL bEnableFMO;
++    OMX_BOOL bEnableASO;
++    OMX_BOOL bEnableRS;
++    OMX_VIDEO_AVCPROFILETYPE eProfile;
++    OMX_VIDEO_AVCLEVELTYPE eLevel;
++    OMX_U32 nAllowedPictureTypes;
++    OMX_BOOL bFrameMBsOnly;
++    OMX_BOOL bMBAFF;
++    OMX_BOOL bEntropyCodingCABAC;
++    OMX_BOOL bWeightedPPrediction;
++    OMX_U32 nWeightedBipredicitonMode;
++    OMX_BOOL bconstIpred ;
++    OMX_BOOL bDirect8x8Inference;
++    OMX_BOOL bDirectSpatialTemporal;
++    OMX_U32 nCabacInitIdc;
++    OMX_VIDEO_AVCLOOPFILTERTYPE eLoopFilterMode;
++} OMX_VIDEO_PARAM_AVCTYPE;
++
++typedef struct OMX_VIDEO_PARAM_PROFILELEVELTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_U32 eProfile;      /**< type is OMX_VIDEO_AVCPROFILETYPE, OMX_VIDEO_H263PROFILETYPE,
++                                 or OMX_VIDEO_MPEG4PROFILETYPE depending on context */
++    OMX_U32 eLevel;        /**< type is OMX_VIDEO_AVCLEVELTYPE, OMX_VIDEO_H263LEVELTYPE,
++                                 or OMX_VIDEO_MPEG4PROFILETYPE depending on context */
++    OMX_U32 nProfileIndex; /**< Used to query for individual profile support information,
++                               This parameter is valid only for
++                               OMX_IndexParamVideoProfileLevelQuerySupported index,
++                               For all other indices this parameter is to be ignored. */
++} OMX_VIDEO_PARAM_PROFILELEVELTYPE;
++
++/**
++ * Structure for dynamically configuring bitrate mode of a codec.
++ *
++ * STRUCT MEMBERS:
++ *  nSize          : Size of the struct in bytes
++ *  nVersion       : OMX spec version info
++ *  nPortIndex     : Port that this struct applies to
++ *  nEncodeBitrate : Target average bitrate to be generated in bps
++ */
++typedef struct OMX_VIDEO_CONFIG_BITRATETYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_U32 nEncodeBitrate;
++} OMX_VIDEO_CONFIG_BITRATETYPE;
++
++/**
++ * Defines Encoder Frame Rate setting
++ *
++ * STRUCT MEMBERS:
++ *  nSize            : Size of the structure in bytes
++ *  nVersion         : OMX specification version information
++ *  nPortIndex       : Port that this structure applies to
++ *  xEncodeFramerate : Encoding framerate represented in Q16 format
++ */
++typedef struct OMX_CONFIG_FRAMERATETYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_U32 xEncodeFramerate; /* Q16 format */
++} OMX_CONFIG_FRAMERATETYPE;
++
++typedef struct OMX_CONFIG_INTRAREFRESHVOPTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_BOOL IntraRefreshVOP;
++} OMX_CONFIG_INTRAREFRESHVOPTYPE;
++
++typedef struct OMX_CONFIG_MACROBLOCKERRORMAPTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_U32 nErrMapSize;           /* Size of the Error Map in bytes */
++    OMX_U8  ErrMap[1];             /* Error map hint */
++} OMX_CONFIG_MACROBLOCKERRORMAPTYPE;
++
++typedef struct OMX_CONFIG_MBERRORREPORTINGTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_BOOL bEnabled;
++} OMX_CONFIG_MBERRORREPORTINGTYPE;
++
++typedef struct OMX_PARAM_MACROBLOCKSTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_U32 nMacroblocks;
++} OMX_PARAM_MACROBLOCKSTYPE;
++
++
++#ifdef AVS80
++/**
++ * Aspects of color.
++ */
++
++// NOTE: this structure is expected to grow in the future if new color aspects are
++// added to codec bitstreams. OMX component should not require a specific nSize
++// though could verify that nSize is at least the size of the structure at the
++// time of implementation. All new fields will be added at the end of the structure
++// ensuring backward compatibility.
++
++typedef enum OMX_RANGE {
++    RangeUnspecified,
++    RangeFull,
++    RangeLimited,
++    RangeOther = 0xff,
++} OMX_RANGE;
++
++typedef enum OMX_PRIMARIES {
++    PrimariesUnspecified,
++    PrimariesBT709_5,		// Rec.ITU-R BT.709-5 or equivalent
++    PrimariesBT470_6M,		// Rec.ITU-R BT.470-6 System M or equivalent
++    PrimariesBT601_6_625,	// Rec.ITU-R BT.601-6 625 or equivalent
++    PrimariesBT601_6_525,	// Rec.ITU-R BT.601-6 525 or equivalent
++    PrimariesGenericFilm,	// Generic Film
++    PrimariesBT2020,		// Rec.ITU-R BT.2020 or equivalent
++    PrimariesOther = 0xff,
++} OMX_PRIMARIES;
++
++typedef enum OMX_TRANSFER {
++    TransferUnspecified,
++    TransferLinear, 		// Linear transfer characteristics
++    TransferSRGB,			// sRGB or equivalent
++    TransferSMPTE170M,		// SMPTE 170M or equivalent (e.g. BT.601/709/2020)
++    TransferGamma22,		// Assumed display gamma 2.2
++    TransferGamma28,		// Assumed display gamma 2.8
++    TransferST2084, 		// SMPTE ST 2084 for 10/12/14/16 bit systems
++    TransferHLG,			// ARIB STD-B67 hybrid-log-gamma
++    // transfers unlikely to be required by Android
++    TransferSMPTE240M = 0x40, // SMPTE 240M
++    TransferXvYCC,			// IEC 61966-2-4
++    TransferBT1361, 		// Rec.ITU-R BT.1361 extended gamut
++    TransferST428,			// SMPTE ST 428-1
++    TransferOther = 0xff,
++} OMX_TRANSFER;
++
++typedef enum OMX_MATRIXCOEFFS {
++    MatrixUnspecified,
++    MatrixBT709_5,			// Rec.ITU-R BT.709-5 or equivalent
++    MatrixBT470_6M, 		// KR=0.30, KB=0.11 or equivalent
++    MatrixBT601_6,			// Rec.ITU-R BT.601-6 625 or equivalent
++    MatrixSMPTE240M,		// SMPTE 240M or equivalent
++    MatrixBT2020,			// Rec.ITU-R BT.2020 non-constant luminance
++    MatrixBT2020Constant,	// Rec.ITU-R BT.2020 constant luminance
++    MatrixOther = 0xff,
++} OMX_MATRIXCOEFFS;
++
++typedef struct OMX_COLORASPECTS {
++    OMX_RANGE mRange;                // IN/OUT
++    OMX_PRIMARIES mPrimaries;        // IN/OUT
++    OMX_TRANSFER mTransfer;          // IN/OUT
++    OMX_MATRIXCOEFFS mMatrixCoeffs;  // IN/OUT
++} OMX_COLORASPECTS;
++
++typedef struct OMX_CONFIG_DESCRIBECOLORASPECTSPARAMS {
++    OMX_U32  nSize;                // IN
++    OMX_VERSIONTYPE nVersion;      // IN
++    OMX_U32  nPortIndex;           // IN
++    OMX_BOOL bRequestingDataSpace; // IN
++    OMX_BOOL bDataSpaceChanged;    // IN
++    OMX_U32  nPixelFormat;         // IN
++    OMX_U32  nDataSpace;           // OUT
++    OMX_COLORASPECTS sAspects;  // IN/OUT
++} OMX_CONFIG_DESCRIBECOLORASPECTSPARAMS;
++#endif
++
++/**
++ * AVC Slice Mode modes
++ *
++ * OMX_VIDEO_SLICEMODE_AVCDefault   : Normal frame encoding, one slice per frame
++ * OMX_VIDEO_SLICEMODE_AVCMBSlice   : NAL mode, number of MBs per frame
++ * OMX_VIDEO_SLICEMODE_AVCByteSlice : NAL mode, number of bytes per frame
++ */
++typedef enum OMX_VIDEO_AVCSLICEMODETYPE {
++    OMX_VIDEO_SLICEMODE_AVCDefault = 0,
++    OMX_VIDEO_SLICEMODE_AVCMBSlice,
++    OMX_VIDEO_SLICEMODE_AVCByteSlice,
++    OMX_VIDEO_SLICEMODE_AVCKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */
++    OMX_VIDEO_SLICEMODE_AVCVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
++    OMX_VIDEO_SLICEMODE_AVCLevelMax = 0x7FFFFFFF
++} OMX_VIDEO_AVCSLICEMODETYPE;
++
++/**
++ * AVC FMO Slice Mode Params
++ *
++ * STRUCT MEMBERS:
++ *  nSize      : Size of the structure in bytes
++ *  nVersion   : OMX specification version information
++ *  nPortIndex : Port that this structure applies to
++ *  nNumSliceGroups : Specifies the number of slice groups
++ *  nSliceGroupMapType : Specifies the type of slice groups
++ *  eSliceMode : Specifies the type of slice
++ */
++typedef struct OMX_VIDEO_PARAM_AVCSLICEFMO {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_U8 nNumSliceGroups;
++    OMX_U8 nSliceGroupMapType;
++    OMX_VIDEO_AVCSLICEMODETYPE eSliceMode;
++} OMX_VIDEO_PARAM_AVCSLICEFMO;
++
++/**
++ * AVC IDR Period Configs
++ *
++ * STRUCT MEMBERS:
++ *  nSize      : Size of the structure in bytes
++ *  nVersion   : OMX specification version information
++ *  nPortIndex : Port that this structure applies to
++ *  nIDRPeriod : Specifies periodicity of IDR frames
++ *  nPFrames : Specifies internal of coding Intra frames
++ */
++typedef struct OMX_VIDEO_CONFIG_AVCINTRAPERIOD {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_U32 nIDRPeriod;
++    OMX_U32 nPFrames;
++} OMX_VIDEO_CONFIG_AVCINTRAPERIOD;
++
++/**
++ * AVC NAL Size Configs
++ *
++ * STRUCT MEMBERS:
++ *  nSize      : Size of the structure in bytes
++ *  nVersion   : OMX specification version information
++ *  nPortIndex : Port that this structure applies to
++ *  nNaluBytes : Specifies the NAL unit size
++ */
++typedef struct OMX_VIDEO_CONFIG_NALSIZE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_U32 nNaluBytes;
++} OMX_VIDEO_CONFIG_NALSIZE;
++
++/** @} */
++
++#ifdef __cplusplus
++}
++#endif /* __cplusplus */
++
++#endif
++/* File EOF */
++
+diff --git a/sf-extra/omx-il/OMX_VideoExt.h b/sf-extra/omx-il/OMX_VideoExt.h
+new file mode 100644
+index 00000000..2c024317
+--- /dev/null
++++ b/sf-extra/omx-il/OMX_VideoExt.h
+@@ -0,0 +1,401 @@
++/*
++ * Copyright (c) 2010 The Khronos Group Inc.
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining
++ * a copy of this software and associated documentation files (the
++ * "Software"), to deal in the Software without restriction, including
++ * without limitation the rights to use, copy, modify, merge, publish,
++ * distribute, sublicense, and/or sell copies of the Software, and to
++ * permit persons to whom the Software is furnished to do so, subject
++ * to the following conditions:
++ * The above copyright notice and this permission notice shall be included
++ * in all copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
++ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
++ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
++ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
++ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
++ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
++ *
++ */
++
++/** OMX_VideoExt.h - OpenMax IL version 1.1.2
++ * The OMX_VideoExt header file contains extensions to the
++ * definitions used by both the application and the component to
++ * access video items.
++ */
++
++#ifndef OMX_VideoExt_h
++#define OMX_VideoExt_h
++
++#ifdef __cplusplus
++extern "C" {
++#endif /* __cplusplus */
++
++/* Each OMX header shall include all required header files to allow the
++ * header to compile without errors.  The includes below are required
++ * for this header file to compile successfully
++ */
++#include <OMX_Core.h>
++
++/** NALU Formats */
++typedef enum OMX_NALUFORMATSTYPE {
++    OMX_NaluFormatStartCodes = 1,
++    OMX_NaluFormatOneNaluPerBuffer = 2,
++    OMX_NaluFormatOneByteInterleaveLength = 4,
++    OMX_NaluFormatTwoByteInterleaveLength = 8,
++    OMX_NaluFormatFourByteInterleaveLength = 16,
++    OMX_NaluFormatCodingMax = 0x7FFFFFFF
++} OMX_NALUFORMATSTYPE;
++
++/** NAL Stream Format */
++typedef struct OMX_NALSTREAMFORMATTYPE{
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_NALUFORMATSTYPE eNaluFormat;
++} OMX_NALSTREAMFORMATTYPE;
++
++/** VP8 profiles */
++typedef enum OMX_VIDEO_VP8PROFILETYPE {
++    OMX_VIDEO_VP8ProfileMain = 0x01,
++    OMX_VIDEO_VP8ProfileUnknown = 0x6EFFFFFF,
++    OMX_VIDEO_VP8ProfileMax = 0x7FFFFFFF
++} OMX_VIDEO_VP8PROFILETYPE;
++
++/** VP8 levels */
++typedef enum OMX_VIDEO_VP8LEVELTYPE {
++    OMX_VIDEO_VP8Level_Version0 = 0x01,
++    OMX_VIDEO_VP8Level_Version1 = 0x02,
++    OMX_VIDEO_VP8Level_Version2 = 0x04,
++    OMX_VIDEO_VP8Level_Version3 = 0x08,
++    OMX_VIDEO_VP8LevelUnknown = 0x6EFFFFFF,
++    OMX_VIDEO_VP8LevelMax = 0x7FFFFFFF
++} OMX_VIDEO_VP8LEVELTYPE;
++
++/** VP9 profiles */
++typedef enum OMX_VIDEO_VP9PROFILETYPE {
++    OMX_VIDEO_VP9Profile0       = 0x1,
++    OMX_VIDEO_VP9Profile1       = 0x2,
++    OMX_VIDEO_VP9Profile2       = 0x4,
++    OMX_VIDEO_VP9Profile3       = 0x8,
++    // HDR profiles also support passing HDR metadata
++    OMX_VIDEO_VP9Profile2HDR    = 0x1000,
++    OMX_VIDEO_VP9Profile3HDR    = 0x2000,
++    OMX_VIDEO_VP9ProfileUnknown = 0x6EFFFFFF,
++    OMX_VIDEO_VP9ProfileMax     = 0x7FFFFFFF
++} OMX_VIDEO_VP9PROFILETYPE;
++
++/** VP9 levels */
++typedef enum OMX_VIDEO_VP9LEVELTYPE {
++    OMX_VIDEO_VP9Level1       = 0x1,
++    OMX_VIDEO_VP9Level11      = 0x2,
++    OMX_VIDEO_VP9Level2       = 0x4,
++    OMX_VIDEO_VP9Level21      = 0x8,
++    OMX_VIDEO_VP9Level3       = 0x10,
++    OMX_VIDEO_VP9Level31      = 0x20,
++    OMX_VIDEO_VP9Level4       = 0x40,
++    OMX_VIDEO_VP9Level41      = 0x80,
++    OMX_VIDEO_VP9Level5       = 0x100,
++    OMX_VIDEO_VP9Level51      = 0x200,
++    OMX_VIDEO_VP9Level52      = 0x400,
++    OMX_VIDEO_VP9Level6       = 0x800,
++    OMX_VIDEO_VP9Level61      = 0x1000,
++    OMX_VIDEO_VP9Level62      = 0x2000,
++    OMX_VIDEO_VP9LevelUnknown = 0x6EFFFFFF,
++    OMX_VIDEO_VP9LevelMax     = 0x7FFFFFFF
++} OMX_VIDEO_VP9LEVELTYPE;
++
++/** VP8 Param */
++typedef struct OMX_VIDEO_PARAM_VP8TYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_VIDEO_VP8PROFILETYPE eProfile;
++    OMX_VIDEO_VP8LEVELTYPE eLevel;
++    OMX_U32 nDCTPartitions;
++    OMX_BOOL bErrorResilientMode;
++} OMX_VIDEO_PARAM_VP8TYPE;
++
++/** Structure for configuring VP8 reference frames */
++typedef struct OMX_VIDEO_VP8REFERENCEFRAMETYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_BOOL bPreviousFrameRefresh;
++    OMX_BOOL bGoldenFrameRefresh;
++    OMX_BOOL bAlternateFrameRefresh;
++    OMX_BOOL bUsePreviousFrame;
++    OMX_BOOL bUseGoldenFrame;
++    OMX_BOOL bUseAlternateFrame;
++} OMX_VIDEO_VP8REFERENCEFRAMETYPE;
++
++/** Structure for querying VP8 reference frame type */
++typedef struct OMX_VIDEO_VP8REFERENCEFRAMEINFOTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_BOOL bIsIntraFrame;
++    OMX_BOOL bIsGoldenOrAlternateFrame;
++} OMX_VIDEO_VP8REFERENCEFRAMEINFOTYPE;
++
++/** Maximum number of VP8 temporal layers */
++#define OMX_VIDEO_ANDROID_MAXVP8TEMPORALLAYERS 3
++
++/** VP8 temporal layer patterns */
++typedef enum OMX_VIDEO_ANDROID_VPXTEMPORALLAYERPATTERNTYPE {
++    OMX_VIDEO_VPXTemporalLayerPatternNone = 0,
++    OMX_VIDEO_VPXTemporalLayerPatternWebRTC = 1,
++    OMX_VIDEO_VPXTemporalLayerPatternMax = 0x7FFFFFFF
++} OMX_VIDEO_ANDROID_VPXTEMPORALLAYERPATTERNTYPE;
++
++/**
++ * Android specific VP8 encoder params
++ *
++ * STRUCT MEMBERS:
++ *  nSize                      : Size of the structure in bytes
++ *  nVersion                   : OMX specification version information
++ *  nPortIndex                 : Port that this structure applies to
++ *  nKeyFrameInterval          : Key frame interval in frames
++ *  eTemporalPattern           : Type of temporal layer pattern
++ *  nTemporalLayerCount        : Number of temporal coding layers
++ *  nTemporalLayerBitrateRatio : Bitrate ratio allocation between temporal
++ *                               streams in percentage
++ *  nMinQuantizer              : Minimum (best quality) quantizer
++ *  nMaxQuantizer              : Maximum (worst quality) quantizer
++ */
++typedef struct OMX_VIDEO_PARAM_ANDROID_VP8ENCODERTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_U32 nKeyFrameInterval;        // distance between consecutive key_frames (including one
++                                      // of the key_frames). 0 means interval is unspecified and
++                                      // can be freely chosen by the codec. 1 means a stream of
++                                      // only key_frames.
++
++    OMX_VIDEO_ANDROID_VPXTEMPORALLAYERPATTERNTYPE eTemporalPattern;
++    OMX_U32 nTemporalLayerCount;
++    OMX_U32 nTemporalLayerBitrateRatio[OMX_VIDEO_ANDROID_MAXVP8TEMPORALLAYERS];
++    OMX_U32 nMinQuantizer;
++    OMX_U32 nMaxQuantizer;
++} OMX_VIDEO_PARAM_ANDROID_VP8ENCODERTYPE;
++
++/** HEVC Profile enum type */
++typedef enum OMX_VIDEO_HEVCPROFILETYPE {
++    OMX_VIDEO_HEVCProfileUnknown      = 0x0,
++    OMX_VIDEO_HEVCProfileMain         = 0x1,
++    OMX_VIDEO_HEVCProfileMain10       = 0x2,
++    // Main10 profile with HDR SEI support.
++    OMX_VIDEO_HEVCProfileMain10HDR10  = 0x1000,
++    OMX_VIDEO_HEVCProfileMax          = 0x7FFFFFFF
++} OMX_VIDEO_HEVCPROFILETYPE;
++
++/** HEVC Level enum type */
++typedef enum OMX_VIDEO_HEVCLEVELTYPE {
++    OMX_VIDEO_HEVCLevelUnknown    = 0x0,
++    OMX_VIDEO_HEVCMainTierLevel1  = 0x1,
++    OMX_VIDEO_HEVCHighTierLevel1  = 0x2,
++    OMX_VIDEO_HEVCMainTierLevel2  = 0x4,
++    OMX_VIDEO_HEVCHighTierLevel2  = 0x8,
++    OMX_VIDEO_HEVCMainTierLevel21 = 0x10,
++    OMX_VIDEO_HEVCHighTierLevel21 = 0x20,
++    OMX_VIDEO_HEVCMainTierLevel3  = 0x40,
++    OMX_VIDEO_HEVCHighTierLevel3  = 0x80,
++    OMX_VIDEO_HEVCMainTierLevel31 = 0x100,
++    OMX_VIDEO_HEVCHighTierLevel31 = 0x200,
++    OMX_VIDEO_HEVCMainTierLevel4  = 0x400,
++    OMX_VIDEO_HEVCHighTierLevel4  = 0x800,
++    OMX_VIDEO_HEVCMainTierLevel41 = 0x1000,
++    OMX_VIDEO_HEVCHighTierLevel41 = 0x2000,
++    OMX_VIDEO_HEVCMainTierLevel5  = 0x4000,
++    OMX_VIDEO_HEVCHighTierLevel5  = 0x8000,
++    OMX_VIDEO_HEVCMainTierLevel51 = 0x10000,
++    OMX_VIDEO_HEVCHighTierLevel51 = 0x20000,
++    OMX_VIDEO_HEVCMainTierLevel52 = 0x40000,
++    OMX_VIDEO_HEVCHighTierLevel52 = 0x80000,
++    OMX_VIDEO_HEVCMainTierLevel6  = 0x100000,
++    OMX_VIDEO_HEVCHighTierLevel6  = 0x200000,
++    OMX_VIDEO_HEVCMainTierLevel61 = 0x400000,
++    OMX_VIDEO_HEVCHighTierLevel61 = 0x800000,
++    OMX_VIDEO_HEVCMainTierLevel62 = 0x1000000,
++    OMX_VIDEO_HEVCHighTierLevel62 = 0x2000000,
++    OMX_VIDEO_HEVCHighTiermax     = 0x7FFFFFFF
++} OMX_VIDEO_HEVCLEVELTYPE;
++
++/** Structure for controlling HEVC video encoding */
++typedef struct OMX_VIDEO_PARAM_HEVCTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_VIDEO_HEVCPROFILETYPE eProfile;
++    OMX_VIDEO_HEVCLEVELTYPE eLevel;
++    OMX_U32 nKeyFrameInterval;        // distance between consecutive I-frames (including one
++                                      // of the I frames). 0 means interval is unspecified and
++                                      // can be freely chosen by the codec. 1 means a stream of
++                                      // only I frames.
++} OMX_VIDEO_PARAM_HEVCTYPE;
++
++/** Structure to define if dependent slice segments should be used */
++typedef struct OMX_VIDEO_SLICESEGMENTSTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_BOOL bDepedentSegments;
++    OMX_BOOL bEnableLoopFilterAcrossSlices;
++} OMX_VIDEO_SLICESEGMENTSTYPE;
++
++/** Structure to return timestamps of rendered output frames as well as EOS
++ *  for tunneled components.
++ */
++typedef struct OMX_VIDEO_RENDEREVENTTYPE {
++    OMX_S64 nMediaTimeUs;  // timestamp of rendered video frame
++    OMX_S64 nSystemTimeNs; // system monotonic time at the time frame was rendered
++                           // Use INT64_MAX for nMediaTimeUs to signal that the EOS
++                           // has been reached. In this case, nSystemTimeNs MUST be
++                           // the system time when the last frame was rendered.
++                           // This MUST be done in addition to returning (and
++                           // following) the render information for the last frame.
++} OMX_VIDEO_RENDEREVENTTYPE;
++
++/** Dolby Vision Profile enum type */
++typedef enum OMX_VIDEO_DOLBYVISIONPROFILETYPE {
++    OMX_VIDEO_DolbyVisionProfileUnknown = 0x0,
++    OMX_VIDEO_DolbyVisionProfileDvavPer = 0x1,
++    OMX_VIDEO_DolbyVisionProfileDvavPen = 0x2,
++    OMX_VIDEO_DolbyVisionProfileDvheDer = 0x4,
++    OMX_VIDEO_DolbyVisionProfileDvheDen = 0x8,
++    OMX_VIDEO_DolbyVisionProfileDvheDtr = 0x10,
++    OMX_VIDEO_DolbyVisionProfileDvheStn = 0x20,
++    OMX_VIDEO_DolbyVisionProfileDvheDth = 0x40,
++    OMX_VIDEO_DolbyVisionProfileDvheDtb = 0x80,
++    OMX_VIDEO_DolbyVisionProfileMax     = 0x7FFFFFFF
++} OMX_VIDEO_DOLBYVISIONPROFILETYPE;
++
++/** Dolby Vision Level enum type */
++typedef enum OMX_VIDEO_DOLBYVISIONLEVELTYPE {
++    OMX_VIDEO_DolbyVisionLevelUnknown = 0x0,
++    OMX_VIDEO_DolbyVisionLevelHd24    = 0x1,
++    OMX_VIDEO_DolbyVisionLevelHd30    = 0x2,
++    OMX_VIDEO_DolbyVisionLevelFhd24   = 0x4,
++    OMX_VIDEO_DolbyVisionLevelFhd30   = 0x8,
++    OMX_VIDEO_DolbyVisionLevelFhd60   = 0x10,
++    OMX_VIDEO_DolbyVisionLevelUhd24   = 0x20,
++    OMX_VIDEO_DolbyVisionLevelUhd30   = 0x40,
++    OMX_VIDEO_DolbyVisionLevelUhd48   = 0x80,
++    OMX_VIDEO_DolbyVisionLevelUhd60   = 0x100,
++    OMX_VIDEO_DolbyVisionLevelmax     = 0x7FFFFFFF
++} OMX_VIDEO_DOLBYVISIONLEVELTYPE;
++
++/**
++ * Structure for configuring video compression intra refresh period
++ *
++ * STRUCT MEMBERS:
++ *  nSize               : Size of the structure in bytes
++ *  nVersion            : OMX specification version information
++ *  nPortIndex          : Port that this structure applies to
++ *  nRefreshPeriod      : Intra refreh period in frames. Value 0 means disable intra refresh
++ */
++typedef struct OMX_VIDEO_CONFIG_ANDROID_INTRAREFRESHTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_U32 nRefreshPeriod;
++} OMX_VIDEO_CONFIG_ANDROID_INTRAREFRESHTYPE;
++
++/** Maximum number of temporal layers supported by AVC/HEVC */
++#define OMX_VIDEO_ANDROID_MAXTEMPORALLAYERS 8
++
++/** temporal layer patterns */
++typedef enum OMX_VIDEO_ANDROID_TEMPORALLAYERINGPATTERNTYPE {
++    OMX_VIDEO_AndroidTemporalLayeringPatternNone = 0,
++    // pattern as defined by WebRTC
++    OMX_VIDEO_AndroidTemporalLayeringPatternWebRTC = 1 << 0,
++    // pattern where frames in any layer other than the base layer only depend on at most the very
++    // last frame from each preceding layer (other than the base layer.)
++    OMX_VIDEO_AndroidTemporalLayeringPatternAndroid = 1 << 1,
++} OMX_VIDEO_ANDROID_TEMPORALLAYERINGPATTERNTYPE;
++
++/**
++ * Android specific param for configuration of temporal layering.
++ * Android only supports temporal layering where successive layers each double the
++ * previous layer's framerate.
++ * NOTE: Reading this parameter at run-time SHALL return actual run-time values.
++ *
++ *  nSize                      : Size of the structure in bytes
++ *  nVersion                   : OMX specification version information
++ *  nPortIndex                 : Port that this structure applies to (output port for encoders)
++ *  eSupportedPatterns         : A bitmask of supported layering patterns
++ *  nLayerCountMax             : Max number of temporal coding layers supported
++ *                               by the encoder (must be at least 1, 1 meaning temporal layering
++ *                               is NOT supported)
++ *  nBLayerCountMax            : Max number of layers that can contain B frames
++ *                               (0) to (nLayerCountMax - 1)
++ *  ePattern                   : Layering pattern.
++ *  nPLayerCountActual         : Number of temporal layers to be coded with non-B frames,
++ *                               starting from and including the base-layer.
++ *                               (1 to nLayerCountMax - nBLayerCountActual)
++ *                               If nPLayerCountActual is 1 and nBLayerCountActual is 0, temporal
++ *                               layering is disabled. Otherwise, it is enabled.
++ *  nBLayerCountActual         : Number of temporal layers to be coded with B frames,
++ *                               starting after non-B layers.
++ *                               (0 to nBLayerCountMax)
++ *  bBitrateRatiosSpecified    : Flag to indicate if layer-wise bitrate
++ *                               distribution is specified.
++ *  nBitrateRatios             : Bitrate ratio (100 based) per layer (index 0 is base layer).
++ *                               Honored if bBitrateRatiosSpecified is set.
++ *                               i.e for 4 layers with desired distribution (25% 25% 25% 25%),
++ *                               nBitrateRatio = {25, 50, 75, 100, ... }
++ *                               Values in indices not less than 'the actual number of layers
++ *                               minus 1' MAY be ignored and assumed to be 100.
++ */
++typedef struct OMX_VIDEO_PARAM_ANDROID_TEMPORALLAYERINGTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_VIDEO_ANDROID_TEMPORALLAYERINGPATTERNTYPE eSupportedPatterns;
++    OMX_U32 nLayerCountMax;
++    OMX_U32 nBLayerCountMax;
++    OMX_VIDEO_ANDROID_TEMPORALLAYERINGPATTERNTYPE ePattern;
++    OMX_U32 nPLayerCountActual;
++    OMX_U32 nBLayerCountActual;
++    OMX_BOOL bBitrateRatiosSpecified;
++    OMX_U32 nBitrateRatios[OMX_VIDEO_ANDROID_MAXTEMPORALLAYERS];
++} OMX_VIDEO_PARAM_ANDROID_TEMPORALLAYERINGTYPE;
++
++/**
++ * Android specific config for changing the temporal-layer count or
++ * bitrate-distribution at run-time.
++ *
++ *  nSize                      : Size of the structure in bytes
++ *  nVersion                   : OMX specification version information
++ *  nPortIndex                 : Port that this structure applies to (output port for encoders)
++ *  ePattern                   : Layering pattern.
++ *  nPLayerCountActual         : Number of temporal layers to be coded with non-B frames.
++ *                               (same OMX_VIDEO_PARAM_ANDROID_TEMPORALLAYERINGTYPE limits apply.)
++ *  nBLayerCountActual         : Number of temporal layers to be coded with B frames.
++ *                               (same OMX_VIDEO_PARAM_ANDROID_TEMPORALLAYERINGTYPE limits apply.)
++ *  bBitrateRatiosSpecified    : Flag to indicate if layer-wise bitrate
++ *                               distribution is specified.
++ *  nBitrateRatios             : Bitrate ratio (100 based, Q16 values) per layer (0 is base layer).
++ *                               Honored if bBitrateRatiosSpecified is set.
++ *                               (same OMX_VIDEO_PARAM_ANDROID_TEMPORALLAYERINGTYPE limits apply.)
++ */
++typedef struct OMX_VIDEO_CONFIG_ANDROID_TEMPORALLAYERINGTYPE {
++    OMX_U32 nSize;
++    OMX_VERSIONTYPE nVersion;
++    OMX_U32 nPortIndex;
++    OMX_VIDEO_ANDROID_TEMPORALLAYERINGPATTERNTYPE ePattern;
++    OMX_U32 nPLayerCountActual;
++    OMX_U32 nBLayerCountActual;
++    OMX_BOOL bBitrateRatiosSpecified;
++    OMX_U32 nBitrateRatios[OMX_VIDEO_ANDROID_MAXTEMPORALLAYERS];
++} OMX_VIDEO_CONFIG_ANDROID_TEMPORALLAYERINGTYPE;
++
++#ifdef __cplusplus
++}
++#endif /* __cplusplus */
++
++#endif /* OMX_VideoExt_h */
++/* File EOF */
+-- 
+2.30.2
+

+ 34 - 0
recipes-multimedia/ffmpeg/ffmpeg/0001-hwcontext_vulkan-remove-optional-encode-decode-exten.patch

@@ -0,0 +1,34 @@
+From: Lynne <dev@lynne.ee>
+Date: Sun, 25 Dec 2022 01:03:30 +0100
+Subject: hwcontext_vulkan: remove optional encode/decode extensions from the
+ list
+
+They're not currently used, so they don't need to be there.
+Vulkan stabilized the decode extensions less than a week ago, and their
+name prefixes were changed from EXT to KHR. It's a bit too soon to be
+depending on it, so rather than bumping, just remove these for now.
+
+(cherry picked from commit eb0455d64690eed0068e5cb202f72ecdf899837c)
+---
+ libavutil/hwcontext_vulkan.c | 8 --------
+ 1 file changed, 8 deletions(-)
+
+diff --git a/libavutil/hwcontext_vulkan.c b/libavutil/hwcontext_vulkan.c
+index 237caa4..3bc0dc8 100644
+--- a/libavutil/hwcontext_vulkan.c
++++ b/libavutil/hwcontext_vulkan.c
+@@ -354,14 +354,6 @@ static const VulkanOptExtension optional_device_exts[] = {
+     { VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME,            FF_VK_EXT_EXTERNAL_WIN32_MEMORY  },
+     { VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME,         FF_VK_EXT_EXTERNAL_WIN32_SEM     },
+ #endif
+-
+-    /* Video encoding/decoding */
+-    { VK_KHR_VIDEO_QUEUE_EXTENSION_NAME,                      FF_VK_EXT_NO_FLAG                },
+-    { VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME,               FF_VK_EXT_NO_FLAG                },
+-    { VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME,               FF_VK_EXT_NO_FLAG                },
+-    { VK_EXT_VIDEO_ENCODE_H264_EXTENSION_NAME,                FF_VK_EXT_NO_FLAG                },
+-    { VK_EXT_VIDEO_DECODE_H264_EXTENSION_NAME,                FF_VK_EXT_NO_FLAG                },
+-    { VK_EXT_VIDEO_DECODE_H265_EXTENSION_NAME,                FF_VK_EXT_NO_FLAG                },
+ };
+ 
+ /* Converts return values to strings */

+ 43 - 0
recipes-multimedia/ffmpeg/ffmpeg/0001-swscale-x86-yuv2rgb-Fix-build-without-SSSE3.patch

@@ -0,0 +1,43 @@
+From bf8eae2d30a205bb76ac625e04c0351106981b9e Mon Sep 17 00:00:00 2001
+From: Parker Ernest <@>
+Date: Sun, 23 Feb 2020 13:22:42 +0100
+Subject: [PATCH] swscale/x86/yuv2rgb: Fix build without SSSE3
+
+commit fc6a5883d6af8cae0e96af84dda0ad74b360a084 breaks build on
+x86_64 CPUs which do not have SSSE3, e.g. AMD Phenom-II
+
+Signed-off-by: Michael Niedermayer <michael@niedermayer.cc>
+[bernd.kuhls@t-online.de:
+  - retrieved from upstream patchwork:
+    https://patchwork.ffmpeg.org/project/ffmpeg/patch/20200223122256.23402-1-michael@niedermayer.cc/
+]
+Signed-off-by: Bernd Kuhls <bernd.kuhls@t-online.de>
+[yann.morin.1998@free.fr: fix reference top patchwork and SoB order]
+Signed-off-by: Yann E. MORIN <yann.morin.1998@free.fr>
+---
+ libswscale/x86/yuv2rgb.c | 2 ++
+ 1 file changed, 2 insertions(+)
+
+diff --git a/libswscale/x86/yuv2rgb.c b/libswscale/x86/yuv2rgb.c
+index c12e88cbb5..4791e5b93a 100644
+--- a/libswscale/x86/yuv2rgb.c
++++ b/libswscale/x86/yuv2rgb.c
+@@ -83,6 +83,7 @@ av_cold SwsFunc ff_yuv2rgb_init_x86(SwsContext *c)
+ #if HAVE_X86ASM
+     int cpu_flags = av_get_cpu_flags();
+ 
++#if HAVE_SSSE3
+     if (EXTERNAL_SSSE3(cpu_flags)) {
+         switch (c->dstFormat) {
+         case AV_PIX_FMT_RGB32:
+@@ -111,6 +112,7 @@ av_cold SwsFunc ff_yuv2rgb_init_x86(SwsContext *c)
+             return yuv420_rgb15_ssse3;
+         }
+     }
++#endif
+ 
+     if (EXTERNAL_MMXEXT(cpu_flags)) {
+         switch (c->dstFormat) {
+-- 
+2.26.2
+

+ 36 - 0
recipes-multimedia/ffmpeg/ffmpeg/0002-avcodec-vaapi_h264-skip-decode-if-pic-has-no-slices.patch

@@ -0,0 +1,36 @@
+From 2c6b3f357331e203ad87214984661c40704aceb7 Mon Sep 17 00:00:00 2001
+From: Rainer Hochecker <fernetmenta@online.de>
+Date: Sat, 26 Jan 2019 19:48:35 +0100
+Subject: [PATCH] avcodec/vaapi_h264: skip decode if pic has no slices
+
+This fixes / workarounds https://bugs.freedesktop.org/show_bug.cgi?id=105368.
+It was hit frequently when watching h264 channels received via DVB-X.
+Corresponding kodi bug: https://github.com/xbmc/xbmc/issues/15704
+
+Downloaded from Kodi ffmpeg repo:
+https://github.com/xbmc/FFmpeg/commit/2c6b3f357331e203ad87214984661c40704aceb7
+
+Patch was sent upstream:
+http://ffmpeg.org/pipermail/ffmpeg-devel/2019-March/240863.html
+
+Signed-off-by: Bernd Kuhls <bernd.kuhls@t-online.de>
+---
+ libavcodec/vaapi_h264.c | 5 +++++
+ 1 file changed, 5 insertions(+)
+
+diff --git a/libavcodec/vaapi_h264.c b/libavcodec/vaapi_h264.c
+index dd2a6571604..e521a05c4ff 100644
+--- a/libavcodec/vaapi_h264.c
++++ b/libavcodec/vaapi_h264.c
+@@ -314,6 +314,11 @@ static int vaapi_h264_end_frame(AVCodecContext *avctx)
+     H264SliceContext *sl = &h->slice_ctx[0];
+     int ret;
+ 
++    if (pic->nb_slices == 0) {
++        ret = AVERROR_INVALIDDATA;
++        goto finish;
++    }
++
+     ret = ff_vaapi_decode_issue(avctx, pic);
+     if (ret < 0)
+         goto finish;

+ 72 - 0
recipes-multimedia/ffmpeg/ffmpeg/0003-libavutil-Fix-mips-build.patch

@@ -0,0 +1,72 @@
+From 6e8daf0d502a2a822f1f08f42368d7d676dc1a9e Mon Sep 17 00:00:00 2001
+From: Bernd Kuhls <bernd.kuhls@t-online.de>
+Date: Sun, 6 Jun 2021 08:54:53 +0200
+Subject: [PATCH] libavutil: Fix mips build
+
+Check for sys/auxv.h because not all toolchains contain this header.
+
+Fixes https://trac.ffmpeg.org/ticket/9138
+
+Patch sent upstream:
+http://ffmpeg.org/pipermail/ffmpeg-devel/2021-June/281272.html
+
+Signed-off-by: Bernd Kuhls <bernd.kuhls@t-online.de>
+---
+ configure            | 2 ++
+ libavutil/mips/cpu.c | 6 +++---
+ 2 files changed, 5 insertions(+), 3 deletions(-)
+
+diff --git a/configure b/configure
+index 6bfd98b384..773a7d516c 100755
+--- a/configure
++++ b/configure
+@@ -2161,6 +2161,7 @@ HEADERS_LIST="
+     opencv2_core_core_c_h
+     OpenGL_gl3_h
+     poll_h
++    sys_auxv_h
+     sys_param_h
+     sys_resource_h
+     sys_select_h
+@@ -6218,6 +6219,7 @@ check_func_headers VideoToolbox/VTCompressionSession.h VTCompressionSessionPrepa
+ check_headers windows.h
+ check_headers X11/extensions/XvMClib.h
+ check_headers asm/types.h
++check_headers sys/auxv.h
+ 
+ # it seems there are versions of clang in some distros that try to use the
+ # gcc headers, which explodes for stdatomic
+diff --git a/libavutil/mips/cpu.c b/libavutil/mips/cpu.c
+index 59619d54de..19196de50b 100644
+--- a/libavutil/mips/cpu.c
++++ b/libavutil/mips/cpu.c
+@@ -19,7 +19,7 @@
+ #include "libavutil/cpu.h"
+ #include "libavutil/cpu_internal.h"
+ #include "config.h"
+-#if defined __linux__ || defined __ANDROID__
++#if (defined __linux__ || defined __ANDROID__) && HAVE_SYS_AUXV_H
+ #include <stdint.h>
+ #include <stdio.h>
+ #include <string.h>
+@@ -28,7 +28,7 @@
+ #include "libavutil/avstring.h"
+ #endif
+ 
+-#if defined __linux__ || defined __ANDROID__
++#if (defined __linux__ || defined __ANDROID__) && HAVE_SYS_AUXV_H
+ 
+ #define HWCAP_LOONGSON_CPUCFG (1 << 14)
+ 
+@@ -105,7 +105,7 @@ static int cpu_flags_cpuinfo(void)
+ 
+ int ff_get_cpu_flags_mips(void)
+ {
+-#if defined __linux__ || defined __ANDROID__
++#if (defined __linux__ || defined __ANDROID__) && HAVE_SYS_AUXV_H
+     if (cpucfg_available())
+         return cpu_flags_cpucfg();
+     else
+-- 
+2.29.2
+

+ 47 - 0
recipes-multimedia/ffmpeg/ffmpeg/0004-configure-add-extralibs-to-extralibs_xxx.patch

@@ -0,0 +1,47 @@
+From 0c288853630b7b4e004774c39945d4a804afcfa8 Mon Sep 17 00:00:00 2001
+From: Fabrice Fontaine <fontaine.fabrice@gmail.com>
+Date: Fri, 6 Aug 2021 09:17:20 +0200
+Subject: [PATCH] configure: add extralibs to extralibs_xxx
+
+Add extralibs to extralibs_xxx (e.g. extralibs_avformat) to allow
+applications such as motion to retrieve ffmpeg dependencies such as
+-latomic through pkg-config
+
+Signed-off-by: Fabrice Fontaine <fontaine.fabrice@gmail.com>
+[Upstream status: not upstreamable]
+---
+ configure | 18 +++++++++---------
+ 1 file changed, 9 insertions(+), 9 deletions(-)
+
+diff --git a/configure b/configure
+index 0bb3a7cf2b..3bda99e415 100755
+--- a/configure
++++ b/configure
+@@ -7602,15 +7602,15 @@ rpath=$(enabled rpath && echo "-Wl,-rpath,\${libdir}")
+ source_path=${source_path}
+ LIBPREF=${LIBPREF}
+ LIBSUF=${LIBSUF}
+-extralibs_avutil="$avutil_extralibs"
+-extralibs_avcodec="$avcodec_extralibs"
+-extralibs_avformat="$avformat_extralibs"
+-extralibs_avdevice="$avdevice_extralibs"
+-extralibs_avfilter="$avfilter_extralibs"
+-extralibs_avresample="$avresample_extralibs"
+-extralibs_postproc="$postproc_extralibs"
+-extralibs_swscale="$swscale_extralibs"
+-extralibs_swresample="$swresample_extralibs"
++extralibs_avutil="$avutil_extralibs $extralibs"
++extralibs_avcodec="$avcodec_extralibs $extralibs"
++extralibs_avformat="$avformat_extralibs $extralibs"
++extralibs_avdevice="$avdevice_extralibs $extralibs"
++extralibs_avfilter="$avfilter_extralibs $extralibs"
++extralibs_avresample="$avresample_extralibs $extralibs"
++extralibs_postproc="$postproc_extralibs $extralibs"
++extralibs_swscale="$swscale_extralibs $extralibs"
++extralibs_swresample="$swresample_extralibs $extralibs"
+ EOF
+ 
+ for lib in $LIBRARY_LIST; do
+-- 
+2.30.2
+

+ 940 - 0
recipes-multimedia/ffmpeg/ffmpeg/0005-avcodec-add-omx-decoder-support.patch

@@ -0,0 +1,940 @@
+From a47ead72e315cdd497af174e81eb72aa9361d598 Mon Sep 17 00:00:00 2001
+From: "sw.multimedia" <se.multimedia@starfivetech.com>
+Date: Wed, 25 May 2022 20:05:11 +0800
+Subject: [PATCH 1/8] avcodec add omx decoder support
+
+Signed-off-by: sw.multimedia <se.multimedia@starfivetech.com>
+---
+ configure              |   1 +
+ libavcodec/Makefile    |   1 +
+ libavcodec/allcodecs.c |   1 +
+ libavcodec/omxdec.c    | 893 +++++++++++++++++++++++++++++++++++++++++
+ 4 files changed, 896 insertions(+)
+ create mode 100644 libavcodec/omxdec.c
+
+--- a/configure
++++ b/configure
+@@ -3176,6 +3176,7 @@
+ h264_nvenc_encoder_deps="nvenc"
+ h264_nvenc_encoder_select="atsc_a53"
+ h264_omx_encoder_deps="omx"
++h264_omx_decoder_deps="omx"
+ h264_qsv_decoder_select="h264_mp4toannexb_bsf qsvdec"
+ h264_qsv_encoder_select="atsc_a53 qsvenc"
+ h264_rkmpp_decoder_deps="rkmpp"
+--- a/libavcodec/Makefile
++++ b/libavcodec/Makefile
+@@ -392,6 +392,7 @@
+ OBJS-$(CONFIG_H264_MMAL_DECODER)       += mmaldec.o
+ OBJS-$(CONFIG_H264_NVENC_ENCODER)      += nvenc_h264.o nvenc.o
+ OBJS-$(CONFIG_H264_OMX_ENCODER)        += omx.o
++OBJS-$(CONFIG_H264_OMX_DECODER)        += omxdec.o
+ OBJS-$(CONFIG_H264_QSV_DECODER)        += qsvdec.o
+ OBJS-$(CONFIG_H264_QSV_ENCODER)        += qsvenc_h264.o
+ OBJS-$(CONFIG_H264_RKMPP_DECODER)      += rkmppdec.o
+--- /dev/null
++++ b/libavcodec/omxdec.c
+@@ -0,0 +1,893 @@
++/*
++ * OMX Video encoder
++ * Copyright (C) 2011 Martin Storsjo
++ *
++ * This file is part of FFmpeg.
++ *
++ * FFmpeg is free software; you can redistribute it and/or
++ * modify it under the terms of the GNU Lesser General Public
++ * License as published by the Free Software Foundation; either
++ * version 2.1 of the License, or (at your option) any later version.
++ *
++ * FFmpeg is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
++ * Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public
++ * License along with FFmpeg; if not, write to the Free Software
++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
++ */
++
++#include "config.h"
++
++#if CONFIG_OMX_RPI
++#define OMX_SKIP64BIT
++#endif
++
++#include <dlfcn.h>
++#include <OMX_Core.h>
++#include <OMX_Component.h>
++#include <pthread.h>
++#include <stdio.h>
++#include <stdlib.h>
++#include <sys/time.h>
++
++#include "libavutil/avstring.h"
++#include "libavutil/avutil.h"
++#include "libavutil/common.h"
++#include "libavutil/imgutils.h"
++#include "libavutil/log.h"
++#include "libavutil/opt.h"
++#include "libavutil/time.h"
++
++#include "avcodec.h"
++#include "h264.h"
++#include "internal.h"
++
++#ifdef OMX_SKIP64BIT
++static OMX_TICKS to_omx_ticks(int64_t value)
++{
++    OMX_TICKS s;
++    s.nLowPart  = value & 0xffffffff;
++    s.nHighPart = value >> 32;
++    return s;
++}
++static int64_t from_omx_ticks(OMX_TICKS value)
++{
++    return (((int64_t)value.nHighPart) << 32) | value.nLowPart;
++}
++#else
++#define to_omx_ticks(x) (x)
++#define from_omx_ticks(x) (x)
++#endif
++
++#define INIT_STRUCT(x) do {                                               \
++        x.nSize = sizeof(x);                                              \
++        x.nVersion = s->version;                                          \
++    } while (0)
++#define CHECK(x) do {                                                     \
++        if (x != OMX_ErrorNone) {                                         \
++            av_log(avctx, AV_LOG_ERROR,                                   \
++                   "err %x (%d) on line %d\n", x, x, __LINE__);           \
++            return AVERROR_UNKNOWN;                                       \
++        }                                                                 \
++    } while (0)
++
++typedef struct OMXContext {
++    void *lib;
++    void *lib2;
++    OMX_ERRORTYPE (*ptr_Init)(void);
++    OMX_ERRORTYPE (*ptr_Deinit)(void);
++    OMX_ERRORTYPE (*ptr_ComponentNameEnum)(OMX_STRING, OMX_U32, OMX_U32);
++    OMX_ERRORTYPE (*ptr_GetHandle)(OMX_HANDLETYPE*, OMX_STRING, OMX_PTR, OMX_CALLBACKTYPE*);
++    OMX_ERRORTYPE (*ptr_FreeHandle)(OMX_HANDLETYPE);
++    OMX_ERRORTYPE (*ptr_GetComponentsOfRole)(OMX_STRING, OMX_U32*, OMX_U8**);
++    OMX_ERRORTYPE (*ptr_GetRolesOfComponent)(OMX_STRING, OMX_U32*, OMX_U8**);
++    void (*host_init)(void);
++} OMXContext;
++
++static av_cold void *dlsym_prefixed(void *handle, const char *symbol, const char *prefix)
++{
++    char buf[50];
++    snprintf(buf, sizeof(buf), "%s%s", prefix ? prefix : "", symbol);
++    return dlsym(handle, buf);
++}
++
++static av_cold int omx_try_load(OMXContext *s, void *logctx,
++                                const char *libname, const char *prefix,
++                                const char *libname2)
++{
++    if (libname2) {
++        s->lib2 = dlopen(libname2, RTLD_NOW | RTLD_GLOBAL);
++        if (!s->lib2) {
++            av_log(logctx, AV_LOG_WARNING, "%s not found\n", libname2);
++            return AVERROR_ENCODER_NOT_FOUND;
++        }
++        s->host_init = dlsym(s->lib2, "bcm_host_init");
++        if (!s->host_init) {
++            av_log(logctx, AV_LOG_WARNING, "bcm_host_init not found\n");
++            dlclose(s->lib2);
++            s->lib2 = NULL;
++            return AVERROR_ENCODER_NOT_FOUND;
++        }
++    }
++    s->lib = dlopen(libname, RTLD_NOW | RTLD_GLOBAL);
++    if (!s->lib) {
++        av_log(logctx, AV_LOG_WARNING, "%s not found\n", libname);
++        return AVERROR_ENCODER_NOT_FOUND;
++    }
++    s->ptr_Init                = dlsym_prefixed(s->lib, "OMX_Init", prefix);
++    s->ptr_Deinit              = dlsym_prefixed(s->lib, "OMX_Deinit", prefix);
++    s->ptr_ComponentNameEnum   = dlsym_prefixed(s->lib, "OMX_ComponentNameEnum", prefix);
++    s->ptr_GetHandle           = dlsym_prefixed(s->lib, "OMX_GetHandle", prefix);
++    s->ptr_FreeHandle          = dlsym_prefixed(s->lib, "OMX_FreeHandle", prefix);
++    s->ptr_GetComponentsOfRole = dlsym_prefixed(s->lib, "OMX_GetComponentsOfRole", prefix);
++    s->ptr_GetRolesOfComponent = dlsym_prefixed(s->lib, "OMX_GetRolesOfComponent", prefix);
++    if (!s->ptr_Init || !s->ptr_Deinit || !s->ptr_ComponentNameEnum ||
++        !s->ptr_GetHandle || !s->ptr_FreeHandle ||
++        !s->ptr_GetComponentsOfRole || !s->ptr_GetRolesOfComponent) {
++        av_log(logctx, AV_LOG_WARNING, "Not all functions found in %s\n", libname);
++        dlclose(s->lib);
++        s->lib = NULL;
++        if (s->lib2)
++            dlclose(s->lib2);
++        s->lib2 = NULL;
++        return AVERROR_ENCODER_NOT_FOUND;
++    }
++    return 0;
++}
++
++static av_cold OMXContext *omx_init(void *logctx, const char *libname, const char *prefix)
++{
++    static const char * const libnames[] = {
++#if CONFIG_OMX_RPI
++        "/opt/vc/lib/libopenmaxil.so", "/opt/vc/lib/libbcm_host.so",
++#else
++        "libOMX_Core.so", NULL,
++        "libOmxCore.so", NULL,
++#endif
++        NULL
++    };
++    const char* const* nameptr;
++    int ret = AVERROR_DECODER_NOT_FOUND;
++    OMXContext *omx_context;
++
++    omx_context = av_mallocz(sizeof(*omx_context));
++    if (!omx_context)
++        return NULL;
++    if (libname) {
++        ret = omx_try_load(omx_context, logctx, libname, prefix, NULL);
++        if (ret < 0) {
++            av_free(omx_context);
++            return NULL;
++        }
++    } else {
++        for (nameptr = libnames; *nameptr; nameptr += 2)
++            if (!(ret = omx_try_load(omx_context, logctx, nameptr[0], prefix, nameptr[1])))
++                break;
++        if (!*nameptr) {
++            av_free(omx_context);
++            return NULL;
++        }
++    }
++
++    if (omx_context->host_init)
++        omx_context->host_init();
++    omx_context->ptr_Init();
++    return omx_context;
++}
++
++static av_cold void omx_deinit(OMXContext *omx_context)
++{
++    if (!omx_context)
++        return;
++
++    omx_context->ptr_Deinit();
++    dlclose(omx_context->lib);
++    av_free(omx_context);
++}
++
++typedef struct OMXCodecContext {
++    const AVClass *class;
++    char *libname;
++    char *libprefix;
++    OMXContext *omx_context;
++
++    AVCodecContext *avctx;
++
++    char component_name[OMX_MAX_STRINGNAME_SIZE];
++    OMX_VERSIONTYPE version;
++    OMX_HANDLETYPE handle;
++    int in_port, out_port;
++    OMX_COLOR_FORMATTYPE color_format;
++    int stride, plane_size;
++
++    int num_in_buffers, num_out_buffers;
++    OMX_BUFFERHEADERTYPE **in_buffer_headers;
++    OMX_BUFFERHEADERTYPE **out_buffer_headers;
++    int num_free_in_buffers;
++    OMX_BUFFERHEADERTYPE **free_in_buffers;
++    int num_done_out_buffers;
++    OMX_BUFFERHEADERTYPE **done_out_buffers;
++    pthread_mutex_t input_mutex;
++    pthread_cond_t input_cond;
++    pthread_mutex_t output_mutex;
++    pthread_cond_t output_cond;
++
++    pthread_mutex_t state_mutex;
++    pthread_cond_t state_cond;
++    OMX_STATETYPE state;
++    OMX_ERRORTYPE error;
++
++    int mutex_cond_inited;
++
++    int eos_sent, got_eos, first_get_outbuffer;
++
++	int extradata_sent;
++
++    uint8_t *output_buf;
++    int output_buf_size;
++
++    int input_zerocopy;
++    int profile;
++} OMXCodecContext;
++
++static void append_buffer(pthread_mutex_t *mutex, pthread_cond_t *cond,
++                          int* array_size, OMX_BUFFERHEADERTYPE **array,
++                          OMX_BUFFERHEADERTYPE *buffer)
++{
++    pthread_mutex_lock(mutex);
++    array[(*array_size)++] = buffer;
++    pthread_cond_broadcast(cond);
++    pthread_mutex_unlock(mutex);
++}
++
++static OMX_BUFFERHEADERTYPE *get_buffer(pthread_mutex_t *mutex, pthread_cond_t *cond,
++                                        int* array_size, OMX_BUFFERHEADERTYPE **array,
++                                        int wait)
++{
++    OMX_BUFFERHEADERTYPE *buffer;
++    pthread_mutex_lock(mutex);
++    if (wait) {
++        while (!*array_size)
++        {
++           pthread_cond_wait(cond, mutex);
++        }
++    }
++    if (*array_size > 0) {
++        buffer = array[0];
++        (*array_size)--;
++        memmove(&array[0], &array[1], (*array_size) * sizeof(OMX_BUFFERHEADERTYPE*));
++    } else {
++        buffer = NULL;
++    }
++    pthread_mutex_unlock(mutex);
++    return buffer;
++}
++
++static OMX_ERRORTYPE event_handler(OMX_HANDLETYPE component, OMX_PTR app_data, OMX_EVENTTYPE event,
++                                   OMX_U32 data1, OMX_U32 data2, OMX_PTR event_data)
++{
++    OMXCodecContext *s = app_data;
++    // This uses casts in the printfs, since OMX_U32 actually is a typedef for
++    // unsigned long in official header versions (but there are also modified
++    // versions where it is something else).
++    switch (event) {
++    case OMX_EventError:
++        pthread_mutex_lock(&s->state_mutex);
++        av_log(s->avctx, AV_LOG_ERROR, "OMX error %"PRIx32"\n", (uint32_t) data1);
++        s->error = data1;
++        pthread_cond_broadcast(&s->state_cond);
++        pthread_mutex_unlock(&s->state_mutex);
++        break;
++    case OMX_EventCmdComplete:
++        if (data1 == OMX_CommandStateSet) {
++            pthread_mutex_lock(&s->state_mutex);
++            s->state = data2;
++            av_log(s->avctx, AV_LOG_VERBOSE, "OMX state changed to %"PRIu32"\n", (uint32_t) data2);
++            pthread_cond_broadcast(&s->state_cond);
++            pthread_mutex_unlock(&s->state_mutex);
++        } else if (data1 == OMX_CommandPortDisable) {
++            av_log(s->avctx, AV_LOG_VERBOSE, "OMX port %"PRIu32" disabled\n", (uint32_t) data2);
++        } else if (data1 == OMX_CommandPortEnable) {
++            av_log(s->avctx, AV_LOG_VERBOSE, "OMX port %"PRIu32" enabled\n", (uint32_t) data2);
++        } else {
++            av_log(s->avctx, AV_LOG_VERBOSE, "OMX command complete, command %"PRIu32", value %"PRIu32"\n",
++                                             (uint32_t) data1, (uint32_t) data2);
++        }
++        break;
++    case OMX_EventPortSettingsChanged:
++        av_log(s->avctx, AV_LOG_VERBOSE, "OMX port %"PRIu32" settings changed\n", (uint32_t) data1);
++        break;
++    default:
++        av_log(s->avctx, AV_LOG_VERBOSE, "OMX event %d %"PRIx32" %"PRIx32"\n",
++                                         event, (uint32_t) data1, (uint32_t) data2);
++        break;
++    }
++    return OMX_ErrorNone;
++}
++
++static OMX_ERRORTYPE empty_buffer_done(OMX_HANDLETYPE component, OMX_PTR app_data,
++                                       OMX_BUFFERHEADERTYPE *buffer)
++{
++
++    OMXCodecContext *s = app_data;
++    if (s->input_zerocopy) {
++        if (buffer->pAppPrivate) {
++            if (buffer->pOutputPortPrivate)
++                av_free(buffer->pAppPrivate);
++            else
++                av_frame_free((AVFrame**)&buffer->pAppPrivate);
++            buffer->pAppPrivate = NULL;
++        }
++    }
++    append_buffer(&s->input_mutex, &s->input_cond,
++                  &s->num_free_in_buffers, s->free_in_buffers, buffer);
++    return OMX_ErrorNone;
++}
++
++static OMX_ERRORTYPE fill_buffer_done(OMX_HANDLETYPE component, OMX_PTR app_data,
++                                      OMX_BUFFERHEADERTYPE *buffer)
++{
++    OMXCodecContext *s = app_data;
++    append_buffer(&s->output_mutex, &s->output_cond,
++                  &s->num_done_out_buffers, s->done_out_buffers, buffer);
++    return OMX_ErrorNone;
++}
++
++static const OMX_CALLBACKTYPE callbacks = {
++    event_handler,
++    empty_buffer_done,
++    fill_buffer_done
++};
++
++static av_cold int find_component(OMXContext *omx_context, void *logctx,
++                                  const char *role, char *str, int str_size)
++{
++    OMX_U32 i, num = 0;
++    char **components;
++    int ret = 0;
++
++#if CONFIG_OMX_RPI
++    if (av_strstart(role, "video_decoder.", NULL)) {
++        av_strlcpy(str, "OMX.broadcom.video_decode", str_size);
++        return 0;
++    }
++#endif
++    omx_context->ptr_GetComponentsOfRole((OMX_STRING) role, &num, NULL);
++    if (!num) {
++        av_log(logctx, AV_LOG_WARNING, "No component for role %s found\n", role);
++        return AVERROR_DECODER_NOT_FOUND;
++    }
++    components = av_mallocz_array(num, sizeof(*components));
++    if (!components)
++        return AVERROR(ENOMEM);
++    for (i = 0; i < num; i++) {
++        components[i] = av_mallocz(OMX_MAX_STRINGNAME_SIZE);
++        if (!components[i]) {
++            ret = AVERROR(ENOMEM);
++            goto end;
++        }
++    }
++    omx_context->ptr_GetComponentsOfRole((OMX_STRING) role, &num, (OMX_U8**) components);
++    av_strlcpy(str, components[0], str_size);
++end:
++    for (i = 0; i < num; i++)
++        av_free(components[i]);
++    av_free(components);
++    return ret;
++}
++
++static av_cold int wait_for_state(OMXCodecContext *s, OMX_STATETYPE state)
++{
++    int ret = 0;
++    pthread_mutex_lock(&s->state_mutex);
++    while (s->state != state && s->error == OMX_ErrorNone)
++        pthread_cond_wait(&s->state_cond, &s->state_mutex);
++    if (s->error != OMX_ErrorNone)
++        ret = AVERROR_DECODER_NOT_FOUND;
++    pthread_mutex_unlock(&s->state_mutex);
++    return ret;
++}
++
++static av_cold int omx_component_init(AVCodecContext *avctx, const char *role)
++{
++    OMXCodecContext *s = avctx->priv_data;
++    OMX_PARAM_COMPONENTROLETYPE role_params = { 0 };
++    OMX_PORT_PARAM_TYPE video_port_params = { 0 };
++    OMX_PARAM_PORTDEFINITIONTYPE in_port_params = { 0 }, out_port_params = { 0 };
++    //OMX_VIDEO_PARAM_PORTFORMATTYPE video_port_format = { 0 };
++    //OMX_VIDEO_PARAM_BITRATETYPE vid_param_bitrate = { 0 };
++    OMX_ERRORTYPE err;
++    int i;
++
++    s->version.s.nVersionMajor = 1;
++    s->version.s.nVersionMinor = 1;
++    s->version.s.nRevision     = 2;
++
++    err = s->omx_context->ptr_GetHandle(&s->handle, s->component_name, s, (OMX_CALLBACKTYPE*) &callbacks);
++    if (err != OMX_ErrorNone) {
++        av_log(avctx, AV_LOG_ERROR, "OMX_GetHandle(%s) failed: %x\n", s->component_name, err);
++        return AVERROR_UNKNOWN;
++    }
++
++    // This one crashes the mediaserver on qcom, if used over IOMX
++    INIT_STRUCT(role_params);
++    av_strlcpy(role_params.cRole, role, sizeof(role_params.cRole));
++    // Intentionally ignore errors on this one
++    OMX_SetParameter(s->handle, OMX_IndexParamStandardComponentRole, &role_params);
++
++    INIT_STRUCT(video_port_params);
++    err = OMX_GetParameter(s->handle, OMX_IndexParamVideoInit, &video_port_params);
++    CHECK(err);
++
++    s->in_port = s->out_port = -1;
++    for (i = 0; i < video_port_params.nPorts; i++) {
++        int port = video_port_params.nStartPortNumber + i;
++        OMX_PARAM_PORTDEFINITIONTYPE port_params = { 0 };
++        INIT_STRUCT(port_params);
++        port_params.nPortIndex = port;
++        err = OMX_GetParameter(s->handle, OMX_IndexParamPortDefinition, &port_params);
++        if (err != OMX_ErrorNone) {
++            av_log(avctx, AV_LOG_WARNING, "port %d error %x\n", port, err);
++            break;
++        }
++        if (port_params.eDir == OMX_DirInput && s->in_port < 0) {
++            in_port_params = port_params;
++            s->in_port = port;
++        } else if (port_params.eDir == OMX_DirOutput && s->out_port < 0) {
++            out_port_params = port_params;
++            s->out_port = port;
++        }
++    }
++    if (s->in_port < 0 || s->out_port < 0) {
++        av_log(avctx, AV_LOG_ERROR, "No in or out port found (in %d out %d)\n", s->in_port, s->out_port);
++        return AVERROR_UNKNOWN;
++    }
++
++    in_port_params.bEnabled   = OMX_TRUE;
++    in_port_params.bPopulated = OMX_FALSE;
++    in_port_params.eDomain    = OMX_PortDomainVideo;
++
++    in_port_params.format.video.pNativeRender         = NULL;
++    in_port_params.format.video.bFlagErrorConcealment = OMX_FALSE;
++    //in_port_params.format.video.eColorFormat          = s->color_format;
++    s->stride     = avctx->width;
++    s->plane_size = avctx->height;
++    // If specific codecs need to manually override the stride/plane_size,
++    // that can be done here.
++    in_port_params.format.video.nStride      = s->stride;
++    in_port_params.format.video.nSliceHeight = s->plane_size;
++    in_port_params.format.video.nFrameWidth  = avctx->width;
++    in_port_params.format.video.nFrameHeight = avctx->height;
++
++    if (avctx->framerate.den > 0 && avctx->framerate.num > 0)
++        in_port_params.format.video.xFramerate = (1LL << 16) * avctx->framerate.num / avctx->framerate.den;
++    else
++        in_port_params.format.video.xFramerate = (1LL << 16) * avctx->time_base.den / avctx->time_base.num;
++
++    err = OMX_SetParameter(s->handle, OMX_IndexParamPortDefinition, &in_port_params);
++    CHECK(err);
++    err = OMX_GetParameter(s->handle, OMX_IndexParamPortDefinition, &in_port_params);
++    CHECK(err);
++
++#if 1
++    s->stride         = in_port_params.format.video.nStride;
++    s->plane_size     = in_port_params.format.video.nSliceHeight;
++    s->num_in_buffers = in_port_params.nBufferCountActual;
++#endif
++    err = OMX_GetParameter(s->handle, OMX_IndexParamPortDefinition, &out_port_params);
++    out_port_params.bEnabled   = OMX_TRUE;
++    out_port_params.bPopulated = OMX_FALSE;
++    out_port_params.eDomain    = OMX_PortDomainVideo;
++    out_port_params.format.video.pNativeRender = NULL;
++	out_port_params.format.video.bFlagErrorConcealment  = OMX_FALSE;
++    out_port_params.format.video.nFrameWidth   = avctx->width;
++    out_port_params.format.video.nFrameHeight  = avctx->height;
++    out_port_params.format.video.nStride       = 0;
++    out_port_params.format.video.nSliceHeight  = 0;
++    out_port_params.format.video.nBitrate      = avctx->bit_rate;
++    out_port_params.format.video.xFramerate    = in_port_params.format.video.xFramerate;
++    out_port_params.format.video.bFlagErrorConcealment  = OMX_FALSE;
++    if (avctx->codec->id == AV_CODEC_ID_MPEG4)
++        out_port_params.format.video.eCompressionFormat = OMX_VIDEO_CodingMPEG4;
++    else if (avctx->codec->id == AV_CODEC_ID_H264)
++        out_port_params.format.video.eCompressionFormat = OMX_VIDEO_CodingAVC;
++
++    err = OMX_SetParameter(s->handle, OMX_IndexParamPortDefinition, &out_port_params);
++    CHECK(err);
++    err = OMX_GetParameter(s->handle, OMX_IndexParamPortDefinition, &out_port_params);
++    CHECK(err);
++    s->num_out_buffers = out_port_params.nBufferCountActual;
++
++
++    err = OMX_SendCommand(s->handle, OMX_CommandStateSet, OMX_StateIdle, NULL);
++    CHECK(err);
++
++    s->in_buffer_headers  = av_mallocz(sizeof(OMX_BUFFERHEADERTYPE*) * s->num_in_buffers);
++    s->free_in_buffers    = av_mallocz(sizeof(OMX_BUFFERHEADERTYPE*) * s->num_in_buffers);
++    s->out_buffer_headers = av_mallocz(sizeof(OMX_BUFFERHEADERTYPE*) * s->num_out_buffers);
++    s->done_out_buffers   = av_mallocz(sizeof(OMX_BUFFERHEADERTYPE*) * s->num_out_buffers);
++    if (!s->in_buffer_headers || !s->free_in_buffers || !s->out_buffer_headers || !s->done_out_buffers)
++        return AVERROR(ENOMEM);
++    for (i = 0; i < s->num_in_buffers && err == OMX_ErrorNone; i++) {
++        if (s->input_zerocopy)
++            err = OMX_UseBuffer(s->handle, &s->in_buffer_headers[i], s->in_port, s, in_port_params.nBufferSize, NULL);
++        else
++            err = OMX_AllocateBuffer(s->handle, &s->in_buffer_headers[i],  s->in_port,  s, in_port_params.nBufferSize);
++        if (err == OMX_ErrorNone)
++            s->in_buffer_headers[i]->pAppPrivate = s->in_buffer_headers[i]->pOutputPortPrivate = NULL;
++    }
++    CHECK(err);
++    s->num_in_buffers = i;
++    for (i = 0; i < s->num_out_buffers && err == OMX_ErrorNone; i++)
++        err = OMX_AllocateBuffer(s->handle, &s->out_buffer_headers[i], s->out_port, s, out_port_params.nBufferSize);
++    CHECK(err);
++    s->num_out_buffers = i;
++
++    if (wait_for_state(s, OMX_StateIdle) < 0) {
++        av_log(avctx, AV_LOG_ERROR, "Didn't get OMX_StateIdle\n");
++        return AVERROR_UNKNOWN;
++    }
++    err = OMX_SendCommand(s->handle, OMX_CommandStateSet, OMX_StateExecuting, NULL);
++    CHECK(err);
++    if (wait_for_state(s, OMX_StateExecuting) < 0) {
++        av_log(avctx, AV_LOG_ERROR, "Didn't get OMX_StateExecuting\n");
++        return AVERROR_UNKNOWN;
++    }
++
++    for (i = 0; i < s->num_out_buffers && err == OMX_ErrorNone; i++)
++        err = OMX_FillThisBuffer(s->handle, s->out_buffer_headers[i]);
++    if (err != OMX_ErrorNone) {
++        for (; i < s->num_out_buffers; i++)
++            s->done_out_buffers[s->num_done_out_buffers++] = s->out_buffer_headers[i];
++    }
++    for (i = 0; i < s->num_in_buffers; i++)
++        s->free_in_buffers[s->num_free_in_buffers++] = s->in_buffer_headers[i];
++    return err != OMX_ErrorNone ? AVERROR_UNKNOWN : 0;
++}
++
++static av_cold void cleanup(OMXCodecContext *s)
++{
++    int i, executing;
++
++    pthread_mutex_lock(&s->state_mutex);
++    executing = s->state == OMX_StateExecuting;
++    pthread_mutex_unlock(&s->state_mutex);
++
++    if (executing) {
++        OMX_SendCommand(s->handle, OMX_CommandStateSet, OMX_StateIdle, NULL);
++        wait_for_state(s, OMX_StateIdle);
++        OMX_SendCommand(s->handle, OMX_CommandStateSet, OMX_StateLoaded, NULL);
++        for (i = 0; i < s->num_in_buffers; i++) {
++            OMX_BUFFERHEADERTYPE *buffer = get_buffer(&s->input_mutex, &s->input_cond,
++                                                      &s->num_free_in_buffers, s->free_in_buffers, 1);
++            if (s->input_zerocopy)
++                buffer->pBuffer = NULL;
++            OMX_FreeBuffer(s->handle, s->in_port, buffer);
++        }
++        for (i = 0; i < s->num_out_buffers; i++) {
++            OMX_BUFFERHEADERTYPE *buffer = get_buffer(&s->output_mutex, &s->output_cond,
++                                                      &s->num_done_out_buffers, s->done_out_buffers, 1);
++            OMX_FreeBuffer(s->handle, s->out_port, buffer);
++        }
++        wait_for_state(s, OMX_StateLoaded);
++    }
++    if (s->handle) {
++        s->omx_context->ptr_FreeHandle(s->handle);
++        s->handle = NULL;
++    }
++
++    omx_deinit(s->omx_context);
++    s->omx_context = NULL;
++    if (s->mutex_cond_inited) {
++        pthread_cond_destroy(&s->state_cond);
++        pthread_mutex_destroy(&s->state_mutex);
++        pthread_cond_destroy(&s->input_cond);
++        pthread_mutex_destroy(&s->input_mutex);
++        pthread_cond_destroy(&s->output_cond);
++        pthread_mutex_destroy(&s->output_mutex);
++        s->mutex_cond_inited = 0;
++    }
++    av_freep(&s->in_buffer_headers);
++    av_freep(&s->out_buffer_headers);
++    av_freep(&s->free_in_buffers);
++    av_freep(&s->done_out_buffers);
++    av_freep(&s->output_buf);
++}
++
++static av_cold int omx_decode_init(AVCodecContext *avctx)
++{
++    OMXCodecContext *s = avctx->priv_data;
++    int ret = AVERROR_ENCODER_NOT_FOUND;
++    const char *role;
++    //OMX_BUFFERHEADERTYPE *buffer;
++    //OMX_ERRORTYPE err;
++
++    s->omx_context = omx_init(avctx, s->libname, s->libprefix);
++    if (!s->omx_context)
++        return AVERROR_ENCODER_NOT_FOUND;
++
++    pthread_mutex_init(&s->state_mutex, NULL);
++    pthread_cond_init(&s->state_cond, NULL);
++    pthread_mutex_init(&s->input_mutex, NULL);
++    pthread_cond_init(&s->input_cond, NULL);
++    pthread_mutex_init(&s->output_mutex, NULL);
++    pthread_cond_init(&s->output_cond, NULL);
++    s->mutex_cond_inited = 1;
++    s->avctx = avctx;
++    s->state = OMX_StateLoaded;
++    s->error = OMX_ErrorNone;
++
++    switch (avctx->codec->id) {
++    case AV_CODEC_ID_MPEG4:
++        role = "video_decoder.mpeg4";
++        break;
++    case AV_CODEC_ID_H264:
++        role = "video_decoder.avc";
++        break;
++    default:
++        return AVERROR(ENOSYS);
++    }
++
++    if ((ret = find_component(s->omx_context, avctx, role, s->component_name, sizeof(s->component_name))) < 0)
++        goto fail;
++
++    av_log(avctx, AV_LOG_INFO, "Using %s\n", s->component_name);
++
++    if ((ret = omx_component_init(avctx, role)) < 0)
++        goto fail;
++
++#if 0
++    if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
++        while (1) {
++            buffer = get_buffer(&s->output_mutex, &s->output_cond,
++                                &s->num_done_out_buffers, s->done_out_buffers, 1);
++            if (buffer->nFlags & OMX_BUFFERFLAG_CODECCONFIG) {
++                if ((ret = av_reallocp(&avctx->extradata, avctx->extradata_size + buffer->nFilledLen + AV_INPUT_BUFFER_PADDING_SIZE)) < 0) {
++                    avctx->extradata_size = 0;
++                    goto fail;
++                }
++                memcpy(avctx->extradata + avctx->extradata_size, buffer->pBuffer + buffer->nOffset, buffer->nFilledLen);
++                avctx->extradata_size += buffer->nFilledLen;
++                memset(avctx->extradata + avctx->extradata_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
++            }
++            err = OMX_FillThisBuffer(s->handle, buffer);
++            if (err != OMX_ErrorNone) {
++                append_buffer(&s->output_mutex, &s->output_cond,
++                              &s->num_done_out_buffers, s->done_out_buffers, buffer);
++                av_log(avctx, AV_LOG_ERROR, "OMX_FillThisBuffer failed: %x\n", err);
++                ret = AVERROR_UNKNOWN;
++                goto fail;
++            }
++            if (avctx->codec->id == AV_CODEC_ID_H264) {
++                // For H.264, the extradata can be returned in two separate buffers
++                // (the videocore encoder on raspberry pi does this);
++                // therefore check that we have got both SPS and PPS before continuing.
++                int nals[32] = { 0 };
++                int i;
++                for (i = 0; i + 4 < avctx->extradata_size; i++) {
++                     if (!avctx->extradata[i + 0] &&
++                         !avctx->extradata[i + 1] &&
++                         !avctx->extradata[i + 2] &&
++                         avctx->extradata[i + 3] == 1) {
++                         nals[avctx->extradata[i + 4] & 0x1f]++;
++                     }
++                }
++                if (nals[H264_NAL_SPS] && nals[H264_NAL_PPS])
++                    break;
++            } else {
++                if (avctx->extradata_size > 0)
++                    break;
++            }
++        }
++    }
++#endif
++	
++    return 0;
++fail:
++    return ret;
++}
++
++
++static int omx_decode_frame(AVCodecContext *avctx, void *data,
++                           int *got_packet, AVPacket *pkt)
++{
++    OMXCodecContext *s = avctx->priv_data;
++    int ret = 0;
++    OMX_BUFFERHEADERTYPE* buffer;
++    OMX_ERRORTYPE err;
++    int had_partial = 0;
++
++	AVFrame *avframe = data;
++	
++	uint8_t *dst[4];
++	int linesize[4];
++
++    if (pkt->size) {
++
++		//VPU init and fill buffer slow, so empty buf sleep to send before get vpu fill buf.
++		if(!s->first_get_outbuffer)
++			av_usleep(100000);
++	
++        buffer = get_buffer(&s->input_mutex, &s->input_cond,
++                            &s->num_free_in_buffers, s->free_in_buffers, 1);
++
++		if (!buffer) {
++        	av_log(avctx, AV_LOG_ERROR, "get_buffer NULL\n");
++            return AVERROR(ENOMEM);
++        }
++
++		//cpy the extradata
++		if(!s->extradata_sent) {
++
++			memcpy(buffer->pBuffer + buffer->nOffset, avctx->extradata, avctx->extradata_size);	
++			memcpy(buffer->pBuffer + buffer->nOffset + avctx->extradata_size, pkt->data, pkt->size);
++			buffer->nFilledLen = pkt->size + avctx->extradata_size;
++			s->extradata_sent = 1;
++		
++		}
++		else {
++			memcpy(buffer->pBuffer + buffer->nOffset, pkt->data, pkt->size);
++			buffer->nFilledLen = pkt->size;
++		}
++
++		/* reduce memcpy. point it addr*/
++		//buffer->pAppPrivate = pkt;
++		//buffer->pBuffer = pkt->data;
++		//buffer->nFilledLen = pkt->size;
++		
++		buffer->pOutputPortPrivate = NULL;
++		buffer->pAppPrivate = avctx->priv_data;
++
++	    err = OMX_EmptyThisBuffer(s->handle, buffer);
++	    if (err != OMX_ErrorNone) {
++	        append_buffer(&s->input_mutex, &s->input_cond, &s->num_free_in_buffers, s->free_in_buffers, buffer);
++	        av_log(avctx, AV_LOG_ERROR, "OMX_EmptyThisBuffer failed: %x\n", err);
++	        return AVERROR_UNKNOWN;
++	    }
++    } else if (!s->eos_sent) {
++
++		if(!s->first_get_outbuffer)
++			av_usleep(1000000);
++		
++        buffer = get_buffer(&s->input_mutex, &s->input_cond,
++                            &s->num_free_in_buffers, s->free_in_buffers, 1);
++
++        buffer->nFilledLen = 0;
++        buffer->nFlags = OMX_BUFFERFLAG_EOS;
++        buffer->pAppPrivate = buffer->pOutputPortPrivate = NULL;
++        err = OMX_EmptyThisBuffer(s->handle, buffer);
++        if (err != OMX_ErrorNone) {
++            append_buffer(&s->input_mutex, &s->input_cond, &s->num_free_in_buffers, s->free_in_buffers, buffer);
++            av_log(avctx, AV_LOG_ERROR, "OMX_EmptyThisBuffer failed: %x\n", err);
++            return AVERROR_UNKNOWN;
++        }
++        s->eos_sent = 1;
++    }
++
++    while (!*got_packet && ret == 0 && !s->got_eos) {
++        // If not flushing, just poll the queue if there's finished packets.
++        // If flushing, do a blocking wait until we either get a completed
++        // packet, or get EOS.
++        buffer = get_buffer(&s->output_mutex, &s->output_cond,
++                            &s->num_done_out_buffers, s->done_out_buffers,
++                            !pkt || had_partial);
++
++        if (!buffer) {
++            /*eos is sent but fill buf still can't get then continue*/
++            if(!s->first_get_outbuffer && s->eos_sent)
++				continue; 
++			else
++				break;
++        }
++		//if (!buffer)
++           // break;
++
++		if(!buffer->nFilledLen)
++			goto end;
++		
++		if(!s->first_get_outbuffer)
++			s->first_get_outbuffer = 1;
++		
++        if (buffer->nFlags & OMX_BUFFERFLAG_EOS)
++            s->got_eos = 1;
++       
++		if ((ret = ff_get_buffer(avctx, avframe, 0)) < 0) {
++			av_log(avctx, AV_LOG_ERROR, "Unable to allocate buffer\n");
++			goto end;
++		}
++		
++		ret = av_image_fill_arrays(dst, linesize, buffer->pBuffer,
++								   avctx->pix_fmt, s->stride, s->plane_size, 1);
++		if (ret < 0)
++			goto end;
++		av_image_copy(avframe->data, avframe->linesize, (const uint8_t**)dst, linesize, 
++							avctx->pix_fmt, avctx->width, avctx->height);
++	
++		//avframe->pts	 = buffer->nTimeStamp;
++		//avframe->pkt_dts = AV_NOPTS_VALUE;
++		//avframe->pict_type= AV_PICTURE_TYPE_I;
++    	//avframe->key_frame= 1;
++
++		*got_packet = 1;
++
++	/*
++		if ((ret = av_frame_ref(data, avframe)) < 0)
++         	goto end;
++         	*/
++
++end:     
++        err = OMX_FillThisBuffer(s->handle, buffer);
++        if (err != OMX_ErrorNone) {
++            append_buffer(&s->output_mutex, &s->output_cond, &s->num_done_out_buffers, s->done_out_buffers, buffer);
++            av_log(avctx, AV_LOG_ERROR, "OMX_FillThisBuffer failed: %x\n", err);
++            ret = AVERROR_UNKNOWN;
++        }
++    }
++    return ret;
++}
++
++static av_cold int omx_decode_end(AVCodecContext *avctx)
++{
++    OMXCodecContext *s = avctx->priv_data;
++
++    cleanup(s);
++    return 0;
++}
++
++#define OFFSET(x) offsetof(OMXCodecContext, x)
++#define VDE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM
++#define VE  AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
++static const AVOption options[] = {
++    { "omx_libname", "OpenMAX library name", OFFSET(libname), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VDE },
++    { "omx_libprefix", "OpenMAX library prefix", OFFSET(libprefix), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VDE },
++    { "zerocopy", "Try to avoid copying input frames if possible", OFFSET(input_zerocopy), AV_OPT_TYPE_INT, { .i64 = CONFIG_OMX_RPI }, 0, 1, VE },
++    { "profile",  "Set the encoding profile", OFFSET(profile), AV_OPT_TYPE_INT,   { .i64 = FF_PROFILE_UNKNOWN },       FF_PROFILE_UNKNOWN, FF_PROFILE_H264_HIGH, VE, "profile" },
++    { "baseline", "",                         0,               AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_H264_BASELINE }, 0, 0, VE, "profile" },
++    { "main",     "",                         0,               AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_H264_MAIN },     0, 0, VE, "profile" },
++    { "high",     "",                         0,               AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_H264_HIGH },     0, 0, VE, "profile" },
++    { NULL }
++};
++
++
++static const AVClass omx_mpeg4dec_class = {
++    .class_name = "mpeg4_omx",
++    .item_name  = av_default_item_name,
++    .option     = options,
++    .version    = LIBAVUTIL_VERSION_INT,
++};
++AVCodec ff_mpeg4_omx_decoder = {
++    .name             = "mpeg4_omx",
++    .long_name        = NULL_IF_CONFIG_SMALL("OpenMAX IL MPEG-4 video decoder"),
++    .type             = AVMEDIA_TYPE_VIDEO,
++    .id               = AV_CODEC_ID_MPEG4,
++    .priv_data_size   = sizeof(OMXCodecContext),
++    .init             = omx_decode_init,
++    .decode           = omx_decode_frame,
++    .close            = omx_decode_end,
++    .capabilities     = AV_CODEC_CAP_DELAY,
++    .caps_internal    = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
++    .priv_class       = &omx_mpeg4dec_class,
++};
++
++static const AVClass omx_h264dec_class = {
++    .class_name = "h264_omx",
++    .item_name  = av_default_item_name,
++    .option     = options,
++    .version    = LIBAVUTIL_VERSION_INT,
++};
++AVCodec ff_h264_omx_decoder = {
++    .name             = "h264_omx",
++    .long_name        = NULL_IF_CONFIG_SMALL("OpenMAX IL H.264 video decoder"),
++    .type             = AVMEDIA_TYPE_VIDEO,
++    .id               = AV_CODEC_ID_H264,
++    .priv_data_size   = sizeof(OMXCodecContext),
++    .init             = omx_decode_init,
++    .decode           = omx_decode_frame,
++    .close            = omx_decode_end,
++    .capabilities     = AV_CODEC_CAP_DELAY,
++    .caps_internal    = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
++    .priv_class       = &omx_h264dec_class,
++};
+--- a/libavcodec/allcodecs.c
++++ b/libavcodec/allcodecs.c
+@@ -823,6 +823,7 @@
+ extern const FFCodec ff_h264_mf_encoder;
+ extern const FFCodec ff_h264_nvenc_encoder;
+ extern const FFCodec ff_h264_omx_encoder;
++extern const FFCodec ff_h264_omx_decoder;
+ extern const FFCodec ff_h264_qsv_encoder;
+ extern const FFCodec ff_h264_v4l2m2m_encoder;
+ extern const FFCodec ff_h264_vaapi_encoder;

+ 199 - 0
recipes-multimedia/ffmpeg/ffmpeg/0006-add-hevc-decoder-and-encoder-support.patch

@@ -0,0 +1,199 @@
+From 0adf789b7c3060e241b82e6afdfc2f7975f1ee39 Mon Sep 17 00:00:00 2001
+From: "sw.multimedia" <se.multimedia@starfivetech.com>
+Date: Wed, 25 May 2022 20:28:21 +0800
+Subject: [PATCH 2/8] add hevc decoder and encoder support
+
+Signed-off-by: sw.multimedia <se.multimedia@starfivetech.com>
+---
+ configure              |  2 ++
+ libavcodec/allcodecs.c |  2 ++
+ libavcodec/omx.c       | 35 +++++++++++++++++++++++++++++++++++
+ libavcodec/omxdec.c    | 35 ++++++++++++++++++++++++++++++++++-
+ libavformat/utils.c    |  7 +++++++
+ 5 files changed, 80 insertions(+), 1 deletion(-)
+
+--- a/configure
++++ b/configure
+@@ -3185,6 +3185,8 @@
+ h264_v4l2m2m_decoder_deps="v4l2_m2m h264_v4l2_m2m"
+ h264_v4l2m2m_decoder_select="h264_mp4toannexb_bsf"
+ h264_v4l2m2m_encoder_deps="v4l2_m2m h264_v4l2_m2m"
++hevc_omx_encoder_deps="omx"
++hevc_omx_decoder_deps="omx"
+ hevc_amf_encoder_deps="amf"
+ hevc_cuvid_decoder_deps="cuvid"
+ hevc_cuvid_decoder_select="hevc_mp4toannexb_bsf"
+--- a/libavcodec/allcodecs.c
++++ b/libavcodec/allcodecs.c
+@@ -824,6 +824,8 @@
+ extern const FFCodec ff_h264_nvenc_encoder;
+ extern const FFCodec ff_h264_omx_encoder;
+ extern const FFCodec ff_h264_omx_decoder;
++extern const FFCodec ff_hevc_omx_encoder;
++extern const FFCodec ff_hevc_omx_decoder;
+ extern const FFCodec ff_h264_qsv_encoder;
+ extern const FFCodec ff_h264_v4l2m2m_encoder;
+ extern const FFCodec ff_h264_vaapi_encoder;
+--- a/libavcodec/omx.c
++++ b/libavcodec/omx.c
+@@ -44,7 +44,8 @@
+ #include "codec_internal.h"
+ #include "h264.h"
+ #include "pthread_internal.h"
+-
++#include "profiles.h"
++ 
+ #ifdef OMX_SKIP64BIT
+ static OMX_TICKS to_omx_ticks(int64_t value)
+ {
+@@ -508,6 +509,8 @@
+         out_port_params.format.video.eCompressionFormat = OMX_VIDEO_CodingMPEG4;
+     else if (avctx->codec->id == AV_CODEC_ID_H264)
+         out_port_params.format.video.eCompressionFormat = OMX_VIDEO_CodingAVC;
++    else if (avctx->codec->id == AV_CODEC_ID_HEVC)
++        out_port_params.format.video.eCompressionFormat = OMX_VIDEO_CodingHEVC;
+ 
+     err = OMX_SetParameter(s->handle, OMX_IndexParamPortDefinition, &out_port_params);
+     CHECK(err);
+@@ -666,6 +669,9 @@
+     case AV_CODEC_ID_H264:
+         role = "video_encoder.avc";
+         break;
++    case AV_CODEC_ID_HEVC:
++		role = "video_encoder.hevc";
++		break;
+     default:
+         return AVERROR(ENOSYS);
+     }
+@@ -926,6 +932,13 @@
+     { NULL }
+ };
+ 
++static const AVOption options_hevc[] = {
++    { "omx_libname", "OpenMAX library name", OFFSET(libname), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VDE },
++    { "omx_libprefix", "OpenMAX library prefix", OFFSET(libprefix), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VDE },
++    { "zerocopy", "Try to avoid copying input frames if possible", OFFSET(input_zerocopy), AV_OPT_TYPE_INT, { .i64 = CONFIG_OMX_RPI }, 0, 1, VE },
++	{ NULL },
++};
++
+ static const enum AVPixelFormat omx_encoder_pix_fmts[] = {
+     AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE
+ };
+@@ -971,3 +984,25 @@
+     .caps_internal    = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
+     .p.priv_class     = &omx_h264enc_class,
+ };
++
++static const AVClass omx_hevcenc_class = {
++	.class_name = "hevc_omx",
++	.item_name = av_default_item_name,
++	.option = options_hevc,
++	.version = LIBAVUTIL_VERSION_INT,
++};
++AVCodec ff_hevc_omx_encoder = {
++	.name 			  = "hevc_omx",
++	.long_name 		  = NULL_IF_CONFIG_SMALL("OpenMAX IL HEVC video encoder"),
++	.type 			  = AVMEDIA_TYPE_VIDEO,
++	.id 			  = AV_CODEC_ID_HEVC,
++	.priv_data_size   = sizeof(OMXCodecContext),
++	.init 			  = omx_encode_init,
++	.encode2 		  = omx_encode_frame,
++	.close 			  = omx_encode_end,
++	.pix_fmts 		  = omx_encoder_pix_fmts,
++	.profiles         = NULL_IF_CONFIG_SMALL(ff_hevc_profiles),
++	.capabilities 	  = AV_CODEC_CAP_DELAY,
++	.caps_internal 	  = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
++	.priv_class 	  = &omx_hevcenc_class,
++};
+--- a/libavcodec/omxdec.c
++++ b/libavcodec/omxdec.c
+@@ -44,6 +44,7 @@
+ #include "avcodec.h"
+ #include "h264.h"
+ #include "internal.h"
++#include "profiles.h"
+ 
+ #ifdef OMX_SKIP64BIT
+ static OMX_TICKS to_omx_ticks(int64_t value)
+@@ -494,6 +495,8 @@
+         out_port_params.format.video.eCompressionFormat = OMX_VIDEO_CodingMPEG4;
+     else if (avctx->codec->id == AV_CODEC_ID_H264)
+         out_port_params.format.video.eCompressionFormat = OMX_VIDEO_CodingAVC;
++    else if (avctx->codec->id == AV_CODEC_ID_HEVC)
++        out_port_params.format.video.eCompressionFormat = OMX_VIDEO_CodingHEVC;
+ 
+     err = OMX_SetParameter(s->handle, OMX_IndexParamPortDefinition, &out_port_params);
+     CHECK(err);
+@@ -627,6 +630,9 @@
+     case AV_CODEC_ID_H264:
+         role = "video_decoder.avc";
+         break;
++    case AV_CODEC_ID_HEVC:
++		role = "video_decoder.hevc";
++		break;
+     default:
+         return AVERROR(ENOSYS);
+     }
+@@ -733,7 +739,7 @@
+ 			buffer->nFilledLen = pkt->size;
+ 		}
+ 
+-		/* reduce memcpy. point it addr*/
++		/* avoid memcpy. point it addr*/
+ 		//buffer->pAppPrivate = pkt;
+ 		//buffer->pBuffer = pkt->data;
+ 		//buffer->nFilledLen = pkt->size;
+@@ -851,6 +857,12 @@
+     { NULL }
+ };
+ 
++static const AVOption options_hevc[] = {
++    { "omx_libname", "OpenMAX library name", OFFSET(libname), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VDE },
++    { "omx_libprefix", "OpenMAX library prefix", OFFSET(libprefix), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VDE },
++    { "zerocopy", "Try to avoid copying input frames if possible", OFFSET(input_zerocopy), AV_OPT_TYPE_INT, { .i64 = CONFIG_OMX_RPI }, 0, 1, VE },
++	{ NULL },
++};
+ 
+ static const AVClass omx_mpeg4dec_class = {
+     .class_name = "mpeg4_omx",
+@@ -891,3 +903,24 @@
+     .caps_internal    = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
+     .priv_class       = &omx_h264dec_class,
+ };
++
++static const AVClass omx_hevcdec_class = {
++    .class_name = "hevc_omx",
++    .item_name  = av_default_item_name,
++    .option     = options_hevc,
++    .version    = LIBAVUTIL_VERSION_INT,
++};
++AVCodec ff_hevc_omx_decoder = {
++    .name             = "hevc_omx",
++    .long_name        = NULL_IF_CONFIG_SMALL("OpenMAX IL HEVC video decoder"),
++    .type             = AVMEDIA_TYPE_VIDEO,
++    .id               = AV_CODEC_ID_HEVC,
++    .priv_data_size   = sizeof(OMXCodecContext),
++    .init             = omx_decode_init,
++    .decode           = omx_decode_frame,
++    .close            = omx_decode_end,
++    .profiles         = NULL_IF_CONFIG_SMALL(ff_hevc_profiles),
++    .capabilities     = AV_CODEC_CAP_DELAY,
++    .caps_internal    = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
++    .priv_class       = &omx_hevcdec_class,
++};
+--- a/libavformat/demux.c
++++ b/libavformat/demux.c
+@@ -77,6 +77,13 @@
+         return avcodec_find_decoder_by_name("h264");
+ #endif
+ 
++#if CONFIG_HEVC_DECODER
++	/* Other parts of the code assume this decoder to be used for h265,
++	 * so force it if possible. */
++	if (codec_id == AV_CODEC_ID_HEVC)
++		return avcodec_find_decoder_by_name("hevc");
++#endif
++
+     codec = ff_find_decoder(s, st, codec_id);
+     if (!codec)
+         return NULL;

+ 307 - 0
recipes-multimedia/ffmpeg/ffmpeg/0007-avcoder-fix-decoder-bug.patch

@@ -0,0 +1,307 @@
+From 9ca5512fde8d237977b102e240c957e7506a276a Mon Sep 17 00:00:00 2001
+From: "sw.multimedia" <se.multimedia@starfivetech.com>
+Date: Wed, 25 May 2022 20:52:37 +0800
+Subject: [PATCH 5/8] avcoder fix decoder bug
+
+Signed-off-by: sw.multimedia <se.multimedia@starfivetech.com>
+---
+ libavcodec/omxdec.c | 182 +++++++++++++++++++++++++++-----------------
+ 1 file changed, 114 insertions(+), 68 deletions(-)
+
+diff --git a/libavcodec/omxdec.c b/libavcodec/omxdec.c
+index 96a2829..9eb5dca 100644
+--- a/libavcodec/omxdec.c
++++ b/libavcodec/omxdec.c
+@@ -46,6 +46,11 @@
+ #include "internal.h"
+ #include "profiles.h"
+ 
++int evnet_bufferflag;
++int dec_out_height;
++int dec_out_width;
++int dec_pix_fmt;
++
+ #ifdef OMX_SKIP64BIT
+ static OMX_TICKS to_omx_ticks(int64_t value)
+ {
+@@ -223,7 +228,7 @@ typedef struct OMXCodecContext {
+ 
+     int mutex_cond_inited;
+ 
+-    int eos_sent, got_eos, first_get_outbuffer;
++    int eos_sent, got_eos, evnet_bufferflag;
+ 
+ 	int extradata_sent;
+ 
+@@ -274,6 +279,11 @@ static OMX_ERRORTYPE event_handler(OMX_HANDLETYPE component, OMX_PTR app_data, O
+     // This uses casts in the printfs, since OMX_U32 actually is a typedef for
+     // unsigned long in official header versions (but there are also modified
+     // versions where it is something else).
++    OMX_PARAM_PORTDEFINITIONTYPE out_port_params = { 0 };
++	OMX_PORT_PARAM_TYPE video_port_params = { 0 };
++	OMX_ERRORTYPE err;
++	int i;
++
+     switch (event) {
+     case OMX_EventError:
+         pthread_mutex_lock(&s->state_mutex);
+@@ -299,8 +309,36 @@ static OMX_ERRORTYPE event_handler(OMX_HANDLETYPE component, OMX_PTR app_data, O
+         }
+         break;
+     case OMX_EventPortSettingsChanged:
+-        av_log(s->avctx, AV_LOG_VERBOSE, "OMX port %"PRIu32" settings changed\n", (uint32_t) data1);
++        av_log(s->avctx, AV_LOG_ERROR, "OMX port %"PRIu32" settings changed\n", (uint32_t) data1);
++		INIT_STRUCT(video_port_params);
++		err = OMX_GetParameter(s->handle, OMX_IndexParamVideoInit, &video_port_params);
++		if(err != OMX_ErrorNone){
++            av_log(s->avctx, AV_LOG_ERROR, "err %d\n",err);          
++            return AVERROR_UNKNOWN;
++			}
++
++		for (i = 0; i < video_port_params.nPorts; i++) {
++	        int port = video_port_params.nStartPortNumber + i;
++	        OMX_PARAM_PORTDEFINITIONTYPE port_params = { 0 };
++	        INIT_STRUCT(port_params);
++	        port_params.nPortIndex = port;
++	        err = OMX_GetParameter(s->handle, OMX_IndexParamPortDefinition, &port_params);
++	        if (err != OMX_ErrorNone) {
++	            av_log(s->avctx, AV_LOG_WARNING, "port %d error %x\n", port, err);
++            return AVERROR_UNKNOWN;
++	        }
++	        if (port_params.eDir == OMX_DirOutput) {
++				out_port_params = port_params;
++				dec_out_width = out_port_params.format.video.nFrameWidth;
++				dec_out_height = out_port_params.format.video.nFrameHeight;
++				dec_pix_fmt = out_port_params.format.video.eColorFormat;
++	            
++	        } 
++	    }		
+         break;
++	case OMX_EventBufferFlag:
++		av_log(s->avctx, AV_LOG_VERBOSE, "OMX decoder competd set event_bufferflag\n");
++		evnet_bufferflag = 1;
+     default:
+         av_log(s->avctx, AV_LOG_VERBOSE, "OMX event %d %"PRIx32" %"PRIx32"\n",
+                                          event, (uint32_t) data1, (uint32_t) data2);
+@@ -453,7 +491,7 @@ static av_cold int omx_component_init(AVCodecContext *avctx, const char *role)
+ 
+     in_port_params.format.video.pNativeRender         = NULL;
+     in_port_params.format.video.bFlagErrorConcealment = OMX_FALSE;
+-    //in_port_params.format.video.eColorFormat          = s->color_format;
++    in_port_params.format.video.eColorFormat          = s->color_format;
+     s->stride     = avctx->width;
+     s->plane_size = avctx->height;
+     // If specific codecs need to manually override the stride/plane_size,
+@@ -473,11 +511,10 @@ static av_cold int omx_component_init(AVCodecContext *avctx, const char *role)
+     err = OMX_GetParameter(s->handle, OMX_IndexParamPortDefinition, &in_port_params);
+     CHECK(err);
+ 
+-#if 1
+     s->stride         = in_port_params.format.video.nStride;
+     s->plane_size     = in_port_params.format.video.nSliceHeight;
+     s->num_in_buffers = in_port_params.nBufferCountActual;
+-#endif
++
+     err = OMX_GetParameter(s->handle, OMX_IndexParamPortDefinition, &out_port_params);
+     out_port_params.bEnabled   = OMX_TRUE;
+     out_port_params.bPopulated = OMX_FALSE;
+@@ -645,51 +682,51 @@ static av_cold int omx_decode_init(AVCodecContext *avctx)
+     if ((ret = omx_component_init(avctx, role)) < 0)
+         goto fail;
+ 
+-#if 0
+-    if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
+-        while (1) {
+-            buffer = get_buffer(&s->output_mutex, &s->output_cond,
+-                                &s->num_done_out_buffers, s->done_out_buffers, 1);
+-            if (buffer->nFlags & OMX_BUFFERFLAG_CODECCONFIG) {
+-                if ((ret = av_reallocp(&avctx->extradata, avctx->extradata_size + buffer->nFilledLen + AV_INPUT_BUFFER_PADDING_SIZE)) < 0) {
+-                    avctx->extradata_size = 0;
+-                    goto fail;
+-                }
+-                memcpy(avctx->extradata + avctx->extradata_size, buffer->pBuffer + buffer->nOffset, buffer->nFilledLen);
+-                avctx->extradata_size += buffer->nFilledLen;
+-                memset(avctx->extradata + avctx->extradata_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
+-            }
+-            err = OMX_FillThisBuffer(s->handle, buffer);
+-            if (err != OMX_ErrorNone) {
+-                append_buffer(&s->output_mutex, &s->output_cond,
+-                              &s->num_done_out_buffers, s->done_out_buffers, buffer);
+-                av_log(avctx, AV_LOG_ERROR, "OMX_FillThisBuffer failed: %x\n", err);
+-                ret = AVERROR_UNKNOWN;
+-                goto fail;
+-            }
+-            if (avctx->codec->id == AV_CODEC_ID_H264) {
+-                // For H.264, the extradata can be returned in two separate buffers
+-                // (the videocore encoder on raspberry pi does this);
+-                // therefore check that we have got both SPS and PPS before continuing.
+-                int nals[32] = { 0 };
+-                int i;
+-                for (i = 0; i + 4 < avctx->extradata_size; i++) {
+-                     if (!avctx->extradata[i + 0] &&
+-                         !avctx->extradata[i + 1] &&
+-                         !avctx->extradata[i + 2] &&
+-                         avctx->extradata[i + 3] == 1) {
+-                         nals[avctx->extradata[i + 4] & 0x1f]++;
+-                     }
+-                }
+-                if (nals[H264_NAL_SPS] && nals[H264_NAL_PPS])
+-                    break;
+-            } else {
+-                if (avctx->extradata_size > 0)
+-                    break;
+-            }
+-        }
+-    }
+-#endif
++// #if 0
++//     if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
++//         while (1) {
++//             buffer = get_buffer(&s->output_mutex, &s->output_cond,
++//                                 &s->num_done_out_buffers, s->done_out_buffers, 1);
++//             if (buffer->nFlags & OMX_BUFFERFLAG_CODECCONFIG) {
++//                 if ((ret = av_reallocp(&avctx->extradata, avctx->extradata_size + buffer->nFilledLen + AV_INPUT_BUFFER_PADDING_SIZE)) < 0) {
++//                     avctx->extradata_size = 0;
++//                     goto fail;
++//                 }
++//                 memcpy(avctx->extradata + avctx->extradata_size, buffer->pBuffer + buffer->nOffset, buffer->nFilledLen);
++//                 avctx->extradata_size += buffer->nFilledLen;
++//                 memset(avctx->extradata + avctx->extradata_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
++//             }
++//             err = OMX_FillThisBuffer(s->handle, buffer);
++//             if (err != OMX_ErrorNone) {
++//                 append_buffer(&s->output_mutex, &s->output_cond,
++//                               &s->num_done_out_buffers, s->done_out_buffers, buffer);
++//                 av_log(avctx, AV_LOG_ERROR, "OMX_FillThisBuffer failed: %x\n", err);
++//                 ret = AVERROR_UNKNOWN;
++//                 goto fail;
++//             }
++//             if (avctx->codec->id == AV_CODEC_ID_H264) {
++//                 // For H.264, the extradata can be returned in two separate buffers
++//                 // (the videocore encoder on raspberry pi does this);
++//                 // therefore check that we have got both SPS and PPS before continuing.
++//                 int nals[32] = { 0 };
++//                 int i;
++//                 for (i = 0; i + 4 < avctx->extradata_size; i++) {
++//                      if (!avctx->extradata[i + 0] &&
++//                          !avctx->extradata[i + 1] &&
++//                          !avctx->extradata[i + 2] &&
++//                          avctx->extradata[i + 3] == 1) {
++//                          nals[avctx->extradata[i + 4] & 0x1f]++;
++//                      }
++//                 }
++//                 if (nals[H264_NAL_SPS] && nals[H264_NAL_PPS])
++//                     break;
++//             } else {
++//                 if (avctx->extradata_size > 0)
++//                     break;
++//             }
++//         }
++//     }
++// #endif
+ 	
+     return 0;
+ fail:
+@@ -712,10 +749,6 @@ static int omx_decode_frame(AVCodecContext *avctx, void *data,
+ 	int linesize[4];
+ 
+     if (pkt->size) {
+-
+-		//VPU init and fill buffer slow, so empty buf sleep to send before get vpu fill buf.
+-		if(!s->first_get_outbuffer)
+-			av_usleep(100000);
+ 	
+         buffer = get_buffer(&s->input_mutex, &s->input_cond,
+                             &s->num_free_in_buffers, s->free_in_buffers, 1);
+@@ -726,7 +759,7 @@ static int omx_decode_frame(AVCodecContext *avctx, void *data,
+         }
+ 
+ 		//cpy the extradata
+-		if(!s->extradata_sent) {
++		if(!s->extradata_sent && avctx->extradata ) {
+ 
+ 			memcpy(buffer->pBuffer + buffer->nOffset, avctx->extradata, avctx->extradata_size);	
+ 			memcpy(buffer->pBuffer + buffer->nOffset + avctx->extradata_size, pkt->data, pkt->size);
+@@ -746,6 +779,7 @@ static int omx_decode_frame(AVCodecContext *avctx, void *data,
+ 		
+ 		buffer->pOutputPortPrivate = NULL;
+ 		buffer->pAppPrivate = avctx->priv_data;
++        buffer->nFlags = OMX_BUFFERFLAG_ENDOFFRAME;
+ 
+ 	    err = OMX_EmptyThisBuffer(s->handle, buffer);
+ 	    if (err != OMX_ErrorNone) {
+@@ -754,16 +788,19 @@ static int omx_decode_frame(AVCodecContext *avctx, void *data,
+ 	        return AVERROR_UNKNOWN;
+ 	    }
+     } else if (!s->eos_sent) {
+-
+-		if(!s->first_get_outbuffer)
+-			av_usleep(1000000);
+ 		
+         buffer = get_buffer(&s->input_mutex, &s->input_cond,
+                             &s->num_free_in_buffers, s->free_in_buffers, 1);
+ 
++        if(!buffer) {
++        	av_log(avctx, AV_LOG_ERROR, "get_buffer NULL\n");
++            return AVERROR(ENOMEM);
++		}
++
+         buffer->nFilledLen = 0;
+         buffer->nFlags = OMX_BUFFERFLAG_EOS;
+         buffer->pAppPrivate = buffer->pOutputPortPrivate = NULL;
++        
+         err = OMX_EmptyThisBuffer(s->handle, buffer);
+         if (err != OMX_ErrorNone) {
+             append_buffer(&s->input_mutex, &s->input_cond, &s->num_free_in_buffers, s->free_in_buffers, buffer);
+@@ -782,20 +819,26 @@ static int omx_decode_frame(AVCodecContext *avctx, void *data,
+                             !pkt || had_partial);
+ 
+         if (!buffer) {
+-            /*eos is sent but fill buf still can't get then continue*/
+-            if(!s->first_get_outbuffer && s->eos_sent)
++            /*eos is sent wait for vpu evnet_bufferflag to get all frames*/
+++           if(s->eos_sent && !evnet_bufferflag){}
+ 				continue; 
+-			else
++            }
+ 				break;
+         }
+ 		//if (!buffer)
+            // break;
+ 
+-		if(!buffer->nFilledLen)
+-			goto end;
+-		
+-		if(!s->first_get_outbuffer)
+-			s->first_get_outbuffer = 1;
++		if(!buffer->nFilledLen){
++            av_log(avctx, AV_LOG_ERROR, "buffer->nFilledLen %d\n",(int)buffer->nFilledLen);
++            goto end;
++        }
++
++        avctx->width = dec_out_width;
++		avctx->height = dec_out_height;
++		avctx->pix_fmt = AV_PIX_FMT_YUV420P;
++		s->stride     = avctx->width;
++    	s->plane_size = avctx->height;
++		//avctx->pix_fmt = dec_pix_fmt;
+ 		
+         if (buffer->nFlags & OMX_BUFFERFLAG_EOS)
+             s->got_eos = 1;
+@@ -807,8 +850,11 @@ static int omx_decode_frame(AVCodecContext *avctx, void *data,
+ 		
+ 		ret = av_image_fill_arrays(dst, linesize, buffer->pBuffer,
+ 								   avctx->pix_fmt, s->stride, s->plane_size, 1);
+-		if (ret < 0)
+-			goto end;
++		if (ret < 0){
++            av_log(avctx, AV_LOG_ERROR, "av_image_fill_arrays ret:%d\n", ret);
++            goto end;
++        }
++
+ 		av_image_copy(avframe->data, avframe->linesize, (const uint8_t**)dst, linesize, 
+ 							avctx->pix_fmt, avctx->width, avctx->height);
+ 	
+-- 
+2.17.1
+

+ 83 - 0
recipes-multimedia/ffmpeg/ffmpeg/0008-fix-omx-decoder-setting-pix-fmt-bug.patch

@@ -0,0 +1,83 @@
+From 39a500044fe9216453960529ae9320fda2ef73e4 Mon Sep 17 00:00:00 2001
+From: "sw.multimedia" <se.multimedia@starfivetech.com>
+Date: Wed, 25 May 2022 20:58:57 +0800
+Subject: [PATCH 6/8] fix omx decoder setting pix-fmt bug
+
+Signed-off-by: sw.multimedia <se.multimedia@starfivetech.com>
+---
+ libavcodec/omxdec.c | 36 ++++++++++++++++++++++++++++++++++--
+ 1 file changed, 34 insertions(+), 2 deletions(-)
+
+diff --git a/libavcodec/omxdec.c b/libavcodec/omxdec.c
+index 9eb5dca..8d00b86 100644
+--- a/libavcodec/omxdec.c
++++ b/libavcodec/omxdec.c
+@@ -28,6 +28,7 @@
+ #include <dlfcn.h>
+ #include <OMX_Core.h>
+ #include <OMX_Component.h>
++#include <OMX_IVCommon.h>
+ #include <pthread.h>
+ #include <stdio.h>
+ #include <stdlib.h>
+@@ -80,6 +81,8 @@ static int64_t from_omx_ticks(OMX_TICKS value)
+         }                                                                 \
+     } while (0)
+ 
++#define FF_ARRAY_ELEMS(a) (sizeof(a) / sizeof((a)[0]))
++
+ typedef struct OMXContext {
+     void *lib;
+     void *lib2;
+@@ -93,6 +96,36 @@ typedef struct OMXContext {
+     void (*host_init)(void);
+ } OMXContext;
+ 
++static const struct {
++
++    int color_format;
++    enum AVPixelFormat pix_fmt;
++
++} color_formats[] = {
++
++    { OMX_COLOR_FormatYUV420Planar,                           AV_PIX_FMT_YUV420P },
++    { OMX_COLOR_FormatYUV420SemiPlanar,                       AV_PIX_FMT_NV12    },
++    { OMX_COLOR_FormatYUV420PackedSemiPlanar,                 AV_PIX_FMT_NV21    },
++    { 0 }
++};
++
++static enum AVPixelFormat omx_map_color_format(AVCodecContext *avctx, int color_format)
++{
++    int i;
++    enum AVPixelFormat ret = AV_PIX_FMT_NONE;
++
++    for (i = 0; i < FF_ARRAY_ELEMS(color_formats); i++) {
++        if (color_formats[i].color_format == color_format) {
++            return color_formats[i].pix_fmt;
++        }
++    }
++
++    av_log(avctx, AV_LOG_ERROR, "Output color format 0x%x (value=%d) is not supported\n",
++        color_format, color_format);
++
++    return ret;
++}
++
+ static av_cold void *dlsym_prefixed(void *handle, const char *symbol, const char *prefix)
+ {
+     char buf[50];
+@@ -835,10 +868,9 @@ static int omx_decode_frame(AVCodecContext *avctx, void *data,
+ 
+         avctx->width = dec_out_width;
+ 		avctx->height = dec_out_height;
+-		avctx->pix_fmt = AV_PIX_FMT_YUV420P;
++        avctx->pix_fmt = omx_map_color_format(avctx, dec_pix_fmt);
+ 		s->stride     = avctx->width;
+     	s->plane_size = avctx->height;
+-		//avctx->pix_fmt = dec_pix_fmt;
+ 		
+         if (buffer->nFlags & OMX_BUFFERFLAG_EOS)
+             s->got_eos = 1;
+-- 
+2.17.1
+

+ 209 - 0
recipes-multimedia/ffmpeg/ffmpeg/0009-ffmpeg-add-mjpeg-decoder-support-and-fix-some-bug.patch

@@ -0,0 +1,209 @@
+From fff5724489cd0a503d206c6f513b1d8572247484 Mon Sep 17 00:00:00 2001
+From: "sw.multimedia" <se.multimedia@starfivetech.com>
+Date: Wed, 25 May 2022 21:28:23 +0800
+Subject: [PATCH] ffmpeg: add mjpeg decoder support and fix some bug
+
+Signed-off-by: sw.multimedia <se.multimedia@starfivetech.com>
+---
+ configure              |  1 +
+ libavcodec/allcodecs.c |  1 +
+ libavcodec/omx.c       | 25 +++++++++++++++++++++---
+ libavcodec/omxdec.c    | 44 +++++++++++++++++++++++++++++++++++++-----
+ libavformat/utils.c    |  7 +++++++
+ 5 files changed, 70 insertions(+), 8 deletions(-)
+
+--- a/configure
++++ b/configure
+@@ -3187,6 +3187,7 @@
+ h264_v4l2m2m_encoder_deps="v4l2_m2m h264_v4l2_m2m"
+ hevc_omx_encoder_deps="omx"
+ hevc_omx_decoder_deps="omx"
++mjpeg_omx_decoder_deps="omx"
+ hevc_amf_encoder_deps="amf"
+ hevc_cuvid_decoder_deps="cuvid"
+ hevc_cuvid_decoder_select="hevc_mp4toannexb_bsf"
+--- a/libavcodec/allcodecs.c
++++ b/libavcodec/allcodecs.c
+@@ -827,6 +827,7 @@
+ extern const FFCodec ff_hevc_omx_encoder;
+ extern const FFCodec ff_hevc_omx_decoder;
+ extern const FFCodec ff_h264_qsv_encoder;
++extern const FFCodec ff_mjpeg_omx_decoder;
+ extern const FFCodec ff_h264_v4l2m2m_encoder;
+ extern const FFCodec ff_h264_vaapi_encoder;
+ extern const FFCodec ff_h264_videotoolbox_encoder;
+--- a/libavcodec/omx.c
++++ b/libavcodec/omx.c
+@@ -43,6 +43,7 @@
+ #include "avcodec.h"
+ #include "codec_internal.h"
+ #include "h264.h"
++#include "hevc.h"
+ #include "pthread_internal.h"
+ #include "profiles.h"
+  
+@@ -481,9 +482,11 @@
+     in_port_params.format.video.nFrameWidth  = avctx->width;
+     in_port_params.format.video.nFrameHeight = avctx->height;
+     if (avctx->framerate.den > 0 && avctx->framerate.num > 0)
+-        in_port_params.format.video.xFramerate = (1LL << 16) * avctx->framerate.num / avctx->framerate.den;
++        //in_port_params.format.video.xFramerate = (1LL << 16) * avctx->framerate.num / avctx->framerate.den;
++        in_port_params.format.video.xFramerate = avctx->framerate.num / avctx->framerate.den;
+     else
+-        in_port_params.format.video.xFramerate = (1LL << 16) * avctx->time_base.den / avctx->time_base.num;
++        //in_port_params.format.video.xFramerate = (1LL << 16) * avctx->time_base.den / avctx->time_base.num;
++        in_port_params.format.video.xFramerate = avctx->time_base.den / avctx->time_base.num;
+ 
+     err = OMX_SetParameter(s->handle, OMX_IndexParamPortDefinition, &in_port_params);
+     CHECK(err);
+@@ -721,7 +724,23 @@
+                 }
+                 if (nals[H264_NAL_SPS] && nals[H264_NAL_PPS])
+                     break;
+-            } else {
++            } else if (avctx->codec->id == AV_CODEC_ID_HEVC) {
++                // For H.265, the extradata can be returned in two separate buffers
++                // (the videocore encoder on raspberry pi does this);
++                // therefore check that we have got both SPS and PPS before continuing.
++                int nals[128] = { 0 };
++                int i;
++                for (i = 0; i + 4 < avctx->extradata_size; i++) {
++                     if (!avctx->extradata[i + 0] &&
++                         !avctx->extradata[i + 1] &&
++                         !avctx->extradata[i + 2] &&
++                         avctx->extradata[i + 3] == 1) {
++                         nals[(avctx->extradata[i + 4] & 0x7E) >> 1]++;
++                     }
++                }
++                if (nals[HEVC_NAL_SPS] && nals[HEVC_NAL_PPS] && nals[HEVC_NAL_VPS])
++                    break;
++		} else {
+                 if (avctx->extradata_size > 0)
+                     break;
+             }
+--- a/libavcodec/omxdec.c
++++ b/libavcodec/omxdec.c
+@@ -106,6 +106,7 @@
+     { OMX_COLOR_FormatYUV420Planar,                           AV_PIX_FMT_YUV420P },
+     { OMX_COLOR_FormatYUV420SemiPlanar,                       AV_PIX_FMT_NV12    },
+     { OMX_COLOR_FormatYUV420PackedSemiPlanar,                 AV_PIX_FMT_NV21    },
++    { OMX_COLOR_FormatYUV444Interleaved,                      AV_PIX_FMT_YUV444P },
+     { 0 }
+ };
+ 
+@@ -366,6 +367,7 @@
+ 				dec_out_height = out_port_params.format.video.nFrameHeight;
+ 				dec_pix_fmt = out_port_params.format.video.eColorFormat;
+ 	            
++                av_log(s->avctx, AV_LOG_VERBOSE, "w:%d, h:%d, fmt:%d\n", dec_out_width, dec_out_height, dec_pix_fmt); 
+ 	        } 
+ 	    }		
+         break;
+@@ -535,9 +537,11 @@
+     in_port_params.format.video.nFrameHeight = avctx->height;
+ 
+     if (avctx->framerate.den > 0 && avctx->framerate.num > 0)
+-        in_port_params.format.video.xFramerate = (1LL << 16) * avctx->framerate.num / avctx->framerate.den;
++        //in_port_params.format.video.xFramerate = (1LL << 16) * avctx->framerate.num / avctx->framerate.den;
++        in_port_params.format.video.xFramerate = avctx->framerate.num / avctx->framerate.den;
+     else
+-        in_port_params.format.video.xFramerate = (1LL << 16) * avctx->time_base.den / avctx->time_base.num;
++        //in_port_params.format.video.xFramerate = (1LL << 16) * avctx->time_base.den / avctx->time_base.num;
++        in_port_params.format.video.xFramerate = avctx->time_base.den / avctx->time_base.num;
+ 
+     err = OMX_SetParameter(s->handle, OMX_IndexParamPortDefinition, &in_port_params);
+     CHECK(err);
+@@ -567,6 +571,8 @@
+         out_port_params.format.video.eCompressionFormat = OMX_VIDEO_CodingAVC;
+     else if (avctx->codec->id == AV_CODEC_ID_HEVC)
+         out_port_params.format.video.eCompressionFormat = OMX_VIDEO_CodingHEVC;
++    else if (avctx->codec->id == AV_CODEC_ID_MJPEG)
++        out_port_params.format.video.eCompressionFormat = OMX_VIDEO_CodingMJPEG;
+ 
+     err = OMX_SetParameter(s->handle, OMX_IndexParamPortDefinition, &out_port_params);
+     CHECK(err);
+@@ -703,6 +709,9 @@
+     case AV_CODEC_ID_HEVC:
+ 		role = "video_decoder.hevc";
+ 		break;
++    case AV_CODEC_ID_MJPEG:
++		role = "video_decoder.mjpeg";
++		break;
+     default:
+         return AVERROR(ENOSYS);
+     }
+@@ -852,11 +861,13 @@
+                             !pkt || had_partial);
+ 
+         if (!buffer) {
+-            /*eos is sent wait for vpu evnet_bufferflag to get all frames*/
+-+           if(s->eos_sent && !evnet_bufferflag){}
++            /*eos is sent wait for vpu evnet_bufferflag to get all frames
++			  mjpeg: sent a frame, then wait for a decoder frame 
++			*/
++            if((s->eos_sent && !evnet_bufferflag) || (avctx->codec_id == AV_CODEC_ID_MJPEG )) {
+ 				continue; 
+             }
+-				break;
++            break;
+         }
+ 		//if (!buffer)
+            // break;
+@@ -924,6 +935,7 @@
+ #define OFFSET(x) offsetof(OMXCodecContext, x)
+ #define VDE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM
+ #define VE  AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
++#define VD  AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
+ static const AVOption options[] = {
+     { "omx_libname", "OpenMAX library name", OFFSET(libname), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VDE },
+     { "omx_libprefix", "OpenMAX library prefix", OFFSET(libprefix), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VDE },
+@@ -980,6 +992,7 @@
+     .capabilities     = AV_CODEC_CAP_DELAY,
+     .caps_internal    = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
+     .priv_class       = &omx_h264dec_class,
++    .bsfs             = "h264_mp4toannexb",
+ };
+ 
+ static const AVClass omx_hevcdec_class = {
+@@ -1001,4 +1014,25 @@
+     .capabilities     = AV_CODEC_CAP_DELAY,
+     .caps_internal    = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
+     .priv_class       = &omx_hevcdec_class,
++    .bsfs             = "hevc_mp4toannexb",
++};
++
++static const AVClass omx_mjpegdec_class = {
++    .class_name = "mjpeg_omx",
++    .item_name  = av_default_item_name,
++    .version    = LIBAVUTIL_VERSION_INT,
++};
++AVCodec ff_mjpeg_omx_decoder = {
++    .name             = "mjpeg_omx",
++    .long_name        = NULL_IF_CONFIG_SMALL("OpenMAX IL mjpeg video decoder"),
++    .type             = AVMEDIA_TYPE_VIDEO,
++    .id               = AV_CODEC_ID_MJPEG,
++    .priv_data_size   = sizeof(OMXCodecContext),
++    .init             = omx_decode_init,
++    .decode           = omx_decode_frame,
++    .close            = omx_decode_end,
++	.capabilities	  = AV_CODEC_CAP_DR1,
++	.max_lowres 	  = 3,
++	.caps_internal	  = FF_CODEC_CAP_INIT_THREADSAFE,
++    .priv_class       = &omx_mjpegdec_class,
+ };
+--- a/libavformat/demux.c
++++ b/libavformat/demux.c
+@@ -84,6 +84,13 @@
+ 		return avcodec_find_decoder_by_name("hevc");
+ #endif
+ 
++#if CONFIG_MJPEG_DECODER
++		/* Other parts of the code assume this decoder to be used for mjpeg,
++		 * so force it if possible. */
++		if (codec_id == AV_CODEC_ID_MJPEG)
++			return avcodec_find_decoder_by_name("mjpeg");
++#endif
++
+     codec = ff_find_decoder(s, st, codec_id);
+     if (!codec)
+         return NULL;

+ 48 - 0
recipes-multimedia/ffmpeg/ffmpeg/0010-ffmpeg-support-to-change-gop.patch

@@ -0,0 +1,48 @@
+From 8b976d184eb1ded7a0635582a4e1b1c619852ed8 Mon Sep 17 00:00:00 2001
+From: "arvin.zhu" <arvin.zhu@starfivetech.com>
+Date: Thu, 22 Sep 2022 18:56:28 +0800
+Subject: [PATCH] ffmpeg: support to change gop
+
+support to change gop of hevc for omc encoder
+
+Signed-off-by: arvin.zhu <arvin.zhu@starfivetech.com>
+---
+ libavcodec/omx.c | 12 ++++++++++++
+ 1 file changed, 12 insertions(+)
+ mode change 100644 => 100755 libavcodec/omx.c
+
+diff --git a/libavcodec/omx.c b/libavcodec/omx.c
+old mode 100644
+new mode 100755
+index 84b0835..1d121af
+--- a/libavcodec/omx.c
++++ b/libavcodec/omx.c
+@@ -28,6 +28,8 @@
+ #include <dlfcn.h>
+ #include <OMX_Core.h>
+ #include <OMX_Component.h>
++#include <OMX_IndexExt.h>
++#include <OMX_VideoExt.h>
+ #include <pthread.h>
+ #include <stdio.h>
+ #include <stdlib.h>
+@@ -545,6 +547,16 @@ static av_cold int omx_component_init(AVCodecContext *avctx, const char *role)
+         }
+         err = OMX_SetParameter(s->handle, OMX_IndexParamVideoAvc, &avc);
+         CHECK(err);
++    } else if (avctx->codec->id == AV_CODEC_ID_HEVC) {
++        OMX_VIDEO_PARAM_AVCTYPE hevc = { 0 };
++        INIT_STRUCT(hevc);
++        hevc.nPortIndex = s->out_port;
++        err = OMX_GetParameter(s->handle, OMX_IndexParamVideoHevc, &hevc);
++        CHECK(err);
++        hevc.nBFrames = 0;
++        hevc.nPFrames = avctx->gop_size;
++        err = OMX_SetParameter(s->handle, OMX_IndexParamVideoHevc, &hevc);
++        CHECK(err);
+     }
+ 
+     err = OMX_SendCommand(s->handle, OMX_CommandStateSet, OMX_StateIdle, NULL);
+-- 
+2.17.1
+

+ 59 - 0
recipes-multimedia/ffmpeg/ffmpeg/0011-ffmpeg-add-delay-for-decoding.patch

@@ -0,0 +1,59 @@
+From f7401faa595d8cd70392c73ce9578ed1e83ed81b Mon Sep 17 00:00:00 2001
+From: "arvin.zhu" <arvin.zhu@starfivetech.com>
+Date: Thu, 22 Sep 2022 19:06:50 +0800
+Subject: [PATCH] ffmpeg: add delay for decoding
+
+add delay for decoding
+
+Signed-off-by: arvin.zhu <arvin.zhu@starfivetech.com>
+---
+ libavcodec/omxdec.c | 9 ++++++++-
+ 1 file changed, 8 insertions(+), 1 deletion(-)
+ mode change 100644 => 100755 libavcodec/omxdec.c
+
+diff --git a/libavcodec/omxdec.c b/libavcodec/omxdec.c
+old mode 100644
+new mode 100755
+index 32f39f3..03a2bca
+--- a/libavcodec/omxdec.c
++++ b/libavcodec/omxdec.c
+@@ -262,7 +262,7 @@ typedef struct OMXCodecContext {
+ 
+     int mutex_cond_inited;
+ 
+-    int eos_sent, got_eos, evnet_bufferflag;
++    int eos_sent, got_eos, evnet_bufferflag, first_get_outbuffer;
+ 
+ 	int extradata_sent;
+ 
+@@ -792,6 +792,9 @@ static int omx_decode_frame(AVCodecContext *avctx, void *data,
+ 
+     if (pkt->size) {
+ 	
++        //VPU init and fill buffer slow, so empty buf sleep to send before get vpu fill buf.
++        if(!s->first_get_outbuffer)
++        av_usleep(100000);
+         buffer = get_buffer(&s->input_mutex, &s->input_cond,
+                             &s->num_free_in_buffers, s->free_in_buffers, 1);
+ 
+@@ -831,6 +834,8 @@ static int omx_decode_frame(AVCodecContext *avctx, void *data,
+ 	    }
+     } else if (!s->eos_sent) {
+ 		
++        if(!s->first_get_outbuffer)
++        av_usleep(1000000);
+         buffer = get_buffer(&s->input_mutex, &s->input_cond,
+                             &s->num_free_in_buffers, s->free_in_buffers, 1);
+ 
+@@ -871,6 +876,8 @@ static int omx_decode_frame(AVCodecContext *avctx, void *data,
+         }
+ 		//if (!buffer)
+            // break;
++        if(!s->first_get_outbuffer)
++            s->first_get_outbuffer = 1;
+ 
+ 		if(!buffer->nFilledLen){
+             av_log(avctx, AV_LOG_ERROR, "buffer->nFilledLen %d\n",(int)buffer->nFilledLen);
+-- 
+2.17.1
+

+ 120 - 0
recipes-multimedia/ffmpeg/ffmpeg/0012-ffmpeg-add-omx_pix_fmt.patch

@@ -0,0 +1,120 @@
+From c4fe39d5b2e35b7195ae3041adcb6ef786322dbb Mon Sep 17 00:00:00 2001
+From: "arvin.zhu" <arvin.zhu@starfivetech.com>
+Date: Fri, 23 Sep 2022 10:04:25 +0800
+Subject: [PATCH] ffmpeg: add omx_pix_fmt
+
+add omx_pix_fmt for mjpeg_omx decoder
+
+Signed-off-by: arvin.zhu <arvin.zhu@starfivetech.com>
+---
+ libavcodec/omxdec.c | 58 +++++++++++++++++++++++++++++++++++++++++----
+ 1 file changed, 54 insertions(+), 4 deletions(-)
+
+diff --git a/libavcodec/omxdec.c b/libavcodec/omxdec.c
+index 03a2bca..b489c09 100755
+--- a/libavcodec/omxdec.c
++++ b/libavcodec/omxdec.c
+@@ -105,8 +105,13 @@ static const struct {
+ 
+     { OMX_COLOR_FormatYUV420Planar,                           AV_PIX_FMT_YUV420P },
+     { OMX_COLOR_FormatYUV420SemiPlanar,                       AV_PIX_FMT_NV12    },
+-    { OMX_COLOR_FormatYUV420PackedSemiPlanar,                 AV_PIX_FMT_NV21    },
+-    { OMX_COLOR_FormatYUV444Interleaved,                      AV_PIX_FMT_YUV444P },
++    { OMX_COLOR_FormatYVU420SemiPlanar,                       AV_PIX_FMT_NV21    },
++    { OMX_COLOR_FormatYUV422SemiPlanar,                       AV_PIX_FMT_NV16    },
++    { OMX_COLOR_FormatYUV422Planar,                           AV_PIX_FMT_YUV422P },
++    { OMX_COLOR_FormatYCbYCr,                                 AV_PIX_FMT_YUYV422 },
++    { OMX_COLOR_FormatYCrYCb,                                 AV_PIX_FMT_YVYU422 },
++    { OMX_COLOR_FormatCbYCrY,                                 AV_PIX_FMT_UYVY422 },
++    { OMX_COLOR_FormatYUV444Planar,                           AV_PIX_FMT_YUV444P },
+     { 0 }
+ };
+ 
+@@ -271,6 +276,7 @@ typedef struct OMXCodecContext {
+ 
+     int input_zerocopy;
+     int profile;
++    char *pixel_format;     /**< Set by a private option. */
+ } OMXCodecContext;
+ 
+ static void append_buffer(pthread_mutex_t *mutex, pthread_cond_t *cond,
+@@ -571,9 +577,43 @@ static av_cold int omx_component_init(AVCodecContext *avctx, const char *role)
+         out_port_params.format.video.eCompressionFormat = OMX_VIDEO_CodingAVC;
+     else if (avctx->codec->id == AV_CODEC_ID_HEVC)
+         out_port_params.format.video.eCompressionFormat = OMX_VIDEO_CodingHEVC;
+-    else if (avctx->codec->id == AV_CODEC_ID_MJPEG)
++    else if (avctx->codec->id == AV_CODEC_ID_MJPEG){
+         out_port_params.format.video.eCompressionFormat = OMX_VIDEO_CodingMJPEG;
+ 
++        av_log(avctx, AV_LOG_VERBOSE, "OMX_pixel_format:%s\n", s->pixel_format);
++        switch (av_get_pix_fmt(s->pixel_format)) {
++        case AV_PIX_FMT_NV12:
++            out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
++            break;
++        case AV_PIX_FMT_NV21:
++            out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYVU420SemiPlanar;
++            break;
++        case AV_PIX_FMT_YUV420P:
++            out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYUV420Planar;
++            break;
++        case AV_PIX_FMT_NV16:
++            out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYUV422SemiPlanar;
++            break;
++        case AV_PIX_FMT_YUV422P:
++            out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYUV422Planar;
++            break;
++        case AV_PIX_FMT_YUYV422:
++            out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYCbYCr;
++            break;
++        case AV_PIX_FMT_YVYU422:
++            out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYCrYCb;
++            break;
++        case AV_PIX_FMT_UYVY422:
++            out_port_params.format.video.eColorFormat = OMX_COLOR_FormatCbYCrY;
++            break;
++        case AV_PIX_FMT_YUV444P:
++            out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYUV444Planar;
++            break;
++        default:
++            out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYUV420Planar;
++        }
++    }
++
+     err = OMX_SetParameter(s->handle, OMX_IndexParamPortDefinition, &out_port_params);
+     CHECK(err);
+     err = OMX_GetParameter(s->handle, OMX_IndexParamPortDefinition, &out_port_params);
+@@ -961,6 +1001,15 @@ static const AVOption options_hevc[] = {
+ 	{ NULL },
+ };
+ 
++static const AVOption options_mjpeg[] = {
++    { "omx_libname", "OpenMAX library name", OFFSET(libname), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VDE },
++    { "omx_libprefix", "OpenMAX library prefix", OFFSET(libprefix), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VDE },
++    { "zerocopy", "Try to avoid copying input frames if possible", OFFSET(input_zerocopy), AV_OPT_TYPE_INT, { .i64 = CONFIG_OMX_RPI }, 0, 1, VD },
++    { "omx_pix_fmt", "Set the decoding pixel format for mjpeg_omx decoder. The following formats are supported: yuv420p, nv12, nv21, nv16, yuv422p, yuyv422, yvyu422, uyvy422, yuv444p.", OFFSET(pixel_format), AV_OPT_TYPE_STRING, { .str = "yuv420p" }, 0, 0, VD },
++
++    { NULL },
++};
++
+ static const AVClass omx_mpeg4dec_class = {
+     .class_name = "mpeg4_omx",
+     .item_name  = av_default_item_name,
+@@ -1027,6 +1076,7 @@ AVCodec ff_hevc_omx_decoder = {
+ static const AVClass omx_mjpegdec_class = {
+     .class_name = "mjpeg_omx",
+     .item_name  = av_default_item_name,
++    .option     = options_mjpeg,
+     .version    = LIBAVUTIL_VERSION_INT,
+ };
+ AVCodec ff_mjpeg_omx_decoder = {
+@@ -1040,6 +1090,6 @@ AVCodec ff_mjpeg_omx_decoder = {
+     .close            = omx_decode_end,
+ 	.capabilities	  = AV_CODEC_CAP_DR1,
+ 	.max_lowres 	  = 3,
+-	.caps_internal	  = FF_CODEC_CAP_INIT_THREADSAFE,
++	.caps_internal	  = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
+     .priv_class       = &omx_mjpegdec_class,
+ };
+-- 
+2.17.1
+

+ 433 - 0
recipes-multimedia/ffmpeg/ffmpeg/0013-ffmpeg-replace-the-indent-with-space.patch

@@ -0,0 +1,433 @@
+From 1a2947195001880a05af0e225b6e93c6f2349123 Mon Sep 17 00:00:00 2001
+From: "arvin.zhu" <arvin.zhu@starfivetech.com>
+Date: Fri, 23 Sep 2022 10:17:00 +0800
+Subject: [PATCH] ffmpeg: replace the indent with space
+
+replace the indent with space
+
+Signed-off-by: arvin.zhu <arvin.zhu@starfivetech.com>
+---
+ libavcodec/omx.c    |  46 +++++-----
+ libavcodec/omxdec.c | 212 ++++++++++++++++++++++----------------------
+ 2 files changed, 129 insertions(+), 129 deletions(-)
+
+diff --git a/libavcodec/omx.c b/libavcodec/omx.c
+index 1d121af..1c4179f 100755
+--- a/libavcodec/omx.c
++++ b/libavcodec/omx.c
+@@ -1,6 +1,6 @@
+ /*
+- * OMX Video encoder
+- * Copyright (C) 2011 Martin Storsjo
++ * OMX Video decoder
++ * Copyright (C) 2018-2022 Starfive Technology
+  *
+  * This file is part of FFmpeg.
+  *
+@@ -685,8 +685,8 @@ static av_cold int omx_encode_init(AVCodecContext *avctx)
+         role = "video_encoder.avc";
+         break;
+     case AV_CODEC_ID_HEVC:
+-		role = "video_encoder.hevc";
+-		break;
++        role = "video_encoder.hevc";
++        break;
+     default:
+         return AVERROR(ENOSYS);
+     }
+@@ -752,7 +752,7 @@ static av_cold int omx_encode_init(AVCodecContext *avctx)
+                 }
+                 if (nals[HEVC_NAL_SPS] && nals[HEVC_NAL_PPS] && nals[HEVC_NAL_VPS])
+                     break;
+-		} else {
++        } else {
+                 if (avctx->extradata_size > 0)
+                     break;
+             }
+@@ -982,7 +982,7 @@ static const AVOption options_hevc[] = {
+     { "omx_libname", "OpenMAX library name", OFFSET(libname), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VDE },
+     { "omx_libprefix", "OpenMAX library prefix", OFFSET(libprefix), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VDE },
+     { "zerocopy", "Try to avoid copying input frames if possible", OFFSET(input_zerocopy), AV_OPT_TYPE_INT, { .i64 = CONFIG_OMX_RPI }, 0, 1, VE },
+-	{ NULL },
++    { NULL },
+ };
+ 
+ static const enum AVPixelFormat omx_encoder_pix_fmts[] = {
+@@ -1032,23 +1032,23 @@ AVCodec ff_h264_omx_encoder = {
+ };
+ 
+ static const AVClass omx_hevcenc_class = {
+-	.class_name = "hevc_omx",
+-	.item_name = av_default_item_name,
+-	.option = options_hevc,
+-	.version = LIBAVUTIL_VERSION_INT,
++    .class_name = "hevc_omx",
++    .item_name = av_default_item_name,
++    .option = options_hevc,
++    .version = LIBAVUTIL_VERSION_INT,
+ };
+ AVCodec ff_hevc_omx_encoder = {
+-	.name 			  = "hevc_omx",
+-	.long_name 		  = NULL_IF_CONFIG_SMALL("OpenMAX IL HEVC video encoder"),
+-	.type 			  = AVMEDIA_TYPE_VIDEO,
+-	.id 			  = AV_CODEC_ID_HEVC,
+-	.priv_data_size   = sizeof(OMXCodecContext),
+-	.init 			  = omx_encode_init,
+-	.encode2 		  = omx_encode_frame,
+-	.close 			  = omx_encode_end,
+-	.pix_fmts 		  = omx_encoder_pix_fmts,
+-	.profiles         = NULL_IF_CONFIG_SMALL(ff_hevc_profiles),
+-	.capabilities 	  = AV_CODEC_CAP_DELAY,
+-	.caps_internal 	  = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
+-	.priv_class 	  = &omx_hevcenc_class,
++    .name             = "hevc_omx",
++    .long_name        = NULL_IF_CONFIG_SMALL("OpenMAX IL HEVC video encoder"),
++    .type             = AVMEDIA_TYPE_VIDEO,
++    .id               = AV_CODEC_ID_HEVC,
++    .priv_data_size   = sizeof(OMXCodecContext),
++    .init             = omx_encode_init,
++    .encode2          = omx_encode_frame,
++    .close            = omx_encode_end,
++    .pix_fmts         = omx_encoder_pix_fmts,
++    .profiles         = NULL_IF_CONFIG_SMALL(ff_hevc_profiles),
++    .capabilities     = AV_CODEC_CAP_DELAY,
++    .caps_internal    = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
++    .priv_class       = &omx_hevcenc_class,
+ };
+diff --git a/libavcodec/omxdec.c b/libavcodec/omxdec.c
+index b489c09..20298b8 100755
+--- a/libavcodec/omxdec.c
++++ b/libavcodec/omxdec.c
+@@ -269,7 +269,7 @@ typedef struct OMXCodecContext {
+ 
+     int eos_sent, got_eos, evnet_bufferflag, first_get_outbuffer;
+ 
+-	int extradata_sent;
++    int extradata_sent;
+ 
+     uint8_t *output_buf;
+     int output_buf_size;
+@@ -320,9 +320,9 @@ static OMX_ERRORTYPE event_handler(OMX_HANDLETYPE component, OMX_PTR app_data, O
+     // unsigned long in official header versions (but there are also modified
+     // versions where it is something else).
+     OMX_PARAM_PORTDEFINITIONTYPE out_port_params = { 0 };
+-	OMX_PORT_PARAM_TYPE video_port_params = { 0 };
+-	OMX_ERRORTYPE err;
+-	int i;
++    OMX_PORT_PARAM_TYPE video_port_params = { 0 };
++    OMX_ERRORTYPE err;
++    int i;
+ 
+     switch (event) {
+     case OMX_EventError:
+@@ -350,36 +350,36 @@ static OMX_ERRORTYPE event_handler(OMX_HANDLETYPE component, OMX_PTR app_data, O
+         break;
+     case OMX_EventPortSettingsChanged:
+         av_log(s->avctx, AV_LOG_ERROR, "OMX port %"PRIu32" settings changed\n", (uint32_t) data1);
+-		INIT_STRUCT(video_port_params);
+-		err = OMX_GetParameter(s->handle, OMX_IndexParamVideoInit, &video_port_params);
+-		if(err != OMX_ErrorNone){
++        INIT_STRUCT(video_port_params);
++        err = OMX_GetParameter(s->handle, OMX_IndexParamVideoInit, &video_port_params);
++        if(err != OMX_ErrorNone){
+             av_log(s->avctx, AV_LOG_ERROR, "err %d\n",err);          
+             return AVERROR_UNKNOWN;
+-			}
+-
+-		for (i = 0; i < video_port_params.nPorts; i++) {
+-	        int port = video_port_params.nStartPortNumber + i;
+-	        OMX_PARAM_PORTDEFINITIONTYPE port_params = { 0 };
+-	        INIT_STRUCT(port_params);
+-	        port_params.nPortIndex = port;
+-	        err = OMX_GetParameter(s->handle, OMX_IndexParamPortDefinition, &port_params);
+-	        if (err != OMX_ErrorNone) {
+-	            av_log(s->avctx, AV_LOG_WARNING, "port %d error %x\n", port, err);
++        }
++
++        for (i = 0; i < video_port_params.nPorts; i++) {
++            int port = video_port_params.nStartPortNumber + i;
++            OMX_PARAM_PORTDEFINITIONTYPE port_params = { 0 };
++            INIT_STRUCT(port_params);
++            port_params.nPortIndex = port;
++            err = OMX_GetParameter(s->handle, OMX_IndexParamPortDefinition, &port_params);
++            if (err != OMX_ErrorNone) {
++                av_log(s->avctx, AV_LOG_WARNING, "port %d error %x\n", port, err);
+             return AVERROR_UNKNOWN;
+-	        }
+-	        if (port_params.eDir == OMX_DirOutput) {
+-				out_port_params = port_params;
+-				dec_out_width = out_port_params.format.video.nFrameWidth;
+-				dec_out_height = out_port_params.format.video.nFrameHeight;
+-				dec_pix_fmt = out_port_params.format.video.eColorFormat;
+-	            
++            }
++            if (port_params.eDir == OMX_DirOutput) {
++                out_port_params = port_params;
++                dec_out_width = out_port_params.format.video.nFrameWidth;
++                dec_out_height = out_port_params.format.video.nFrameHeight;
++                dec_pix_fmt = out_port_params.format.video.eColorFormat;
++
+                 av_log(s->avctx, AV_LOG_VERBOSE, "w:%d, h:%d, fmt:%d\n", dec_out_width, dec_out_height, dec_pix_fmt); 
+-	        } 
+-	    }		
++            } 
++        }
+         break;
+-	case OMX_EventBufferFlag:
+-		av_log(s->avctx, AV_LOG_VERBOSE, "OMX decoder competd set event_bufferflag\n");
+-		evnet_bufferflag = 1;
++    case OMX_EventBufferFlag:
++        av_log(s->avctx, AV_LOG_VERBOSE, "OMX decoder competd set event_bufferflag\n");
++        evnet_bufferflag = 1;
+     default:
+         av_log(s->avctx, AV_LOG_VERBOSE, "OMX event %d %"PRIx32" %"PRIx32"\n",
+                                          event, (uint32_t) data1, (uint32_t) data2);
+@@ -563,7 +563,7 @@ static av_cold int omx_component_init(AVCodecContext *avctx, const char *role)
+     out_port_params.bPopulated = OMX_FALSE;
+     out_port_params.eDomain    = OMX_PortDomainVideo;
+     out_port_params.format.video.pNativeRender = NULL;
+-	out_port_params.format.video.bFlagErrorConcealment  = OMX_FALSE;
++    out_port_params.format.video.bFlagErrorConcealment  = OMX_FALSE;
+     out_port_params.format.video.nFrameWidth   = avctx->width;
+     out_port_params.format.video.nFrameHeight  = avctx->height;
+     out_port_params.format.video.nStride       = 0;
+@@ -747,11 +747,11 @@ static av_cold int omx_decode_init(AVCodecContext *avctx)
+         role = "video_decoder.avc";
+         break;
+     case AV_CODEC_ID_HEVC:
+-		role = "video_decoder.hevc";
+-		break;
++        role = "video_decoder.hevc";
++        break;
+     case AV_CODEC_ID_MJPEG:
+-		role = "video_decoder.mjpeg";
+-		break;
++        role = "video_decoder.mjpeg";
++        break;
+     default:
+         return AVERROR(ENOSYS);
+     }
+@@ -809,7 +809,7 @@ static av_cold int omx_decode_init(AVCodecContext *avctx)
+ //         }
+ //     }
+ // #endif
+-	
++
+     return 0;
+ fail:
+     return ret;
+@@ -825,64 +825,64 @@ static int omx_decode_frame(AVCodecContext *avctx, void *data,
+     OMX_ERRORTYPE err;
+     int had_partial = 0;
+ 
+-	AVFrame *avframe = data;
+-	
+-	uint8_t *dst[4];
+-	int linesize[4];
++    AVFrame *avframe = data;
++
++    uint8_t *dst[4];
++    int linesize[4];
+ 
+     if (pkt->size) {
+-	
++
+         //VPU init and fill buffer slow, so empty buf sleep to send before get vpu fill buf.
+         if(!s->first_get_outbuffer)
+         av_usleep(100000);
+         buffer = get_buffer(&s->input_mutex, &s->input_cond,
+                             &s->num_free_in_buffers, s->free_in_buffers, 1);
+ 
+-		if (!buffer) {
+-        	av_log(avctx, AV_LOG_ERROR, "get_buffer NULL\n");
++        if (!buffer) {
++            av_log(avctx, AV_LOG_ERROR, "get_buffer NULL\n");
+             return AVERROR(ENOMEM);
+         }
+ 
+-		//cpy the extradata
+-		if(!s->extradata_sent && avctx->extradata ) {
+-
+-			memcpy(buffer->pBuffer + buffer->nOffset, avctx->extradata, avctx->extradata_size);	
+-			memcpy(buffer->pBuffer + buffer->nOffset + avctx->extradata_size, pkt->data, pkt->size);
+-			buffer->nFilledLen = pkt->size + avctx->extradata_size;
+-			s->extradata_sent = 1;
+-		
+-		}
+-		else {
+-			memcpy(buffer->pBuffer + buffer->nOffset, pkt->data, pkt->size);
+-			buffer->nFilledLen = pkt->size;
+-		}
+-
+-		/* avoid memcpy. point it addr*/
+-		//buffer->pAppPrivate = pkt;
+-		//buffer->pBuffer = pkt->data;
+-		//buffer->nFilledLen = pkt->size;
+-		
+-		buffer->pOutputPortPrivate = NULL;
+-		buffer->pAppPrivate = avctx->priv_data;
++        //cpy the extradata
++        if(!s->extradata_sent && avctx->extradata ) {
++
++            memcpy(buffer->pBuffer + buffer->nOffset, avctx->extradata, avctx->extradata_size);    
++            memcpy(buffer->pBuffer + buffer->nOffset + avctx->extradata_size, pkt->data, pkt->size);
++            buffer->nFilledLen = pkt->size + avctx->extradata_size;
++            s->extradata_sent = 1;
++        
++        }
++        else {
++            memcpy(buffer->pBuffer + buffer->nOffset, pkt->data, pkt->size);
++            buffer->nFilledLen = pkt->size;
++        }
++
++        /* avoid memcpy. point it addr*/
++        //buffer->pAppPrivate = pkt;
++        //buffer->pBuffer = pkt->data;
++        //buffer->nFilledLen = pkt->size;
++        
++        buffer->pOutputPortPrivate = NULL;
++        buffer->pAppPrivate = avctx->priv_data;
+         buffer->nFlags = OMX_BUFFERFLAG_ENDOFFRAME;
+ 
+-	    err = OMX_EmptyThisBuffer(s->handle, buffer);
+-	    if (err != OMX_ErrorNone) {
+-	        append_buffer(&s->input_mutex, &s->input_cond, &s->num_free_in_buffers, s->free_in_buffers, buffer);
+-	        av_log(avctx, AV_LOG_ERROR, "OMX_EmptyThisBuffer failed: %x\n", err);
+-	        return AVERROR_UNKNOWN;
+-	    }
++        err = OMX_EmptyThisBuffer(s->handle, buffer);
++        if (err != OMX_ErrorNone) {
++            append_buffer(&s->input_mutex, &s->input_cond, &s->num_free_in_buffers, s->free_in_buffers, buffer);
++            av_log(avctx, AV_LOG_ERROR, "OMX_EmptyThisBuffer failed: %x\n", err);
++            return AVERROR_UNKNOWN;
++        }
+     } else if (!s->eos_sent) {
+-		
++
+         if(!s->first_get_outbuffer)
+         av_usleep(1000000);
+         buffer = get_buffer(&s->input_mutex, &s->input_cond,
+                             &s->num_free_in_buffers, s->free_in_buffers, 1);
+ 
+         if(!buffer) {
+-        	av_log(avctx, AV_LOG_ERROR, "get_buffer NULL\n");
++            av_log(avctx, AV_LOG_ERROR, "get_buffer NULL\n");
+             return AVERROR(ENOMEM);
+-		}
++        }
+ 
+         buffer->nFilledLen = 0;
+         buffer->nFlags = OMX_BUFFERFLAG_EOS;
+@@ -907,58 +907,58 @@ static int omx_decode_frame(AVCodecContext *avctx, void *data,
+ 
+         if (!buffer) {
+             /*eos is sent wait for vpu evnet_bufferflag to get all frames
+-			  mjpeg: sent a frame, then wait for a decoder frame 
+-			*/
++              mjpeg: sent a frame, then wait for a decoder frame 
++            */
+             if((s->eos_sent && !evnet_bufferflag) || (avctx->codec_id == AV_CODEC_ID_MJPEG )) {
+-				continue; 
++                continue; 
+             }
+             break;
+         }
+-		//if (!buffer)
++        //if (!buffer)
+            // break;
+         if(!s->first_get_outbuffer)
+             s->first_get_outbuffer = 1;
+ 
+-		if(!buffer->nFilledLen){
++        if(!buffer->nFilledLen){
+             av_log(avctx, AV_LOG_ERROR, "buffer->nFilledLen %d\n",(int)buffer->nFilledLen);
+             goto end;
+         }
+ 
+         avctx->width = dec_out_width;
+-		avctx->height = dec_out_height;
++        avctx->height = dec_out_height;
+         avctx->pix_fmt = omx_map_color_format(avctx, dec_pix_fmt);
+-		s->stride     = avctx->width;
+-    	s->plane_size = avctx->height;
+-		
++        s->stride     = avctx->width;
++        s->plane_size = avctx->height;
++        
+         if (buffer->nFlags & OMX_BUFFERFLAG_EOS)
+             s->got_eos = 1;
+-       
+-		if ((ret = ff_get_buffer(avctx, avframe, 0)) < 0) {
+-			av_log(avctx, AV_LOG_ERROR, "Unable to allocate buffer\n");
+-			goto end;
+-		}
+-		
+-		ret = av_image_fill_arrays(dst, linesize, buffer->pBuffer,
+-								   avctx->pix_fmt, s->stride, s->plane_size, 1);
+-		if (ret < 0){
++
++        if ((ret = ff_get_buffer(avctx, avframe, 0)) < 0) {
++            av_log(avctx, AV_LOG_ERROR, "Unable to allocate buffer\n");
++            goto end;
++        }
++
++        ret = av_image_fill_arrays(dst, linesize, buffer->pBuffer,
++                                   avctx->pix_fmt, s->stride, s->plane_size, 1);
++        if (ret < 0){
+             av_log(avctx, AV_LOG_ERROR, "av_image_fill_arrays ret:%d\n", ret);
+             goto end;
+         }
+ 
+-		av_image_copy(avframe->data, avframe->linesize, (const uint8_t**)dst, linesize, 
+-							avctx->pix_fmt, avctx->width, avctx->height);
+-	
+-		//avframe->pts	 = buffer->nTimeStamp;
+-		//avframe->pkt_dts = AV_NOPTS_VALUE;
+-		//avframe->pict_type= AV_PICTURE_TYPE_I;
+-    	//avframe->key_frame= 1;
++        av_image_copy(avframe->data, avframe->linesize, (const uint8_t**)dst, linesize, 
++                            avctx->pix_fmt, avctx->width, avctx->height);
+ 
+-		*got_packet = 1;
++        //avframe->pts     = buffer->nTimeStamp;
++        //avframe->pkt_dts = AV_NOPTS_VALUE;
++        //avframe->pict_type= AV_PICTURE_TYPE_I;
++        //avframe->key_frame= 1;
+ 
+-	/*
+-		if ((ret = av_frame_ref(data, avframe)) < 0)
+-         	goto end;
+-         	*/
++        *got_packet = 1;
++
++        /*
++        if ((ret = av_frame_ref(data, avframe)) < 0)
++            goto end;
++        */
+ 
+ end:     
+         err = OMX_FillThisBuffer(s->handle, buffer);
+@@ -998,7 +998,7 @@ static const AVOption options_hevc[] = {
+     { "omx_libname", "OpenMAX library name", OFFSET(libname), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VDE },
+     { "omx_libprefix", "OpenMAX library prefix", OFFSET(libprefix), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VDE },
+     { "zerocopy", "Try to avoid copying input frames if possible", OFFSET(input_zerocopy), AV_OPT_TYPE_INT, { .i64 = CONFIG_OMX_RPI }, 0, 1, VE },
+-	{ NULL },
++    { NULL },
+ };
+ 
+ static const AVOption options_mjpeg[] = {
+@@ -1088,8 +1088,8 @@ AVCodec ff_mjpeg_omx_decoder = {
+     .init             = omx_decode_init,
+     .decode           = omx_decode_frame,
+     .close            = omx_decode_end,
+-	.capabilities	  = AV_CODEC_CAP_DR1,
+-	.max_lowres 	  = 3,
+-	.caps_internal	  = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
++    .capabilities     = AV_CODEC_CAP_DR1,
++    .max_lowres       = 3,
++    .caps_internal    = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
+     .priv_class       = &omx_mjpegdec_class,
+ };
+-- 
+2.17.1
+

+ 159 - 0
recipes-multimedia/ffmpeg/ffmpeg/0014-ffmpeg-add-pixel-foramt.patch

@@ -0,0 +1,159 @@
+From 474232dff26df2188fe37287aeb7834f6d3853d1 Mon Sep 17 00:00:00 2001
+From: "arvin.zhu" <arvin.zhu@starfivetech.com>
+Date: Thu, 29 Sep 2022 16:05:09 +0800
+Subject: [PATCH] ffmpeg: add pixel foramt
+
+add pixel format option for codecs of VPU
+
+Signed-off-by: arvin.zhu <arvin.zhu@starfivetech.com>
+---
+ libavcodec/omx.c    | 19 ++++++++++++++++---
+ libavcodec/omxdec.c | 43 +++++++++++++++++++++++++++++++++++++------
+ 2 files changed, 53 insertions(+), 9 deletions(-)
+
+diff --git a/libavcodec/omx.c b/libavcodec/omx.c
+index 1c4179f..6976884 100755
+--- a/libavcodec/omx.c
++++ b/libavcodec/omx.c
+@@ -456,18 +456,31 @@ static av_cold int omx_component_init(AVCodecContext *avctx, const char *role)
+             break;
+         }
+     }
++
+     if (s->color_format == 0) {
+         av_log(avctx, AV_LOG_ERROR, "No supported pixel formats (%d formats available)\n", i);
+         return AVERROR_UNKNOWN;
+     }
+-
++    av_log(avctx, AV_LOG_VERBOSE, "OMX setting pixel_format:%s\n", av_get_pix_fmt_name(avctx->pix_fmt));
+     in_port_params.bEnabled   = OMX_TRUE;
+     in_port_params.bPopulated = OMX_FALSE;
+     in_port_params.eDomain    = OMX_PortDomainVideo;
+ 
+     in_port_params.format.video.pNativeRender         = NULL;
+     in_port_params.format.video.bFlagErrorConcealment = OMX_FALSE;
+-    in_port_params.format.video.eColorFormat          = s->color_format;
++    switch (avctx->pix_fmt) {
++        case AV_PIX_FMT_NV12:
++            in_port_params.format.video.eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
++            break;
++        case AV_PIX_FMT_NV21:
++            in_port_params.format.video.eColorFormat = OMX_COLOR_FormatYVU420SemiPlanar;
++            break;
++        case AV_PIX_FMT_YUV420P:
++            out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYUV420Planar;
++            break;
++        default:
++            return AVERROR_OPTION_NOT_FOUND;
++        }
+     s->stride     = avctx->width;
+     s->plane_size = avctx->height;
+     // If specific codecs need to manually override the stride/plane_size,
+@@ -986,7 +999,7 @@ static const AVOption options_hevc[] = {
+ };
+ 
+ static const enum AVPixelFormat omx_encoder_pix_fmts[] = {
+-    AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE
++    AV_PIX_FMT_YUV420P, AV_PIX_FMT_NV12, AV_PIX_FMT_NV21, AV_PIX_FMT_NONE
+ };
+ 
+ static const AVClass omx_mpeg4enc_class = {
+diff --git a/libavcodec/omxdec.c b/libavcodec/omxdec.c
+index 20298b8..074ff4a 100755
+--- a/libavcodec/omxdec.c
++++ b/libavcodec/omxdec.c
+@@ -481,7 +481,7 @@ static av_cold int omx_component_init(AVCodecContext *avctx, const char *role)
+     //OMX_VIDEO_PARAM_BITRATETYPE vid_param_bitrate = { 0 };
+     OMX_ERRORTYPE err;
+     int i;
+-
++av_log(avctx, AV_LOG_VERBOSE, "OMX avctx pixel_format:%s\n", av_get_pix_fmt_name(avctx->pix_fmt));
+     s->version.s.nVersionMajor = 1;
+     s->version.s.nVersionMinor = 1;
+     s->version.s.nRevision     = 2;
+@@ -571,16 +571,46 @@ static av_cold int omx_component_init(AVCodecContext *avctx, const char *role)
+     out_port_params.format.video.nBitrate      = avctx->bit_rate;
+     out_port_params.format.video.xFramerate    = in_port_params.format.video.xFramerate;
+     out_port_params.format.video.bFlagErrorConcealment  = OMX_FALSE;
++    av_log(avctx, AV_LOG_VERBOSE, "OMX setting pixel_format:%s\n", s->pixel_format);
+     if (avctx->codec->id == AV_CODEC_ID_MPEG4)
+         out_port_params.format.video.eCompressionFormat = OMX_VIDEO_CodingMPEG4;
+-    else if (avctx->codec->id == AV_CODEC_ID_H264)
++    else if (avctx->codec->id == AV_CODEC_ID_H264) {
+         out_port_params.format.video.eCompressionFormat = OMX_VIDEO_CodingAVC;
+-    else if (avctx->codec->id == AV_CODEC_ID_HEVC)
++
++        switch (av_get_pix_fmt(s->pixel_format)) {
++        case AV_PIX_FMT_NV12:
++            out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
++            break;
++        case AV_PIX_FMT_NV21:
++            out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYVU420SemiPlanar;
++            break;
++        case AV_PIX_FMT_YUV420P:
++            out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYUV420Planar;
++            break;
++        default:
++            return AVERROR_OPTION_NOT_FOUND;
++        }
++    }
++    else if (avctx->codec->id == AV_CODEC_ID_HEVC) {
+         out_port_params.format.video.eCompressionFormat = OMX_VIDEO_CodingHEVC;
++
++        switch (av_get_pix_fmt(s->pixel_format)) {
++        case AV_PIX_FMT_NV12:
++            out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
++            break;
++        case AV_PIX_FMT_NV21:
++            out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYVU420SemiPlanar;
++            break;
++        case AV_PIX_FMT_YUV420P:
++            out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYUV420Planar;
++            break;
++        default:
++            return AVERROR_OPTION_NOT_FOUND;
++        }
++    }
+     else if (avctx->codec->id == AV_CODEC_ID_MJPEG){
+         out_port_params.format.video.eCompressionFormat = OMX_VIDEO_CodingMJPEG;
+ 
+-        av_log(avctx, AV_LOG_VERBOSE, "OMX_pixel_format:%s\n", s->pixel_format);
+         switch (av_get_pix_fmt(s->pixel_format)) {
+         case AV_PIX_FMT_NV12:
+             out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
+@@ -610,7 +640,7 @@ static av_cold int omx_component_init(AVCodecContext *avctx, const char *role)
+             out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYUV444Planar;
+             break;
+         default:
+-            out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYUV420Planar;
++            return AVERROR_OPTION_NOT_FOUND;
+         }
+     }
+ 
+@@ -991,6 +1021,7 @@ static const AVOption options[] = {
+     { "baseline", "",                         0,               AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_H264_BASELINE }, 0, 0, VE, "profile" },
+     { "main",     "",                         0,               AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_H264_MAIN },     0, 0, VE, "profile" },
+     { "high",     "",                         0,               AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_H264_HIGH },     0, 0, VE, "profile" },
++    { "omx_pix_fmt", "Set the decoding pixel format for h264_omx decoder. The following formats are supported: yuv420p, nv12, nv21.", OFFSET(pixel_format), AV_OPT_TYPE_STRING, { .str = "yuv420p" }, 0, 0, VD },
+     { NULL }
+ };
+ 
+@@ -998,6 +1029,7 @@ static const AVOption options_hevc[] = {
+     { "omx_libname", "OpenMAX library name", OFFSET(libname), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VDE },
+     { "omx_libprefix", "OpenMAX library prefix", OFFSET(libprefix), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VDE },
+     { "zerocopy", "Try to avoid copying input frames if possible", OFFSET(input_zerocopy), AV_OPT_TYPE_INT, { .i64 = CONFIG_OMX_RPI }, 0, 1, VE },
++    { "omx_pix_fmt", "Set the decoding pixel format for hevc_omx decoder. The following formats are supported: yuv420p, nv12, nv21.", OFFSET(pixel_format), AV_OPT_TYPE_STRING, { .str = "yuv420p" }, 0, 0, VD },
+     { NULL },
+ };
+ 
+@@ -1006,7 +1038,6 @@ static const AVOption options_mjpeg[] = {
+     { "omx_libprefix", "OpenMAX library prefix", OFFSET(libprefix), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VDE },
+     { "zerocopy", "Try to avoid copying input frames if possible", OFFSET(input_zerocopy), AV_OPT_TYPE_INT, { .i64 = CONFIG_OMX_RPI }, 0, 1, VD },
+     { "omx_pix_fmt", "Set the decoding pixel format for mjpeg_omx decoder. The following formats are supported: yuv420p, nv12, nv21, nv16, yuv422p, yuyv422, yvyu422, uyvy422, yuv444p.", OFFSET(pixel_format), AV_OPT_TYPE_STRING, { .str = "yuv420p" }, 0, 0, VD },
+-
+     { NULL },
+ };
+ 
+-- 
+2.17.1
+

+ 52 - 0
recipes-multimedia/ffmpeg/ffmpeg/0015-ffmpeg-remove-delay.patch

@@ -0,0 +1,52 @@
+From 74c4c2a25bb185ede7162a39a2d43c75a6276573 Mon Sep 17 00:00:00 2001
+From: "arvin.zhu" <arvin.zhu@starfivetech.com>
+Date: Fri, 30 Sep 2022 12:01:06 +0800
+Subject: [PATCH] ffmpeg: remove delay
+
+remove delay for decoding in omx.c file
+
+Signed-off-by: arvin.zhu <arvin.zhu@starfivetech.com>
+---
+ libavcodec/omxdec.c | 12 ++++++------
+ 1 file changed, 6 insertions(+), 6 deletions(-)
+
+diff --git a/libavcodec/omxdec.c b/libavcodec/omxdec.c
+index 074ff4a..0957605 100755
+--- a/libavcodec/omxdec.c
++++ b/libavcodec/omxdec.c
+@@ -863,8 +863,8 @@ static int omx_decode_frame(AVCodecContext *avctx, void *data,
+     if (pkt->size) {
+ 
+         //VPU init and fill buffer slow, so empty buf sleep to send before get vpu fill buf.
+-        if(!s->first_get_outbuffer)
+-        av_usleep(100000);
++        // if(!s->first_get_outbuffer)
++        // av_usleep(100000);
+         buffer = get_buffer(&s->input_mutex, &s->input_cond,
+                             &s->num_free_in_buffers, s->free_in_buffers, 1);
+ 
+@@ -904,8 +904,8 @@ static int omx_decode_frame(AVCodecContext *avctx, void *data,
+         }
+     } else if (!s->eos_sent) {
+ 
+-        if(!s->first_get_outbuffer)
+-        av_usleep(1000000);
++        // if(!s->first_get_outbuffer)
++        // av_usleep(1000000);
+         buffer = get_buffer(&s->input_mutex, &s->input_cond,
+                             &s->num_free_in_buffers, s->free_in_buffers, 1);
+ 
+@@ -946,8 +946,8 @@ static int omx_decode_frame(AVCodecContext *avctx, void *data,
+         }
+         //if (!buffer)
+            // break;
+-        if(!s->first_get_outbuffer)
+-            s->first_get_outbuffer = 1;
++        // if(!s->first_get_outbuffer)
++        //     s->first_get_outbuffer = 1;
+ 
+         if(!buffer->nFilledLen){
+             av_log(avctx, AV_LOG_ERROR, "buffer->nFilledLen %d\n",(int)buffer->nFilledLen);
+-- 
+2.17.1
+

+ 209 - 0
recipes-multimedia/ffmpeg/ffmpeg/0016-FFmpeg-omx-add-scale-option-for-omx.patch

@@ -0,0 +1,209 @@
+From 246a5308151416e99dbe53ad52d415abdfb6df29 Mon Sep 17 00:00:00 2001
+From: "arvin.zhu" <arvin.zhu@starfivetech.com>
+Date: Fri, 14 Oct 2022 16:50:55 +0800
+Subject: [PATCH] FFmpeg:omx: add scale option for omx
+
+add scale option for omx decoder
+
+Signed-off-by: arvin.zhu <arvin.zhu@starfivetech.com>
+---
+ libavcodec/omx.c    |  4 +-
+ libavcodec/omxdec.c | 92 +++++++++++++++++++++++++++------------------
+ 2 files changed, 58 insertions(+), 38 deletions(-)
+
+diff --git a/libavcodec/omx.c b/libavcodec/omx.c
+index 6976884..77012ce 100755
+--- a/libavcodec/omx.c
++++ b/libavcodec/omx.c
+@@ -1,6 +1,6 @@
+ /*
+- * OMX Video decoder
+- * Copyright (C) 2018-2022 Starfive Technology
++ * OMX Video encoder
++ * Copyright (C) 2011 Martin Storsjo
+  *
+  * This file is part of FFmpeg.
+  *
+diff --git a/libavcodec/omxdec.c b/libavcodec/omxdec.c
+index 0957605..87e5a1a 100755
+--- a/libavcodec/omxdec.c
++++ b/libavcodec/omxdec.c
+@@ -1,6 +1,6 @@
+ /*
+- * OMX Video encoder
+- * Copyright (C) 2011 Martin Storsjo
++ * OMX Video decoder
++ * Copyright (C) 2018-2022 Starfive Technology
+  *
+  * This file is part of FFmpeg.
+  *
+@@ -274,6 +274,9 @@ typedef struct OMXCodecContext {
+     uint8_t *output_buf;
+     int output_buf_size;
+ 
++    OMX_U32 scale_width;
++    OMX_U32 scale_height;
++
+     int input_zerocopy;
+     int profile;
+     char *pixel_format;     /**< Set by a private option. */
+@@ -481,7 +484,6 @@ static av_cold int omx_component_init(AVCodecContext *avctx, const char *role)
+     //OMX_VIDEO_PARAM_BITRATETYPE vid_param_bitrate = { 0 };
+     OMX_ERRORTYPE err;
+     int i;
+-av_log(avctx, AV_LOG_VERBOSE, "OMX avctx pixel_format:%s\n", av_get_pix_fmt_name(avctx->pix_fmt));
+     s->version.s.nVersionMajor = 1;
+     s->version.s.nVersionMinor = 1;
+     s->version.s.nRevision     = 2;
+@@ -564,8 +566,6 @@ av_log(avctx, AV_LOG_VERBOSE, "OMX avctx pixel_format:%s\n", av_get_pix_fmt_name
+     out_port_params.eDomain    = OMX_PortDomainVideo;
+     out_port_params.format.video.pNativeRender = NULL;
+     out_port_params.format.video.bFlagErrorConcealment  = OMX_FALSE;
+-    out_port_params.format.video.nFrameWidth   = avctx->width;
+-    out_port_params.format.video.nFrameHeight  = avctx->height;
+     out_port_params.format.video.nStride       = 0;
+     out_port_params.format.video.nSliceHeight  = 0;
+     out_port_params.format.video.nBitrate      = avctx->bit_rate;
+@@ -576,41 +576,29 @@ av_log(avctx, AV_LOG_VERBOSE, "OMX avctx pixel_format:%s\n", av_get_pix_fmt_name
+         out_port_params.format.video.eCompressionFormat = OMX_VIDEO_CodingMPEG4;
+     else if (avctx->codec->id == AV_CODEC_ID_H264) {
+         out_port_params.format.video.eCompressionFormat = OMX_VIDEO_CodingAVC;
+-
+-        switch (av_get_pix_fmt(s->pixel_format)) {
+-        case AV_PIX_FMT_NV12:
+-            out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
+-            break;
+-        case AV_PIX_FMT_NV21:
+-            out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYVU420SemiPlanar;
+-            break;
+-        case AV_PIX_FMT_YUV420P:
+-            out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYUV420Planar;
+-            break;
+-        default:
+-            return AVERROR_OPTION_NOT_FOUND;
+-        }
+     }
+     else if (avctx->codec->id == AV_CODEC_ID_HEVC) {
+         out_port_params.format.video.eCompressionFormat = OMX_VIDEO_CodingHEVC;
+-
+-        switch (av_get_pix_fmt(s->pixel_format)) {
+-        case AV_PIX_FMT_NV12:
+-            out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
+-            break;
+-        case AV_PIX_FMT_NV21:
+-            out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYVU420SemiPlanar;
+-            break;
+-        case AV_PIX_FMT_YUV420P:
+-            out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYUV420Planar;
+-            break;
+-        default:
+-            return AVERROR_OPTION_NOT_FOUND;
+-        }
+     }
+     else if (avctx->codec->id == AV_CODEC_ID_MJPEG){
+         out_port_params.format.video.eCompressionFormat = OMX_VIDEO_CodingMJPEG;
+ 
++        /* Set Scale config setting*/
++        if (s->scale_width || s->scale_height) {
++            av_log(avctx, AV_LOG_TRACE, "mjpeg decoder: scaling width: %ld scaling height: %ld .\n", s->scale_width, s->scale_height);
++            OMX_CONFIG_SCALEFACTORTYPE ScaleConfig;
++            INIT_STRUCT(ScaleConfig);
++            ScaleConfig.nPortIndex = 1;
++            OMX_GetConfig(s->handle, OMX_IndexConfigCommonScale, &ScaleConfig);
++            /* in Q16 format */
++            ScaleConfig.xWidth = (1 << 16) >> (s->scale_width & 0x3);
++            ScaleConfig.xHeight = (1 << 16) >> (s->scale_height & 0x3);
++            OMX_SetConfig(s->handle, OMX_IndexConfigCommonScale, &ScaleConfig);
++        } else {
++            out_port_params.format.video.nFrameWidth   = avctx->width;
++            out_port_params.format.video.nFrameHeight  = avctx->height;
++        }
++
+         switch (av_get_pix_fmt(s->pixel_format)) {
+         case AV_PIX_FMT_NV12:
+             out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
+@@ -643,6 +631,35 @@ av_log(avctx, AV_LOG_VERBOSE, "OMX avctx pixel_format:%s\n", av_get_pix_fmt_name
+             return AVERROR_OPTION_NOT_FOUND;
+         }
+     }
++    if (avctx->codec->id == AV_CODEC_ID_H264 || avctx->codec->id == AV_CODEC_ID_HEVC) {
++        /* Set Scale config setting*/
++        if ((s->scale_width != 0) && ((s->scale_width < avctx->width/8) ||
++             (s->scale_width > avctx->width) || (s->scale_width % 8 != 0))) {
++            av_log(avctx, AV_LOG_ERROR, "scale_width: Invalid scale parameter\n");
++            return AVERROR_INVALIDDATA;
++        }
++        if ((s->scale_height != 0) && ((s->scale_height < avctx->height/8) ||
++             (s->scale_height > avctx->height) || (s->scale_height % 8 != 0))) {
++            av_log(avctx, AV_LOG_ERROR, "scale_height: Invalid scale parameter\n");
++            return AVERROR_INVALIDDATA;
++        }
++        out_port_params.format.video.nFrameWidth   = s->scale_width ? s->scale_width : avctx->width;
++        out_port_params.format.video.nFrameHeight  = s->scale_height ? s->scale_height : avctx->height;
++
++        switch (av_get_pix_fmt(s->pixel_format)) {
++        case AV_PIX_FMT_NV12:
++            out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
++            break;
++        case AV_PIX_FMT_NV21:
++            out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYVU420SemiPlanar;
++            break;
++        case AV_PIX_FMT_YUV420P:
++            out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYUV420Planar;
++            break;
++        default:
++            return AVERROR_OPTION_NOT_FOUND;
++        }
++    }
+ 
+     err = OMX_SetParameter(s->handle, OMX_IndexParamPortDefinition, &out_port_params);
+     CHECK(err);
+@@ -650,10 +667,8 @@ av_log(avctx, AV_LOG_VERBOSE, "OMX avctx pixel_format:%s\n", av_get_pix_fmt_name
+     CHECK(err);
+     s->num_out_buffers = out_port_params.nBufferCountActual;
+ 
+-
+     err = OMX_SendCommand(s->handle, OMX_CommandStateSet, OMX_StateIdle, NULL);
+     CHECK(err);
+-
+     s->in_buffer_headers  = av_mallocz(sizeof(OMX_BUFFERHEADERTYPE*) * s->num_in_buffers);
+     s->free_in_buffers    = av_mallocz(sizeof(OMX_BUFFERHEADERTYPE*) * s->num_in_buffers);
+     s->out_buffer_headers = av_mallocz(sizeof(OMX_BUFFERHEADERTYPE*) * s->num_out_buffers);
+@@ -674,7 +689,6 @@ av_log(avctx, AV_LOG_VERBOSE, "OMX avctx pixel_format:%s\n", av_get_pix_fmt_name
+         err = OMX_AllocateBuffer(s->handle, &s->out_buffer_headers[i], s->out_port, s, out_port_params.nBufferSize);
+     CHECK(err);
+     s->num_out_buffers = i;
+-
+     if (wait_for_state(s, OMX_StateIdle) < 0) {
+         av_log(avctx, AV_LOG_ERROR, "Didn't get OMX_StateIdle\n");
+         return AVERROR_UNKNOWN;
+@@ -1022,6 +1036,8 @@ static const AVOption options[] = {
+     { "main",     "",                         0,               AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_H264_MAIN },     0, 0, VE, "profile" },
+     { "high",     "",                         0,               AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_H264_HIGH },     0, 0, VE, "profile" },
+     { "omx_pix_fmt", "Set the decoding pixel format for h264_omx decoder. The following formats are supported: yuv420p, nv12, nv21.", OFFSET(pixel_format), AV_OPT_TYPE_STRING, { .str = "yuv420p" }, 0, 0, VD },
++    { "scale_width", "Set the scaling width for omx (Only zoom out is support, ceil 8(width/8) and minimum 1/8)", OFFSET(scale_width), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, VD },
++    { "scale_height", "Set the scaling height for omx (Only zoom out is support, ceil 8(height/8) and minimum 1/8)", OFFSET(scale_height), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, VD },
+     { NULL }
+ };
+ 
+@@ -1030,6 +1046,8 @@ static const AVOption options_hevc[] = {
+     { "omx_libprefix", "OpenMAX library prefix", OFFSET(libprefix), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VDE },
+     { "zerocopy", "Try to avoid copying input frames if possible", OFFSET(input_zerocopy), AV_OPT_TYPE_INT, { .i64 = CONFIG_OMX_RPI }, 0, 1, VE },
+     { "omx_pix_fmt", "Set the decoding pixel format for hevc_omx decoder. The following formats are supported: yuv420p, nv12, nv21.", OFFSET(pixel_format), AV_OPT_TYPE_STRING, { .str = "yuv420p" }, 0, 0, VD },
++    { "scale_width", "Set the scaling width for omx (Only zoom out is support, ceil 8(width/8) and minimum 1/8)", OFFSET(scale_width), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, VD },
++    { "scale_height", "Set the scaling height for omx (Only zoom out is support, ceil 8(height/8) and minimum 1/8)", OFFSET(scale_height), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, VD },
+     { NULL },
+ };
+ 
+@@ -1038,6 +1056,8 @@ static const AVOption options_mjpeg[] = {
+     { "omx_libprefix", "OpenMAX library prefix", OFFSET(libprefix), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VDE },
+     { "zerocopy", "Try to avoid copying input frames if possible", OFFSET(input_zerocopy), AV_OPT_TYPE_INT, { .i64 = CONFIG_OMX_RPI }, 0, 1, VD },
+     { "omx_pix_fmt", "Set the decoding pixel format for mjpeg_omx decoder. The following formats are supported: yuv420p, nv12, nv21, nv16, yuv422p, yuyv422, yvyu422, uyvy422, yuv444p.", OFFSET(pixel_format), AV_OPT_TYPE_STRING, { .str = "yuv420p" }, 0, 0, VD },
++    { "scale_width", "Set the scaling width for omx (Only zoom out is support, Horizontal downscale: 0(none), 1(1/2), 2(1/4), 3(1/8)) and minimum 1/8)", OFFSET(scale_width), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 3, VD },
++    { "scale_height", "Set the scaling height for omx (Only zoom out is support, Vertical downscale: 0(none), 1(1/2), 2(1/4), 3(1/8)) and minimum 1/8)", OFFSET(scale_height), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 3, VD },
+     { NULL },
+ };
+ 
+-- 
+2.17.1
+

+ 265 - 0
recipes-multimedia/ffmpeg/ffmpeg/0017-FFmpeg-omxdec-add-mirror-rotation-and-crop-option.patch

@@ -0,0 +1,265 @@
+From 0c7df7e92eb46143fabeefd42af3023e6b7fc53f Mon Sep 17 00:00:00 2001
+From: "arvin.zhu" <arvin.zhu@starfivetech.com>
+Date: Fri, 21 Oct 2022 10:39:31 +0800
+Subject: [PATCH] FFmpeg:omxdec: add mirror rotation and crop option
+
+add mirror rotation and crop option for mjpeg_omx decoder
+
+Signed-off-by: arvin.zhu <arvin.zhu@starfivetech.com>
+---
+ libavcodec/omxdec.c | 181 +++++++++++++++++++++++++++++++++++---------
+ 1 file changed, 146 insertions(+), 35 deletions(-)
+
+diff --git a/libavcodec/omxdec.c b/libavcodec/omxdec.c
+index 87e5a1a..b4a7c96 100755
+--- a/libavcodec/omxdec.c
++++ b/libavcodec/omxdec.c
+@@ -276,6 +276,15 @@ typedef struct OMXCodecContext {
+ 
+     OMX_U32 scale_width;
+     OMX_U32 scale_height;
++    OMX_U32 rotation;
++    OMX_U32 mirror;
++    char *crop_expr;
++    struct {
++        int x;
++        int y;
++        int w;
++        int h;
++    } crop;
+ 
+     int input_zerocopy;
+     int profile;
+@@ -359,7 +368,6 @@ static OMX_ERRORTYPE event_handler(OMX_HANDLETYPE component, OMX_PTR app_data, O
+             av_log(s->avctx, AV_LOG_ERROR, "err %d\n",err);          
+             return AVERROR_UNKNOWN;
+         }
+-
+         for (i = 0; i < video_port_params.nPorts; i++) {
+             int port = video_port_params.nStartPortNumber + i;
+             OMX_PARAM_PORTDEFINITIONTYPE port_params = { 0 };
+@@ -571,7 +579,7 @@ static av_cold int omx_component_init(AVCodecContext *avctx, const char *role)
+     out_port_params.format.video.nBitrate      = avctx->bit_rate;
+     out_port_params.format.video.xFramerate    = in_port_params.format.video.xFramerate;
+     out_port_params.format.video.bFlagErrorConcealment  = OMX_FALSE;
+-    av_log(avctx, AV_LOG_VERBOSE, "OMX setting pixel_format:%s\n", s->pixel_format);
++
+     if (avctx->codec->id == AV_CODEC_ID_MPEG4)
+         out_port_params.format.video.eCompressionFormat = OMX_VIDEO_CodingMPEG4;
+     else if (avctx->codec->id == AV_CODEC_ID_H264) {
+@@ -580,12 +588,12 @@ static av_cold int omx_component_init(AVCodecContext *avctx, const char *role)
+     else if (avctx->codec->id == AV_CODEC_ID_HEVC) {
+         out_port_params.format.video.eCompressionFormat = OMX_VIDEO_CodingHEVC;
+     }
+-    else if (avctx->codec->id == AV_CODEC_ID_MJPEG){
++    else if (avctx->codec->id == AV_CODEC_ID_MJPEG) {
+         out_port_params.format.video.eCompressionFormat = OMX_VIDEO_CodingMJPEG;
+ 
+         /* Set Scale config setting*/
+         if (s->scale_width || s->scale_height) {
+-            av_log(avctx, AV_LOG_TRACE, "mjpeg decoder: scaling width: %ld scaling height: %ld .\n", s->scale_width, s->scale_height);
++            av_log(avctx, AV_LOG_TRACE, "mjpeg decoder: scaling width: %d scaling height: %d .\n", s->scale_width, s->scale_height);
+             OMX_CONFIG_SCALEFACTORTYPE ScaleConfig;
+             INIT_STRUCT(ScaleConfig);
+             ScaleConfig.nPortIndex = 1;
+@@ -599,38 +607,138 @@ static av_cold int omx_component_init(AVCodecContext *avctx, const char *role)
+             out_port_params.format.video.nFrameHeight  = avctx->height;
+         }
+ 
+-        switch (av_get_pix_fmt(s->pixel_format)) {
+-        case AV_PIX_FMT_NV12:
+-            out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
+-            break;
+-        case AV_PIX_FMT_NV21:
+-            out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYVU420SemiPlanar;
+-            break;
+-        case AV_PIX_FMT_YUV420P:
+-            out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYUV420Planar;
+-            break;
+-        case AV_PIX_FMT_NV16:
+-            out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYUV422SemiPlanar;
+-            break;
+-        case AV_PIX_FMT_YUV422P:
+-            out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYUV422Planar;
+-            break;
+-        case AV_PIX_FMT_YUYV422:
+-            out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYCbYCr;
+-            break;
+-        case AV_PIX_FMT_YVYU422:
+-            out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYCrYCb;
+-            break;
+-        case AV_PIX_FMT_UYVY422:
+-            out_port_params.format.video.eColorFormat = OMX_COLOR_FormatCbYCrY;
+-            break;
+-        case AV_PIX_FMT_YUV444P:
+-            out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYUV444Planar;
+-            break;
+-        default:
++        /* Set pixel format to decoder output*/
++        if (s->pixel_format) {
++            switch (av_get_pix_fmt(s->pixel_format)) {
++            case AV_PIX_FMT_NV12:
++                out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
++                break;
++            case AV_PIX_FMT_NV21:
++                out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYVU420SemiPlanar;
++                break;
++            case AV_PIX_FMT_YUV420P:
++                out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYUV420Planar;
++                break;
++            case AV_PIX_FMT_NV16:
++                out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYUV422SemiPlanar;
++                break;
++            case AV_PIX_FMT_YUV422P:
++                out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYUV422Planar;
++                break;
++            case AV_PIX_FMT_YUYV422:
++                out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYCbYCr;
++                break;
++            case AV_PIX_FMT_YVYU422:
++                out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYCrYCb;
++                break;
++            case AV_PIX_FMT_UYVY422:
++                out_port_params.format.video.eColorFormat = OMX_COLOR_FormatCbYCrY;
++                break;
++            case AV_PIX_FMT_YUV444P:
++                out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYUV444Planar;
++                break;
++            default:
++                return AVERROR_OPTION_NOT_FOUND;
++            }
++            av_log(avctx, AV_LOG_VERBOSE, "OMX setting pixel_format:%s\n", s->pixel_format);
++        } else {
++            switch (avctx->pix_fmt) {
++            case AV_PIX_FMT_YUVJ420P:
++                out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYUV420Planar;
++                break;
++            case AV_PIX_FMT_YUVJ422P:
++                out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYUV422Planar;
++                break;
++            case AV_PIX_FMT_YUVJ444P:
++                out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYUV444Planar;
++                break;
++            default:
++                out_port_params.format.video.eColorFormat = OMX_COLOR_FormatYUV420Planar;
++                break;
++            }
++        }
++
++        /* Set Mirror config setting*/
++        if (s->mirror) {
++            if (s->pixel_format || s->scale_width || s->scale_height || s->rotation) {
++                av_log(avctx, AV_LOG_ERROR, "Mirror cannot work with other option together.\n");
++                return AVERROR_INVALIDDATA;
++            }
++            av_log(avctx, AV_LOG_TRACE, "mjpeg decoder: mirror\n");
++            OMX_CONFIG_MIRRORTYPE MirrorConfig;
++            INIT_STRUCT(MirrorConfig);
++            MirrorConfig.nPortIndex = 1;
++            OMX_GetConfig(s->handle, OMX_IndexConfigCommonMirror, &MirrorConfig);
++            MirrorConfig.eMirror = s->mirror;
++            OMX_SetConfig(s->handle, OMX_IndexConfigCommonMirror, &MirrorConfig);
++        }
++
++        /* Set Rotation config setting*/
++        if (s->rotation) {
++            if (s->pixel_format || s->scale_width || s->scale_height || s->mirror) {
++                av_log(avctx, AV_LOG_ERROR, "Rotation cannot work with other option together.\n");
++                return AVERROR_INVALIDDATA;
++            }
++            av_log(avctx, AV_LOG_TRACE, "mjpeg decoder: rotation\n");
++            OMX_CONFIG_ROTATIONTYPE RotatConfig;
++            INIT_STRUCT(RotatConfig);
++            RotatConfig.nPortIndex = 1;
++            OMX_GetConfig(s->handle, OMX_IndexConfigCommonRotate, &RotatConfig);
++            switch (s->rotation) {
++            case 1:
++                RotatConfig.nRotation = 90;
++                break;
++            case 2:
++                RotatConfig.nRotation = 180;
++                break;
++            case 3:
++                RotatConfig.nRotation = 270;
++                break;
++            default:
++                RotatConfig.nRotation = 0;
++                break;
++            }
++            OMX_SetConfig(s->handle, OMX_IndexConfigCommonRotate, &RotatConfig);
++        }
++
++        /* Set Roi config setting*/
++        if (s->crop_expr && sscanf(s->crop_expr, "%d,%d,%d,%d",
++                                &s->crop.x, &s->crop.y,
++                                &s->crop.w, &s->crop.h) != 4) {
++            av_log(avctx, AV_LOG_ERROR, "Invalid cropping expressions.\n");
+             return AVERROR_OPTION_NOT_FOUND;
+         }
++
++        if (s->crop.w && s->crop.h) {
++            if (s->pixel_format || s->scale_width || s->scale_height || s->mirror || s->rotation) {
++                av_log(avctx, AV_LOG_ERROR, "Crop cannot work with other option together.\n");
++                return AVERROR_INVALIDDATA;
++            }
++            if ((s->crop.x < 0) || (s->crop.x > (avctx->width - s->crop.w)) ||
++                 (s->crop.y < 0) || (s->crop.y > (avctx->height - s->crop.h)) ||
++                 (s->crop.w < 16) || (s->crop.w > (avctx->width - s->crop.x)) ||
++                 (s->crop.h < 16) || (s->crop.h > (avctx->height - s->crop.y))) {
++                av_log(avctx, AV_LOG_ERROR, "Invalid cropping range.\n");
++                return AVERROR_INVALIDDATA;
++            }
++            if (s->crop.w % 16 != 0 || s->crop.h % 16 != 0) {
++                av_log(avctx, AV_LOG_ERROR, "The width/height must be an integer multiple of 16\n");
++                return AVERROR_INVALIDDATA;
++            }
++
++            OMX_CONFIG_RECTTYPE RectConfig; 
++            INIT_STRUCT(RectConfig);
++            RectConfig.nPortIndex = 1;
++            OMX_GetConfig(s->handle, OMX_IndexConfigCommonOutputCrop, &RectConfig);
++            RectConfig.nLeft = s->crop.x;
++            RectConfig.nTop = s->crop.y;
++            RectConfig.nWidth = s->crop.w;
++            RectConfig.nHeight = s->crop.h;
++            OMX_SetConfig(s->handle, OMX_IndexConfigCommonOutputCrop, &RectConfig);
++            av_log(avctx, AV_LOG_ERROR, "mjpeg decoder:roi x: %d y: %d w: %d h: %d .\n", s->crop.x, s->crop.y, s->crop.w, s->crop.h);
++        }
+     }
++
+     if (avctx->codec->id == AV_CODEC_ID_H264 || avctx->codec->id == AV_CODEC_ID_HEVC) {
+         /* Set Scale config setting*/
+         if ((s->scale_width != 0) && ((s->scale_width < avctx->width/8) ||
+@@ -675,6 +783,7 @@ static av_cold int omx_component_init(AVCodecContext *avctx, const char *role)
+     s->done_out_buffers   = av_mallocz(sizeof(OMX_BUFFERHEADERTYPE*) * s->num_out_buffers);
+     if (!s->in_buffer_headers || !s->free_in_buffers || !s->out_buffer_headers || !s->done_out_buffers)
+         return AVERROR(ENOMEM);
++
+     for (i = 0; i < s->num_in_buffers && err == OMX_ErrorNone; i++) {
+         if (s->input_zerocopy)
+             err = OMX_UseBuffer(s->handle, &s->in_buffer_headers[i], s->in_port, s, in_port_params.nBufferSize, NULL);
+@@ -699,7 +808,6 @@ static av_cold int omx_component_init(AVCodecContext *avctx, const char *role)
+         av_log(avctx, AV_LOG_ERROR, "Didn't get OMX_StateExecuting\n");
+         return AVERROR_UNKNOWN;
+     }
+-
+     for (i = 0; i < s->num_out_buffers && err == OMX_ErrorNone; i++)
+         err = OMX_FillThisBuffer(s->handle, s->out_buffer_headers[i]);
+     if (err != OMX_ErrorNone) {
+@@ -1055,9 +1163,12 @@ static const AVOption options_mjpeg[] = {
+     { "omx_libname", "OpenMAX library name", OFFSET(libname), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VDE },
+     { "omx_libprefix", "OpenMAX library prefix", OFFSET(libprefix), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VDE },
+     { "zerocopy", "Try to avoid copying input frames if possible", OFFSET(input_zerocopy), AV_OPT_TYPE_INT, { .i64 = CONFIG_OMX_RPI }, 0, 1, VD },
+-    { "omx_pix_fmt", "Set the decoding pixel format for mjpeg_omx decoder. The following formats are supported: yuv420p, nv12, nv21, nv16, yuv422p, yuyv422, yvyu422, uyvy422, yuv444p.", OFFSET(pixel_format), AV_OPT_TYPE_STRING, { .str = "yuv420p" }, 0, 0, VD },
++    { "omx_pix_fmt", "Set the decoding pixel format for mjpeg_omx decoder. The following formats are supported: yuv420p, nv12, nv21, nv16, yuv422p, yuyv422, yvyu422, uyvy422, yuv444p.", OFFSET(pixel_format), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, VD },
+     { "scale_width", "Set the scaling width for omx (Only zoom out is support, Horizontal downscale: 0(none), 1(1/2), 2(1/4), 3(1/8)) and minimum 1/8)", OFFSET(scale_width), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 3, VD },
+     { "scale_height", "Set the scaling height for omx (Only zoom out is support, Vertical downscale: 0(none), 1(1/2), 2(1/4), 3(1/8)) and minimum 1/8)", OFFSET(scale_height), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 3, VD },
++    { "mirror", "mirror 0(none), 1(V), 2(H) or 3(VH), cannot be set at the same time as pixel format conversion, rotation and crop", OFFSET(mirror), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 3, VD },
++    { "rotation", "rotation 0(0), 1(90), 2(180) or 3(270), cannot be set at the same time as pixel format conversion, mirror and crop", OFFSET(rotation), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 3, VD },
++    { "crop", "crop <x>,<y>,<w>,<h>: crop coord and width/height(from left/top, must be an integer multiple of 16), cannot be set at the same time as pixel format conversion, mirror and rotation", OFFSET(crop_expr), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, VD },
+     { NULL },
+ };
+ 
+-- 
+2.17.1
+

+ 35 - 0
recipes-multimedia/ffmpeg/ffmpeg/0018-FFmpeg-omx-gop-parameter-of-hevc-encoder.patch

@@ -0,0 +1,35 @@
+From 67b9e00e3abaa9179de91387bab9d00aa994d250 Mon Sep 17 00:00:00 2001
+From: "arvin.zhu" <arvin.zhu@starfivetech.com>
+Date: Wed, 2 Nov 2022 12:32:56 +0800
+Subject: [PATCH] FFmpeg:omx: gop parameter of hevc encoder
+
+repair gop parameter of hevc encoder not take effect
+
+Signed-off-by: arvin.zhu <arvin.zhu@starfivetech.com>
+---
+ libavcodec/omx.c | 5 ++---
+ 1 file changed, 2 insertions(+), 3 deletions(-)
+
+diff --git a/libavcodec/omx.c b/libavcodec/omx.c
+index 77012ce..d101fa4 100755
+--- a/libavcodec/omx.c
++++ b/libavcodec/omx.c
+@@ -561,13 +561,12 @@ static av_cold int omx_component_init(AVCodecContext *avctx, const char *role)
+         err = OMX_SetParameter(s->handle, OMX_IndexParamVideoAvc, &avc);
+         CHECK(err);
+     } else if (avctx->codec->id == AV_CODEC_ID_HEVC) {
+-        OMX_VIDEO_PARAM_AVCTYPE hevc = { 0 };
++        OMX_VIDEO_PARAM_HEVCTYPE hevc = { 0 };
+         INIT_STRUCT(hevc);
+         hevc.nPortIndex = s->out_port;
+         err = OMX_GetParameter(s->handle, OMX_IndexParamVideoHevc, &hevc);
+         CHECK(err);
+-        hevc.nBFrames = 0;
+-        hevc.nPFrames = avctx->gop_size;
++        hevc.nKeyFrameInterval = avctx->gop_size;
+         err = OMX_SetParameter(s->handle, OMX_IndexParamVideoHevc, &hevc);
+         CHECK(err);
+     }
+-- 
+2.17.1
+

+ 34 - 0
recipes-multimedia/ffmpeg/ffmpeg/0019-FFmpeg-omcdec-fix-mjpeg_omx-decoder-scale-option-bug.patch

@@ -0,0 +1,34 @@
+From bc391d931fa56ab788ae9cee7c249f91a9263d5b Mon Sep 17 00:00:00 2001
+From: "arvin.zhu" <arvin.zhu@starfivetech.com>
+Date: Wed, 2 Nov 2022 17:21:01 +0800
+Subject: [PATCH] FFmpeg:omcdec: fix mjpeg_omx decoder scale option bug
+
+fix mjpeg_omx decoder scale option bug
+
+Signed-off-by: arvin.zhu <arvin.zhu@starfivetech.com>
+---
+ libavcodec/omxdec.c | 6 +++---
+ 1 file changed, 3 insertions(+), 3 deletions(-)
+
+diff --git a/libavcodec/omxdec.c b/libavcodec/omxdec.c
+index b4a7c96..019db2e 100755
+--- a/libavcodec/omxdec.c
++++ b/libavcodec/omxdec.c
+@@ -602,11 +602,11 @@ static av_cold int omx_component_init(AVCodecContext *avctx, const char *role)
+             ScaleConfig.xWidth = (1 << 16) >> (s->scale_width & 0x3);
+             ScaleConfig.xHeight = (1 << 16) >> (s->scale_height & 0x3);
+             OMX_SetConfig(s->handle, OMX_IndexConfigCommonScale, &ScaleConfig);
+-        } else {
+-            out_port_params.format.video.nFrameWidth   = avctx->width;
+-            out_port_params.format.video.nFrameHeight  = avctx->height;
+         }
+ 
++        out_port_params.format.video.nFrameWidth   = avctx->width;
++        out_port_params.format.video.nFrameHeight  = avctx->height;
++
+         /* Set pixel format to decoder output*/
+         if (s->pixel_format) {
+             switch (av_get_pix_fmt(s->pixel_format)) {
+-- 
+2.17.1
+

+ 63 - 0
recipes-multimedia/ffmpeg/ffmpeg/0020-FFmpeg-omxdec-modify-the-range-of-width-and-height-o.patch

@@ -0,0 +1,63 @@
+From e29c31f71f4a2cf28142d2440c715a43672b08e8 Mon Sep 17 00:00:00 2001
+From: "arvin.zhu" <arvin.zhu@starfivetech.com>
+Date: Wed, 16 Nov 2022 11:19:47 +0800
+Subject: [PATCH] FFmpeg:omxdec: modify the range of width and height of scale
+
+modify the range of width and height of scale for omx decoder
+
+Signed-off-by: arvin.zhu <arvin.zhu@starfivetech.com>
+---
+ libavcodec/omxdec.c | 16 ++++++++++++----
+ 1 file changed, 12 insertions(+), 4 deletions(-)
+
+diff --git a/libavcodec/omxdec.c b/libavcodec/omxdec.c
+index 019db2e..4974833 100755
+--- a/libavcodec/omxdec.c
++++ b/libavcodec/omxdec.c
+@@ -361,7 +361,7 @@ static OMX_ERRORTYPE event_handler(OMX_HANDLETYPE component, OMX_PTR app_data, O
+         }
+         break;
+     case OMX_EventPortSettingsChanged:
+-        av_log(s->avctx, AV_LOG_ERROR, "OMX port %"PRIu32" settings changed\n", (uint32_t) data1);
++        av_log(s->avctx, AV_LOG_VERBOSE, "OMX port %"PRIu32" settings changed\n", (uint32_t) data1);
+         INIT_STRUCT(video_port_params);
+         err = OMX_GetParameter(s->handle, OMX_IndexParamVideoInit, &video_port_params);
+         if(err != OMX_ErrorNone){
+@@ -742,15 +742,23 @@ static av_cold int omx_component_init(AVCodecContext *avctx, const char *role)
+     if (avctx->codec->id == AV_CODEC_ID_H264 || avctx->codec->id == AV_CODEC_ID_HEVC) {
+         /* Set Scale config setting*/
+         if ((s->scale_width != 0) && ((s->scale_width < avctx->width/8) ||
+-             (s->scale_width > avctx->width) || (s->scale_width % 8 != 0))) {
++             (s->scale_width > avctx->width) || (s->scale_width % 2 != 0))) {
+             av_log(avctx, AV_LOG_ERROR, "scale_width: Invalid scale parameter\n");
+             return AVERROR_INVALIDDATA;
+         }
++        if (s->scale_width == avctx->width/8 && (s->scale_width % 8 != 0)) {
++            av_log(avctx, AV_LOG_ERROR, "When scale_width is width/8, scale_width must be a multiple of 8(ceil 8).\n");
++            return AVERROR_INVALIDDATA;
++        }
+         if ((s->scale_height != 0) && ((s->scale_height < avctx->height/8) ||
+-             (s->scale_height > avctx->height) || (s->scale_height % 8 != 0))) {
++             (s->scale_height > avctx->height) || (s->scale_height % 2 != 0))) {
+             av_log(avctx, AV_LOG_ERROR, "scale_height: Invalid scale parameter\n");
+             return AVERROR_INVALIDDATA;
+         }
++        if (s->scale_height == avctx->height/8 && (s->scale_height % 8 != 0)) {
++            av_log(avctx, AV_LOG_ERROR, "When scale_height is height/8, scale_height must be a multiple of 8(ceil 8).\n");
++            return AVERROR_INVALIDDATA;
++        }
+         out_port_params.format.video.nFrameWidth   = s->scale_width ? s->scale_width : avctx->width;
+         out_port_params.format.video.nFrameHeight  = s->scale_height ? s->scale_height : avctx->height;
+ 
+@@ -1072,7 +1080,7 @@ static int omx_decode_frame(AVCodecContext *avctx, void *data,
+         //     s->first_get_outbuffer = 1;
+ 
+         if(!buffer->nFilledLen){
+-            av_log(avctx, AV_LOG_ERROR, "buffer->nFilledLen %d\n",(int)buffer->nFilledLen);
++            av_log(avctx, AV_LOG_VERBOSE, "buffer->nFilledLen %d\n",(int)buffer->nFilledLen);
+             goto end;
+         }
+ 
+-- 
+2.17.1
+

+ 238 - 0
recipes-multimedia/ffmpeg/ffmpeg/0021-FFmpeg-omxdec-set-pts-of-avframe-and-fix-some-compil.patch

@@ -0,0 +1,238 @@
+From 888f1780682a6a73b4004bec4d51c450ddaac710 Mon Sep 17 00:00:00 2001
+From: "arvin.zhu" <arvin.zhu@starfivetech.com>
+Date: Wed, 23 Nov 2022 15:08:36 +0800
+Subject: [PATCH] FFmpeg:omxdec: set pts of avframe and fix some compilation
+ warnings
+
+set pts of avframe from video container and fix some compilation warnings
+
+Signed-off-by: arvin.zhu <arvin.zhu@starfivetech.com>
+---
+ libavcodec/omxdec.c | 129 +++++++++++++++++++++++++++++++++++++++-----
+ 1 file changed, 116 insertions(+), 13 deletions(-)
+
+diff --git a/libavcodec/omxdec.c b/libavcodec/omxdec.c
+index 4974833..1bb08b1 100755
+--- a/libavcodec/omxdec.c
++++ b/libavcodec/omxdec.c
+@@ -96,13 +96,96 @@ typedef struct OMXContext {
+     void (*host_init)(void);
+ } OMXContext;
+ 
+-static const struct {
++typedef struct OMXDecodeQueueNode {
++    int64_t val;
++    struct OMXDecodeQueueNode* next;
++} OMXDecodeQueueNode;
++
++typedef struct OMXDecodeQueue {
++    OMXDecodeQueueNode* head;
++    OMXDecodeQueueNode* tail;
++} OMXDecodeQueue;
++
++static av_cold void OMXDecodeQueueInit(OMXDecodeQueue* pq)
++{
++    assert(pq);
++    pq->head = pq->tail = NULL;
++}
++
++static av_cold void OMXDecodeQueueDestory(OMXDecodeQueue* pq)
++{
++    OMXDecodeQueueNode* cur = pq->head;
++    assert(pq);
++    while (cur)
++    {
++        OMXDecodeQueueNode* next = cur->next;
++        av_free(cur);
++        cur = next;
++    }
++    pq->tail = pq->head = NULL;
++}
++
++static void OMXDecodeQueuePush(OMXDecodeQueue* pq, int64_t x)
++{
++    OMXDecodeQueueNode* newNode = (OMXDecodeQueueNode*)malloc(sizeof(OMXDecodeQueueNode));
++    if (NULL == newNode)
++    {
++        av_log(NULL, AV_LOG_ERROR, "malloc queue error\n");
++        exit(-1);
++    }
++    assert(pq);
++    newNode->val = x;
++    newNode->next = NULL;
++
++    if (pq->tail == NULL)
++    {
++        assert(pq->head == NULL);
++        pq->head = pq->tail = newNode;
++    }
++    else
++    {
++        pq->tail->next = newNode;
++        pq->tail = newNode;
++    }
+ 
++}
++
++static void OMXDecodeQueuePop(OMXDecodeQueue* pq)
++{
++    assert(pq);
++    assert(pq->head && pq->tail);
++    if (pq->head->next == NULL)
++    {
++        av_free(pq->head);
++        pq->head = pq->tail = NULL;
++    }
++    else
++    {
++        OMXDecodeQueueNode* next = pq->head->next;
++        av_free(pq->head);
++        pq->head = next;
++    }
++}
++
++static int OMXDecodeQueueEmpty(OMXDecodeQueue* pq)
++{
++    assert(pq);
++
++    return pq->head == NULL;
++}
++
++static int64_t OMXDecodeQueueFront(OMXDecodeQueue* pq)
++{
++    assert(pq);
++    assert(pq->head);
++
++    return pq->head->val;
++}
++
++static const struct {
+     int color_format;
+     enum AVPixelFormat pix_fmt;
+-
+ } color_formats[] = {
+-
+     { OMX_COLOR_FormatYUV420Planar,                           AV_PIX_FMT_YUV420P },
+     { OMX_COLOR_FormatYUV420SemiPlanar,                       AV_PIX_FMT_NV12    },
+     { OMX_COLOR_FormatYVU420SemiPlanar,                       AV_PIX_FMT_NV21    },
+@@ -286,6 +369,8 @@ typedef struct OMXCodecContext {
+         int h;
+     } crop;
+ 
++    OMXDecodeQueue decode_pts_queue;
++    int decode_flag;
+     int input_zerocopy;
+     int profile;
+     char *pixel_format;     /**< Set by a private option. */
+@@ -491,6 +576,10 @@ static av_cold int omx_component_init(AVCodecContext *avctx, const char *role)
+     //OMX_VIDEO_PARAM_PORTFORMATTYPE video_port_format = { 0 };
+     //OMX_VIDEO_PARAM_BITRATETYPE vid_param_bitrate = { 0 };
+     OMX_ERRORTYPE err;
++    OMX_CONFIG_SCALEFACTORTYPE ScaleConfig;
++    OMX_CONFIG_MIRRORTYPE MirrorConfig;
++    OMX_CONFIG_ROTATIONTYPE RotatConfig;
++    OMX_CONFIG_RECTTYPE RectConfig;
+     int i;
+     s->version.s.nVersionMajor = 1;
+     s->version.s.nVersionMinor = 1;
+@@ -594,7 +683,6 @@ static av_cold int omx_component_init(AVCodecContext *avctx, const char *role)
+         /* Set Scale config setting*/
+         if (s->scale_width || s->scale_height) {
+             av_log(avctx, AV_LOG_TRACE, "mjpeg decoder: scaling width: %d scaling height: %d .\n", s->scale_width, s->scale_height);
+-            OMX_CONFIG_SCALEFACTORTYPE ScaleConfig;
+             INIT_STRUCT(ScaleConfig);
+             ScaleConfig.nPortIndex = 1;
+             OMX_GetConfig(s->handle, OMX_IndexConfigCommonScale, &ScaleConfig);
+@@ -665,7 +753,6 @@ static av_cold int omx_component_init(AVCodecContext *avctx, const char *role)
+                 return AVERROR_INVALIDDATA;
+             }
+             av_log(avctx, AV_LOG_TRACE, "mjpeg decoder: mirror\n");
+-            OMX_CONFIG_MIRRORTYPE MirrorConfig;
+             INIT_STRUCT(MirrorConfig);
+             MirrorConfig.nPortIndex = 1;
+             OMX_GetConfig(s->handle, OMX_IndexConfigCommonMirror, &MirrorConfig);
+@@ -680,7 +767,6 @@ static av_cold int omx_component_init(AVCodecContext *avctx, const char *role)
+                 return AVERROR_INVALIDDATA;
+             }
+             av_log(avctx, AV_LOG_TRACE, "mjpeg decoder: rotation\n");
+-            OMX_CONFIG_ROTATIONTYPE RotatConfig;
+             INIT_STRUCT(RotatConfig);
+             RotatConfig.nPortIndex = 1;
+             OMX_GetConfig(s->handle, OMX_IndexConfigCommonRotate, &RotatConfig);
+@@ -726,7 +812,6 @@ static av_cold int omx_component_init(AVCodecContext *avctx, const char *role)
+                 return AVERROR_INVALIDDATA;
+             }
+ 
+-            OMX_CONFIG_RECTTYPE RectConfig; 
+             INIT_STRUCT(RectConfig);
+             RectConfig.nPortIndex = 1;
+             OMX_GetConfig(s->handle, OMX_IndexConfigCommonOutputCrop, &RectConfig);
+@@ -869,6 +954,8 @@ static av_cold void cleanup(OMXCodecContext *s)
+         pthread_mutex_destroy(&s->output_mutex);
+         s->mutex_cond_inited = 0;
+     }
++    OMXDecodeQueueDestory(&s->decode_pts_queue);
++    av_freep(&s->decode_pts_queue);
+     av_freep(&s->in_buffer_headers);
+     av_freep(&s->out_buffer_headers);
+     av_freep(&s->free_in_buffers);
+@@ -883,7 +970,10 @@ static av_cold int omx_decode_init(AVCodecContext *avctx)
+     const char *role;
+     //OMX_BUFFERHEADERTYPE *buffer;
+     //OMX_ERRORTYPE err;
++    OMXDecodeQueueInit(&s->decode_pts_queue);
+ 
++    av_log(avctx, AV_LOG_VERBOSE, "avctx->time_base: %d/%d \n", avctx->time_base.num, avctx->time_base.den);
++    av_log(avctx, AV_LOG_VERBOSE, "avctx->framerate: %d/%d \n", avctx->framerate.num, avctx->framerate.den);
+     s->omx_context = omx_init(avctx, s->libname, s->libprefix);
+     if (!s->omx_context)
+         return AVERROR_ENCODER_NOT_FOUND;
+@@ -898,6 +988,7 @@ static av_cold int omx_decode_init(AVCodecContext *avctx)
+     s->avctx = avctx;
+     s->state = OMX_StateLoaded;
+     s->error = OMX_ErrorNone;
++    s->decode_flag = 0;
+ 
+     switch (avctx->codec->id) {
+     case AV_CODEC_ID_MPEG4:
+@@ -990,6 +1081,15 @@ static int omx_decode_frame(AVCodecContext *avctx, void *data,
+     uint8_t *dst[4];
+     int linesize[4];
+ 
++    av_log(avctx, AV_LOG_VERBOSE, "s->decode_flag: %d\n", s->decode_flag);
++    av_log(avctx, AV_LOG_VERBOSE, "avctx->time_base: %d/%d \n", avctx->time_base.num, avctx->time_base.den);
++    av_log(avctx, AV_LOG_VERBOSE, "avctx->pkt_timebase: %d/%d \n", avctx->pkt_timebase.num, avctx->pkt_timebase.den);
++    av_log(avctx, AV_LOG_VERBOSE, "avctx->framerate: %d/%d \n", avctx->framerate.num, avctx->framerate.den);
++    av_log(avctx, AV_LOG_VERBOSE, "avpkt->size: %d avpkt->pts: %ld avpkt->dts: %ld avpkt->duration: %ld\n",
++                                     pkt->size, pkt->pts, pkt->dts, pkt->duration);
++    av_log(avctx, AV_LOG_VERBOSE, "avctx->pts_correction_last_pts: %ld avctx->pts_correction_last_dts: %ld\n",
++                                     avctx->pts_correction_last_pts, avctx->pts_correction_last_dts);
++    OMXDecodeQueuePush(&s->decode_pts_queue, pkt->dts);
+     if (pkt->size) {
+ 
+         //VPU init and fill buffer slow, so empty buf sleep to send before get vpu fill buf.
+@@ -1107,12 +1207,15 @@ static int omx_decode_frame(AVCodecContext *avctx, void *data,
+ 
+         av_image_copy(avframe->data, avframe->linesize, (const uint8_t**)dst, linesize, 
+                             avctx->pix_fmt, avctx->width, avctx->height);
+-
+-        //avframe->pts     = buffer->nTimeStamp;
+-        //avframe->pkt_dts = AV_NOPTS_VALUE;
+-        //avframe->pict_type= AV_PICTURE_TYPE_I;
+-        //avframe->key_frame= 1;
+-
++        if (pkt->pts) {
++            if (OMXDecodeQueueEmpty(&s->decode_pts_queue) != 0){
++                av_log(avctx, AV_LOG_ERROR, "The queue of decode pts is empty.\n");
++                return AVERROR_INVALIDDATA;
++            }
++            avframe->pts = OMXDecodeQueueFront(&s->decode_pts_queue);
++            OMXDecodeQueuePop(&s->decode_pts_queue);
++        }
++        s->decode_flag += 1;
+         *got_packet = 1;
+ 
+         /*
+-- 
+2.17.1
+

+ 142 - 0
recipes-multimedia/ffmpeg/ffmpeg/0022-FFmpeg-enable-internal-optimize.patch

@@ -0,0 +1,142 @@
+diff --git a/libavcodec/omxdec.c b/libavcodec/omxdec.c
+index 1bb08b1..c518542 100755
+--- a/libavcodec/omxdec.c
++++ b/libavcodec/omxdec.c
+@@ -342,6 +342,8 @@ typedef struct OMXCodecContext {
+     pthread_cond_t input_cond;
+     pthread_mutex_t output_mutex;
+     pthread_cond_t output_cond;
++    pthread_mutex_t disableEVnt_mutex;
++    pthread_cond_t disableEVnt_cond;
+ 
+     pthread_mutex_t state_mutex;
+     pthread_cond_t state_cond;
+@@ -419,7 +421,7 @@ static OMX_ERRORTYPE event_handler(OMX_HANDLETYPE component, OMX_PTR app_data, O
+     OMX_PARAM_PORTDEFINITIONTYPE out_port_params = { 0 };
+     OMX_PORT_PARAM_TYPE video_port_params = { 0 };
+     OMX_ERRORTYPE err;
+-    int i;
++    int i, num;
+ 
+     switch (event) {
+     case OMX_EventError:
+@@ -438,6 +440,11 @@ static OMX_ERRORTYPE event_handler(OMX_HANDLETYPE component, OMX_PTR app_data, O
+             pthread_mutex_unlock(&s->state_mutex);
+         } else if (data1 == OMX_CommandPortDisable) {
+             av_log(s->avctx, AV_LOG_VERBOSE, "OMX port %"PRIu32" disabled\n", (uint32_t) data2);
++            if (data2 == 1) {
++                pthread_mutex_lock(&s->disableEVnt_mutex);
++                pthread_cond_broadcast(&s->disableEVnt_cond);
++                pthread_mutex_unlock(&s->disableEVnt_mutex);
++            }
+         } else if (data1 == OMX_CommandPortEnable) {
+             av_log(s->avctx, AV_LOG_VERBOSE, "OMX port %"PRIu32" enabled\n", (uint32_t) data2);
+         } else {
+@@ -470,6 +477,32 @@ static OMX_ERRORTYPE event_handler(OMX_HANDLETYPE component, OMX_PTR app_data, O
+                 dec_pix_fmt = out_port_params.format.video.eColorFormat;
+ 
+                 av_log(s->avctx, AV_LOG_VERBOSE, "w:%d, h:%d, fmt:%d\n", dec_out_width, dec_out_height, dec_pix_fmt); 
++                if (!s->num_out_buffers) {
++                    s->num_out_buffers = out_port_params.nBufferCountActual;
++                    s->out_buffer_headers = av_mallocz(sizeof(OMX_BUFFERHEADERTYPE*) * s->num_out_buffers);
++                    s->done_out_buffers   = av_mallocz(sizeof(OMX_BUFFERHEADERTYPE*) * s->num_out_buffers);
++
++                    if (!s->out_buffer_headers || !s->done_out_buffers)
++                        return AVERROR(ENOMEM);
++
++                    OMX_SendCommand(s->handle, OMX_CommandPortEnable, 1, NULL);
++
++                    for (num = 0; num < s->num_out_buffers && err == OMX_ErrorNone; num++)
++                        err = OMX_AllocateBuffer(s->handle, &s->out_buffer_headers[num], s->out_port, s, out_port_params.nBufferSize);
++
++                    if (err != OMX_ErrorNone) {
++                        av_log(s->avctx, AV_LOG_ERROR,  "err %x (%d) on line %d\n", err, err, __LINE__);
++                        return AVERROR_UNKNOWN;
++                    }
++                    s->num_out_buffers = num;
++
++                    for (num = 0; num < s->num_out_buffers && err == OMX_ErrorNone; num++)
++                        err = OMX_FillThisBuffer(s->handle, s->out_buffer_headers[num]);
++                    if (err != OMX_ErrorNone) {
++                        for (; num < s->num_out_buffers; num++)
++                            s->done_out_buffers[s->num_done_out_buffers++] = s->out_buffer_headers[num];
++                    }
++                }
+             } 
+         }
+         break;
+@@ -866,15 +899,18 @@ static av_cold int omx_component_init(AVCodecContext *avctx, const char *role)
+     CHECK(err);
+     err = OMX_GetParameter(s->handle, OMX_IndexParamPortDefinition, &out_port_params);
+     CHECK(err);
+-    s->num_out_buffers = out_port_params.nBufferCountActual;
++
++    OMX_SendCommand(s->handle, OMX_CommandPortDisable, 1, NULL);
++    pthread_mutex_lock(&s->disableEVnt_mutex);
++    pthread_cond_wait(&s->disableEVnt_cond, &s->disableEVnt_mutex);
++    pthread_mutex_unlock(&s->disableEVnt_mutex);
+ 
+     err = OMX_SendCommand(s->handle, OMX_CommandStateSet, OMX_StateIdle, NULL);
+     CHECK(err);
+     s->in_buffer_headers  = av_mallocz(sizeof(OMX_BUFFERHEADERTYPE*) * s->num_in_buffers);
+     s->free_in_buffers    = av_mallocz(sizeof(OMX_BUFFERHEADERTYPE*) * s->num_in_buffers);
+-    s->out_buffer_headers = av_mallocz(sizeof(OMX_BUFFERHEADERTYPE*) * s->num_out_buffers);
+-    s->done_out_buffers   = av_mallocz(sizeof(OMX_BUFFERHEADERTYPE*) * s->num_out_buffers);
+-    if (!s->in_buffer_headers || !s->free_in_buffers || !s->out_buffer_headers || !s->done_out_buffers)
++
++    if (!s->in_buffer_headers || !s->free_in_buffers)
+         return AVERROR(ENOMEM);
+ 
+     for (i = 0; i < s->num_in_buffers && err == OMX_ErrorNone; i++) {
+@@ -887,10 +923,7 @@ static av_cold int omx_component_init(AVCodecContext *avctx, const char *role)
+     }
+     CHECK(err);
+     s->num_in_buffers = i;
+-    for (i = 0; i < s->num_out_buffers && err == OMX_ErrorNone; i++)
+-        err = OMX_AllocateBuffer(s->handle, &s->out_buffer_headers[i], s->out_port, s, out_port_params.nBufferSize);
+-    CHECK(err);
+-    s->num_out_buffers = i;
++
+     if (wait_for_state(s, OMX_StateIdle) < 0) {
+         av_log(avctx, AV_LOG_ERROR, "Didn't get OMX_StateIdle\n");
+         return AVERROR_UNKNOWN;
+@@ -901,12 +934,7 @@ static av_cold int omx_component_init(AVCodecContext *avctx, const char *role)
+         av_log(avctx, AV_LOG_ERROR, "Didn't get OMX_StateExecuting\n");
+         return AVERROR_UNKNOWN;
+     }
+-    for (i = 0; i < s->num_out_buffers && err == OMX_ErrorNone; i++)
+-        err = OMX_FillThisBuffer(s->handle, s->out_buffer_headers[i]);
+-    if (err != OMX_ErrorNone) {
+-        for (; i < s->num_out_buffers; i++)
+-            s->done_out_buffers[s->num_done_out_buffers++] = s->out_buffer_headers[i];
+-    }
++
+     for (i = 0; i < s->num_in_buffers; i++)
+         s->free_in_buffers[s->num_free_in_buffers++] = s->in_buffer_headers[i];
+     return err != OMX_ErrorNone ? AVERROR_UNKNOWN : 0;
+@@ -952,6 +980,8 @@ static av_cold void cleanup(OMXCodecContext *s)
+         pthread_mutex_destroy(&s->input_mutex);
+         pthread_cond_destroy(&s->output_cond);
+         pthread_mutex_destroy(&s->output_mutex);
++        pthread_cond_destroy(&s->disableEVnt_cond);
++        pthread_mutex_destroy(&s->disableEVnt_mutex);
+         s->mutex_cond_inited = 0;
+     }
+     OMXDecodeQueueDestory(&s->decode_pts_queue);
+@@ -984,6 +1014,8 @@ static av_cold int omx_decode_init(AVCodecContext *avctx)
+     pthread_cond_init(&s->input_cond, NULL);
+     pthread_mutex_init(&s->output_mutex, NULL);
+     pthread_cond_init(&s->output_cond, NULL);
++    pthread_mutex_init(&s->disableEVnt_mutex, NULL);
++    pthread_cond_init(&s->disableEVnt_cond, NULL);
+     s->mutex_cond_inited = 1;
+     s->avctx = avctx;
+     s->state = OMX_StateLoaded;
+@@ -1009,6 +1041,7 @@ static av_cold int omx_decode_init(AVCodecContext *avctx)
+ 
+     if ((ret = find_component(s->omx_context, avctx, role, s->component_name, sizeof(s->component_name))) < 0)
+         goto fail;
++    strcat(s->component_name, ".internal");
+ 
+     av_log(avctx, AV_LOG_INFO, "Using %s\n", s->component_name);
+ 

+ 191 - 0
recipes-multimedia/ffmpeg/ffmpeg/0023-FFmpeg_upstream_AVCodec_struct_to_FFCodec.patch

@@ -0,0 +1,191 @@
+Description: <short summary of the patch>
+ TODO: Put a short summary on the line above and replace this paragraph
+ with a longer explanation of this change. Complete the meta-information
+ with other relevant fields (see below for details). To make it easier, the
+ information below has been extracted from the changelog. Adjust it or drop
+ it.
+ .
+ ffmpeg (7:5.1.2-3) unstable; urgency=medium
+ .
+   * debian/rules: Disable more tests on ppc64 (Closes: #1022764)
+   * debian/patches: Add upstream patch to fix FTBFS after vulkan changes
+     (Closes: #1031447)
+Author: Sebastian Ramacher <sramacher@debian.org>
+Bug-Debian: https://bugs.debian.org/1022764
+Bug-Debian: https://bugs.debian.org/1031447
+
+---
+The information above should follow the Patch Tagging Guidelines, please
+checkout https://dep.debian.net/deps/dep3/ to learn about the format. Here
+are templates for supplementary fields that you might want to add:
+
+Origin: (upstream|backport|vendor|other), (<patch-url>|commit:<commit-id>)
+Bug: <upstream-bugtracker-url>
+Bug-Debian: https://bugs.debian.org/<bugnumber>
+Bug-Ubuntu: https://launchpad.net/bugs/<bugnumber>
+Forwarded: (no|not-needed|<patch-forwarded-url>)
+Applied-Upstream: <version>, (<commit-url>|commit:<commid-id>)
+Reviewed-By: <name and email of someone who approved/reviewed the patch>
+Last-Update: 2023-02-21
+
+--- ffmpeg-5.1.2.orig/libavcodec/omx.c
++++ ffmpeg-5.1.2/libavcodec/omx.c
+@@ -1034,18 +1034,18 @@ static const AVClass omx_hevcenc_class =
+     .option = options_hevc,
+     .version = LIBAVUTIL_VERSION_INT,
+ };
+-AVCodec ff_hevc_omx_encoder = {
+-    .name             = "hevc_omx",
+-    .long_name        = NULL_IF_CONFIG_SMALL("OpenMAX IL HEVC video encoder"),
+-    .type             = AVMEDIA_TYPE_VIDEO,
+-    .id               = AV_CODEC_ID_HEVC,
++FFCodec ff_hevc_omx_encoder = {
++    .p.name             = "hevc_omx",
++    .p.long_name        = NULL_IF_CONFIG_SMALL("OpenMAX IL HEVC video encoder"),
++    .p.type             = AVMEDIA_TYPE_VIDEO,
++    .p.id               = AV_CODEC_ID_HEVC,
+     .priv_data_size   = sizeof(OMXCodecContext),
+     .init             = omx_encode_init,
+-    .encode2          = omx_encode_frame,
++    FF_CODEC_ENCODE_CB(omx_encode_frame),
+     .close            = omx_encode_end,
+-    .pix_fmts         = omx_encoder_pix_fmts,
+-    .profiles         = NULL_IF_CONFIG_SMALL(ff_hevc_profiles),
+-    .capabilities     = AV_CODEC_CAP_DELAY,
++    .p.pix_fmts         = omx_encoder_pix_fmts,
++    .p.profiles         = NULL_IF_CONFIG_SMALL(ff_hevc_profiles),
++    .p.capabilities     = AV_CODEC_CAP_DELAY,
+     .caps_internal    = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
+-    .priv_class       = &omx_hevcenc_class,
++    .p.priv_class       = &omx_hevcenc_class,
+ };
+--- ffmpeg-5.1.2.orig/libavcodec/omxdec.c
++++ ffmpeg-5.1.2/libavcodec/omxdec.c
+@@ -46,7 +46,7 @@
+ #include "h264.h"
+ #include "internal.h"
+ #include "profiles.h"
+-
++#include "codec_internal.h"
+ int evnet_bufferflag;
+ int dec_out_height;
+ int dec_out_width;
+@@ -1100,7 +1100,7 @@ fail:
+ }
+ 
+ 
+-static int omx_decode_frame(AVCodecContext *avctx, void *data,
++static int omx_decode_frame(AVCodecContext *avctx, AVFrame *data,
+                            int *got_packet, AVPacket *pkt)
+ {
+     OMXCodecContext *s = avctx->priv_data;
+@@ -1322,18 +1322,18 @@ static const AVClass omx_mpeg4dec_class
+     .option     = options,
+     .version    = LIBAVUTIL_VERSION_INT,
+ };
+-AVCodec ff_mpeg4_omx_decoder = {
+-    .name             = "mpeg4_omx",
+-    .long_name        = NULL_IF_CONFIG_SMALL("OpenMAX IL MPEG-4 video decoder"),
+-    .type             = AVMEDIA_TYPE_VIDEO,
+-    .id               = AV_CODEC_ID_MPEG4,
++FFCodec ff_mpeg4_omx_decoder = {
++    .p.name             = "mpeg4_omx",
++    .p.long_name        = NULL_IF_CONFIG_SMALL("OpenMAX IL MPEG-4 video decoder"),
++    .p.type             = AVMEDIA_TYPE_VIDEO,
++    .p.id               = AV_CODEC_ID_MPEG4,
+     .priv_data_size   = sizeof(OMXCodecContext),
+     .init             = omx_decode_init,
+-    .decode           = omx_decode_frame,
++    FF_CODEC_ENCODE_CB(omx_decode_frame),
+     .close            = omx_decode_end,
+-    .capabilities     = AV_CODEC_CAP_DELAY,
++    .p.capabilities     = AV_CODEC_CAP_DELAY,
+     .caps_internal    = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
+-    .priv_class       = &omx_mpeg4dec_class,
++    .p.priv_class       = &omx_mpeg4dec_class,
+ };
+ 
+ static const AVClass omx_h264dec_class = {
+@@ -1342,18 +1342,18 @@ static const AVClass omx_h264dec_class =
+     .option     = options,
+     .version    = LIBAVUTIL_VERSION_INT,
+ };
+-AVCodec ff_h264_omx_decoder = {
+-    .name             = "h264_omx",
+-    .long_name        = NULL_IF_CONFIG_SMALL("OpenMAX IL H.264 video decoder"),
+-    .type             = AVMEDIA_TYPE_VIDEO,
+-    .id               = AV_CODEC_ID_H264,
++FFCodec ff_h264_omx_decoder = {
++    .p.name             = "h264_omx",
++    .p.long_name        = NULL_IF_CONFIG_SMALL("OpenMAX IL H.264 video decoder"),
++    .p.type             = AVMEDIA_TYPE_VIDEO,
++    .p.id               = AV_CODEC_ID_H264,
+     .priv_data_size   = sizeof(OMXCodecContext),
+     .init             = omx_decode_init,
+-    .decode           = omx_decode_frame,
++    FF_CODEC_DECODE_CB(omx_decode_frame),
+     .close            = omx_decode_end,
+-    .capabilities     = AV_CODEC_CAP_DELAY,
++    .p.capabilities     = AV_CODEC_CAP_DELAY,
+     .caps_internal    = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
+-    .priv_class       = &omx_h264dec_class,
++    .p.priv_class       = &omx_h264dec_class,
+     .bsfs             = "h264_mp4toannexb",
+ };
+ 
+@@ -1363,19 +1363,19 @@ static const AVClass omx_hevcdec_class =
+     .option     = options_hevc,
+     .version    = LIBAVUTIL_VERSION_INT,
+ };
+-AVCodec ff_hevc_omx_decoder = {
+-    .name             = "hevc_omx",
+-    .long_name        = NULL_IF_CONFIG_SMALL("OpenMAX IL HEVC video decoder"),
+-    .type             = AVMEDIA_TYPE_VIDEO,
+-    .id               = AV_CODEC_ID_HEVC,
++FFCodec ff_hevc_omx_decoder = {
++    .p.name             = "hevc_omx",
++    .p.long_name        = NULL_IF_CONFIG_SMALL("OpenMAX IL HEVC video decoder"),
++    .p.type             = AVMEDIA_TYPE_VIDEO,
++    .p.id               = AV_CODEC_ID_HEVC,
+     .priv_data_size   = sizeof(OMXCodecContext),
+     .init             = omx_decode_init,
+-    .decode           = omx_decode_frame,
++    FF_CODEC_DECODE_CB(omx_decode_frame),
+     .close            = omx_decode_end,
+-    .profiles         = NULL_IF_CONFIG_SMALL(ff_hevc_profiles),
+-    .capabilities     = AV_CODEC_CAP_DELAY,
++    .p.profiles         = NULL_IF_CONFIG_SMALL(ff_hevc_profiles),
++    .p.capabilities     = AV_CODEC_CAP_DELAY,
+     .caps_internal    = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
+-    .priv_class       = &omx_hevcdec_class,
++    .p.priv_class       = &omx_hevcdec_class,
+     .bsfs             = "hevc_mp4toannexb",
+ };
+ 
+@@ -1385,17 +1385,17 @@ static const AVClass omx_mjpegdec_class
+     .option     = options_mjpeg,
+     .version    = LIBAVUTIL_VERSION_INT,
+ };
+-AVCodec ff_mjpeg_omx_decoder = {
+-    .name             = "mjpeg_omx",
+-    .long_name        = NULL_IF_CONFIG_SMALL("OpenMAX IL mjpeg video decoder"),
+-    .type             = AVMEDIA_TYPE_VIDEO,
+-    .id               = AV_CODEC_ID_MJPEG,
++FFCodec ff_mjpeg_omx_decoder = {
++    .p.name             = "mjpeg_omx",
++    .p.long_name        = NULL_IF_CONFIG_SMALL("OpenMAX IL mjpeg video decoder"),
++    .p.type             = AVMEDIA_TYPE_VIDEO,
++    .p.id               = AV_CODEC_ID_MJPEG,
+     .priv_data_size   = sizeof(OMXCodecContext),
+     .init             = omx_decode_init,
+-    .decode           = omx_decode_frame,
++    FF_CODEC_DECODE_CB(omx_decode_frame),
+     .close            = omx_decode_end,
+-    .capabilities     = AV_CODEC_CAP_DR1,
+-    .max_lowres       = 3,
++    .p.capabilities     = AV_CODEC_CAP_DR1,
++    .p.max_lowres       = 3,
+     .caps_internal    = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
+-    .priv_class       = &omx_mjpegdec_class,
++    .p.priv_class       = &omx_mjpegdec_class,
+ };

+ 257 - 0
recipes-multimedia/ffmpeg/ffmpeg/0024-FFmpeg-optimize-copy-for-omxdec.patch

@@ -0,0 +1,257 @@
+Description: <short summary of the patch>
+ TODO: Put a short summary on the line above and replace this paragraph
+ with a longer explanation of this change. Complete the meta-information
+ with other relevant fields (see below for details). To make it easier, the
+ information below has been extracted from the changelog. Adjust it or drop
+ it.
+ .
+ ffmpeg (7:5.1.2-3) unstable; urgency=medium
+ .
+   * debian/rules: Disable more tests on ppc64 (Closes: #1022764)
+   * debian/patches: Add upstream patch to fix FTBFS after vulkan changes
+     (Closes: #1031447)
+Author: Sebastian Ramacher <sramacher@debian.org>
+Bug-Debian: https://bugs.debian.org/1022764
+Bug-Debian: https://bugs.debian.org/1031447
+
+---
+The information above should follow the Patch Tagging Guidelines, please
+checkout https://dep.debian.net/deps/dep3/ to learn about the format. Here
+are templates for supplementary fields that you might want to add:
+
+Origin: (upstream|backport|vendor|other), (<patch-url>|commit:<commit-id>)
+Bug: <upstream-bugtracker-url>
+Bug-Debian: https://bugs.debian.org/<bugnumber>
+Bug-Ubuntu: https://launchpad.net/bugs/<bugnumber>
+Forwarded: (no|not-needed|<patch-forwarded-url>)
+Applied-Upstream: <version>, (<commit-url>|commit:<commid-id>)
+Reviewed-By: <name and email of someone who approved/reviewed the patch>
+Last-Update: 2023-03-15
+
+--- ffmpeg-5.1.2.orig/libavcodec/allcodecs.c
++++ ffmpeg-5.1.2/libavcodec/allcodecs.c
+@@ -34,6 +34,10 @@
+ #include "codec_id.h"
+ #include "codec_internal.h"
+ 
++extern const FFCodec ff_h264_omx_decoder;
++extern const FFCodec ff_hevc_omx_encoder;
++extern const FFCodec ff_hevc_omx_decoder;
++extern const FFCodec ff_mjpeg_omx_decoder;
+ extern const FFCodec ff_a64multi_encoder;
+ extern const FFCodec ff_a64multi5_encoder;
+ extern const FFCodec ff_aasc_decoder;
+@@ -823,11 +827,7 @@ extern const FFCodec ff_h264_cuvid_decod
+ extern const FFCodec ff_h264_mf_encoder;
+ extern const FFCodec ff_h264_nvenc_encoder;
+ extern const FFCodec ff_h264_omx_encoder;
+-extern const FFCodec ff_h264_omx_decoder;
+-extern const FFCodec ff_hevc_omx_encoder;
+-extern const FFCodec ff_hevc_omx_decoder;
+ extern const FFCodec ff_h264_qsv_encoder;
+-extern const FFCodec ff_mjpeg_omx_decoder;
+ extern const FFCodec ff_h264_v4l2m2m_encoder;
+ extern const FFCodec ff_h264_vaapi_encoder;
+ extern const FFCodec ff_h264_videotoolbox_encoder;
+--- ffmpeg-5.1.2.orig/libavcodec/omxdec.c
++++ ffmpeg-5.1.2/libavcodec/omxdec.c
+@@ -34,6 +34,7 @@
+ #include <stdlib.h>
+ #include <sys/time.h>
+ 
++#include "libavcodec/decode.h"
+ #include "libavutil/avstring.h"
+ #include "libavutil/avutil.h"
+ #include "libavutil/common.h"
+@@ -355,6 +356,7 @@ typedef struct OMXCodecContext {
+     int eos_sent, got_eos, evnet_bufferflag, first_get_outbuffer;
+ 
+     int extradata_sent;
++    int has_cleanup;
+ 
+     uint8_t *output_buf;
+     int output_buf_size;
+@@ -943,6 +945,7 @@ static av_cold int omx_component_init(AV
+ static av_cold void cleanup(OMXCodecContext *s)
+ {
+     int i, executing;
++    OMX_BUFFERHEADERTYPE *buffer;
+ 
+     pthread_mutex_lock(&s->state_mutex);
+     executing = s->state == OMX_StateExecuting;
+@@ -953,17 +956,24 @@ static av_cold void cleanup(OMXCodecCont
+         wait_for_state(s, OMX_StateIdle);
+         OMX_SendCommand(s->handle, OMX_CommandStateSet, OMX_StateLoaded, NULL);
+         for (i = 0; i < s->num_in_buffers; i++) {
+-            OMX_BUFFERHEADERTYPE *buffer = get_buffer(&s->input_mutex, &s->input_cond,
++            buffer = get_buffer(&s->input_mutex, &s->input_cond,
+                                                       &s->num_free_in_buffers, s->free_in_buffers, 1);
+             if (s->input_zerocopy)
+                 buffer->pBuffer = NULL;
+             OMX_FreeBuffer(s->handle, s->in_port, buffer);
+         }
+-        for (i = 0; i < s->num_out_buffers; i++) {
+-            OMX_BUFFERHEADERTYPE *buffer = get_buffer(&s->output_mutex, &s->output_cond,
+-                                                      &s->num_done_out_buffers, s->done_out_buffers, 1);
++
++        while (buffer = get_buffer(&s->output_mutex, &s->output_cond,
++                    &s->num_done_out_buffers, s->done_out_buffers, 0)) {
+             OMX_FreeBuffer(s->handle, s->out_port, buffer);
++            s->num_out_buffers--;
++        }
++
++        if (s->num_out_buffers) {
++            s->has_cleanup = 1;
++            return;
+         }
++
+         wait_for_state(s, OMX_StateLoaded);
+     }
+     if (s->handle) {
+@@ -1099,6 +1109,94 @@ fail:
+     return ret;
+ }
+ 
++static void omx_free_out_buffer(void *opaque, uint8_t *unused)
++{
++    OMX_ERRORTYPE err;
++    OMX_BUFFERHEADERTYPE *buffer = opaque;
++    OMXCodecContext *s = buffer->pAppPrivate;
++
++    if (!s->has_cleanup) {
++        err = OMX_FillThisBuffer(s->handle, buffer);
++        if (err != OMX_ErrorNone) {
++            append_buffer(&s->output_mutex, &s->output_cond, &s->num_done_out_buffers, s->done_out_buffers, buffer);
++            av_log(s->avctx, AV_LOG_ERROR, "OMX_FillThisBuffer failed, err: %x\n", err);
++        }
++    } else {
++        OMX_FreeBuffer(s->handle, s->out_port, buffer);
++        s->num_out_buffers--;
++        if (!s->num_out_buffers) {
++            wait_for_state(s, OMX_StateLoaded);
++            if (s->handle) {
++                s->omx_context->ptr_FreeHandle(s->handle);
++                s->handle = NULL;
++            }
++
++            omx_deinit(s->omx_context);
++            s->omx_context = NULL;
++            if (s->mutex_cond_inited) {
++                pthread_cond_destroy(&s->state_cond);
++                pthread_mutex_destroy(&s->state_mutex);
++                pthread_cond_destroy(&s->input_cond);
++                pthread_mutex_destroy(&s->input_mutex);
++                pthread_cond_destroy(&s->output_cond);
++                pthread_mutex_destroy(&s->output_mutex);
++                pthread_cond_destroy(&s->disableEVnt_cond);
++                pthread_mutex_destroy(&s->disableEVnt_mutex);
++                s->mutex_cond_inited = 0;
++            }
++            OMXDecodeQueueDestory(&s->decode_pts_queue);
++            av_freep(&s->decode_pts_queue);
++            av_freep(&s->in_buffer_headers);
++            av_freep(&s->out_buffer_headers);
++            av_freep(&s->free_in_buffers);
++            av_freep(&s->done_out_buffers);
++            av_freep(&s->output_buf);
++        }
++    }
++}
++
++static int omx_buf_to_swframe(OMXCodecContext *s, AVFrame *frame, OMX_BUFFERHEADERTYPE *buffer)
++{
++    int ret;
++    uint8_t *dst[4];
++    int linesize[4];
++
++    frame->buf[0] = av_buffer_create((char *)buffer->pBuffer, buffer->nFilledLen, omx_free_out_buffer, buffer, 0);
++
++    if (!frame->buf[0])
++        return AVERROR(ENOMEM);
++
++    ret = av_image_fill_arrays(dst, linesize, buffer->pBuffer,
++                               s->avctx->pix_fmt, s->stride, s->plane_size, 1);
++    if (ret < 0){
++        av_log(s->avctx, AV_LOG_ERROR, "av_image_fill_arrays ret:%d\n", ret);
++        return AVERROR(EINVAL);
++    }
++
++    frame->linesize[0] = linesize[0];
++    frame->data[0] = frame->buf[0]->data;
++
++    /* fixup special cases */
++    switch (s->avctx->pix_fmt) {
++    case AV_PIX_FMT_NV12:
++    case AV_PIX_FMT_NV21:
++        frame->linesize[1] = linesize[1];
++        frame->data[1] = dst[1];
++        break;
++
++    case AV_PIX_FMT_YUV420P:
++        frame->linesize[1] = linesize[1];
++        frame->linesize[2] = linesize[2];
++        frame->data[1] = dst[1];
++        frame->data[2] = dst[2];
++        break;
++
++    default:
++        break;
++    }
++
++    return 0;
++}
+ 
+ static int omx_decode_frame(AVCodecContext *avctx, AVFrame *data,
+                            int *got_packet, AVPacket *pkt)
+@@ -1111,9 +1209,6 @@ static int omx_decode_frame(AVCodecConte
+ 
+     AVFrame *avframe = data;
+ 
+-    uint8_t *dst[4];
+-    int linesize[4];
+-
+     av_log(avctx, AV_LOG_VERBOSE, "s->decode_flag: %d\n", s->decode_flag);
+     av_log(avctx, AV_LOG_VERBOSE, "avctx->time_base: %d/%d \n", avctx->time_base.num, avctx->time_base.den);
+     av_log(avctx, AV_LOG_VERBOSE, "avctx->pkt_timebase: %d/%d \n", avctx->pkt_timebase.num, avctx->pkt_timebase.den);
+@@ -1226,20 +1321,21 @@ static int omx_decode_frame(AVCodecConte
+         if (buffer->nFlags & OMX_BUFFERFLAG_EOS)
+             s->got_eos = 1;
+ 
+-        if ((ret = ff_get_buffer(avctx, avframe, 0)) < 0) {
+-            av_log(avctx, AV_LOG_ERROR, "Unable to allocate buffer\n");
++        avframe->width  = avctx->width;
++        avframe->height = avctx->height;
++
++        ret = ff_decode_frame_props(avctx, avframe);
++        if(ret < 0) {
++            av_log(avctx, AV_LOG_ERROR, "Unable to fill buffer props\n");
+             goto end;
+         }
+ 
+-        ret = av_image_fill_arrays(dst, linesize, buffer->pBuffer,
+-                                   avctx->pix_fmt, s->stride, s->plane_size, 1);
+-        if (ret < 0){
+-            av_log(avctx, AV_LOG_ERROR, "av_image_fill_arrays ret:%d\n", ret);
++        ret = omx_buf_to_swframe(s, avframe, buffer);
++        if(ret < 0) {
++            av_log(avctx, AV_LOG_ERROR, "Unable to alloce frame\n");
+             goto end;
+         }
+ 
+-        av_image_copy(avframe->data, avframe->linesize, (const uint8_t**)dst, linesize, 
+-                            avctx->pix_fmt, avctx->width, avctx->height);
+         if (pkt->pts) {
+             if (OMXDecodeQueueEmpty(&s->decode_pts_queue) != 0){
+                 av_log(avctx, AV_LOG_ERROR, "The queue of decode pts is empty.\n");
+@@ -1251,10 +1347,7 @@ static int omx_decode_frame(AVCodecConte
+         s->decode_flag += 1;
+         *got_packet = 1;
+ 
+-        /*
+-        if ((ret = av_frame_ref(data, avframe)) < 0)
+-            goto end;
+-        */
++        return ret;
+ 
+ end:     
+         err = OMX_FillThisBuffer(s->handle, buffer);

+ 42 - 0
recipes-multimedia/ffmpeg/ffmpeg/0025-FFmpeg-fix-pts-incorrect.patch

@@ -0,0 +1,42 @@
+Description: Fix omx decoder fill frames pts incorrect
+ If there is no pts value from pkt, decoder should fill the pts field 
+ according to the pkt's duration.
+ .
+ ffmpeg (7:5.1.2-1.1) UNRELEASED; urgency=medium
+ .
+   * libavcodec/omxdec:	Optimize copy for omxdec plugins.
+Author: Som Qin <som.qin@starfivetech.com>
+
+---
+The information above should follow the Patch Tagging Guidelines, please
+checkout https://dep.debian.net/deps/dep3/ to learn about the format. Here
+are templates for supplementary fields that you might want to add:
+
+Origin: (upstream|backport|vendor|other), (<patch-url>|commit:<commit-id>)
+Bug: <upstream-bugtracker-url>
+Bug-Debian: https://bugs.debian.org/<bugnumber>
+Bug-Ubuntu: https://launchpad.net/bugs/<bugnumber>
+Forwarded: (no|not-needed|<patch-forwarded-url>)
+Applied-Upstream: <version>, (<commit-url>|commit:<commid-id>)
+Reviewed-By: <name and email of someone who approved/reviewed the patch>
+Last-Update: 2023-04-23
+
+--- ffmpeg-5.1.2.orig/libavcodec/omxdec.c
++++ ffmpeg-5.1.2/libavcodec/omxdec.c
+@@ -1217,7 +1217,15 @@ static int omx_decode_frame(AVCodecConte
+                                      pkt->size, pkt->pts, pkt->dts, pkt->duration);
+     av_log(avctx, AV_LOG_VERBOSE, "avctx->pts_correction_last_pts: %ld avctx->pts_correction_last_dts: %ld\n",
+                                      avctx->pts_correction_last_pts, avctx->pts_correction_last_dts);
+-    OMXDecodeQueuePush(&s->decode_pts_queue, pkt->dts);
++    if (pkt->dts != AV_NOPTS_VALUE) {
++        OMXDecodeQueuePush(&s->decode_pts_queue, pkt->dts);
++    } else {
++        if (OMXDecodeQueueEmpty(&s->decode_pts_queue)) {
++            OMXDecodeQueuePush(&s->decode_pts_queue, 0);
++        } else {
++            OMXDecodeQueuePush(&s->decode_pts_queue, s->decode_pts_queue.tail->val + pkt->duration);
++        }
++    }
+     if (pkt->size) {
+ 
+         //VPU init and fill buffer slow, so empty buf sleep to send before get vpu fill buf.

+ 212 - 0
recipes-multimedia/ffmpeg/ffmpeg_5.1.2.bb

@@ -0,0 +1,212 @@
+SUMMARY = "A complete, cross-platform solution to record, convert and stream audio and video."
+DESCRIPTION = "FFmpeg is the leading multimedia framework, able to decode, encode, transcode, \
+               mux, demux, stream, filter and play pretty much anything that humans and machines \
+               have created. It supports the most obscure ancient formats up to the cutting edge."
+HOMEPAGE = "https://www.ffmpeg.org/"
+SECTION = "libs"
+
+LICENSE = "GPL-2.0-or-later & LGPL-2.1-or-later & ISC & MIT & BSD-2-Clause & BSD-3-Clause & IJG"
+LICENSE:${PN} = "GPL-2.0-or-later"
+LICENSE:libavcodec = "${@bb.utils.contains('PACKAGECONFIG', 'gpl', 'GPL-2.0-or-later', 'LGPL-2.1-or-later', d)}"
+LICENSE:libavdevice = "${@bb.utils.contains('PACKAGECONFIG', 'gpl', 'GPL-2.0-or-later', 'LGPL-2.1-or-later', d)}"
+LICENSE:libavfilter = "${@bb.utils.contains('PACKAGECONFIG', 'gpl', 'GPL-2.0-or-later', 'LGPL-2.1-or-later', d)}"
+LICENSE:libavformat = "${@bb.utils.contains('PACKAGECONFIG', 'gpl', 'GPL-2.0-or-later', 'LGPL-2.1-or-later', d)}"
+LICENSE:libavutil = "${@bb.utils.contains('PACKAGECONFIG', 'gpl', 'GPL-2.0-or-later', 'LGPL-2.1-or-later', d)}"
+LICENSE:libpostproc = "GPL-2.0-or-later"
+LICENSE:libswresample = "${@bb.utils.contains('PACKAGECONFIG', 'gpl', 'GPL-2.0-or-later', 'LGPL-2.1-or-later', d)}"
+LICENSE:libswscale = "${@bb.utils.contains('PACKAGECONFIG', 'gpl', 'GPL-2.0-or-later', 'LGPL-2.1-or-later', d)}"
+LICENSE_FLAGS = "commercial"
+
+LIC_FILES_CHKSUM = "file://COPYING.GPLv2;md5=b234ee4d69f5fce4486a80fdaf4a4263 \
+                    file://COPYING.GPLv3;md5=d32239bcb673463ab874e80d47fae504 \
+                    file://COPYING.LGPLv2.1;md5=bd7a443320af8c812e4c18d1b79df004 \
+                    file://COPYING.LGPLv3;md5=e6a600fd5e1d9cbde2d983680233ad02"
+
+S = "${WORKDIR}/${BP}"
+FILESEXTRAPATHS:prepend := "${THISDIR}/${PN}:"
+
+SRC_URI += " \
+	https://www.ffmpeg.org/releases/${BP}.tar.xz \
+	file://0001-Add-sf-extra-folder.patch \
+	file://0001-hwcontext_vulkan-remove-optional-encode-decode-exten.patch \
+	file://0005-avcodec-add-omx-decoder-support.patch \
+	file://0006-add-hevc-decoder-and-encoder-support.patch \
+	file://0007-avcoder-fix-decoder-bug.patch \
+	file://0008-fix-omx-decoder-setting-pix-fmt-bug.patch \
+	file://0009-ffmpeg-add-mjpeg-decoder-support-and-fix-some-bug.patch \
+	file://0010-ffmpeg-support-to-change-gop.patch \
+	file://0011-ffmpeg-add-delay-for-decoding.patch \
+	file://0012-ffmpeg-add-omx_pix_fmt.patch \
+	file://0013-ffmpeg-replace-the-indent-with-space.patch \
+	file://0014-ffmpeg-add-pixel-foramt.patch \
+	file://0015-ffmpeg-remove-delay.patch \
+	file://0016-FFmpeg-omx-add-scale-option-for-omx.patch \
+	file://0017-FFmpeg-omxdec-add-mirror-rotation-and-crop-option.patch \
+	file://0018-FFmpeg-omx-gop-parameter-of-hevc-encoder.patch \
+	file://0019-FFmpeg-omcdec-fix-mjpeg_omx-decoder-scale-option-bug.patch \
+	file://0020-FFmpeg-omxdec-modify-the-range-of-width-and-height-o.patch \
+	file://0021-FFmpeg-omxdec-set-pts-of-avframe-and-fix-some-compil.patch \
+	file://0022-FFmpeg-enable-internal-optimize.patch \
+	file://0023-FFmpeg_upstream_AVCodec_struct_to_FFCodec.patch \
+	file://0024-FFmpeg-optimize-copy-for-omxdec.patch \
+	file://0025-FFmpeg-fix-pts-incorrect.patch \
+	"
+
+SRC_URI[sha256sum] = "619e706d662c8420859832ddc259cd4d4096a48a2ce1eefd052db9e440eef3dc"
+
+# Build fails when thumb is enabled: https://bugzilla.yoctoproject.org/show_bug.cgi?id=7717
+ARM_INSTRUCTION_SET:armv4 = "arm"
+ARM_INSTRUCTION_SET:armv5 = "arm"
+ARM_INSTRUCTION_SET:armv6 = "arm"
+
+# Should be API compatible with libav (which was a fork of ffmpeg)
+# libpostproc was previously packaged from a separate recipe
+PROVIDES = "libav libpostproc"
+
+DEPENDS = "nasm-native"
+
+inherit autotools pkgconfig
+
+PACKAGECONFIG ??= " \
+	avdevice avfilter avcodec avformat swresample swscale postproc \
+	alsa bzlib lzma pic pthreads shared theora zlib \
+	${@bb.utils.contains('AVAILTUNES', 'mips32r2', 'mips32r2', '', d)} \
+	${@bb.utils.contains('DISTRO_FEATURES', 'x11', 'xv xcb', '', d)} \
+	gpl mp3lame libopus speex srt theora libvorbis vpx omx sdl2 \
+	"
+
+# libraries to build in addition to avutil
+PACKAGECONFIG[avdevice] = "--enable-avdevice,--disable-avdevice"
+PACKAGECONFIG[avfilter] = "--enable-avfilter,--disable-avfilter"
+PACKAGECONFIG[avcodec] = "--enable-avcodec,--disable-avcodec"
+PACKAGECONFIG[avformat] = "--enable-avformat,--disable-avformat"
+PACKAGECONFIG[swresample] = "--enable-swresample,--disable-swresample"
+PACKAGECONFIG[swscale] = "--enable-swscale,--disable-swscale"
+PACKAGECONFIG[postproc] = "--enable-postproc,--disable-postproc"
+PACKAGECONFIG[omx] = "--enable-omx,--disable-omx"
+
+# features to support
+PACKAGECONFIG[alsa] = "--enable-alsa,--disable-alsa,alsa-lib"
+PACKAGECONFIG[altivec] = "--enable-altivec,--disable-altivec,"
+PACKAGECONFIG[bzlib] = "--enable-bzlib,--disable-bzlib,bzip2"
+PACKAGECONFIG[fdk-aac] = "--enable-libfdk-aac --enable-nonfree,--disable-libfdk-aac,fdk-aac"
+PACKAGECONFIG[gpl] = "--enable-gpl,--disable-gpl"
+PACKAGECONFIG[gsm] = "--enable-libgsm,--disable-libgsm,libgsm"
+PACKAGECONFIG[jack] = "--enable-indev=jack,--disable-indev=jack,jack"
+PACKAGECONFIG[libopus] = "--enable-libopus,--disable-libopus,libopus"
+PACKAGECONFIG[libvorbis] = "--enable-libvorbis,--disable-libvorbis,libvorbis"
+PACKAGECONFIG[lzma] = "--enable-lzma,--disable-lzma,xz"
+PACKAGECONFIG[mfx] = "--enable-libmfx,--disable-libmfx,intel-mediasdk"
+PACKAGECONFIG[mp3lame] = "--enable-libmp3lame,--disable-libmp3lame,lame"
+PACKAGECONFIG[openssl] = "--enable-openssl,--disable-openssl,openssl"
+PACKAGECONFIG[sdl2] = "--enable-sdl2,--disable-sdl2,virtual/libsdl2"
+PACKAGECONFIG[speex] = "--enable-libspeex,--disable-libspeex,speex"
+PACKAGECONFIG[srt] = "--enable-libsrt,--disable-libsrt,srt"
+PACKAGECONFIG[theora] = "--enable-libtheora,--disable-libtheora,libtheora libogg"
+PACKAGECONFIG[vaapi] = "--enable-vaapi,--disable-vaapi,libva"
+PACKAGECONFIG[vdpau] = "--enable-vdpau,--disable-vdpau,libvdpau"
+PACKAGECONFIG[vpx] = "--enable-libvpx,--disable-libvpx,libvpx"
+PACKAGECONFIG[x264] = "--enable-libx264,--disable-libx264,x264"
+PACKAGECONFIG[x265] = "--enable-libx265,--disable-libx265,x265"
+PACKAGECONFIG[xcb] = "--enable-libxcb,--disable-libxcb,libxcb"
+PACKAGECONFIG[xv] = "--enable-outdev=xv,--disable-outdev=xv,libxv"
+PACKAGECONFIG[zlib] = "--enable-zlib,--disable-zlib,zlib"
+
+# other configuration options
+PACKAGECONFIG[mips32r2] = ",--disable-mipsdsp --disable-mipsdspr2"
+PACKAGECONFIG[pic] = "--enable-pic"
+PACKAGECONFIG[pthreads] = "--enable-pthreads,--disable-pthreads"
+PACKAGECONFIG[shared] = "--enable-shared"
+PACKAGECONFIG[strip] = ",--disable-stripping"
+
+# Check codecs that require --enable-nonfree
+USE_NONFREE = "${@bb.utils.contains_any('PACKAGECONFIG', [ 'openssl' ], 'yes', '', d)}"
+
+def cpu(d):
+    for arg in (d.getVar('TUNE_CCARGS') or '').split():
+        if arg.startswith('-mcpu='):
+            return arg[6:]
+    return 'generic'
+
+EXTRA_OECONF = " \
+    ${@bb.utils.contains('USE_NONFREE', 'yes', '--enable-nonfree', '', d)} \
+    \
+    --cross-prefix=${TARGET_PREFIX} \
+    \
+    --ld='${CCLD}' \
+    --cc='${CC}' \
+    --cxx='${CXX}' \
+    --arch=${TARGET_ARCH} \
+    --target-os='linux' \
+    --enable-cross-compile \
+    --extra-cflags='${CFLAGS} ${HOST_CC_ARCH}${TOOLCHAIN_OPTIONS}' \
+    --extra-ldflags='${LDFLAGS}' \
+    --sysroot='${STAGING_DIR_TARGET}' \
+    ${EXTRA_FFCONF} \
+    --libdir=${libdir} \
+    --shlibdir=${libdir} \
+    --datadir=${datadir}/ffmpeg \
+    --cpu=${@cpu(d)} \
+    --pkg-config=pkg-config \
+"
+
+EXTRA_OECONF:append:linux-gnux32 = " --disable-asm"
+
+EXTRA_OECONF += "${@bb.utils.contains('TUNE_FEATURES', 'mipsisa64r6', '--disable-mips64r2 --disable-mips32r2', '', d)}"
+EXTRA_OECONF += "${@bb.utils.contains('TUNE_FEATURES', 'mipsisa64r2', '--disable-mips64r6 --disable-mips32r6', '', d)}"
+EXTRA_OECONF += "${@bb.utils.contains('TUNE_FEATURES', 'mips32r2', '--disable-mips64r6 --disable-mips32r6', '', d)}"
+EXTRA_OECONF += "${@bb.utils.contains('TUNE_FEATURES', 'mips32r6', '--disable-mips64r2 --disable-mips32r2', '', d)}"
+EXTRA_OECONF:append:mips = " --extra-libs=-latomic --disable-mips32r5 --disable-mipsdsp --disable-mipsdspr2 \
+                             --disable-loongson2 --disable-loongson3 --disable-mmi --disable-msa"
+EXTRA_OECONF:append:riscv32 = " --extra-libs=-latomic"
+EXTRA_OECONF:append:armv5 = " --extra-libs=-latomic"
+EXTRA_OECONF:append:powerpc = " --extra-libs=-latomic"
+
+# gold crashes on x86, another solution is to --disable-asm but thats more hacky
+# ld.gold: internal error in relocate_section, at ../../gold/i386.cc:3684
+
+LDFLAGS:append:x86 = "${@bb.utils.contains('DISTRO_FEATURES', 'ld-is-gold', ' -fuse-ld=bfd ', '', d)}"
+
+EXTRA_OEMAKE = "V=1"
+
+CFLAGS += "-I${S}/sf-extra/omx-il"
+
+do_configure() {
+    export TMPDIR="${B}/tmp"
+    mkdir -p ${B}/tmp
+    ${S}/configure ${EXTRA_OECONF}
+    sed -i -e "s,^X86ASMFLAGS=.*,& --debug-prefix-map=${S}=/usr/src/debug/${PN}/${EXTENDPE}${PV}-${PR} --debug-prefix-map=${B}=/usr/src/debug/${PN}/${EXTENDPE}${PV}-${PR},g" ${B}/ffbuild/config.mak
+}
+
+# patch out build host paths for reproducibility
+do_compile:prepend:class-target() {
+        sed -i -e "s,${WORKDIR},,g" ${B}/config.h
+}
+
+PACKAGES =+ "libavcodec \
+             libavdevice \
+             libavfilter \
+             libavformat \
+             libavutil \
+             libpostproc \
+             libswresample \
+             libswscale \
+	     "
+
+FILES:libavcodec = "${libdir}/libavcodec${SOLIBS}"
+FILES:libavdevice = "${libdir}/libavdevice${SOLIBS}"
+FILES:libavfilter = "${libdir}/libavfilter${SOLIBS}"
+FILES:libavformat = "${libdir}/libavformat${SOLIBS}"
+FILES:libavutil = "${libdir}/libavutil${SOLIBS}"
+FILES:libpostproc = "${libdir}/libpostproc${SOLIBS}"
+FILES:libswresample = "${libdir}/libswresample${SOLIBS}"
+FILES:libswscale = "${libdir}/libswscale${SOLIBS}"
+# ffmpeg disables PIC on some platforms (e.g. x86-32)
+INSANE_SKIP:${MLPREFIX}libavcodec = "textrel"
+INSANE_SKIP:${MLPREFIX}libavdevice = "textrel"
+INSANE_SKIP:${MLPREFIX}libavfilter = "textrel"
+INSANE_SKIP:${MLPREFIX}libavformat = "textrel"
+INSANE_SKIP:${MLPREFIX}libavutil = "textrel"
+INSANE_SKIP:${MLPREFIX}libswscale = "textrel"
+INSANE_SKIP:${MLPREFIX}libswresample = "textrel"
+INSANE_SKIP:${MLPREFIX}libpostproc = "textrel"