1 /*
2  * Copyright (C) 2015 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_GL_WORKER_H_
18 #define ANDROID_GL_WORKER_H_
19 
20 #include <pthread.h>
21 
22 #include <memory>
23 #include <vector>
24 
25 #define EGL_EGLEXT_PROTOTYPES
26 #define GL_GLEXT_PROTOTYPES
27 
28 #include <EGL/egl.h>
29 #include <EGL/eglext.h>
30 #include <GLES2/gl2.h>
31 #include <GLES2/gl2ext.h>
32 
33 struct hwc_layer_1;
34 
35 namespace android {
36 
37 #define AUTO_GL_TYPE(name, type, zero, deleter) \
38   struct name##Deleter {                        \
39     typedef type pointer;                       \
40                                                 \
41     void operator()(pointer p) const {          \
42       if (p != zero) {                          \
43         deleter;                                \
44       }                                         \
45     }                                           \
46   };                                            \
47   typedef std::unique_ptr<type, name##Deleter> name;
48 
49 AUTO_GL_TYPE(AutoGLFramebuffer, GLuint, 0, glDeleteFramebuffers(1, &p))
50 AUTO_GL_TYPE(AutoGLBuffer, GLuint, 0, glDeleteBuffers(1, &p))
51 AUTO_GL_TYPE(AutoGLTexture, GLuint, 0, glDeleteTextures(1, &p))
52 AUTO_GL_TYPE(AutoGLShader, GLint, 0, glDeleteShader(p))
53 AUTO_GL_TYPE(AutoGLProgram, GLint, 0, glDeleteProgram(p))
54 
55 struct EGLImageDeleter {
56   typedef EGLImageKHR pointer;
57 
58   EGLDisplay egl_display_;
59 
EGLImageDeleterEGLImageDeleter60   EGLImageDeleter(EGLDisplay egl_display) : egl_display_(egl_display) {
61   }
62 
operatorEGLImageDeleter63   void operator()(EGLImageKHR p) const {
64     if (p != EGL_NO_IMAGE_KHR) {
65       eglDestroyImageKHR(egl_display_, p);
66     }
67   }
68 };
69 typedef std::unique_ptr<EGLImageKHR, EGLImageDeleter> AutoEGLImageKHR;
70 
71 struct AutoEGLImageAndGLTexture {
72   AutoEGLImageKHR image;
73   AutoGLTexture texture;
74 
AutoEGLImageAndGLTextureAutoEGLImageAndGLTexture75   AutoEGLImageAndGLTexture(EGLDisplay egl_display)
76       : image(EGL_NO_IMAGE_KHR, EGLImageDeleter(egl_display)) {
77   }
78 };
79 
80 class GLWorker {
81  public:
82   struct Work {
83     hwc_layer_1 *layers;
84     size_t num_layers;
85     int timeline_fd;
86     sp<GraphicBuffer> framebuffer;
87 
88     Work() = default;
89     Work(const Work &rhs) = delete;
90   };
91 
92   class Compositor {
93    public:
94     Compositor();
95     ~Compositor();
96 
97     int Init();
98 
99     int Composite(hwc_layer_1 *layers, size_t num_layers,
100                   sp<GraphicBuffer> framebuffer);
101 
102    private:
103     EGLDisplay egl_display_;
104     EGLContext egl_ctx_;
105 
106     std::vector<AutoGLProgram> blend_programs_;
107     AutoGLBuffer vertex_buffer_;
108   };
109 
110   GLWorker();
111   ~GLWorker();
112 
113   int Init();
114 
115   int DoWork(Work *work);
116 
117  private:
118   bool initialized_;
119   pthread_t thread_;
120   pthread_mutex_t lock_;
121   pthread_cond_t work_ready_cond_;
122   pthread_cond_t work_done_cond_;
123   Work *worker_work_;
124   bool work_ready_;
125   bool worker_exit_;
126   int worker_ret_;
127 
128   void WorkerRoutine();
129   int DoComposition(Compositor &compositor, Work *work);
130 
131   int SignalWorker(Work *work, bool worker_exit);
132 
133   static void *StartRoutine(void *arg);
134 };
135 }
136 
137 #endif
138