diff options
Diffstat (limited to 'src/egl')
-rw-r--r-- | src/egl/drivers/Makefile.template | 4 | ||||
-rw-r--r-- | src/egl/drivers/dri2/egl_dri2.c | 480 | ||||
-rw-r--r-- | src/egl/drivers/glx/egl_glx.c | 34 | ||||
-rw-r--r-- | src/egl/main/SConscript | 92 | ||||
-rw-r--r-- | src/egl/main/eglapi.c | 35 | ||||
-rw-r--r-- | src/egl/main/eglarray.h | 2 | ||||
-rw-r--r-- | src/egl/main/eglconfig.c | 34 | ||||
-rw-r--r-- | src/egl/main/eglconfig.h | 28 | ||||
-rw-r--r-- | src/egl/main/eglcontext.c | 99 | ||||
-rw-r--r-- | src/egl/main/eglcontext.h | 45 | ||||
-rw-r--r-- | src/egl/main/eglcurrent.c | 40 | ||||
-rw-r--r-- | src/egl/main/egldisplay.c | 53 | ||||
-rw-r--r-- | src/egl/main/egldisplay.h | 15 | ||||
-rw-r--r-- | src/egl/main/egldriver.c | 65 | ||||
-rw-r--r-- | src/egl/main/egldriver.h | 2 | ||||
-rw-r--r-- | src/egl/main/eglimage.c | 4 | ||||
-rw-r--r-- | src/egl/main/eglimage.h | 39 | ||||
-rw-r--r-- | src/egl/main/egllog.c | 5 | ||||
-rw-r--r-- | src/egl/main/eglmode.c | 60 | ||||
-rw-r--r-- | src/egl/main/eglmode.h | 5 | ||||
-rw-r--r-- | src/egl/main/eglscreen.c | 117 | ||||
-rw-r--r-- | src/egl/main/eglscreen.h | 37 | ||||
-rw-r--r-- | src/egl/main/eglsurface.c | 3 | ||||
-rw-r--r-- | src/egl/main/eglsurface.h | 41 | ||||
-rw-r--r-- | src/egl/main/eglsync.c | 5 | ||||
-rw-r--r-- | src/egl/main/eglsync.h | 42 |
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 */ |