2 * EGL Configuration (pixel format) functions.
10 #include "eglconfig.h"
11 #include "egldisplay.h"
12 #include "egldriver.h"
13 #include "eglglobals.h"
17 #define MIN2(A, B) (((A) < (B)) ? (A) : (B))
18 #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
22 * Init the given _EGLconfig to default values.
23 * \param id the configuration's ID.
25 * Note that id must be positive for the config to be valid.
26 * It is also recommended that when there are N configs, their
27 * IDs are from 1 to N respectively.
30 _eglInitConfig(_EGLConfig
*config
, EGLint id
)
32 memset(config
, 0, sizeof(*config
));
34 /* some attributes take non-zero default values */
35 SET_CONFIG_ATTRIB(config
, EGL_CONFIG_ID
, id
);
36 SET_CONFIG_ATTRIB(config
, EGL_CONFIG_CAVEAT
, EGL_NONE
);
37 SET_CONFIG_ATTRIB(config
, EGL_TRANSPARENT_TYPE
, EGL_NONE
);
38 SET_CONFIG_ATTRIB(config
, EGL_NATIVE_VISUAL_TYPE
, EGL_NONE
);
39 #ifdef EGL_VERSION_1_2
40 SET_CONFIG_ATTRIB(config
, EGL_COLOR_BUFFER_TYPE
, EGL_RGB_BUFFER
);
41 #endif /* EGL_VERSION_1_2 */
46 * Link a config to a display and return the handle of the link.
47 * The handle can be passed to client directly.
49 * Note that we just save the ptr to the config (we don't copy the config).
52 _eglAddConfig(_EGLDisplay
*dpy
, _EGLConfig
*conf
)
57 assert(GET_CONFIG_ATTRIB(conf
, EGL_CONFIG_ID
) > 0);
59 configs
= dpy
->Configs
;
60 if (dpy
->NumConfigs
>= dpy
->MaxConfigs
) {
61 EGLint new_size
= dpy
->MaxConfigs
+ 16;
62 assert(dpy
->NumConfigs
< new_size
);
64 configs
= realloc(dpy
->Configs
, new_size
* sizeof(dpy
->Configs
[0]));
66 return (EGLConfig
) NULL
;
68 dpy
->Configs
= configs
;
69 dpy
->MaxConfigs
= new_size
;
73 dpy
->Configs
[dpy
->NumConfigs
++] = conf
;
75 return (EGLConfig
) conf
;
79 #ifndef _EGL_SKIP_HANDLE_CHECK
83 _eglCheckConfigHandle(EGLConfig config
, _EGLDisplay
*dpy
)
85 EGLint num_configs
= (dpy
) ? dpy
->NumConfigs
: 0;
88 for (i
= 0; i
< num_configs
; i
++) {
89 _EGLConfig
*conf
= dpy
->Configs
[i
];
90 if (conf
== (_EGLConfig
*) config
) {
91 assert(conf
->Display
== dpy
);
95 return (i
< num_configs
);
99 #endif /* _EGL_SKIP_HANDLE_CHECK */
108 ATTRIB_TYPE_PSEUDO
, /* non-queryable */
109 ATTRIB_TYPE_PLATFORM
, /* platform-dependent */
111 ATTRIB_CRITERION_EXACT
,
112 ATTRIB_CRITERION_ATLEAST
,
113 ATTRIB_CRITERION_MASK
,
114 ATTRIB_CRITERION_SPECIAL
,
115 ATTRIB_CRITERION_IGNORE
,
119 /* EGL spec Table 3.1 and 3.4 */
120 static const struct {
124 EGLint default_value
;
125 } _eglValidationTable
[] =
127 { EGL_BUFFER_SIZE
, ATTRIB_TYPE_INTEGER
,
128 ATTRIB_CRITERION_ATLEAST
,
130 { EGL_RED_SIZE
, ATTRIB_TYPE_INTEGER
,
131 ATTRIB_CRITERION_ATLEAST
,
133 { EGL_GREEN_SIZE
, ATTRIB_TYPE_INTEGER
,
134 ATTRIB_CRITERION_ATLEAST
,
136 { EGL_BLUE_SIZE
, ATTRIB_TYPE_INTEGER
,
137 ATTRIB_CRITERION_ATLEAST
,
139 { EGL_LUMINANCE_SIZE
, ATTRIB_TYPE_INTEGER
,
140 ATTRIB_CRITERION_ATLEAST
,
142 { EGL_ALPHA_SIZE
, ATTRIB_TYPE_INTEGER
,
143 ATTRIB_CRITERION_ATLEAST
,
145 { EGL_ALPHA_MASK_SIZE
, ATTRIB_TYPE_INTEGER
,
146 ATTRIB_CRITERION_ATLEAST
,
148 { EGL_BIND_TO_TEXTURE_RGB
, ATTRIB_TYPE_BOOLEAN
,
149 ATTRIB_CRITERION_EXACT
,
151 { EGL_BIND_TO_TEXTURE_RGBA
, ATTRIB_TYPE_BOOLEAN
,
152 ATTRIB_CRITERION_EXACT
,
154 { EGL_COLOR_BUFFER_TYPE
, ATTRIB_TYPE_ENUM
,
155 ATTRIB_CRITERION_EXACT
,
157 { EGL_CONFIG_CAVEAT
, ATTRIB_TYPE_ENUM
,
158 ATTRIB_CRITERION_EXACT
,
160 { EGL_CONFIG_ID
, ATTRIB_TYPE_INTEGER
,
161 ATTRIB_CRITERION_EXACT
,
163 { EGL_CONFORMANT
, ATTRIB_TYPE_BITMASK
,
164 ATTRIB_CRITERION_MASK
,
166 { EGL_DEPTH_SIZE
, ATTRIB_TYPE_INTEGER
,
167 ATTRIB_CRITERION_ATLEAST
,
169 { EGL_LEVEL
, ATTRIB_TYPE_PLATFORM
,
170 ATTRIB_CRITERION_EXACT
,
172 { EGL_MAX_PBUFFER_WIDTH
, ATTRIB_TYPE_INTEGER
,
173 ATTRIB_CRITERION_IGNORE
,
175 { EGL_MAX_PBUFFER_HEIGHT
, ATTRIB_TYPE_INTEGER
,
176 ATTRIB_CRITERION_IGNORE
,
178 { EGL_MAX_PBUFFER_PIXELS
, ATTRIB_TYPE_INTEGER
,
179 ATTRIB_CRITERION_IGNORE
,
181 { EGL_MAX_SWAP_INTERVAL
, ATTRIB_TYPE_INTEGER
,
182 ATTRIB_CRITERION_EXACT
,
184 { EGL_MIN_SWAP_INTERVAL
, ATTRIB_TYPE_INTEGER
,
185 ATTRIB_CRITERION_EXACT
,
187 { EGL_NATIVE_RENDERABLE
, ATTRIB_TYPE_BOOLEAN
,
188 ATTRIB_CRITERION_EXACT
,
190 { EGL_NATIVE_VISUAL_ID
, ATTRIB_TYPE_PLATFORM
,
191 ATTRIB_CRITERION_IGNORE
,
193 { EGL_NATIVE_VISUAL_TYPE
, ATTRIB_TYPE_PLATFORM
,
194 ATTRIB_CRITERION_EXACT
,
196 { EGL_RENDERABLE_TYPE
, ATTRIB_TYPE_BITMASK
,
197 ATTRIB_CRITERION_MASK
,
199 { EGL_SAMPLE_BUFFERS
, ATTRIB_TYPE_INTEGER
,
200 ATTRIB_CRITERION_ATLEAST
,
202 { EGL_SAMPLES
, ATTRIB_TYPE_INTEGER
,
203 ATTRIB_CRITERION_ATLEAST
,
205 { EGL_STENCIL_SIZE
, ATTRIB_TYPE_INTEGER
,
206 ATTRIB_CRITERION_ATLEAST
,
208 { EGL_SURFACE_TYPE
, ATTRIB_TYPE_BITMASK
,
209 ATTRIB_CRITERION_MASK
,
211 { EGL_TRANSPARENT_TYPE
, ATTRIB_TYPE_ENUM
,
212 ATTRIB_CRITERION_EXACT
,
214 { EGL_TRANSPARENT_RED_VALUE
, ATTRIB_TYPE_INTEGER
,
215 ATTRIB_CRITERION_EXACT
,
217 { EGL_TRANSPARENT_GREEN_VALUE
, ATTRIB_TYPE_INTEGER
,
218 ATTRIB_CRITERION_EXACT
,
220 { EGL_TRANSPARENT_BLUE_VALUE
, ATTRIB_TYPE_INTEGER
,
221 ATTRIB_CRITERION_EXACT
,
223 /* these are not real attributes */
224 { EGL_MATCH_NATIVE_PIXMAP
, ATTRIB_TYPE_PSEUDO
,
225 ATTRIB_CRITERION_SPECIAL
,
227 { EGL_PRESERVED_RESOURCES
, ATTRIB_TYPE_PSEUDO
,
228 ATTRIB_CRITERION_IGNORE
,
230 { EGL_NONE
, ATTRIB_TYPE_PSEUDO
,
231 ATTRIB_CRITERION_IGNORE
,
237 * Return true if a config is valid. When for_matching is true,
238 * EGL_DONT_CARE is accepted as a valid attribute value, and checks
239 * for conflicting attribute values are skipped.
241 * Note that some attributes are platform-dependent and are not
245 _eglValidateConfig(const _EGLConfig
*conf
, EGLBoolean for_matching
)
248 EGLBoolean valid
= EGL_TRUE
;
249 EGLint red_size
= 0, green_size
= 0, blue_size
= 0, luminance_size
= 0;
250 EGLint alpha_size
= 0, buffer_size
= 0;
252 /* all attributes should have been listed */
253 assert(ARRAY_SIZE(_eglValidationTable
) == _EGL_CONFIG_NUM_ATTRIBS
);
255 /* check attributes by their types */
256 for (i
= 0; i
< ARRAY_SIZE(_eglValidationTable
); i
++) {
259 attr
= _eglValidationTable
[i
].attr
;
260 val
= GET_CONFIG_ATTRIB(conf
, attr
);
262 switch (_eglValidationTable
[i
].type
) {
263 case ATTRIB_TYPE_INTEGER
:
266 /* config id must be positive */
270 case EGL_SAMPLE_BUFFERS
:
271 /* there can be at most 1 sample buffer */
284 case EGL_LUMINANCE_SIZE
:
285 luminance_size
= val
;
290 case EGL_BUFFER_SIZE
:
297 case ATTRIB_TYPE_BOOLEAN
:
298 if (val
!= EGL_TRUE
&& val
!= EGL_FALSE
)
301 case ATTRIB_TYPE_ENUM
:
303 case EGL_CONFIG_CAVEAT
:
304 if (val
!= EGL_NONE
&& val
!= EGL_SLOW_CONFIG
&&
305 val
!= EGL_NON_CONFORMANT_CONFIG
)
308 case EGL_TRANSPARENT_TYPE
:
309 if (val
!= EGL_NONE
&& val
!= EGL_TRANSPARENT_RGB
)
312 case EGL_COLOR_BUFFER_TYPE
:
313 if (val
!= EGL_RGB_BUFFER
&& val
!= EGL_LUMINANCE_BUFFER
)
321 case ATTRIB_TYPE_BITMASK
:
323 case EGL_SURFACE_TYPE
:
324 mask
= EGL_PBUFFER_BIT
|
327 EGL_VG_COLORSPACE_LINEAR_BIT
|
328 EGL_VG_ALPHA_FORMAT_PRE_BIT
|
329 EGL_MULTISAMPLE_RESOLVE_BOX_BIT
|
330 EGL_SWAP_BEHAVIOR_PRESERVED_BIT
;
332 case EGL_RENDERABLE_TYPE
:
334 mask
= EGL_OPENGL_ES_BIT
|
346 case ATTRIB_TYPE_PLATFORM
:
347 /* unable to check platform-dependent attributes here */
349 case ATTRIB_TYPE_PSEUDO
:
350 /* pseudo attributes should not be set */
359 if (!valid
&& for_matching
) {
360 /* accept EGL_DONT_CARE as a valid value */
361 if (val
== EGL_DONT_CARE
)
363 if (_eglValidationTable
[i
].criterion
== ATTRIB_CRITERION_SPECIAL
)
370 /* any invalid attribute value should have been catched */
371 if (!valid
|| for_matching
)
374 /* now check for conflicting attribute values */
376 switch (GET_CONFIG_ATTRIB(conf
, EGL_COLOR_BUFFER_TYPE
)) {
380 if (red_size
+ green_size
+ blue_size
+ alpha_size
!= buffer_size
)
383 case EGL_LUMINANCE_BUFFER
:
384 if (red_size
|| green_size
|| blue_size
)
386 if (luminance_size
+ alpha_size
!= buffer_size
)
391 val
= GET_CONFIG_ATTRIB(conf
, EGL_SAMPLE_BUFFERS
);
392 if (!val
&& GET_CONFIG_ATTRIB(conf
, EGL_SAMPLES
))
395 val
= GET_CONFIG_ATTRIB(conf
, EGL_SURFACE_TYPE
);
396 if (!(val
& EGL_WINDOW_BIT
)) {
397 if (GET_CONFIG_ATTRIB(conf
, EGL_NATIVE_VISUAL_ID
) != 0 ||
398 GET_CONFIG_ATTRIB(conf
, EGL_NATIVE_VISUAL_TYPE
) != EGL_NONE
)
401 if (!(val
& EGL_PBUFFER_BIT
)) {
402 if (GET_CONFIG_ATTRIB(conf
, EGL_BIND_TO_TEXTURE_RGB
) ||
403 GET_CONFIG_ATTRIB(conf
, EGL_BIND_TO_TEXTURE_RGBA
))
412 * Return true if a config matches the criteria. This and
413 * _eglParseConfigAttribList together implement the algorithm
414 * described in "Selection of EGLConfigs".
416 * Note that attributes that are special (currently, only
417 * EGL_MATCH_NATIVE_PIXMAP) are ignored.
420 _eglMatchConfig(const _EGLConfig
*conf
, const _EGLConfig
*criteria
)
423 EGLBoolean matched
= EGL_TRUE
;
425 for (i
= 0; i
< ARRAY_SIZE(_eglValidationTable
); i
++) {
427 if (_eglValidationTable
[i
].criterion
== ATTRIB_CRITERION_IGNORE
)
430 attr
= _eglValidationTable
[i
].attr
;
431 cmp
= GET_CONFIG_ATTRIB(criteria
, attr
);
432 if (cmp
== EGL_DONT_CARE
)
435 val
= GET_CONFIG_ATTRIB(conf
, attr
);
436 switch (_eglValidationTable
[i
].criterion
) {
437 case ATTRIB_CRITERION_EXACT
:
441 case ATTRIB_CRITERION_ATLEAST
:
445 case ATTRIB_CRITERION_MASK
:
446 if ((val
& cmp
) != cmp
)
449 case ATTRIB_CRITERION_SPECIAL
:
466 * Initialize a criteria config from the given attribute list.
467 * Return EGL_FALSE if any of the attribute is invalid.
470 _eglParseConfigAttribList(_EGLConfig
*conf
, const EGLint
*attrib_list
)
473 EGLint config_id
= 0, level
= 0;
474 EGLBoolean has_native_visual_type
= EGL_FALSE
;
475 EGLBoolean has_transparent_color
= EGL_FALSE
;
477 /* reset to default values */
478 for (i
= 0; i
< ARRAY_SIZE(_eglValidationTable
); i
++) {
479 attr
= _eglValidationTable
[i
].attr
;
480 val
= _eglValidationTable
[i
].default_value
;
481 SET_CONFIG_ATTRIB(conf
, attr
, val
);
485 for (i
= 0; attrib_list
&& attrib_list
[i
] != EGL_NONE
; i
+= 2) {
488 attr
= attrib_list
[i
];
489 val
= attrib_list
[i
+ 1];
491 idx
= _eglIndexConfig(conf
, attr
);
494 conf
->Storage
[idx
] = val
;
496 /* rememeber some attributes for post-processing */
504 case EGL_NATIVE_VISUAL_TYPE
:
505 has_native_visual_type
= EGL_TRUE
;
507 case EGL_TRANSPARENT_RED_VALUE
:
508 case EGL_TRANSPARENT_GREEN_VALUE
:
509 case EGL_TRANSPARENT_BLUE_VALUE
:
510 has_transparent_color
= EGL_TRUE
;
517 if (!_eglValidateConfig(conf
, EGL_TRUE
))
520 /* the spec says that EGL_LEVEL cannot be EGL_DONT_CARE */
521 if (level
== EGL_DONT_CARE
)
524 /* ignore other attributes when EGL_CONFIG_ID is given */
526 _eglResetConfigKeys(conf
, EGL_DONT_CARE
);
527 SET_CONFIG_ATTRIB(conf
, EGL_CONFIG_ID
, config_id
);
530 if (has_native_visual_type
) {
531 val
= GET_CONFIG_ATTRIB(conf
, EGL_SURFACE_TYPE
);
532 if (!(val
& EGL_WINDOW_BIT
))
533 SET_CONFIG_ATTRIB(conf
, EGL_NATIVE_VISUAL_TYPE
, EGL_DONT_CARE
);
536 if (has_transparent_color
) {
537 val
= GET_CONFIG_ATTRIB(conf
, EGL_TRANSPARENT_TYPE
);
538 if (val
== EGL_NONE
) {
539 SET_CONFIG_ATTRIB(conf
, EGL_TRANSPARENT_RED_VALUE
,
541 SET_CONFIG_ATTRIB(conf
, EGL_TRANSPARENT_GREEN_VALUE
,
543 SET_CONFIG_ATTRIB(conf
, EGL_TRANSPARENT_BLUE_VALUE
,
554 * Decide the ordering of conf1 and conf2, under the given criteria.
555 * When compare_id is true, this implements the algorithm described
556 * in "Sorting of EGLConfigs". When compare_id is false,
557 * EGL_CONFIG_ID is not compared.
559 * It returns a negative integer if conf1 is considered to come
560 * before conf2; a positive integer if conf2 is considered to come
561 * before conf1; zero if the ordering cannot be decided.
563 * Note that EGL_NATIVE_VISUAL_TYPE is platform-dependent and is
567 _eglCompareConfigs(const _EGLConfig
*conf1
, const _EGLConfig
*conf2
,
568 const _EGLConfig
*criteria
, EGLBoolean compare_id
)
570 const EGLint compare_attribs
[] = {
579 EGLBoolean rgb_buffer
;
585 /* the enum values have the desired ordering */
586 assert(EGL_NONE
< EGL_SLOW_CONFIG
);
587 assert(EGL_SLOW_CONFIG
< EGL_NON_CONFORMANT_CONFIG
);
588 val1
= GET_CONFIG_ATTRIB(conf1
, EGL_CONFIG_CAVEAT
);
589 val2
= GET_CONFIG_ATTRIB(conf2
, EGL_CONFIG_CAVEAT
);
591 return (val1
- val2
);
593 /* the enum values have the desired ordering */
594 assert(EGL_RGB_BUFFER
< EGL_LUMINANCE_BUFFER
);
595 val1
= GET_CONFIG_ATTRIB(conf1
, EGL_COLOR_BUFFER_TYPE
);
596 val2
= GET_CONFIG_ATTRIB(conf2
, EGL_COLOR_BUFFER_TYPE
);
598 return (val1
- val2
);
599 rgb_buffer
= (val1
== EGL_RGB_BUFFER
);
604 if (GET_CONFIG_ATTRIB(criteria
, EGL_RED_SIZE
) > 0) {
605 val1
+= GET_CONFIG_ATTRIB(conf1
, EGL_RED_SIZE
);
606 val2
+= GET_CONFIG_ATTRIB(conf2
, EGL_RED_SIZE
);
608 if (GET_CONFIG_ATTRIB(criteria
, EGL_GREEN_SIZE
) > 0) {
609 val1
+= GET_CONFIG_ATTRIB(conf1
, EGL_GREEN_SIZE
);
610 val2
+= GET_CONFIG_ATTRIB(conf2
, EGL_GREEN_SIZE
);
612 if (GET_CONFIG_ATTRIB(criteria
, EGL_BLUE_SIZE
) > 0) {
613 val1
+= GET_CONFIG_ATTRIB(conf1
, EGL_BLUE_SIZE
);
614 val2
+= GET_CONFIG_ATTRIB(conf2
, EGL_BLUE_SIZE
);
618 if (GET_CONFIG_ATTRIB(criteria
, EGL_LUMINANCE_SIZE
) > 0) {
619 val1
+= GET_CONFIG_ATTRIB(conf1
, EGL_LUMINANCE_SIZE
);
620 val2
+= GET_CONFIG_ATTRIB(conf2
, EGL_LUMINANCE_SIZE
);
623 if (GET_CONFIG_ATTRIB(criteria
, EGL_ALPHA_SIZE
) > 0) {
624 val1
+= GET_CONFIG_ATTRIB(conf1
, EGL_ALPHA_SIZE
);
625 val2
+= GET_CONFIG_ATTRIB(conf2
, EGL_ALPHA_SIZE
);
629 /* assume the default criteria, which gives no specific ordering */
633 /* for color bits, larger one is preferred */
635 return (val2
- val1
);
637 for (i
= 0; i
< ARRAY_SIZE(compare_attribs
); i
++) {
638 val1
= GET_CONFIG_ATTRIB(conf1
, compare_attribs
[i
]);
639 val2
= GET_CONFIG_ATTRIB(conf2
, compare_attribs
[i
]);
641 return (val1
- val2
);
644 /* EGL_NATIVE_VISUAL_TYPE cannot be compared here */
647 val1
= GET_CONFIG_ATTRIB(conf1
, EGL_CONFIG_ID
);
648 val2
= GET_CONFIG_ATTRIB(conf2
, EGL_CONFIG_ID
);
649 assert(val1
!= val2
);
655 return (val1
- val2
);
660 void _eglSwapConfigs(const _EGLConfig
**conf1
, const _EGLConfig
**conf2
)
662 const _EGLConfig
*tmp
= *conf1
;
669 * Quick sort an array of configs. This differs from the standard
670 * qsort() in that the compare function accepts an additional
674 _eglSortConfigs(const _EGLConfig
**configs
, EGLint count
,
675 EGLint (*compare
)(const _EGLConfig
*, const _EGLConfig
*,
679 const EGLint pivot
= 0;
685 _eglSwapConfigs(&configs
[pivot
], &configs
[count
/ 2]);
689 while (i
< count
&& compare(configs
[i
], configs
[pivot
], priv_data
) < 0)
691 while (compare(configs
[j
], configs
[pivot
], priv_data
) > 0)
694 _eglSwapConfigs(&configs
[i
], &configs
[j
]);
704 _eglSwapConfigs(&configs
[pivot
], &configs
[j
]);
706 _eglSortConfigs(configs
, j
, compare
, priv_data
);
707 _eglSortConfigs(configs
+ i
, count
- i
, compare
, priv_data
);
712 _eglFallbackCompare(const _EGLConfig
*conf1
, const _EGLConfig
*conf2
,
715 const _EGLConfig
*criteria
= (const _EGLConfig
*) priv_data
;
716 return _eglCompareConfigs(conf1
, conf2
, criteria
, EGL_TRUE
);
721 * Typical fallback routine for eglChooseConfig
724 _eglChooseConfig(_EGLDriver
*drv
, _EGLDisplay
*disp
, const EGLint
*attrib_list
,
725 EGLConfig
*configs
, EGLint config_size
, EGLint
*num_configs
)
727 _EGLConfig
**configList
, criteria
;
731 return _eglError(EGL_BAD_PARAMETER
, "eglChooseConfigs");
733 _eglInitConfig(&criteria
, 0);
734 if (!_eglParseConfigAttribList(&criteria
, attrib_list
))
735 return _eglError(EGL_BAD_ATTRIBUTE
, "eglChooseConfig");
737 /* allocate array of config pointers */
738 configList
= (_EGLConfig
**)
739 malloc(disp
->NumConfigs
* sizeof(_EGLConfig
*));
741 return _eglError(EGL_BAD_ALLOC
, "eglChooseConfig(out of memory)");
743 /* perform selection of configs */
745 for (i
= 0; i
< disp
->NumConfigs
; i
++) {
746 if (_eglMatchConfig(disp
->Configs
[i
], &criteria
))
747 configList
[count
++] = disp
->Configs
[i
];
750 /* perform sorting of configs */
751 if (configs
&& count
) {
752 _eglSortConfigs((const _EGLConfig
**) configList
, count
,
753 _eglFallbackCompare
, (void *) &criteria
);
754 count
= MIN2(count
, config_size
);
755 for (i
= 0; i
< count
; i
++)
756 configs
[i
] = _eglGetConfigHandle(configList
[i
]);
761 *num_configs
= count
;
767 static INLINE EGLBoolean
768 _eglIsConfigAttribValid(_EGLConfig
*conf
, EGLint attr
)
770 if (_eglIndexConfig(conf
, attr
) < 0)
773 /* there are some holes in the range */
775 case EGL_PRESERVED_RESOURCES
:
777 #ifdef EGL_VERSION_1_4
778 case EGL_MATCH_NATIVE_PIXMAP
:
790 * Fallback for eglGetConfigAttrib.
793 _eglGetConfigAttrib(_EGLDriver
*drv
, _EGLDisplay
*dpy
, _EGLConfig
*conf
,
794 EGLint attribute
, EGLint
*value
)
796 if (!_eglIsConfigAttribValid(conf
, attribute
))
797 return _eglError(EGL_BAD_ATTRIBUTE
, "eglGetConfigAttrib");
799 return _eglError(EGL_BAD_PARAMETER
, "eglGetConfigAttrib");
801 *value
= GET_CONFIG_ATTRIB(conf
, attribute
);
807 * Fallback for eglGetConfigs.
810 _eglGetConfigs(_EGLDriver
*drv
, _EGLDisplay
*disp
, EGLConfig
*configs
,
811 EGLint config_size
, EGLint
*num_config
)
814 return _eglError(EGL_BAD_PARAMETER
, "eglGetConfigs");
818 *num_config
= MIN2(disp
->NumConfigs
, config_size
);
819 for (i
= 0; i
< *num_config
; i
++)
820 configs
[i
] = _eglGetConfigHandle(disp
->Configs
[i
]);
823 /* just return total number of supported configs */
824 *num_config
= disp
->NumConfigs
;