diff -r 71ca22bcf22a -r 5a06f39ad45b khronosfws/openmax_al/src/common/xaequalizeritf.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/khronosfws/openmax_al/src/common/xaequalizeritf.c	Fri Apr 16 15:29:42 2010 +0300
@@ -0,0 +1,605 @@
+/*
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: 
+*
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include "xaequalizeritf.h"
+#ifdef _GSTREAMER_BACKEND_  
+#include "XAEqualizerItfAdaptation.h"
+#endif
+static const XAuint16 equalizerNumOfPresets = 0;
+
+/**
+ * XAEqualizerItfImpl* GetImpl(XAEqualizerItf self)
+ * Description: Validated interface pointer and cast it to implementations pointer.
+ **/
+static XAEqualizerItfImpl* GetImpl(XAEqualizerItf self)
+{
+    if(self)
+    {
+        XAEqualizerItfImpl *impl = (XAEqualizerItfImpl*)(*self);
+        if(impl && impl == impl->self)
+        {
+            return impl;
+        }
+    }
+    return NULL;
+}
+
+/**
+ * Base interface XAEqualizerItf implementation
+ */
+
+/**
+ * XAresult XAEqualizerItfImpl_SetEnabled(XAEqualizerItf self,XAboolean enabled)
+ * Description: Enables the effect.
+ **/
+XAresult XAEqualizerItfImpl_SetEnabled(XAEqualizerItf self,XAboolean enabled)
+{
+    XAresult ret = XA_RESULT_SUCCESS;
+    XAEqualizerItfImpl* impl = GetImpl(self);
+    
+    DEBUG_API("->XAEqualizerItfImpl_SetEnabled");
+
+    if(!impl)
+    {
+        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+        DEBUG_API("<-XAEqualizerItfImpl_SetEnabled");
+        /* invalid parameter */
+        return XA_RESULT_PARAMETER_INVALID;
+    }
+#ifdef _GSTREAMER_BACKEND_
+    XAuint16 index = 0;
+    if(enabled && !(impl->enabled))
+    {
+        for(index = 0; index < EQUALIZER_NUM_OF_BANDS; index++)
+        {
+            if(impl->changeLevel[index])
+            {
+                ret = XAEqualizerItfAdapt_SetBandLevel(impl->adapCtx, index, impl->levels[index]);
+
+                if(XA_RESULT_SUCCESS == ret)
+                {
+                    impl->changeLevel[index] = XA_BOOLEAN_FALSE;
+                }
+            }
+        }
+    }
+    else if(!enabled && impl->enabled)
+    {
+        for(index = 0; index < EQUALIZER_NUM_OF_BANDS; index++)
+        {
+            ret = XAEqualizerItfAdapt_SetBandLevel(impl->adapCtx, index, EQUALIZER_DEFAULT_BAND_LEVEL);
+
+            if(XA_RESULT_SUCCESS == ret)
+            {
+                impl->changeLevel[index] = XA_BOOLEAN_FALSE;
+            }
+        }
+    }
+    else
+    {
+        /* do nothing */
+    }
+#endif
+    if(ret == XA_RESULT_SUCCESS)
+    {
+        impl->enabled = enabled;
+    }
+
+    DEBUG_API("<-XAEqualizerItfImpl_SetEnabled");
+    return ret;
+}
+
+/**
+ * XAresult XAEqualizerItfImpl_IsEnabled(XAEqualizerItf self, XAboolean *pEnabled)
+ * Description: Gets the enabled status of the effect.
+ **/
+XAresult XAEqualizerItfImpl_IsEnabled(XAEqualizerItf self, XAboolean *pEnabled)
+{
+    XAresult ret = XA_RESULT_SUCCESS;
+
+    XAEqualizerItfImpl* impl = GetImpl(self);
+    DEBUG_API("->XAEqualizerItfImpl_IsEnabled");
+
+    if(!impl || !pEnabled)
+    {
+        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+        DEBUG_API("<-XAEqualizerItfImpl_IsEnabled");
+        /* invalid parameter */
+        return XA_RESULT_PARAMETER_INVALID;
+    }
+
+    *pEnabled = impl->enabled;
+
+    DEBUG_API("<-XAEqualizerItfImpl_IsEnabled");
+    return ret;
+}
+
+/**
+ * XAresult XAEqualizerItfImpl_GetNumberOfBands(XAEqualizerItf self,
+ *                                              XAuint16 *pNumBands)
+ * Description: Gets the number of frequency bands that the equalizer supports.
+ * A valid equalizer must have at least two bands.
+ **/
+XAresult XAEqualizerItfImpl_GetNumberOfBands(XAEqualizerItf self,
+                                             XAuint16 *pNumBands)
+{
+    XAresult ret = XA_RESULT_SUCCESS;
+
+    XAEqualizerItfImpl* impl = GetImpl(self);
+    DEBUG_API("->XAEqualizerItfImpl_GetNumberOfBands");
+
+    if(!impl || !pNumBands)
+    {
+        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+        DEBUG_API("<-XAEqualizerItfImpl_GetNumberOfBands");
+        /* invalid parameter */
+        return XA_RESULT_PARAMETER_INVALID;
+    }
+#ifdef _GSTREAMER_BACKEND_  
+    *pNumBands = EQUALIZER_NUM_OF_BANDS;
+#endif
+    DEBUG_API("<-XAEqualizerItfImpl_GetNumberOfBands");
+    return ret;
+}
+
+/**
+ * XAresult XAEqualizerItfImpl_GetBandLevelRange(XAEqualizerItf self,
+ *                                               XAmillibel *pMin,
+ *                                               XAmillibel *pMax)
+ * Description: Returns the minimun and maximun band levels supported.
+ **/
+XAresult XAEqualizerItfImpl_GetBandLevelRange(XAEqualizerItf self,
+                                              XAmillibel *pMin,
+                                              XAmillibel *pMax)
+{
+    XAresult ret = XA_RESULT_SUCCESS;
+    XAEqualizerItfImpl* impl = GetImpl(self);
+    DEBUG_API("->XAEqualizerItfImpl_GetBandLevelRange");
+
+    if(!impl || (!pMin && !pMax)) /* other may be NULL */
+    {
+        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+        DEBUG_API("<-XAEqualizerItfImpl_GetBandLevelRange");
+        /* invalid parameter */
+        return XA_RESULT_PARAMETER_INVALID;
+    }
+#ifdef _GSTREAMER_BACKEND_  
+    ret = XAEqualizerItfAdapt_ThreadEntry(impl->adapCtx);
+    if( ret == XA_RESULT_PARAMETER_INVALID || ret == XA_RESULT_PRECONDITIONS_VIOLATED )
+    {
+        DEBUG_API("<-XAEqualizerItfImpl_GetBandLevelRange");
+        return ret;
+    }
+    ret = XAEqualizerItfAdapt_GetBandLevelRange(impl->adapCtx, pMin, pMax);
+    XAEqualizerItfAdapt_ThreadExit(impl->adapCtx);
+#endif
+    DEBUG_API("<-XAEqualizerItfImpl_GetBandLevelRange");
+    return ret;
+}
+
+/**
+ * XAresult XAEqualizerItfImpl_SetBandLevel(XAEqualizerItf self, XAuint16 band,
+ *                                          XAmillibel level)
+ * Description: Sets the given equalizer band to the given gain value.
+ **/
+XAresult XAEqualizerItfImpl_SetBandLevel(XAEqualizerItf self, XAuint16 band,
+                                         XAmillibel level)
+{
+    XAresult ret = XA_RESULT_SUCCESS;
+    XAuint16 numOfBands = 0;
+    XAmillibel minLevel = 0;
+    XAmillibel maxLevel = 0;
+    XAEqualizerItfImpl* impl = NULL;
+
+    DEBUG_API("->XAEqualizerItfImpl_SetBandLevel");
+    impl = GetImpl(self);
+
+    /* Get number of bands */
+    if(XA_RESULT_SUCCESS != XAEqualizerItfImpl_GetNumberOfBands(self, &numOfBands))
+    {
+        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+        DEBUG_API("<-XAEqualizerItfImpl_SetBandLevel");
+        /* invalid parameter */
+        return XA_RESULT_PARAMETER_INVALID;
+    }
+
+    /* Get minimum and maximum level */
+    if(XA_RESULT_SUCCESS != XAEqualizerItfImpl_GetBandLevelRange(self, &minLevel, &maxLevel))
+    {
+        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+        DEBUG_API("<-XAEqualizerItfImpl_SetBandLevel");
+        /* invalid parameter */
+        return XA_RESULT_PARAMETER_INVALID;
+    }
+
+    if(!impl || band > (numOfBands-1) || level < minLevel || level > maxLevel)
+    {
+        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+        DEBUG_API("<-XAEqualizerItfImpl_SetBandLevel");
+        /* invalid parameter */
+        return XA_RESULT_PARAMETER_INVALID;
+    }
+#ifdef _GSTREAMER_BACKEND_  
+    ret = XAEqualizerItfAdapt_ThreadEntry(impl->adapCtx);
+    if( ret == XA_RESULT_PARAMETER_INVALID  || ret == XA_RESULT_PRECONDITIONS_VIOLATED )
+    {
+        DEBUG_API("<-XAEqualizerItfImpl_SetBandLevel");
+        return ret;
+    }
+
+    if(impl->enabled)
+    {
+        ret = XAEqualizerItfAdapt_SetBandLevel(impl->adapCtx, band, level);
+        if(XA_RESULT_SUCCESS == ret)
+        {
+            impl->levels[band] = level;
+        }
+    }
+    else
+    {
+        impl->changeLevel[band] = XA_BOOLEAN_TRUE;
+        impl->levels[band] = level;
+    }
+
+    XAEqualizerItfAdapt_ThreadExit(impl->adapCtx);
+#endif    
+    DEBUG_API("<-XAEqualizerItfImpl_SetBandLevel");
+    return ret;
+}
+
+/**
+ * XAresult XAEqualizerItfImpl_GetBandLevel(XAEqualizerItf self, XAuint16 band,
+ *                                          XAmillibel *pLevel)
+ * Description: Gets the gain set for the given equalizer band.
+ **/
+XAresult XAEqualizerItfImpl_GetBandLevel(XAEqualizerItf self, XAuint16 band,
+                                         XAmillibel *pLevel)
+{
+    XAresult ret = XA_RESULT_SUCCESS;
+    DEBUG_API("->XAEqualizerItfImpl_GetBandLevel");
+#ifdef _GSTREAMER_BACKEND_  
+    XAEqualizerItfImpl* impl = GetImpl(self);
+    if(!impl || !pLevel ||  band >= EQUALIZER_NUM_OF_BANDS)
+    {
+        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+        DEBUG_API("<-XAEqualizerItfImpl_GetBandLevel");
+        /* invalid parameter */
+        return XA_RESULT_PARAMETER_INVALID;
+    }
+
+    *pLevel = impl->levels[band];
+#endif
+    DEBUG_API("<-XAEqualizerItfImpl_GetBandLevel");
+    return ret;
+}
+
+/**
+ * XAresult XAEqualizerItfImpl_GetCenterFreq(XAEqualizerItf self, XAuint16 band,
+ *                                           XAmilliHertz *pCenter)
+ * Description: Gets the center frequency of the given band.
+ **/
+XAresult XAEqualizerItfImpl_GetCenterFreq(XAEqualizerItf self, XAuint16 band,
+                                          XAmilliHertz *pCenter)
+{
+    XAresult ret = XA_RESULT_SUCCESS;
+    XAEqualizerItfImpl* impl = GetImpl(self);
+    DEBUG_API("->XAEqualizerItfImpl_GetCenterFreq");
+
+    if(!impl || !pCenter)
+    {
+        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+        DEBUG_API("<-XAEqualizerItfImpl_GetCenterFreq");
+        /* invalid parameter */
+        return XA_RESULT_PARAMETER_INVALID;
+    }
+#ifdef _GSTREAMER_BACKEND_  
+    ret = XAEqualizerItfAdapt_ThreadEntry(impl->adapCtx);
+    if( ret == XA_RESULT_PARAMETER_INVALID || ret == XA_RESULT_PRECONDITIONS_VIOLATED )
+    {
+        DEBUG_API("<-XAEqualizerItfImpl_GetCenterFreq");
+        return ret;
+    }
+    ret = XAEqualizerItfAdapt_GetCenterFreq(impl->adapCtx, band, pCenter);
+
+    XAEqualizerItfAdapt_ThreadExit(impl->adapCtx);
+#endif
+    DEBUG_API("<-XAEqualizerItfImpl_GetCenterFreq");
+    return ret;
+}
+
+/**
+ * XAresult XAEqualizerItfImpl_GetBandFreqRange(XAEqualizerItf self, XAuint16 band,
+ *                                              XAmilliHertz *pMin,
+ *                                              XAmilliHertz *pMax)
+ * Description: Gets the frequency range of the given frequency band.
+ **/
+XAresult XAEqualizerItfImpl_GetBandFreqRange(XAEqualizerItf self, XAuint16 band,
+                                             XAmilliHertz *pMin,
+                                             XAmilliHertz *pMax)
+{
+    XAresult ret = XA_RESULT_SUCCESS;
+    XAuint16 numOfBands = 0;
+    XAEqualizerItfImpl* impl = GetImpl(self);
+    DEBUG_API("->XAEqualizerItfImpl_GetBandFreqRange");
+
+    /* Get number of bands */
+    if(XA_RESULT_SUCCESS != XAEqualizerItfImpl_GetNumberOfBands(self, &numOfBands))
+    {
+        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+        DEBUG_API("<-XAEqualizerItfImpl_GetBandFreqRange");
+        /* invalid parameter */
+        return XA_RESULT_PARAMETER_INVALID;
+    }
+
+    if(!impl || (!pMin && !pMax) || band > numOfBands) /* pMin or pMax may be NULL */
+    {
+        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+        DEBUG_API("<-XAEqualizerItfImpl_GetBandFreqRange");
+        /* invalid parameter */
+        return XA_RESULT_PARAMETER_INVALID;
+    }
+
+#ifdef _GSTREAMER_BACKEND_  
+    ret = XAEqualizerItfAdapt_ThreadEntry(impl->adapCtx);
+    if( ret == XA_RESULT_PARAMETER_INVALID || ret == XA_RESULT_PRECONDITIONS_VIOLATED )
+    {
+        DEBUG_API("<-XAEqualizerItfImpl_GetBandFreqRange");
+        return ret;
+    }
+    ret = XAEqualizerItfAdapt_GetBandFreqRange(impl->adapCtx, band, pMin, pMax);
+
+    XAEqualizerItfAdapt_ThreadExit(impl->adapCtx);
+#endif    
+    DEBUG_API("<-XAEqualizerItfImpl_GetBandFreqRange");
+    return ret;
+}
+
+/**
+ * XAresult XAEqualizerItfImpl_GetBand(XAEqualizerItf self, XAmilliHertz frequency,
+ *                                     XAuint16 *pBand)
+ *
+ * Description: Gets the band that has the most effect on the given frequency.
+ * If no band has an effect on the given frequency, XA_EQUALIZER_UNDEFINED is returned.
+ **/
+XAresult XAEqualizerItfImpl_GetBand(XAEqualizerItf self, XAmilliHertz frequency,
+                                    XAuint16 *pBand)
+{
+    XAresult ret = XA_RESULT_SUCCESS;
+    XAEqualizerItfImpl* impl = GetImpl(self);
+    DEBUG_API("->XAEqualizerItfImpl_GetBand");
+
+    if(!impl || !pBand)
+    {
+        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+        DEBUG_API("<-XAEqualizerItfImpl_GetBand");
+        /* invalid parameter */
+        return XA_RESULT_PARAMETER_INVALID;
+    }
+#ifdef _GSTREAMER_BACKEND_  
+    ret = XAEqualizerItfAdapt_ThreadEntry(impl->adapCtx);
+    if( ret == XA_RESULT_PARAMETER_INVALID || ret == XA_RESULT_PRECONDITIONS_VIOLATED )
+    {
+        DEBUG_API("<-XAEqualizerItfImpl_GetBand");
+        return ret;
+    }
+    ret = XAEqualizerItfAdapt_GetBand(impl->adapCtx, frequency, pBand);
+
+    XAEqualizerItfAdapt_ThreadExit(impl->adapCtx);
+#endif
+    DEBUG_API("<-XAEqualizerItfImpl_GetBand");
+    return ret;
+}
+
+/**
+ * XAresult XAEqualizerItfImpl_GetCurrentPreset(XAEqualizerItf self,
+ *                                              XAuint16 *pPreset)
+ * Description: Gets the current preset.
+ **/
+XAresult XAEqualizerItfImpl_GetCurrentPreset(XAEqualizerItf self,
+                                             XAuint16 *pPreset)
+{
+    XAresult ret = XA_RESULT_SUCCESS;
+    XAEqualizerItfImpl* impl = GetImpl(self);
+    DEBUG_API("->XAEqualizerItfImpl_GetCurrentPreset");
+
+    if(!impl || !pPreset)
+    {
+        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+        DEBUG_API("<-XAEqualizerItfImpl_GetCurrentPreset");
+        /* invalid parameter */
+        return XA_RESULT_PARAMETER_INVALID;
+    }
+
+    /* no presets defined */
+
+    if(ret == XA_RESULT_SUCCESS)
+    {
+        *pPreset = impl->preset;
+    }
+
+    DEBUG_API("<-XAEqualizerItfImpl_GetCurrentPreset");
+    return ret;
+}
+
+/**
+ * XAresult XAEqualizerItfImpl_UsePreset(XAEqualizerItf self, XAuint16 index)
+ * Description: Sets the equalizer according to the given preset
+ **/
+XAresult XAEqualizerItfImpl_UsePreset(XAEqualizerItf self, XAuint16 index)
+{
+    XAresult ret = XA_RESULT_SUCCESS;
+    XAuint16 numOfPresets = 0;
+    XAEqualizerItfImpl* impl = GetImpl(self);
+
+    DEBUG_API("->XAEqualizerItfImpl_UsePreset");
+
+    /* get number of presets */
+    if( XA_RESULT_SUCCESS != XAEqualizerItfImpl_GetNumberOfPresets(self, &numOfPresets))
+    {
+        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+        DEBUG_API("<-XAEqualizerItfImpl_UsePreset");
+        /* invalid parameter */
+        return XA_RESULT_PARAMETER_INVALID;
+    }
+
+    if(!impl || index >= numOfPresets )
+    {
+        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+        DEBUG_API("<-XAEqualizerItfImpl_UsePreset");
+        /* invalid parameter */
+        return XA_RESULT_PARAMETER_INVALID;
+    }
+
+    impl->preset = index;
+
+    DEBUG_API("<-XAEqualizerItfImpl_UsePreset");
+    return ret;
+}
+
+/**
+ * XAresult XAEqualizerItfImpl_GetNumberOfPresets(XAEqualizerItf self,
+ *                                                XAuint16 *pNumPresets)
+ * Description: Gets the total number of presets the equalizer supports.
+ **/
+XAresult XAEqualizerItfImpl_GetNumberOfPresets(XAEqualizerItf self,
+                                               XAuint16 *pNumPresets)
+{
+    XAresult ret = XA_RESULT_SUCCESS;
+    XAEqualizerItfImpl* impl = GetImpl(self);
+    DEBUG_API("->XAEqualizerItfImpl_GetNumberOfPresets");
+
+    if(!impl || !pNumPresets)
+    {
+        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+        DEBUG_API("<-XAEqualizerItfImpl_GetNumberOfPresets");
+        /* invalid parameter */
+        return XA_RESULT_PARAMETER_INVALID;
+    }
+
+    /* No presets defined. */
+    *pNumPresets = equalizerNumOfPresets;
+
+    DEBUG_API("<-XAEqualizerItfImpl_GetNumberOfPresets");
+    return ret;
+}
+
+/**
+ * XAresult XAEqualizerItfImpl_GetPresetName(XAEqualizerItf self, XAuint16 index,
+ *                                           const XAchar **ppName)
+ * Description: Gets the preset name based on the index.
+ **/
+XAresult XAEqualizerItfImpl_GetPresetName(XAEqualizerItf self, XAuint16 index,
+                                          const XAchar **ppName)
+{
+    XAresult ret = XA_RESULT_SUCCESS;
+    XAuint16 numOfPresets = 0;
+    XAEqualizerItfImpl* impl = GetImpl(self);
+
+    DEBUG_API("->XAEqualizerItfImpl_GetPresetName");
+
+    /* get number of presets */
+    if( XA_RESULT_SUCCESS != XAEqualizerItfImpl_GetNumberOfPresets(self, &numOfPresets))
+    {
+        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+        DEBUG_API("<-XAEqualizerItfImpl_GetPresetName");
+        /* invalid parameter */
+        return XA_RESULT_PARAMETER_INVALID;
+    }
+
+    if(!impl || !ppName || index > (numOfPresets-1))
+    {
+        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+        DEBUG_API("<-XAEqualizerItfImpl_GetPresetName");
+        /* invalid parameter */
+        return XA_RESULT_PARAMETER_INVALID;
+    }
+
+    /* Implementation placeholder here for presets when defined.
+       Currently always return XA_RESULT_PARAMETER_INVALID */
+
+    DEBUG_API("<-XAEqualizerItfImpl_GetPresetName");
+    return ret;
+}
+
+/**
+ * XAEqualizerItfImpl -specific methods
+ **/
+#ifdef _GSTREAMER_BACKEND_  
+
+/**
+ * XAEqualizerItfImplImpl* XAEqualizerItfImpl_Create()
+ * @return  XAEqualizerItfImplImpl* - Pointer to  EqualizerItf interface implementation
+ **/
+XAEqualizerItfImpl* XAEqualizerItfImpl_Create(XAAdaptationBaseCtx *adapCtx)
+{
+    XAuint16 index = 0;
+
+    XAEqualizerItfImpl *self = (XAEqualizerItfImpl*)
+        calloc(1,sizeof(XAEqualizerItfImpl));
+
+    DEBUG_API("->XAEqualizerItfImpl_Create");
+
+    if(self)
+    {
+        /* init itf default implementation */
+        self->itf.GetBand = XAEqualizerItfImpl_GetBand;
+        self->itf.GetBandFreqRange = XAEqualizerItfImpl_GetBandFreqRange;
+        self->itf.GetBandLevel = XAEqualizerItfImpl_GetBandLevel;
+        self->itf.GetBandLevelRange = XAEqualizerItfImpl_GetBandLevelRange;
+        self->itf.GetCenterFreq = XAEqualizerItfImpl_GetCenterFreq;
+        self->itf.GetCurrentPreset = XAEqualizerItfImpl_GetCurrentPreset;
+        self->itf.GetNumberOfBands = XAEqualizerItfImpl_GetNumberOfBands;
+        self->itf.GetNumberOfPresets = XAEqualizerItfImpl_GetNumberOfPresets;
+        self->itf.GetPresetName = XAEqualizerItfImpl_GetPresetName;
+        self->itf.IsEnabled = XAEqualizerItfImpl_IsEnabled;
+        self->itf.SetBandLevel = XAEqualizerItfImpl_SetBandLevel;
+        self->itf.SetEnabled = XAEqualizerItfImpl_SetEnabled;
+        self->itf.UsePreset = XAEqualizerItfImpl_UsePreset;
+
+        /* init variables */
+        self->enabled = XA_BOOLEAN_FALSE;
+        self->preset = XA_EQUALIZER_UNDEFINED;
+
+        for(index = 0; index < EQUALIZER_NUM_OF_BANDS; index++)
+        {
+            self->levels[index] = EQUALIZER_DEFAULT_BAND_LEVEL;
+            self->changeLevel[index] = XA_BOOLEAN_FALSE;
+        }
+
+        self->adapCtx = adapCtx;
+
+        self->self = self;
+    }
+
+    DEBUG_API("<-XAEqualizerItfImpl_Create");
+    return self;
+}
+#endif
+/**
+ * void XAEqualizerItfImpl_Free(XAEqualizerItfImpl* self)
+ * @param  XAEqualizerItfImpl* self -
+ **/
+void XAEqualizerItfImpl_Free(XAEqualizerItfImpl* self)
+{
+    DEBUG_API("->XAEqualizerItfImpl_Free");
+    assert(self==self->self);
+    free(self);
+    DEBUG_API("<-XAEqualizerItfImpl_Free");
+}