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