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

     }