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