1 /* 2 ** Copyright 2007, The Android Open Source Project 3 ** 4 ** Licensed under the Apache License, Version 2.0 (the "License"); 5 ** you may not use this file except in compliance with the License. 6 ** You may obtain a copy of the License at 7 ** 8 ** http://www.apache.org/licenses/LICENSE-2.0 9 ** 10 ** Unless required by applicable law or agreed to in writing, software 11 ** distributed under the License is distributed on an "AS IS" BASIS, 12 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 ** See the License for the specific language governing permissions and 14 ** limitations under the License. 15 */ 16 17 #ifndef ANDROID_EGL_DISPLAY_H 18 #define ANDROID_EGL_DISPLAY_H 19 20 21 #include <stdint.h> 22 #include <stddef.h> 23 24 #include <condition_variable> 25 #include <mutex> 26 #include <string> 27 #include <unordered_set> 28 29 #include <EGL/egl.h> 30 #include <EGL/eglext.h> 31 32 #include <cutils/compiler.h> 33 34 #include "egldefs.h" 35 #include "../hooks.h" 36 37 // ---------------------------------------------------------------------------- 38 namespace android { 39 // ---------------------------------------------------------------------------- 40 41 class egl_object_t; 42 class egl_context_t; 43 struct egl_connection_t; 44 45 bool findExtension(const char* exts, const char* name, size_t nameLen = 0); 46 47 // ---------------------------------------------------------------------------- 48 49 class EGLAPI egl_display_t { // marked as EGLAPI for testing purposes 50 static egl_display_t sDisplay[NUM_DISPLAYS]; 51 EGLDisplay getDisplay(EGLNativeDisplayType display); 52 void loseCurrentImpl(egl_context_t * cur_c); 53 54 public: 55 enum { 56 NOT_INITIALIZED = 0, 57 INITIALIZED = 1, 58 TERMINATED = 2 59 }; 60 61 egl_display_t(); 62 ~egl_display_t(); 63 64 EGLBoolean initialize(EGLint *major, EGLint *minor); 65 EGLBoolean terminate(); 66 67 // add object to this display's list 68 void addObject(egl_object_t* object); 69 // remove object from this display's list 70 void removeObject(egl_object_t* object); 71 // add reference to this object. returns true if this is a valid object. 72 bool getObject(egl_object_t* object) const; 73 74 static egl_display_t* get(EGLDisplay dpy); 75 static EGLDisplay getFromNativeDisplay(EGLNativeDisplayType disp); 76 77 EGLBoolean makeCurrent(egl_context_t* c, egl_context_t* cur_c, 78 EGLSurface draw, EGLSurface read, EGLContext ctx, 79 EGLSurface impl_draw, EGLSurface impl_read, EGLContext impl_ctx); 80 static void loseCurrent(egl_context_t * cur_c); 81 82 inline bool isReady() const { return (refs > 0); } 83 inline bool isValid() const { return magic == '_dpy'; } 84 inline bool isAlive() const { return isValid(); } 85 86 char const * getVendorString() const { return mVendorString.c_str(); } 87 char const * getVersionString() const { return mVersionString.c_str(); } 88 char const * getClientApiString() const { return mClientApiString.c_str(); } 89 char const * getExtensionString() const { return mExtensionString.c_str(); } 90 91 bool haveExtension(const char* name, size_t nameLen = 0) const; 92 93 inline uint32_t getRefsCount() const { return refs; } 94 95 struct strings_t { 96 char const * vendor; 97 char const * version; 98 char const * clientApi; 99 char const * extensions; 100 }; 101 102 struct DisplayImpl { 103 DisplayImpl() : dpy(EGL_NO_DISPLAY), state(NOT_INITIALIZED) { } 104 EGLDisplay dpy; 105 EGLint state; 106 strings_t queryString; 107 }; 108 109 private: 110 uint32_t magic; 111 112 public: 113 DisplayImpl disp; 114 bool finishOnSwap; // property: debug.egl.finish 115 bool traceGpuCompletion; // property: debug.egl.traceGpuCompletion 116 bool hasColorSpaceSupport; 117 118 private: 119 friend class egl_display_ptr; 120 121 uint32_t refs; 122 bool eglIsInitialized; 123 mutable std::mutex lock; 124 mutable std::mutex refLock; 125 mutable std::condition_variable refCond; 126 std::unordered_set<egl_object_t*> objects; 127 std::string mVendorString; 128 std::string mVersionString; 129 std::string mClientApiString; 130 std::string mExtensionString; 131 }; 132 133 // ---------------------------------------------------------------------------- 134 135 // An egl_display_ptr is a kind of smart pointer for egl_display_t objects. 136 // It doesn't refcount the egl_display_t, but does ensure that the underlying 137 // EGL implementation is "awake" (not hibernating) and ready for use as long 138 // as the egl_display_ptr exists. 139 class egl_display_ptr { 140 public: 141 explicit egl_display_ptr(egl_display_t* dpy): mDpy(dpy) {} 142 143 // We only really need a C++11 move constructor, not a copy constructor. 144 // A move constructor would save an enter()/leave() pair on every EGL API 145 // call. But enabling -std=c++0x causes lots of errors elsewhere, so I 146 // can't use a move constructor until those are cleaned up. 147 // 148 // egl_display_ptr(egl_display_ptr&& other) { 149 // mDpy = other.mDpy; 150 // other.mDpy = NULL; 151 // } 152 // 153 egl_display_ptr(const egl_display_ptr& other): mDpy(other.mDpy) {} 154 155 ~egl_display_ptr() {} 156 157 const egl_display_t* operator->() const { return mDpy; } 158 egl_display_t* operator->() { return mDpy; } 159 160 const egl_display_t* get() const { return mDpy; } 161 egl_display_t* get() { return mDpy; } 162 163 operator bool() const { return mDpy != NULL; } 164 165 private: 166 egl_display_t* mDpy; 167 168 // non-assignable 169 egl_display_ptr& operator=(const egl_display_ptr&); 170 }; 171 172 // ---------------------------------------------------------------------------- 173 174 inline egl_display_ptr get_display(EGLDisplay dpy) { 175 return egl_display_ptr(egl_display_t::get(dpy)); 176 } 177 178 // Does not ensure EGL is unhibernated. Use with caution: calls into the 179 // underlying EGL implementation are not safe. 180 inline egl_display_t* get_display_nowake(EGLDisplay dpy) { 181 return egl_display_t::get(dpy); 182 } 183 184 // ---------------------------------------------------------------------------- 185 186 egl_display_ptr validate_display(EGLDisplay dpy); 187 egl_display_ptr validate_display_connection(EGLDisplay dpy, 188 egl_connection_t*& cnx); 189 EGLBoolean validate_display_context(EGLDisplay dpy, EGLContext ctx); 190 EGLBoolean validate_display_surface(EGLDisplay dpy, EGLSurface surface); 191 192 // ---------------------------------------------------------------------------- 193 }; // namespace android 194 // ---------------------------------------------------------------------------- 195 196 #endif // ANDROID_EGL_DISPLAY_H 197
