egl_object.h revision 32397c1cd3327905173b36baa6fd1c579bc328ff 
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_OBJECT_H
18#define ANDROID_EGL_OBJECT_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#include <GLES/gl.h>
28#include <GLES/glext.h>
29
30#include <utils/threads.h>
31
32#include <system/window.h>
33
34#include "egl_display.h"
35
36// ----------------------------------------------------------------------------
37namespace android {
38// ----------------------------------------------------------------------------
39
40struct egl_display_t;
41
42class egl_object_t {
43    egl_display_t *display;
44    mutable volatile int32_t count;
45
46protected:
47    virtual ~egl_object_t();
48
49public:
50    egl_object_t(egl_display_t* display);
51    void destroy();
52
53    inline int32_t incRef() { return android_atomic_inc(&count); }
54    inline int32_t decRef() { return android_atomic_dec(&count); }
55    inline egl_display_t* getDisplay() const { return display; }
56
57private:
58    void terminate();
59    static bool get(egl_display_t const* display, egl_object_t* object);
60
61public:
62    template <typename N, typename T>
63    class LocalRef {
64        egl_object_t* ref;
65        LocalRef();
66        LocalRef(const LocalRef* rhs);
67    public:
68        ~LocalRef();
69        explicit LocalRef(egl_object_t* rhs);
70        explicit LocalRef(egl_display_t const* display, T o) : ref(0) {
71            egl_object_t* native = reinterpret_cast<N*>(o);
72            if (o && egl_object_t::get(display, native)) {
73                ref = native;
74            }
75        }
76        inline N* get() {
77            return static_cast<N*>(ref);
78        }
79        void acquire() const;
80        void release() const;
81        void terminate();
82    };
83    template <typename N, typename T>
84    friend class LocalRef;
85};
86
87template<typename N, typename T>
88egl_object_t::LocalRef<N, T>::LocalRef(egl_object_t* rhs) : ref(rhs) {
89    if (ref) {
90        ref->incRef();
91    }
92}
93
94template <typename N, typename T>
95egl_object_t::LocalRef<N,T>::~LocalRef() {
96    if (ref) {
97        ref->destroy();
98    }
99}
100
101template <typename N, typename T>
102void egl_object_t::LocalRef<N,T>::acquire() const {
103    if (ref) {
104        ref->incRef();
105    }
106}
107
108template <typename N, typename T>
109void egl_object_t::LocalRef<N,T>::release() const {
110    if (ref) {
111        if (ref->decRef() == 1) {
112            // shouldn't happen because this is called from LocalRef
113            LOGE("LocalRef::release() removed the last reference!");
114        }
115    }
116}
117
118template <typename N, typename T>
119void egl_object_t::LocalRef<N,T>::terminate() {
120    if (ref) {
121        ref->terminate();
122    }
123}
124
125// ----------------------------------------------------------------------------
126
127class egl_surface_t: public egl_object_t {
128protected:
129    ~egl_surface_t() {
130        ANativeWindow* const window = win.get();
131        if (window != NULL) {
132            native_window_set_buffers_format(window, 0);
133            if (native_window_api_disconnect(window, NATIVE_WINDOW_API_EGL)) {
134                ALOGW("EGLNativeWindowType %p disconnect failed", window);
135            }
136        }
137    }
138public:
139    typedef egl_object_t::LocalRef<egl_surface_t, EGLSurface> Ref;
140
141    egl_surface_t(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win,
142            EGLSurface surface, int impl, egl_connection_t const* cnx) :
143        egl_object_t(get_display(dpy)), dpy(dpy), surface(surface),
144                config(config), win(win), impl(impl), cnx(cnx) {
145    }
146    EGLDisplay dpy;
147    EGLSurface surface;
148    EGLConfig config;
149    sp<ANativeWindow> win;
150    int impl;
151    egl_connection_t const* cnx;
152};
153
154class egl_context_t: public egl_object_t {
155protected:
156    ~egl_context_t() {}
157public:
158    typedef egl_object_t::LocalRef<egl_context_t, EGLContext> Ref;
159
160    egl_context_t(EGLDisplay dpy, EGLContext context, EGLConfig config,
161            int impl, egl_connection_t const* cnx, int version) :
162        egl_object_t(get_display(dpy)), dpy(dpy), context(context),
163                config(config), read(0), draw(0), impl(impl), cnx(cnx),
164                version(version) {
165    }
166    EGLDisplay dpy;
167    EGLContext context;
168    EGLConfig config;
169    EGLSurface read;
170    EGLSurface draw;
171    int impl;
172    egl_connection_t const* cnx;
173    int version;
174};
175
176class egl_image_t: public egl_object_t {
177protected:
178    ~egl_image_t() {}
179public:
180    typedef egl_object_t::LocalRef<egl_image_t, EGLImageKHR> Ref;
181
182    egl_image_t(EGLDisplay dpy, EGLContext context) :
183        egl_object_t(get_display(dpy)), dpy(dpy), context(context) {
184        memset(images, 0, sizeof(images));
185    }
186    EGLDisplay dpy;
187    EGLContext context;
188    EGLImageKHR images[IMPL_NUM_IMPLEMENTATIONS];
189};
190
191class egl_sync_t: public egl_object_t {
192protected:
193    ~egl_sync_t() {}
194public:
195    typedef egl_object_t::LocalRef<egl_sync_t, EGLSyncKHR> Ref;
196
197    egl_sync_t(EGLDisplay dpy, EGLContext context, EGLSyncKHR sync) :
198        egl_object_t(get_display(dpy)), dpy(dpy), context(context), sync(sync) {
199    }
200    EGLDisplay dpy;
201    EGLContext context;
202    EGLSyncKHR sync;
203};
204
205// ----------------------------------------------------------------------------
206
207typedef egl_surface_t::Ref  SurfaceRef;
208typedef egl_context_t::Ref  ContextRef;
209typedef egl_image_t::Ref    ImageRef;
210typedef egl_sync_t::Ref     SyncRef;
211
212// ----------------------------------------------------------------------------
213
214template<typename NATIVE, typename EGL>
215static inline NATIVE* egl_to_native_cast(EGL arg) {
216    return reinterpret_cast<NATIVE*>(arg);
217}
218
219static inline
220egl_surface_t* get_surface(EGLSurface surface) {
221    return egl_to_native_cast<egl_surface_t>(surface);
222}
223
224static inline
225egl_context_t* get_context(EGLContext context) {
226    return egl_to_native_cast<egl_context_t>(context);
227}
228
229static inline
230egl_image_t* get_image(EGLImageKHR image) {
231    return egl_to_native_cast<egl_image_t>(image);
232}
233
234static inline
235egl_sync_t* get_sync(EGLSyncKHR sync) {
236    return egl_to_native_cast<egl_sync_t>(sync);
237}
238
239// ----------------------------------------------------------------------------
240}; // namespace android
241// ----------------------------------------------------------------------------
242
243#endif // ANDROID_EGL_OBJECT_H
244