code.vuplus.com Git - vuplus_webkit/blob - Source/WebCore/platform/graphics/openvg/EGLDisplayOpenVG.cpp

   1 /*
   2  * Copyright (C) Research In Motion Limited 2009-2010. All rights reserved.
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public License
  15  * along with this library; see the file COPYING.LIB.  If not, write to
  16  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  17  * Boston, MA 02110-1301, USA.
  18  */
  19
  20 #include "config.h"
  21 #include "EGLDisplayOpenVG.h"
  22
  23 #include "EGLUtils.h"
  24 #include "IntSize.h"
  25 #include "SurfaceOpenVG.h"
  26
  27 #include <wtf/Assertions.h>
  28 #include <wtf/StdLibExtras.h>
  29
  30 namespace WebCore {
  31
  32 // Need to typedef this, otherwise DEFINE_STATIC_LOCAL() doesn't swallow it.
  33 typedef HashMap<EGLDisplay, EGLDisplayOpenVG*> EGLDisplayManagerMap;
  34
  35 // File-static variables.
  36 static EGLDisplayManagerMap& displayManagers()
  37 {
  38     DEFINE_STATIC_LOCAL(EGLDisplayManagerMap, managers, ());
  39     return managers;
  40 }
  41
  42 static EGLDisplayOpenVG* s_current = 0;
  43
  44 // Static class members.
  45
  46 SurfaceOpenVG* EGLDisplayOpenVG::currentSurface()
  47 {
  48     EGLDisplayManagerMap& managers = displayManagers();
  49     EGLDisplay currentDisplay = eglGetCurrentDisplay();
  50
  51     if (currentDisplay == EGL_NO_DISPLAY || !managers.contains(currentDisplay))
  52         return 0;
  53
  54     EGLDisplayOpenVG* displayManager = managers.get(currentDisplay);
  55     EGLSurface currentSurface = eglGetCurrentSurface(EGL_DRAW);
  56
  57     if (currentSurface == EGL_NO_SURFACE || !displayManager->m_platformSurfaces.contains(currentSurface))
  58         return 0;
  59
  60     return displayManager->m_platformSurfaces.get(currentSurface);
  61 }
  62
  63 void EGLDisplayOpenVG::registerPlatformSurface(SurfaceOpenVG* platformSurface)
  64 {
  65     EGLDisplayOpenVG* displayManager = EGLDisplayOpenVG::forDisplay(platformSurface->eglDisplay());
  66     displayManager->m_platformSurfaces.set(platformSurface->eglSurface(), platformSurface);
  67 }
  68
  69 void EGLDisplayOpenVG::unregisterPlatformSurface(SurfaceOpenVG* platformSurface)
  70 {
  71     EGLDisplayOpenVG* displayManager = EGLDisplayOpenVG::forDisplay(platformSurface->eglDisplay());
  72     displayManager->m_platformSurfaces.remove(platformSurface->eglSurface());
  73 }
  74
  75 void EGLDisplayOpenVG::setCurrentDisplay(const EGLDisplay& display)
  76 {
  77     s_current = EGLDisplayOpenVG::forDisplay(display);
  78 }
  79
  80 EGLDisplayOpenVG* EGLDisplayOpenVG::current()
  81 {
  82     if (!s_current) {
  83         EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
  84         eglInitialize(display, 0, 0);
  85         ASSERT_EGL_NO_ERROR();
  86
  87         s_current = EGLDisplayOpenVG::forDisplay(display);
  88     }
  89     return s_current;
  90 }
  91
  92 EGLDisplayOpenVG* EGLDisplayOpenVG::forDisplay(const EGLDisplay& display)
  93 {
  94     EGLDisplayManagerMap& managers = displayManagers();
  95
  96     if (!managers.contains(display))
  97         managers.set(display, new EGLDisplayOpenVG(display));
  98
  99     return managers.get(display);
 100 }
 101
 102
 103 // Object/instance members.
 104
 105 EGLDisplayOpenVG::EGLDisplayOpenVG(const EGLDisplay& display)
 106     : m_display(display)
 107     , m_sharedPlatformSurface(0)
 108     , m_pbufferConfigId(0)
 109     , m_windowConfigId(0)
 110 {
 111     eglBindAPI(EGL_OPENVG_API);
 112     ASSERT_EGL_NO_ERROR();
 113 }
 114
 115 EGLDisplayOpenVG::~EGLDisplayOpenVG()
 116 {
 117     eglMakeCurrent(m_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
 118     ASSERT_EGL_NO_ERROR();
 119
 120     delete m_sharedPlatformSurface;
 121
 122     HashMap<EGLSurface, EGLint>::const_iterator end = m_surfaceConfigIds.end();
 123     for (HashMap<EGLSurface, EGLint>::const_iterator it = m_surfaceConfigIds.begin(); it != end; ++it)
 124         destroySurface((*it).first);
 125
 126     eglTerminate(m_display);
 127     ASSERT_EGL_NO_ERROR();
 128 }
 129
 130 void EGLDisplayOpenVG::setDefaultPbufferConfig(const EGLConfig& config)
 131 {
 132     EGLint configId;
 133     EGLBoolean success = eglGetConfigAttrib(m_display, config, EGL_CONFIG_ID, &configId);
 134     ASSERT(success == EGL_TRUE);
 135     ASSERT(configId != EGL_BAD_ATTRIBUTE);
 136
 137     m_pbufferConfigId = configId;
 138 }
 139
 140 EGLConfig EGLDisplayOpenVG::defaultPbufferConfig()
 141 {
 142     EGLConfig config;
 143     EGLint numConfigs;
 144
 145     // Hopefully the client will have set the pbuffer config of its choice
 146     // by now - if not, use a 32-bit generic one as default.
 147     if (!m_pbufferConfigId) {
 148         static const EGLint configAttribs[] = {
 149             EGL_RED_SIZE, 8,
 150             EGL_GREEN_SIZE, 8,
 151             EGL_BLUE_SIZE, 8,
 152             EGL_ALPHA_SIZE, 8,
 153             EGL_ALPHA_MASK_SIZE, 1,
 154             EGL_LUMINANCE_SIZE, EGL_DONT_CARE,
 155             EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
 156             EGL_RENDERABLE_TYPE, EGL_OPENVG_BIT,
 157             EGL_NONE
 158         };
 159         eglChooseConfig(m_display, configAttribs, &config, 1, &numConfigs);
 160     } else {
 161         const EGLint configAttribs[] = {
 162             EGL_CONFIG_ID, m_pbufferConfigId,
 163             EGL_NONE
 164         };
 165         eglChooseConfig(m_display, configAttribs, &config, 1, &numConfigs);
 166     }
 167
 168     ASSERT_EGL_NO_ERROR();
 169     ASSERT(numConfigs == 1);
 170     return config;
 171 }
 172
 173 void EGLDisplayOpenVG::setDefaultWindowConfig(const EGLConfig& config)
 174 {
 175     EGLint configId;
 176     EGLBoolean success = eglGetConfigAttrib(m_display, config, EGL_CONFIG_ID, &configId);
 177     ASSERT(success == EGL_TRUE);
 178     ASSERT(configId != EGL_BAD_ATTRIBUTE);
 179
 180     m_windowConfigId = configId;
 181 }
 182
 183 EGLConfig EGLDisplayOpenVG::defaultWindowConfig()
 184 {
 185     EGLConfig config;
 186     EGLint numConfigs;
 187
 188     // Hopefully the client will have set the window config of its choice
 189     // by now - if not, use a 32-bit generic one as default.
 190     if (!m_windowConfigId) {
 191         static const EGLint configAttribs[] = {
 192             EGL_RED_SIZE, 8,
 193             EGL_GREEN_SIZE, 8,
 194             EGL_BLUE_SIZE, 8,
 195             EGL_ALPHA_SIZE, 8,
 196             EGL_ALPHA_MASK_SIZE, 1,
 197             EGL_LUMINANCE_SIZE, EGL_DONT_CARE,
 198             EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
 199             EGL_RENDERABLE_TYPE, EGL_OPENVG_BIT,
 200             EGL_NONE
 201         };
 202         eglChooseConfig(m_display, configAttribs, &config, 1, &numConfigs);
 203     } else {
 204         const EGLint configAttribs[] = {
 205             EGL_CONFIG_ID, m_windowConfigId,
 206             EGL_NONE
 207         };
 208         eglChooseConfig(m_display, configAttribs, &config, 1, &numConfigs);
 209     }
 210
 211     ASSERT_EGL_NO_ERROR();
 212     ASSERT(numConfigs == 1);
 213     return config;
 214 }
 215
 216 SurfaceOpenVG* EGLDisplayOpenVG::sharedPlatformSurface()
 217 {
 218     if (!m_sharedPlatformSurface) {
 219         // The shared surface doesn't need to be drawn on, it just exists so
 220         // that we can always make the shared context current (which in turn is
 221         // the owner of long-living resources such as images, paths and fonts).
 222         // We'll just make the shared surface as small as possible: 1x1 pixel.
 223         EGLConfig config = defaultPbufferConfig();
 224         EGLSurface surface = createPbufferSurface(IntSize(1, 1), config);
 225
 226         EGLContext context = eglCreateContext(m_display, config, EGL_NO_CONTEXT, 0);
 227         ASSERT_EGL_NO_ERROR();
 228         m_contexts.set(m_surfaceConfigIds.get(surface), context);
 229
 230         m_sharedPlatformSurface = new SurfaceOpenVG;
 231         m_sharedPlatformSurface->m_eglDisplay = m_display;
 232         m_sharedPlatformSurface->m_eglSurface = surface;
 233         m_sharedPlatformSurface->m_eglContext = context;
 234         m_platformSurfaces.set(surface, m_sharedPlatformSurface); // a.k.a. registerPlatformSurface()
 235     }
 236     return m_sharedPlatformSurface;
 237 }
 238
 239 EGLSurface EGLDisplayOpenVG::createPbufferSurface(const IntSize& size, const EGLConfig& config, EGLint* errorCode)
 240 {
 241     const EGLint attribList[] = {
 242         EGL_WIDTH, size.width(),
 243         EGL_HEIGHT, size.height(),
 244         EGL_NONE
 245     };
 246     EGLSurface surface = eglCreatePbufferSurface(m_display, config, attribList);
 247
 248     if (errorCode)
 249         *errorCode = eglGetError();
 250     else
 251         ASSERT_EGL_NO_ERROR();
 252
 253     if (surface == EGL_NO_SURFACE)
 254         return EGL_NO_SURFACE;
 255
 256     EGLint surfaceConfigId;
 257     EGLBoolean success = eglGetConfigAttrib(m_display, config, EGL_CONFIG_ID, &surfaceConfigId);
 258     ASSERT(success == EGL_TRUE);
 259     ASSERT(surfaceConfigId != EGL_BAD_ATTRIBUTE);
 260
 261     ASSERT(!m_surfaceConfigIds.contains(surface));
 262     m_surfaceConfigIds.set(surface, surfaceConfigId);
 263     return surface;
 264 }
 265
 266 EGLSurface EGLDisplayOpenVG::createPbufferFromClientBuffer(
 267     EGLClientBuffer clientBuffer, EGLenum bufferType, const EGLConfig& config, EGLint* errorCode)
 268 {
 269     EGLSurface surface = eglCreatePbufferFromClientBuffer(m_display,
 270         bufferType, clientBuffer, config, 0 /* attribList */);
 271
 272     if (errorCode)
 273         *errorCode = eglGetError();
 274     else
 275         ASSERT_EGL_NO_ERROR();
 276
 277     if (surface == EGL_NO_SURFACE)
 278         return EGL_NO_SURFACE;
 279
 280     EGLint surfaceConfigId;
 281     EGLBoolean success = eglGetConfigAttrib(m_display, config, EGL_CONFIG_ID, &surfaceConfigId);
 282     ASSERT(success == EGL_TRUE);
 283     ASSERT(surfaceConfigId != EGL_BAD_ATTRIBUTE);
 284
 285     ASSERT(!m_surfaceConfigIds.contains(surface));
 286     m_surfaceConfigIds.set(surface, surfaceConfigId);
 287     return surface;
 288 }
 289
 290 EGLSurface EGLDisplayOpenVG::surfaceForWindow(EGLNativeWindowType wId, const EGLConfig& config)
 291 {
 292     if (m_windowSurfaces.contains(wId))
 293         return m_windowSurfaces.get(wId);
 294
 295     EGLSurface surface = eglCreateWindowSurface(m_display, config, wId, 0);
 296     ASSERT_EGL_NO_ERROR();
 297
 298     EGLint surfaceConfigId;
 299     EGLBoolean success = eglGetConfigAttrib(m_display, config, EGL_CONFIG_ID, &surfaceConfigId);
 300     ASSERT(success == EGL_TRUE);
 301     ASSERT(surfaceConfigId != EGL_BAD_ATTRIBUTE);
 302
 303     ASSERT(!m_surfaceConfigIds.contains(surface));
 304     m_surfaceConfigIds.set(surface, surfaceConfigId);
 305     return surface;
 306 }
 307
 308 bool EGLDisplayOpenVG::surfacesCompatible(const EGLSurface& surface, const EGLSurface& otherSurface)
 309 {
 310     if (surface == EGL_NO_SURFACE || otherSurface == EGL_NO_SURFACE)
 311         return false;
 312
 313     // Currently, we assume that all surfaces known to this object are
 314     // context-compatible to each other (which is reasonable to assume,
 315     // otherwise eglCreateContext() would fail with EGL_BAD_MATCH for shared
 316     // context compatibility anyways.
 317     return m_surfaceConfigIds.contains(surface) && m_surfaceConfigIds.contains(otherSurface);
 318 }
 319
 320 void EGLDisplayOpenVG::destroySurface(const EGLSurface& surface)
 321 {
 322     ASSERT(surface != EGL_NO_SURFACE);
 323
 324     if (eglGetCurrentSurface(EGL_DRAW) == surface) {
 325         eglMakeCurrent(m_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
 326         ASSERT_EGL_NO_ERROR();
 327     }
 328
 329     // Destroy the context associated to the surface, if we already created one.
 330     if (m_surfaceConfigIds.contains(surface)) {
 331         EGLint surfaceConfigId = m_surfaceConfigIds.take(surface); // take = get and remove
 332         bool isContextReferenced = false;
 333
 334         if (m_compatibleConfigIds.contains(surfaceConfigId))
 335             surfaceConfigId = m_compatibleConfigIds.get(surfaceConfigId);
 336
 337         HashMap<EGLSurface, EGLint>::iterator end = m_surfaceConfigIds.end();
 338
 339         // ...but only if there's no other surfaces associated to that context.
 340         for (HashMap<EGLSurface, EGLint>::iterator it = m_surfaceConfigIds.begin(); it != end; ++it) {
 341             if ((*it).second == surfaceConfigId) {
 342                 isContextReferenced = true;
 343                 break;
 344             }
 345         }
 346         if (!isContextReferenced && m_contexts.contains(surfaceConfigId)) {
 347             EGLContext context = m_contexts.take(surfaceConfigId);
 348             eglDestroyContext(m_display, context);
 349             ASSERT_EGL_NO_ERROR();
 350         }
 351     }
 352
 353     m_platformSurfaces.remove(surface);
 354
 355     HashMap<EGLNativeWindowType, EGLSurface>::iterator end = m_windowSurfaces.end();
 356     for (HashMap<EGLNativeWindowType, EGLSurface>::iterator it = m_windowSurfaces.begin(); it != end; ++it) {
 357         if ((*it).second == surface) {
 358             m_windowSurfaces.remove(it);
 359             break;
 360         }
 361     }
 362
 363     eglDestroySurface(m_display, surface);
 364     ASSERT_EGL_NO_ERROR();
 365 }
 366
 367 EGLContext EGLDisplayOpenVG::contextForSurface(const EGLSurface& surface)
 368 {
 369     ASSERT(surface != EGL_NO_SURFACE);
 370
 371     if (m_platformSurfaces.contains(surface))
 372         return m_platformSurfaces.get(surface)->eglContext();
 373
 374     eglBindAPI(EGL_OPENVG_API);
 375     ASSERT_EGL_NO_ERROR();
 376
 377     EGLint surfaceConfigId;
 378
 379     if (m_surfaceConfigIds.contains(surface))
 380         surfaceConfigId = m_surfaceConfigIds.get(surface);
 381     else {
 382         // Retrieve the same EGL config for context creation that was used to
 383         // create the the EGL surface.
 384         EGLBoolean success = eglQuerySurface(m_display, surface, EGL_CONFIG_ID, &surfaceConfigId);
 385         ASSERT(success == EGL_TRUE);
 386         ASSERT(surfaceConfigId != EGL_BAD_ATTRIBUTE);
 387
 388         m_surfaceConfigIds.set(surface, surfaceConfigId);
 389     }
 390
 391     if (m_compatibleConfigIds.contains(surfaceConfigId))
 392         surfaceConfigId = m_compatibleConfigIds.get(surfaceConfigId);
 393
 394     if (m_contexts.contains(surfaceConfigId))
 395         return m_contexts.get(surfaceConfigId);
 396
 397     if (!m_sharedPlatformSurface) // shared context has not been created yet
 398         sharedPlatformSurface(); // creates the shared surface & context
 399
 400     EGLDisplay currentDisplay = eglGetCurrentDisplay();
 401     EGLSurface currentReadSurface = eglGetCurrentSurface(EGL_READ);
 402     EGLSurface currentDrawSurface = eglGetCurrentSurface(EGL_DRAW);
 403     EGLContext currentContext = eglGetCurrentContext();
 404
 405     // Before creating a new context, let's try whether an existing one
 406     // is compatible with the surface. EGL doesn't give us a different way
 407     // to check context/surface compatibility than trying it out, so let's
 408     // do just that.
 409     HashMap<EGLint, EGLContext>::iterator end = m_contexts.end();
 410
 411     for (HashMap<EGLint, EGLContext>::iterator it = m_contexts.begin(); it != end; ++it) {
 412         eglMakeCurrent(m_display, surface, surface, (*it).second);
 413         if (eglGetError() == EGL_SUCCESS) {
 414             // Restore previous surface/context.
 415             if (currentContext != EGL_NO_CONTEXT) {
 416                 eglMakeCurrent(currentDisplay, currentReadSurface, currentDrawSurface, currentContext);
 417                 ASSERT_EGL_NO_ERROR();
 418             }
 419             // Cool, surface is compatible to one of our existing contexts.
 420             m_compatibleConfigIds.set(surfaceConfigId, (*it).first);
 421             return (*it).second;
 422         }
 423     }
 424     // Restore previous surface/context.
 425     if (currentContext != EGL_NO_CONTEXT) {
 426         eglMakeCurrent(currentDisplay, currentReadSurface, currentDrawSurface, currentContext);
 427         ASSERT_EGL_NO_ERROR();
 428     }
 429
 430     EGLConfig config;
 431     EGLint numConfigs;
 432
 433     const EGLint configAttribs[] = {
 434         EGL_CONFIG_ID, surfaceConfigId,
 435         EGL_NONE
 436     };
 437
 438     eglChooseConfig(m_display, configAttribs, &config, 1, &numConfigs);
 439     ASSERT_EGL_NO_ERROR();
 440     ASSERT(numConfigs == 1);
 441
 442     // We share all of the images and paths amongst the different contexts,
 443     // so that they can be used in all of them. Resources that are created
 444     // while m_sharedPlatformSurface->context() is current will be
 445     // accessible from all other contexts, but are not restricted to the
 446     // lifetime of those contexts.
 447     EGLContext context = eglCreateContext(m_display, config, m_sharedPlatformSurface->eglContext(), 0);
 448     ASSERT_EGL_NO_ERROR();
 449
 450     ASSERT(!m_contexts.contains(surfaceConfigId));
 451     m_contexts.set(surfaceConfigId, context);
 452     return context;
 453 }
 454
 455 }