diff --git a/libexternal/external.cpp b/libexternal/external.cpp
index 43451de..e3de5ce 100644
--- a/libexternal/external.cpp
+++ b/libexternal/external.cpp
@@ -781,6 +781,11 @@
             height = 2160;
             fps = 24;
             break;
+        case HDMI_VFRMT_3840x2160p25_16_9:
+            width = 3840;
+            height = 2160;
+            fps = 25;
+            break;
         case HDMI_VFRMT_3840x2160p30_16_9:
             width = 3840;
             height = 2160;
diff --git a/libhwcomposer/Android.mk b/libhwcomposer/Android.mk
index 3b08fc5..4b9d04b 100644
--- a/libhwcomposer/Android.mk
+++ b/libhwcomposer/Android.mk
@@ -5,11 +5,13 @@
 LOCAL_MODULE                  := hwcomposer.$(TARGET_BOARD_PLATFORM)
 LOCAL_MODULE_PATH             := $(TARGET_OUT_SHARED_LIBRARIES)/hw
 LOCAL_MODULE_TAGS             := optional
-LOCAL_C_INCLUDES              := $(common_includes) $(kernel_includes)
+LOCAL_C_INCLUDES              := $(common_includes) $(kernel_includes) \
+                                 $(TOP)/external/skia/include/core \
+                                 $(TOP)/external/skia/include/images
 LOCAL_SHARED_LIBRARIES        := $(common_libs) libEGL liboverlay \
                                  libexternal libqdutils libhardware_legacy \
                                  libdl libmemalloc libqservice libsync \
-                                 libbinder libmedia
+                                 libbinder libmedia libskia
 LOCAL_CFLAGS                  := $(common_flags) -DLOG_TAG=\"qdhwcomposer\"
 LOCAL_ADDITIONAL_DEPENDENCIES := $(common_deps)
 LOCAL_SRC_FILES               := hwc.cpp          \
@@ -19,6 +21,7 @@
                                  hwc_fbupdate.cpp \
                                  hwc_mdpcomp.cpp  \
                                  hwc_copybit.cpp  \
-                                 hwc_qclient.cpp
+                                 hwc_qclient.cpp  \
+                                 hwc_dump_layers.cpp
 
 include $(BUILD_SHARED_LIBRARY)
diff --git a/libhwcomposer/hwc.cpp b/libhwcomposer/hwc.cpp
index 42f5c85..8e7afa2 100644
--- a/libhwcomposer/hwc.cpp
+++ b/libhwcomposer/hwc.cpp
@@ -32,6 +32,7 @@
 #include "hwc_utils.h"
 #include "hwc_fbupdate.h"
 #include "hwc_mdpcomp.h"
+#include "hwc_dump_layers.h"
 #include "external.h"
 #include "hwc_copybit.h"
 #include "profiler.h"
@@ -357,6 +358,10 @@
         if(list->numHwLayers > 1)
             hwc_sync(ctx, list, dpy, fd);
 
+        // Dump the layers for primary
+        if(ctx->mHwcDebug[dpy])
+            ctx->mHwcDebug[dpy]->dumpLayers(list);
+
         if (!ctx->mMDPComp[dpy]->draw(ctx, list)) {
             ALOGE("%s: MDPComp draw failed", __FUNCTION__);
             ret = -1;
@@ -406,6 +411,10 @@
         if(list->numHwLayers > 1)
             hwc_sync(ctx, list, dpy, fd);
 
+        // Dump the layers for external
+        if(ctx->mHwcDebug[dpy])
+            ctx->mHwcDebug[dpy]->dumpLayers(list);
+
         if (!ctx->mMDPComp[dpy]->draw(ctx, list)) {
             ALOGE("%s: MDPComp draw failed", __FUNCTION__);
             ret = -1;
diff --git a/libhwcomposer/hwc_dump_layers.cpp b/libhwcomposer/hwc_dump_layers.cpp
new file mode 100644
index 0000000..cf23b65
--- /dev/null
+++ b/libhwcomposer/hwc_dump_layers.cpp
@@ -0,0 +1,437 @@
+/*
+ * Copyright (c) 2012-2013, Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   * Neither the name of Linux Foundation nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef LOG_TAG
+#define LOG_TAG "qsfdump"
+#endif
+#define LOG_NDEBUG 0
+#include <hwc_utils.h>
+#include <hwc_dump_layers.h>
+#include <cutils/log.h>
+#include <sys/stat.h>
+#include <comptype.h>
+#include <SkBitmap.h>
+#include <SkImageEncoder.h>
+
+namespace qhwc {
+
+// MAX_ALLOWED_FRAMEDUMPS must be capped to (LONG_MAX - 1)
+// 60fps => 216000 frames per hour
+// Below setting of 216000 * 24 * 7 => 1 week or 168 hours of capture.
+  enum {
+    MAX_ALLOWED_FRAMEDUMPS = (216000 * 24 * 7)
+  };
+
+bool HwcDebug::sDumpEnable = false;
+
+HwcDebug::HwcDebug(uint32_t dpy):
+  mDumpCntLimRaw(0),
+  mDumpCntrRaw(1),
+  mDumpCntLimPng(0),
+  mDumpCntrPng(1),
+  mDpy(dpy) {
+    char dumpPropStr[PROPERTY_VALUE_MAX];
+    if(mDpy) {
+        strncpy(mDisplayName, "external", strlen("external"));
+    } else {
+        strncpy(mDisplayName, "primary", strlen("primary"));
+    }
+    sprintf(mDumpPropKeyDisplayType, "debug.sf.dump.%s", (char *)mDisplayName);
+
+    if ((property_get("debug.sf.dump.enable", dumpPropStr, NULL) > 0)) {
+        if(!strncmp(dumpPropStr, "true", strlen("true"))) {
+            sDumpEnable = true;
+        }
+    }
+}
+
+void HwcDebug::dumpLayers(hwc_display_contents_1_t* list)
+{
+    // Check need for dumping layers for debugging.
+    if (UNLIKELY(sDumpEnable) && UNLIKELY(needToDumpLayers()) && LIKELY(list)) {
+        logHwcProps(list->flags);
+        for (size_t i = 0; i < list->numHwLayers; i++) {
+            logLayer(i, list->hwLayers);
+            dumpLayer(i, list->hwLayers);
+        }
+    }
+}
+
+bool HwcDebug::needToDumpLayers()
+{
+    bool bDumpLayer = false;
+    char dumpPropStr[PROPERTY_VALUE_MAX];
+    // Enable primary dump and disable external dump by default.
+    bool bDumpEnable = !mDpy;
+    time_t timeNow;
+    tm dumpTime;
+
+    // Override the bDumpEnable based on the property value, if the property
+    // is present in the build.prop file.
+    if ((property_get(mDumpPropKeyDisplayType, dumpPropStr, NULL) > 0)) {
+        if(!strncmp(dumpPropStr, "true", strlen("true")))
+            bDumpEnable = true;
+        else
+            bDumpEnable = false;
+    }
+
+    if (false == bDumpEnable)
+        return false;
+
+    time(&timeNow);
+    localtime_r(&timeNow, &dumpTime);
+
+    if ((property_get("debug.sf.dump.png", dumpPropStr, NULL) > 0) &&
+            (strncmp(dumpPropStr, mDumpPropStrPng, PROPERTY_VALUE_MAX - 1))) {
+        // Strings exist & not equal implies it has changed, so trigger a dump
+        strncpy(mDumpPropStrPng, dumpPropStr, PROPERTY_VALUE_MAX - 1);
+        mDumpCntLimPng = atoi(dumpPropStr);
+        if (mDumpCntLimPng > MAX_ALLOWED_FRAMEDUMPS) {
+            ALOGW("Warning: Using debug.sf.dump.png %d (= max)",
+                MAX_ALLOWED_FRAMEDUMPS);
+            mDumpCntLimPng = MAX_ALLOWED_FRAMEDUMPS;
+        }
+        mDumpCntLimPng = (mDumpCntLimPng < 0) ? 0: mDumpCntLimPng;
+        if (mDumpCntLimPng) {
+            sprintf(mDumpDirPng,
+                    "/data/sfdump.png.%04d.%02d.%02d.%02d.%02d.%02d",
+                    dumpTime.tm_year + 1900, dumpTime.tm_mon + 1,
+                    dumpTime.tm_mday, dumpTime.tm_hour,
+                    dumpTime.tm_min, dumpTime.tm_sec);
+            if (0 == mkdir(mDumpDirPng, 0777))
+                mDumpCntrPng = 0;
+            else {
+                ALOGE("Error: %s. Failed to create sfdump directory: %s",
+                    strerror(errno), mDumpDirPng);
+                mDumpCntrPng = mDumpCntLimPng + 1;
+            }
+        }
+    }
+
+    if (mDumpCntrPng <= mDumpCntLimPng)
+        mDumpCntrPng++;
+
+    if ((property_get("debug.sf.dump", dumpPropStr, NULL) > 0) &&
+            (strncmp(dumpPropStr, mDumpPropStrRaw, PROPERTY_VALUE_MAX - 1))) {
+        // Strings exist & not equal implies it has changed, so trigger a dump
+        strncpy(mDumpPropStrRaw, dumpPropStr, PROPERTY_VALUE_MAX - 1);
+        mDumpCntLimRaw = atoi(dumpPropStr);
+        if (mDumpCntLimRaw > MAX_ALLOWED_FRAMEDUMPS) {
+            ALOGW("Warning: Using debug.sf.dump %d (= max)",
+                MAX_ALLOWED_FRAMEDUMPS);
+            mDumpCntLimRaw = MAX_ALLOWED_FRAMEDUMPS;
+        }
+        mDumpCntLimRaw = (mDumpCntLimRaw < 0) ? 0: mDumpCntLimRaw;
+        if (mDumpCntLimRaw) {
+            sprintf(mDumpDirRaw,
+                    "/data/sfdump.raw.%04d.%02d.%02d.%02d.%02d.%02d",
+                    dumpTime.tm_year + 1900, dumpTime.tm_mon + 1,
+                    dumpTime.tm_mday, dumpTime.tm_hour,
+                    dumpTime.tm_min, dumpTime.tm_sec);
+            if (0 == mkdir(mDumpDirRaw, 0777))
+                mDumpCntrRaw = 0;
+            else {
+                ALOGE("Error: %s. Failed to create sfdump directory: %s",
+                    strerror(errno), mDumpDirRaw);
+                mDumpCntrRaw = mDumpCntLimRaw + 1;
+            }
+        }
+    }
+
+    if (mDumpCntrRaw <= mDumpCntLimRaw)
+        mDumpCntrRaw++;
+
+    bDumpLayer = (mDumpCntLimPng || mDumpCntLimRaw)? true : false;
+    return bDumpLayer;
+}
+
+void HwcDebug::logHwcProps(uint32_t listFlags)
+{
+    static int hwcModuleCompType = -1;
+    static int sMdpCompMaxLayers = 0;
+    static String8 hwcModuleCompTypeLog("");
+    if (-1 == hwcModuleCompType) {
+        // One time stuff
+        char mdpCompPropStr[PROPERTY_VALUE_MAX];
+        if (property_get("debug.mdpcomp.maxlayer", mdpCompPropStr, NULL) > 0) {
+            sMdpCompMaxLayers = atoi(mdpCompPropStr);
+        }
+        hwcModuleCompType =
+            qdutils::QCCompositionType::getInstance().getCompositionType();
+        hwcModuleCompTypeLog.appendFormat("%s%s%s%s%s%s",
+            // Is hwc module composition type now a bit-field?!
+            (hwcModuleCompType == qdutils::COMPOSITION_TYPE_GPU)?
+                "[GPU]": "",
+            (hwcModuleCompType & qdutils::COMPOSITION_TYPE_MDP)?
+                "[MDP]": "",
+            (hwcModuleCompType & qdutils::COMPOSITION_TYPE_C2D)?
+                "[C2D]": "",
+            (hwcModuleCompType & qdutils::COMPOSITION_TYPE_CPU)?
+                "[CPU]": "",
+            (hwcModuleCompType & qdutils::COMPOSITION_TYPE_DYN)?
+                "[DYN]": "",
+            (hwcModuleCompType >= (qdutils::COMPOSITION_TYPE_DYN << 1))?
+                "[???]": "");
+    }
+    ALOGI("Display[%s] Layer[*] %s-HwcModuleCompType, %d-layer MdpComp %s",
+         mDisplayName, hwcModuleCompTypeLog.string(), sMdpCompMaxLayers,
+        (listFlags & HWC_GEOMETRY_CHANGED)? "[HwcList Geometry Changed]": "");
+}
+
+void HwcDebug::logLayer(size_t layerIndex, hwc_layer_1_t hwLayers[])
+{
+    if (NULL == hwLayers) {
+        ALOGE("Display[%s] Layer[%d] Error. No hwc layers to log.",
+            mDisplayName, layerIndex);
+        return;
+    }
+
+    hwc_layer_1_t *layer = &hwLayers[layerIndex];
+    hwc_rect_t sourceCrop = layer->sourceCrop;
+    hwc_rect_t displayFrame = layer->displayFrame;
+    size_t numHwcRects = layer->visibleRegionScreen.numRects;
+    hwc_rect_t const *hwcRects = layer->visibleRegionScreen.rects;
+    private_handle_t *hnd = (private_handle_t *)layer->handle;
+
+    char pixFormatStr[32] = "None";
+    String8 hwcVisRegsScrLog("[None]");
+
+    for (size_t i = 0 ; (hwcRects && (i < numHwcRects)); i++) {
+        if (0 == i)
+            hwcVisRegsScrLog.clear();
+        hwcVisRegsScrLog.appendFormat("[%dl, %dt, %dr, %db]",
+                                        hwcRects[i].left, hwcRects[i].top,
+                                        hwcRects[i].right, hwcRects[i].bottom);
+    }
+
+    if (hnd)
+        getHalPixelFormatStr(hnd->format, pixFormatStr);
+
+    // Log Line 1
+    ALOGI("Display[%s] Layer[%d] SrcBuff[%dx%d] SrcCrop[%dl, %dt, %dr, %db] "
+        "DispFrame[%dl, %dt, %dr, %db] VisRegsScr%s", mDisplayName, layerIndex,
+        (hnd)? hnd->width : -1, (hnd)? hnd->height : -1,
+        sourceCrop.left, sourceCrop.top,
+        sourceCrop.right, sourceCrop.bottom,
+        displayFrame.left, displayFrame.top,
+        displayFrame.right, displayFrame.bottom,
+        hwcVisRegsScrLog.string());
+    // Log Line 2
+    ALOGI("Display[%s] Layer[%d] LayerCompType = %s, Format = %s, "
+        "Orientation = %s, Flags = %s%s%s, Hints = %s%s%s, "
+        "Blending = %s%s%s", mDisplayName, layerIndex,
+        (layer->compositionType == HWC_FRAMEBUFFER)? "Framebuffer(GPU)":
+            (layer->compositionType == HWC_OVERLAY)? "Overlay":
+            (layer->compositionType == HWC_BACKGROUND)? "Background":"???",
+         pixFormatStr,
+         (layer->transform == 0)? "ROT_0":
+             (layer->transform == HWC_TRANSFORM_FLIP_H)? "FLIP_H":
+             (layer->transform == HWC_TRANSFORM_FLIP_V)? "FLIP_V":
+             (layer->transform == HWC_TRANSFORM_ROT_90)? "ROT_90":
+                                                        "ROT_INVALID",
+         (layer->flags)? "": "[None]",
+         (layer->flags & HWC_SKIP_LAYER)? "[Skip layer]":"",
+         (layer->flags & qhwc::HWC_MDPCOMP)? "[MDP Comp]":"",
+         (layer->hints)? "":"[None]",
+         (layer->hints & HWC_HINT_TRIPLE_BUFFER)? "[Triple Buffer]":"",
+         (layer->hints & HWC_HINT_CLEAR_FB)? "[Clear FB]":"",
+         (layer->blending == HWC_BLENDING_NONE)? "[None]":"",
+         (layer->blending == HWC_BLENDING_PREMULT)? "[PreMult]":"",
+         (layer->blending == HWC_BLENDING_COVERAGE)? "[Coverage]":"");
+}
+
+void HwcDebug::dumpLayer(size_t layerIndex, hwc_layer_1_t hwLayers[])
+{
+    char dumpLogStrPng[128] = "";
+    char dumpLogStrRaw[128] = "";
+    bool needDumpPng = (mDumpCntrPng <= mDumpCntLimPng)? true:false;
+    bool needDumpRaw = (mDumpCntrRaw <= mDumpCntLimRaw)? true:false;
+
+    if (needDumpPng) {
+        sprintf(dumpLogStrPng, "[png-dump-frame: %03d of %03d]", mDumpCntrPng,
+            mDumpCntLimPng);
+    }
+    if (needDumpRaw) {
+        sprintf(dumpLogStrRaw, "[raw-dump-frame: %03d of %03d]", mDumpCntrRaw,
+            mDumpCntLimRaw);
+    }
+
+    if (!(needDumpPng || needDumpRaw))
+        return;
+
+    if (NULL == hwLayers) {
+        ALOGE("Display[%s] Layer[%d] %s%s Error: No hwc layers to dump.",
+            mDisplayName, layerIndex, dumpLogStrRaw, dumpLogStrPng);
+        return;
+    }
+
+    hwc_layer_1_t *layer = &hwLayers[layerIndex];
+    private_handle_t *hnd = (private_handle_t *)layer->handle;
+    char pixFormatStr[32] = "None";
+
+    if (NULL == hnd) {
+        ALOGI("Display[%s] Layer[%d] %s%s Skipping dump: Bufferless layer.",
+            mDisplayName, layerIndex, dumpLogStrRaw, dumpLogStrPng);
+        return;
+    }
+
+    getHalPixelFormatStr(hnd->format, pixFormatStr);
+
+    if (needDumpPng && hnd->base) {
+        bool bResult = false;
+        char dumpFilename[PATH_MAX];
+        SkBitmap *tempSkBmp = new SkBitmap();
+        SkBitmap::Config tempSkBmpConfig = SkBitmap::kNo_Config;
+        sprintf(dumpFilename, "%s/sfdump%03d.layer%d.%s.png", mDumpDirPng,
+            mDumpCntrPng, layerIndex, mDisplayName);
+
+        switch (hnd->format) {
+            case HAL_PIXEL_FORMAT_RGBA_8888:
+            case HAL_PIXEL_FORMAT_RGBX_8888:
+            case HAL_PIXEL_FORMAT_BGRA_8888:
+                tempSkBmpConfig = SkBitmap::kARGB_8888_Config;
+                break;
+            case HAL_PIXEL_FORMAT_RGB_565:
+            case HAL_PIXEL_FORMAT_RGBA_5551:
+            case HAL_PIXEL_FORMAT_RGBA_4444:
+                tempSkBmpConfig = SkBitmap::kRGB_565_Config;
+                break;
+            case HAL_PIXEL_FORMAT_RGB_888:
+            default:
+                tempSkBmpConfig = SkBitmap::kNo_Config;
+                break;
+        }
+        if (SkBitmap::kNo_Config != tempSkBmpConfig) {
+            tempSkBmp->setConfig(tempSkBmpConfig, hnd->width, hnd->height);
+            tempSkBmp->setPixels((void*)hnd->base);
+            bResult = SkImageEncoder::EncodeFile(dumpFilename,
+                                    *tempSkBmp, SkImageEncoder::kPNG_Type, 100);
+            ALOGI("Display[%s] Layer[%d] %s Dump to %s: %s",
+                mDisplayName, layerIndex, dumpLogStrPng,
+                dumpFilename, bResult ? "Success" : "Fail");
+        } else {
+            ALOGI("Display[%s] Layer[%d] %s Skipping dump: Unsupported layer"
+                " format %s for png encoder",
+                mDisplayName, layerIndex, dumpLogStrPng, pixFormatStr);
+        }
+        delete tempSkBmp; // Calls SkBitmap::freePixels() internally.
+    }
+
+    if (needDumpRaw && hnd->base) {
+        char dumpFilename[PATH_MAX];
+        bool bResult = false;
+        sprintf(dumpFilename, "%s/sfdump%03d.layer%d.%dx%d.%s.%s.raw",
+            mDumpDirRaw, mDumpCntrRaw,
+            layerIndex, hnd->width, hnd->height,
+            pixFormatStr, mDisplayName);
+        FILE* fp = fopen(dumpFilename, "w+");
+        if (NULL != fp) {
+            bResult = (bool) fwrite((void*)hnd->base, hnd->size, 1, fp);
+            fclose(fp);
+        }
+        ALOGI("Display[%s] Layer[%d] %s Dump to %s: %s",
+            mDisplayName, layerIndex, dumpLogStrRaw,
+            dumpFilename, bResult ? "Success" : "Fail");
+    }
+}
+
+void HwcDebug::getHalPixelFormatStr(int format, char pixFormatStr[])
+{
+    if (!pixFormatStr)
+        return;
+
+    switch(format) {
+        case HAL_PIXEL_FORMAT_RGBA_8888:
+            strcpy(pixFormatStr, "RGBA_8888");
+            break;
+        case HAL_PIXEL_FORMAT_RGBX_8888:
+            strcpy(pixFormatStr, "RGBX_8888");
+            break;
+        case HAL_PIXEL_FORMAT_RGB_888:
+            strcpy(pixFormatStr, "RGB_888");
+            break;
+        case HAL_PIXEL_FORMAT_RGB_565:
+            strcpy(pixFormatStr, "RGB_565");
+            break;
+        case HAL_PIXEL_FORMAT_BGRA_8888:
+            strcpy(pixFormatStr, "BGRA_8888");
+            break;
+        case HAL_PIXEL_FORMAT_RGBA_5551:
+            strcpy(pixFormatStr, "RGBA_5551");
+            break;
+        case HAL_PIXEL_FORMAT_RGBA_4444:
+            strcpy(pixFormatStr, "RGBA_4444");
+            break;
+        case HAL_PIXEL_FORMAT_YV12:
+            strcpy(pixFormatStr, "YV12");
+            break;
+        case HAL_PIXEL_FORMAT_YCbCr_422_SP:
+            strcpy(pixFormatStr, "YCbCr_422_SP_NV16");
+            break;
+        case HAL_PIXEL_FORMAT_YCrCb_420_SP:
+            strcpy(pixFormatStr, "YCrCb_420_SP_NV21");
+            break;
+        case HAL_PIXEL_FORMAT_YCbCr_422_I:
+            strcpy(pixFormatStr, "YCbCr_422_I_YUY2");
+            break;
+        case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:
+            strcpy(pixFormatStr, "NV12_ENCODEABLE");
+            break;
+        case HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED:
+            strcpy(pixFormatStr, "YCbCr_420_SP_TILED_TILE_4x2");
+            break;
+        case HAL_PIXEL_FORMAT_YCbCr_420_SP:
+            strcpy(pixFormatStr, "YCbCr_420_SP");
+            break;
+        case HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO:
+            strcpy(pixFormatStr, "YCrCb_420_SP_ADRENO");
+            break;
+        case HAL_PIXEL_FORMAT_YCrCb_422_SP:
+            strcpy(pixFormatStr, "YCrCb_422_SP");
+            break;
+        case HAL_PIXEL_FORMAT_R_8:
+            strcpy(pixFormatStr, "R_8");
+            break;
+        case HAL_PIXEL_FORMAT_RG_88:
+            strcpy(pixFormatStr, "RG_88");
+            break;
+        case HAL_PIXEL_FORMAT_INTERLACE:
+            strcpy(pixFormatStr, "INTERLACE");
+            break;
+        case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
+            strcpy(pixFormatStr, "YCbCr_420_SP_VENUS");
+            break;
+        default:
+            sprintf(pixFormatStr, "Unknown0x%X", format);
+            break;
+    }
+}
+
+} // namespace qhwc
+
diff --git a/libhwcomposer/hwc_dump_layers.h b/libhwcomposer/hwc_dump_layers.h
new file mode 100644
index 0000000..f0d654f
--- /dev/null
+++ b/libhwcomposer/hwc_dump_layers.h
@@ -0,0 +1,138 @@
+/*
+ * Copyright (c) 2012-2013, Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   * Neither the name of Linux Foundation nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef HWC_DUMP_LAYERS_H
+#define HWC_DUMP_LAYERS_H
+
+#include <gralloc_priv.h>
+#include <comptype.h>
+#include <ui/Region.h>
+#include <hardware/hwcomposer.h>
+#include <utils/String8.h>
+
+namespace qhwc {
+
+class HwcDebug {
+private:
+
+// Using static variables for layer dumping since "property_set("debug.sf.dump",
+// property)" does not work.
+  int mDumpCntLimRaw;
+  int mDumpCntrRaw;
+  char mDumpPropStrRaw[PROPERTY_VALUE_MAX];
+  char mDumpDirRaw[PATH_MAX];
+  int mDumpCntLimPng;
+  int mDumpCntrPng;
+  char mDumpPropStrPng[PROPERTY_VALUE_MAX];
+  char mDumpDirPng[PATH_MAX];
+  uint32_t mDpy;
+  char mDisplayName[PROPERTY_VALUE_MAX];
+  char mDumpPropKeyDisplayType[PROPERTY_KEY_MAX];
+  static bool sDumpEnable;
+
+public:
+    HwcDebug(uint32_t dpy);
+    ~HwcDebug() {};
+
+    /*
+     * Dump layers for debugging based on "debug.sf.dump*" system property.
+     * See needToDumpLayers() for usage.
+     *
+     * @param: list - The HWC layer-list to dump.
+     *
+     */
+    void dumpLayers(hwc_display_contents_1_t* list);
+
+/*
+ * Checks if layers need to be dumped based on system property "debug.sf.dump"
+ * for raw dumps and "debug.sf.dump.png" for png dumps.
+ *
+ * Note: Set "debug.sf.dump.primary" or "debug.sf.dump.external" as true
+ * in the device's /system/build.prop file to enable layer logging/capturing
+ * feature for primary or external respectively. The feature is disabled by
+ * default to avoid per-frame property_get() calls.
+ *
+ * To turn on layer dump, set "debug.sf.dump.enable" to true in build.prop.
+ * By default debug.sf.dump.primary will be set to true for user convenience.
+ *
+ * To turn on layer dump for primary, do,
+ *     adb shell setprop debug.sf.dump.primary true
+ *
+ * To turn on layer dump for external, do,
+ *     adb shell setprop debug.sf.dump.external true
+ *
+ * For example, to dump 25 frames in raw format, do,
+ *     adb shell setprop debug.sf.dump 25
+ * Layers are dumped in a time-stamped location: /data/sfdump*.
+ *
+ * To dump 10 frames in png format, do,
+ *     adb shell setprop debug.sf.dump.png 10
+ * To dump another 25 or so frames in raw format, do,
+ *     adb shell setprop debug.sf.dump 26
+ *
+ * To turn off logcat logging of layer-info, set both properties to 0,
+ *     adb shell setprop debug.sf.dump.png 0
+ *     adb shell setprop debug.sf.dump 0
+ *
+ * @return: true if layers need to be dumped (or logcat-ed).
+ */
+bool needToDumpLayers();
+
+/*
+ * Log a few per-frame hwc properties into logcat.
+ *
+ * @param: listFlags - Flags used in hwcomposer's list.
+ *
+ */
+void logHwcProps(uint32_t listFlags);
+
+/*
+ * Log a layer's info into logcat.
+ *
+ * @param: layerIndex - Index of layer being dumped.
+ * @param: hwLayers - Address of hwc_layer_1_t to log and dump.
+ *
+ */
+void logLayer(size_t layerIndex, hwc_layer_1_t hwLayers[]);
+
+/*
+ * Dumps a layer buffer into raw/png files.
+ *
+ * @param: layerIndex - Index of layer being dumped.
+ * @param: hwLayers - Address of hwc_layer_1_t to log and dump.
+ *
+ */
+void dumpLayer(size_t layerIndex, hwc_layer_1_t hwLayers[]);
+
+void getHalPixelFormatStr(int format, char pixelformatstr[]);
+};
+
+} // namespace qhwc
+
+#endif /* HWC_DUMP_LAYERS_H */
diff --git a/libhwcomposer/hwc_fbupdate.cpp b/libhwcomposer/hwc_fbupdate.cpp
index f1f81c1..b8e6976 100644
--- a/libhwcomposer/hwc_fbupdate.cpp
+++ b/libhwcomposer/hwc_fbupdate.cpp
@@ -219,17 +219,19 @@
         ov.setTransform(orient, destR);
 
         hwc_rect_t displayFrame = sourceCrop;
-        //For FB left, top will always be 0
-        //That should also be the case if using 2 mixers for single display
-        ovutils::Dim dposL(displayFrame.left,
+        const int halfWidth = (displayFrame.right - displayFrame.left) / 2;
+        const int height = displayFrame.bottom - displayFrame.top;
+
+        ovutils::Dim dposL(MAX_DISPLAY_DIM - halfWidth,
                            displayFrame.top,
-                           (displayFrame.right - displayFrame.left) / 2,
-                           displayFrame.bottom - displayFrame.top);
+                           halfWidth,
+                           height);
         ov.setPosition(dposL, destL);
+
         ovutils::Dim dposR(0,
                            displayFrame.top,
-                           (displayFrame.right - displayFrame.left) / 2,
-                           displayFrame.bottom - displayFrame.top);
+                           halfWidth,
+                           height);
         ov.setPosition(dposR, destR);
 
         ret = true;
diff --git a/libhwcomposer/hwc_utils.cpp b/libhwcomposer/hwc_utils.cpp
index 57f94fe..db927e5 100644
--- a/libhwcomposer/hwc_utils.cpp
+++ b/libhwcomposer/hwc_utils.cpp
@@ -31,6 +31,7 @@
 #include "hwc_fbupdate.h"
 #include "mdp_version.h"
 #include "hwc_copybit.h"
+#include "hwc_dump_layers.h"
 #include "external.h"
 #include "hwc_qclient.h"
 #include "QService.h"
@@ -134,6 +135,9 @@
          MDPComp::getObject(ctx->dpyAttr[HWC_DISPLAY_PRIMARY].xres,
          HWC_DISPLAY_PRIMARY);
 
+    for (uint32_t i = 0; i < MAX_DISPLAYS; i++) {
+        ctx->mHwcDebug[i] = new HwcDebug(i);
+    }
     MDPComp::init(ctx);
 
     pthread_mutex_init(&(ctx->vstate.lock), NULL);
@@ -192,6 +196,10 @@
             delete ctx->mMDPComp[i];
             ctx->mMDPComp[i] = NULL;
         }
+        if(ctx->mHwcDebug[i]) {
+            delete ctx->mHwcDebug[i];
+            ctx->mHwcDebug[i] = NULL;
+        }
     }
 
 
@@ -670,8 +678,6 @@
     Dim srcCrop(crop.left, crop.top,
             crop.right - crop.left,
             crop.bottom - crop.top);
-    //getMdpOrient will switch the flips if the source is 90 rotated.
-    //Clients in Android dont factor in 90 rotation while deciding the flip.
     orient = static_cast<eTransform>(ovutils::getMdpOrient(orient));
     preRotateSource(orient, whf, srcCrop);
     crop.left = srcCrop.x;
diff --git a/libhwcomposer/hwc_utils.h b/libhwcomposer/hwc_utils.h
index 9da10f4..8c51b38 100644
--- a/libhwcomposer/hwc_utils.h
+++ b/libhwcomposer/hwc_utils.h
@@ -59,6 +59,7 @@
 class IVideoOverlay;
 class MDPComp;
 class CopyBit;
+class HwcDebug;
 
 
 struct MDPInfo {
@@ -259,6 +260,7 @@
     qhwc::ListStats listStats[MAX_DISPLAYS];
     qhwc::LayerProp *layerProp[MAX_DISPLAYS];
     qhwc::MDPComp *mMDPComp[MAX_DISPLAYS];
+    qhwc::HwcDebug *mHwcDebug[MAX_DISPLAYS];
 
     //Securing in progress indicator
     bool mSecuring;
diff --git a/liboverlay/overlayMdp.cpp b/liboverlay/overlayMdp.cpp
index ee8bf51..96cb56e 100644
--- a/liboverlay/overlayMdp.cpp
+++ b/liboverlay/overlayMdp.cpp
@@ -117,8 +117,6 @@
 void MdpCtrl::setTransform(const utils::eTransform& orient) {
     int rot = utils::getMdpOrient(orient);
     setUserData(rot);
-    //getMdpOrient will switch the flips if the source is 90 rotated.
-    //Clients in Android dont factor in 90 rotation while deciding the flip.
     mOrientation = static_cast<utils::eTransform>(rot);
 }
 
@@ -139,6 +137,7 @@
 }
 
 bool MdpCtrl::set() {
+    int mdpVersion = qdutils::MDPVersion::getInstance().getMDPVersion();
     //deferred calcs, so APIs could be called in any order.
     doTransform();
     doDownscale();
@@ -146,8 +145,10 @@
     if(utils::isYuv(whf.format)) {
         normalizeCrop(mOVInfo.src_rect.x, mOVInfo.src_rect.w);
         normalizeCrop(mOVInfo.src_rect.y, mOVInfo.src_rect.h);
-        utils::even_floor(mOVInfo.dst_rect.w);
-        utils::even_floor(mOVInfo.dst_rect.h);
+        if(mdpVersion < qdutils::MDSS_V5) {
+            utils::even_floor(mOVInfo.dst_rect.w);
+            utils::even_floor(mOVInfo.dst_rect.h);
+        }
     }
 
     if(this->ovChanged()) {
diff --git a/liboverlay/overlayMdpRot.cpp b/liboverlay/overlayMdpRot.cpp
index d1e036c..ecf31fa 100755
--- a/liboverlay/overlayMdpRot.cpp
+++ b/liboverlay/overlayMdpRot.cpp
@@ -104,8 +104,6 @@
 {
     int r = utils::getMdpOrient(rot);
     setRotations(r);
-    //getMdpOrient will switch the flips if the source is 90 rotated.
-    //Clients in Android dont factor in 90 rotation while deciding the flip.
     mOrientation = static_cast<utils::eTransform>(r);
     ALOGE_IF(DEBUG_OVERLAY, "%s: r=%d", __FUNCTION__, r);
 }
diff --git a/liboverlay/overlayMdssRot.cpp b/liboverlay/overlayMdssRot.cpp
index cf6d6fa..b9a22a9 100644
--- a/liboverlay/overlayMdssRot.cpp
+++ b/liboverlay/overlayMdssRot.cpp
@@ -98,8 +98,6 @@
     int flags = utils::getMdpOrient(rot);
     if (flags != -1)
         setRotations(flags);
-    //getMdpOrient will switch the flips if the source is 90 rotated.
-    //Clients in Android dont factor in 90 rotation while deciding the flip.
     mOrientation = static_cast<utils::eTransform>(flags);
     ALOGE_IF(DEBUG_OVERLAY, "%s: rot=%d", __FUNCTION__, flags);
 }
diff --git a/liboverlay/overlayUtils.cpp b/liboverlay/overlayUtils.cpp
index 898132f..edf3cec 100644
--- a/liboverlay/overlayUtils.cpp
+++ b/liboverlay/overlayUtils.cpp
@@ -180,6 +180,40 @@
     return -1;
 }
 
+int getMdpOrient(eTransform rotation) {
+    int retTrans = 0;
+    bool trans90 = false;
+    int mdpVersion = qdutils::MDPVersion::getInstance().getMDPVersion();
+    bool aFamily = (mdpVersion < qdutils::MDSS_V5);
+
+    ALOGD_IF(DEBUG_OVERLAY, "%s: In rotation = %d", __FUNCTION__, rotation);
+    if(rotation & OVERLAY_TRANSFORM_ROT_90) {
+        retTrans |= MDP_ROT_90;
+        trans90 = true;
+    }
+
+    if(rotation & OVERLAY_TRANSFORM_FLIP_H) {
+        if(trans90 && aFamily) {
+            //Swap for a-family, since its driver does 90 first
+            retTrans |= MDP_FLIP_UD;
+        } else {
+            retTrans |= MDP_FLIP_LR;
+        }
+    }
+
+    if(rotation & OVERLAY_TRANSFORM_FLIP_V) {
+        if(trans90 && aFamily) {
+            //Swap for a-family, since its driver does 90 first
+            retTrans |= MDP_FLIP_LR;
+        } else {
+            retTrans |= MDP_FLIP_UD;
+        }
+    }
+
+    ALOGD_IF(DEBUG_OVERLAY, "%s: Out rotation = %d", __FUNCTION__, retTrans);
+    return retTrans;
+}
+
 int getDownscaleFactor(const int& src_w, const int& src_h,
         const int& dst_w, const int& dst_h) {
     int dscale_factor = utils::ROT_DS_NONE;
@@ -215,9 +249,6 @@
     return x - ( y + z );
 }
 
-//Expects transform to be adjusted for clients of Android.
-//i.e flips switched if 90 component present.
-//See getMdpOrient()
 void preRotateSource(const eTransform& tr, Whf& whf, Dim& srcCrop) {
     if(tr & OVERLAY_TRANSFORM_FLIP_H) {
         srcCrop.x = compute(whf.w, srcCrop.x, srcCrop.w);
diff --git a/liboverlay/overlayUtils.h b/liboverlay/overlayUtils.h
index c189bb7..ceb238d 100644
--- a/liboverlay/overlayUtils.h
+++ b/liboverlay/overlayUtils.h
@@ -47,7 +47,7 @@
 
 // Older platforms do not support Venus
 #ifndef VENUS_COLOR_FORMAT
-#define MDP_Y_CBCR_H2V2_VENUS (MDP_IMGTYPE_LIMIT2 + 1)
+#define MDP_Y_CBCR_H2V2_VENUS MDP_IMGTYPE_LIMIT
 #endif
 
 /*
@@ -488,43 +488,47 @@
 }
 
 inline const char* getFormatString(int format){
-    static const char* const formats[] = {
-        "MDP_RGB_565",
-        "MDP_XRGB_8888",
-        "MDP_Y_CBCR_H2V2",
-        "MDP_Y_CBCR_H2V2_ADRENO",
-        "MDP_ARGB_8888",
-        "MDP_RGB_888",
-        "MDP_Y_CRCB_H2V2",
-        "MDP_YCRYCB_H2V1",
-        "MDP_Y_CRCB_H2V1",
-        "MDP_Y_CBCR_H2V1",
-        "MDP_Y_CRCB_H1V2",
-        "MDP_Y_CBCR_H1V2",
-        "MDP_RGBA_8888",
-        "MDP_BGRA_8888",
-        "MDP_RGBX_8888",
-        "MDP_Y_CRCB_H2V2_TILE",
-        "MDP_Y_CBCR_H2V2_TILE",
-        "MDP_Y_CR_CB_H2V2",
-        "MDP_Y_CR_CB_GH2V2",
-        "MDP_Y_CB_CR_H2V2",
-        "MDP_Y_CRCB_H1V1",
-        "MDP_Y_CBCR_H1V1",
-        "MDP_YCRCB_H1V1",
-        "MDP_YCBCR_H1V1",
-        "MDP_BGR_565",
-        "MDP_BGR_888",
-        "MDP_Y_CBCR_H2V2_VENUS",
-        "MDP_IMGTYPE_LIMIT",
-        "MDP_RGB_BORDERFILL",
-        "MDP_FB_FORMAT",
-        "MDP_IMGTYPE_LIMIT2"
-    };
-    if(format < 0 || format >= (int)(sizeof(formats) / sizeof(formats[0]))) {
+    #define STR(f) #f;
+    static const char* formats[MDP_IMGTYPE_LIMIT + 1] = {0};
+    formats[MDP_RGB_565] = STR(MDP_RGB_565);
+    formats[MDP_XRGB_8888] = STR(MDP_XRGB_8888);
+    formats[MDP_Y_CBCR_H2V2] = STR(MDP_Y_CBCR_H2V2);
+    formats[MDP_Y_CBCR_H2V2_ADRENO] = STR(MDP_Y_CBCR_H2V2_ADRENO);
+    formats[MDP_ARGB_8888] = STR(MDP_ARGB_8888);
+    formats[MDP_RGB_888] = STR(MDP_RGB_888);
+    formats[MDP_Y_CRCB_H2V2] = STR(MDP_Y_CRCB_H2V2);
+    formats[MDP_YCRYCB_H2V1] = STR(MDP_YCRYCB_H2V1);
+    formats[MDP_CBYCRY_H2V1] = STR(MDP_CBYCRY_H2V1);
+    formats[MDP_Y_CRCB_H2V1] = STR(MDP_Y_CRCB_H2V1);
+    formats[MDP_Y_CBCR_H2V1] = STR(MDP_Y_CBCR_H2V1);
+    formats[MDP_Y_CRCB_H1V2] = STR(MDP_Y_CRCB_H1V2);
+    formats[MDP_Y_CBCR_H1V2] = STR(MDP_Y_CBCR_H1V2);
+    formats[MDP_RGBA_8888] = STR(MDP_RGBA_8888);
+    formats[MDP_BGRA_8888] = STR(MDP_BGRA_8888);
+    formats[MDP_RGBX_8888] = STR(MDP_RGBX_8888);
+    formats[MDP_Y_CRCB_H2V2_TILE] = STR(MDP_Y_CRCB_H2V2_TILE);
+    formats[MDP_Y_CBCR_H2V2_TILE] = STR(MDP_Y_CBCR_H2V2_TILE);
+    formats[MDP_Y_CR_CB_H2V2] = STR(MDP_Y_CR_CB_H2V2);
+    formats[MDP_Y_CR_CB_GH2V2] = STR(MDP_Y_CR_CB_GH2V2);
+    formats[MDP_Y_CB_CR_H2V2] = STR(MDP_Y_CB_CR_H2V2);
+    formats[MDP_Y_CRCB_H1V1] = STR(MDP_Y_CRCB_H1V1);
+    formats[MDP_Y_CBCR_H1V1] = STR(MDP_Y_CBCR_H1V1);
+    formats[MDP_YCRCB_H1V1] = STR(MDP_YCRCB_H1V1);
+    formats[MDP_YCBCR_H1V1] = STR(MDP_YCBCR_H1V1);
+    formats[MDP_BGR_565] = STR(MDP_BGR_565);
+    formats[MDP_BGR_888] = STR(MDP_BGR_888);
+    formats[MDP_Y_CBCR_H2V2_VENUS] = STR(MDP_Y_CBCR_H2V2_VENUS);
+    formats[MDP_BGRX_8888] = STR(MDP_BGRX_8888);
+    formats[MDP_IMGTYPE_LIMIT] = STR(MDP_IMGTYPE_LIMIT);
+
+    if(format < 0 || format >= MDP_IMGTYPE_LIMIT) {
         ALOGE("%s wrong fmt %d", __FUNCTION__, format);
         return "Unsupported format";
     }
+    if(formats[format] == 0) {
+        ALOGE("%s: table missing format %d from header", __FUNCTION__, format);
+        return "";
+    }
     return formats[format];
 }
 
@@ -537,29 +541,6 @@
     ALOGE("== Dump Dim x=%d y=%d w=%d h=%d start/end ==", x, y, w, h);
 }
 
-inline int getMdpOrient(eTransform rotation) {
-    ALOGE_IF(DEBUG_OVERLAY, "%s: rot=%d", __FUNCTION__, rotation);
-    switch(rotation)
-    {
-        case OVERLAY_TRANSFORM_0 : return 0;
-        case OVERLAY_TRANSFORM_FLIP_V:  return MDP_FLIP_UD;
-        case OVERLAY_TRANSFORM_FLIP_H:  return MDP_FLIP_LR;
-        case OVERLAY_TRANSFORM_ROT_90:  return MDP_ROT_90;
-        //getMdpOrient will switch the flips if the source is 90 rotated.
-        //Clients in Android dont factor in 90 rotation while deciding flip.
-        case OVERLAY_TRANSFORM_ROT_90_FLIP_V:
-                return MDP_ROT_90 | MDP_FLIP_LR;
-        case OVERLAY_TRANSFORM_ROT_90_FLIP_H:
-                return MDP_ROT_90 | MDP_FLIP_UD;
-        case OVERLAY_TRANSFORM_ROT_180: return MDP_ROT_180;
-        case OVERLAY_TRANSFORM_ROT_270: return MDP_ROT_270;
-        default:
-            ALOGE("%s: invalid rotation value (value = 0x%x",
-                    __FUNCTION__, rotation);
-    }
-    return -1;
-}
-
 // FB0
 template <int CHAN>
 inline Dim getPositionS3DImpl(const Whf& whf)