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 Win32 EGL native display factory 22 *//*--------------------------------------------------------------------*/ 23 24 #include "tcuWin32EGLNativeDisplayFactory.hpp" 25 26 #include "egluDefs.hpp" 27 #include "tcuWin32Window.hpp" 28 #include "tcuWin32API.h" 29 #include "tcuTexture.hpp" 30 #include "deMemory.h" 31 #include "deThread.h" 32 #include "deClock.h" 33 #include "eglwLibrary.hpp" 34 #include "eglwEnums.hpp" 35 36 // Assume no call translation is needed 37 DE_STATIC_ASSERT(sizeof(eglw::EGLNativeDisplayType) == sizeof(HDC)); 38 DE_STATIC_ASSERT(sizeof(eglw::EGLNativePixmapType) == sizeof(HBITMAP)); 39 DE_STATIC_ASSERT(sizeof(eglw::EGLNativeWindowType) == sizeof(HWND)); 40 41 namespace tcu 42 { 43 namespace win32 44 { 45 namespace 46 { 47 48 using namespace eglw; 49 50 enum 51 { 52 DEFAULT_SURFACE_WIDTH = 400, 53 DEFAULT_SURFACE_HEIGHT = 300, 54 WAIT_WINDOW_VISIBLE_MS = 500 //!< Time to wait before issuing screenshot after changing window visibility (hack for DWM) 55 }; 56 57 static const eglu::NativeDisplay::Capability DISPLAY_CAPABILITIES = eglu::NativeDisplay::CAPABILITY_GET_DISPLAY_LEGACY; 58 static const eglu::NativePixmap::Capability BITMAP_CAPABILITIES = eglu::NativePixmap::CAPABILITY_CREATE_SURFACE_LEGACY; 59 static const eglu::NativeWindow::Capability WINDOW_CAPABILITIES = (eglu::NativeWindow::Capability) 60 (eglu::NativeWindow::CAPABILITY_CREATE_SURFACE_LEGACY | 61 eglu::NativeWindow::CAPABILITY_GET_SURFACE_SIZE | 62 eglu::NativeWindow::CAPABILITY_GET_SCREEN_SIZE | 63 eglu::NativeWindow::CAPABILITY_READ_SCREEN_PIXELS | 64 eglu::NativeWindow::CAPABILITY_SET_SURFACE_SIZE | 65 eglu::NativeWindow::CAPABILITY_CHANGE_VISIBILITY); 66 67 class NativeDisplay : public eglu::NativeDisplay 68 { 69 public: 70 NativeDisplay (void); 71 virtual ~NativeDisplay (void) {} 72 73 virtual EGLNativeDisplayType getLegacyNative (void) { return m_deviceContext; } 74 const eglw::Library& getLibrary (void) const { return m_library; } 75 76 HDC getDeviceContext (void) { return m_deviceContext; } 77 78 private: 79 HDC m_deviceContext; 80 eglw::DefaultLibrary m_library; 81 }; 82 83 class NativePixmapFactory : public eglu::NativePixmapFactory 84 { 85 public: 86 NativePixmapFactory (void); 87 ~NativePixmapFactory (void) {} 88 89 virtual eglu::NativePixmap* createPixmap (eglu::NativeDisplay* nativeDisplay, int width, int height) const; 90 virtual eglu::NativePixmap* createPixmap (eglu::NativeDisplay* nativeDisplay, EGLDisplay display, EGLConfig config, const EGLAttrib* attribList, int width, int height) const; 91 }; 92 93 class NativePixmap : public eglu::NativePixmap 94 { 95 public: 96 NativePixmap (NativeDisplay* nativeDisplay, int width, int height, int bitDepth); 97 virtual ~NativePixmap (void); 98 99 EGLNativePixmapType getLegacyNative (void) { return m_bitmap; } 100 101 private: 102 HBITMAP m_bitmap; 103 }; 104 105 class NativeWindowFactory : public eglu::NativeWindowFactory 106 { 107 public: 108 NativeWindowFactory (HINSTANCE instance); 109 virtual ~NativeWindowFactory (void) {} 110 111 virtual eglu::NativeWindow* createWindow (eglu::NativeDisplay* nativeDisplay, const eglu::WindowParams& params) const; 112 113 private: 114 const HINSTANCE m_instance; 115 }; 116 117 class NativeWindow : public eglu::NativeWindow 118 { 119 public: 120 NativeWindow (NativeDisplay* nativeDisplay, HINSTANCE instance, const eglu::WindowParams& params); 121 virtual ~NativeWindow (void); 122 123 EGLNativeWindowType getLegacyNative (void) { return m_window.getHandle(); } 124 virtual IVec2 getSurfaceSize (void) const; 125 virtual IVec2 getScreenSize (void) const { return getSurfaceSize(); } 126 virtual void processEvents (void); 127 virtual void setSurfaceSize (IVec2 size); 128 virtual void setVisibility (eglu::WindowParams::Visibility visibility); 129 virtual void readScreenPixels (tcu::TextureLevel* dst) const; 130 131 private: 132 win32::Window m_window; 133 eglu::WindowParams::Visibility m_curVisibility; 134 deUint64 m_setVisibleTime; //!< Time window was set visible. 135 }; 136 137 // NativeDisplay 138 139 NativeDisplay::NativeDisplay (void) 140 : eglu::NativeDisplay (DISPLAY_CAPABILITIES) 141 , m_deviceContext ((HDC)EGL_DEFAULT_DISPLAY) 142 , m_library ("libEGL.dll") 143 { 144 } 145 146 // NativePixmap 147 148 NativePixmap::NativePixmap (NativeDisplay* nativeDisplay, int width, int height, int bitDepth) 149 : eglu::NativePixmap (BITMAP_CAPABILITIES) 150 , m_bitmap (DE_NULL) 151 { 152 const HDC deviceCtx = nativeDisplay->getDeviceContext(); 153 BITMAPINFO bitmapInfo; 154 155 memset(&bitmapInfo, 0, sizeof(bitmapInfo)); 156 157 if (bitDepth != 24 && bitDepth != 32) 158 throw NotSupportedError("Unsupported pixmap bit depth", DE_NULL, __FILE__, __LINE__); 159 160 bitmapInfo.bmiHeader.biSize = sizeof(bitmapInfo); 161 bitmapInfo.bmiHeader.biWidth = width; 162 bitmapInfo.bmiHeader.biHeight = height; 163 bitmapInfo.bmiHeader.biPlanes = 1; 164 bitmapInfo.bmiHeader.biBitCount = bitDepth; 165 bitmapInfo.bmiHeader.biCompression = BI_RGB; 166 bitmapInfo.bmiHeader.biSizeImage = 0; 167 bitmapInfo.bmiHeader.biXPelsPerMeter = 1; 168 bitmapInfo.bmiHeader.biYPelsPerMeter = 1; 169 bitmapInfo.bmiHeader.biClrUsed = 0; 170 bitmapInfo.bmiHeader.biClrImportant = 0; 171 172 void* bitmapPtr = DE_NULL; 173 m_bitmap = CreateDIBSection(deviceCtx, &bitmapInfo, DIB_RGB_COLORS, &bitmapPtr, NULL, 0); 174 175 if (!m_bitmap) 176 throw ResourceError("Failed to create bitmap", DE_NULL, __FILE__, __LINE__); 177 } 178 179 NativePixmap::~NativePixmap (void) 180 { 181 DeleteObject(m_bitmap); 182 } 183 184 // NativePixmapFactory 185 186 NativePixmapFactory::NativePixmapFactory (void) 187 : eglu::NativePixmapFactory ("bitmap", "Win32 Bitmap", BITMAP_CAPABILITIES) 188 { 189 } 190 191 eglu::NativePixmap* NativePixmapFactory::createPixmap (eglu::NativeDisplay* nativeDisplay, EGLDisplay display, EGLConfig config, const EGLAttrib* attribList, int width, int height) const 192 { 193 const Library& egl = nativeDisplay->getLibrary(); 194 int redBits = 0; 195 int greenBits = 0; 196 int blueBits = 0; 197 int alphaBits = 0; 198 int bitSum = 0; 199 200 DE_ASSERT(display != EGL_NO_DISPLAY); 201 202 egl.getConfigAttrib(display, config, EGL_RED_SIZE, &redBits); 203 egl.getConfigAttrib(display, config, EGL_GREEN_SIZE, &greenBits); 204 egl.getConfigAttrib(display, config, EGL_BLUE_SIZE, &blueBits); 205 egl.getConfigAttrib(display, config, EGL_ALPHA_SIZE, &alphaBits); 206 EGLU_CHECK_MSG(egl, "eglGetConfigAttrib()"); 207 208 bitSum = redBits+greenBits+blueBits+alphaBits; 209 210 return new NativePixmap(dynamic_cast<NativeDisplay*>(nativeDisplay), width, height, bitSum); 211 } 212 213 eglu::NativePixmap* NativePixmapFactory::createPixmap (eglu::NativeDisplay* nativeDisplay, int width, int height) const 214 { 215 const int defaultDepth = 32; 216 return new NativePixmap(dynamic_cast<NativeDisplay*>(nativeDisplay), width, height, defaultDepth); 217 } 218 219 // NativeWindowFactory 220 221 NativeWindowFactory::NativeWindowFactory (HINSTANCE instance) 222 : eglu::NativeWindowFactory ("window", "Win32 Window", WINDOW_CAPABILITIES) 223 , m_instance (instance) 224 { 225 } 226 227 eglu::NativeWindow* NativeWindowFactory::createWindow (eglu::NativeDisplay* nativeDisplay, const eglu::WindowParams& params) const 228 { 229 return new NativeWindow(dynamic_cast<NativeDisplay*>(nativeDisplay), m_instance, params); 230 } 231 232 // NativeWindow 233 234 NativeWindow::NativeWindow (NativeDisplay* nativeDisplay, HINSTANCE instance, const eglu::WindowParams& params) 235 : eglu::NativeWindow (WINDOW_CAPABILITIES) 236 , m_window (instance, 237 params.width == eglu::WindowParams::SIZE_DONT_CARE ? DEFAULT_SURFACE_WIDTH : params.width, 238 params.height == eglu::WindowParams::SIZE_DONT_CARE ? DEFAULT_SURFACE_HEIGHT : params.height) 239 , m_curVisibility (eglu::WindowParams::VISIBILITY_HIDDEN) 240 , m_setVisibleTime (0) 241 { 242 if (params.visibility != eglu::WindowParams::VISIBILITY_DONT_CARE) 243 setVisibility(params.visibility); 244 } 245 246 void NativeWindow::setVisibility (eglu::WindowParams::Visibility visibility) 247 { 248 switch (visibility) 249 { 250 case eglu::WindowParams::VISIBILITY_HIDDEN: 251 m_window.setVisible(false); 252 m_curVisibility = visibility; 253 break; 254 255 case eglu::WindowParams::VISIBILITY_VISIBLE: 256 case eglu::WindowParams::VISIBILITY_FULLSCREEN: 257 // \todo [2014-03-12 pyry] Implement FULLSCREEN, or at least SW_MAXIMIZE. 258 m_window.setVisible(true); 259 m_curVisibility = eglu::WindowParams::VISIBILITY_VISIBLE; 260 m_setVisibleTime = deGetMicroseconds(); 261 break; 262 263 default: 264 DE_ASSERT(DE_FALSE); 265 } 266 } 267 268 NativeWindow::~NativeWindow (void) 269 { 270 } 271 272 IVec2 NativeWindow::getSurfaceSize (void) const 273 { 274 return m_window.getSize(); 275 } 276 277 void NativeWindow::processEvents (void) 278 { 279 m_window.processEvents(); 280 } 281 282 void NativeWindow::setSurfaceSize (IVec2 size) 283 { 284 m_window.setSize(size.x(), size.y()); 285 } 286 287 void NativeWindow::readScreenPixels (tcu::TextureLevel* dst) const 288 { 289 HDC windowDC = DE_NULL; 290 HDC screenDC = DE_NULL; 291 HDC tmpDC = DE_NULL; 292 HBITMAP tmpBitmap = DE_NULL; 293 RECT rect; 294 295 TCU_CHECK_INTERNAL(m_curVisibility != eglu::WindowParams::VISIBILITY_HIDDEN); 296 297 // Hack for DWM: There is no way to wait for DWM animations to finish, so we just have to wait 298 // for a while before issuing screenshot if window was just made visible. 299 { 300 const deInt64 timeSinceVisibleUs = (deInt64)(deGetMicroseconds()-m_setVisibleTime); 301 302 if (timeSinceVisibleUs < (deInt64)WAIT_WINDOW_VISIBLE_MS*1000) 303 deSleep(WAIT_WINDOW_VISIBLE_MS - (deUint32)(timeSinceVisibleUs/1000)); 304 } 305 306 TCU_CHECK(GetClientRect(m_window.getHandle(), &rect)); 307 308 try 309 { 310 const int width = rect.right - rect.left; 311 const int height = rect.bottom - rect.top; 312 BITMAPINFOHEADER bitmapInfo; 313 314 deMemset(&bitmapInfo, 0, sizeof(bitmapInfo)); 315 316 screenDC = GetDC(DE_NULL); 317 TCU_CHECK(screenDC); 318 319 windowDC = GetDC(m_window.getHandle()); 320 TCU_CHECK(windowDC); 321 322 tmpDC = CreateCompatibleDC(screenDC); 323 TCU_CHECK(tmpDC != DE_NULL); 324 325 MapWindowPoints(m_window.getHandle(), DE_NULL, (LPPOINT)&rect, 2); 326 327 tmpBitmap = CreateCompatibleBitmap(screenDC, width, height); 328 TCU_CHECK(tmpBitmap != DE_NULL); 329 330 TCU_CHECK(SelectObject(tmpDC, tmpBitmap) != DE_NULL); 331 332 TCU_CHECK(BitBlt(tmpDC, 0, 0, width, height, screenDC, rect.left, rect.top, SRCCOPY)); 333 334 335 bitmapInfo.biSize = sizeof(BITMAPINFOHEADER); 336 bitmapInfo.biWidth = width; 337 bitmapInfo.biHeight = -height; 338 bitmapInfo.biPlanes = 1; 339 bitmapInfo.biBitCount = 32; 340 bitmapInfo.biCompression = BI_RGB; 341 bitmapInfo.biSizeImage = 0; 342 bitmapInfo.biXPelsPerMeter = 0; 343 bitmapInfo.biYPelsPerMeter = 0; 344 bitmapInfo.biClrUsed = 0; 345 bitmapInfo.biClrImportant = 0; 346 347 dst->setStorage(TextureFormat(TextureFormat::BGRA, TextureFormat::UNORM_INT8), width, height); 348 349 TCU_CHECK(GetDIBits(screenDC, tmpBitmap, 0, height, dst->getAccess().getDataPtr(), (BITMAPINFO*)&bitmapInfo, DIB_RGB_COLORS)); 350 351 DeleteObject(tmpBitmap); 352 tmpBitmap = DE_NULL; 353 354 ReleaseDC(DE_NULL, screenDC); 355 screenDC = DE_NULL; 356 357 ReleaseDC(m_window.getHandle(), windowDC); 358 windowDC = DE_NULL; 359 360 DeleteDC(tmpDC); 361 tmpDC = DE_NULL; 362 } 363 catch (...) 364 { 365 if (screenDC) 366 ReleaseDC(DE_NULL, screenDC); 367 368 if (windowDC) 369 ReleaseDC(m_window.getHandle(), windowDC); 370 371 if (tmpBitmap) 372 DeleteObject(tmpBitmap); 373 374 if (tmpDC) 375 DeleteDC(tmpDC); 376 377 throw; 378 } 379 } 380 381 } // anonymous 382 383 EGLNativeDisplayFactory::EGLNativeDisplayFactory (HINSTANCE instance) 384 : eglu::NativeDisplayFactory ("win32", "Native Win32 Display", DISPLAY_CAPABILITIES) 385 , m_instance (instance) 386 { 387 m_nativeWindowRegistry.registerFactory(new NativeWindowFactory(m_instance)); 388 m_nativePixmapRegistry.registerFactory(new NativePixmapFactory()); 389 } 390 391 EGLNativeDisplayFactory::~EGLNativeDisplayFactory (void) 392 { 393 } 394 395 eglu::NativeDisplay* EGLNativeDisplayFactory::createDisplay (const EGLAttrib* attribList) const 396 { 397 DE_UNREF(attribList); 398 return new NativeDisplay(); 399 } 400 401 } // win32 402 } // tcu 403
