diff --git a/libhwcomposer/hwc.cpp b/libhwcomposer/hwc.cpp
index a5e31ef..699e2ac 100644
--- a/libhwcomposer/hwc.cpp
+++ b/libhwcomposer/hwc.cpp
@@ -23,6 +23,7 @@
 #include <EGL/egl.h>
 
 #include "hwc_utils.h"
+#include "hwc_video.h"
 
 using namespace qhwc;
 
@@ -65,19 +66,19 @@
 static int hwc_prepare(hwc_composer_device_t *dev, hwc_layer_list_t* list)
 {
     hwc_context_t* ctx = (hwc_context_t*)(dev);
+    ctx->overlayInUse = false;
+
+    //Prepare is called after a vsync, so unlock previous buffers here.
+    ctx->qbuf->unlockAllPrevious();
+
     if (LIKELY(list)) {
         getLayerStats(ctx, list);
-        cleanOverlays(ctx);
-        for (int i=list->numHwLayers-1; i >= 0 ; i--) {
-            private_handle_t *hnd =
-                (private_handle_t *)list->hwLayers[i].handle;
-            if (isSkipLayer(&list->hwLayers[i])) {
-                break;
-            } else if(isYuvBuffer(hnd)) {
-                handleYUV(ctx,&list->hwLayers[i]);
-            } else {
-                list->hwLayers[i].compositionType = HWC_FRAMEBUFFER;
-            }
+        if(VideoOverlay::prepare(ctx, list)) {
+            ctx->overlayInUse = true;
+            //Nothing here
+        } else if (0) {
+            //Other features
+            ctx->overlayInUse = true;
         }
     }
     return 0;
@@ -91,21 +92,16 @@
     int ret = 0;
     hwc_context_t* ctx = (hwc_context_t*)(dev);
     if (LIKELY(list)) {
-        for (size_t i=0; i<list->numHwLayers; i++) {
-            if (list->hwLayers[i].flags & HWC_SKIP_LAYER) {
-                continue;
-            } else if (list->hwLayers[i].compositionType == HWC_OVERLAY) {
-                drawLayerUsingOverlay(ctx, &(list->hwLayers[i]));
-            }
-        }
-        //XXX: Handle vsync with FBIO_WAITFORVSYNC ioctl
-        //All other operations (including pan display) should be NOWAIT
+        VideoOverlay::draw(ctx, list);
         EGLBoolean sucess = eglSwapBuffers((EGLDisplay)dpy, (EGLSurface)sur);
     } else {
-        //XXX: put in a wrapper for non overlay targets
-        setOverlayState(ctx, ovutils::OV_CLOSED);
+        ctx->mOverlay->setState(ovutils::OV_CLOSED);
+        ctx->qbuf->unlockAllPrevious();
     }
-    ctx->qbuf->unlockAllPrevious();
+
+    if(!ctx->overlayInUse)
+        ctx->mOverlay->setState(ovutils::OV_CLOSED);
+
     return ret;
 }
 
