fl_compositor_opengl.h File Reference

#include <gtk/gtk.h>
#include "flutter/shell/platform/embedder/embedder.h"
#include "flutter/shell/platform/linux/fl_framebuffer.h"
#include "flutter/shell/platform/linux/fl_opengl_manager.h"

Go to the source code of this file.

Functions
G_BEGIN_DECLS	G_DECLARE_FINAL_TYPE (FlCompositorOpenGL, fl_compositor_opengl, FL, COMPOSITOR_OPENGL, GObject) FlCompositorOpenGL *fl_compositor_opengl_new(FlOpenGLManager *opengl_manager
gboolean	fl_compositor_opengl_composite_layers (FlCompositorOpenGL *compositor, const FlutterLayer **layers, size_t layers_count)
void	fl_compositor_opengl_get_frame_size (FlCompositorOpenGL *compositor, size_t *width, size_t *height)
gboolean	fl_compositor_opengl_render (FlCompositorOpenGL *compositor, cairo_t *cr, GdkWindow *window)

Variables
G_BEGIN_DECLS gboolean	shareable

Function Documentation

fl_compositor_opengl_composite_layers()

gboolean fl_compositor_opengl_composite_layers	(	FlCompositorOpenGL *	compositor,
		const FlutterLayer **	layers,
		size_t	layers_count
	)

fl_compositor_opengl_composite_layers: @compositor: an #FlCompositorOpenGL. @layers: layers to be composited. @layers_count: number of layers.

Composite layers into the stored frame using the current OpenGL context.

Returns TRUE if successful.

Definition at line 86 of file fl_compositor_opengl.cc.

                                                                    {
  if (layers_count == 0) {
    return TRUE;
  }
 
  GLint general_format = GL_RGBA;
  if (epoxy_has_gl_extension("GL_EXT_texture_format_BGRA8888")) {
    general_format = GL_BGRA_EXT;
  }
 
  // Save bindings that are set by this function.  All bindings must be restored
  // to their original values because Skia expects that its bindings have not
  // been altered.
  GLint saved_texture_binding;
  glGetIntegerv(GL_TEXTURE_BINDING_2D, &saved_texture_binding);
  GLint saved_vao_binding;
  glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &saved_vao_binding);
  GLint saved_array_buffer_binding;
  glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &saved_array_buffer_binding);
  GLint saved_draw_framebuffer_binding;
  glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &saved_draw_framebuffer_binding);
  GLint saved_read_framebuffer_binding;
  glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, &saved_read_framebuffer_binding);
  GLint saved_current_program;
  glGetIntegerv(GL_CURRENT_PROGRAM, &saved_current_program);
  GLboolean saved_scissor_test = glIsEnabled(GL_SCISSOR_TEST);
  GLboolean saved_blend = glIsEnabled(GL_BLEND);
  GLint saved_src_rgb;
  glGetIntegerv(GL_BLEND_SRC_RGB, &saved_src_rgb);
  GLint saved_src_alpha;
  glGetIntegerv(GL_BLEND_SRC_ALPHA, &saved_src_alpha);
  GLint saved_dst_rgb;
  glGetIntegerv(GL_BLEND_DST_RGB, &saved_dst_rgb);
  GLint saved_dst_alpha;
  glGetIntegerv(GL_BLEND_DST_ALPHA, &saved_dst_alpha);
 
  // Update framebuffer to write into.
  size_t width = layers[0]->size.width;
  size_t height = layers[0]->size.height;
  if (self->framebuffer == nullptr ||
      fl_framebuffer_get_width(self->framebuffer) != width ||
      fl_framebuffer_get_height(self->framebuffer) != height) {
    g_clear_object(&self->framebuffer);
    self->framebuffer =
        fl_framebuffer_new(general_format, width, height, self->shareable);
 
    // If not shareable make buffer to copy frame pixels into.
    if (!self->shareable) {
      size_t data_length = width * height * 4;
      self->pixels =
          static_cast<uint8_t*>(g_realloc(self->pixels, data_length));
    }
  }
 
  // FIXME(robert-ancell): The vertex array is the same for all views, but
  // cannot be shared in OpenGL. Find a way to not generate this every time.
  GLuint vao;
  glGenVertexArrays(1, &vao);
  glBindVertexArray(vao);
 
  glEnable(GL_BLEND);
  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
  fl_compositor_opengl_shader_use(self->shader);
 
  // Disable the scissor test as it can affect blit operations.
  // Prevents regressions like: https://github.com/flutter/flutter/issues/140828
  // See OpenGL specification version 4.6, section 18.3.1.
  glDisable(GL_SCISSOR_TEST);
 
  glBindFramebuffer(GL_DRAW_FRAMEBUFFER,
                    fl_framebuffer_get_id(self->framebuffer));
  gboolean first_layer = TRUE;
  for (size_t i = 0; i < layers_count; ++i) {
    const FlutterLayer* layer = layers[i];
    switch (layer->type) {
      case kFlutterLayerContentTypeBackingStore: {
        const FlutterBackingStore* backing_store = layer->backing_store;
        FlFramebuffer* framebuffer =
            FL_FRAMEBUFFER(backing_store->open_gl.framebuffer.user_data);
        glBindFramebuffer(GL_READ_FRAMEBUFFER,
                          fl_framebuffer_get_id(framebuffer));
        // The first layer can be blitted, and following layers composited with
        // this.
        if (first_layer) {
          glBlitFramebuffer(layer->offset.x, layer->offset.y, layer->size.width,
                            layer->size.height, layer->offset.x,
                            layer->offset.y, layer->size.width,
                            layer->size.height, GL_COLOR_BUFFER_BIT,
                            GL_NEAREST);
          first_layer = FALSE;
        } else {
          composite_layer(self, framebuffer, layer->offset.x, layer->offset.y,
                          width, height);
        }
      } break;
      case kFlutterLayerContentTypePlatformView: {
        // TODO(robert-ancell) Not implemented -
        // https://github.com/flutter/flutter/issues/41724
      } break;
    }
  }
  glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
  glFlush();
 
  glDeleteVertexArrays(1, &vao);
 
  if (saved_blend) {
    glEnable(GL_BLEND);
  } else {
    glDisable(GL_BLEND);
  }
  if (saved_scissor_test) {
    glEnable(GL_SCISSOR_TEST);
  } else {
    glDisable(GL_SCISSOR_TEST);
  }
 
  glBindTexture(GL_TEXTURE_2D, saved_texture_binding);
  glBindVertexArray(saved_vao_binding);
  glBindBuffer(GL_ARRAY_BUFFER, saved_array_buffer_binding);
  glBindFramebuffer(GL_DRAW_FRAMEBUFFER, saved_draw_framebuffer_binding);
  glUseProgram(saved_current_program);
  glBlendFuncSeparate(saved_src_rgb, saved_dst_rgb, saved_src_alpha,
                      saved_dst_alpha);
 
  if (!self->shareable) {
    glBindFramebuffer(GL_READ_FRAMEBUFFER,
                      fl_framebuffer_get_id(self->framebuffer));
    glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, self->pixels);
    glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
  }
  glBindFramebuffer(GL_READ_FRAMEBUFFER, saved_read_framebuffer_binding);
 
  return TRUE;
}

References FlutterLayer::backing_store, composite_layer(), epoxy_has_gl_extension(), fl_compositor_opengl_shader_use(), fl_framebuffer_get_height(), fl_framebuffer_get_id(), fl_framebuffer_get_width(), fl_framebuffer_new(), FlutterOpenGLBackingStore::framebuffer, height, FlutterSize::height, i, kFlutterLayerContentTypeBackingStore, kFlutterLayerContentTypePlatformView, layers, layers_count, FlutterLayer::offset, FlutterBackingStore::open_gl, self, FlutterLayer::size, TRUE, FlutterLayer::type, FlutterOpenGLFramebuffer::user_data, width, FlutterSize::width, FlutterPoint::x, and FlutterPoint::y.

Referenced by fl_view_renderer_opengl_present_layers(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), and TEST_F().

fl_compositor_opengl_get_frame_size()

void fl_compositor_opengl_get_frame_size	(	FlCompositorOpenGL *	compositor,
		size_t *	width,
		size_t *	height
	)

fl_compositor_opengl_get_frame_size: @compositor: an #FlCompositorOpenGL. @width: location to write frame width in pixels. @height: location to write frame height in pixels.

Get the size of the layer ready for rendering.

Definition at line 225 of file fl_compositor_opengl.cc.

                                                         {
  if (width != nullptr) {
    *width = self->framebuffer != nullptr
                 ? fl_framebuffer_get_width(self->framebuffer)
                 : 0;
  }
  if (height != nullptr) {
    *height = self->framebuffer != nullptr
                  ? fl_framebuffer_get_height(self->framebuffer)
                  : 0;
  }
}

References fl_framebuffer_get_height(), fl_framebuffer_get_width(), height, self, and width.

Referenced by G_DEFINE_TYPE(), TEST_F(), TEST_F(), and wait_for_frame().

fl_compositor_opengl_render()

gboolean fl_compositor_opengl_render	(	FlCompositorOpenGL *	compositor,
		cairo_t *	cr,
		GdkWindow *	window
	)

fl_compositor_opengl_render: @compositor: an #FlCompositorOpenGL. @cr: a Cairo rendering context. @window: window being rendered into.

Renders the current frame using the current OpenGL context.

Returns TRUE if successful.

Definition at line 240 of file fl_compositor_opengl.cc.

                                                        {
  if (self->framebuffer == nullptr) {
    return FALSE;
  }
 
  gint scale_factor = gdk_window_get_scale_factor(window);
  size_t width = gdk_window_get_width(window) * scale_factor;
  size_t height = gdk_window_get_height(window) * scale_factor;
 
  if (fl_framebuffer_get_shareable(self->framebuffer)) {
    g_autoptr(FlFramebuffer) sibling =
        fl_framebuffer_create_sibling(self->framebuffer);
    gdk_cairo_draw_from_gl(cr, window, fl_framebuffer_get_texture_id(sibling),
                           GL_TEXTURE, scale_factor, 0, 0, width, height);
  } else {
    GLint saved_texture_binding;
    glGetIntegerv(GL_TEXTURE_BINDING_2D, &saved_texture_binding);
 
    GLuint texture_id;
    glGenTextures(1, &texture_id);
    glBindTexture(GL_TEXTURE_2D, texture_id);
    GLsizei fb_width = 0;
    GLsizei fb_height = 0;
    if (self->framebuffer != nullptr) {
      fb_width =
          static_cast<GLsizei>(fl_framebuffer_get_width(self->framebuffer));
      fb_height =
          static_cast<GLsizei>(fl_framebuffer_get_height(self->framebuffer));
    }
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, fb_width, fb_height, 0, GL_RGBA,
                 GL_UNSIGNED_BYTE, self->pixels);
 
    gdk_cairo_draw_from_gl(cr, window, texture_id, GL_TEXTURE, scale_factor, 0,
                           0, width, height);
 
    glDeleteTextures(1, &texture_id);
 
    glBindTexture(GL_TEXTURE_2D, saved_texture_binding);
  }
 
  glFlush();
 
  return TRUE;
}

References fl_framebuffer_create_sibling(), fl_framebuffer_get_height(), fl_framebuffer_get_shareable(), fl_framebuffer_get_texture_id(), fl_framebuffer_get_width(), g_autoptr(), gdk_cairo_draw_from_gl(), gdk_window_get_height(), gdk_window_get_scale_factor(), gdk_window_get_width(), height, self, texture_id, TRUE, width, and window.

Referenced by fl_view_renderer_opengl_draw(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), and TEST_F().

G_DECLARE_FINAL_TYPE()

G_BEGIN_DECLS G_DECLARE_FINAL_TYPE	(	FlCompositorOpenGL	,
		fl_compositor_opengl	,
		FL	,
		COMPOSITOR_OPENGL	,
		GObject
	)

FlCompositorOpenGL:

#FlCompositorOpenGL is class that implements compositing using OpenGL.

The composited frame is stored in an OpenGL framebuffer (texture).

A frame may be written by fl_compositor_opengl_composite_layers using one OpenGL context and read by fl_compositor_opengl_render using another. When the compositor is created as shareable the two contexts must belong to the same share group so the frame texture can be accessed from both, and the writing context issues a glFlush() so the frame is visible to the reading context. When not shareable the frame is copied to CPU memory by the writing context and uploaded into a new texture by the reading context. fl_compositor_opengl_new: @opengl_manager: an #FlOpenGLManager @shareable: TRUE if the compositor can use a framebuffer that is shared between contexts.

Creates a new OpenGL compositor.

Returns: a new #FlCompositorOpenGL.

Variable Documentation

shareable

G_BEGIN_DECLS gboolean shareable

Definition at line 49 of file fl_compositor_opengl.h.

Referenced by fl_compositor_opengl_new(), fl_framebuffer_new(), and fl_view_renderer_opengl_realize().