fl_compositor_opengl.cc File Reference

#include "fl_compositor_opengl.h"
#include <epoxy/egl.h>
#include <epoxy/gl.h>
#include "flutter/common/constants.h"
#include "flutter/shell/platform/embedder/embedder.h"
#include "flutter/shell/platform/linux/fl_engine_private.h"
#include "flutter/shell/platform/linux/fl_framebuffer.h"

Go to the source code of this file.

Classes
struct	_FlCompositorOpenGL

Functions
	G_DEFINE_TYPE (FlCompositorOpenGL, fl_compositor_opengl, fl_compositor_get_type()) static gchar *get_shader_log(GLuint shader)
static gchar *	get_program_log (GLuint program)
static void	setup_shader (FlCompositorOpenGL *self)
static void	cleanup_shader (FlCompositorOpenGL *self)
static void	composite_layer (FlCompositorOpenGL *self, FlFramebuffer *framebuffer, double x, double y, int width, int height)
static gboolean	fl_compositor_opengl_present_layers (FlCompositor *compositor, const FlutterLayer **layers, size_t layers_count)
static void	fl_compositor_opengl_get_frame_size (FlCompositor *compositor, size_t *width, size_t *height)
static gboolean	fl_compositor_opengl_render (FlCompositor *compositor, cairo_t *cr, GdkWindow *window, gboolean wait_for_frame)
static void	fl_compositor_opengl_dispose (GObject *object)
static void	fl_compositor_opengl_class_init (FlCompositorOpenGLClass *klass)
static void	fl_compositor_opengl_init (FlCompositorOpenGL *self)
FlCompositorOpenGL *	fl_compositor_opengl_new (FlTaskRunner *task_runner, FlOpenGLManager *opengl_manager, gboolean shareable)

Variables
static const char *	vertex_shader_src
static const char *	fragment_shader_src

Function Documentation

cleanup_shader()

static void cleanup_shader ( FlCompositorOpenGL *  self )

static

Definition at line 171 of file fl_compositor_opengl.cc.

                                                     {
  if (!fl_opengl_manager_make_platform_current(self->opengl_manager)) {
    g_warning(
        "Failed to cleanup compositor shaders, unable to make OpenGL context "
        "current");
    return;
  }
 
  if (self->program != 0) {
    glDeleteProgram(self->program);
  }
  if (self->vertex_buffer != 0) {
    glDeleteBuffers(1, &self->vertex_buffer);
  }
}

References fl_opengl_manager_make_platform_current(), and self.

Referenced by fl_compositor_opengl_dispose().

composite_layer()

static void composite_layer ( FlCompositorOpenGL *  self, FlFramebuffer *  framebuffer, double  x, double  y, int  width, int  height  )

static

Definition at line 187 of file fl_compositor_opengl.cc.

                                        {
  size_t texture_width = fl_framebuffer_get_width(framebuffer);
  size_t texture_height = fl_framebuffer_get_height(framebuffer);
  glUniform2f(self->offset_location, (2 * x / width) - 1.0,
              (2 * y / width) - 1.0);
  glUniform2f(self->scale_location, texture_width / width,
              texture_height / height);
 
  GLuint texture_id = fl_framebuffer_get_texture_id(framebuffer);
  glBindTexture(GL_TEXTURE_2D, texture_id);
 
  glDrawArrays(GL_TRIANGLES, 0, 6);
}

References fl_framebuffer_get_height(), fl_framebuffer_get_texture_id(), fl_framebuffer_get_width(), height, self, texture_id, width, x, and y.

Referenced by fl_compositor_opengl_present_layers().

fl_compositor_opengl_class_init()

static void fl_compositor_opengl_class_init ( FlCompositorOpenGLClass *  klass )

static

Definition at line 470 of file fl_compositor_opengl.cc.

                                                                            {
  FL_COMPOSITOR_CLASS(klass)->present_layers =
      fl_compositor_opengl_present_layers;
  FL_COMPOSITOR_CLASS(klass)->get_frame_size =
      fl_compositor_opengl_get_frame_size;
  FL_COMPOSITOR_CLASS(klass)->render = fl_compositor_opengl_render;
 
  G_OBJECT_CLASS(klass)->dispose = fl_compositor_opengl_dispose;
}

References fl_compositor_opengl_dispose(), fl_compositor_opengl_get_frame_size(), fl_compositor_opengl_present_layers(), and fl_compositor_opengl_render().

fl_compositor_opengl_dispose()

static void fl_compositor_opengl_dispose ( GObject *  object )

static

Definition at line 456 of file fl_compositor_opengl.cc.

                                                          {
  FlCompositorOpenGL* self = FL_COMPOSITOR_OPENGL(object);
 
  cleanup_shader(self);
 
  g_clear_object(&self->task_runner);
  g_clear_object(&self->opengl_manager);
  g_clear_object(&self->framebuffer);
  g_clear_pointer(&self->pixels, g_free);
  g_mutex_clear(&self->frame_mutex);
 
  G_OBJECT_CLASS(fl_compositor_opengl_parent_class)->dispose(object);
}

References cleanup_shader(), and self.

Referenced by fl_compositor_opengl_class_init().

fl_compositor_opengl_get_frame_size()

static void fl_compositor_opengl_get_frame_size ( FlCompositor *  compositor, size_t *  width, size_t *  height  )

static

Definition at line 365 of file fl_compositor_opengl.cc.

                                                                {
  FlCompositorOpenGL* self = FL_COMPOSITOR_OPENGL(compositor);
 
  g_autoptr(GMutexLocker) locker = g_mutex_locker_new(&self->frame_mutex);
 
  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(), g_autoptr(), height, self, and width.

Referenced by fl_compositor_opengl_class_init().

fl_compositor_opengl_init()

static void fl_compositor_opengl_init ( FlCompositorOpenGL *  self )

static

Definition at line 480 of file fl_compositor_opengl.cc.

                                                                {
  g_mutex_init(&self->frame_mutex);
}

References self.

fl_compositor_opengl_new()

FlCompositorOpenGL * fl_compositor_opengl_new	(	FlTaskRunner *	task_runner,
		FlOpenGLManager *	opengl_manager,
		gboolean	shareable
	)

Definition at line 484 of file fl_compositor_opengl.cc.

                                                                 {
  FlCompositorOpenGL* self = FL_COMPOSITOR_OPENGL(
      g_object_new(fl_compositor_opengl_get_type(), nullptr));
 
  self->task_runner = FL_TASK_RUNNER(g_object_ref(task_runner));
  self->shareable = shareable;
  self->opengl_manager = FL_OPENGL_MANAGER(g_object_ref(opengl_manager));
 
  setup_shader(self);
 
  return self;
}

References opengl_manager, self, setup_shader(), and shareable.

Referenced by setup_opengl(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), and TEST().

fl_compositor_opengl_present_layers()

static gboolean fl_compositor_opengl_present_layers ( FlCompositor *  compositor, const FlutterLayer **  layers, size_t  layers_count  )

static

Definition at line 206 of file fl_compositor_opengl.cc.

                                                                         {
  FlCompositorOpenGL* self = FL_COMPOSITOR_OPENGL(compositor);
 
  g_mutex_lock(&self->frame_mutex);
  if (layers_count == 0) {
    g_mutex_unlock(&self->frame_mutex);
    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));
    }
  }
 
  self->had_first_frame = true;
 
  // 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);
  glBindBuffer(GL_ARRAY_BUFFER, self->vertex_buffer);
  GLint position_location = glGetAttribLocation(self->program, "position");
  glEnableVertexAttribArray(position_location);
  glVertexAttribPointer(position_location, 2, GL_FLOAT, GL_FALSE,
                        sizeof(GLfloat) * 4, 0);
  GLint texcoord_location = glGetAttribLocation(self->program, "in_texcoord");
  glEnableVertexAttribArray(texcoord_location);
  glVertexAttribPointer(texcoord_location, 2, GL_FLOAT, GL_FALSE,
                        sizeof(GLfloat) * 4,
                        reinterpret_cast<void*>(sizeof(GLfloat) * 2));
 
  glEnable(GL_BLEND);
  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
  glUseProgram(self->program);
 
  // 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);
 
  g_mutex_unlock(&self->frame_mutex);
 
  fl_task_runner_stop_wait(self->task_runner);
 
  return TRUE;
}

References FlutterLayer::backing_store, composite_layer(), epoxy_has_gl_extension(), fl_framebuffer_get_height(), fl_framebuffer_get_id(), fl_framebuffer_get_width(), fl_framebuffer_new(), fl_task_runner_stop_wait(), 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_compositor_opengl_class_init().

fl_compositor_opengl_render()

static gboolean fl_compositor_opengl_render ( FlCompositor *  compositor, cairo_t *  cr, GdkWindow *  window, gboolean  wait_for_frame  )

static

Definition at line 384 of file fl_compositor_opengl.cc.

                                                                     {
  FlCompositorOpenGL* self = FL_COMPOSITOR_OPENGL(compositor);
 
  g_mutex_lock(&self->frame_mutex);
  if (self->framebuffer == nullptr) {
    g_mutex_unlock(&self->frame_mutex);
    return FALSE;
  }
 
  // If frame not ready, then wait for it.
  gint scale_factor = gdk_window_get_scale_factor(window);
  size_t width, height;
  gint64 expiry_time =
      g_get_monotonic_time() + kCompositorRenderTimeoutMicroseconds;
  while (true) {
    width = gdk_window_get_width(window) * scale_factor;
    height = gdk_window_get_height(window) * scale_factor;
    if (!wait_for_frame) {
      break;
    }
 
    size_t framebuffer_width = fl_framebuffer_get_width(self->framebuffer);
    size_t framebuffer_height = fl_framebuffer_get_height(self->framebuffer);
    if (framebuffer_width == width && framebuffer_height == height) {
      break;
    }
 
    if (g_get_monotonic_time() > expiry_time) {
      g_warning(
          "Timed out waiting for OpenGL frame of size %zdx%zd (have %zdx%zd)",
          width, height, framebuffer_width, framebuffer_height);
      break;
    }
 
    g_mutex_unlock(&self->frame_mutex);
    fl_task_runner_wait(self->task_runner, expiry_time);
    g_mutex_lock(&self->frame_mutex);
  }
 
  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);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, 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();
 
  g_mutex_unlock(&self->frame_mutex);
 
  return TRUE;
}

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

Referenced by fl_compositor_opengl_class_init().

G_DEFINE_TYPE()

G_DEFINE_TYPE	(	FlCompositorOpenGL	,
		fl_compositor_opengl	,
		fl_compositor_get_type()
	)

Definition at line 82 of file fl_compositor_opengl.cc.

                                            {
  GLint log_length;
  gchar* log;
 
  glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &log_length);
 
  log = static_cast<gchar*>(g_malloc(log_length + 1));
  glGetShaderInfoLog(shader, log_length, nullptr, log);
 
  return log;
}

get_program_log()

static gchar * get_program_log ( GLuint  program )

static

Definition at line 100 of file fl_compositor_opengl.cc.

                                              {
  GLint log_length;
  gchar* log;
 
  glGetProgramiv(program, GL_INFO_LOG_LENGTH, &log_length);
 
  log = static_cast<gchar*>(g_malloc(log_length + 1));
  glGetProgramInfoLog(program, log_length, nullptr, log);
 
  return log;
}

Referenced by setup_shader().

setup_shader()

static void setup_shader ( FlCompositorOpenGL *  self )

static

Definition at line 112 of file fl_compositor_opengl.cc.

                                                   {
  if (!fl_opengl_manager_make_platform_current(self->opengl_manager)) {
    g_warning(
        "Failed to setup compositor shaders, unable to make OpenGL context "
        "current");
    return;
  }
 
  GLuint vertex_shader = glCreateShader(GL_VERTEX_SHADER);
  glShaderSource(vertex_shader, 1, &vertex_shader_src, nullptr);
  glCompileShader(vertex_shader);
  GLint vertex_compile_status;
  glGetShaderiv(vertex_shader, GL_COMPILE_STATUS, &vertex_compile_status);
  if (vertex_compile_status == GL_FALSE) {
    g_autofree gchar* shader_log = get_shader_log(vertex_shader);
    g_warning("Failed to compile vertex shader: %s", shader_log);
  }
 
  GLuint fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
  glShaderSource(fragment_shader, 1, &fragment_shader_src, nullptr);
  glCompileShader(fragment_shader);
  GLint fragment_compile_status;
  glGetShaderiv(fragment_shader, GL_COMPILE_STATUS, &fragment_compile_status);
  if (fragment_compile_status == GL_FALSE) {
    g_autofree gchar* shader_log = get_shader_log(fragment_shader);
    g_warning("Failed to compile fragment shader: %s", shader_log);
  }
 
  self->program = glCreateProgram();
  glAttachShader(self->program, vertex_shader);
  glAttachShader(self->program, fragment_shader);
  glLinkProgram(self->program);
 
  GLint link_status;
  glGetProgramiv(self->program, GL_LINK_STATUS, &link_status);
  if (link_status == GL_FALSE) {
    g_autofree gchar* program_log = get_program_log(self->program);
    g_warning("Failed to link program: %s", program_log);
  }
 
  self->offset_location = glGetUniformLocation(self->program, "offset");
  self->scale_location = glGetUniformLocation(self->program, "scale");
 
  glDeleteShader(vertex_shader);
  glDeleteShader(fragment_shader);
 
  // The uniform square abcd in two triangles cba + cdb
  // a--b
  // |  |
  // c--d
  GLfloat vertex_data[] = {-1, -1, 0, 0, 1, 1,  1, 1, -1, 1, 0, 1,
                           -1, -1, 0, 0, 1, -1, 1, 0, 1,  1, 1, 1};
 
  glGenBuffers(1, &self->vertex_buffer);
  glBindBuffer(GL_ARRAY_BUFFER, self->vertex_buffer);
  glBufferData(GL_ARRAY_BUFFER, sizeof(vertex_data), vertex_data,
               GL_STATIC_DRAW);
}

References fl_opengl_manager_make_platform_current(), fragment_shader_src, get_program_log(), self, and vertex_shader_src.

Referenced by fl_compositor_opengl_new().

Variable Documentation

fragment_shader_src

const char* fragment_shader_src

static

Initial value:

=
    "#ifdef GL_ES\n"
    "precision mediump float;\n"
    "#endif\n"
    "\n"
    "uniform sampler2D texture;\n"
    "varying vec2 texcoord;\n"
    "\n"
    "void main() {\n"
    "  gl_FragColor = texture2D(texture, texcoord);\n"
    "}\n"

Definition at line 29 of file fl_compositor_opengl.cc.

Referenced by setup_shader().

vertex_shader_src

const char* vertex_shader_src

static

Initial value:

=
    "attribute vec2 position;\n"
    "attribute vec2 in_texcoord;\n"
    "uniform vec2 offset;\n"
    "uniform vec2 scale;\n"
    "varying vec2 texcoord;\n"
    "\n"
    "void main() {\n"
    "  gl_Position = vec4(offset + position * scale, 0, 1);\n"
    "  texcoord = in_texcoord;\n"
    "}\n"

Definition at line 16 of file fl_compositor_opengl.cc.

Referenced by setup_shader().