X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fegl%2Fmain%2Feglsurface.h;h=903957a6eb307c0cc9661f753674131b74fdaf33;hb=3e03a3fc5315b488468b28aa40a7e9416f506520;hp=b75fa9c3686643f5641ddb8337fd47180afa0b0b;hpb=8fc433fa0f8c5364454858f9be919387feda440c;p=mesa.git diff --git a/src/egl/main/eglsurface.h b/src/egl/main/eglsurface.h index b75fa9c3686..903957a6eb3 100644 --- a/src/egl/main/eglsurface.h +++ b/src/egl/main/eglsurface.h @@ -1,114 +1,283 @@ +/************************************************************************** + * + * Copyright 2008 VMware, Inc. + * Copyright 2009-2010 Chia-I Wu + * Copyright 2010 LunarG, Inc. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sub license, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice (including the + * next paragraph) shall be included in all copies or substantial portions + * of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + * + **************************************************************************/ + + #ifndef EGLSURFACE_INCLUDED #define EGLSURFACE_INCLUDED +#include "c99_compat.h" #include "egltypedefs.h" +#include "egldisplay.h" +#ifdef __cplusplus +extern "C" { +#endif + +struct _egl_xy +{ + EGLint x; + EGLint y; +}; + +struct _egl_hdr_metadata +{ + struct _egl_xy display_primary_r; + struct _egl_xy display_primary_g; + struct _egl_xy display_primary_b; + struct _egl_xy white_point; + EGLint max_luminance; + EGLint min_luminance; + EGLint max_cll; + EGLint max_fall; +}; + /** * "Base" class for device driver surfaces. */ struct _egl_surface { - /* Managed by EGLDisplay for linking */ - _EGLDisplay *Display; - _EGLSurface *Next; + /* A surface is a display resource */ + _EGLResource Resource; - /* The bound status of the surface */ - _EGLContext *Binding; - EGLBoolean BoundToTexture; + /* The context that is currently bound to the surface */ + _EGLContext *CurrentContext; _EGLConfig *Config; EGLint Type; /* one of EGL_WINDOW_BIT, EGL_PIXMAP_BIT or EGL_PBUFFER_BIT */ - EGLint Width, Height; - EGLint TextureFormat, TextureTarget; - EGLint MipmapTexture, MipmapLevel; - EGLint SwapInterval; - /* If type == EGL_SCREEN_BIT: */ - EGLint VisibleRefCount; /* number of screens I'm displayed on */ + /* The native surface is lost. The EGL spec requires certain functions + * to generate EGL_BAD_NATIVE_WINDOW when given this surface. + */ + EGLBoolean Lost; + + /* attributes set by attribute list */ + EGLint Width, Height; + EGLenum TextureFormat; + EGLenum TextureTarget; + EGLBoolean MipmapTexture; + EGLBoolean LargestPbuffer; + + /** + * Value of EGL_RENDER_BUFFER selected at creation. + * + * The user may select, for window surfaces, the EGL_RENDER_BUFFER through + * the attribute list of eglCreateWindowSurface(). The EGL spec allows the + * implementation to ignore request, though; hence why we maintain both + * RequestedRenderBuffer and ActiveRenderBuffer. For pbuffer and pixmap + * surfaces, the EGL spec hard-codes the EGL_RENDER_BUFFER value and the + * user must not provide it in the attribute list. + * + * Normally, the attribute is immutable and after surface creation. + * However, EGL_KHR_mutable_render_buffer allows the user to change it in + * window surfaces via eglSurfaceAttrib, in which case + * eglQuerySurface(EGL_RENDER_BUFFER) will immediately afterwards return + * the requested value but the actual render buffer used by the context + * does not change until completion of the next eglSwapBuffers call. + * + * From the EGL_KHR_mutable_render_buffer spec (v12): + * + * Querying EGL_RENDER_BUFFER returns the buffer which client API + * rendering is requested to use. For a window surface, this is the + * attribute value specified when the surface was created or last set + * via eglSurfaceAttrib. + * + * eglQueryContext(EGL_RENDER_BUFFER) ignores this. + */ + EGLenum RequestedRenderBuffer; + + /** + * The EGL_RENDER_BUFFER in use by the context. + * + * This is valid only when bound as the draw surface. This may differ from + * the RequestedRenderBuffer. + * + * Refer to eglQueryContext(EGL_RENDER_BUFFER) in the EGL spec. + * eglQuerySurface(EGL_RENDER_BUFFER) ignores this. + * + * If a window surface is bound as the draw surface and has a pending, + * user-requested change to EGL_RENDER_BUFFER, then the next eglSwapBuffers + * will flush the pending change. (The flush of EGL_RENDER_BUFFER state may + * occur without the implicit glFlush induced by eglSwapBuffers). The spec + * requires that the flush occur at that time and nowhere else. During the + * state-flush, we copy RequestedRenderBuffer to ActiveRenderBuffer. + * + * From the EGL_KHR_mutable_render_buffer spec (v12): + * + * If [...] there is a pending change to the EGL_RENDER_BUFFER + * attribute, eglSwapBuffers performs an implicit flush operation on the + * context and effects the attribute change. + */ + EGLenum ActiveRenderBuffer; + + EGLenum VGAlphaFormat; + EGLenum VGColorspace; + EGLenum GLColorspace; + + /* attributes set by eglSurfaceAttrib */ + EGLint MipmapLevel; + EGLenum MultisampleResolve; + EGLenum SwapBehavior; -#ifdef EGL_VERSION_1_2 - EGLint SwapBehavior; /* one of EGL_BUFFER_PRESERVED/DESTROYED */ EGLint HorizontalResolution, VerticalResolution; EGLint AspectRatio; - EGLint RenderBuffer; /* EGL_BACK_BUFFER or EGL_SINGLE_BUFFER */ - EGLint AlphaFormat; /* EGL_ALPHA_FORMAT_NONPRE or EGL_ALPHA_FORMAT_PRE */ - EGLint Colorspace; /* EGL_COLORSPACE_sRGB or EGL_COLORSPACE_LINEAR */ -#endif /* EGL_VERSION_1_2 */ -}; + EGLint SwapInterval; -extern EGLBoolean -_eglInitSurface(_EGLDriver *drv, _EGLSurface *surf, EGLint type, - _EGLConfig *config, const EGLint *attrib_list); + /* EGL_KHR_partial_update + * True if the damage region is already set + * between frame boundaries. + */ + EGLBoolean SetDamageRegionCalled; + /* EGL_KHR_partial_update + * True if the buffer age is read by the client + * between frame boundaries. + */ + EGLBoolean BufferAgeRead; -extern EGLBoolean -_eglSwapBuffers(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf); + /* True if the surface is bound to an OpenGL ES texture */ + EGLBoolean BoundToTexture; + EGLBoolean PostSubBufferSupportedNV; -extern EGLBoolean -_eglCopyBuffers(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf, NativePixmapType target); + struct _egl_hdr_metadata HdrMetadata; + void *NativeSurface; +}; -extern EGLBoolean -_eglQuerySurface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf, EGLint attribute, EGLint *value); +extern EGLBoolean +_eglInitSurface(_EGLSurface *surf, _EGLDisplay *disp, EGLint type, + _EGLConfig *config, const EGLint *attrib_list, + void *native_surface); -extern _EGLSurface * -_eglCreateWindowSurface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf, NativeWindowType window, const EGLint *attrib_list); +extern EGLBoolean +_eglQuerySurface(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf, EGLint attribute, EGLint *value); -extern _EGLSurface * -_eglCreatePixmapSurface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf, NativePixmapType pixmap, const EGLint *attrib_list); +extern EGLBoolean +_eglSurfaceAttrib(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf, EGLint attribute, EGLint value); -extern _EGLSurface * -_eglCreatePbufferSurface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf, const EGLint *attrib_list); +extern EGLBoolean +_eglBindTexImage(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf, EGLint buffer); extern EGLBoolean -_eglDestroySurface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf); +_eglReleaseTexImage(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf, EGLint buffer); extern EGLBoolean -_eglSurfaceAttrib(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf, EGLint attribute, EGLint value); +_eglSwapInterval(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf, EGLint interval); +extern EGLBoolean +_eglSurfaceHasMutableRenderBuffer(_EGLSurface *surf); extern EGLBoolean -_eglBindTexImage(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf, EGLint buffer); +_eglSurfaceInSharedBufferMode(_EGLSurface *surf); +/** + * Increment reference count for the surface. + */ +static inline _EGLSurface * +_eglGetSurface(_EGLSurface *surf) +{ + if (surf) + _eglGetResource(&surf->Resource); + return surf; +} -extern EGLBoolean -_eglReleaseTexImage(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf, EGLint buffer); +/** + * Decrement reference count for the surface. + */ +static inline EGLBoolean +_eglPutSurface(_EGLSurface *surf) +{ + return (surf) ? _eglPutResource(&surf->Resource) : EGL_FALSE; +} -extern EGLBoolean -_eglSwapInterval(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf, EGLint interval); + +/** + * Link a surface to its display and return the handle of the link. + * The handle can be passed to client directly. + */ +static inline EGLSurface +_eglLinkSurface(_EGLSurface *surf) +{ + _eglLinkResource(&surf->Resource, _EGL_RESOURCE_SURFACE); + return (EGLSurface) surf; +} -#ifdef EGL_VERSION_1_2 +/** + * Unlink a linked surface from its display. + * Accessing an unlinked surface should generate EGL_BAD_SURFACE error. + */ +static inline void +_eglUnlinkSurface(_EGLSurface *surf) +{ + _eglUnlinkResource(&surf->Resource, _EGL_RESOURCE_SURFACE); +} -extern _EGLSurface * -_eglCreatePbufferFromClientBuffer(_EGLDriver *drv, _EGLDisplay *dpy, - EGLenum buftype, EGLClientBuffer buffer, - _EGLConfig *conf, const EGLint *attrib_list); -#endif /* EGL_VERSION_1_2 */ +/** + * Lookup a handle to find the linked surface. + * Return NULL if the handle has no corresponding linked surface. + */ +static inline _EGLSurface * +_eglLookupSurface(EGLSurface surface, _EGLDisplay *disp) +{ + _EGLSurface *surf = (_EGLSurface *) surface; + if (!disp || !_eglCheckResource((void *) surf, _EGL_RESOURCE_SURFACE, disp)) + surf = NULL; + return surf; +} /** - * Return true if the surface is bound to a thread. - * A surface bound to a texutre is not considered bound by - * this function. + * Return the handle of a linked surface, or EGL_NO_SURFACE. */ -static INLINE EGLBoolean -_eglIsSurfaceBound(_EGLSurface *surf) +static inline EGLSurface +_eglGetSurfaceHandle(_EGLSurface *surf) { - return (surf->Binding != NULL); + _EGLResource *res = (_EGLResource *) surf; + return (res && _eglIsResourceLinked(res)) ? + (EGLSurface) surf : EGL_NO_SURFACE; } +#ifdef __cplusplus +} +#endif + #endif /* EGLSURFACE_INCLUDED */