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 "egldefines.h"
40 #include "egldisplay.h"
41 #include "egldriver.h"
42 #include "eglcontext.h"
43 #include "eglconfig.h"
44 #include "eglcurrent.h"
46 #include "eglsurface.h"
48 #include "util/macros.h"
51 * Parse the list of surface attributes and return the proper error code.
54 _eglParseSurfaceAttribList(_EGLSurface
*surf
, const EGLint
*attrib_list
)
56 _EGLDisplay
*disp
= surf
->Resource
.Display
;
57 EGLint type
= surf
->Type
;
58 EGLint texture_type
= EGL_PBUFFER_BIT
;
59 EGLint i
, err
= EGL_SUCCESS
;
60 EGLint attr
= EGL_NONE
;
61 EGLint val
= EGL_NONE
;
66 if (disp
->Extensions
.NOK_texture_from_pixmap
)
67 texture_type
|= EGL_PIXMAP_BIT
;
69 for (i
= 0; attrib_list
[i
] != EGL_NONE
; i
++) {
70 attr
= attrib_list
[i
++];
74 /* common attributes */
75 case EGL_GL_COLORSPACE_KHR
:
76 if (!disp
->Extensions
.KHR_gl_colorspace
) {
77 err
= EGL_BAD_ATTRIBUTE
;
81 case EGL_GL_COLORSPACE_SRGB_KHR
:
82 case EGL_GL_COLORSPACE_LINEAR_KHR
:
85 err
= EGL_BAD_ATTRIBUTE
;
87 if (err
!= EGL_SUCCESS
)
89 surf
->GLColorspace
= val
;
91 case EGL_SMPTE2086_DISPLAY_PRIMARY_RX_EXT
:
92 if (!disp
->Extensions
.EXT_surface_SMPTE2086_metadata
) {
93 err
= EGL_BAD_ATTRIBUTE
;
96 surf
->HdrMetadata
.display_primary_r
.x
= val
;
98 case EGL_SMPTE2086_DISPLAY_PRIMARY_RY_EXT
:
99 if (!disp
->Extensions
.EXT_surface_SMPTE2086_metadata
) {
100 err
= EGL_BAD_ATTRIBUTE
;
103 surf
->HdrMetadata
.display_primary_r
.y
= val
;
105 case EGL_SMPTE2086_DISPLAY_PRIMARY_GX_EXT
:
106 if (!disp
->Extensions
.EXT_surface_SMPTE2086_metadata
) {
107 err
= EGL_BAD_ATTRIBUTE
;
110 surf
->HdrMetadata
.display_primary_g
.x
= val
;
112 case EGL_SMPTE2086_DISPLAY_PRIMARY_GY_EXT
:
113 if (!disp
->Extensions
.EXT_surface_SMPTE2086_metadata
) {
114 err
= EGL_BAD_ATTRIBUTE
;
117 surf
->HdrMetadata
.display_primary_g
.y
= val
;
119 case EGL_SMPTE2086_DISPLAY_PRIMARY_BX_EXT
:
120 if (!disp
->Extensions
.EXT_surface_SMPTE2086_metadata
) {
121 err
= EGL_BAD_ATTRIBUTE
;
124 surf
->HdrMetadata
.display_primary_b
.x
= val
;
126 case EGL_SMPTE2086_DISPLAY_PRIMARY_BY_EXT
:
127 if (!disp
->Extensions
.EXT_surface_SMPTE2086_metadata
) {
128 err
= EGL_BAD_ATTRIBUTE
;
131 surf
->HdrMetadata
.display_primary_b
.y
= val
;
133 case EGL_SMPTE2086_WHITE_POINT_X_EXT
:
134 if (!disp
->Extensions
.EXT_surface_SMPTE2086_metadata
) {
135 err
= EGL_BAD_ATTRIBUTE
;
138 surf
->HdrMetadata
.white_point
.x
= val
;
140 case EGL_SMPTE2086_WHITE_POINT_Y_EXT
:
141 if (!disp
->Extensions
.EXT_surface_SMPTE2086_metadata
) {
142 err
= EGL_BAD_ATTRIBUTE
;
145 surf
->HdrMetadata
.white_point
.y
= val
;
147 case EGL_SMPTE2086_MAX_LUMINANCE_EXT
:
148 if (!disp
->Extensions
.EXT_surface_SMPTE2086_metadata
) {
149 err
= EGL_BAD_ATTRIBUTE
;
152 surf
->HdrMetadata
.max_luminance
= val
;
154 case EGL_SMPTE2086_MIN_LUMINANCE_EXT
:
155 if (!disp
->Extensions
.EXT_surface_SMPTE2086_metadata
) {
156 err
= EGL_BAD_ATTRIBUTE
;
159 surf
->HdrMetadata
.min_luminance
= val
;
161 case EGL_CTA861_3_MAX_CONTENT_LIGHT_LEVEL_EXT
:
162 if (!disp
->Extensions
.EXT_surface_CTA861_3_metadata
) {
163 err
= EGL_BAD_ATTRIBUTE
;
166 surf
->HdrMetadata
.max_cll
= val
;
168 case EGL_CTA861_3_MAX_FRAME_AVERAGE_LEVEL_EXT
:
169 if (!disp
->Extensions
.EXT_surface_CTA861_3_metadata
) {
170 err
= EGL_BAD_ATTRIBUTE
;
173 surf
->HdrMetadata
.max_fall
= val
;
175 case EGL_VG_COLORSPACE
:
177 case EGL_VG_COLORSPACE_sRGB
:
178 case EGL_VG_COLORSPACE_LINEAR
:
181 err
= EGL_BAD_ATTRIBUTE
;
184 if (err
!= EGL_SUCCESS
)
186 surf
->VGColorspace
= val
;
188 case EGL_VG_ALPHA_FORMAT
:
190 case EGL_VG_ALPHA_FORMAT_NONPRE
:
191 case EGL_VG_ALPHA_FORMAT_PRE
:
194 err
= EGL_BAD_ATTRIBUTE
;
197 if (err
!= EGL_SUCCESS
)
199 surf
->VGAlphaFormat
= val
;
201 /* window surface attributes */
202 case EGL_RENDER_BUFFER
:
203 if (type
!= EGL_WINDOW_BIT
) {
204 err
= EGL_BAD_ATTRIBUTE
;
207 if (val
!= EGL_BACK_BUFFER
&& val
!= EGL_SINGLE_BUFFER
) {
208 err
= EGL_BAD_ATTRIBUTE
;
211 surf
->RequestedRenderBuffer
= val
;
212 if (surf
->Config
->SurfaceType
& EGL_MUTABLE_RENDER_BUFFER_BIT_KHR
) {
213 /* Unlike normal EGLSurfaces, one with a mutable render buffer
214 * uses the application-chosen render buffer.
216 surf
->ActiveRenderBuffer
= val
;
219 case EGL_POST_SUB_BUFFER_SUPPORTED_NV
:
220 if (!disp
->Extensions
.NV_post_sub_buffer
||
221 type
!= EGL_WINDOW_BIT
) {
222 err
= EGL_BAD_ATTRIBUTE
;
225 if (val
!= EGL_TRUE
&& val
!= EGL_FALSE
) {
226 err
= EGL_BAD_PARAMETER
;
229 surf
->PostSubBufferSupportedNV
= val
;
231 /* pbuffer surface attributes */
233 if (type
!= EGL_PBUFFER_BIT
) {
234 err
= EGL_BAD_ATTRIBUTE
;
238 err
= EGL_BAD_PARAMETER
;
244 if (type
!= EGL_PBUFFER_BIT
) {
245 err
= EGL_BAD_ATTRIBUTE
;
249 err
= EGL_BAD_PARAMETER
;
254 case EGL_LARGEST_PBUFFER
:
255 if (type
!= EGL_PBUFFER_BIT
) {
256 err
= EGL_BAD_ATTRIBUTE
;
259 surf
->LargestPbuffer
= !!val
;
261 /* for eglBindTexImage */
262 case EGL_TEXTURE_FORMAT
:
263 if (!(type
& texture_type
)) {
264 err
= EGL_BAD_ATTRIBUTE
;
269 case EGL_TEXTURE_RGB
:
270 case EGL_TEXTURE_RGBA
:
274 err
= EGL_BAD_ATTRIBUTE
;
277 if (err
!= EGL_SUCCESS
)
279 surf
->TextureFormat
= val
;
281 case EGL_TEXTURE_TARGET
:
282 if (!(type
& texture_type
)) {
283 err
= EGL_BAD_ATTRIBUTE
;
292 err
= EGL_BAD_ATTRIBUTE
;
295 if (err
!= EGL_SUCCESS
)
297 surf
->TextureTarget
= val
;
299 case EGL_MIPMAP_TEXTURE
:
300 if (!(type
& texture_type
)) {
301 err
= EGL_BAD_ATTRIBUTE
;
304 surf
->MipmapTexture
= !!val
;
306 /* no pixmap surface specific attributes */
308 err
= EGL_BAD_ATTRIBUTE
;
312 if (err
!= EGL_SUCCESS
)
316 if (err
== EGL_SUCCESS
&& type
== EGL_PBUFFER_BIT
) {
317 if ((surf
->TextureTarget
== EGL_NO_TEXTURE
&& surf
->TextureFormat
!= EGL_NO_TEXTURE
) ||
318 (surf
->TextureFormat
== EGL_NO_TEXTURE
&& surf
->TextureTarget
!= EGL_NO_TEXTURE
)) {
319 attr
= surf
->TextureTarget
== EGL_NO_TEXTURE
? EGL_TEXTURE_TARGET
: EGL_TEXTURE_FORMAT
;
324 if (err
!= EGL_SUCCESS
)
325 _eglLog(_EGL_WARNING
, "bad surface attribute 0x%04x", attr
);
332 * Do error check on parameters and initialize the given _EGLSurface object.
333 * \return EGL_TRUE if no errors, EGL_FALSE otherwise.
336 _eglInitSurface(_EGLSurface
*surf
, _EGLDisplay
*disp
, EGLint type
,
337 _EGLConfig
*conf
, const EGLint
*attrib_list
,
338 void *native_surface
)
341 EGLint renderBuffer
= EGL_BACK_BUFFER
;
342 EGLint swapBehavior
= EGL_BUFFER_DESTROYED
;
345 /* Swap behavior can be preserved only if config supports this. */
346 if (conf
->SurfaceType
& EGL_SWAP_BEHAVIOR_PRESERVED_BIT
)
347 swapBehavior
= EGL_BUFFER_PRESERVED
;
351 func
= "eglCreateWindowSurface";
352 swapBehavior
= EGL_BUFFER_DESTROYED
;
355 func
= "eglCreatePixmapSurface";
356 renderBuffer
= EGL_SINGLE_BUFFER
;
358 case EGL_PBUFFER_BIT
:
359 func
= "eglCreatePBufferSurface";
362 _eglLog(_EGL_WARNING
, "Bad type in _eglInitSurface");
366 if ((conf
->SurfaceType
& type
) == 0)
367 /* The config can't be used to create a surface of this type */
368 return _eglError(EGL_BAD_MATCH
, func
);
370 _eglInitResource(&surf
->Resource
, sizeof(*surf
), disp
);
373 surf
->Lost
= EGL_FALSE
;
377 surf
->TextureFormat
= EGL_NO_TEXTURE
;
378 surf
->TextureTarget
= EGL_NO_TEXTURE
;
379 surf
->MipmapTexture
= EGL_FALSE
;
380 surf
->LargestPbuffer
= EGL_FALSE
;
381 surf
->RequestedRenderBuffer
= renderBuffer
;
382 surf
->ActiveRenderBuffer
= renderBuffer
;
383 surf
->VGAlphaFormat
= EGL_VG_ALPHA_FORMAT_NONPRE
;
384 surf
->VGColorspace
= EGL_VG_COLORSPACE_sRGB
;
385 surf
->GLColorspace
= EGL_GL_COLORSPACE_LINEAR_KHR
;
387 surf
->MipmapLevel
= 0;
388 surf
->MultisampleResolve
= EGL_MULTISAMPLE_RESOLVE_DEFAULT
;
389 surf
->SwapBehavior
= swapBehavior
;
391 surf
->HorizontalResolution
= EGL_UNKNOWN
;
392 surf
->VerticalResolution
= EGL_UNKNOWN
;
393 surf
->AspectRatio
= EGL_UNKNOWN
;
395 surf
->PostSubBufferSupportedNV
= EGL_FALSE
;
396 surf
->SetDamageRegionCalled
= EGL_FALSE
;
397 surf
->BufferAgeRead
= EGL_FALSE
;
399 /* the default swap interval is 1 */
400 surf
->SwapInterval
= 1;
402 surf
->HdrMetadata
.display_primary_r
.x
= EGL_DONT_CARE
;
403 surf
->HdrMetadata
.display_primary_r
.y
= EGL_DONT_CARE
;
404 surf
->HdrMetadata
.display_primary_g
.x
= EGL_DONT_CARE
;
405 surf
->HdrMetadata
.display_primary_g
.y
= EGL_DONT_CARE
;
406 surf
->HdrMetadata
.display_primary_b
.x
= EGL_DONT_CARE
;
407 surf
->HdrMetadata
.display_primary_b
.y
= EGL_DONT_CARE
;
408 surf
->HdrMetadata
.white_point
.x
= EGL_DONT_CARE
;
409 surf
->HdrMetadata
.white_point
.y
= EGL_DONT_CARE
;
410 surf
->HdrMetadata
.max_luminance
= EGL_DONT_CARE
;
411 surf
->HdrMetadata
.min_luminance
= EGL_DONT_CARE
;
412 surf
->HdrMetadata
.max_cll
= EGL_DONT_CARE
;
413 surf
->HdrMetadata
.max_fall
= EGL_DONT_CARE
;
415 err
= _eglParseSurfaceAttribList(surf
, attrib_list
);
416 if (err
!= EGL_SUCCESS
)
417 return _eglError(err
, func
);
419 /* if EGL_LARGEST_PBUFFER in use, clamp width and height */
420 if (surf
->LargestPbuffer
) {
421 surf
->Width
= MIN2(surf
->Width
, _EGL_MAX_PBUFFER_WIDTH
);
422 surf
->Height
= MIN2(surf
->Height
, _EGL_MAX_PBUFFER_HEIGHT
);
425 surf
->NativeSurface
= native_surface
;
432 _eglQuerySurface(_EGLDisplay
*disp
, _EGLSurface
*surface
,
433 EGLint attribute
, EGLint
*value
)
437 *value
= surface
->Width
;
440 *value
= surface
->Height
;
443 *value
= surface
->Config
->ConfigID
;
445 case EGL_LARGEST_PBUFFER
:
446 if (surface
->Type
== EGL_PBUFFER_BIT
)
447 *value
= surface
->LargestPbuffer
;
449 case EGL_TEXTURE_FORMAT
:
450 /* texture attributes: only for pbuffers, no error otherwise */
451 if (surface
->Type
== EGL_PBUFFER_BIT
)
452 *value
= surface
->TextureFormat
;
454 case EGL_TEXTURE_TARGET
:
455 if (surface
->Type
== EGL_PBUFFER_BIT
)
456 *value
= surface
->TextureTarget
;
458 case EGL_MIPMAP_TEXTURE
:
459 if (surface
->Type
== EGL_PBUFFER_BIT
)
460 *value
= surface
->MipmapTexture
;
462 case EGL_MIPMAP_LEVEL
:
463 if (surface
->Type
== EGL_PBUFFER_BIT
)
464 *value
= surface
->MipmapLevel
;
466 case EGL_SWAP_BEHAVIOR
:
467 *value
= surface
->SwapBehavior
;
469 case EGL_RENDER_BUFFER
:
470 /* From the EGL_KHR_mutable_render_buffer spec (v12):
472 * Querying EGL_RENDER_BUFFER returns the buffer which client API
473 * rendering is requested to use. For a window surface, this is the
474 * attribute value specified when the surface was created or last set
475 * via eglSurfaceAttrib.
477 * In other words, querying a window surface returns the value most
478 * recently *requested* by the user.
480 * The paragraph continues in the EGL 1.5 spec (2014.08.27):
482 * For a pbuffer surface, it is always EGL_BACK_BUFFER . For a pixmap
483 * surface, it is always EGL_SINGLE_BUFFER . To determine the actual
484 * buffer being rendered to by a context, call eglQueryContext.
486 switch (surface
->Type
) {
488 unreachable("bad EGLSurface type");
490 *value
= surface
->RequestedRenderBuffer
;
492 case EGL_PBUFFER_BIT
:
493 *value
= EGL_BACK_BUFFER
;
496 *value
= EGL_SINGLE_BUFFER
;
500 case EGL_PIXEL_ASPECT_RATIO
:
501 *value
= surface
->AspectRatio
;
503 case EGL_HORIZONTAL_RESOLUTION
:
504 *value
= surface
->HorizontalResolution
;
506 case EGL_VERTICAL_RESOLUTION
:
507 *value
= surface
->VerticalResolution
;
509 case EGL_MULTISAMPLE_RESOLVE
:
510 *value
= surface
->MultisampleResolve
;
512 case EGL_VG_ALPHA_FORMAT
:
513 *value
= surface
->VGAlphaFormat
;
515 case EGL_VG_COLORSPACE
:
516 *value
= surface
->VGColorspace
;
518 case EGL_GL_COLORSPACE_KHR
:
519 if (!disp
->Extensions
.KHR_gl_colorspace
)
520 return _eglError(EGL_BAD_ATTRIBUTE
, "eglQuerySurface");
522 *value
= surface
->GLColorspace
;
524 case EGL_POST_SUB_BUFFER_SUPPORTED_NV
:
525 *value
= surface
->PostSubBufferSupportedNV
;
527 case EGL_BUFFER_AGE_EXT
:
528 /* Both EXT_buffer_age and KHR_partial_update accept EGL_BUFFER_AGE_EXT.
529 * To be precise, the KHR one accepts EGL_BUFFER_AGE_KHR which is an
530 * alias with the same numeric value.
532 if (!disp
->Extensions
.EXT_buffer_age
&&
533 !disp
->Extensions
.KHR_partial_update
)
534 return _eglError(EGL_BAD_ATTRIBUTE
, "eglQuerySurface");
536 _EGLContext
*ctx
= _eglGetCurrentContext();
537 const _EGLDriver
*drv
= disp
->Driver
;
538 EGLint result
= drv
->QueryBufferAge(drv
, disp
, surface
);
542 if (_eglGetContextHandle(ctx
) == EGL_NO_CONTEXT
||
543 ctx
->DrawSurface
!= surface
)
544 return _eglError(EGL_BAD_SURFACE
, "eglQuerySurface");
547 surface
->BufferAgeRead
= EGL_TRUE
;
549 case EGL_SMPTE2086_DISPLAY_PRIMARY_RX_EXT
:
550 *value
= surface
->HdrMetadata
.display_primary_r
.x
;
552 case EGL_SMPTE2086_DISPLAY_PRIMARY_RY_EXT
:
553 *value
= surface
->HdrMetadata
.display_primary_r
.y
;
555 case EGL_SMPTE2086_DISPLAY_PRIMARY_GX_EXT
:
556 *value
= surface
->HdrMetadata
.display_primary_g
.x
;
558 case EGL_SMPTE2086_DISPLAY_PRIMARY_GY_EXT
:
559 *value
= surface
->HdrMetadata
.display_primary_g
.y
;
561 case EGL_SMPTE2086_DISPLAY_PRIMARY_BX_EXT
:
562 *value
= surface
->HdrMetadata
.display_primary_b
.x
;
564 case EGL_SMPTE2086_DISPLAY_PRIMARY_BY_EXT
:
565 *value
= surface
->HdrMetadata
.display_primary_b
.y
;
567 case EGL_SMPTE2086_WHITE_POINT_X_EXT
:
568 *value
= surface
->HdrMetadata
.white_point
.x
;
570 case EGL_SMPTE2086_WHITE_POINT_Y_EXT
:
571 *value
= surface
->HdrMetadata
.white_point
.y
;
573 case EGL_SMPTE2086_MAX_LUMINANCE_EXT
:
574 *value
= surface
->HdrMetadata
.max_luminance
;
576 case EGL_SMPTE2086_MIN_LUMINANCE_EXT
:
577 *value
= surface
->HdrMetadata
.min_luminance
;
579 case EGL_CTA861_3_MAX_CONTENT_LIGHT_LEVEL_EXT
:
580 *value
= surface
->HdrMetadata
.max_cll
;
582 case EGL_CTA861_3_MAX_FRAME_AVERAGE_LEVEL_EXT
:
583 *value
= surface
->HdrMetadata
.max_fall
;
586 return _eglError(EGL_BAD_ATTRIBUTE
, "eglQuerySurface");
594 * Default fallback routine - drivers might override this.
597 _eglSurfaceAttrib(const _EGLDriver
*drv
, _EGLDisplay
*disp
, _EGLSurface
*surface
,
598 EGLint attribute
, EGLint value
)
601 EGLint err
= EGL_SUCCESS
;
602 EGLint all_es_bits
= EGL_OPENGL_ES_BIT
|
604 EGL_OPENGL_ES3_BIT_KHR
;
607 case EGL_MIPMAP_LEVEL
:
608 confval
= surface
->Config
->RenderableType
;
609 if (!(confval
& all_es_bits
)) {
610 err
= EGL_BAD_PARAMETER
;
613 surface
->MipmapLevel
= value
;
615 case EGL_MULTISAMPLE_RESOLVE
:
617 case EGL_MULTISAMPLE_RESOLVE_DEFAULT
:
619 case EGL_MULTISAMPLE_RESOLVE_BOX
:
620 confval
= surface
->Config
->SurfaceType
;
621 if (!(confval
& EGL_MULTISAMPLE_RESOLVE_BOX_BIT
))
625 err
= EGL_BAD_ATTRIBUTE
;
628 if (err
!= EGL_SUCCESS
)
630 surface
->MultisampleResolve
= value
;
632 case EGL_RENDER_BUFFER
:
633 if (!disp
->Extensions
.KHR_mutable_render_buffer
) {
634 err
= EGL_BAD_ATTRIBUTE
;
638 if (value
!= EGL_BACK_BUFFER
&& value
!= EGL_SINGLE_BUFFER
) {
639 err
= EGL_BAD_PARAMETER
;
643 /* From the EGL_KHR_mutable_render_buffer spec (v12):
645 * If attribute is EGL_RENDER_BUFFER, and the EGL_SURFACE_TYPE
646 * attribute of the EGLConfig used to create surface does not contain
647 * EGL_MUTABLE_RENDER_BUFFER_BIT_KHR, [...] an EGL_BAD_MATCH error is
650 if (!(surface
->Config
->SurfaceType
& EGL_MUTABLE_RENDER_BUFFER_BIT_KHR
)) {
655 surface
->RequestedRenderBuffer
= value
;
657 case EGL_SWAP_BEHAVIOR
:
659 case EGL_BUFFER_DESTROYED
:
661 case EGL_BUFFER_PRESERVED
:
662 confval
= surface
->Config
->SurfaceType
;
663 if (!(confval
& EGL_SWAP_BEHAVIOR_PRESERVED_BIT
))
667 err
= EGL_BAD_ATTRIBUTE
;
670 if (err
!= EGL_SUCCESS
)
672 surface
->SwapBehavior
= value
;
674 case EGL_SMPTE2086_DISPLAY_PRIMARY_RX_EXT
:
675 surface
->HdrMetadata
.display_primary_r
.x
= value
;
677 case EGL_SMPTE2086_DISPLAY_PRIMARY_RY_EXT
:
678 surface
->HdrMetadata
.display_primary_r
.y
= value
;
680 case EGL_SMPTE2086_DISPLAY_PRIMARY_GX_EXT
:
681 surface
->HdrMetadata
.display_primary_g
.x
= value
;
683 case EGL_SMPTE2086_DISPLAY_PRIMARY_GY_EXT
:
684 surface
->HdrMetadata
.display_primary_g
.y
= value
;
686 case EGL_SMPTE2086_DISPLAY_PRIMARY_BX_EXT
:
687 surface
->HdrMetadata
.display_primary_b
.x
= value
;
689 case EGL_SMPTE2086_DISPLAY_PRIMARY_BY_EXT
:
690 surface
->HdrMetadata
.display_primary_b
.y
= value
;
692 case EGL_SMPTE2086_WHITE_POINT_X_EXT
:
693 surface
->HdrMetadata
.white_point
.x
= value
;
695 case EGL_SMPTE2086_WHITE_POINT_Y_EXT
:
696 surface
->HdrMetadata
.white_point
.y
= value
;
698 case EGL_SMPTE2086_MAX_LUMINANCE_EXT
:
699 surface
->HdrMetadata
.max_luminance
= value
;
701 case EGL_SMPTE2086_MIN_LUMINANCE_EXT
:
702 surface
->HdrMetadata
.min_luminance
= value
;
704 case EGL_CTA861_3_MAX_CONTENT_LIGHT_LEVEL_EXT
:
705 surface
->HdrMetadata
.max_cll
= value
;
707 case EGL_CTA861_3_MAX_FRAME_AVERAGE_LEVEL_EXT
:
708 surface
->HdrMetadata
.max_fall
= value
;
711 err
= EGL_BAD_ATTRIBUTE
;
715 if (err
!= EGL_SUCCESS
)
716 return _eglError(err
, "eglSurfaceAttrib");
722 _eglBindTexImage(_EGLDisplay
*disp
, _EGLSurface
*surface
, EGLint buffer
)
724 EGLint texture_type
= EGL_PBUFFER_BIT
;
726 /* Just do basic error checking and return success/fail.
727 * Drivers must implement the real stuff.
730 if (disp
->Extensions
.NOK_texture_from_pixmap
)
731 texture_type
|= EGL_PIXMAP_BIT
;
733 if (!(surface
->Type
& texture_type
))
734 return _eglError(EGL_BAD_SURFACE
, "eglBindTexImage");
736 if (surface
->TextureFormat
== EGL_NO_TEXTURE
)
737 return _eglError(EGL_BAD_MATCH
, "eglBindTexImage");
739 if (surface
->TextureTarget
== EGL_NO_TEXTURE
)
740 return _eglError(EGL_BAD_MATCH
, "eglBindTexImage");
742 if (buffer
!= EGL_BACK_BUFFER
)
743 return _eglError(EGL_BAD_PARAMETER
, "eglBindTexImage");
745 surface
->BoundToTexture
= EGL_TRUE
;
751 _eglReleaseTexImage(_EGLDisplay
*disp
, _EGLSurface
*surf
, EGLint buffer
)
753 /* Just do basic error checking and return success/fail.
754 * Drivers must implement the real stuff.
757 EGLint texture_type
= EGL_PBUFFER_BIT
;
759 if (surf
== EGL_NO_SURFACE
)
760 return _eglError(EGL_BAD_SURFACE
, "eglReleaseTexImage");
762 if (!surf
->BoundToTexture
)
764 /* Not an error, simply nothing to do */
768 if (surf
->TextureFormat
== EGL_NO_TEXTURE
)
769 return _eglError(EGL_BAD_MATCH
, "eglReleaseTexImage");
771 if (buffer
!= EGL_BACK_BUFFER
)
772 return _eglError(EGL_BAD_PARAMETER
, "eglReleaseTexImage");
774 if (disp
->Extensions
.NOK_texture_from_pixmap
)
775 texture_type
|= EGL_PIXMAP_BIT
;
777 if (!(surf
->Type
& texture_type
))
778 return _eglError(EGL_BAD_SURFACE
, "eglReleaseTexImage");
780 surf
->BoundToTexture
= EGL_FALSE
;
787 _eglSwapInterval(_EGLDisplay
*disp
, _EGLSurface
*surf
, EGLint interval
)
793 _eglSurfaceHasMutableRenderBuffer(_EGLSurface
*surf
)
795 return surf
->Type
== EGL_WINDOW_BIT
&&
797 (surf
->Config
->SurfaceType
& EGL_MUTABLE_RENDER_BUFFER_BIT_KHR
);
801 _eglSurfaceInSharedBufferMode(_EGLSurface
*surf
)
803 return _eglSurfaceHasMutableRenderBuffer(surf
) &&
804 surf
->ActiveRenderBuffer
== EGL_SINGLE_BUFFER
;