// 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:
// eglsynchelper.c
//

#include "eglsynchelper.h"
#include "EGL/egltypes.h"

#ifndef EGL_EGLEXT_PROTOTYPES

#define EGLSYNC_TYPE 0xE5

/* sync object data type for POSIX thread implementation*/

typedef struct CondVarSync_* NativeSyncType;

#ifdef __cplusplus
extern "C" {
#endif

/*-------------------------------------------------------------------*//*!
 * \brief   Create a sync object for the specified display.
 * \ingroup api
 * \param   dpy     Identifier of the display which will own the sync object
 * \param   type    Type of the sync object. EGL_SYNC_REUSABLE_KHR is only supported
 * \param   attrib_list Attribute-value list specifying attributes of the sync 
 * object, terminated by an attribute entry EGL_NONE
 * \return  Handle for the created sync object if successful, EGL_NO_SYNC_KHR otherwise
 * \error   EGL_BAD_DISPLAY if <dpy> is not a name of a valid EGLDisplay;
 * EGL_NOT_INITIALIZED if the display object associated with the <dpy> has not been initialized;
 * EGL_BAD_ATTRIBUTE if <attrib_list> is neither NULL nor empty (containing only EGL_NONE) or 
 * if <type> is not a supported type of sync object;
 * EGL_BAD_ALLOC if the memory allocation related to sync object is not successful
 * \note    If <type> is EGL_SYNC_REUSABLE_KHR, a reusable sync object is created. 
 * In this case <attrib_list> must be NULL or empty (containing only EGL_NONE).
 *  *//*-------------------------------------------------------------------*/
EGLSyncKHR eglCreateSyncKHR( EGLDisplay dpy,
                       EGLenum condition,
                       const EGLint *attrib_list )
{
    PFNEGLCREATESYNCKHRPROC createPointer = (PFNEGLCREATESYNCKHRPROC) eglGetProcAddress("eglCreateSyncKHR");

	if (createPointer == NULL)
		{
		return EGL_NO_SYNC_KHR;
		}
	else
		{
		return createPointer(dpy, condition, attrib_list);
		}
}


/*-------------------------------------------------------------------*//*!
 * \brief   Destroy a sync object and free memory associated with it
 * \ingroup api
 * \param   dpy     Identifier of the display which owns the sync object
 * \param   sync    Sync object handle. 
 * \return  EGL_TRUE if deletion was successful and EGL_FALSE otherwise
 * \error   EGL_BAD_DISPLAY if <dpy> is not a name of a valid EGLDisplay;
 * EGL_NOT_INITIALIZED if the display object associated with the <dpy> has not been initialized;
 * EGL_BAD_PARAMETER if <sync> is not a valid sync object for <dpy>
 * \note    If any eglClientWaitSyncKHR commands are blocking on <sync> when 
 * eglDestroySyncKHR is called, they will be woken up, as if <sync> were signaled. 
 * If no errors are generated, <sync> will no longer be the handle of a valid sync object.
 *//*-------------------------------------------------------------------*/
EGLBoolean eglDestroySyncKHR( EGLDisplay dpy, EGLSyncKHR sync )
{
    PFNEGLDESTROYSYNCKHRPROC destroyPointer = (PFNEGLDESTROYSYNCKHRPROC) eglGetProcAddress("eglDestroySyncKHR");

	if (destroyPointer == NULL)
		{
		return EGL_FALSE;
		}
	else
		{
		return destroyPointer(dpy, sync);
		}
}

/*-------------------------------------------------------------------*//*!
 * \brief   Blocks the calling thread until the specified sync object 
 * is signaled, or until <timeout> nanoseconds have passed.  
 * \ingroup api
 * \param   dpy     Identifier of the display which owns the sync object.
 * \param   sync    Sync object handle. 
 * \param   flags   If the EGL_FLUSH_COMMANDS_BIT_KHR bit is set in <flags>
 * and <sync> is unsignaled when the function is called, then the equivalent
 * of Flush() will be performed for the current API context.   
 * \param   timeout The thread will be unblocked when <timeout> is expired.
 * If the <timeout> is to zero, the function just test the current status 
 * of the sync object. If the <timeout> is set to EGL_FOREVER_KHR, then the 
 * function does not time out. For all other values, <timeout> is adjusted to 
 * the closest value which may be substantially longer than one nanosecond. 
 * \return  EGL_CONDITION_SATISFIED if <sync> was signaled before
 * the timeout expired, which includes the case when <sync> was already 
 * signaled when eglClientWaitSyncKHR was called; EGL_TIMEOUT_EXPIRED_KHR if the 
 * specified timeout period expired before <sync> was signaled; 
 * EGL_FALSE if an error occurs.
 * \error   EGL_BAD_DISPLAY if <dpy> is not a name of a valid EGLDisplay;
 * EGL_NOT_INITIALIZED if the display object associated with the <dpy> has not been initialized;
 * EGL_BAD_PARAMETER if <sync> is not a valid sync object for <dpy> or 
 * if <flags> does not equal to 0 or EGL_SYNC_FLUSH_COMMAND_BIT_KHR
 * Note\    More than one eglClientWaitSyncKHR may be outstanding on the same <sync> at any given time. 
 * When there are multiple threads blocked on the same <sync> and the sync object is signaled, 
 * all such threads are released, but the order in which they are released is not defined.
 * If a sync object is destroyed while an eglClientWaitSyncKHR is blocking on that object, 
 * eglClientWaitSyncKHR will unblock and return immediately, just as if the sync object 
 * had been signaled prior to being destroyed.
 *//*-------------------------------------------------------------------*/
EGLint eglClientWaitSyncKHR( EGLDisplay dpy,
                             EGLSyncKHR sync,
                             EGLint flags,
                             EGLTimeKHR timeout )
{
    PFNEGLCLIENTWAITSYNCKHRPROC clientWaitPointer = (PFNEGLCLIENTWAITSYNCKHRPROC) eglGetProcAddress("eglClientWaitSyncKHR");

	if (clientWaitPointer == NULL)
		{
		return EGL_FALSE;
		}
	else
		{
		return clientWaitPointer(dpy, sync, flags, timeout);
		}
}

/*-------------------------------------------------------------------*//*!
 * \brief   Signals or unsignals the reusable sync object.  
 * \ingroup api
 * \param   dpy     Identifier of the display which owns the sync object.
 * \param   sync    Sync object handle. 
 * \param   mode    Status of the sync object. There are two possible states: 
 *  EGL_SIGNALED_KHR and EGL_UNSIGNALED_KHR. 
 * \return  EGL_TRUE if an operation was successful and EGL_FALSE otherwise.
 * \note    The error code returned from eglSignalSyncImpl() will be generated
 *//*-------------------------------------------------------------------*/
EGLBoolean eglSignalSyncKHR( EGLDisplay dpy,
                             EGLSyncKHR sync,
                             EGLenum mode )
{
    PFNEGLSIGNALSYNCKHRPROC signalPointer = (PFNEGLSIGNALSYNCKHRPROC) eglGetProcAddress("eglSignalSyncKHR");
	
   if (signalPointer == NULL)
	   {
	   return EGL_FALSE;
       }
   else
	   {
	   return signalPointer(dpy, sync, mode);
	   }
}


/*-------------------------------------------------------------------*//*!
 * \brief   Query an attribute of the sync object  
 * \ingroup api
 * \param   dpy     Identifier of the display which owns the sync object
 * \param   sync    Sync object handle. 
 * \param   attribute   An attribute to be retrieved. 
 * \param   value   Pointer to the value for the requested attribute which will be filled on function return. 
 * \return  EGL_TRUE if an operation was successful and EGL_FALSE otherwise
 * \error   EGL_BAD_DISPLAY if <dpy> is not a name of a valid EGLDisplay;
 * EGL_NOT_INITIALIZED if the display object associated with the <dpy> has not been initialized;
 * EGL_BAD_PARAMETER if <sync> is not a valid sync object for <dpy> or if <value> is not 
 * a valid pointer; EGL_BAD_ATTRIBUTE if <attribute>  does not lie within expected range;
 * EGL_BAD_MATCH if <attribute> is not supported for the type of sync object passed in <sync>
 *//*-------------------------------------------------------------------*/
EGLBoolean eglGetSyncAttribKHR( EGLDisplay dpy,
                                EGLSyncKHR sync,
                                EGLint attribute,
                                EGLint *value )
{
    PFNEGLGETSYNCATTRIBKHRPROC getAttribPointer = (PFNEGLGETSYNCATTRIBKHRPROC) eglGetProcAddress("eglGetSyncAttribKHR");

	if (getAttribPointer == NULL)
		{
		return EGL_FALSE;
		}
	else
		{
		return getAttribPointer(dpy, sync, attribute, value);
		}
}



#ifdef __cplusplus
}
#endif
#endif