Home | History | Annotate | Download | only in EGL
      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 <ctype.h>
     22 #include <stdint.h>
     23 #include <stdlib.h>
     24 
     25 #include <EGL/egl.h>
     26 #include <EGL/eglext.h>
     27 
     28 #include <cutils/compiler.h>
     29 #include <utils/SortedVector.h>
     30 #include <utils/threads.h>
     31 #include <utils/String8.h>
     32 
     33 #include "egldefs.h"
     34 #include "../hooks.h"
     35 
     36 // ----------------------------------------------------------------------------
     37 namespace android {
     38 // ----------------------------------------------------------------------------
     39 
     40 class egl_object_t;
     41 class egl_context_t;
     42 class egl_connection_t;
     43 
     44 // ----------------------------------------------------------------------------
     45 
     46 class EGLAPI egl_display_t { // marked as EGLAPI for testing purposes
     47     static egl_display_t sDisplay[NUM_DISPLAYS];
     48     EGLDisplay getDisplay(EGLNativeDisplayType display);
     49     void loseCurrentImpl(egl_context_t * cur_c);
     50 
     51 public:
     52     enum {
     53         NOT_INITIALIZED = 0,
     54         INITIALIZED     = 1,
     55         TERMINATED      = 2
     56     };
     57 
     58     egl_display_t();
     59     ~egl_display_t();
     60 
     61     EGLBoolean initialize(EGLint *major, EGLint *minor);
     62     EGLBoolean terminate();
     63 
     64     // add object to this display's list
     65     void addObject(egl_object_t* object);
     66     // remove object from this display's list
     67     void removeObject(egl_object_t* object);
     68     // add reference to this object. returns true if this is a valid object.
     69     bool getObject(egl_object_t* object) const;
     70 
     71     // These notifications allow the display to keep track of how many window
     72     // surfaces exist, which it uses to decide whether to hibernate the
     73     // underlying EGL implementation. They can be called by any thread without
     74     // holding a lock, but must be called via egl_display_ptr to ensure
     75     // proper hibernate/wakeup sequencing. If a surface destruction triggers
     76     // hibernation, hibernation will be delayed at least until the calling
     77     // thread's egl_display_ptr is destroyed.
     78     void onWindowSurfaceCreated() {
     79         mHibernation.incWakeCount(HibernationMachine::STRONG);
     80     }
     81     void onWindowSurfaceDestroyed() {
     82         mHibernation.decWakeCount(HibernationMachine::STRONG);
     83     }
     84 
     85     static egl_display_t* get(EGLDisplay dpy);
     86     static EGLDisplay getFromNativeDisplay(EGLNativeDisplayType disp);
     87 
     88     EGLBoolean makeCurrent(egl_context_t* c, egl_context_t* cur_c,
     89             EGLSurface draw, EGLSurface read, EGLContext ctx,
     90             EGLSurface impl_draw, EGLSurface impl_read, EGLContext impl_ctx);
     91     static void loseCurrent(egl_context_t * cur_c);
     92 
     93     inline bool isReady() const { return (refs > 0); }
     94     inline bool isValid() const { return magic == '_dpy'; }
     95     inline bool isAlive() const { return isValid(); }
     96 
     97     char const * getVendorString() const { return mVendorString.string(); }
     98     char const * getVersionString() const { return mVersionString.string(); }
     99     char const * getClientApiString() const { return mClientApiString.string(); }
    100     char const * getExtensionString() const { return mExtensionString.string(); }
    101 
    102     bool haveExtension(const char* name, size_t nameLen = 0) const;
    103 
    104     inline uint32_t getRefsCount() const { return refs; }
    105 
    106     struct strings_t {
    107         char const * vendor;
    108         char const * version;
    109         char const * clientApi;
    110         char const * extensions;
    111     };
    112 
    113     struct DisplayImpl {
    114         DisplayImpl() : dpy(EGL_NO_DISPLAY), state(NOT_INITIALIZED) { }
    115         EGLDisplay  dpy;
    116         EGLint      state;
    117         strings_t   queryString;
    118     };
    119 
    120 private:
    121     uint32_t        magic;
    122 
    123 public:
    124     DisplayImpl     disp;
    125     bool    finishOnSwap;       // property: debug.egl.finish
    126     bool    traceGpuCompletion; // property: debug.egl.traceGpuCompletion
    127 
    128 private:
    129     friend class egl_display_ptr;
    130     bool enter() { return mHibernation.incWakeCount(HibernationMachine::WEAK); }
    131     void leave() { return mHibernation.decWakeCount(HibernationMachine::WEAK); }
    132 
    133             uint32_t                    refs;
    134     mutable Mutex                       lock;
    135             SortedVector<egl_object_t*> objects;
    136             String8 mVendorString;
    137             String8 mVersionString;
    138             String8 mClientApiString;
    139             String8 mExtensionString;
    140 
    141     // HibernationMachine uses its own internal mutex to protect its own data.
    142     // The owning egl_display_t's lock may be but is not required to be held
    143     // when calling HibernationMachine methods. As a result, nothing in this
    144     // class may call back up to egl_display_t directly or indirectly.
    145     class HibernationMachine {
    146     public:
    147         // STRONG refs cancel (inc) or initiate (dec) a hibernation attempt
    148         // the next time the wakecount reaches zero. WEAK refs don't affect
    149         // whether a hibernation attempt will be made. Use STRONG refs only
    150         // for infrequent/heavy changes that are likely to indicate the
    151         // EGLDisplay is entering or leaving a long-term idle state.
    152         enum WakeRefStrength {
    153             WEAK   = 0,
    154             STRONG = 1,
    155         };
    156 
    157         HibernationMachine(): mWakeCount(0), mHibernating(false),
    158                 mAttemptHibernation(false), mDpyValid(false),
    159 #if BOARD_ALLOW_EGL_HIBERNATION
    160                 mAllowHibernation(true)
    161 #else
    162                 mAllowHibernation(false)
    163 #endif
    164         {}
    165         ~HibernationMachine() {}
    166 
    167         bool incWakeCount(WakeRefStrength strenth);
    168         void decWakeCount(WakeRefStrength strenth);
    169 
    170         void setDisplayValid(bool valid);
    171 
    172     private:
    173         Mutex      mLock;
    174         int32_t    mWakeCount;
    175         bool       mHibernating;
    176         bool       mAttemptHibernation;
    177         bool       mDpyValid;
    178         const bool mAllowHibernation;
    179     };
    180     HibernationMachine mHibernation;
    181 };
    182 
    183 // ----------------------------------------------------------------------------
    184 
    185 // An egl_display_ptr is a kind of smart pointer for egl_display_t objects.
    186 // It doesn't refcount the egl_display_t, but does ensure that the underlying
    187 // EGL implementation is "awake" (not hibernating) and ready for use as long
    188 // as the egl_display_ptr exists.
    189 class egl_display_ptr {
    190 public:
    191     explicit egl_display_ptr(egl_display_t* dpy): mDpy(dpy) {
    192         if (mDpy) {
    193             if (CC_UNLIKELY(!mDpy->enter())) {
    194                 mDpy = NULL;
    195             }
    196         }
    197     }
    198 
    199     // We only really need a C++11 move constructor, not a copy constructor.
    200     // A move constructor would save an enter()/leave() pair on every EGL API
    201     // call. But enabling -std=c++0x causes lots of errors elsewhere, so I
    202     // can't use a move constructor until those are cleaned up.
    203     //
    204     // egl_display_ptr(egl_display_ptr&& other) {
    205     //     mDpy = other.mDpy;
    206     //     other.mDpy = NULL;
    207     // }
    208     //
    209     egl_display_ptr(const egl_display_ptr& other): mDpy(other.mDpy) {
    210         if (mDpy) {
    211             mDpy->enter();
    212         }
    213     }
    214 
    215     ~egl_display_ptr() {
    216         if (mDpy) {
    217             mDpy->leave();
    218         }
    219     }
    220 
    221     const egl_display_t* operator->() const { return mDpy; }
    222           egl_display_t* operator->()       { return mDpy; }
    223 
    224     const egl_display_t* get() const { return mDpy; }
    225           egl_display_t* get()       { return mDpy; }
    226 
    227     operator bool() const { return mDpy != NULL; }
    228 
    229 private:
    230     egl_display_t* mDpy;
    231 
    232     // non-assignable
    233     egl_display_ptr& operator=(const egl_display_ptr&);
    234 };
    235 
    236 // ----------------------------------------------------------------------------
    237 
    238 inline egl_display_ptr get_display(EGLDisplay dpy) {
    239     return egl_display_ptr(egl_display_t::get(dpy));
    240 }
    241 
    242 // Does not ensure EGL is unhibernated. Use with caution: calls into the
    243 // underlying EGL implementation are not safe.
    244 inline egl_display_t* get_display_nowake(EGLDisplay dpy) {
    245     return egl_display_t::get(dpy);
    246 }
    247 
    248 // ----------------------------------------------------------------------------
    249 
    250 egl_display_ptr validate_display(EGLDisplay dpy);
    251 egl_display_ptr validate_display_connection(EGLDisplay dpy,
    252         egl_connection_t*& cnx);
    253 EGLBoolean validate_display_context(EGLDisplay dpy, EGLContext ctx);
    254 EGLBoolean validate_display_surface(EGLDisplay dpy, EGLSurface surface);
    255 
    256 // ----------------------------------------------------------------------------
    257 }; // namespace android
    258 // ----------------------------------------------------------------------------
    259 
    260 #endif // ANDROID_EGL_DISPLAY_H
    261