1 /* 2 * Copyright (C) 2011 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 // #define LOG_NDEBUG 0 17 18 #include "base/logging.h" 19 #include "base/utilities.h" 20 #include "core/gl_env.h" 21 #include "core/shader_program.h" 22 #include "core/vertex_frame.h" 23 #include "system/window.h" 24 25 #include <map> 26 #include <string> 27 #include <EGL/eglext.h> 28 29 namespace android { 30 namespace filterfw { 31 32 GLEnv::GLEnv() 33 : display_(EGL_NO_DISPLAY), 34 context_id_(0), 35 surface_id_(0), 36 max_surface_id_(0), 37 created_context_(false), 38 created_surface_(false), 39 initialized_(false) { 40 } 41 42 GLEnv::~GLEnv() { 43 // Destroy surfaces 44 for (std::map<int, SurfaceWindowPair>::iterator it = surfaces_.begin(); 45 it != surfaces_.end(); 46 ++it) { 47 if (it->first != 0 || created_surface_) { 48 eglDestroySurface(display(), it->second.first); 49 if (it->second.second) { 50 it->second.second->Destroy(); 51 delete it->second.second; 52 } 53 } 54 } 55 56 // Destroy contexts 57 for (std::map<int, EGLContext>::iterator it = contexts_.begin(); 58 it != contexts_.end(); 59 ++it) { 60 if (it->first != 0 || created_context_) 61 eglDestroyContext(display(), it->second); 62 } 63 64 // Destroy attached shaders and frames 65 STLDeleteValues(&attached_shaders_); 66 STLDeleteValues(&attached_vframes_); 67 68 // Destroy display 69 if (initialized_) 70 eglTerminate(display()); 71 72 // Log error if this did not work 73 if (CheckEGLError("TearDown!")) 74 ALOGE("GLEnv: Error tearing down GL Environment!"); 75 } 76 77 bool GLEnv::IsInitialized() const { 78 return (contexts_.size() > 0 && 79 surfaces_.size() > 0 && 80 display_ != EGL_NO_DISPLAY); 81 } 82 83 bool GLEnv::Deactivate() { 84 eglMakeCurrent(display(), EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); 85 return !CheckEGLError("eglMakeCurrent"); 86 } 87 88 bool GLEnv::Activate() { 89 ALOGV("Activate()"); 90 if (display() != eglGetCurrentDisplay() || 91 context() != eglGetCurrentContext() || 92 surface() != eglGetCurrentSurface(EGL_DRAW)) { 93 // Make sure we are initialized 94 if (context() == EGL_NO_CONTEXT || surface() == EGL_NO_SURFACE) 95 return false; 96 97 // Make our context current 98 ALOGV("eglMakeCurrent"); 99 eglMakeCurrent(display(), surface(), surface(), context()); 100 101 return !CheckEGLMakeCurrentError(); 102 } 103 return true; 104 } 105 106 bool GLEnv::SwapBuffers() { 107 const bool result = eglSwapBuffers(display(), surface()) == EGL_TRUE; 108 return !CheckEGLError("eglSwapBuffers") && result; 109 } 110 111 bool GLEnv::InitWithCurrentContext() { 112 if (IsInitialized()) 113 return true; 114 115 display_ = eglGetCurrentDisplay(); 116 contexts_[0] = eglGetCurrentContext(); 117 surfaces_[0] = SurfaceWindowPair(eglGetCurrentSurface(EGL_DRAW), NULL); 118 119 return (context() != EGL_NO_CONTEXT) && 120 (display() != EGL_NO_DISPLAY) && 121 (surface() != EGL_NO_SURFACE); 122 } 123 124 bool GLEnv::InitWithNewContext() { 125 if (IsInitialized()) { 126 ALOGE("GLEnv: Attempting to reinitialize environment!"); 127 return false; 128 } 129 130 display_ = eglGetDisplay(EGL_DEFAULT_DISPLAY); 131 if (CheckEGLError("eglGetDisplay")) return false; 132 133 EGLint majorVersion; 134 EGLint minorVersion; 135 eglInitialize(display(), &majorVersion, &minorVersion); 136 if (CheckEGLError("eglInitialize")) return false; 137 initialized_ = true; 138 139 // Configure context/surface 140 EGLConfig config; 141 EGLint numConfigs = -1; 142 143 // TODO(renn): Do we need the window bit here? 144 // TODO: Currently choosing the config that includes all 145 // This is not needed if the encoding is not being used 146 EGLint configAttribs[] = { 147 EGL_SURFACE_TYPE, EGL_WINDOW_BIT, 148 EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, 149 EGL_RED_SIZE, 8, 150 EGL_GREEN_SIZE, 8, 151 EGL_BLUE_SIZE, 8, 152 EGL_RECORDABLE_ANDROID, EGL_TRUE, 153 EGL_NONE 154 }; 155 156 eglChooseConfig(display(), configAttribs, &config, 1, &numConfigs); 157 if (numConfigs < 1) { 158 ALOGE("GLEnv::Init: No suitable EGL configuration found!"); 159 return false; 160 } 161 162 // Create dummy surface using a GLConsumer 163 surfaceTexture_ = new GLConsumer(0); 164 window_ = new Surface(static_cast<sp<IGraphicBufferProducer> >( 165 surfaceTexture_->getBufferQueue())); 166 167 surfaces_[0] = SurfaceWindowPair(eglCreateWindowSurface(display(), config, window_.get(), NULL), NULL); 168 if (CheckEGLError("eglCreateWindowSurface")) return false; 169 170 // Create context 171 EGLint context_attribs[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE }; 172 contexts_[0] = eglCreateContext(display(), 173 config, 174 EGL_NO_CONTEXT, 175 context_attribs); 176 if (CheckEGLError("eglCreateContext")) return false; 177 178 created_context_ = created_surface_ = true; 179 180 return true; 181 } 182 183 bool GLEnv::IsActive() const { 184 ALOGV("IsActive()"); 185 return context() == eglGetCurrentContext() 186 && display() == eglGetCurrentDisplay() 187 && surface() == eglGetCurrentSurface(EGL_DRAW); 188 } 189 190 bool GLEnv::IsContextActive() const { 191 return context() == eglGetCurrentContext(); 192 } 193 194 bool GLEnv::IsAnyContextActive() { 195 return eglGetCurrentContext() != EGL_NO_CONTEXT; 196 } 197 198 int GLEnv::AddWindowSurface(const EGLSurface& surface, WindowHandle* window_handle) { 199 const int id = ++max_surface_id_; 200 surfaces_[id] = SurfaceWindowPair(surface, window_handle); 201 return id; 202 } 203 204 int GLEnv::AddSurface(const EGLSurface& surface) { 205 return AddWindowSurface(surface, NULL); 206 } 207 208 bool GLEnv::SwitchToSurfaceId(int surface_id) { 209 ALOGV("SwitchToSurfaceId"); 210 if (surface_id_ != surface_id) { 211 const SurfaceWindowPair* surface = FindOrNull(surfaces_, surface_id); 212 if (surface) { 213 bool wasActive = IsActive(); 214 surface_id_ = surface_id; 215 return wasActive ? Activate() : true; 216 } 217 return false; 218 } 219 return true; 220 } 221 222 bool GLEnv::ReleaseSurfaceId(int surface_id) { 223 if (surface_id > 0) { 224 const SurfaceWindowPair* surface_window_pair = FindOrNull(surfaces_, surface_id); 225 if (surface_window_pair) { 226 if (surface_id_ == surface_id) 227 SwitchToSurfaceId(0); 228 eglDestroySurface(display(), surface_window_pair->first); 229 if (surface_window_pair->second) { 230 surface_window_pair->second->Destroy(); 231 delete surface_window_pair->second; 232 } 233 surfaces_.erase(surface_id); 234 return true; 235 } 236 } 237 return false; 238 } 239 240 bool GLEnv::SetSurfaceTimestamp(int64_t timestamp) { 241 if (surface_id_ > 0) { 242 const SurfaceWindowPair* surface_window_pair = FindOrNull(surfaces_, 243 surface_id_); 244 if (surface_window_pair) { 245 ANativeWindow *window = static_cast<ANativeWindow*>( 246 surface_window_pair->second->InternalHandle()); 247 native_window_set_buffers_timestamp(window, timestamp); 248 return true; 249 } 250 } 251 return false; 252 } 253 254 int GLEnv::FindSurfaceIdForWindow(const WindowHandle* window_handle) { 255 for (std::map<int, SurfaceWindowPair>::iterator it = surfaces_.begin(); 256 it != surfaces_.end(); 257 ++it) { 258 const WindowHandle* my_handle = it->second.second; 259 if (my_handle && my_handle->Equals(window_handle)) { 260 return it->first; 261 } 262 } 263 return -1; 264 } 265 266 267 int GLEnv::AddContext(const EGLContext& context) { 268 const int id = contexts_.size(); 269 contexts_[id] = context; 270 return id; 271 } 272 273 bool GLEnv::SwitchToContextId(int context_id) { 274 const EGLContext* context = FindOrNull(contexts_, context_id); 275 if (context) { 276 if (context_id_ != context_id) { 277 context_id_ = context_id; 278 return Activate(); 279 } 280 return true; 281 } 282 return false; 283 } 284 285 void GLEnv::ReleaseContextId(int context_id) { 286 if (context_id > 0) { 287 const EGLContext* context = FindOrNull(contexts_, context_id); 288 if (context) { 289 contexts_.erase(context_id); 290 if (context_id_ == context_id && IsActive()) 291 SwitchToContextId(0); 292 eglDestroyContext(display(), *context); 293 } 294 } 295 } 296 297 bool GLEnv::CheckGLError(const std::string& op) { 298 bool err = false; 299 for (GLint error = glGetError(); error; error = glGetError()) { 300 ALOGE("GL Error: Operation '%s' caused GL error (0x%x)\n", 301 op.c_str(), 302 error); 303 err = true; 304 } 305 return err; 306 } 307 308 bool GLEnv::CheckEGLError(const std::string& op) { 309 bool err = false; 310 for (EGLint error = eglGetError(); 311 error != EGL_SUCCESS; 312 error = eglGetError()) { 313 ALOGE("EGL Error: Operation '%s' caused EGL error (0x%x)\n", 314 op.c_str(), 315 error); 316 err = true; 317 } 318 return err; 319 } 320 321 bool GLEnv::CheckEGLMakeCurrentError() { 322 bool err = false; 323 for (EGLint error = eglGetError(); 324 error != EGL_SUCCESS; 325 error = eglGetError()) { 326 switch (error) { 327 case EGL_BAD_DISPLAY: 328 ALOGE("EGL Error: Attempting to activate context with bad display!"); 329 break; 330 case EGL_BAD_SURFACE: 331 ALOGE("EGL Error: Attempting to activate context with bad surface!"); 332 break; 333 case EGL_BAD_ACCESS: 334 ALOGE("EGL Error: Attempting to activate context, which is " 335 "already active in another thread!"); 336 break; 337 default: 338 ALOGE("EGL Error: Making EGL rendering context current caused " 339 "error: 0x%x\n", error); 340 } 341 err = true; 342 } 343 return err; 344 } 345 346 GLuint GLEnv::GetCurrentProgram() { 347 GLint result; 348 glGetIntegerv(GL_CURRENT_PROGRAM, &result); 349 ALOG_ASSERT(result >= 0); 350 return static_cast<GLuint>(result); 351 } 352 353 EGLDisplay GLEnv::GetCurrentDisplay() { 354 return eglGetCurrentDisplay(); 355 } 356 357 int GLEnv::NumberOfComponents(GLenum type) { 358 switch (type) { 359 case GL_BOOL: 360 case GL_FLOAT: 361 case GL_INT: 362 return 1; 363 case GL_BOOL_VEC2: 364 case GL_FLOAT_VEC2: 365 case GL_INT_VEC2: 366 return 2; 367 case GL_INT_VEC3: 368 case GL_FLOAT_VEC3: 369 case GL_BOOL_VEC3: 370 return 3; 371 case GL_BOOL_VEC4: 372 case GL_FLOAT_VEC4: 373 case GL_INT_VEC4: 374 case GL_FLOAT_MAT2: 375 return 4; 376 case GL_FLOAT_MAT3: 377 return 9; 378 case GL_FLOAT_MAT4: 379 return 16; 380 default: 381 return 0; 382 } 383 } 384 385 void GLEnv::AttachShader(int key, ShaderProgram* shader) { 386 ShaderProgram* existingShader = ShaderWithKey(key); 387 if (existingShader) 388 delete existingShader; 389 attached_shaders_[key] = shader; 390 } 391 392 void GLEnv::AttachVertexFrame(int key, VertexFrame* frame) { 393 VertexFrame* existingFrame = VertexFrameWithKey(key); 394 if (existingFrame) 395 delete existingFrame; 396 attached_vframes_[key] = frame; 397 } 398 399 ShaderProgram* GLEnv::ShaderWithKey(int key) { 400 return FindPtrOrNull(attached_shaders_, key); 401 } 402 403 VertexFrame* GLEnv::VertexFrameWithKey(int key) { 404 return FindPtrOrNull(attached_vframes_, key); 405 } 406 407 } // namespace filterfw 408 } // namespace android 409