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