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
