// Copyright (c) 2010 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:

// EGL sync implementation

#include "eglapi.h"

const EGLint CEglSync::KSupportedFlags = EGL_SYNC_FLUSH_COMMANDS_BIT_KHR;

// ToDo get rid of these macros

#define EGL_SET_ERROR(e)                    { Instance().SetError(e); }

#define TEST_AND_RET(c, r, t)               { if (!(c)) { EGL_TRACE(t); return (r); } }

#define TEST_CLEANUP_RET(c, r, clnp, t)     { if (!(c)) { clnp; EGL_TRACE(t); return (r); } }

#define CHECK_AND_RET(c, e, r, t)           { if (!(c)) { EGL_SET_ERROR(e); EGL_TRACE(t); return (r); } }

#define CHECK_CLEANUP_RET(c, e, r, clnp, t) { if (!(c)) { EGL_SET_ERROR(e); clnp; EGL_TRACE(t); return (r); } }

#define RESET_EGL_ERROR()                   { EGL_SET_ERROR(EGL_SUCCESS); }

// ToDo use EGL Panics & panic messages

void SyncPanic(TInt aPanic)

    {

    _LIT(KPanic, "EGL SYNC");

    User::Panic(KPanic, aPanic);

    }

CEglSync* CEglSync::Create(RFastLock& aFrontLock, EGLSyncKHR aSync, EGLDisplay aDisplay, EGLenum aType)

    {

    CEglSync* sync= new CEglSync(aFrontLock, aSync, aDisplay, aType);

    TEST_AND_RET(sync != NULL, sync, "CEglSync::Create couldn't create the object");

    if (KErrNone == sync->Initialize())

        {

        EGL_TRACE("CEglSync::Create OK aDisplay=%d aSync=%d aSyncType=0x%x", aDisplay, aSync, aType);

        return sync;

        }

    else

        {

        EGL_TRACE("CEglSync::Create FAILED aDisplay=%d aSync=%d aSyncType=0x%x", aDisplay, aSync, aType);

        delete sync;

        return NULL;

        }

    }

TInt CEglSync::Initialize()

    {

    TInt err = KErrNone;

    err = iSyncMutex.CreateLocal();

    TEST_AND_RET(err == KErrNone, err, "CEglSync::Initialize failed to create mutex");

    err = iSyncCondVar.CreateLocal();

    TEST_AND_RET(err == KErrNone, err, "CEglSync::Initialize failed to create cond var");

    return err;

    }

CEglSync::CEglSync(RFastLock& aFrontLock, EGLSyncKHR aSync, EGLDisplay aDisplay, EGLenum aType):

iEglSync(aSync),

iDisplay(aDisplay),

iSyncType(aType),

iSyncState(EGL_UNSIGNALED_KHR),

iDestroyed(EGL_FALSE),

iWaiters(0),

iFrontLock(aFrontLock)

    {

    }

CEglSync::~CEglSync()

    {

    iSyncMutex.Close();

    iSyncCondVar.Close();

    EGL_TRACE("CEglSync::~CEglSync iDisplay=%d iEglSync=%d", iDisplay, iEglSync);

    }

EGLBoolean CEglSync::DestroySyncReady()

    {

    EGL_TRACE("CEglSync::DestroySync iDisplay=%d iEglSync=%d iWaiters=%d", iDisplay, iEglSync, iWaiters);

    iSyncMutex.Wait();

    if (iWaiters == 0)

        {

        EGL_TRACE("CEglSync::DestroySync READY TO DESTROY iDisplay=%d iEglSync=%d iWaiters=%d", iDisplay, iEglSync, iWaiters);

        iDestroyed = EGL_TRUE;

        return EGL_TRUE;

        }

    else if (!iDestroyed)

        {

        EGL_TRACE("CEglSync::DestroySync BROADCAST iDisplay=%d iEglSync=%d iWaiters=%d", iDisplay, iEglSync, iWaiters);

        iSyncCondVar.Broadcast();

        }

    iDestroyed = EGL_TRUE;

    iSyncMutex.Signal();

    return EGL_FALSE;

    }

EGLint CEglSync::SignalSync(EGLenum aMode)

    {

    EGL_TRACE("CEglSync::SignalSync aMode=%d", aMode);

    iSyncMutex.Wait();

    if (aMode != iSyncState)

        {

        iSyncState = aMode;

        if (aMode == EGL_SIGNALED_KHR)

            {

            iSyncCondVar.Broadcast();

            }

        }

    iSyncMutex.Signal();

    return EGL_SUCCESS;

    }

EGLint CEglSync::ClientWaitSync(EGLint aFlags, EGLTimeKHR aTimeout)

    {

    EGL_TRACE("CEglSync::ClientWaitSync aFlags=%d aTimeout=%d", aFlags, aTimeout);

    CHECK_CLEANUP_RET(!(aFlags & (~KSupportedFlags)),

                  EGL_BAD_PARAMETER,

                  EGL_FALSE,

                  iFrontLock.Signal();,

                  "CEglSync::ClientWaitSync bad flags parameter");

    iSyncMutex.Wait();

    iFrontLock.Signal();

    CHECK_CLEANUP_RET(!iDestroyed ,

                      EGL_BAD_PARAMETER,

                      EGL_FALSE,

                      iSyncMutex.Signal();,

                      "CEglSync::ClientWaitSync sync already destroyed");

    EGLint ret = (EGLint) EGL_FALSE;

    if (iSyncState == EGL_UNSIGNALED_KHR)

        {

        if (aTimeout && (aFlags & EGL_SYNC_FLUSH_COMMANDS_BIT_KHR) && (eglGetCurrentContext() != EGL_NO_CONTEXT))

            {

            switch(eglQueryAPI())

                {

                case EGL_OPENGL_ES_API:

                    //ToDo: make sure these cases are covered

                    //glFlush();

                    break;

                case EGL_OPENVG_API:

                    //ToDo: make sure these cases are covered

                    //vgFlush();

                    break;

                default:

                	SyncPanic(__LINE__);

                }

            }

        switch (aTimeout)

            {

            case 0:

                ret = EGL_TIMEOUT_EXPIRED_KHR;

                break;

            case EGL_FOREVER_KHR:

                {

                EGLint res = KErrNone;

                ++iWaiters;

                EGL_TRACE("CEglSync::ClientWaitSync iSyncCondVar.Wait");

                res = iSyncCondVar.Wait(iSyncMutex);

                --iWaiters;

                if (res == KErrNone)

                    {

                    ret = EGL_CONDITION_SATISFIED_KHR;

                    }

                else

                    {

                    ret = EGL_FALSE;

                    }

                break;

                }

            default:

                {

                    /*

                     * Since the supported range of timeout at function RCondVar::TimedWait(mutex, timeout)

                     * is 0 to KMaxTInt, looping mechanism below is used to support 64bit timeout.

                     */

                    EGLint res = KErrTimedOut;

                    EGL_TRACE("CEglSync::ClientWaitSync iSyncCondVar.TimedWait");

                    for(TInt64 timeoutMicroseconds = aTimeout/1000; (res == KErrTimedOut) && (timeoutMicroseconds > 0); timeoutMicroseconds -= KMaxTInt)

                        {

                        ++iWaiters;

                        res = iSyncCondVar.TimedWait(iSyncMutex, (timeoutMicroseconds > KMaxTInt) ? KMaxTInt:timeoutMicroseconds);

                        --iWaiters;

                        }

                    switch (res)

                        {

                        case KErrNone:

                            ret = EGL_CONDITION_SATISFIED_KHR;

                            break;

                        case KErrTimedOut:

                            ret = EGL_TIMEOUT_EXPIRED_KHR;

                            break;

                        default:

                            ret = EGL_FALSE;

                            break;

                        }

                    break;

                }

            }

        }

    else

        {

            ret = EGL_CONDITION_SATISFIED_KHR;

            EGL_TRACE("CEglSync::ClientWaitSync sync in signalled state");

        }

    if (iDestroyed && (iWaiters == 0))

        {

        EGL_TRACE("CEglSync::ClientWaitSync sync autodestroyed");

        delete this;

        }

    else

        {

        EGL_TRACE("CEglSync::ClientWaitSync release sync mutex");

        iSyncMutex.Signal();

        }

    EGL_TRACE("CEglSync::ClientWaitSync sync exit ret=0x%x", ret);

    return ret;

    }

EGLBoolean CEglSync::GetSyncAttrib(EGLint aAttribute, EGLint *aValue)

    {

    EGL_TRACE("CEglSync::GetSyncAttrib aAttribute=0x%x aValue", aValue);

    CHECK_AND_RET(aValue,

                  EGL_BAD_PARAMETER,

                  EGL_FALSE,

                  "CEglSync::GetSyncAttrib undefined parameter aValue is NUL");

    CHECK_AND_RET((aAttribute == EGL_SYNC_TYPE_KHR) || (aAttribute == EGL_SYNC_STATUS_KHR),

                  EGL_BAD_ATTRIBUTE,

                  EGL_FALSE,

                  "CEglSync::GetSyncAttrib unnexpected attribute parameter");

    iSyncMutex.Wait();

    EGLBoolean ret = EGL_FALSE;

    switch(aAttribute)

        {

        case EGL_SYNC_TYPE_KHR:

            {

            *aValue = iSyncType;

            ret = EGL_TRUE;

            break;

            }

        case EGL_SYNC_STATUS_KHR:

            {

            *aValue = iSyncState;

            ret = EGL_TRUE;

            break;

            }

        default:

            {

            EGL_SET_ERROR(EGL_BAD_ATTRIBUTE);

            }

        }

    iSyncMutex.Signal();

    return ret;

    }

CEglSyncExtension* CEglSyncExtension::Create(CGuestEGL& aEglInstance)

    {

    EGL_TRACE("CEglSyncExtension::Create");

    CEglSyncExtension* eglSyncExt= new CEglSyncExtension(aEglInstance);

    if (eglSyncExt && eglSyncExt->Construct())

        {

        return eglSyncExt;

        }

    delete eglSyncExt;

    return NULL;

    }

EGLBoolean CEglSyncExtension::Construct()

    {

    if  (iEglSyncMapLock.CreateLocal() == KErrNone)

        {

        EGL_TRACE("CEglSyncExtension::Construct OK");

        return EGL_TRUE;

        }

    EGL_TRACE("CEglSyncExtension::Construct FAILED");

    return EGL_FALSE;

    }

CEglSyncExtension::CEglSyncExtension(CGuestEGL& aEglInstance):

iEglSyncMap(),

iEglSyncId(0),

iEglInstance(aEglInstance)

    {

    }

CEglSyncExtension::~CEglSyncExtension()

    {

    if (iEglSyncMapLock.Handle())

        {

        iEglSyncMapLock.Wait();

        }

    EglDestroySync(EGL_NO_DISPLAY);

    iEglSyncMap.Close();

    iEglSyncMapLock.Close();

    }

TInt CEglSyncExtension::EglSyncDisplayCreate(EGLDisplay aDisplay)

    {

        return KErrNone;

    }

void CEglSyncExtension::EglDestroySync(EGLDisplay aDisplay)

	{

	EGL_TRACE("CEglSyncExtension::EglDestroySync");

	REglSyncHashMap::TIter iter(iEglSyncMap);

	while (iter.NextKey())

		{

		CEglSync* const* syncpp = NULL;

		syncpp = iter.CurrentValue();

		if (syncpp && *syncpp && ((aDisplay == EGL_NO_DISPLAY) || (*syncpp)->Display() == aDisplay))

			{

			const EGLint* key = iter.CurrentKey();

			EGLPANIC_ASSERT(key, EEglPanicTemp);

			if (aDisplay != EGL_NO_DISPLAY)

				{

				// we expect that the map is to be closed after removing the elements

				// therefore we can skip to remove the syncs from map

				if (KErrNone != iEglSyncMap.Remove(*key))

					{

					SyncPanic(__LINE__);

					}

				}

			if ((*syncpp)->DestroySyncReady())

				{

				delete *syncpp;

				}

			}

		}

	}

void CEglSyncExtension::EglSyncDisplayDestroy(EGLDisplay aDisplay)

    {

    iEglSyncMapLock.Wait();

    EglDestroySync(aDisplay);

    iEglSyncMapLock.Signal();

    }

EGLSyncKHR CEglSyncExtension::EglCreateSyncKHR(EGLDisplay aDisplay, EGLenum aType, const EGLint* aAttribList)

    {

    EGL_TRACE("CEglSyncExtension::EglCreateSyncKHR aDisplay=%d, aType=%d", aDisplay, aType);

    RESET_EGL_ERROR();

    CHECK_AND_RET(aType == EGL_SYNC_REUSABLE_KHR,

                  EGL_BAD_ATTRIBUTE,

                  EGL_NO_SYNC_KHR,

                  "CEglSyncExtension::EglCreateSyncKHR unsupported sync type");

    CHECK_AND_RET((aAttribList == NULL) || (*aAttribList == EGL_NONE),

                  EGL_BAD_ATTRIBUTE,

                  EGL_NO_SYNC_KHR,

                  "CEglSyncExtension::EglCreateSyncKHR invalid attribute list");

    EGLint lockErr = FindAndLockDisplay(aDisplay);

    CHECK_AND_RET(lockErr == EGL_SUCCESS,

                      lockErr,

                      EGL_NO_SYNC_KHR,

                      "CEglSyncExtension::EglCreateSyncKHR couldn't find and lock display");

    RHeap* callerHeap = CVghwUtils::SwitchToVghwHeap();

    iEglSyncMapLock.Wait();

    ReleaseDisplayLock(aDisplay);

    EGLSyncKHR dispRet = CreateSync(aDisplay, aType);

    iEglSyncMapLock.Signal();

    CVghwUtils::SwitchFromVghwHeap(callerHeap);

    EGL_TRACE("CEglSyncExtension::EglCreateSyncKHR EXIT aDisplay=%d, sync=%d", aDisplay, dispRet);

    return dispRet;

    }

EGLBoolean CEglSyncExtension::EglDestroySyncKHR(EGLDisplay aDisplay, EGLSyncKHR aSync)

    {

    EGL_TRACE("CEglSyncExtension::EglDestroySyncKHR aDisplay=%d, aSync=%d", aDisplay, aSync);

    RESET_EGL_ERROR();

    EGLint lockErr = FindAndLockDisplay(aDisplay);

    CHECK_AND_RET(lockErr == EGL_SUCCESS,

                      lockErr,

                      EGL_FALSE,

                      "CEglSyncExtension::EglDestroySyncKHR couldn't find and lock display");

    RHeap* callerHeap = CVghwUtils::SwitchToVghwHeap();

    iEglSyncMapLock.Wait();

    ReleaseDisplayLock(aDisplay);

    CEglSync** sync = iEglSyncMap.Find((EGLint)aSync);

    CHECK_CLEANUP_RET(sync && (*sync) && ((*sync)->Display() == aDisplay),

                      EGL_BAD_PARAMETER,

                      EGL_FALSE,

                      iEglSyncMapLock.Signal(),

                      "CEglSyncDisplayMap::EglDestroySyncKHR cannot find the sync");

    if (KErrNone != iEglSyncMap.Remove((EGLint)aSync))

        {

		SyncPanic(__LINE__);

        }

    if ((*sync)->DestroySyncReady())

        {

        delete *sync;

        }

    iEglSyncMapLock.Signal();

    CVghwUtils::SwitchFromVghwHeap(callerHeap);

    EGL_TRACE("CEglSyncExtension::EglDestroySyncKHR EXIT aDisplay=%d, aSync=%d ret=%s", aDisplay, aSync, "EGL_TRUE");

    return EGL_TRUE;

    }

EGLBoolean CEglSyncExtension::EglSignalSyncKHR(EGLDisplay aDisplay, EGLSyncKHR aSync, EGLenum aMode)

    {

    EGL_TRACE("CEglSyncExtension::EglSignalSyncKHR aDisplay=%d, aSync=%d aMode=%d", aDisplay, aSync, aMode);

    EGLBoolean ret = EGL_FALSE;

    RESET_EGL_ERROR();

    CHECK_AND_RET((aMode == EGL_SIGNALED_KHR) || (aMode == EGL_UNSIGNALED_KHR),

                   EGL_BAD_PARAMETER,

                   ret,

                   "CEglSyncExtension::EglSignalSyncKHR unsupported sync mode");

    EGLint lockErr = FindAndLockDisplay(aDisplay);

    CHECK_AND_RET(lockErr == EGL_SUCCESS,

                      lockErr,

                      EGL_FALSE,

                      "CEglSyncExtension::EglSignalSyncKHR couldn't find and lock display");

    RHeap* callerHeap = CVghwUtils::SwitchToVghwHeap();

    iEglSyncMapLock.Wait();

    ReleaseDisplayLock(aDisplay);

    CEglSync** sync= iEglSyncMap.Find((EGLint)aSync);

    CHECK_CLEANUP_RET(sync && (*sync) && ((*sync)->Display()==aDisplay),

                      EGL_BAD_PARAMETER,

                      EGL_FALSE,

                      iEglSyncMapLock.Signal(); CVghwUtils::SwitchFromVghwHeap(callerHeap);,

                      "CEglSyncExtension::EglSignalSyncKHR cannot find the lock");

    TEST_CLEANUP_RET((*sync)->Display() == EGL_SYNC_REUSABLE_KHR,

                     EGL_BAD_MATCH,

                     iEglSyncMapLock.Signal(); CVghwUtils::SwitchFromVghwHeap(callerHeap);,

                     "CEglSyncExtension::EglSignalSyncKHR bad sync type");

    EGLint signalRet = (*sync)->SignalSync(aMode);

    if (signalRet != EGL_SUCCESS)

        {

        EGL_SET_ERROR(ret);

        EGL_TRACE("CEglSyncExtension::EglSignalSyncKHR failed (%d)", ret);

        ret = EGL_FALSE;

        }

    else

        {

        ret = EGL_TRUE;

        }

    iEglSyncMapLock.Signal();

    CVghwUtils::SwitchFromVghwHeap(callerHeap);

    EGL_TRACE("CEglSyncExtension::EglSignalSyncKHR EXIT aDisplay=%d, aSync=%d ret=%s", aDisplay, aSync, ret ? "EGL_TRUE":"EGL_FALSE");

    return ret;

    }

EGLint CEglSyncExtension::Egl_Private_SignalSyncNOK(EGLDisplay aDisplay, EGLSyncKHR aSync, EGLenum aMode)

    {

    EGL_TRACE("CEglSyncExtension::EglPrivateSignalSyncKHR aDisplay=%d, aSync=%d aMode=%d", aDisplay, aSync, aMode);

    TEST_AND_RET((aMode == EGL_SIGNALED_KHR) || (aMode == EGL_UNSIGNALED_KHR),

                 EGL_BAD_PARAMETER,

                 "CEglSyncExtension::EglPrivateSignalSyncKHR unsupported sync mode");

    EGLint lockErr = FindAndLockDisplay(aDisplay);

    TEST_AND_RET(lockErr == EGL_SUCCESS,

                     lockErr,

                     "CEglSyncExtension::EglPrivateSignalSyncKHR couldn't find and lock display");

    RHeap* callerHeap = CVghwUtils::SwitchToVghwHeap();

    iEglSyncMapLock.Wait();

    ReleaseDisplayLock(aDisplay);

    CEglSync** sync= iEglSyncMap.Find((EGLint)aSync);

    TEST_CLEANUP_RET(sync && (*sync) && ((*sync)->Display()==aDisplay),

                     EGL_BAD_PARAMETER,

                     iEglSyncMapLock.Signal(); CVghwUtils::SwitchFromVghwHeap(callerHeap);,

                     "CEglSyncExtension::EglPrivateSignalSyncKHR cannot find the lock");

    EGLint ret = (*sync)->SignalSync(aMode);

    if (ret != EGL_SUCCESS)

        {

        EGL_TRACE("CEglSyncExtension::EglPrivateSignalSyncKHR failed (%d)", ret);

        }

    iEglSyncMapLock.Signal();