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