src/third_party/angle/src/libEGL/Display.cpp

   1 //
   2 // Copyright (c) 2002-2014 The ANGLE Project Authors. All rights reserved.
   3 // Use of this source code is governed by a BSD-style license that can be
   4 // found in the LICENSE file.
   5 //
   6
   7 // Display.cpp: Implements the egl::Display class, representing the abstract
   8 // display on which graphics are drawn. Implements EGLDisplay.
   9 // [EGL 1.4] section 2.1.2 page 3.
  10
  11 #include "libEGL/Display.h"
  12
  13 #include <algorithm>
  14 #include <map>
  15 #include <vector>
  16 #include <sstream>
  17
  18 #include "common/debug.h"
  19 #include "common/mathutil.h"
  20 #include "libGLESv2/main.h"
  21 #include "libGLESv2/Context.h"
  22 #include "libGLESv2/renderer/SwapChain.h"
  23
  24 #include "libEGL/main.h"
  25 #include "libEGL/Surface.h"
  26
  27 namespace egl
  28 {
  29
  30 typedef std::map<EGLNativeDisplayType, Display*> DisplayMap;
  31 static DisplayMap *GetDisplayMap()
  32 {
  33     static DisplayMap displays;
  34     return &displays;
  35 }
  36
  37 egl::Display *Display::getDisplay(EGLNativeDisplayType displayId, EGLint displayType)
  38 {
  39     DisplayMap *displays = GetDisplayMap();
  40     DisplayMap::const_iterator iter = displays->find(displayId);
  41     if (iter != displays->end())
  42     {
  43         return iter->second;
  44     }
  45
  46     // FIXME: Check if displayId is a valid display device context
  47
  48     egl::Display *display = new egl::Display(displayId, displayType);
  49     displays->insert(std::make_pair(displayId, display));
  50
  51     return display;
  52 }
  53
  54 Display::Display(EGLNativeDisplayType displayId, EGLint displayType)
  55     : mDisplayId(displayId),
  56       mRequestedDisplayType(displayType),
  57       mRenderer(NULL)
  58 {
  59 }
  60
  61 Display::~Display()
  62 {
  63     terminate();
  64
  65     DisplayMap *displays = GetDisplayMap();
  66     DisplayMap::iterator iter = displays->find(mDisplayId);
  67     if (iter != displays->end())
  68     {
  69         displays->erase(iter);
  70     }
  71 }
  72
  73 bool Display::initialize()
  74 {
  75     if (isInitialized())
  76     {
  77         return true;
  78     }
  79
  80     mRenderer = glCreateRenderer(this, mDisplayId, mRequestedDisplayType);
  81
  82     if (!mRenderer)
  83     {
  84         terminate();
  85         return error(EGL_NOT_INITIALIZED, false);
  86     }
  87
  88     EGLint minSwapInterval = mRenderer->getMinSwapInterval();
  89     EGLint maxSwapInterval = mRenderer->getMaxSwapInterval();
  90     EGLint maxTextureSize = mRenderer->getRendererCaps().max2DTextureSize;
  91
  92     rx::ConfigDesc *descList;
  93     int numConfigs = mRenderer->generateConfigs(&descList);
  94     ConfigSet configSet;
  95
  96     for (int i = 0; i < numConfigs; ++i)
  97     {
  98         configSet.add(descList[i], minSwapInterval, maxSwapInterval, maxTextureSize, maxTextureSize);
  99     }
 100
 101     // Give the sorted configs a unique ID and store them internally
 102     EGLint index = 1;
 103     for (ConfigSet::Iterator config = configSet.mSet.begin(); config != configSet.mSet.end(); config++)
 104     {
 105         Config configuration = *config;
 106         configuration.mConfigID = index;
 107         index++;
 108
 109         mConfigSet.mSet.insert(configuration);
 110     }
 111
 112     mRenderer->deleteConfigs(descList);
 113     descList = NULL;
 114
 115     if (!isInitialized())
 116     {
 117         terminate();
 118         return false;
 119     }
 120
 121     initDisplayExtensionString();
 122     initVendorString();
 123
 124     return true;
 125 }
 126
 127 void Display::terminate()
 128 {
 129     while (!mSurfaceSet.empty())
 130     {
 131         destroySurface(*mSurfaceSet.begin());
 132     }
 133
 134     while (!mContextSet.empty())
 135     {
 136         destroyContext(*mContextSet.begin());
 137     }
 138
 139     glDestroyRenderer(mRenderer);
 140     mRenderer = NULL;
 141 }
 142
 143 bool Display::getConfigs(EGLConfig *configs, const EGLint *attribList, EGLint configSize, EGLint *numConfig)
 144 {
 145     return mConfigSet.getConfigs(configs, attribList, configSize, numConfig);
 146 }
 147
 148 bool Display::getConfigAttrib(EGLConfig config, EGLint attribute, EGLint *value)
 149 {
 150     const egl::Config *configuration = mConfigSet.get(config);
 151
 152     switch (attribute)
 153     {
 154       case EGL_BUFFER_SIZE:               *value = configuration->mBufferSize;             break;
 155       case EGL_ALPHA_SIZE:                *value = configuration->mAlphaSize;              break;
 156       case EGL_BLUE_SIZE:                 *value = configuration->mBlueSize;               break;
 157       case EGL_GREEN_SIZE:                *value = configuration->mGreenSize;              break;
 158       case EGL_RED_SIZE:                  *value = configuration->mRedSize;                break;
 159       case EGL_DEPTH_SIZE:                *value = configuration->mDepthSize;              break;
 160       case EGL_STENCIL_SIZE:              *value = configuration->mStencilSize;            break;
 161       case EGL_CONFIG_CAVEAT:             *value = configuration->mConfigCaveat;           break;
 162       case EGL_CONFIG_ID:                 *value = configuration->mConfigID;               break;
 163       case EGL_LEVEL:                     *value = configuration->mLevel;                  break;
 164       case EGL_NATIVE_RENDERABLE:         *value = configuration->mNativeRenderable;       break;
 165       case EGL_NATIVE_VISUAL_TYPE:        *value = configuration->mNativeVisualType;       break;
 166       case EGL_SAMPLES:                   *value = configuration->mSamples;                break;
 167       case EGL_SAMPLE_BUFFERS:            *value = configuration->mSampleBuffers;          break;
 168       case EGL_SURFACE_TYPE:              *value = configuration->mSurfaceType;            break;
 169       case EGL_TRANSPARENT_TYPE:          *value = configuration->mTransparentType;        break;
 170       case EGL_TRANSPARENT_BLUE_VALUE:    *value = configuration->mTransparentBlueValue;   break;
 171       case EGL_TRANSPARENT_GREEN_VALUE:   *value = configuration->mTransparentGreenValue;  break;
 172       case EGL_TRANSPARENT_RED_VALUE:     *value = configuration->mTransparentRedValue;    break;
 173       case EGL_BIND_TO_TEXTURE_RGB:       *value = configuration->mBindToTextureRGB;       break;
 174       case EGL_BIND_TO_TEXTURE_RGBA:      *value = configuration->mBindToTextureRGBA;      break;
 175       case EGL_MIN_SWAP_INTERVAL:         *value = configuration->mMinSwapInterval;        break;
 176       case EGL_MAX_SWAP_INTERVAL:         *value = configuration->mMaxSwapInterval;        break;
 177       case EGL_LUMINANCE_SIZE:            *value = configuration->mLuminanceSize;          break;
 178       case EGL_ALPHA_MASK_SIZE:           *value = configuration->mAlphaMaskSize;          break;
 179       case EGL_COLOR_BUFFER_TYPE:         *value = configuration->mColorBufferType;        break;
 180       case EGL_RENDERABLE_TYPE:           *value = configuration->mRenderableType;         break;
 181       case EGL_MATCH_NATIVE_PIXMAP:       *value = false; UNIMPLEMENTED();                 break;
 182       case EGL_CONFORMANT:                *value = configuration->mConformant;             break;
 183       case EGL_MAX_PBUFFER_WIDTH:         *value = configuration->mMaxPBufferWidth;        break;
 184       case EGL_MAX_PBUFFER_HEIGHT:        *value = configuration->mMaxPBufferHeight;       break;
 185       case EGL_MAX_PBUFFER_PIXELS:        *value = configuration->mMaxPBufferPixels;       break;
 186       default:
 187         return false;
 188     }
 189
 190     return true;
 191 }
 192
 193
 194
 195 EGLSurface Display::createWindowSurface(HWND window, EGLConfig config, const EGLint *attribList)
 196 {
 197     const Config *configuration = mConfigSet.get(config);
 198     EGLint postSubBufferSupported = EGL_FALSE;
 199
 200     EGLint width = 0;
 201     EGLint height = 0;
 202     EGLint fixedSize = EGL_FALSE;
 203
 204     if (attribList)
 205     {
 206         while (*attribList != EGL_NONE)
 207         {
 208             switch (attribList[0])
 209             {
 210               case EGL_RENDER_BUFFER:
 211                 switch (attribList[1])
 212                 {
 213                   case EGL_BACK_BUFFER:
 214                     break;
 215                   case EGL_SINGLE_BUFFER:
 216                     return error(EGL_BAD_MATCH, EGL_NO_SURFACE);   // Rendering directly to front buffer not supported
 217                   default:
 218                     return error(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE);
 219                 }
 220                 break;
 221               case EGL_POST_SUB_BUFFER_SUPPORTED_NV:
 222                 postSubBufferSupported = attribList[1];
 223                 break;
 224               case EGL_WIDTH:
 225                 width = attribList[1];
 226                 break;
 227               case EGL_HEIGHT:
 228                 height = attribList[1];
 229                 break;
 230               case EGL_FIXED_SIZE_ANGLE:
 231                 fixedSize = attribList[1];
 232                 break;
 233               case EGL_VG_COLORSPACE:
 234                 return error(EGL_BAD_MATCH, EGL_NO_SURFACE);
 235               case EGL_VG_ALPHA_FORMAT:
 236                 return error(EGL_BAD_MATCH, EGL_NO_SURFACE);
 237               default:
 238                 return error(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE);
 239             }
 240
 241             attribList += 2;
 242         }
 243     }
 244
 245     if (width < 0 || height < 0)
 246     {
 247         return error(EGL_BAD_PARAMETER, EGL_NO_SURFACE);
 248     }
 249
 250     if (!fixedSize)
 251     {
 252         width = -1;
 253         height = -1;
 254     }
 255
 256     if (hasExistingWindowSurface(window))
 257     {
 258         return error(EGL_BAD_ALLOC, EGL_NO_SURFACE);
 259     }
 260
 261     if (mRenderer->testDeviceLost(false))
 262     {
 263         if (!restoreLostDevice())
 264             return EGL_NO_SURFACE;
 265     }
 266
 267     Surface *surface = new Surface(this, configuration, window, fixedSize, width, height, postSubBufferSupported);
 268
 269     if (!surface->initialize())
 270     {
 271         delete surface;
 272         return EGL_NO_SURFACE;
 273     }
 274
 275     mSurfaceSet.insert(surface);
 276
 277     return success(surface);
 278 }
 279
 280 EGLSurface Display::createOffscreenSurface(EGLConfig config, HANDLE shareHandle, const EGLint *attribList)
 281 {
 282     EGLint width = 0, height = 0;
 283     EGLenum textureFormat = EGL_NO_TEXTURE;
 284     EGLenum textureTarget = EGL_NO_TEXTURE;
 285     const Config *configuration = mConfigSet.get(config);
 286
 287     if (attribList)
 288     {
 289         while (*attribList != EGL_NONE)
 290         {
 291             switch (attribList[0])
 292             {
 293               case EGL_WIDTH:
 294                 width = attribList[1];
 295                 break;
 296               case EGL_HEIGHT:
 297                 height = attribList[1];
 298                 break;
 299               case EGL_LARGEST_PBUFFER:
 300                 if (attribList[1] != EGL_FALSE)
 301                   UNIMPLEMENTED(); // FIXME
 302                 break;
 303               case EGL_TEXTURE_FORMAT:
 304                 switch (attribList[1])
 305                 {
 306                   case EGL_NO_TEXTURE:
 307                   case EGL_TEXTURE_RGB:
 308                   case EGL_TEXTURE_RGBA:
 309                     textureFormat = attribList[1];
 310                     break;
 311                   default:
 312                     return error(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE);
 313                 }
 314                 break;
 315               case EGL_TEXTURE_TARGET:
 316                 switch (attribList[1])
 317                 {
 318                   case EGL_NO_TEXTURE:
 319                   case EGL_TEXTURE_2D:
 320                     textureTarget = attribList[1];
 321                     break;
 322                   default:
 323                     return error(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE);
 324                 }
 325                 break;
 326               case EGL_MIPMAP_TEXTURE:
 327                 if (attribList[1] != EGL_FALSE)
 328                   return error(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE);
 329                 break;
 330               case EGL_VG_COLORSPACE:
 331                 return error(EGL_BAD_MATCH, EGL_NO_SURFACE);
 332               case EGL_VG_ALPHA_FORMAT:
 333                 return error(EGL_BAD_MATCH, EGL_NO_SURFACE);
 334               default:
 335                 return error(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE);
 336             }
 337
 338             attribList += 2;
 339         }
 340     }
 341
 342     if (width < 0 || height < 0)
 343     {
 344         return error(EGL_BAD_PARAMETER, EGL_NO_SURFACE);
 345     }
 346
 347     if (width == 0 || height == 0)
 348     {
 349         return error(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE);
 350     }
 351
 352     if (textureFormat != EGL_NO_TEXTURE && !mRenderer->getRendererExtensions().textureNPOT && (!gl::isPow2(width) || !gl::isPow2(height)))
 353     {
 354         return error(EGL_BAD_MATCH, EGL_NO_SURFACE);
 355     }
 356
 357     if ((textureFormat != EGL_NO_TEXTURE && textureTarget == EGL_NO_TEXTURE) ||
 358         (textureFormat == EGL_NO_TEXTURE && textureTarget != EGL_NO_TEXTURE))
 359     {
 360         return error(EGL_BAD_MATCH, EGL_NO_SURFACE);
 361     }
 362
 363     if (!(configuration->mSurfaceType & EGL_PBUFFER_BIT))
 364     {
 365         return error(EGL_BAD_MATCH, EGL_NO_SURFACE);
 366     }
 367
 368     if ((textureFormat == EGL_TEXTURE_RGB && configuration->mBindToTextureRGB != EGL_TRUE) ||
 369         (textureFormat == EGL_TEXTURE_RGBA && configuration->mBindToTextureRGBA != EGL_TRUE))
 370     {
 371         return error(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE);
 372     }
 373
 374     if (mRenderer->testDeviceLost(false))
 375     {
 376         if (!restoreLostDevice())
 377             return EGL_NO_SURFACE;
 378     }
 379
 380     Surface *surface = new Surface(this, configuration, shareHandle, width, height, textureFormat, textureTarget);
 381
 382     if (!surface->initialize())
 383     {
 384         delete surface;
 385         return EGL_NO_SURFACE;
 386     }
 387
 388     mSurfaceSet.insert(surface);
 389
 390     return success(surface);
 391 }
 392
 393 EGLContext Display::createContext(EGLConfig configHandle, EGLint clientVersion, const gl::Context *shareContext, bool notifyResets, bool robustAccess)
 394 {
 395     if (!mRenderer)
 396     {
 397         return EGL_NO_CONTEXT;
 398     }
 399     else if (mRenderer->testDeviceLost(false))   // Lost device
 400     {
 401         if (!restoreLostDevice())
 402         {
 403             return error(EGL_CONTEXT_LOST, EGL_NO_CONTEXT);
 404         }
 405     }
 406
 407     if (clientVersion > 2 && mRenderer->getMajorShaderModel() < 4)
 408     {
 409         return error(EGL_BAD_CONFIG, EGL_NO_CONTEXT);
 410     }
 411
 412     gl::Context *context = glCreateContext(clientVersion, shareContext, mRenderer, notifyResets, robustAccess);
 413     mContextSet.insert(context);
 414
 415     return success(context);
 416 }
 417
 418 bool Display::restoreLostDevice()
 419 {
 420     for (ContextSet::iterator ctx = mContextSet.begin(); ctx != mContextSet.end(); ctx++)
 421     {
 422         if ((*ctx)->isResetNotificationEnabled())
 423             return false;   // If reset notifications have been requested, application must delete all contexts first
 424     }
 425
 426     // Release surface resources to make the Reset() succeed
 427     for (SurfaceSet::iterator surface = mSurfaceSet.begin(); surface != mSurfaceSet.end(); surface++)
 428     {
 429         (*surface)->release();
 430     }
 431
 432     if (!mRenderer->resetDevice())
 433     {
 434         return error(EGL_BAD_ALLOC, false);
 435     }
 436
 437     // Restore any surfaces that may have been lost
 438     for (SurfaceSet::iterator surface = mSurfaceSet.begin(); surface != mSurfaceSet.end(); surface++)
 439     {
 440         (*surface)->resetSwapChain();
 441     }
 442
 443     return true;
 444 }
 445
 446
 447 void Display::destroySurface(egl::Surface *surface)
 448 {
 449     delete surface;
 450     mSurfaceSet.erase(surface);
 451 }
 452
 453 void Display::destroyContext(gl::Context *context)
 454 {
 455     glDestroyContext(context);
 456     mContextSet.erase(context);
 457 }
 458
 459 void Display::notifyDeviceLost()
 460 {
 461     for (ContextSet::iterator context = mContextSet.begin(); context != mContextSet.end(); context++)
 462     {
 463         (*context)->markContextLost();
 464     }
 465     egl::error(EGL_CONTEXT_LOST);
 466 }
 467
 468 void Display::recreateSwapChains()
 469 {
 470     for (SurfaceSet::iterator surface = mSurfaceSet.begin(); surface != mSurfaceSet.end(); surface++)
 471     {
 472         (*surface)->getSwapChain()->recreate();
 473     }
 474 }
 475
 476 bool Display::isInitialized() const
 477 {
 478     return mRenderer != NULL && mConfigSet.size() > 0;
 479 }
 480
 481 bool Display::isValidConfig(EGLConfig config)
 482 {
 483     return mConfigSet.get(config) != NULL;
 484 }
 485
 486 bool Display::isValidContext(gl::Context *context)
 487 {
 488     return mContextSet.find(context) != mContextSet.end();
 489 }
 490
 491 bool Display::isValidSurface(egl::Surface *surface)
 492 {
 493     return mSurfaceSet.find(surface) != mSurfaceSet.end();
 494 }
 495
 496 bool Display::hasExistingWindowSurface(HWND window)
 497 {
 498     for (SurfaceSet::iterator surface = mSurfaceSet.begin(); surface != mSurfaceSet.end(); surface++)
 499     {
 500         if ((*surface)->getWindowHandle() == window)
 501         {
 502             return true;
 503         }
 504     }
 505
 506     return false;
 507 }
 508
 509 std::string Display::generateClientExtensionString()
 510 {
 511     std::vector<std::string> extensions;
 512
 513     extensions.push_back("EGL_EXT_client_extensions");
 514
 515     extensions.push_back("ANGLE_platform_angle");
 516
 517     if (supportsPlatformD3D())
 518     {
 519         extensions.push_back("ANGLE_platform_angle_d3d");
 520     }
 521
 522     if (supportsPlatformOpenGL())
 523     {
 524         extensions.push_back("ANGLE_platform_angle_opengl");
 525     }
 526
 527     std::ostringstream stream;
 528     std::copy(extensions.begin(), extensions.end(), std::ostream_iterator<std::string>(stream, " "));
 529     return stream.str();
 530 }
 531
 532 void Display::initDisplayExtensionString()
 533 {
 534     std::vector<std::string> extensions;
 535
 536     // Multi-vendor (EXT) extensions
 537     extensions.push_back("EGL_EXT_create_context_robustness");
 538
 539     // ANGLE-specific extensions
 540     if (mRenderer->getShareHandleSupport())
 541     {
 542         extensions.push_back("EGL_ANGLE_d3d_share_handle_client_buffer");
 543         extensions.push_back("EGL_ANGLE_surface_d3d_texture_2d_share_handle");
 544     }
 545
 546     extensions.push_back("EGL_ANGLE_query_surface_pointer");
 547     extensions.push_back("EGL_ANGLE_window_fixed_size");
 548
 549     if (mRenderer->getPostSubBufferSupport())
 550     {
 551         extensions.push_back("EGL_NV_post_sub_buffer");
 552     }
 553
 554     // TODO: complete support for the EGL_KHR_create_context extension
 555     extensions.push_back("EGL_KHR_create_context");
 556
 557     std::ostringstream stream;
 558     std::copy(extensions.begin(), extensions.end(), std::ostream_iterator<std::string>(stream, " "));
 559     mDisplayExtensionString = stream.str();
 560 }
 561
 562 const char *Display::getExtensionString(egl::Display *display)
 563 {
 564     if (display != EGL_NO_DISPLAY)
 565     {
 566         return display->mDisplayExtensionString.c_str();
 567     }
 568     else
 569     {
 570         static std::string clientExtensions = generateClientExtensionString();
 571         return clientExtensions.c_str();
 572     }
 573 }
 574
 575 bool Display::supportsPlatformD3D()
 576 {
 577 #if defined(ANGLE_ENABLE_D3D9) || defined(ANGLE_ENABLE_D3D11)
 578     return true;
 579 #else
 580     return false;
 581 #endif
 582 }
 583
 584 bool Display::supportsPlatformOpenGL()
 585 {
 586     return false;
 587 }
 588
 589 void Display::initVendorString()
 590 {
 591     mVendorString = "Google Inc.";
 592
 593     LUID adapterLuid = {0};
 594
 595     if (mRenderer && mRenderer->getLUID(&adapterLuid))
 596     {
 597         char adapterLuidString[64];
 598         sprintf_s(adapterLuidString, sizeof(adapterLuidString), " (adapter LUID: %08x%08x)", adapterLuid.HighPart, adapterLuid.LowPart);
 599
 600         mVendorString += adapterLuidString;
 601     }
 602 }
 603
 604 const char *Display::getVendorString() const
 605 {
 606     return mVendorString.c_str();
 607 }
 608
 609 }