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