1 /**************************************************************************
3 * Copyright 2008 VMware, Inc.
4 * Copyright 2009-2010 Chia-I Wu <olvaffe@gmail.com>
5 * Copyright 2010 LunarG, Inc.
8 * Permission is hereby granted, free of charge, to any person obtaining a
9 * copy of this software and associated documentation files (the
10 * "Software"), to deal in the Software without restriction, including
11 * without limitation the rights to use, copy, modify, merge, publish,
12 * distribute, sub license, and/or sell copies of the Software, and to
13 * permit persons to whom the Software is furnished to do so, subject to
14 * the following conditions:
16 * The above copyright notice and this permission notice (including the
17 * next paragraph) shall be included in all copies or substantial portions
20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
21 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
23 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
24 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
25 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
26 * DEALINGS IN THE SOFTWARE.
28 **************************************************************************/
32 * Surface-related functions.
39 #include "egldisplay.h"
40 #include "egldriver.h"
41 #include "eglcontext.h"
42 #include "eglconfig.h"
43 #include "eglcurrent.h"
45 #include "eglsurface.h"
49 * Parse the list of surface attributes and return the proper error code.
52 _eglParseSurfaceAttribList(_EGLSurface
*surf
, const EGLint
*attrib_list
)
54 _EGLDisplay
*dpy
= surf
->Resource
.Display
;
55 EGLint type
= surf
->Type
;
56 EGLint texture_type
= EGL_PBUFFER_BIT
;
57 EGLint i
, err
= EGL_SUCCESS
;
58 EGLint attr
= EGL_NONE
;
59 EGLint val
= EGL_NONE
;
64 if (dpy
->Extensions
.NOK_texture_from_pixmap
)
65 texture_type
|= EGL_PIXMAP_BIT
;
67 for (i
= 0; attrib_list
[i
] != EGL_NONE
; i
++) {
68 attr
= attrib_list
[i
++];
72 /* common attributes */
73 case EGL_GL_COLORSPACE_KHR
:
74 if (!dpy
->Extensions
.KHR_gl_colorspace
) {
75 err
= EGL_BAD_ATTRIBUTE
;
79 case EGL_GL_COLORSPACE_SRGB_KHR
:
80 case EGL_GL_COLORSPACE_LINEAR_KHR
:
83 err
= EGL_BAD_ATTRIBUTE
;
85 if (err
!= EGL_SUCCESS
)
87 surf
->GLColorspace
= val
;
89 case EGL_SMPTE2086_DISPLAY_PRIMARY_RX_EXT
:
90 if (!dpy
->Extensions
.EXT_surface_SMPTE2086_metadata
) {
91 err
= EGL_BAD_ATTRIBUTE
;
94 surf
->HdrMetadata
.display_primary_r
.x
= val
;
96 case EGL_SMPTE2086_DISPLAY_PRIMARY_RY_EXT
:
97 if (!dpy
->Extensions
.EXT_surface_SMPTE2086_metadata
) {
98 err
= EGL_BAD_ATTRIBUTE
;
101 surf
->HdrMetadata
.display_primary_r
.y
= val
;
103 case EGL_SMPTE2086_DISPLAY_PRIMARY_GX_EXT
:
104 if (!dpy
->Extensions
.EXT_surface_SMPTE2086_metadata
) {
105 err
= EGL_BAD_ATTRIBUTE
;
108 surf
->HdrMetadata
.display_primary_g
.x
= val
;
110 case EGL_SMPTE2086_DISPLAY_PRIMARY_GY_EXT
:
111 if (!dpy
->Extensions
.EXT_surface_SMPTE2086_metadata
) {
112 err
= EGL_BAD_ATTRIBUTE
;
115 surf
->HdrMetadata
.display_primary_g
.y
= val
;
117 case EGL_SMPTE2086_DISPLAY_PRIMARY_BX_EXT
:
118 if (!dpy
->Extensions
.EXT_surface_SMPTE2086_metadata
) {
119 err
= EGL_BAD_ATTRIBUTE
;
122 surf
->HdrMetadata
.display_primary_b
.x
= val
;
124 case EGL_SMPTE2086_DISPLAY_PRIMARY_BY_EXT
:
125 if (!dpy
->Extensions
.EXT_surface_SMPTE2086_metadata
) {
126 err
= EGL_BAD_ATTRIBUTE
;
129 surf
->HdrMetadata
.display_primary_b
.y
= val
;
131 case EGL_SMPTE2086_WHITE_POINT_X_EXT
:
132 if (!dpy
->Extensions
.EXT_surface_SMPTE2086_metadata
) {
133 err
= EGL_BAD_ATTRIBUTE
;
136 surf
->HdrMetadata
.white_point
.x
= val
;
138 case EGL_SMPTE2086_WHITE_POINT_Y_EXT
:
139 if (!dpy
->Extensions
.EXT_surface_SMPTE2086_metadata
) {
140 err
= EGL_BAD_ATTRIBUTE
;
143 surf
->HdrMetadata
.white_point
.y
= val
;
145 case EGL_SMPTE2086_MAX_LUMINANCE_EXT
:
146 if (!dpy
->Extensions
.EXT_surface_SMPTE2086_metadata
) {
147 err
= EGL_BAD_ATTRIBUTE
;
150 surf
->HdrMetadata
.max_luminance
= val
;
152 case EGL_SMPTE2086_MIN_LUMINANCE_EXT
:
153 if (!dpy
->Extensions
.EXT_surface_SMPTE2086_metadata
) {
154 err
= EGL_BAD_ATTRIBUTE
;
157 surf
->HdrMetadata
.min_luminance
= val
;
159 case EGL_CTA861_3_MAX_CONTENT_LIGHT_LEVEL_EXT
:
160 if (!dpy
->Extensions
.EXT_surface_CTA861_3_metadata
) {
161 err
= EGL_BAD_ATTRIBUTE
;
164 surf
->HdrMetadata
.max_cll
= val
;
166 case EGL_CTA861_3_MAX_FRAME_AVERAGE_LEVEL_EXT
:
167 if (!dpy
->Extensions
.EXT_surface_CTA861_3_metadata
) {
168 err
= EGL_BAD_ATTRIBUTE
;
171 surf
->HdrMetadata
.max_fall
= val
;
173 case EGL_VG_COLORSPACE
:
175 case EGL_VG_COLORSPACE_sRGB
:
176 case EGL_VG_COLORSPACE_LINEAR
:
179 err
= EGL_BAD_ATTRIBUTE
;
182 if (err
!= EGL_SUCCESS
)
184 surf
->VGColorspace
= val
;
186 case EGL_VG_ALPHA_FORMAT
:
188 case EGL_VG_ALPHA_FORMAT_NONPRE
:
189 case EGL_VG_ALPHA_FORMAT_PRE
:
192 err
= EGL_BAD_ATTRIBUTE
;
195 if (err
!= EGL_SUCCESS
)
197 surf
->VGAlphaFormat
= val
;
199 /* window surface attributes */
200 case EGL_RENDER_BUFFER
:
201 if (type
!= EGL_WINDOW_BIT
) {
202 err
= EGL_BAD_ATTRIBUTE
;
205 if (val
!= EGL_BACK_BUFFER
&& val
!= EGL_SINGLE_BUFFER
) {
206 err
= EGL_BAD_ATTRIBUTE
;
209 surf
->RequestedRenderBuffer
= val
;
210 if (surf
->Config
->SurfaceType
& EGL_MUTABLE_RENDER_BUFFER_BIT_KHR
) {
211 /* Unlike normal EGLSurfaces, one with a mutable render buffer
212 * uses the application-chosen render buffer.
214 surf
->ActiveRenderBuffer
= val
;
217 case EGL_POST_SUB_BUFFER_SUPPORTED_NV
:
218 if (!dpy
->Extensions
.NV_post_sub_buffer
||
219 type
!= EGL_WINDOW_BIT
) {
220 err
= EGL_BAD_ATTRIBUTE
;
223 if (val
!= EGL_TRUE
&& val
!= EGL_FALSE
) {
224 err
= EGL_BAD_PARAMETER
;
227 surf
->PostSubBufferSupportedNV
= val
;
229 /* pbuffer surface attributes */
231 if (type
!= EGL_PBUFFER_BIT
) {
232 err
= EGL_BAD_ATTRIBUTE
;
236 err
= EGL_BAD_PARAMETER
;
242 if (type
!= EGL_PBUFFER_BIT
) {
243 err
= EGL_BAD_ATTRIBUTE
;
247 err
= EGL_BAD_PARAMETER
;
252 case EGL_LARGEST_PBUFFER
:
253 if (type
!= EGL_PBUFFER_BIT
) {
254 err
= EGL_BAD_ATTRIBUTE
;
257 surf
->LargestPbuffer
= !!val
;
259 /* for eglBindTexImage */
260 case EGL_TEXTURE_FORMAT
:
261 if (!(type
& texture_type
)) {
262 err
= EGL_BAD_ATTRIBUTE
;
267 case EGL_TEXTURE_RGB
:
268 case EGL_TEXTURE_RGBA
:
272 err
= EGL_BAD_ATTRIBUTE
;
275 if (err
!= EGL_SUCCESS
)
277 surf
->TextureFormat
= val
;
279 case EGL_TEXTURE_TARGET
:
280 if (!(type
& texture_type
)) {
281 err
= EGL_BAD_ATTRIBUTE
;
290 err
= EGL_BAD_ATTRIBUTE
;
293 if (err
!= EGL_SUCCESS
)
295 surf
->TextureTarget
= val
;
297 case EGL_MIPMAP_TEXTURE
:
298 if (!(type
& texture_type
)) {
299 err
= EGL_BAD_ATTRIBUTE
;
302 surf
->MipmapTexture
= !!val
;
304 /* no pixmap surface specific attributes */
306 err
= EGL_BAD_ATTRIBUTE
;
310 if (err
!= EGL_SUCCESS
)
314 if (err
== EGL_SUCCESS
&& type
== EGL_PBUFFER_BIT
) {
315 if ((surf
->TextureTarget
== EGL_NO_TEXTURE
&& surf
->TextureFormat
!= EGL_NO_TEXTURE
) ||
316 (surf
->TextureFormat
== EGL_NO_TEXTURE
&& surf
->TextureTarget
!= EGL_NO_TEXTURE
)) {
317 attr
= surf
->TextureTarget
== EGL_NO_TEXTURE
? EGL_TEXTURE_TARGET
: EGL_TEXTURE_FORMAT
;
322 if (err
!= EGL_SUCCESS
)
323 _eglLog(_EGL_WARNING
, "bad surface attribute 0x%04x", attr
);
330 * Do error check on parameters and initialize the given _EGLSurface object.
331 * \return EGL_TRUE if no errors, EGL_FALSE otherwise.
334 _eglInitSurface(_EGLSurface
*surf
, _EGLDisplay
*dpy
, EGLint type
,
335 _EGLConfig
*conf
, const EGLint
*attrib_list
)
338 EGLint renderBuffer
= EGL_BACK_BUFFER
;
339 EGLint swapBehavior
= EGL_BUFFER_DESTROYED
;
342 /* Swap behavior can be preserved only if config supports this. */
343 if (conf
->SurfaceType
& EGL_SWAP_BEHAVIOR_PRESERVED_BIT
)
344 swapBehavior
= EGL_BUFFER_PRESERVED
;
348 func
= "eglCreateWindowSurface";
349 swapBehavior
= EGL_BUFFER_DESTROYED
;
352 func
= "eglCreatePixmapSurface";
353 renderBuffer
= EGL_SINGLE_BUFFER
;
355 case EGL_PBUFFER_BIT
:
356 func
= "eglCreatePBufferSurface";
359 _eglLog(_EGL_WARNING
, "Bad type in _eglInitSurface");
363 if ((conf
->SurfaceType
& type
) == 0)
364 /* The config can't be used to create a surface of this type */
365 return _eglError(EGL_BAD_MATCH
, func
);
367 _eglInitResource(&surf
->Resource
, sizeof(*surf
), dpy
);
370 surf
->Lost
= EGL_FALSE
;
374 surf
->TextureFormat
= EGL_NO_TEXTURE
;
375 surf
->TextureTarget
= EGL_NO_TEXTURE
;
376 surf
->MipmapTexture
= EGL_FALSE
;
377 surf
->LargestPbuffer
= EGL_FALSE
;
378 surf
->RequestedRenderBuffer
= renderBuffer
;
379 surf
->ActiveRenderBuffer
= renderBuffer
;
380 surf
->VGAlphaFormat
= EGL_VG_ALPHA_FORMAT_NONPRE
;
381 surf
->VGColorspace
= EGL_VG_COLORSPACE_sRGB
;
382 surf
->GLColorspace
= EGL_GL_COLORSPACE_LINEAR_KHR
;
384 surf
->MipmapLevel
= 0;
385 surf
->MultisampleResolve
= EGL_MULTISAMPLE_RESOLVE_DEFAULT
;
386 surf
->SwapBehavior
= swapBehavior
;
388 surf
->HorizontalResolution
= EGL_UNKNOWN
;
389 surf
->VerticalResolution
= EGL_UNKNOWN
;
390 surf
->AspectRatio
= EGL_UNKNOWN
;
392 surf
->PostSubBufferSupportedNV
= EGL_FALSE
;
393 surf
->SetDamageRegionCalled
= EGL_FALSE
;
394 surf
->BufferAgeRead
= EGL_FALSE
;
396 /* the default swap interval is 1 */
397 surf
->SwapInterval
= 1;
399 surf
->HdrMetadata
.display_primary_r
.x
= EGL_DONT_CARE
;
400 surf
->HdrMetadata
.display_primary_r
.y
= EGL_DONT_CARE
;
401 surf
->HdrMetadata
.display_primary_g
.x
= EGL_DONT_CARE
;
402 surf
->HdrMetadata
.display_primary_g
.y
= EGL_DONT_CARE
;
403 surf
->HdrMetadata
.display_primary_b
.x
= EGL_DONT_CARE
;
404 surf
->HdrMetadata
.display_primary_b
.y
= EGL_DONT_CARE
;
405 surf
->HdrMetadata
.white_point
.x
= EGL_DONT_CARE
;
406 surf
->HdrMetadata
.white_point
.y
= EGL_DONT_CARE
;
407 surf
->HdrMetadata
.max_luminance
= EGL_DONT_CARE
;
408 surf
->HdrMetadata
.min_luminance
= EGL_DONT_CARE
;
409 surf
->HdrMetadata
.max_cll
= EGL_DONT_CARE
;
410 surf
->HdrMetadata
.max_fall
= EGL_DONT_CARE
;
412 err
= _eglParseSurfaceAttribList(surf
, attrib_list
);
413 if (err
!= EGL_SUCCESS
)
414 return _eglError(err
, func
);
416 /* if EGL_LARGEST_PBUFFER in use, clamp width and height */
417 if (surf
->LargestPbuffer
) {
418 surf
->Width
= MIN2(surf
->Width
, _EGL_MAX_PBUFFER_WIDTH
);
419 surf
->Height
= MIN2(surf
->Height
, _EGL_MAX_PBUFFER_HEIGHT
);
427 _eglQuerySurface(_EGLDriver
*drv
, _EGLDisplay
*dpy
, _EGLSurface
*surface
,
428 EGLint attribute
, EGLint
*value
)
432 *value
= surface
->Width
;
435 *value
= surface
->Height
;
438 *value
= surface
->Config
->ConfigID
;
440 case EGL_LARGEST_PBUFFER
:
441 if (surface
->Type
== EGL_PBUFFER_BIT
)
442 *value
= surface
->LargestPbuffer
;
444 case EGL_TEXTURE_FORMAT
:
445 /* texture attributes: only for pbuffers, no error otherwise */
446 if (surface
->Type
== EGL_PBUFFER_BIT
)
447 *value
= surface
->TextureFormat
;
449 case EGL_TEXTURE_TARGET
:
450 if (surface
->Type
== EGL_PBUFFER_BIT
)
451 *value
= surface
->TextureTarget
;
453 case EGL_MIPMAP_TEXTURE
:
454 if (surface
->Type
== EGL_PBUFFER_BIT
)
455 *value
= surface
->MipmapTexture
;
457 case EGL_MIPMAP_LEVEL
:
458 if (surface
->Type
== EGL_PBUFFER_BIT
)
459 *value
= surface
->MipmapLevel
;
461 case EGL_SWAP_BEHAVIOR
:
462 *value
= surface
->SwapBehavior
;
464 case EGL_RENDER_BUFFER
:
465 /* From the EGL_KHR_mutable_render_buffer spec (v12):
467 * Querying EGL_RENDER_BUFFER returns the buffer which client API
468 * rendering is requested to use. For a window surface, this is the
469 * attribute value specified when the surface was created or last set
470 * via eglSurfaceAttrib.
472 * In other words, querying a window surface returns the value most
473 * recently *requested* by the user.
475 * The paragraph continues in the EGL 1.5 spec (2014.08.27):
477 * For a pbuffer surface, it is always EGL_BACK_BUFFER . For a pixmap
478 * surface, it is always EGL_SINGLE_BUFFER . To determine the actual
479 * buffer being rendered to by a context, call eglQueryContext.
481 switch (surface
->Type
) {
483 unreachable("bad EGLSurface type");
485 *value
= surface
->RequestedRenderBuffer
;
487 case EGL_PBUFFER_BIT
:
488 *value
= EGL_BACK_BUFFER
;
491 *value
= EGL_SINGLE_BUFFER
;
495 case EGL_PIXEL_ASPECT_RATIO
:
496 *value
= surface
->AspectRatio
;
498 case EGL_HORIZONTAL_RESOLUTION
:
499 *value
= surface
->HorizontalResolution
;
501 case EGL_VERTICAL_RESOLUTION
:
502 *value
= surface
->VerticalResolution
;
504 case EGL_MULTISAMPLE_RESOLVE
:
505 *value
= surface
->MultisampleResolve
;
507 case EGL_VG_ALPHA_FORMAT
:
508 *value
= surface
->VGAlphaFormat
;
510 case EGL_VG_COLORSPACE
:
511 *value
= surface
->VGColorspace
;
513 case EGL_GL_COLORSPACE_KHR
:
514 if (!dpy
->Extensions
.KHR_gl_colorspace
)
515 return _eglError(EGL_BAD_ATTRIBUTE
, "eglQuerySurface");
517 *value
= surface
->GLColorspace
;
519 case EGL_POST_SUB_BUFFER_SUPPORTED_NV
:
520 *value
= surface
->PostSubBufferSupportedNV
;
522 case EGL_BUFFER_AGE_EXT
:
523 if (!dpy
->Extensions
.EXT_buffer_age
)
524 return _eglError(EGL_BAD_ATTRIBUTE
, "eglQuerySurface");
526 _EGLContext
*ctx
= _eglGetCurrentContext();
527 EGLint result
= drv
->API
.QueryBufferAge(drv
, dpy
, surface
);
531 if (_eglGetContextHandle(ctx
) == EGL_NO_CONTEXT
||
532 ctx
->DrawSurface
!= surface
)
533 return _eglError(EGL_BAD_SURFACE
, "eglQuerySurface");
536 surface
->BufferAgeRead
= EGL_TRUE
;
538 case EGL_SMPTE2086_DISPLAY_PRIMARY_RX_EXT
:
539 *value
= surface
->HdrMetadata
.display_primary_r
.x
;
541 case EGL_SMPTE2086_DISPLAY_PRIMARY_RY_EXT
:
542 *value
= surface
->HdrMetadata
.display_primary_r
.y
;
544 case EGL_SMPTE2086_DISPLAY_PRIMARY_GX_EXT
:
545 *value
= surface
->HdrMetadata
.display_primary_g
.x
;
547 case EGL_SMPTE2086_DISPLAY_PRIMARY_GY_EXT
:
548 *value
= surface
->HdrMetadata
.display_primary_g
.y
;
550 case EGL_SMPTE2086_DISPLAY_PRIMARY_BX_EXT
:
551 *value
= surface
->HdrMetadata
.display_primary_b
.x
;
553 case EGL_SMPTE2086_DISPLAY_PRIMARY_BY_EXT
:
554 *value
= surface
->HdrMetadata
.display_primary_b
.y
;
556 case EGL_SMPTE2086_WHITE_POINT_X_EXT
:
557 *value
= surface
->HdrMetadata
.white_point
.x
;
559 case EGL_SMPTE2086_WHITE_POINT_Y_EXT
:
560 *value
= surface
->HdrMetadata
.white_point
.y
;
562 case EGL_SMPTE2086_MAX_LUMINANCE_EXT
:
563 *value
= surface
->HdrMetadata
.max_luminance
;
565 case EGL_SMPTE2086_MIN_LUMINANCE_EXT
:
566 *value
= surface
->HdrMetadata
.min_luminance
;
568 case EGL_CTA861_3_MAX_CONTENT_LIGHT_LEVEL_EXT
:
569 *value
= surface
->HdrMetadata
.max_cll
;
571 case EGL_CTA861_3_MAX_FRAME_AVERAGE_LEVEL_EXT
:
572 *value
= surface
->HdrMetadata
.max_fall
;
575 return _eglError(EGL_BAD_ATTRIBUTE
, "eglQuerySurface");
583 * Default fallback routine - drivers might override this.
586 _eglSurfaceAttrib(_EGLDriver
*drv
, _EGLDisplay
*dpy
, _EGLSurface
*surface
,
587 EGLint attribute
, EGLint value
)
590 EGLint err
= EGL_SUCCESS
;
591 EGLint all_es_bits
= EGL_OPENGL_ES_BIT
|
593 EGL_OPENGL_ES3_BIT_KHR
;
596 case EGL_MIPMAP_LEVEL
:
597 confval
= surface
->Config
->RenderableType
;
598 if (!(confval
& all_es_bits
)) {
599 err
= EGL_BAD_PARAMETER
;
602 surface
->MipmapLevel
= value
;
604 case EGL_MULTISAMPLE_RESOLVE
:
606 case EGL_MULTISAMPLE_RESOLVE_DEFAULT
:
608 case EGL_MULTISAMPLE_RESOLVE_BOX
:
609 confval
= surface
->Config
->SurfaceType
;
610 if (!(confval
& EGL_MULTISAMPLE_RESOLVE_BOX_BIT
))
614 err
= EGL_BAD_ATTRIBUTE
;
617 if (err
!= EGL_SUCCESS
)
619 surface
->MultisampleResolve
= value
;
621 case EGL_RENDER_BUFFER
:
622 if (!dpy
->Extensions
.KHR_mutable_render_buffer
) {
623 err
= EGL_BAD_ATTRIBUTE
;
627 if (value
!= EGL_BACK_BUFFER
&& value
!= EGL_SINGLE_BUFFER
) {
628 err
= EGL_BAD_PARAMETER
;
632 /* From the EGL_KHR_mutable_render_buffer spec (v12):
634 * If attribute is EGL_RENDER_BUFFER, and the EGL_SURFACE_TYPE
635 * attribute of the EGLConfig used to create surface does not contain
636 * EGL_MUTABLE_RENDER_BUFFER_BIT_KHR, [...] an EGL_BAD_MATCH error is
639 if (!(surface
->Config
->SurfaceType
& EGL_MUTABLE_RENDER_BUFFER_BIT_KHR
)) {
644 surface
->RequestedRenderBuffer
= value
;
646 case EGL_SWAP_BEHAVIOR
:
648 case EGL_BUFFER_DESTROYED
:
650 case EGL_BUFFER_PRESERVED
:
651 confval
= surface
->Config
->SurfaceType
;
652 if (!(confval
& EGL_SWAP_BEHAVIOR_PRESERVED_BIT
))
656 err
= EGL_BAD_ATTRIBUTE
;
659 if (err
!= EGL_SUCCESS
)
661 surface
->SwapBehavior
= value
;
663 case EGL_SMPTE2086_DISPLAY_PRIMARY_RX_EXT
:
664 surface
->HdrMetadata
.display_primary_r
.x
= value
;
666 case EGL_SMPTE2086_DISPLAY_PRIMARY_RY_EXT
:
667 surface
->HdrMetadata
.display_primary_r
.y
= value
;
669 case EGL_SMPTE2086_DISPLAY_PRIMARY_GX_EXT
:
670 surface
->HdrMetadata
.display_primary_g
.x
= value
;
672 case EGL_SMPTE2086_DISPLAY_PRIMARY_GY_EXT
:
673 surface
->HdrMetadata
.display_primary_g
.y
= value
;
675 case EGL_SMPTE2086_DISPLAY_PRIMARY_BX_EXT
:
676 surface
->HdrMetadata
.display_primary_b
.x
= value
;
678 case EGL_SMPTE2086_DISPLAY_PRIMARY_BY_EXT
:
679 surface
->HdrMetadata
.display_primary_b
.y
= value
;
681 case EGL_SMPTE2086_WHITE_POINT_X_EXT
:
682 surface
->HdrMetadata
.white_point
.x
= value
;
684 case EGL_SMPTE2086_WHITE_POINT_Y_EXT
:
685 surface
->HdrMetadata
.white_point
.y
= value
;
687 case EGL_SMPTE2086_MAX_LUMINANCE_EXT
:
688 surface
->HdrMetadata
.max_luminance
= value
;
690 case EGL_SMPTE2086_MIN_LUMINANCE_EXT
:
691 surface
->HdrMetadata
.min_luminance
= value
;
693 case EGL_CTA861_3_MAX_CONTENT_LIGHT_LEVEL_EXT
:
694 surface
->HdrMetadata
.max_cll
= value
;
696 case EGL_CTA861_3_MAX_FRAME_AVERAGE_LEVEL_EXT
:
697 surface
->HdrMetadata
.max_fall
= value
;
700 err
= EGL_BAD_ATTRIBUTE
;
704 if (err
!= EGL_SUCCESS
)
705 return _eglError(err
, "eglSurfaceAttrib");
711 _eglBindTexImage(_EGLDriver
*drv
, _EGLDisplay
*dpy
, _EGLSurface
*surface
,
714 EGLint texture_type
= EGL_PBUFFER_BIT
;
716 /* Just do basic error checking and return success/fail.
717 * Drivers must implement the real stuff.
720 if (dpy
->Extensions
.NOK_texture_from_pixmap
)
721 texture_type
|= EGL_PIXMAP_BIT
;
723 if (!(surface
->Type
& texture_type
))
724 return _eglError(EGL_BAD_SURFACE
, "eglBindTexImage");
726 if (surface
->TextureFormat
== EGL_NO_TEXTURE
)
727 return _eglError(EGL_BAD_MATCH
, "eglBindTexImage");
729 if (surface
->TextureTarget
== EGL_NO_TEXTURE
)
730 return _eglError(EGL_BAD_MATCH
, "eglBindTexImage");
732 if (buffer
!= EGL_BACK_BUFFER
)
733 return _eglError(EGL_BAD_PARAMETER
, "eglBindTexImage");
735 surface
->BoundToTexture
= EGL_TRUE
;
741 _eglReleaseTexImage(_EGLDriver
*drv
, _EGLDisplay
*dpy
, _EGLSurface
*surf
,
744 /* Just do basic error checking and return success/fail.
745 * Drivers must implement the real stuff.
748 EGLint texture_type
= EGL_PBUFFER_BIT
;
750 if (surf
== EGL_NO_SURFACE
)
751 return _eglError(EGL_BAD_SURFACE
, "eglReleaseTexImage");
753 if (!surf
->BoundToTexture
)
755 /* Not an error, simply nothing to do */
759 if (surf
->TextureFormat
== EGL_NO_TEXTURE
)
760 return _eglError(EGL_BAD_MATCH
, "eglReleaseTexImage");
762 if (buffer
!= EGL_BACK_BUFFER
)
763 return _eglError(EGL_BAD_PARAMETER
, "eglReleaseTexImage");
765 if (dpy
->Extensions
.NOK_texture_from_pixmap
)
766 texture_type
|= EGL_PIXMAP_BIT
;
768 if (!(surf
->Type
& texture_type
))
769 return _eglError(EGL_BAD_SURFACE
, "eglReleaseTexImage");
771 surf
->BoundToTexture
= EGL_FALSE
;
778 _eglSwapInterval(_EGLDriver
*drv
, _EGLDisplay
*dpy
, _EGLSurface
*surf
,
785 _eglSurfaceHasMutableRenderBuffer(_EGLSurface
*surf
)
787 return surf
->Type
== EGL_WINDOW_BIT
&&
789 (surf
->Config
->SurfaceType
& EGL_MUTABLE_RENDER_BUFFER_BIT_KHR
);
793 _eglSurfaceInSharedBufferMode(_EGLSurface
*surf
)
795 return _eglSurfaceHasMutableRenderBuffer(surf
) &&
796 surf
->ActiveRenderBuffer
== EGL_SINGLE_BUFFER
;