/*

* 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"

#include "xaequalizeritfadaptation.h"

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);

    XAuint16 index = 0;

    DEBUG_API("->XAEqualizerItfImpl_SetEnabled");

    if(!impl)

    {

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        DEBUG_API("<-XAEqualizerItfImpl_SetEnabled");

        /* invalid parameter */

        return XA_RESULT_PARAMETER_INVALID;

    }

    if(enabled && !(impl->enabled))

    {

        for(index = 0; index < EQUALIZER_NUM_OF_BANDS; index++)

        {

            if(impl->changeLevel[index])

            {

                ret = XAEqualizerItfAdapt_SetBandLevel((XAAdaptationGstCtx*)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((XAAdaptationGstCtx*)impl->adapCtx, index, EQUALIZER_DEFAULT_BAND_LEVEL);

            if(XA_RESULT_SUCCESS == ret)

            {

                impl->changeLevel[index] = XA_BOOLEAN_FALSE;

            }

        }

    }

    else

    {

        /* do nothing */

    }

    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;

    }

    *pNumBands = EQUALIZER_NUM_OF_BANDS;

    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;

    }

    ret = XAAdaptationBase_ThreadEntry(impl->adapCtx);

    if( ret == XA_RESULT_PARAMETER_INVALID || ret == XA_RESULT_PRECONDITIONS_VIOLATED )

    {

        DEBUG_API("<-XAEqualizerItfImpl_GetBandLevelRange");

        return ret;

    }

    ret = XAEqualizerItfAdapt_GetBandLevelRange((XAAdaptationGstCtx*)impl->adapCtx, pMin, pMax);

    XAAdaptationBase_ThreadExit(impl->adapCtx);

    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;

    }

    ret = XAAdaptationBase_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((XAAdaptationGstCtx*)impl->adapCtx, band, level);

        if(XA_RESULT_SUCCESS == ret)

        {

            impl->levels[band] = level;

        }

    }

    else

    {

        impl->changeLevel[band] = XA_BOOLEAN_TRUE;

        impl->levels[band] = level;

    }

    XAAdaptationBase_ThreadExit(impl->adapCtx);

    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;

    XAEqualizerItfImpl* impl = GetImpl(self);

    DEBUG_API("->XAEqualizerItfImpl_GetBandLevel");

    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];

    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;

    }

    ret = XAAdaptationBase_ThreadEntry(impl->adapCtx);

    if( ret == XA_RESULT_PARAMETER_INVALID || ret == XA_RESULT_PRECONDITIONS_VIOLATED )

    {

        DEBUG_API("<-XAEqualizerItfImpl_GetCenterFreq");

        return ret;

    }

    ret = XAEqualizerItfAdapt_GetCenterFreq((XAAdaptationGstCtx*)impl->adapCtx, band, pCenter);

    XAAdaptationBase_ThreadExit(impl->adapCtx);

    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;

    }

    ret = XAAdaptationBase_ThreadEntry(impl->adapCtx);

    if( ret == XA_RESULT_PARAMETER_INVALID || ret == XA_RESULT_PRECONDITIONS_VIOLATED )

    {

        DEBUG_API("<-XAEqualizerItfImpl_GetBandFreqRange");

        return ret;

    }

    ret = XAEqualizerItfAdapt_GetBandFreqRange((XAAdaptationGstCtx*)impl->adapCtx, band, pMin, pMax);

    XAAdaptationBase_ThreadExit(impl->adapCtx);

    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;

    }

    ret = XAAdaptationBase_ThreadEntry(impl->adapCtx);

    if( ret == XA_RESULT_PARAMETER_INVALID || ret == XA_RESULT_PRECONDITIONS_VIOLATED )

    {

        DEBUG_API("<-XAEqualizerItfImpl_GetBand");

        return ret;

    }

    ret = XAEqualizerItfAdapt_GetBand((XAAdaptationGstCtx*)impl->adapCtx, frequency, pBand);

    XAAdaptationBase_ThreadExit(impl->adapCtx);

    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;