2 * Copyright (C) 2011 The Android Open Source Project
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
17 #define LOG_TAG "OpenGLRenderer"
21 #include <private/hwui/DrawGlInfo.h>
23 #include "LayerCache.h"
24 #include "LayerRenderer.h"
26 #include "Properties.h"
30 namespace uirenderer {
32 ///////////////////////////////////////////////////////////////////////////////
34 ///////////////////////////////////////////////////////////////////////////////
36 LayerRenderer::LayerRenderer(Layer* layer): mLayer(layer) {
39 LayerRenderer::~LayerRenderer() {
42 void LayerRenderer::setViewport(int width, int height) {
43 initViewport(width, height);
46 status_t LayerRenderer::prepareDirty(float left, float top, float right, float bottom,
48 LAYER_RENDERER_LOGD("Rendering into layer, fbo = %d", mLayer->getFbo());
50 glBindFramebuffer(GL_FRAMEBUFFER, mLayer->getFbo());
52 const float width = mLayer->layer.getWidth();
53 const float height = mLayer->layer.getHeight();
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);
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);
65 mLayer->clipRect.set(dirty);
67 return OpenGLRenderer::prepareDirty(dirty.left, dirty.top, dirty.right, dirty.bottom, opaque);
70 status_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);
75 getCaches().resetScissor();
76 mLayer->setDirty(false);
78 return DrawGlInfo::kStatusDone;
81 return OpenGLRenderer::clear(left, top, right, bottom, opaque);
84 void LayerRenderer::finish() {
85 OpenGLRenderer::finish();
89 LAYER_RENDERER_LOGD("Finished rendering into layer, fbo = %d", mLayer->getFbo());
91 // No need to unbind our FBO, this will be taken care of by the caller
92 // who will invoke OpenGLRenderer::resume()
95 GLint LayerRenderer::getTargetFbo() const {
96 return mLayer->getFbo();
99 bool LayerRenderer::suppressErrorChecks() const {
103 ///////////////////////////////////////////////////////////////////////////////
105 ///////////////////////////////////////////////////////////////////////////////
107 bool LayerRenderer::hasLayer() const {
111 void LayerRenderer::ensureStencilBuffer() {
112 attachStencilBufferToLayer(mLayer);
115 ///////////////////////////////////////////////////////////////////////////////
116 // Dirty region tracking
117 ///////////////////////////////////////////////////////////////////////////////
119 Region* LayerRenderer::getRegion() const {
120 if (getSnapshot()->flags & Snapshot::kFlagFboTarget) {
121 return OpenGLRenderer::getRegion();
123 return &mLayer->region;
126 // TODO: This implementation uses a very simple approach to fixing T-junctions which keeps the
127 // results as rectangles, and is thus not necessarily efficient in the geometry
128 // produced. Eventually, it may be better to develop triangle-based mechanism.
129 void LayerRenderer::generateMesh() {
130 if (mLayer->region.isRect() || mLayer->region.isEmpty()) {
132 delete[] mLayer->mesh;
133 delete[] mLayer->meshIndices;
136 mLayer->meshIndices = NULL;
137 mLayer->meshElementCount = 0;
140 mLayer->setRegionAsRect();
144 // avoid T-junctions as they cause artifacts in between the resultant
145 // geometry when complex transforms occur.
146 // TODO: generate the safeRegion only if necessary based on drawing transform (see
147 // OpenGLRenderer::composeLayerRegion())
148 Region safeRegion = Region::createTJunctionFreeRegion(mLayer->region);
151 const android::Rect* rects = safeRegion.getArray(&count);
153 GLsizei elementCount = count * 6;
155 if (mLayer->mesh && mLayer->meshElementCount < elementCount) {
156 delete[] mLayer->mesh;
157 delete[] mLayer->meshIndices;
160 mLayer->meshIndices = NULL;
163 bool rebuildIndices = false;
165 mLayer->mesh = new TextureVertex[count * 4];
166 mLayer->meshIndices = new uint16_t[elementCount];
167 rebuildIndices = true;
169 mLayer->meshElementCount = elementCount;
171 const float texX = 1.0f / float(mLayer->getWidth());
172 const float texY = 1.0f / float(mLayer->getHeight());
173 const float height = mLayer->layer.getHeight();
175 TextureVertex* mesh = mLayer->mesh;
176 uint16_t* indices = mLayer->meshIndices;
178 for (size_t i = 0; i < count; i++) {
179 const android::Rect* r = &rects[i];
181 const float u1 = r->left * texX;
182 const float v1 = (height - r->top) * texY;
183 const float u2 = r->right * texX;
184 const float v2 = (height - r->bottom) * texY;
186 TextureVertex::set(mesh++, r->left, r->top, u1, v1);
187 TextureVertex::set(mesh++, r->right, r->top, u2, v1);
188 TextureVertex::set(mesh++, r->left, r->bottom, u1, v2);
189 TextureVertex::set(mesh++, r->right, r->bottom, u2, v2);
191 if (rebuildIndices) {
192 uint16_t quad = i * 4;
194 indices[index ] = quad; // top-left
195 indices[index + 1] = quad + 1; // top-right
196 indices[index + 2] = quad + 2; // bottom-left
197 indices[index + 3] = quad + 2; // bottom-left
198 indices[index + 4] = quad + 1; // top-right
199 indices[index + 5] = quad + 3; // bottom-right
204 ///////////////////////////////////////////////////////////////////////////////
206 ///////////////////////////////////////////////////////////////////////////////
208 Layer* LayerRenderer::createLayer(uint32_t width, uint32_t height, bool isOpaque) {
209 LAYER_RENDERER_LOGD("Requesting new render layer %dx%d", width, height);
211 Caches& caches = Caches::getInstance();
212 GLuint fbo = caches.fboCache.get();
214 ALOGW("Could not obtain an FBO");
218 caches.activeTexture(0);
219 Layer* layer = caches.layerCache.get(width, height);
221 ALOGW("Could not obtain a layer");
225 // We first obtain a layer before comparing against the max texture size
226 // because layers are not allocated at the exact desired size. They are
227 // always created slighly larger to improve recycling
228 const uint32_t maxTextureSize = caches.maxTextureSize;
229 if (layer->getWidth() > maxTextureSize || layer->getHeight() > maxTextureSize) {
230 ALOGW("Layer exceeds max. dimensions supported by the GPU (%dx%d, max=%dx%d)",
231 width, height, maxTextureSize, maxTextureSize);
233 // Creating a new layer always increment its refcount by 1, this allows
234 // us to destroy the layer object if one was created for us
235 Caches::getInstance().resourceCache.decrementRefcount(layer);
241 layer->layer.set(0.0f, 0.0f, width, height);
242 layer->texCoords.set(0.0f, height / float(layer->getHeight()),
243 width / float(layer->getWidth()), 0.0f);
244 layer->setAlpha(255, SkXfermode::kSrcOver_Mode);
245 layer->setBlend(!isOpaque);
246 layer->setColorFilter(NULL);
247 layer->setDirty(true);
248 layer->region.clear();
251 glGetIntegerv(GL_FRAMEBUFFER_BINDING, (GLint*) &previousFbo);
253 glBindFramebuffer(GL_FRAMEBUFFER, layer->getFbo());
254 layer->bindTexture();
256 // Initialize the texture if needed
257 if (layer->isEmpty()) {
261 * Make sure there is no stale error leftover from some previous code
262 * sequence before we embark on this series of gl operations.
264 while ((an_error = glGetError()) != GL_NO_ERROR) {
265 ALOGD("createLayer clearing stale error code 0x%04x", an_error);
268 layer->setEmpty(false);
269 layer->allocateTexture();
271 /* Detect and clear errors from setEmpty(), allocateTexture() */
273 while ((an_error = glGetError()) != GL_NO_ERROR) {
275 ALOGD("Could not allocate texture for layer (fbo=%d %dx%d)"
277 fbo, width, height, an_error);
279 if (num_errors != 0) {
280 glBindFramebuffer(GL_FRAMEBUFFER, previousFbo);
281 caches.resourceCache.decrementRefcount(layer);
286 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
287 layer->getTexture(), 0);
289 glBindFramebuffer(GL_FRAMEBUFFER, previousFbo);
294 bool LayerRenderer::resizeLayer(Layer* layer, uint32_t width, uint32_t height) {
296 LAYER_RENDERER_LOGD("Resizing layer fbo = %d to %dx%d", layer->getFbo(), width, height);
298 if (layer->resize(width, height)) {
299 layer->layer.set(0.0f, 0.0f, width, height);
300 layer->texCoords.set(0.0f, height / float(layer->getHeight()),
301 width / float(layer->getWidth()), 0.0f);
310 Layer* LayerRenderer::createTextureLayer(bool isOpaque) {
311 LAYER_RENDERER_LOGD("Creating new texture layer");
313 Layer* layer = new Layer(0, 0);
314 layer->setCacheable(false);
315 layer->setTextureLayer(true);
316 layer->setBlend(!isOpaque);
317 layer->setEmpty(true);
319 layer->setAlpha(255, SkXfermode::kSrcOver_Mode);
320 layer->layer.set(0.0f, 0.0f, 0.0f, 0.0f);
321 layer->texCoords.set(0.0f, 1.0f, 1.0f, 0.0f);
322 layer->region.clear();
323 layer->setRenderTarget(GL_NONE); // see ::updateTextureLayer()
325 Caches::getInstance().activeTexture(0);
326 layer->generateTexture();
331 void LayerRenderer::updateTextureLayer(Layer* layer, uint32_t width, uint32_t height,
332 bool isOpaque, GLenum renderTarget, float* transform) {
334 layer->setBlend(!isOpaque);
335 layer->setSize(width, height);
336 layer->layer.set(0.0f, 0.0f, width, height);
337 layer->region.set(width, height);
338 layer->regionRect.set(0.0f, 0.0f, width, height);
339 layer->getTexTransform().load(transform);
341 if (renderTarget != layer->getRenderTarget()) {
342 layer->setRenderTarget(renderTarget);
343 layer->bindTexture();
344 layer->setFilter(GL_NEAREST, false, true);
345 layer->setWrap(GL_CLAMP_TO_EDGE, false, true);
350 void LayerRenderer::destroyLayer(Layer* layer) {
352 LAYER_RENDERER_LOGD("Recycling layer, %dx%d fbo = %d",
353 layer->getWidth(), layer->getHeight(), layer->getFbo());
355 if (!Caches::getInstance().layerCache.put(layer)) {
356 LAYER_RENDERER_LOGD(" Destroyed!");
357 Caches::getInstance().resourceCache.decrementRefcount(layer);
359 LAYER_RENDERER_LOGD(" Cached!");
360 #if DEBUG_LAYER_RENDERER
361 Caches::getInstance().layerCache.dump();
364 layer->region.clear();
369 void LayerRenderer::destroyLayerDeferred(Layer* layer) {
371 LAYER_RENDERER_LOGD("Deferring layer destruction, fbo = %d", layer->getFbo());
373 Caches::getInstance().deleteLayerDeferred(layer);
377 void LayerRenderer::flushLayer(Layer* layer) {
378 #ifdef GL_EXT_discard_framebuffer
379 GLuint fbo = layer->getFbo();
381 // If possible, discard any enqueud operations on deferred
382 // rendering architectures
383 if (Extensions::getInstance().hasDiscardFramebuffer()) {
385 glGetIntegerv(GL_FRAMEBUFFER_BINDING, (GLint*) &previousFbo);
386 if (fbo != previousFbo) glBindFramebuffer(GL_FRAMEBUFFER, fbo);
388 const GLenum attachments[] = { GL_COLOR_ATTACHMENT0 };
389 glDiscardFramebufferEXT(GL_FRAMEBUFFER, 1, attachments);
391 if (fbo != previousFbo) glBindFramebuffer(GL_FRAMEBUFFER, previousFbo);
397 bool LayerRenderer::copyLayer(Layer* layer, SkBitmap* bitmap) {
398 Caches& caches = Caches::getInstance();
399 if (layer && bitmap->width() <= caches.maxTextureSize &&
400 bitmap->height() <= caches.maxTextureSize) {
402 GLuint fbo = caches.fboCache.get();
404 ALOGW("Could not obtain an FBO");
408 SkAutoLockPixels alp(*bitmap);
412 GLuint previousViewport[4];
417 GLenum error = GL_NO_ERROR;
420 switch (bitmap->config()) {
421 case SkBitmap::kA8_Config:
423 type = GL_UNSIGNED_BYTE;
425 case SkBitmap::kRGB_565_Config:
427 type = GL_UNSIGNED_SHORT_5_6_5;
429 case SkBitmap::kARGB_4444_Config:
431 type = GL_UNSIGNED_SHORT_4_4_4_4;
433 case SkBitmap::kARGB_8888_Config:
436 type = GL_UNSIGNED_BYTE;
440 float alpha = layer->getAlpha();
441 SkXfermode::Mode mode = layer->getMode();
442 GLuint previousLayerFbo = layer->getFbo();
444 layer->setAlpha(255, SkXfermode::kSrc_Mode);
447 glGetIntegerv(GL_FRAMEBUFFER_BINDING, (GLint*) &previousFbo);
448 glGetIntegerv(GL_VIEWPORT, (GLint*) &previousViewport);
449 glBindFramebuffer(GL_FRAMEBUFFER, fbo);
451 glGenTextures(1, &texture);
452 if ((error = glGetError()) != GL_NO_ERROR) goto error;
454 caches.activeTexture(0);
455 glBindTexture(GL_TEXTURE_2D, texture);
457 glPixelStorei(GL_PACK_ALIGNMENT, bitmap->bytesPerPixel());
459 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
460 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
462 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
463 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
465 glTexImage2D(GL_TEXTURE_2D, 0, format, bitmap->width(), bitmap->height(),
466 0, format, type, NULL);
467 if ((error = glGetError()) != GL_NO_ERROR) goto error;
469 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
470 GL_TEXTURE_2D, texture, 0);
471 if ((error = glGetError()) != GL_NO_ERROR) goto error;
474 LayerRenderer renderer(layer);
475 renderer.setViewport(bitmap->width(), bitmap->height());
476 renderer.OpenGLRenderer::prepareDirty(0.0f, 0.0f,
477 bitmap->width(), bitmap->height(), !layer->isBlend());
479 caches.disableScissor();
480 renderer.translate(0.0f, bitmap->height());
481 renderer.scale(1.0f, -1.0f);
483 mat4 texTransform(layer->getTexTransform());
486 invert.translate(0.0f, 1.0f, 0.0f);
487 invert.scale(1.0f, -1.0f, 1.0f);
488 layer->getTexTransform().multiply(invert);
490 if ((error = glGetError()) != GL_NO_ERROR) goto error;
494 bounds.set(0.0f, 0.0f, bitmap->width(), bitmap->height());
495 renderer.drawTextureLayer(layer, bounds);
497 glReadPixels(0, 0, bitmap->width(), bitmap->height(), format,
498 type, bitmap->getPixels());
500 if ((error = glGetError()) != GL_NO_ERROR) goto error;
503 layer->getTexTransform().load(texTransform);
509 if (error != GL_NO_ERROR) {
510 ALOGD("GL error while copying layer into bitmap = 0x%x", error);
514 glBindFramebuffer(GL_FRAMEBUFFER, previousFbo);
515 layer->setAlpha(alpha, mode);
516 layer->setFbo(previousLayerFbo);
517 glDeleteTextures(1, &texture);
518 caches.fboCache.put(fbo);
519 glViewport(previousViewport[0], previousViewport[1],
520 previousViewport[2], previousViewport[3]);
527 }; // namespace uirenderer
528 }; // namespace android