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 bool needsAndroidPEglMitigation(); 47 48 // ---------------------------------------------------------------------------- 49 50 class EGLAPI egl_display_t { // marked as EGLAPI for testing purposes 51 static egl_display_t sDisplay[NUM_DISPLAYS]; 52 EGLDisplay getDisplay(EGLNativeDisplayType display); 53 EGLDisplay getPlatformDisplay(EGLNativeDisplayType display, const EGLAttrib* attrib_list); 54 void loseCurrentImpl(egl_context_t * cur_c); 55 56 public: 57 enum { 58 NOT_INITIALIZED = 0, 59 INITIALIZED = 1, 60 TERMINATED = 2 61 }; 62 63 egl_display_t(); 64 ~egl_display_t(); 65 66 EGLBoolean initialize(EGLint *major, EGLint *minor); 67 EGLBoolean terminate(); 68 69 // add object to this display's list 70 void addObject(egl_object_t* object); 71 // remove object from this display's list 72 void removeObject(egl_object_t* object); 73 // add reference to this object. returns true if this is a valid object. 74 bool getObject(egl_object_t* object) const; 75 76 static egl_display_t* get(EGLDisplay dpy); 77 static EGLDisplay getFromNativeDisplay(EGLNativeDisplayType disp, const EGLAttrib* attrib_list); 78 79 EGLBoolean makeCurrent(egl_context_t* c, egl_context_t* cur_c, 80 EGLSurface draw, EGLSurface read, EGLContext ctx, 81 EGLSurface impl_draw, EGLSurface impl_read, EGLContext impl_ctx); 82 static void loseCurrent(egl_context_t * cur_c); 83 84 inline bool isReady() const { return (refs > 0); } 85 inline bool isValid() const { return magic == '_dpy'; } 86 inline bool isAlive() const { return isValid(); } 87 88 char const * getVendorString() const { return mVendorString.c_str(); } 89 char const * getVersionString() const { return mVersionString.c_str(); } 90 char const * getClientApiString() const { return mClientApiString.c_str(); } 91 char const * getExtensionString() const { return mExtensionString.c_str(); } 92 93 bool haveExtension(const char* name, size_t nameLen = 0) const; 94 95 inline uint32_t getRefsCount() const { return refs; } 96 97 struct strings_t { 98 char const * vendor; 99 char const * version; 100 char const * clientApi; 101 char const * extensions; 102 }; 103 104 struct DisplayImpl { 105 DisplayImpl() : dpy(EGL_NO_DISPLAY), state(NOT_INITIALIZED) { } 106 EGLDisplay dpy; 107 EGLint state; 108 strings_t queryString; 109 }; 110 111 private: 112 uint32_t magic; 113 114 public: 115 DisplayImpl disp; 116 bool finishOnSwap; // property: debug.egl.finish 117 bool traceGpuCompletion; // property: debug.egl.traceGpuCompletion 118 bool hasColorSpaceSupport; 119 120 private: 121 friend class egl_display_ptr; 122 123 uint32_t refs; 124 bool eglIsInitialized; 125 mutable std::mutex lock; 126 mutable std::mutex refLock; 127 mutable std::condition_variable refCond; 128 std::unordered_set<egl_object_t*> objects; 129 std::string mVendorString; 130 std::string mVersionString; 131 std::string mClientApiString; 132 std::string mExtensionString; 133 }; 134 135 // ---------------------------------------------------------------------------- 136 137 // An egl_display_ptr is a kind of smart pointer for egl_display_t objects. 138 // It doesn't refcount the egl_display_t, but does ensure that the underlying 139 // EGL implementation is "awake" (not hibernating) and ready for use as long 140 // as the egl_display_ptr exists. 141 class egl_display_ptr { 142 public: 143 explicit egl_display_ptr(egl_display_t* dpy): mDpy(dpy) {} 144 145 // We only really need a C++11 move constructor, not a copy constructor. 146 // A move constructor would save an enter()/leave() pair on every EGL API 147 // call. But enabling -std=c++0x causes lots of errors elsewhere, so I 148 // can't use a move constructor until those are cleaned up. 149 // 150 // egl_display_ptr(egl_display_ptr&& other) { 151 // mDpy = other.mDpy; 152 // other.mDpy = NULL; 153 // } 154 // 155 egl_display_ptr(const egl_display_ptr& other): mDpy(other.mDpy) {} 156 157 ~egl_display_ptr() {} 158 159 const egl_display_t* operator->() const { return mDpy; } 160 egl_display_t* operator->() { return mDpy; } 161 162 const egl_display_t* get() const { return mDpy; } 163 egl_display_t* get() { return mDpy; } 164 165 operator bool() const { return mDpy != nullptr; } 166 167 private: 168 egl_display_t* mDpy; 169 170 // non-assignable 171 egl_display_ptr& operator=(const egl_display_ptr&); 172 }; 173 174 // ---------------------------------------------------------------------------- 175 176 inline egl_display_ptr get_display(EGLDisplay dpy) { 177 return egl_display_ptr(egl_display_t::get(dpy)); 178 } 179 180 // Does not ensure EGL is unhibernated. Use with caution: calls into the 181 // underlying EGL implementation are not safe. 182 inline egl_display_t* get_display_nowake(EGLDisplay dpy) { 183 return egl_display_t::get(dpy); 184 } 185 186 // ---------------------------------------------------------------------------- 187 188 egl_display_ptr validate_display(EGLDisplay dpy); 189 egl_display_ptr validate_display_connection(EGLDisplay dpy, 190 egl_connection_t*& cnx); 191 EGLBoolean validate_display_context(EGLDisplay dpy, EGLContext ctx); 192 EGLBoolean validate_display_surface(EGLDisplay dpy, EGLSurface surface); 193 194 // ---------------------------------------------------------------------------- 195 }; // namespace android 196 // ---------------------------------------------------------------------------- 197 198 #endif // ANDROID_EGL_DISPLAY_H 199
