Home | History | Annotate | Download | only in libEGL 
      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 }
    610