main/omxplayer: add tentative support for alsa

For playing videos with audio output via add-on board.
Tentative version and subject for changes.

This is basically the code from:
https://github.com/stupid-boy/xbmc/commits/OMX_ALSA

but it has been rebased, fitted to omxplayer and modified slightly
to compile with omxplayer default compiler flags.

2 files changed, 6514 insertions, 2 deletions

diff --git a/main/omxplayer/APKBUILD b/main/omxplayer/APKBUILD
index 8ea504b2ee..438a2d6250 100644
--- a/main/omxplayer/APKBUILD
+++ b/main/omxplayer/APKBUILD
@@ -2,14 +2,14 @@
 pkgname=omxplayer
 pkgver=0.20150911
 _commitid=d99bd86c9fd80ea01f98761e130d7ac9a2bb7588
-pkgrel=1
+pkgrel=2
 pkgdesc="Commandline OMX player for Raspberry Pi"
 url="https://github.com/popcornmix/omxplayer"
 arch="armhf"
 license="GPLv2"
 depends="ttf-freefont"
 makedepends="linux-headers raspberrypi-dev ffmpeg-dev pcre-dev
-	boost-dev freetype-dev dbus-dev"
+	boost-dev freetype-dev dbus-dev alsa-lib-dev"
 install=""
 subpackages="$pkgname-doc $pkgname-dbg"
 source="omxplayer-$pkgver.tar.gz::https://github.com/popcornmix/omxplayer/archive/$_commitid.tar.gz
@@ -17,6 +17,7 @@ source="omxplayer-$pkgver.tar.gz::https://github.com/popcornmix/omxplayer/archiv
 	issue-297.patch
 	fix-makefile.patch
 	default-font.patch
+	omxplayer-alsa.patch
 
 	omxplayer.initd
 	omxplayer.confd
@@ -62,6 +63,7 @@ a900cdded87b7df503c6599ac43bd8de  issue-260.patch
 4cd10bfb7e995288f4efc312acbc4252  issue-297.patch
 d8f335e1dff4b34faf36c25ad2c2b881  fix-makefile.patch
 9ebd96155288809fe0a657cf491e433f  default-font.patch
+628a9bc0b26f75547299e92542e65d47  omxplayer-alsa.patch
 b4054a311d76aef91aa10bacd68bc9c4  omxplayer.initd
 80e37e7ac04402808015084e26e6072d  omxplayer.confd"
 sha256sums="9be32352afd9198c733b74b1a2ec9a9b73a0ee2777c79e76914df00c9c6e5115  omxplayer-0.20150911.tar.gz
@@ -69,6 +71,7 @@ sha256sums="9be32352afd9198c733b74b1a2ec9a9b73a0ee2777c79e76914df00c9c6e5115  om
 75cf8af95b35bc734550c55036ef49dbff04b6940f3317b51eddea06866ecf3a  issue-297.patch
 799b0aba6aef8c665a685777cd912268315309d0d74ce76be5fdfd0dcffbb422  fix-makefile.patch
 2bab3d05b12d730737220b8c0052498a34bbebc12b7beb8afb3c054beb0fb3bb  default-font.patch
+87dc80b61ce6c69a52637dffb64f526e7fa213e4c2b0c97177457c95851ec594  omxplayer-alsa.patch
 e2db0f7ffbe2488dd69ee0bfad006bd863f418554f078ca3432f643de7589d2f  omxplayer.initd
 530eb9aa50e72fb4828af410b965e0ec7653d1bed87aa86bf04fc340ff3232bd  omxplayer.confd"
 sha512sums="a552b508981ebbed8c70fc92d3556502da97902d4ed1d2c4c68670d0eba0565759ddecf4d8821697dab7388bed1d3246673e0a9ee558ee1a817c1483db3c89f3  omxplayer-0.20150911.tar.gz
@@ -76,5 +79,6 @@ c349eea5f7c513a07d82a6cf6467c4d21bcb29c053bc5e39d8f675b1212db9beef0abf5248d50ac5
 606c71dc4e47bd1303ecb21bd6f265f61223f792e45661b724fbdc09619d4c0cf1f9c10fd2680a2889685516849076d1bddabfed5edbcbf09e9a246e92a25c4e  issue-297.patch
 3210242f9b834ffec9d3077d5a25caf8be84aa7f4f13c73eb7f61c0a406ec787e4055951fc5a6236f1da7897c95db94a5e11e25d1b3e859a6ea67f31fc6eb517  fix-makefile.patch
 8aa58aaa07453186302dc68d92f28c1b50bf0f8fccd50359640a7fc8339b233b32a0c8c02284a9974599e56d69cc557acc25e76e6438c6d64d15afd9c1788a8e  default-font.patch
+bc11327631453026784a7b80efb259f6f86a670a12dfc3ba8b92b841611db73408ffab89b9c131bc7ff59695a5eef6f3e94af19136ffcfcbac9a9a7362a93f5f  omxplayer-alsa.patch
 3ddd32235d87a46478d0237ee9b253edeb75729e377b09a33069ecdca2ee230d2851f308897ee75ff69a9f3bdd2876f490bc1667a572dce1c186f80fddcf6df3  omxplayer.initd
 4f906ada035869a0e515e7615056b18b0f6906ce4b3a2d34081c0efa79bb9455380f729e7c5270180f5ace89c53a7ac7c93f609e6761825f639f44aa22346bb2  omxplayer.confd"
diff --git a/main/omxplayer/omxplayer-alsa.patch b/main/omxplayer/omxplayer-alsa.patch
new file mode 100644
index 0000000000..0886b896a3
--- /dev/null
+++ b/main/omxplayer/omxplayer-alsa.patch
@@ -0,0 +1,6508 @@
+diff --git a/Makefile b/Makefile
+index 9fc45de..921b449 100644
+--- a/Makefile
++++ b/Makefile
+@@ -8,7 +8,21 @@ INCLUDES+=-I./ -Ilinux -Iffmpeg_compiled/usr/local/include/ -I /usr/include/dbus
+ 
+ DIST ?= omxplayer-dist
+ 
+-SRC=linux/XMemUtils.cpp \
++INCLUDES+=-Ialsa
++LDFLAGS+=-lasound
++SRC += \
++	alsa/omx_semaphore.cpp \
++	alsa/omx_alsasink_component.cpp \
++	alsa/omx_base_audio_port.cpp \
++	alsa/omx_base_clock_port.cpp \
++	alsa/omx_base_component.cpp \
++	alsa/omx_base_port.cpp \
++	alsa/omx_base_sink.cpp \
++	alsa/omx_queue.cpp \
++	alsa/omx_loader_XBMC.cpp
++
++SRC += \
++		linux/XMemUtils.cpp \
+ 		utils/log.cpp \
+ 		DynamicDll.cpp \
+ 		utils/PCMRemap.cpp \
+@@ -34,8 +48,9 @@ SRC=linux/XMemUtils.cpp \
+ 		Srt.cpp \
+ 		KeyConfig.cpp \
+ 		OMXControl.cpp \
+-		Keyboard.cpp \
+-		omxplayer.cpp \
++		Keyboard.cpp
++
++SRC += omxplayer.cpp
+ 
+ OBJS+=$(filter %.o,$(SRC:.cpp=.o))
+ 
+diff --git a/Makefile.include b/Makefile.include
+index 58e9560..3b99d3b 100644
+--- a/Makefile.include
++++ b/Makefile.include
+@@ -1,40 +1,5 @@
+-USE_BUILDROOT=0
+-FLOAT=hard
+-
+-ifeq ($(USE_BUILDROOT), 1)
+-BUILDROOT	:=/opt/xbmc-bcm/buildroot
+-SDKSTAGE	:=$(BUILDROOT)/output/staging
+-TARGETFS	:=$(BUILDROOT)/output/target
+-TOOLCHAIN	:=$(BUILDROOT)/output/host/usr/
+-HOST			:=arm-unknown-linux-gnueabi
+-SYSROOT		:=$(BUILDROOT)/output/host/usr/arm-unknown-linux-gnueabi/sysroot
+-else
+-BUILDROOT	:=/opt/bcm-rootfs
+-SDKSTAGE	:=/opt/bcm-rootfs
+-TARGETFS	:=/opt/bcm-rootfs
+-TOOLCHAIN	:=/home/dc4/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian/
+-HOST		:=arm-linux-gnueabihf
+-#SYSROOT		:=$(TOOLCHAIN)/arm-bcm2708hardfp-linux-gnueabi/sysroot
+-SYSROOT		:=/opt/bcm-rootfs
+-endif
+-
+-JOBS=7
+-
+-CFLAGS			:= -isystem$(PREFIX)/include
+-CXXFLAGS		:= $(CFLAGS)
+-CPPFLAGS		:= $(CFLAGS)
+-LDFLAGS			:= -L$(BUILDROOT)/lib
+-LD					:= $(TOOLCHAIN)/bin/$(HOST)-ld --sysroot=$(SYSROOT)
+-CC					:= $(TOOLCHAIN)/bin/$(HOST)-gcc --sysroot=$(SYSROOT)
+-CXX         := $(TOOLCHAIN)/bin/$(HOST)-g++ --sysroot=$(SYSROOT)
+-OBJDUMP			:= $(TOOLCHAIN)/bin/$(HOST)-objdump
+-RANLIB			:= $(TOOLCHAIN)/bin/$(HOST)-ranlib
+-STRIP				:= $(TOOLCHAIN)/bin/$(HOST)-strip
+-AR 					:= $(TOOLCHAIN)/bin/$(HOST)-ar
+-CXXCP 			:= $(CXX) -E
+-PATH 				:= $(PREFIX)/bin:$(BUILDROOT)/output/host/usr/bin:$(PATH)
+-
+-CFLAGS			+= -pipe -mfloat-abi=$(FLOAT) -mcpu=arm1176jzf-s -fomit-frame-pointer -mabi=aapcs-linux -mtune=arm1176jzf-s -mfpu=vfp -Wno-psabi -mno-apcs-stack-check -g -mstructure-size-boundary=32 -mno-sched-prolog
+-LDFLAGS			+= -L$(SDKSTAGE)/lib -L$(SDKSTAGE)/usr/lib -L$(SDKSTAGE)/opt/vc/lib/ -Lpcre/build
+-#INCLUDES		+= -isystem$(SDKSTAGE)/usr/include -isystem$(SDKSTAGE)/opt/vc/include -isystem$(SYSROOT)/usr/include -isystem$(SDKSTAGE)/opt/vc/include/interface/vcos/pthreads -isystem$(SDKSTAGE)/usr/include/freetype2
+-INCLUDES		+= -isystem$(SDKSTAGE)/opt/vc/include -isystem$(SYSROOT)/usr/include -isystem$(SDKSTAGE)/opt/vc/include/interface/vcos/pthreads -Ipcre/build -Iboost-trunk -Ifreetype2/include
++INCLUDES:=-I/opt/vc/include -I/opt/vc/include/interface/vcos/pthreads -I/opt/vc/include/interface/vmcs_host/linux
++INCLUDES+=-I/usr/include/freetype2 -I/usr/include/libpng16 -I/usr/include/dbus-1.0 -I/usr/lib/dbus-1.0/include  
++LDFLAGS:=-L/opt/vc/lib -Wl,-rpath,/opt/vc/lib
++LDFLAGS+=-lfreetype -ldbus-1  
++STRIP:=echo
+diff --git a/OMXAudio.cpp b/OMXAudio.cpp
+index 41f282d..e1e82c4 100644
+--- a/OMXAudio.cpp
++++ b/OMXAudio.cpp
+@@ -112,6 +112,11 @@ bool COMXAudio::PortSettingsChanged()
+     if(!m_omx_render_hdmi.Initialize("OMX.broadcom.audio_render", OMX_IndexParamAudioInit))
+       return false;
+   }
++  if (m_config.device == "omx:alsa")
++  {
++    if(!m_omx_render_analog.Initialize("OMX.XBMC.alsa.alsasink", OMX_IndexParamAudioInit))
++      return false;
++  }
+ 
+   UpdateAttenuation();
+ 
+diff --git a/OMXCore.cpp b/OMXCore.cpp
+index 9d5fe61..389c41e 100644
+--- a/OMXCore.cpp
++++ b/OMXCore.cpp
+@@ -35,6 +35,7 @@
+ 
+ #ifdef TARGET_LINUX
+ #include "XMemUtils.h"
++#include "alsa/omx_loader_XBMC.h"
+ #endif
+ 
+ //#define OMX_DEBUG_EVENTS
+@@ -1430,6 +1431,12 @@ bool COMXCoreComponent::Initialize( const std::string &component_name, OMX_INDEX
+   if(!m_handle)
+   {
+     omx_err = m_DllOMX->OMX_GetHandle(&m_handle, (char*)component_name.c_str(), this, &m_callbacks);
++#ifdef TARGET_LINUX
++    if (strncmp("OMX.XBMC.", component_name.c_str(), 9) == 0)
++      omx_err = OMX_GetHandle_XBMC(&m_handle, (char*) component_name.c_str(), this, &m_callbacks);
++    else
++#endif
++    omx_err = m_DllOMX->OMX_GetHandle(&m_handle, (char*)component_name.c_str(), this, &m_callbacks);
+     if (!m_handle || omx_err != OMX_ErrorNone)
+     {
+       CLog::Log(LOGERROR, "COMXCoreComponent::Initialize - could not get component handle for %s omx_err(0x%08x)\n",
+@@ -1505,6 +1512,11 @@ bool COMXCoreComponent::Deinitialize()
+ 
+     CLog::Log(LOGDEBUG, "COMXCoreComponent::Deinitialize : %s handle %p\n",
+         m_componentName.c_str(), m_handle);
++#ifdef TARGET_LINUX
++    if (strncmp("OMX.XBMC.", m_componentName.c_str(), 9) == 0)
++      omx_err = OMX_FreeHandle_XBMC(m_handle);
++    else
++#endif
+     omx_err = m_DllOMX->OMX_FreeHandle(m_handle);
+     if (omx_err != OMX_ErrorNone)
+     {
+diff --git a/README.md b/README.md
+index 2eb78f3..f70d73c 100644
+--- a/README.md
++++ b/README.md
+@@ -55,7 +55,7 @@ Usage: omxplayer [OPTIONS] [FILE]
+     -v  --version               Print version info
+     -k  --keys                  Print key bindings
+     -n  --aidx  index           Audio stream index    : e.g. 1
+-    -o  --adev  device          Audio out device      : e.g. hdmi/local/both
++    -o  --adev  device          Audio out device      : e.g. hdmi/local/both/alsa
+     -i  --info                  Dump stream format and exit
+     -I  --with-info             dump stream format before playback
+     -s  --stats                 Pts and buffer stats
+diff --git a/alsa/omx_alsasink_component.cpp b/alsa/omx_alsasink_component.cpp
+new file mode 100644
+index 0000000..9803e63
+--- /dev/null
++++ b/alsa/omx_alsasink_component.cpp
+@@ -0,0 +1,1035 @@
++/**
++  @file src/components/alsa/omx_alsasink_component.c
++
++  OpenMAX ALSA sink component. This component is an audio sink that uses ALSA library.
++
++  Copyright (C) 2007-2008 STMicroelectronics
++  Copyright (C) 2007-2008 Nokia Corporation and/or its subsidiary(-ies).
++
++  This library 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.
++
++  This library 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 this library; if not, write to the Free Software Foundation, Inc.,
++  51 Franklin St, Fifth Floor, Boston, MA
++  02110-1301  USA
++
++  $Date: 2008-08-08 06:56:06 +0200 (Fri, 08 Aug 2008) $
++  Revision $Rev: 581 $
++  Author $Author: pankaj_sen $
++
++*/
++
++#undef OMX_SKIP64BIT
++#include <omx_base_component.h>
++#include <omx_base_audio_port.h>
++#include <omx_base_clock_port.h>
++#include <omx_alsasink_component.h>
++
++/** Maximum Number of AlsaSink Instance*/
++#define MAX_COMPONENT_ALSASINK 1
++
++/** Number of AlsaSink Instance*/
++static OMX_U32 noAlsasinkInstance=0;
++
++#ifdef AV_SYNC_LOG  /* for checking AV sync */ //TODO : give seg fault if enabled
++static FILE *fd = NULL;
++#endif
++
++/** The Constructor
++ */
++OMX_ERRORTYPE omx_alsasink_component_Constructor(OMX_COMPONENTTYPE *openmaxStandComp,OMX_STRING cComponentName) {
++  int                                 err;
++  int                                 omxErr;
++  omx_base_audio_PortType             *pPort;
++  omx_alsasink_component_PrivateType* omx_alsasink_component_Private;
++
++  if (!openmaxStandComp->pComponentPrivate) {
++    openmaxStandComp->pComponentPrivate = calloc(1, sizeof(omx_alsasink_component_PrivateType));
++    if(openmaxStandComp->pComponentPrivate==NULL) {
++      return OMX_ErrorInsufficientResources;
++    }
++  }
++
++  omx_alsasink_component_Private = (omx_alsasink_component_PrivateType*)openmaxStandComp->pComponentPrivate;
++  omx_alsasink_component_Private->ports = NULL;
++
++  omxErr = omx_base_sink_Constructor(openmaxStandComp,cComponentName);
++  if (omxErr != OMX_ErrorNone) {
++    return OMX_ErrorInsufficientResources;
++  }
++
++  omx_alsasink_component_Private->sPortTypesParam[OMX_PortDomainAudio].nStartPortNumber = 0;
++  omx_alsasink_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts = 1;
++
++  omx_alsasink_component_Private->sPortTypesParam[OMX_PortDomainOther].nStartPortNumber = 1;
++  omx_alsasink_component_Private->sPortTypesParam[OMX_PortDomainOther].nPorts = 1;
++
++  /** Allocate Ports and call port constructor. */
++  if ((omx_alsasink_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts +
++       omx_alsasink_component_Private->sPortTypesParam[OMX_PortDomainOther].nPorts)
++       && !omx_alsasink_component_Private->ports) {
++    omx_alsasink_component_Private->ports = (omx_base_PortType**)calloc((omx_alsasink_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts +
++                                                    omx_alsasink_component_Private->sPortTypesParam[OMX_PortDomainOther].nPorts), sizeof(omx_base_PortType *));
++    if (!omx_alsasink_component_Private->ports) {
++      return OMX_ErrorInsufficientResources;
++    }
++    omx_alsasink_component_Private->ports[0] = (omx_base_PortType*)calloc(1, sizeof(omx_base_audio_PortType));
++    if (!omx_alsasink_component_Private->ports[0]) {
++      return OMX_ErrorInsufficientResources;
++    }
++    base_audio_port_Constructor(openmaxStandComp, &omx_alsasink_component_Private->ports[0], 0, OMX_TRUE);
++
++    omx_alsasink_component_Private->ports[1] = (omx_base_PortType*)calloc(1, sizeof(omx_base_clock_PortType));
++    if (!omx_alsasink_component_Private->ports[1]) {
++      return OMX_ErrorInsufficientResources;
++    }
++    base_clock_port_Constructor(openmaxStandComp, &omx_alsasink_component_Private->ports[1], 1, OMX_TRUE);
++    omx_alsasink_component_Private->ports[1]->sPortParam.bEnabled = OMX_FALSE;
++  }
++
++  pPort = (omx_base_audio_PortType *) omx_alsasink_component_Private->ports[OMX_BASE_SINK_INPUTPORT_INDEX];
++
++  // set the pPort params, now that the ports exist
++  /** Domain specific section for the ports. */
++  pPort->sPortParam.format.audio.eEncoding = OMX_AUDIO_CodingPCM;
++  /*Input pPort buffer size is equal to the size of the output buffer of the previous component*/
++  pPort->sPortParam.nBufferSize = DEFAULT_OUT_BUFFER_SIZE;
++
++ /* Initializing the function pointers */
++  omx_alsasink_component_Private->BufferMgmtCallback  = omx_alsasink_component_BufferMgmtCallback;
++  omx_alsasink_component_Private->destructor          = omx_alsasink_component_Destructor;
++  pPort->Port_SendBufferFunction                      = omx_alsasink_component_port_SendBufferFunction;
++  pPort->FlushProcessingBuffers                       = omx_alsasink_component_port_FlushProcessingBuffers;
++
++  setHeader(&pPort->sAudioParam, sizeof(OMX_AUDIO_PARAM_PORTFORMATTYPE));
++  pPort->sAudioParam.nPortIndex = 0;
++  pPort->sAudioParam.nIndex = 0;
++  pPort->sAudioParam.eEncoding = OMX_AUDIO_CodingPCM;
++
++  /* OMX_AUDIO_PARAM_PCMMODETYPE */
++  setHeader(&omx_alsasink_component_Private->sPCMModeParam, sizeof(OMX_AUDIO_PARAM_PCMMODETYPE));
++  omx_alsasink_component_Private->sPCMModeParam.nPortIndex = 0;
++  omx_alsasink_component_Private->sPCMModeParam.nChannels = 2;
++  omx_alsasink_component_Private->sPCMModeParam.eNumData = OMX_NumericalDataSigned;
++  omx_alsasink_component_Private->sPCMModeParam.eEndian = OMX_EndianLittle;
++  omx_alsasink_component_Private->sPCMModeParam.bInterleaved = OMX_TRUE;
++  omx_alsasink_component_Private->sPCMModeParam.nBitPerSample = 16;
++  omx_alsasink_component_Private->sPCMModeParam.nSamplingRate = 44100;
++  omx_alsasink_component_Private->sPCMModeParam.ePCMMode = OMX_AUDIO_PCMModeLinear;
++  omx_alsasink_component_Private->sPCMModeParam.eChannelMapping[0] = OMX_AUDIO_ChannelNone;
++
++/* testing the A/V sync */
++#ifdef AV_SYNC_LOG
++  fd = fopen("audio_timestamps.out","w");
++  if(!fd) {
++    DEBUG(DEB_LEV_ERR, "Couldn't open audio timestamp log err=%d\n",errno);
++  }
++#endif
++
++  noAlsasinkInstance++;
++  if(noAlsasinkInstance > MAX_COMPONENT_ALSASINK) {
++    return OMX_ErrorInsufficientResources;
++  }
++
++  /* Allocate the playback handle and the hardware parameter structure */
++  char* name = "default";
++  if ((err = snd_pcm_open (&omx_alsasink_component_Private->playback_handle, name, SND_PCM_STREAM_PLAYBACK, 0)) < 0) {
++    DEBUG(DEB_LEV_ERR, "cannot open audio device %s (%s)\n", name, snd_strerror (err));
++    return OMX_ErrorHardware;
++  }
++  else
++    DEBUG(DEB_LEV_SIMPLE_SEQ, "Got playback handle at %p %p in %i\n", omx_alsasink_component_Private->playback_handle, &omx_alsasink_component_Private->playback_handle, getpid());
++
++  if (snd_pcm_status_malloc(&omx_alsasink_component_Private->pcm_status) < 0 ) {
++    DEBUG(DEB_LEV_ERR, "%s: failed allocating pcm_status\n", __func__);
++    return OMX_ErrorHardware;
++  }
++
++  openmaxStandComp->SetParameter  = omx_alsasink_component_SetParameter;
++  openmaxStandComp->GetParameter  = omx_alsasink_component_GetParameter;
++  openmaxStandComp->GetConfig     = omx_alsasink_component_GetConfig;
++
++  /* Write in the default parameters */
++  omx_alsasink_component_Private->AudioPCMConfigured  = 0;
++  omx_alsasink_component_Private->eState  = OMX_TIME_ClockStateStopped;
++  omx_alsasink_component_Private->xScale  = 1<<16;
++
++  if (!omx_alsasink_component_Private->AudioPCMConfigured) {
++    DEBUG(DEB_LEV_SIMPLE_SEQ, "Configuring the PCM interface in the Init function\n");
++    omxErr = omx_alsasink_component_SetParameter(openmaxStandComp, OMX_IndexParamAudioPcm, &omx_alsasink_component_Private->sPCMModeParam);
++    if(omxErr != OMX_ErrorNone){
++      DEBUG(DEB_LEV_ERR, "In %s Error %08x\n",__func__,omxErr);
++    }
++  }
++
++  return OMX_ErrorNone;
++}
++
++/** The Destructor
++ */
++OMX_ERRORTYPE omx_alsasink_component_Destructor(OMX_COMPONENTTYPE *openmaxStandComp) {
++  omx_alsasink_component_PrivateType* omx_alsasink_component_Private = (omx_alsasink_component_PrivateType*)openmaxStandComp->pComponentPrivate;
++  OMX_U32 i;
++
++  if(omx_alsasink_component_Private->pcm_status) {
++    snd_pcm_status_free(omx_alsasink_component_Private->pcm_status);
++  }
++  if(omx_alsasink_component_Private->playback_handle) {
++    snd_pcm_close(omx_alsasink_component_Private->playback_handle);
++  }
++
++  /* frees port/s */
++  if (omx_alsasink_component_Private->ports) {
++    for (i=0; i < (omx_alsasink_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts +
++                   omx_alsasink_component_Private->sPortTypesParam[OMX_PortDomainOther].nPorts); i++) {
++      if(omx_alsasink_component_Private->ports[i])
++        omx_alsasink_component_Private->ports[i]->PortDestructor(omx_alsasink_component_Private->ports[i]);
++    }
++    free(omx_alsasink_component_Private->ports);
++    omx_alsasink_component_Private->ports=NULL;
++  }
++
++#ifdef AV_SYNC_LOG
++      fclose(fd);
++#endif
++
++  noAlsasinkInstance--;
++
++  return omx_base_sink_Destructor(openmaxStandComp);
++
++}
++
++/** @brief the entry point for sending buffers to the alsa sink port
++ *
++ * This function can be called by the EmptyThisBuffer or FillThisBuffer. It depends on
++ * the nature of the port, that can be an input or output port.
++ */
++OMX_ERRORTYPE omx_alsasink_component_port_SendBufferFunction(omx_base_PortType *openmaxStandPort, OMX_BUFFERHEADERTYPE* pBuffer) {
++
++  OMX_ERRORTYPE                   err;
++  OMX_U32                         portIndex;
++  OMX_COMPONENTTYPE*              omxComponent = openmaxStandPort->standCompContainer;
++  omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)omxComponent->pComponentPrivate;
++  OMX_BOOL                        SendFrame;
++  omx_base_clock_PortType*        pClockPort;
++#if NO_GST_OMX_PATCH
++  unsigned int i;
++#endif
++
++  portIndex = (openmaxStandPort->sPortParam.eDir == OMX_DirInput)?pBuffer->nInputPortIndex:pBuffer->nOutputPortIndex;
++  DEBUG(DEB_LEV_FUNCTION_NAME, "In %s portIndex %lu\n", __func__, (unsigned long)portIndex);
++
++  if (portIndex != openmaxStandPort->sPortParam.nPortIndex) {
++    DEBUG(DEB_LEV_ERR, "In %s: wrong port for this operation portIndex=%d port->portIndex=%d\n",
++           __func__, (int)portIndex, (int)openmaxStandPort->sPortParam.nPortIndex);
++    return OMX_ErrorBadPortIndex;
++  }
++
++  if(omx_base_component_Private->state == OMX_StateInvalid) {
++    DEBUG(DEB_LEV_ERR, "In %s: we are in OMX_StateInvalid\n", __func__);
++    return OMX_ErrorInvalidState;
++  }
++
++  if(omx_base_component_Private->state != OMX_StateExecuting &&
++    omx_base_component_Private->state != OMX_StatePause &&
++    omx_base_component_Private->state != OMX_StateIdle) {
++    DEBUG(DEB_LEV_ERR, "In %s: we are not in executing/paused/idle state, but in %d\n", __func__, omx_base_component_Private->state);
++    return OMX_ErrorIncorrectStateOperation;
++  }
++  if (!PORT_IS_ENABLED(openmaxStandPort) || (PORT_IS_BEING_DISABLED(openmaxStandPort) && !PORT_IS_TUNNELED_N_BUFFER_SUPPLIER(openmaxStandPort)) ||
++      (omx_base_component_Private->transientState == OMX_TransStateExecutingToIdle &&
++      (PORT_IS_TUNNELED(openmaxStandPort) && !PORT_IS_BUFFER_SUPPLIER(openmaxStandPort)))) {
++    DEBUG(DEB_LEV_ERR, "In %s: Port %d is disabled comp = %s \n", __func__, (int)portIndex,omx_base_component_Private->name);
++    return OMX_ErrorIncorrectStateOperation;
++  }
++
++  /* Temporarily disable this check for gst-openmax */
++#if NO_GST_OMX_PATCH
++  {
++  OMX_BOOL foundBuffer = OMX_FALSE;
++  if(pBuffer!=NULL && pBuffer->pBuffer!=NULL) {
++    for(i=0; i < openmaxStandPort->sPortParam.nBufferCountActual; i++){
++    if (pBuffer->pBuffer == openmaxStandPort->pInternalBufferStorage[i]->pBuffer) {
++      foundBuffer = OMX_TRUE;
++      break;
++    }
++    }
++  }
++  if (!foundBuffer) {
++    return OMX_ErrorBadParameter;
++  }
++  }
++#endif
++
++  if ((err = checkHeader(pBuffer, sizeof(OMX_BUFFERHEADERTYPE))) != OMX_ErrorNone) {
++    DEBUG(DEB_LEV_ERR, "In %s: received wrong buffer header on input port\n", __func__);
++    return err;
++  }
++
++  /* And notify the buffer management thread we have a fresh new buffer to manage */
++  if(!PORT_IS_BEING_FLUSHED(openmaxStandPort) && !(PORT_IS_BEING_DISABLED(openmaxStandPort) && PORT_IS_TUNNELED_N_BUFFER_SUPPLIER(openmaxStandPort))){
++      omx_queue(openmaxStandPort->pBufferQueue, pBuffer);
++      omx_tsem_up(openmaxStandPort->pBufferSem);
++      //DEBUG(DEB_LEV_PARAMS, "In %s Signalling bMgmtSem Port Index=%d\n",__func__, (int)portIndex);
++      omx_tsem_up(omx_base_component_Private->bMgmtSem);
++  }else if(PORT_IS_BUFFER_SUPPLIER(openmaxStandPort)){
++      DEBUG(DEB_LEV_FULL_SEQ, "In %s: Comp %s received io:%d buffer\n",
++        __func__,omx_base_component_Private->name,(int)openmaxStandPort->sPortParam.nPortIndex);
++      omx_queue(openmaxStandPort->pBufferQueue, pBuffer);
++      omx_tsem_up(openmaxStandPort->pBufferSem);
++  }
++  else { // If port being flushed and not tunneled then return error
++    DEBUG(DEB_LEV_FULL_SEQ, "In %s \n", __func__);
++    return OMX_ErrorIncorrectStateOperation;
++  }
++  return OMX_ErrorNone;
++}
++
++OMX_ERRORTYPE omx_alsasink_component_GetConfig(
++  OMX_IN  OMX_HANDLETYPE hComponent,
++  OMX_IN  OMX_INDEXTYPE nIndex,
++  OMX_INOUT OMX_PTR pComponentConfigStructure) {
++
++  DEBUG(DEB_LEV_FUNCTION_NAME, "In %s\n", __func__);
++
++  if (nIndex == OMX_IndexConfigAudioRenderingLatency) {
++    OMX_PARAM_U32TYPE* param = (OMX_PARAM_U32TYPE*)pComponentConfigStructure;
++
++    omx_alsasink_component_PrivateType* omx_alsasink_component_Private = (omx_alsasink_component_PrivateType*)((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate;
++
++    if (param->nPortIndex == OMX_BASE_SINK_INPUTPORT_INDEX ) {
++      // As this is used only as bool, we can return 'just something' here.
++      // TODO: Add appropriate processing when needed
++      param->nU32 = omx_alsasink_component_Private->ports[OMX_BASE_SINK_INPUTPORT_INDEX]->pBufferQueue->nelem;
++      DEBUG(DEB_LEV_FUNCTION_NAME, "In %s  OMX_IndexConfigAudioRenderingLatency return %d\n", __func__, param->nU32);
++      return OMX_ErrorNone;
++    }
++  }
++
++  return OMX_ErrorNotImplemented;
++}
++
++
++OMX_BOOL omx_alsasink_component_ClockPortHandleFunction(omx_alsasink_component_PrivateType* omx_alsasink_component_Private, OMX_BUFFERHEADERTYPE* inputbuffer){
++  omx_base_clock_PortType*            pClockPort;
++  OMX_BUFFERHEADERTYPE*               clockBuffer;
++  OMX_TIME_MEDIATIMETYPE*             pMediaTime;
++  OMX_HANDLETYPE                      hclkComponent;
++  OMX_TIME_CONFIG_TIMESTAMPTYPE       sClientTimeStamp;
++  OMX_ERRORTYPE                       err;
++  OMX_BOOL                            SendFrame=OMX_TRUE;
++  omx_base_audio_PortType             *pAudioPort;
++
++  int static                          count=0; //frame counter
++
++  pClockPort    = (omx_base_clock_PortType*)omx_alsasink_component_Private->ports[OMX_BASE_SINK_CLOCKPORT_INDEX];
++  pAudioPort    = (omx_base_audio_PortType *) omx_alsasink_component_Private->ports[OMX_BASE_SINK_INPUTPORT_INDEX];
++  hclkComponent = pClockPort->hTunneledComponent;
++  setHeader(&pClockPort->sMediaTimeRequest, sizeof(OMX_TIME_CONFIG_MEDIATIMEREQUESTTYPE));
++
++  /* check for any scale change information from the clock component */
++  if(pClockPort->pBufferSem->semval>0){
++    omx_tsem_down(pClockPort->pBufferSem);
++    if(pClockPort->pBufferQueue->nelem > 0) {
++      clockBuffer = (OMX_BUFFERHEADERTYPE*)omx_dequeue(pClockPort->pBufferQueue);
++      pMediaTime  = (OMX_TIME_MEDIATIMETYPE*)clockBuffer->pBuffer;
++      if(pMediaTime->eUpdateType==OMX_TIME_UpdateScaleChanged) {
++       //if((pMediaTime->xScale>>16)==1){ /* check with Q16 format only */
++       //      /* rebase the clock time base when turning to normal play mode*/
++       //   hclkComponent = pClockPort->hTunneledComponent;
++       //   setHeader(&sClientTimeStamp, sizeof(OMX_TIME_CONFIG_TIMESTAMPTYPE));
++       //   sClientTimeStamp.nPortIndex = pClockPort->nTunneledPort;
++       //   sClientTimeStamp.nTimestamp = inputbuffer->nTimeStamp;
++       //   err = OMX_SetConfig(hclkComponent, OMX_IndexConfigTimeCurrentAudioReference, &sClientTimeStamp);
++       //   if(err!=OMX_ErrorNone) {
++       //     DEBUG(DEB_LEV_ERR,"Error %08x In OMX_SetConfig in func=%s line=%d\n",err,__func__, __LINE__);
++       //   }
++       //}
++       omx_alsasink_component_Private->eState = pMediaTime->eState;
++       omx_alsasink_component_Private->xScale = pMediaTime->xScale;
++       DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s OMX_TIME_UpdateScaleChanged Line=%d new eState=%d xScale=%d\n",
++         __func__, __LINE__, pMediaTime->eState, pMediaTime->xScale);
++       /// AND
++      } else if(pMediaTime->eUpdateType==OMX_TIME_UpdateClockStateChanged) {
++        omx_alsasink_component_Private->eState = pMediaTime->eState;
++        omx_alsasink_component_Private->xScale = pMediaTime->xScale;
++        DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s OMX_TIME_UpdateClockStateChanged Line=%d new eState=%d xScale=%d\n",
++          __func__, __LINE__, pMediaTime->eState, pMediaTime->xScale);
++      }
++      /// AND
++      pClockPort->ReturnBufferFunction((omx_base_PortType*)pClockPort,clockBuffer);
++    }
++  }
++
++  /* if  first time stamp is received then notify the clock component */
++  if(inputbuffer->nFlags == OMX_BUFFERFLAG_STARTTIME) {
++    DEBUG(DEB_LEV_FULL_SEQ,"In %s  first time stamp = %llx \n", __func__,(long long)inputbuffer->nTimeStamp);
++    inputbuffer->nFlags = 0;
++    hclkComponent = pClockPort->hTunneledComponent;
++    setHeader(&sClientTimeStamp, sizeof(OMX_TIME_CONFIG_TIMESTAMPTYPE));
++    sClientTimeStamp.nPortIndex = pClockPort->nTunneledPort;
++    sClientTimeStamp.nTimestamp = inputbuffer->nTimeStamp;
++    err = OMX_SetConfig(hclkComponent, OMX_IndexConfigTimeClientStartTime, &sClientTimeStamp);
++    if(err!=OMX_ErrorNone) {
++      DEBUG(DEB_LEV_ERR,"Error %08x In OMX_SetConfig in func=%s \n",err,__func__);
++    }
++
++    if(!PORT_IS_BEING_FLUSHED(pAudioPort) && !PORT_IS_BEING_FLUSHED(pClockPort)) {
++      omx_tsem_down(pClockPort->pBufferSem); /* wait for state change notification from clock src*/
++
++      /* update the clock state and clock scale info into the alsa sink private data */
++      if(pClockPort->pBufferQueue->nelem > 0) {
++        clockBuffer = (OMX_BUFFERHEADERTYPE*)omx_dequeue(pClockPort->pBufferQueue);
++        pMediaTime  = (OMX_TIME_MEDIATIMETYPE*)clockBuffer->pBuffer;
++        omx_alsasink_component_Private->eState = pMediaTime->eState;
++        omx_alsasink_component_Private->xScale = pMediaTime->xScale;
++        pClockPort->ReturnBufferFunction((omx_base_PortType*)pClockPort,clockBuffer);
++      }
++    }
++  }
++
++  /* do not send the data to alsa and return back, if the clock is not running or the scale is anything but 1*/
++  /*if(!(omx_alsasink_component_Private->eState==OMX_TIME_ClockStateRunning  && omx_alsasink_component_Private->xScale==(1<<16))){
++    // TODO: 0 means PAUSED. is correct to keep that frame?
++    if ((omx_alsasink_component_Private->xScale!=0) && (omx_alsasink_component_Private->xScale!=(1<<16))){
++      inputbuffer->nFilledLen=0;
++      DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Dropping frame !!!!!  eState=%d  xScale=%d\n", __func__, omx_alsasink_component_Private->eState, omx_alsasink_component_Private->xScale);
++    }
++    //return;
++    SendFrame = OMX_FALSE;
++    return SendFrame;
++  }*/
++
++  count++;
++  if(count==15) { //send request for every 15th frame
++    count=0;
++
++    OMX_TIME_CONFIG_TIMESTAMPTYPE ts;
++    setHeader(&ts, sizeof(OMX_TIME_CONFIG_TIMESTAMPTYPE));
++    ts.nPortIndex = pClockPort->nTunneledPort;
++
++    snd_pcm_sframes_t avail = 0;
++    int diff = 0;
++    snd_pcm_sframes_t delay = 0;
++
++    OMX_AUDIO_PARAM_PCMMODETYPE* sPCMModeParam = &omx_alsasink_component_Private->sPCMModeParam;
++
++    //snd_pcm_delay(omx_alsasink_component_Private->playback_handle, &delay);
++    // snd_pcm_avail() & snd_pcm_avail_update() are broken on raspberry pi!!!!
++    //avail = snd_pcm_avail(omx_alsasink_component_Private->playback_handle);
++
++    if (snd_pcm_status(omx_alsasink_component_Private->playback_handle, omx_alsasink_component_Private->pcm_status) < 0) {
++      DEBUG(DEB_LEV_ERR,"In %s unable to obtain pcm_status.\n",__func__);
++    }
++
++    delay = snd_pcm_status_get_delay(omx_alsasink_component_Private->pcm_status);
++    avail = (snd_pcm_sframes_t) snd_pcm_status_get_avail(omx_alsasink_component_Private->pcm_status);
++
++    diff = ((double)(delay - avail) / sPCMModeParam->nSamplingRate) * 1000 * 1000; // in microseconds !!!
++
++    //DEBUG(DEB_LEV_FULL_SEQ,"In %s delay=%d  avail=%d  diff=%d  inputbuffer->nTimeStamp=%lld  corected nTimeStamp=%lld\n",
++    //  __func__, delay, avail, diff, inputbuffer->nTimeStamp, inputbuffer->nTimeStamp - (OMX_TICKS)diff);
++
++    ts.nTimestamp = inputbuffer->nTimeStamp - (OMX_TICKS)diff;
++
++    if (OMX_ErrorNone != OMX_SetConfig(hclkComponent, OMX_IndexConfigTimeCurrentAudioReference,&ts)) {
++        DEBUG(DEB_LEV_ERR,"In %s unable to update reference clock.\n",__func__);
++    }
++
++#if 0
++    /* requesting for the timestamp for the data delivery */
++    if(!PORT_IS_BEING_FLUSHED(pAudioPort) && !PORT_IS_BEING_FLUSHED(pClockPort)&&
++        omx_alsasink_component_Private->transientState != OMX_TransStateExecutingToIdle) {
++      pClockPort->sMediaTimeRequest.nOffset         = 100; /*set the requested offset */
++      pClockPort->sMediaTimeRequest.nPortIndex      = pClockPort->nTunneledPort;
++      pClockPort->sMediaTimeRequest.pClientPrivate  = NULL; /* fill the appropriate value */
++      pClockPort->sMediaTimeRequest.nMediaTimestamp = inputbuffer->nTimeStamp;
++      err = OMX_SetConfig(hclkComponent, OMX_IndexConfigTimeMediaTimeRequest, &pClockPort->sMediaTimeRequest);
++      if(err!=OMX_ErrorNone) {
++       DEBUG(DEB_LEV_ERR,"Error %08x In OMX_SetConfig in func=%s \n",err,__func__);
++      }
++      if(!PORT_IS_BEING_FLUSHED(pAudioPort) && !PORT_IS_BEING_FLUSHED(pClockPort) &&
++        omx_alsasink_component_Private->transientState != OMX_TransStateExecutingToIdle) {
++        omx_tsem_down(pClockPort->pBufferSem); /* wait for the request fullfillment */
++        if(pClockPort->pBufferQueue->nelem > 0) {
++          clockBuffer = omx_dequeue(pClockPort->pBufferQueue);
++          pMediaTime  = (OMX_TIME_MEDIATIMETYPE*)clockBuffer->pBuffer;
++          if(pMediaTime->eUpdateType==OMX_TIME_UpdateScaleChanged) {
++            /// AND
++            //if((pMediaTime->xScale>>16)==1){ /* check with Q16 format only */
++            // /* rebase the clock time base when turning to normal play mode*/
++            //  hclkComponent = pClockPort->hTunneledComponent;
++            //  setHeader(&sClientTimeStamp, sizeof(OMX_TIME_CONFIG_TIMESTAMPTYPE));
++            //  sClientTimeStamp.nPortIndex = pClockPort->nTunneledPort;
++            //  sClientTimeStamp.nTimestamp = inputbuffer->nTimeStamp;
++            //  err = OMX_SetConfig(hclkComponent, OMX_IndexConfigTimeCurrentAudioReference, &sClientTimeStamp);
++            //  if(err!=OMX_ErrorNone) {
++            //    DEBUG(DEB_LEV_ERR,"Error %08x In OMX_SetConfig in func=%s line=%d\n",err,__func__, __LINE__);
++            //  }
++            //}
++            /// AND
++            omx_alsasink_component_Private->eState = pMediaTime->eState;
++            omx_alsasink_component_Private->xScale = pMediaTime->xScale;
++            DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s OMX_TIME_UpdateScaleChanged Line=%d new eState=%d xScale=%d\n",
++              __func__, __LINE__, pMediaTime->eState, pMediaTime->xScale);
++           /// AND
++          } else if(pMediaTime->eUpdateType==OMX_TIME_UpdateClockStateChanged) {
++            omx_alsasink_component_Private->eState = pMediaTime->eState;
++            omx_alsasink_component_Private->xScale = pMediaTime->xScale;
++            DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s OMX_TIME_UpdateClockStateChanged Line=%d new eState=%d xScale=%d\n",
++              __func__, __LINE__, pMediaTime->eState, pMediaTime->xScale);
++          }
++          /// AND
++          if(pMediaTime->eUpdateType==OMX_TIME_UpdateRequestFulfillment) {
++            if((pMediaTime->nOffset)>0) {
++#ifdef AV_SYNC_LOG
++         fprintf(fd,"%lld %lld\n",inputbuffer->nTimeStamp,pMediaTime->nWallTimeAtMediaTime);
++#endif
++              SendFrame = OMX_TRUE; /* as offset is >0 send the data to the device */
++            }
++            else {
++              SendFrame = OMX_FALSE; /* as offset is <0 do not send the data to the device */
++              //DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Dropping frame !!!!! nOffset>0 !!!  nOffset=%ll\n", __func__, pMediaTime->nOffset);
++            }
++          }
++          pClockPort->ReturnBufferFunction((omx_base_PortType*)pClockPort,clockBuffer);
++        }
++      }
++    }
++#endif
++  }
++
++  return(SendFrame);
++}
++
++/** @brief Releases buffers under processing.
++ * This function must be implemented in the derived classes, for the
++ * specific processing
++ */
++OMX_ERRORTYPE omx_alsasink_component_port_FlushProcessingBuffers(omx_base_PortType *openmaxStandPort) {
++  omx_base_component_PrivateType* omx_base_component_Private;
++  omx_alsasink_component_PrivateType* omx_alsasink_component_Private;
++  OMX_BUFFERHEADERTYPE* pBuffer;
++  omx_base_clock_PortType               *pClockPort;
++
++  DEBUG(DEB_LEV_FUNCTION_NAME, "In %s\n", __func__);
++  omx_base_component_Private        = (omx_base_component_PrivateType*)openmaxStandPort->standCompContainer->pComponentPrivate;
++  omx_alsasink_component_Private  = ( omx_alsasink_component_PrivateType*) omx_base_component_Private;
++
++  pClockPort    = (omx_base_clock_PortType*) omx_alsasink_component_Private->ports[OMX_BASE_SINK_CLOCKPORT_INDEX];
++
++  if (!PORT_IS_ENABLED(openmaxStandPort) || PORT_IS_BEING_DISABLED(openmaxStandPort)) {
++    if (PORT_IS_TUNNELED_N_BUFFER_SUPPLIER(openmaxStandPort)) {
++      DEBUG(DEB_LEV_FULL_SEQ, "In %s ---------- waiting for buffers. qelem=%d\n",__func__,openmaxStandPort->pBufferQueue->nelem);
++      int nRetry = 0;
++      while((openmaxStandPort->pBufferQueue->nelem != openmaxStandPort->nNumAssignedBuffers) &&
++            (nRetry < TUNNEL_USE_BUFFER_RETRY)){
++        usleep(TUNNEL_USE_BUFFER_RETRY_USLEEP_TIME);
++        nRetry++;
++      }
++      if (nRetry == TUNNEL_USE_BUFFER_RETRY){
++        // In some rare cases we can't collect all buffers back
++        DEBUG(DEB_LEV_ERR, "In %s Failed to get buffers back. Got a buffer qelem=%d\n",__func__,openmaxStandPort->pBufferQueue->nelem);
++      }
++      else{
++        DEBUG(DEB_LEV_FULL_SEQ, "In %s All buffers returned in %d iterations.\n",__func__, nRetry);
++      }
++
++      omx_tsem_reset(openmaxStandPort->pBufferSem);
++    }
++    return OMX_ErrorNone;
++  }
++
++  if(openmaxStandPort->sPortParam.eDomain!=OMX_PortDomainOther) { /* clock buffers not used in the clients buffer managment function */
++    pthread_mutex_lock(&omx_base_component_Private->flush_mutex);
++    openmaxStandPort->bIsPortFlushed=OMX_TRUE;
++    /*Signal the buffer management thread of port flush,if it is waiting for buffers*/
++    if(omx_base_component_Private->bMgmtSem->semval==0) {
++      omx_tsem_up(omx_base_component_Private->bMgmtSem);
++    }
++
++    if(omx_base_component_Private->state==OMX_StatePause ) {
++      /*Waiting at paused state*/
++      omx_tsem_signal(omx_base_component_Private->bStateSem);
++    }
++    DEBUG(DEB_LEV_FULL_SEQ, "In %s waiting for flush all condition port index =%d\n", __func__,(int)openmaxStandPort->sPortParam.nPortIndex);
++    /* Wait until flush is completed */
++    pthread_mutex_unlock(&omx_base_component_Private->flush_mutex);
++
++    /*Dummy signal to clock port*/
++    if(pClockPort->pBufferSem->semval == 0) {
++      omx_tsem_up(pClockPort->pBufferSem);
++    }
++    omx_tsem_down(omx_base_component_Private->flush_all_condition);
++    if(pClockPort->pBufferSem->semval > 0) {
++      omx_tsem_down(pClockPort->pBufferSem);
++    }
++  }
++
++  omx_tsem_reset(omx_base_component_Private->bMgmtSem);
++
++  /* Flush all the buffers not under processing */
++  while (openmaxStandPort->pBufferSem->semval > 0) {
++    DEBUG(DEB_LEV_FULL_SEQ, "In %s TFlag=%x Flusing Port=%d,Semval=%d Qelem=%d\n",
++    __func__,(int)openmaxStandPort->nTunnelFlags,(int)openmaxStandPort->sPortParam.nPortIndex,
++    (int)openmaxStandPort->pBufferSem->semval,(int)openmaxStandPort->pBufferQueue->nelem);
++
++    omx_tsem_down(openmaxStandPort->pBufferSem);
++    pBuffer = (OMX_BUFFERHEADERTYPE*)omx_dequeue(openmaxStandPort->pBufferQueue);
++    if (PORT_IS_TUNNELED(openmaxStandPort)) {
++      DEBUG(DEB_LEV_FULL_SEQ, "In %s: Comp %s is returning io:%d buffer\n",
++        __func__,omx_base_component_Private->name,(int)openmaxStandPort->sPortParam.nPortIndex);
++      if (openmaxStandPort->sPortParam.eDir == OMX_DirInput) {
++        ((OMX_COMPONENTTYPE*)(openmaxStandPort->hTunneledComponent))->FillThisBuffer(openmaxStandPort->hTunneledComponent, pBuffer);
++      } else {
++        ((OMX_COMPONENTTYPE*)(openmaxStandPort->hTunneledComponent))->EmptyThisBuffer(openmaxStandPort->hTunneledComponent, pBuffer);
++      }
++    } else {
++      (*(openmaxStandPort->BufferProcessedCallback))(
++        openmaxStandPort->standCompContainer,
++        omx_base_component_Private->callbackData,
++        pBuffer);
++    }
++  }
++
++  pthread_mutex_lock(&omx_base_component_Private->flush_mutex);
++  openmaxStandPort->bIsPortFlushed=OMX_FALSE;
++  pthread_mutex_unlock(&omx_base_component_Private->flush_mutex);
++
++  omx_tsem_up(omx_base_component_Private->flush_condition);
++
++  DEBUG(DEB_LEV_FULL_SEQ, "Out %s Port Index=%d bIsPortFlushed=%d Component %s\n", __func__,
++    (int)openmaxStandPort->sPortParam.nPortIndex,(int)openmaxStandPort->bIsPortFlushed,omx_base_component_Private->name);
++
++  DEBUG(DEB_LEV_PARAMS, "In %s TFlag=%x Qelem=%d BSem=%d bMgmtsem=%d component=%s\n", __func__,
++    (int)openmaxStandPort->nTunnelFlags,
++    (int)openmaxStandPort->pBufferQueue->nelem,
++    (int)openmaxStandPort->pBufferSem->semval,
++    (int)omx_base_component_Private->bMgmtSem->semval,
++    omx_base_component_Private->name);
++
++  DEBUG(DEB_LEV_FUNCTION_NAME, "Out %s Port Index=%d\n", __func__,(int)openmaxStandPort->sPortParam.nPortIndex);
++
++  return OMX_ErrorNone;
++}
++
++/**
++ * This function plays the input buffer. When fully consumed it returns.
++ */
++void omx_alsasink_component_BufferMgmtCallback(OMX_COMPONENTTYPE *openmaxStandComp, OMX_BUFFERHEADERTYPE* inputbuffer) {
++  OMX_U32                             frameSize;
++  OMX_S32                             written;
++  OMX_S32                             totalBuffer;
++  OMX_S32                             offsetBuffer;
++  OMX_BOOL                            allDataSent;
++  omx_alsasink_component_PrivateType* omx_alsasink_component_Private = (omx_alsasink_component_PrivateType*) openmaxStandComp->pComponentPrivate;
++
++  frameSize = (omx_alsasink_component_Private->sPCMModeParam.nChannels * omx_alsasink_component_Private->sPCMModeParam.nBitPerSample) >> 3;
++  //DEBUG(DEB_LEV_FULL_SEQ, "Framesize is %u chl=%d bufSize=%d\n",
++  //(int)frameSize, (int)omx_alsasink_component_Private->sPCMModeParam.nChannels, (int)inputbuffer->nFilledLen);
++
++  if(inputbuffer->nFilledLen < frameSize){
++    DEBUG(DEB_LEV_ERR, "Ouch!! In %s input buffer filled len(%d) less than frame size(%d)\n",__func__, (int)inputbuffer->nFilledLen, (int)frameSize);
++    return;
++  }
++
++  allDataSent = OMX_FALSE;
++
++  totalBuffer = inputbuffer->nFilledLen/frameSize;
++
++  omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)omx_alsasink_component_Private;
++  omx_base_clock_PortType*pClockPort  = (omx_base_clock_PortType*)omx_base_component_Private->ports[OMX_BASE_SINK_CLOCKPORT_INDEX];
++  omx_base_PortType *openmaxStandPort = omx_base_component_Private->ports[OMX_BASE_SINK_INPUTPORT_INDEX];
++  if(PORT_IS_TUNNELED(pClockPort) && !PORT_IS_BEING_FLUSHED(openmaxStandPort) &&
++      (omx_base_component_Private->transientState != OMX_TransStateExecutingToIdle) &&
++      (inputbuffer->nFlags != OMX_BUFFERFLAG_EOS)){
++    omx_alsasink_component_ClockPortHandleFunction(omx_alsasink_component_Private, inputbuffer);
++    if(inputbuffer->nFilledLen == 0)
++    {
++      // Dropped frame by clock
++      return;
++    }
++  }
++
++  /* Feed it to ALSA */
++
++  offsetBuffer = 0;
++  while (!allDataSent) {
++  DEBUG(DEB_LEV_SIMPLE_SEQ, "Writing to the device ..\n");
++    written = snd_pcm_writei(omx_alsasink_component_Private->playback_handle, inputbuffer->pBuffer + (offsetBuffer * frameSize), totalBuffer);
++    if (written < 0) {
++      if(written == -EPIPE){
++        DEBUG(DEB_LEV_ERR, "ALSA Underrun..\n");
++        snd_pcm_prepare(omx_alsasink_component_Private->playback_handle);
++        written = 0;
++      } else {
++        DEBUG(DEB_LEV_ERR, "Cannot send any data to the audio device %s (%s)\n", "default", snd_strerror (written));
++        DEBUG(DEB_LEV_ERR, "IB FilledLen=%d,totalBuffer=%d,frame size=%d,offset=%d\n",
++        (int)inputbuffer->nFilledLen, (int)totalBuffer, (int)frameSize, (int)offsetBuffer);
++        break;
++        return;
++      }
++    }
++
++    if(written != totalBuffer){
++      totalBuffer = totalBuffer - written;
++      offsetBuffer = written;
++    } else {
++      DEBUG(DEB_LEV_FULL_SEQ, "Buffer successfully sent to ALSA. Length was %i\n", (int)inputbuffer->nFilledLen);
++      allDataSent = OMX_TRUE;
++    }
++  }
++
++  inputbuffer->nFilledLen=0;
++}
++
++OMX_ERRORTYPE omx_alsasink_component_SetParameter(
++  OMX_IN  OMX_HANDLETYPE hComponent,
++  OMX_IN  OMX_INDEXTYPE nParamIndex,
++  OMX_IN  OMX_PTR ComponentParameterStructure)
++{
++  int err;
++  OMX_ERRORTYPE omxErr = OMX_ErrorNone;
++  OMX_AUDIO_PARAM_PORTFORMATTYPE *pAudioPortFormat;
++  OMX_OTHER_PARAM_PORTFORMATTYPE *pOtherPortFormat;
++  OMX_AUDIO_PARAM_MP3TYPE * pAudioMp3;
++  OMX_U32 portIndex;
++
++  /* Check which structure we are being fed and make control its header */
++  OMX_COMPONENTTYPE *openmaxStandComp = (OMX_COMPONENTTYPE*)hComponent;
++  omx_alsasink_component_PrivateType* omx_alsasink_component_Private = (omx_alsasink_component_PrivateType*)openmaxStandComp->pComponentPrivate;
++  omx_base_audio_PortType* pPort = (omx_base_audio_PortType *) omx_alsasink_component_Private->ports[OMX_BASE_SINK_INPUTPORT_INDEX];
++  omx_base_clock_PortType *pClockPort;
++  snd_pcm_t* playback_handle = omx_alsasink_component_Private->playback_handle;
++
++  if (ComponentParameterStructure == NULL) {
++    return OMX_ErrorBadParameter;
++  }
++
++  DEBUG(DEB_LEV_SIMPLE_SEQ, "   Setting parameter %i\n", nParamIndex);
++
++  switch(nParamIndex) {
++  case OMX_IndexParamAudioPortFormat:
++    pAudioPortFormat = (OMX_AUDIO_PARAM_PORTFORMATTYPE*)ComponentParameterStructure;
++    portIndex = pAudioPortFormat->nPortIndex;
++    /*Check Structure Header and verify component state*/
++    omxErr = omx_base_component_ParameterSanityCheck(hComponent, portIndex, pAudioPortFormat, sizeof(OMX_AUDIO_PARAM_PORTFORMATTYPE));
++    if(omxErr!=OMX_ErrorNone) {
++      DEBUG(DEB_LEV_ERR, "In %s Parameter Check Error=%x\n", __func__, omxErr);
++      break;
++    }
++    if (portIndex < 1) {
++      memcpy(&pPort->sAudioParam,pAudioPortFormat,sizeof(OMX_AUDIO_PARAM_PORTFORMATTYPE));
++    } else {
++      return OMX_ErrorBadPortIndex;
++    }
++    break;
++  case  OMX_IndexParamOtherPortFormat:
++      pOtherPortFormat = (OMX_OTHER_PARAM_PORTFORMATTYPE*)ComponentParameterStructure;
++      portIndex = pOtherPortFormat->nPortIndex;
++      err = omx_base_component_ParameterSanityCheck(hComponent, portIndex, pOtherPortFormat, sizeof(OMX_OTHER_PARAM_PORTFORMATTYPE));
++      if(err!=OMX_ErrorNone) {
++        DEBUG(DEB_LEV_ERR, "In %s Parameter Check Error=%x\n",__func__,err);
++        break;
++      }
++      if(portIndex != 1) {
++        return OMX_ErrorBadPortIndex;
++      }
++      pClockPort = (omx_base_clock_PortType *) omx_alsasink_component_Private->ports[portIndex];
++
++      pClockPort->sOtherParam.eFormat = pOtherPortFormat->eFormat;
++      break;
++  case OMX_IndexParamAudioPcm:
++    {
++      unsigned int rate;
++      OMX_AUDIO_PARAM_PCMMODETYPE* sPCMModeParam = (OMX_AUDIO_PARAM_PCMMODETYPE*)ComponentParameterStructure;
++      snd_pcm_hw_params_t *hw_params;
++      snd_pcm_hw_params_alloca(&hw_params);
++
++      /** Each time we are (re)configuring the hw_params thing
++      * we need to reinitialize it, otherwise previous changes will not take effect.
++      * e.g.: changing a previously configured sampling rate does not have
++      * any effect if we are not calling this each time.
++      */
++      snd_pcm_hw_params_any(omx_alsasink_component_Private->playback_handle, hw_params);
++
++      portIndex = sPCMModeParam->nPortIndex;
++      /*Check Structure Header and verify component state*/
++      omxErr = omx_base_component_ParameterSanityCheck(hComponent, portIndex, sPCMModeParam, sizeof(OMX_AUDIO_PARAM_PCMMODETYPE));
++      if(omxErr!=OMX_ErrorNone) {
++        DEBUG(DEB_LEV_ERR, "In %s Parameter Check Error=%x\n", __func__, omxErr);
++        break;
++      }
++
++      omx_alsasink_component_Private->AudioPCMConfigured  = 1;
++      if(sPCMModeParam->nPortIndex != omx_alsasink_component_Private->sPCMModeParam.nPortIndex){
++        DEBUG(DEB_LEV_ERR, "Error setting input pPort index\n");
++        omxErr = OMX_ErrorBadParameter;
++        break;
++      }
++
++      if(snd_pcm_hw_params_set_channels(playback_handle, hw_params, sPCMModeParam->nChannels)){
++        DEBUG(DEB_LEV_ERR, "Error setting number of channels\n");
++        return OMX_ErrorBadParameter;
++      }
++
++      if(sPCMModeParam->bInterleaved == OMX_TRUE){
++        if ((err = snd_pcm_hw_params_set_access(playback_handle, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) {
++          DEBUG(DEB_LEV_ERR, "cannot set access type intrleaved (%s)\n", snd_strerror (err));
++          return OMX_ErrorHardware;
++        }
++      }
++      else{
++        if ((err = snd_pcm_hw_params_set_access(playback_handle, hw_params, SND_PCM_ACCESS_RW_NONINTERLEAVED)) < 0) {
++          DEBUG(DEB_LEV_ERR, "cannot set access type non interleaved (%s)\n", snd_strerror (err));
++          return OMX_ErrorHardware;
++        }
++      }
++      rate = sPCMModeParam->nSamplingRate;
++      if ((err = snd_pcm_hw_params_set_rate_near(playback_handle, hw_params, &rate, 0)) < 0) {
++        DEBUG(DEB_LEV_ERR, "cannot set sample rate (%s)\n", snd_strerror (err));
++        return OMX_ErrorHardware;
++      }
++      else{
++        DEBUG(DEB_LEV_SIMPLE_SEQ, "Set correctly sampling rate from %lu to %lu\n", (unsigned long)sPCMModeParam->nSamplingRate, (unsigned long)rate);
++        sPCMModeParam->nSamplingRate = rate;
++      }
++
++      if(sPCMModeParam->ePCMMode == OMX_AUDIO_PCMModeLinear){
++        snd_pcm_format_t snd_pcm_format = SND_PCM_FORMAT_UNKNOWN;
++        DEBUG(DEB_LEV_SIMPLE_SEQ, "Bit per sample %i, signed=%i, little endian=%i\n",
++        (int)sPCMModeParam->nBitPerSample,
++        (int)sPCMModeParam->eNumData == OMX_NumericalDataSigned,
++        (int)sPCMModeParam->eEndian ==  OMX_EndianLittle);
++
++        switch(sPCMModeParam->nBitPerSample){
++        case 8:
++          if(sPCMModeParam->eNumData == OMX_NumericalDataSigned) {
++            snd_pcm_format = SND_PCM_FORMAT_S8;
++          } else {
++            snd_pcm_format = SND_PCM_FORMAT_U8;
++          }
++          break;
++        case 16:
++          if(sPCMModeParam->eNumData == OMX_NumericalDataSigned){
++            if(sPCMModeParam->eEndian ==  OMX_EndianLittle) {
++              snd_pcm_format = SND_PCM_FORMAT_S16_LE;
++            } else {
++              snd_pcm_format = SND_PCM_FORMAT_S16_BE;
++            }
++          }
++        if(sPCMModeParam->eNumData == OMX_NumericalDataUnsigned){
++          if(sPCMModeParam->eEndian ==  OMX_EndianLittle){
++            snd_pcm_format = SND_PCM_FORMAT_U16_LE;
++          } else {
++            snd_pcm_format = SND_PCM_FORMAT_U16_BE;
++          }
++        }
++        break;
++        case 24:
++          if(sPCMModeParam->eNumData == OMX_NumericalDataSigned){
++            if(sPCMModeParam->eEndian ==  OMX_EndianLittle) {
++              snd_pcm_format = SND_PCM_FORMAT_S24_LE;
++            } else {
++              snd_pcm_format = SND_PCM_FORMAT_S24_BE;
++            }
++          }
++          if(sPCMModeParam->eNumData == OMX_NumericalDataUnsigned){
++            if(sPCMModeParam->eEndian ==  OMX_EndianLittle) {
++              snd_pcm_format = SND_PCM_FORMAT_U24_LE;
++            } else {
++              snd_pcm_format = SND_PCM_FORMAT_U24_BE;
++            }
++          }
++          break;
++
++        case 32:
++          if(sPCMModeParam->eNumData == OMX_NumericalDataSigned){
++            if(sPCMModeParam->eEndian ==  OMX_EndianLittle) {
++              snd_pcm_format = SND_PCM_FORMAT_S32_LE;
++            } else {
++              snd_pcm_format = SND_PCM_FORMAT_S32_BE;
++            }
++          }
++          if(sPCMModeParam->eNumData == OMX_NumericalDataUnsigned){
++            if(sPCMModeParam->eEndian ==  OMX_EndianLittle) {
++              snd_pcm_format = SND_PCM_FORMAT_U32_LE;
++            } else {
++              snd_pcm_format = SND_PCM_FORMAT_U32_BE;
++            }
++          }
++          break;
++        default:
++          omxErr = OMX_ErrorBadParameter;
++          break;
++        }
++
++        if(snd_pcm_format != SND_PCM_FORMAT_UNKNOWN){
++          if ((err = snd_pcm_hw_params_set_format(playback_handle, hw_params, snd_pcm_format)) < 0) {
++            DEBUG(DEB_LEV_ERR, "cannot set sample format (%s)\n",  snd_strerror (err));
++            return OMX_ErrorHardware;
++          }
++          memcpy(&omx_alsasink_component_Private->sPCMModeParam, ComponentParameterStructure, sizeof(OMX_AUDIO_PARAM_PCMMODETYPE));
++        } else{
++          DEBUG(DEB_LEV_SIMPLE_SEQ, "ALSA OMX_IndexParamAudioPcm configured\n");
++          memcpy(&omx_alsasink_component_Private->sPCMModeParam, ComponentParameterStructure, sizeof(OMX_AUDIO_PARAM_PCMMODETYPE));
++        }
++      }
++      else if(sPCMModeParam->ePCMMode == OMX_AUDIO_PCMModeALaw){
++        DEBUG(DEB_LEV_SIMPLE_SEQ, "Configuring ALAW format\n\n");
++        if ((err = snd_pcm_hw_params_set_format(playback_handle, hw_params, SND_PCM_FORMAT_A_LAW)) < 0) {
++          DEBUG(DEB_LEV_ERR, "cannot set sample format (%s)\n",  snd_strerror (err));
++          return OMX_ErrorHardware;
++        }
++        memcpy(&omx_alsasink_component_Private->sPCMModeParam, ComponentParameterStructure, sizeof(OMX_AUDIO_PARAM_PCMMODETYPE));
++      }
++      else if(sPCMModeParam->ePCMMode == OMX_AUDIO_PCMModeMULaw){
++        DEBUG(DEB_LEV_SIMPLE_SEQ, "Configuring ALAW format\n\n");
++        if ((err = snd_pcm_hw_params_set_format(playback_handle, hw_params, SND_PCM_FORMAT_MU_LAW)) < 0) {
++          DEBUG(DEB_LEV_ERR, "cannot set sample format (%s)\n", snd_strerror (err));
++          return OMX_ErrorHardware;
++        }
++        memcpy(&omx_alsasink_component_Private->sPCMModeParam, ComponentParameterStructure, sizeof(OMX_AUDIO_PARAM_PCMMODETYPE));
++      }
++
++      snd_pcm_uframes_t periodSize, bufferSize;
++      bufferSize = sPCMModeParam->nSamplingRate / 5;
++      periodSize = bufferSize / 4; //sPCMModeParam->nSamplingRate / 20;
++
++      snd_pcm_uframes_t periodSizeMax = bufferSize / 3;
++      DEBUG(DEB_LEV_SIMPLE_SEQ, "trying snd_pcm_hw_params_set_period_size_max (%d)\n", (int)periodSizeMax);
++      if ((err = snd_pcm_hw_params_set_period_size_max(omx_alsasink_component_Private->playback_handle, hw_params, &periodSizeMax, NULL)) < 0) {
++        DEBUG(DEB_LEV_ERR, "cannot snd_pcm_hw_params_set_period_size_max (%s)\n",  snd_strerror (err));
++        return OMX_ErrorHardware;
++      }
++
++      DEBUG(DEB_LEV_SIMPLE_SEQ, "trying snd_pcm_hw_params_set_buffer_size_near (%d)\n", (int)bufferSize);
++      if ((err = snd_pcm_hw_params_set_buffer_size_near(omx_alsasink_component_Private->playback_handle, hw_params, &bufferSize)) < 0) {
++      //if (err = snd_pcm_hw_params_set_buffer_size(omx_alsasink_component_Private->playback_handle, hw_params, bufferSize) < 0) {
++        DEBUG(DEB_LEV_ERR, "cannot snd_pcm_hw_params_set_buffer_size_near (%s)\n",  snd_strerror (err));
++        return OMX_ErrorHardware;
++      }
++      DEBUG(DEB_LEV_SIMPLE_SEQ, "snd_pcm_hw_params_set_buffer_size_near returned (%d)\n", (int)bufferSize);
++
++      DEBUG(DEB_LEV_SIMPLE_SEQ, "trying snd_pcm_hw_params_set_period_size_near (%d)\n", (int)periodSize);
++      if ((err = snd_pcm_hw_params_set_period_size_near(omx_alsasink_component_Private->playback_handle, hw_params, &periodSize, NULL)) < 0) {
++      //if (err = snd_pcm_hw_params_set_period_size(omx_alsasink_component_Private->playback_handle, hw_params, periodSize, 0) < 0) {
++        DEBUG(DEB_LEV_ERR, "cannot snd_pcm_hw_params_set_period_size_near (%s)\n",  snd_strerror (err));
++        return OMX_ErrorHardware;
++      }
++      DEBUG(DEB_LEV_SIMPLE_SEQ, "snd_pcm_hw_params_set_period_size_near returned (%d)\n", (int)periodSize);
++      /*
++      unsigned int val = 200000;
++      DEBUG(DEB_LEV_SIMPLE_SEQ, "trying snd_pcm_hw_params_set_buffer_time_near (%d)\n", val);
++      if (err = snd_pcm_hw_params_set_buffer_time_near(omx_alsasink_component_Private->playback_handle, hw_params, &val, NULL) < 0 ) {
++        DEBUG(DEB_LEV_ERR, "cannot snd_pcm_hw_params_set_buffer_time (%s)\n",  snd_strerror (err));
++        return;
++      }
++      DEBUG(DEB_LEV_SIMPLE_SEQ, "snd_pcm_hw_params_set_buffer_time_near returned (%d)\n", val);
++      */
++
++      /** Configure and prepare the ALSA handle */
++      DEBUG(DEB_LEV_SIMPLE_SEQ, "Configuring the PCM interface\n");
++      if ((err = snd_pcm_hw_params(playback_handle, hw_params)) < 0) {
++        DEBUG(DEB_LEV_ERR, "cannot set parameters (%s)\n",  snd_strerror (err));
++        return OMX_ErrorHardware;
++      }
++
++      if ((err = snd_pcm_prepare (playback_handle)) < 0) {
++        DEBUG(DEB_LEV_ERR, "cannot prepare audio interface for use (%s)\n", snd_strerror (err));
++        return OMX_ErrorHardware;
++      }
++    }
++    break;
++  case OMX_IndexParamAudioMp3:
++    pAudioMp3 = (OMX_AUDIO_PARAM_MP3TYPE*)ComponentParameterStructure;
++    /*Check Structure Header and verify component state*/
++    omxErr = omx_base_component_ParameterSanityCheck(hComponent, pAudioMp3->nPortIndex, pAudioMp3, sizeof(OMX_AUDIO_PARAM_MP3TYPE));
++    if(omxErr != OMX_ErrorNone) {
++      DEBUG(DEB_LEV_ERR, "In %s Parameter Check Error=%x\n", __func__, omxErr);
++      break;
++    }
++    break;
++  default: /*Call the base component function*/
++    return omx_base_component_SetParameter(hComponent, nParamIndex, ComponentParameterStructure);
++  }
++  return omxErr;
++}
++
++OMX_ERRORTYPE omx_alsasink_component_GetParameter(
++  OMX_IN  OMX_HANDLETYPE hComponent,
++  OMX_IN  OMX_INDEXTYPE nParamIndex,
++  OMX_INOUT OMX_PTR ComponentParameterStructure)
++{
++  OMX_AUDIO_PARAM_PORTFORMATTYPE *pAudioPortFormat;
++  OMX_OTHER_PARAM_PORTFORMATTYPE *pOtherPortFormat;
++  OMX_ERRORTYPE err = OMX_ErrorNone;
++  OMX_COMPONENTTYPE *openmaxStandComp = (OMX_COMPONENTTYPE*)hComponent;
++  omx_alsasink_component_PrivateType* omx_alsasink_component_Private = (omx_alsasink_component_PrivateType*)openmaxStandComp->pComponentPrivate;
++  omx_base_audio_PortType *pPort = (omx_base_audio_PortType *) omx_alsasink_component_Private->ports[OMX_BASE_SINK_INPUTPORT_INDEX];
++  omx_base_clock_PortType *pClockPort = (omx_base_clock_PortType *) omx_alsasink_component_Private->ports[1];
++  if (ComponentParameterStructure == NULL) {
++    return OMX_ErrorBadParameter;
++  }
++  DEBUG(DEB_LEV_SIMPLE_SEQ, "   Getting parameter %i\n", nParamIndex);
++  /* Check which structure we are being fed and fill its header */
++  switch(nParamIndex) {
++  case OMX_IndexParamAudioInit:
++    if ((err = checkHeader(ComponentParameterStructure, sizeof(OMX_PORT_PARAM_TYPE))) != OMX_ErrorNone) {
++      break;
++    }
++    memcpy(ComponentParameterStructure, &omx_alsasink_component_Private->sPortTypesParam[OMX_PortDomainAudio], sizeof(OMX_PORT_PARAM_TYPE));
++    break;
++  case OMX_IndexParamOtherInit:
++    if ((err = checkHeader(ComponentParameterStructure, sizeof(OMX_PORT_PARAM_TYPE))) != OMX_ErrorNone) {
++      break;
++    }
++    memcpy(ComponentParameterStructure, &omx_alsasink_component_Private->sPortTypesParam[OMX_PortDomainOther], sizeof(OMX_PORT_PARAM_TYPE));
++    break;
++  case OMX_IndexParamAudioPortFormat:
++    pAudioPortFormat = (OMX_AUDIO_PARAM_PORTFORMATTYPE*)ComponentParameterStructure;
++    if ((err = checkHeader(ComponentParameterStructure, sizeof(OMX_AUDIO_PARAM_PORTFORMATTYPE))) != OMX_ErrorNone) {
++      break;
++    }
++    if (pAudioPortFormat->nPortIndex < 1) {
++      memcpy(pAudioPortFormat, &pPort->sAudioParam, sizeof(OMX_AUDIO_PARAM_PORTFORMATTYPE));
++    } else {
++      return OMX_ErrorBadPortIndex;
++    }
++    break;
++  case OMX_IndexParamAudioPcm:
++    if(((OMX_AUDIO_PARAM_PCMMODETYPE*)ComponentParameterStructure)->nPortIndex !=
++      omx_alsasink_component_Private->sPCMModeParam.nPortIndex) {
++      return OMX_ErrorBadParameter;
++    }
++    if ((err = checkHeader(ComponentParameterStructure, sizeof(OMX_AUDIO_PARAM_PCMMODETYPE))) != OMX_ErrorNone) {
++      break;
++    }
++    memcpy(ComponentParameterStructure, &omx_alsasink_component_Private->sPCMModeParam, sizeof(OMX_AUDIO_PARAM_PCMMODETYPE));
++    break;
++  case  OMX_IndexParamOtherPortFormat:
++
++      pOtherPortFormat = (OMX_OTHER_PARAM_PORTFORMATTYPE*)ComponentParameterStructure;
++
++      if ((err = checkHeader(ComponentParameterStructure, sizeof(OMX_OTHER_PARAM_PORTFORMATTYPE))) != OMX_ErrorNone) {
++        break;
++      }
++      if (pOtherPortFormat->nPortIndex == 1) {
++        memcpy(pOtherPortFormat, &pClockPort->sOtherParam, sizeof(OMX_OTHER_PARAM_PORTFORMATTYPE));
++      } else {
++        return OMX_ErrorBadPortIndex;
++      }
++      break;
++  default: /*Call the base component function*/
++  return omx_base_component_GetParameter(hComponent, nParamIndex, ComponentParameterStructure);
++  }
++  return err;
++}
+diff --git a/alsa/omx_alsasink_component.h b/alsa/omx_alsasink_component.h
+new file mode 100644
+index 0000000..a6f2e7d
+--- /dev/null
++++ b/alsa/omx_alsasink_component.h
+@@ -0,0 +1,94 @@
++/**
++  @file src/components/alsa/omx_alsasink_component.h
++
++  OpenMAX ALSA sink component. This component is an audio sink that uses ALSA library.
++
++  Copyright (C) 2007-2008 STMicroelectronics
++  Copyright (C) 2007-2008 Nokia Corporation and/or its subsidiary(-ies).
++
++  This library 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.
++
++  This library 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 this library; if not, write to the Free Software Foundation, Inc.,
++  51 Franklin St, Fifth Floor, Boston, MA
++  02110-1301  USA
++
++  $Date: 2008-08-08 06:56:06 +0200 (Fri, 08 Aug 2008) $
++  Revision $Rev: 581 $
++  Author $Author: pankaj_sen $
++
++*/
++
++#ifndef _OMX_ALSASINK_COMPONENT_H_
++#define _OMX_ALSASINK_COMPONENT_H_
++
++//#include <OMX_Types.h>
++//#include <IL/OMX_Component.h>
++//#include <IL/OMX_Core.h>
++//#include <IL/OMX_Audio.h>
++#include <pthread.h>
++#include <omx_base_sink.h>
++#include <alsa/asoundlib.h>
++
++/** Alsasinkport component private structure.
++ * see the define above
++ * @param sPCMModeParam Audio PCM specific OpenMAX parameter
++ * @param AudioPCMConfigured boolean flag to check if the audio has been configured
++ * @param playback_handle ALSA specif handle for audio player
++ * @param xScale the scale of the media clock
++ * @param eState the state of the media clock
++ * @param hw_params ALSA specif hardware parameters
++ */
++DERIVEDCLASS(omx_alsasink_component_PrivateType, omx_base_sink_PrivateType)
++#define omx_alsasink_component_PrivateType_FIELDS omx_base_sink_PrivateType_FIELDS \
++  OMX_AUDIO_PARAM_PCMMODETYPE  sPCMModeParam; \
++  char                         AudioPCMConfigured;  \
++  snd_pcm_t*                   playback_handle;  \
++  snd_pcm_status_t*            pcm_status; \
++  OMX_S32                      xScale; \
++  OMX_TIME_CLOCKSTATE          eState;
++ENDCLASS(omx_alsasink_component_PrivateType)
++
++/* Component private entry points declaration */
++OMX_ERRORTYPE omx_alsasink_component_Constructor(OMX_COMPONENTTYPE *openmaxStandComp,OMX_STRING cComponentName);
++OMX_ERRORTYPE omx_alsasink_component_Destructor(OMX_COMPONENTTYPE *openmaxStandComp);
++
++void omx_alsasink_component_BufferMgmtCallback(
++  OMX_COMPONENTTYPE *openmaxStandComp,
++  OMX_BUFFERHEADERTYPE* inputbuffer);
++
++OMX_ERRORTYPE omx_alsasink_component_port_SendBufferFunction(
++  omx_base_PortType *openmaxStandPort,
++  OMX_BUFFERHEADERTYPE* pBuffer);
++
++/* to handle the communication at the clock port */
++OMX_BOOL omx_alsasink_component_ClockPortHandleFunction(
++  omx_alsasink_component_PrivateType* omx_alsasink_component_Private,
++  OMX_BUFFERHEADERTYPE* inputbuffer);
++
++OMX_ERRORTYPE omx_alsasink_component_GetParameter(
++  OMX_IN  OMX_HANDLETYPE hComponent,
++  OMX_IN  OMX_INDEXTYPE nParamIndex,
++  OMX_INOUT OMX_PTR ComponentParameterStructure);
++
++OMX_ERRORTYPE omx_alsasink_component_SetParameter(
++  OMX_IN  OMX_HANDLETYPE hComponent,
++  OMX_IN  OMX_INDEXTYPE nParamIndex,
++  OMX_IN  OMX_PTR ComponentParameterStructure);
++
++OMX_ERRORTYPE omx_alsasink_component_GetConfig(
++  OMX_IN  OMX_HANDLETYPE hComponent,
++  OMX_IN  OMX_INDEXTYPE nIndex,
++  OMX_INOUT OMX_PTR pComponentConfigStructure);
++
++OMX_ERRORTYPE omx_alsasink_component_port_FlushProcessingBuffers(omx_base_PortType *openmaxStandPort);
++
++#endif
+diff --git a/alsa/omx_base_audio_port.cpp b/alsa/omx_base_audio_port.cpp
+new file mode 100644
+index 0000000..fb611d7
+--- /dev/null
++++ b/alsa/omx_base_audio_port.cpp
+@@ -0,0 +1,111 @@
++/**
++  @file src/base/omx_base_audio_port.c
++
++  Base Audio Port class for OpenMAX ports to be used in derived components.
++
++  Copyright (C) 2007-2008 STMicroelectronics
++  Copyright (C) 2007-2008 Nokia Corporation and/or its subsidiary(-ies).
++
++  This library 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.
++
++  This library 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 this library; if not, write to the Free Software Foundation, Inc.,
++  51 Franklin St, Fifth Floor, Boston, MA
++  02110-1301  USA
++
++  $Date: 2008-08-07 12:42:40 +0200 (Thu, 07 Aug 2008) $
++  Revision $Rev: 580 $
++  Author $Author: pankaj_sen $
++*/
++
++#include <stdlib.h>
++#include <string.h>
++#include <unistd.h>
++//#include <IL/OMX_Core.h>
++//#include <IL/OMX_Component.h>
++
++#include "omx_base_component.h"
++#include "omx_base_audio_port.h"
++
++/**
++  * @brief The base contructor for the generic OpenMAX ST Audio port
++  *
++  * This function is executed by the component that uses a port.
++  * The parameter contains the info about the component.
++  * It takes care of constructing the instance of the port and
++  * every object needed by the base port.
++  *
++  * @param openmaxStandComp pointer to the Handle of the component
++  * @param openmaxStandPort the ST port to be initialized
++  * @param nPortIndex Index of the port to be constructed
++  * @param isInput specifices if the port is an input or an output
++  *
++  * @return OMX_ErrorInsufficientResources if a memory allocation fails
++  */
++
++OMX_ERRORTYPE base_audio_port_Constructor(OMX_COMPONENTTYPE *openmaxStandComp,omx_base_PortType **openmaxStandPort,OMX_U32 nPortIndex, OMX_BOOL isInput) {
++
++  omx_base_audio_PortType *omx_base_audio_Port;
++
++  if (!(*openmaxStandPort)) {
++    *openmaxStandPort = (omx_base_PortType *) calloc(1,sizeof (omx_base_audio_PortType));
++  }
++
++  if (!(*openmaxStandPort)) {
++    return OMX_ErrorInsufficientResources;
++  }
++
++  base_port_Constructor(openmaxStandComp,openmaxStandPort,nPortIndex, isInput);
++
++  omx_base_audio_Port = (omx_base_audio_PortType *)*openmaxStandPort;
++
++  setHeader(&omx_base_audio_Port->sAudioParam, sizeof(OMX_AUDIO_PARAM_PORTFORMATTYPE));
++  omx_base_audio_Port->sAudioParam.nPortIndex = nPortIndex;
++  omx_base_audio_Port->sAudioParam.nIndex = 0;
++  omx_base_audio_Port->sAudioParam.eEncoding = OMX_AUDIO_CodingUnused;
++
++  omx_base_audio_Port->sPortParam.eDomain = OMX_PortDomainAudio;
++  omx_base_audio_Port->sPortParam.format.audio.cMIMEType = (OMX_STRING) malloc(DEFAULT_MIME_STRING_LENGTH);
++  strcpy(omx_base_audio_Port->sPortParam.format.audio.cMIMEType, "raw/audio");
++  omx_base_audio_Port->sPortParam.format.audio.pNativeRender = 0;
++  omx_base_audio_Port->sPortParam.format.audio.bFlagErrorConcealment = OMX_FALSE;
++  omx_base_audio_Port->sPortParam.format.audio.eEncoding = OMX_AUDIO_CodingUnused;
++
++  omx_base_audio_Port->sPortParam.nBufferSize = (isInput == OMX_TRUE)?DEFAULT_IN_BUFFER_SIZE:DEFAULT_OUT_BUFFER_SIZE ;
++
++  omx_base_audio_Port->PortDestructor = &base_audio_port_Destructor;
++
++  return OMX_ErrorNone;
++}
++
++/**
++  * @brief The base audio port destructor for the generic OpenMAX ST Audio port
++  *
++  * This function is executed by the component that uses a port.
++  * The parameter contains the info about the port.
++  * It takes care of destructing the instance of the port
++  *
++  * @param openmaxStandPort the ST port to be destructed
++  *
++  * @return OMX_ErrorNone
++  */
++
++OMX_ERRORTYPE base_audio_port_Destructor(omx_base_PortType *openmaxStandPort){
++
++  if(openmaxStandPort->sPortParam.format.audio.cMIMEType) {
++    free(openmaxStandPort->sPortParam.format.audio.cMIMEType);
++    openmaxStandPort->sPortParam.format.audio.cMIMEType = NULL;
++  }
++
++  base_port_Destructor(openmaxStandPort);
++
++  return OMX_ErrorNone;
++}
+diff --git a/alsa/omx_base_audio_port.h b/alsa/omx_base_audio_port.h
+new file mode 100644
+index 0000000..d03a83c
+--- /dev/null
++++ b/alsa/omx_base_audio_port.h
+@@ -0,0 +1,88 @@
++/**
++  @file src/base/omx_base_audio_port.h
++
++  Base Audio Port class for OpenMAX ports to be used in derived components.
++
++  Copyright (C) 2007-2008 STMicroelectronics
++  Copyright (C) 2007-2008 Nokia Corporation and/or its subsidiary(-ies).
++
++  This library 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.
++
++  This library 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 this library; if not, write to the Free Software Foundation, Inc.,
++  51 Franklin St, Fifth Floor, Boston, MA
++  02110-1301  USA
++
++  $Date: 2008-07-07 14:30:38 +0200 (Mon, 07 Jul 2008) $
++  Revision $Rev: 562 $
++  Author $Author: gsent $
++
++*/
++
++#include "omx_classmagic.h"
++#include "omx_base_port.h"
++
++#ifndef __OMX_BASE_AUDIO_PORT_H__
++#define __OMX_BASE_AUDIO_PORT_H__
++
++/**
++ * @brief the base audio domain structure that describes each port.
++ *
++ * The data structure is derived from base port class and contain audio
++ * domain specific parameters.
++ * Other elements can be added in the derived components structures.
++ */
++
++DERIVEDCLASS(omx_base_audio_PortType, omx_base_PortType)
++#define omx_base_audio_PortType_FIELDS omx_base_PortType_FIELDS \
++  /** @param sAudioParam Domain specific (audio) OpenMAX port parameter */ \
++  OMX_AUDIO_PARAM_PORTFORMATTYPE sAudioParam;
++ENDCLASS(omx_base_audio_PortType)
++
++/**
++  * @brief the base contructor for the generic OpenMAX ST Audio port
++  *
++  * This function is executed by the component that uses a port.
++  * The parameter contains the info about the component.
++  * It takes care of constructing the instance of the port and
++  * every object needed by the base port.
++  *
++  * @param openmaxStandComp pointer to the Handle of the component
++  * @param openmaxStandPort the ST port to be initialized
++  * @param nPortIndex Index of the port to be constructed
++  * @param isInput specifices if the port is an input or an output
++  *
++  * @return OMX_ErrorInsufficientResources if a memory allocation fails
++  */
++
++OMX_ERRORTYPE base_audio_port_Constructor(
++  OMX_COMPONENTTYPE *openmaxStandComp,
++  omx_base_PortType **openmaxStandPort,
++  OMX_U32 nPortIndex,
++  OMX_BOOL isInput);
++
++/**
++  * @brief the base audio port destructor for the generic OpenMAX ST Audio port
++  *
++  * This function is executed by the component that uses a port.
++  * The parameter contains the info about the port.
++  * It takes care of destructing the instance of the port
++  *
++  * @param openmaxStandPort the ST port to be destructed
++  *
++  * @return OMX_ErrorNone
++  */
++
++
++OMX_ERRORTYPE base_audio_port_Destructor(
++  omx_base_PortType *openmaxStandPort);
++
++#endif
+diff --git a/alsa/omx_base_clock_port.cpp b/alsa/omx_base_clock_port.cpp
+new file mode 100644
+index 0000000..cf27b71
+--- /dev/null
++++ b/alsa/omx_base_clock_port.cpp
+@@ -0,0 +1,209 @@
++/**
++  @file src/base/omx_base_clock_port.c
++
++  Base Clock Port class for OpenMAX clock ports to be used in derived components.
++
++  Copyright (C) 2007-2008 STMicroelectronics
++  Copyright (C) 2007-2008 Nokia Corporation and/or its subsidiary(-ies).
++
++  This library 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.
++
++  This library 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 this library; if not, write to the Free Software Foundation, Inc.,
++  51 Franklin St, Fifth Floor, Boston, MA
++  02110-1301  USA
++
++  $Date: 2008-07-04 11:48:31 +0200 (Fri, 04 Jul 2008) $
++  Revision $Rev: 560 $
++  Author $Author: gsent $
++*/
++
++#undef OMX_SKIP64BIT
++#include <stdlib.h>
++#include <string.h>
++#include <unistd.h>
++//#include <IL/OMX_Core.h>
++//#include <IL/OMX_Component.h>
++#include "omx_base_component.h"
++#include "omx_base_clock_port.h"
++
++/**
++  * @brief the base contructor for the generic openmax ST Clock port
++  *
++  * This function is executed by the component that uses a port.
++  * The parameter contains the info about the component.
++  * It takes care of constructing the instance of the port and
++  * every object needed by the base port.
++  *
++  * @param openmaxStandComp pointer to the Handle of the component
++  * @param openmaxStandPort the ST port to be initialized
++  * @param nPortIndex Index of the port to be constructed
++  * @param isInput specifices if the port is an input or an output
++  *
++  * @return OMX_ErrorInsufficientResources if a memory allocation fails
++  */
++
++OMX_ERRORTYPE base_clock_port_Constructor(OMX_COMPONENTTYPE *openmaxStandComp,omx_base_PortType **openmaxStandPort,OMX_U32 nPortIndex, OMX_BOOL isInput) {
++
++  omx_base_clock_PortType *omx_base_clock_Port;
++
++  if (!(*openmaxStandPort)) {
++    *openmaxStandPort = (omx_base_PortType*)calloc(1,sizeof (omx_base_clock_PortType));
++  }
++
++  if (!(*openmaxStandPort)) {
++    return OMX_ErrorInsufficientResources;
++  }
++
++  base_port_Constructor(openmaxStandComp,openmaxStandPort,nPortIndex, isInput);
++
++  omx_base_clock_Port = (omx_base_clock_PortType *)*openmaxStandPort;
++
++  setHeader(&omx_base_clock_Port->sOtherParam, sizeof(OMX_OTHER_PARAM_PORTFORMATTYPE));
++  omx_base_clock_Port->sOtherParam.nPortIndex = nPortIndex;
++  omx_base_clock_Port->sOtherParam.nIndex = 0;
++  omx_base_clock_Port->sOtherParam.eFormat = OMX_OTHER_FormatTime;
++
++  omx_base_clock_Port->sPortParam.eDomain              = OMX_PortDomainOther;
++  omx_base_clock_Port->sPortParam.format.other.eFormat = OMX_OTHER_FormatTime;
++  omx_base_clock_Port->sPortParam.nBufferSize          = sizeof(OMX_TIME_MEDIATIMETYPE) ;
++  omx_base_clock_Port->sPortParam.nBufferCountActual   = 1;
++  omx_base_clock_Port->sPortParam.nBufferCountMin      = 1;
++  omx_base_clock_Port->sPortParam.format.other.eFormat = OMX_OTHER_FormatTime;
++
++  setHeader(&omx_base_clock_Port->sTimeStamp, sizeof(OMX_TIME_CONFIG_TIMESTAMPTYPE));
++  omx_base_clock_Port->sTimeStamp.nPortIndex = nPortIndex;
++  omx_base_clock_Port->sTimeStamp.nTimestamp = 0x00;
++
++
++  setHeader(&omx_base_clock_Port->sMediaTime, sizeof(OMX_TIME_MEDIATIMETYPE));
++  omx_base_clock_Port->sMediaTime.nClientPrivate = 0;
++  omx_base_clock_Port->sMediaTime.nOffset = 0x0;
++  omx_base_clock_Port->sMediaTime.xScale = 1;
++
++  setHeader(&omx_base_clock_Port->sMediaTimeRequest, sizeof(OMX_TIME_MEDIATIMETYPE));
++  omx_base_clock_Port->sMediaTimeRequest.nPortIndex = nPortIndex;
++  omx_base_clock_Port->sMediaTimeRequest.pClientPrivate = NULL;
++  omx_base_clock_Port->sMediaTimeRequest.nOffset = 0x0;
++
++  omx_base_clock_Port->Port_SendBufferFunction = &base_clock_port_SendBufferFunction;
++  omx_base_clock_Port->PortDestructor = &base_clock_port_Destructor;
++
++  return OMX_ErrorNone;
++}
++
++/**
++  * @brief the base clock port destructor for the generic openmax ST clock port
++  *
++  * This function is executed by the component that uses a port.
++  * The parameter contains the info about the port.
++  * It takes care of destructing the instance of the port
++  *
++  * @param openmaxStandPort the ST port to be destructed
++  *
++  * @return OMX_ErrorNone
++  */
++
++OMX_ERRORTYPE base_clock_port_Destructor(omx_base_PortType *openmaxStandPort){
++
++  base_port_Destructor(openmaxStandPort);
++
++  return OMX_ErrorNone;
++}
++
++/** @brief the entry point for sending buffers to the port
++ *
++ * This function can be called by the EmptyThisBuffer or FillThisBuffer. It depends on
++ * the nature of the port, that can be an input or output port.
++ */
++OMX_ERRORTYPE base_clock_port_SendBufferFunction(
++  omx_base_PortType *openmaxStandPort,
++  OMX_BUFFERHEADERTYPE* pBuffer) {
++
++  OMX_ERRORTYPE err;
++  OMX_U32 portIndex;
++  OMX_COMPONENTTYPE* omxComponent = openmaxStandPort->standCompContainer;
++  omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)omxComponent->pComponentPrivate;
++#if NO_GST_OMX_PATCH
++  unsigned int i;
++#endif
++  portIndex = (openmaxStandPort->sPortParam.eDir == OMX_DirInput)?pBuffer->nInputPortIndex:pBuffer->nOutputPortIndex;
++  DEBUG(DEB_LEV_FUNCTION_NAME, "In %s portIndex %lu\n", __func__, (unsigned long)portIndex);
++
++  if (portIndex != openmaxStandPort->sPortParam.nPortIndex) {
++    DEBUG(DEB_LEV_ERR, "In %s: wrong port for this operation portIndex=%d port->portIndex=%d\n", __func__, (int)portIndex, (int)openmaxStandPort->sPortParam.nPortIndex);
++    return OMX_ErrorBadPortIndex;
++  }
++
++  if(omx_base_component_Private->state == OMX_StateInvalid) {
++    DEBUG(DEB_LEV_ERR, "In %s: we are in OMX_StateInvalid\n", __func__);
++    return OMX_ErrorInvalidState;
++  }
++
++  if(omx_base_component_Private->state != OMX_StateExecuting &&
++    omx_base_component_Private->state != OMX_StatePause &&
++    omx_base_component_Private->state != OMX_StateIdle) {
++    DEBUG(DEB_LEV_ERR, "In %s: we are not in executing/paused/idle state, but in %d\n", __func__, omx_base_component_Private->state);
++    return OMX_ErrorIncorrectStateOperation;
++  }
++  if (!PORT_IS_ENABLED(openmaxStandPort) || (PORT_IS_BEING_DISABLED(openmaxStandPort) && !PORT_IS_TUNNELED_N_BUFFER_SUPPLIER(openmaxStandPort)) ||
++      (omx_base_component_Private->transientState == OMX_TransStateExecutingToIdle &&
++      (PORT_IS_TUNNELED(openmaxStandPort) && !PORT_IS_BUFFER_SUPPLIER(openmaxStandPort)))) {
++    DEBUG(DEB_LEV_ERR, "In %s: Port %d is disabled comp = %s \n", __func__, (int)portIndex,omx_base_component_Private->name);
++    return OMX_ErrorIncorrectStateOperation;
++  }
++
++  /* Temporarily disable this check for gst-openmax */
++#if NO_GST_OMX_PATCH
++  {
++  OMX_BOOL foundBuffer = OMX_FALSE;
++  if(pBuffer!=NULL && pBuffer->pBuffer!=NULL) {
++    for(i=0; i < openmaxStandPort->sPortParam.nBufferCountActual; i++){
++    if (pBuffer->pBuffer == openmaxStandPort->pInternalBufferStorage[i]->pBuffer) {
++      foundBuffer = OMX_TRUE;
++      break;
++    }
++    }
++  }
++  if (!foundBuffer) {
++    return OMX_ErrorBadParameter;
++  }
++  }
++#endif
++
++  if ((err = checkHeader(pBuffer, sizeof(OMX_BUFFERHEADERTYPE))) != OMX_ErrorNone) {
++    DEBUG(DEB_LEV_ERR, "In %s: received wrong buffer header on input port\n", __func__);
++    return err;
++  }
++  /*If port is not tunneled then simply return the buffer except paused state*/
++  if (!PORT_IS_TUNNELED(openmaxStandPort) && (omx_base_component_Private->state != OMX_StatePause)) {
++    openmaxStandPort->ReturnBufferFunction(openmaxStandPort,pBuffer);
++    return OMX_ErrorNone;
++  }
++
++  /* And notify the buffer management thread we have a fresh new buffer to manage */
++  if(!PORT_IS_BEING_FLUSHED(openmaxStandPort) && !(PORT_IS_BEING_DISABLED(openmaxStandPort) && PORT_IS_TUNNELED_N_BUFFER_SUPPLIER(openmaxStandPort))){
++    omx_queue(openmaxStandPort->pBufferQueue, pBuffer);
++    omx_tsem_up(openmaxStandPort->pBufferSem);
++    DEBUG(DEB_LEV_PARAMS, "In %s Signalling bMgmtSem Port Index=%d\n",__func__, (int)portIndex);
++    omx_tsem_up(omx_base_component_Private->bMgmtSem);
++  }else if(PORT_IS_BUFFER_SUPPLIER(openmaxStandPort)){
++    DEBUG(DEB_LEV_FULL_SEQ, "In %s: Comp %s received io:%d buffer\n",
++        __func__,omx_base_component_Private->name,(int)openmaxStandPort->sPortParam.nPortIndex);
++    omx_queue(openmaxStandPort->pBufferQueue, pBuffer);
++    omx_tsem_up(openmaxStandPort->pBufferSem);
++  }
++  else { // If port being flushed and not tunneled then return error
++    DEBUG(DEB_LEV_FULL_SEQ, "In %s \n", __func__);
++    return OMX_ErrorIncorrectStateOperation;
++  }
++  return OMX_ErrorNone;
++}
+diff --git a/alsa/omx_base_clock_port.h b/alsa/omx_base_clock_port.h
+new file mode 100644
+index 0000000..97f543e
+--- /dev/null
++++ b/alsa/omx_base_clock_port.h
+@@ -0,0 +1,95 @@
++/**
++  @file src/base/omx_base_clock_port.h
++
++  Base Clock Port class for OpenMAX clock ports to be used in derived components.
++
++  Copyright (C) 2007-2008 STMicroelectronics
++  Copyright (C) 2007-2008 Nokia Corporation and/or its subsidiary(-ies).
++
++  This library 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.
++
++  This library 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 this library; if not, write to the Free Software Foundation, Inc.,
++  51 Franklin St, Fifth Floor, Boston, MA
++  02110-1301  USA
++
++  $Date: 2008-07-04 11:48:31 +0200 (Fri, 04 Jul 2008) $
++  Revision $Rev: 560 $
++  Author $Author: gsent $
++
++*/
++
++#include "omx_classmagic.h"
++#include "omx_base_port.h"
++
++#ifndef __OMX_BASE_CLOCK_PORT_H__
++#define __OMX_BASE_CLOCK_PORT_H__
++
++/**
++ * @brief the base clock domain structure that describes each port.
++ *
++ * The data structure is derived from base port class and contain clock
++ * domain specific parameters.
++ * Other elements can be added in the derived components structures.
++ *
++ * @param sOtherParam Domain specific (other) OpenMAX port parameter
++ */
++
++DERIVEDCLASS(omx_base_clock_PortType, omx_base_PortType)
++#define omx_base_clock_PortType_FIELDS omx_base_PortType_FIELDS \
++  OMX_TIME_CONFIG_TIMESTAMPTYPE        sTimeStamp;  /**< General OpenMAX configuration time stamp parameter */ \
++  OMX_TIME_MEDIATIMETYPE               sMediaTime; \
++  OMX_TIME_CONFIG_MEDIATIMEREQUESTTYPE sMediaTimeRequest; \
++  OMX_OTHER_PARAM_PORTFORMATTYPE       sOtherParam; /**< Domain specific (other) OpenMAX port parameter */
++ENDCLASS(omx_base_clock_PortType)
++
++/**
++  * @brief the base contructor for the generic openmax ST clock port
++  *
++  * This function is executed by the component that uses a port.
++  * The parameter contains the info about the component.
++  * It takes care of constructing the instance of the port and
++  * every object needed by the base port.
++  *
++  * @param openmaxStandComp pointer to the Handle of the component
++  * @param openmaxStandPort the ST port to be initialized
++  * @param nPortIndex Index of the port to be constructed
++  * @param isInput specifices if the port is an input or an output
++  *
++  * @return OMX_ErrorInsufficientResources if a memory allocation fails
++  */
++
++OMX_ERRORTYPE base_clock_port_Constructor(
++  OMX_COMPONENTTYPE *openmaxStandComp,
++  omx_base_PortType **openmaxStandPort,
++  OMX_U32 nPortIndex,
++  OMX_BOOL isInput);
++
++/**
++  * @brief the base clock port destructor for the generic openmax ST clock port
++  *
++  * This function is executed by the component that uses a port.
++  * The parameter contains the info about the port.
++  * It takes care of destructing the instance of the port
++  *
++  * @param openmaxStandPort the ST port to be destructed
++  *
++  * @return OMX_ErrorNone
++  */
++
++OMX_ERRORTYPE base_clock_port_Destructor(
++  omx_base_PortType *openmaxStandPort);
++
++OMX_ERRORTYPE base_clock_port_SendBufferFunction(
++  omx_base_PortType *openmaxStandPort,
++  OMX_BUFFERHEADERTYPE* pBuffer);
++
++#endif
+diff --git a/alsa/omx_base_component.cpp b/alsa/omx_base_component.cpp
+new file mode 100644
+index 0000000..8396979
+--- /dev/null
++++ b/alsa/omx_base_component.cpp
+@@ -0,0 +1,1755 @@
++/**
++  @file src/base/omx_base_component.c
++
++  OpenMAX base_component component. This component does not perform any multimedia
++  processing.  It is used as a base_component for new components development.
++
++  Copyright (C) 2007-2008 STMicroelectronics
++  Copyright (C) 2007-2008 Nokia Corporation and/or its subsidiary(-ies).
++
++  This library 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.
++
++  This library 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 this library; if not, write to the Free Software Foundation, Inc.,
++  51 Franklin St, Fifth Floor, Boston, MA
++  02110-1301  USA
++
++  $Date: 2008-09-16 15:59:45 +0200 (Tue, 16 Sep 2008) $
++  Revision $Rev: 621 $
++  Author $Author: gsent $
++
++*/
++
++#include <stdlib.h>
++#include <stdio.h>
++#include <string.h>
++#include <unistd.h>
++#include <errno.h>
++
++//#include <IL/OMX_Core.h>
++//#include <IL/OMX_Component.h>
++
++#include "omx_semaphore.h"
++#include "omx_base_component.h"
++
++/**
++ * @brief The base contructor for the OpenMAX st components
++ *
++ * This function is executed by the ST static component loader.
++ * It takes care of constructing the instance of the component.
++ * For the base_component component, the following is done:
++ *
++ * 1) Fills the basic OpenMAX structure. The fields can be overwritten
++ *    by derived components.
++ * 2) Allocates (if needed) the omx_base_component_PrivateType private structure
++ *
++ * @param openmaxStandComp the ST component to be initialized
++ * @param cComponentName the OpenMAX string that describes the component
++ *
++ * @return OMX_ErrorInsufficientResources if a memory allocation fails
++ */
++OMX_ERRORTYPE omx_base_component_Constructor(OMX_COMPONENTTYPE *openmaxStandComp,OMX_STRING cComponentName) {
++  omx_base_component_PrivateType* omx_base_component_Private;
++  OMX_U32 i;
++
++  DEBUG(DEB_LEV_FUNCTION_NAME, "In %s\n", __func__);
++
++  if (openmaxStandComp->pComponentPrivate) {
++    omx_base_component_Private = (omx_base_component_PrivateType*)openmaxStandComp->pComponentPrivate;
++  } else {
++    omx_base_component_Private = (omx_base_component_PrivateType*)calloc(1,sizeof(omx_base_component_PrivateType));
++    if (!omx_base_component_Private) {
++      return OMX_ErrorInsufficientResources;
++    }
++  }
++
++  if(!omx_base_component_Private->messageQueue) {
++    omx_base_component_Private->messageQueue = (omx_queue_t*)calloc(1,sizeof(omx_queue_t));
++    omx_queue_init(omx_base_component_Private->messageQueue);
++  }
++
++  if(!omx_base_component_Private->messageSem) {
++    omx_base_component_Private->messageSem = (omx_tsem_t*)calloc(1,sizeof(omx_tsem_t));
++    omx_tsem_init(omx_base_component_Private->messageSem, 0);
++  }
++  if(!omx_base_component_Private->bMgmtSem) {
++    omx_base_component_Private->bMgmtSem = (omx_tsem_t*)calloc(1,sizeof(omx_tsem_t));
++    omx_tsem_init(omx_base_component_Private->bMgmtSem, 0);
++  }
++
++  if(!omx_base_component_Private->bStateSem) {
++    omx_base_component_Private->bStateSem = (omx_tsem_t*)calloc(1,sizeof(omx_tsem_t));
++    omx_tsem_init(omx_base_component_Private->bStateSem, 0);
++  }
++
++  openmaxStandComp->nSize = sizeof(OMX_COMPONENTTYPE);
++  openmaxStandComp->pApplicationPrivate = NULL;
++  openmaxStandComp->GetComponentVersion = omx_base_component_GetComponentVersion;
++  openmaxStandComp->SendCommand = omx_base_component_SendCommand;
++  openmaxStandComp->GetParameter = omx_base_component_GetParameter;
++  openmaxStandComp->SetParameter = omx_base_component_SetParameter;
++  openmaxStandComp->GetConfig = omx_base_component_GetConfig;
++  openmaxStandComp->SetConfig = omx_base_component_SetConfig;
++  openmaxStandComp->GetExtensionIndex = omx_base_component_GetExtensionIndex;
++  openmaxStandComp->GetState = omx_base_component_GetState;
++  openmaxStandComp->SetCallbacks = omx_base_component_SetCallbacks;
++  openmaxStandComp->ComponentDeInit = omx_base_component_ComponentDeInit;
++  openmaxStandComp->ComponentRoleEnum = omx_base_component_ComponentRoleEnum;
++  openmaxStandComp->ComponentTunnelRequest =omx_base_component_ComponentTunnelRequest;
++
++  /*Will make Specific port Allocate buffer call*/
++  openmaxStandComp->AllocateBuffer = omx_base_component_AllocateBuffer;
++  openmaxStandComp->UseBuffer = omx_base_component_UseBuffer;
++  openmaxStandComp->UseEGLImage = omx_base_component_UseEGLImage;
++  openmaxStandComp->FreeBuffer = omx_base_component_FreeBuffer;
++  openmaxStandComp->EmptyThisBuffer = omx_base_component_EmptyThisBuffer;
++  openmaxStandComp->FillThisBuffer = omx_base_component_FillThisBuffer;
++
++  openmaxStandComp->nVersion.s.nVersionMajor = OMX_VERSION_MAJOR;
++  openmaxStandComp->nVersion.s.nVersionMinor = OMX_VERSION_MINOR;
++  openmaxStandComp->nVersion.s.nRevision = OMX_VERSION_REVISION;
++  openmaxStandComp->nVersion.s.nStep = OMX_VERSION_STEP;
++
++  omx_base_component_Private->name = (char*)calloc(1,OMX_MAX_STRINGNAME_SIZE);
++  if (!omx_base_component_Private->name) {
++    return OMX_ErrorInsufficientResources;
++  }
++  strcpy(omx_base_component_Private->name,cComponentName);
++  omx_base_component_Private->state = OMX_StateLoaded;
++  omx_base_component_Private->transientState = OMX_TransStateMax;
++  omx_base_component_Private->callbacks = NULL;
++  omx_base_component_Private->callbackData = NULL;
++  omx_base_component_Private->nGroupPriority = 0;
++  omx_base_component_Private->nGroupID = 0;
++  omx_base_component_Private->pMark.hMarkTargetComponent = NULL;
++  omx_base_component_Private->pMark.pMarkData            = NULL;
++  omx_base_component_Private->openmaxStandComp=openmaxStandComp;
++  omx_base_component_Private->DoStateSet = &omx_base_component_DoStateSet;
++  omx_base_component_Private->messageHandler = omx_base_component_MessageHandler;
++  omx_base_component_Private->destructor = omx_base_component_Destructor;
++  omx_base_component_Private->bufferMgmtThreadID = -1;
++
++  pthread_mutex_init(&omx_base_component_Private->flush_mutex, NULL);
++
++  if(!omx_base_component_Private->flush_all_condition) {
++    omx_base_component_Private->flush_all_condition = (omx_tsem_t*)calloc(1,sizeof(omx_tsem_t));
++    omx_tsem_init(omx_base_component_Private->flush_all_condition, 0);
++  }
++
++  if(!omx_base_component_Private->flush_condition) {
++    omx_base_component_Private->flush_condition = (omx_tsem_t*)calloc(1,sizeof(omx_tsem_t));
++    omx_tsem_init(omx_base_component_Private->flush_condition, 0);
++  }
++
++  for(i=0;i<NUM_DOMAINS;i++) {
++    memset(&omx_base_component_Private->sPortTypesParam[i], 0, sizeof(OMX_PORT_PARAM_TYPE));
++    setHeader(&omx_base_component_Private->sPortTypesParam[i], sizeof(OMX_PORT_PARAM_TYPE));
++  }
++
++  omx_base_component_Private->messageHandlerThreadID = pthread_create(&omx_base_component_Private->messageHandlerThread,
++  NULL,
++  compMessageHandlerFunction,
++  openmaxStandComp);
++
++  DEBUG(DEB_LEV_FUNCTION_NAME,"Out of %s\n",__func__);
++  return OMX_ErrorNone;
++}
++
++/** @brief The base destructor for ST OpenMAX components
++ *
++ * This function is called by the standard function ComponentDeInit()
++ * that is called by the IL core during the execution of the  FreeHandle()
++ *
++ * @param openmaxStandComp the ST OpenMAX component to be disposed
++ */
++OMX_ERRORTYPE omx_base_component_Destructor(OMX_COMPONENTTYPE *openmaxStandComp) {
++  omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)openmaxStandComp->pComponentPrivate;
++  int err;
++
++  DEBUG(DEB_LEV_FUNCTION_NAME, "In %s\n", __func__);
++  omx_base_component_Private->state = OMX_StateInvalid;
++
++  /*Send Dummy signal to Component Message handler to exit*/
++  omx_tsem_up(omx_base_component_Private->messageSem);
++  DEBUG(DEB_LEV_FUNCTION_NAME,"In %s messageSem signaled. messageSem->semval=%d\n", __func__, omx_base_component_Private->messageSem->semval);
++
++  err = pthread_join(omx_base_component_Private->messageHandlerThread,NULL);
++  if(err!=0) {
++    DEBUG(DEB_LEV_FUNCTION_NAME,"In %s pthread_join returned err=%d\n", __func__, err);
++  }
++  DEBUG(DEB_LEV_FUNCTION_NAME,"In %s past pthread_join\n", __func__);
++
++  omx_base_component_Private->callbacks=NULL;
++
++  /*Deinitialize and free message queue*/
++  if(omx_base_component_Private->messageQueue) {
++    omx_queue_deinit(omx_base_component_Private->messageQueue);
++    free(omx_base_component_Private->messageQueue);
++    omx_base_component_Private->messageQueue=NULL;
++  }
++
++  /*Deinitialize and free buffer management semaphore*/
++  if(omx_base_component_Private->bMgmtSem){
++    omx_tsem_deinit(omx_base_component_Private->bMgmtSem);
++    free(omx_base_component_Private->bMgmtSem);
++    omx_base_component_Private->bMgmtSem=NULL;
++  }
++
++  /*Deinitialize and free message semaphore*/
++  if(omx_base_component_Private->messageSem) {
++    omx_tsem_deinit(omx_base_component_Private->messageSem);
++    free(omx_base_component_Private->messageSem);
++    omx_base_component_Private->messageSem=NULL;
++  }
++
++  if(omx_base_component_Private->bStateSem){
++    omx_tsem_deinit(omx_base_component_Private->bStateSem);
++    free(omx_base_component_Private->bStateSem);
++    omx_base_component_Private->bStateSem=NULL;
++  }
++
++  if(omx_base_component_Private->name){
++    free(omx_base_component_Private->name);
++    omx_base_component_Private->name=NULL;
++  }
++
++  pthread_mutex_destroy(&omx_base_component_Private->flush_mutex);
++
++  if(omx_base_component_Private->flush_all_condition){
++    omx_tsem_deinit(omx_base_component_Private->flush_all_condition);
++    free(omx_base_component_Private->flush_all_condition);
++    omx_base_component_Private->flush_all_condition=NULL;
++  }
++
++  if(omx_base_component_Private->flush_condition){
++    omx_tsem_deinit(omx_base_component_Private->flush_condition);
++    free(omx_base_component_Private->flush_condition);
++    omx_base_component_Private->flush_condition=NULL;
++  }
++
++  DEBUG(DEB_LEV_FUNCTION_NAME,"Out of %s\n",__func__);
++  return OMX_ErrorNone;
++}
++
++/** @brief This standard functionality is called when the component is
++ * destroyed in the FreeHandle standard call.
++ *
++ * In this way the implementation of the FreeHandle is standard,
++ * and it does not need a support by a specific component loader.
++ * The implementaiton of the ComponentDeInit contains the
++ * implementation specific part of the destroying phase.
++ */
++OMX_ERRORTYPE omx_base_component_ComponentDeInit(
++  OMX_IN  OMX_HANDLETYPE hComponent) {
++  OMX_COMPONENTTYPE *openmaxStandComp = (OMX_COMPONENTTYPE *)hComponent;
++  omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)openmaxStandComp->pComponentPrivate;
++
++  DEBUG(DEB_LEV_FUNCTION_NAME, "In %s pComponentPrivate =%x \n", __func__,(int)openmaxStandComp->pComponentPrivate);
++  omx_base_component_Private->destructor(openmaxStandComp);
++
++  free(openmaxStandComp->pComponentPrivate);
++  openmaxStandComp->pComponentPrivate=NULL;
++  return OMX_ErrorNone;
++}
++
++/** Changes the state of a component taking proper actions depending on
++ * the transiotion requested. This base function cover only the state
++ * changes that do not involve any port
++ *
++ * @param openmaxStandComp the OpenMAX component which state is to be changed
++ * @param destinationState the requested target state
++ *
++ * @return OMX_ErrorNotImplemented if the state change is noty handled in this base class, but needs
++ * a specific handling
++ */
++OMX_ERRORTYPE omx_base_component_DoStateSet(OMX_COMPONENTTYPE *openmaxStandComp, OMX_U32 destinationState) {
++  omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)openmaxStandComp->pComponentPrivate;
++  omx_base_PortType *pPort;
++  OMX_U32 i,j,k;
++  OMX_ERRORTYPE err=OMX_ErrorNone;
++
++  DEBUG(DEB_LEV_FUNCTION_NAME, "In %s\n", __func__);
++  DEBUG(DEB_LEV_PARAMS, "Changing state from %i to %i\n", omx_base_component_Private->state, (int)destinationState);
++
++  if(destinationState == OMX_StateLoaded){
++    switch(omx_base_component_Private->state){
++    case OMX_StateInvalid:
++      err = OMX_ErrorInvalidState;
++      break;
++    case OMX_StateWaitForResources:
++      /* return back from wait for resources */
++      omx_base_component_Private->state = OMX_StateLoaded;
++      break;
++    case OMX_StateLoaded:
++      err = OMX_ErrorSameState;
++      break;
++    case OMX_StateIdle:
++      /* for all ports */
++      for(j = 0; j < NUM_DOMAINS; j++) {
++        for(i = omx_base_component_Private->sPortTypesParam[j].nStartPortNumber;
++          i < omx_base_component_Private->sPortTypesParam[j].nStartPortNumber +
++            omx_base_component_Private->sPortTypesParam[j].nPorts; i++) {
++
++          pPort = omx_base_component_Private->ports[i];
++          if (PORT_IS_TUNNELED(pPort) && PORT_IS_BUFFER_SUPPLIER(pPort)) {
++            while(pPort->pBufferQueue->nelem > 0) {
++              DEBUG(DEB_LEV_PARAMS, "In %s Buffer %d remained in the port %d queue of comp%s\n",
++                   __func__,(int)pPort->pBufferQueue->nelem,(int)i,omx_base_component_Private->name);
++              omx_dequeue(pPort->pBufferQueue);
++            }
++            /* Freeing here the buffers allocated for the tunneling:*/
++            err = pPort->Port_FreeTunnelBuffer(pPort,i);
++            if(err!=OMX_ErrorNone) {
++              DEBUG(DEB_LEV_ERR, "In %s Freeing Tunnel Buffer Error=%x\n",__func__,err);
++              return err;
++            }
++          } else {
++            DEBUG(DEB_LEV_FULL_SEQ, "In %s nPortIndex=%d pAllocSem Semval=%x\n", __func__,(int)i,(int)pPort->pAllocSem->semval);
++
++            /*If ports are enabled then wait till all buffers are freed*/
++            if(PORT_IS_ENABLED(pPort)) {
++              omx_tsem_down(pPort->pAllocSem);
++            }
++          }
++          pPort->sPortParam.bPopulated = OMX_FALSE;
++
++          if(pPort->bTunnelTearDown == OMX_TRUE){
++            DEBUG(DEB_LEV_PARAMS, "In %s TearDown tunnel\n", __func__);
++            pPort->hTunneledComponent = 0;
++            pPort->nTunneledPort = 0;
++            pPort->nTunnelFlags = 0;
++            pPort->eBufferSupplier=OMX_BufferSupplyUnspecified;
++            pPort->bTunnelTearDown = OMX_FALSE;
++          }
++
++          if(pPort->pInternalBufferStorage != NULL) {
++            free(pPort->pInternalBufferStorage);
++            pPort->pInternalBufferStorage=NULL;
++          }
++
++          if(pPort->bBufferStateAllocated != NULL) {
++            free(pPort->bBufferStateAllocated);
++            pPort->bBufferStateAllocated=NULL;
++          }
++        }
++      }
++      omx_base_component_Private->state = OMX_StateLoaded;
++
++      if(omx_base_component_Private->bufferMgmtThreadID == 0 ){
++        /*Signal Buffer Management thread to exit*/
++        omx_tsem_up(omx_base_component_Private->bMgmtSem);
++        pthread_join(omx_base_component_Private->bufferMgmtThread,NULL);
++        omx_base_component_Private->bufferMgmtThreadID = -1;
++        if(err != 0) {
++          DEBUG(DEB_LEV_FUNCTION_NAME,"In %s pthread_join returned err=%d\n",__func__,err);
++        }
++      }
++
++      break;
++    default:
++      DEBUG(DEB_LEV_ERR, "In %s: state transition not allowed\n", __func__);
++      err = OMX_ErrorIncorrectStateTransition;
++      break;
++    }
++    return err;
++  }
++
++  if(destinationState == OMX_StateWaitForResources){
++    switch(omx_base_component_Private->state){
++    case OMX_StateInvalid:
++      err = OMX_ErrorInvalidState;
++      break;
++    case OMX_StateLoaded:
++      omx_base_component_Private->state = OMX_StateWaitForResources;
++      break;
++    case OMX_StateWaitForResources:
++      err = OMX_ErrorSameState;
++      break;
++    default:
++      DEBUG(DEB_LEV_ERR, "In %s: state transition not allowed\n", __func__);
++      err = OMX_ErrorIncorrectStateTransition;
++      break;
++    }
++    return err;
++  }
++
++  if(destinationState == OMX_StateIdle){
++    switch(omx_base_component_Private->state){
++    case OMX_StateInvalid:
++      err = OMX_ErrorInvalidState;
++      break;
++    case OMX_StateWaitForResources:
++      omx_base_component_Private->state = OMX_StateIdle;
++      break;
++    case OMX_StateLoaded:
++      /* for all ports */
++      for(j = 0; j < NUM_DOMAINS; j++) {
++        for(i = omx_base_component_Private->sPortTypesParam[j].nStartPortNumber;
++            i < omx_base_component_Private->sPortTypesParam[j].nStartPortNumber +
++              omx_base_component_Private->sPortTypesParam[j].nPorts; i++) {
++        pPort = omx_base_component_Private->ports[i];
++        if (PORT_IS_TUNNELED(pPort) && PORT_IS_BUFFER_SUPPLIER(pPort)) {
++          if(PORT_IS_ENABLED(pPort)) {
++            /** Allocate here the buffers needed for the tunneling */
++            err= pPort->Port_AllocateTunnelBuffer(pPort, i, omx_base_component_Private->ports[i]->sPortParam.nBufferSize);
++            if(err!=OMX_ErrorNone) {
++              DEBUG(DEB_LEV_ERR, "In %s Allocating Tunnel Buffer Port=%d, Error=%x\n",__func__,i,err);
++              return err;
++            }
++          }
++        } else {
++          if(PORT_IS_ENABLED(pPort)) {
++            DEBUG(DEB_LEV_FULL_SEQ, "In %s: wait for buffers. port enabled %i,  port populated %i\n",
++              __func__, pPort->sPortParam.bEnabled,pPort->sPortParam.bPopulated);
++            omx_tsem_down(pPort->pAllocSem);
++            pPort->sPortParam.bPopulated = OMX_TRUE;
++          }
++          else
++            DEBUG(DEB_LEV_ERR, "In %s: Port %i Disabled So no wait\n",__func__,(int)i);
++        }
++        DEBUG(DEB_LEV_SIMPLE_SEQ, "---> Tunnel status : port %d flags  0x%x\n",(int)i, (int)pPort->nTunnelFlags);
++        }
++      }
++      omx_base_component_Private->state = OMX_StateIdle;
++      /** starting buffer management thread */
++      omx_base_component_Private->bufferMgmtThreadID = pthread_create(&omx_base_component_Private->bufferMgmtThread,
++      NULL,
++      omx_base_component_Private->BufferMgmtFunction,
++      openmaxStandComp);
++      if(omx_base_component_Private->bufferMgmtThreadID < 0){
++        DEBUG(DEB_LEV_ERR, "Starting buffer management thread failed\n");
++        return OMX_ErrorUndefined;
++      }
++      break;
++    case OMX_StateIdle:
++      err = OMX_ErrorSameState;
++      break;
++    case OMX_StateExecuting:
++      /*Flush Ports*/
++      /* for all ports */
++      for(j = 0; j < NUM_DOMAINS; j++) {
++        for(i = omx_base_component_Private->sPortTypesParam[j].nStartPortNumber;
++        i < omx_base_component_Private->sPortTypesParam[j].nStartPortNumber +
++        omx_base_component_Private->sPortTypesParam[j].nPorts; i++) {
++          DEBUG(DEB_LEV_FULL_SEQ, "Flushing Port %i\n",(int)i);
++          pPort = omx_base_component_Private->ports[i];
++          if(PORT_IS_ENABLED(pPort)) {
++            pPort->FlushProcessingBuffers(pPort);
++          }
++        }
++      }
++      omx_base_component_Private->state = OMX_StateIdle;
++      break;
++      case OMX_StatePause:
++      omx_base_component_Private->state = OMX_StateIdle;
++      /*Signal buffer management thread if waiting at paused state*/
++      omx_tsem_signal(omx_base_component_Private->bStateSem);
++      break;
++    default:
++      DEBUG(DEB_LEV_ERR, "In %s: state transition not allowed\n", __func__);
++      err = OMX_ErrorIncorrectStateTransition;
++      break;
++    }
++    return err;
++  }
++
++  if(destinationState == OMX_StatePause) {
++  switch(omx_base_component_Private->state) {
++    case OMX_StateInvalid:
++      err = OMX_ErrorInvalidState;
++      break;
++    case OMX_StatePause:
++      err = OMX_ErrorSameState;
++      break;
++    case OMX_StateExecuting:
++    case OMX_StateIdle:
++      omx_base_component_Private->state = OMX_StatePause;
++      break;
++    default:
++      DEBUG(DEB_LEV_ERR, "In %s: state transition not allowed\n", __func__);
++      err = OMX_ErrorIncorrectStateTransition;
++      break;
++    }
++    return err;
++  }
++
++  if(destinationState == OMX_StateExecuting) {
++    switch(omx_base_component_Private->state) {
++    case OMX_StateInvalid:
++      err = OMX_ErrorInvalidState;
++      break;
++    case OMX_StateIdle:
++      omx_base_component_Private->state=OMX_StateExecuting;
++      /*Send Tunneled Buffer to the Neighbouring Components*/
++      /* for all ports */
++      for(j = 0; j < NUM_DOMAINS; j++) {
++        for(i = omx_base_component_Private->sPortTypesParam[j].nStartPortNumber;
++        i < omx_base_component_Private->sPortTypesParam[j].nStartPortNumber +
++          omx_base_component_Private->sPortTypesParam[j].nPorts; i++) {
++          pPort = omx_base_component_Private->ports[i];
++          if (PORT_IS_TUNNELED(pPort) && PORT_IS_BUFFER_SUPPLIER(pPort) && PORT_IS_ENABLED(pPort)) {
++            for(k=0;k<pPort->nNumTunnelBuffer;k++) {
++              omx_tsem_up(pPort->pBufferSem);
++              /*signal buffer management thread availability of buffers*/
++              omx_tsem_up(omx_base_component_Private->bMgmtSem);
++            }
++          }
++        }
++      }
++      omx_base_component_Private->transientState = OMX_TransStateMax;
++      err = OMX_ErrorNone;
++      break;
++    case OMX_StatePause:
++      omx_base_component_Private->state=OMX_StateExecuting;
++
++      /* Tunneled Supplier Ports were enabled in paused state. So signal buffer managment thread*/
++      /* for all ports */
++      for(j = 0; j < NUM_DOMAINS; j++) {
++        for(i = omx_base_component_Private->sPortTypesParam[j].nStartPortNumber;
++          i < omx_base_component_Private->sPortTypesParam[j].nStartPortNumber +
++          omx_base_component_Private->sPortTypesParam[j].nPorts; i++) {
++
++          pPort=omx_base_component_Private->ports[i];
++          DEBUG(DEB_LEV_PARAMS, "In %s: state transition Paused 2 Executing, nelem=%d,semval=%d,Buf Count Actual=%d\n", __func__,
++            pPort->pBufferQueue->nelem,pPort->pBufferSem->semval,(int)pPort->sPortParam.nBufferCountActual);
++
++          if (PORT_IS_TUNNELED_N_BUFFER_SUPPLIER(pPort) &&
++            (pPort->pBufferQueue->nelem == (pPort->pBufferSem->semval + pPort->sPortParam.nBufferCountActual))) {
++            for(k=0; k < pPort->sPortParam.nBufferCountActual;k++) {
++              omx_tsem_up(pPort->pBufferSem);
++              omx_tsem_up(omx_base_component_Private->bMgmtSem);
++            }
++          }
++        }
++      }
++      /*Signal buffer management thread if waiting at paused state*/
++      omx_tsem_signal(omx_base_component_Private->bStateSem);
++      break;
++    case OMX_StateExecuting:
++      err = OMX_ErrorSameState;
++      break;
++    default:
++      DEBUG(DEB_LEV_ERR, "In %s: state transition not allowed\n", __func__);
++      err = OMX_ErrorIncorrectStateTransition;
++      break;
++    }
++    return err;
++  }
++
++  if(destinationState == OMX_StateInvalid) {
++    switch(omx_base_component_Private->state) {
++    case OMX_StateInvalid:
++      err = OMX_ErrorInvalidState;
++      break;
++    default:
++      omx_base_component_Private->state = OMX_StateInvalid;
++
++      if(omx_base_component_Private->bufferMgmtThreadID == 0 ){
++        /*Signal Buffer Management Thread to Exit*/
++        omx_tsem_up(omx_base_component_Private->bMgmtSem);
++        pthread_join(omx_base_component_Private->bufferMgmtThread,NULL);
++        omx_base_component_Private->bufferMgmtThreadID = -1;
++        if(err!=0) {
++          DEBUG(DEB_LEV_FUNCTION_NAME,"In %s pthread_join returned err=%d\n",__func__,err);
++        }
++      }
++      err = OMX_ErrorInvalidState;
++      break;
++    }
++    return err;
++  }
++  return OMX_ErrorNone;
++}
++
++/** @brief Checks the header of a structure for consistency
++ * with size and spec version
++ *
++ * @param header Pointer to the structure to be checked
++ * @param size Size of the structure. it is in general obtained
++ * with a sizeof call applied to the structure
++ *
++ * @return OMX error code. If the header has failed the check,
++ * OMX_ErrorVersionMismatch is returned.
++ * If the header fails the size check OMX_ErrorBadParameter is returned
++ */
++OMX_ERRORTYPE checkHeader(OMX_PTR header, OMX_U32 size) {
++  OMX_VERSIONTYPE* ver;
++  if (header == NULL) {
++    DEBUG(DEB_LEV_ERR, "In %s the header is null\n",__func__);
++    return OMX_ErrorBadParameter;
++  }
++  ver = (OMX_VERSIONTYPE*)((char*)header + sizeof(OMX_U32));
++  if(*((OMX_U32*)header) != size) {
++    DEBUG(DEB_LEV_ERR, "In %s the header has a wrong size %i should be %i\n",__func__,(int)*((OMX_U32*)header),(int)size);
++    return OMX_ErrorBadParameter;
++  }
++  if(ver->s.nVersionMajor != OMX_VERSION_MAJOR ||
++    ver->s.nVersionMinor != OMX_VERSION_MINOR) {
++    DEBUG(DEB_LEV_ERR, "The version does not match\n");
++    return OMX_ErrorVersionMismatch;
++  }
++  return OMX_ErrorNone;
++}
++
++/** @brief Simply fills the first two fields in any OMX structure
++ * with the size and the version
++ *
++ * @param header pointer to the structure to be filled
++ * @param size size of the structure. It can be obtained with
++ * a call to sizeof of the structure type
++ */
++void setHeader(OMX_PTR header, OMX_U32 size) {
++  OMX_VERSIONTYPE* ver = (OMX_VERSIONTYPE*)((char*)header + sizeof(OMX_U32));
++  *((OMX_U32*)header) = size;
++
++  ver->s.nVersionMajor = OMX_VERSION_MAJOR;
++  ver->s.nVersionMinor = OMX_VERSION_MINOR;
++  ver->s.nRevision = OMX_VERSION_REVISION;
++  ver->s.nStep = OMX_VERSION_STEP;
++}
++
++/**
++ * This function verify Component State and Structure header
++ */
++OMX_ERRORTYPE omx_base_component_ParameterSanityCheck(OMX_IN  OMX_HANDLETYPE hComponent,
++  OMX_IN  OMX_U32 nPortIndex,
++  OMX_IN  OMX_PTR pStructure,
++  OMX_IN  size_t size) {
++  omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)(((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate);
++  omx_base_PortType *pPort;
++  int nNumPorts;
++
++  nNumPorts = omx_base_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts +
++              omx_base_component_Private->sPortTypesParam[OMX_PortDomainVideo].nPorts +
++              omx_base_component_Private->sPortTypesParam[OMX_PortDomainImage].nPorts +
++              omx_base_component_Private->sPortTypesParam[OMX_PortDomainOther].nPorts;
++
++  if (nPortIndex >= nNumPorts) {
++    DEBUG(DEB_LEV_ERR, "Bad Port index %i when the component has %i ports\n", (int)nPortIndex, (int)nNumPorts);
++    return OMX_ErrorBadPortIndex;
++  }
++
++  pPort = omx_base_component_Private->ports[nPortIndex];
++
++  if (omx_base_component_Private->state != OMX_StateLoaded && omx_base_component_Private->state != OMX_StateWaitForResources) {
++    if(PORT_IS_ENABLED(pPort)) {
++      DEBUG(DEB_LEV_ERR, "In %s Incorrect State=%x lineno=%d\n",__func__,omx_base_component_Private->state,__LINE__);
++      return OMX_ErrorIncorrectStateOperation;
++    }
++  }
++
++  return checkHeader(pStructure , size);
++}
++
++/** @brief Standard OpenMAX function
++ *
++ * it returns the version of the component. See OMX_Core.h
++ */
++OMX_ERRORTYPE omx_base_component_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) {
++
++  OMX_COMPONENTTYPE* omx_component = (OMX_COMPONENTTYPE*)hComponent;
++  omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)omx_component->pComponentPrivate;
++
++  OMX_U32 uuid[3];
++
++  DEBUG(DEB_LEV_FUNCTION_NAME, "In %s\n", __func__);
++  /* Fill component name */
++  strcpy(pComponentName, omx_base_component_Private->name);
++
++  /* Fill component version */
++  pComponentVersion->s.nVersionMajor = OMX_VERSION_MAJOR;
++  pComponentVersion->s.nVersionMinor = OMX_VERSION_MINOR;
++  pComponentVersion->s.nRevision = OMX_VERSION_REVISION;
++  pComponentVersion->s.nStep = OMX_VERSION_STEP;
++
++  /* Fill spec version (copy from component field) */
++  memcpy(pSpecVersion, &omx_component->nVersion, sizeof(OMX_VERSIONTYPE));
++
++  /* Fill UUID with handle address, PID and UID.
++   * This should guarantee uiniqness */
++  uuid[0] = (OMX_U32)omx_component;
++  uuid[1] = getpid();
++  uuid[2] = getuid();
++  memcpy(*pComponentUUID, uuid, 3*sizeof(uuid));
++
++  DEBUG(DEB_LEV_FUNCTION_NAME, "Out of %s\n", __func__);
++  return OMX_ErrorNone;
++}
++
++/** @brief Enumerates all the roles of the component.
++ *
++ * This function is intended to be used only by a core. The ST static core
++ * in any case does not use this function, because it can not be used before the
++ * creation of the component, but uses a static list.
++ * It is implemented only for API completion,and it will be not overriden
++ * by a derived component
++ */
++OMX_ERRORTYPE omx_base_component_ComponentRoleEnum(
++  OMX_IN OMX_HANDLETYPE hComponent,
++  OMX_OUT OMX_U8 *cRole,
++  OMX_IN OMX_U32 nIndex) {
++  strcat((char*)cRole, "\0");
++  return OMX_ErrorNoMore;
++}
++
++/** @brief standard OpenMAX function
++ *
++ * it sets the callback functions given by the IL client.
++ * See OMX_Component.h
++ */
++OMX_ERRORTYPE omx_base_component_SetCallbacks(
++  OMX_IN  OMX_HANDLETYPE hComponent,
++  OMX_IN  OMX_CALLBACKTYPE* pCallbacks,
++  OMX_IN  OMX_PTR pAppData) {
++
++  OMX_COMPONENTTYPE *omxcomponent = (OMX_COMPONENTTYPE*)hComponent;
++  omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)omxcomponent->pComponentPrivate;
++  omx_base_PortType *pPort;
++  OMX_U32 i,j;
++
++  DEBUG(DEB_LEV_FUNCTION_NAME, "In %s\n", __func__);
++  omx_base_component_Private->callbacks = pCallbacks;
++  omx_base_component_Private->callbackData = pAppData;
++
++  /* for all ports */
++  for(j = 0; j < NUM_DOMAINS; j++) {
++    for(i = omx_base_component_Private->sPortTypesParam[j].nStartPortNumber;
++    i < omx_base_component_Private->sPortTypesParam[j].nStartPortNumber +
++      omx_base_component_Private->sPortTypesParam[j].nPorts; i++) {
++      pPort = omx_base_component_Private->ports[i];
++      if (pPort->sPortParam.eDir == OMX_DirInput) {
++        pPort->BufferProcessedCallback = omx_base_component_Private->callbacks->EmptyBufferDone;
++      } else {
++        pPort->BufferProcessedCallback = omx_base_component_Private->callbacks->FillBufferDone;
++      }
++    }
++  }
++  return OMX_ErrorNone;
++}
++
++/** @brief Part of the standard OpenMAX function
++ *
++ * This function return the parameters not related to any port.
++ * These parameters are handled in the derived components
++ * See OMX_Core.h for standard reference
++ *
++ * @return OMX_ErrorUnsupportedIndex if the index is not supported or not handled here
++ */
++OMX_ERRORTYPE omx_base_component_GetParameter(
++  OMX_IN  OMX_HANDLETYPE hComponent,
++  OMX_IN  OMX_INDEXTYPE nParamIndex,
++  OMX_INOUT OMX_PTR ComponentParameterStructure) {
++
++  OMX_COMPONENTTYPE *omxcomponent = (OMX_COMPONENTTYPE*)hComponent;
++  omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)omxcomponent->pComponentPrivate;
++  OMX_PRIORITYMGMTTYPE* pPrioMgmt;
++  OMX_PARAM_PORTDEFINITIONTYPE *pPortDef;
++  OMX_PARAM_BUFFERSUPPLIERTYPE *pBufferSupplier;
++  omx_base_PortType *pPort;
++  OMX_PORT_PARAM_TYPE* pPortDomains;
++  OMX_ERRORTYPE err = OMX_ErrorNone;
++  OMX_VENDOR_PROP_TUNNELSETUPTYPE *pPropTunnelSetup;
++
++  DEBUG(DEB_LEV_FUNCTION_NAME, "In %s\n", __func__);
++  DEBUG(DEB_LEV_PARAMS, "Getting parameter %i\n", nParamIndex);
++  if (ComponentParameterStructure == NULL) {
++    return OMX_ErrorBadParameter;
++  }
++  switch(nParamIndex) {
++  case OMX_IndexParamAudioInit:
++  case OMX_IndexParamVideoInit:
++  case OMX_IndexParamImageInit:
++  case OMX_IndexParamOtherInit:
++    pPortDomains = (OMX_PORT_PARAM_TYPE*)ComponentParameterStructure;
++    if ((err = checkHeader(ComponentParameterStructure, sizeof(OMX_PORT_PARAM_TYPE))) != OMX_ErrorNone) {
++      break;
++    }
++    pPortDomains->nPorts = 0;
++    pPortDomains->nStartPortNumber = 0;
++    break;
++  case OMX_IndexParamPortDefinition:
++    pPortDef  = (OMX_PARAM_PORTDEFINITIONTYPE*) ComponentParameterStructure;
++    if ((err = checkHeader(ComponentParameterStructure, sizeof(OMX_PARAM_PORTDEFINITIONTYPE))) != OMX_ErrorNone) {
++      break;
++    }
++    if (pPortDef->nPortIndex >= (omx_base_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts +
++                                 omx_base_component_Private->sPortTypesParam[OMX_PortDomainVideo].nPorts +
++                                 omx_base_component_Private->sPortTypesParam[OMX_PortDomainImage].nPorts +
++                                 omx_base_component_Private->sPortTypesParam[OMX_PortDomainOther].nPorts)) {
++      return OMX_ErrorBadPortIndex;
++    }
++
++    memcpy(pPortDef, &omx_base_component_Private->ports[pPortDef->nPortIndex]->sPortParam, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
++    break;
++  case OMX_IndexParamPriorityMgmt:
++    pPrioMgmt = (OMX_PRIORITYMGMTTYPE*)ComponentParameterStructure;
++    if ((err = checkHeader(ComponentParameterStructure, sizeof(OMX_PRIORITYMGMTTYPE))) != OMX_ErrorNone) {
++      break;
++    }
++    pPrioMgmt->nGroupPriority = omx_base_component_Private->nGroupPriority;
++    pPrioMgmt->nGroupID = omx_base_component_Private->nGroupID;
++    break;
++  case OMX_IndexParamCompBufferSupplier:
++    pBufferSupplier = (OMX_PARAM_BUFFERSUPPLIERTYPE*)ComponentParameterStructure;
++    if ((err = checkHeader(ComponentParameterStructure, sizeof(OMX_PARAM_BUFFERSUPPLIERTYPE))) != OMX_ErrorNone) {
++      break;
++    }
++    if (pBufferSupplier->nPortIndex >= (omx_base_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts +
++                                        omx_base_component_Private->sPortTypesParam[OMX_PortDomainVideo].nPorts +
++                                        omx_base_component_Private->sPortTypesParam[OMX_PortDomainImage].nPorts +
++                                        omx_base_component_Private->sPortTypesParam[OMX_PortDomainOther].nPorts)) {
++      return OMX_ErrorBadPortIndex;
++    }
++
++    pPort = omx_base_component_Private->ports[pBufferSupplier->nPortIndex];
++
++    if (pPort->sPortParam.eDir == OMX_DirInput) {
++      if (PORT_IS_BUFFER_SUPPLIER(pPort)) {
++        pBufferSupplier->eBufferSupplier = OMX_BufferSupplyInput;
++      } else if (PORT_IS_TUNNELED(pPort)) {
++        pBufferSupplier->eBufferSupplier = OMX_BufferSupplyOutput;
++      } else {
++        pBufferSupplier->eBufferSupplier = OMX_BufferSupplyUnspecified;
++      }
++    } else {
++      if (PORT_IS_BUFFER_SUPPLIER(pPort)) {
++        pBufferSupplier->eBufferSupplier = OMX_BufferSupplyOutput;
++      } else if (PORT_IS_TUNNELED(pPort)) {
++        pBufferSupplier->eBufferSupplier = OMX_BufferSupplyInput;
++      } else {
++        pBufferSupplier->eBufferSupplier = OMX_BufferSupplyUnspecified;
++      }
++    }
++    break;
++  case OMX_IndexVendorCompPropTunnelFlags:
++    pPropTunnelSetup = (OMX_VENDOR_PROP_TUNNELSETUPTYPE*)ComponentParameterStructure;
++
++    if (pPropTunnelSetup->nPortIndex >= (omx_base_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts +
++                                         omx_base_component_Private->sPortTypesParam[OMX_PortDomainVideo].nPorts +
++                                         omx_base_component_Private->sPortTypesParam[OMX_PortDomainImage].nPorts +
++                                         omx_base_component_Private->sPortTypesParam[OMX_PortDomainOther].nPorts)) {
++
++      DEBUG(DEB_LEV_ERR,"In %s OMX_IndexVendorCompPropTunnelFlags nPortIndex=%d Line=%d \n",
++          __func__,(int)pPropTunnelSetup->nPortIndex,__LINE__);
++
++      return OMX_ErrorBadPortIndex;
++    }
++
++    pPort = omx_base_component_Private->ports[pPropTunnelSetup->nPortIndex];
++
++    pPropTunnelSetup->nTunnelSetup.nTunnelFlags  = pPort->nTunnelFlags;
++    pPropTunnelSetup->nTunnelSetup.eSupplier     = pPort->eBufferSupplier;
++    break;
++  default:
++    err = OMX_ErrorUnsupportedIndex;
++    break;
++  }
++  return err;
++}
++
++/** @brief Part of the standard OpenMAX function
++ *
++ * This function sets the parameters not related to any port.
++ * These parameters are handled in the derived components
++ * See OMX_Core.h for standard reference
++ *
++ * @return OMX_ErrorUnsupportedIndex if the index is not supported or not handled here
++ */
++OMX_ERRORTYPE omx_base_component_SetParameter(
++  OMX_IN  OMX_HANDLETYPE hComponent,
++  OMX_IN  OMX_INDEXTYPE nParamIndex,
++  OMX_IN  OMX_PTR ComponentParameterStructure) {
++
++  OMX_PRIORITYMGMTTYPE* pPrioMgmt;
++  OMX_PARAM_PORTDEFINITIONTYPE *pPortDef;
++  OMX_ERRORTYPE err = OMX_ErrorNone;
++  OMX_COMPONENTTYPE *omxcomponent = (OMX_COMPONENTTYPE*)hComponent;
++  omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)omxcomponent->pComponentPrivate;
++  OMX_PARAM_BUFFERSUPPLIERTYPE *pBufferSupplier;
++  omx_base_PortType *pPort;
++
++  DEBUG(DEB_LEV_FUNCTION_NAME, "In %s\n", __func__);
++  DEBUG(DEB_LEV_PARAMS, "Setting parameter %x\n", nParamIndex);
++  if (ComponentParameterStructure == NULL) {
++    DEBUG(DEB_LEV_ERR, "In %s parameter provided is null! err = %x\n", __func__, err);
++    return OMX_ErrorBadParameter;
++  }
++
++  switch(nParamIndex) {
++  case OMX_IndexParamAudioInit:
++  case OMX_IndexParamVideoInit:
++  case OMX_IndexParamImageInit:
++  case OMX_IndexParamOtherInit:
++    /* pPortParam  = (OMX_PORT_PARAM_TYPE* ) ComponentParameterStructure;*/
++    if (omx_base_component_Private->state != OMX_StateLoaded &&
++      omx_base_component_Private->state != OMX_StateWaitForResources) {
++      return OMX_ErrorIncorrectStateOperation;
++    }
++    if ((err = checkHeader(ComponentParameterStructure, sizeof(OMX_PORT_PARAM_TYPE))) != OMX_ErrorNone) {
++      break;
++    }
++    err = OMX_ErrorUndefined;
++    break;
++  case OMX_IndexParamPortDefinition:
++    pPortDef  = (OMX_PARAM_PORTDEFINITIONTYPE*) ComponentParameterStructure;
++    DEBUG(DEB_LEV_PARAMS, "Setting parameter OMX_IndexParamPortDefinition for port %d\n", pPortDef->nPortIndex);
++    err = omx_base_component_ParameterSanityCheck(hComponent, pPortDef->nPortIndex, pPortDef, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
++    if(err!=OMX_ErrorNone) {
++      DEBUG(DEB_LEV_ERR, "In %s Parameter Check Error=%x\n",__func__,err);
++      break;
++    }
++    {
++      OMX_PARAM_PORTDEFINITIONTYPE *pPortParam;
++      OMX_U32 j,old_nBufferCountActual=0;
++      pPortParam = &omx_base_component_Private->ports[pPortDef->nPortIndex]->sPortParam;
++      if(pPortDef->nBufferCountActual < pPortParam->nBufferCountMin) {
++        DEBUG(DEB_LEV_ERR, "In %s nBufferCountActual of param (%i) is < of nBufferCountMin of port(%i)\n",__func__, (int)pPortDef->nBufferCountActual, (int)pPortParam->nBufferCountMin);
++        err = OMX_ErrorBadParameter;
++        break;
++      }
++      old_nBufferCountActual         = pPortParam->nBufferCountActual;
++      pPortParam->nBufferCountActual = pPortDef->nBufferCountActual;
++
++      switch(pPortDef->eDomain) {
++      case OMX_PortDomainAudio:
++        memcpy(&pPortParam->format.audio, &pPortDef->format.audio, sizeof(OMX_AUDIO_PORTDEFINITIONTYPE));
++        break;
++      case OMX_PortDomainVideo:
++        pPortParam->format.video.pNativeRender          = pPortDef->format.video.pNativeRender;
++        pPortParam->format.video.nFrameWidth            = pPortDef->format.video.nFrameWidth;
++        pPortParam->format.video.nFrameHeight           = pPortDef->format.video.nFrameHeight;
++        pPortParam->format.video.nStride                = pPortDef->format.video.nStride;
++        pPortParam->format.video.xFramerate             = pPortDef->format.video.xFramerate;
++        pPortParam->format.video.bFlagErrorConcealment  = pPortDef->format.video.bFlagErrorConcealment;
++        pPortParam->format.video.eCompressionFormat     = pPortDef->format.video.eCompressionFormat;
++        pPortParam->format.video.eColorFormat           = pPortDef->format.video.eColorFormat;
++        pPortParam->format.video.pNativeWindow          = pPortDef->format.video.pNativeWindow;
++        break;
++      case OMX_PortDomainImage:
++        pPortParam->format.image.nFrameWidth            = pPortDef->format.image.nFrameWidth;
++        pPortParam->format.image.nFrameHeight           = pPortDef->format.image.nFrameHeight;
++        pPortParam->format.image.nStride                = pPortDef->format.image.nStride;
++        pPortParam->format.image.bFlagErrorConcealment  = pPortDef->format.image.bFlagErrorConcealment;
++        pPortParam->format.image.eCompressionFormat     = pPortDef->format.image.eCompressionFormat;
++        pPortParam->format.image.eColorFormat           = pPortDef->format.image.eColorFormat;
++        pPortParam->format.image.pNativeWindow          = pPortDef->format.image.pNativeWindow;
++        break;
++      case OMX_PortDomainOther:
++        memcpy(&pPortParam->format.other, &pPortDef->format.other, sizeof(OMX_OTHER_PORTDEFINITIONTYPE));
++        break;
++      default:
++        DEBUG(DEB_LEV_ERR, "In %s wrong port domain. Out of OpenMAX scope\n",__func__);
++        err = OMX_ErrorBadParameter;
++        break;
++      }
++
++      /*If component state Idle/Pause/Executing and re-alloc the following private variables */
++      if ((omx_base_component_Private->state == OMX_StateIdle ||
++        omx_base_component_Private->state == OMX_StatePause  ||
++        omx_base_component_Private->state == OMX_StateExecuting) &&
++        (pPortParam->nBufferCountActual > old_nBufferCountActual)) {
++
++        pPort = omx_base_component_Private->ports[pPortDef->nPortIndex];
++        if(pPort->pInternalBufferStorage) {
++          if(PORT_IS_TUNNELED(pPort)){
++            DEBUG(DEB_LEV_ERR, "In %s Attempt to reallocate tunneled buffers!\n",__func__);
++            return OMX_ErrorIncorrectStateOperation;
++          }
++          pPort->pInternalBufferStorage = (OMX_BUFFERHEADERTYPE**)realloc(pPort->pInternalBufferStorage,pPort->sPortParam.nBufferCountActual*sizeof(OMX_BUFFERHEADERTYPE *));
++        }
++
++        if(pPort->bBufferStateAllocated) {
++          pPort->bBufferStateAllocated = (BUFFER_STATUS_FLAG*)realloc(pPort->bBufferStateAllocated,pPort->sPortParam.nBufferCountActual*sizeof(BUFFER_STATUS_FLAG));
++          for(j=0; j < pPort->sPortParam.nBufferCountActual; j++) {
++            pPort->bBufferStateAllocated[j] = BUFFER_FREE;
++          }
++        }
++      }
++    }
++    break;
++  case OMX_IndexParamPriorityMgmt:
++    if (omx_base_component_Private->state != OMX_StateLoaded &&
++      omx_base_component_Private->state != OMX_StateWaitForResources) {
++      return OMX_ErrorIncorrectStateOperation;
++    }
++    pPrioMgmt = (OMX_PRIORITYMGMTTYPE*)ComponentParameterStructure;
++    if ((err = checkHeader(ComponentParameterStructure, sizeof(OMX_PRIORITYMGMTTYPE))) != OMX_ErrorNone) {
++      break;
++    }
++    omx_base_component_Private->nGroupPriority = pPrioMgmt->nGroupPriority;
++    omx_base_component_Private->nGroupID = pPrioMgmt->nGroupID;
++    break;
++  case OMX_IndexParamCompBufferSupplier:
++    pBufferSupplier = (OMX_PARAM_BUFFERSUPPLIERTYPE*)ComponentParameterStructure;
++
++    DEBUG(DEB_LEV_PARAMS, "In %s Buf Sup Port index=%d\n", __func__,(int)pBufferSupplier->nPortIndex);
++
++    if(pBufferSupplier == NULL) {
++      DEBUG(DEB_LEV_ERR, "In %s pBufferSupplier is null!\n",__func__);
++      return OMX_ErrorBadParameter;
++    }
++    if(pBufferSupplier->nPortIndex > (omx_base_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts +
++                                      omx_base_component_Private->sPortTypesParam[OMX_PortDomainVideo].nPorts +
++                                      omx_base_component_Private->sPortTypesParam[OMX_PortDomainImage].nPorts +
++                                      omx_base_component_Private->sPortTypesParam[OMX_PortDomainOther].nPorts)) {
++      return OMX_ErrorBadPortIndex;
++    }
++    err = omx_base_component_ParameterSanityCheck(hComponent, pBufferSupplier->nPortIndex, pBufferSupplier, sizeof(OMX_PARAM_BUFFERSUPPLIERTYPE));
++    if(err==OMX_ErrorIncorrectStateOperation) {
++      if (PORT_IS_ENABLED(omx_base_component_Private->ports[pBufferSupplier->nPortIndex])) {
++        DEBUG(DEB_LEV_ERR, "In %s Incorrect State=%x\n",__func__,omx_base_component_Private->state);
++        return OMX_ErrorIncorrectStateOperation;
++      }
++    } else if (err != OMX_ErrorNone) {
++      break;
++    }
++
++    if (pBufferSupplier->eBufferSupplier == OMX_BufferSupplyUnspecified) {
++      DEBUG(DEB_LEV_PARAMS, "In %s: port is already buffer supplier unspecified\n", __func__);
++      return OMX_ErrorNone;
++    }
++    if ((PORT_IS_TUNNELED(omx_base_component_Private->ports[pBufferSupplier->nPortIndex])) == 0) {
++      return OMX_ErrorNone;
++    }
++
++    pPort = omx_base_component_Private->ports[pBufferSupplier->nPortIndex];
++
++    if ((pBufferSupplier->eBufferSupplier == OMX_BufferSupplyInput) &&
++        (pPort->sPortParam.eDir == OMX_DirInput)) {
++      /** These two cases regard the first stage of client override */
++      if (PORT_IS_BUFFER_SUPPLIER(pPort)) {
++        err = OMX_ErrorNone;
++      }
++      pPort->nTunnelFlags |= TUNNEL_IS_SUPPLIER;
++      pBufferSupplier->nPortIndex = pPort->nTunneledPort;
++      err = OMX_SetParameter(pPort->hTunneledComponent, OMX_IndexParamCompBufferSupplier, pBufferSupplier);
++    } else if ((pBufferSupplier->eBufferSupplier == OMX_BufferSupplyOutput) &&
++               (pPort->sPortParam.eDir == OMX_DirInput)) {
++      if (PORT_IS_BUFFER_SUPPLIER(pPort)) {
++        pPort->nTunnelFlags &= ~TUNNEL_IS_SUPPLIER;
++        pBufferSupplier->nPortIndex = pPort->nTunneledPort;
++        err = OMX_SetParameter(pPort->hTunneledComponent, OMX_IndexParamCompBufferSupplier, pBufferSupplier);
++      }
++      err = OMX_ErrorNone;
++    } else if ((pBufferSupplier->eBufferSupplier == OMX_BufferSupplyOutput) &&
++               (pPort->sPortParam.eDir == OMX_DirOutput)) {
++      /** these two cases regard the second stage of client override */
++      if (PORT_IS_BUFFER_SUPPLIER(pPort)) {
++        err = OMX_ErrorNone;
++      }
++      pPort->nTunnelFlags |= TUNNEL_IS_SUPPLIER;
++    } else {
++      if (PORT_IS_BUFFER_SUPPLIER(pPort)) {
++        pPort->nTunnelFlags &= ~TUNNEL_IS_SUPPLIER;
++        err = OMX_ErrorNone;
++      }
++      err = OMX_ErrorNone;
++    }
++    DEBUG(DEB_LEV_PARAMS, "In %s port %d Tunnel flag=%x \n", __func__,(int)pBufferSupplier->nPortIndex, (int)pPort->nTunnelFlags);
++    break;
++  default:
++    err = OMX_ErrorUnsupportedIndex;
++    break;
++  }
++  return err;
++}
++
++/** @brief base GetConfig function
++ *
++ * This base function is not implemented. If a derived component
++ * needs to support any config, it must implement a derived
++ * version of this function and assign it to the correct pointer
++ * in the private component descriptor
++ */
++OMX_ERRORTYPE omx_base_component_GetConfig(
++  OMX_IN  OMX_HANDLETYPE hComponent,
++  OMX_IN  OMX_INDEXTYPE nIndex,
++  OMX_INOUT OMX_PTR pComponentConfigStructure) {
++  return OMX_ErrorNotImplemented;
++}
++
++/** @brief base SetConfig function
++ *
++ * This base function is not implemented. If a derived component
++ * needs to support any config, it must implement a derived
++ * version of this function and assign it to the correct pointer
++ * in the private component descriptor
++ */
++OMX_ERRORTYPE omx_base_component_SetConfig(
++  OMX_IN  OMX_HANDLETYPE hComponent,
++  OMX_IN  OMX_INDEXTYPE nIndex,
++  OMX_IN  OMX_PTR pComponentConfigStructure) {
++  // TODO: For now, do not return OMX_ErrorNotImplemented here because it breaks current COMXAudio
++  return OMX_ErrorNone;
++}
++
++/** @brief base function not implemented
++ *
++ * This function can be eventually implemented by a
++ * derived component if needed
++ */
++OMX_ERRORTYPE omx_base_component_GetExtensionIndex(
++  OMX_IN  OMX_HANDLETYPE hComponent,
++  OMX_IN  OMX_STRING cParameterName,
++  OMX_OUT OMX_INDEXTYPE* pIndexType) {
++
++  DEBUG(DEB_LEV_FUNCTION_NAME,"In  %s \n",__func__);
++
++  return OMX_ErrorBadParameter;
++}
++
++/** @return the state of the component
++ *
++ * This function does not need any override by derived components
++ */
++OMX_ERRORTYPE omx_base_component_GetState(
++  OMX_IN  OMX_HANDLETYPE hComponent,
++  OMX_OUT OMX_STATETYPE* pState) {
++  OMX_COMPONENTTYPE *omxcomponent = (OMX_COMPONENTTYPE*)hComponent;
++  omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)omxcomponent->pComponentPrivate;
++  *pState = omx_base_component_Private->state;
++  return OMX_ErrorNone;
++}
++
++/** @brief standard SendCommand function
++ *
++ * In general this function does not need a overwrite, but
++ * a special derived component could do it.
++ */
++OMX_ERRORTYPE omx_base_component_SendCommand(
++  OMX_IN  OMX_HANDLETYPE hComponent,
++  OMX_IN  OMX_COMMANDTYPE Cmd,
++  OMX_IN  OMX_U32 nParam,
++  OMX_IN  OMX_PTR pCmdData) {
++  OMX_COMPONENTTYPE* omxComponent = (OMX_COMPONENTTYPE*)hComponent;
++  omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)omxComponent->pComponentPrivate;
++  internalRequestMessageType *message;
++  omx_queue_t* messageQueue;
++  omx_tsem_t* messageSem;
++  OMX_U32 i,j,k;
++  omx_base_PortType *pPort;
++  OMX_ERRORTYPE err = OMX_ErrorNone;
++  DEBUG(DEB_LEV_FUNCTION_NAME, "In %s\n", __func__);
++
++  messageQueue = omx_base_component_Private->messageQueue;
++  messageSem = omx_base_component_Private->messageSem;
++
++  if (omx_base_component_Private->state == OMX_StateInvalid) {
++    return OMX_ErrorInvalidState;
++  }
++
++  message = (internalRequestMessageType*)calloc(1,sizeof(internalRequestMessageType));
++  message->messageParam = nParam;
++  message->pCmdData=pCmdData;
++  /** Fill in the message */
++  switch (Cmd) {
++  case OMX_CommandStateSet:
++    DEBUG(DEB_LEV_FUNCTION_NAME, "In %s  OMX_CommandStateSet  desired state=%d\n", __func__, nParam);
++    message->messageType = OMX_CommandStateSet;
++    if ((nParam == OMX_StateIdle) && (omx_base_component_Private->state == OMX_StateLoaded)) {
++      /*Allocate Internal Buffer Storage and Buffer Allocation State flags*/
++       /* for all ports */
++      for(j = 0; j < NUM_DOMAINS; j++) {
++        for(i = omx_base_component_Private->sPortTypesParam[j].nStartPortNumber;
++            i < omx_base_component_Private->sPortTypesParam[j].nStartPortNumber +
++              omx_base_component_Private->sPortTypesParam[j].nPorts; i++) {
++
++          pPort = omx_base_component_Private->ports[i];
++
++          if(pPort->pInternalBufferStorage == NULL) {
++            pPort->pInternalBufferStorage = (OMX_BUFFERHEADERTYPE**)calloc(pPort->sPortParam.nBufferCountActual,sizeof(OMX_BUFFERHEADERTYPE *));
++          }
++
++          if(pPort->bBufferStateAllocated == NULL) {
++            pPort->bBufferStateAllocated = (BUFFER_STATUS_FLAG*)calloc(pPort->sPortParam.nBufferCountActual,sizeof(BUFFER_STATUS_FLAG));
++            for(k=0; k < pPort->sPortParam.nBufferCountActual; k++)
++            {
++              pPort->bBufferStateAllocated[k] = BUFFER_FREE;
++            }
++          }
++        }
++      }
++
++      omx_base_component_Private->transientState = OMX_TransStateLoadedToIdle;
++    } else if ((nParam == OMX_StateLoaded) && (omx_base_component_Private->state == OMX_StateIdle)) {
++      omx_base_component_Private->transientState = OMX_TransStateIdleToLoaded;
++    } else if ((nParam == OMX_StateIdle) && (omx_base_component_Private->state == OMX_StateExecuting)) {
++      omx_base_component_Private->transientState = OMX_TransStateExecutingToIdle;
++    }
++    break;
++  case OMX_CommandFlush:
++    DEBUG(DEB_LEV_FUNCTION_NAME, "In %s  OMX_CommandFlush port=%d\n", __func__, nParam);
++    if (nParam >= (omx_base_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts +
++                   omx_base_component_Private->sPortTypesParam[OMX_PortDomainVideo].nPorts +
++                   omx_base_component_Private->sPortTypesParam[OMX_PortDomainImage].nPorts +
++                   omx_base_component_Private->sPortTypesParam[OMX_PortDomainOther].nPorts) && nParam != OMX_ALL) {
++      return OMX_ErrorBadPortIndex;
++    }
++    message->messageType = OMX_CommandFlush;
++    break;
++  case OMX_CommandPortDisable:
++    DEBUG(DEB_LEV_FUNCTION_NAME, "In %s  OMX_CommandPortDisable  port=%d\n", __func__, nParam);
++    if (nParam >= (omx_base_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts +
++                   omx_base_component_Private->sPortTypesParam[OMX_PortDomainVideo].nPorts +
++                   omx_base_component_Private->sPortTypesParam[OMX_PortDomainImage].nPorts +
++                   omx_base_component_Private->sPortTypesParam[OMX_PortDomainOther].nPorts) && nParam != OMX_ALL) {
++      return OMX_ErrorBadPortIndex;
++    }
++    message->messageType = OMX_CommandPortDisable;
++    if(message->messageParam == OMX_ALL) {
++       /* for all ports */
++      for(j = 0; j < NUM_DOMAINS; j++) {
++        for(i = omx_base_component_Private->sPortTypesParam[j].nStartPortNumber;
++            i < omx_base_component_Private->sPortTypesParam[j].nStartPortNumber +
++              omx_base_component_Private->sPortTypesParam[j].nPorts; i++) {
++          omx_base_component_Private->ports[i]->bIsTransientToDisabled = OMX_TRUE;
++        }
++      }
++    } else {
++      omx_base_component_Private->ports[message->messageParam]->bIsTransientToDisabled = OMX_TRUE;
++    }
++    break;
++  case OMX_CommandPortEnable:
++    DEBUG(DEB_LEV_FUNCTION_NAME, "In %s  OMX_CommandPortEnable  port=%d\n", __func__, nParam);
++    if (nParam >= (omx_base_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts +
++                   omx_base_component_Private->sPortTypesParam[OMX_PortDomainVideo].nPorts +
++                   omx_base_component_Private->sPortTypesParam[OMX_PortDomainImage].nPorts +
++                   omx_base_component_Private->sPortTypesParam[OMX_PortDomainOther].nPorts) && nParam != OMX_ALL) {
++      return OMX_ErrorBadPortIndex;
++    }
++    message->messageType = OMX_CommandPortEnable;
++    if(message->messageParam == OMX_ALL) {
++       /* for all ports */
++      for(j = 0; j < NUM_DOMAINS; j++) {
++        for(i = omx_base_component_Private->sPortTypesParam[j].nStartPortNumber;
++            i < omx_base_component_Private->sPortTypesParam[j].nStartPortNumber +
++              omx_base_component_Private->sPortTypesParam[j].nPorts; i++) {
++          omx_base_component_Private->ports[i]->bIsTransientToEnabled = OMX_TRUE;
++        }
++      }
++    } else {
++      omx_base_component_Private->ports[message->messageParam]->bIsTransientToEnabled = OMX_TRUE;
++    }
++    break;
++  case OMX_CommandMarkBuffer:
++    DEBUG(DEB_LEV_FUNCTION_NAME, "In %s  OMX_CommandMarkBuffer  port=%d\n", __func__, nParam);
++    if (nParam >= (omx_base_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts +
++                   omx_base_component_Private->sPortTypesParam[OMX_PortDomainVideo].nPorts +
++                   omx_base_component_Private->sPortTypesParam[OMX_PortDomainImage].nPorts +
++                   omx_base_component_Private->sPortTypesParam[OMX_PortDomainOther].nPorts) && nParam != OMX_ALL) {
++      return OMX_ErrorBadPortIndex;
++    }
++    message->messageType = OMX_CommandMarkBuffer;
++    break;
++  default:
++    err = OMX_ErrorUnsupportedIndex;
++    break;
++  }
++
++  if (err == OMX_ErrorNone)
++  {
++    omx_queue(messageQueue, message);
++    omx_tsem_up(messageSem);
++  }
++
++  DEBUG(DEB_LEV_FULL_SEQ, "In %s messageSem up param=%d\n", __func__,message->messageParam);
++
++  return err;
++}
++
++/** @brief Component's message handler thread function
++ *
++ * Handles all messages coming from components and
++ * processes them by dispatching them back to the
++ * triggering component.
++ */
++void* compMessageHandlerFunction(void* param) {
++  OMX_COMPONENTTYPE *openmaxStandComp = (OMX_COMPONENTTYPE *)param;
++  omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)openmaxStandComp->pComponentPrivate;
++  internalRequestMessageType *message;
++
++  while(1){
++    if (omx_base_component_Private == NULL) {
++      break;
++    }
++
++    /* Wait for an incoming message */
++    omx_tsem_down(omx_base_component_Private->messageSem);
++    DEBUG(DEB_LEV_FUNCTION_NAME, "In %s\n", __func__);
++
++    /*Destructor has been called. So exit from the loop*/
++    if(omx_base_component_Private->state == OMX_StateInvalid) {
++      break;
++    }
++
++    /* Dequeue it */
++    message = (internalRequestMessageType*)omx_dequeue(omx_base_component_Private->messageQueue);
++    if(message == NULL){
++      DEBUG(DEB_LEV_ERR, "In %s: ouch!! had null message!\n", __func__);
++      break;
++    }
++    /* Process it by calling component's message handler method */
++    omx_base_component_Private->messageHandler(openmaxStandComp,message);
++    /* Message ownership has been transferred to us
++    * so we gonna free it when finished.
++    */
++    free(message);
++    message = NULL;
++  }
++  DEBUG(DEB_LEV_FUNCTION_NAME,"Exiting Message Handler thread\n");
++  return NULL;
++}
++
++/** This is called by the component message entry point.
++ * In thea base version this function is named compMessageHandlerFunction
++ *
++ * A request is made by the component when some asynchronous services are needed:
++ * 1) A SendCommand() is to be processed
++ * 2) An error needs to be notified
++ * 3) ...
++ *
++ * @param openmaxStandComp the component itself
++ * @param message the message that has been passed to core
++ */
++OMX_ERRORTYPE omx_base_component_MessageHandler(OMX_COMPONENTTYPE *openmaxStandComp,internalRequestMessageType* message) {
++  omx_base_component_PrivateType* omx_base_component_Private=(omx_base_component_PrivateType*)openmaxStandComp->pComponentPrivate;
++  OMX_U32                         i,j,k;
++  OMX_ERRORTYPE                   err = OMX_ErrorNone;
++  omx_base_PortType*              pPort;
++
++  DEBUG(DEB_LEV_FUNCTION_NAME, "In %s\n", __func__);
++
++  /* Dealing with a SendCommand call.
++  * -messageType contains the command to execute
++  * -messageParam contains the parameter of the command
++  *  (destination state in case of a state change command).
++  */
++  switch(message->messageType){
++  case OMX_CommandStateSet: {
++    /* Do the actual state change */
++    err = (*(omx_base_component_Private->DoStateSet))(openmaxStandComp, message->messageParam);
++    if (err != OMX_ErrorNone) {
++      (*(omx_base_component_Private->callbacks->EventHandler))
++      (openmaxStandComp,
++      omx_base_component_Private->callbackData,
++      OMX_EventError, /* The command was completed */
++      err, /* The commands was a OMX_CommandStateSet */
++      0, /* The state has been changed in message->messageParam */
++      NULL);
++    } else {
++      /* And run the callback */
++      DEBUG(DEB_LEV_FULL_SEQ,"running callback in %s\n",__func__);
++      (*(omx_base_component_Private->callbacks->EventHandler))
++      (openmaxStandComp,
++      omx_base_component_Private->callbackData,
++      OMX_EventCmdComplete, /* The command was completed */
++      OMX_CommandStateSet, /* The commands was a OMX_CommandStateSet */
++      message->messageParam, /* The state has been changed in message->messageParam */
++      NULL);
++    }
++  }
++  break;
++  case OMX_CommandFlush: {
++    /*Flush port/s*/
++    if(message->messageParam == OMX_ALL) {
++       /* for all ports */
++      for(j = 0; j < NUM_DOMAINS; j++) {
++        for(i = omx_base_component_Private->sPortTypesParam[j].nStartPortNumber;
++            i < omx_base_component_Private->sPortTypesParam[j].nStartPortNumber +
++              omx_base_component_Private->sPortTypesParam[j].nPorts; i++) {
++          omx_base_component_Private->ports[i]->bIsPortFlushed = OMX_TRUE;
++        }
++      }
++      /* for all ports */
++      for(j = 0; j < NUM_DOMAINS; j++) {
++        for(i = omx_base_component_Private->sPortTypesParam[j].nStartPortNumber;
++        i < omx_base_component_Private->sPortTypesParam[j].nStartPortNumber +
++          omx_base_component_Private->sPortTypesParam[j].nPorts; i++) {
++          pPort=omx_base_component_Private->ports[i];
++          err = pPort->FlushProcessingBuffers(pPort);
++        }
++      }
++    }
++    else {
++      pPort=omx_base_component_Private->ports[message->messageParam];
++      err = pPort->FlushProcessingBuffers(pPort);
++    }
++    if (err != OMX_ErrorNone) {
++      (*(omx_base_component_Private->callbacks->EventHandler))
++      (openmaxStandComp,
++      omx_base_component_Private->callbackData,
++      OMX_EventError, /* The command was completed */
++      err, /* The commands was a OMX_CommandStateSet */
++      0, /* The state has been changed in message->messageParam */
++      NULL);
++    } else {
++      if(message->messageParam == OMX_ALL){ /*Flush all port*/
++        /* for all ports */
++        for(j = 0; j < NUM_DOMAINS; j++) {
++          for(i = omx_base_component_Private->sPortTypesParam[j].nStartPortNumber;
++          i < omx_base_component_Private->sPortTypesParam[j].nStartPortNumber +
++            omx_base_component_Private->sPortTypesParam[j].nPorts; i++) {
++            (*(omx_base_component_Private->callbacks->EventHandler))
++            (openmaxStandComp,
++            omx_base_component_Private->callbackData,
++            OMX_EventCmdComplete, /* The command was completed */
++            OMX_CommandFlush, /* The commands was a OMX_CommandStateSet */
++            i, /* The state has been changed in message->messageParam */
++            NULL);
++
++            pPort=omx_base_component_Private->ports[i];
++            /* Signal the buffer Semaphore and the buffer managment semaphore, to restart the exchange of buffers after flush */
++            if (PORT_IS_TUNNELED(pPort) && PORT_IS_BUFFER_SUPPLIER(pPort)) {
++              for(k=0;k<pPort->nNumTunnelBuffer;k++) {
++                omx_tsem_up(pPort->pBufferSem);
++                /*signal buffer management thread availability of buffers*/
++                omx_tsem_up(omx_base_component_Private->bMgmtSem);
++              }
++            }
++          }
++        }
++      } else {/*Flush input/output port*/
++        (*(omx_base_component_Private->callbacks->EventHandler))
++        (openmaxStandComp,
++        omx_base_component_Private->callbackData,
++        OMX_EventCmdComplete, /* The command was completed */
++        OMX_CommandFlush, /* The commands was a OMX_CommandStateSet */
++        message->messageParam, /* The state has been changed in message->messageParam */
++        NULL);
++        /* Signal the buffer Semaphore and the buffer managment semaphore, to restart the exchange of buffers after flush */
++        if (PORT_IS_TUNNELED(omx_base_component_Private->ports[message->messageParam])
++             && PORT_IS_BUFFER_SUPPLIER(omx_base_component_Private->ports[message->messageParam])) {
++            for(j=0;j<omx_base_component_Private->ports[message->messageParam]->nNumTunnelBuffer;j++) {
++              omx_tsem_up(omx_base_component_Private->ports[message->messageParam]->pBufferSem);
++              /*signal buffer management thread availability of buffers*/
++              omx_tsem_up(omx_base_component_Private->bMgmtSem);
++            }
++          }
++      }
++    }
++  }
++  break;
++  case OMX_CommandPortDisable: {
++    /*Flush port/s*/
++    if(message->messageParam == OMX_ALL) {
++      /*If Component is not in loaded state,then First Flush all buffers then disable the port*/
++      if(omx_base_component_Private->state!=OMX_StateLoaded) {
++        /* for all ports */
++        for(j = 0; j < NUM_DOMAINS; j++) {
++          for(i = omx_base_component_Private->sPortTypesParam[j].nStartPortNumber;
++          i < omx_base_component_Private->sPortTypesParam[j].nStartPortNumber +
++            omx_base_component_Private->sPortTypesParam[j].nPorts; i++) {
++          pPort=omx_base_component_Private->ports[i];
++          err = pPort->FlushProcessingBuffers(pPort);
++          }
++        }
++      }
++      /* for all ports */
++      for(j = 0; j < NUM_DOMAINS; j++) {
++        for(i = omx_base_component_Private->sPortTypesParam[j].nStartPortNumber;
++        i < omx_base_component_Private->sPortTypesParam[j].nStartPortNumber +
++          omx_base_component_Private->sPortTypesParam[j].nPorts; i++) {
++          pPort=omx_base_component_Private->ports[i];
++          err = pPort->Port_DisablePort(pPort);
++        }
++      }
++    }
++    else {
++      pPort=omx_base_component_Private->ports[message->messageParam];
++      if(omx_base_component_Private->state!=OMX_StateLoaded) {
++        err = pPort->FlushProcessingBuffers(pPort);
++        DEBUG(DEB_LEV_FULL_SEQ, "In %s: Port Flush completed for Comp %s\n",__func__,omx_base_component_Private->name);
++      }
++      err = pPort->Port_DisablePort(pPort);
++    }
++    /** This condition is added to pass the tests, it is not significant for the environment */
++    if (err != OMX_ErrorNone) {
++      (*(omx_base_component_Private->callbacks->EventHandler))
++      (openmaxStandComp,
++      omx_base_component_Private->callbackData,
++      OMX_EventError, /* The command was completed */
++      err, /* The commands was a OMX_CommandStateSet */
++      0, /* The state has been changed in message->messageParam */
++      NULL);
++    } else {
++      if(message->messageParam == OMX_ALL){ /*Disable all ports*/
++        /* for all ports */
++        for(j = 0; j < NUM_DOMAINS; j++) {
++          for(i = omx_base_component_Private->sPortTypesParam[j].nStartPortNumber;
++            i < omx_base_component_Private->sPortTypesParam[j].nStartPortNumber +
++              omx_base_component_Private->sPortTypesParam[j].nPorts; i++) {
++            (*(omx_base_component_Private->callbacks->EventHandler))
++            (openmaxStandComp,
++            omx_base_component_Private->callbackData,
++            OMX_EventCmdComplete, /* The command was completed */
++            OMX_CommandPortDisable, /* The commands was a OMX_CommandStateSet */
++            i, /* The state has been changed in message->messageParam */
++            NULL);
++          }
++        }
++      } else {
++        (*(omx_base_component_Private->callbacks->EventHandler))
++        (openmaxStandComp,
++        omx_base_component_Private->callbackData,
++        OMX_EventCmdComplete, /* The command was completed */
++        OMX_CommandPortDisable, /* The commands was a OMX_CommandStateSet */
++        message->messageParam, /* The state has been changed in message->messageParam */
++        NULL);
++      }
++    }
++  }
++  break;
++  case OMX_CommandPortEnable:{
++    /*Flush port/s*/
++    if(message->messageParam == OMX_ALL) {
++      /* for all ports */
++      for(j = 0; j < NUM_DOMAINS; j++) {
++        for(i = omx_base_component_Private->sPortTypesParam[j].nStartPortNumber;
++          i < omx_base_component_Private->sPortTypesParam[j].nStartPortNumber +
++            omx_base_component_Private->sPortTypesParam[j].nPorts; i++) {
++          pPort=omx_base_component_Private->ports[i];
++          err = pPort->Port_EnablePort(pPort);
++          }
++        }
++    } else {
++      pPort=omx_base_component_Private->ports[message->messageParam];
++      err = pPort->Port_EnablePort(pPort);
++    }
++    if (err != OMX_ErrorNone) {
++      (*(omx_base_component_Private->callbacks->EventHandler))
++      (openmaxStandComp,
++      omx_base_component_Private->callbackData,
++      OMX_EventError, /* The command was completed */
++      err, /* The commands was a OMX_CommandStateSet */
++      0, /* The state has been changed in message->messageParam */
++      NULL);
++    } else {
++      if(message->messageParam != OMX_ALL) {
++        (*(omx_base_component_Private->callbacks->EventHandler))
++        (openmaxStandComp,
++        omx_base_component_Private->callbackData,
++        OMX_EventCmdComplete, /* The command was completed */
++        OMX_CommandPortEnable, /* The commands was a OMX_CommandStateSet */
++        message->messageParam, /* The state has been changed in message->messageParam */
++        NULL);
++
++        if (omx_base_component_Private->state==OMX_StateExecuting) {
++          pPort=omx_base_component_Private->ports[message->messageParam];
++          if (PORT_IS_BUFFER_SUPPLIER(pPort)) {
++            for(i=0; i < pPort->sPortParam.nBufferCountActual;i++) {
++              omx_tsem_up(pPort->pBufferSem);
++              omx_tsem_up(omx_base_component_Private->bMgmtSem);
++            }
++          }
++        }
++
++      } else {
++        /* for all ports */
++        for(j = 0; j < NUM_DOMAINS; j++) {
++          for(i = omx_base_component_Private->sPortTypesParam[j].nStartPortNumber;
++          i < omx_base_component_Private->sPortTypesParam[j].nStartPortNumber +
++            omx_base_component_Private->sPortTypesParam[j].nPorts; i++) {
++          (*(omx_base_component_Private->callbacks->EventHandler))
++          (openmaxStandComp,
++          omx_base_component_Private->callbackData,
++          OMX_EventCmdComplete, /* The command was completed */
++          OMX_CommandPortEnable, /* The commands was a OMX_CommandStateSet */
++          i, /* The state has been changed in message->messageParam */
++          NULL);
++          }
++        }
++
++        if (omx_base_component_Private->state==OMX_StateExecuting) {
++          /* for all ports */
++          for(j = 0; j < NUM_DOMAINS; j++) {
++            for(i = omx_base_component_Private->sPortTypesParam[j].nStartPortNumber;
++            i < omx_base_component_Private->sPortTypesParam[j].nStartPortNumber +
++              omx_base_component_Private->sPortTypesParam[j].nPorts; i++) {
++              pPort=omx_base_component_Private->ports[i];
++              if (PORT_IS_BUFFER_SUPPLIER(pPort)) {
++                for(k=0; k < pPort->sPortParam.nBufferCountActual;k++) {
++                  omx_tsem_up(pPort->pBufferSem);
++                  omx_tsem_up(omx_base_component_Private->bMgmtSem);
++                }
++              }
++            }
++          }
++        }
++      }
++    }
++  }
++  break;
++  case OMX_CommandMarkBuffer: {
++    omx_base_component_Private->pMark.hMarkTargetComponent = ((OMX_MARKTYPE *)message->pCmdData)->hMarkTargetComponent;
++    omx_base_component_Private->pMark.pMarkData            = ((OMX_MARKTYPE *)message->pCmdData)->pMarkData;
++  }
++  break;
++  default:
++    DEBUG(DEB_LEV_ERR, "In %s: Unrecognized command %i\n", __func__, message->messageType);
++  break;
++  }
++  DEBUG(DEB_LEV_SIMPLE_SEQ, "Returning from %s: \n", __func__);
++  return OMX_ErrorNone;
++}
++
++OMX_ERRORTYPE omx_base_component_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) {
++  omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate;
++  omx_base_PortType *pPort;
++
++  if (nPortIndex >= (omx_base_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts +
++                     omx_base_component_Private->sPortTypesParam[OMX_PortDomainVideo].nPorts +
++                     omx_base_component_Private->sPortTypesParam[OMX_PortDomainImage].nPorts +
++                     omx_base_component_Private->sPortTypesParam[OMX_PortDomainOther].nPorts)) {
++    DEBUG(DEB_LEV_ERR, "In %s: wrong port index\n", __func__);
++    return OMX_ErrorBadPortIndex;
++  }
++  pPort = omx_base_component_Private->ports[nPortIndex];
++
++  return pPort->Port_AllocateBuffer(pPort,
++                                    ppBuffer,
++                                    nPortIndex,
++                                    pAppPrivate,
++                                    nSizeBytes);
++}
++
++OMX_ERRORTYPE omx_base_component_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) {
++  omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate;
++  omx_base_PortType *pPort;
++
++  if (nPortIndex >= (omx_base_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts +
++                     omx_base_component_Private->sPortTypesParam[OMX_PortDomainVideo].nPorts +
++                     omx_base_component_Private->sPortTypesParam[OMX_PortDomainImage].nPorts +
++                     omx_base_component_Private->sPortTypesParam[OMX_PortDomainOther].nPorts)) {
++    DEBUG(DEB_LEV_ERR, "In %s: wrong port index\n", __func__);
++    return OMX_ErrorBadPortIndex;
++  }
++  pPort = omx_base_component_Private->ports[nPortIndex];
++
++  return  pPort->Port_UseBuffer(pPort,
++                                ppBufferHdr,
++                                nPortIndex,
++                                pAppPrivate,
++                                nSizeBytes,
++                                pBuffer);
++}
++
++OMX_ERRORTYPE omx_base_component_UseEGLImage (
++        OMX_HANDLETYPE hComponent,
++        OMX_BUFFERHEADERTYPE** ppBufferHdr,
++        OMX_U32 nPortIndex,
++        OMX_PTR pAppPrivate,
++        void* eglImage) {
++  return OMX_ErrorNotImplemented;
++}
++
++OMX_ERRORTYPE omx_base_component_FreeBuffer(
++            OMX_IN  OMX_HANDLETYPE hComponent,
++            OMX_IN  OMX_U32 nPortIndex,
++            OMX_IN  OMX_BUFFERHEADERTYPE* pBuffer) {
++  omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate;
++  omx_base_PortType *pPort;
++
++  if (nPortIndex >= (omx_base_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts +
++                     omx_base_component_Private->sPortTypesParam[OMX_PortDomainVideo].nPorts +
++                     omx_base_component_Private->sPortTypesParam[OMX_PortDomainImage].nPorts +
++                     omx_base_component_Private->sPortTypesParam[OMX_PortDomainOther].nPorts)) {
++    DEBUG(DEB_LEV_ERR, "In %s: wrong port index\n", __func__);
++    return OMX_ErrorBadPortIndex;
++  }
++
++  pPort = omx_base_component_Private->ports[nPortIndex];
++
++  return pPort->Port_FreeBuffer(pPort,
++                                nPortIndex,
++                                pBuffer);
++}
++
++OMX_ERRORTYPE omx_base_component_EmptyThisBuffer(
++            OMX_IN  OMX_HANDLETYPE hComponent,
++            OMX_IN  OMX_BUFFERHEADERTYPE* pBuffer) {
++  omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate;
++  omx_base_PortType *pPort;
++  //DEBUG(DEB_LEV_FUNCTION_NAME, "In %s pBuffer=0x%x pBuffer->pBuffer=0x%x nInputPortIndex=%d  nOutputPortIndex=%d  nAllocLen=%d nFilledLen=%d\n",
++  //  __func__, pBuffer, pBuffer->pBuffer, pBuffer->nInputPortIndex, pBuffer->nOutputPortIndex, pBuffer->nAllocLen, pBuffer->nFilledLen);
++
++  if (pBuffer->nInputPortIndex >= (omx_base_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts +
++                                   omx_base_component_Private->sPortTypesParam[OMX_PortDomainVideo].nPorts +
++                                   omx_base_component_Private->sPortTypesParam[OMX_PortDomainImage].nPorts +
++                                   omx_base_component_Private->sPortTypesParam[OMX_PortDomainOther].nPorts)) {
++    DEBUG(DEB_LEV_ERR, "In %s: wrong port index\n", __func__);
++    return OMX_ErrorBadPortIndex;
++  }
++  pPort = omx_base_component_Private->ports[pBuffer->nInputPortIndex];
++  if (pPort->sPortParam.eDir != OMX_DirInput) {
++    DEBUG(DEB_LEV_ERR, "In %s: wrong port direction in Component %s\n", __func__,omx_base_component_Private->name);
++    return OMX_ErrorBadPortIndex;
++  }
++  return pPort->Port_SendBufferFunction(pPort, pBuffer);
++}
++
++OMX_ERRORTYPE omx_base_component_FillThisBuffer(
++  OMX_IN  OMX_HANDLETYPE hComponent,
++  OMX_IN  OMX_BUFFERHEADERTYPE* pBuffer) {
++
++  omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate;
++  omx_base_PortType *pPort;
++  DEBUG(DEB_LEV_FUNCTION_NAME, "In %s\n", __func__);
++  if (pBuffer->nOutputPortIndex >= (omx_base_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts +
++                                    omx_base_component_Private->sPortTypesParam[OMX_PortDomainVideo].nPorts +
++                                    omx_base_component_Private->sPortTypesParam[OMX_PortDomainImage].nPorts +
++                                    omx_base_component_Private->sPortTypesParam[OMX_PortDomainOther].nPorts)) {
++    DEBUG(DEB_LEV_ERR, "In %s: wrong port index\n", __func__);
++    return OMX_ErrorBadPortIndex;
++  }
++  pPort = omx_base_component_Private->ports[pBuffer->nOutputPortIndex];
++  if (pPort->sPortParam.eDir != OMX_DirOutput) {
++    DEBUG(DEB_LEV_ERR, "In %s: wrong port direction in Component %s\n", __func__,omx_base_component_Private->name);
++    return OMX_ErrorBadPortIndex;
++  }
++  return pPort->Port_SendBufferFunction(pPort,  pBuffer);
++}
++
++OMX_ERRORTYPE omx_base_component_ComponentTunnelRequest(
++  OMX_IN  OMX_HANDLETYPE hComponent,
++  OMX_IN  OMX_U32 nPort,
++  OMX_IN  OMX_HANDLETYPE hTunneledComp,
++  OMX_IN  OMX_U32 nTunneledPort,
++  OMX_INOUT  OMX_TUNNELSETUPTYPE* pTunnelSetup) {
++
++  omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate;
++  omx_base_PortType *pPort;
++
++  if (nPort >= (omx_base_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts +
++                omx_base_component_Private->sPortTypesParam[OMX_PortDomainVideo].nPorts +
++                omx_base_component_Private->sPortTypesParam[OMX_PortDomainImage].nPorts +
++                omx_base_component_Private->sPortTypesParam[OMX_PortDomainOther].nPorts)) {
++    return OMX_ErrorBadPortIndex;
++  }
++
++  pPort = omx_base_component_Private->ports[nPort];
++
++  return pPort->ComponentTunnelRequest(pPort, hTunneledComp, nTunneledPort, pTunnelSetup);
++}
+diff --git a/alsa/omx_base_component.h b/alsa/omx_base_component.h
+new file mode 100644
+index 0000000..9134119
+--- /dev/null
++++ b/alsa/omx_base_component.h
+@@ -0,0 +1,412 @@
++/**
++  @file src/base/omx_base_component.h
++
++  OpenMAX base component. This component does not perform any multimedia
++  processing.It is used as a base component for new components development.
++
++  Copyright (C) 2007-2008 STMicroelectronics
++  Copyright (C) 2007-2008 Nokia Corporation and/or its subsidiary(-ies).
++
++  This library 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.
++
++  This library 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 this library; if not, write to the Free Software Foundation, Inc.,
++  51 Franklin St, Fifth Floor, Boston, MA
++  02110-1301  USA
++
++  $Date: 2008-09-11 11:45:59 +0200 (Thu, 11 Sep 2008) $
++  Revision $Rev: 613 $
++  Author $Author: pankaj_sen $
++
++*/
++#ifndef _OMX_BASE_COMPONENT_H_
++#define _OMX_BASE_COMPONENT_H_
++
++#include <pthread.h>
++
++#include "omx_semaphore.h"
++#include "omx_queue.h"
++#include "omx_classmagic.h"
++#include "omx_base_port.h"
++
++/** Default size of the internal input buffer */
++#define DEFAULT_IN_BUFFER_SIZE  4 * 1024
++/** Default size of the internal output buffer */
++#define DEFAULT_OUT_BUFFER_SIZE 16 * 1024  /*32 * 1024*/ /*16 * 1024 */ // TODO - check this size is ok
++/** Default MIME string length */
++#define DEFAULT_MIME_STRING_LENGTH 128
++
++#define NUM_DOMAINS 4
++
++/* Check if Component is deinitalizing*/
++#define IS_COMPONENT_DEINIT(component_Private, exit_condition)  \
++                pthread_mutex_lock(&component_Private->exit_mutex)      ,\
++                exit_condition = component_Private->bIsComponentDeinit ,\
++                pthread_mutex_unlock(&component_Private->exit_mutex) ,\
++                (exit_condition == OMX_TRUE) ? OMX_TRUE:OMX_FALSE \
++
++typedef struct OMX_VENDOR_EXTRADATATYPE  {
++  OMX_U32 nPortIndex;
++  OMX_U32 nDataSize;   // Size of the supporting data to follow
++  OMX_U8  *pData;     // Supporting data hint
++} OMX_VENDOR_EXTRADATATYPE;
++
++typedef struct OMX_VENDOR_PROP_TUNNELSETUPTYPE  {
++  OMX_U32 nPortIndex;
++  OMX_TUNNELSETUPTYPE nTunnelSetup;   // Tunnel setup flags
++} OMX_VENDOR_PROP_TUNNELSETUPTYPE;
++
++/** this is the list of custom vendor index */
++typedef enum OMX_INDEXVENDORTYPE {
++  /** only one index for file reader component input file */
++  OMX_IndexVendorFileReadInputFilename = 0xFF000001,
++  OMX_IndexVendorParser3gpInputFilename = 0xFF000002,
++  OMX_IndexVendorVideoExtraData = 0xFF000003,
++  OMX_IndexVendorAudioExtraData = 0xFF000004,
++  OMX_IndexVendorCompPropTunnelFlags = 0xFF000005 /* Will use OMX_TUNNELSETUPTYPE structure*/
++} OMX_INDEXVENDORTYPE;
++
++/** This enum defines the transition states of the Component*/
++typedef enum OMX_TRANS_STATETYPE {
++    OMX_TransStateInvalid,
++    OMX_TransStateLoadedToIdle,
++    OMX_TransStateIdleToPause,
++    OMX_TransStatePauseToExecuting,
++    OMX_TransStateIdleToExecuting,
++    OMX_TransStateExecutingToIdle,
++    OMX_TransStateExecutingToPause,
++    OMX_TransStatePauseToIdle,
++    OMX_TransStateIdleToLoaded,
++    OMX_TransStateMax = 0X7FFFFFFF
++} OMX_TRANS_STATETYPE;
++
++/** @brief Enumerates all the possible types of messages
++ * handled internally by the component
++ */
++typedef enum INTERNAL_MESSAGE_TYPE {
++  SENDCOMMAND_MSG_TYPE = 1,/**< this flag specifies that the message send is a command */
++  ERROR_MSG_TYPE,/**< this flag specifies that the message send is an error message */
++  WARNING_MSG_TYPE /**< this flag specifies that the message send is a warning message */
++} INTERNAL_MESSAGE_TYPE;
++
++/** @brief The container of an internal message
++ *
++ * This structure contains a generic OpenMAX request (from send command).
++ * It is processed by the internal message handler thread
++ */
++typedef struct internalRequestMessageType {
++  int messageType; /**< the flag that specifies if the message is a command, a warning or an error */
++  int messageParam; /**< the second field of the message. Its use is the same as specified for the command in OpenMAX spec */
++  OMX_PTR pCmdData; /**< This pointer could contain some proprietary data not covered by the standard */
++} internalRequestMessageType;
++
++/**
++ * @brief the base descriptor for a ST component
++ */
++CLASS(omx_base_component_PrivateType)
++#define omx_base_component_PrivateType_FIELDS \
++  OMX_COMPONENTTYPE *openmaxStandComp; /**< The OpenMAX standard data structure describing a component */ \
++  omx_base_PortType **ports; /** @param ports The ports of the component */ \
++  OMX_PORT_PARAM_TYPE sPortTypesParam[NUM_DOMAINS]; /** @param sPortTypesParam OpenMAX standard parameter that contains a short description of the available ports */ \
++  char uniqueID; /**< ID code that identifies an ST static component*/ \
++  char* name; /**< component name */\
++  OMX_STATETYPE state; /**< The state of the component */ \
++  OMX_TRANS_STATETYPE transientState; /**< The transient state in case of transition between \
++                              Loaded/waitForResources - Idle. It is equal to  \
++                              Invalid if the state or transition are not corect \
++                              Loaded when the transition is from Idle to Loaded \
++                              Idle when the transition is from Loaded to Idle */ \
++  OMX_CALLBACKTYPE* callbacks; /**< pointer to every client callback function, \
++                                as specified by the standard*/ \
++  OMX_PTR callbackData;/**< Private data that can be send with \
++                        the client callbacks. Not specified by the standard */ \
++  omx_queue_t* messageQueue;/**< the queue of all the messages recevied by the component */\
++  omx_tsem_t* messageSem;/**< the semaphore that coordinates the access to the message queue */\
++  OMX_U32 nGroupPriority; /**< @param nGroupPriority Resource management field: component priority (common to a group of components) */\
++  OMX_U32 nGroupID; /**< @param nGroupID ID of a group of components that share the same logical chain */\
++  OMX_MARKTYPE pMark; /**< @param pMark This field holds the private data associated with a mark request, if any */\
++  pthread_mutex_t flush_mutex;  /** @param flush_mutex mutex for the flush condition from buffers */ \
++  omx_tsem_t* flush_all_condition;  /** @param flush_all_condition condition for the flush all buffers */ \
++  omx_tsem_t* flush_condition;  /** @param The flush_condition condition */ \
++  omx_tsem_t* bMgmtSem;/**< @param bMgmtSem the semaphore that control BufferMgmtFunction processing */\
++  omx_tsem_t* bStateSem;/**< @param bMgmtSem the semaphore that control BufferMgmtFunction processing */\
++  int messageHandlerThreadID; /** @param  messageHandlerThreadID The ID of the pthread that handles the messages for the components */ \
++  pthread_t messageHandlerThread; /** @param  messageHandlerThread This field contains the reference to the thread that receives messages for the components */ \
++  int bufferMgmtThreadID; /** @param  bufferMgmtThreadID The ID of the pthread that process buffers */ \
++  pthread_t bufferMgmtThread; /** @param  bufferMgmtThread This field contains the reference to the thread that process buffers */ \
++  void *loader; /**< pointer to the loader that created this component, used for destruction */ \
++  void* (*BufferMgmtFunction)(void* param); /** @param BufferMgmtFunction This function processes input output buffers */ \
++  OMX_ERRORTYPE (*messageHandler)(OMX_COMPONENTTYPE*,internalRequestMessageType*);/** This function receives messages from the message queue. It is needed for each Linux ST OpenMAX component */ \
++  OMX_ERRORTYPE (*DoStateSet)(OMX_COMPONENTTYPE *openmaxStandComp, OMX_U32); /**< @param DoStateSet internal function called when a generic state transition is requested*/ \
++  OMX_ERRORTYPE (*destructor)(OMX_COMPONENTTYPE *openmaxStandComp); /** Component Destructor*/
++ENDCLASS(omx_base_component_PrivateType)
++
++/**
++ * @brief The base contructor for the OpenMAX ST components
++ *
++ * This function is executed by the ST static component loader.
++ * It takes care of constructing the instance of the component.
++ * For the base_component component, the following is done:
++ *
++ * 1) Fills the basic OpenMAX structure. The fields can be overwritten
++ *    by derived components.
++ * 2) Allocates (if needed) the omx_base_component_PrivateType private structure
++ *
++ * @param openmaxStandComp the ST component to be initialized
++ * @param cComponentName the OpenMAX string that describes the component
++ *
++ * @return OMX_ErrorInsufficientResources if a memory allocation fails
++ */
++OMX_ERRORTYPE omx_base_component_Constructor(OMX_COMPONENTTYPE *openmaxStandComp,OMX_STRING cComponentName);
++
++/** @brief the base destructor for ST OpenMAX components
++ *
++ * This function is called by the standard function ComponentDeInit()
++ * that is called by the IL core during the execution of the  FreeHandle()
++ *
++ * @param openmaxStandComp the ST OpenMAX component to be disposed
++ */
++OMX_ERRORTYPE omx_base_component_Destructor(OMX_COMPONENTTYPE *openmaxStandComp);
++
++/** Changes the state of a component taking proper actions depending on
++ * the transiotion requested. This base function cover only the state
++ * changes that do not involve any port
++ *
++ * @param openmaxStandComp the OpenMAX component which state is to be changed
++ * @param destinationState the requested target state
++ *
++ * @return OMX_ErrorNotImplemented if the state change is noty handled
++ * in this base class, but needs a specific handling
++ */
++OMX_ERRORTYPE omx_base_component_DoStateSet(
++  OMX_COMPONENTTYPE *openmaxStandComp,
++  OMX_U32 destinationState);
++
++/** @brief Checks the header of a structure for consistency
++ * with size and spec version
++ *
++ * @param header Pointer to the structure to be checked
++ * @param size Size of the structure. it is in general obtained
++ * with a sizeof call applied to the structure
++ *
++ * @return OMX error code. If the header has failed the check,
++ * OMX_ErrorVersionMismatch is returned.
++ * If the header fails the size check OMX_ErrorBadParameter is returned
++ */
++OMX_ERRORTYPE checkHeader(OMX_PTR header, OMX_U32 size);
++
++/** @brief Simply fills the first two fields in any OMX structure
++ * with the size and the version
++ *
++ * @param header pointer to the structure to be filled
++ * @param size size of the structure. It can be obtained with
++ * a call to sizeof of the structure type
++ */
++void setHeader(OMX_PTR header, OMX_U32 size);
++
++/** @brief standard openmax function
++ *
++ * it returns the version of the component. See OMX_Core.h
++ */
++OMX_ERRORTYPE omx_base_component_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);
++
++/** @brief Enumerates all the role of the component.
++ *
++ * This function is intended to be used only by a core. The ST static core
++ * in any case does not use this function, because it can not be used before the
++ * creation of the component, but uses a static list.
++ * It is implemented only for API completion, and it will be not overriden
++ * by a derived component.
++ *
++ * @param hComponent handle of the component
++ * @param cRole the output string containing the n-role of the component
++ * @param nIndex the index of the role requested
++ */
++OMX_ERRORTYPE omx_base_component_ComponentRoleEnum(
++  OMX_IN OMX_HANDLETYPE hComponent,
++  OMX_OUT OMX_U8 *cRole,
++  OMX_IN OMX_U32 nIndex);
++
++/** @brief standard OpenMAX function
++ *
++ * it sets the callback functions given by the IL client.
++ * See OMX_Component.h
++ */
++OMX_ERRORTYPE omx_base_component_SetCallbacks(
++  OMX_IN  OMX_HANDLETYPE hComponent,
++  OMX_IN  OMX_CALLBACKTYPE* pCallbacks,
++  OMX_IN  OMX_PTR pAppData);
++
++/** @brief Part of the standard OpenMAX function
++ *
++ * This function return the parameters not related to any port.
++ * These parameters are handled in the derived components
++ * See OMX_Core.h for standard reference.
++ */
++OMX_ERRORTYPE omx_base_component_GetParameter(
++  OMX_IN  OMX_HANDLETYPE hComponent,
++  OMX_IN  OMX_INDEXTYPE nParamIndex,
++  OMX_INOUT OMX_PTR ComponentParameterStructure);
++
++/** @brief part of the standard openmax function
++ *
++ * This function return the parameters not related to any port,
++ * These parameters are handled in the derived components
++ * See OMX_Core.h for standard reference.
++ *
++ * @return OMX_ErrorUnsupportedIndex if the index is not supported or not handled here
++ */
++OMX_ERRORTYPE omx_base_component_SetParameter(
++  OMX_IN  OMX_HANDLETYPE hComponent,
++  OMX_IN  OMX_INDEXTYPE nParamIndex,
++  OMX_IN  OMX_PTR ComponentParameterStructure);
++
++/** @brief base GetConfig function
++ *
++ * This base function is not implemented. If a derived component
++ * needs to support any config, it must implement a derived
++ * version of this function and assign it to the correct pointer
++ * in the private component descriptor.
++ */
++OMX_ERRORTYPE omx_base_component_GetConfig(
++  OMX_IN  OMX_HANDLETYPE hComponent,
++  OMX_IN  OMX_INDEXTYPE nIndex,
++  OMX_INOUT OMX_PTR pComponentConfigStructure);
++
++/** @brief base SetConfig function
++ *
++ * This base function is not implemented. If a derived component
++ * needs to support any config, it must implement a derived
++ * version of this function and assign it to the correct pointer
++ * in the private component descriptor.
++ */
++OMX_ERRORTYPE omx_base_component_SetConfig(
++  OMX_IN  OMX_HANDLETYPE hComponent,
++  OMX_IN  OMX_INDEXTYPE nIndex,
++  OMX_IN  OMX_PTR pComponentConfigStructure);
++
++/** @brief base function not implemented
++ *
++ * This function can be eventually implemented by a
++ * derived component if needed.
++ */
++OMX_ERRORTYPE omx_base_component_GetExtensionIndex(
++  OMX_IN  OMX_HANDLETYPE hComponent,
++  OMX_IN  OMX_STRING cParameterName,
++  OMX_OUT OMX_INDEXTYPE* pIndexType);
++
++/** @returns the state of the component
++ *
++ * This function does not need any override by derived components.
++ */
++OMX_ERRORTYPE omx_base_component_GetState(
++  OMX_IN  OMX_HANDLETYPE hComponent,
++  OMX_OUT OMX_STATETYPE* pState);
++
++/** @brief standard SendCommand function
++ *
++ * In general this function does not need a overwrite, but
++ * a special derived component could do it.
++ */
++OMX_ERRORTYPE omx_base_component_SendCommand(
++  OMX_IN  OMX_HANDLETYPE hComponent,
++  OMX_IN  OMX_COMMANDTYPE Cmd,
++  OMX_IN  OMX_U32 nParam,
++  OMX_IN  OMX_PTR pCmdData);
++
++/** @brief This standard functionality is called when the component is
++ * destroyed in the FreeHandle standard call.
++ *
++ * In this way the implementation of the FreeHandle is standard,
++ * and it does not need a support by a specific component loader.
++ * The implementaiton of the ComponentDeInit contains the
++ * implementation specific part of the destroying phase.
++ */
++OMX_ERRORTYPE omx_base_component_ComponentDeInit(
++  OMX_IN  OMX_HANDLETYPE hComponent);
++
++/** @brief Component's message handler thread function
++ *
++ * Handles all messages coming from components and
++ * processes them by dispatching them back to the
++ * triggering component.
++ */
++void* compMessageHandlerFunction(void*);
++
++/** This is called by the component message entry point.
++ * In thea base version this function is named compMessageHandlerFunction
++ *
++ * A request is made by the component when some asynchronous services are needed:
++ * 1) A SendCommand() is to be processed
++ * 2) An error needs to be notified
++ * 3) ...
++ *
++ * @param openmaxStandComp the component itself
++ * @param message the message that has been passed to core
++ */
++OMX_ERRORTYPE omx_base_component_MessageHandler(OMX_COMPONENTTYPE *openmaxStandComp,internalRequestMessageType* message);
++
++/**
++ * This function verify Component State and Structure header
++ */
++OMX_ERRORTYPE omx_base_component_ParameterSanityCheck(
++            OMX_IN  OMX_HANDLETYPE hComponent,
++            OMX_IN  OMX_U32 nPortIndex,
++            OMX_IN  OMX_PTR pStructure,
++            OMX_IN  size_t size);
++
++OMX_ERRORTYPE omx_base_component_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);
++
++OMX_ERRORTYPE omx_base_component_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);
++
++OMX_ERRORTYPE omx_base_component_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 omx_base_component_FreeBuffer(
++            OMX_IN  OMX_HANDLETYPE hComponent,
++            OMX_IN  OMX_U32 nPortIndex,
++            OMX_IN  OMX_BUFFERHEADERTYPE* pBuffer);
++
++OMX_ERRORTYPE omx_base_component_EmptyThisBuffer(
++            OMX_IN  OMX_HANDLETYPE hComponent,
++            OMX_IN  OMX_BUFFERHEADERTYPE* pBuffer);
++
++OMX_ERRORTYPE omx_base_component_FillThisBuffer(
++            OMX_IN  OMX_HANDLETYPE hComponent,
++            OMX_IN  OMX_BUFFERHEADERTYPE* pBuffer);
++
++OMX_ERRORTYPE omx_base_component_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);
++
++#endif
+diff --git a/alsa/omx_base_port.cpp b/alsa/omx_base_port.cpp
+new file mode 100644
+index 0000000..67d003a
+--- /dev/null
++++ b/alsa/omx_base_port.cpp
+@@ -0,0 +1,1163 @@
++/**
++  @file src/base/omx_base_port.c
++
++  Base class for OpenMAX ports to be used in derived components.
++
++  Copyright (C) 2007-2008 STMicroelectronics
++  Copyright (C) 2007-2008 Nokia Corporation and/or its subsidiary(-ies).
++
++  This library 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.
++
++  This library 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 this library; if not, write to the Free Software Foundation, Inc.,
++  51 Franklin St, Fifth Floor, Boston, MA
++  02110-1301  USA
++
++  $Date: 2008-09-11 15:28:59 +0200 (Thu, 11 Sep 2008) $
++  Revision $Rev: 614 $
++  Author $Author: gsent $
++*/
++
++#include <stdlib.h>
++#include <string.h>
++#include <unistd.h>
++//#include <IL/OMX_Core.h>
++//#include <IL/OMX_Component.h>
++
++#include "omx_base_component.h"
++#include "omx_base_port.h"
++
++/** The default value for the number of needed buffers for each port. */
++#define DEFAULT_NUMBER_BUFFERS_PER_PORT 4
++/** The default value for the minimum number of needed buffers for each port. */
++#define DEFAULT_MIN_NUMBER_BUFFERS_PER_PORT 4
++/**
++  * @brief The base contructor for the generic OpenMAX ST port
++  *
++  * This function is executed by the component that uses a port.
++  * The parameter contains the info about the component.
++  * It takes care of constructing the instance of the port and
++  * every object needed by the base port.
++  *
++  * @param openmaxStandComp in the component that holds the port
++  * @param openmaxStandPort the ST port to be initialized
++  * @param nPortIndex the index of the port
++  * @param isInput specifices if the port is an input or an output
++  *
++  * @return OMX_ErrorInsufficientResources if a memory allocation fails
++  */
++
++OMX_ERRORTYPE base_port_Constructor(OMX_COMPONENTTYPE *openmaxStandComp,omx_base_PortType **openmaxStandPort,OMX_U32 nPortIndex, OMX_BOOL isInput) {
++
++  /* omx_base_component_PrivateType* omx_base_component_Private; */
++
++  DEBUG(DEB_LEV_FUNCTION_NAME, "In %s\n", __func__);
++  /* omx_base_component_Private = (omx_base_component_PrivateType*)openmaxStandComp->pComponentPrivate; */
++
++  // create ports, but only if the subclass hasn't done it
++  if (!(*openmaxStandPort)) {
++    *openmaxStandPort = (omx_base_PortType*)calloc(1,sizeof (omx_base_PortType));
++  }
++
++  if (!(*openmaxStandPort)) {
++    return OMX_ErrorInsufficientResources;
++  }
++
++  (*openmaxStandPort)->hTunneledComponent = NULL;
++  (*openmaxStandPort)->nTunnelFlags=0;
++  (*openmaxStandPort)->nTunneledPort=0;
++  (*openmaxStandPort)->eBufferSupplier=OMX_BufferSupplyUnspecified;
++  (*openmaxStandPort)->nNumTunnelBuffer=0;
++  (*openmaxStandPort)->bTunnelTearDown = OMX_FALSE;
++
++  if((*openmaxStandPort)->pAllocSem==NULL) {
++    (*openmaxStandPort)->pAllocSem = (omx_tsem_t*)calloc(1,sizeof(omx_tsem_t));
++    if((*openmaxStandPort)->pAllocSem==NULL) {
++      return OMX_ErrorInsufficientResources;
++    }
++    omx_tsem_init((*openmaxStandPort)->pAllocSem, 0);
++  }
++  (*openmaxStandPort)->nNumBufferFlushed=0;
++  (*openmaxStandPort)->bIsPortFlushed=OMX_FALSE;
++  /** Allocate and initialize buffer queue */
++  if(!(*openmaxStandPort)->pBufferQueue) {
++    (*openmaxStandPort)->pBufferQueue = (omx_queue_t*)calloc(1,sizeof(omx_queue_t));
++    if((*openmaxStandPort)->pBufferQueue==NULL) return OMX_ErrorInsufficientResources;
++    omx_queue_init((*openmaxStandPort)->pBufferQueue);
++  }
++  /*Allocate and initialise port semaphores*/
++  if(!(*openmaxStandPort)->pBufferSem) {
++    (*openmaxStandPort)->pBufferSem = (omx_tsem_t*)calloc(1,sizeof(omx_tsem_t));
++    if((*openmaxStandPort)->pBufferSem==NULL) return OMX_ErrorInsufficientResources;
++    omx_tsem_init((*openmaxStandPort)->pBufferSem, 0);
++  }
++
++  (*openmaxStandPort)->nNumAssignedBuffers=0;
++  setHeader(&(*openmaxStandPort)->sPortParam, sizeof (OMX_PARAM_PORTDEFINITIONTYPE));
++  (*openmaxStandPort)->sPortParam.nPortIndex = nPortIndex;
++  (*openmaxStandPort)->sPortParam.nBufferCountActual = DEFAULT_NUMBER_BUFFERS_PER_PORT;
++  (*openmaxStandPort)->sPortParam.nBufferCountMin = DEFAULT_MIN_NUMBER_BUFFERS_PER_PORT;
++  (*openmaxStandPort)->sPortParam.bEnabled = OMX_TRUE;
++  (*openmaxStandPort)->sPortParam.bPopulated = OMX_FALSE;
++  (*openmaxStandPort)->sPortParam.eDir  =  (isInput == OMX_TRUE)?OMX_DirInput:OMX_DirOutput;
++
++  (*openmaxStandPort)->standCompContainer=openmaxStandComp;
++  (*openmaxStandPort)->bIsTransientToEnabled=OMX_FALSE;
++  (*openmaxStandPort)->bIsTransientToDisabled=OMX_FALSE;
++  (*openmaxStandPort)->bIsFullOfBuffers=OMX_FALSE;
++  (*openmaxStandPort)->bIsEmptyOfBuffers=OMX_FALSE;
++  (*openmaxStandPort)->bBufferStateAllocated = NULL;
++  (*openmaxStandPort)->pInternalBufferStorage = NULL;
++
++  (*openmaxStandPort)->PortDestructor = &base_port_Destructor;
++  (*openmaxStandPort)->Port_AllocateBuffer = &base_port_AllocateBuffer;
++  (*openmaxStandPort)->Port_UseBuffer = &base_port_UseBuffer;
++  (*openmaxStandPort)->Port_FreeBuffer = &base_port_FreeBuffer;
++  (*openmaxStandPort)->Port_DisablePort = &base_port_DisablePort;
++  (*openmaxStandPort)->Port_EnablePort = &base_port_EnablePort;
++  (*openmaxStandPort)->Port_SendBufferFunction = &base_port_SendBufferFunction;
++  (*openmaxStandPort)->FlushProcessingBuffers = &base_port_FlushProcessingBuffers;
++  (*openmaxStandPort)->ReturnBufferFunction = &base_port_ReturnBufferFunction;
++  (*openmaxStandPort)->ComponentTunnelRequest = &base_port_ComponentTunnelRequest;
++  (*openmaxStandPort)->Port_AllocateTunnelBuffer = &base_port_AllocateTunnelBuffer;
++  (*openmaxStandPort)->Port_FreeTunnelBuffer = &base_port_FreeTunnelBuffer;
++
++  return OMX_ErrorNone;
++}
++
++OMX_ERRORTYPE base_port_Destructor(omx_base_PortType *openmaxStandPort){
++
++  if(openmaxStandPort->pAllocSem) {
++    omx_tsem_deinit(openmaxStandPort->pAllocSem);
++    free(openmaxStandPort->pAllocSem);
++    openmaxStandPort->pAllocSem=NULL;
++  }
++  /** Allocate and initialize buffer queue */
++  if(openmaxStandPort->pBufferQueue) {
++    omx_queue_deinit(openmaxStandPort->pBufferQueue);
++    free(openmaxStandPort->pBufferQueue);
++    openmaxStandPort->pBufferQueue=NULL;
++  }
++  /*Allocate and initialise port semaphores*/
++  if(openmaxStandPort->pBufferSem) {
++    omx_tsem_deinit(openmaxStandPort->pBufferSem);
++    free(openmaxStandPort->pBufferSem);
++    openmaxStandPort->pBufferSem=NULL;
++  }
++
++  free(openmaxStandPort);
++  openmaxStandPort = NULL;
++  return OMX_ErrorNone;
++}
++
++/** @brief Releases buffers under processing.
++ * This function must be implemented in the derived classes, for the
++ * specific processing
++ */
++OMX_ERRORTYPE base_port_FlushProcessingBuffers(omx_base_PortType *openmaxStandPort) {
++  omx_base_component_PrivateType* omx_base_component_Private;
++  OMX_BUFFERHEADERTYPE* pBuffer;
++
++  DEBUG(DEB_LEV_FUNCTION_NAME, "In %s\n", __func__);
++  omx_base_component_Private = (omx_base_component_PrivateType*)openmaxStandPort->standCompContainer->pComponentPrivate;
++
++  if(openmaxStandPort->sPortParam.eDomain!=OMX_PortDomainOther) { /* clock buffers not used in the clients buffer managment function */
++    pthread_mutex_lock(&omx_base_component_Private->flush_mutex);
++    openmaxStandPort->bIsPortFlushed=OMX_TRUE;
++    /*Signal the buffer management thread of port flush,if it is waiting for buffers*/
++    if(omx_base_component_Private->bMgmtSem->semval==0) {
++      omx_tsem_up(omx_base_component_Private->bMgmtSem);
++    }
++
++    if(omx_base_component_Private->state==OMX_StatePause ) {
++      /*Waiting at paused state*/
++      omx_tsem_signal(omx_base_component_Private->bStateSem);
++    }
++    DEBUG(DEB_LEV_FULL_SEQ, "In %s waiting for flush all condition port index =%d\n", __func__,(int)openmaxStandPort->sPortParam.nPortIndex);
++    /* Wait until flush is completed */
++    pthread_mutex_unlock(&omx_base_component_Private->flush_mutex);
++    omx_tsem_down(omx_base_component_Private->flush_all_condition);
++  }
++
++  omx_tsem_reset(omx_base_component_Private->bMgmtSem);
++
++  /* Flush all the buffers not under processing */
++  while (openmaxStandPort->pBufferSem->semval > 0) {
++    DEBUG(DEB_LEV_FULL_SEQ, "In %s TFlag=%x Flusing Port=%d,Semval=%d Qelem=%d\n",
++    __func__,(int)openmaxStandPort->nTunnelFlags,(int)openmaxStandPort->sPortParam.nPortIndex,
++    (int)openmaxStandPort->pBufferSem->semval,(int)openmaxStandPort->pBufferQueue->nelem);
++
++    omx_tsem_down(openmaxStandPort->pBufferSem);
++    pBuffer = (OMX_BUFFERHEADERTYPE*)omx_dequeue(openmaxStandPort->pBufferQueue);
++    if (PORT_IS_TUNNELED(openmaxStandPort) && !PORT_IS_BUFFER_SUPPLIER(openmaxStandPort)) {
++      DEBUG(DEB_LEV_FULL_SEQ, "In %s: Comp %s is returning io:%d buffer\n",
++        __func__,omx_base_component_Private->name,(int)openmaxStandPort->sPortParam.nPortIndex);
++      if (openmaxStandPort->sPortParam.eDir == OMX_DirInput) {
++        ((OMX_COMPONENTTYPE*)(openmaxStandPort->hTunneledComponent))->FillThisBuffer(openmaxStandPort->hTunneledComponent, pBuffer);
++      } else {
++        ((OMX_COMPONENTTYPE*)(openmaxStandPort->hTunneledComponent))->EmptyThisBuffer(openmaxStandPort->hTunneledComponent, pBuffer);
++      }
++    } else if (PORT_IS_TUNNELED_N_BUFFER_SUPPLIER(openmaxStandPort)) {
++      omx_queue(openmaxStandPort->pBufferQueue,pBuffer);
++    } else {
++      (*(openmaxStandPort->BufferProcessedCallback))(
++        openmaxStandPort->standCompContainer,
++        omx_base_component_Private->callbackData,
++        pBuffer);
++    }
++  }
++  /*Port is tunneled and supplier and didn't received all it's buffer then wait for the buffers*/
++  if (PORT_IS_TUNNELED_N_BUFFER_SUPPLIER(openmaxStandPort)) {
++    while(openmaxStandPort->pBufferQueue->nelem!= openmaxStandPort->nNumAssignedBuffers){
++      omx_tsem_down(openmaxStandPort->pBufferSem);
++      DEBUG(DEB_LEV_PARAMS, "In %s Got a buffer qelem=%d\n",__func__,openmaxStandPort->pBufferQueue->nelem);
++    }
++    omx_tsem_reset(openmaxStandPort->pBufferSem);
++  }
++
++  pthread_mutex_lock(&omx_base_component_Private->flush_mutex);
++  openmaxStandPort->bIsPortFlushed=OMX_FALSE;
++  pthread_mutex_unlock(&omx_base_component_Private->flush_mutex);
++
++  omx_tsem_up(omx_base_component_Private->flush_condition);
++
++  DEBUG(DEB_LEV_FULL_SEQ, "Out %s Port Index=%d bIsPortFlushed=%d Component %s\n", __func__,
++    (int)openmaxStandPort->sPortParam.nPortIndex,(int)openmaxStandPort->bIsPortFlushed,omx_base_component_Private->name);
++
++  DEBUG(DEB_LEV_PARAMS, "In %s TFlag=%x Qelem=%d BSem=%d bMgmtsem=%d component=%s\n", __func__,
++    (int)openmaxStandPort->nTunnelFlags,
++    (int)openmaxStandPort->pBufferQueue->nelem,
++    (int)openmaxStandPort->pBufferSem->semval,
++    (int)omx_base_component_Private->bMgmtSem->semval,
++    omx_base_component_Private->name);
++
++  DEBUG(DEB_LEV_FUNCTION_NAME, "Out %s Port Index=%d\n", __func__,(int)openmaxStandPort->sPortParam.nPortIndex);
++
++  return OMX_ErrorNone;
++}
++
++/** @brief Disables the port.
++ *
++ * This function is called due to a request by the IL client
++ *
++ * @param openmaxStandPort the reference to the port
++ *
++ */
++OMX_ERRORTYPE base_port_DisablePort(omx_base_PortType *openmaxStandPort) {
++  omx_base_component_PrivateType* omx_base_component_Private;
++  OMX_ERRORTYPE err=OMX_ErrorNone;
++
++  DEBUG(DEB_LEV_FUNCTION_NAME, "In %s Port Index=%d\n", __func__,(int)openmaxStandPort->sPortParam.nPortIndex);
++  omx_base_component_Private = (omx_base_component_PrivateType*)openmaxStandPort->standCompContainer->pComponentPrivate;
++  if (! PORT_IS_ENABLED(openmaxStandPort)) {
++    return OMX_ErrorNone;
++  }
++
++  if(omx_base_component_Private->state!=OMX_StateLoaded) {
++    if(!PORT_IS_BUFFER_SUPPLIER(openmaxStandPort)) {
++      /*Signal Buffer Mgmt Thread if it's holding any buffer*/
++      if(omx_base_component_Private->bMgmtSem->semval==0) {
++        omx_tsem_up(omx_base_component_Private->bMgmtSem);
++      }
++      /*Wait till all buffers are freed*/
++      omx_tsem_down(openmaxStandPort->pAllocSem);
++      omx_tsem_reset(omx_base_component_Private->bMgmtSem);
++    } else {
++      /*Since port is being disabled then remove buffers from the queue*/
++      while(openmaxStandPort->pBufferQueue->nelem > 0) {
++        omx_dequeue(openmaxStandPort->pBufferQueue);
++      }
++
++      err = openmaxStandPort->Port_FreeTunnelBuffer(openmaxStandPort,openmaxStandPort->sPortParam.nPortIndex);
++      if(err!=OMX_ErrorNone) {
++        DEBUG(DEB_LEV_ERR, "In %s Freeing Tunnel Buffer Error=%x\n",__func__,err);
++      }
++      DEBUG(DEB_LEV_PARAMS, "In %s Qelem=%d\n", __func__,openmaxStandPort->pBufferQueue->nelem);
++    }
++
++    if(openmaxStandPort->bTunnelTearDown == OMX_TRUE){
++      DEBUG(DEB_LEV_PARAMS, "In %s TearDown tunnel\n", __func__);
++      openmaxStandPort->hTunneledComponent = 0;
++      openmaxStandPort->nTunneledPort = 0;
++      openmaxStandPort->nTunnelFlags = 0;
++      openmaxStandPort->eBufferSupplier=OMX_BufferSupplyUnspecified;
++      openmaxStandPort->bTunnelTearDown = OMX_FALSE;
++    }
++  }
++
++  DEBUG(DEB_LEV_PARAMS, "In %s TFlag=%x Qelem=%d BSem=%d bMgmtsem=%d component=%s\n", __func__,
++    (int)openmaxStandPort->nTunnelFlags,
++    (int)openmaxStandPort->pBufferQueue->nelem,
++    (int)openmaxStandPort->pBufferSem->semval,
++    (int)omx_base_component_Private->bMgmtSem->semval,
++    omx_base_component_Private->name);
++  openmaxStandPort->bIsTransientToDisabled = OMX_FALSE;
++  openmaxStandPort->sPortParam.bEnabled = OMX_FALSE;
++  DEBUG(DEB_LEV_FUNCTION_NAME, "Out %s Port Index=%d isEnabled=%d\n", __func__,
++    (int)openmaxStandPort->sPortParam.nPortIndex,
++    (int)openmaxStandPort->sPortParam.bEnabled);
++  return err;
++}
++
++/** @brief Enables the port.
++ *
++ * This function is called due to a request by the IL client
++ *
++ * @param openmaxStandPort the reference to the port
++ *
++ */
++OMX_ERRORTYPE base_port_EnablePort(omx_base_PortType *openmaxStandPort) {
++  omx_base_component_PrivateType* omx_base_component_Private;
++  OMX_ERRORTYPE err=OMX_ErrorNone;
++  OMX_U32 i;
++
++  DEBUG(DEB_LEV_FUNCTION_NAME, "In %s\n", __func__);
++  if (PORT_IS_ENABLED(openmaxStandPort)) {
++    return OMX_ErrorNone;
++  }
++  omx_base_component_Private = (omx_base_component_PrivateType*)openmaxStandPort->standCompContainer->pComponentPrivate;
++
++  openmaxStandPort->sPortParam.bEnabled = OMX_TRUE;
++
++  DEBUG(DEB_LEV_FUNCTION_NAME, "In %s port T flag=%x popu=%d state=%x\n", __func__,
++    (int)openmaxStandPort->nTunnelFlags,
++    (int)openmaxStandPort->sPortParam.bPopulated,
++    (int)omx_base_component_Private->state);
++
++
++  if (!PORT_IS_BUFFER_SUPPLIER(openmaxStandPort)) {
++    /*Wait Till All buffers are allocated if the component state is not Loaded*/
++    if (omx_base_component_Private->state!=OMX_StateLoaded && omx_base_component_Private->state!=OMX_StateWaitForResources)  {
++      omx_tsem_down(openmaxStandPort->pAllocSem);
++      openmaxStandPort->sPortParam.bPopulated = OMX_TRUE;
++    }
++  } else { //Port Tunneled and supplier. Then allocate tunnel buffers
++    err= openmaxStandPort->Port_AllocateTunnelBuffer(openmaxStandPort, openmaxStandPort->sPortParam.nPortIndex, openmaxStandPort->sPortParam.nBufferSize);
++    if(err!=OMX_ErrorNone) {
++      DEBUG(DEB_LEV_ERR, "In %s Allocating Tunnel Buffer Error=%x\n",__func__,err);
++      return err;
++    }
++    openmaxStandPort->sPortParam.bPopulated = OMX_TRUE;
++    if (omx_base_component_Private->state==OMX_StateExecuting) {
++      for(i=0; i < openmaxStandPort->sPortParam.nBufferCountActual;i++) {
++        omx_tsem_up(openmaxStandPort->pBufferSem);
++        omx_tsem_up(omx_base_component_Private->bMgmtSem);
++      }
++    }
++    DEBUG(DEB_LEV_PARAMS, "In %s Qelem=%d BSem=%d\n", __func__,openmaxStandPort->pBufferQueue->nelem,openmaxStandPort->pBufferSem->semval);
++  }
++
++  openmaxStandPort->bIsTransientToEnabled = OMX_FALSE;
++
++  DEBUG(DEB_LEV_FUNCTION_NAME, "Out of %s\n", __func__);
++
++  return OMX_ErrorNone;
++}
++
++/** @brief Called by the standard allocate buffer, it implements a base functionality.
++ *
++ * This function can be overriden if the allocation of the buffer is not a simply calloc call.
++ * The parameters are the same as the standard function, except for the handle of the port
++ * instead of the handler of the component
++ * When the buffers needed by this port are all assigned or allocated, the variable
++ * bIsFullOfBuffers becomes equal to OMX_TRUE
++ */
++OMX_ERRORTYPE base_port_AllocateBuffer(
++  omx_base_PortType *openmaxStandPort,
++  OMX_BUFFERHEADERTYPE** pBuffer,
++  OMX_U32 nPortIndex,
++  OMX_PTR pAppPrivate,
++  OMX_U32 nSizeBytes) {
++
++  unsigned int i;
++  OMX_COMPONENTTYPE* omxComponent = openmaxStandPort->standCompContainer;
++  omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)omxComponent->pComponentPrivate;
++  DEBUG(DEB_LEV_FUNCTION_NAME, "In %s\n", __func__);
++
++  if (nPortIndex != openmaxStandPort->sPortParam.nPortIndex) {
++    return OMX_ErrorBadPortIndex;
++  }
++  if (PORT_IS_TUNNELED_N_BUFFER_SUPPLIER(openmaxStandPort)) {
++    return OMX_ErrorBadPortIndex;
++  }
++
++  if ((omx_base_component_Private->transientState != OMX_TransStateLoadedToIdle) || (omx_base_component_Private->state!=OMX_StateLoaded)) {
++    if (!openmaxStandPort->bIsTransientToEnabled) {
++      DEBUG(DEB_LEV_ERR, "In %s: The port is not allowed to receive buffers\n", __func__);
++      return OMX_ErrorIncorrectStateTransition;
++    }
++  }
++
++  if(nSizeBytes < openmaxStandPort->sPortParam.nBufferSize) {
++    DEBUG(DEB_LEV_ERR, "In %s: Requested Buffer Size %lu is less than Minimum Buffer Size %lu\n", __func__, (unsigned long)nSizeBytes, (unsigned long)openmaxStandPort->sPortParam.nBufferSize);
++    return OMX_ErrorIncorrectStateTransition;
++  }
++
++  for(i=0; i < openmaxStandPort->sPortParam.nBufferCountActual; i++){
++    if (openmaxStandPort->bBufferStateAllocated[i] == BUFFER_FREE) {
++      openmaxStandPort->pInternalBufferStorage[i] = (OMX_BUFFERHEADERTYPE*)calloc(1,sizeof(OMX_BUFFERHEADERTYPE));
++      if (!openmaxStandPort->pInternalBufferStorage[i]) {
++        return OMX_ErrorInsufficientResources;
++      }
++      setHeader(openmaxStandPort->pInternalBufferStorage[i], sizeof(OMX_BUFFERHEADERTYPE));
++      /* allocate the buffer */
++      openmaxStandPort->pInternalBufferStorage[i]->pBuffer = (OMX_U8*)calloc(1,nSizeBytes);
++      if(openmaxStandPort->pInternalBufferStorage[i]->pBuffer==NULL) {
++        return OMX_ErrorInsufficientResources;
++      }
++      openmaxStandPort->pInternalBufferStorage[i]->nAllocLen = nSizeBytes;
++      openmaxStandPort->pInternalBufferStorage[i]->pPlatformPrivate = openmaxStandPort;
++      openmaxStandPort->pInternalBufferStorage[i]->pAppPrivate = pAppPrivate;
++      *pBuffer = openmaxStandPort->pInternalBufferStorage[i];
++      openmaxStandPort->bBufferStateAllocated[i] = BUFFER_ALLOCATED;
++      openmaxStandPort->bBufferStateAllocated[i] |= HEADER_ALLOCATED;
++      if (openmaxStandPort->sPortParam.eDir == OMX_DirInput) {
++        openmaxStandPort->pInternalBufferStorage[i]->nInputPortIndex = openmaxStandPort->sPortParam.nPortIndex;
++      } else {
++        openmaxStandPort->pInternalBufferStorage[i]->nOutputPortIndex = openmaxStandPort->sPortParam.nPortIndex;
++      }
++      openmaxStandPort->nNumAssignedBuffers++;
++      DEBUG(DEB_LEV_PARAMS, "openmaxStandPort->nNumAssignedBuffers %i\n", (int)openmaxStandPort->nNumAssignedBuffers);
++
++      if (openmaxStandPort->sPortParam.nBufferCountActual == openmaxStandPort->nNumAssignedBuffers) {
++        openmaxStandPort->sPortParam.bPopulated = OMX_TRUE;
++        openmaxStandPort->bIsFullOfBuffers = OMX_TRUE;
++        DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s nPortIndex=%d\n",__func__,(int)nPortIndex);
++        omx_tsem_up(openmaxStandPort->pAllocSem);
++      }
++      return OMX_ErrorNone;
++    }
++  }
++  DEBUG(DEB_LEV_ERR, "In %s Error: no available buffers\n",__func__);
++  return OMX_ErrorInsufficientResources;
++}
++
++/** @brief Called by the standard use buffer, it implements a base functionality.
++ *
++ * This function can be overriden if the use buffer implicate more complicated operations.
++ * The parameters are the same as the standard function, except for the handle of the port
++ * instead of the handler of the component.
++ * When the buffers needed by this port are all assigned or allocated, the variable
++ * bIsFullOfBuffers becomes equal to OMX_TRUE
++ */
++OMX_ERRORTYPE base_port_UseBuffer(
++  omx_base_PortType *openmaxStandPort,
++  OMX_BUFFERHEADERTYPE** ppBufferHdr,
++  OMX_U32 nPortIndex,
++  OMX_PTR pAppPrivate,
++  OMX_U32 nSizeBytes,
++  OMX_U8* pBuffer) {
++
++  unsigned int i;
++  OMX_BUFFERHEADERTYPE* returnBufferHeader;
++  OMX_COMPONENTTYPE* omxComponent = openmaxStandPort->standCompContainer;
++  omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)omxComponent->pComponentPrivate;
++  DEBUG(DEB_LEV_FUNCTION_NAME, "In %s\n", __func__);
++  if (nPortIndex != openmaxStandPort->sPortParam.nPortIndex) {
++    return OMX_ErrorBadPortIndex;
++  }
++  if (PORT_IS_TUNNELED_N_BUFFER_SUPPLIER(openmaxStandPort)) {
++    return OMX_ErrorBadPortIndex;
++  }
++
++  if (omx_base_component_Private->transientState != OMX_TransStateLoadedToIdle) {
++    if (!openmaxStandPort->bIsTransientToEnabled) {
++      DEBUG(DEB_LEV_ERR, "In %s: The port of Comp %s is not allowed to receive buffers\n", __func__,omx_base_component_Private->name);
++      return OMX_ErrorIncorrectStateTransition;
++    }
++  }
++
++  /// AND
++  /*
++  if(nSizeBytes < openmaxStandPort->sPortParam.nBufferSize) {
++    DEBUG(DEB_LEV_ERR, "In %s: Given Buffer Size %lu is less than Minimum Buffer Size %lu\n", __func__, nSizeBytes, openmaxStandPort->sPortParam.nBufferSize);
++    return OMX_ErrorIncorrectStateTransition;
++  }
++  */
++  /// AND
++
++  for(i=0; i < openmaxStandPort->sPortParam.nBufferCountActual; i++){
++    if (openmaxStandPort->bBufferStateAllocated[i] == BUFFER_FREE) {
++      openmaxStandPort->pInternalBufferStorage[i] = (OMX_BUFFERHEADERTYPE*)calloc(1,sizeof(OMX_BUFFERHEADERTYPE));
++      if (!openmaxStandPort->pInternalBufferStorage[i]) {
++        return OMX_ErrorInsufficientResources;
++      }
++      openmaxStandPort->bIsEmptyOfBuffers = OMX_FALSE;
++      setHeader(openmaxStandPort->pInternalBufferStorage[i], sizeof(OMX_BUFFERHEADERTYPE));
++
++      openmaxStandPort->pInternalBufferStorage[i]->pBuffer = pBuffer;
++      openmaxStandPort->pInternalBufferStorage[i]->nAllocLen = nSizeBytes;
++      openmaxStandPort->pInternalBufferStorage[i]->pPlatformPrivate = openmaxStandPort;
++      openmaxStandPort->pInternalBufferStorage[i]->pAppPrivate = pAppPrivate;
++      openmaxStandPort->bBufferStateAllocated[i] = BUFFER_ASSIGNED;
++      openmaxStandPort->bBufferStateAllocated[i] |= HEADER_ALLOCATED;
++      returnBufferHeader = (OMX_BUFFERHEADERTYPE*)calloc(1,sizeof(OMX_BUFFERHEADERTYPE));
++      if (!returnBufferHeader) {
++        return OMX_ErrorInsufficientResources;
++      }
++      setHeader(returnBufferHeader, sizeof(OMX_BUFFERHEADERTYPE));
++      returnBufferHeader->pBuffer = pBuffer;
++      returnBufferHeader->nAllocLen = nSizeBytes;
++      returnBufferHeader->pPlatformPrivate = openmaxStandPort;
++      returnBufferHeader->pAppPrivate = pAppPrivate;
++      if (openmaxStandPort->sPortParam.eDir == OMX_DirInput) {
++        openmaxStandPort->pInternalBufferStorage[i]->nInputPortIndex = openmaxStandPort->sPortParam.nPortIndex;
++        returnBufferHeader->nInputPortIndex = openmaxStandPort->sPortParam.nPortIndex;
++      } else {
++        openmaxStandPort->pInternalBufferStorage[i]->nOutputPortIndex = openmaxStandPort->sPortParam.nPortIndex;
++        returnBufferHeader->nOutputPortIndex = openmaxStandPort->sPortParam.nPortIndex;
++      }
++      *ppBufferHdr = returnBufferHeader;
++      openmaxStandPort->nNumAssignedBuffers++;
++      DEBUG(DEB_LEV_PARAMS, "openmaxStandPort->nNumAssignedBuffers %i\n", (int)openmaxStandPort->nNumAssignedBuffers);
++
++      if (openmaxStandPort->sPortParam.nBufferCountActual == openmaxStandPort->nNumAssignedBuffers) {
++        openmaxStandPort->sPortParam.bPopulated = OMX_TRUE;
++        openmaxStandPort->bIsFullOfBuffers = OMX_TRUE;
++        omx_tsem_up(openmaxStandPort->pAllocSem);
++      }
++      return OMX_ErrorNone;
++    }
++  }
++  DEBUG(DEB_LEV_ERR, "In %s Error: no available buffers CompName=%s\n",__func__,omx_base_component_Private->name);
++  return OMX_ErrorInsufficientResources;
++}
++
++/** @brief Called by the standard function.
++ *
++ * It frees the buffer header and in case also the buffer itself, if needed.
++ * When all the bufers are done, the variable bIsEmptyOfBuffers is set to OMX_TRUE
++ */
++OMX_ERRORTYPE base_port_FreeBuffer(
++  omx_base_PortType *openmaxStandPort,
++  OMX_U32 nPortIndex,
++  OMX_BUFFERHEADERTYPE* pBuffer) {
++
++  unsigned int i;
++  OMX_COMPONENTTYPE* omxComponent = openmaxStandPort->standCompContainer;
++  omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)omxComponent->pComponentPrivate;
++  DEBUG(DEB_LEV_FUNCTION_NAME, "In %s\n", __func__);
++
++  if (nPortIndex != openmaxStandPort->sPortParam.nPortIndex) {
++    return OMX_ErrorBadPortIndex;
++  }
++  if (PORT_IS_TUNNELED_N_BUFFER_SUPPLIER(openmaxStandPort)) {
++    return OMX_ErrorBadPortIndex;
++  }
++
++  if (omx_base_component_Private->transientState != OMX_TransStateIdleToLoaded) {
++    if (!openmaxStandPort->bIsTransientToDisabled) {
++      DEBUG(DEB_LEV_FULL_SEQ, "In %s: The port is not allowed to free the buffers\n", __func__);
++      (*(omx_base_component_Private->callbacks->EventHandler))
++        (omxComponent,
++        omx_base_component_Private->callbackData,
++        OMX_EventError, /* The command was completed */
++        OMX_ErrorPortUnpopulated, /* The commands was a OMX_CommandStateSet */
++        nPortIndex, /* The state has been changed in message->messageParam2 */
++        NULL);
++    }
++  }
++
++  for(i=0; i < openmaxStandPort->sPortParam.nBufferCountActual; i++){
++    if (openmaxStandPort->bBufferStateAllocated[i] & (BUFFER_ASSIGNED | BUFFER_ALLOCATED)) {
++
++      openmaxStandPort->bIsFullOfBuffers = OMX_FALSE;
++      if (openmaxStandPort->bBufferStateAllocated[i] & BUFFER_ALLOCATED) {
++        if(openmaxStandPort->pInternalBufferStorage[i]->pBuffer){
++          DEBUG(DEB_LEV_PARAMS, "In %s freeing %i pBuffer=%x\n",__func__, (int)i, (int)openmaxStandPort->pInternalBufferStorage[i]->pBuffer);
++          free(openmaxStandPort->pInternalBufferStorage[i]->pBuffer);
++          openmaxStandPort->pInternalBufferStorage[i]->pBuffer=NULL;
++        }
++      } else if (openmaxStandPort->bBufferStateAllocated[i] & BUFFER_ASSIGNED) {
++        free(pBuffer);
++      }
++      if(openmaxStandPort->bBufferStateAllocated[i] & HEADER_ALLOCATED) {
++        free(openmaxStandPort->pInternalBufferStorage[i]);
++        openmaxStandPort->pInternalBufferStorage[i]=NULL;
++      }
++
++      openmaxStandPort->bBufferStateAllocated[i] = BUFFER_FREE;
++
++      openmaxStandPort->nNumAssignedBuffers--;
++      DEBUG(DEB_LEV_PARAMS, "openmaxStandPort->nNumAssignedBuffers %i\n", (int)openmaxStandPort->nNumAssignedBuffers);
++
++      if (openmaxStandPort->nNumAssignedBuffers == 0) {
++        openmaxStandPort->sPortParam.bPopulated = OMX_FALSE;
++        openmaxStandPort->bIsEmptyOfBuffers = OMX_TRUE;
++        omx_tsem_up(openmaxStandPort->pAllocSem);
++      }
++      return OMX_ErrorNone;
++    }
++  }
++  return OMX_ErrorInsufficientResources;
++}
++
++OMX_ERRORTYPE base_port_AllocateTunnelBuffer(omx_base_PortType *openmaxStandPort,OMX_IN OMX_U32 nPortIndex,OMX_IN OMX_U32 nSizeBytes)
++{
++  unsigned int i;
++  OMX_COMPONENTTYPE* omxComponent = openmaxStandPort->standCompContainer;
++  omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)omxComponent->pComponentPrivate;
++  OMX_U8* pBuffer=NULL;
++  OMX_ERRORTYPE eError=OMX_ErrorNone;
++  OMX_U32 numRetry=0;
++  DEBUG(DEB_LEV_FUNCTION_NAME, "In %s, nPortIndex=%d, nSizeBytes=%d, nBufferCountActual=%d\n", __func__, nPortIndex, nSizeBytes, openmaxStandPort->sPortParam.nBufferCountActual);
++
++  if (nPortIndex != openmaxStandPort->sPortParam.nPortIndex) {
++    DEBUG(DEB_LEV_ERR, "In %s: Bad Port Index\n", __func__);
++    return OMX_ErrorBadPortIndex;
++  }
++  if (! PORT_IS_TUNNELED_N_BUFFER_SUPPLIER(openmaxStandPort)) {
++    DEBUG(DEB_LEV_ERR, "In %s: Port is not tunneled Flag=%x\n", __func__, (int)openmaxStandPort->nTunnelFlags);
++    return OMX_ErrorBadPortIndex;
++  }
++
++  if (omx_base_component_Private->transientState != OMX_TransStateLoadedToIdle) {
++    if (!openmaxStandPort->bIsTransientToEnabled) {
++      DEBUG(DEB_LEV_ERR, "In %s: The port is not allowed to receive buffers\n", __func__);
++      return OMX_ErrorIncorrectStateTransition;
++    }
++  }
++
++  if( NULL == openmaxStandPort->bBufferStateAllocated )
++  {
++    openmaxStandPort->bBufferStateAllocated = (BUFFER_STATUS_FLAG*)calloc(openmaxStandPort->sPortParam.nBufferCountActual, sizeof(openmaxStandPort->bBufferStateAllocated[0] ));
++    for(i=0; i < openmaxStandPort->sPortParam.nBufferCountActual; i++)
++    {
++      openmaxStandPort->bBufferStateAllocated[i] = BUFFER_FREE;
++    }
++  }
++
++  if( NULL == openmaxStandPort->pInternalBufferStorage )
++  {
++    openmaxStandPort->pInternalBufferStorage = (OMX_BUFFERHEADERTYPE**)calloc(openmaxStandPort->sPortParam.nBufferCountActual, sizeof(OMX_BUFFERHEADERTYPE*));
++    /*for(i=0; i < openmaxStandPort->sPortParam.nBufferCountActual; i++)
++    {
++      //memset(&openmaxStandPort->pInternalBufferStorage[i], 0, sizeof(OMX_BUFFERHEADERTYPE*));
++      setHeader(&openmaxStandPort->pInternalBufferStorage[i], sizeof(OMX_BUFFERHEADERTYPE*));
++    }*/
++  }
++
++  for(i=0; i < openmaxStandPort->sPortParam.nBufferCountActual; i++){
++    if (openmaxStandPort->bBufferStateAllocated[i] == BUFFER_FREE) {
++      pBuffer = (OMX_U8*)calloc(1,nSizeBytes);
++      if(pBuffer==NULL) {
++        return OMX_ErrorInsufficientResources;
++      }
++      /*Retry more than once, if the tunneled component is not in Loaded->Idle State*/
++      while(numRetry <TUNNEL_USE_BUFFER_RETRY) {
++        eError=OMX_UseBuffer(openmaxStandPort->hTunneledComponent,&openmaxStandPort->pInternalBufferStorage[i],
++                             openmaxStandPort->nTunneledPort,NULL,nSizeBytes,pBuffer);
++        if (checkHeader(openmaxStandPort->pInternalBufferStorage[i], sizeof(OMX_BUFFERHEADERTYPE)) != OMX_ErrorNone) {
++          DEBUG(DEB_LEV_ERR, "In %s: received wrong buffer header after OMX_UseBuffer\n", __func__);
++          return OMX_ErrorBadParameter;
++        }
++        if(eError!=OMX_ErrorNone) {
++          OMX_STATETYPE state;
++          OMX_GetState( openmaxStandPort->hTunneledComponent, &state );
++          DEBUG(DEB_LEV_FULL_SEQ,"Tunneled Component Couldn't Use buffer %i From Comp=%s Retry=%d Other state=%d\n",
++          i,omx_base_component_Private->name,(int)numRetry, (int)state);
++          /// AND
++          // see 2.1.1 and 3.2 in http://www.khronos.org/registry/omxil/specs/OpenMAX_IL_1_1_2_Application_Note_318.pdf
++          //if((eError ==  OMX_ErrorIncorrectStateTransition) && numRetry<TUNNEL_USE_BUFFER_RETRY) {
++          if(((eError ==  OMX_ErrorIncorrectStateTransition)||(eError ==  OMX_ErrorIncorrectStateOperation)) && numRetry<TUNNEL_USE_BUFFER_RETRY) {
++            /// AND
++            DEBUG(DEB_LEV_FULL_SEQ,"Waiting for next try %i \n",(int)numRetry);
++            usleep(TUNNEL_USE_BUFFER_RETRY_USLEEP_TIME);
++            numRetry++;
++            continue;
++          }
++          free(pBuffer);
++          pBuffer = NULL;
++          return eError;
++        }
++        else {
++          DEBUG(DEB_LEV_FULL_SEQ,"Tunneled Component Used buffer %i From Comp=%s Retry=%d\n",
++          i,omx_base_component_Private->name,(int)numRetry);
++          break;
++        }
++      }
++      if(eError!=OMX_ErrorNone) {
++        free(pBuffer);
++        pBuffer = NULL;
++        DEBUG(DEB_LEV_ERR,"In %s Tunneled Component Couldn't Use Buffer %x \n",__func__,(int)eError);
++        return eError;
++      }
++      openmaxStandPort->bBufferStateAllocated[i] = BUFFER_ALLOCATED;
++      openmaxStandPort->nNumAssignedBuffers++;
++      DEBUG(DEB_LEV_PARAMS, "openmaxStandPort->nNumAssignedBuffers %i\n", (int)openmaxStandPort->nNumAssignedBuffers);
++
++      if (openmaxStandPort->sPortParam.nBufferCountActual == openmaxStandPort->nNumAssignedBuffers) {
++        openmaxStandPort->sPortParam.bPopulated = OMX_TRUE;
++        openmaxStandPort->bIsFullOfBuffers = OMX_TRUE;
++        DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s nPortIndex=%d\n",__func__, (int)nPortIndex);
++      }
++      omx_queue(openmaxStandPort->pBufferQueue, openmaxStandPort->pInternalBufferStorage[i]);
++    }
++  }
++  DEBUG(DEB_LEV_FUNCTION_NAME, "In %s Allocated all buffers\n",__func__);
++  return OMX_ErrorNone;
++}
++
++OMX_ERRORTYPE base_port_FreeTunnelBuffer(omx_base_PortType *openmaxStandPort,OMX_U32 nPortIndex)
++{
++  unsigned int i;
++  OMX_COMPONENTTYPE* omxComponent = openmaxStandPort->standCompContainer;
++  omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)omxComponent->pComponentPrivate;
++  OMX_ERRORTYPE eError=OMX_ErrorNone;
++  OMX_U32 numRetry=0;
++  DEBUG(DEB_LEV_FUNCTION_NAME, "In %s\n", __func__);
++
++  if (nPortIndex != openmaxStandPort->sPortParam.nPortIndex) {
++    DEBUG(DEB_LEV_ERR, "In %s: Bad Port Index\n", __func__);
++    return OMX_ErrorBadPortIndex;
++  }
++  if (! PORT_IS_TUNNELED_N_BUFFER_SUPPLIER(openmaxStandPort)) {
++    DEBUG(DEB_LEV_ERR, "In %s: Port is not tunneled\n", __func__);
++    return OMX_ErrorBadPortIndex;
++  }
++
++  if (omx_base_component_Private->transientState != OMX_TransStateIdleToLoaded) {
++    if (!openmaxStandPort->bIsTransientToDisabled) {
++      DEBUG(DEB_LEV_FULL_SEQ, "In %s: The port is not allowed to free the buffers\n", __func__);
++      (*(omx_base_component_Private->callbacks->EventHandler))
++        (omxComponent,
++        omx_base_component_Private->callbackData,
++        OMX_EventError, /* The command was completed */
++        OMX_ErrorPortUnpopulated, /* The commands was a OMX_CommandStateSet */
++        nPortIndex, /* The state has been changed in message->messageParam2 */
++        NULL);
++    }
++  }
++
++  for(i=0; i < openmaxStandPort->sPortParam.nBufferCountActual; i++){
++    if (openmaxStandPort->bBufferStateAllocated[i] & (BUFFER_ASSIGNED | BUFFER_ALLOCATED)) {
++
++      openmaxStandPort->bIsFullOfBuffers = OMX_FALSE;
++      if (openmaxStandPort->bBufferStateAllocated[i] & BUFFER_ALLOCATED) {
++        free(openmaxStandPort->pInternalBufferStorage[i]->pBuffer);
++        openmaxStandPort->pInternalBufferStorage[i]->pBuffer = NULL;
++      }
++      /*Retry more than once, if the tunneled component is not in Idle->Loaded State*/
++      while(numRetry <TUNNEL_USE_BUFFER_RETRY) {
++        eError=OMX_FreeBuffer(openmaxStandPort->hTunneledComponent,openmaxStandPort->nTunneledPort,openmaxStandPort->pInternalBufferStorage[i]);
++        if(eError!=OMX_ErrorNone) {
++          DEBUG(DEB_LEV_ERR,"Tunneled Component Couldn't free buffer %i \n",i);
++          // see 2.1.2 and 3.1 in http://www.khronos.org/registry/omxil/specs/OpenMAX_IL_1_1_2_Application_Note_318.pdf
++          if((eError ==  OMX_ErrorIncorrectStateTransition) && numRetry<TUNNEL_USE_BUFFER_RETRY) {
++            DEBUG(DEB_LEV_ERR,"Waiting for next try %i \n",(int)numRetry);
++            usleep(TUNNEL_USE_BUFFER_RETRY_USLEEP_TIME);
++            numRetry++;
++            continue;
++          }
++          return eError;
++        } else {
++          break;
++        }
++      }
++      openmaxStandPort->bBufferStateAllocated[i] = BUFFER_FREE;
++
++      openmaxStandPort->nNumAssignedBuffers--;
++      DEBUG(DEB_LEV_PARAMS, "openmaxStandPort->nNumAssignedBuffers %i\n", (int)openmaxStandPort->nNumAssignedBuffers);
++
++      if (openmaxStandPort->nNumAssignedBuffers == 0) {
++        openmaxStandPort->sPortParam.bPopulated = OMX_FALSE;
++        openmaxStandPort->bIsEmptyOfBuffers = OMX_TRUE;
++        //omx_tsem_up(openmaxStandPort->pAllocSem);
++      }
++    }
++  }
++  DEBUG(DEB_LEV_FUNCTION_NAME, "In %s Qelem=%d BSem=%d\n", __func__,openmaxStandPort->pBufferQueue->nelem,openmaxStandPort->pBufferSem->semval);
++  return OMX_ErrorNone;
++}
++
++/** @brief the entry point for sending buffers to the port
++ *
++ * This function can be called by the EmptyThisBuffer or FillThisBuffer. It depends on
++ * the nature of the port, that can be an input or output port.
++ */
++OMX_ERRORTYPE base_port_SendBufferFunction(
++  omx_base_PortType *openmaxStandPort,
++  OMX_BUFFERHEADERTYPE* pBuffer) {
++
++  OMX_ERRORTYPE err;
++  OMX_U32 portIndex;
++  OMX_COMPONENTTYPE* omxComponent = openmaxStandPort->standCompContainer;
++  omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)omxComponent->pComponentPrivate;
++#if NO_GST_OMX_PATCH
++  unsigned int i;
++#endif
++  portIndex = (openmaxStandPort->sPortParam.eDir == OMX_DirInput)?pBuffer->nInputPortIndex:pBuffer->nOutputPortIndex;
++  DEBUG(DEB_LEV_FUNCTION_NAME, "In %s portIndex %lu\n", __func__, (unsigned long)portIndex);
++
++  if (portIndex != openmaxStandPort->sPortParam.nPortIndex) {
++    DEBUG(DEB_LEV_ERR, "In %s: wrong port for this operation portIndex=%d port->portIndex=%d\n", __func__, (int)portIndex, (int)openmaxStandPort->sPortParam.nPortIndex);
++    return OMX_ErrorBadPortIndex;
++  }
++
++  if(omx_base_component_Private->state == OMX_StateInvalid) {
++    DEBUG(DEB_LEV_ERR, "In %s: we are in OMX_StateInvalid\n", __func__);
++    return OMX_ErrorInvalidState;
++  }
++
++  if(omx_base_component_Private->state != OMX_StateExecuting &&
++    omx_base_component_Private->state != OMX_StatePause &&
++    omx_base_component_Private->state != OMX_StateIdle) {
++    DEBUG(DEB_LEV_ERR, "In %s: we are not in executing/paused/idle state, but in %d\n", __func__, omx_base_component_Private->state);
++    return OMX_ErrorIncorrectStateOperation;
++  }
++  if (!PORT_IS_ENABLED(openmaxStandPort) || (PORT_IS_BEING_DISABLED(openmaxStandPort) && !PORT_IS_TUNNELED_N_BUFFER_SUPPLIER(openmaxStandPort)) ||
++      (omx_base_component_Private->transientState == OMX_TransStateExecutingToIdle &&
++      (PORT_IS_TUNNELED(openmaxStandPort) && !PORT_IS_BUFFER_SUPPLIER(openmaxStandPort)))) {
++    DEBUG(DEB_LEV_ERR, "In %s: Port %d is disabled comp = %s \n", __func__, (int)portIndex,omx_base_component_Private->name);
++    return OMX_ErrorIncorrectStateOperation;
++  }
++
++  /* Temporarily disable this check for gst-openmax */
++#if NO_GST_OMX_PATCH
++  {
++  OMX_BOOL foundBuffer = OMX_FALSE;
++  if(pBuffer!=NULL && pBuffer->pBuffer!=NULL) {
++    for(i=0; i < openmaxStandPort->sPortParam.nBufferCountActual; i++){
++    if (pBuffer->pBuffer == openmaxStandPort->pInternalBufferStorage[i]->pBuffer) {
++      foundBuffer = OMX_TRUE;
++      break;
++    }
++    }
++  }
++  if (!foundBuffer) {
++    return OMX_ErrorBadParameter;
++  }
++  }
++#endif
++
++  if ((err = checkHeader(pBuffer, sizeof(OMX_BUFFERHEADERTYPE))) != OMX_ErrorNone) {
++    DEBUG(DEB_LEV_ERR, "In %s: received wrong buffer header on input port\n", __func__);
++    return err;
++  }
++
++  /* And notify the buffer management thread we have a fresh new buffer to manage */
++  if(!PORT_IS_BEING_FLUSHED(openmaxStandPort) && !(PORT_IS_BEING_DISABLED(openmaxStandPort) && PORT_IS_TUNNELED_N_BUFFER_SUPPLIER(openmaxStandPort))){
++    omx_queue(openmaxStandPort->pBufferQueue, pBuffer);
++    omx_tsem_up(openmaxStandPort->pBufferSem);
++    DEBUG(DEB_LEV_PARAMS, "In %s Signalling bMgmtSem Port Index=%d\n",__func__, (int)portIndex);
++    omx_tsem_up(omx_base_component_Private->bMgmtSem);
++  }else if(PORT_IS_BUFFER_SUPPLIER(openmaxStandPort)){
++    DEBUG(DEB_LEV_FULL_SEQ, "In %s: Comp %s received io:%d buffer\n",
++        __func__,omx_base_component_Private->name,(int)openmaxStandPort->sPortParam.nPortIndex);
++    omx_queue(openmaxStandPort->pBufferQueue, pBuffer);
++    omx_tsem_up(openmaxStandPort->pBufferSem);
++  }
++  else { // If port being flushed and not tunneled then return error
++    DEBUG(DEB_LEV_FULL_SEQ, "In %s \n", __func__);
++    return OMX_ErrorIncorrectStateOperation;
++  }
++  return OMX_ErrorNone;
++}
++
++/**
++ * Returns Input/Output Buffer to the IL client or Tunneled Component
++ */
++OMX_ERRORTYPE base_port_ReturnBufferFunction(omx_base_PortType* openmaxStandPort,OMX_BUFFERHEADERTYPE* pBuffer){
++  omx_base_component_PrivateType* omx_base_component_Private=(omx_base_component_PrivateType*)openmaxStandPort->standCompContainer->pComponentPrivate;
++  omx_queue_t* pQueue = openmaxStandPort->pBufferQueue;
++  omx_tsem_t* pSem = openmaxStandPort->pBufferSem;
++  OMX_ERRORTYPE eError = OMX_ErrorNone;
++
++  DEBUG(DEB_LEV_FUNCTION_NAME, "In %s\n", __func__);
++  if (PORT_IS_TUNNELED(openmaxStandPort) &&
++    ! PORT_IS_BUFFER_SUPPLIER(openmaxStandPort)) {
++    if (openmaxStandPort->sPortParam.eDir == OMX_DirInput) {
++      pBuffer->nOutputPortIndex = openmaxStandPort->nTunneledPort;
++      pBuffer->nInputPortIndex = openmaxStandPort->sPortParam.nPortIndex;
++      eError = ((OMX_COMPONENTTYPE*)(openmaxStandPort->hTunneledComponent))->FillThisBuffer(openmaxStandPort->hTunneledComponent, pBuffer);
++      if(eError != OMX_ErrorNone) {
++        DEBUG(DEB_LEV_ERR, "In %s eError %08x in FillThis Buffer from Component %s Non-Supplier\n",
++        __func__, eError,omx_base_component_Private->name);
++      }
++    } else {
++      pBuffer->nInputPortIndex = openmaxStandPort->nTunneledPort;
++      pBuffer->nOutputPortIndex = openmaxStandPort->sPortParam.nPortIndex;
++      eError = ((OMX_COMPONENTTYPE*)(openmaxStandPort->hTunneledComponent))->EmptyThisBuffer(openmaxStandPort->hTunneledComponent, pBuffer);
++      if(eError != OMX_ErrorNone) {
++        DEBUG(DEB_LEV_ERR, "In %s eError %08x in EmptyThis Buffer from Component %s Non-Supplier\n",
++        __func__, eError,omx_base_component_Private->name);
++      }
++    }
++  }
++  else if (PORT_IS_TUNNELED_N_BUFFER_SUPPLIER(openmaxStandPort) &&
++            !PORT_IS_BEING_FLUSHED(openmaxStandPort)) {
++    if (!PORT_IS_ENABLED(openmaxStandPort) || PORT_IS_BEING_DISABLED(openmaxStandPort)) {
++      omx_queue(pQueue, pBuffer);
++      omx_tsem_up(pSem);
++    } else if (openmaxStandPort->sPortParam.eDir == OMX_DirInput) {
++      eError = ((OMX_COMPONENTTYPE*)(openmaxStandPort->hTunneledComponent))->FillThisBuffer(openmaxStandPort->hTunneledComponent, pBuffer);
++      /// AND TODO:
++      /// see 2.2 of http://www.khronos.org/registry/omxil/specs/OpenMAX_IL_1_1_2_Application_Note_318.pdf
++      if(eError != OMX_ErrorNone) {
++        DEBUG(DEB_LEV_FULL_SEQ, "In %s eError %08x in FillThis Buffer from Component %s Supplier\n",
++        __func__, eError,omx_base_component_Private->name);
++        /*If Error Occured then queue the buffer*/
++        omx_queue(pQueue, pBuffer);
++        omx_tsem_up(pSem);
++      }
++    } else {
++      eError = ((OMX_COMPONENTTYPE*)(openmaxStandPort->hTunneledComponent))->EmptyThisBuffer(openmaxStandPort->hTunneledComponent, pBuffer);
++      if(eError != OMX_ErrorNone) {
++        DEBUG(DEB_LEV_FULL_SEQ, "In %s eError %08x in EmptyThis Buffer from Component %s Supplier\n",
++        __func__, eError,omx_base_component_Private->name);
++        /*If Error Occured then queue the buffer*/
++        omx_queue(pQueue, pBuffer);
++        omx_tsem_up(pSem);
++      }
++    }
++  }else if (! PORT_IS_TUNNELED(openmaxStandPort)){
++    (*(openmaxStandPort->BufferProcessedCallback))(
++      openmaxStandPort->standCompContainer,
++      omx_base_component_Private->callbackData,
++      pBuffer);
++  }
++  else {
++    omx_queue(pQueue,pBuffer);
++    openmaxStandPort->nNumBufferFlushed++;
++  }
++
++  return OMX_ErrorNone;
++}
++
++
++OMX_ERRORTYPE base_port_ComponentTunnelRequest(omx_base_PortType* openmaxStandPort,OMX_IN  OMX_HANDLETYPE hTunneledComp,OMX_IN  OMX_U32 nTunneledPort,OMX_INOUT  OMX_TUNNELSETUPTYPE* pTunnelSetup) {
++  OMX_ERRORTYPE err = OMX_ErrorNone;
++  OMX_PARAM_PORTDEFINITIONTYPE param;
++  OMX_PARAM_BUFFERSUPPLIERTYPE pSupplier;
++
++  DEBUG(DEB_LEV_FUNCTION_NAME, "In %s\n", __func__);
++
++  if (pTunnelSetup == NULL || hTunneledComp == 0) {
++    /* cancel previous tunnel */
++    OMX_COMPONENTTYPE* omxComponent = openmaxStandPort->standCompContainer;
++    omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)omxComponent->pComponentPrivate;
++    if (PORT_IS_TUNNELED(openmaxStandPort) && (PORT_IS_BEING_DISABLED(openmaxStandPort) || (omx_base_component_Private->transientState == OMX_TransStateIdleToLoaded)))
++    {
++      DEBUG(DEB_LEV_FUNCTION_NAME, "In %s Scheduled TearDown  port=%d  PORT_IS_BEING_DISABLED(%d)  transientState=%d\n",
++          __func__, openmaxStandPort->sPortParam.nPortIndex, PORT_IS_BEING_DISABLED(openmaxStandPort), omx_base_component_Private->transientState);
++      openmaxStandPort->bTunnelTearDown = OMX_TRUE;
++    }
++    else {
++      openmaxStandPort->hTunneledComponent = 0;
++      openmaxStandPort->nTunneledPort = 0;
++      openmaxStandPort->nTunnelFlags = 0;
++      openmaxStandPort->eBufferSupplier=OMX_BufferSupplyUnspecified;
++    }
++    return OMX_ErrorNone;
++  }
++
++  if (openmaxStandPort->sPortParam.eDir == OMX_DirInput) {
++    /* Get Port Definition of the Tunnelled Component*/
++    param.nPortIndex=nTunneledPort;
++    setHeader(&param, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
++    err = OMX_GetParameter(hTunneledComp, OMX_IndexParamPortDefinition, &param);
++    if (err != OMX_ErrorNone) {
++      DEBUG(DEB_LEV_ERR,"In %s Get Tunneled Port Definition error=0x%08x Line=%d\n",__func__,err,__LINE__);
++      // compatibility not reached
++      return OMX_ErrorPortsNotCompatible;
++    }
++
++    // Negotiate buffer params
++    param.nBufferCountActual = param.nBufferCountMin > openmaxStandPort->sPortParam.nBufferCountMin ?
++      param.nBufferCountMin : openmaxStandPort->sPortParam.nBufferCountMin;
++    openmaxStandPort->sPortParam.nBufferCountActual = param.nBufferCountActual;
++
++    param.nBufferSize = param.nBufferSize > openmaxStandPort->sPortParam.nBufferSize ?
++      param.nBufferSize : openmaxStandPort->sPortParam.nBufferSize;
++    openmaxStandPort->sPortParam.nBufferSize = param.nBufferSize;
++
++    err = OMX_SetParameter(hTunneledComp, OMX_IndexParamPortDefinition, &param);
++    if (err != OMX_ErrorNone) {
++      DEBUG(DEB_LEV_ERR,"In %s Set Tunneled Port Definition error=0x%08x Line=%d\n",__func__,err,__LINE__);
++      return OMX_ErrorPortsNotCompatible;
++    }
++
++    openmaxStandPort->nNumTunnelBuffer=param.nBufferCountActual; //nBufferCountMin;
++
++    if(param.eDomain!=openmaxStandPort->sPortParam.eDomain) {
++      return OMX_ErrorPortsNotCompatible;
++    }
++    if(param.eDomain==OMX_PortDomainAudio) {
++      if(param.format.audio.eEncoding == OMX_AUDIO_CodingMax) {
++        return OMX_ErrorPortsNotCompatible;
++      }
++    } else if(param.eDomain==OMX_PortDomainVideo) {
++      if(param.format.video.eCompressionFormat == OMX_VIDEO_CodingMax) {
++        return OMX_ErrorPortsNotCompatible;
++      }
++    } else if(param.eDomain==OMX_PortDomainOther) {
++      if(param.format.other.eFormat == OMX_OTHER_FormatMax) {
++        return OMX_ErrorPortsNotCompatible;
++      }
++    }
++
++    /* Get Buffer Supplier type of the Tunnelled Component*/
++    pSupplier.nPortIndex=nTunneledPort;
++    setHeader(&pSupplier, sizeof(OMX_PARAM_BUFFERSUPPLIERTYPE));
++    err = OMX_GetParameter(hTunneledComp, OMX_IndexParamCompBufferSupplier, &pSupplier);
++    if (err != OMX_ErrorNone) {
++      // compatibility not reached
++      DEBUG(DEB_LEV_ERR,"In %s Tunneled Buffer Supplier error=0x%08x Line=%d\n",__func__,err,__LINE__);
++      return OMX_ErrorPortsNotCompatible;
++    } else {
++      DEBUG(DEB_LEV_FULL_SEQ,"Tunneled Port eBufferSupplier=%x\n",pSupplier.eBufferSupplier);
++    }
++
++    // store the current callbacks, if defined
++    openmaxStandPort->hTunneledComponent = hTunneledComp;
++    openmaxStandPort->nTunneledPort = nTunneledPort;
++
++    /*Check for and set proprietary communication flag.
++      In case a component support Deep Tunneling should set it's tunnel flag to PROPRIETARY_COMMUNICATION_ESTABLISHED */
++    /// AND: No proprietary communication
++    /*
++    if(PORT_IS_DEEP_TUNNELED(openmaxStandPort)) {
++      OMX_VENDOR_PROP_TUNNELSETUPTYPE pPropTunnelSetup;
++      pPropTunnelSetup.nPortIndex = nTunneledPort;
++
++      err = OMX_GetParameter(hTunneledComp, OMX_IndexVendorCompPropTunnelFlags, &pPropTunnelSetup);
++      if (err != OMX_ErrorNone) {
++        // compatibility not reached
++        DEBUG(DEB_LEV_ERR,"In %s Proprietary Tunneled Buffer Supplier nTunneledPort=%d error=0x%08x Line=%d \n",
++          __func__,(int)pPropTunnelSetup.nPortIndex,err,__LINE__);
++        openmaxStandPort->nTunnelFlags = 0;
++      } else {
++        openmaxStandPort->nTunnelFlags = PROPRIETARY_COMMUNICATION_ESTABLISHED;
++      }
++    } else {
++      openmaxStandPort->nTunnelFlags = 0;
++    }
++    */
++    openmaxStandPort->nTunnelFlags = 0;
++    /// AND
++
++    // Negotiation
++    if (pTunnelSetup->nTunnelFlags & OMX_PORTTUNNELFLAG_READONLY) {
++      // the buffer provider MUST be the output port provider
++      /// AND: WRONG!!!!
++      /*
++      pTunnelSetup->eSupplier = OMX_BufferSupplyInput;
++      openmaxStandPort->nTunnelFlags |= TUNNEL_IS_SUPPLIER;
++      openmaxStandPort->eBufferSupplier=OMX_BufferSupplyInput;
++      */
++      DEBUG(DEB_LEV_ERR,"In %s --------------> OMX_PORTTUNNELFLAG_READONLY Line=%d\n",__func__,__LINE__);
++      pTunnelSetup->eSupplier = OMX_BufferSupplyOutput;
++      openmaxStandPort->eBufferSupplier=OMX_BufferSupplyOutput;
++      /// AND
++    } else {
++      //if (pTunnelSetup->eSupplier == OMX_BufferSupplyInput) {
++      //  DEBUG(DEB_LEV_ERR,"In %s --------------> OMX_BufferSupplyInput Line=%d\n",__func__,__LINE__);
++      //  openmaxStandPort->nTunnelFlags |= TUNNEL_IS_SUPPLIER;
++      //  openmaxStandPort->eBufferSupplier=OMX_BufferSupplyInput;
++      //} else if (pTunnelSetup->eSupplier == OMX_BufferSupplyUnspecified) {
++      //  /// AND TODO: Can be reversed????
++      //  DEBUG(DEB_LEV_ERR,"In %s --------------> OMX_BufferSupplyUnspecified Line=%d\n",__func__,__LINE__);
++      //  pTunnelSetup->eSupplier = OMX_BufferSupplyInput;
++      //  openmaxStandPort->nTunnelFlags |= TUNNEL_IS_SUPPLIER;
++      //  openmaxStandPort->eBufferSupplier=OMX_BufferSupplyInput;
++      //  //pTunnelSetup->eSupplier = OMX_BufferSupplyOutput;
++      //  //openmaxStandPort->eBufferSupplier=OMX_BufferSupplyOutput;
++      //  /// AND
++      //} else if (pTunnelSetup->eSupplier == OMX_BufferSupplyOutput){
++      //  DEBUG(DEB_LEV_ERR,"In %s --------------> OMX_BufferSupplyOutput Line=%d\n",__func__,__LINE__);
++      //  pTunnelSetup->eSupplier = OMX_BufferSupplyOutput;
++      //  openmaxStandPort->eBufferSupplier=OMX_BufferSupplyOutput;
++      //} else {
++      //  DEBUG(DEB_LEV_ERR,"In %s --------------> undefined pTunnelSetup->eSupplier = %d Line=%d\n",__func__,(int)pTunnelSetup->eSupplier,__LINE__);
++      //}
++
++      // fixed to work only in this direction
++      DEBUG(DEB_LEV_ERR,"In %s --------------> OMX_BufferSupply Line=%d\n",__func__,__LINE__);
++      pTunnelSetup->eSupplier = OMX_BufferSupplyInput;
++      openmaxStandPort->nTunnelFlags |= TUNNEL_IS_SUPPLIER;
++      openmaxStandPort->eBufferSupplier=OMX_BufferSupplyInput;
++      /// AND
++
++    }
++    openmaxStandPort->nTunnelFlags |= TUNNEL_ESTABLISHED;
++
++    /* Set Buffer Supplier type of the Tunnelled Component after final negotiation*/
++    pSupplier.nPortIndex=nTunneledPort;
++    pSupplier.eBufferSupplier=openmaxStandPort->eBufferSupplier;
++    err = OMX_SetParameter(hTunneledComp, OMX_IndexParamCompBufferSupplier, &pSupplier);
++    if (err != OMX_ErrorNone) {
++      // compatibility not reached
++      DEBUG(DEB_LEV_ERR,"In %s Tunneled Buffer Supplier error=0x%08x Line=%d\n",__func__,err,__LINE__);
++      openmaxStandPort->nTunnelFlags=0;
++      return OMX_ErrorPortsNotCompatible;
++    }
++  } else {
++    // output port
++    // all the consistency checks are under other component responsibility
++
++    /* Get Port Definition of the Tunnelled Component*/
++    param.nPortIndex=nTunneledPort;
++    setHeader(&param, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
++    err = OMX_GetParameter(hTunneledComp, OMX_IndexParamPortDefinition, &param);
++    if (err != OMX_ErrorNone) {
++      DEBUG(DEB_LEV_ERR,"In %s Tunneled Port Definition error=0x%08x Line=%d\n",__func__,err,__LINE__);
++      // compatibility not reached
++      return OMX_ErrorPortsNotCompatible;
++    }
++    if(param.eDomain!=openmaxStandPort->sPortParam.eDomain) {
++      return OMX_ErrorPortsNotCompatible;
++    }
++
++    if(param.eDomain==OMX_PortDomainAudio) {
++      if(param.format.audio.eEncoding == OMX_AUDIO_CodingMax) {
++        return OMX_ErrorPortsNotCompatible;
++      }
++    } else if(param.eDomain==OMX_PortDomainVideo) {
++      if(param.format.video.eCompressionFormat == OMX_VIDEO_CodingMax) {
++        return OMX_ErrorPortsNotCompatible;
++      }
++    } else if(param.eDomain==OMX_PortDomainOther) {
++      if(param.format.other.eFormat == OMX_OTHER_FormatMax) {
++        return OMX_ErrorPortsNotCompatible;
++      }
++    }
++
++    /*Check for and set proprietary communication flag*/
++    if(PORT_IS_DEEP_TUNNELED(openmaxStandPort)) {
++      OMX_VENDOR_PROP_TUNNELSETUPTYPE pPropTunnelSetup;
++      pPropTunnelSetup.nPortIndex = nTunneledPort;
++
++      err = OMX_GetParameter(hTunneledComp, (OMX_INDEXTYPE)OMX_IndexVendorCompPropTunnelFlags, &pPropTunnelSetup);
++      if (err != OMX_ErrorNone) {
++        // compatibility not reached
++        DEBUG(DEB_LEV_ERR,"In %s Proprietary Tunneled Buffer Supplier nTunneledPort=%d error=0x%08x Line=%d \n",
++          __func__,(int)pPropTunnelSetup.nPortIndex,err,__LINE__);
++        openmaxStandPort->nTunnelFlags = 0;
++      } else {
++        openmaxStandPort->nTunnelFlags = PROPRIETARY_COMMUNICATION_ESTABLISHED;
++      }
++    } else {
++      openmaxStandPort->nTunnelFlags = 0;
++    }
++
++    openmaxStandPort->nNumTunnelBuffer=param.nBufferCountMin;
++
++    openmaxStandPort->hTunneledComponent = hTunneledComp;
++    openmaxStandPort->nTunneledPort = nTunneledPort;
++    pTunnelSetup->eSupplier = OMX_BufferSupplyOutput;
++    openmaxStandPort->nTunnelFlags |= TUNNEL_IS_SUPPLIER;
++    openmaxStandPort->nTunnelFlags |= TUNNEL_ESTABLISHED;
++
++    openmaxStandPort->eBufferSupplier=OMX_BufferSupplyOutput;
++  }
++
++  return OMX_ErrorNone;
++}
+diff --git a/alsa/omx_base_port.h b/alsa/omx_base_port.h
+new file mode 100644
+index 0000000..3159b92
+--- /dev/null
++++ b/alsa/omx_base_port.h
+@@ -0,0 +1,288 @@
++/**
++  @file src/base/omx_base_port.h
++
++  Base class for OpenMAX ports to be used in derived components.
++
++  Copyright (C) 2007-2008 STMicroelectronics
++  Copyright (C) 2007-2008 Nokia Corporation and/or its subsidiary(-ies).
++
++  This library 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.
++
++  This library 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 this library; if not, write to the Free Software Foundation, Inc.,
++  51 Franklin St, Fifth Floor, Boston, MA
++  02110-1301  USA
++
++  $Date: 2008-08-08 06:56:06 +0200 (Fri, 08 Aug 2008) $
++  Revision $Rev: 581 $
++  Author $Author: pankaj_sen $
++
++*/
++
++#include "omx_comp_debug_levels.h"
++
++#include "omx_semaphore.h"
++#include "omx_queue.h"
++#include "omx_classmagic.h"
++#pragma pack(4)
++//#include <IL/OMX_Types.h>
++#include <IL/OMX_Core.h>
++#include <IL/OMX_Component.h>
++#include <IL/OMX_Audio.h>
++#pragma pack()
++
++#define OMX_ErrorIncorrectStateTransition OMX_ErrorIncorrectStateOperation
++
++#ifndef __OMX_BASE_PORT_H__
++#define __OMX_BASE_PORT_H__
++
++#define TUNNEL_USE_BUFFER_RETRY 20
++#define TUNNEL_USE_BUFFER_RETRY_USLEEP_TIME 5000
++#define NO_GST_OMX_PATCH 1
++
++/**
++ * Port Specific Macro's
++ */
++#define PORT_IS_BEING_FLUSHED(pPort)                             (pPort->bIsPortFlushed == OMX_TRUE)
++#define PORT_IS_BEING_DISABLED(pPort)                            (pPort->bIsTransientToDisabled == OMX_TRUE)
++#define PORT_IS_ENABLED(pPort)                                   (pPort->sPortParam.bEnabled == OMX_TRUE)
++#define PORT_IS_POPULATED(pPort)                                 (pPort->sPortParam.bPopulated == OMX_TRUE)
++#define PORT_IS_TUNNELED(pPort)                                  (pPort->nTunnelFlags & TUNNEL_ESTABLISHED)
++#define PORT_IS_DEEP_TUNNELED(pPort)                             (pPort->nTunnelFlags & PROPRIETARY_COMMUNICATION_ESTABLISHED)
++#define PORT_IS_BUFFER_SUPPLIER(pPort)                           (pPort->nTunnelFlags & TUNNEL_IS_SUPPLIER)
++#define PORT_IS_TUNNELED_N_BUFFER_SUPPLIER(pPort)                ((pPort->nTunnelFlags & TUNNEL_ESTABLISHED) && (pPort->nTunnelFlags & TUNNEL_IS_SUPPLIER))
++
++/** The following enum values are used to characterize each buffer
++  * allocated or assigned to the component. A buffer list is
++  * created for each port of the component. The buffer can be assigned
++  * to the port, or owned by the port. The buffer flag are applied for each buffer
++  * in each port buffer list. The following use cases are currently implemented:
++  * - When the IL Client asks the component to allocate a buffer
++  *   for a given port, with the call to AllocateBuffer, the
++  *   buffer created is characterizeed by the flag BUFFER_ALLOCATED
++  * - When the IL Client asks the component to use a buffer allocated
++  *   by the client itself, the buffer flag is BUFFER_ASSIGNED
++  * - When the component is tunneled by another component, and the first
++  *   is supplier of the buffer, the buffer is marked with the
++  *   BUFFER_ALLOCATED flag.
++  * - When the component is tunneled by another component, and the second
++  *   is supplier of the buffer, the buffer is marked with the
++  *   BUFFER_ASSIGNED flag.
++  * - The case of a buffer supplied by the first component but allocated by another
++  *   component or another port inside the same component, as in the case
++  *   of shared buffers, is not yet implemented in these components
++  * - During hte deallocation phase each buffer is marked with the BUFFER_FREE
++  *   flag, so that the component can check if all the buffers have been deallocated
++  *   before switch the component state to Loaded, as specified by
++  *   the OpenMAX specs
++  */
++typedef unsigned int BUFFER_STATUS_FLAG;
++
++#define BUFFER_FREE		0
++#define BUFFER_ALLOCATED	0x0001	/**< This flag is applied to a buffer when it is allocated
++			                 by the given port of the component */
++#define BUFFER_ASSIGNED		0x0002	/**< This flag is applied to a buffer when it is assigned
++					 from another port or by the IL client */
++#define HEADER_ALLOCATED	0x0004	/**< This flag is applied to a buffer when buffer header is allocated
++ 					 by the given port of the component */
++
++/** @brief the status of a port related to the tunneling with another component
++ */
++typedef unsigned int TUNNEL_STATUS_FLAG;
++#define NO_TUNNEL		0 /**< No tunnel established */
++#define TUNNEL_ESTABLISHED	0x0001 /**< the TUNNEL_ESTABLISHED specifies if a port is tunneled.
++                              		* It is assigned to a private field of the port if it is tunneled
++                              		*/
++#define TUNNEL_IS_SUPPLIER	0x0002 /**< the TUNNEL_IS_SUPPLIER specifies if a tunneled port is the supplier.
++					* It is assigned to a private field of the port if it is tunneled and also it is the buffer supplier for the tunnel.
++					*/
++#define PROPRIETARY_COMMUNICATION_ESTABLISHED 0x0004 /** The tunnel established is created between two components of the same
++                                                  * vendor. These components can take advantage from a vendor specific
++                                                  * communication
++                                                  */
++
++/**
++ * @brief the base structure that describes each port.
++ *
++ * The data structure that describes a port contains the basic elements used in the
++ * base component. Other elements can be added in the derived components structures.
++ */
++CLASS(omx_base_PortType)
++#define omx_base_PortType_FIELDS \
++  OMX_HANDLETYPE hTunneledComponent; /**< @param hTunneledComponent Handle to the tunnelled component */\
++  OMX_U32 nTunnelFlags; /**< This field contains one or more tags that describe the tunnel status of the port */\
++  OMX_U32 nTunneledPort; /**< @param nTunneledPort Tunneled port number */ \
++  OMX_BOOL bTunnelTearDown; /**< @param nTunneledPort Helper for assinc TearDown */ \
++  OMX_BUFFERSUPPLIERTYPE eBufferSupplier; /**< @param eBufferSupplier the type of supplier in case of tunneling */\
++  OMX_U32 nNumTunnelBuffer; /**< @param nNumTunnelBuffer Number of buffer to be tunnelled */\
++  omx_tsem_t* pAllocSem; /**< @param pFlushSem Semaphore that locks the execution until the buffers have been flushed, if needed */ \
++  OMX_U32 nNumBufferFlushed; /**< @param nNumBufferFlushed Number of buffer Flushed */\
++  OMX_BOOL bIsPortFlushed;/**< @param bIsPortFlushed Boolean variables indicate port is being flushed at the moment */ \
++  omx_queue_t* pBufferQueue; /**< @param pBufferQueue queue for buffer to be processed by the port */\
++  omx_tsem_t* pBufferSem; /**< @param pBufferSem Semaphore for buffer queue access synchronization */\
++  OMX_U32 nNumAssignedBuffers; /**< @param nNumAssignedBuffers Number of buffer assigned on each port */\
++  OMX_PARAM_PORTDEFINITIONTYPE sPortParam; /**< @param sPortParam General OpenMAX port parameter */\
++  OMX_BUFFERHEADERTYPE **pInternalBufferStorage; /**< This array contains the reference to all the buffers hadled by this port and already registered*/\
++  BUFFER_STATUS_FLAG *bBufferStateAllocated; /**< @param bBufferStateAllocated The State of the Buffer whether assigned or allocated */\
++  OMX_COMPONENTTYPE *standCompContainer;/**< The OpenMAX component reference that contains this port */\
++  OMX_BOOL bIsTransientToEnabled;/**< It indicates that the port is going from disabled to enabled */ \
++  OMX_BOOL bIsTransientToDisabled;/**< It indicates that the port is going from enabled to disabled */ \
++  OMX_BOOL bIsFullOfBuffers; /**< It indicates if the port has all the buffers needed */ \
++  OMX_BOOL bIsEmptyOfBuffers;/**< It indicates if the port has no buffers*/ \
++  OMX_ERRORTYPE (*PortConstructor)(OMX_COMPONENTTYPE *openmaxStandComp,omx_base_PortType **openmaxStandPort,OMX_U32 nPortIndex, OMX_BOOL isInput); /**< The contructor of the port. It fills all the other function pointers */ \
++  OMX_ERRORTYPE (*PortDestructor)(omx_base_PortType *openmaxStandPort); /**< The destructor of the port*/ \
++  OMX_ERRORTYPE (*Port_DisablePort)(omx_base_PortType *openmaxStandPort); /**< Disables the port */ \
++  OMX_ERRORTYPE (*Port_EnablePort)(omx_base_PortType *openmaxStandPort); /**< Enables the port */ \
++  OMX_ERRORTYPE (*Port_SendBufferFunction)(omx_base_PortType *openmaxStandPort, OMX_BUFFERHEADERTYPE* pBuffer);  /**< Holds the EmptyThisBuffer of FillThisBuffer function, if the port is input or output */ \
++  OMX_ERRORTYPE (*Port_AllocateBuffer)(omx_base_PortType *openmaxStandPort,OMX_INOUT OMX_BUFFERHEADERTYPE** pBuffer,OMX_IN OMX_U32 nPortIndex,OMX_IN OMX_PTR pAppPrivate,OMX_IN OMX_U32 nSizeBytes);/**< Replaces the AllocateBuffer call for the base port. */   \
++  OMX_ERRORTYPE (*Port_UseBuffer)(omx_base_PortType *openmaxStandPort,OMX_BUFFERHEADERTYPE** ppBufferHdr,OMX_U32 nPortIndex,OMX_PTR pAppPrivate,OMX_U32 nSizeBytes,OMX_U8* pBuffer);/**< The standard use buffer function applied to the port class */ \
++  OMX_ERRORTYPE (*Port_FreeBuffer)(omx_base_PortType *openmaxStandPort,OMX_U32 nPortIndex,OMX_BUFFERHEADERTYPE* pBuffer); /**< The standard free buffer function applied to the port class */ \
++  OMX_ERRORTYPE (*Port_AllocateTunnelBuffer)(omx_base_PortType *openmaxStandPort,OMX_IN OMX_U32 nPortIndex,OMX_IN OMX_U32 nSizeBytes);/**< AllocateTunnelBuffer call for the base port. */   \
++  OMX_ERRORTYPE (*Port_FreeTunnelBuffer)(omx_base_PortType *openmaxStandPort,OMX_U32 nPortIndex); /**< The free buffer function used to free tunnelled buffers */ \
++  OMX_ERRORTYPE (*BufferProcessedCallback)(OMX_HANDLETYPE hComponent, OMX_PTR pAppData, OMX_BUFFERHEADERTYPE* pBuffer);/**< Holds the EmptyBufferDone or FillBufferDone callback, if the port is input or output port */ \
++  OMX_ERRORTYPE (*FlushProcessingBuffers)(omx_base_PortType *openmaxStandPort); /**< release all the buffers currently under processing */ \
++  OMX_ERRORTYPE (*ReturnBufferFunction)(omx_base_PortType* openmaxStandPort,OMX_BUFFERHEADERTYPE* pBuffer); /**< Call appropriate function to return buffers to peer or IL Client*/ \
++  OMX_ERRORTYPE (*ComponentTunnelRequest)(omx_base_PortType* openmaxStandPort,OMX_IN  OMX_HANDLETYPE hTunneledComp,OMX_IN  OMX_U32 nTunneledPort,OMX_INOUT  OMX_TUNNELSETUPTYPE* pTunnelSetup); /**< Setup tunnel with the port */
++ENDCLASS(omx_base_PortType)
++
++/**
++ * @brief The base contructor for the generic OpenMAX ST port
++ *
++ * This function is executed by the component that uses a port.
++ * The parameter contains the info about the component.
++ * It takes care of constructing the instance of the port and
++ * every object needed by the base port.
++ *
++ * @param openmaxStandPort the ST port to be initialized
++ *
++ * @return OMX_ErrorInsufficientResources if a memory allocation fails
++ */
++OMX_ERRORTYPE base_port_Constructor(OMX_COMPONENTTYPE *openmaxStandComp,omx_base_PortType **openmaxStandPort,OMX_U32 nPortIndex, OMX_BOOL isInput);
++
++/** @brief The base destructor for the generic OpenMAX ST port
++ *
++ * This function is executed by the component that uses a port.
++ * The parameter contains the info about the component.
++ * It takes care of destructing the instance of the port and
++ * every object used by the base port.
++ *
++ * @param openmaxStandPort the ST port to be disposed
++  */
++OMX_ERRORTYPE base_port_Destructor(omx_base_PortType *openmaxStandPort);
++
++/** @brief Disables the port.
++ *
++ * This function is called due to a request by the IL client
++ *
++ * @param openmaxStandPort the reference to the port
++ *
++ */
++OMX_ERRORTYPE base_port_DisablePort(omx_base_PortType *openmaxStandPort);
++
++/** @brief Enables the port.
++ *
++ * This function is called due to a request by the IL client
++ *
++ * @param openmaxStandPort the reference to the port
++ *
++ */
++OMX_ERRORTYPE base_port_EnablePort(omx_base_PortType *openmaxStandPort);
++
++/** @brief The entry point for sending buffers to the port
++ *
++ * This function can be called by the EmptyThisBuffer or FillThisBuffer. It depends on
++ * the nature of the port, that can be an input or output port.
++ */
++OMX_ERRORTYPE base_port_SendBufferFunction(
++  omx_base_PortType *openmaxStandPort,
++  OMX_BUFFERHEADERTYPE* pBuffer);
++
++/** @brief Called by the standard allocate buffer, it implements a base functionality.
++ *
++ * This function can be overriden if the allocation of the buffer is not a simply malloc call.
++ * The parameters are the same as the standard function, except for the handle of the port
++ * instead of the handler of the component
++ * When the buffers needed by this port are all assigned or allocated, the variable
++ * bIsFullOfBuffers becomes equal to OMX_TRUE
++ */
++OMX_ERRORTYPE base_port_AllocateBuffer(
++  omx_base_PortType *openmaxStandPort,
++  OMX_BUFFERHEADERTYPE** pBuffer,
++  OMX_U32 nPortIndex,
++  OMX_PTR pAppPrivate,
++  OMX_U32 nSizeBytes);
++
++/** @brief Called by the standard use buffer, it implements a base functionality.
++ *
++ * This function can be overriden if the use buffer implicate more complicated operations.
++ * The parameters are the same as the standard function, except for the handle of the port
++ * instead of the handler of the component
++ * When the buffers needed by this port are all assigned or allocated, the variable
++ * bIsFullOfBuffers becomes equal to OMX_TRUE
++ */
++OMX_ERRORTYPE base_port_UseBuffer(
++  omx_base_PortType *openmaxStandPort,
++  OMX_BUFFERHEADERTYPE** ppBufferHdr,
++  OMX_U32 nPortIndex,
++  OMX_PTR pAppPrivate,
++  OMX_U32 nSizeBytes,
++  OMX_U8* pBuffer);
++
++/** @brief Called by the standard function.
++ *
++ * It frees the buffer header and in case also the buffer itself, if needed.
++ * When all the bufers are done, the variable bIsEmptyOfBuffers is set to OMX_TRUE
++ */
++OMX_ERRORTYPE base_port_FreeBuffer(
++  omx_base_PortType *openmaxStandPort,
++  OMX_U32 nPortIndex,
++  OMX_BUFFERHEADERTYPE* pBuffer);
++
++/** @brief Releases buffers under processing.
++ *
++ * This function must be implemented in the derived classes, for the
++ * specific processing
++ */
++OMX_ERRORTYPE base_port_FlushProcessingBuffers(omx_base_PortType *openmaxStandPort);
++
++/** @brief Returns buffers when processed.
++ *
++ * Call appropriate function to return buffers to peer or IL Client
++ */
++
++OMX_ERRORTYPE base_port_ReturnBufferFunction(
++  omx_base_PortType* openmaxStandPort,
++  OMX_BUFFERHEADERTYPE* pBuffer);
++
++/** @brief Setup Tunnel with the port
++ */
++
++OMX_ERRORTYPE base_port_ComponentTunnelRequest(
++  omx_base_PortType* openmaxStandPort,
++  OMX_IN  OMX_HANDLETYPE hTunneledComp,
++  OMX_IN  OMX_U32 nTunneledPort,
++  OMX_INOUT  OMX_TUNNELSETUPTYPE* pTunnelSetup);
++
++/** @brief Allocate Buffers for tunneling use
++ */
++OMX_ERRORTYPE base_port_AllocateTunnelBuffer(
++  omx_base_PortType *openmaxStandPort,
++  OMX_IN OMX_U32 nPortIndex,
++  OMX_IN OMX_U32 nSizeBytes);
++
++/** @brief Free buffers used in tunnel
++ */
++OMX_ERRORTYPE base_port_FreeTunnelBuffer(
++  omx_base_PortType *openmaxStandPort,
++  OMX_U32 nPortIndex);
++
++
++#endif
+diff --git a/alsa/omx_base_sink.cpp b/alsa/omx_base_sink.cpp
+new file mode 100644
+index 0000000..ae8b3e3
+--- /dev/null
++++ b/alsa/omx_base_sink.cpp
+@@ -0,0 +1,189 @@
++/**
++  @file src/base/omx_base_sink.c
++
++  OpenMAX base sink component. This component does not perform any multimedia
++  processing. It derives from base component and contains a single input port.
++  It can be used as base class for sink components.
++
++  Copyright (C) 2007-2008 STMicroelectronics
++  Copyright (C) 2007-2008 Nokia Corporation and/or its subsidiary(-ies).
++
++  This library 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.
++
++  This library 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 this library; if not, write to the Free Software Foundation, Inc.,
++  51 Franklin St, Fifth Floor, Boston, MA
++  02110-1301  USA
++
++  $Date: 2008-09-12 08:12:11 +0200 (Fri, 12 Sep 2008) $
++  Revision $Rev: 615 $
++  Author $Author: pankaj_sen $
++*/
++
++#include <omx_base_sink.h>
++
++OMX_ERRORTYPE omx_base_sink_Constructor(OMX_COMPONENTTYPE *openmaxStandComp,OMX_STRING cComponentName) {
++  OMX_ERRORTYPE err = OMX_ErrorNone;
++  omx_base_sink_PrivateType* omx_base_sink_Private;
++
++  if (openmaxStandComp->pComponentPrivate) {
++    omx_base_sink_Private = (omx_base_sink_PrivateType*)openmaxStandComp->pComponentPrivate;
++  } else {
++    omx_base_sink_Private = (omx_base_sink_PrivateType*)calloc(1,sizeof(omx_base_sink_PrivateType));
++    if (!omx_base_sink_Private) {
++      return OMX_ErrorInsufficientResources;
++    }
++  }
++
++  // we could create our own port structures here
++  // fixme maybe the base class could use a "port factory" function pointer?
++  err = omx_base_component_Constructor(openmaxStandComp,cComponentName);
++
++  /* here we can override whatever defaults the base_component constructor set
++  * e.g. we can override the function pointers in the private struct  */
++  omx_base_sink_Private = (omx_base_sink_PrivateType*)openmaxStandComp->pComponentPrivate;
++
++  omx_base_sink_Private->BufferMgmtFunction = omx_base_sink_BufferMgmtFunction;
++
++  return err;
++}
++
++OMX_ERRORTYPE omx_base_sink_Destructor(OMX_COMPONENTTYPE *openmaxStandComp)
++{
++  return omx_base_component_Destructor(openmaxStandComp);
++}
++
++/** This is the central function for component processing. It
++  * is executed in a separate thread, is synchronized with
++  * semaphores at each port, those are released each time a new buffer
++  * is available on the given port.
++  */
++void* omx_base_sink_BufferMgmtFunction (void* param) {
++  OMX_COMPONENTTYPE* openmaxStandComp = (OMX_COMPONENTTYPE*)param;
++  omx_base_component_PrivateType* omx_base_component_Private  = (omx_base_component_PrivateType*)openmaxStandComp->pComponentPrivate;
++  omx_base_sink_PrivateType*      omx_base_sink_Private       = (omx_base_sink_PrivateType*)omx_base_component_Private;
++  omx_base_PortType               *pInPort                    = (omx_base_PortType *)omx_base_sink_Private->ports[OMX_BASE_SINK_INPUTPORT_INDEX];
++  omx_tsem_t*                         pInputSem                   = pInPort->pBufferSem;
++  omx_queue_t*                        pInputQueue                 = pInPort->pBufferQueue;
++  OMX_BUFFERHEADERTYPE*           pInputBuffer                = NULL;
++  OMX_COMPONENTTYPE*              target_component;
++  OMX_BOOL                        isInputBufferNeeded         = OMX_TRUE;
++  int                             inBufExchanged              = 0;
++
++  DEBUG(DEB_LEV_FUNCTION_NAME, "In %s \n", __func__);
++  while(omx_base_component_Private->state == OMX_StateIdle ||
++        omx_base_component_Private->state == OMX_StateExecuting ||
++        omx_base_component_Private->state == OMX_StatePause ||
++        omx_base_component_Private->transientState == OMX_TransStateLoadedToIdle){
++
++    /*Wait till the ports are being flushed*/
++    pthread_mutex_lock(&omx_base_sink_Private->flush_mutex);
++    while( PORT_IS_BEING_FLUSHED(pInPort)) {
++      pthread_mutex_unlock(&omx_base_sink_Private->flush_mutex);
++
++      if(isInputBufferNeeded==OMX_FALSE) {
++        pInPort->ReturnBufferFunction(pInPort,pInputBuffer);
++        inBufExchanged--;
++        pInputBuffer=NULL;
++        isInputBufferNeeded=OMX_TRUE;
++        DEBUG(DEB_LEV_FULL_SEQ, "Ports are flushing,so returning input buffer\n");
++      }
++      DEBUG(DEB_LEV_FULL_SEQ, "In %s signalling flush all condition \n", __func__);
++
++      omx_tsem_up(omx_base_sink_Private->flush_all_condition);
++      omx_tsem_down(omx_base_sink_Private->flush_condition);
++      pthread_mutex_lock(&omx_base_sink_Private->flush_mutex);
++    }
++    pthread_mutex_unlock(&omx_base_sink_Private->flush_mutex);
++
++    /*No buffer to process. So wait here*/
++    if((pInputSem->semval==0 && isInputBufferNeeded==OMX_TRUE ) &&
++      (omx_base_sink_Private->state != OMX_StateLoaded && omx_base_sink_Private->state != OMX_StateInvalid)) {
++      DEBUG(DEB_LEV_SIMPLE_SEQ, "Waiting for input buffer \n");
++      omx_tsem_down(omx_base_sink_Private->bMgmtSem);
++    }
++
++    if(omx_base_sink_Private->state == OMX_StateLoaded || omx_base_sink_Private->state == OMX_StateInvalid) {
++      DEBUG(DEB_LEV_FULL_SEQ, "In %s Buffer Management Thread is exiting\n",__func__);
++      break;
++    }
++
++    DEBUG(DEB_LEV_SIMPLE_SEQ, "Waiting for input buffer semval=%d \n",pInputSem->semval);
++    if(pInputSem->semval>0 && isInputBufferNeeded==OMX_TRUE ) {
++      omx_tsem_down(pInputSem);
++      if(pInputQueue->nelem>0){
++        inBufExchanged++;
++        isInputBufferNeeded=OMX_FALSE;
++        pInputBuffer = (OMX_BUFFERHEADERTYPE*)omx_dequeue(pInputQueue);
++        if(pInputBuffer == NULL){
++          DEBUG(DEB_LEV_ERR, "Had NULL input buffer!!\n");
++          break;
++        }
++      }
++    }
++
++    if(isInputBufferNeeded==OMX_FALSE) {
++      if(pInputBuffer->nFlags==OMX_BUFFERFLAG_EOS) {
++        DEBUG(DEB_LEV_SIMPLE_SEQ, "Detected EOS flags in input buffer\n");
++
++        (*(omx_base_component_Private->callbacks->EventHandler))
++          (openmaxStandComp,
++          omx_base_component_Private->callbackData,
++          OMX_EventBufferFlag, /* The command was completed */
++          0, /* The commands was a OMX_CommandStateSet */
++          pInputBuffer->nFlags, /* The state has been changed in message->messageParam2 */
++          NULL);
++        pInputBuffer->nFlags=0;
++      }
++
++      target_component=(OMX_COMPONENTTYPE*)pInputBuffer->hMarkTargetComponent;
++      if(target_component==(OMX_COMPONENTTYPE *)openmaxStandComp) {
++        /*Clear the mark and generate an event*/
++        (*(omx_base_component_Private->callbacks->EventHandler))
++          (openmaxStandComp,
++          omx_base_component_Private->callbackData,
++          OMX_EventMark, /* The command was completed */
++          1, /* The commands was a OMX_CommandStateSet */
++          0, /* The state has been changed in message->messageParam2 */
++          pInputBuffer->pMarkData);
++      } else if(pInputBuffer->hMarkTargetComponent!=NULL){
++        /*If this is not the target component then pass the mark*/
++        DEBUG(DEB_LEV_FULL_SEQ, "Can't Pass Mark. This is a Sink!!\n");
++      }
++      if (omx_base_sink_Private->BufferMgmtCallback && pInputBuffer->nFilledLen > 0) {
++        (*(omx_base_sink_Private->BufferMgmtCallback))(openmaxStandComp, pInputBuffer);
++      }
++      else {
++        /*If no buffer management call back the explicitly consume input buffer*/
++        DEBUG(DEB_LEV_FULL_SEQ, "If no buffer management call back, explicitly consume input buffer. nInputPortIndex=%d   BufferMgmtCallback=0x%p  nFilledLen=%d\n",
++          (int)pInputBuffer->nInputPortIndex, omx_base_sink_Private->BufferMgmtCallback, (int)pInputBuffer->nFilledLen);
++        pInputBuffer->nFilledLen = 0;
++      }
++      /*Input Buffer has been completely consumed. So, get new input buffer*/
++
++      if(omx_base_sink_Private->state==OMX_StatePause && !PORT_IS_BEING_FLUSHED(pInPort)) {
++        /*Waiting at paused state*/
++        omx_tsem_wait(omx_base_sink_Private->bStateSem);
++      }
++
++      /*Input Buffer has been completely consumed. So, return input buffer*/
++      if(pInputBuffer->nFilledLen==0) {
++        pInPort->ReturnBufferFunction(pInPort,pInputBuffer);
++        inBufExchanged--;
++        pInputBuffer=NULL;
++        isInputBufferNeeded = OMX_TRUE;
++      }
++
++    }
++  }
++  DEBUG(DEB_LEV_SIMPLE_SEQ,"Exiting Buffer Management Thread\n");
++  return NULL;
++}
+diff --git a/alsa/omx_base_sink.h b/alsa/omx_base_sink.h
+new file mode 100644
+index 0000000..dfe7e9c
+--- /dev/null
++++ b/alsa/omx_base_sink.h
+@@ -0,0 +1,73 @@
++/**
++  @file src/base/omx_base_sink.h
++
++  OpenMAX base sink component. This component does not perform any multimedia
++  processing. It derives from base component and contains a single port. It can be used
++  as base class for sink components.
++
++  Copyright (C) 2007-2008 STMicroelectronics
++  Copyright (C) 2007-2008 Nokia Corporation and/or its subsidiary(-ies).
++
++  This library 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.
++
++  This library 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 this library; if not, write to the Free Software Foundation, Inc.,
++  51 Franklin St, Fifth Floor, Boston, MA
++  02110-1301  USA
++
++  $Date: 2008-08-28 17:50:08 +0200 (Thu, 28 Aug 2008) $
++  Revision $Rev: 583 $
++  Author $Author: gsent $
++
++*/
++
++#ifndef _OMX_BASE_SINK_COMPONENT_H_
++#define _OMX_BASE_SINK_COMPONENT_H_
++
++//#include <OMX_Types.h>
++//#include <IL/OMX_Component.h>
++//#include <IL/OMX_Core.h>
++#include <pthread.h>
++#include "omx_base_component.h"
++#include <stdlib.h>
++
++
++#define OMX_BASE_SINK_INPUTPORT_INDEX   0     /* The index of the input port for the derived components */
++#define OMX_BASE_SINK_CLOCKPORT_INDEX   1     /* The index of the clock port for the dervied components */
++
++/** OMX_BASE_SINK_ALLPORT_INDEX as the standard specifies, the -1 value for port index is used to point to all the ports
++ */
++#define OMX_BASE_SINK_ALLPORT_INDEX -1
++
++/** base sink component private structure.
++ */
++DERIVEDCLASS(omx_base_sink_PrivateType, omx_base_component_PrivateType)
++#define omx_base_sink_PrivateType_FIELDS omx_base_component_PrivateType_FIELDS \
++  /** @param BufferMgmtCallback function pointer for algorithm callback */ \
++  void (*BufferMgmtCallback)(OMX_COMPONENTTYPE* openmaxStandComp, OMX_BUFFERHEADERTYPE* inputbuffer);
++ENDCLASS(omx_base_sink_PrivateType)
++
++/** Base sink contructor
++ */
++OMX_ERRORTYPE omx_base_sink_Constructor(OMX_COMPONENTTYPE *openmaxStandComp,OMX_STRING cComponentName);
++
++/** The base sink destructor. It simply calls the base destructor
++ */
++OMX_ERRORTYPE omx_base_sink_Destructor(OMX_COMPONENTTYPE *openmaxStandComp);
++
++/** This is the central function for component processing. It
++ * is executed in a separate thread, is synchronized with
++ * semaphores at each port, those are released each time a new buffer
++ * is available on the given port.
++ */
++void* omx_base_sink_BufferMgmtFunction(void* param);
++
++#endif
+diff --git a/alsa/omx_classmagic.h b/alsa/omx_classmagic.h
+new file mode 100644
+index 0000000..2560041
+--- /dev/null
++++ b/alsa/omx_classmagic.h
+@@ -0,0 +1,100 @@
++/**
++  @file src/base/omx_classmagic.h
++
++  This file contains class handling helper macros
++  It is left as an exercise to the reader how they do the magic (FIXME)
++
++  Usage Rules:
++  1) include this file
++  2) if your don't inherit, start your class with CLASS(classname)
++  3) if you inherit something, start your class with
++  	DERIVEDCLASS(classname, inheritedclassname)
++  4) end your class with ENDCLASS(classname)
++  5) define your class variables with a #define classname_FIELDS inheritedclassname_FIELDS
++  	inside your class and always add a backslash at the end of line (except last)
++  6) if you want to use doxygen, use C-style comments inside the #define, and
++  	enable macro expansion in doxyconf and predefine DOXYGEN_PREPROCESSING there, etc.
++
++  See examples at the end of this file (in #if 0 block)
++
++  Copyright (C) 2007-2008 STMicroelectronics
++  Copyright (C) 2007-2008 Nokia Corporation and/or its subsidiary(-ies).
++
++  This library 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.
++
++  This library 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 this library; if not, write to the Free Software Foundation, Inc.,
++  51 Franklin St, Fifth Floor, Boston, MA
++  02110-1301  USA
++
++  $Date: 2008-06-27 12:00:23 +0200 (Fri, 27 Jun 2008) $
++  Revision $Rev: 554 $
++  Author $Author: pankaj_sen $
++
++*/
++#ifndef OMX_CLASSMAGIC_H_
++#define OMX_CLASSMAGIC_H_
++
++
++#ifdef DOXYGEN_PREPROCESSING
++#define CLASS(a) class a { public:
++#define DERIVEDCLASS(a, b) class a : public b { public:
++#define ENDCLASS(a) a##_FIELDS };
++#else
++#define CLASS(a) typedef struct a a; \
++ struct a {
++#define DERIVEDCLASS(a, b) typedef struct a a; \
++ struct a {
++#define ENDCLASS(a) a##_FIELDS };
++#endif
++
++#if 0 /*EXAMPLES*/
++/**
++ * Class A is a nice class
++ */
++CLASS(A)
++#define A_FIELDS \
++/** @param a very nice parameter */ \
++ 	int a; \
++/** @param ash another very nice parameter */ \
++ 	int ash;
++ENDCLASS(A)
++
++/**
++ * Class B is a nice derived class
++ */
++DERIVEDCLASS(B,A)
++#define B_FIELDS A_FIELDS \
++/** @param b very nice parameter */ \
++	int b;
++ENDCLASS(B)
++
++/**
++ * Class B2 is a nice derived class
++ */
++DERIVEDCLASS(B2,A)
++#define B2_FIELDS A_FIELDS \
++/** @param b2 very nice parameter */ \
++	int b2;
++ENDCLASS(B2)
++
++/**
++ * Class C is an even nicer derived class.
++ */
++DERIVEDCLASS(C,B)
++#define C_FIELDS B_FIELDS \
++/** @param c very nice parameter */ \
++	int c;
++ENDCLASS(C)
++
++#endif /* 0 */
++
++#endif
+diff --git a/alsa/omx_comp_debug_levels.h b/alsa/omx_comp_debug_levels.h
+new file mode 100644
+index 0000000..dda6a79
+--- /dev/null
++++ b/alsa/omx_comp_debug_levels.h
+@@ -0,0 +1,77 @@
++/**
++  @file src/omx_comp_debug_levels.h
++
++  Define the level of debug prints on standard err. The different levels can
++  be composed with binary OR.
++  The debug levels defined here belong to OpenMAX components and IL core
++
++  Copyright (C) 2007-2008 STMicroelectronics
++  Copyright (C) 2007-2008 Nokia Corporation and/or its subsidiary(-ies).
++
++  This library 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.
++
++  This library 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 this library; if not, write to the Free Software Foundation, Inc.,
++  51 Franklin St, Fifth Floor, Boston, MA
++  02110-1301  USA
++
++  $Date: 2008-07-16 09:39:31 +0200 (Wed, 16 Jul 2008) $
++  Revision $Rev: 577 $
++  Author $Author: gsent $
++
++*/
++
++#ifndef __OMX_COMP_DEBUG_LEVELS_H__
++#define __OMX_COMP_DEBUG_LEVELS_H__
++
++#include <stdio.h>
++
++/** Remove all debug output lines
++ */
++#define DEB_LEV_NO_OUTPUT  0
++
++/** Messages explaing the reason of critical errors
++ */
++#define DEB_LEV_ERR        1
++
++/** Messages showing values related to the test and the component/s used
++ */
++#define DEB_LEV_PARAMS     2
++
++/** Messages representing steps in the execution. These are the simple messages, because
++ * they avoid iterations
++ */
++#define DEB_LEV_SIMPLE_SEQ 4
++
++/** Messages representing steps in the execution. All the steps are described,
++ * also with iterations. With this level of output the performances are
++ * seriously compromised
++ */
++#define DEB_LEV_FULL_SEQ   8
++
++/** Messages that indicates the beginning and the end of a function.
++ * It can be used to trace the execution
++ */
++#define DEB_LEV_FUNCTION_NAME 16
++
++/** All the messages - max value
++ */
++#define DEB_ALL_MESS   255
++
++/** \def DEBUG_LEVEL is the current level do debug output on standard err */
++#define DEBUG_LEVEL (DEB_ALL_MESS)
++#if DEBUG_LEVEL > 0
++#define DEBUG(n, fmt, args...) do { if (DEBUG_LEVEL & (n)){fprintf(stdout, "OMX-" fmt, ##args);} } while (0)
++#else
++#define DEBUG(n, fmt, args...)
++#endif
++
++#endif
+diff --git a/alsa/omx_loader_XBMC.cpp b/alsa/omx_loader_XBMC.cpp
+new file mode 100644
+index 0000000..5ea1855
+--- /dev/null
++++ b/alsa/omx_loader_XBMC.cpp
+@@ -0,0 +1,69 @@
++
++#include "omx_loader_XBMC.h"
++#include <omx_alsasink_component.h>
++
++OMX_ERRORTYPE OMX_GetHandle_XBMC(OMX_OUT OMX_HANDLETYPE* pHandle,
++  OMX_IN  OMX_STRING cComponentName,
++  OMX_IN  OMX_PTR pAppData,
++  OMX_IN  OMX_CALLBACKTYPE* pCallBacks)
++{
++  OMX_ERRORTYPE err = OMX_ErrorNone;
++  OMX_COMPONENTTYPE* openmaxStandComp;
++  omx_base_component_PrivateType* priv;
++
++  if(!strcmp("OMX.XBMC.alsa.alsasink", cComponentName))
++  {
++    openmaxStandComp = (OMX_COMPONENTTYPE*)calloc(1,sizeof(OMX_COMPONENTTYPE));
++    if (!openmaxStandComp) {
++      return OMX_ErrorInsufficientResources;
++    }
++
++    err = omx_alsasink_component_Constructor(openmaxStandComp,cComponentName);
++    if (err != OMX_ErrorNone)
++    {
++      if (err == OMX_ErrorInsufficientResources)
++      {
++        *pHandle = openmaxStandComp;
++        priv = (omx_base_component_PrivateType *) openmaxStandComp->pComponentPrivate;
++        return OMX_ErrorInsufficientResources;
++      }
++      DEBUG(DEB_LEV_ERR, "Error during component construction\n");
++      openmaxStandComp->ComponentDeInit(openmaxStandComp);
++      free(openmaxStandComp);
++      openmaxStandComp = NULL;
++      return OMX_ErrorComponentNotFound;
++    }
++    priv = (omx_base_component_PrivateType *) openmaxStandComp->pComponentPrivate;
++
++    *pHandle = openmaxStandComp;
++    ((OMX_COMPONENTTYPE*)*pHandle)->SetCallbacks(*pHandle, pCallBacks, pAppData);
++  }
++  else
++  {
++    err = OMX_ErrorComponentNotFound;
++  }
++
++  return err;
++}
++
++
++OMX_ERRORTYPE OMX_FreeHandle_XBMC(OMX_IN OMX_HANDLETYPE hComponent)
++{
++  int i;
++  OMX_ERRORTYPE err = OMX_ErrorNone;
++  omx_base_component_PrivateType * priv = (omx_base_component_PrivateType *) ((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate;
++
++  if(!strcmp("OMX.XBMC.alsa.alsasink", priv->name))
++  {
++    err = ((OMX_COMPONENTTYPE*)hComponent)->ComponentDeInit(hComponent);
++
++    free((OMX_COMPONENTTYPE*)hComponent);
++    hComponent = NULL;
++  }
++  else
++  {
++    err = OMX_ErrorComponentNotFound;
++  }
++
++  return err;
++}
+\ No newline at end of file
+diff --git a/alsa/omx_loader_XBMC.h b/alsa/omx_loader_XBMC.h
+new file mode 100644
+index 0000000..c835043
+--- /dev/null
++++ b/alsa/omx_loader_XBMC.h
+@@ -0,0 +1,27 @@
++#pragma once
++
++
++#ifndef __OMX_LOADER_XBMC__
++#define __OMX_LOADER_XBMC__
++
++#ifdef __cplusplus
++extern "C" {
++#endif /* __cplusplus */
++
++#pragma pack(4)
++#include <IL/OMX_Component.h>
++#include <IL/OMX_Types.h>
++#pragma pack()
++
++OMX_ERRORTYPE OMX_GetHandle_XBMC(OMX_OUT OMX_HANDLETYPE* pHandle,
++  OMX_IN  OMX_STRING cComponentName,
++  OMX_IN  OMX_PTR pAppData,
++  OMX_IN  OMX_CALLBACKTYPE* pCallBacks);
++
++OMX_ERRORTYPE OMX_FreeHandle_XBMC(OMX_IN OMX_HANDLETYPE hComponent);
++
++#ifdef __cplusplus
++}
++#endif /* __cplusplus */
++
++#endif
+\ No newline at end of file
+diff --git a/alsa/omx_queue.cpp b/alsa/omx_queue.cpp
+new file mode 100644
+index 0000000..e4ecd25
+--- /dev/null
++++ b/alsa/omx_queue.cpp
+@@ -0,0 +1,136 @@
++/**
++  @file src/queue.c
++
++  Implements a simple LIFO structure used for queueing OMX buffers.
++
++  Copyright (C) 2007-2008 STMicroelectronics
++  Copyright (C) 2007-2008 Nokia Corporation and/or its subsidiary(-ies).
++
++  This library 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.
++
++  This library 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 this library; if not, write to the Free Software Foundation, Inc.,
++  51 Franklin St, Fifth Floor, Boston, MA
++  02110-1301  USA
++
++  $Date: 2008-06-27 12:00:23 +0200 (Fri, 27 Jun 2008) $
++  Revision $Rev: 554 $
++  Author $Author: pankaj_sen $
++*/
++
++#include <stdio.h>
++#include <stdlib.h>
++#include <string.h>
++
++#include "omx_queue.h"
++#include "omx_comp_debug_levels.h"
++
++/** Initialize a queue descriptor
++ *
++ * @param queue The queue descriptor to initialize.
++ * The user needs to allocate the queue
++ */
++void omx_queue_init(omx_queue_t* queue) {
++  int i;
++  omx_qelem_t* newelem;
++  omx_qelem_t* current;
++  queue->first = (omx_qelem_t*)malloc(sizeof(omx_qelem_t));
++  memset(queue->first, 0, sizeof(omx_qelem_t));
++  current = queue->last = queue->first;
++  queue->nelem = 0;
++  for (i = 0; i<MAX_QUEUE_ELEMENTS - 2; i++) {
++    newelem = (omx_qelem_t*)malloc(sizeof(omx_qelem_t));
++    memset(newelem, 0, sizeof(omx_qelem_t));
++    current->q_forw = newelem;
++    current = newelem;
++  }
++  current->q_forw = queue->first;
++
++  pthread_mutex_init(&queue->mutex, NULL);
++}
++
++/** Deinitialize a queue descriptor
++ * flushing all of its internal data
++ *
++ * @param queue the queue descriptor to dump
++ */
++void omx_queue_deinit(omx_queue_t* queue) {
++  int i;
++  omx_qelem_t* current;
++  current = queue->first;
++  for (i = 0; i<MAX_QUEUE_ELEMENTS - 2; i++) {
++    if (current != NULL) {
++      current = current->q_forw;
++      free(queue->first);
++      queue->first = current;
++    }
++  }
++  if(queue->first) {
++    free(queue->first);
++    queue->first = NULL;
++  }
++  pthread_mutex_destroy(&queue->mutex);
++}
++
++/** Enqueue an element to the given queue descriptor
++ *
++ * @param queue the queue descritpor where to queue data
++ *
++ * @param data the data to be enqueued
++ */
++void omx_queue(omx_queue_t* queue, void* data) {
++  if (queue->last->data != NULL) {
++    DEBUG(DEB_LEV_ERR, "In %s ERROR! Full queue\n",__func__);
++    return;
++  }
++  pthread_mutex_lock(&queue->mutex);
++  queue->last->data = data;
++  queue->last = queue->last->q_forw;
++  queue->nelem++;
++  pthread_mutex_unlock(&queue->mutex);
++}
++
++/** Dequeue an element from the given queue descriptor
++ *
++ * @param queue the queue descriptor from which to dequeue the element
++ *
++ * @return the element that has bee dequeued. If the queue is empty
++ *  a NULL value is returned
++ */
++void* omx_dequeue(omx_queue_t* queue) {
++  void* data;
++  if (queue->first->data == NULL) {
++    DEBUG(DEB_LEV_ERR, "In %s ERROR! Empty queue\n",__func__);
++    return NULL;
++  }
++  pthread_mutex_lock(&queue->mutex);
++  data = queue->first->data;
++  queue->first->data = NULL;
++  queue->first = queue->first->q_forw;
++  queue->nelem--;
++  pthread_mutex_unlock(&queue->mutex);
++
++  return data;
++}
++
++/** Returns the number of elements hold in the queue
++ *
++ * @param queue the requested queue
++ *
++ * @return the number of elements in the queue
++ */
++int omx_getquenelem(omx_queue_t* queue) {
++  int qelem;
++  pthread_mutex_lock(&queue->mutex);
++  qelem = queue->nelem;
++  pthread_mutex_unlock(&queue->mutex);
++  return qelem;
++}
+diff --git a/alsa/omx_queue.h b/alsa/omx_queue.h
+new file mode 100644
+index 0000000..bf80f90
+--- /dev/null
++++ b/alsa/omx_queue.h
+@@ -0,0 +1,94 @@
++/**
++  @file src/omx_queue.h
++
++  Implements a simple LIFO structure used for queueing OMX buffers.
++
++  Copyright (C) 2007-2008 STMicroelectronics
++  Copyright (C) 2007-2008 Nokia Corporation and/or its subsidiary(-ies).
++
++  This library 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.
++
++  This library 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 this library; if not, write to the Free Software Foundation, Inc.,
++  51 Franklin St, Fifth Floor, Boston, MA
++  02110-1301  USA
++
++  $Date: 2008-06-27 12:00:23 +0200 (Fri, 27 Jun 2008) $
++  Revision $Rev: 554 $
++  Author $Author: pankaj_sen $
++*/
++
++#pragma once
++
++#ifndef __OMX_QUEUE_H__
++#define __OMX_QUEUE_H__
++
++#include <pthread.h>
++/** Maximum number of elements in a queue
++ */
++#define MAX_QUEUE_ELEMENTS 20
++/** Output port queue element. Contains an OMX buffer header type
++ */
++typedef struct omx_qelem_t omx_qelem_t;
++struct omx_qelem_t{
++  omx_qelem_t* q_forw;
++  void* data;
++};
++
++/** This structure contains the queue
++ */
++typedef struct omx_queue_t{
++  omx_qelem_t* first; /**< Output buffer queue head */
++  omx_qelem_t* last; /**< Output buffer queue tail */
++  int nelem; /**< Number of elements in the queue */
++  pthread_mutex_t mutex;
++} omx_queue_t;
++
++/** Initialize a queue descriptor
++ *
++ * @param queue The queue descriptor to initialize.
++ * The user needs to allocate the queue
++ */
++void omx_queue_init(omx_queue_t* queue);
++
++/** Deinitialize a queue descriptor
++ * flushing all of its internal data
++ *
++ * @param queue the queue descriptor to dump
++ */
++void omx_queue_deinit(omx_queue_t* queue);
++
++/** Enqueue an element to the given queue descriptor
++ *
++ * @param queue the queue descritpor where to queue data
++ *
++ * @param data the data to be enqueued
++ */
++void omx_queue(omx_queue_t* queue, void* data);
++
++/** Dequeue an element from the given queue descriptor
++ *
++ * @param queue the queue descriptor from which to dequeue the element
++ *
++ * @return the element that has bee dequeued. If the queue is empty
++ *  a NULL value is returned
++ */
++void* omx_dequeue(omx_queue_t* queue);
++
++/** Returns the number of elements hold in the queue
++ *
++ * @param queue the requested queue
++ *
++ * @return the number of elements in the queue
++ */
++int omx_getquenelem(omx_queue_t* queue);
++
++#endif
+diff --git a/alsa/omx_semaphore.cpp b/alsa/omx_semaphore.cpp
+new file mode 100644
+index 0000000..eca3a0f
+--- /dev/null
++++ b/alsa/omx_semaphore.cpp
+@@ -0,0 +1,111 @@
++/**
++  @file src/tsemaphore.c
++
++  Implements a simple inter-thread semaphore so not to have to deal with IPC
++  creation and the like.
++
++  Copyright (C) 2007-2008 STMicroelectronics
++  Copyright (C) 2007-2008 Nokia Corporation and/or its subsidiary(-ies).
++
++  This library 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.
++
++  This library 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 this library; if not, write to the Free Software Foundation, Inc.,
++  51 Franklin St, Fifth Floor, Boston, MA
++  02110-1301  USA
++
++  $Date: 2008-06-27 12:00:23 +0200 (Fri, 27 Jun 2008) $
++  Revision $Rev: 554 $
++  Author $Author: pankaj_sen $
++*/
++
++#include <pthread.h>
++#include <sys/time.h>
++#include <errno.h>
++#include "omx_semaphore.h"
++//#include "omx_comp_debug_levels.h"
++
++/** Initializes the semaphore at a given value
++ *
++ * @param tsem the semaphore to initialize
++ * @param val the initial value of the semaphore
++ *
++ */
++void omx_tsem_init(omx_tsem_t* tsem, unsigned int val) {
++  pthread_cond_init(&tsem->condition, NULL);
++  pthread_mutex_init(&tsem->mutex, NULL);
++  tsem->semval = val;
++}
++
++/** Destroy the semaphore
++ *
++ * @param tsem the semaphore to destroy
++ */
++void omx_tsem_deinit(omx_tsem_t* tsem) {
++  pthread_cond_destroy(&tsem->condition);
++  pthread_mutex_destroy(&tsem->mutex);
++}
++
++/** Decreases the value of the semaphore. Blocks if the semaphore
++ * value is zero.
++ *
++ * @param tsem the semaphore to decrease
++ */
++void omx_tsem_down(omx_tsem_t* tsem) {
++  pthread_mutex_lock(&tsem->mutex);
++  while (tsem->semval == 0) {
++    pthread_cond_wait(&tsem->condition, &tsem->mutex);
++  }
++  tsem->semval--;
++  pthread_mutex_unlock(&tsem->mutex);
++}
++
++/** Increases the value of the semaphore
++ *
++ * @param tsem the semaphore to increase
++ */
++void omx_tsem_up(omx_tsem_t* tsem) {
++  pthread_mutex_lock(&tsem->mutex);
++  tsem->semval++;
++  pthread_cond_signal(&tsem->condition);
++  pthread_mutex_unlock(&tsem->mutex);
++}
++
++/** Reset the value of the semaphore
++ *
++ * @param tsem the semaphore to reset
++ */
++void omx_tsem_reset(omx_tsem_t* tsem) {
++  pthread_mutex_lock(&tsem->mutex);
++  tsem->semval=0;
++  pthread_mutex_unlock(&tsem->mutex);
++}
++
++/** Wait on the condition.
++ *
++ * @param tsem the semaphore to wait
++ */
++void omx_tsem_wait(omx_tsem_t* tsem) {
++  pthread_mutex_lock(&tsem->mutex);
++  pthread_cond_wait(&tsem->condition, &tsem->mutex);
++  pthread_mutex_unlock(&tsem->mutex);
++}
++
++/** Signal the condition,if waiting
++ *
++ * @param tsem the semaphore to signal
++ */
++void omx_tsem_signal(omx_tsem_t* tsem) {
++  pthread_mutex_lock(&tsem->mutex);
++  pthread_cond_signal(&tsem->condition);
++  pthread_mutex_unlock(&tsem->mutex);
++}
++
+diff --git a/alsa/omx_semaphore.h b/alsa/omx_semaphore.h
+new file mode 100644
+index 0000000..1e3f3db
+--- /dev/null
++++ b/alsa/omx_semaphore.h
+@@ -0,0 +1,92 @@
++/**
++  @file src/omx_semaphore.h
++
++  Implements a simple inter-thread semaphore so not to have to deal with IPC
++  creation and the like.
++
++  Copyright (C) 2007-2008 STMicroelectronics
++  Copyright (C) 2007-2008 Nokia Corporation and/or its subsidiary(-ies).
++
++  This library 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.
++
++  This library 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 this library; if not, write to the Free Software Foundation, Inc.,
++  51 Franklin St, Fifth Floor, Boston, MA
++  02110-1301  USA
++
++  $Date: 2008-06-27 12:00:23 +0200 (Fri, 27 Jun 2008) $
++  Revision $Rev: 554 $
++  Author $Author: pankaj_sen $
++
++*/
++
++#pragma once
++
++#ifndef __OMX_SEMAPHORE_H__
++#define __OMX_SEMAPHORE_H__
++
++#include <pthread.h>
++#include <semaphore.h>
++
++/** The structure contains the semaphore value, mutex and green light flag
++ */
++typedef struct omx_tsem_t {
++  pthread_cond_t condition;
++  pthread_mutex_t mutex;
++  unsigned int semval;
++} omx_tsem_t;
++
++/** Initializes the semaphore at a given value
++ *
++ * @param tsem the semaphore to initialize
++ *
++ * @param val the initial value of the semaphore
++ */
++void omx_tsem_init(omx_tsem_t* tsem, unsigned int val);
++
++/** Destroy the semaphore
++ *
++ * @param tsem the semaphore to destroy
++ */
++void omx_tsem_deinit(omx_tsem_t* tsem);
++
++/** Decreases the value of the semaphore. Blocks if the semaphore
++ * value is zero.
++ *
++ * @param tsem the semaphore to decrease
++ */
++void omx_tsem_down(omx_tsem_t* tsem);
++
++/** Increases the value of the semaphore
++ *
++ * @param tsem the semaphore to increase
++ */
++void omx_tsem_up(omx_tsem_t* tsem);
++
++/** Reset the value of the semaphore
++ *
++ * @param tsem the semaphore to reset
++ */
++void omx_tsem_reset(omx_tsem_t* tsem);
++
++/** Wait on the condition.
++ *
++ * @param tsem the semaphore to wait
++ */
++void omx_tsem_wait(omx_tsem_t* tsem);
++
++/** Signal the condition,if waiting
++ *
++ * @param tsem the semaphore to signal
++ */
++void omx_tsem_signal(omx_tsem_t* tsem);
++
++#endif
+diff --git a/omxplayer.cpp b/omxplayer.cpp
+index b554a58..3e5b99b 100644
+--- a/omxplayer.cpp
++++ b/omxplayer.cpp
+@@ -699,7 +699,7 @@ int main(int argc, char *argv[])
+         break;
+       case 'o':
+         m_config_audio.device = optarg;
+-        if(m_config_audio.device != "local" && m_config_audio.device != "hdmi" && m_config_audio.device != "both")
++        if(m_config_audio.device != "local" && m_config_audio.device != "hdmi" && m_config_audio.device != "both" && m_config_audio.device != "alsa")
+         {
+           print_usage();
+           return 0;