sde: Replace device with display wherever its applicable.
1. Replace device interfaces between display engine and hwcomposer
with display interfaces.
2. Replace all device interfaces internal to display engine with
display interfaces.
3. Rename device_base header and source files to display_base header
and source files.
4. Rename hwc_sink header and source files to hwc_display header and
source files.
Change-Id: Iedde81fb19583bcaf71cc631d935c7268511027f
diff --git a/displayengine/include/core/core_interface.h b/displayengine/include/core/core_interface.h
index 3328d64..45d9c8c 100644
--- a/displayengine/include/core/core_interface.h
+++ b/displayengine/include/core/core_interface.h
@@ -34,7 +34,7 @@
#include <stdint.h>
-#include "device_interface.h"
+#include "display_interface.h"
#include "display_types.h"
/*! @brief Display core interface version.
@@ -150,16 +150,16 @@
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[in] type \link DisplayType \endlink
+ @param[in] event_handler \link DisplayEventHandler \endlink
@param[out] interface \link DisplayInterface \endlink
@return \link DisplayError \endlink
- @sa DestroyDevice
+ @sa DestroyDisplay
*/
- virtual DisplayError CreateDevice(DeviceType type, DeviceEventHandler *event_handler,
- DeviceInterface **interface) = 0;
+ virtual DisplayError CreateDisplay(DisplayType type, DisplayEventHandler *event_handler,
+ DisplayInterface **interface) = 0;
/*! @brief Method to destroy a display device.
@@ -169,9 +169,9 @@
@return \link DisplayError \endlink
- @sa CreateDevice
+ @sa CreateDisplay
*/
- virtual DisplayError DestroyDevice(DeviceInterface *interface) = 0;
+ virtual DisplayError DestroyDisplay(DisplayInterface *interface) = 0;
protected:
virtual ~CoreInterface() { }
diff --git a/displayengine/include/core/device_interface.h b/displayengine/include/core/display_interface.h
similarity index 84%
rename from displayengine/include/core/device_interface.h
rename to displayengine/include/core/display_interface.h
index 01c5446..bb03921 100644
--- a/displayengine/include/core/device_interface.h
+++ b/displayengine/include/core/display_interface.h
@@ -22,7 +22,7 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-/*! @file device_interface.h
+/*! @file display_interface.h
@brief Interface file for display device which represents a physical panel or an output buffer
where contents can be rendered.
@@ -30,8 +30,8 @@
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__
+#ifndef __DISPLAY_INTERFACE_H__
+#define __DISPLAY_INTERFACE_H__
#include <stdint.h>
@@ -42,10 +42,10 @@
/*! @brief This enum represents display device types where contents can be rendered.
- @sa CoreInterface::CreateDevice
- @sa CoreInterface::IsDeviceSupported
+ @sa CoreInterface::CreateDisplay
+ @sa CoreInterface::IsDisplaySupported
*/
-enum DeviceType {
+enum DisplayType {
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
@@ -54,10 +54,10 @@
/*! @brief This enum represents states of a display device.
- @sa DisplayInterface::GetDeviceState
- @sa DisplayInterface::SetDeviceState
+ @sa DisplayInterface::GetDisplayState
+ @sa DisplayInterface::SetDisplayState
*/
-enum DeviceState {
+enum DisplayState {
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.
@@ -75,11 +75,11 @@
@sa DisplayInterface::GetConfig
@sa DisplayInterface::SetConfig
*/
-struct DeviceConfigFixedInfo {
+struct DisplayConfigFixedInfo {
bool underscan; //!< If display support CE underscan.
bool secure; //!< If this display is capable of handling secure content.
- DeviceConfigFixedInfo() : underscan(false), secure(false) { }
+ DisplayConfigFixedInfo() : underscan(false), secure(false) { }
};
/*! @brief This structure defines configuration for variable properties of a display device.
@@ -87,7 +87,7 @@
@sa DisplayInterface::GetConfig
@sa DisplayInterface::SetConfig
*/
-struct DeviceConfigVariableInfo {
+struct DisplayConfigVariableInfo {
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.
@@ -95,18 +95,18 @@
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),
+ DisplayConfigVariableInfo() : 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
+ @sa DisplayEventHandler::VSync
*/
-struct DeviceEventVSync {
+struct DisplayEventVSync {
int64_t timestamp; //!< System monotonic clock timestamp in nanoseconds.
- DeviceEventVSync() : timestamp(0) { }
+ DisplayEventVSync() : timestamp(0) { }
};
/*! @brief Display device event handler implemented by the client.
@@ -116,23 +116,23 @@
Client must post heavy-weight event handling to a separate thread and unblock display engine
thread instantly.
- @sa CoreInterface::CreateDevice
+ @sa CoreInterface::CreateDisplay
*/
-class DeviceEventHandler {
+class DisplayEventHandler {
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
+ @param[in] vsync \link DisplayEventVSync \endlink
@return \link DisplayError \endlink
- @sa DeviceInterface::GetDeviceState
- @sa DeviceInterface::SetDeviceState
+ @sa DisplayInterface::GetDisplayState
+ @sa DisplayInterface::SetDisplayState
*/
- virtual DisplayError VSync(const DeviceEventVSync &vsync) = 0;
+ virtual DisplayError VSync(const DisplayEventVSync &vsync) = 0;
/*! @brief Event handler for Refresh event.
@@ -142,13 +142,13 @@
@return \link DisplayError \endlink
- @sa DeviceInterface::Prepare
- @sa DeviceInterface::Commit
+ @sa DisplayInterface::Prepare
+ @sa DisplayInterface::Commit
*/
virtual DisplayError Refresh() = 0;
protected:
- virtual ~DeviceEventHandler() { }
+ virtual ~DisplayEventHandler() { }
};
/*! @brief Display device interface.
@@ -157,10 +157,10 @@
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
+ @sa CoreInterface::CreateDisplay
+ @sa CoreInterface::DestroyDisplay
*/
-class DeviceInterface {
+class DisplayInterface {
public:
/*! @brief Method to determine hardware capability to compose layers associated with given frame.
@@ -212,9 +212,9 @@
@return \link DisplayError \endlink
- @sa SetDeviceState
+ @sa SetDisplayState
*/
- virtual DisplayError GetDeviceState(DeviceState *state) = 0;
+ virtual DisplayError GetDisplayState(DisplayState *state) = 0;
/*! @brief Method to get number of configurations(variable properties) supported on the display
device.
@@ -227,20 +227,20 @@
/*! @brief Method to get configuration for fixed properties of the display device.
- @param[out] fixed_info \link DeviceConfigFixedInfo \endlink
+ @param[out] fixed_info \link DisplayConfigFixedInfo \endlink
@return \link DisplayError \endlink
*/
- virtual DisplayError GetConfig(DeviceConfigFixedInfo *fixed_info) = 0;
+ virtual DisplayError GetConfig(DisplayConfigFixedInfo *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
+ @param[out] variable_info \link DisplayConfigVariableInfo \endlink
@return \link DisplayError \endlink
*/
- virtual DisplayError GetConfig(DeviceConfigVariableInfo *variable_info, uint32_t mode) = 0;
+ virtual DisplayError GetConfig(DisplayConfigVariableInfo *variable_info, uint32_t mode) = 0;
/*! @brief Method to get VSync event state. Default event state is disabled.
@@ -256,9 +256,9 @@
@return \link DisplayError \endlink
- @sa SetDeviceState
+ @sa SetDisplayState
*/
- virtual DisplayError SetDeviceState(DeviceState state) = 0;
+ virtual DisplayError SetDisplayState(DisplayState state) = 0;
/*! @brief Method to set configuration for variable properties of the display device.
@@ -277,10 +277,10 @@
virtual DisplayError SetVSyncState(bool enable) = 0;
protected:
- virtual ~DeviceInterface() { }
+ virtual ~DisplayInterface() { }
};
} // namespace sde
-#endif // __DEVICE_INTERFACE_H__
+#endif // __DISPLAY_INTERFACE_H__
diff --git a/displayengine/include/core/dump_interface.h b/displayengine/include/core/dump_interface.h
index 3a7d93d..acdc71f 100644
--- a/displayengine/include/core/dump_interface.h
+++ b/displayengine/include/core/dump_interface.h
@@ -53,7 +53,7 @@
@return \link DisplayError \endlink
- @warning Client shall ensure that this interface is not used while a device is being either
+ @warning Client shall ensure that this interface is not used while a display is being either
created or destroyed through display core.
*/
static DisplayError GetDump(char *buffer, uint32_t length);
diff --git a/displayengine/include/private/strategy_interface.h b/displayengine/include/private/strategy_interface.h
index 23dea8e..8a3b789 100644
--- a/displayengine/include/private/strategy_interface.h
+++ b/displayengine/include/private/strategy_interface.h
@@ -69,7 +69,7 @@
*/
const int kMaxSDELayers = 16;
-/*! @brief This structure defines constraints and device properties that shall be considered for
+/*! @brief This structure defines constraints and display properties that shall be considered for
deciding a composition strategy.
@sa GetNextStrategy
diff --git a/displayengine/libs/core/Android.mk b/displayengine/libs/core/Android.mk
index 496c899..337cb73 100644
--- a/displayengine/libs/core/Android.mk
+++ b/displayengine/libs/core/Android.mk
@@ -2,7 +2,7 @@
include hardware/qcom/display/displayengine/libs/common.mk
include $(CLEAR_VARS)
-LOCAL_MODULE := libsdecore
+LOCAL_MODULE := libsde
LOCAL_MODULE_TAGS := optional
LOCAL_C_INCLUDES := $(common_includes) $(kernel_includes)
LOCAL_CFLAGS := $(common_flags) -DLOG_TAG=\"SDE\"
@@ -10,10 +10,10 @@
LOCAL_ADDITIONAL_DEPENDENCIES := $(common_deps)
LOCAL_SRC_FILES := core_interface.cpp \
core_impl.cpp \
- device_base.cpp \
- device_primary.cpp \
- device_hdmi.cpp \
- device_virtual.cpp \
+ display_base.cpp \
+ display_primary.cpp \
+ display_hdmi.cpp \
+ display_virtual.cpp \
comp_manager.cpp \
strategy_default.cpp \
res_manager.cpp \
diff --git a/displayengine/libs/core/comp_manager.cpp b/displayengine/libs/core/comp_manager.cpp
index 42a28c2..0d51bb0 100644
--- a/displayengine/libs/core/comp_manager.cpp
+++ b/displayengine/libs/core/comp_manager.cpp
@@ -87,48 +87,50 @@
return kErrorNone;
}
-DisplayError CompManager::RegisterDevice(DeviceType type, const HWDeviceAttributes &attributes,
- Handle *device) {
+DisplayError CompManager::RegisterDisplay(DisplayType type, const HWDisplayAttributes &attributes,
+ Handle *display_ctx) {
SCOPE_LOCK(locker_);
DisplayError error = kErrorNone;
- CompManagerDevice *comp_mgr_device = new CompManagerDevice();
- if (!comp_mgr_device) {
+ DisplayCompositionContext *display_comp_ctx = new DisplayCompositionContext();
+ if (!display_comp_ctx) {
return kErrorMemory;
}
- error = res_mgr_.RegisterDevice(type, attributes, &comp_mgr_device->res_mgr_device);
+ error = res_mgr_.RegisterDisplay(type, attributes, &display_comp_ctx->display_resource_ctx);
if (error != kErrorNone) {
- delete comp_mgr_device;
+ delete display_comp_ctx;
return error;
}
SET_BIT(registered_displays_, type);
- comp_mgr_device->device_type = type;
- *device = comp_mgr_device;
- // New device has been added, so move the composition mode to safe mode until unless resources
- // for the added display is configured properly.
+ display_comp_ctx->display_type = type;
+ *display_ctx = display_comp_ctx;
+ // New display device has been added, so move the composition mode to safe mode until unless
+ // resources for the added display is configured properly.
safe_mode_ = true;
return kErrorNone;
}
-DisplayError CompManager::UnregisterDevice(Handle device) {
+DisplayError CompManager::UnregisterDisplay(Handle comp_handle) {
SCOPE_LOCK(locker_);
- CompManagerDevice *comp_mgr_device = reinterpret_cast<CompManagerDevice *>(device);
+ DisplayCompositionContext *display_comp_ctx =
+ reinterpret_cast<DisplayCompositionContext *>(comp_handle);
- res_mgr_.UnregisterDevice(comp_mgr_device->res_mgr_device);
- CLEAR_BIT(registered_displays_, comp_mgr_device->device_type);
- CLEAR_BIT(configured_displays_, comp_mgr_device->device_type);
- delete comp_mgr_device;
+ res_mgr_.UnregisterDisplay(display_comp_ctx->display_resource_ctx);
+ CLEAR_BIT(registered_displays_, display_comp_ctx->display_type);
+ CLEAR_BIT(configured_displays_, display_comp_ctx->display_type);
+ delete display_comp_ctx;
return kErrorNone;
}
-void CompManager::PrepareStrategyConstraints(Handle device, HWLayers *hw_layers) {
- CompManagerDevice *comp_mgr_device = reinterpret_cast<CompManagerDevice *>(device);
- StrategyConstraints *constraints = &comp_mgr_device->constraints;
+void CompManager::PrepareStrategyConstraints(Handle comp_handle, HWLayers *hw_layers) {
+ DisplayCompositionContext *display_comp_ctx =
+ reinterpret_cast<DisplayCompositionContext *>(comp_handle);
+ StrategyConstraints *constraints = &display_comp_ctx->constraints;
constraints->safe_mode = safe_mode_;
// If validation for the best available composition strategy with driver has failed, just
@@ -139,20 +141,21 @@
}
}
-DisplayError CompManager::Prepare(Handle device, HWLayers *hw_layers) {
+DisplayError CompManager::Prepare(Handle display_ctx, HWLayers *hw_layers) {
SCOPE_LOCK(locker_);
- CompManagerDevice *comp_mgr_device = reinterpret_cast<CompManagerDevice *>(device);
- Handle &res_mgr_device = comp_mgr_device->res_mgr_device;
+ DisplayCompositionContext *display_comp_ctx =
+ reinterpret_cast<DisplayCompositionContext *>(display_ctx);
+ Handle &display_resource_ctx = display_comp_ctx->display_resource_ctx;
DisplayError error = kErrorNone;
- PrepareStrategyConstraints(device, hw_layers);
+ PrepareStrategyConstraints(display_ctx, hw_layers);
// Select a composition strategy, and try to allocate resources for it.
- res_mgr_.Start(res_mgr_device);
+ res_mgr_.Start(display_resource_ctx);
while (true) {
- error = strategy_intf_->GetNextStrategy(&comp_mgr_device->constraints, &hw_layers->info);
+ error = strategy_intf_->GetNextStrategy(&display_comp_ctx->constraints, &hw_layers->info);
if (UNLIKELY(error != kErrorNone)) {
// Composition strategies exhausted. Resource Manager could not allocate resources even for
// GPU composition. This will never happen.
@@ -160,7 +163,7 @@
return error;
}
- error = res_mgr_.Acquire(res_mgr_device, hw_layers);
+ error = res_mgr_.Acquire(display_resource_ctx, hw_layers);
if (error != kErrorNone) {
// Not enough resources, try next strategy.
continue;
@@ -169,33 +172,35 @@
break;
}
}
- res_mgr_.Stop(res_mgr_device);
+ res_mgr_.Stop(display_resource_ctx);
return kErrorNone;
}
-void CompManager::PostPrepare(Handle device, HWLayers *hw_layers) {
+void CompManager::PostPrepare(Handle display_ctx, HWLayers *hw_layers) {
SCOPE_LOCK(locker_);
}
-void CompManager::PostCommit(Handle device, HWLayers *hw_layers) {
+void CompManager::PostCommit(Handle display_ctx, HWLayers *hw_layers) {
SCOPE_LOCK(locker_);
- CompManagerDevice *comp_mgr_device = reinterpret_cast<CompManagerDevice *>(device);
- SET_BIT(configured_displays_, comp_mgr_device->device_type);
+ DisplayCompositionContext *display_comp_ctx =
+ reinterpret_cast<DisplayCompositionContext *>(display_ctx);
+ SET_BIT(configured_displays_, display_comp_ctx->display_type);
if (configured_displays_ == registered_displays_) {
safe_mode_ = false;
}
- res_mgr_.PostCommit(comp_mgr_device->res_mgr_device, hw_layers);
+ res_mgr_.PostCommit(display_comp_ctx->display_resource_ctx, hw_layers);
}
-void CompManager::Purge(Handle device) {
+void CompManager::Purge(Handle display_ctx) {
SCOPE_LOCK(locker_);
- CompManagerDevice *comp_mgr_device = reinterpret_cast<CompManagerDevice *>(device);
+ DisplayCompositionContext *display_comp_ctx =
+ reinterpret_cast<DisplayCompositionContext *>(display_ctx);
- res_mgr_.Purge(comp_mgr_device->res_mgr_device);
+ res_mgr_.Purge(display_comp_ctx->display_resource_ctx);
}
void CompManager::AppendDump(char *buffer, uint32_t length) {
diff --git a/displayengine/libs/core/comp_manager.h b/displayengine/libs/core/comp_manager.h
index f9c9202..492500a 100644
--- a/displayengine/libs/core/comp_manager.h
+++ b/displayengine/libs/core/comp_manager.h
@@ -25,7 +25,7 @@
#ifndef __COMP_MANAGER_H__
#define __COMP_MANAGER_H__
-#include <core/device_interface.h>
+#include <core/display_interface.h>
#include "hw_interface.h"
#include "strategy_default.h"
@@ -39,23 +39,23 @@
CompManager();
DisplayError Init(const HWResourceInfo &hw_res_info_);
DisplayError Deinit();
- DisplayError RegisterDevice(DeviceType type, const HWDeviceAttributes &attributes,
- Handle *device);
- DisplayError UnregisterDevice(Handle device);
- DisplayError Prepare(Handle device, HWLayers *hw_layers);
- void PostPrepare(Handle device, HWLayers *hw_layers);
- void PostCommit(Handle device, HWLayers *hw_layers);
- void Purge(Handle device);
+ DisplayError RegisterDisplay(DisplayType type, const HWDisplayAttributes &attributes,
+ Handle *res_mgr_hnd);
+ DisplayError UnregisterDisplay(Handle res_mgr_hnd);
+ DisplayError Prepare(Handle display_ctx, HWLayers *hw_layers);
+ void PostPrepare(Handle display_ctx, HWLayers *hw_layers);
+ void PostCommit(Handle display_ctx, HWLayers *hw_layers);
+ void Purge(Handle display_ctx);
// DumpImpl method
virtual void AppendDump(char *buffer, uint32_t length);
private:
- void PrepareStrategyConstraints(Handle device, HWLayers *hw_layers);
- struct CompManagerDevice {
+ void PrepareStrategyConstraints(Handle display_ctx, HWLayers *hw_layers);
+ struct DisplayCompositionContext {
StrategyConstraints constraints;
- Handle res_mgr_device;
- DeviceType device_type;
+ Handle display_resource_ctx;
+ DisplayType display_type;
};
Locker locker_;
diff --git a/displayengine/libs/core/core_impl.cpp b/displayengine/libs/core/core_impl.cpp
index 9a1fa12..a3dfde1 100644
--- a/displayengine/libs/core/core_impl.cpp
+++ b/displayengine/libs/core/core_impl.cpp
@@ -31,9 +31,9 @@
#include <utils/constants.h>
#include "core_impl.h"
-#include "device_primary.h"
-#include "device_hdmi.h"
-#include "device_virtual.h"
+#include "display_primary.h"
+#include "display_hdmi.h"
+#include "display_virtual.h"
namespace sde {
@@ -84,57 +84,57 @@
return kErrorNone;
}
-DisplayError CoreImpl::CreateDevice(DeviceType type, DeviceEventHandler *event_handler,
- DeviceInterface **intf) {
+DisplayError CoreImpl::CreateDisplay(DisplayType type, DisplayEventHandler *event_handler,
+ DisplayInterface **intf) {
SCOPE_LOCK(locker_);
if (UNLIKELY(!event_handler || !intf)) {
return kErrorParameters;
}
- DeviceBase *device_base = NULL;
+ DisplayBase *display_base = NULL;
switch (type) {
case kPrimary:
- device_base = new DevicePrimary(event_handler, hw_intf_, &comp_mgr_);
+ display_base = new DisplayPrimary(event_handler, hw_intf_, &comp_mgr_);
break;
- case kHWHDMI:
- device_base = new DeviceHDMI(event_handler, hw_intf_, &comp_mgr_);
+ case kHDMI:
+ display_base = new DisplayHDMI(event_handler, hw_intf_, &comp_mgr_);
break;
case kVirtual:
- device_base = new DeviceVirtual(event_handler, hw_intf_, &comp_mgr_);
+ display_base = new DisplayVirtual(event_handler, hw_intf_, &comp_mgr_);
break;
default:
- DLOGE("Spurious device type %d", type);
+ DLOGE("Spurious display type %d", type);
return kErrorParameters;
}
- if (UNLIKELY(!device_base)) {
+ if (UNLIKELY(!display_base)) {
return kErrorMemory;
}
- DisplayError error = device_base->Init();
+ DisplayError error = display_base->Init();
if (UNLIKELY(error != kErrorNone)) {
- delete device_base;
+ delete display_base;
return error;
}
- *intf = device_base;
+ *intf = display_base;
return kErrorNone;
}
-DisplayError CoreImpl::DestroyDevice(DeviceInterface *intf) {
+DisplayError CoreImpl::DestroyDisplay(DisplayInterface *intf) {
SCOPE_LOCK(locker_);
if (UNLIKELY(!intf)) {
return kErrorParameters;
}
- DeviceBase *device_base = static_cast<DeviceBase *>(intf);
- device_base->Deinit();
- delete device_base;
+ DisplayBase *display_base = static_cast<DisplayBase *>(intf);
+ display_base->Deinit();
+ delete display_base;
return kErrorNone;
}
diff --git a/displayengine/libs/core/core_impl.h b/displayengine/libs/core/core_impl.h
index 16a01f2..ad86c60 100644
--- a/displayengine/libs/core/core_impl.h
+++ b/displayengine/libs/core/core_impl.h
@@ -52,9 +52,9 @@
virtual DisplayError Deinit();
// Methods from core interface
- virtual DisplayError CreateDevice(DeviceType type, DeviceEventHandler *event_handler,
- DeviceInterface **intf);
- virtual DisplayError DestroyDevice(DeviceInterface *intf);
+ virtual DisplayError CreateDisplay(DisplayType type, DisplayEventHandler *event_handler,
+ DisplayInterface **intf);
+ virtual DisplayError DestroyDisplay(DisplayInterface *intf);
protected:
Locker locker_;
diff --git a/displayengine/libs/core/device_primary.cpp b/displayengine/libs/core/device_primary.cpp
deleted file mode 100644
index c5d45b8..0000000
--- a/displayengine/libs/core/device_primary.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
-* 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.
-*/
-
-// SDE_LOG_TAG definition must precede debug.h include.
-#define SDE_LOG_TAG kTagCore
-#define SDE_MODULE_NAME "DevicePrimary"
-#include <utils/debug.h>
-
-#include <utils/constants.h>
-
-#include "device_primary.h"
-
-namespace sde {
-
-DevicePrimary::DevicePrimary(DeviceEventHandler *event_handler, HWInterface *hw_intf,
- CompManager *comp_manager)
- : DeviceBase(kPrimary, event_handler, kHWPrimary, hw_intf, comp_manager) {
-}
-
-} // namespace sde
-
diff --git a/displayengine/libs/core/device_primary.h b/displayengine/libs/core/device_primary.h
deleted file mode 100644
index 771a6f7..0000000
--- a/displayengine/libs/core/device_primary.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
-* 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 __DEVICE_PRIMARY_H__
-#define __DEVICE_PRIMARY_H__
-
-#include "device_base.h"
-
-namespace sde {
-
-class DevicePrimary : public DeviceBase {
- public:
- DevicePrimary(DeviceEventHandler *event_handler, HWInterface *hw_intf, CompManager *comp_manager);
-};
-
-} // namespace sde
-
-#endif // __DEVICE_PRIMARY_H__
-
diff --git a/displayengine/libs/core/device_virtual.h b/displayengine/libs/core/device_virtual.h
deleted file mode 100644
index e279f12..0000000
--- a/displayengine/libs/core/device_virtual.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
-* 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 __DEVICE_VIRTUAL_H__
-#define __DEVICE_VIRTUAL_H__
-
-#include "device_base.h"
-
-namespace sde {
-
-class DeviceVirtual : public DeviceBase {
- public:
- DeviceVirtual(DeviceEventHandler *event_handler, HWInterface *hw_intf, CompManager *comp_manager);
-};
-
-} // namespace sde
-
-#endif // __DEVICE_VIRTUAL_H__
-
diff --git a/displayengine/libs/core/device_base.cpp b/displayengine/libs/core/display_base.cpp
similarity index 75%
rename from displayengine/libs/core/device_base.cpp
rename to displayengine/libs/core/display_base.cpp
index 6dc3ebd..5b2d0af 100644
--- a/displayengine/libs/core/device_base.cpp
+++ b/displayengine/libs/core/display_base.cpp
@@ -24,24 +24,24 @@
// SDE_LOG_TAG definition must precede debug.h include.
#define SDE_LOG_TAG kTagCore
-#define SDE_MODULE_NAME "DeviceBase"
+#define SDE_MODULE_NAME "DisplayBase"
#include <utils/debug.h>
#include <utils/constants.h>
-#include "device_base.h"
+#include "display_base.h"
namespace sde {
-DeviceBase::DeviceBase(DeviceType device_type, DeviceEventHandler *event_handler,
- HWBlockType hw_block_type, HWInterface *hw_intf, CompManager *comp_manager)
- : device_type_(device_type), event_handler_(event_handler), hw_block_type_(hw_block_type),
+DisplayBase::DisplayBase(DisplayType display_type, DisplayEventHandler *event_handler,
+ HWBlockType hw_block_type, HWInterface *hw_intf, CompManager *comp_manager)
+ : display_type_(display_type), event_handler_(event_handler), hw_block_type_(hw_block_type),
hw_intf_(hw_intf), comp_manager_(comp_manager), state_(kStateOff), hw_device_(0),
- comp_mgr_device_(0), device_attributes_(NULL), num_modes_(0), active_mode_index_(0),
+ display_comp_ctx_(0), display_attributes_(NULL), num_modes_(0), active_mode_index_(0),
pending_commit_(false), vsync_enable_(false) {
}
-DisplayError DeviceBase::Init() {
+DisplayError DisplayBase::Init() {
SCOPE_LOCK(locker_);
DisplayError error = kErrorNone;
@@ -51,19 +51,19 @@
return error;
}
- error = hw_intf_->GetNumDeviceAttributes(hw_device_, &num_modes_);
+ error = hw_intf_->GetNumDisplayAttributes(hw_device_, &num_modes_);
if (UNLIKELY(error != kErrorNone)) {
goto CleanupOnError;
}
- device_attributes_ = new HWDeviceAttributes[num_modes_];
- if (!device_attributes_) {
+ display_attributes_ = new HWDisplayAttributes[num_modes_];
+ if (!display_attributes_) {
error = kErrorMemory;
goto CleanupOnError;
}
for (uint32_t i = 0; i < num_modes_; i++) {
- error = hw_intf_->GetDeviceAttributes(hw_device_, &device_attributes_[i], i);
+ error = hw_intf_->GetDisplayAttributes(hw_device_, &display_attributes_[i], i);
if (UNLIKELY(error != kErrorNone)) {
goto CleanupOnError;
}
@@ -71,8 +71,8 @@
active_mode_index_ = 0;
- error = comp_manager_->RegisterDevice(device_type_, device_attributes_[active_mode_index_],
- &comp_mgr_device_);
+ error = comp_manager_->RegisterDisplay(display_type_, display_attributes_[active_mode_index_],
+ &display_comp_ctx_);
if (UNLIKELY(error != kErrorNone)) {
goto CleanupOnError;
}
@@ -80,10 +80,10 @@
return kErrorNone;
CleanupOnError:
- comp_manager_->UnregisterDevice(comp_mgr_device_);
+ comp_manager_->UnregisterDisplay(display_comp_ctx_);
- if (device_attributes_) {
- delete[] device_attributes_;
+ if (display_attributes_) {
+ delete[] display_attributes_;
}
hw_intf_->Close(hw_device_);
@@ -91,17 +91,17 @@
return error;
}
-DisplayError DeviceBase::Deinit() {
+DisplayError DisplayBase::Deinit() {
SCOPE_LOCK(locker_);
- comp_manager_->UnregisterDevice(comp_mgr_device_);
- delete[] device_attributes_;
+ comp_manager_->UnregisterDisplay(display_comp_ctx_);
+ delete[] display_attributes_;
hw_intf_->Close(hw_device_);
return kErrorNone;
}
-DisplayError DeviceBase::Prepare(LayerStack *layer_stack) {
+DisplayError DisplayBase::Prepare(LayerStack *layer_stack) {
SCOPE_LOCK(locker_);
DisplayError error = kErrorNone;
@@ -118,7 +118,7 @@
hw_layers_.info.stack = layer_stack;
while (true) {
- error = comp_manager_->Prepare(comp_mgr_device_, &hw_layers_);
+ error = comp_manager_->Prepare(display_comp_ctx_, &hw_layers_);
if (UNLIKELY(error != kErrorNone)) {
break;
}
@@ -126,7 +126,7 @@
error = hw_intf_->Validate(hw_device_, &hw_layers_);
if (LIKELY(error == kErrorNone)) {
// Strategy is successful now, wait for Commit().
- comp_manager_->PostPrepare(comp_mgr_device_, &hw_layers_);
+ comp_manager_->PostPrepare(display_comp_ctx_, &hw_layers_);
pending_commit_ = true;
break;
}
@@ -136,7 +136,7 @@
return error;
}
-DisplayError DeviceBase::Commit(LayerStack *layer_stack) {
+DisplayError DisplayBase::Commit(LayerStack *layer_stack) {
SCOPE_LOCK(locker_);
DisplayError error = kErrorNone;
@@ -153,7 +153,7 @@
if (LIKELY(state_ == kStateOn)) {
error = hw_intf_->Commit(hw_device_, &hw_layers_);
if (LIKELY(error == kErrorNone)) {
- comp_manager_->PostCommit(comp_mgr_device_, &hw_layers_);
+ comp_manager_->PostCommit(display_comp_ctx_, &hw_layers_);
} else {
DLOGE("Unexpected error. Commit failed on driver.");
}
@@ -164,7 +164,7 @@
return kErrorNone;
}
-DisplayError DeviceBase::GetDeviceState(DeviceState *state) {
+DisplayError DisplayBase::GetDisplayState(DisplayState *state) {
SCOPE_LOCK(locker_);
if (UNLIKELY(!state)) {
@@ -175,7 +175,7 @@
return kErrorNone;
}
-DisplayError DeviceBase::GetNumVariableInfoConfigs(uint32_t *count) {
+DisplayError DisplayBase::GetNumVariableInfoConfigs(uint32_t *count) {
SCOPE_LOCK(locker_);
if (UNLIKELY(!count)) {
@@ -187,7 +187,7 @@
return kErrorNone;
}
-DisplayError DeviceBase::GetConfig(DeviceConfigFixedInfo *fixed_info) {
+DisplayError DisplayBase::GetConfig(DisplayConfigFixedInfo *fixed_info) {
SCOPE_LOCK(locker_);
if (UNLIKELY(!fixed_info)) {
@@ -197,19 +197,19 @@
return kErrorNone;
}
-DisplayError DeviceBase::GetConfig(DeviceConfigVariableInfo *variable_info, uint32_t mode) {
+DisplayError DisplayBase::GetConfig(DisplayConfigVariableInfo *variable_info, uint32_t mode) {
SCOPE_LOCK(locker_);
if (UNLIKELY(!variable_info || mode >= num_modes_)) {
return kErrorParameters;
}
- *variable_info = device_attributes_[mode];
+ *variable_info = display_attributes_[mode];
return kErrorNone;
}
-DisplayError DeviceBase::GetVSyncState(bool *enabled) {
+DisplayError DisplayBase::GetVSyncState(bool *enabled) {
SCOPE_LOCK(locker_);
if (UNLIKELY(!enabled)) {
@@ -219,7 +219,7 @@
return kErrorNone;
}
-DisplayError DeviceBase::SetDeviceState(DeviceState state) {
+DisplayError DisplayBase::SetDisplayState(DisplayState state) {
SCOPE_LOCK(locker_);
DisplayError error = kErrorNone;
@@ -233,7 +233,7 @@
switch (state) {
case kStateOff:
- comp_manager_->Purge(comp_mgr_device_);
+ comp_manager_->Purge(display_comp_ctx_);
error = hw_intf_->PowerOff(hw_device_);
break;
@@ -261,13 +261,13 @@
return error;
}
-DisplayError DeviceBase::SetConfig(uint32_t mode) {
+DisplayError DisplayBase::SetConfig(uint32_t mode) {
SCOPE_LOCK(locker_);
return kErrorNone;
}
-DisplayError DeviceBase::SetVSyncState(bool enable) {
+DisplayError DisplayBase::SetVSyncState(bool enable) {
SCOPE_LOCK(locker_);
DisplayError error = kErrorNone;
if (vsync_enable_ != enable) {
@@ -280,9 +280,9 @@
return error;
}
-DisplayError DeviceBase::VSync(int64_t timestamp) {
+DisplayError DisplayBase::VSync(int64_t timestamp) {
if (vsync_enable_) {
- DeviceEventVSync vsync;
+ DisplayEventVSync vsync;
vsync.timestamp = timestamp;
event_handler_->VSync(vsync);
}
@@ -290,20 +290,20 @@
return kErrorNone;
}
-DisplayError DeviceBase::Blank(bool blank) {
+DisplayError DisplayBase::Blank(bool blank) {
return kErrorNone;
}
-void DeviceBase::AppendDump(char *buffer, uint32_t length) {
+void DisplayBase::AppendDump(char *buffer, uint32_t length) {
SCOPE_LOCK(locker_);
AppendString(buffer, length, "\n-----------------------");
- AppendString(buffer, length, "\ndevice type: %u", device_type_);
+ AppendString(buffer, length, "\ndevice type: %u", display_type_);
AppendString(buffer, length, "\nstate: %u, vsync on: %u", state_, INT(vsync_enable_));
AppendString(buffer, length, "\nnum configs: %u, active config index: %u",
num_modes_, active_mode_index_);
- DeviceConfigVariableInfo &info = device_attributes_[active_mode_index_];
+ DisplayConfigVariableInfo &info = display_attributes_[active_mode_index_];
AppendString(buffer, length, "\nres:%ux%u, dpi:%.2fx%.2f, fps:%.2f, vsync period: %u",
info.x_pixels, info.y_pixels, info.x_dpi, info.y_dpi, info.fps, info.vsync_period_ns);
@@ -344,7 +344,8 @@
}
}
-void DeviceBase::AppendRect(char *buffer, uint32_t length, const char *rect_name, LayerRect *rect) {
+void DisplayBase::AppendRect(char *buffer, uint32_t length, const char *rect_name,
+ LayerRect *rect) {
AppendString(buffer, length, "%s %.1f, %.1f, %.1f, %.1f",
rect_name, rect->left, rect->top, rect->right, rect->bottom);
}
diff --git a/displayengine/libs/core/device_base.h b/displayengine/libs/core/display_base.h
similarity index 78%
rename from displayengine/libs/core/device_base.h
rename to displayengine/libs/core/display_base.h
index a2ef93b..5eaac37 100644
--- a/displayengine/libs/core/device_base.h
+++ b/displayengine/libs/core/display_base.h
@@ -22,10 +22,10 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#ifndef __DEVICE_BASE_H__
-#define __DEVICE_BASE_H__
+#ifndef __DISPLAY_BASE_H__
+#define __DISPLAY_BASE_H__
-#include <core/device_interface.h>
+#include <core/display_interface.h>
#include <private/strategy_interface.h>
#include <utils/locker.h>
@@ -34,21 +34,21 @@
namespace sde {
-class DeviceBase : public DeviceInterface, HWEventHandler, DumpImpl {
+class DisplayBase : public DisplayInterface, HWEventHandler, DumpImpl {
public:
- DeviceBase(DeviceType device_type, DeviceEventHandler *event_handler,
+ DisplayBase(DisplayType display_type, DisplayEventHandler *event_handler,
HWBlockType hw_block_type, HWInterface *hw_intf, CompManager *comp_manager);
- virtual ~DeviceBase() { }
+ virtual ~DisplayBase() { }
virtual DisplayError Init();
virtual DisplayError Deinit();
virtual DisplayError Prepare(LayerStack *layer_stack);
virtual DisplayError Commit(LayerStack *layer_stack);
- virtual DisplayError GetDeviceState(DeviceState *state);
+ virtual DisplayError GetDisplayState(DisplayState *state);
virtual DisplayError GetNumVariableInfoConfigs(uint32_t *count);
- virtual DisplayError GetConfig(DeviceConfigFixedInfo *fixed_info);
- virtual DisplayError GetConfig(DeviceConfigVariableInfo *variable_info, uint32_t mode);
+ virtual DisplayError GetConfig(DisplayConfigFixedInfo *fixed_info);
+ virtual DisplayError GetConfig(DisplayConfigVariableInfo *variable_info, uint32_t mode);
virtual DisplayError GetVSyncState(bool *enabled);
- virtual DisplayError SetDeviceState(DeviceState state);
+ virtual DisplayError SetDisplayState(DisplayState state);
virtual DisplayError SetConfig(uint32_t mode);
virtual DisplayError SetVSyncState(bool enable);
@@ -62,15 +62,15 @@
protected:
Locker locker_;
- DeviceType device_type_;
- DeviceEventHandler *event_handler_;
+ DisplayType display_type_;
+ DisplayEventHandler *event_handler_;
HWBlockType hw_block_type_;
HWInterface *hw_intf_;
CompManager *comp_manager_;
- DeviceState state_;
+ DisplayState state_;
Handle hw_device_;
- Handle comp_mgr_device_;
- HWDeviceAttributes *device_attributes_;
+ Handle display_comp_ctx_;
+ HWDisplayAttributes *display_attributes_;
uint32_t num_modes_;
uint32_t active_mode_index_;
HWLayers hw_layers_;
@@ -80,5 +80,5 @@
} // namespace sde
-#endif // __DEVICE_BASE_H__
+#endif // __DISPLAY_BASE_H__
diff --git a/displayengine/libs/core/device_hdmi.cpp b/displayengine/libs/core/display_hdmi.cpp
similarity index 86%
rename from displayengine/libs/core/device_hdmi.cpp
rename to displayengine/libs/core/display_hdmi.cpp
index a7c8c4f..b44bc87 100644
--- a/displayengine/libs/core/device_hdmi.cpp
+++ b/displayengine/libs/core/display_hdmi.cpp
@@ -24,18 +24,18 @@
// SDE_LOG_TAG definition must precede debug.h include.
#define SDE_LOG_TAG kTagCore
-#define SDE_MODULE_NAME "DeviceHDMI"
+#define SDE_MODULE_NAME "DisplayHDMI"
#include <utils/debug.h>
#include <utils/constants.h>
-#include "device_hdmi.h"
+#include "display_hdmi.h"
namespace sde {
-DeviceHDMI::DeviceHDMI(DeviceEventHandler *event_handler, HWInterface *hw_intf,
- CompManager *comp_manager)
- : DeviceBase(kHDMI, event_handler, kHWHDMI, hw_intf, comp_manager) {
+DisplayHDMI::DisplayHDMI(DisplayEventHandler *event_handler, HWInterface *hw_intf,
+ CompManager *comp_manager)
+ : DisplayBase(kHDMI, event_handler, kHWHDMI, hw_intf, comp_manager) {
}
} // namespace sde
diff --git a/displayengine/libs/core/device_hdmi.h b/displayengine/libs/core/display_hdmi.h
similarity index 86%
rename from displayengine/libs/core/device_hdmi.h
rename to displayengine/libs/core/display_hdmi.h
index 7d8cbc6..85f53fc 100644
--- a/displayengine/libs/core/device_hdmi.h
+++ b/displayengine/libs/core/display_hdmi.h
@@ -22,19 +22,19 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#ifndef __DEVICE_HDMI_H__
-#define __DEVICE_HDMI_H__
+#ifndef __DISPLAY_HDMI_H__
+#define __DISPLAY_HDMI_H__
-#include "device_base.h"
+#include "display_base.h"
namespace sde {
-class DeviceHDMI : public DeviceBase {
+class DisplayHDMI : public DisplayBase {
public:
- DeviceHDMI(DeviceEventHandler *event_handler, HWInterface *hw_intf, CompManager *comp_manager);
+ DisplayHDMI(DisplayEventHandler *event_handler, HWInterface *hw_intf, CompManager *comp_manager);
};
} // namespace sde
-#endif // __DEVICE_HDMI_H__
+#endif // __DISPLAY_HDMI_H__
diff --git a/displayengine/libs/core/device_virtual.cpp b/displayengine/libs/core/display_primary.cpp
similarity index 85%
rename from displayengine/libs/core/device_virtual.cpp
rename to displayengine/libs/core/display_primary.cpp
index 4e18f93..96ff08a 100644
--- a/displayengine/libs/core/device_virtual.cpp
+++ b/displayengine/libs/core/display_primary.cpp
@@ -24,18 +24,18 @@
// SDE_LOG_TAG definition must precede debug.h include.
#define SDE_LOG_TAG kTagCore
-#define SDE_MODULE_NAME "DeviceVirtual"
+#define SDE_MODULE_NAME "DisplayPrimary"
#include <utils/debug.h>
#include <utils/constants.h>
-#include "device_virtual.h"
+#include "display_primary.h"
namespace sde {
-DeviceVirtual::DeviceVirtual(DeviceEventHandler *event_handler, HWInterface *hw_intf,
- CompManager *comp_manager)
- : DeviceBase(kVirtual, event_handler, kHWBlockMax, hw_intf, comp_manager) {
+DisplayPrimary::DisplayPrimary(DisplayEventHandler *event_handler, HWInterface *hw_intf,
+ CompManager *comp_manager)
+ : DisplayBase(kPrimary, event_handler, kHWPrimary, hw_intf, comp_manager) {
}
} // namespace sde
diff --git a/displayengine/libs/core/device_hdmi.h b/displayengine/libs/core/display_primary.h
similarity index 84%
copy from displayengine/libs/core/device_hdmi.h
copy to displayengine/libs/core/display_primary.h
index 7d8cbc6..183e964 100644
--- a/displayengine/libs/core/device_hdmi.h
+++ b/displayengine/libs/core/display_primary.h
@@ -22,19 +22,20 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#ifndef __DEVICE_HDMI_H__
-#define __DEVICE_HDMI_H__
+#ifndef __DISPLAY_PRIMARY_H__
+#define __DISPLAY_PRIMARY_H__
-#include "device_base.h"
+#include "display_base.h"
namespace sde {
-class DeviceHDMI : public DeviceBase {
+class DisplayPrimary : public DisplayBase {
public:
- DeviceHDMI(DeviceEventHandler *event_handler, HWInterface *hw_intf, CompManager *comp_manager);
+ DisplayPrimary(DisplayEventHandler *event_handler, HWInterface *hw_intf,
+ CompManager *comp_manager);
};
} // namespace sde
-#endif // __DEVICE_HDMI_H__
+#endif // __DISPLAY_PRIMARY_H__
diff --git a/displayengine/libs/core/device_virtual.cpp b/displayengine/libs/core/display_virtual.cpp
similarity index 85%
copy from displayengine/libs/core/device_virtual.cpp
copy to displayengine/libs/core/display_virtual.cpp
index 4e18f93..dc18146 100644
--- a/displayengine/libs/core/device_virtual.cpp
+++ b/displayengine/libs/core/display_virtual.cpp
@@ -24,18 +24,18 @@
// SDE_LOG_TAG definition must precede debug.h include.
#define SDE_LOG_TAG kTagCore
-#define SDE_MODULE_NAME "DeviceVirtual"
+#define SDE_MODULE_NAME "DisplayVirtual"
#include <utils/debug.h>
#include <utils/constants.h>
-#include "device_virtual.h"
+#include "display_virtual.h"
namespace sde {
-DeviceVirtual::DeviceVirtual(DeviceEventHandler *event_handler, HWInterface *hw_intf,
- CompManager *comp_manager)
- : DeviceBase(kVirtual, event_handler, kHWBlockMax, hw_intf, comp_manager) {
+DisplayVirtual::DisplayVirtual(DisplayEventHandler *event_handler, HWInterface *hw_intf,
+ CompManager *comp_manager)
+ : DisplayBase(kVirtual, event_handler, kHWBlockMax, hw_intf, comp_manager) {
}
} // namespace sde
diff --git a/displayengine/libs/core/device_hdmi.h b/displayengine/libs/core/display_virtual.h
similarity index 84%
copy from displayengine/libs/core/device_hdmi.h
copy to displayengine/libs/core/display_virtual.h
index 7d8cbc6..a8e29e7 100644
--- a/displayengine/libs/core/device_hdmi.h
+++ b/displayengine/libs/core/display_virtual.h
@@ -22,19 +22,20 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#ifndef __DEVICE_HDMI_H__
-#define __DEVICE_HDMI_H__
+#ifndef __DISPLAY_VIRTUAL_H__
+#define __DISPLAY_VIRTUAL_H__
-#include "device_base.h"
+#include "display_base.h"
namespace sde {
-class DeviceHDMI : public DeviceBase {
+class DisplayVirtual : public DisplayBase {
public:
- DeviceHDMI(DeviceEventHandler *event_handler, HWInterface *hw_intf, CompManager *comp_manager);
+ DisplayVirtual(DisplayEventHandler *event_handler, HWInterface *hw_intf,
+ CompManager *comp_manager);
};
} // namespace sde
-#endif // __DEVICE_HDMI_H__
+#endif // __DISPLAY_VIRTUAL_H__
diff --git a/displayengine/libs/core/hw_framebuffer.cpp b/displayengine/libs/core/hw_framebuffer.cpp
index 8dc3330..63adf8c 100644
--- a/displayengine/libs/core/hw_framebuffer.cpp
+++ b/displayengine/libs/core/hw_framebuffer.cpp
@@ -227,7 +227,7 @@
return kErrorNone;
}
-DisplayError HWFrameBuffer::GetNumDeviceAttributes(Handle device, uint32_t *count) {
+DisplayError HWFrameBuffer::GetNumDisplayAttributes(Handle device, uint32_t *count) {
HWContext *hw_context = reinterpret_cast<HWContext *>(device);
// TODO(user): Query modes
@@ -236,9 +236,9 @@
return kErrorNone;
}
-DisplayError HWFrameBuffer::GetDeviceAttributes(Handle device,
- HWDeviceAttributes *device_attributes,
- uint32_t mode) {
+DisplayError HWFrameBuffer::GetDisplayAttributes(Handle device,
+ HWDisplayAttributes *display_attributes,
+ uint32_t mode) {
HWContext *hw_context = reinterpret_cast<HWContext *>(device);
int &device_fd = hw_context->device_fd;
@@ -265,15 +265,16 @@
var_screeninfo.height = INT((FLOAT(var_screeninfo.yres) * 25.4f)/160.0f + 0.5f);
}
- device_attributes->x_pixels = var_screeninfo.xres;
- device_attributes->y_pixels = var_screeninfo.yres;
- device_attributes->x_dpi = (FLOAT(var_screeninfo.xres) * 25.4f) / FLOAT(var_screeninfo.width);
- device_attributes->y_dpi = (FLOAT(var_screeninfo.yres) * 25.4f) / FLOAT(var_screeninfo.height);
- device_attributes->vsync_period_ns = UINT32(1000000000L / FLOAT(meta_data.data.panel_frame_rate));
+ display_attributes->x_pixels = var_screeninfo.xres;
+ display_attributes->y_pixels = var_screeninfo.yres;
+ display_attributes->x_dpi = (FLOAT(var_screeninfo.xres) * 25.4f) / FLOAT(var_screeninfo.width);
+ display_attributes->y_dpi = (FLOAT(var_screeninfo.yres) * 25.4f) / FLOAT(var_screeninfo.height);
+ display_attributes->vsync_period_ns =
+ UINT32(1000000000L / FLOAT(meta_data.data.panel_frame_rate));
// TODO(user): set panel information from sysfs
- device_attributes->is_device_split = true;
- device_attributes->split_left = device_attributes->x_pixels / 2;
+ display_attributes->is_device_split = true;
+ display_attributes->split_left = display_attributes->x_pixels / 2;
return kErrorNone;
}
diff --git a/displayengine/libs/core/hw_framebuffer.h b/displayengine/libs/core/hw_framebuffer.h
index 6b844af..d74d03e 100644
--- a/displayengine/libs/core/hw_framebuffer.h
+++ b/displayengine/libs/core/hw_framebuffer.h
@@ -43,9 +43,9 @@
virtual DisplayError GetHWCapabilities(HWResourceInfo *hw_res_info);
virtual DisplayError Open(HWBlockType type, Handle *device, HWEventHandler *eventhandler);
virtual DisplayError Close(Handle device);
- virtual DisplayError GetNumDeviceAttributes(Handle device, uint32_t *count);
- virtual DisplayError GetDeviceAttributes(Handle device, HWDeviceAttributes *device_attributes,
- uint32_t mode);
+ virtual DisplayError GetNumDisplayAttributes(Handle device, uint32_t *count);
+ virtual DisplayError GetDisplayAttributes(Handle device, HWDisplayAttributes *display_attributes,
+ uint32_t mode);
virtual DisplayError PowerOn(Handle device);
virtual DisplayError PowerOff(Handle device);
virtual DisplayError Doze(Handle device);
diff --git a/displayengine/libs/core/hw_interface.h b/displayengine/libs/core/hw_interface.h
index bb2a8a9..a9bdb96 100644
--- a/displayengine/libs/core/hw_interface.h
+++ b/displayengine/libs/core/hw_interface.h
@@ -25,7 +25,7 @@
#ifndef __HW_INTERFACE_H__
#define __HW_INTERFACE_H__
-#include <core/device_interface.h>
+#include <core/display_interface.h>
#include <private/strategy_interface.h>
#include <utils/constants.h>
@@ -103,14 +103,14 @@
HWLayerConfig config[kMaxSDELayers];
};
-struct HWDeviceAttributes : DeviceConfigVariableInfo {
+struct HWDisplayAttributes : DisplayConfigVariableInfo {
bool is_device_split;
uint32_t split_left;
- HWDeviceAttributes() : is_device_split(false), split_left(0) { }
+ HWDisplayAttributes() : is_device_split(false), split_left(0) { }
};
-// HWEventHandler - Implemented in DeviceBase and HWInterface implementation
+// HWEventHandler - Implemented in DisplayBase and HWInterface implementation
class HWEventHandler {
public:
virtual DisplayError VSync(int64_t timestamp) = 0;
@@ -126,9 +126,9 @@
virtual DisplayError GetHWCapabilities(HWResourceInfo *hw_res_info) = 0;
virtual DisplayError Open(HWBlockType type, Handle *device, HWEventHandler *eventhandler) = 0;
virtual DisplayError Close(Handle device) = 0;
- virtual DisplayError GetNumDeviceAttributes(Handle device, uint32_t *count) = 0;
- virtual DisplayError GetDeviceAttributes(Handle device, HWDeviceAttributes *device_attributes,
- uint32_t mode) = 0;
+ virtual DisplayError GetNumDisplayAttributes(Handle device, uint32_t *count) = 0;
+ virtual DisplayError GetDisplayAttributes(Handle device,
+ HWDisplayAttributes *display_attributes, uint32_t mode) = 0;
virtual DisplayError PowerOn(Handle device) = 0;
virtual DisplayError PowerOff(Handle device) = 0;
virtual DisplayError Doze(Handle device) = 0;
diff --git a/displayengine/libs/core/res_config.cpp b/displayengine/libs/core/res_config.cpp
index 0f71945..6e642ed 100644
--- a/displayengine/libs/core/res_config.cpp
+++ b/displayengine/libs/core/res_config.cpp
@@ -34,9 +34,9 @@
namespace sde {
-DisplayError ResManager::Config(ResManagerDevice *res_mgr_device, HWLayers *hw_layers) {
- HWBlockType hw_block_id = res_mgr_device->hw_block_id;
- HWDeviceAttributes &device_attributes = res_mgr_device->device_attributes;
+DisplayError ResManager::Config(DisplayResourceContext *display_resource_ctx, HWLayers *hw_layers) {
+ HWBlockType hw_block_id = display_resource_ctx->hw_block_id;
+ HWDisplayAttributes &display_attributes = display_resource_ctx->display_attributes;
HWLayersInfo &layer_info = hw_layers->info;
for (uint32_t i = 0; i < layer_info.count; i++) {
@@ -48,8 +48,8 @@
}
LayerRect scissor;
- scissor.right = FLOAT(device_attributes.split_left);
- scissor.bottom = FLOAT(device_attributes.y_pixels);
+ scissor.right = FLOAT(display_attributes.split_left);
+ scissor.bottom = FLOAT(display_attributes.y_pixels);
LayerRect crop = layer.src_rect;
LayerRect dst = layer.dst_rect;
LayerRect cropRight = crop;
@@ -65,11 +65,11 @@
if ((dstRight.right - dstRight.left) > kMaxInterfaceWidth ||
crop_width > kMaxInterfaceWidth ||
((hw_block_id == kHWPrimary) && hw_res_info_.is_src_split &&
- (crop_width > device_attributes.split_left))) {
- scissor.left = FLOAT(device_attributes.split_left);
+ (crop_width > display_attributes.split_left))) {
+ scissor.left = FLOAT(display_attributes.split_left);
scissor.top = 0.0f;
- scissor.right = FLOAT(device_attributes.x_pixels);
- scissor.bottom = FLOAT(device_attributes.y_pixels);
+ scissor.right = FLOAT(display_attributes.x_pixels);
+ scissor.bottom = FLOAT(display_attributes.y_pixels);
CalculateCropRects(&cropRight, &dstRight, scissor, layer.transform);
pipe_info->src_roi = cropRight;
pipe_info->dst_roi = dstRight;
diff --git a/displayengine/libs/core/res_manager.cpp b/displayengine/libs/core/res_manager.cpp
index de73437..3f5bd32 100644
--- a/displayengine/libs/core/res_manager.cpp
+++ b/displayengine/libs/core/res_manager.cpp
@@ -92,8 +92,8 @@
return kErrorNone;
}
-DisplayError ResManager::RegisterDevice(DeviceType type, const HWDeviceAttributes &attributes,
- Handle *device) {
+DisplayError ResManager::RegisterDisplay(DisplayType type, const HWDisplayAttributes &attributes,
+ Handle *display_ctx) {
DisplayError error = kErrorNone;
HWBlockType hw_block_id = kHWBlockMax;
@@ -118,7 +118,7 @@
break;
default:
- DLOGW("RegisterDevice, invalid type %d", type);
+ DLOGW("RegisterDisplay, invalid type %d", type);
return kErrorParameters;
}
@@ -126,37 +126,39 @@
return kErrorResources;
}
- ResManagerDevice *res_mgr_device = new ResManagerDevice();
- if (UNLIKELY(!res_mgr_device)) {
+ DisplayResourceContext *display_resource_ctx = new DisplayResourceContext();
+ if (UNLIKELY(!display_resource_ctx)) {
return kErrorMemory;
}
hw_block_ctx_[hw_block_id].is_in_use = true;
- res_mgr_device->device_attributes = attributes;
- res_mgr_device->device_type = type;
- res_mgr_device->hw_block_id = hw_block_id;
+ display_resource_ctx->display_attributes = attributes;
+ display_resource_ctx->display_type = type;
+ display_resource_ctx->hw_block_id = hw_block_id;
- *device = res_mgr_device;
+ *display_ctx = display_resource_ctx;
return kErrorNone;
}
-DisplayError ResManager::UnregisterDevice(Handle device) {
- ResManagerDevice *res_mgr_device = reinterpret_cast<ResManagerDevice *>(device);
+DisplayError ResManager::UnregisterDisplay(Handle display_ctx) {
+ DisplayResourceContext *display_resource_ctx =
+ reinterpret_cast<DisplayResourceContext *>(display_ctx);
- Purge(device);
- hw_block_ctx_[res_mgr_device->hw_block_id].is_in_use = false;
- delete res_mgr_device;
+ Purge(display_ctx);
+ hw_block_ctx_[display_resource_ctx->hw_block_id].is_in_use = false;
+ delete display_resource_ctx;
return kErrorNone;
}
-DisplayError ResManager::Start(Handle device) {
+DisplayError ResManager::Start(Handle display_ctx) {
locker_.Lock();
- ResManagerDevice *res_mgr_device = reinterpret_cast<ResManagerDevice *>(device);
+ DisplayResourceContext *display_resource_ctx =
+ reinterpret_cast<DisplayResourceContext *>(display_ctx);
if (frame_start_) {
return kErrorNone; // keep context locked.
@@ -164,10 +166,10 @@
// First call in the cycle
frame_start_ = true;
- res_mgr_device->frame_count++;
+ display_resource_ctx->frame_count++;
// Release the pipes not used in the previous cycle
- HWBlockType hw_block_id = res_mgr_device->hw_block_id;
+ HWBlockType hw_block_id = display_resource_ctx->hw_block_id;
for (uint32_t i = 0; i < num_pipe_; i++) {
if ((src_pipes_[i].hw_block_id == hw_block_id) &&
(src_pipes_[i].state == kPipeStateToRelease)) {
@@ -177,16 +179,18 @@
return kErrorNone;
}
-DisplayError ResManager::Stop(Handle device) {
+DisplayError ResManager::Stop(Handle display_ctx) {
locker_.Unlock();
- ResManagerDevice *res_mgr_device = reinterpret_cast<ResManagerDevice *>(device);
+ DisplayResourceContext *display_resource_ctx =
+ reinterpret_cast<DisplayResourceContext *>(display_ctx);
return kErrorNone;
}
-DisplayError ResManager::Acquire(Handle device, HWLayers *hw_layers) {
- ResManagerDevice *res_mgr_device = reinterpret_cast<ResManagerDevice *>(device);
+DisplayError ResManager::Acquire(Handle display_ctx, HWLayers *hw_layers) {
+ DisplayResourceContext *display_resource_ctx =
+ reinterpret_cast<DisplayResourceContext *>(display_ctx);
DisplayError error = kErrorNone;
const struct HWLayersInfo &layer_info = hw_layers->info;
@@ -199,14 +203,14 @@
return kErrorResources;
}
- error = Config(res_mgr_device, hw_layers);
+ error = Config(display_resource_ctx, hw_layers);
if (UNLIKELY(error != kErrorNone)) {
return error;
}
uint32_t left_index = 0;
bool need_scale = false;
- HWBlockType hw_block_id = res_mgr_device->hw_block_id;
+ HWBlockType hw_block_id = display_resource_ctx->hw_block_id;
// Clear reserved marking
for (uint32_t i = 0; i < num_pipe_; i++) {
@@ -274,10 +278,11 @@
return kErrorResources;
}
-void ResManager::PostCommit(Handle device, HWLayers *hw_layers) {
- ResManagerDevice *res_mgr_device = reinterpret_cast<ResManagerDevice *>(device);
- HWBlockType hw_block_id = res_mgr_device->hw_block_id;
- uint64_t frame_count = res_mgr_device->frame_count;
+void ResManager::PostCommit(Handle display_ctx, HWLayers *hw_layers) {
+ DisplayResourceContext *display_resource_ctx =
+ reinterpret_cast<DisplayResourceContext *>(display_ctx);
+ HWBlockType hw_block_id = display_resource_ctx->hw_block_id;
+ uint64_t frame_count = display_resource_ctx->frame_count;
DLOGV("Resource for hw_block=%d frame_count=%d", hw_block_id, frame_count);
@@ -310,11 +315,12 @@
frame_start_ = false;
}
-void ResManager::Purge(Handle device) {
+void ResManager::Purge(Handle display_ctx) {
SCOPE_LOCK(locker_);
- ResManagerDevice *res_mgr_device = reinterpret_cast<ResManagerDevice *>(device);
- HWBlockType hw_block_id = res_mgr_device->hw_block_id;
+ DisplayResourceContext *display_resource_ctx =
+ reinterpret_cast<DisplayResourceContext *>(display_ctx);
+ HWBlockType hw_block_id = display_resource_ctx->hw_block_id;
for (uint32_t i = 0; i < num_pipe_; i++) {
if (src_pipes_[i].hw_block_id == hw_block_id)
diff --git a/displayengine/libs/core/res_manager.h b/displayengine/libs/core/res_manager.h
index b2698c9..c4d425b 100644
--- a/displayengine/libs/core/res_manager.h
+++ b/displayengine/libs/core/res_manager.h
@@ -25,7 +25,7 @@
#ifndef __RES_MANAGER_H__
#define __RES_MANAGER_H__
-#include <core/device_interface.h>
+#include <core/display_interface.h>
#include <utils/locker.h>
#include "hw_interface.h"
@@ -38,14 +38,14 @@
ResManager();
DisplayError Init(const HWResourceInfo &hw_res_info);
DisplayError Deinit();
- DisplayError RegisterDevice(DeviceType type, const HWDeviceAttributes &attributes,
- Handle *device);
- DisplayError UnregisterDevice(Handle device);
- DisplayError Start(Handle device);
- DisplayError Stop(Handle device);
- DisplayError Acquire(Handle device, HWLayers *hw_layers);
- void PostCommit(Handle device, HWLayers *hw_layers);
- void Purge(Handle device);
+ DisplayError RegisterDisplay(DisplayType type, const HWDisplayAttributes &attributes,
+ Handle *display_ctx);
+ DisplayError UnregisterDisplay(Handle display_ctx);
+ DisplayError Start(Handle display_ctx);
+ DisplayError Stop(Handle display_ctx);
+ DisplayError Acquire(Handle display_ctx, HWLayers *hw_layers);
+ void PostCommit(Handle display_ctx, HWLayers *hw_layers);
+ void Purge(Handle display_ctx);
// DumpImpl method
virtual void AppendDump(char *buffer, uint32_t length);
@@ -103,14 +103,14 @@
reserved(false) { }
};
- struct ResManagerDevice {
- HWDeviceAttributes device_attributes;
- DeviceType device_type;
+ struct DisplayResourceContext {
+ HWDisplayAttributes display_attributes;
+ DisplayType display_type;
HWBlockType hw_block_id;
uint64_t frame_count;
int32_t session_id; // applicable for virtual display sessions only
- ResManagerDevice() : hw_block_id(kHWBlockMax), frame_count(0), session_id(-1) { }
+ DisplayResourceContext() : hw_block_id(kHWBlockMax), frame_count(0), session_id(-1) { }
};
struct HWBlockContext {
@@ -123,7 +123,7 @@
uint32_t GetPipe(HWBlockType hw_block_id, bool is_yuv, bool need_scale, bool at_right,
bool use_non_dma_pipe);
bool IsScalingNeeded(const HWPipeInfo *pipe_info);
- DisplayError Config(ResManagerDevice *res_mgr_device, HWLayers *hw_layers);
+ DisplayError Config(DisplayResourceContext *display_resource_ctx, HWLayers *hw_layers);
bool IsValidDimension(const Layer &layer, float *width_scale, float *height_scale);
void CalculateCut(float *left_cut_ratio, float *top_cut_ratio, float *right_cut_ratio,
float *bottom_cut_ratio, const LayerTransform &transform);
diff --git a/displayengine/libs/core/strategy_default.h b/displayengine/libs/core/strategy_default.h
index c72bab9..c4e10f4 100644
--- a/displayengine/libs/core/strategy_default.h
+++ b/displayengine/libs/core/strategy_default.h
@@ -25,7 +25,7 @@
#ifndef __STRATEGY_DEFAULT_H__
#define __STRATEGY_DEFAULT_H__
-#include <core/device_interface.h>
+#include <core/display_interface.h>
#include <private/strategy_interface.h>
namespace sde {
diff --git a/displayengine/libs/hwc/Android.mk b/displayengine/libs/hwc/Android.mk
index be7e18c..c32337a 100644
--- a/displayengine/libs/hwc/Android.mk
+++ b/displayengine/libs/hwc/Android.mk
@@ -9,12 +9,12 @@
LOCAL_CFLAGS := $(common_flags) -DLOG_TAG=\"HWComposer\"
LOCAL_SHARED_LIBRARIES := $(common_libs) libEGL libhardware_legacy \
libdl libsync \
- libbinder libmedia libskia libsdecore
+ libbinder libmedia libskia libsde
LOCAL_ADDITIONAL_DEPENDENCIES := $(common_deps)
LOCAL_SRC_FILES := hwc_session.cpp \
- hwc_sink.cpp \
- hwc_sink_primary.cpp \
- hwc_sink_external.cpp \
- hwc_sink_virtual.cpp
+ hwc_display.cpp \
+ hwc_display_primary.cpp \
+ hwc_display_external.cpp \
+ hwc_display_virtual.cpp
include $(BUILD_SHARED_LIBRARY)
diff --git a/displayengine/libs/hwc/hwc_sink.cpp b/displayengine/libs/hwc/hwc_display.cpp
similarity index 86%
rename from displayengine/libs/hwc/hwc_sink.cpp
rename to displayengine/libs/hwc/hwc_display.cpp
index 0fb4b8c..ce81fdd 100644
--- a/displayengine/libs/hwc/hwc_sink.cpp
+++ b/displayengine/libs/hwc/hwc_display.cpp
@@ -27,19 +27,20 @@
#include <utils/constants.h>
// HWC_MODULE_NAME definition must precede hwc_logger.h include.
-#define HWC_MODULE_NAME "HWCSink"
+#define HWC_MODULE_NAME "HWCDisplay"
#include "hwc_logger.h"
-#include "hwc_sink.h"
+#include "hwc_display.h"
namespace sde {
-HWCSink::HWCSink(CoreInterface *core_intf, hwc_procs_t const **hwc_procs, DeviceType type, int id)
- : core_intf_(core_intf), hwc_procs_(hwc_procs), type_(type), id_(id), device_intf_(NULL) {
+HWCDisplay::HWCDisplay(CoreInterface *core_intf, hwc_procs_t const **hwc_procs, DisplayType type,
+ int id)
+ : core_intf_(core_intf), hwc_procs_(hwc_procs), type_(type), id_(id), display_intf_(NULL) {
}
-int HWCSink::Init() {
- DisplayError error = core_intf_->CreateDevice(type_, this, &device_intf_);
+int HWCDisplay::Init() {
+ DisplayError error = core_intf_->CreateDisplay(type_, this, &display_intf_);
if (UNLIKELY(error != kErrorNone)) {
DLOGE("Display device create failed. Error = %d", error);
return -EINVAL;
@@ -48,8 +49,8 @@
return 0;
}
-int HWCSink::Deinit() {
- DisplayError error = core_intf_->DestroyDevice(device_intf_);
+int HWCDisplay::Deinit() {
+ DisplayError error = core_intf_->DestroyDisplay(display_intf_);
if (UNLIKELY(error != kErrorNone)) {
DLOGE("Display device destroy failed. Error = %d", error);
return -EINVAL;
@@ -62,12 +63,12 @@
return 0;
}
-int HWCSink::EventControl(int event, int enable) {
+int HWCDisplay::EventControl(int event, int enable) {
DisplayError error = kErrorNone;
switch (event) {
case HWC_EVENT_VSYNC:
- error = device_intf_->SetVSyncState(enable);
+ error = display_intf_->SetVSyncState(enable);
break;
default:
@@ -82,13 +83,13 @@
return 0;
}
-int HWCSink::Blank(int blank) {
+int HWCDisplay::Blank(int blank) {
DLOGI("Blank : %d, display : %d", blank, id_);
- DeviceState state = blank ? kStateOff : kStateOn;
+ DisplayState state = blank ? kStateOff : kStateOn;
return SetState(state);
}
-int HWCSink::GetDisplayConfigs(uint32_t *configs, size_t *num_configs) {
+int HWCDisplay::GetDisplayConfigs(uint32_t *configs, size_t *num_configs) {
if (*num_configs > 0) {
configs[0] = 0;
*num_configs = 1;
@@ -97,11 +98,11 @@
return 0;
}
-int HWCSink::GetDisplayAttributes(uint32_t config, const uint32_t *attributes, int32_t *values) {
+int HWCDisplay::GetDisplayAttributes(uint32_t config, const uint32_t *attributes, int32_t *values) {
DisplayError error = kErrorNone;
- DeviceConfigVariableInfo variable_config;
- error = device_intf_->GetConfig(&variable_config, 0);
+ DisplayConfigVariableInfo variable_config;
+ error = display_intf_->GetConfig(&variable_config, 0);
if (UNLIKELY(error != kErrorNone)) {
DLOGE("GetConfig variable info failed. Error = %d", error);
return -EINVAL;
@@ -133,8 +134,8 @@
return 0;
}
-int HWCSink::SetState(DeviceState state) {
- DisplayError error = device_intf_->SetDeviceState(state);
+int HWCDisplay::SetState(DisplayState state) {
+ DisplayError error = display_intf_->SetDisplayState(state);
if (UNLIKELY(error != kErrorNone)) {
DLOGE("Set state failed. Error = %d", error);
return -EINVAL;
@@ -143,7 +144,7 @@
return 0;
}
-DisplayError HWCSink::VSync(const DeviceEventVSync &vsync) {
+DisplayError HWCDisplay::VSync(const DisplayEventVSync &vsync) {
if (*hwc_procs_) {
(*hwc_procs_)->vsync(*hwc_procs_, id_, vsync.timestamp);
}
@@ -151,7 +152,7 @@
return kErrorNone;
}
-DisplayError HWCSink::Refresh() {
+DisplayError HWCDisplay::Refresh() {
if (*hwc_procs_) {
(*hwc_procs_)->invalidate(*hwc_procs_);
}
@@ -159,7 +160,7 @@
return kErrorNone;
}
-int HWCSink::AllocateLayerStack(hwc_display_contents_1_t *content_list) {
+int HWCDisplay::AllocateLayerStack(hwc_display_contents_1_t *content_list) {
size_t num_hw_layers = content_list->numHwLayers;
// Allocate memory for a) total number of layers b) buffer handle for each layer c) number of
@@ -220,7 +221,7 @@
return 0;
}
-int HWCSink::PrepareLayerStack(hwc_display_contents_1_t *content_list) {
+int HWCDisplay::PrepareLayerStack(hwc_display_contents_1_t *content_list) {
size_t num_hw_layers = content_list->numHwLayers;
if (UNLIKELY(num_hw_layers <= 1)) {
return 0;
@@ -282,7 +283,7 @@
// Configure layer stack
layer_stack_.flags.geometry_changed = ((content_list->flags & HWC_GEOMETRY_CHANGED) > 0);
- DisplayError error = device_intf_->Prepare(&layer_stack_);
+ DisplayError error = display_intf_->Prepare(&layer_stack_);
if (UNLIKELY(error != kErrorNone)) {
DLOGE("Prepare failed. Error = %d", error);
return -EINVAL;
@@ -304,7 +305,7 @@
return 0;
}
-void HWCSink::CacheLayerStackInfo(hwc_display_contents_1_t *content_list) {
+void HWCDisplay::CacheLayerStackInfo(hwc_display_contents_1_t *content_list) {
uint32_t layer_count = layer_stack_.layer_count;
for (size_t i = 0; i < layer_count; i++) {
@@ -315,7 +316,7 @@
layer_stack_cache_.layer_count = layer_count;
}
-bool HWCSink::NeedsFrameBufferRefresh(hwc_display_contents_1_t *content_list) {
+bool HWCDisplay::NeedsFrameBufferRefresh(hwc_display_contents_1_t *content_list) {
uint32_t layer_count = layer_stack_.layer_count;
// Frame buffer needs to be refreshed for the following reasons:
@@ -343,7 +344,7 @@
return false;
}
-int HWCSink::CommitLayerStack(hwc_display_contents_1_t *content_list) {
+int HWCDisplay::CommitLayerStack(hwc_display_contents_1_t *content_list) {
size_t num_hw_layers = content_list->numHwLayers;
if (UNLIKELY(num_hw_layers <= 1)) {
return 0;
@@ -356,7 +357,7 @@
layer_buffer->acquire_fence_fd = hwc_layer.acquireFenceFd;
}
- DisplayError error = device_intf_->Commit(&layer_stack_);
+ DisplayError error = display_intf_->Commit(&layer_stack_);
if (UNLIKELY(error != kErrorNone)) {
DLOGE("Commit failed. Error = %d", error);
return -EINVAL;
@@ -379,21 +380,21 @@
return 0;
}
-void HWCSink::SetRect(LayerRect *target, const hwc_rect_t &source) {
+void HWCDisplay::SetRect(LayerRect *target, const hwc_rect_t &source) {
target->left = FLOAT(source.left);
target->top = FLOAT(source.top);
target->right = FLOAT(source.right);
target->bottom = FLOAT(source.bottom);
}
-void HWCSink::SetRect(LayerRect *target, const hwc_frect_t &source) {
+void HWCDisplay::SetRect(LayerRect *target, const hwc_frect_t &source) {
target->left = source.left;
target->top = source.top;
target->right = source.right;
target->bottom = source.bottom;
}
-void HWCSink::SetComposition(LayerComposition *target, const int32_t &source) {
+void HWCDisplay::SetComposition(LayerComposition *target, const int32_t &source) {
switch (source) {
case HWC_FRAMEBUFFER_TARGET:
*target = kCompositionGPUTarget;
@@ -404,7 +405,7 @@
}
}
-void HWCSink::SetComposition(int32_t *target, const LayerComposition &source) {
+void HWCDisplay::SetComposition(int32_t *target, const LayerComposition &source) {
switch (source) {
case kCompositionGPUTarget:
*target = HWC_FRAMEBUFFER_TARGET;
@@ -418,7 +419,7 @@
}
}
-void HWCSink::SetBlending(LayerBlending *target, const int32_t &source) {
+void HWCDisplay::SetBlending(LayerBlending *target, const int32_t &source) {
switch (source) {
case HWC_BLENDING_PREMULT:
*target = kBlendingPremultiplied;
@@ -432,7 +433,7 @@
}
}
-int HWCSink::SetFormat(LayerBufferFormat *target, const int &source) {
+int HWCDisplay::SetFormat(LayerBufferFormat *target, const int &source) {
switch (source) {
case HAL_PIXEL_FORMAT_RGBA_8888:
*target = kFormatRGBA8888;
diff --git a/displayengine/libs/hwc/hwc_sink.h b/displayengine/libs/hwc/hwc_display.h
similarity index 89%
rename from displayengine/libs/hwc/hwc_sink.h
rename to displayengine/libs/hwc/hwc_display.h
index 551a77b..67356af 100644
--- a/displayengine/libs/hwc/hwc_sink.h
+++ b/displayengine/libs/hwc/hwc_display.h
@@ -22,15 +22,15 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#ifndef __HWC_SINK_H__
-#define __HWC_SINK_H__
+#ifndef __HWC_DISPLAY_H__
+#define __HWC_DISPLAY_H__
#include <hardware/hwcomposer.h>
#include <core/core_interface.h>
namespace sde {
-class HWCSink : public DeviceEventHandler {
+class HWCDisplay : public DisplayEventHandler {
public:
virtual int Init();
virtual int Deinit();
@@ -40,7 +40,7 @@
virtual int Blank(int blank);
virtual int GetDisplayConfigs(uint32_t *configs, size_t *num_configs);
virtual int GetDisplayAttributes(uint32_t config, const uint32_t *attributes, int32_t *values);
- int SetState(DeviceState state);
+ int SetState(DisplayState state);
protected:
// Maximum number of layers supported by display engine.
@@ -55,11 +55,11 @@
LayerStackMemory() : raw(NULL), size(0) { }
};
- HWCSink(CoreInterface *core_intf, hwc_procs_t const **hwc_procs, DeviceType type, int id);
- virtual ~HWCSink() { }
+ HWCDisplay(CoreInterface *core_intf, hwc_procs_t const **hwc_procs, DisplayType type, int id);
+ virtual ~HWCDisplay() { }
- // DeviceEventHandler methods
- virtual DisplayError VSync(const DeviceEventVSync &vsync);
+ // DisplayEventHandler methods
+ virtual DisplayError VSync(const DisplayEventVSync &vsync);
virtual DisplayError Refresh();
virtual int AllocateLayerStack(hwc_display_contents_1_t *content_list);
@@ -75,9 +75,9 @@
LayerStackMemory layer_stack_;
CoreInterface *core_intf_;
hwc_procs_t const **hwc_procs_;
- DeviceType type_;
+ DisplayType type_;
int id_;
- DeviceInterface *device_intf_;
+ DisplayInterface *display_intf_;
private:
struct LayerCache {
@@ -102,5 +102,5 @@
} // namespace sde
-#endif // __HWC_SINK_H__
+#endif // __HWC_DISPLAY_H__
diff --git a/displayengine/libs/hwc/hwc_sink_external.cpp b/displayengine/libs/hwc/hwc_display_external.cpp
similarity index 77%
copy from displayengine/libs/hwc/hwc_sink_external.cpp
copy to displayengine/libs/hwc/hwc_display_external.cpp
index d506194..369d286 100644
--- a/displayengine/libs/hwc/hwc_sink_external.cpp
+++ b/displayengine/libs/hwc/hwc_display_external.cpp
@@ -25,38 +25,38 @@
#include <utils/constants.h>
// HWC_MODULE_NAME definition must precede hwc_logger.h include.
-#define HWC_MODULE_NAME "HWCSinkExternal"
+#define HWC_MODULE_NAME "HWCDisplayExternal"
#include "hwc_logger.h"
-#include "hwc_sink_external.h"
+#include "hwc_display_external.h"
namespace sde {
-HWCSinkExternal::HWCSinkExternal(CoreInterface *core_intf, hwc_procs_t const **hwc_procs)
- : HWCSink(core_intf, hwc_procs, kHDMI, HWC_DISPLAY_EXTERNAL) {
+HWCDisplayExternal::HWCDisplayExternal(CoreInterface *core_intf, hwc_procs_t const **hwc_procs)
+ : HWCDisplay(core_intf, hwc_procs, kHDMI, HWC_DISPLAY_EXTERNAL) {
}
-int HWCSinkExternal::Init() {
+int HWCDisplayExternal::Init() {
return 0;
}
-int HWCSinkExternal::Deinit() {
+int HWCDisplayExternal::Deinit() {
return 0;
}
-int HWCSinkExternal::Prepare(hwc_display_contents_1_t *content_list) {
+int HWCDisplayExternal::Prepare(hwc_display_contents_1_t *content_list) {
return 0;
}
-int HWCSinkExternal::Commit(hwc_display_contents_1_t *content_list) {
+int HWCDisplayExternal::Commit(hwc_display_contents_1_t *content_list) {
return 0;
}
-int HWCSinkExternal::PowerOn() {
+int HWCDisplayExternal::PowerOn() {
return 0;
}
-int HWCSinkExternal::PowerOff() {
+int HWCDisplayExternal::PowerOff() {
return 0;
}
diff --git a/displayengine/libs/hwc/hwc_sink_external.h b/displayengine/libs/hwc/hwc_display_external.h
similarity index 87%
rename from displayengine/libs/hwc/hwc_sink_external.h
rename to displayengine/libs/hwc/hwc_display_external.h
index c0eab7f..012c653 100644
--- a/displayengine/libs/hwc/hwc_sink_external.h
+++ b/displayengine/libs/hwc/hwc_display_external.h
@@ -22,16 +22,16 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#ifndef __HWC_SINK_EXTERNAL_H__
-#define __HWC_SINK_EXTERNAL_H__
+#ifndef __HWC_DISPLAY_EXTERNAL_H__
+#define __HWC_DISPLAY_EXTERNAL_H__
-#include "hwc_sink.h"
+#include "hwc_display.h"
namespace sde {
-class HWCSinkExternal : public HWCSink {
+class HWCDisplayExternal : public HWCDisplay {
public:
- explicit HWCSinkExternal(CoreInterface *core_intf, hwc_procs_t const **hwc_procs);
+ explicit HWCDisplayExternal(CoreInterface *core_intf, hwc_procs_t const **hwc_procs);
virtual int Init();
virtual int Deinit();
virtual int Prepare(hwc_display_contents_1_t *content_list);
@@ -42,5 +42,5 @@
} // namespace sde
-#endif // __HWC_SINK_EXTERNAL_H__
+#endif // __HWC_DISPLAY_EXTERNAL_H__
diff --git a/displayengine/libs/hwc/hwc_sink_primary.cpp b/displayengine/libs/hwc/hwc_display_primary.cpp
similarity index 77%
rename from displayengine/libs/hwc/hwc_sink_primary.cpp
rename to displayengine/libs/hwc/hwc_display_primary.cpp
index a9b74bf..d0c0734 100644
--- a/displayengine/libs/hwc/hwc_sink_primary.cpp
+++ b/displayengine/libs/hwc/hwc_display_primary.cpp
@@ -25,26 +25,26 @@
#include <utils/constants.h>
// HWC_MODULE_NAME definition must precede hwc_logger.h include.
-#define HWC_MODULE_NAME "HWCSinkPrimary"
+#define HWC_MODULE_NAME "HWCDisplayPrimary"
#include "hwc_logger.h"
-#include "hwc_sink_primary.h"
+#include "hwc_display_primary.h"
namespace sde {
-HWCSinkPrimary::HWCSinkPrimary(CoreInterface *core_intf, hwc_procs_t const **hwc_procs)
- : HWCSink(core_intf, hwc_procs, kPrimary, HWC_DISPLAY_PRIMARY) {
+HWCDisplayPrimary::HWCDisplayPrimary(CoreInterface *core_intf, hwc_procs_t const **hwc_procs)
+ : HWCDisplay(core_intf, hwc_procs, kPrimary, HWC_DISPLAY_PRIMARY) {
}
-int HWCSinkPrimary::Init() {
- return HWCSink::Init();
+int HWCDisplayPrimary::Init() {
+ return HWCDisplay::Init();
}
-int HWCSinkPrimary::Deinit() {
- return HWCSink::Deinit();
+int HWCDisplayPrimary::Deinit() {
+ return HWCDisplay::Deinit();
}
-int HWCSinkPrimary::Prepare(hwc_display_contents_1_t *content_list) {
+int HWCDisplayPrimary::Prepare(hwc_display_contents_1_t *content_list) {
int status = 0;
status = AllocateLayerStack(content_list);
@@ -60,10 +60,10 @@
return 0;
}
-int HWCSinkPrimary::Commit(hwc_display_contents_1_t *content_list) {
+int HWCDisplayPrimary::Commit(hwc_display_contents_1_t *content_list) {
int status = 0;
- status = HWCSink::CommitLayerStack(content_list);
+ status = HWCDisplay::CommitLayerStack(content_list);
if (UNLIKELY(status)) {
return status;
}
@@ -73,11 +73,11 @@
return 0;
}
-int HWCSinkPrimary::PowerOn() {
+int HWCDisplayPrimary::PowerOn() {
return SetState(kStateOn);
}
-int HWCSinkPrimary::PowerOff() {
+int HWCDisplayPrimary::PowerOff() {
return SetState(kStateOff);
}
diff --git a/displayengine/libs/hwc/hwc_sink_virtual.h b/displayengine/libs/hwc/hwc_display_primary.h
similarity index 87%
copy from displayengine/libs/hwc/hwc_sink_virtual.h
copy to displayengine/libs/hwc/hwc_display_primary.h
index 381c1e3..cd8ae0f 100644
--- a/displayengine/libs/hwc/hwc_sink_virtual.h
+++ b/displayengine/libs/hwc/hwc_display_primary.h
@@ -22,16 +22,16 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#ifndef __HWC_SINK_VIRTUAL_H__
-#define __HWC_SINK_VIRTUAL_H__
+#ifndef __HWC_DISPLAY_PRIMARY_H__
+#define __HWC_DISPLAY_PRIMARY_H__
-#include "hwc_sink.h"
+#include "hwc_display.h"
namespace sde {
-class HWCSinkVirtual : public HWCSink {
+class HWCDisplayPrimary : public HWCDisplay {
public:
- explicit HWCSinkVirtual(CoreInterface *core_intf, hwc_procs_t const **hwc_procs);
+ explicit HWCDisplayPrimary(CoreInterface *core_intf, hwc_procs_t const **hwc_procs);
virtual int Init();
virtual int Deinit();
virtual int Prepare(hwc_display_contents_1_t *content_list);
@@ -42,5 +42,5 @@
} // namespace sde
-#endif // __HWC_SINK_VIRTUAL_H__
+#endif // __HWC_DISPLAY_PRIMARY_H__
diff --git a/displayengine/libs/hwc/hwc_sink_external.cpp b/displayengine/libs/hwc/hwc_display_virtual.cpp
similarity index 77%
rename from displayengine/libs/hwc/hwc_sink_external.cpp
rename to displayengine/libs/hwc/hwc_display_virtual.cpp
index d506194..62e4d2f 100644
--- a/displayengine/libs/hwc/hwc_sink_external.cpp
+++ b/displayengine/libs/hwc/hwc_display_virtual.cpp
@@ -25,38 +25,38 @@
#include <utils/constants.h>
// HWC_MODULE_NAME definition must precede hwc_logger.h include.
-#define HWC_MODULE_NAME "HWCSinkExternal"
+#define HWC_MODULE_NAME "HWCDisplayVirtual"
#include "hwc_logger.h"
-#include "hwc_sink_external.h"
+#include "hwc_display_virtual.h"
namespace sde {
-HWCSinkExternal::HWCSinkExternal(CoreInterface *core_intf, hwc_procs_t const **hwc_procs)
- : HWCSink(core_intf, hwc_procs, kHDMI, HWC_DISPLAY_EXTERNAL) {
+HWCDisplayVirtual::HWCDisplayVirtual(CoreInterface *core_intf, hwc_procs_t const **hwc_procs)
+ : HWCDisplay(core_intf, hwc_procs, kVirtual, HWC_DISPLAY_VIRTUAL) {
}
-int HWCSinkExternal::Init() {
+int HWCDisplayVirtual::Init() {
return 0;
}
-int HWCSinkExternal::Deinit() {
+int HWCDisplayVirtual::Deinit() {
return 0;
}
-int HWCSinkExternal::Prepare(hwc_display_contents_1_t *content_list) {
+int HWCDisplayVirtual::Prepare(hwc_display_contents_1_t *content_list) {
return 0;
}
-int HWCSinkExternal::Commit(hwc_display_contents_1_t *content_list) {
+int HWCDisplayVirtual::Commit(hwc_display_contents_1_t *content_list) {
return 0;
}
-int HWCSinkExternal::PowerOn() {
+int HWCDisplayVirtual::PowerOn() {
return 0;
}
-int HWCSinkExternal::PowerOff() {
+int HWCDisplayVirtual::PowerOff() {
return 0;
}
diff --git a/displayengine/libs/hwc/hwc_sink_virtual.h b/displayengine/libs/hwc/hwc_display_virtual.h
similarity index 87%
rename from displayengine/libs/hwc/hwc_sink_virtual.h
rename to displayengine/libs/hwc/hwc_display_virtual.h
index 381c1e3..6159425 100644
--- a/displayengine/libs/hwc/hwc_sink_virtual.h
+++ b/displayengine/libs/hwc/hwc_display_virtual.h
@@ -22,16 +22,16 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#ifndef __HWC_SINK_VIRTUAL_H__
-#define __HWC_SINK_VIRTUAL_H__
+#ifndef __HWC_DISPLAY_VIRTUAL_H__
+#define __HWC_DISPLAY_VIRTUAL_H__
-#include "hwc_sink.h"
+#include "hwc_display.h"
namespace sde {
-class HWCSinkVirtual : public HWCSink {
+class HWCDisplayVirtual : public HWCDisplay {
public:
- explicit HWCSinkVirtual(CoreInterface *core_intf, hwc_procs_t const **hwc_procs);
+ explicit HWCDisplayVirtual(CoreInterface *core_intf, hwc_procs_t const **hwc_procs);
virtual int Init();
virtual int Deinit();
virtual int Prepare(hwc_display_contents_1_t *content_list);
@@ -42,5 +42,5 @@
} // namespace sde
-#endif // __HWC_SINK_VIRTUAL_H__
+#endif // __HWC_DISPLAY_VIRTUAL_H__
diff --git a/displayengine/libs/hwc/hwc_session.cpp b/displayengine/libs/hwc/hwc_session.cpp
index 9dfa920..9749fb1 100644
--- a/displayengine/libs/hwc/hwc_session.cpp
+++ b/displayengine/libs/hwc/hwc_session.cpp
@@ -77,24 +77,24 @@
int status = -EINVAL;
// Create and power on primary display
- sink_primary_ = new HWCSinkPrimary(core_intf_, &hwc_procs_);
- if (UNLIKELY(!sink_primary_)) {
+ display_primary_ = new HWCDisplayPrimary(core_intf_, &hwc_procs_);
+ if (UNLIKELY(!display_primary_)) {
CoreInterface::DestroyCore();
return -ENOMEM;
}
- status = sink_primary_->Init();
+ status = display_primary_->Init();
if (UNLIKELY(status)) {
CoreInterface::DestroyCore();
- delete sink_primary_;
+ delete display_primary_;
return status;
}
- status = sink_primary_->PowerOn();
+ status = display_primary_->PowerOn();
if (UNLIKELY(status)) {
CoreInterface::DestroyCore();
- sink_primary_->Deinit();
- delete sink_primary_;
+ display_primary_->Deinit();
+ delete display_primary_;
return status;
}
@@ -102,9 +102,9 @@
}
int HWCSession::Deinit() {
- sink_primary_->PowerOff();
- sink_primary_->Deinit();
- delete sink_primary_;
+ display_primary_->PowerOff();
+ display_primary_->Deinit();
+ delete display_primary_;
DisplayError error = CoreInterface::DestroyCore();
if (error != kErrorNone) {
@@ -173,7 +173,7 @@
switch (i) {
case HWC_DISPLAY_PRIMARY:
- status = hwc_session->sink_primary_->Prepare(content_list);
+ status = hwc_session->display_primary_->Prepare(content_list);
break;
default:
status = -EINVAL;
@@ -207,7 +207,7 @@
switch (i) {
case HWC_DISPLAY_PRIMARY:
- status = hwc_session->sink_primary_->Commit(content_list);
+ status = hwc_session->display_primary_->Commit(content_list);
break;
default:
status = -EINVAL;
@@ -233,7 +233,7 @@
switch (disp) {
case HWC_DISPLAY_PRIMARY:
- status = hwc_session->sink_primary_->EventControl(event, enable);
+ status = hwc_session->display_primary_->EventControl(event, enable);
break;
default:
status = -EINVAL;
@@ -254,7 +254,7 @@
switch (disp) {
case HWC_DISPLAY_PRIMARY:
- status = hwc_session->sink_primary_->Blank(blank);
+ status = hwc_session->display_primary_->Blank(blank);
break;
default:
status = -EINVAL;
@@ -301,7 +301,7 @@
switch (disp) {
case HWC_DISPLAY_PRIMARY:
- status = hwc_session->sink_primary_->GetDisplayConfigs(configs, num_configs);
+ status = hwc_session->display_primary_->GetDisplayConfigs(configs, num_configs);
break;
default:
status = -EINVAL;
@@ -321,7 +321,7 @@
switch (disp) {
case HWC_DISPLAY_PRIMARY:
- status = hwc_session->sink_primary_->GetDisplayAttributes(config, attributes, values);
+ status = hwc_session->display_primary_->GetDisplayAttributes(config, attributes, values);
break;
default:
status = -EINVAL;
diff --git a/displayengine/libs/hwc/hwc_session.h b/displayengine/libs/hwc/hwc_session.h
index 8390459..6b3346b 100644
--- a/displayengine/libs/hwc/hwc_session.h
+++ b/displayengine/libs/hwc/hwc_session.h
@@ -29,7 +29,7 @@
#include <core/core_interface.h>
#include <utils/locker.h>
-#include "hwc_sink_primary.h"
+#include "hwc_display_primary.h"
namespace sde {
@@ -69,7 +69,7 @@
static Locker locker_;
CoreInterface *core_intf_;
hwc_procs_t const *hwc_procs_;
- HWCSinkPrimary *sink_primary_;
+ HWCDisplayPrimary *display_primary_;
};
} // namespace sde
diff --git a/displayengine/libs/hwc/hwc_sink_primary.h b/displayengine/libs/hwc/hwc_sink_primary.h
deleted file mode 100644
index f16c5a6..0000000
--- a/displayengine/libs/hwc/hwc_sink_primary.h
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
-* 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 __HWC_SINK_PRIMARY_H__
-#define __HWC_SINK_PRIMARY_H__
-
-#include "hwc_sink.h"
-
-namespace sde {
-
-class HWCSinkPrimary : public HWCSink {
- public:
- explicit HWCSinkPrimary(CoreInterface *core_intf, hwc_procs_t const **hwc_procs);
- virtual int Init();
- virtual int Deinit();
- virtual int Prepare(hwc_display_contents_1_t *content_list);
- virtual int Commit(hwc_display_contents_1_t *content_list);
- virtual int PowerOn();
- virtual int PowerOff();
-};
-
-} // namespace sde
-
-#endif // __HWC_SINK_PRIMARY_H__
-
diff --git a/displayengine/libs/hwc/hwc_sink_virtual.cpp b/displayengine/libs/hwc/hwc_sink_virtual.cpp
deleted file mode 100644
index 49334a3..0000000
--- a/displayengine/libs/hwc/hwc_sink_virtual.cpp
+++ /dev/null
@@ -1,64 +0,0 @@
-/*
-* 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.
-*/
-
-#include <utils/constants.h>
-
-// HWC_MODULE_NAME definition must precede hwc_logger.h include.
-#define HWC_MODULE_NAME "HWCSinkVirtual"
-#include "hwc_logger.h"
-
-#include "hwc_sink_virtual.h"
-
-namespace sde {
-
-HWCSinkVirtual::HWCSinkVirtual(CoreInterface *core_intf, hwc_procs_t const **hwc_procs)
- : HWCSink(core_intf, hwc_procs, kVirtual, HWC_DISPLAY_VIRTUAL) {
-}
-
-int HWCSinkVirtual::Init() {
- return 0;
-}
-
-int HWCSinkVirtual::Deinit() {
- return 0;
-}
-
-int HWCSinkVirtual::Prepare(hwc_display_contents_1_t *content_list) {
- return 0;
-}
-
-int HWCSinkVirtual::Commit(hwc_display_contents_1_t *content_list) {
- return 0;
-}
-
-int HWCSinkVirtual::PowerOn() {
- return 0;
-}
-
-int HWCSinkVirtual::PowerOff() {
- return 0;
-}
-
-} // namespace sde
-