diff --git a/drm_hwcomposer.h b/drm_hwcomposer.h
index cebdbee..fdf389b 100644
--- a/drm_hwcomposer.h
+++ b/drm_hwcomposer.h
@@ -22,6 +22,7 @@
 
 #include <hardware/hardware.h>
 #include <hardware/hwcomposer.h>
+#include "seperate_rects.h"
 
 struct hwc_import_context;
 
@@ -71,4 +72,202 @@
 bool hwc_import_bo_release(int fd, struct hwc_import_context *ctx,
                            struct hwc_drm_bo *bo);
 
+namespace android {
+
+class Importer;
+
+class UniqueFd {
+ public:
+  UniqueFd() = default;
+  UniqueFd(int fd) : fd_(fd) {
+  }
+  UniqueFd(UniqueFd &&rhs) {
+    fd_ = rhs.fd_;
+    rhs.fd_ = -1;
+  }
+
+  UniqueFd &operator=(UniqueFd &&rhs) {
+    Set(rhs.Release());
+    return *this;
+  }
+
+  ~UniqueFd() {
+    if (fd_ >= 0)
+      close(fd_);
+  }
+
+  int Release() {
+    int old_fd = fd_;
+    fd_ = -1;
+    return old_fd;
+  }
+
+  int Set(int fd) {
+    if (fd_ >= 0)
+      close(fd_);
+    fd_ = fd;
+    return fd_;
+  }
+
+  void Close() {
+    if (fd_ >= 0)
+      close(fd_);
+    fd_ = -1;
+  }
+
+  int get() {
+    return fd_;
+  }
+
+ private:
+  int fd_ = -1;
+};
+
+struct OutputFd {
+  OutputFd() = default;
+  OutputFd(int *fd) : fd_(fd) {
+  }
+  OutputFd(OutputFd &&rhs) {
+    fd_ = rhs.fd_;
+    rhs.fd_ = NULL;
+  }
+
+  OutputFd &operator=(OutputFd &&rhs);
+
+  int Set(int fd) {
+    if (*fd_ >= 0)
+      close(*fd_);
+    *fd_ = fd;
+    return fd;
+  }
+
+  int get() {
+    return *fd_;
+  }
+
+ private:
+  int *fd_ = NULL;
+};
+
+class DrmHwcBuffer {
+ public:
+  DrmHwcBuffer() = default;
+  DrmHwcBuffer(const hwc_drm_bo &bo, Importer *importer)
+      : bo_(bo), importer_(importer) {
+  }
+  DrmHwcBuffer(DrmHwcBuffer &&rhs) : bo_(rhs.bo_), importer_(rhs.importer_) {
+    rhs.importer_ = NULL;
+  }
+
+  ~DrmHwcBuffer() {
+    Clear();
+  }
+
+  DrmHwcBuffer &operator=(DrmHwcBuffer &&rhs) {
+    Clear();
+    importer_ = rhs.importer_;
+    rhs.importer_ = NULL;
+    bo_ = rhs.bo_;
+    return *this;
+  }
+
+  operator bool() {
+    return importer_ != NULL;
+  }
+
+  hwc_drm_bo *operator->();
+
+  void Clear();
+
+  int ImportBuffer(buffer_handle_t handle, Importer *importer);
+
+ private:
+  hwc_drm_bo bo_;
+  Importer *importer_ = NULL;
+};
+
+class DrmHwcNativeHandle {
+ public:
+  DrmHwcNativeHandle() = default;
+
+  DrmHwcNativeHandle(const gralloc_module_t *gralloc, native_handle_t *handle)
+      : gralloc_(gralloc), handle_(handle) {
+  }
+
+  DrmHwcNativeHandle(DrmHwcNativeHandle &&rhs) {
+    gralloc_ = rhs.gralloc_;
+    rhs.gralloc_ = NULL;
+    handle_ = rhs.handle_;
+    rhs.handle_ = NULL;
+  }
+
+  ~DrmHwcNativeHandle();
+
+  DrmHwcNativeHandle &operator=(DrmHwcNativeHandle &&rhs) {
+    Clear();
+    gralloc_ = rhs.gralloc_;
+    rhs.gralloc_ = NULL;
+    handle_ = rhs.handle_;
+    rhs.handle_ = NULL;
+    return *this;
+  }
+
+  int CopyBufferHandle(buffer_handle_t handle, const gralloc_module_t *gralloc);
+
+  void Clear();
+
+  buffer_handle_t get() const {
+    return handle_;
+  }
+
+ private:
+  const gralloc_module_t *gralloc_ = NULL;
+  native_handle_t *handle_ = NULL;
+};
+
+template <typename T>
+using DrmHwcRect = seperate_rects::Rect<T>;
+
+enum class DrmHwcTransform : uint32_t {
+  kIdentity = 0,
+  kFlipH = HWC_TRANSFORM_FLIP_H,
+  kFlipV = HWC_TRANSFORM_FLIP_V,
+  kRotate90 = HWC_TRANSFORM_ROT_90,
+  kRotate180 = HWC_TRANSFORM_ROT_180,
+  kRotate270 = HWC_TRANSFORM_ROT_270,
+};
+
+enum class DrmHwcBlending : int32_t {
+  kNone = HWC_BLENDING_NONE,
+  kPreMult = HWC_BLENDING_PREMULT,
+  kCoverage = HWC_BLENDING_COVERAGE,
+};
+
+struct DrmHwcLayer {
+  buffer_handle_t sf_handle = NULL;
+  DrmHwcBuffer buffer;
+  DrmHwcNativeHandle handle;
+  DrmHwcTransform transform = DrmHwcTransform::kIdentity;
+  DrmHwcBlending blending = DrmHwcBlending::kNone;
+  uint8_t alpha = 0xff;
+  DrmHwcRect<float> source_crop;
+  DrmHwcRect<int> display_frame;
+  std::vector<DrmHwcRect<int>> source_damage;
+
+  UniqueFd acquire_fence;
+  OutputFd release_fence;
+
+  DrmHwcLayer() = default;
+  DrmHwcLayer(DrmHwcLayer &&rhs) = default;
+
+  int InitFromHwcLayer(hwc_layer_1_t *sf_layer, Importer *importer,
+                       const gralloc_module_t *gralloc);
+};
+
+struct DrmHwcDisplayContents {
+  OutputFd retire_fence;
+  std::vector<DrmHwcLayer> layers;
+};
+}
+
 #endif
diff --git a/drmcomposition.cpp b/drmcomposition.cpp
index 864c5e5..634b0bb 100644
--- a/drmcomposition.cpp
+++ b/drmcomposition.cpp
@@ -69,15 +69,15 @@
 }
 
 int DrmComposition::SetLayers(size_t num_displays,
-                              const DrmCompositionDisplayLayersMap *maps) {
+                              DrmCompositionDisplayLayersMap *maps) {
   int ret = 0;
   for (size_t display_index = 0; display_index < num_displays;
        display_index++) {
-    const DrmCompositionDisplayLayersMap &map = maps[display_index];
+    DrmCompositionDisplayLayersMap &map = maps[display_index];
     int display = map.display;
 
     ret = composition_map_[display]->SetLayers(
-        map.layers, map.num_layers, map.layer_indices, &primary_planes_,
+        map.layers.data(), map.layers.size(), &primary_planes_,
         &overlay_planes_);
     if (ret)
       return ret;
diff --git a/drmcomposition.h b/drmcomposition.h
index 426ced0..a5d9cf1 100644
--- a/drmcomposition.h
+++ b/drmcomposition.h
@@ -22,7 +22,6 @@
 #include "drmplane.h"
 #include "importer.h"
 
-#include <deque>
 #include <map>
 #include <vector>
 
@@ -33,9 +32,11 @@
 
 struct DrmCompositionDisplayLayersMap {
   int display;
-  size_t num_layers;
-  hwc_layer_1_t *layers;
-  size_t *layer_indices;
+  std::vector<DrmHwcLayer> layers;
+
+  DrmCompositionDisplayLayersMap() = default;
+  DrmCompositionDisplayLayersMap(DrmCompositionDisplayLayersMap &&rhs) =
+      default;
 };
 
 class DrmComposition {
@@ -44,8 +45,7 @@
 
   int Init(uint64_t frame_no);
 
-  int SetLayers(size_t num_displays,
-                const DrmCompositionDisplayLayersMap *maps);
+  int SetLayers(size_t num_displays, DrmCompositionDisplayLayersMap *maps);
   int SetDpmsMode(int display, uint32_t dpms_mode);
 
   std::unique_ptr<DrmDisplayComposition> TakeDisplayComposition(int display);
diff --git a/drmdisplaycomposition.cpp b/drmdisplaycomposition.cpp
index c1848e0..457fb5a 100644
--- a/drmdisplaycomposition.cpp
+++ b/drmdisplaycomposition.cpp
@@ -30,39 +30,18 @@
 
 namespace android {
 
-static native_handle_t *dup_buffer_handle(buffer_handle_t handle) {
-  native_handle_t *new_handle =
-      native_handle_create(handle->numFds, handle->numInts);
-  if (new_handle == NULL)
-    return NULL;
-
-  const int *old_data = handle->data;
-  int *new_data = new_handle->data;
-  for (int i = 0; i < handle->numFds; i++) {
-    *new_data = dup(*old_data);
-    old_data++;
-    new_data++;
-  }
-  memcpy(new_data, old_data, sizeof(int) * handle->numInts);
-
-  return new_handle;
-}
-
-static void free_buffer_handle(native_handle_t *handle) {
-  int ret = native_handle_close(handle);
-  if (ret)
-    ALOGE("Failed to close native handle %d", ret);
-  ret = native_handle_delete(handle);
-  if (ret)
-    ALOGE("Failed to delete native handle %d", ret);
-}
-
-DrmCompositionLayer::DrmCompositionLayer()
-    : crtc(NULL), plane(NULL), handle(NULL) {
-  memset(&layer, 0, sizeof(layer));
-  layer.releaseFenceFd = -1;
-  layer.acquireFenceFd = -1;
-  memset(&bo, 0, sizeof(bo));
+DrmCompositionLayer::DrmCompositionLayer(DrmCrtc *crtc, DrmHwcLayer &&l)
+    : crtc(crtc),
+      sf_handle(l.sf_handle),
+      buffer(std::move(l.buffer)),
+      handle(std::move(l.handle)),
+      transform(l.transform),
+      blending(l.blending),
+      alpha(l.alpha),
+      source_crop(l.source_crop),
+      display_frame(l.display_frame),
+      source_damage(l.source_damage),
+      acquire_fence(std::move(l.acquire_fence)) {
 }
 
 DrmDisplayComposition::DrmDisplayComposition()
@@ -79,20 +58,6 @@
 }
 
 DrmDisplayComposition::~DrmDisplayComposition() {
-  for (DrmCompositionLayerVector_t::iterator iter = layers_.begin();
-       iter != layers_.end(); ++iter) {
-    if (importer_ && iter->bo.fb_id)
-      importer_->ReleaseBuffer(&iter->bo);
-
-    if (iter->handle) {
-      gralloc_->unregisterBuffer(gralloc_, iter->handle);
-      free_buffer_handle(iter->handle);
-    }
-
-    if (iter->layer.acquireFenceFd >= 0)
-      close(iter->layer.acquireFenceFd);
-  }
-
   if (timeline_fd_ >= 0) {
     FinishComposition();
     close(timeline_fd_);
@@ -103,18 +68,11 @@
 int DrmDisplayComposition::Init(DrmResources *drm, DrmCrtc *crtc,
                                 Importer *importer, uint64_t frame_no) {
   drm_ = drm;
-  crtc_ = crtc; // Can be NULL if we haven't modeset yet
+  crtc_ = crtc;  // Can be NULL if we haven't modeset yet
   importer_ = importer;
   frame_no_ = frame_no;
 
-  int ret = hw_get_module(GRALLOC_HARDWARE_MODULE_ID,
-                          (const hw_module_t **)&gralloc_);
-  if (ret) {
-    ALOGE("Failed to open gralloc module %d", ret);
-    return ret;
-  }
-
-  ret = sw_sync_timeline_create();
+  int ret = sw_sync_timeline_create();
   if (ret < 0) {
     ALOGE("Failed to create sw sync timeline %d", ret);
     return ret;
@@ -170,8 +128,7 @@
   return ret;
 }
 
-int DrmDisplayComposition::SetLayers(hwc_layer_1_t *layers, size_t num_layers,
-                                     size_t *layer_indices,
+int DrmDisplayComposition::SetLayers(DrmHwcLayer *layers, size_t num_layers,
                                      std::vector<DrmPlane *> *primary_planes,
                                      std::vector<DrmPlane *> *overlay_planes) {
   int ret = 0;
@@ -179,32 +136,10 @@
     return -EINVAL;
 
   for (size_t layer_index = 0; layer_index < num_layers; layer_index++) {
-    hwc_layer_1_t *layer = &layers[layer_indices[layer_index]];
+    DrmHwcLayer *layer = &layers[layer_index];
 
-    native_handle_t *handle_copy = dup_buffer_handle(layer->handle);
-    if (handle_copy == NULL) {
-      ALOGE("Failed to duplicate handle");
-      return -ENOMEM;
-    }
-
-    int ret = gralloc_->registerBuffer(gralloc_, handle_copy);
-    if (ret) {
-      ALOGE("Failed to register buffer handle %d", ret);
-      free_buffer_handle(handle_copy);
-      return ret;
-    }
-
-    layers_.emplace_back();
-    DrmCompositionLayer_t *c_layer = &layers_.back();
-    c_layer->layer = *layer;
-    c_layer->handle = handle_copy;
-    c_layer->crtc = crtc_;
-
-    ret = importer_->ImportBuffer(layer->handle, &c_layer->bo);
-    if (ret) {
-      ALOGE("Failed to import handle of layer %d", ret);
-      goto fail;
-    }
+    layers_.emplace_back(crtc_, std::move(*layer));
+    DrmCompositionLayer *c_layer = &layers_.back();
 
     if (pre_composition_layer_index_ == -1) {
       c_layer->plane = TakePlane(crtc_, primary_planes, overlay_planes);
@@ -218,27 +153,19 @@
         layers_.emplace_back();
         // c_layer's address might have changed when we resized the vector
         c_layer = &layers_[layers_.size() - 2];
-        DrmCompositionLayer_t &pre_comp_layer = layers_.back();
+        DrmCompositionLayer &pre_comp_layer = layers_.back();
         pre_comp_layer.crtc = crtc_;
-        hwc_layer_1_t &pre_comp_output_layer = pre_comp_layer.layer;
-        memset(&pre_comp_output_layer, 0, sizeof(pre_comp_output_layer));
-        pre_comp_output_layer.compositionType = HWC_OVERLAY;
-        pre_comp_output_layer.acquireFenceFd = -1;
-        pre_comp_output_layer.releaseFenceFd = -1;
-        pre_comp_output_layer.planeAlpha = 0xff;
-        pre_comp_output_layer.visibleRegionScreen.numRects = 1;
-        pre_comp_output_layer.visibleRegionScreen.rects =
-            &pre_comp_output_layer.displayFrame;
 
         pre_composition_layer_index_ = layers_.size() - 1;
 
         // This is all to fix up the previous layer, which has now become part
         // of the set of pre-composition layers because we are stealing its
         // plane.
-        DrmCompositionLayer_t &last_c_layer = layers_[layers_.size() - 3];
+        DrmCompositionLayer &last_c_layer = layers_[layers_.size() - 3];
         std::swap(pre_comp_layer.plane, last_c_layer.plane);
-        hwc_layer_1_t *last_layer = &layers[layer_indices[layer_index - 1]];
-        ret = last_layer->releaseFenceFd = CreateNextTimelineFence();
+        OutputFd &last_release_fence = layers[layer_index - 1].release_fence;
+        last_release_fence.Set(CreateNextTimelineFence());
+        ret = last_release_fence.get();
         if (ret < 0) {
           ALOGE("Could not create release fence %d", ret);
           goto fail;
@@ -249,7 +176,8 @@
     if (c_layer->plane == NULL) {
       // Layers to be pre composited all get the earliest release fences as they
       // will get released soonest.
-      ret = layer->releaseFenceFd = CreateNextTimelineFence();
+      layer->release_fence.Set(CreateNextTimelineFence());
+      ret = layer->release_fence.get();
       if (ret < 0) {
         ALOGE("Could not create release fence %d", ret);
         goto fail;
@@ -260,22 +188,17 @@
   timeline_pre_comp_done_ = timeline_;
 
   for (size_t layer_index = 0; layer_index < num_layers; layer_index++) {
-    hwc_layer_1_t *layer = &layers[layer_indices[layer_index]];
-    if (layer->releaseFenceFd >= 0)
+    DrmHwcLayer *layer = &layers[layer_index];
+    if (layer->release_fence.get() >= 0)
       continue;
 
-    ret = layer->releaseFenceFd = CreateNextTimelineFence();
+    ret = layer->release_fence.Set(CreateNextTimelineFence());
     if (ret < 0) {
       ALOGE("Could not create release fence %d", ret);
       goto fail;
     }
   }
 
-  for (size_t layer_index = 0; layer_index < num_layers; layer_index++) {
-    hwc_layer_1_t *layer = &layers[layer_indices[layer_index]];
-    layer->acquireFenceFd = -1;  // We own this now
-  }
-
   type_ = DRM_COMPOSITION_TYPE_FRAME;
   return 0;
 
@@ -283,13 +206,7 @@
 
   for (size_t c_layer_index = 0; c_layer_index < layers_.size();
        c_layer_index++) {
-    DrmCompositionLayer_t &c_layer = layers_[c_layer_index];
-    if (c_layer.handle) {
-      gralloc_->unregisterBuffer(gralloc_, c_layer.handle);
-      free_buffer_handle(c_layer.handle);
-    }
-    if (c_layer.bo.fb_id)
-      importer_->ReleaseBuffer(&c_layer.bo);
+    DrmCompositionLayer &c_layer = layers_[c_layer_index];
     if (c_layer.plane != NULL) {
       std::vector<DrmPlane *> *return_to =
           (c_layer.plane->type() == DRM_PLANE_TYPE_PRIMARY) ? primary_planes
@@ -297,15 +214,9 @@
       return_to->insert(return_to->begin() + c_layer_index, c_layer.plane);
     }
   }
+
   layers_.clear();
 
-  for (size_t layer_index = 0; layer_index < num_layers; layer_index++) {
-    hwc_layer_1_t *layer = &layers[layer_indices[layer_index]];
-    if (layer->releaseFenceFd >= 0) {
-      close(layer->releaseFenceFd);
-      layer->releaseFenceFd = -1;
-    }
-  }
   sw_sync_timeline_inc(timeline_fd_, timeline_ - timeline_current_);
 
   timeline_ = timeline_current_;
@@ -322,35 +233,16 @@
 
 int DrmDisplayComposition::AddPlaneDisable(DrmPlane *plane) {
   layers_.emplace_back();
-  DrmCompositionLayer_t &c_layer = layers_.back();
+  DrmCompositionLayer &c_layer = layers_.back();
   c_layer.crtc = NULL;
   c_layer.plane = plane;
   return 0;
 }
 
 void DrmDisplayComposition::RemoveNoPlaneLayers() {
-  for (auto &comp_layer : layers_) {
-    if (comp_layer.plane != NULL)
-      continue;
-
-    if (importer_ && comp_layer.bo.fb_id) {
-      importer_->ReleaseBuffer(&comp_layer.bo);
-    }
-
-    if (comp_layer.handle) {
-      gralloc_->unregisterBuffer(gralloc_, comp_layer.handle);
-      free_buffer_handle(comp_layer.handle);
-    }
-
-    if (comp_layer.layer.acquireFenceFd >= 0) {
-      close(comp_layer.layer.acquireFenceFd);
-      comp_layer.layer.acquireFenceFd = -1;
-    }
-  }
-
   layers_.erase(
       std::remove_if(layers_.begin(), layers_.end(),
-                     [](DrmCompositionLayer_t &l) { return l.plane == NULL; }),
+                     [](DrmCompositionLayer &l) { return l.plane == NULL; }),
       layers_.end());
 }
 
@@ -362,7 +254,8 @@
   return IncreaseTimelineToPoint(timeline_);
 }
 
-DrmCompositionLayerVector_t *DrmDisplayComposition::GetCompositionLayers() {
+std::vector<DrmCompositionLayer>
+    *DrmDisplayComposition::GetCompositionLayers() {
   return &layers_;
 }
 
diff --git a/drmdisplaycomposition.h b/drmdisplaycomposition.h
index be4ecef..06784f1 100644
--- a/drmdisplaycomposition.h
+++ b/drmdisplaycomposition.h
@@ -37,16 +37,32 @@
   DRM_COMPOSITION_TYPE_DPMS,
 };
 
-typedef struct DrmCompositionLayer {
-  DrmCompositionLayer();
+struct DrmCompositionLayer {
+  DrmCrtc *crtc = NULL;
+  DrmPlane *plane = NULL;
 
-  hwc_layer_1_t layer;
-  hwc_drm_bo_t bo;
-  DrmCrtc *crtc;
-  DrmPlane *plane;
-  native_handle_t *handle;
-} DrmCompositionLayer_t;
-typedef std::vector<DrmCompositionLayer_t> DrmCompositionLayerVector_t;
+  buffer_handle_t sf_handle = NULL;
+  DrmHwcBuffer buffer;
+  DrmHwcNativeHandle handle;
+  DrmHwcTransform transform = DrmHwcTransform::kIdentity;
+  DrmHwcBlending blending = DrmHwcBlending::kNone;
+  uint8_t alpha = 0xff;
+  DrmHwcRect<float> source_crop;
+  DrmHwcRect<int> display_frame;
+  std::vector<DrmHwcRect<int>> source_damage;
+
+  UniqueFd acquire_fence;
+
+  DrmCompositionLayer() = default;
+  DrmCompositionLayer(DrmCrtc *crtc, DrmHwcLayer &&l);
+  DrmCompositionLayer(DrmCompositionLayer &&l) = default;
+
+  DrmCompositionLayer &operator=(DrmCompositionLayer &&l) = default;
+
+  buffer_handle_t get_usable_handle() const {
+    return handle.get() != NULL ? handle.get() : sf_handle;
+  }
+};
 
 class DrmDisplayComposition {
  public:
@@ -58,7 +74,7 @@
 
   DrmCompositionType type() const;
 
-  int SetLayers(hwc_layer_1_t *layers, size_t num_layers, size_t *layer_indices,
+  int SetLayers(DrmHwcLayer *layers, size_t num_layers,
                 std::vector<DrmPlane *> *primary_planes,
                 std::vector<DrmPlane *> *overlay_planes);
   int AddPlaneDisable(DrmPlane *plane);
@@ -68,7 +84,7 @@
   int SignalPreCompositionDone();
   int FinishComposition();
 
-  DrmCompositionLayerVector_t *GetCompositionLayers();
+  std::vector<DrmCompositionLayer> *GetCompositionLayers();
   int pre_composition_layer_index() const;
   uint32_t dpms_mode() const;
 
@@ -97,7 +113,7 @@
   int timeline_current_;
   int timeline_pre_comp_done_;
 
-  DrmCompositionLayerVector_t layers_;
+  std::vector<DrmCompositionLayer> layers_;
   int pre_composition_layer_index_;
   uint32_t dpms_mode_;
 
diff --git a/drmdisplaycompositor.cpp b/drmdisplaycompositor.cpp
index b293681..6ee145f 100644
--- a/drmdisplaycompositor.cpp
+++ b/drmdisplaycompositor.cpp
@@ -146,7 +146,7 @@
 }
 
 static bool drm_composition_layer_has_plane(
-    const DrmCompositionLayer_t &comp_layer) {
+    const DrmCompositionLayer &comp_layer) {
   if (comp_layer.plane != NULL)
     if (comp_layer.plane->type() == DRM_PLANE_TYPE_OVERLAY ||
         comp_layer.plane->type() == DRM_PLANE_TYPE_PRIMARY)
@@ -155,14 +155,15 @@
 }
 
 static bool drm_composition_layer_has_no_plane(
-    const DrmCompositionLayer_t &comp_layer) {
+    const DrmCompositionLayer &comp_layer) {
   return comp_layer.plane == NULL;
 }
 
 int DrmDisplayCompositor::ApplyPreComposite(
     DrmDisplayComposition *display_comp) {
   int ret = 0;
-  DrmCompositionLayerVector_t *layers = display_comp->GetCompositionLayers();
+  std::vector<DrmCompositionLayer> *layers =
+      display_comp->GetCompositionLayers();
 
   DrmConnector *connector = drm_->GetConnectorForDisplay(display_);
   if (connector == NULL) {
@@ -185,12 +186,10 @@
     return -ENOMEM;
   }
 
-  std::vector<hwc_layer_1_t> pre_comp_layers;
+  std::vector<DrmCompositionLayer> pre_comp_layers;
   for (auto &comp_layer : *layers) {
     if (comp_layer.plane == NULL) {
-      pre_comp_layers.push_back(comp_layer.layer);
-      pre_comp_layers.back().handle = comp_layer.handle;
-      comp_layer.layer.acquireFenceFd = -1;
+      pre_comp_layers.emplace_back(std::move(comp_layer));
     }
   }
 
@@ -198,36 +197,26 @@
                                    pre_comp_layers.size(), fb.buffer());
   pre_compositor_->Finish();
 
-  for (auto &pre_comp_layer : pre_comp_layers) {
-    if (pre_comp_layer.acquireFenceFd >= 0) {
-      close(pre_comp_layer.acquireFenceFd);
-      pre_comp_layer.acquireFenceFd = -1;
-    }
-  }
-
   if (ret) {
     ALOGE("Failed to composite layers");
     return ret;
   }
 
-  DrmCompositionLayer_t &pre_comp_layer =
+  DrmCompositionLayer &pre_comp_layer =
       layers->at(display_comp->pre_composition_layer_index());
-  ret = display_comp->importer()->ImportBuffer(fb.buffer()->handle,
-                                               &pre_comp_layer.bo);
+  ret = pre_comp_layer.buffer.ImportBuffer(fb.buffer()->handle,
+                                           display_comp->importer());
   if (ret) {
     ALOGE("Failed to import handle of layer %d", ret);
     return ret;
   }
-  hwc_layer_1_t &pre_comp_output_layer = pre_comp_layer.layer;
-  pre_comp_output_layer.handle = fb.buffer()->handle;
-  pre_comp_output_layer.visibleRegionScreen.rects =
-      &pre_comp_output_layer.displayFrame;
-  pre_comp_output_layer.sourceCropf.right =
-      pre_comp_output_layer.displayFrame.right = fb.buffer()->getWidth();
-  pre_comp_output_layer.sourceCropf.bottom =
-      pre_comp_output_layer.displayFrame.bottom = fb.buffer()->getHeight();
+  pre_comp_layer.source_crop = DrmHwcRect<float>(0, 0, fb.buffer()->getWidth(),
+                                                 fb.buffer()->getHeight());
+  pre_comp_layer.display_frame =
+      DrmHwcRect<int>(0, 0, fb.buffer()->getWidth(), fb.buffer()->getHeight());
 
-  fb.set_release_fence_fd(pre_comp_output_layer.releaseFenceFd);
+  // TODO(zachr) get a release fence
+  // fb.set_release_fence_fd(pre_comp_layer.release_fence.Release());
   framebuffer_index_ = (framebuffer_index_ + 1) % DRM_DISPLAY_BUFFERS;
 
   display_comp->RemoveNoPlaneLayers();
@@ -250,24 +239,22 @@
     return -ENOMEM;
   }
 
-  DrmCompositionLayerVector_t *layers = display_comp->GetCompositionLayers();
-  for (DrmCompositionLayerVector_t::iterator iter = layers->begin();
-       iter != layers->end(); ++iter) {
-    hwc_layer_1_t *layer = &iter->layer;
-
-    if (layer->acquireFenceFd >= 0) {
-      ret = sync_wait(layer->acquireFenceFd, -1);
+  std::vector<DrmCompositionLayer> *layers =
+      display_comp->GetCompositionLayers();
+  for (DrmCompositionLayer &layer : *layers) {
+    int acquire_fence = layer.acquire_fence.get();
+    if (acquire_fence >= 0) {
+      ret = sync_wait(acquire_fence, -1);
       if (ret) {
-        ALOGE("Failed to wait for acquire %d/%d", layer->acquireFenceFd, ret);
+        ALOGE("Failed to wait for acquire %d/%d", acquire_fence, ret);
         drmModePropertySetFree(pset);
         return ret;
       }
-      close(layer->acquireFenceFd);
-      layer->acquireFenceFd = -1;
+      layer.acquire_fence.Close();
     }
 
-    DrmPlane *plane = iter->plane;
-    DrmCrtc *crtc = iter->crtc;
+    DrmPlane *plane = layer.plane;
+    DrmCrtc *crtc = layer.crtc;
 
     // Disable the plane if there's no crtc
     if (!crtc) {
@@ -282,28 +269,34 @@
       continue;
     }
 
+    if (!layer.buffer) {
+      ALOGE("Expected a valid framebuffer for pset");
+      ret = -EINVAL;
+      break;
+    }
+
     uint64_t rotation;
-    switch (layer->transform) {
-      case HWC_TRANSFORM_FLIP_H:
+    switch (layer.transform) {
+      case DrmHwcTransform::kFlipH:
         rotation = 1 << DRM_REFLECT_X;
         break;
-      case HWC_TRANSFORM_FLIP_V:
+      case DrmHwcTransform::kFlipV:
         rotation = 1 << DRM_REFLECT_Y;
         break;
-      case HWC_TRANSFORM_ROT_90:
+      case DrmHwcTransform::kRotate90:
         rotation = 1 << DRM_ROTATE_90;
         break;
-      case HWC_TRANSFORM_ROT_180:
+      case DrmHwcTransform::kRotate180:
         rotation = 1 << DRM_ROTATE_180;
         break;
-      case HWC_TRANSFORM_ROT_270:
+      case DrmHwcTransform::kRotate270:
         rotation = 1 << DRM_ROTATE_270;
         break;
-      case 0:
+      case DrmHwcTransform::kIdentity:
         rotation = 0;
         break;
       default:
-        ALOGE("Invalid transform value 0x%x given", layer->transform);
+        ALOGE("Invalid transform value 0x%x given", layer.transform);
         ret = -EINVAL;
         break;
     }
@@ -321,27 +314,27 @@
         drmModePropertySetAdd(pset, plane->id(), plane->crtc_property().id(),
                               crtc->id()) ||
         drmModePropertySetAdd(pset, plane->id(), plane->fb_property().id(),
-                              iter->bo.fb_id) ||
+                              layer.buffer->fb_id) ||
         drmModePropertySetAdd(pset, plane->id(), plane->crtc_x_property().id(),
-                              layer->displayFrame.left) ||
+                              layer.display_frame.left) ||
         drmModePropertySetAdd(pset, plane->id(), plane->crtc_y_property().id(),
-                              layer->displayFrame.top) ||
+                              layer.display_frame.top) ||
         drmModePropertySetAdd(
             pset, plane->id(), plane->crtc_w_property().id(),
-            layer->displayFrame.right - layer->displayFrame.left) ||
+            layer.display_frame.right - layer.display_frame.left) ||
         drmModePropertySetAdd(
             pset, plane->id(), plane->crtc_h_property().id(),
-            layer->displayFrame.bottom - layer->displayFrame.top) ||
+            layer.display_frame.bottom - layer.display_frame.top) ||
         drmModePropertySetAdd(pset, plane->id(), plane->src_x_property().id(),
-                              (int)(layer->sourceCropf.left) << 16) ||
+                              (int)(layer.source_crop.left) << 16) ||
         drmModePropertySetAdd(pset, plane->id(), plane->src_y_property().id(),
-                              (int)(layer->sourceCropf.top) << 16) ||
+                              (int)(layer.source_crop.top) << 16) ||
         drmModePropertySetAdd(
             pset, plane->id(), plane->src_w_property().id(),
-            (int)(layer->sourceCropf.right - layer->sourceCropf.left) << 16) ||
+            (int)(layer.source_crop.right - layer.source_crop.left) << 16) ||
         drmModePropertySetAdd(
             pset, plane->id(), plane->src_h_property().id(),
-            (int)(layer->sourceCropf.bottom - layer->sourceCropf.top) << 16);
+            (int)(layer.source_crop.bottom - layer.source_crop.top) << 16);
     if (ret) {
       ALOGE("Failed to add plane %d to set", plane->id());
       break;
@@ -412,6 +405,7 @@
 
   std::unique_ptr<DrmDisplayComposition> composition(
       std::move(composite_queue_.front()));
+
   composite_queue_.pop();
 
   ret = pthread_mutex_unlock(&lock_);
@@ -474,6 +468,22 @@
   return empty_ret;
 }
 
+struct DrmDumpLayer {
+  int plane_id;
+  int crtc_id;
+  DrmHwcTransform transform;
+  DrmHwcRect<float> source_crop;
+  DrmHwcRect<int> display_frame;
+
+  DrmDumpLayer(DrmCompositionLayer &rhs)
+      : plane_id(rhs.plane->id()),
+        crtc_id(rhs.crtc ? rhs.crtc->id() : -1),
+        transform(rhs.transform),
+        source_crop(rhs.source_crop),
+        display_frame(rhs.display_frame) {
+  }
+};
+
 void DrmDisplayCompositor::Dump(std::ostringstream *out) const {
   uint64_t cur_ts;
 
@@ -487,9 +497,11 @@
   struct timespec ts;
   ret = clock_gettime(CLOCK_MONOTONIC, &ts);
 
-  DrmCompositionLayerVector_t layers;
+  std::vector<DrmCompositionLayer> *input_layers =
+      active_composition_->GetCompositionLayers();
+  std::vector<DrmDumpLayer> layers;
   if (active_composition_)
-    layers = *active_composition_->GetCompositionLayers();
+    layers.insert(layers.begin(), input_layers->begin(), input_layers->end());
   else
     ret = -EAGAIN;
 
@@ -508,29 +520,26 @@
   dump_last_timestamp_ns_ = cur_ts;
 
   *out << "---- DrmDisplayCompositor Layers: num=" << layers.size() << "\n";
-  for (DrmCompositionLayerVector_t::iterator iter = layers.begin();
+  for (std::vector<DrmDumpLayer>::iterator iter = layers.begin();
        iter != layers.end(); ++iter) {
-    hwc_layer_1_t *layer = &iter->layer;
-    DrmPlane *plane = iter->plane;
+    *out << "------ DrmDisplayCompositor Layer: plane=" << iter->plane_id
+         << " ";
 
-    *out << "------ DrmDisplayCompositor Layer: plane=" << plane->id() << " ";
-
-    DrmCrtc *crtc = iter->crtc;
-    if (!crtc) {
+    if (iter->crtc_id < 0) {
       *out << "disabled\n";
       continue;
     }
 
-    *out << "crtc=" << crtc->id()
-         << " crtc[x/y/w/h]=" << layer->displayFrame.left << "/"
-         << layer->displayFrame.top << "/"
-         << layer->displayFrame.right - layer->displayFrame.left << "/"
-         << layer->displayFrame.bottom - layer->displayFrame.top << " "
-         << " src[x/y/w/h]=" << layer->sourceCropf.left << "/"
-         << layer->sourceCropf.top << "/"
-         << layer->sourceCropf.right - layer->sourceCropf.left << "/"
-         << layer->sourceCropf.bottom - layer->sourceCropf.top
-         << " transform=" << layer->transform << "\n";
+    *out << "crtc=" << iter->crtc_id
+         << " crtc[x/y/w/h]=" << iter->display_frame.left << "/"
+         << iter->display_frame.top << "/"
+         << iter->display_frame.right - iter->display_frame.left << "/"
+         << iter->display_frame.bottom - iter->display_frame.top << " "
+         << " src[x/y/w/h]=" << iter->source_crop.left << "/"
+         << iter->source_crop.top << "/"
+         << iter->source_crop.right - iter->source_crop.left << "/"
+         << iter->source_crop.bottom - iter->source_crop.top
+         << " transform=" << (uint32_t)iter->transform << "\n";
   }
 }
 }
diff --git a/glworker.cpp b/glworker.cpp
index f18ace9..34969e6 100644
--- a/glworker.cpp
+++ b/glworker.cpp
@@ -33,6 +33,8 @@
 
 #include <utils/Trace.h>
 
+#include "drmdisplaycomposition.h"
+
 #include "glworker.h"
 
 #include "seperate_rects.h"
@@ -305,18 +307,15 @@
   }
 };
 
-static void ConstructCommands(const hwc_layer_1 *layers, size_t num_layers,
+static void ConstructCommands(DrmCompositionLayer *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));
+    DrmCompositionLayer &layer = layers[rect_index];
+    in_rects.emplace_back(layer.display_frame);
   }
 
   seperate_frects_64(in_rects, &out_rects);
@@ -326,23 +325,22 @@
     commands->push_back(RenderingCommand());
     RenderingCommand &cmd = commands->back();
 
-    memcpy(cmd.bounds, out_rect.rect.bounds, sizeof(cmd.bounds));
+    for (int i = 0; i < 4; i++)
+      cmd.bounds[i] = out_rect.rect.bounds[i];
 
     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];
+        DrmCompositionLayer &layer = layers[i];
 
-        FRect display_rect(layer.displayFrame.left, layer.displayFrame.top,
-                           layer.displayFrame.right, layer.displayFrame.bottom);
+        FRect display_rect(layer.display_frame);
         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);
+        FRect crop_rect(layer.source_crop);
         float crop_size[2] = {crop_rect.bounds[2] - crop_rect.bounds[0],
                               crop_rect.bounds[3] - crop_rect.bounds[1]};
 
@@ -352,27 +350,39 @@
 
         bool swap_xy, flip_xy[2];
         switch (layer.transform) {
-          case HWC_TRANSFORM_FLIP_H:
-            swap_xy = false; flip_xy[0] = true; flip_xy[1] = false;
+          case DrmHwcTransform::kFlipH:
+            swap_xy = false;
+            flip_xy[0] = true;
+            flip_xy[1] = false;
             break;
-          case HWC_TRANSFORM_FLIP_V:
-            swap_xy = false; flip_xy[0] = false; flip_xy[1] = true;
+          case DrmHwcTransform::kFlipV:
+            swap_xy = false;
+            flip_xy[0] = false;
+            flip_xy[1] = true;
             break;
-          case HWC_TRANSFORM_ROT_90:
-            swap_xy = true; flip_xy[0] = false; flip_xy[1] = true;
+          case DrmHwcTransform::kRotate90:
+            swap_xy = true;
+            flip_xy[0] = false;
+            flip_xy[1] = true;
             break;
-          case HWC_TRANSFORM_ROT_180:
-            swap_xy = false; flip_xy[0] = true; flip_xy[1] = true;
+          case DrmHwcTransform::kRotate180:
+            swap_xy = false;
+            flip_xy[0] = true;
+            flip_xy[1] = true;
             break;
-          case HWC_TRANSFORM_ROT_270:
-            swap_xy = true; flip_xy[0] = true; flip_xy[1] = false;
+          case DrmHwcTransform::kRotate270:
+            swap_xy = true;
+            flip_xy[0] = true;
+            flip_xy[1] = false;
             break;
           default:
             ALOGE(
                 "Unknown transform for layer: defaulting to identity "
                 "transform");
-          case 0:
-            swap_xy = false; flip_xy[0] = false; flip_xy[1] = false;
+          case DrmHwcTransform::kIdentity:
+            swap_xy = false;
+            flip_xy[0] = false;
+            flip_xy[1] = false;
             break;
         }
 
@@ -394,14 +404,14 @@
           }
         }
 
-        if (layer.blending == HWC_BLENDING_NONE) {
+        if (layer.blending == DrmHwcBlending::kNone) {
           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;
+        src.alpha = layer.alpha / 255.0f;
       }
     }
   }
@@ -559,7 +569,8 @@
       ALOGE("Failed to destroy OpenGL ES Context: %s", GetEGLError());
 }
 
-int GLWorkerCompositor::Composite(hwc_layer_1 *layers, size_t num_layers,
+int GLWorkerCompositor::Composite(DrmCompositionLayer *layers,
+                                  size_t num_layers,
                                   const sp<GraphicBuffer> &framebuffer) {
   ATRACE_CALL();
   int ret = 0;
@@ -581,23 +592,14 @@
   }
 
   for (i = 0; i < num_layers; i++) {
-    struct hwc_layer_1 *layer = &layers[i];
-
-    if (ret) {
-      if (layer->acquireFenceFd >= 0) {
-        close(layer->acquireFenceFd);
-        layer->acquireFenceFd = -1;
-      }
-      continue;
-    }
+    DrmCompositionLayer *layer = &layers[i];
 
     layer_textures.emplace_back();
-    ret = CreateTextureFromHandle(egl_display_, layer->handle,
+    ret = CreateTextureFromHandle(egl_display_, layer->get_usable_handle(),
                                   &layer_textures.back());
 
     if (!ret) {
-      ret = EGLFenceWait(egl_display_, layer->acquireFenceFd);
-      layer->acquireFenceFd = -1;
+      ret = EGLFenceWait(egl_display_, layer->acquire_fence.Release());
     }
     if (ret) {
       layer_textures.pop_back();
diff --git a/glworker.h b/glworker.h
index ce41444..b3163ce 100644
--- a/glworker.h
+++ b/glworker.h
@@ -33,13 +33,15 @@
 
 namespace android {
 
+struct DrmCompositionLayer;
+
 class GLWorkerCompositor {
  public:
   GLWorkerCompositor();
   ~GLWorkerCompositor();
 
   int Init();
-  int Composite(hwc_layer_1 *layers, size_t num_layers,
+  int Composite(DrmCompositionLayer *layers, size_t num_layers,
                 const sp<GraphicBuffer> &framebuffer);
   void Finish();
 
diff --git a/hwcomposer.cpp b/hwcomposer.cpp
index 060a955..0a8b661 100644
--- a/hwcomposer.cpp
+++ b/hwcomposer.cpp
@@ -26,6 +26,7 @@
 
 #include <map>
 #include <vector>
+#include <sstream>
 
 #include <errno.h>
 #include <fcntl.h>
@@ -39,6 +40,8 @@
 #include <cutils/properties.h>
 #include <hardware/hardware.h>
 #include <hardware/hwcomposer.h>
+#include <sw_sync.h>
+#include <sync/sync.h>
 #include <utils/Trace.h>
 
 #define UM_PER_INCH 25400
@@ -46,6 +49,72 @@
 
 namespace android {
 
+class DummySwSyncTimeline {
+ public:
+  int Init() {
+    int ret = timeline_fd_.Set(sw_sync_timeline_create());
+    if (ret < 0)
+      return ret;
+    return 0;
+  }
+
+  UniqueFd CreateDummyFence() {
+    int ret = sw_sync_fence_create(timeline_fd_.get(), "dummy fence",
+                                   timeline_pt_ + 1);
+    if (ret < 0) {
+      ALOGE("Failed to create dummy fence %d", ret);
+      return ret;
+    }
+
+    UniqueFd ret_fd(ret);
+
+    ret = sw_sync_timeline_inc(timeline_fd_.get(), 1);
+    if (ret) {
+      ALOGE("Failed to increment dummy sync timeline %d", ret);
+      return ret;
+    }
+
+    ++timeline_pt_;
+    return ret_fd;
+  }
+
+ private:
+  UniqueFd timeline_fd_;
+  int timeline_pt_ = 0;
+};
+
+struct CheckedOutputFd {
+  CheckedOutputFd(int *fd, const char *description,
+                  DummySwSyncTimeline &timeline)
+      : fd_(fd), description_(description), timeline_(timeline) {
+  }
+  CheckedOutputFd(CheckedOutputFd &&rhs)
+      : description_(rhs.description_), timeline_(rhs.timeline_) {
+    std::swap(fd_, rhs.fd_);
+  }
+
+  CheckedOutputFd &operator=(const CheckedOutputFd &rhs) = delete;
+
+  ~CheckedOutputFd() {
+    if (fd_ == NULL)
+      return;
+
+    if (*fd_ >= 0)
+      return;
+
+    *fd_ = timeline_.CreateDummyFence().Release();
+
+    if (*fd_ < 0)
+      ALOGE("Failed to fill %s (%p == %d) before destruction",
+            description_.c_str(), fd_, *fd_);
+  }
+
+ private:
+  int *fd_ = NULL;
+  std::string description_;
+  DummySwSyncTimeline &timeline_;
+};
+
 typedef struct hwc_drm_display {
   struct hwc_context_t *ctx;
   int display;
@@ -73,9 +142,184 @@
   DisplayMap displays;
   DrmResources drm;
   Importer *importer;
+  const gralloc_module_t *gralloc;
+  DummySwSyncTimeline dummy_timeline;
   bool use_framebuffer_target;
 };
 
+static native_handle_t *dup_buffer_handle(buffer_handle_t handle) {
+  native_handle_t *new_handle =
+      native_handle_create(handle->numFds, handle->numInts);
+  if (new_handle == NULL)
+    return NULL;
+
+  const int *old_data = handle->data;
+  int *new_data = new_handle->data;
+  for (int i = 0; i < handle->numFds; i++) {
+    *new_data = dup(*old_data);
+    old_data++;
+    new_data++;
+  }
+  memcpy(new_data, old_data, sizeof(int) * handle->numInts);
+
+  return new_handle;
+}
+
+static void free_buffer_handle(native_handle_t *handle) {
+  int ret = native_handle_close(handle);
+  if (ret)
+    ALOGE("Failed to close native handle %d", ret);
+  ret = native_handle_delete(handle);
+  if (ret)
+    ALOGE("Failed to delete native handle %d", ret);
+}
+
+OutputFd &OutputFd::operator=(OutputFd &&rhs) {
+  if (fd_ == NULL) {
+    std::swap(fd_, rhs.fd_);
+  } else {
+    if (*fd_ < 0) {
+      ALOGE("Failed to fill OutputFd %p before assignment", fd_);
+    }
+    fd_ = rhs.fd_;
+    rhs.fd_ = NULL;
+  }
+
+  return *this;
+}
+
+hwc_drm_bo *DrmHwcBuffer::operator->() {
+  if (importer_ == NULL) {
+    ALOGE("Access of none existent BO");
+    exit(1);
+    return NULL;
+  }
+  return &bo_;
+}
+
+void DrmHwcBuffer::Clear() {
+  if (importer_ != NULL) {
+    importer_->ReleaseBuffer(&bo_);
+    importer_ = NULL;
+  }
+}
+
+int DrmHwcBuffer::ImportBuffer(buffer_handle_t handle, Importer *importer) {
+  hwc_drm_bo tmp_bo;
+
+  int ret = importer->ImportBuffer(handle, &tmp_bo);
+  if (ret)
+    return ret;
+
+  if (importer_ != NULL) {
+    importer_->ReleaseBuffer(&bo_);
+  }
+
+  importer_ = importer;
+
+  bo_ = tmp_bo;
+
+  return 0;
+}
+
+int DrmHwcNativeHandle::CopyBufferHandle(buffer_handle_t handle,
+                                         const gralloc_module_t *gralloc) {
+  native_handle_t *handle_copy = dup_buffer_handle(handle);
+  if (handle_copy == NULL) {
+    ALOGE("Failed to duplicate handle");
+    return -ENOMEM;
+  }
+
+  int ret = gralloc->registerBuffer(gralloc, handle_copy);
+  if (ret) {
+    ALOGE("Failed to register buffer handle %d", ret);
+    free_buffer_handle(handle_copy);
+    return ret;
+  }
+
+  Clear();
+
+  gralloc_ = gralloc;
+  handle_ = handle_copy;
+
+  return 0;
+}
+
+DrmHwcNativeHandle::~DrmHwcNativeHandle() {
+  Clear();
+}
+
+void DrmHwcNativeHandle::Clear() {
+  if (gralloc_ != NULL && handle_ != NULL) {
+    gralloc_->unregisterBuffer(gralloc_, handle_);
+    free_buffer_handle(handle_);
+    gralloc_ = NULL;
+    handle_ = NULL;
+  }
+}
+
+int DrmHwcLayer::InitFromHwcLayer(hwc_layer_1_t *sf_layer, Importer *importer,
+                                  const gralloc_module_t *gralloc) {
+  sf_handle = sf_layer->handle;
+  int ret = buffer.ImportBuffer(sf_layer->handle, importer);
+  if (ret)
+    return ret;
+
+  ret = handle.CopyBufferHandle(sf_layer->handle, gralloc);
+  if (ret)
+    return ret;
+
+  alpha = sf_layer->planeAlpha;
+
+  switch (sf_layer->transform) {
+    case 0:
+      transform = DrmHwcTransform::kIdentity;
+      break;
+    case HWC_TRANSFORM_FLIP_H:
+      transform = DrmHwcTransform::kFlipH;
+      break;
+    case HWC_TRANSFORM_FLIP_V:
+      transform = DrmHwcTransform::kFlipV;
+      break;
+    case HWC_TRANSFORM_ROT_90:
+      transform = DrmHwcTransform::kRotate90;
+      break;
+    case HWC_TRANSFORM_ROT_180:
+      transform = DrmHwcTransform::kRotate180;
+      break;
+    case HWC_TRANSFORM_ROT_270:
+      transform = DrmHwcTransform::kRotate270;
+      break;
+    default:
+      ALOGE("Invalid transform in hwc_layer_1_t %d", sf_layer->transform);
+      return -EINVAL;
+  }
+
+  switch (sf_layer->blending) {
+    case HWC_BLENDING_NONE:
+      blending = DrmHwcBlending::kNone;
+      break;
+    case HWC_BLENDING_PREMULT:
+      blending = DrmHwcBlending::kPreMult;
+      break;
+    case HWC_BLENDING_COVERAGE:
+      blending = DrmHwcBlending::kCoverage;
+      break;
+    default:
+      ALOGE("Invalid blending in hwc_layer_1_t %d", sf_layer->blending);
+      return -EINVAL;
+  }
+
+  source_crop = DrmHwcRect<float>(
+      sf_layer->sourceCropf.left, sf_layer->sourceCropf.top,
+      sf_layer->sourceCropf.right, sf_layer->sourceCropf.bottom);
+  display_frame = DrmHwcRect<int>(
+      sf_layer->displayFrame.left, sf_layer->displayFrame.top,
+      sf_layer->displayFrame.right, sf_layer->displayFrame.bottom);
+
+  return 0;
+}
+
 static void hwc_dump(struct hwc_composer_device_1 *dev, char *buff,
                      int buff_len) {
   struct hwc_context_t *ctx = (struct hwc_context_t *)&dev->common;
@@ -131,27 +375,6 @@
   return 0;
 }
 
-static void hwc_set_cleanup(size_t num_displays,
-                            hwc_display_contents_1_t **display_contents) {
-  for (int i = 0; i < (int)num_displays; ++i) {
-    if (!display_contents[i])
-      continue;
-
-    hwc_display_contents_1_t *dc = display_contents[i];
-    for (size_t j = 0; j < dc->numHwLayers; ++j) {
-      hwc_layer_1_t *layer = &dc->hwLayers[j];
-      if (layer->acquireFenceFd >= 0) {
-        close(layer->acquireFenceFd);
-        layer->acquireFenceFd = -1;
-      }
-    }
-    if (dc->outbufAcquireFenceFd >= 0) {
-      close(dc->outbufAcquireFenceFd);
-      dc->outbufAcquireFenceFd = -1;
-    }
-  }
-}
-
 static void hwc_add_layer_to_retire_fence(
     hwc_layer_1_t *layer, hwc_display_contents_1_t *display_contents) {
   if (layer->releaseFenceFd < 0)
@@ -168,109 +391,133 @@
 }
 
 static int hwc_set(hwc_composer_device_1_t *dev, size_t num_displays,
-                   hwc_display_contents_1_t **display_contents) {
+                   hwc_display_contents_1_t **sf_display_contents) {
   ATRACE_CALL();
   struct hwc_context_t *ctx = (struct hwc_context_t *)&dev->common;
-  int ret;
-  std::unique_ptr<DrmComposition> composition(
-      ctx->drm.compositor()->CreateComposition(ctx->importer));
-  if (!composition) {
-    ALOGE("Drm composition init failed");
-    hwc_set_cleanup(num_displays, display_contents);
-    return -EINVAL;
-  }
+  int ret = 0;
 
+  std::vector<CheckedOutputFd> checked_output_fences;
+  std::vector<DrmHwcDisplayContents> displays_contents;
   std::vector<DrmCompositionDisplayLayersMap> layers_map;
   std::vector<std::vector<size_t>> layers_indices;
-  layers_map.reserve(num_displays);
+  displays_contents.reserve(num_displays);
+  // layers_map.reserve(num_displays);
   layers_indices.reserve(num_displays);
 
-  for (int i = 0; i < (int)num_displays; ++i) {
-    if (!display_contents[i])
+  // Phase one does nothing that would cause errors. Only take ownership of FDs.
+  for (size_t i = 0; i < num_displays; ++i) {
+    hwc_display_contents_1_t *dc = sf_display_contents[i];
+    displays_contents.emplace_back();
+    DrmHwcDisplayContents &display_contents = displays_contents.back();
+
+    if (!sf_display_contents[i])
       continue;
-    hwc_display_contents_1_t *dc = display_contents[i];
 
-    layers_map.emplace_back();
-    DrmCompositionDisplayLayersMap &map = layers_map[i];
-    map.display = i;
-    map.layers = dc->hwLayers;
+    std::ostringstream display_index_formatter;
+    display_index_formatter << "retire fence for display " << i;
+    std::string display_fence_description(display_index_formatter.str());
+    checked_output_fences.emplace_back(&dc->retireFenceFd,
+                                       display_fence_description.c_str(),
+                                       ctx->dummy_timeline);
+    display_contents.retire_fence = OutputFd(&dc->retireFenceFd);
 
+    size_t num_dc_layers = dc->numHwLayers;
     std::vector<size_t> indices_to_composite;
-    unsigned num_dc_layers = dc->numHwLayers;
     int framebuffer_target_index = -1;
-    for (int j = 0; j < (int)num_dc_layers; ++j) {
-      hwc_layer_1_t *layer = &dc->hwLayers[j];
-      if (layer->flags & HWC_SKIP_LAYER)
+    for (size_t j = 0; j < num_dc_layers; ++j) {
+      hwc_layer_1_t *sf_layer = &dc->hwLayers[j];
+
+      display_contents.layers.emplace_back();
+      DrmHwcLayer &layer = display_contents.layers.back();
+
+      if (sf_layer->flags & HWC_SKIP_LAYER)
         continue;
+
       if (!ctx->use_framebuffer_target) {
-        if (layer->compositionType == HWC_OVERLAY)
+        if (sf_layer->compositionType == HWC_OVERLAY)
           indices_to_composite.push_back(j);
-        if (layer->compositionType == HWC_FRAMEBUFFER_TARGET)
+        if (sf_layer->compositionType == HWC_FRAMEBUFFER_TARGET)
           framebuffer_target_index = j;
       } else {
-        if (layer->compositionType == HWC_FRAMEBUFFER_TARGET)
+        if (sf_layer->compositionType == HWC_FRAMEBUFFER_TARGET)
           indices_to_composite.push_back(j);
       }
+
+      layer.acquire_fence.Set(sf_layer->acquireFenceFd);
+      sf_layer->acquireFenceFd = -1;
+
+      std::ostringstream layer_fence_formatter;
+      layer_fence_formatter << "release fence for layer " << j << " of display "
+                            << i;
+      std::string layer_fence_description(layer_fence_formatter.str());
+      checked_output_fences.emplace_back(&sf_layer->releaseFenceFd,
+                                         layer_fence_description.c_str(),
+                                         ctx->dummy_timeline);
+      layer.release_fence = OutputFd(&sf_layer->releaseFenceFd);
     }
+
     if (ctx->use_framebuffer_target) {
       if (indices_to_composite.size() != 1) {
         ALOGE("Expected 1 (got %d) layer with HWC_FRAMEBUFFER_TARGET",
               indices_to_composite.size());
-        hwc_set_cleanup(num_displays, display_contents);
-        return -EINVAL;
+        ret = -EINVAL;
       }
     } else {
       if (indices_to_composite.empty() && framebuffer_target_index >= 0) {
-        // Fall back to use HWC_FRAMEBUFFER_TARGET if all HWC_OVERLAY layers
-        // are skipped.
-        hwc_layer_1_t *layer = &dc->hwLayers[framebuffer_target_index];
-        if (!layer->handle || (layer->flags & HWC_SKIP_LAYER)) {
-          ALOGE("Expected valid layer with HWC_FRAMEBUFFER_TARGET when all "
-                "HWC_OVERLAY layers are skipped.");
-          hwc_set_cleanup(num_displays, display_contents);
-          return -EINVAL;
+        hwc_layer_1_t *sf_layer = &dc->hwLayers[framebuffer_target_index];
+        if (!sf_layer->handle || (sf_layer->flags & HWC_SKIP_LAYER)) {
+          ALOGE(
+              "Expected valid layer with HWC_FRAMEBUFFER_TARGET when all "
+              "HWC_OVERLAY layers are skipped.");
+          ret = -EINVAL;
         }
         indices_to_composite.push_back(framebuffer_target_index);
       }
     }
+    layers_indices.emplace_back(indices_to_composite);
+  }
 
-    map.num_layers = indices_to_composite.size();
-    layers_indices.emplace_back(std::move(indices_to_composite));
-    map.layer_indices = layers_indices.back().data();
+  if (ret)
+    return ret;
+
+  for (size_t i = 0; i < num_displays; ++i) {
+    hwc_display_contents_1_t *dc = sf_display_contents[i];
+    DrmHwcDisplayContents &display_contents = displays_contents[i];
+    if (!sf_display_contents[i])
+      continue;
+
+    layers_map.emplace_back();
+    DrmCompositionDisplayLayersMap &map = layers_map.back();
+    std::vector<size_t> &indices_to_composite = layers_indices[i];
+    for (size_t j : indices_to_composite) {
+      hwc_layer_1_t *sf_layer = &dc->hwLayers[j];
+
+      DrmHwcLayer &layer = display_contents.layers[j];
+
+      layer.InitFromHwcLayer(sf_layer, ctx->importer, ctx->gralloc);
+      map.layers.emplace_back(std::move(layer));
+    }
+  }
+
+  std::unique_ptr<DrmComposition> composition(
+      ctx->drm.compositor()->CreateComposition(ctx->importer));
+  if (!composition) {
+    ALOGE("Drm composition init failed");
+    return -EINVAL;
   }
 
   ret = composition->SetLayers(layers_map.size(), layers_map.data());
   if (ret) {
-    hwc_set_cleanup(num_displays, display_contents);
     return -EINVAL;
   }
 
   ret = ctx->drm.compositor()->QueueComposition(std::move(composition));
   if (ret) {
-    hwc_set_cleanup(num_displays, display_contents);
     return -EINVAL;
   }
 
   composition.reset(NULL);
 
-  for (int i = 0; i < (int)num_displays; ++i) {
-    if (!display_contents[i])
-      continue;
-    hwc_display_contents_1_t *dc = display_contents[i];
-    unsigned num_dc_layers = dc->numHwLayers;
-    for (int j = 0; j < (int)num_dc_layers; ++j) {
-      hwc_layer_1_t *layer = &dc->hwLayers[j];
-      if (layer->flags & HWC_SKIP_LAYER)
-        continue;
-      if (layer->compositionType == HWC_OVERLAY)
-        hwc_add_layer_to_retire_fence(layer, dc);
-    }
-  }
-
-  if (ret) {
-    ALOGE("Failed to queue the composition");
-  }
-  hwc_set_cleanup(num_displays, display_contents);
   return ret;
 }
 
@@ -551,6 +798,20 @@
     return ret;
   }
 
+  ret = hw_get_module(GRALLOC_HARDWARE_MODULE_ID,
+                      (const hw_module_t **)&ctx->gralloc);
+  if (ret) {
+    ALOGE("Failed to open gralloc module %d", ret);
+    delete ctx;
+    return ret;
+  }
+
+  ret = ctx->dummy_timeline.Init();
+  if (ret) {
+    ALOGE("Failed to create dummy sw sync timeline %d", ret);
+    return ret;
+  }
+
   ctx->importer = Importer::CreateInstance(&ctx->drm);
   if (!ctx->importer) {
     ALOGE("Failed to create importer instance");
diff --git a/seperate_rects.h b/seperate_rects.h
index 9bf95a3..540a5e8 100644
--- a/seperate_rects.h
+++ b/seperate_rects.h
@@ -43,11 +43,19 @@
       : x1(xx1), y1(yy1), x2(xx2), y2(yy2) {
   }
 
-  Rect(const Rect &rhs) {
+  template <typename T>
+  Rect(const Rect<T> &rhs) {
     for (int i = 0; i < 4; i++)
       bounds[i] = rhs.bounds[i];
   }
 
+  template <typename T>
+  Rect<TFloat> &operator=(const Rect<T> &rhs) {
+    for (int i = 0; i < 4; i++)
+      bounds[i] = rhs.bounds[i];
+    return *this;
+  }
+
   bool operator==(const Rect &rhs) const {
     for (int i = 0; i < 4; i++) {
       if (bounds[i] != rhs.bounds[i])