diff --git a/displayengine/include/core/core_interface.h b/displayengine/include/core/core_interface.h
new file mode 100644
index 0000000..3328d64
--- /dev/null
+++ b/displayengine/include/core/core_interface.h
@@ -0,0 +1,183 @@
+/*
+* Copyright (c) 2014, The 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 The 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.
+*/
+
+/*! @file core_interface.h
+  @brief Interface file for core of the display subsystem.
+
+  @details Display core is primarily used for loading and unloading different display device
+  components viz primary, external and virtual. Display core is a statically linked library which
+  runs in caller's process context.
+*/
+#ifndef __CORE_INTERFACE_H__
+#define __CORE_INTERFACE_H__
+
+#include <stdint.h>
+
+#include "device_interface.h"
+#include "display_types.h"
+
+/*! @brief Display core interface version.
+
+  @details Display core interfaces are version tagged to maintain backward compatibility. This
+  version is supplied as a default argument during display core initialization.
+
+  Client may use an older version of interfaces and link to a higher version of display core
+  library, but vice versa is not allowed.
+
+  A 32-bit client must use 32-bit display core library and a 64-bit client must use 64-bit display
+  core library.
+
+  Display core interfaces follow default data structures alignment. Client must not override the
+  default padding rules while using these interfaces.
+
+  @warning It is assumed that client upgrades or downgrades display core interface all at once
+  and recompile all binaries which use these interfaces. Mix and match of these interfaces can
+  lead to unpredictable behaviour.
+
+  @sa CoreInterface::CreateCore
+*/
+#define CORE_REVISION_MAJOR (1)
+#define CORE_REVISION_MINOR (0)
+
+#define CORE_VERSION_TAG ((uint32_t) ((CORE_REVISION_MAJOR << 24) | (CORE_REVISION_MINOR << 16) \
+                    | (sizeof(DisplayCompatibility) << 8) | sizeof(int *)))
+
+namespace sde {
+
+/*! @brief Event data associated with hotplug event.
+
+  @sa CoreEventHandler::Hotplug
+*/
+struct CoreEventHotplug {
+  bool connected;   //!< True when device is connected.
+
+  CoreEventHotplug() : connected(false) { }
+};
+
+/*! @brief Display core event handler implemented by the client.
+
+  @details This class declares prototype for display core event handler methods which must be
+  implemented by the client. Display core will use these methods to notify events to the client.
+  Client must post heavy-weight event handling to a separate thread and unblock display core thread
+  instantly.
+
+  @sa CoreInterface::CreateCore
+*/
+class CoreEventHandler {
+ public:
+  /*! @brief Event handler for Hotplug event.
+
+    @details Event generated when a display device is connected or disconnected. Applicable to
+    detachable displays only.
+
+    @param[in] \link CoreEventHotplug \endlink
+
+    @return \link DisplayError \endlink
+  */
+  virtual DisplayError Hotplug(const CoreEventHotplug &hotplug) = 0;
+
+ protected:
+  virtual ~CoreEventHandler() { }
+};
+
+/*! @brief Display core interface.
+
+  @details This class defines display core interfaces. It contains methods which client shall use
+  to create/destroy different display devices. This interface is created during display core
+  CreateCore() and remains valid until DestroyCore().
+
+  @sa CoreInterface::CreateCore
+  @sa CoreInterface::DestroyCore
+*/
+class CoreInterface {
+ public:
+  /*! @brief Method to create and get handle to display core interface.
+
+    @details This method is the entry point into the display core. Client can create and operate on
+    different display devices only through a valid interface handle obtained using this method. An
+    object of display core is created and handle to this object is returned via output parameter.
+    This interface shall be called only once.
+
+    @param[in] event_handler \link CoreEventHandler \endlink
+    @param[out] interface \link CoreInterface \endlink
+    @param[in] version \link CORE_VERSION_TAG \endlink. Client must not override this argument.
+
+    @return \link DisplayError \endlink
+
+    @sa DestroyCore
+  */
+  static DisplayError CreateCore(CoreEventHandler *event_handler, CoreInterface **interface,
+                                 uint32_t version = CORE_VERSION_TAG);
+
+  /*! @brief Method to release handle to display core interface.
+
+    @details The object of corresponding display core is destroyed when this method is invoked.
+    Client must explicitly destroy all created display device objects associated with this handle
+    before invoking this method.
+
+    @param[in] interface \link CoreInterface \endlink
+
+    @return \link DisplayError \endlink
+
+    @sa CreateCore
+  */
+  static DisplayError DestroyCore();
+
+  /*! @brief Method to create a display device for a given type.
+
+    @details Client shall use this method to create each of the connected display type. A handle to
+    interface associated with this object is returned via output parameter which can be used to
+    interact further with the display device.
+
+    @param[in] type \link DeviceType \endlink
+    @param[in] event_handler \link DeviceEventHandler \endlink
+    @param[out] interface \link DisplayInterface \endlink
+
+    @return \link DisplayError \endlink
+
+    @sa DestroyDevice
+  */
+  virtual DisplayError CreateDevice(DeviceType type, DeviceEventHandler *event_handler,
+                                    DeviceInterface **interface) = 0;
+
+  /*! @brief Method to destroy a display device.
+
+    @details Client shall use this method to destroy each of the created display device objects.
+
+    @param[in] interface \link DisplayInterface \endlink
+
+    @return \link DisplayError \endlink
+
+    @sa CreateDevice
+  */
+  virtual DisplayError DestroyDevice(DeviceInterface *interface) = 0;
+
+ protected:
+  virtual ~CoreInterface() { }
+};
+
+}  // namespace sde
+
+#endif  // __CORE_INTERFACE_H__
+
diff --git a/displayengine/include/core/debug_interface.h b/displayengine/include/core/debug_interface.h
new file mode 100644
index 0000000..2c6349a
--- /dev/null
+++ b/displayengine/include/core/debug_interface.h
@@ -0,0 +1,65 @@
+/*
+* Copyright (c) 2014, The 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 The 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.
+*/
+
+/*! @file debug_interface.h
+  @brief Interface file for debugging options provided by display engine.
+
+*/
+#ifndef __DEBUG_INTERFACE_H__
+#define __DEBUG_INTERFACE_H__
+
+#include <stdint.h>
+
+#include "display_types.h"
+
+namespace sde {
+
+/*! @brief Display debug interface.
+
+  @details This class defines debugging methods provided by display engine.
+
+*/
+class DebugInterface {
+ public:
+  /*! @brief Method to get debugging information in form of a string.
+
+    @details Client shall use this method to get current snapshot of display engine context in form
+    of a formatted string for logging or dumping purposes.
+
+    @param[out] buffer String buffer allocated by the client. Filled with debugging information
+    upon return.
+    @param[in] length Length of the string buffer. Length shall be offset adjusted if any.
+
+    @return \link DisplayError \endlink
+  */
+  static DisplayError GetDump(uint8_t *buffer, uint32_t length);
+
+ protected:
+  virtual ~DebugInterface() { }
+};
+
+}  // namespace sde
+
+#endif  // __DEBUG_INTERFACE_H__
+
diff --git a/displayengine/include/core/device_interface.h b/displayengine/include/core/device_interface.h
new file mode 100644
index 0000000..60d7667
--- /dev/null
+++ b/displayengine/include/core/device_interface.h
@@ -0,0 +1,286 @@
+/*
+* Copyright (c) 2014, The 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 The 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.
+*/
+
+/*! @file device_interface.h
+  @brief Interface file for display device which represents a physical panel or an output buffer
+  where contents can be rendered.
+
+  @details Display device is used to send layer buffers for composition and get them rendered onto
+  the target device. Each display device represents a unique display target which may be either a
+  physical panel or an output buffer..
+*/
+#ifndef __DEVICE_INTERFACE_H__
+#define __DEVICE_INTERFACE_H__
+
+#include <stdint.h>
+
+#include "layer_stack.h"
+#include "display_types.h"
+
+namespace sde {
+
+/*! @brief This enum represents display device types where contents can be rendered.
+
+  @sa CoreInterface::CreateDevice
+  @sa CoreInterface::IsDeviceSupported
+*/
+enum DeviceType {
+  kPrimary,         //!< Main physical display which is attached to the handheld device.
+  kHDMI,            //!< HDMI physical display which is generally detachable.
+  kVirtual,         //!< Contents would be rendered into the output buffer provided by the client
+                    //!< e.g. wireless display.
+};
+
+/*! @brief This enum represents states of a display device.
+
+  @sa DisplayInterface::GetDeviceState
+  @sa DisplayInterface::SetDeviceState
+*/
+enum DeviceState {
+  kStateOff,        //!< Display is OFF. Contents are not rendered in this state. Client will not
+                    //!< receive VSync events in this state. This is default state as well.
+
+  kStateOn,         //!< Display is ON. Contents are rendered in this state.
+
+  kStateDoze,       //!< Display is ON but not updating contents. Client shall not push any contents
+                    //!< in this state.
+
+  kStateStandby,    //!< Display is OFF. Client will continue to receive VSync events in this state
+                    //!< if VSync is enabled. Contents are not rendered in this state.
+};
+
+/*! @brief This structure defines configuration for fixed properties of a display device.
+
+  @sa DisplayInterface::GetConfig
+  @sa DisplayInterface::SetConfig
+*/
+struct DeviceConfigFixedInfo {
+  bool underscan;   //!< If display support CE underscan.
+  bool secure;      //!< If this display is capable of handling secure content.
+
+  DeviceConfigFixedInfo() : underscan(false), secure(false) { }
+};
+
+/*! @brief This structure defines configuration for variable properties of a display device.
+
+  @sa DisplayInterface::GetConfig
+  @sa DisplayInterface::SetConfig
+*/
+struct DeviceConfigVariableInfo {
+  uint32_t x_pixels;          //!< Total number of pixels in X-direction on the display panel.
+  uint32_t y_pixels;          //!< Total number of pixels in Y-direction on the display panel.
+  float x_dpi;                //!< Dots per inch in X-direction.
+  float y_dpi;                //!< Dots per inch in Y-direction.
+  float fps;                  //!< Frame rate per second.
+  uint32_t vsync_period_ns;   //!< VSync period in nanoseconds.
+
+  DeviceConfigVariableInfo() : x_pixels(0), y_pixels(0), x_dpi(0.0f), y_dpi(0.0f),
+                               fps(0.0f), vsync_period_ns(0) { }
+};
+
+/*! @brief Event data associated with VSync event.
+
+  @sa DeviceEventHandler::VSync
+*/
+struct DeviceEventVSync {
+  int64_t timestamp;    //!< System monotonic clock timestamp in nanoseconds.
+
+  DeviceEventVSync() : timestamp(0) { }
+};
+
+/*! @brief Display device event handler implemented by the client.
+
+  @details This class declares prototype for display device event handler methods which must be
+  implemented by the client. Display device will use these methods to notify events to the client.
+  Client must post heavy-weight event handling to a separate thread and unblock display engine
+  thread instantly.
+
+  @sa CoreInterface::CreateDevice
+*/
+class DeviceEventHandler {
+ public:
+  /*! @brief Event handler for VSync event.
+
+    @details This event is dispatched on every vertical synchronization. The event is disabled by
+    default.
+
+    @param[in] vsync \link DeviceEventVSync \endlink
+
+    @return \link DisplayError \endlink
+
+    @sa DeviceInterface::GetDeviceState
+    @sa DeviceInterface::SetDeviceState
+  */
+  virtual DisplayError VSync(const DeviceEventVSync &vsync) = 0;
+
+  /*! @brief Event handler for Refresh event.
+
+    @details This event is dispatched to trigger a screen refresh. Client must call Prepare() and
+    Commit() in response to it from a separate thread. There is no data associated with this
+    event.
+
+    @return \link DisplayError \endlink
+
+    @sa DeviceInterface::Prepare
+    @sa DeviceInterface::Commit
+  */
+  virtual DisplayError Refresh() = 0;
+
+ protected:
+  virtual ~DeviceEventHandler() { }
+};
+
+/*! @brief Display device interface.
+
+  @details This class defines display device interface. It contains methods which client shall use
+  to configure or submit layers for composition on the display device. This interface is created
+  during display device creation and remains valid until destroyed.
+
+  @sa CoreInterface::CreateDevice
+  @sa CoreInterface::DestroyDevice
+*/
+class DeviceInterface {
+ public:
+  /*! @brief Method to determine hardware capability to compose layers associated with given frame.
+
+    @details Client shall send all layers associated with a frame targeted for current display
+    using this method and check the layers which can be handled completely in display engine.
+
+    Client shall mark composition type for one of the layer as kCompositionGPUTarget; the GPU
+    composed output would be rendered at the specified layer if some of the layers are not handled
+    by SDE.
+
+    Display engine will set each layer as kCompositionGPU or kCompositionSDE upon return. Client
+    shall render all the layers marked as kCompositionGPU using GPU.
+
+    This method can be called multiple times but only last call prevails. This method must be
+    followed by Commit().
+
+    @param[inout] layer_stack \link LayerStack \endlink
+
+    @return \link DisplayError \endlink
+
+    @sa Commit
+  */
+  virtual DisplayError Prepare(LayerStack *layer_stack) = 0;
+
+  /*! @brief Method to commit layers of a frame submitted in a former call to Prepare().
+
+    @details Client shall call this method to submit layers for final composition. The composed
+    output would be displayed on the panel or written in output buffer.
+
+    Client must ensure that layer stack is same as previous call to Prepare.
+
+    This method shall be called only once for each frame.
+
+    In the event of an error as well, this call will cause any fences returned in the previous call
+    to Commit() to eventually become signaled, so the client's wait on fences can be released to
+    prevent deadlocks.
+
+    @param[in] layer_stack \link LayerStack \endlink
+
+    @return \link DisplayError \endlink
+
+    @sa Prepare
+  */
+  virtual DisplayError Commit(LayerStack *layer_stack) = 0;
+
+  /*! @brief Method to get current state of the display device.
+
+    @param[out] state \link DisplayState \endlink
+
+    @return \link DisplayError \endlink
+
+    @sa SetDeviceState
+  */
+  virtual DisplayError GetDeviceState(DeviceState *state) = 0;
+
+  /*! @brief Method to get number of configurations(variable properties) supported on the display
+    device.
+
+    @param[out] count Number of modes supported; mode index starts with 0.
+
+    @return \link DisplayError \endlink
+  */
+  virtual DisplayError GetNumVariableInfoConfigs(uint32_t *count) = 0;
+
+  /*! @brief Method to get configuration for fixed properties of the display device.
+
+    @param[out] fixed_info \link DeviceConfigFixedInfo \endlink
+
+    @return \link DisplayError \endlink
+  */
+  virtual DisplayError GetConfig(DeviceConfigFixedInfo *fixed_info) = 0;
+
+  /*! @brief Method to get configuration for variable properties of the display device.
+
+    @param[in] mode index of the mode
+    @param[out] variable_info \link DeviceConfigVariableInfo \endlink
+
+    @return \link DisplayError \endlink
+  */
+  virtual DisplayError GetConfig(DeviceConfigVariableInfo *variable_info, uint32_t mode) = 0;
+
+  /*! @brief Method to get VSync event state. Default event state is disabled.
+
+    @param[out] enabled vsync state
+
+    @return \link DisplayError \endlink
+  */
+  virtual DisplayError GetVSyncState(bool *enabled) = 0;
+
+  /*! @brief Method to set current state of the display device.
+
+    @param[in] state \link DisplayState \endlink
+
+    @return \link DisplayError \endlink
+
+    @sa SetDeviceState
+  */
+  virtual DisplayError SetDeviceState(DeviceState state) = 0;
+
+  /*! @brief Method to set configuration for variable properties of the display device.
+
+    @param[in] mode index of the mode corresponding to variable properties.
+
+    @return \link DisplayError \endlink
+  */
+  virtual DisplayError SetConfig(uint32_t mode) = 0;
+
+  /*! @brief Method to set VSync event state. Default event state is disabled.
+
+    @param[out] enabled vsync state
+
+    @return \link DisplayError \endlink
+  */
+  virtual DisplayError SetVSyncState(bool enabled) = 0;
+
+ protected:
+  virtual ~DeviceInterface() { }
+};
+
+}  // namespace sde
+
+#endif  // __DEVICE_INTERFACE_H__
+
diff --git a/displayengine/include/core/display_types.h b/displayengine/include/core/display_types.h
new file mode 100644
index 0000000..128e7d9
--- /dev/null
+++ b/displayengine/include/core/display_types.h
@@ -0,0 +1,65 @@
+/*
+* Copyright (c) 2014, The 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 The 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.
+*/
+
+/*! @file display_types.h
+  @brief This file contains miscellaneous data types used across display interfaces.
+*/
+#ifndef __DISPLAY_TYPES_H__
+#define __DISPLAY_TYPES_H__
+
+namespace sde {
+
+/*! @brief This enum represents different error codes that display interfaces may return.
+*/
+enum DisplayError {
+  kErrorNone = 0,         //!< Call executed successfully.
+  kErrorUndefined,        //!< An unspecified error has occured.
+  kErrorNotSupported,     //!< Requested operation is not supported.
+  kErrorVersion,          //!< Client is using advanced version of interfaces and calling into an
+                          //!< older version of display library.
+  kErrorDataAlignment,    //!< Client data structures are not aligned on naturual boundaries.
+  kErrorInstructionSet,   //!< 32-bit client is calling into 64-bit library or vice versa.
+  kErrorParameters,       //!< Invalid parameters passed to a method.
+  kErrorFileDescriptor,   //!< Invalid file descriptor.
+  kErrorMemory,           //!< System is running low on memory.
+  kErrorResources,        //!< Not enough hardware resources available to execute call.
+  kErrorHardware,         //!< A hardware error has occured.
+  kErrorTimeOut,          //!< The operation has timed out to prevent client from waiting forever.
+};
+
+/*! @brief This structure is defined for client and library compatibility check purpose only. This
+  structure is used in CORE_VERSION_TAG definition only. Client should not refer it directly for
+  any purpose.
+*/
+struct DisplayCompatibility {
+  char c1;
+  int i1;
+  char c2;
+  int i2;
+};
+
+}  // namespace sde
+
+#endif  // __DISPLAY_TYPES_H__
+
diff --git a/displayengine/include/core/layer_buffer.h b/displayengine/include/core/layer_buffer.h
new file mode 100644
index 0000000..e6dcf1c
--- /dev/null
+++ b/displayengine/include/core/layer_buffer.h
@@ -0,0 +1,159 @@
+/*
+* Copyright (c) 2014, The 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 The 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.
+*/
+
+/*! @file layer_buffer.h
+  @brief File for layer buffer structure.
+
+*/
+#ifndef __LAYER_BUFFER_H__
+#define __LAYER_BUFFER_H__
+
+#include <stdint.h>
+
+#include "display_types.h"
+
+namespace sde {
+
+/*! @brief This enum represents different buffer formats supported by display engine.
+
+  @sa LayerBuffer
+*/
+enum LayerBufferFormat {
+  /* All RGB formats, Any new format will be added towards end of this group to maintain backward
+     compatibility.
+  */
+  kFormatARGB8888,      //!< 8-bits Alpha, Red, Green, Blue interleaved in ARGB order.
+  kFormatRGBA8888,      //!< 8-bits Red, Green, Blue, Alpha interleaved in RGBA order.
+  kFormatBGRA8888,      //!< 8-bits Blue, Green, Red, Alpha interleaved in BGRA order.
+  kFormatXRGB8888,      //!< 8-bits Padding, Red, Green, Blue interleaved in XRGB order. No Alpha.
+  kFormatRGBX8888,      //!< 8-bits Red, Green, Blue, Padding interleaved in RGBX order. No Alpha.
+  kFormatBGRX8888,      //!< 8-bits Blue, Green, Red, Padding interleaved in BGRX order. No Alpha.
+  kFormatRGB888,        //!< 8-bits Red, Green, Blue interleaved in RGB order. No Alpha.
+  kFormatRGB565,        //!< 5-bit Red, 6-bit Green, 5-bit Blue interleaved in RGB order. No Alpha.
+
+  /* All YUV-Planar formats, Any new format will be added towards end of this group to maintain
+     backward compatibility.
+  */
+  kFormatYCbCr420Planar = 0x100,  //!< Y-plane: y(0), y(1), y(2) ... y(n)
+                                  //!< 2x2 subsampled U-plane: u(0), u(2) ... u(n-1)
+                                  //!< 2x2 subsampled V-plane: v(0), v(2) ... v(n-1)
+
+  kFormatYCrCb420Planar,          //!< Y-plane: y(0), y(1), y(2) ... y(n)
+                                  //!< 2x2 subsampled V-plane: v(0), v(2) ... v(n-1)
+                                  //!< 2x2 subsampled U-plane: u(0), u(2) ... u(n-1)
+
+  /* All YUV-Semiplanar formats, Any new format will be added towards end of this group to
+     maintain backward compatibility.
+  */
+  kFormatYCbCr420SemiPlanar = 0x200,  //!< Y-plane: y(0), y(1), y(2) ... y(n)
+                                      //!< 2x2 subsampled interleaved UV-plane:
+                                      //!<    u(0), v(0), u(2), v(2) ... u(n-1), v(n-1)
+                                      //!< aka NV12.
+
+  kFormatYCrCb420SemiPlanar,          //!< Y-plane: y(0), y(1), y(2) ... y(n)
+                                      //!< 2x2 subsampled interleaved VU-plane:
+                                      //!<    v(0), u(0), v(2), u(2) ... v(n-1), u(n-1)
+                                      //!< aka NV21.
+
+  /* All YUV-Packed formats, Any new format will be added towards end of this group to maintain
+     backward compatibility.
+  */
+  kFormatYCbCr422Packed = 0x300,      //!< Y-plane interleaved with horizontally subsampled U/V by
+                                      //!< factor of 2
+                                      //!<    u(0), y(0), v(0), y(1), u(2), y(2), v(2), y(3)
+                                      //!<    u(n-1), y(n-1), v(n-1), y(n)
+};
+
+/*! @brief This structure defines a color sample plane belonging to a buffer format. RGB buffer
+  formats have 1 plane whereas YUV buffer formats may have upto 4 planes.
+
+  @sa LayerBuffer
+*/
+struct LayerBufferPlane {
+  int fd;           //!< File descriptor referring to the buffer associated with this plane.
+  uint32_t offset;  //!< Offset of the plane in bytes from beginning of the buffer.
+  uint32_t stride;  //!< Stride in bytes i.e. length of a scanline including padding.
+
+  LayerBufferPlane() : fd(-1), offset(0), stride(0) { }
+};
+
+/*! @brief This structure defines flags associated with a layer buffer. The 1-bit flag can be set
+  to ON(1) or OFF(0).
+
+  @sa LayerBuffer
+*/
+struct LayerBufferFlags {
+  uint64_t secure : 1;  //!< This flag shall be set by client to indicate that the buffer need
+                        //!< to be handled securely.
+
+  LayerBufferFlags() : secure(0) { }
+};
+
+/*! @brief This structure defines a layer buffer handle which contains raw buffer and its associated
+  properties.
+
+  @sa LayerBuffer
+  @sa LayerStack
+*/
+struct LayerBuffer {
+  uint32_t width;               //!< Actual width of the Layer that this buffer is for.
+  uint32_t height;              //!< Actual height of the Layer that this buffer is for.
+  LayerBufferFormat format;     //!< Format of the buffer content.
+  LayerBufferPlane planes[4];   //!< Array of planes that this buffer contains. RGB buffer formats
+                                //!< have 1 plane whereas YUV buffer formats may have upto 4 planes.
+                                //!< Total number of planes for the buffer will be interpreted based
+                                //!< on the buffer format specified.
+
+  int acquire_fence_fd;         //!< File descriptor referring to a sync fence object which will be
+                                //!< signaled when buffer can be read/write by display engine.
+                                //!< This fence object is set by the client during Commit(). For
+                                //!< input buffers client shall signal this fence when buffer
+                                //!< content is available and can be read by display engine. For
+                                //!< output buffers, client shall signal fence when buffer is ready
+                                //!< to be written by display engine.
+
+                                //!< This field is used only during Commit() and shall be set to -1
+                                //!< by the client when buffer is already available for read/write.
+
+  int release_fence_fd;         //!< File descriptor referring to a sync fence object which will be
+                                //!< signaled when buffer has been read/written by display engine.
+                                //!< This fence object is set by display engine during Commit().
+                                //!< For input buffers display engine will signal this fence when
+                                //!< buffer has been consumed. For output buffers, display engine
+                                //!< will signal this fence when buffer is produced.
+
+                                //!< This field is used only during Commit() and will be set to -1
+                                //!< by display engine when buffer is already available for
+                                //!< read/write.
+
+  LayerBufferFlags flags;       //!< Flags associated with this buffer.
+
+  LayerBuffer() : width(0), height(0), format(kFormatRGBA8888), acquire_fence_fd(-1),
+                  release_fence_fd(-1) { }
+};
+
+}  // namespace sde
+
+#endif  // __LAYER_BUFFER_H__
+
diff --git a/displayengine/include/core/layer_stack.h b/displayengine/include/core/layer_stack.h
new file mode 100644
index 0000000..20d6728
--- /dev/null
+++ b/displayengine/include/core/layer_stack.h
@@ -0,0 +1,227 @@
+/*
+* Copyright (c) 2014, The 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 The 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.
+*/
+
+/*! @file layer_stack.h
+  @brief File for display layer stack structure which represents a drawing buffer.
+
+  @details Display layer is a drawing buffer object which will be blended with other drawing buffers
+  under blending rules.
+*/
+#ifndef __LAYER_STACK_H__
+#define __LAYER_STACK_H__
+
+#include <stdint.h>
+
+#include "layer_buffer.h"
+#include "display_types.h"
+
+namespace sde {
+
+/*! @brief This enum represents display layer blending types.
+
+  @sa Layer
+*/
+enum LayerBlending {
+  kBlendingNone = 0,        //!< Blend operation is not specified.
+
+  kBlendingOpaque,          //!< Pixel color is expressed using straight alpha in color tuples. It
+                            //!< is constant blend operation. The layer would appear opaque if plane
+                            //!< alpha is 0xFF.
+
+  kBlendingPremultiplied,   //!< Pixel color is expressed using premultiplied alpha in RGBA tuples.
+                            //!< If plane alpha is less than 0xFF, apply modulation as well.
+                            //!<   pixel.rgb = src.rgb + dest.rgb x (1 - src.a)
+
+  kBlendingCoverage,        //!< Pixel color is expressed using straight alpha in color tuples. If
+                            //!< plane alpha is less than 0xff, apply modulation as well.
+                            //!<   pixel.rgb = src.rgb x src.a + dest.rgb x (1 - src.a)
+};
+
+/*! @brief This enum represents display layer composition types.
+
+  @sa Layer
+*/
+enum LayerComposition {
+  kCompositionGPU,        //!< This layer will be drawn into the target buffer by GPU. Display
+                          //!< device will mark the layer for SDE composition if it can handle it
+                          //!< or it will mark the layer for GPU composition.
+
+  kCompositionSDE,        //!< This layer will be handled by SDE. It must not be composed by GPU.
+
+  kCompositionGPUTarget,  //!< This layer will hold result of composition for layers marked for GPU
+                          //!< composition. If display device sets all other layers for SDE
+                          //!< composition then this layer would be ignored during Commit().
+                          //!< Only one layer shall be marked as target buffer by the caller.
+};
+
+/*! @brief This structure defines rotation and flip values for a display layer.
+
+  @sa Layer
+*/
+struct LayerTransform {
+  float rotation;         //!< Left most pixel coordinate.
+  bool flip_horizontal;   //!< Mirror reversal of the layer across a horizontal axis.
+  bool flip_vertical;     //!< Mirror reversal of the layer across a vertical axis.
+
+  LayerTransform() : rotation(0.0f), flip_horizontal(false), flip_vertical(false) { }
+};
+
+/*! @brief This structure defines flags associated with a layer. The 1-bit flag can be set to ON(1)
+  or OFF(0).
+
+  @sa LayerBuffer
+*/
+struct LayerFlags {
+  uint64_t skip : 1;  //!< This flag shall be set by client to indicate that this layer will be
+                      //!< handled by GPU. Device Device will not consider it for composition.
+
+  LayerFlags() : skip(0) { }
+};
+
+/*! @brief This structure defines flags associated with a layer stack. The 1-bit flag can be set to
+  ON(1) or OFF(0).
+
+  @sa LayerBuffer
+*/
+struct LayerStackFlags {
+  uint64_t geometry_changed : 1;  //!< This flag shall be set by client to indicate that the layer
+                                  //!< set passed to Prepare() has changed by more than just the
+                                  //!< buffer handles and acquire fences.
+
+  LayerStackFlags() : geometry_changed(0) { }
+};
+
+/*! @brief This structure defines a rectanglular area inside a display layer.
+
+  @sa LayerRectArray
+*/
+struct LayerRect {
+  float left;     //!< Left-most pixel coordinate.
+  float top;      //!< Top-most pixel coordinate.
+  float right;    //!< Right-most pixel coordinate.
+  float bottom;   //!< Bottom-most pixel coordinate.
+
+  LayerRect() : left(0.0f), top(0.0f), right(0.0f), bottom(0.0f) { }
+};
+
+/*! @brief This structure defines an array of display layer rectangles.
+
+  @sa LayerRect
+*/
+struct LayerRectArray {
+  LayerRect *rect;  //!< Pointer to first element of array.
+  size_t count;     //!< Number of elements in the array.
+
+  LayerRectArray() : rect(NULL), count(0) { }
+};
+
+/*! @brief This structure defines display layer object which contains layer properties and a drawing
+  buffer.
+
+  @sa LayerArray
+*/
+struct Layer {
+  LayerBuffer *input_buffer;        //!< Pointer to the buffer to be composed. If this remains
+                                    //!< unchanged between two consecutive Prepare() calls and
+                                    //!< geometry_changed flag is not set for the second call, then
+                                    //!< the display device will assume that buffer content has not
+                                    //!< changed.
+
+  LayerComposition composition;     //!< Composition type which can be set by either the client or
+                                    //!< the display device. This value should be preserved between
+                                    //!< Prepare() and Commit() calls.
+
+  LayerRect src_rect;               //!< Rectangular area of the layer buffer to consider for
+                                    //!< composition.
+
+  LayerRect dst_rect;               //!< The target position where the frame will be displayed.
+                                    //!< Cropping rectangle is scaled to fit into this rectangle.
+                                    //!< The origin is top-left corner of the screen.
+
+  LayerRectArray visible_regions;   //!< Visible rectangular areas in screen space. The visible
+                                    //!< region includes areas overlapped by a translucent layer.
+
+  LayerRectArray dirty_regions;     //!< Rectangular areas in the current frames that have changed
+                                    //!< in comparison to previous frame.
+
+  LayerBlending blending;           //!< Blending operation which need to be applied on the layer
+                                    //!< buffer during composition.
+
+  LayerTransform transform;         //!< Rotation/Flip operations which need to be applied to the
+                                    //!< layer buffer during composition.
+
+  uint8_t plane_alpha;              //!< Alpha value applied to the whole layer. Value of each pixel
+                                    //!< computed as:
+                                    //!<    if(kBlendingPremultiplied) {
+                                    //!<      pixel.RGB = pixel.RGB * planeAlpha / 255
+                                    //!<    }
+                                    //!<    pixel.a = pixel.a * planeAlpha
+
+  LayerFlags flags;                 //!< Flags associated with this layer.
+
+  Layer() : input_buffer(NULL), composition(kCompositionGPU), blending(kBlendingNone),
+            plane_alpha(0) { }
+};
+
+/*! @brief This structure defines an array of display layers.
+
+  @sa LayerStack
+*/
+struct LayerArray {
+  Layer *layer;   //!< Pointer to first element of array.
+  size_t count;   //!< Number of elements in the array.
+
+  LayerArray() : layer(NULL), count(0) { }
+};
+
+/*! @brief This structure defines a layer stack that contains layers which need to be composed and
+  rendered onto the target.
+
+  @sa DisplayInterface::Prepare
+  @sa DisplayInterface::Commit
+*/
+struct LayerStack {
+  union {
+    int retire_fence_fd;          //!< File descriptor referring to a sync fence object which will
+                                  //!< be signaled when this composited frame has been replaced on
+                                  //!< screen by a subsequent frame on a physical display. The fence
+                                  //!< object is created and returned during Commit(). Client shall
+                                  //!< Client shall close the returned file descriptor.
+                                  //!< NOTE: This field applies to a physical display only.
+
+    LayerBuffer *output_buffer;   //!< Pointer to the buffer where composed buffer would be rendered
+                                  //!< for virtual displays.
+                                  //!< NOTE: This field applies to a virtual display only.
+  };
+
+  LayerArray layers;      //!< Array of layers.
+  LayerStackFlags flags;  //!< Flags associated with this layer set.
+
+  LayerStack() : output_buffer(NULL) { }
+};
+
+}  // namespace sde
+
+#endif  // __LAYER_STACK_H__
+
diff --git a/displayengine/include/private/strategy_interface.h b/displayengine/include/private/strategy_interface.h
new file mode 100644
index 0000000..755af1d
--- /dev/null
+++ b/displayengine/include/private/strategy_interface.h
@@ -0,0 +1,130 @@
+/*
+* Copyright (c) 2014, The 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 The 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.
+*/
+
+/*! @file strategy_interface.h
+    @brief Interface file for strategy manager which will be used by display core to select a
+    composition strategy for a frame to be displayed on target.
+*/
+#ifndef __STRATEGY_INTERFACE_H__
+#define __STRATEGY_INTERFACE_H__
+
+#include <core/display_types.h>
+
+namespace sde {
+
+/*! @brief Strategy library name
+
+    @details This macro defines name for the composition strategy library. This macro shall be used
+    to load library using dlopen().
+
+    @sa GetStrategyInterface
+*/
+#define STRATEGY_LIBRARY_NAME "libsdestrategy.so"
+
+/*! @brief Function name to get composer strategy interface
+
+    @details This macro defines function name for GetStrategyInterface() which will be implemented
+    in the composition strategy library. This macro shall be used to specify name of the function
+    in dlsym().
+
+    @sa GetStrategyInterface
+*/
+#define GET_STRATEGY_INTERFACE_NAME "GetStrategyInterface"
+
+class StrategyInterface;
+
+/*! @brief Function to get composer strategy interface.
+
+    @details This function is used to get StrategyInterface object which resides in the composer
+    strategy library loaded at runtime.
+
+    @param[out] interface \link StrategyInterface \endlink
+
+    @return \link DisplayError \endlink
+*/
+typedef DisplayError (*GetStrategyInterface)(StrategyInterface **interface);
+
+/*! @brief Maximum number of layers that can be handled by hardware in a given layer stack.
+*/
+const int kNumLayersMax = 16;
+
+/*! @brief This structure defines constraints and device properties that shall be considered for
+    deciding a composition strategy.
+
+    @sa GetNextStrategy
+*/
+struct StrategyConstraints {
+  bool gpu_only;          //!< Select GPU only composition for this layer stack.
+  uint32_t max_layers;    //!< Maximum number of layers that shall be programmed on hardware for the
+                          //!< given layer stack.
+
+  StrategyConstraints() : gpu_only(false), max_layers(kNumLayersMax) { }
+};
+
+/*! @brief Flag to denote that GPU composition is performed for the given layer stack.
+*/
+const uint32_t kFlagGPU = 0x1;
+
+/*! @brief This structure encapsulates information about the input layer stack and the layers which
+    shall be programmed on hardware.
+
+    @sa GetNextStrategy
+*/
+struct HWLayersInfo {
+  LayerStack *stack;        //!< Input layer stack. Set by the caller.
+
+  uint32_t index[kNumLayersMax];
+                            //!< Indexes of the layers from the layer stack which need to be
+                            //!< programmed on hardware.
+  uint32_t count;           //!< Total number of layers which need to be set on hardware.
+  uint32_t flags;           //!< Strategy flags. There is one flag set for each of the strategy
+                            //!< that has been selected for this layer stack. This flag is preserved
+                            //!< between multiple GetNextStrategy() calls. Composition manager
+                            //!< relies on the total flag count to check the number of strategies
+                            //!< that are attempted for this layer stack.
+
+  HWLayersInfo() : stack(NULL), count(0), flags(0) { }
+};
+
+class StrategyInterface {
+ public:
+  /*! @brief Method to get strategy for a layer stack. Caller can loop through this method to try
+    get all applicable strategies.
+
+    @param[in] constraints \link StrategyConstraints \endlink
+    @param[inout] layers_info \link HWLayersInfo \endlink
+
+    @return \link DisplayError \endlink
+  */
+  virtual DisplayError GetNextStrategy(StrategyConstraints *constraints,
+                                       HWLayersInfo *hw_layers_info) = 0;
+
+ protected:
+  virtual ~StrategyInterface() { }
+};
+
+}  // namespace sde
+
+#endif  // __STRATEGY_INTERFACE_H__
+
diff --git a/displayengine/include/utils/constants.h b/displayengine/include/utils/constants.h
new file mode 100644
index 0000000..658c852
--- /dev/null
+++ b/displayengine/include/utils/constants.h
@@ -0,0 +1,53 @@
+/*
+* Copyright (c) 2014, The 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 The 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 __CONSTANTS_H__
+#define __CONSTANTS_H__
+
+#define LIKELY(exp) __builtin_expect((exp) != 0, true)
+#define UNLIKELY(exp) __builtin_expect((exp) != 0, false)
+
+#define INT(exp) static_cast<int>(exp)
+#define FLOAT(exp) static_cast<float>(exp)
+#define UINT32(exp) static_cast<uint32_t>(exp)
+#define INT32(exp) static_cast<int32_t>(exp)
+
+#define STRUCT_VAR(struct_name, var_name) \
+          struct struct_name var_name; \
+          memset(&var_name, 0, sizeof(var_name));
+
+#define STRUCT_VAR_ARRAY(struct_name, var_name, num_var) \
+          struct struct_name var_name[num_var]; \
+          memset(&var_name[0], 0, sizeof(var_name));
+
+#define ROUND_UP(number, step) ((((number) + ((step) - 1)) / (step)) * (step))
+
+namespace sde {
+
+  typedef void * Handle;
+
+}  // namespace sde
+
+#endif  // __CONSTANTS_H__
+
diff --git a/displayengine/include/utils/debug.h b/displayengine/include/utils/debug.h
new file mode 100644
index 0000000..6b1d418
--- /dev/null
+++ b/displayengine/include/utils/debug.h
@@ -0,0 +1,56 @@
+/*
+* Copyright (c) 2014, The 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 The 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 __DEBUG_H__
+#define __DEBUG_H__
+
+namespace sde {
+
+enum LogTag {
+  kTagNone = 0,   //!< Log tag name is not specified.
+  kTagCore,       //!< Log is tagged for display core.
+  kTagStrategy,   //!< Log is tagged for composition strategy.
+};
+
+class Debug {
+ public:
+  // Log handlers
+  static void Error(const LogTag &tag, const char *format, ...);
+  static void Warning(const LogTag &tag, const char *format, ...);
+  static void Info(const LogTag &tag, const char *format, ...);
+  static void Verbose(const LogTag &tag, const char *format, ...);
+
+  // Debug properties
+  static bool IsVirtualDriver() { return debug_.virtual_driver_; }
+
+ private:
+  Debug();
+  bool virtual_driver_;
+  static Debug debug_;
+};
+
+}  // namespace sde
+
+#endif  // __DEBUG_H__
+
diff --git a/displayengine/include/utils/locker.h b/displayengine/include/utils/locker.h
new file mode 100644
index 0000000..2c1ef9a
--- /dev/null
+++ b/displayengine/include/utils/locker.h
@@ -0,0 +1,85 @@
+/*
+* Copyright (c) 2014, The 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 The 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 __LOCKER_H__
+#define __LOCKER_H__
+
+#include <stdint.h>
+#include <pthread.h>
+
+#define SCOPE_LOCK(locker) Locker::ScopeLock scopeLock(locker)
+
+namespace sde {
+
+class Locker {
+ public:
+  class ScopeLock {
+   public:
+    explicit ScopeLock(Locker& locker) : locker_(locker) {
+      locker_.Lock();
+    }
+
+    ~ScopeLock() {
+      locker_.Unlock();
+    }
+
+   private:
+    Locker &locker_;
+  };
+
+  Locker() {
+    pthread_mutex_init(&mutex_, 0);
+    pthread_cond_init(&condition_, 0);
+  }
+
+  ~Locker() {
+    pthread_mutex_destroy(&mutex_);
+    pthread_cond_destroy(&condition_);
+  }
+
+  void Lock() { pthread_mutex_lock(&mutex_); }
+  void Unlock() { pthread_mutex_unlock(&mutex_); }
+  void Signal() { pthread_cond_signal(&condition_); }
+  void Broadcast() { pthread_cond_broadcast(&condition_); }
+  void Wait() { pthread_cond_wait(&condition_, &mutex_); }
+  int WaitFinite(long int ms) {
+    struct timespec ts;
+    struct timeval tv;
+    gettimeofday(&tv, NULL);
+    ts.tv_sec = tv.tv_sec + ms/1000;
+    ts.tv_nsec = tv.tv_usec*1000 + (ms%1000)*1000000;
+    ts.tv_sec += ts.tv_nsec/1000000000L;
+    ts.tv_nsec += ts.tv_nsec%1000000000L;
+    return pthread_cond_timedwait(&condition_, &mutex_, &ts);
+  }
+
+ private:
+  pthread_mutex_t mutex_;
+  pthread_cond_t condition_;
+};
+
+}  // namespace sde
+
+#endif  // __LOCKER_H__
+
diff --git a/displayengine/include/utils/logger.h b/displayengine/include/utils/logger.h
new file mode 100644
index 0000000..03c398a
--- /dev/null
+++ b/displayengine/include/utils/logger.h
@@ -0,0 +1,53 @@
+/*
+* Copyright (c) 2014, The 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 The 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 __LOGGER_H__
+#define __LOGGER_H__
+
+#include "debug.h"
+
+namespace sde {
+
+#ifndef DISPLAY_LOG_TAG
+#define DISPLAY_LOG_TAG kLogTagNone
+#endif
+
+#ifndef DISPLAY_MODULE_NAME
+#define DISPLAY_MODULE_NAME "SDE"
+#endif
+
+#define DLOG(method, format, ...) Debug::method(DISPLAY_LOG_TAG, \
+                                                DISPLAY_MODULE_NAME ": " format, ##__VA_ARGS__)
+
+// DISPLAY_LOG_TAG and DISPLAY_MODULE_NAME must be defined before #include this header file in
+// respective module, else default definitions are used.
+#define DLOGE(format, ...) DLOG(Error, format, ##__VA_ARGS__)
+#define DLOGW(format, ...) DLOG(Warning, format, ##__VA_ARGS__)
+#define DLOGI(format, ...) DLOG(Info, format, ##__VA_ARGS__)
+#define DLOGV(format, ...) DLOG(Verbose, format, ##__VA_ARGS__)
+
+}  // namespace sde
+
+#endif  // __LOGGER_H__
+