LayerRenderer.cpp revision 2055abaa0a590c35e27e1ae2e7d7cfccdfb98b59
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 17#define LOG_TAG "OpenGLRenderer" 18 19#include <ui/Rect.h> 20 21#include <private/hwui/DrawGlInfo.h> 22 23#include "LayerCache.h" 24#include "LayerRenderer.h" 25#include "Matrix.h" 26#include "Properties.h" 27#include "Rect.h" 28 29namespace android { 30namespace uirenderer { 31 32/////////////////////////////////////////////////////////////////////////////// 33// Rendering 34/////////////////////////////////////////////////////////////////////////////// 35 36LayerRenderer::LayerRenderer(Layer* layer): mLayer(layer) { 37} 38 39LayerRenderer::~LayerRenderer() { 40} 41 42void LayerRenderer::setViewport(int width, int height) { 43 initViewport(width, height); 44} 45 46status_t LayerRenderer::prepareDirty(float left, float top, float right, float bottom, 47 bool opaque) { 48 LAYER_RENDERER_LOGD("Rendering into layer, fbo = %d", mLayer->getFbo()); 49 50 glBindFramebuffer(GL_FRAMEBUFFER, mLayer->getFbo()); 51 52 const float width = mLayer->layer.getWidth(); 53 const float height = mLayer->layer.getHeight(); 54 55 Rect dirty(left, top, right, bottom); 56 if (dirty.isEmpty() || (dirty.left <= 0 && dirty.top <= 0 && 57 dirty.right >= width && dirty.bottom >= height)) { 58 mLayer->region.clear(); 59 dirty.set(0.0f, 0.0f, width, height); 60 } else { 61 dirty.intersect(0.0f, 0.0f, width, height); 62 android::Rect r(dirty.left, dirty.top, dirty.right, dirty.bottom); 63 mLayer->region.subtractSelf(r); 64 } 65 66 return OpenGLRenderer::prepareDirty(dirty.left, dirty.top, dirty.right, dirty.bottom, opaque); 67} 68 69status_t LayerRenderer::clear(float left, float top, float right, float bottom, bool opaque) { 70 if (mLayer->isDirty()) { 71 getCaches().disableScissor(); 72 glClear(GL_COLOR_BUFFER_BIT); 73 74 getCaches().resetScissor(); 75 mLayer->setDirty(false); 76 77 return DrawGlInfo::kStatusDone; 78 } 79 80 return OpenGLRenderer::clear(left, top, right, bottom, opaque); 81} 82 83void LayerRenderer::finish() { 84 OpenGLRenderer::finish(); 85 86 generateMesh(); 87 88 LAYER_RENDERER_LOGD("Finished rendering into layer, fbo = %d", mLayer->getFbo()); 89 90 // No need to unbind our FBO, this will be taken care of by the caller 91 // who will invoke OpenGLRenderer::resume() 92} 93 94GLint LayerRenderer::getTargetFbo() { 95 return mLayer->getFbo(); 96} 97 98bool LayerRenderer::suppressErrorChecks() { 99 return true; 100} 101 102/////////////////////////////////////////////////////////////////////////////// 103// Layer support 104/////////////////////////////////////////////////////////////////////////////// 105 106bool LayerRenderer::hasLayer() { 107 return true; 108} 109 110void LayerRenderer::ensureStencilBuffer() { 111 attachStencilBufferToLayer(mLayer); 112} 113 114/////////////////////////////////////////////////////////////////////////////// 115// Dirty region tracking 116/////////////////////////////////////////////////////////////////////////////// 117 118Region* LayerRenderer::getRegion() { 119 if (getSnapshot()->flags & Snapshot::kFlagFboTarget) { 120 return OpenGLRenderer::getRegion(); 121 } 122 return &mLayer->region; 123} 124 125// TODO: This implementation is flawed and can generate T-junctions 126// in the mesh, which will in turn produce cracks when the 127// mesh is rotated/skewed. The easiest way to fix this would 128// be, for each row, to add new vertices shared with the previous 129// row when the two rows share an edge. 130// In practice, T-junctions do not appear often so this has yet 131// to be fixed. 132void LayerRenderer::generateMesh() { 133 if (mLayer->region.isRect() || mLayer->region.isEmpty()) { 134 if (mLayer->mesh) { 135 delete mLayer->mesh; 136 delete mLayer->meshIndices; 137 138 mLayer->mesh = NULL; 139 mLayer->meshIndices = NULL; 140 mLayer->meshElementCount = 0; 141 } 142 143 mLayer->setRegionAsRect(); 144 return; 145 } 146 147 size_t count; 148 const android::Rect* rects = mLayer->region.getArray(&count); 149 150 GLsizei elementCount = count * 6; 151 152 if (mLayer->mesh && mLayer->meshElementCount < elementCount) { 153 delete mLayer->mesh; 154 delete mLayer->meshIndices; 155 156 mLayer->mesh = NULL; 157 mLayer->meshIndices = NULL; 158 } 159 160 bool rebuildIndices = false; 161 if (!mLayer->mesh) { 162 mLayer->mesh = new TextureVertex[count * 4]; 163 mLayer->meshIndices = new uint16_t[elementCount]; 164 rebuildIndices = true; 165 } 166 mLayer->meshElementCount = elementCount; 167 168 const float texX = 1.0f / float(mLayer->getWidth()); 169 const float texY = 1.0f / float(mLayer->getHeight()); 170 const float height = mLayer->layer.getHeight(); 171 172 TextureVertex* mesh = mLayer->mesh; 173 uint16_t* indices = mLayer->meshIndices; 174 175 for (size_t i = 0; i < count; i++) { 176 const android::Rect* r = &rects[i]; 177 178 const float u1 = r->left * texX; 179 const float v1 = (height - r->top) * texY; 180 const float u2 = r->right * texX; 181 const float v2 = (height - r->bottom) * texY; 182 183 TextureVertex::set(mesh++, r->left, r->top, u1, v1); 184 TextureVertex::set(mesh++, r->right, r->top, u2, v1); 185 TextureVertex::set(mesh++, r->left, r->bottom, u1, v2); 186 TextureVertex::set(mesh++, r->right, r->bottom, u2, v2); 187 188 if (rebuildIndices) { 189 uint16_t quad = i * 4; 190 int index = i * 6; 191 indices[index ] = quad; // top-left 192 indices[index + 1] = quad + 1; // top-right 193 indices[index + 2] = quad + 2; // bottom-left 194 indices[index + 3] = quad + 2; // bottom-left 195 indices[index + 4] = quad + 1; // top-right 196 indices[index + 5] = quad + 3; // bottom-right 197 } 198 } 199} 200 201/////////////////////////////////////////////////////////////////////////////// 202// Layers management 203/////////////////////////////////////////////////////////////////////////////// 204 205Layer* LayerRenderer::createLayer(uint32_t width, uint32_t height, bool isOpaque) { 206 LAYER_RENDERER_LOGD("Requesting new render layer %dx%d", width, height); 207 208 Caches& caches = Caches::getInstance(); 209 GLuint fbo = caches.fboCache.get(); 210 if (!fbo) { 211 ALOGW("Could not obtain an FBO"); 212 return NULL; 213 } 214 215 caches.activeTexture(0); 216 Layer* layer = caches.layerCache.get(width, height); 217 if (!layer) { 218 ALOGW("Could not obtain a layer"); 219 return NULL; 220 } 221 222 layer->setFbo(fbo); 223 layer->layer.set(0.0f, 0.0f, width, height); 224 layer->texCoords.set(0.0f, height / float(layer->getHeight()), 225 width / float(layer->getWidth()), 0.0f); 226 layer->setAlpha(255, SkXfermode::kSrcOver_Mode); 227 layer->setBlend(!isOpaque); 228 layer->setColorFilter(NULL); 229 layer->setDirty(true); 230 layer->region.clear(); 231 232 GLuint previousFbo; 233 glGetIntegerv(GL_FRAMEBUFFER_BINDING, (GLint*) &previousFbo); 234 235 glBindFramebuffer(GL_FRAMEBUFFER, layer->getFbo()); 236 layer->bindTexture(); 237 238 // Initialize the texture if needed 239 if (layer->isEmpty()) { 240 layer->setEmpty(false); 241 layer->allocateTexture(GL_RGBA, GL_UNSIGNED_BYTE); 242 243 if (glGetError() != GL_NO_ERROR) { 244 ALOGD("Could not allocate texture for layer (fbo=%d %dx%d)", 245 fbo, width, height); 246 247 glBindFramebuffer(GL_FRAMEBUFFER, previousFbo); 248 249 Caches::getInstance().resourceCache.decrementRefcount(layer); 250 251 return NULL; 252 } 253 } 254 255 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 256 layer->getTexture(), 0); 257 258 glBindFramebuffer(GL_FRAMEBUFFER, previousFbo); 259 260 return layer; 261} 262 263bool LayerRenderer::resizeLayer(Layer* layer, uint32_t width, uint32_t height) { 264 if (layer) { 265 LAYER_RENDERER_LOGD("Resizing layer fbo = %d to %dx%d", layer->getFbo(), width, height); 266 267 if (layer->resize(width, height)) { 268 layer->layer.set(0.0f, 0.0f, width, height); 269 layer->texCoords.set(0.0f, height / float(layer->getHeight()), 270 width / float(layer->getWidth()), 0.0f); 271 } else { 272 Caches::getInstance().resourceCache.decrementRefcount(layer); 273 return false; 274 } 275 } 276 277 return true; 278} 279 280Layer* LayerRenderer::createTextureLayer(bool isOpaque) { 281 LAYER_RENDERER_LOGD("Creating new texture layer"); 282 283 Layer* layer = new Layer(0, 0); 284 layer->setCacheable(false); 285 layer->setTextureLayer(true); 286 layer->setBlend(!isOpaque); 287 layer->setEmpty(true); 288 layer->setFbo(0); 289 layer->setAlpha(255, SkXfermode::kSrcOver_Mode); 290 layer->layer.set(0.0f, 0.0f, 0.0f, 0.0f); 291 layer->texCoords.set(0.0f, 1.0f, 1.0f, 0.0f); 292 layer->region.clear(); 293 layer->setRenderTarget(GL_NONE); // see ::updateTextureLayer() 294 295 Caches::getInstance().activeTexture(0); 296 layer->generateTexture(); 297 298 return layer; 299} 300 301void LayerRenderer::updateTextureLayer(Layer* layer, uint32_t width, uint32_t height, 302 bool isOpaque, GLenum renderTarget, float* transform) { 303 if (layer) { 304 layer->setBlend(!isOpaque); 305 layer->setSize(width, height); 306 layer->layer.set(0.0f, 0.0f, width, height); 307 layer->region.set(width, height); 308 layer->regionRect.set(0.0f, 0.0f, width, height); 309 layer->getTexTransform().load(transform); 310 311 if (renderTarget != layer->getRenderTarget()) { 312 layer->setRenderTarget(renderTarget); 313 layer->bindTexture(); 314 layer->setFilter(GL_NEAREST, false, true); 315 layer->setWrap(GL_CLAMP_TO_EDGE, false, true); 316 } 317 } 318} 319 320void LayerRenderer::destroyLayer(Layer* layer) { 321 if (layer) { 322 LAYER_RENDERER_LOGD("Recycling layer, %dx%d fbo = %d", 323 layer->getWidth(), layer->getHeight(), layer->getFbo()); 324 325 if (!Caches::getInstance().layerCache.put(layer)) { 326 LAYER_RENDERER_LOGD(" Destroyed!"); 327 Caches::getInstance().resourceCache.decrementRefcount(layer); 328 } else { 329 LAYER_RENDERER_LOGD(" Cached!"); 330#if DEBUG_LAYER_RENDERER 331 Caches::getInstance().layerCache.dump(); 332#endif 333 layer->removeFbo(); 334 layer->region.clear(); 335 } 336 } 337} 338 339void LayerRenderer::destroyLayerDeferred(Layer* layer) { 340 if (layer) { 341 LAYER_RENDERER_LOGD("Deferring layer destruction, fbo = %d", layer->getFbo()); 342 343 Caches::getInstance().deleteLayerDeferred(layer); 344 } 345} 346 347void LayerRenderer::flushLayer(Layer* layer) { 348#ifdef GL_EXT_discard_framebuffer 349 GLuint fbo = layer->getFbo(); 350 if (layer && fbo) { 351 // If possible, discard any enqueud operations on deferred 352 // rendering architectures 353 if (Caches::getInstance().extensions.hasDiscardFramebuffer()) { 354 GLuint previousFbo; 355 glGetIntegerv(GL_FRAMEBUFFER_BINDING, (GLint*) &previousFbo); 356 if (fbo != previousFbo) glBindFramebuffer(GL_FRAMEBUFFER, fbo); 357 358 const GLenum attachments[] = { GL_COLOR_ATTACHMENT0 }; 359 glDiscardFramebufferEXT(GL_FRAMEBUFFER, 1, attachments); 360 361 if (fbo != previousFbo) glBindFramebuffer(GL_FRAMEBUFFER, previousFbo); 362 } 363 } 364#endif 365} 366 367bool LayerRenderer::copyLayer(Layer* layer, SkBitmap* bitmap) { 368 Caches& caches = Caches::getInstance(); 369 if (layer && bitmap->width() <= caches.maxTextureSize && 370 bitmap->height() <= caches.maxTextureSize) { 371 372 GLuint fbo = caches.fboCache.get(); 373 if (!fbo) { 374 ALOGW("Could not obtain an FBO"); 375 return false; 376 } 377 378 SkAutoLockPixels alp(*bitmap); 379 380 GLuint texture; 381 GLuint previousFbo; 382 GLuint previousViewport[4]; 383 384 GLenum format; 385 GLenum type; 386 387 GLenum error = GL_NO_ERROR; 388 bool status = false; 389 390 switch (bitmap->config()) { 391 case SkBitmap::kA8_Config: 392 format = GL_ALPHA; 393 type = GL_UNSIGNED_BYTE; 394 break; 395 case SkBitmap::kRGB_565_Config: 396 format = GL_RGB; 397 type = GL_UNSIGNED_SHORT_5_6_5; 398 break; 399 case SkBitmap::kARGB_4444_Config: 400 format = GL_RGBA; 401 type = GL_UNSIGNED_SHORT_4_4_4_4; 402 break; 403 case SkBitmap::kARGB_8888_Config: 404 default: 405 format = GL_RGBA; 406 type = GL_UNSIGNED_BYTE; 407 break; 408 } 409 410 float alpha = layer->getAlpha(); 411 SkXfermode::Mode mode = layer->getMode(); 412 GLuint previousLayerFbo = layer->getFbo(); 413 414 layer->setAlpha(255, SkXfermode::kSrc_Mode); 415 layer->setFbo(fbo); 416 417 glGetIntegerv(GL_FRAMEBUFFER_BINDING, (GLint*) &previousFbo); 418 glGetIntegerv(GL_VIEWPORT, (GLint*) &previousViewport); 419 glBindFramebuffer(GL_FRAMEBUFFER, fbo); 420 421 glGenTextures(1, &texture); 422 if ((error = glGetError()) != GL_NO_ERROR) goto error; 423 424 caches.activeTexture(0); 425 glBindTexture(GL_TEXTURE_2D, texture); 426 427 glPixelStorei(GL_PACK_ALIGNMENT, bitmap->bytesPerPixel()); 428 429 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 430 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 431 432 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 433 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 434 435 glTexImage2D(GL_TEXTURE_2D, 0, format, bitmap->width(), bitmap->height(), 436 0, format, type, NULL); 437 if ((error = glGetError()) != GL_NO_ERROR) goto error; 438 439 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, 440 GL_TEXTURE_2D, texture, 0); 441 if ((error = glGetError()) != GL_NO_ERROR) goto error; 442 443 { 444 LayerRenderer renderer(layer); 445 renderer.setViewport(bitmap->width(), bitmap->height()); 446 renderer.OpenGLRenderer::prepareDirty(0.0f, 0.0f, 447 bitmap->width(), bitmap->height(), !layer->isBlend()); 448 449 caches.disableScissor(); 450 renderer.translate(0.0f, bitmap->height()); 451 renderer.scale(1.0f, -1.0f); 452 453 mat4 texTransform(layer->getTexTransform()); 454 455 mat4 invert; 456 invert.translate(0.0f, 1.0f, 0.0f); 457 invert.scale(1.0f, -1.0f, 1.0f); 458 layer->getTexTransform().multiply(invert); 459 460 if ((error = glGetError()) != GL_NO_ERROR) goto error; 461 462 { 463 Rect bounds; 464 bounds.set(0.0f, 0.0f, bitmap->width(), bitmap->height()); 465 renderer.drawTextureLayer(layer, bounds); 466 467 glReadPixels(0, 0, bitmap->width(), bitmap->height(), format, 468 type, bitmap->getPixels()); 469 470 if ((error = glGetError()) != GL_NO_ERROR) goto error; 471 } 472 473 layer->getTexTransform().load(texTransform); 474 status = true; 475 } 476 477error: 478#if DEBUG_OPENGL 479 if (error != GL_NO_ERROR) { 480 ALOGD("GL error while copying layer into bitmap = 0x%x", error); 481 } 482#endif 483 484 glBindFramebuffer(GL_FRAMEBUFFER, previousFbo); 485 layer->setAlpha(alpha, mode); 486 layer->setFbo(previousLayerFbo); 487 glDeleteTextures(1, &texture); 488 caches.fboCache.put(fbo); 489 glViewport(previousViewport[0], previousViewport[1], 490 previousViewport[2], previousViewport[3]); 491 492 return status; 493 } 494 return false; 495} 496 497}; // namespace uirenderer 498}; // namespace android 499