summaryrefslogtreecommitdiff
path: root/src/egl
diff options
context:
space:
mode:
Diffstat (limited to 'src/egl')
-rw-r--r--src/egl/drivers/Makefile.template4
-rw-r--r--src/egl/drivers/dri2/egl_dri2.c480
-rw-r--r--src/egl/drivers/glx/egl_glx.c34
-rw-r--r--src/egl/main/SConscript92
-rw-r--r--src/egl/main/eglapi.c35
-rw-r--r--src/egl/main/eglarray.h2
-rw-r--r--src/egl/main/eglconfig.c34
-rw-r--r--src/egl/main/eglconfig.h28
-rw-r--r--src/egl/main/eglcontext.c99
-rw-r--r--src/egl/main/eglcontext.h45
-rw-r--r--src/egl/main/eglcurrent.c40
-rw-r--r--src/egl/main/egldisplay.c53
-rw-r--r--src/egl/main/egldisplay.h15
-rw-r--r--src/egl/main/egldriver.c65
-rw-r--r--src/egl/main/egldriver.h2
-rw-r--r--src/egl/main/eglimage.c4
-rw-r--r--src/egl/main/eglimage.h39
-rw-r--r--src/egl/main/egllog.c5
-rw-r--r--src/egl/main/eglmode.c60
-rw-r--r--src/egl/main/eglmode.h5
-rw-r--r--src/egl/main/eglscreen.c117
-rw-r--r--src/egl/main/eglscreen.h37
-rw-r--r--src/egl/main/eglsurface.c3
-rw-r--r--src/egl/main/eglsurface.h41
-rw-r--r--src/egl/main/eglsync.c5
-rw-r--r--src/egl/main/eglsync.h42
26 files changed, 940 insertions, 446 deletions
diff --git a/src/egl/drivers/Makefile.template b/src/egl/drivers/Makefile.template
index 08e82c65e9..47709e3c59 100644
--- a/src/egl/drivers/Makefile.template
+++ b/src/egl/drivers/Makefile.template
@@ -24,8 +24,8 @@ $(EGL_DRIVER_PATH): $(EGL_DRIVER)
$(EGL_DRIVER): $(EGL_OBJECTS) Makefile $(TOP)/src/egl/drivers/Makefile.template
@$(MKLIB) -o $(EGL_DRIVER) -noprefix \
- -linker '$(CC)' -ldflags '$(LDFLAGS)' \
- -L$(TOP)/$(LIB_DIR) $(MKLIB_OPTIONS) \
+ -linker '$(CC)' -ldflags '-L$(TOP)/$(LIB_DIR) $(LDFLAGS)' \
+ $(MKLIB_OPTIONS) \
$(EGL_OBJECTS) $(EGL_LIBS) -l$(EGL_LIB)
.c.o:
diff --git a/src/egl/drivers/dri2/egl_dri2.c b/src/egl/drivers/dri2/egl_dri2.c
index eb8996f7a7..a83f32b0d1 100644
--- a/src/egl/drivers/dri2/egl_dri2.c
+++ b/src/egl/drivers/dri2/egl_dri2.c
@@ -272,7 +272,7 @@ dri2_add_config(_EGLDisplay *disp, const __DRIconfig *dri_config, int id,
if (conf != NULL) {
memcpy(&conf->base, &base, sizeof base);
conf->dri_config = dri_config;
- _eglAddConfig(disp, &conf->base);
+ _eglLinkConfig(&conf->base);
}
return conf;
@@ -750,7 +750,7 @@ dri2_create_screen(_EGLDisplay *disp)
if (dri2_dpy->dri2->base.version >= 2)
api_mask = dri2_dpy->dri2->getAPIMask(dri2_dpy->dri_screen);
else
- api_mask = __DRI_API_OPENGL;
+ api_mask = 1 << __DRI_API_OPENGL;
disp->ClientAPIsMask = 0;
if (api_mask & (1 <<__DRI_API_OPENGL))
@@ -899,10 +899,20 @@ const int i915_chip_ids[] = {
0x29b2, /* PCI_CHIP_Q35_G */
0x29c2, /* PCI_CHIP_G33_G */
0x29d2, /* PCI_CHIP_Q33_G */
+ 0xa001, /* PCI_CHIP_IGD_G */
0xa011, /* Pineview */
};
const int i965_chip_ids[] = {
+ 0x0042, /* PCI_CHIP_ILD_G */
+ 0x0046, /* PCI_CHIP_ILM_G */
+ 0x0102, /* PCI_CHIP_SANDYBRIDGE_GT1 */
+ 0x0106, /* PCI_CHIP_SANDYBRIDGE_M_GT1 */
+ 0x010a, /* PCI_CHIP_SANDYBRIDGE_S */
+ 0x0112, /* PCI_CHIP_SANDYBRIDGE_GT2 */
+ 0x0116, /* PCI_CHIP_SANDYBRIDGE_M_GT2 */
+ 0x0122, /* PCI_CHIP_SANDYBRIDGE_GT2_PLUS */
+ 0x0126, /* PCI_CHIP_SANDYBRIDGE_M_GT2_PLUS */
0x29a2, /* PCI_CHIP_I965_G */
0x2992, /* PCI_CHIP_I965_Q */
0x2982, /* PCI_CHIP_I965_G_1 */
@@ -914,11 +924,440 @@ const int i965_chip_ids[] = {
0x2e12, /* PCI_CHIP_Q45_G */
0x2e22, /* PCI_CHIP_G45_G */
0x2e32, /* PCI_CHIP_G41_G */
+ 0x2e42, /* PCI_CHIP_B43_G */
+ 0x2e92, /* PCI_CHIP_B43_G1 */
+};
+
+const int r100_chip_ids[] = {
+ 0x4C57, /* PCI_CHIP_RADEON_LW */
+ 0x4C58, /* PCI_CHIP_RADEON_LX */
+ 0x4C59, /* PCI_CHIP_RADEON_LY */
+ 0x4C5A, /* PCI_CHIP_RADEON_LZ */
+ 0x5144, /* PCI_CHIP_RADEON_QD */
+ 0x5145, /* PCI_CHIP_RADEON_QE */
+ 0x5146, /* PCI_CHIP_RADEON_QF */
+ 0x5147, /* PCI_CHIP_RADEON_QG */
+ 0x5159, /* PCI_CHIP_RADEON_QY */
+ 0x515A, /* PCI_CHIP_RADEON_QZ */
+ 0x5157, /* PCI_CHIP_RV200_QW */
+ 0x5158, /* PCI_CHIP_RV200_QX */
+ 0x515E, /* PCI_CHIP_RN50_515E */
+ 0x5969, /* PCI_CHIP_RN50_5969 */
+ 0x4136, /* PCI_CHIP_RS100_4136 */
+ 0x4336, /* PCI_CHIP_RS100_4336 */
+ 0x4137, /* PCI_CHIP_RS200_4137 */
+ 0x4337, /* PCI_CHIP_RS200_4337 */
+ 0x4237, /* PCI_CHIP_RS250_4237 */
+ 0x4437, /* PCI_CHIP_RS250_4437 */
+};
+
+const int r200_chip_ids[] = {
+ 0x5148, /* PCI_CHIP_R200_QH */
+ 0x514C, /* PCI_CHIP_R200_QL */
+ 0x514D, /* PCI_CHIP_R200_QM */
+ 0x4242, /* PCI_CHIP_R200_BB */
+ 0x4243, /* PCI_CHIP_R200_BC */
+ 0x4966, /* PCI_CHIP_RV250_If */
+ 0x4967, /* PCI_CHIP_RV250_Ig */
+ 0x4C64, /* PCI_CHIP_RV250_Ld */
+ 0x4C66, /* PCI_CHIP_RV250_Lf */
+ 0x4C67, /* PCI_CHIP_RV250_Lg */
+ 0x5960, /* PCI_CHIP_RV280_5960 */
+ 0x5961, /* PCI_CHIP_RV280_5961 */
+ 0x5962, /* PCI_CHIP_RV280_5962 */
+ 0x5964, /* PCI_CHIP_RV280_5964 */
+ 0x5965, /* PCI_CHIP_RV280_5965 */
+ 0x5C61, /* PCI_CHIP_RV280_5C61 */
+ 0x5C63, /* PCI_CHIP_RV280_5C63 */
+ 0x5834, /* PCI_CHIP_RS300_5834 */
+ 0x5835, /* PCI_CHIP_RS300_5835 */
+ 0x7834, /* PCI_CHIP_RS350_7834 */
+ 0x7835, /* PCI_CHIP_RS350_7835 */
+};
+
+const int r300_chip_ids[] = {
+ 0x4144, /* PCI_CHIP_R300_AD */
+ 0x4145, /* PCI_CHIP_R300_AE */
+ 0x4146, /* PCI_CHIP_R300_AF */
+ 0x4147, /* PCI_CHIP_R300_AG */
+ 0x4E44, /* PCI_CHIP_R300_ND */
+ 0x4E45, /* PCI_CHIP_R300_NE */
+ 0x4E46, /* PCI_CHIP_R300_NF */
+ 0x4E47, /* PCI_CHIP_R300_NG */
+ 0x4E48, /* PCI_CHIP_R350_NH */
+ 0x4E49, /* PCI_CHIP_R350_NI */
+ 0x4E4B, /* PCI_CHIP_R350_NK */
+ 0x4148, /* PCI_CHIP_R350_AH */
+ 0x4149, /* PCI_CHIP_R350_AI */
+ 0x414A, /* PCI_CHIP_R350_AJ */
+ 0x414B, /* PCI_CHIP_R350_AK */
+ 0x4E4A, /* PCI_CHIP_R360_NJ */
+ 0x4150, /* PCI_CHIP_RV350_AP */
+ 0x4151, /* PCI_CHIP_RV350_AQ */
+ 0x4152, /* PCI_CHIP_RV350_AR */
+ 0x4153, /* PCI_CHIP_RV350_AS */
+ 0x4154, /* PCI_CHIP_RV350_AT */
+ 0x4155, /* PCI_CHIP_RV350_AU */
+ 0x4156, /* PCI_CHIP_RV350_AV */
+ 0x4E50, /* PCI_CHIP_RV350_NP */
+ 0x4E51, /* PCI_CHIP_RV350_NQ */
+ 0x4E52, /* PCI_CHIP_RV350_NR */
+ 0x4E53, /* PCI_CHIP_RV350_NS */
+ 0x4E54, /* PCI_CHIP_RV350_NT */
+ 0x4E56, /* PCI_CHIP_RV350_NV */
+ 0x5460, /* PCI_CHIP_RV370_5460 */
+ 0x5462, /* PCI_CHIP_RV370_5462 */
+ 0x5464, /* PCI_CHIP_RV370_5464 */
+ 0x5B60, /* PCI_CHIP_RV370_5B60 */
+ 0x5B62, /* PCI_CHIP_RV370_5B62 */
+ 0x5B63, /* PCI_CHIP_RV370_5B63 */
+ 0x5B64, /* PCI_CHIP_RV370_5B64 */
+ 0x5B65, /* PCI_CHIP_RV370_5B65 */
+ 0x3150, /* PCI_CHIP_RV380_3150 */
+ 0x3152, /* PCI_CHIP_RV380_3152 */
+ 0x3154, /* PCI_CHIP_RV380_3154 */
+ 0x3155, /* PCI_CHIP_RV380_3155 */
+ 0x3E50, /* PCI_CHIP_RV380_3E50 */
+ 0x3E54, /* PCI_CHIP_RV380_3E54 */
+ 0x4A48, /* PCI_CHIP_R420_JH */
+ 0x4A49, /* PCI_CHIP_R420_JI */
+ 0x4A4A, /* PCI_CHIP_R420_JJ */
+ 0x4A4B, /* PCI_CHIP_R420_JK */
+ 0x4A4C, /* PCI_CHIP_R420_JL */
+ 0x4A4D, /* PCI_CHIP_R420_JM */
+ 0x4A4E, /* PCI_CHIP_R420_JN */
+ 0x4A4F, /* PCI_CHIP_R420_JO */
+ 0x4A50, /* PCI_CHIP_R420_JP */
+ 0x4A54, /* PCI_CHIP_R420_JT */
+ 0x5548, /* PCI_CHIP_R423_UH */
+ 0x5549, /* PCI_CHIP_R423_UI */
+ 0x554A, /* PCI_CHIP_R423_UJ */
+ 0x554B, /* PCI_CHIP_R423_UK */
+ 0x5550, /* PCI_CHIP_R423_5550 */
+ 0x5551, /* PCI_CHIP_R423_UQ */
+ 0x5552, /* PCI_CHIP_R423_UR */
+ 0x5554, /* PCI_CHIP_R423_UT */
+ 0x5D57, /* PCI_CHIP_R423_5D57 */
+ 0x554C, /* PCI_CHIP_R430_554C */
+ 0x554D, /* PCI_CHIP_R430_554D */
+ 0x554E, /* PCI_CHIP_R430_554E */
+ 0x554F, /* PCI_CHIP_R430_554F */
+ 0x5D48, /* PCI_CHIP_R430_5D48 */
+ 0x5D49, /* PCI_CHIP_R430_5D49 */
+ 0x5D4A, /* PCI_CHIP_R430_5D4A */
+ 0x5D4C, /* PCI_CHIP_R480_5D4C */
+ 0x5D4D, /* PCI_CHIP_R480_5D4D */
+ 0x5D4E, /* PCI_CHIP_R480_5D4E */
+ 0x5D4F, /* PCI_CHIP_R480_5D4F */
+ 0x5D50, /* PCI_CHIP_R480_5D50 */
+ 0x5D52, /* PCI_CHIP_R480_5D52 */
+ 0x4B49, /* PCI_CHIP_R481_4B49 */
+ 0x4B4A, /* PCI_CHIP_R481_4B4A */
+ 0x4B4B, /* PCI_CHIP_R481_4B4B */
+ 0x4B4C, /* PCI_CHIP_R481_4B4C */
+ 0x564A, /* PCI_CHIP_RV410_564A */
+ 0x564B, /* PCI_CHIP_RV410_564B */
+ 0x564F, /* PCI_CHIP_RV410_564F */
+ 0x5652, /* PCI_CHIP_RV410_5652 */
+ 0x5653, /* PCI_CHIP_RV410_5653 */
+ 0x5657, /* PCI_CHIP_RV410_5657 */
+ 0x5E48, /* PCI_CHIP_RV410_5E48 */
+ 0x5E4A, /* PCI_CHIP_RV410_5E4A */
+ 0x5E4B, /* PCI_CHIP_RV410_5E4B */
+ 0x5E4C, /* PCI_CHIP_RV410_5E4C */
+ 0x5E4D, /* PCI_CHIP_RV410_5E4D */
+ 0x5E4F, /* PCI_CHIP_RV410_5E4F */
+ 0x5A41, /* PCI_CHIP_RS400_5A41 */
+ 0x5A42, /* PCI_CHIP_RS400_5A42 */
+ 0x5A61, /* PCI_CHIP_RC410_5A61 */
+ 0x5A62, /* PCI_CHIP_RC410_5A62 */
+ 0x5954, /* PCI_CHIP_RS480_5954 */
+ 0x5955, /* PCI_CHIP_RS480_5955 */
+ 0x5974, /* PCI_CHIP_RS482_5974 */
+ 0x5975, /* PCI_CHIP_RS482_5975 */
+ 0x7100, /* PCI_CHIP_R520_7100 */
+ 0x7101, /* PCI_CHIP_R520_7101 */
+ 0x7102, /* PCI_CHIP_R520_7102 */
+ 0x7103, /* PCI_CHIP_R520_7103 */
+ 0x7104, /* PCI_CHIP_R520_7104 */
+ 0x7105, /* PCI_CHIP_R520_7105 */
+ 0x7106, /* PCI_CHIP_R520_7106 */
+ 0x7108, /* PCI_CHIP_R520_7108 */
+ 0x7109, /* PCI_CHIP_R520_7109 */
+ 0x710A, /* PCI_CHIP_R520_710A */
+ 0x710B, /* PCI_CHIP_R520_710B */
+ 0x710C, /* PCI_CHIP_R520_710C */
+ 0x710E, /* PCI_CHIP_R520_710E */
+ 0x710F, /* PCI_CHIP_R520_710F */
+ 0x7140, /* PCI_CHIP_RV515_7140 */
+ 0x7141, /* PCI_CHIP_RV515_7141 */
+ 0x7142, /* PCI_CHIP_RV515_7142 */
+ 0x7143, /* PCI_CHIP_RV515_7143 */
+ 0x7144, /* PCI_CHIP_RV515_7144 */
+ 0x7145, /* PCI_CHIP_RV515_7145 */
+ 0x7146, /* PCI_CHIP_RV515_7146 */
+ 0x7147, /* PCI_CHIP_RV515_7147 */
+ 0x7149, /* PCI_CHIP_RV515_7149 */
+ 0x714A, /* PCI_CHIP_RV515_714A */
+ 0x714B, /* PCI_CHIP_RV515_714B */
+ 0x714C, /* PCI_CHIP_RV515_714C */
+ 0x714D, /* PCI_CHIP_RV515_714D */
+ 0x714E, /* PCI_CHIP_RV515_714E */
+ 0x714F, /* PCI_CHIP_RV515_714F */
+ 0x7151, /* PCI_CHIP_RV515_7151 */
+ 0x7152, /* PCI_CHIP_RV515_7152 */
+ 0x7153, /* PCI_CHIP_RV515_7153 */
+ 0x715E, /* PCI_CHIP_RV515_715E */
+ 0x715F, /* PCI_CHIP_RV515_715F */
+ 0x7180, /* PCI_CHIP_RV515_7180 */
+ 0x7181, /* PCI_CHIP_RV515_7181 */
+ 0x7183, /* PCI_CHIP_RV515_7183 */
+ 0x7186, /* PCI_CHIP_RV515_7186 */
+ 0x7187, /* PCI_CHIP_RV515_7187 */
+ 0x7188, /* PCI_CHIP_RV515_7188 */
+ 0x718A, /* PCI_CHIP_RV515_718A */
+ 0x718B, /* PCI_CHIP_RV515_718B */
+ 0x718C, /* PCI_CHIP_RV515_718C */
+ 0x718D, /* PCI_CHIP_RV515_718D */
+ 0x718F, /* PCI_CHIP_RV515_718F */
+ 0x7193, /* PCI_CHIP_RV515_7193 */
+ 0x7196, /* PCI_CHIP_RV515_7196 */
+ 0x719B, /* PCI_CHIP_RV515_719B */
+ 0x719F, /* PCI_CHIP_RV515_719F */
+ 0x7200, /* PCI_CHIP_RV515_7200 */
+ 0x7210, /* PCI_CHIP_RV515_7210 */
+ 0x7211, /* PCI_CHIP_RV515_7211 */
+ 0x71C0, /* PCI_CHIP_RV530_71C0 */
+ 0x71C1, /* PCI_CHIP_RV530_71C1 */
+ 0x71C2, /* PCI_CHIP_RV530_71C2 */
+ 0x71C3, /* PCI_CHIP_RV530_71C3 */
+ 0x71C4, /* PCI_CHIP_RV530_71C4 */
+ 0x71C5, /* PCI_CHIP_RV530_71C5 */
+ 0x71C6, /* PCI_CHIP_RV530_71C6 */
+ 0x71C7, /* PCI_CHIP_RV530_71C7 */
+ 0x71CD, /* PCI_CHIP_RV530_71CD */
+ 0x71CE, /* PCI_CHIP_RV530_71CE */
+ 0x71D2, /* PCI_CHIP_RV530_71D2 */
+ 0x71D4, /* PCI_CHIP_RV530_71D4 */
+ 0x71D5, /* PCI_CHIP_RV530_71D5 */
+ 0x71D6, /* PCI_CHIP_RV530_71D6 */
+ 0x71DA, /* PCI_CHIP_RV530_71DA */
+ 0x71DE, /* PCI_CHIP_RV530_71DE */
+ 0x7281, /* PCI_CHIP_RV560_7281 */
+ 0x7283, /* PCI_CHIP_RV560_7283 */
+ 0x7287, /* PCI_CHIP_RV560_7287 */
+ 0x7290, /* PCI_CHIP_RV560_7290 */
+ 0x7291, /* PCI_CHIP_RV560_7291 */
+ 0x7293, /* PCI_CHIP_RV560_7293 */
+ 0x7297, /* PCI_CHIP_RV560_7297 */
+ 0x7280, /* PCI_CHIP_RV570_7280 */
+ 0x7288, /* PCI_CHIP_RV570_7288 */
+ 0x7289, /* PCI_CHIP_RV570_7289 */
+ 0x728B, /* PCI_CHIP_RV570_728B */
+ 0x728C, /* PCI_CHIP_RV570_728C */
+ 0x7240, /* PCI_CHIP_R580_7240 */
+ 0x7243, /* PCI_CHIP_R580_7243 */
+ 0x7244, /* PCI_CHIP_R580_7244 */
+ 0x7245, /* PCI_CHIP_R580_7245 */
+ 0x7246, /* PCI_CHIP_R580_7246 */
+ 0x7247, /* PCI_CHIP_R580_7247 */
+ 0x7248, /* PCI_CHIP_R580_7248 */
+ 0x7249, /* PCI_CHIP_R580_7249 */
+ 0x724A, /* PCI_CHIP_R580_724A */
+ 0x724B, /* PCI_CHIP_R580_724B */
+ 0x724C, /* PCI_CHIP_R580_724C */
+ 0x724D, /* PCI_CHIP_R580_724D */
+ 0x724E, /* PCI_CHIP_R580_724E */
+ 0x724F, /* PCI_CHIP_R580_724F */
+ 0x7284, /* PCI_CHIP_R580_7284 */
+ 0x793F, /* PCI_CHIP_RS600_793F */
+ 0x7941, /* PCI_CHIP_RS600_7941 */
+ 0x7942, /* PCI_CHIP_RS600_7942 */
+ 0x791E, /* PCI_CHIP_RS690_791E */
+ 0x791F, /* PCI_CHIP_RS690_791F */
+ 0x796C, /* PCI_CHIP_RS740_796C */
+ 0x796D, /* PCI_CHIP_RS740_796D */
+ 0x796E, /* PCI_CHIP_RS740_796E */
+ 0x796F, /* PCI_CHIP_RS740_796F */
+};
+
+const int r600_chip_ids[] = {
+ 0x9400, /* PCI_CHIP_R600_9400 */
+ 0x9401, /* PCI_CHIP_R600_9401 */
+ 0x9402, /* PCI_CHIP_R600_9402 */
+ 0x9403, /* PCI_CHIP_R600_9403 */
+ 0x9405, /* PCI_CHIP_R600_9405 */
+ 0x940A, /* PCI_CHIP_R600_940A */
+ 0x940B, /* PCI_CHIP_R600_940B */
+ 0x940F, /* PCI_CHIP_R600_940F */
+ 0x94C0, /* PCI_CHIP_RV610_94C0 */
+ 0x94C1, /* PCI_CHIP_RV610_94C1 */
+ 0x94C3, /* PCI_CHIP_RV610_94C3 */
+ 0x94C4, /* PCI_CHIP_RV610_94C4 */
+ 0x94C5, /* PCI_CHIP_RV610_94C5 */
+ 0x94C6, /* PCI_CHIP_RV610_94C6 */
+ 0x94C7, /* PCI_CHIP_RV610_94C7 */
+ 0x94C8, /* PCI_CHIP_RV610_94C8 */
+ 0x94C9, /* PCI_CHIP_RV610_94C9 */
+ 0x94CB, /* PCI_CHIP_RV610_94CB */
+ 0x94CC, /* PCI_CHIP_RV610_94CC */
+ 0x94CD, /* PCI_CHIP_RV610_94CD */
+ 0x9580, /* PCI_CHIP_RV630_9580 */
+ 0x9581, /* PCI_CHIP_RV630_9581 */
+ 0x9583, /* PCI_CHIP_RV630_9583 */
+ 0x9586, /* PCI_CHIP_RV630_9586 */
+ 0x9587, /* PCI_CHIP_RV630_9587 */
+ 0x9588, /* PCI_CHIP_RV630_9588 */
+ 0x9589, /* PCI_CHIP_RV630_9589 */
+ 0x958A, /* PCI_CHIP_RV630_958A */
+ 0x958B, /* PCI_CHIP_RV630_958B */
+ 0x958C, /* PCI_CHIP_RV630_958C */
+ 0x958D, /* PCI_CHIP_RV630_958D */
+ 0x958E, /* PCI_CHIP_RV630_958E */
+ 0x958F, /* PCI_CHIP_RV630_958F */
+ 0x9500, /* PCI_CHIP_RV670_9500 */
+ 0x9501, /* PCI_CHIP_RV670_9501 */
+ 0x9504, /* PCI_CHIP_RV670_9504 */
+ 0x9505, /* PCI_CHIP_RV670_9505 */
+ 0x9506, /* PCI_CHIP_RV670_9506 */
+ 0x9507, /* PCI_CHIP_RV670_9507 */
+ 0x9508, /* PCI_CHIP_RV670_9508 */
+ 0x9509, /* PCI_CHIP_RV670_9509 */
+ 0x950F, /* PCI_CHIP_RV670_950F */
+ 0x9511, /* PCI_CHIP_RV670_9511 */
+ 0x9515, /* PCI_CHIP_RV670_9515 */
+ 0x9517, /* PCI_CHIP_RV670_9517 */
+ 0x9519, /* PCI_CHIP_RV670_9519 */
+ 0x95C0, /* PCI_CHIP_RV620_95C0 */
+ 0x95C2, /* PCI_CHIP_RV620_95C2 */
+ 0x95C4, /* PCI_CHIP_RV620_95C4 */
+ 0x95C5, /* PCI_CHIP_RV620_95C5 */
+ 0x95C6, /* PCI_CHIP_RV620_95C6 */
+ 0x95C7, /* PCI_CHIP_RV620_95C7 */
+ 0x95C9, /* PCI_CHIP_RV620_95C9 */
+ 0x95CC, /* PCI_CHIP_RV620_95CC */
+ 0x95CD, /* PCI_CHIP_RV620_95CD */
+ 0x95CE, /* PCI_CHIP_RV620_95CE */
+ 0x95CF, /* PCI_CHIP_RV620_95CF */
+ 0x9590, /* PCI_CHIP_RV635_9590 */
+ 0x9591, /* PCI_CHIP_RV635_9591 */
+ 0x9593, /* PCI_CHIP_RV635_9593 */
+ 0x9595, /* PCI_CHIP_RV635_9595 */
+ 0x9596, /* PCI_CHIP_RV635_9596 */
+ 0x9597, /* PCI_CHIP_RV635_9597 */
+ 0x9598, /* PCI_CHIP_RV635_9598 */
+ 0x9599, /* PCI_CHIP_RV635_9599 */
+ 0x959B, /* PCI_CHIP_RV635_959B */
+ 0x9610, /* PCI_CHIP_RS780_9610 */
+ 0x9611, /* PCI_CHIP_RS780_9611 */
+ 0x9612, /* PCI_CHIP_RS780_9612 */
+ 0x9613, /* PCI_CHIP_RS780_9613 */
+ 0x9614, /* PCI_CHIP_RS780_9614 */
+ 0x9615, /* PCI_CHIP_RS780_9615 */
+ 0x9616, /* PCI_CHIP_RS780_9616 */
+ 0x9710, /* PCI_CHIP_RS880_9710 */
+ 0x9711, /* PCI_CHIP_RS880_9711 */
+ 0x9712, /* PCI_CHIP_RS880_9712 */
+ 0x9713, /* PCI_CHIP_RS880_9713 */
+ 0x9714, /* PCI_CHIP_RS880_9714 */
+ 0x9715, /* PCI_CHIP_RS880_9715 */
+ 0x9440, /* PCI_CHIP_RV770_9440 */
+ 0x9441, /* PCI_CHIP_RV770_9441 */
+ 0x9442, /* PCI_CHIP_RV770_9442 */
+ 0x9443, /* PCI_CHIP_RV770_9443 */
+ 0x9444, /* PCI_CHIP_RV770_9444 */
+ 0x9446, /* PCI_CHIP_RV770_9446 */
+ 0x944A, /* PCI_CHIP_RV770_944A */
+ 0x944B, /* PCI_CHIP_RV770_944B */
+ 0x944C, /* PCI_CHIP_RV770_944C */
+ 0x944E, /* PCI_CHIP_RV770_944E */
+ 0x9450, /* PCI_CHIP_RV770_9450 */
+ 0x9452, /* PCI_CHIP_RV770_9452 */
+ 0x9456, /* PCI_CHIP_RV770_9456 */
+ 0x945A, /* PCI_CHIP_RV770_945A */
+ 0x945B, /* PCI_CHIP_RV770_945B */
+ 0x945E, /* PCI_CHIP_RV770_945E */
+ 0x9460, /* PCI_CHIP_RV790_9460 */
+ 0x9462, /* PCI_CHIP_RV790_9462 */
+ 0x946A, /* PCI_CHIP_RV770_946A */
+ 0x946B, /* PCI_CHIP_RV770_946B */
+ 0x947A, /* PCI_CHIP_RV770_947A */
+ 0x947B, /* PCI_CHIP_RV770_947B */
+ 0x9480, /* PCI_CHIP_RV730_9480 */
+ 0x9487, /* PCI_CHIP_RV730_9487 */
+ 0x9488, /* PCI_CHIP_RV730_9488 */
+ 0x9489, /* PCI_CHIP_RV730_9489 */
+ 0x948A, /* PCI_CHIP_RV730_948A */
+ 0x948F, /* PCI_CHIP_RV730_948F */
+ 0x9490, /* PCI_CHIP_RV730_9490 */
+ 0x9491, /* PCI_CHIP_RV730_9491 */
+ 0x9495, /* PCI_CHIP_RV730_9495 */
+ 0x9498, /* PCI_CHIP_RV730_9498 */
+ 0x949C, /* PCI_CHIP_RV730_949C */
+ 0x949E, /* PCI_CHIP_RV730_949E */
+ 0x949F, /* PCI_CHIP_RV730_949F */
+ 0x9540, /* PCI_CHIP_RV710_9540 */
+ 0x9541, /* PCI_CHIP_RV710_9541 */
+ 0x9542, /* PCI_CHIP_RV710_9542 */
+ 0x954E, /* PCI_CHIP_RV710_954E */
+ 0x954F, /* PCI_CHIP_RV710_954F */
+ 0x9552, /* PCI_CHIP_RV710_9552 */
+ 0x9553, /* PCI_CHIP_RV710_9553 */
+ 0x9555, /* PCI_CHIP_RV710_9555 */
+ 0x9557, /* PCI_CHIP_RV710_9557 */
+ 0x955F, /* PCI_CHIP_RV710_955F */
+ 0x94A0, /* PCI_CHIP_RV740_94A0 */
+ 0x94A1, /* PCI_CHIP_RV740_94A1 */
+ 0x94A3, /* PCI_CHIP_RV740_94A3 */
+ 0x94B1, /* PCI_CHIP_RV740_94B1 */
+ 0x94B3, /* PCI_CHIP_RV740_94B3 */
+ 0x94B4, /* PCI_CHIP_RV740_94B4 */
+ 0x94B5, /* PCI_CHIP_RV740_94B5 */
+ 0x94B9, /* PCI_CHIP_RV740_94B9 */
+ 0x68E0, /* PCI_CHIP_CEDAR_68E0 */
+ 0x68E1, /* PCI_CHIP_CEDAR_68E1 */
+ 0x68E4, /* PCI_CHIP_CEDAR_68E4 */
+ 0x68E5, /* PCI_CHIP_CEDAR_68E5 */
+ 0x68E8, /* PCI_CHIP_CEDAR_68E8 */
+ 0x68E9, /* PCI_CHIP_CEDAR_68E9 */
+ 0x68F1, /* PCI_CHIP_CEDAR_68F1 */
+ 0x68F8, /* PCI_CHIP_CEDAR_68F8 */
+ 0x68F9, /* PCI_CHIP_CEDAR_68F9 */
+ 0x68FE, /* PCI_CHIP_CEDAR_68FE */
+ 0x68C0, /* PCI_CHIP_REDWOOD_68C0 */
+ 0x68C1, /* PCI_CHIP_REDWOOD_68C1 */
+ 0x68C8, /* PCI_CHIP_REDWOOD_68C8 */
+ 0x68C9, /* PCI_CHIP_REDWOOD_68C9 */
+ 0x68D8, /* PCI_CHIP_REDWOOD_68D8 */
+ 0x68D9, /* PCI_CHIP_REDWOOD_68D9 */
+ 0x68DA, /* PCI_CHIP_REDWOOD_68DA */
+ 0x68DE, /* PCI_CHIP_REDWOOD_68DE */
+ 0x68A0, /* PCI_CHIP_JUNIPER_68A0 */
+ 0x68A1, /* PCI_CHIP_JUNIPER_68A1 */
+ 0x68A8, /* PCI_CHIP_JUNIPER_68A8 */
+ 0x68A9, /* PCI_CHIP_JUNIPER_68A9 */
+ 0x68B0, /* PCI_CHIP_JUNIPER_68B0 */
+ 0x68B8, /* PCI_CHIP_JUNIPER_68B8 */
+ 0x68B9, /* PCI_CHIP_JUNIPER_68B9 */
+ 0x68BE, /* PCI_CHIP_JUNIPER_68BE */
+ 0x6880, /* PCI_CHIP_CYPRESS_6880 */
+ 0x6888, /* PCI_CHIP_CYPRESS_6888 */
+ 0x6889, /* PCI_CHIP_CYPRESS_6889 */
+ 0x688A, /* PCI_CHIP_CYPRESS_688A */
+ 0x6898, /* PCI_CHIP_CYPRESS_6898 */
+ 0x6899, /* PCI_CHIP_CYPRESS_6899 */
+ 0x689E, /* PCI_CHIP_CYPRESS_689E */
+ 0x689C, /* PCI_CHIP_HEMLOCK_689C */
+ 0x689D, /* PCI_CHIP_HEMLOCK_689D */
};
const struct dri2_driver_map driver_map[] = {
{ 0x8086, "i915", i915_chip_ids, ARRAY_SIZE(i915_chip_ids) },
{ 0x8086, "i965", i965_chip_ids, ARRAY_SIZE(i965_chip_ids) },
+ { 0x1002, "radeon", r100_chip_ids, ARRAY_SIZE(r100_chip_ids) },
+ { 0x1002, "r200", r200_chip_ids, ARRAY_SIZE(r200_chip_ids) },
+ { 0x1002, "r300", r300_chip_ids, ARRAY_SIZE(r300_chip_ids) },
+ { 0x1002, "r600", r600_chip_ids, ARRAY_SIZE(r600_chip_ids) },
};
static char *
@@ -1160,7 +1599,7 @@ dri2_destroy_surface(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf)
(void) drv;
- if (_eglIsSurfaceBound(surf))
+ if (!_eglPutSurface(surf))
return EGL_TRUE;
(*dri2_dpy->core->destroyDrawable)(dri2_surf->dri_drawable);
@@ -1187,15 +1626,17 @@ dri2_make_current(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *dsurf,
struct dri2_egl_surface *dri2_dsurf = dri2_egl_surface(dsurf);
struct dri2_egl_surface *dri2_rsurf = dri2_egl_surface(rsurf);
struct dri2_egl_context *dri2_ctx = dri2_egl_context(ctx);
+ _EGLContext *old_ctx;
+ _EGLSurface *old_dsurf, *old_rsurf;
__DRIdrawable *ddraw, *rdraw;
__DRIcontext *cctx;
- /* bind the new context and return the "orphaned" one */
- if (!_eglBindContext(&ctx, &dsurf, &rsurf))
+ /* make new bindings */
+ if (!_eglBindContext(ctx, dsurf, rsurf, &old_ctx, &old_dsurf, &old_rsurf))
return EGL_FALSE;
/* flush before context switch */
- if (ctx && dri2_drv->glFlush)
+ if (old_ctx && dri2_drv->glFlush)
dri2_drv->glFlush();
ddraw = (dri2_dsurf) ? dri2_dsurf->dri_drawable : NULL;
@@ -1204,16 +1645,29 @@ dri2_make_current(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *dsurf,
if ((cctx == NULL && ddraw == NULL && rdraw == NULL) ||
dri2_dpy->core->bindContext(cctx, ddraw, rdraw)) {
- if (dsurf && !_eglIsSurfaceLinked(dsurf))
- dri2_destroy_surface(drv, disp, dsurf);
- if (rsurf && rsurf != dsurf && !_eglIsSurfaceLinked(dsurf))
- dri2_destroy_surface(drv, disp, rsurf);
- if (ctx != NULL && !_eglIsContextLinked(ctx))
- dri2_dpy->core->unbindContext(dri2_egl_context(ctx)->dri_context);
+ dri2_destroy_surface(drv, disp, old_dsurf);
+ dri2_destroy_surface(drv, disp, old_rsurf);
+ if (old_ctx) {
+ dri2_dpy->core->unbindContext(dri2_egl_context(old_ctx)->dri_context);
+ /* no destroy? */
+ _eglPutContext(old_ctx);
+ }
return EGL_TRUE;
} else {
- _eglBindContext(&ctx, &dsurf, &rsurf);
+ /* undo the previous _eglBindContext */
+ _eglBindContext(old_ctx, old_dsurf, old_rsurf, &ctx, &dsurf, &rsurf);
+ assert(&dri2_ctx->base == ctx &&
+ &dri2_dsurf->base == dsurf &&
+ &dri2_rsurf->base == rsurf);
+
+ _eglPutSurface(dsurf);
+ _eglPutSurface(rsurf);
+ _eglPutContext(ctx);
+
+ _eglPutSurface(old_dsurf);
+ _eglPutSurface(old_rsurf);
+ _eglPutContext(old_ctx);
return EGL_FALSE;
}
diff --git a/src/egl/drivers/glx/egl_glx.c b/src/egl/drivers/glx/egl_glx.c
index 9bebc61de9..8ec7c48c50 100644
--- a/src/egl/drivers/glx/egl_glx.c
+++ b/src/egl/drivers/glx/egl_glx.c
@@ -452,7 +452,7 @@ create_configs(_EGLDisplay *dpy, struct GLX_egl_display *GLX_dpy,
memcpy(GLX_conf, &template, sizeof(template));
GLX_conf->index = i;
- _eglAddConfig(dpy, &GLX_conf->Base);
+ _eglLinkConfig(&GLX_conf->Base);
id++;
}
}
@@ -677,14 +677,16 @@ GLX_eglMakeCurrent(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *dsurf,
struct GLX_egl_surface *GLX_dsurf = GLX_egl_surface(dsurf);
struct GLX_egl_surface *GLX_rsurf = GLX_egl_surface(rsurf);
struct GLX_egl_context *GLX_ctx = GLX_egl_context(ctx);
+ _EGLContext *old_ctx;
+ _EGLSurface *old_dsurf, *old_rsurf;
GLXDrawable ddraw, rdraw;
GLXContext cctx;
EGLBoolean ret = EGL_FALSE;
(void) drv;
- /* bind the new context and return the "orphaned" one */
- if (!_eglBindContext(&ctx, &dsurf, &rsurf))
+ /* make new bindings */
+ if (!_eglBindContext(ctx, dsurf, rsurf, &old_ctx, &old_dsurf, &old_rsurf))
return EGL_FALSE;
ddraw = (GLX_dsurf) ? GLX_dsurf->glx_drawable : None;
@@ -697,13 +699,27 @@ GLX_eglMakeCurrent(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *dsurf,
ret = glXMakeCurrent(GLX_dpy->dpy, ddraw, cctx);
if (ret) {
- if (dsurf && !_eglIsSurfaceLinked(dsurf))
- destroy_surface(disp, dsurf);
- if (rsurf && rsurf != dsurf && !_eglIsSurfaceLinked(rsurf))
- destroy_surface(disp, rsurf);
+ if (_eglPutSurface(old_dsurf))
+ destroy_surface(disp, old_dsurf);
+ if (_eglPutSurface(old_rsurf))
+ destroy_surface(disp, old_rsurf);
+ /* no destroy? */
+ _eglPutContext(old_ctx);
}
else {
- _eglBindContext(&ctx, &dsurf, &rsurf);
+ /* undo the previous _eglBindContext */
+ _eglBindContext(old_ctx, old_dsurf, old_rsurf, &ctx, &dsurf, &rsurf);
+ assert(&GLX_ctx->Base == ctx &&
+ &GLX_dsurf->Base == dsurf &&
+ &GLX_rsurf->Base == rsurf);
+
+ _eglPutSurface(dsurf);
+ _eglPutSurface(rsurf);
+ _eglPutContext(ctx);
+
+ _eglPutSurface(old_dsurf);
+ _eglPutSurface(old_rsurf);
+ _eglPutContext(old_ctx);
}
return ret;
@@ -907,7 +923,7 @@ GLX_eglDestroySurface(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf)
{
(void) drv;
- if (!_eglIsSurfaceBound(surf))
+ if (_eglPutSurface(surf))
destroy_surface(disp, surf);
return EGL_TRUE;
diff --git a/src/egl/main/SConscript b/src/egl/main/SConscript
index 8ade85b357..f001b81600 100644
--- a/src/egl/main/SConscript
+++ b/src/egl/main/SConscript
@@ -4,49 +4,49 @@
Import('*')
-if env['platform'] != 'winddk':
-
- env = env.Clone()
-
- env.Append(CPPDEFINES = [
- '_EGL_NATIVE_PLATFORM=_EGL_PLATFORM_WINDOWS',
- '_EGL_DRIVER_SEARCH_DIR=\\"\\"',
- '_EGL_OS_WINDOWS',
- '_EGL_GET_CORE_ADDRESSES',
- 'KHRONOS_DLL_EXPORTS',
- ])
-
- env.Append(CPPPATH = [
- '#/include',
- ])
-
- egl_sources = [
- 'eglapi.c',
- 'eglarray.c',
- 'eglconfig.c',
- 'eglcontext.c',
- 'eglcurrent.c',
- 'egldisplay.c',
- 'egldriver.c',
- 'eglfallbacks.c',
- 'eglglobals.c',
- 'eglimage.c',
- 'egllog.c',
- 'eglmisc.c',
- 'eglmode.c',
- 'eglscreen.c',
- 'eglstring.c',
- 'eglsurface.c',
- 'eglsync.c',
- ]
-
- egl = env.SharedLibrary(
- target = 'libEGL',
- source = egl_sources + ['egl.def'],
- )
-
- env.InstallSharedLibrary(egl, version=(1, 4, 0))
-
- egl = [env.FindIxes(egl, 'LIBPREFIX', 'LIBSUFFIX')]
-
- Export('egl')
+env = env.Clone()
+
+env.Append(CPPDEFINES = [
+ '_EGL_NATIVE_PLATFORM=_EGL_PLATFORM_WINDOWS',
+ '_EGL_DRIVER_SEARCH_DIR=\\"\\"',
+ '_EGL_OS_WINDOWS',
+ '_EGL_GET_CORE_ADDRESSES',
+ 'KHRONOS_DLL_EXPORTS',
+])
+
+env.Append(CPPPATH = [
+ '#/include',
+])
+
+egl_sources = [
+ 'eglapi.c',
+ 'eglarray.c',
+ 'eglconfig.c',
+ 'eglcontext.c',
+ 'eglcurrent.c',
+ 'egldisplay.c',
+ 'egldriver.c',
+ 'eglfallbacks.c',
+ 'eglglobals.c',
+ 'eglimage.c',
+ 'egllog.c',
+ 'eglmisc.c',
+ 'eglmode.c',
+ 'eglscreen.c',
+ 'eglstring.c',
+ 'eglsurface.c',
+ 'eglsync.c',
+]
+
+egl = env.SharedLibrary(
+ target = 'libEGL',
+ source = egl_sources + ['egl.def'],
+)
+
+installed_egl = env.InstallSharedLibrary(egl, version=(1, 4, 0))
+
+env.Alias('egl', installed_egl)
+
+egl = [env.FindIxes(egl, 'LIBPREFIX', 'LIBSUFFIX')]
+
+Export('egl')
diff --git a/src/egl/main/eglapi.c b/src/egl/main/eglapi.c
index e8f856f6be..efa9e97346 100644
--- a/src/egl/main/eglapi.c
+++ b/src/egl/main/eglapi.c
@@ -416,7 +416,7 @@ eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_list,
RETURN_EGL_ERROR(disp, EGL_BAD_CONTEXT, EGL_NO_CONTEXT);
context = drv->API.CreateContext(drv, disp, conf, share, attrib_list);
- ret = (context) ? _eglLinkContext(context, disp) : EGL_NO_CONTEXT;
+ ret = (context) ? _eglLinkContext(context) : EGL_NO_CONTEXT;
RETURN_EGL_EVAL(disp, ret);
}
@@ -515,7 +515,7 @@ eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config,
RETURN_EGL_ERROR(disp, EGL_BAD_NATIVE_WINDOW, EGL_NO_SURFACE);
surf = drv->API.CreateWindowSurface(drv, disp, conf, window, attrib_list);
- ret = (surf) ? _eglLinkSurface(surf, disp) : EGL_NO_SURFACE;
+ ret = (surf) ? _eglLinkSurface(surf) : EGL_NO_SURFACE;
RETURN_EGL_EVAL(disp, ret);
}
@@ -536,7 +536,7 @@ eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config,
RETURN_EGL_ERROR(disp, EGL_BAD_NATIVE_PIXMAP, EGL_NO_SURFACE);
surf = drv->API.CreatePixmapSurface(drv, disp, conf, pixmap, attrib_list);
- ret = (surf) ? _eglLinkSurface(surf, disp) : EGL_NO_SURFACE;
+ ret = (surf) ? _eglLinkSurface(surf) : EGL_NO_SURFACE;
RETURN_EGL_EVAL(disp, ret);
}
@@ -555,7 +555,7 @@ eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config,
_EGL_CHECK_CONFIG(disp, conf, EGL_NO_SURFACE, drv);
surf = drv->API.CreatePbufferSurface(drv, disp, conf, attrib_list);
- ret = (surf) ? _eglLinkSurface(surf, disp) : EGL_NO_SURFACE;
+ ret = (surf) ? _eglLinkSurface(surf) : EGL_NO_SURFACE;
RETURN_EGL_EVAL(disp, ret);
}
@@ -648,11 +648,12 @@ eglSwapInterval(EGLDisplay dpy, EGLint interval)
_EGL_CHECK_DISPLAY(disp, EGL_FALSE, drv);
- if (!ctx || !_eglIsContextLinked(ctx) || ctx->Resource.Display != disp)
+ if (_eglGetContextHandle(ctx) == EGL_NO_CONTEXT ||
+ ctx->Resource.Display != disp)
RETURN_EGL_ERROR(disp, EGL_BAD_CONTEXT, EGL_FALSE);
surf = ctx->DrawSurface;
- if (!_eglIsSurfaceLinked(surf))
+ if (_eglGetSurfaceHandle(surf) == EGL_NO_SURFACE)
RETURN_EGL_ERROR(disp, EGL_BAD_SURFACE, EGL_FALSE);
ret = drv->API.SwapInterval(drv, disp, surf, interval);
@@ -673,7 +674,8 @@ eglSwapBuffers(EGLDisplay dpy, EGLSurface surface)
_EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv);
/* surface must be bound to current context in EGL 1.4 */
- if (!ctx || !_eglIsContextLinked(ctx) || surf != ctx->DrawSurface)
+ if (_eglGetContextHandle(ctx) == EGL_NO_CONTEXT ||
+ surf != ctx->DrawSurface)
RETURN_EGL_ERROR(disp, EGL_BAD_SURFACE, EGL_FALSE);
ret = drv->API.SwapBuffers(drv, disp, surf);
@@ -714,7 +716,8 @@ eglWaitClient(void)
_eglLockMutex(&disp->Mutex);
/* let bad current context imply bad current surface */
- if (!_eglIsContextLinked(ctx) || !_eglIsSurfaceLinked(ctx->DrawSurface))
+ if (_eglGetContextHandle(ctx) == EGL_NO_CONTEXT ||
+ _eglGetSurfaceHandle(ctx->DrawSurface) == EGL_NO_SURFACE)
RETURN_EGL_ERROR(disp, EGL_BAD_CURRENT_SURFACE, EGL_FALSE);
/* a valid current context implies an initialized current display */
@@ -763,7 +766,8 @@ eglWaitNative(EGLint engine)
_eglLockMutex(&disp->Mutex);
/* let bad current context imply bad current surface */
- if (!_eglIsContextLinked(ctx) || !_eglIsSurfaceLinked(ctx->DrawSurface))
+ if (_eglGetContextHandle(ctx) == EGL_NO_CONTEXT ||
+ _eglGetSurfaceHandle(ctx->DrawSurface) == EGL_NO_SURFACE)
RETURN_EGL_ERROR(disp, EGL_BAD_CURRENT_SURFACE, EGL_FALSE);
/* a valid current context implies an initialized current display */
@@ -1043,7 +1047,7 @@ eglCreateScreenSurfaceMESA(EGLDisplay dpy, EGLConfig config,
_EGL_CHECK_CONFIG(disp, conf, EGL_NO_SURFACE, drv);
surf = drv->API.CreateScreenSurfaceMESA(drv, disp, conf, attrib_list);
- ret = (surf) ? _eglLinkSurface(surf, disp) : EGL_NO_SURFACE;
+ ret = (surf) ? _eglLinkSurface(surf) : EGL_NO_SURFACE;
RETURN_EGL_EVAL(disp, ret);
}
@@ -1235,7 +1239,7 @@ eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype,
surf = drv->API.CreatePbufferFromClientBuffer(drv, disp, buftype, buffer,
conf, attrib_list);
- ret = (surf) ? _eglLinkSurface(surf, disp) : EGL_NO_SURFACE;
+ ret = (surf) ? _eglLinkSurface(surf) : EGL_NO_SURFACE;
RETURN_EGL_EVAL(disp, ret);
}
@@ -1298,7 +1302,7 @@ eglCreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target,
img = drv->API.CreateImageKHR(drv,
disp, context, target, buffer, attr_list);
- ret = (img) ? _eglLinkImage(img, disp) : EGL_NO_IMAGE_KHR;
+ ret = (img) ? _eglLinkImage(img) : EGL_NO_IMAGE_KHR;
RETURN_EGL_EVAL(disp, ret);
}
@@ -1344,7 +1348,7 @@ eglCreateSyncKHR(EGLDisplay dpy, EGLenum type, const EGLint *attrib_list)
RETURN_EGL_EVAL(disp, EGL_NO_SYNC_KHR);
sync = drv->API.CreateSyncKHR(drv, disp, type, attrib_list);
- ret = (sync) ? _eglLinkSync(sync, disp) : EGL_NO_SYNC_KHR;
+ ret = (sync) ? _eglLinkSync(sync) : EGL_NO_SYNC_KHR;
RETURN_EGL_EVAL(disp, ret);
}
@@ -1437,7 +1441,8 @@ eglSwapBuffersRegionNOK(EGLDisplay dpy, EGLSurface surface,
RETURN_EGL_EVAL(disp, EGL_FALSE);
/* surface must be bound to current context in EGL 1.4 */
- if (!ctx || !_eglIsContextLinked(ctx) || surf != ctx->DrawSurface)
+ if (_eglGetContextHandle(ctx) == EGL_NO_CONTEXT ||
+ surf != ctx->DrawSurface)
RETURN_EGL_ERROR(disp, EGL_BAD_SURFACE, EGL_FALSE);
ret = drv->API.SwapBuffersRegionNOK(drv, disp, surf, numRects, rects);
@@ -1463,7 +1468,7 @@ eglCreateDRMImageMESA(EGLDisplay dpy, const EGLint *attr_list)
RETURN_EGL_EVAL(disp, EGL_NO_IMAGE_KHR);
img = drv->API.CreateDRMImageMESA(drv, disp, attr_list);
- ret = (img) ? _eglLinkImage(img, disp) : EGL_NO_IMAGE_KHR;
+ ret = (img) ? _eglLinkImage(img) : EGL_NO_IMAGE_KHR;
RETURN_EGL_EVAL(disp, ret);
}
diff --git a/src/egl/main/eglarray.h b/src/egl/main/eglarray.h
index fe92efc11e..c8309fb066 100644
--- a/src/egl/main/eglarray.h
+++ b/src/egl/main/eglarray.h
@@ -37,7 +37,7 @@ void *
_eglFindArray(_EGLArray *array, void *elem);
-void **
+PUBLIC void **
_eglFilterArray(_EGLArray *array, EGLint *size,
_EGLArrayForEach filter, void *filter_data);
diff --git a/src/egl/main/eglconfig.c b/src/egl/main/eglconfig.c
index 4d313a9bb5..fec94fb20c 100644
--- a/src/egl/main/eglconfig.c
+++ b/src/egl/main/eglconfig.c
@@ -40,16 +40,18 @@ _eglInitConfig(_EGLConfig *conf, _EGLDisplay *dpy, EGLint id)
/**
- * Link a config to a display and return the handle of the link.
+ * Link a config to its display and return the handle of the link.
* The handle can be passed to client directly.
*
* Note that we just save the ptr to the config (we don't copy the config).
*/
-EGLConfig
-_eglAddConfig(_EGLDisplay *dpy, _EGLConfig *conf)
+PUBLIC EGLConfig
+_eglLinkConfig(_EGLConfig *conf)
{
+ _EGLDisplay *dpy = conf->Display;
+
/* sanity check */
- assert(conf->ConfigID > 0);
+ assert(dpy && conf->ConfigID > 0);
if (!dpy->Configs) {
dpy->Configs = _eglCreateArray("Config", 16);
@@ -57,23 +59,29 @@ _eglAddConfig(_EGLDisplay *dpy, _EGLConfig *conf)
return (EGLConfig) NULL;
}
- conf->Display = dpy;
_eglAppendArray(dpy->Configs, (void *) conf);
return (EGLConfig) conf;
}
-EGLBoolean
-_eglCheckConfigHandle(EGLConfig config, _EGLDisplay *dpy)
+/**
+ * Lookup a handle to find the linked config.
+ * Return NULL if the handle has no corresponding linked config.
+ */
+_EGLConfig *
+_eglLookupConfig(EGLConfig config, _EGLDisplay *dpy)
{
_EGLConfig *conf;
+ if (!dpy)
+ return NULL;
+
conf = (_EGLConfig *) _eglFindArray(dpy->Configs, (void *) config);
if (conf)
assert(conf->Display == dpy);
- return (conf != NULL);
+ return conf;
}
@@ -464,10 +472,13 @@ _eglIsConfigAttribValid(_EGLConfig *conf, EGLint attr)
* Return EGL_FALSE if any of the attribute is invalid.
*/
EGLBoolean
-_eglParseConfigAttribList(_EGLConfig *conf, const EGLint *attrib_list)
+_eglParseConfigAttribList(_EGLConfig *conf, _EGLDisplay *dpy,
+ const EGLint *attrib_list)
{
EGLint attr, val, i;
+ _eglInitConfig(conf, dpy, EGL_DONT_CARE);
+
/* reset to default values */
for (i = 0; i < ARRAY_SIZE(_eglValidationTable); i++) {
attr = _eglValidationTable[i].attr;
@@ -494,7 +505,7 @@ _eglParseConfigAttribList(_EGLConfig *conf, const EGLint *attrib_list)
return EGL_FALSE;
/* ignore other attributes when EGL_CONFIG_ID is given */
- if (conf->ConfigID > 0) {
+ if (conf->ConfigID != EGL_DONT_CARE) {
for (i = 0; i < ARRAY_SIZE(_eglValidationTable); i++) {
attr = _eglValidationTable[i].attr;
if (attr != EGL_CONFIG_ID)
@@ -683,8 +694,7 @@ _eglChooseConfig(_EGLDriver *drv, _EGLDisplay *disp, const EGLint *attrib_list,
if (!num_configs)
return _eglError(EGL_BAD_PARAMETER, "eglChooseConfigs");
- _eglInitConfig(&criteria, disp, 0);
- if (!_eglParseConfigAttribList(&criteria, attrib_list))
+ if (!_eglParseConfigAttribList(&criteria, disp, attrib_list))
return _eglError(EGL_BAD_ATTRIBUTE, "eglChooseConfig");
configList = (_EGLConfig **) _eglFilterArray(disp->Configs, &count,
diff --git a/src/egl/main/eglconfig.h b/src/egl/main/eglconfig.h
index 892815fa63..2169960fd1 100644
--- a/src/egl/main/eglconfig.h
+++ b/src/egl/main/eglconfig.h
@@ -3,6 +3,7 @@
#include <assert.h>
+#include <stddef.h>
#include "egltypedefs.h"
@@ -136,34 +137,20 @@ _eglInitConfig(_EGLConfig *config, _EGLDisplay *dpy, EGLint id);
PUBLIC EGLConfig
-_eglAddConfig(_EGLDisplay *dpy, _EGLConfig *conf);
+_eglLinkConfig(_EGLConfig *conf);
-extern EGLBoolean
-_eglCheckConfigHandle(EGLConfig config, _EGLDisplay *dpy);
-
-
-/**
- * Lookup a handle to find the linked config.
- * Return NULL if the handle has no corresponding linked config.
- */
-static INLINE _EGLConfig *
-_eglLookupConfig(EGLConfig config, _EGLDisplay *dpy)
-{
- _EGLConfig *conf = (_EGLConfig *) config;
- if (!dpy || !_eglCheckConfigHandle(config, dpy))
- conf = NULL;
- return conf;
-}
+extern _EGLConfig *
+_eglLookupConfig(EGLConfig config, _EGLDisplay *dpy);
/**
- * Return the handle of a linked config, or NULL.
+ * Return the handle of a linked config.
*/
static INLINE EGLConfig
_eglGetConfigHandle(_EGLConfig *conf)
{
- return (EGLConfig) ((conf && conf->Display) ? conf : NULL);
+ return (EGLConfig) conf;
}
@@ -176,7 +163,8 @@ _eglMatchConfig(const _EGLConfig *conf, const _EGLConfig *criteria);
PUBLIC EGLBoolean
-_eglParseConfigAttribList(_EGLConfig *conf, const EGLint *attrib_list);
+_eglParseConfigAttribList(_EGLConfig *conf, _EGLDisplay *dpy,
+ const EGLint *attrib_list);
PUBLIC EGLint
diff --git a/src/egl/main/eglcontext.c b/src/egl/main/eglcontext.c
index 113e4e48fb..33dcfa6875 100644
--- a/src/egl/main/eglcontext.c
+++ b/src/egl/main/eglcontext.c
@@ -103,8 +103,7 @@ _eglInitContext(_EGLContext *ctx, _EGLDisplay *dpy, _EGLConfig *conf,
return EGL_FALSE;
}
- memset(ctx, 0, sizeof(_EGLContext));
- ctx->Resource.Display = dpy;
+ _eglInitResource(&ctx->Resource, sizeof(*ctx), dpy);
ctx->ClientAPI = api;
ctx->Config = conf;
ctx->WindowRenderBuffer = EGL_NONE;
@@ -250,10 +249,6 @@ _eglCheckMakeCurrent(_EGLContext *ctx, _EGLSurface *draw, _EGLSurface *read)
if (!surfaceless && (draw == NULL || read == NULL))
return _eglError(EGL_BAD_MATCH, "eglMakeCurrent");
- /* context stealing from another thread is not allowed */
- if (ctx->Binding && ctx->Binding != t)
- return _eglError(EGL_BAD_ACCESS, "eglMakeCurrent");
-
/*
* The spec says
*
@@ -261,16 +256,23 @@ _eglCheckMakeCurrent(_EGLContext *ctx, _EGLSurface *draw, _EGLSurface *read)
* bound to contexts in another thread, an EGL_BAD_ACCESS error is
* generated."
*
- * But it also says
+ * and
*
* "at most one context may be bound to a particular surface at a given
* time"
- *
- * The latter is more restrictive so we can check only the latter case.
*/
- if ((draw && draw->CurrentContext && draw->CurrentContext != ctx) ||
- (read && read->CurrentContext && read->CurrentContext != ctx))
+ if (ctx->Binding && ctx->Binding != t)
return _eglError(EGL_BAD_ACCESS, "eglMakeCurrent");
+ if (draw && draw->CurrentContext && draw->CurrentContext != ctx) {
+ if (draw->CurrentContext->Binding != t ||
+ draw->CurrentContext->ClientAPI != ctx->ClientAPI)
+ return _eglError(EGL_BAD_ACCESS, "eglMakeCurrent");
+ }
+ if (read && read->CurrentContext && read->CurrentContext != ctx) {
+ if (read->CurrentContext->Binding != t ||
+ read->CurrentContext->ClientAPI != ctx->ClientAPI)
+ return _eglError(EGL_BAD_ACCESS, "eglMakeCurrent");
+ }
/* simply require the configs to be equal */
if ((draw && draw->Config != ctx->Config) ||
@@ -301,54 +303,65 @@ _eglCheckMakeCurrent(_EGLContext *ctx, _EGLSurface *draw, _EGLSurface *read)
/**
* Bind the context to the current thread and given surfaces. Return the
- * "orphaned" context and surfaces. Each argument is both input and output.
+ * previous bound context and surfaces. The caller should unreference the
+ * returned context and surfaces.
+ *
+ * Making a second call with the resources returned by the first call
+ * unsurprisingly undoes the first call, except for the resouce reference
+ * counts.
*/
EGLBoolean
-_eglBindContext(_EGLContext **ctx, _EGLSurface **draw, _EGLSurface **read)
+_eglBindContext(_EGLContext *ctx, _EGLSurface *draw, _EGLSurface *read,
+ _EGLContext **old_ctx,
+ _EGLSurface **old_draw, _EGLSurface **old_read)
{
_EGLThreadInfo *t = _eglGetCurrentThread();
- _EGLContext *newCtx = *ctx, *oldCtx;
- _EGLSurface *newDraw = *draw, *newRead = *read;
+ _EGLContext *prev_ctx;
+ _EGLSurface *prev_draw, *prev_read;
- if (!_eglCheckMakeCurrent(newCtx, newDraw, newRead))
+ if (!_eglCheckMakeCurrent(ctx, draw, read))
return EGL_FALSE;
+ /* increment refcounts before binding */
+ _eglGetContext(ctx);
+ _eglGetSurface(draw);
+ _eglGetSurface(read);
+
/* bind the new context */
- oldCtx = _eglBindContextToThread(newCtx, t);
+ prev_ctx = _eglBindContextToThread(ctx, t);
- /* break old bindings */
- if (oldCtx) {
- *ctx = oldCtx;
- *draw = oldCtx->DrawSurface;
- *read = oldCtx->ReadSurface;
+ /* break previous bindings */
+ if (prev_ctx) {
+ prev_draw = prev_ctx->DrawSurface;
+ prev_read = prev_ctx->ReadSurface;
- if (*draw)
- (*draw)->CurrentContext = NULL;
- if (*read)
- (*read)->CurrentContext = NULL;
+ if (prev_draw)
+ prev_draw->CurrentContext = NULL;
+ if (prev_read)
+ prev_read->CurrentContext = NULL;
- oldCtx->DrawSurface = NULL;
- oldCtx->ReadSurface = NULL;
+ prev_ctx->DrawSurface = NULL;
+ prev_ctx->ReadSurface = NULL;
+ }
+ else {
+ prev_draw = prev_read = NULL;
}
/* establish new bindings */
- if (newCtx) {
- if (newDraw)
- newDraw->CurrentContext = newCtx;
- if (newRead)
- newRead->CurrentContext = newCtx;
-
- newCtx->DrawSurface = newDraw;
- newCtx->ReadSurface = newRead;
+ if (ctx) {
+ if (draw)
+ draw->CurrentContext = ctx;
+ if (read)
+ read->CurrentContext = ctx;
+
+ ctx->DrawSurface = draw;
+ ctx->ReadSurface = read;
}
- /* an old context or surface is not orphaned if it is still bound */
- if (*ctx == newCtx)
- *ctx = NULL;
- if (*draw == newDraw || *draw == newRead)
- *draw = NULL;
- if (*read == newDraw || *read == newRead)
- *read = NULL;
+ assert(old_ctx && old_draw && old_read);
+ *old_ctx = prev_ctx;
+ *old_draw = prev_draw;
+ *old_read = prev_read;
return EGL_TRUE;
}
diff --git a/src/egl/main/eglcontext.h b/src/egl/main/eglcontext.h
index 148f160cae..8cd0df1731 100644
--- a/src/egl/main/eglcontext.h
+++ b/src/egl/main/eglcontext.h
@@ -39,30 +39,41 @@ _eglQueryContext(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *ctx, EGLint att
PUBLIC EGLBoolean
-_eglBindContext(_EGLContext **ctx, _EGLSurface **draw, _EGLSurface **read);
+_eglBindContext(_EGLContext *ctx, _EGLSurface *draw, _EGLSurface *read,
+ _EGLContext **old_ctx,
+ _EGLSurface **old_draw, _EGLSurface **old_read);
/**
- * Return true if the context is bound to a thread.
- *
- * The binding is considered a reference to the context. Drivers should not
- * destroy a context when it is bound.
+ * Increment reference count for the context.
+ */
+static INLINE _EGLContext *
+_eglGetContext(_EGLContext *ctx)
+{
+ if (ctx)
+ _eglGetResource(&ctx->Resource);
+ return ctx;
+}
+
+
+/**
+ * Decrement reference count for the context.
*/
static INLINE EGLBoolean
-_eglIsContextBound(_EGLContext *ctx)
+_eglPutContext(_EGLContext *ctx)
{
- return (ctx->Binding != NULL);
+ return (ctx) ? _eglPutResource(&ctx->Resource) : EGL_FALSE;
}
/**
- * Link a context to a display and return the handle of the link.
+ * Link a context to its display and return the handle of the link.
* The handle can be passed to client directly.
*/
static INLINE EGLContext
-_eglLinkContext(_EGLContext *ctx, _EGLDisplay *dpy)
+_eglLinkContext(_EGLContext *ctx)
{
- _eglLinkResource(&ctx->Resource, _EGL_RESOURCE_CONTEXT, dpy);
+ _eglLinkResource(&ctx->Resource, _EGL_RESOURCE_CONTEXT);
return (EGLContext) ctx;
}
@@ -104,18 +115,4 @@ _eglGetContextHandle(_EGLContext *ctx)
}
-/**
- * Return true if the context is linked to a display.
- *
- * The link is considered a reference to the context (the display is owning the
- * context). Drivers should not destroy a context when it is linked.
- */
-static INLINE EGLBoolean
-_eglIsContextLinked(_EGLContext *ctx)
-{
- _EGLResource *res = (_EGLResource *) ctx;
- return (res && _eglIsResourceLinked(res));
-}
-
-
#endif /* EGLCONTEXT_INCLUDED */
diff --git a/src/egl/main/eglcurrent.c b/src/egl/main/eglcurrent.c
index c0e8c119a9..cbca9ff2c2 100644
--- a/src/egl/main/eglcurrent.c
+++ b/src/egl/main/eglcurrent.c
@@ -14,33 +14,7 @@
static _EGLThreadInfo dummy_thread = _EGL_THREAD_INFO_INITIALIZER;
-#ifdef GLX_USE_TLS
-static __thread const _EGLThreadInfo *_egl_TSD
- __attribute__ ((tls_model("initial-exec")));
-
-static INLINE void _eglSetTSD(const _EGLThreadInfo *t)
-{
- _egl_TSD = t;
-}
-
-static INLINE _EGLThreadInfo *_eglGetTSD(void)
-{
- return (_EGLThreadInfo *) _egl_TSD;
-}
-
-static INLINE void _eglFiniTSD(void)
-{
-}
-
-static INLINE EGLBoolean _eglInitTSD(void (*dtor)(_EGLThreadInfo *))
-{
- /* TODO destroy TSD */
- (void) dtor;
- (void) _eglFiniTSD;
- return EGL_TRUE;
-}
-
-#elif PTHREADS
+#if PTHREADS
#include <pthread.h>
static _EGL_DECLARE_MUTEX(_egl_TSDMutex);
@@ -48,14 +22,26 @@ static EGLBoolean _egl_TSDInitialized;
static pthread_key_t _egl_TSD;
static void (*_egl_FreeTSD)(_EGLThreadInfo *);
+#ifdef GLX_USE_TLS
+static __thread const _EGLThreadInfo *_egl_TLS
+ __attribute__ ((tls_model("initial-exec")));
+#endif
+
static INLINE void _eglSetTSD(const _EGLThreadInfo *t)
{
pthread_setspecific(_egl_TSD, (const void *) t);
+#ifdef GLX_USE_TLS
+ _egl_TLS = t;
+#endif
}
static INLINE _EGLThreadInfo *_eglGetTSD(void)
{
+#ifdef GLX_USE_TLS
+ return (_EGLThreadInfo *) _egl_TLS;
+#else
return (_EGLThreadInfo *) pthread_getspecific(_egl_TSD);
+#endif
}
static INLINE void _eglFiniTSD(void)
diff --git a/src/egl/main/egldisplay.c b/src/egl/main/egldisplay.c
index cc0f03e01b..565e44d2d2 100644
--- a/src/egl/main/egldisplay.c
+++ b/src/egl/main/egldisplay.c
@@ -233,17 +233,53 @@ _eglCheckResource(void *res, _EGLResourceType type, _EGLDisplay *dpy)
/**
- * Link a resource to a display.
+ * Initialize a display resource.
*/
void
-_eglLinkResource(_EGLResource *res, _EGLResourceType type, _EGLDisplay *dpy)
+_eglInitResource(_EGLResource *res, EGLint size, _EGLDisplay *dpy)
{
- assert(!res->Display || res->Display == dpy);
-
+ memset(res, 0, size);
res->Display = dpy;
+ res->RefCount = 1;
+}
+
+
+/**
+ * Increment reference count for the resource.
+ */
+void
+_eglGetResource(_EGLResource *res)
+{
+ assert(res && res->RefCount > 0);
+ /* hopefully a resource is always manipulated with its display locked */
+ res->RefCount++;
+}
+
+
+/**
+ * Decrement reference count for the resource.
+ */
+EGLBoolean
+_eglPutResource(_EGLResource *res)
+{
+ assert(res && res->RefCount > 0);
+ res->RefCount--;
+ return (!res->RefCount);
+}
+
+
+/**
+ * Link a resource to its display.
+ */
+void
+_eglLinkResource(_EGLResource *res, _EGLResourceType type)
+{
+ assert(res->Display);
+
res->IsLinked = EGL_TRUE;
- res->Next = dpy->ResourceLists[type];
- dpy->ResourceLists[type] = res;
+ res->Next = res->Display->ResourceLists[type];
+ res->Display->ResourceLists[type] = res;
+ _eglGetResource(res);
}
@@ -270,6 +306,9 @@ _eglUnlinkResource(_EGLResource *res, _EGLResourceType type)
}
res->Next = NULL;
- /* do not reset res->Display */
res->IsLinked = EGL_FALSE;
+ _eglPutResource(res);
+
+ /* We always unlink before destroy. The driver still owns a reference */
+ assert(res->RefCount);
}
diff --git a/src/egl/main/egldisplay.h b/src/egl/main/egldisplay.h
index 3863cce010..bcba05480a 100644
--- a/src/egl/main/egldisplay.h
+++ b/src/egl/main/egldisplay.h
@@ -40,6 +40,7 @@ struct _egl_resource
/* which display the resource belongs to */
_EGLDisplay *Display;
EGLBoolean IsLinked;
+ EGLint RefCount;
/* used to link resources of the same type */
_EGLResource *Next;
@@ -162,7 +163,19 @@ _eglGetDisplayHandle(_EGLDisplay *dpy)
extern void
-_eglLinkResource(_EGLResource *res, _EGLResourceType type, _EGLDisplay *dpy);
+_eglInitResource(_EGLResource *res, EGLint size, _EGLDisplay *dpy);
+
+
+PUBLIC void
+_eglGetResource(_EGLResource *res);
+
+
+PUBLIC EGLBoolean
+_eglPutResource(_EGLResource *res);
+
+
+extern void
+_eglLinkResource(_EGLResource *res, _EGLResourceType type);
extern void
diff --git a/src/egl/main/egldriver.c b/src/egl/main/egldriver.c
index 2359253ff1..ff0011c4b1 100644
--- a/src/egl/main/egldriver.c
+++ b/src/egl/main/egldriver.c
@@ -395,35 +395,62 @@ _eglPreloadForEach(const char *search_path,
static const char *
_eglGetSearchPath(void)
{
- static const char *search_path;
+ static char search_path[1024];
#if defined(_EGL_OS_UNIX) || defined(_EGL_OS_WINDOWS)
- if (!search_path) {
- static char buffer[1024];
- const char *p;
+ if (search_path[0] == '\0') {
+ char *buf = search_path;
+ size_t len = sizeof(search_path);
+ EGLBoolean use_env;
+ char dir_sep;
int ret;
- p = getenv("EGL_DRIVERS_PATH");
#if defined(_EGL_OS_UNIX)
- if (p && (geteuid() != getuid() || getegid() != getgid())) {
+ use_env = (geteuid() == getuid() && getegid() == getgid());
+ dir_sep = '/';
+#else
+ use_env = EGL_TRUE;
+ dir_sep = '\\';
+#endif
+
+ if (use_env) {
+ char *p;
+
+ /* extract the dirname from EGL_DRIVER */
+ p = getenv("EGL_DRIVER");
+ if (p && strchr(p, dir_sep)) {
+ ret = _eglsnprintf(buf, len, "%s", p);
+ if (ret > 0 && ret < len) {
+ p = strrchr(buf, dir_sep);
+ *p++ = ':';
+
+ len -= p - buf;
+ buf = p;
+ }
+ }
+
+ /* append EGL_DRIVERS_PATH */
+ p = getenv("EGL_DRIVERS_PATH");
+ if (p) {
+ ret = _eglsnprintf(buf, len, "%s:", p);
+ if (ret > 0 && ret < len) {
+ buf += ret;
+ len -= ret;
+ }
+ }
+ }
+ else {
_eglLog(_EGL_DEBUG,
"ignore EGL_DRIVERS_PATH for setuid/setgid binaries");
- p = NULL;
}
-#endif /* _EGL_OS_UNIX */
- if (p) {
- ret = _eglsnprintf(buffer, sizeof(buffer),
- "%s:%s", p, _EGL_DRIVER_SEARCH_DIR);
- if (ret > 0 && ret < sizeof(buffer))
- search_path = buffer;
- }
+ ret = _eglsnprintf(buf, len, "%s", _EGL_DRIVER_SEARCH_DIR);
+ if (ret < 0 || ret >= len)
+ search_path[0] = '\0';
+
+ _eglLog(_EGL_DEBUG, "EGL search path is %s", search_path);
}
- if (!search_path)
- search_path = _EGL_DRIVER_SEARCH_DIR;
-#else
- search_path = "";
-#endif
+#endif /* defined(_EGL_OS_UNIX) || defined(_EGL_OS_WINDOWS) */
return search_path;
}
diff --git a/src/egl/main/egldriver.h b/src/egl/main/egldriver.h
index 1ca7c6cd93..1a0aaad1f8 100644
--- a/src/egl/main/egldriver.h
+++ b/src/egl/main/egldriver.h
@@ -4,7 +4,7 @@
#include "egltypedefs.h"
#include "eglapi.h"
-
+#include <stddef.h>
/**
* Define an inline driver typecast function.
diff --git a/src/egl/main/eglimage.c b/src/egl/main/eglimage.c
index af4a29fb0e..6d4ee4e08b 100644
--- a/src/egl/main/eglimage.c
+++ b/src/egl/main/eglimage.c
@@ -2,7 +2,6 @@
#include <string.h>
#include "eglimage.h"
-#include "eglcurrent.h"
#include "egllog.h"
@@ -81,8 +80,7 @@ _eglParseImageAttribList(_EGLImageAttribs *attrs, _EGLDisplay *dpy,
EGLBoolean
_eglInitImage(_EGLImage *img, _EGLDisplay *dpy)
{
- memset(img, 0, sizeof(_EGLImage));
- img->Resource.Display = dpy;
+ _eglInitResource(&img->Resource, sizeof(*img), dpy);
return EGL_TRUE;
}
diff --git a/src/egl/main/eglimage.h b/src/egl/main/eglimage.h
index 7cd92c1125..adb939a9e0 100644
--- a/src/egl/main/eglimage.h
+++ b/src/egl/main/eglimage.h
@@ -43,13 +43,35 @@ _eglInitImage(_EGLImage *img, _EGLDisplay *dpy);
/**
- * Link an image to a display and return the handle of the link.
+ * Increment reference count for the image.
+ */
+static INLINE _EGLImage *
+_eglGetImage(_EGLImage *img)
+{
+ if (img)
+ _eglGetResource(&img->Resource);
+ return img;
+}
+
+
+/**
+ * Decrement reference count for the image.
+ */
+static INLINE EGLBoolean
+_eglPutImage(_EGLImage *img)
+{
+ return (img) ? _eglPutResource(&img->Resource) : EGL_FALSE;
+}
+
+
+/**
+ * Link an image to its display and return the handle of the link.
* The handle can be passed to client directly.
*/
static INLINE EGLImageKHR
-_eglLinkImage(_EGLImage *img, _EGLDisplay *dpy)
+_eglLinkImage(_EGLImage *img)
{
- _eglLinkResource(&img->Resource, _EGL_RESOURCE_IMAGE, dpy);
+ _eglLinkResource(&img->Resource, _EGL_RESOURCE_IMAGE);
return (EGLImageKHR) img;
}
@@ -91,15 +113,4 @@ _eglGetImageHandle(_EGLImage *img)
}
-/**
- * Return true if the image is linked to a display.
- */
-static INLINE EGLBoolean
-_eglIsImageLinked(_EGLImage *img)
-{
- _EGLResource *res = (_EGLResource *) img;
- return (res && _eglIsResourceLinked(res));
-}
-
-
#endif /* EGLIMAGE_INCLUDED */
diff --git a/src/egl/main/egllog.c b/src/egl/main/egllog.c
index 8f3bae2243..12c55f901a 100644
--- a/src/egl/main/egllog.c
+++ b/src/egl/main/egllog.c
@@ -151,6 +151,7 @@ _eglLog(EGLint level, const char *fmtStr, ...)
{
va_list args;
char msg[MAXSTRING];
+ int ret;
/* one-time initialization; a little race here is fine */
if (!logging.initialized)
@@ -162,7 +163,9 @@ _eglLog(EGLint level, const char *fmtStr, ...)
if (logging.logger) {
va_start(args, fmtStr);
- vsnprintf(msg, MAXSTRING, fmtStr, args);
+ ret = vsnprintf(msg, MAXSTRING, fmtStr, args);
+ if (ret < 0 || ret >= MAXSTRING)
+ strcpy(msg, "<message truncated>");
va_end(args);
logging.logger(level, msg);
diff --git a/src/egl/main/eglmode.c b/src/egl/main/eglmode.c
index ed107d5d7a..a9653496c3 100644
--- a/src/egl/main/eglmode.c
+++ b/src/egl/main/eglmode.c
@@ -3,11 +3,9 @@
#include <string.h>
#include "egldisplay.h"
-#include "egldriver.h"
#include "eglmode.h"
#include "eglcurrent.h"
#include "eglscreen.h"
-#include "eglstring.h"
#ifdef EGL_MESA_screen_surface
@@ -31,56 +29,24 @@ _eglLookupMode(EGLModeMESA mode, _EGLDisplay *disp)
/* loop over all screens on the display */
for (scrnum = 0; scrnum < disp->Screens->Size; scrnum++) {
const _EGLScreen *scrn = disp->Screens->Elements[scrnum];
- EGLint i;
- /* search list of modes for handle */
- for (i = 0; i < scrn->NumModes; i++) {
- if (scrn->Modes[i].Handle == mode) {
- return scrn->Modes + i;
- }
- }
- }
+ EGLint idx;
- return NULL;
-}
+ /*
+ * the mode ids of a screen ranges from scrn->Handle to scrn->Handle +
+ * scrn->NumModes
+ */
+ if (mode >= scrn->Handle &&
+ mode < scrn->Handle + _EGL_SCREEN_MAX_MODES) {
+ idx = mode - scrn->Handle;
+ assert(idx < scrn->NumModes && scrn->Modes[idx].Handle == mode);
-/**
- * Add a new mode with the given attributes (width, height, depth, refreshRate)
- * to the given screen.
- * Assign a new mode ID/handle to the mode as well.
- * \return pointer to the new _EGLMode
- */
-_EGLMode *
-_eglAddNewMode(_EGLScreen *screen, EGLint width, EGLint height,
- EGLint refreshRate, const char *name)
-{
- EGLint n;
- _EGLMode *newModes;
-
- assert(screen);
- assert(width > 0);
- assert(height > 0);
- assert(refreshRate > 0);
-
- n = screen->NumModes;
- newModes = (_EGLMode *) realloc(screen->Modes, (n+1) * sizeof(_EGLMode));
- if (newModes) {
- screen->Modes = newModes;
- screen->Modes[n].Handle = n + 1;
- screen->Modes[n].Width = width;
- screen->Modes[n].Height = height;
- screen->Modes[n].RefreshRate = refreshRate;
- screen->Modes[n].Optimal = EGL_FALSE;
- screen->Modes[n].Interlaced = EGL_FALSE;
- screen->Modes[n].Name = _eglstrdup(name);
- screen->NumModes++;
- return screen->Modes + n;
- }
- else {
- return NULL;
+ return &scrn->Modes[idx];
+ }
}
-}
+ return NULL;
+}
/**
diff --git a/src/egl/main/eglmode.h b/src/egl/main/eglmode.h
index 9167cbc4b9..ed4eb2c34a 100644
--- a/src/egl/main/eglmode.h
+++ b/src/egl/main/eglmode.h
@@ -32,11 +32,6 @@ extern _EGLMode *
_eglLookupMode(EGLModeMESA mode, _EGLDisplay *dpy);
-PUBLIC _EGLMode *
-_eglAddNewMode(_EGLScreen *screen, EGLint width, EGLint height,
- EGLint refreshRate, const char *name);
-
-
extern EGLBoolean
_eglChooseModeMESA(_EGLDriver *drv, _EGLDisplay *dpy, _EGLScreen *scrn,
const EGLint *attrib_list, EGLModeMESA *modes,
diff --git a/src/egl/main/eglscreen.c b/src/egl/main/eglscreen.c
index 2ae403494e..3abe85ff22 100644
--- a/src/egl/main/eglscreen.c
+++ b/src/egl/main/eglscreen.c
@@ -18,7 +18,6 @@
#include "egldisplay.h"
#include "eglcurrent.h"
#include "eglmode.h"
-#include "eglconfig.h"
#include "eglsurface.h"
#include "eglscreen.h"
#include "eglmutex.h"
@@ -42,7 +41,8 @@ _eglAllocScreenHandle(void)
EGLScreenMESA s;
_eglLockMutex(&_eglNextScreenHandleMutex);
- s = _eglNextScreenHandle++;
+ s = _eglNextScreenHandle;
+ _eglNextScreenHandle += _EGL_SCREEN_MAX_MODES;
_eglUnlockMutex(&_eglNextScreenHandleMutex);
return s;
@@ -53,60 +53,80 @@ _eglAllocScreenHandle(void)
* Initialize an _EGLScreen object to default values.
*/
void
-_eglInitScreen(_EGLScreen *screen)
+_eglInitScreen(_EGLScreen *screen, _EGLDisplay *dpy, EGLint num_modes)
{
memset(screen, 0, sizeof(_EGLScreen));
+
+ screen->Display = dpy;
+ screen->NumModes = num_modes;
screen->StepX = 1;
screen->StepY = 1;
+
+ if (num_modes > _EGL_SCREEN_MAX_MODES)
+ num_modes = _EGL_SCREEN_MAX_MODES;
+ screen->Modes = (_EGLMode *) calloc(num_modes, sizeof(*screen->Modes));
+ screen->NumModes = (screen->Modes) ? num_modes : 0;
}
/**
- * Given a public screen handle, return the internal _EGLScreen object.
+ * Link a screen to its display and return the handle of the link.
+ * The handle can be passed to client directly.
*/
-_EGLScreen *
-_eglLookupScreen(EGLScreenMESA screen, _EGLDisplay *display)
+EGLScreenMESA
+_eglLinkScreen(_EGLScreen *screen)
{
+ _EGLDisplay *display;
EGLint i;
- if (!display || !display->Screens)
- return NULL;
+ assert(screen && screen->Display);
+ display = screen->Display;
- for (i = 0; i < display->Screens->Size; i++) {
- _EGLScreen *scr = (_EGLScreen *) display->Screens->Elements[i];
- if (scr->Handle == screen)
- return scr;
+ if (!display->Screens) {
+ display->Screens = _eglCreateArray("Screen", 4);
+ if (!display->Screens)
+ return (EGLScreenMESA) 0;
}
- return NULL;
+
+ screen->Handle = _eglAllocScreenHandle();
+ for (i = 0; i < screen->NumModes; i++)
+ screen->Modes[i].Handle = screen->Handle + i;
+
+ _eglAppendArray(display->Screens, (void *) screen);
+
+ return screen->Handle;
}
/**
- * Add the given _EGLScreen to the display's list of screens.
+ * Lookup a handle to find the linked config.
+ * Return NULL if the handle has no corresponding linked config.
*/
-void
-_eglAddScreen(_EGLDisplay *display, _EGLScreen *screen)
+_EGLScreen *
+_eglLookupScreen(EGLScreenMESA screen, _EGLDisplay *display)
{
- assert(display);
- assert(screen);
+ EGLint i;
- if (!display->Screens) {
- display->Screens = _eglCreateArray("Screen", 4);
- if (!display->Screens)
- return;
+ if (!display || !display->Screens)
+ return NULL;
+
+ for (i = 0; i < display->Screens->Size; i++) {
+ _EGLScreen *scr = (_EGLScreen *) display->Screens->Elements[i];
+ if (scr->Handle == screen) {
+ assert(scr->Display == display);
+ return scr;
+ }
}
- screen->Handle = _eglAllocScreenHandle();
- _eglAppendArray(display->Screens, (void *) screen);
+ return NULL;
}
-
static EGLBoolean
_eglFlattenScreen(void *elem, void *buffer)
{
_EGLScreen *scr = (_EGLScreen *) elem;
EGLScreenMESA *handle = (EGLScreenMESA *) buffer;
- *handle = scr->Handle;
+ *handle = _eglGetScreenHandle(scr);
return EGL_TRUE;
}
@@ -123,22 +143,6 @@ _eglGetScreensMESA(_EGLDriver *drv, _EGLDisplay *display, EGLScreenMESA *screens
/**
- * Set a screen's current display mode.
- * Note: mode = EGL_NO_MODE is valid (turns off the screen)
- *
- * This is just a placeholder function; drivers will always override
- * this with code that _really_ sets the mode.
- */
-EGLBoolean
-_eglScreenModeMESA(_EGLDriver *drv, _EGLDisplay *dpy, _EGLScreen *scrn,
- _EGLMode *m)
-{
- scrn->CurrentMode = m;
- return EGL_TRUE;
-}
-
-
-/**
* Set a screen's surface origin.
*/
EGLBoolean
@@ -198,33 +202,4 @@ _eglQueryScreenMESA(_EGLDriver *drv, _EGLDisplay *dpy, _EGLScreen *scrn,
}
-/**
- * Delete the modes associated with given screen.
- */
-void
-_eglDestroyScreenModes(_EGLScreen *scrn)
-{
- EGLint i;
- for (i = 0; i < scrn->NumModes; i++) {
- if (scrn->Modes[i].Name)
- free((char *) scrn->Modes[i].Name); /* cast away const */
- }
- if (scrn->Modes)
- free(scrn->Modes);
- scrn->Modes = NULL;
- scrn->NumModes = 0;
-}
-
-
-/**
- * Default fallback routine - drivers should usually override this.
- */
-void
-_eglDestroyScreen(_EGLScreen *scrn)
-{
- _eglDestroyScreenModes(scrn);
- free(scrn);
-}
-
-
#endif /* EGL_MESA_screen_surface */
diff --git a/src/egl/main/eglscreen.h b/src/egl/main/eglscreen.h
index e564793e51..2a99f23c50 100644
--- a/src/egl/main/eglscreen.h
+++ b/src/egl/main/eglscreen.h
@@ -8,6 +8,9 @@
#ifdef EGL_MESA_screen_surface
+#define _EGL_SCREEN_MAX_MODES 16
+
+
/**
* Per-screen information.
* Note that an EGL screen doesn't have a size. A screen may be set to
@@ -19,6 +22,8 @@
*/
struct _egl_screen
{
+ _EGLDisplay *Display;
+
EGLScreenMESA Handle; /* The public/opaque handle which names this object */
_EGLMode *CurrentMode;
@@ -33,15 +38,25 @@ struct _egl_screen
PUBLIC void
-_eglInitScreen(_EGLScreen *screen);
+_eglInitScreen(_EGLScreen *screen, _EGLDisplay *dpy, EGLint num_modes);
+
+
+PUBLIC EGLScreenMESA
+_eglLinkScreen(_EGLScreen *screen);
extern _EGLScreen *
_eglLookupScreen(EGLScreenMESA screen, _EGLDisplay *dpy);
-PUBLIC void
-_eglAddScreen(_EGLDisplay *display, _EGLScreen *screen);
+/**
+ * Return the handle of a linked screen.
+ */
+static INLINE EGLScreenMESA
+_eglGetScreenHandle(_EGLScreen *screen)
+{
+ return (screen) ? screen->Handle : (EGLScreenMESA) 0;
+}
extern EGLBoolean
@@ -49,18 +64,10 @@ _eglGetScreensMESA(_EGLDriver *drv, _EGLDisplay *dpy, EGLScreenMESA *screens, EG
extern EGLBoolean
-_eglScreenModeMESA(_EGLDriver *drv, _EGLDisplay *dpy, _EGLScreen *scrn, _EGLMode *m);
-
-
-extern EGLBoolean
_eglScreenPositionMESA(_EGLDriver *drv, _EGLDisplay *dpy, _EGLScreen *scrn, EGLint x, EGLint y);
extern EGLBoolean
-_eglQueryDisplayMESA(_EGLDriver *drv, _EGLDisplay *dpy, EGLint attribute, EGLint *value);
-
-
-extern EGLBoolean
_eglQueryScreenSurfaceMESA(_EGLDriver *drv, _EGLDisplay *dpy,
_EGLScreen *scrn, _EGLSurface **surface);
@@ -73,14 +80,6 @@ extern EGLBoolean
_eglQueryScreenMESA(_EGLDriver *drv, _EGLDisplay *dpy, _EGLScreen *scrn, EGLint attribute, EGLint *value);
-extern void
-_eglDestroyScreenModes(_EGLScreen *scrn);
-
-
-PUBLIC void
-_eglDestroyScreen(_EGLScreen *scrn);
-
-
#endif /* EGL_MESA_screen_surface */
diff --git a/src/egl/main/eglsurface.c b/src/egl/main/eglsurface.c
index 74f10230ea..cc505045e1 100644
--- a/src/egl/main/eglsurface.c
+++ b/src/egl/main/eglsurface.c
@@ -269,8 +269,7 @@ _eglInitSurface(_EGLSurface *surf, _EGLDisplay *dpy, EGLint type,
return EGL_FALSE;
}
- memset(surf, 0, sizeof(_EGLSurface));
- surf->Resource.Display = dpy;
+ _eglInitResource(&surf->Resource, sizeof(*surf), dpy);
surf->Type = type;
surf->Config = conf;
diff --git a/src/egl/main/eglsurface.h b/src/egl/main/eglsurface.h
index 729499e80a..ef01b32ede 100644
--- a/src/egl/main/eglsurface.h
+++ b/src/egl/main/eglsurface.h
@@ -68,26 +68,35 @@ _eglSwapInterval(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf, EGLint in
/**
- * Return true if there is a context bound to the surface.
- *
- * The binding is considered a reference to the surface. Drivers should not
- * destroy a surface when it is bound.
+ * Increment reference count for the surface.
+ */
+static INLINE _EGLSurface *
+_eglGetSurface(_EGLSurface *surf)
+{
+ if (surf)
+ _eglGetResource(&surf->Resource);
+ return surf;
+}
+
+
+/**
+ * Decrement reference count for the surface.
*/
static INLINE EGLBoolean
-_eglIsSurfaceBound(_EGLSurface *surf)
+_eglPutSurface(_EGLSurface *surf)
{
- return (surf->CurrentContext != NULL);
+ return (surf) ? _eglPutResource(&surf->Resource) : EGL_FALSE;
}
/**
- * Link a surface to a display and return the handle of the link.
+ * 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, _EGLDisplay *dpy)
+_eglLinkSurface(_EGLSurface *surf)
{
- _eglLinkResource(&surf->Resource, _EGL_RESOURCE_SURFACE, dpy);
+ _eglLinkResource(&surf->Resource, _EGL_RESOURCE_SURFACE);
return (EGLSurface) surf;
}
@@ -129,18 +138,4 @@ _eglGetSurfaceHandle(_EGLSurface *surf)
}
-/**
- * Return true if the surface is linked to a display.
- *
- * The link is considered a reference to the surface (the display is owning the
- * surface). Drivers should not destroy a surface when it is linked.
- */
-static INLINE EGLBoolean
-_eglIsSurfaceLinked(_EGLSurface *surf)
-{
- _EGLResource *res = (_EGLResource *) surf;
- return (res && _eglIsResourceLinked(res));
-}
-
-
#endif /* EGLSURFACE_INCLUDED */
diff --git a/src/egl/main/eglsync.c b/src/egl/main/eglsync.c
index b9cd99a332..95e97c7354 100644
--- a/src/egl/main/eglsync.c
+++ b/src/egl/main/eglsync.c
@@ -50,10 +50,7 @@ _eglInitSync(_EGLSync *sync, _EGLDisplay *dpy, EGLenum type,
!(type == EGL_SYNC_FENCE_KHR && dpy->Extensions.KHR_fence_sync))
return _eglError(EGL_BAD_ATTRIBUTE, "eglCreateSyncKHR");
- memset(sync, 0, sizeof(*sync));
-
- sync->Resource.Display = dpy;
-
+ _eglInitResource(&sync->Resource, sizeof(*sync), dpy);
sync->Type = type;
sync->SyncStatus = EGL_UNSIGNALED_KHR;
sync->SyncCondition = EGL_SYNC_PRIOR_COMMANDS_COMPLETE_KHR;
diff --git a/src/egl/main/eglsync.h b/src/egl/main/eglsync.h
index 052d016681..a0025237e7 100644
--- a/src/egl/main/eglsync.h
+++ b/src/egl/main/eglsync.h
@@ -34,13 +34,35 @@ _eglGetSyncAttribKHR(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSync *sync,
/**
- * Link a sync to a display and return the handle of the link.
+ * Increment reference count for the sync.
+ */
+static INLINE _EGLSync *
+_eglGetSync(_EGLSync *sync)
+{
+ if (sync)
+ _eglGetResource(&sync->Resource);
+ return sync;
+}
+
+
+/**
+ * Decrement reference count for the sync.
+ */
+static INLINE EGLBoolean
+_eglPutSync(_EGLSync *sync)
+{
+ return (sync) ? _eglPutResource(&sync->Resource) : EGL_FALSE;
+}
+
+
+/**
+ * Link a sync to its display and return the handle of the link.
* The handle can be passed to client directly.
*/
static INLINE EGLSyncKHR
-_eglLinkSync(_EGLSync *sync, _EGLDisplay *dpy)
+_eglLinkSync(_EGLSync *sync)
{
- _eglLinkResource(&sync->Resource, _EGL_RESOURCE_SYNC, dpy);
+ _eglLinkResource(&sync->Resource, _EGL_RESOURCE_SYNC);
return (EGLSyncKHR) sync;
}
@@ -81,20 +103,6 @@ _eglGetSyncHandle(_EGLSync *sync)
}
-/**
- * Return true if the sync is linked to a display.
- *
- * The link is considered a reference to the sync (the display is owning the
- * sync). Drivers should not destroy a sync when it is linked.
- */
-static INLINE EGLBoolean
-_eglIsSyncLinked(_EGLSync *sync)
-{
- _EGLResource *res = (_EGLResource *) sync;
- return (res && _eglIsResourceLinked(res));
-}
-
-
#endif /* EGL_KHR_reusable_sync */
generated by cgit v1.2.3 (git 2.39.1) at 2024-08-13 17:23:11 +0000