/*

* 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 "xaimageeffectsitf.h"

#include "xaimageeffectsitfadaptation.h"

static XAImageEffectsItfImpl* GetImpl(XAImageEffectsItf self)

{

    if(self)

    {

        XAImageEffectsItfImpl* impl = (XAImageEffectsItfImpl*)(*self);

        if(impl && (impl == impl->self))

        {

            return impl;

        }

    }

    return NULL;

}

/**

 * Base interface XAImageEffectsItf implementation

 */

/**

 * XAresult XAImageEffectsItfImpl_QuerySupportedImageEffects(XAImageEffectsItf self,

 *                                                           XAuint32 index,

 *                                                           XAuint32 *pImageEffectId)

 * Description: Queries image effects supported.

 **/

XAresult XAImageEffectsItfImpl_QuerySupportedImageEffects(XAImageEffectsItf self,

                                                          XAuint32 index,

                                                          XAuint32 *pImageEffectId)

{

    XAresult ret = XA_RESULT_SUCCESS;

    XAImageEffectsItfImpl* impl = GetImpl(self);

    DEBUG_API("->XAImageEffectsItfImpl_QuerySupportedImageEffects");

    if(!impl || !pImageEffectId)

    {

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        /* invalid parameter */

        DEBUG_API("<-XAImageEffectsItfImpl_QuerySupportedImageEffects");

        return XA_RESULT_PARAMETER_INVALID;

    }

    ret = XAAdaptationBase_ThreadEntry(impl->adapCtx);

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

    {

        DEBUG_API("<-XAImageEffectsItfImpl_QuerySupportedImageEffects");

        return ret;

    }

    ret = XAImageEffectsItfAdapt_QuerySupportedImageEffects((XAAdaptationGstCtx*)impl->adapCtx, index,

                                                            pImageEffectId);

    if( ret == XA_RESULT_SUCCESS )

    {

        impl->index = index;

    }

    XAAdaptationBase_ThreadExit(impl->adapCtx);

    DEBUG_API("<-XAImageEffectsItfImpl_QuerySupportedImageEffects");

    return ret;

}

/**

 * XAresult XAImageEffectsItfImpl_EnableImageEffect(XAImageEffectsItf self,

 *                                                  XAuint32 imageEffectID

 * Description: Enables an image effect.

 **/

XAresult XAImageEffectsItfImpl_EnableImageEffect(XAImageEffectsItf self,

                                                 XAuint32 imageEffectID)

{

    XAresult ret = XA_RESULT_SUCCESS;

    XAImageEffectsItfImpl* impl = GetImpl(self);

    DEBUG_API("->XAImageEffectsItfImpl_EnableImageEffect");

    if(!impl)

    {

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        /* invalid parameter */

        DEBUG_API("<-XAImageEffectsItfImpl_EnableImageEffect");

        return XA_RESULT_PARAMETER_INVALID;

    }

    ret = XAAdaptationBase_ThreadEntry(impl->adapCtx);

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

    {

        DEBUG_API("<-XAImageEffectsItfImpl_EnableImageEffect");

        return ret;

    }

    ret = XAImageEffectsItfAdapt_EnableImageEffect((XAAdaptationGstCtx*)impl->adapCtx, imageEffectID);

    if( ret == XA_RESULT_SUCCESS )

    {

        impl->imageEffectID = imageEffectID;

    }

    XAAdaptationBase_ThreadExit(impl->adapCtx);

    DEBUG_API("<-XAImageEffectsItfImpl_EnableImageEffect");

    return ret;

}

/**

 * XAresult XAImageEffectsItfImpl_DisableImageEffect(XAImageEffectsItf self,

 *                                                   XAuint32 imageEffectID)

 * Description: Disable an image effect.

 **/

XAresult XAImageEffectsItfImpl_DisableImageEffect(XAImageEffectsItf self,

                                                  XAuint32 imageEffectID)

{

    XAresult ret = XA_RESULT_SUCCESS;

    XAImageEffectsItfImpl* impl = GetImpl(self);

    DEBUG_API("->XAImageEffectsItfImpl_DisableImageEffect");

    if(!impl)

    {

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        /* invalid parameter */

        DEBUG_API("<-XAImageEffectsItfImpl_DisableImageEffect");

        return XA_RESULT_PARAMETER_INVALID;

    }

    ret = XAAdaptationBase_ThreadEntry(impl->adapCtx);

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

    {

        DEBUG_API("<-XAImageEffectsItfImpl_DisableImageEffect");

        return ret;

    }

    ret = XAImageEffectsItfAdapt_DisableImageEffect((XAAdaptationGstCtx*)impl->adapCtx, imageEffectID);

    if( ret == XA_RESULT_SUCCESS )

    {

        impl->imageEffectID = NO_IMAGE_EFFECTS;

    }

    XAAdaptationBase_ThreadExit(impl->adapCtx);

    DEBUG_API("<-XAImageEffectsItfImpl_DisableImageEffect");

    return ret;

}

/**

 * XAresult XAImageEffectsItfImpl_IsImageEffectEnabled(XAImageEffectsItf self,

 *                                                     XAuint32 imageEffectID,

 *                                                     XAboolean *pEnabled)

 * Description: Checks to see if an image effect is enabled.

 **/

XAresult XAImageEffectsItfImpl_IsImageEffectEnabled(XAImageEffectsItf self,

                                                    XAuint32 imageEffectID,

                                                    XAboolean *pEnabled)

{

    XAresult ret = XA_RESULT_SUCCESS;

    XAImageEffectsItfImpl* impl = GetImpl(self);

    DEBUG_API("->XAImageEffectsItfImpl_IsImageEffectEnabled");

    if(!impl || !pEnabled)

    {

        DEBUG_ERR("XA_RESUT_PARAMETER_INVALID");

        /* invalid parameter */

        DEBUG_API("<-XAImageEffectsItfImpl_IsImageEffectEnabled");

        return XA_RESULT_PARAMETER_INVALID;

    }

    ret = XAAdaptationBase_ThreadEntry(impl->adapCtx);

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

    {

        DEBUG_API("<-XAImageEffectsItfImpl_IsImageEffectEnabled");

        return ret;

    }

    ret = XAImageEffectsItfAdapt_IsImageEffectEnabled((XAAdaptationGstCtx*)impl->adapCtx, imageEffectID,

                                                      pEnabled);

    XAAdaptationBase_ThreadExit(impl->adapCtx);

    DEBUG_API("<-XAImageEffectsItfImpl_IsImageEffectEnabled");

    return ret;

}

/**

 * XAImageEffectsItfImpl -specific methods

 **/

/**

 * XAImageEffectsItfImplImpl* XAImageEffectsItfImpl_Create()

 * @return  XAImageEffectsItfImplImpl* - Pointer to  ImageEffectsItf interface implementation

 **/

XAImageEffectsItfImpl* XAImageEffectsItfImpl_Create(XAAdaptationBaseCtx *adapCtx)

{

    XAImageEffectsItfImpl* self = (XAImageEffectsItfImpl*)

        calloc(1,sizeof(XAImageEffectsItfImpl));

    DEBUG_API("->XAImageEffectsItfImpl_Create");

    if(self)

    {

        /* init itf default implementation */

        self->itf.DisableImageEffect = XAImageEffectsItfImpl_DisableImageEffect;

        self->itf.EnableImageEffect = XAImageEffectsItfImpl_EnableImageEffect;

        self->itf.IsImageEffectEnabled = XAImageEffectsItfImpl_IsImageEffectEnabled;

        self->itf.QuerySupportedImageEffects = XAImageEffectsItfImpl_QuerySupportedImageEffects;

        /* init variables */

        self->enabled = XA_BOOLEAN_FALSE;

        self->index = 0;

        self->imageEffectID = NO_IMAGE_EFFECTS;

        self->adapCtx = adapCtx;

        self->self = self;

    }

    DEBUG_API("<-XAImageEffectsItfImpl_Create");

    return self;

}

/**

 * void XAImageEffectsItfImpl_Free(XAImageEffectsItfImpl* self)

 * @param  XAImageEffectsItfImpl* self -

 **/

void XAImageEffectsItfImpl_Free(XAImageEffectsItfImpl* self)

{

    DEBUG_API("->XAImageEffectsItfImpl_Free");

    assert(self==self->self);

    free(self);

    DEBUG_API("<-XAImageEffectsItfImpl_Free");

}