// 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:

// Reference EGL implementation to support EGL sync objects and OpenWF extensions

#include "eglprivate.h"

CEglSync::CEglSync(CEglDisplay& aDisplay):

    iDisplay(aDisplay),

    iType(EGL_SYNC_REUSABLE_KHR),

    iStatus(EGL_UNSIGNALED_KHR)

    {

    }

CEglSync::~CEglSync()

    {

    iCondVar.Close();

    iMutex.Close();

    }

TInt CEglSync::Construct()

    {

    TInt err = iMutex.CreateLocal();

    if (err != KErrNone)

        {

        return err;

        }

    err = iCondVar.CreateLocal();

    if (err != KErrNone)

        {

        return err;

        }

    err = iDisplay.RegisterSyncObj(*this);

    if (err != KErrNone)

        {

        return err;

        }

    iRefCount = 1;

    return KErrNone;

    }

CEglSync* CEglSync::Create(CEglDisplay& aDisplay)

    {

    // sync object will be allocated in the EGL shared heap and added to sync object list

    // we need to switch current heap to EGL shared heap

    //

    RHeap* callerHeap = User::SwitchHeap(&aDisplay.Heap());

    CEglSync* syncObj = new CEglSync(aDisplay);

    if (!syncObj)

        {

        User::SwitchHeap(callerHeap);

        return NULL;

        }

    const TInt err = syncObj->Construct();

    if (err != KErrNone)

        {

        delete syncObj;

        User::SwitchHeap(callerHeap);

        return NULL;

        }

    User::SwitchHeap(callerHeap);

    return syncObj;

    }

void CEglSync::Destroy()

    {

    // multiple calls to Destroy() is not allowed, it's either coming from eglDestroySyncKHR or eglTerminate

    //

    __ASSERT_DEBUG(!iIsDestroyed, User::Panic(KEglPanicCategory, EEglPanicSyncObjHasBeenDestroyed));

    iIsDestroyed = ETrue;

    // wake up all waiting threads

    iCondVar.Broadcast();

    // always remove sync obj from hash map when it is destroyed, the actual deletion will be done from Close(),

    // which can happen when eglClientWaitSyncKHR is called by user

    RHeap* callerHeap = User::SwitchHeap(&iDisplay.Heap());

    iDisplay.UnregisterSyncObj(*this);

    User::SwitchHeap(callerHeap);

    // decrement refcount for this sync obj, it will delete the object if refcount is zero

    Close();

    }

void CEglSync::Close()

    {

    if (--iRefCount == 0)

        {

        // we're here either from Destroy() or eglClientWaitSyncKHR

        RHeap* callerHeap = User::SwitchHeap(&iDisplay.Heap());

        delete this;

        User::SwitchHeap(callerHeap);

        }

    }

void CEglSync::Signal(EGLenum aMode)

    {

    iMutex.Wait();

    if (iStatus != aMode)

        {

        iStatus = aMode;

        if (iStatus == EGL_SIGNALED_KHR)

            {

            iCondVar.Broadcast();

            }

        }

    iMutex.Signal();

    }

EGLint CEglSync::Wait(EGLTimeKHR aTimeOut)

    {

    // driver display lock is not held when we're about to enter block wait on condition variable

    // we use sync object mutex to synchronise threads access from this point until end of this function

    iMutex.Wait();

    EGLint errCode = EGL_CONDITION_SATISFIED_KHR;

    if (iStatus == EGL_UNSIGNALED_KHR)

        {

        switch(aTimeOut) 

            {

            case EGL_FOREVER_KHR:

                {

                const TInt res = iCondVar.Wait(iMutex); 

                //we do not expect to fail here

                __ASSERT_DEBUG(res == KErrNone, User::Panic(KEglPanicCategory, EEglPanicCondVarWaitFail));

                break;

                }

            case 0:

                {

                //by setting this we notify the caller that the sync object is in unsignaled state

                errCode = EGL_TIMEOUT_EXPIRED_KHR; 

                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.      

                //

                TInt res = KErrTimedOut;

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

                    {

                    res = iCondVar.TimedWait(iMutex, (timeoutMicroseconds > KMaxTInt?KMaxTInt:timeoutMicroseconds));

                    //we do not expect to fail here

                    __ASSERT_DEBUG(res == KErrNone || res == KErrTimedOut, User::Panic(KEglPanicCategory, EEglPanicCondVarTimedWaitFail));

                    }

                if(res == KErrTimedOut)

                    {

                    errCode = EGL_TIMEOUT_EXPIRED_KHR;

                    }

                break;

                }

            }

        }

    iMutex.Signal();

    return errCode;

    }