diff --git a/Android.mk b/Android.mk
index 5eef35f..e20615e 100644
--- a/Android.mk
+++ b/Android.mk
@@ -49,6 +49,7 @@
 	drmplane.cpp \
 	drmproperty.cpp \
 	gl_compositor.cpp \
+	glworker.cpp \
 	hwcomposer.cpp \
 	seperate_rects.cpp \
 	vsyncworker.cpp \
diff --git a/gl_compositor.cpp b/gl_compositor.cpp
index 38f1e03..0605c04 100644
--- a/gl_compositor.cpp
+++ b/gl_compositor.cpp
@@ -17,50 +17,23 @@
 #define ATRACE_TAG ATRACE_TAG_GRAPHICS
 #define LOG_TAG "GLCompositor"
 
-#include <sstream>
-#include <string>
 #include <vector>
 
 #include <cutils/log.h>
 
-#define EGL_EGLEXT_PROTOTYPES
-#define GL_GLEXT_PROTOTYPES
-
-#include <EGL/egl.h>
-#include <EGL/eglext.h>
-#include <GLES2/gl2.h>
-#include <GLES2/gl2ext.h>
-
-#include <hardware/hardware.h>
-#include <hardware/hwcomposer.h>
-
 #include <ui/GraphicBuffer.h>
-#include <ui/PixelFormat.h>
 #include <utils/Trace.h>
 
-#include <cutils/properties.h>
 #include <sync/sync.h>
 #include <sw_sync.h>
 
 #include "drm_hwcomposer.h"
 
 #include "gl_compositor.h"
-#include "seperate_rects.h"
-
-// TODO(zachr): use hwc_drm_bo to turn buffer handles into textures
-#ifndef EGL_NATIVE_HANDLE_ANDROID_NVX
-#define EGL_NATIVE_HANDLE_ANDROID_NVX 0x322A
-#endif
-
-#define MAX_OVERLAPPING_LAYERS 64
+#include "glworker.h"
 
 namespace android {
 
-struct GLCompositor::texture_from_handle {
-  EGLImageKHR image;
-  GLuint texture;
-};
-
 static const char *get_gl_error(void);
 static const char *get_egl_error(void);
 static bool has_extension(const char *extension, const char *extensions);
@@ -89,58 +62,31 @@
 
 struct GLTarget {
   sp<GraphicBuffer> fb;
-  EGLImageKHR egl_fb_image;
-  GLuint gl_fb;
-  GLuint gl_fb_tex;
   bool forgotten;
   unsigned composition_count;
 
-  GLTarget()
-      : egl_fb_image(EGL_NO_IMAGE_KHR),
-        gl_fb(0),
-        gl_fb_tex(0),
-        forgotten(true),
-        composition_count(0) {
+  GLTarget() : forgotten(true), composition_count(0) {
   }
 
   void Reset() {
     fb.clear();
-    egl_fb_image = EGL_NO_IMAGE_KHR;
-    gl_fb = 0;
-    gl_fb_tex = 0;
     forgotten = true;
     composition_count = 0;
   }
 
   bool is_some() const {
-    return egl_fb_image != EGL_NO_IMAGE_KHR;
+    return fb != NULL;
   }
 };
 
 struct GLCompositor::priv_data {
-  EGLDisplay egl_display;
-  EGLContext egl_ctx;
-
-  EGLDisplay saved_egl_display;
-  EGLContext saved_egl_ctx;
-  EGLSurface saved_egl_read;
-  EGLSurface saved_egl_draw;
-
   int current_target;
   std::vector<GLTarget> targets;
   std::vector<GLComposition *> compositions;
 
-  std::vector<GLint> blend_programs;
-  GLuint vertex_buffer;
+  GLWorker worker;
 
-  priv_data()
-      : egl_display(EGL_NO_DISPLAY),
-        egl_ctx(EGL_NO_CONTEXT),
-        saved_egl_display(EGL_NO_DISPLAY),
-        saved_egl_ctx(EGL_NO_CONTEXT),
-        saved_egl_read(EGL_NO_SURFACE),
-        saved_egl_draw(EGL_NO_SURFACE),
-        current_target(-1) {
+  priv_data() : current_target(-1) {
   }
 };
 
@@ -152,10 +98,18 @@
   };
 
   GLComposition(GLCompositor *owner, Importer *imp)
-      : compositor(owner), importer(imp), target_handle(-1) {
+      : compositor(owner), importer(imp), target_handle(-1), timeline_fd(-1) {
+    int ret = sw_sync_timeline_create();
+    if (ret < 0) {
+      ALOGE("Failed to create sw sync timeline %d", ret);
+    }
+    timeline_fd = ret;
   }
 
   virtual ~GLComposition() {
+    if (timeline_fd >= 0)
+      close(timeline_fd);
+
     if (compositor == NULL) {
       return;
     }
@@ -186,10 +140,10 @@
       return 1;
     }
 
-    layer_data.push_back(LayerData());
-    LayerData &layer_datum = layer_data.back();
-    layer_datum.layer = *layer;
-    layer_datum.bo = *bo;
+    layer->releaseFenceFd = sw_sync_fence_create(
+        timeline_fd, "GLComposition release fence", layers.size() + 1);
+
+    layers.push_back(*layer);
 
     return importer->ReleaseBuffer(bo);
   }
@@ -202,114 +156,15 @@
   GLCompositor *compositor;
   Importer *importer;
   int target_handle;
-  std::vector<LayerData> layer_data;
+  int timeline_fd;
+  std::vector<hwc_layer_1> layers;
 };
 
-struct RenderingCommand {
-  struct TextureSource {
-    unsigned texture_index;
-    float crop_bounds[4];
-    float alpha;
-  };
-
-  float bounds[4];
-  unsigned texture_count;
-  TextureSource textures[MAX_OVERLAPPING_LAYERS];
-
-  RenderingCommand() : texture_count(0) {
-  }
-};
-
-static void ConstructCommands(const GLComposition &composition,
-                              std::vector<RenderingCommand> *commands) {
-  std::vector<seperate_rects::Rect<float> > in_rects;
-  std::vector<seperate_rects::RectSet<uint64_t, float> > out_rects;
-  int i;
-
-  for (unsigned rect_index = 0; rect_index < composition.layer_data.size();
-       rect_index++) {
-    const struct hwc_layer_1 &layer = composition.layer_data[rect_index].layer;
-    seperate_rects::Rect<float> rect;
-    in_rects.push_back(seperate_rects::Rect<float>(
-        layer.displayFrame.left, layer.displayFrame.top,
-        layer.displayFrame.right, layer.displayFrame.bottom));
-  }
-
-  seperate_frects_64(in_rects, &out_rects);
-
-  for (unsigned rect_index = 0; rect_index < out_rects.size(); rect_index++) {
-    const seperate_rects::RectSet<uint64_t, float> &out_rect =
-        out_rects[rect_index];
-    commands->push_back(RenderingCommand());
-    RenderingCommand &cmd = commands->back();
-
-    memcpy(cmd.bounds, out_rect.rect.bounds, sizeof(cmd.bounds));
-
-    uint64_t tex_set = out_rect.id_set.getBits();
-    for (unsigned i = composition.layer_data.size() - 1; tex_set != 0x0; i--) {
-      if (tex_set & (0x1 << i)) {
-        tex_set &= ~(0x1 << i);
-
-        const struct hwc_layer_1 &layer = composition.layer_data[i].layer;
-
-        seperate_rects::Rect<float> display_rect(
-            layer.displayFrame.left, layer.displayFrame.top,
-            layer.displayFrame.right, layer.displayFrame.bottom);
-        float display_size[2] = {
-            display_rect.bounds[2] - display_rect.bounds[0],
-            display_rect.bounds[3] - display_rect.bounds[1]};
-
-        seperate_rects::Rect<float> crop_rect(
-            layer.sourceCropf.left, layer.sourceCropf.top,
-            layer.sourceCropf.right, layer.sourceCropf.bottom);
-        float crop_size[2] = {crop_rect.bounds[2] - crop_rect.bounds[0],
-                              crop_rect.bounds[3] - crop_rect.bounds[1]};
-
-        RenderingCommand::TextureSource &src = cmd.textures[cmd.texture_count];
-        cmd.texture_count++;
-        src.texture_index = i;
-
-        for (int b = 0; b < 4; b++) {
-          float bound_percent = (cmd.bounds[b] - display_rect.bounds[b % 2]) /
-                                display_size[b % 2];
-          src.crop_bounds[b] =
-              crop_rect.bounds[b % 2] + bound_percent * crop_size[b % 2];
-        }
-
-        if (layer.blending == HWC_BLENDING_NONE) {
-          src.alpha = 1.0f;
-          // This layer is opaque. There is no point in using layers below this
-          // one.
-          break;
-        }
-
-        src.alpha = layer.planeAlpha / 255.0f;
-      }
-    }
-  }
-}
-
 GLCompositor::GLCompositor() {
   priv_ = new priv_data;
 }
 
 GLCompositor::~GLCompositor() {
-  if (BeginContext()) {
-    goto destroy_ctx;
-  }
-
-  glBindFramebuffer(GL_FRAMEBUFFER, 0);
-  glBindTexture(GL_TEXTURE_2D, 0);
-
-  for (std::vector<GLTarget>::iterator it = priv_->targets.end();
-       it != priv_->targets.begin(); it = priv_->targets.end()) {
-    --it;
-    glDeleteFramebuffers(1, &it->gl_fb);
-    glDeleteTextures(1, &it->gl_fb_tex);
-    eglDestroyImageKHR(priv_->egl_display, it->egl_fb_image);
-    priv_->targets.erase(it);
-  }
-
   for (std::vector<GLComposition *>::iterator it = priv_->compositions.end();
        it != priv_->compositions.begin(); it = priv_->compositions.end()) {
     --it;
@@ -320,111 +175,11 @@
     priv_->compositions.erase(it);
   }
 
-destroy_ctx:
-  eglMakeCurrent(priv_->egl_display,
-                 EGL_NO_SURFACE /* No default draw surface */,
-                 EGL_NO_SURFACE /* No default draw read */, EGL_NO_CONTEXT);
-  eglDestroyContext(priv_->egl_display, priv_->egl_ctx);
-
-  EndContext();
   delete priv_;
 }
 
 int GLCompositor::Init() {
-  int ret = 0;
-  const char *egl_extensions;
-  const char *gl_extensions;
-  EGLint num_configs;
-  EGLint attribs[] = {EGL_WIDTH, 1, EGL_HEIGHT, 1, EGL_NONE, EGL_NONE};
-  EGLConfig egl_config;
-
-  // clang-format off
-  const GLfloat verts[] = {
-    0.0f,  0.0f,    0.0f, 0.0f,
-    0.0f,  1.0f,    0.0f, 1.0f,
-    1.0f,  0.0f,    1.0f, 0.0f,
-    1.0f,  1.0f,    1.0f, 1.0f
-  };
-  // clang-format on
-
-  const EGLint config_attribs[] = {EGL_RENDERABLE_TYPE,
-                                   EGL_OPENGL_ES2_BIT,
-                                   EGL_RED_SIZE,
-                                   8,
-                                   EGL_GREEN_SIZE,
-                                   8,
-                                   EGL_BLUE_SIZE,
-                                   8,
-                                   EGL_NONE};
-
-  const EGLint context_attribs[] = {EGL_CONTEXT_CLIENT_VERSION, 3, EGL_NONE};
-
-  priv_->egl_display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
-  if (priv_->egl_display == EGL_NO_DISPLAY) {
-    ALOGE("Failed to get egl display");
-    ret = 1;
-    goto out;
-  }
-
-  if (!eglInitialize(priv_->egl_display, NULL, NULL)) {
-    ALOGE("Failed to initialize egl: %s", get_egl_error());
-    ret = 1;
-    goto out;
-  }
-
-  egl_extensions = eglQueryString(priv_->egl_display, EGL_EXTENSIONS);
-
-  // These extensions are all technically required but not always reported due
-  // to meta EGL filtering them out.
-  if (!has_extension("EGL_KHR_image_base", egl_extensions))
-    ALOGW("EGL_KHR_image_base extension not supported");
-
-  if (!has_extension("EGL_ANDROID_image_native_buffer", egl_extensions))
-    ALOGW("EGL_ANDROID_image_native_buffer extension not supported");
-
-  if (!has_extension("EGL_ANDROID_native_fence_sync", egl_extensions))
-    ALOGW("EGL_ANDROID_native_fence_sync extension not supported");
-
-  if (!eglChooseConfig(priv_->egl_display, config_attribs, &egl_config, 1,
-                       &num_configs)) {
-    ALOGE("eglChooseConfig() failed with error: %s", get_egl_error());
-    goto out;
-  }
-
-  priv_->egl_ctx =
-      eglCreateContext(priv_->egl_display, egl_config,
-                       EGL_NO_CONTEXT /* No shared context */, context_attribs);
-
-  if (priv_->egl_ctx == EGL_NO_CONTEXT) {
-    ALOGE("Failed to create OpenGL ES Context: %s", get_egl_error());
-    ret = 1;
-    goto out;
-  }
-
-  ret = BeginContext();
-  if (ret)
-    goto out;
-
-  gl_extensions = (const char *)glGetString(GL_EXTENSIONS);
-
-  if (!has_extension("GL_OES_EGL_image", gl_extensions))
-    ALOGW("GL_OES_EGL_image extension not supported");
-
-  glGenBuffers(1, &priv_->vertex_buffer);
-  glBindBuffer(GL_ARRAY_BUFFER, priv_->vertex_buffer);
-  glBufferData(GL_ARRAY_BUFFER, sizeof(verts), verts, GL_STATIC_DRAW);
-  glBindBuffer(GL_ARRAY_BUFFER, 0);
-
-  if (GenerateShaders()) {
-    ret = 1;
-    goto end_ctx;
-  }
-
-end_ctx:
-  EndContext();
-
-out:
-  return ret;
+  return priv_->worker.Init();
 }
 
 Targeting *GLCompositor::targeting() {
@@ -434,63 +189,13 @@
 int GLCompositor::CreateTarget(sp<GraphicBuffer> &buffer) {
   int ret;
 
-  ret = BeginContext();
-  if (ret)
-    return -1;
-
   int target_handle = AllocResource(priv_->targets);
   GLTarget *target = &priv_->targets[target_handle];
 
   target->fb = buffer;
-
-  target->egl_fb_image = eglCreateImageKHR(
-      priv_->egl_display, EGL_NO_CONTEXT, EGL_NATIVE_BUFFER_ANDROID,
-      (EGLClientBuffer)target->fb->getNativeBuffer(), NULL /* no attribs */);
-
-  if (target->egl_fb_image == EGL_NO_IMAGE_KHR) {
-    ALOGE("Failed to make image from target buffer: %s", get_egl_error());
-    ret = -1;
-    goto fail_create_image;
-  }
-
-  glGenTextures(1, &target->gl_fb_tex);
-  glBindTexture(GL_TEXTURE_2D, target->gl_fb_tex);
-  glEGLImageTargetTexture2DOES(GL_TEXTURE_2D,
-                               (GLeglImageOES)target->egl_fb_image);
-  glBindTexture(GL_TEXTURE_2D, 0);
-
-  glGenFramebuffers(1, &target->gl_fb);
-  glBindFramebuffer(GL_FRAMEBUFFER, target->gl_fb);
-  glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
-                         target->gl_fb_tex, 0);
-
-  if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
-    ALOGE("Failed framebuffer check for created target buffer");
-    ret = 1;
-    goto fail_framebuffer_status;
-  }
-
   target->forgotten = false;
 
-  ret = target_handle;
-  goto out;
-
-fail_framebuffer_status:
-  glBindFramebuffer(GL_FRAMEBUFFER, 0);
-  glDeleteFramebuffers(1, &target->gl_fb);
-  glDeleteTextures(1, &target->gl_fb_tex);
-  eglDestroyImageKHR(priv_->egl_display, target->egl_fb_image);
-  target->gl_fb = 0;
-  target->gl_fb_tex = 0;
-  target->egl_fb_image = EGL_NO_IMAGE_KHR;
-
-fail_create_image:
-  target->fb.clear();
-  FreeResource(priv_->targets, target_handle);
-
-out:
-  EndContext();
-  return ret;
+  return target_handle;
 }
 
 void GLCompositor::SetTarget(int target_handle) {
@@ -525,13 +230,6 @@
 void GLCompositor::CheckAndDestroyTarget(int target_handle) {
   GLTarget *target = &priv_->targets[target_handle];
   if (target->composition_count == 0 && target->forgotten) {
-    if (BeginContext() == 0) {
-      glDeleteFramebuffers(1, &target->gl_fb);
-      glDeleteTextures(1, &target->gl_fb_tex);
-      eglDestroyImageKHR(priv_->egl_display, target->egl_fb_image);
-      EndContext();
-    }
-
     FreeResource(priv_->targets, target_handle);
   }
 }
@@ -557,7 +255,9 @@
 
 int GLCompositor::QueueComposition(Composition *composition) {
   if (composition) {
-    int ret = DoComposition(*(GLComposition *)composition);
+    GLComposition *gl_composition = (GLComposition *)composition;
+    int ret = DoComposition(gl_composition);
+    gl_composition->timeline_fd = -1;
     delete composition;
     return ret;
   }
@@ -571,454 +271,25 @@
   return 0;
 }
 
-int GLCompositor::BeginContext() {
-  priv_->saved_egl_display = eglGetCurrentDisplay();
-  priv_->saved_egl_ctx = eglGetCurrentContext();
-
-  if (priv_->saved_egl_display != priv_->egl_display ||
-      priv_->saved_egl_ctx != priv_->egl_ctx) {
-    priv_->saved_egl_read = eglGetCurrentSurface(EGL_READ);
-    priv_->saved_egl_draw = eglGetCurrentSurface(EGL_DRAW);
-  } else {
-    return 0;
-  }
-
-  if (!eglMakeCurrent(priv_->egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE,
-                      priv_->egl_ctx)) {
-    ALOGE("Failed to make the OpenGL ES Context current: %s", get_egl_error());
-    return 1;
-  }
-  return 0;
-}
-
-int GLCompositor::EndContext() {
-  if (priv_->saved_egl_display != eglGetCurrentDisplay() ||
-      priv_->saved_egl_ctx != eglGetCurrentContext()) {
-    if (!eglMakeCurrent(priv_->saved_egl_display, priv_->saved_egl_read,
-                        priv_->saved_egl_draw, priv_->saved_egl_ctx)) {
-      ALOGE("Failed to make the old OpenGL ES Context current: %s",
-            get_egl_error());
-      return 1;
-    }
-  }
-
-  return 0;
-}
-
-GLint CompileAndCheckShader(GLenum type, unsigned source_count,
-                            const GLchar **sources, std::string *shader_log) {
-  GLint status;
-  GLint shader = glCreateShader(type);
-  if (!shader) {
-    *shader_log = "glCreateShader failed";
-    return 0;
-  }
-  glShaderSource(shader, source_count, sources, NULL);
-  glCompileShader(shader);
-  glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
-  if (!status) {
-    if (shader_log) {
-      GLint log_length;
-      glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &log_length);
-      shader_log->resize(log_length);
-      glGetShaderInfoLog(shader, log_length, NULL, &(*shader_log)[0]);
-    }
-    glDeleteShader(shader);
-    return 0;
-  }
-
-  return shader;
-}
-
-int GLCompositor::GenerateShaders() {
-  // Limits: GL_MAX_VARYING_COMPONENTS, GL_MAX_TEXTURE_IMAGE_UNITS,
-  // GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS
-  // clang-format off
-  const GLchar *shader_preamble = "#version 300 es\n#define LAYER_COUNT ";
-
-  const GLchar *vertex_shader_source =
-"\n"
-"precision mediump int;                                                     \n"
-"uniform vec4 uViewport;                                                    \n"
-"uniform sampler2D uLayerTextures[LAYER_COUNT];                             \n"
-"uniform vec4 uLayerCrop[LAYER_COUNT];                                      \n"
-"in vec2 vPosition;                                                         \n"
-"in vec2 vTexCoords;                                                        \n"
-"out vec2 fTexCoords[LAYER_COUNT];                                          \n"
-"void main() {                                                              \n"
-"  for (int i = 0; i < LAYER_COUNT; i++) {                                  \n"
-"    fTexCoords[i] = (uLayerCrop[i].xy + vTexCoords * uLayerCrop[i].zw) /   \n"
-"                     vec2(textureSize(uLayerTextures[i], 0));              \n"
-"  }                                                                        \n"
-"  vec2 scaledPosition = uViewport.xy + vPosition * uViewport.zw;           \n"
-"  gl_Position = vec4(scaledPosition * vec2(2.0) - vec2(1.0), 0.0, 1.0);    \n"
-"}                                                                          \n";
-
-  const GLchar *fragment_shader_source =
-"\n"
-"precision mediump float;                                                   \n"
-"uniform sampler2D uLayerTextures[LAYER_COUNT];                             \n"
-"uniform float uLayerAlpha[LAYER_COUNT];                                    \n"
-"in vec2 fTexCoords[LAYER_COUNT];                                           \n"
-"out vec4 oFragColor;                                                       \n"
-"void main() {                                                              \n"
-"  vec3 color = vec3(0.0, 0.0, 0.0);                                        \n"
-"  float alphaCover = 1.0;                                                  \n"
-"  for (int i = 0; i < LAYER_COUNT; i++) {                                  \n"
-"    vec4 texSample = texture(uLayerTextures[i], fTexCoords[i]);            \n"
-"    float a = texSample.a * uLayerAlpha[i];                                \n"
-"    color += a * alphaCover * texSample.rgb;                               \n"
-"    alphaCover *= 1.0 - a;                                                 \n"
-"    if (alphaCover <= 0.5/255.0)                                           \n"
-"      break;                                                               \n"
-"  }                                                                        \n"
-"  oFragColor = vec4(color, 1.0 - alphaCover);                              \n"
-"}                                                                          \n";
-  // clang-format on
-
-  int i, ret = 1;
-  GLint max_texture_images, vertex_shader, fragment_shader, program, status;
-  std::string shader_log;
-
-  glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &max_texture_images);
-
-  for (i = 1; i <= max_texture_images; i++) {
-    std::ostringstream layer_count_formatter;
-    layer_count_formatter << i;
-    std::string layer_count(layer_count_formatter.str());
-    const GLchar *shader_sources[3] = {shader_preamble, layer_count.c_str(),
-                                       NULL};
-
-    shader_sources[2] = vertex_shader_source;
-    vertex_shader = CompileAndCheckShader(GL_VERTEX_SHADER, 3, shader_sources,
-                                          ret ? &shader_log : NULL);
-    if (!vertex_shader) {
-      if (ret) {
-        ALOGE("Failed to make vertex shader:\n%s", shader_log.c_str());
-      }
-      break;
-    }
-
-    shader_sources[2] = fragment_shader_source;
-    fragment_shader = CompileAndCheckShader(
-        GL_FRAGMENT_SHADER, 3, shader_sources, ret ? &shader_log : NULL);
-    if (!fragment_shader) {
-      if (ret) {
-        ALOGE("Failed to make fragment shader:\n%s", shader_log.c_str());
-      }
-      goto delete_vs;
-    }
-
-    program = glCreateProgram();
-    if (!program) {
-      if (ret)
-        ALOGE("Failed to create program %s", get_gl_error());
-      goto delete_fs;
-    }
-
-    glAttachShader(program, vertex_shader);
-    glAttachShader(program, fragment_shader);
-    glBindAttribLocation(program, 0, "vPosition");
-    glBindAttribLocation(program, 1, "vTexCoords");
-    glLinkProgram(program);
-    glDetachShader(program, vertex_shader);
-    glDeleteShader(vertex_shader);
-    glDetachShader(program, fragment_shader);
-    glDeleteShader(fragment_shader);
-
-    glGetProgramiv(program, GL_LINK_STATUS, &status);
-    if (!status) {
-      if (ret) {
-        GLint log_length;
-        glGetProgramiv(program, GL_INFO_LOG_LENGTH, &log_length);
-        std::string program_log(log_length, ' ');
-        glGetProgramInfoLog(program, log_length, NULL, &program_log[0]);
-        ALOGE("Failed to link program: \n%s", program_log.c_str());
-      }
-      glDeleteProgram(program);
-      break;
-    }
-
-    ret = 0;
-    priv_->blend_programs.push_back(program);
-
-    continue;
-
-  delete_fs:
-    glDeleteShader(fragment_shader);
-
-  delete_vs:
-    glDeleteShader(vertex_shader);
-
-    if (ret)
-      break;
-  }
-
-  return ret;
-}
-
-int GLCompositor::DoComposition(const GLComposition &composition) {
+int GLCompositor::DoComposition(GLComposition *composition) {
   ATRACE_CALL();
   int ret = 0;
-  size_t i;
-  std::vector<struct texture_from_handle> layer_textures;
-  std::vector<RenderingCommand> commands;
 
-  if (composition.layer_data.size() == 0) {
-    return -EALREADY;
+  GLTarget *target = &priv_->targets[composition->target_handle];
+  GLWorker::Work work;
+  work.layers = composition->layers.data();
+  work.num_layers = composition->layers.size();
+  work.timeline_fd = composition->timeline_fd;
+  work.framebuffer = target->fb;
+
+  ret = priv_->worker.DoWork(&work);
+
+  if (work.timeline_fd >= 0) {
+    sw_sync_timeline_inc(work.timeline_fd, work.num_layers + 1);
+    close(work.timeline_fd);
   }
 
-  if (BeginContext()) {
-    return -EINVAL;
-  }
-
-  GLTarget *target = &priv_->targets[composition.target_handle];
-  GLint frame_width = target->fb->getWidth();
-  GLint frame_height = target->fb->getHeight();
-  EGLSyncKHR finished_sync;
-
-  for (i = 0; i < composition.layer_data.size(); i++) {
-    const struct hwc_layer_1 *layer = &composition.layer_data[i].layer;
-
-    if (ret) {
-      if (layer->acquireFenceFd >= 0)
-        close(layer->acquireFenceFd);
-      continue;
-    }
-
-    layer_textures.push_back(texture_from_handle());
-    ret = CreateTextureFromHandle(layer->handle, &layer_textures.back());
-    if (!ret) {
-      ret = DoFenceWait(layer->acquireFenceFd);
-    }
-    if (ret) {
-      layer_textures.pop_back();
-      ret = -EINVAL;
-    }
-  }
-
-  if (ret) {
-    goto destroy_textures;
-  }
-
-  ConstructCommands(composition, &commands);
-
-  glBindFramebuffer(GL_FRAMEBUFFER, target->gl_fb);
-
-  glViewport(0, 0, frame_width, frame_height);
-
-  glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
-  glClear(GL_COLOR_BUFFER_BIT);
-
-  glBindBuffer(GL_ARRAY_BUFFER, priv_->vertex_buffer);
-  glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 4, NULL);
-  glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 4,
-                        (void *)(sizeof(float) * 2));
-  glEnableVertexAttribArray(0);
-  glEnableVertexAttribArray(1);
-
-  for (std::vector<RenderingCommand>::iterator it = commands.begin();
-       it != commands.end(); ++it) {
-    const RenderingCommand &cmd = *it;
-
-    if (cmd.texture_count <= 0) {
-      continue;
-    }
-
-    // TODO(zachr): handle the case of too many overlapping textures for one
-    // area by falling back to rendering as many layers as possible using
-    // multiple blending passes.
-    if (cmd.texture_count > priv_->blend_programs.size()) {
-      ALOGE("Too many layers to render in one area");
-      continue;
-    }
-
-    GLint program = priv_->blend_programs[cmd.texture_count - 1];
-    glUseProgram(program);
-    GLint gl_viewport_loc = glGetUniformLocation(program, "uViewport");
-    GLint gl_tex_loc = glGetUniformLocation(program, "uLayerTextures");
-    GLint gl_crop_loc = glGetUniformLocation(program, "uLayerCrop");
-    GLint gl_alpha_loc = glGetUniformLocation(program, "uLayerAlpha");
-    glUniform4f(gl_viewport_loc, cmd.bounds[0] / (float)frame_width,
-                cmd.bounds[1] / (float)frame_height,
-                (cmd.bounds[2] - cmd.bounds[0]) / (float)frame_width,
-                (cmd.bounds[3] - cmd.bounds[1]) / (float)frame_height);
-
-    for (unsigned src_index = 0; src_index < cmd.texture_count; src_index++) {
-      const RenderingCommand::TextureSource &src = cmd.textures[src_index];
-      glUniform1f(gl_alpha_loc + src_index, src.alpha);
-      glUniform4f(gl_crop_loc + src_index, src.crop_bounds[0],
-                  src.crop_bounds[1], src.crop_bounds[2] - src.crop_bounds[0],
-                  src.crop_bounds[3] - src.crop_bounds[1]);
-
-      glUniform1i(gl_tex_loc + src_index, src_index);
-      glActiveTexture(GL_TEXTURE0 + src_index);
-      glBindTexture(GL_TEXTURE_2D, layer_textures[src.texture_index].texture);
-    }
-
-    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
-
-    for (unsigned src_index = 0; src_index < cmd.texture_count; src_index++) {
-      glActiveTexture(GL_TEXTURE0 + src_index);
-      glBindTexture(GL_TEXTURE_2D, 0);
-    }
-  }
-
-  glActiveTexture(GL_TEXTURE0);
-  glDisableVertexAttribArray(0);
-  glDisableVertexAttribArray(1);
-  glBindBuffer(GL_ARRAY_BUFFER, 0);
-  glUseProgram(0);
-
-  glBindFramebuffer(GL_FRAMEBUFFER, 0);
-
-  finished_sync =
-      eglCreateSyncKHR(priv_->egl_display, EGL_SYNC_NATIVE_FENCE_ANDROID, NULL);
-  if (finished_sync != EGL_NO_SYNC_KHR) {
-    glFlush();  // Creates the syncpoint
-    ret = eglDupNativeFenceFDANDROID(priv_->egl_display, finished_sync);
-    eglDestroySyncKHR(priv_->egl_display, finished_sync);
-    if (ret != EGL_NO_NATIVE_FENCE_FD_ANDROID) {
-      goto destroy_textures;
-    }
-  }
-
-  // Used as a fallback if the native sync fence fails.
-  ret = -EALREADY;
-  glFinish();
-
-destroy_textures:
-  for (i = 0; i < layer_textures.size(); i++)
-    DestroyTextureFromHandle(layer_textures[i]);
-
-  EndContext();
-
   return ret;
 }
 
-int GLCompositor::DoFenceWait(int acquireFenceFd) {
-  int ret = 0;
-
-  EGLint attribs[] = {EGL_SYNC_NATIVE_FENCE_FD_ANDROID, acquireFenceFd,
-                      EGL_NONE};
-  EGLSyncKHR egl_sync = eglCreateSyncKHR(
-      priv_->egl_display, EGL_SYNC_NATIVE_FENCE_ANDROID, attribs);
-  if (egl_sync == EGL_NO_SYNC_KHR) {
-    ALOGE("Failed to make EGLSyncKHR from acquireFenceFd: %s", get_egl_error());
-    close(acquireFenceFd);
-    return 1;
-  }
-
-  EGLint success = eglWaitSyncKHR(priv_->egl_display, egl_sync, 0);
-  if (success == EGL_FALSE) {
-    ALOGE("Failed to wait for acquire: %s", get_egl_error());
-    ret = 1;
-  }
-  eglDestroySyncKHR(priv_->egl_display, egl_sync);
-
-  return ret;
-}
-
-int GLCompositor::CreateTextureFromHandle(buffer_handle_t handle,
-                                          struct texture_from_handle *tex) {
-  EGLImageKHR image = eglCreateImageKHR(
-      priv_->egl_display, EGL_NO_CONTEXT, EGL_NATIVE_HANDLE_ANDROID_NVX,
-      (EGLClientBuffer)handle, NULL /* no attribs */);
-
-  if (image == EGL_NO_IMAGE_KHR) {
-    ALOGE("Failed to make image %s %p", get_egl_error(), handle);
-    return 1;
-  }
-
-  glGenTextures(1, &tex->texture);
-  glBindTexture(GL_TEXTURE_2D, tex->texture);
-  glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, (GLeglImageOES)image);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-
-  tex->image = image;
-
-  return 0;
-}
-
-void GLCompositor::DestroyTextureFromHandle(
-    const struct texture_from_handle &tex) {
-  glDeleteTextures(1, &tex.texture);
-  eglDestroyImageKHR(priv_->egl_display, tex.image);
-}
-
-static const char *get_gl_error(void) {
-  switch (glGetError()) {
-    case GL_NO_ERROR:
-      return "GL_NO_ERROR";
-    case GL_INVALID_ENUM:
-      return "GL_INVALID_ENUM";
-    case GL_INVALID_VALUE:
-      return "GL_INVALID_VALUE";
-    case GL_INVALID_OPERATION:
-      return "GL_INVALID_OPERATION";
-    case GL_INVALID_FRAMEBUFFER_OPERATION:
-      return "GL_INVALID_FRAMEBUFFER_OPERATION";
-    case GL_OUT_OF_MEMORY:
-      return "GL_OUT_OF_MEMORY";
-    default:
-      return "Unknown error";
-  }
-}
-
-static const char *get_egl_error(void) {
-  switch (eglGetError()) {
-    case EGL_SUCCESS:
-      return "EGL_SUCCESS";
-    case EGL_NOT_INITIALIZED:
-      return "EGL_NOT_INITIALIZED";
-    case EGL_BAD_ACCESS:
-      return "EGL_BAD_ACCESS";
-    case EGL_BAD_ALLOC:
-      return "EGL_BAD_ALLOC";
-    case EGL_BAD_ATTRIBUTE:
-      return "EGL_BAD_ATTRIBUTE";
-    case EGL_BAD_CONTEXT:
-      return "EGL_BAD_CONTEXT";
-    case EGL_BAD_CONFIG:
-      return "EGL_BAD_CONFIG";
-    case EGL_BAD_CURRENT_SURFACE:
-      return "EGL_BAD_CURRENT_SURFACE";
-    case EGL_BAD_DISPLAY:
-      return "EGL_BAD_DISPLAY";
-    case EGL_BAD_SURFACE:
-      return "EGL_BAD_SURFACE";
-    case EGL_BAD_MATCH:
-      return "EGL_BAD_MATCH";
-    case EGL_BAD_PARAMETER:
-      return "EGL_BAD_PARAMETER";
-    case EGL_BAD_NATIVE_PIXMAP:
-      return "EGL_BAD_NATIVE_PIXMAP";
-    case EGL_BAD_NATIVE_WINDOW:
-      return "EGL_BAD_NATIVE_WINDOW";
-    case EGL_CONTEXT_LOST:
-      return "EGL_CONTEXT_LOST";
-    default:
-      return "Unknown error";
-  }
-}
-
-static bool has_extension(const char *extension, const char *extensions) {
-  const char *start, *where, *terminator;
-  start = extensions;
-  for (;;) {
-    where = (char *)strstr((const char *)start, extension);
-    if (!where)
-      break;
-    terminator = where + strlen(extension);
-    if (where == start || *(where - 1) == ' ')
-      if (*terminator == ' ' || *terminator == '\0')
-        return true;
-    start = terminator;
-  }
-  return false;
-}
-
 }  // namespace android
diff --git a/gl_compositor.h b/gl_compositor.h
index 528d8ac..450ca67 100644
--- a/gl_compositor.h
+++ b/gl_compositor.h
@@ -48,7 +48,7 @@
   int BeginContext();
   int EndContext();
   int GenerateShaders();
-  int DoComposition(const GLComposition &composition);
+  int DoComposition(GLComposition *composition);
   int DoFenceWait(int acquireFenceFd);
   int CreateTextureFromHandle(buffer_handle_t handle,
                               struct texture_from_handle *tex);
diff --git a/glworker.cpp b/glworker.cpp
new file mode 100644
index 0000000..b2deb3e
--- /dev/null
+++ b/glworker.cpp
@@ -0,0 +1,846 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define ATRACE_TAG ATRACE_TAG_GRAPHICS
+#define LOG_TAG "GLWorker"
+
+#include <string>
+#include <sstream>
+
+#include <sys/resource.h>
+
+#include <sync/sync.h>
+#include <sw_sync.h>
+
+#include <hardware/hardware.h>
+#include <hardware/hwcomposer.h>
+
+#include <ui/GraphicBuffer.h>
+#include <ui/PixelFormat.h>
+
+#include <utils/Trace.h>
+
+#include "glworker.h"
+
+#include "seperate_rects.h"
+
+// TODO(zachr): use hwc_drm_bo to turn buffer handles into textures
+#ifndef EGL_NATIVE_HANDLE_ANDROID_NVX
+#define EGL_NATIVE_HANDLE_ANDROID_NVX 0x322A
+#endif
+
+#define MAX_OVERLAPPING_LAYERS 64
+
+namespace android {
+
+typedef seperate_rects::Rect<float> FRect;
+typedef seperate_rects::RectSet<uint64_t, float> FRectSet;
+
+static const char *GetGLError(void) {
+  switch (glGetError()) {
+    case GL_NO_ERROR:
+      return "GL_NO_ERROR";
+    case GL_INVALID_ENUM:
+      return "GL_INVALID_ENUM";
+    case GL_INVALID_VALUE:
+      return "GL_INVALID_VALUE";
+    case GL_INVALID_OPERATION:
+      return "GL_INVALID_OPERATION";
+    case GL_INVALID_FRAMEBUFFER_OPERATION:
+      return "GL_INVALID_FRAMEBUFFER_OPERATION";
+    case GL_OUT_OF_MEMORY:
+      return "GL_OUT_OF_MEMORY";
+    default:
+      return "Unknown error";
+  }
+}
+
+static const char *GetGLFramebufferError(void) {
+  switch (glCheckFramebufferStatus(GL_FRAMEBUFFER)) {
+    case GL_FRAMEBUFFER_COMPLETE:
+      return "GL_FRAMEBUFFER_COMPLETE";
+    case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
+      return "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT";
+    case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
+      return "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT";
+    case GL_FRAMEBUFFER_UNSUPPORTED:
+      return "GL_FRAMEBUFFER_UNSUPPORTED";
+    case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
+      return "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS";
+    default:
+      return "Unknown error";
+  }
+}
+
+static const char *GetEGLError(void) {
+  switch (eglGetError()) {
+    case EGL_SUCCESS:
+      return "EGL_SUCCESS";
+    case EGL_NOT_INITIALIZED:
+      return "EGL_NOT_INITIALIZED";
+    case EGL_BAD_ACCESS:
+      return "EGL_BAD_ACCESS";
+    case EGL_BAD_ALLOC:
+      return "EGL_BAD_ALLOC";
+    case EGL_BAD_ATTRIBUTE:
+      return "EGL_BAD_ATTRIBUTE";
+    case EGL_BAD_CONTEXT:
+      return "EGL_BAD_CONTEXT";
+    case EGL_BAD_CONFIG:
+      return "EGL_BAD_CONFIG";
+    case EGL_BAD_CURRENT_SURFACE:
+      return "EGL_BAD_CURRENT_SURFACE";
+    case EGL_BAD_DISPLAY:
+      return "EGL_BAD_DISPLAY";
+    case EGL_BAD_SURFACE:
+      return "EGL_BAD_SURFACE";
+    case EGL_BAD_MATCH:
+      return "EGL_BAD_MATCH";
+    case EGL_BAD_PARAMETER:
+      return "EGL_BAD_PARAMETER";
+    case EGL_BAD_NATIVE_PIXMAP:
+      return "EGL_BAD_NATIVE_PIXMAP";
+    case EGL_BAD_NATIVE_WINDOW:
+      return "EGL_BAD_NATIVE_WINDOW";
+    case EGL_CONTEXT_LOST:
+      return "EGL_CONTEXT_LOST";
+    default:
+      return "Unknown error";
+  }
+}
+
+static bool HasExtension(const char *extension, const char *extensions) {
+  const char *start, *where, *terminator;
+  start = extensions;
+  for (;;) {
+    where = (char *)strstr((const char *)start, extension);
+    if (!where)
+      break;
+    terminator = where + strlen(extension);
+    if (where == start || *(where - 1) == ' ')
+      if (*terminator == ' ' || *terminator == '\0')
+        return true;
+    start = terminator;
+  }
+  return false;
+}
+
+static AutoGLShader CompileAndCheckShader(GLenum type, unsigned source_count,
+                                          const GLchar **sources,
+                                          std::string *shader_log) {
+  GLint status;
+  AutoGLShader shader(glCreateShader(type));
+  if (shader.get() == 0) {
+    *shader_log = "glCreateShader failed";
+    return 0;
+  }
+  glShaderSource(shader.get(), source_count, sources, NULL);
+  glCompileShader(shader.get());
+  glGetShaderiv(shader.get(), GL_COMPILE_STATUS, &status);
+  if (!status) {
+    if (shader_log) {
+      GLint log_length;
+      glGetShaderiv(shader.get(), GL_INFO_LOG_LENGTH, &log_length);
+      shader_log->resize(log_length);
+      glGetShaderInfoLog(shader.get(), log_length, NULL, &(*shader_log)[0]);
+    }
+    return 0;
+  }
+
+  return shader;
+}
+
+static int GenerateShaders(std::vector<AutoGLProgram> *blend_programs) {
+  // Limits: GL_MAX_VARYING_COMPONENTS, GL_MAX_TEXTURE_IMAGE_UNITS,
+  // GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS
+  // clang-format off
+  const GLchar *shader_preamble = "#version 300 es\n#define LAYER_COUNT ";
+
+  const GLchar *vertex_shader_source =
+"\n"
+"precision mediump int;                                                     \n"
+"uniform vec4 uViewport;                                                    \n"
+"uniform sampler2D uLayerTextures[LAYER_COUNT];                             \n"
+"uniform vec4 uLayerCrop[LAYER_COUNT];                                      \n"
+"in vec2 vPosition;                                                         \n"
+"in vec2 vTexCoords;                                                        \n"
+"out vec2 fTexCoords[LAYER_COUNT];                                          \n"
+"void main() {                                                              \n"
+"  for (int i = 0; i < LAYER_COUNT; i++) {                                  \n"
+"    fTexCoords[i] = (uLayerCrop[i].xy + vTexCoords * uLayerCrop[i].zw) /   \n"
+"                     vec2(textureSize(uLayerTextures[i], 0));              \n"
+"  }                                                                        \n"
+"  vec2 scaledPosition = uViewport.xy + vPosition * uViewport.zw;           \n"
+"  gl_Position = vec4(scaledPosition * vec2(2.0) - vec2(1.0), 0.0, 1.0);    \n"
+"}                                                                          \n";
+
+  const GLchar *fragment_shader_source =
+"\n"
+"precision mediump float;                                                   \n"
+"uniform sampler2D uLayerTextures[LAYER_COUNT];                             \n"
+"uniform float uLayerAlpha[LAYER_COUNT];                                    \n"
+"in vec2 fTexCoords[LAYER_COUNT];                                           \n"
+"out vec4 oFragColor;                                                       \n"
+"void main() {                                                              \n"
+"  vec3 color = vec3(0.0, 0.0, 0.0);                                        \n"
+"  float alphaCover = 1.0;                                                  \n"
+"  for (int i = 0; i < LAYER_COUNT; i++) {                                  \n"
+"    vec4 texSample = texture(uLayerTextures[i], fTexCoords[i]);            \n"
+"    float a = texSample.a * uLayerAlpha[i];                                \n"
+"    color += a * alphaCover * texSample.rgb;                               \n"
+"    alphaCover *= 1.0 - a;                                                 \n"
+"    if (alphaCover <= 0.5/255.0)                                           \n"
+"      break;                                                               \n"
+"  }                                                                        \n"
+"  oFragColor = vec4(color, 1.0 - alphaCover);                              \n"
+"}                                                                          \n";
+  // clang-format on
+
+  int i, ret = 1;
+  GLint max_texture_images, status;
+  AutoGLShader vertex_shader, fragment_shader;
+  AutoGLProgram program;
+  std::string shader_log;
+
+  glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &max_texture_images);
+
+  for (i = 1; i <= max_texture_images; i++) {
+    std::ostringstream layer_count_formatter;
+    layer_count_formatter << i;
+    std::string layer_count(layer_count_formatter.str());
+    const GLchar *shader_sources[3] = {shader_preamble, layer_count.c_str(),
+                                       NULL};
+
+    shader_sources[2] = vertex_shader_source;
+    vertex_shader = CompileAndCheckShader(GL_VERTEX_SHADER, 3, shader_sources,
+                                          ret ? &shader_log : NULL);
+    if (!vertex_shader.get()) {
+      if (ret)
+        ALOGE("Failed to make vertex shader:\n%s", shader_log.c_str());
+      break;
+    }
+
+    shader_sources[2] = fragment_shader_source;
+    fragment_shader = CompileAndCheckShader(
+        GL_FRAGMENT_SHADER, 3, shader_sources, ret ? &shader_log : NULL);
+    if (!fragment_shader.get()) {
+      if (ret)
+        ALOGE("Failed to make fragment shader:\n%s", shader_log.c_str());
+      break;
+    }
+
+    program = AutoGLProgram(glCreateProgram());
+    if (!program.get()) {
+      if (ret)
+        ALOGE("Failed to create program %s", GetGLError());
+      break;
+    }
+
+    glAttachShader(program.get(), vertex_shader.get());
+    glAttachShader(program.get(), fragment_shader.get());
+    glBindAttribLocation(program.get(), 0, "vPosition");
+    glBindAttribLocation(program.get(), 1, "vTexCoords");
+    glLinkProgram(program.get());
+    glDetachShader(program.get(), vertex_shader.get());
+    glDetachShader(program.get(), fragment_shader.get());
+
+    glGetProgramiv(program.get(), GL_LINK_STATUS, &status);
+    if (!status) {
+      if (ret) {
+        GLint log_length;
+        glGetProgramiv(program.get(), GL_INFO_LOG_LENGTH, &log_length);
+        std::string program_log(log_length, ' ');
+        glGetProgramInfoLog(program.get(), log_length, NULL, &program_log[0]);
+        ALOGE("Failed to link program: \n%s", program_log.c_str());
+      }
+      break;
+    }
+
+    ret = 0;
+    blend_programs->emplace_back(std::move(program));
+  }
+
+  return ret;
+}
+
+struct RenderingCommand {
+  struct TextureSource {
+    unsigned texture_index;
+    float crop_bounds[4];
+    float alpha;
+  };
+
+  float bounds[4];
+  unsigned texture_count;
+  TextureSource textures[MAX_OVERLAPPING_LAYERS];
+
+  RenderingCommand() : texture_count(0) {
+  }
+};
+
+static void ConstructCommands(const hwc_layer_1 *layers, size_t num_layers,
+                              std::vector<RenderingCommand> *commands) {
+  std::vector<FRect> in_rects;
+  std::vector<FRectSet> out_rects;
+  int i;
+
+  for (unsigned rect_index = 0; rect_index < num_layers; rect_index++) {
+    const hwc_layer_1 &layer = layers[rect_index];
+    FRect rect;
+    in_rects.push_back(FRect(layer.displayFrame.left, layer.displayFrame.top,
+                             layer.displayFrame.right,
+                             layer.displayFrame.bottom));
+  }
+
+  seperate_frects_64(in_rects, &out_rects);
+
+  for (unsigned rect_index = 0; rect_index < out_rects.size(); rect_index++) {
+    const FRectSet &out_rect = out_rects[rect_index];
+    commands->push_back(RenderingCommand());
+    RenderingCommand &cmd = commands->back();
+
+    memcpy(cmd.bounds, out_rect.rect.bounds, sizeof(cmd.bounds));
+
+    uint64_t tex_set = out_rect.id_set.getBits();
+    for (unsigned i = num_layers - 1; tex_set != 0x0; i--) {
+      if (tex_set & (0x1 << i)) {
+        tex_set &= ~(0x1 << i);
+
+        const hwc_layer_1 &layer = layers[i];
+
+        FRect display_rect(layer.displayFrame.left, layer.displayFrame.top,
+                           layer.displayFrame.right, layer.displayFrame.bottom);
+        float display_size[2] = {
+            display_rect.bounds[2] - display_rect.bounds[0],
+            display_rect.bounds[3] - display_rect.bounds[1]};
+
+        FRect crop_rect(layer.sourceCropf.left, layer.sourceCropf.top,
+                        layer.sourceCropf.right, layer.sourceCropf.bottom);
+        float crop_size[2] = {crop_rect.bounds[2] - crop_rect.bounds[0],
+                              crop_rect.bounds[3] - crop_rect.bounds[1]};
+
+        RenderingCommand::TextureSource &src = cmd.textures[cmd.texture_count];
+        cmd.texture_count++;
+        src.texture_index = i;
+
+        for (int b = 0; b < 4; b++) {
+          float bound_percent = (cmd.bounds[b] - display_rect.bounds[b % 2]) /
+                                display_size[b % 2];
+          src.crop_bounds[b] =
+              crop_rect.bounds[b % 2] + bound_percent * crop_size[b % 2];
+        }
+
+        if (layer.blending == HWC_BLENDING_NONE) {
+          src.alpha = 1.0f;
+          // This layer is opaque. There is no point in using layers below this
+          // one.
+          break;
+        }
+
+        src.alpha = layer.planeAlpha / 255.0f;
+      }
+    }
+  }
+}
+
+static int EGLFenceWait(EGLDisplay egl_display, int acquireFenceFd) {
+  int ret = 0;
+
+  EGLint attribs[] = {EGL_SYNC_NATIVE_FENCE_FD_ANDROID, acquireFenceFd,
+                      EGL_NONE};
+  EGLSyncKHR egl_sync =
+      eglCreateSyncKHR(egl_display, EGL_SYNC_NATIVE_FENCE_ANDROID, attribs);
+  if (egl_sync == EGL_NO_SYNC_KHR) {
+    ALOGE("Failed to make EGLSyncKHR from acquireFenceFd: %s", GetEGLError());
+    close(acquireFenceFd);
+    return 1;
+  }
+
+  EGLint success = eglWaitSyncKHR(egl_display, egl_sync, 0);
+  if (success == EGL_FALSE) {
+    ALOGE("Failed to wait for acquire: %s", GetEGLError());
+    ret = 1;
+  }
+  eglDestroySyncKHR(egl_display, egl_sync);
+
+  return ret;
+}
+
+static int CreateTextureFromHandle(EGLDisplay egl_display,
+                                   buffer_handle_t handle,
+                                   AutoEGLImageAndGLTexture *out) {
+  EGLImageKHR image = eglCreateImageKHR(
+      egl_display, EGL_NO_CONTEXT, EGL_NATIVE_HANDLE_ANDROID_NVX,
+      (EGLClientBuffer)handle, NULL /* no attribs */);
+
+  if (image == EGL_NO_IMAGE_KHR) {
+    ALOGE("Failed to make image %s %p", GetEGLError(), handle);
+    return -EINVAL;
+  }
+
+  GLuint texture;
+  glGenTextures(1, &texture);
+  glBindTexture(GL_TEXTURE_2D, texture);
+  glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, (GLeglImageOES)image);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+  glBindTexture(GL_TEXTURE_2D, 0);
+
+  out->image.reset(image);
+  out->texture.reset(texture);
+
+  return 0;
+}
+
+GLWorker::Compositor::Compositor()
+    : egl_display_(EGL_NO_DISPLAY), egl_ctx_(EGL_NO_CONTEXT) {
+}
+
+int GLWorker::Compositor::Init() {
+  int ret = 0;
+  const char *egl_extensions;
+  const char *gl_extensions;
+  EGLint num_configs;
+  EGLint attribs[] = {EGL_WIDTH, 1, EGL_HEIGHT, 1, EGL_NONE, EGL_NONE};
+  EGLConfig egl_config;
+
+  // clang-format off
+  const GLfloat verts[] = {
+    0.0f,  0.0f,    0.0f, 0.0f,
+    0.0f,  2.0f,    0.0f, 2.0f,
+    2.0f,  0.0f,    2.0f, 0.0f
+  };
+  // clang-format on
+
+  const EGLint config_attribs[] = {EGL_RENDERABLE_TYPE,
+                                   EGL_OPENGL_ES2_BIT,
+                                   EGL_RED_SIZE,
+                                   8,
+                                   EGL_GREEN_SIZE,
+                                   8,
+                                   EGL_BLUE_SIZE,
+                                   8,
+                                   EGL_NONE};
+
+  const EGLint context_attribs[] = {EGL_CONTEXT_CLIENT_VERSION, 3, EGL_NONE};
+
+  egl_display_ = eglGetDisplay(EGL_DEFAULT_DISPLAY);
+  if (egl_display_ == EGL_NO_DISPLAY) {
+    ALOGE("Failed to get egl display");
+    return 1;
+  }
+
+  if (!eglInitialize(egl_display_, NULL, NULL)) {
+    ALOGE("Failed to initialize egl: %s", GetEGLError());
+    return 1;
+  }
+
+  egl_extensions = eglQueryString(egl_display_, EGL_EXTENSIONS);
+
+  // These extensions are all technically required but not always reported due
+  // to meta EGL filtering them out.
+  if (!HasExtension("EGL_KHR_image_base", egl_extensions))
+    ALOGW("EGL_KHR_image_base extension not supported");
+
+  if (!HasExtension("EGL_ANDROID_image_native_buffer", egl_extensions))
+    ALOGW("EGL_ANDROID_image_native_buffer extension not supported");
+
+  if (!HasExtension("EGL_ANDROID_native_fence_sync", egl_extensions))
+    ALOGW("EGL_ANDROID_native_fence_sync extension not supported");
+
+  if (!eglChooseConfig(egl_display_, config_attribs, &egl_config, 1,
+                       &num_configs)) {
+    ALOGE("eglChooseConfig() failed with error: %s", GetEGLError());
+    return 1;
+  }
+
+  egl_ctx_ =
+      eglCreateContext(egl_display_, egl_config,
+                       EGL_NO_CONTEXT /* No shared context */, context_attribs);
+
+  if (egl_ctx_ == EGL_NO_CONTEXT) {
+    ALOGE("Failed to create OpenGL ES Context: %s", GetEGLError());
+    return 1;
+  }
+
+  if (!eglMakeCurrent(egl_display_, EGL_NO_SURFACE, EGL_NO_SURFACE, egl_ctx_)) {
+    ALOGE("Failed to make the OpenGL ES Context current: %s", GetEGLError());
+    return 1;
+  }
+
+  gl_extensions = (const char *)glGetString(GL_EXTENSIONS);
+
+  if (!HasExtension("GL_OES_EGL_image", gl_extensions))
+    ALOGW("GL_OES_EGL_image extension not supported");
+
+  GLuint vertex_buffer;
+  glGenBuffers(1, &vertex_buffer);
+  glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);
+  glBufferData(GL_ARRAY_BUFFER, sizeof(verts), verts, GL_STATIC_DRAW);
+  glBindBuffer(GL_ARRAY_BUFFER, 0);
+  vertex_buffer_.reset(vertex_buffer);
+
+  if (GenerateShaders(&blend_programs_)) {
+    return 1;
+  }
+
+  return 0;
+}
+
+GLWorker::Compositor::~Compositor() {
+  if (egl_display_ != EGL_NO_DISPLAY && egl_ctx_ != EGL_NO_CONTEXT)
+    if (eglDestroyContext(egl_display_, egl_ctx_) == EGL_FALSE)
+      ALOGE("Failed to destroy OpenGL ES Context: %s", GetEGLError());
+}
+
+int GLWorker::Compositor::Composite(hwc_layer_1 *layers, size_t num_layers,
+                                    sp<GraphicBuffer> framebuffer) {
+  ATRACE_CALL();
+  int ret = 0;
+  size_t i;
+  std::vector<AutoEGLImageAndGLTexture> layer_textures;
+  std::vector<RenderingCommand> commands;
+
+  if (num_layers == 0) {
+    return -EALREADY;
+  }
+
+  GLint frame_width = framebuffer->getWidth();
+  GLint frame_height = framebuffer->getHeight();
+  EGLSyncKHR finished_sync;
+
+  AutoEGLImageKHR egl_fb_image(
+      eglCreateImageKHR(egl_display_, EGL_NO_CONTEXT, EGL_NATIVE_BUFFER_ANDROID,
+                        (EGLClientBuffer)framebuffer->getNativeBuffer(),
+                        NULL /* no attribs */),
+      EGLImageDeleter(egl_display_));
+
+  if (egl_fb_image.get() == EGL_NO_IMAGE_KHR) {
+    ALOGE("Failed to make image from target buffer: %s", GetEGLError());
+    return -EINVAL;
+  }
+
+  GLuint gl_fb_tex;
+  glGenTextures(1, &gl_fb_tex);
+  AutoGLTexture gl_fb_tex_auto(gl_fb_tex);
+  glBindTexture(GL_TEXTURE_2D, gl_fb_tex);
+  glEGLImageTargetTexture2DOES(GL_TEXTURE_2D,
+                               (GLeglImageOES)egl_fb_image.get());
+  glBindTexture(GL_TEXTURE_2D, 0);
+
+  GLuint gl_fb;
+  glGenFramebuffers(1, &gl_fb);
+  AutoGLFramebuffer gl_fb_auto(gl_fb);
+  glBindFramebuffer(GL_FRAMEBUFFER, gl_fb);
+  glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
+                         gl_fb_tex, 0);
+
+  if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
+    ALOGE("Failed framebuffer check for created target buffer: %s",
+          GetGLFramebufferError());
+    return -EINVAL;
+  }
+
+  for (i = 0; i < num_layers; i++) {
+    const struct hwc_layer_1 *layer = &layers[i];
+
+    if (ret) {
+      if (layer->acquireFenceFd >= 0)
+        close(layer->acquireFenceFd);
+      continue;
+    }
+
+    layer_textures.emplace_back(egl_display_);
+    ret = CreateTextureFromHandle(egl_display_, layer->handle,
+                                  &layer_textures.back());
+    if (!ret) {
+      ret = EGLFenceWait(egl_display_, layer->acquireFenceFd);
+    }
+    if (ret) {
+      layer_textures.pop_back();
+      ret = -EINVAL;
+    }
+  }
+
+  if (ret)
+    return ret;
+
+  ConstructCommands(layers, num_layers, &commands);
+
+  glViewport(0, 0, frame_width, frame_height);
+
+  glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
+  glClear(GL_COLOR_BUFFER_BIT);
+
+  glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer_.get());
+  glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 4, NULL);
+  glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 4,
+                        (void *)(sizeof(float) * 2));
+  glEnableVertexAttribArray(0);
+  glEnableVertexAttribArray(1);
+  glEnable(GL_SCISSOR_TEST);
+
+  for (const RenderingCommand &cmd : commands) {
+    if (cmd.texture_count <= 0) {
+      continue;
+    }
+
+    // TODO(zachr): handle the case of too many overlapping textures for one
+    // area by falling back to rendering as many layers as possible using
+    // multiple blending passes.
+    if (cmd.texture_count > blend_programs_.size()) {
+      ALOGE("Too many layers to render in one area");
+      continue;
+    }
+
+    GLint program = blend_programs_[cmd.texture_count - 1].get();
+    glUseProgram(program);
+    GLint gl_viewport_loc = glGetUniformLocation(program, "uViewport");
+    GLint gl_tex_loc = glGetUniformLocation(program, "uLayerTextures");
+    GLint gl_crop_loc = glGetUniformLocation(program, "uLayerCrop");
+    GLint gl_alpha_loc = glGetUniformLocation(program, "uLayerAlpha");
+    glUniform4f(gl_viewport_loc, cmd.bounds[0] / (float)frame_width,
+                cmd.bounds[1] / (float)frame_height,
+                (cmd.bounds[2] - cmd.bounds[0]) / (float)frame_width,
+                (cmd.bounds[3] - cmd.bounds[1]) / (float)frame_height);
+
+    for (unsigned src_index = 0; src_index < cmd.texture_count; src_index++) {
+      const RenderingCommand::TextureSource &src = cmd.textures[src_index];
+      glUniform1f(gl_alpha_loc + src_index, src.alpha);
+      glUniform4f(gl_crop_loc + src_index, src.crop_bounds[0],
+                  src.crop_bounds[1], src.crop_bounds[2] - src.crop_bounds[0],
+                  src.crop_bounds[3] - src.crop_bounds[1]);
+
+      glUniform1i(gl_tex_loc + src_index, src_index);
+      glActiveTexture(GL_TEXTURE0 + src_index);
+      glBindTexture(GL_TEXTURE_2D,
+                    layer_textures[src.texture_index].texture.get());
+    }
+
+    glScissor(cmd.bounds[0], cmd.bounds[1], cmd.bounds[2] - cmd.bounds[0],
+              cmd.bounds[3] - cmd.bounds[1]);
+    glDrawArrays(GL_TRIANGLES, 0, 3);
+
+    for (unsigned src_index = 0; src_index < cmd.texture_count; src_index++) {
+      glActiveTexture(GL_TEXTURE0 + src_index);
+      glBindTexture(GL_TEXTURE_2D, 0);
+    }
+  }
+
+  glDisable(GL_SCISSOR_TEST);
+  glActiveTexture(GL_TEXTURE0);
+  glDisableVertexAttribArray(0);
+  glDisableVertexAttribArray(1);
+  glBindBuffer(GL_ARRAY_BUFFER, 0);
+  glUseProgram(0);
+
+  glBindFramebuffer(GL_FRAMEBUFFER, 0);
+
+  return ret;
+}
+
+int GLWorker::DoComposition(Compositor &compositor, Work *work) {
+  int ret =
+      compositor.Composite(work->layers, work->num_layers, work->framebuffer);
+
+  int timeline_fd = work->timeline_fd;
+  work->timeline_fd = -1;
+
+  if (ret) {
+    worker_ret_ = ret;
+    glFinish();
+    sw_sync_timeline_inc(timeline_fd, work->num_layers);
+    close(timeline_fd);
+    return pthread_cond_signal(&work_done_cond_);
+  }
+
+  unsigned timeline_count = work->num_layers + 1;
+  worker_ret_ = sw_sync_fence_create(timeline_fd, "GLComposition done fence",
+                                     timeline_count);
+  ret = pthread_cond_signal(&work_done_cond_);
+
+  glFinish();
+
+  sw_sync_timeline_inc(timeline_fd, timeline_count);
+  close(timeline_fd);
+
+  return ret;
+}
+
+GLWorker::GLWorker() : initialized_(false) {
+}
+
+GLWorker::~GLWorker() {
+  if (!initialized_)
+    return;
+
+  if (SignalWorker(NULL, true) != 0 || pthread_join(thread_, NULL) != 0)
+    pthread_kill(thread_, SIGTERM);
+
+  pthread_cond_destroy(&work_ready_cond_);
+  pthread_cond_destroy(&work_done_cond_);
+  pthread_mutex_destroy(&lock_);
+}
+
+#define TRY(x, n, g)                  \
+  ret = x;                            \
+  if (ret) {                          \
+    ALOGE("Failed to " n " %d", ret); \
+    g;                                \
+  }
+
+#define TRY_RETURN(x, n) TRY(x, n, return ret)
+
+int GLWorker::Init() {
+  int ret = 0;
+
+  worker_work_ = NULL;
+  worker_exit_ = false;
+  worker_ret_ = -1;
+
+  ret = pthread_cond_init(&work_ready_cond_, NULL);
+  if (ret) {
+    ALOGE("Failed to int GLThread condition %d", ret);
+    return ret;
+  }
+
+  ret = pthread_cond_init(&work_done_cond_, NULL);
+  if (ret) {
+    ALOGE("Failed to int GLThread condition %d", ret);
+    pthread_cond_destroy(&work_ready_cond_);
+    return ret;
+  }
+
+  ret = pthread_mutex_init(&lock_, NULL);
+  if (ret) {
+    ALOGE("Failed to init GLThread lock %d", ret);
+    pthread_cond_destroy(&work_ready_cond_);
+    pthread_cond_destroy(&work_done_cond_);
+    return ret;
+  }
+
+  ret = pthread_create(&thread_, NULL, StartRoutine, this);
+  if (ret) {
+    ALOGE("Failed to create GLThread %d", ret);
+    pthread_cond_destroy(&work_ready_cond_);
+    pthread_cond_destroy(&work_done_cond_);
+    pthread_mutex_destroy(&lock_);
+    return ret;
+  }
+
+  initialized_ = true;
+
+  TRY_RETURN(pthread_mutex_lock(&lock_), "lock GLThread");
+
+  while (!worker_exit_ && worker_ret_ != 0)
+    TRY(pthread_cond_wait(&work_done_cond_, &lock_), "wait on condition",
+        goto out_unlock);
+
+  ret = worker_ret_;
+
+out_unlock:
+  int unlock_ret = pthread_mutex_unlock(&lock_);
+  if (unlock_ret) {
+    ret = unlock_ret;
+    ALOGE("Failed to unlock GLThread %d", unlock_ret);
+  }
+  return ret;
+}
+
+int GLWorker::SignalWorker(Work *work, bool worker_exit) {
+  int ret = 0;
+  if (worker_exit_)
+    return -EINVAL;
+  TRY_RETURN(pthread_mutex_lock(&lock_), "lock GLThread");
+  worker_work_ = work;
+  worker_exit_ = worker_exit;
+  ret = pthread_cond_signal(&work_ready_cond_);
+  if (ret) {
+    ALOGE("Failed to signal GLThread caller %d", ret);
+    pthread_mutex_unlock(&lock_);
+    return ret;
+  }
+  ret = pthread_cond_wait(&work_done_cond_, &lock_);
+  if (ret) {
+    ALOGE("Failed to wait on GLThread %d", ret);
+    pthread_mutex_unlock(&lock_);
+    return ret;
+  }
+
+  ret = worker_ret_;
+  if (ret) {
+    pthread_mutex_unlock(&lock_);
+    return ret;
+  }
+  TRY_RETURN(pthread_mutex_unlock(&lock_), "unlock GLThread");
+  return ret;
+}
+
+int GLWorker::DoWork(Work *work) {
+  return SignalWorker(work, false);
+}
+
+void GLWorker::WorkerRoutine() {
+  int ret = 0;
+
+  TRY(pthread_mutex_lock(&lock_), "lock GLThread", return );
+
+  Compositor compositor;
+
+  TRY(compositor.Init(), "initialize GL", goto out_signal_done);
+
+  worker_ret_ = 0;
+  TRY(pthread_cond_signal(&work_done_cond_), "signal GLThread caller",
+      goto out_signal_done);
+
+  while (true) {
+    while (worker_work_ == NULL && !worker_exit_)
+      TRY(pthread_cond_wait(&work_ready_cond_, &lock_), "wait on condition",
+          goto out_signal_done);
+
+    if (worker_exit_) {
+      ret = 0;
+      break;
+    }
+
+    ret = DoComposition(compositor, worker_work_);
+
+    worker_work_ = NULL;
+    if (ret) {
+      break;
+    }
+  }
+
+out_signal_done:
+  worker_exit_ = true;
+  worker_ret_ = ret;
+  TRY(pthread_cond_signal(&work_done_cond_), "signal GLThread caller",
+      goto out_unlock);
+out_unlock:
+  TRY(pthread_mutex_unlock(&lock_), "unlock GLThread", return );
+}
+
+/* static */
+void *GLWorker::StartRoutine(void *arg) {
+  setpriority(PRIO_PROCESS, 0, HAL_PRIORITY_URGENT_DISPLAY);
+  GLWorker *worker = (GLWorker *)arg;
+  worker->WorkerRoutine();
+  return NULL;
+}
+
+}  // namespace android
diff --git a/glworker.h b/glworker.h
new file mode 100644
index 0000000..4ac0e7d
--- /dev/null
+++ b/glworker.h
@@ -0,0 +1,137 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ANDROID_GL_WORKER_H_
+#define ANDROID_GL_WORKER_H_
+
+#include <pthread.h>
+
+#include <memory>
+#include <vector>
+
+#define EGL_EGLEXT_PROTOTYPES
+#define GL_GLEXT_PROTOTYPES
+
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+#include <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
+
+struct hwc_layer_1;
+
+namespace android {
+
+#define AUTO_GL_TYPE(name, type, zero, deleter) \
+  struct name##Deleter {                        \
+    typedef type pointer;                       \
+                                                \
+    void operator()(pointer p) const {          \
+      if (p != zero) {                          \
+        deleter;                                \
+      }                                         \
+    }                                           \
+  };                                            \
+  typedef std::unique_ptr<type, name##Deleter> name;
+
+AUTO_GL_TYPE(AutoGLFramebuffer, GLuint, 0, glDeleteFramebuffers(1, &p))
+AUTO_GL_TYPE(AutoGLBuffer, GLuint, 0, glDeleteBuffers(1, &p))
+AUTO_GL_TYPE(AutoGLTexture, GLuint, 0, glDeleteTextures(1, &p))
+AUTO_GL_TYPE(AutoGLShader, GLint, 0, glDeleteShader(p))
+AUTO_GL_TYPE(AutoGLProgram, GLint, 0, glDeleteProgram(p))
+
+struct EGLImageDeleter {
+  typedef EGLImageKHR pointer;
+
+  EGLDisplay egl_display_;
+
+  EGLImageDeleter(EGLDisplay egl_display) : egl_display_(egl_display) {
+  }
+
+  void operator()(EGLImageKHR p) const {
+    if (p != EGL_NO_IMAGE_KHR) {
+      eglDestroyImageKHR(egl_display_, p);
+    }
+  }
+};
+typedef std::unique_ptr<EGLImageKHR, EGLImageDeleter> AutoEGLImageKHR;
+
+struct AutoEGLImageAndGLTexture {
+  AutoEGLImageKHR image;
+  AutoGLTexture texture;
+
+  AutoEGLImageAndGLTexture(EGLDisplay egl_display)
+      : image(EGL_NO_IMAGE_KHR, EGLImageDeleter(egl_display)) {
+  }
+};
+
+class GLWorker {
+ public:
+  struct Work {
+    hwc_layer_1 *layers;
+    size_t num_layers;
+    int timeline_fd;
+    sp<GraphicBuffer> framebuffer;
+
+    Work() = default;
+    Work(const Work &rhs) = delete;
+  };
+
+  class Compositor {
+   public:
+    Compositor();
+    ~Compositor();
+
+    int Init();
+
+    int Composite(hwc_layer_1 *layers, size_t num_layers,
+                  sp<GraphicBuffer> framebuffer);
+
+   private:
+    EGLDisplay egl_display_;
+    EGLContext egl_ctx_;
+
+    std::vector<AutoGLProgram> blend_programs_;
+    AutoGLBuffer vertex_buffer_;
+  };
+
+  GLWorker();
+  ~GLWorker();
+
+  int Init();
+
+  int DoWork(Work *work);
+
+ private:
+  bool initialized_;
+  pthread_t thread_;
+  pthread_mutex_t lock_;
+  pthread_cond_t work_ready_cond_;
+  pthread_cond_t work_done_cond_;
+  Work *worker_work_;
+  bool work_ready_;
+  bool worker_exit_;
+  int worker_ret_;
+
+  void WorkerRoutine();
+  int DoComposition(Compositor &compositor, Work *work);
+
+  int SignalWorker(Work *work, bool worker_exit);
+
+  static void *StartRoutine(void *arg);
+};
+}
+
+#endif