Home | History | Annotate | Download | only in X11
      1 /*-------------------------------------------------------------------------
      2  * drawElements Quality Program Tester Core
      3  * ----------------------------------------
      4  *
      5  * Copyright 2014 The Android Open Source Project
      6  *
      7  * Licensed under the Apache License, Version 2.0 (the "License");
      8  * you may not use this file except in compliance with the License.
      9  * You may obtain a copy of the License at
     10  *
     11  *      http://www.apache.org/licenses/LICENSE-2.0
     12  *
     13  * Unless required by applicable law or agreed to in writing, software
     14  * distributed under the License is distributed on an "AS IS" BASIS,
     15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     16  * See the License for the specific language governing permissions and
     17  * limitations under the License.
     18  *
     19  *//*!
     20  * \file
     21  * \brief X11Egl Platform.
     22  *//*--------------------------------------------------------------------*/
     23 
     24 #include "tcuX11EglPlatform.hpp"
     25 #include "egluGLContextFactory.hpp"
     26 #include "eglwLibrary.hpp"
     27 #include "eglwFunctions.hpp"
     28 #include "eglwEnums.hpp"
     29 
     30 namespace tcu
     31 {
     32 namespace x11
     33 {
     34 namespace egl
     35 {
     36 
     37 typedef ::Display*	EGLNativeDisplayType;
     38 typedef ::Pixmap	EGLNativePixmapType;
     39 typedef ::Window	EGLNativeWindowType;
     40 
     41 DE_STATIC_ASSERT(sizeof(EGLNativeDisplayType)	<= sizeof(eglw::EGLNativeDisplayType));
     42 DE_STATIC_ASSERT(sizeof(EGLNativePixmapType)	<= sizeof(eglw::EGLNativePixmapType));
     43 DE_STATIC_ASSERT(sizeof(EGLNativeWindowType)	<= sizeof(eglw::EGLNativeWindowType));
     44 
     45 extern "C"
     46 {
     47 
     48 typedef EGLW_APICALL	eglw::EGLDisplay	(EGLW_APIENTRY* eglX11GetDisplayFunc)			(EGLNativeDisplayType display_id);
     49 typedef EGLW_APICALL	eglw::EGLBoolean	(EGLW_APIENTRY* eglX11CopyBuffersFunc)			(eglw::EGLDisplay dpy, eglw::EGLSurface surface, EGLNativePixmapType target);
     50 typedef EGLW_APICALL	eglw::EGLSurface	(EGLW_APIENTRY* eglX11CreatePixmapSurfaceFunc)	(eglw::EGLDisplay dpy, eglw::EGLConfig config, EGLNativePixmapType pixmap, const eglw::EGLint* attrib_list);
     51 typedef EGLW_APICALL	eglw::EGLSurface	(EGLW_APIENTRY* eglX11CreateWindowSurfaceFunc)	(eglw::EGLDisplay dpy, eglw::EGLConfig config, EGLNativeWindowType win, const eglw::EGLint* attrib_list);
     52 
     53 }
     54 
     55 using std::string;
     56 
     57 using de::MovePtr;
     58 using de::UniquePtr;
     59 using glu::ContextFactory;
     60 using eglu::GLContextFactory;
     61 using eglu::NativeDisplay;
     62 using eglu::NativeDisplayFactory;
     63 using eglu::NativeWindow;
     64 using eglu::NativeWindowFactory;
     65 using eglu::NativePixmap;
     66 using eglu::NativePixmapFactory;
     67 using eglu::WindowParams;
     68 using tcu::TextureLevel;
     69 
     70 class Library : public eglw::DefaultLibrary
     71 {
     72 public:
     73 	Library (void)
     74 		: eglw::DefaultLibrary("libEGL.so")
     75 	{
     76 	}
     77 
     78 	eglw::EGLBoolean copyBuffers (eglw::EGLDisplay dpy, eglw::EGLSurface surface, eglw::EGLNativePixmapType target) const
     79 	{
     80 		return ((eglX11CopyBuffersFunc)m_egl.copyBuffers)(dpy, surface, reinterpret_cast<EGLNativePixmapType>(target));
     81 	}
     82 
     83 	eglw::EGLSurface createPixmapSurface (eglw::EGLDisplay dpy, eglw::EGLConfig config, eglw::EGLNativePixmapType pixmap, const eglw::EGLint *attrib_list) const
     84 	{
     85 		return ((eglX11CreatePixmapSurfaceFunc)m_egl.createPixmapSurface)(dpy, config, reinterpret_cast<EGLNativePixmapType>(pixmap), attrib_list);
     86 	}
     87 
     88 	eglw::EGLSurface createWindowSurface (eglw::EGLDisplay dpy, eglw::EGLConfig config, eglw::EGLNativeWindowType win, const eglw::EGLint *attrib_list) const
     89 	{
     90 		return ((eglX11CreateWindowSurfaceFunc)m_egl.createWindowSurface)(dpy, config, reinterpret_cast<EGLNativeWindowType>(win), attrib_list);
     91 	}
     92 
     93 	eglw::EGLDisplay getDisplay (eglw::EGLNativeDisplayType display_id) const
     94 	{
     95 		return ((eglX11GetDisplayFunc)m_egl.getDisplay)(reinterpret_cast<EGLNativeDisplayType>(display_id));
     96 	}
     97 };
     98 
     99 class Display : public NativeDisplay
    100 {
    101 public:
    102 	static const Capability CAPABILITIES 		= Capability(CAPABILITY_GET_DISPLAY_LEGACY |
    103 															 CAPABILITY_GET_DISPLAY_PLATFORM);
    104 
    105 								Display				(MovePtr<x11::Display> x11Display)
    106 									: NativeDisplay	(CAPABILITIES,
    107 													 EGL_PLATFORM_X11_EXT,
    108 													 "EGL_EXT_platform_x11")
    109 									, m_display		(x11Display) {}
    110 
    111 	void*						getPlatformNative		(void) 	{ return m_display->getXDisplay(); }
    112 	eglw::EGLNativeDisplayType	getLegacyNative			(void)	{ return reinterpret_cast<eglw::EGLNativeDisplayType>(m_display->getXDisplay()); }
    113 
    114 	x11::Display&				getX11Display			(void)			{ return *m_display;	}
    115 	const eglw::Library&		getLibrary				(void) const	{ return m_library;		}
    116 	const eglw::EGLAttrib*		getPlatformAttributes	(void) const	{ return DE_NULL;		}
    117 
    118 private:
    119 	UniquePtr<x11::Display>		m_display;
    120 	Library						m_library;
    121 };
    122 
    123 class Window : public NativeWindow
    124 {
    125 public:
    126 	static const Capability	CAPABILITIES		= Capability(CAPABILITY_CREATE_SURFACE_LEGACY |
    127 															 CAPABILITY_CREATE_SURFACE_PLATFORM |
    128 															 CAPABILITY_GET_SURFACE_SIZE |
    129 															 CAPABILITY_SET_SURFACE_SIZE |
    130 															 CAPABILITY_GET_SCREEN_SIZE);
    131 
    132 								Window				(Display&				display,
    133 													 const WindowParams&	params,
    134 													 Visual*				visual);
    135 
    136 	eglw::EGLNativeWindowType	getLegacyNative		(void) { return reinterpret_cast<eglw::EGLNativeWindowType>(m_window.getXID()); }
    137 	void*						getPlatformNative	(void) { return &m_window.getXID();	}
    138 
    139 	IVec2						getSurfaceSize		(void) const;
    140 	void						setSurfaceSize		(IVec2 size);
    141 	IVec2						getScreenSize		(void) const { return getSurfaceSize(); }
    142 
    143 private:
    144 	x11::Window					m_window;
    145 };
    146 
    147 Window::Window (Display& display, const WindowParams& params, Visual* visual)
    148 	: NativeWindow	(CAPABILITIES)
    149 	, m_window		(display.getX11Display(), params.width, params.height, visual)
    150 {
    151 	m_window.setVisibility((params.visibility != WindowParams::VISIBILITY_HIDDEN));
    152 }
    153 
    154 IVec2 Window::getSurfaceSize (void) const
    155 {
    156 	IVec2 ret;
    157 	m_window.getDimensions(&ret.x(), &ret.y());
    158 	return ret;
    159 }
    160 
    161 void Window::setSurfaceSize (IVec2 size)
    162 {
    163 	m_window.setDimensions(size.x(), size.y());
    164 }
    165 
    166 class WindowFactory : public NativeWindowFactory
    167 {
    168 public:
    169 						WindowFactory		(void);
    170 
    171 	NativeWindow*		createWindow		(NativeDisplay*			nativeDisplay,
    172 											 const WindowParams&	params) const;
    173 
    174 	NativeWindow*		createWindow		(NativeDisplay*			nativeDisplay,
    175 											 eglw::EGLDisplay		display,
    176 											 eglw::EGLConfig		config,
    177 											 const eglw::EGLAttrib*	attribList,
    178 											 const WindowParams&	params) const;
    179 };
    180 
    181 WindowFactory::WindowFactory (void)
    182 	: NativeWindowFactory ("window", "X11 Window", Window::CAPABILITIES)
    183 {
    184 }
    185 
    186 NativeWindow* WindowFactory::createWindow (NativeDisplay*		nativeDisplay,
    187 										   const WindowParams&	params) const
    188 {
    189 	Display&	display	= *dynamic_cast<Display*>(nativeDisplay);
    190 
    191 	return new Window(display, params, DE_NULL);
    192 }
    193 
    194 NativeWindow* WindowFactory::createWindow (NativeDisplay*			nativeDisplay,
    195 										   eglw::EGLDisplay			eglDisplay,
    196 										   eglw::EGLConfig			config,
    197 										   const eglw::EGLAttrib*	attribList,
    198 										   const WindowParams&		params) const
    199 {
    200 	DE_UNREF(attribList);
    201 
    202 	Display&		display		= *dynamic_cast<Display*>(nativeDisplay);
    203 	eglw::EGLint	visualID	= 0;
    204 	::Visual*		visual		= DE_NULL;
    205 	nativeDisplay->getLibrary().getConfigAttrib(eglDisplay, config, EGL_NATIVE_VISUAL_ID, &visualID);
    206 
    207 	if (visualID != 0)
    208 		visual = display.getX11Display().getVisual(visualID);
    209 
    210 	return new Window(display, params, visual);
    211 }
    212 
    213 #if 0
    214 class Pixmap : public NativePixmap
    215 {
    216 public:
    217 	enum {
    218 		CAPABILITIES = (CAPABILITY_CREATE_SURFACE_LEGACY |
    219 						CAPABILITY_CREATE_SURFACE_PLATFORM |
    220 						CAPABILITY_READ_PIXELS)
    221 	};
    222 
    223 							Pixmap				(MovePtr<x11::Pixmap> x11Pixmap)
    224 								: NativePixmap	(CAPABILITIES)
    225 								, m_pixmap		(x11Pixmap) {}
    226 
    227 	void*					getPlatformNative	(void) { return &m_pixmap.getXID(); }
    228 	void					readPixels			(TextureLevel* dst);
    229 
    230 private:
    231 	UniquePtr<x11::Pixmap>	m_pixmap;
    232 };
    233 
    234 class PixmapFactory : public NativePixmapFactory
    235 {
    236 public:
    237 					PixmapFactory	(void)
    238 						: NativePixmapFactory ("pixmap", "X11 Pixmap", Pixmap::CAPABILITIES) {}
    239 
    240 	NativePixmap*	createPixmap	(NativeDisplay* nativeDisplay,
    241 									 int			width,
    242 									 int			height) const;
    243 };
    244 
    245 NativePixmap* PixmapFactory::createPixmap (NativeDisplay* nativeDisplay,
    246 										   int			width,
    247 										   int			height) const
    248 
    249 {
    250 	Display*				display		= dynamic_cast<Display*>(nativeDisplay);
    251 	MovePtr<x11::Pixmap>	x11Pixmap	(new x11::Pixmap(display->getX11Display(),
    252 														 width, height));
    253 	return new Pixmap(x11Pixmap);
    254 }
    255 #endif
    256 
    257 class DisplayFactory : public NativeDisplayFactory
    258 {
    259 public:
    260 						DisplayFactory		(EventState& eventState);
    261 
    262 	NativeDisplay*		createDisplay		(const eglw::EGLAttrib* attribList) const;
    263 
    264 private:
    265 	EventState&			m_eventState;
    266 };
    267 
    268 DisplayFactory::DisplayFactory (EventState& eventState)
    269 	: NativeDisplayFactory	("x11", "Native X11 Display",
    270 							 Display::CAPABILITIES,
    271 							 EGL_PLATFORM_X11_SCREEN_EXT,
    272 							 "EGL_EXT_platform_x11")
    273 	, m_eventState			(eventState)
    274 {
    275 	m_nativeWindowRegistry.registerFactory(new WindowFactory());
    276 	// m_nativePixmapRegistry.registerFactory(new PixmapFactory());
    277 }
    278 
    279 NativeDisplay* DisplayFactory::createDisplay (const eglw::EGLAttrib* attribList) const
    280 {
    281 	DE_UNREF(attribList);
    282 
    283 	//! \todo [2014-03-18 lauri] Somehow make the display configurable from command line
    284 	MovePtr<x11::Display>	x11Display	(new x11::Display(m_eventState, DE_NULL));
    285 
    286 	return new Display(x11Display);
    287 }
    288 
    289 Platform::Platform (EventState& eventState)
    290 {
    291 	m_nativeDisplayFactoryRegistry.registerFactory(new DisplayFactory(eventState));
    292 }
    293 
    294 MovePtr<ContextFactory> Platform::createContextFactory (void)
    295 {
    296 	return MovePtr<ContextFactory>(new GLContextFactory(m_nativeDisplayFactoryRegistry));
    297 }
    298 
    299 
    300 } // egl
    301 } // x11
    302 } // tcu
    303