#include "DrmHwcTwo.h"
+#include <fcntl.h>
#include <hardware/hardware.h>
#include <hardware/hwcomposer2.h>
#include <sync/sync.h>
+#include <unistd.h>
#include <cinttypes>
#include <iostream>
HWC2::Error DrmHwcTwo::CreateDisplay(hwc2_display_t displ,
HWC2::DisplayType type) {
- DrmDevice *drm = resource_manager_.GetDrmDevice(displ);
- std::shared_ptr<Importer> importer = resource_manager_.GetImporter(displ);
- if (!drm || !importer) {
- ALOGE("Failed to get a valid drmresource and importer");
+ DrmDevice *drm = resource_manager_.GetDrmDevice(static_cast<int>(displ));
+ if (!drm) {
+ ALOGE("Failed to get a valid drmresource");
return HWC2::Error::NoResources;
}
displays_.emplace(std::piecewise_construct, std::forward_as_tuple(displ),
- std::forward_as_tuple(&resource_manager_, drm, importer,
- displ, type));
+ std::forward_as_tuple(&resource_manager_, drm, displ, type,
+ this));
DrmCrtc *crtc = drm->GetCrtcForDisplay(static_cast<int>(displ));
if (!crtc) {
}
}
- const auto &drm_devices = resource_manager_.getDrmDevices();
- for (const auto &device : drm_devices) {
- // NOLINTNEXTLINE(cppcoreguidelines-owning-memory)
- device->RegisterHotplugHandler(new DrmHotplugHandler(this, device.get()));
- }
- return ret;
-}
-
-template <typename... Args>
-static inline HWC2::Error unsupported(char const *func, Args... /*args*/) {
- ALOGV("Unsupported function: %s", func);
- return HWC2::Error::Unsupported;
-}
+ resource_manager_.GetUEventListener()->RegisterHotplugHandler(
+ [this] { HandleHotplugUEvent(); });
-static inline void supported(char const *func) {
- ALOGV("Supported function: %s", func);
+ return ret;
}
-HWC2::Error DrmHwcTwo::CreateVirtualDisplay(uint32_t width, uint32_t height,
- int32_t *format,
- hwc2_display_t *display) {
+HWC2::Error DrmHwcTwo::CreateVirtualDisplay(uint32_t /*width*/,
+ uint32_t /*height*/,
+ int32_t * /*format*/,
+ hwc2_display_t * /*display*/) {
// TODO(nobody): Implement virtual display
- return unsupported(__func__, width, height, format, display);
+ return HWC2::Error::Unsupported;
}
-HWC2::Error DrmHwcTwo::DestroyVirtualDisplay(hwc2_display_t display) {
+HWC2::Error DrmHwcTwo::DestroyVirtualDisplay(hwc2_display_t /*display*/) {
// TODO(nobody): Implement virtual display
- return unsupported(__func__, display);
+ return HWC2::Error::Unsupported;
}
std::string DrmHwcTwo::HwcDisplay::DumpDelta(
}
std::string DrmHwcTwo::HwcDisplay::Dump() {
+ std::string flattening_state_str;
+ switch (flattenning_state_) {
+ case ClientFlattenningState::Disabled:
+ flattening_state_str = "Disabled";
+ break;
+ case ClientFlattenningState::NotRequired:
+ flattening_state_str = "Not needed";
+ break;
+ case ClientFlattenningState::Flattened:
+ flattening_state_str = "Active";
+ break;
+ case ClientFlattenningState::ClientRefreshRequested:
+ flattening_state_str = "Refresh requested";
+ break;
+ default:
+ flattening_state_str = std::to_string(flattenning_state_) +
+ " VSync remains";
+ }
+
std::stringstream ss;
ss << "- Display on: " << connector_->name() << "\n"
- << " Flattening state: " << compositor_.GetFlatteningState() << "\n"
+ << " Flattening state: " << flattening_state_str << "\n"
<< "Statistics since system boot:\n"
<< DumpDelta(total_stats_) << "\n\n"
<< "Statistics since last dumpsys request:\n"
}
void DrmHwcTwo::Dump(uint32_t *outSize, char *outBuffer) {
- supported(__func__);
-
if (outBuffer != nullptr) {
auto copied_bytes = mDumpString.copy(outBuffer, *outSize);
*outSize = static_cast<uint32_t>(copied_bytes);
uint32_t DrmHwcTwo::GetMaxVirtualDisplayCount() {
// TODO(nobody): Implement virtual display
- unsupported(__func__);
return 0;
}
HWC2::Error DrmHwcTwo::RegisterCallback(int32_t descriptor,
hwc2_callback_data_t data,
hwc2_function_pointer_t function) {
- supported(__func__);
+ std::unique_lock<std::mutex> lock(callback_lock_);
switch (static_cast<HWC2::Callback>(descriptor)) {
case HWC2::Callback::Hotplug: {
- SetHotplugCallback(data, function);
+ hotplug_callback_ = std::make_pair(HWC2_PFN_HOTPLUG(function), data);
+ lock.unlock();
const auto &drm_devices = resource_manager_.getDrmDevices();
for (const auto &device : drm_devices)
HandleInitialHotplugState(device.get());
break;
}
case HWC2::Callback::Refresh: {
- for (std::pair<const hwc2_display_t, DrmHwcTwo::HwcDisplay> &d :
- displays_)
- d.second.RegisterRefreshCallback(data, function);
+ refresh_callback_ = std::make_pair(HWC2_PFN_REFRESH(function), data);
break;
}
case HWC2::Callback::Vsync: {
- for (std::pair<const hwc2_display_t, DrmHwcTwo::HwcDisplay> &d :
- displays_)
- d.second.RegisterVsyncCallback(data, function);
+ vsync_callback_ = std::make_pair(HWC2_PFN_VSYNC(function), data);
+ break;
+ }
+#if PLATFORM_SDK_VERSION > 29
+ case HWC2::Callback::Vsync_2_4: {
+ vsync_2_4_callback_ = std::make_pair(HWC2_PFN_VSYNC_2_4(function), data);
break;
}
+#endif
default:
break;
}
}
DrmHwcTwo::HwcDisplay::HwcDisplay(ResourceManager *resource_manager,
- DrmDevice *drm,
- std::shared_ptr<Importer> importer,
- hwc2_display_t handle, HWC2::DisplayType type)
- : resource_manager_(resource_manager),
+ DrmDevice *drm, hwc2_display_t handle,
+ HWC2::DisplayType type, DrmHwcTwo *hwc2)
+ : hwc2_(hwc2),
+ resource_manager_(resource_manager),
drm_(drm),
- importer_(std::move(importer)),
handle_(handle),
type_(type),
color_transform_hint_(HAL_COLOR_TRANSFORM_IDENTITY) {
- supported(__func__);
-
// clang-format off
color_transform_matrix_ = {1.0, 0.0, 0.0, 0.0,
0.0, 1.0, 0.0, 0.0,
}
void DrmHwcTwo::HwcDisplay::ClearDisplay() {
- compositor_.ClearDisplay();
+ AtomicCommitArgs a_args = {.clear_active_composition = true};
+ compositor_.ExecuteAtomicCommit(a_args);
}
HWC2::Error DrmHwcTwo::HwcDisplay::Init(std::vector<DrmPlane *> *planes) {
- supported(__func__);
planner_ = Planner::CreateInstance(drm_);
if (!planner_) {
ALOGE("Failed to create planner instance for composition");
return HWC2::Error::BadDisplay;
}
- ret = vsync_worker_.Init(drm_, display);
+ ret = vsync_worker_.Init(drm_, display, [this](int64_t timestamp) {
+ const std::lock_guard<std::mutex> lock(hwc2_->callback_lock_);
+ /* vsync callback */
+#if PLATFORM_SDK_VERSION > 29
+ if (hwc2_->vsync_2_4_callback_.first != nullptr &&
+ hwc2_->vsync_2_4_callback_.second != nullptr) {
+ hwc2_vsync_period_t period_ns{};
+ GetDisplayVsyncPeriod(&period_ns);
+ hwc2_->vsync_2_4_callback_.first(hwc2_->vsync_2_4_callback_.second,
+ handle_, timestamp, period_ns);
+ } else
+#endif
+ if (hwc2_->vsync_callback_.first != nullptr &&
+ hwc2_->vsync_callback_.second != nullptr) {
+ hwc2_->vsync_callback_.first(hwc2_->vsync_callback_.second, handle_,
+ timestamp);
+ }
+ });
+ if (ret) {
+ ALOGE("Failed to create event worker for d=%d %d\n", display, ret);
+ return HWC2::Error::BadDisplay;
+ }
+
+ ret = flattening_vsync_worker_.Init(drm_, display, [this](int64_t /*timestamp*/) {
+ const std::lock_guard<std::mutex> lock(hwc2_->callback_lock_);
+ /* Frontend flattening */
+ if (flattenning_state_ > ClientFlattenningState::ClientRefreshRequested &&
+ --flattenning_state_ ==
+ ClientFlattenningState::ClientRefreshRequested &&
+ hwc2_->refresh_callback_.first != nullptr &&
+ hwc2_->refresh_callback_.second != nullptr) {
+ hwc2_->refresh_callback_.first(hwc2_->refresh_callback_.second, handle_);
+ flattening_vsync_worker_.VSyncControl(false);
+ }
+ });
if (ret) {
ALOGE("Failed to create event worker for d=%d %d\n", display, ret);
return HWC2::Error::BadDisplay;
return HWC2::Error::BadDisplay;
}
+ client_layer_.SetLayerBlendMode(HWC2_BLEND_MODE_PREMULTIPLIED);
+
return ChosePreferredConfig();
}
uint32_t num_configs = 0;
HWC2::Error err = GetDisplayConfigs(&num_configs, nullptr);
if (err != HWC2::Error::None || !num_configs)
- return err;
-
- return SetActiveConfig(connector_->get_preferred_mode_id());
-}
-
-void DrmHwcTwo::HwcDisplay::RegisterVsyncCallback(
- hwc2_callback_data_t data, hwc2_function_pointer_t func) {
- supported(__func__);
- vsync_worker_.RegisterClientCallback(data, func);
-}
+ return HWC2::Error::BadDisplay;
-void DrmHwcTwo::HwcDisplay::RegisterRefreshCallback(
- hwc2_callback_data_t data, hwc2_function_pointer_t func) {
- supported(__func__);
- compositor_.SetRefreshCallback(data, func);
+ return SetActiveConfig(preferred_config_id_);
}
HWC2::Error DrmHwcTwo::HwcDisplay::AcceptDisplayChanges() {
- supported(__func__);
for (std::pair<const hwc2_layer_t, DrmHwcTwo::HwcLayer> &l : layers_)
l.second.accept_type_change();
return HWC2::Error::None;
}
HWC2::Error DrmHwcTwo::HwcDisplay::CreateLayer(hwc2_layer_t *layer) {
- supported(__func__);
layers_.emplace(static_cast<hwc2_layer_t>(layer_idx_), HwcLayer());
*layer = static_cast<hwc2_layer_t>(layer_idx_);
++layer_idx_;
}
HWC2::Error DrmHwcTwo::HwcDisplay::DestroyLayer(hwc2_layer_t layer) {
- supported(__func__);
if (!get_layer(layer))
return HWC2::Error::BadLayer;
return HWC2::Error::None;
}
-HWC2::Error DrmHwcTwo::HwcDisplay::GetActiveConfig(hwc2_config_t *config) {
- supported(__func__);
- DrmMode const &mode = connector_->active_mode();
- if (mode.id() == 0)
+HWC2::Error DrmHwcTwo::HwcDisplay::GetActiveConfig(
+ hwc2_config_t *config) const {
+ if (hwc_configs_.count(active_config_id_) == 0)
return HWC2::Error::BadConfig;
- *config = mode.id();
+ *config = active_config_id_;
return HWC2::Error::None;
}
HWC2::Error DrmHwcTwo::HwcDisplay::GetChangedCompositionTypes(
uint32_t *num_elements, hwc2_layer_t *layers, int32_t *types) {
- supported(__func__);
uint32_t num_changes = 0;
for (std::pair<const hwc2_layer_t, DrmHwcTwo::HwcLayer> &l : layers_) {
if (l.second.type_changed()) {
uint32_t height,
int32_t /*format*/,
int32_t dataspace) {
- supported(__func__);
std::pair<uint32_t, uint32_t> min = drm_->min_resolution();
std::pair<uint32_t, uint32_t> max = drm_->max_resolution();
HWC2::Error DrmHwcTwo::HwcDisplay::GetColorModes(uint32_t *num_modes,
int32_t *modes) {
- supported(__func__);
if (!modes)
*num_modes = 1;
HWC2::Error DrmHwcTwo::HwcDisplay::GetDisplayAttribute(hwc2_config_t config,
int32_t attribute_in,
int32_t *value) {
- supported(__func__);
- auto mode = std::find_if(connector_->modes().begin(),
- connector_->modes().end(),
- [config](DrmMode const &m) {
- return m.id() == config;
- });
- if (mode == connector_->modes().end()) {
- ALOGE("Could not find active mode for %d", config);
+ int conf = static_cast<int>(config);
+
+ if (hwc_configs_.count(conf) == 0) {
+ ALOGE("Could not find active mode for %d", conf);
return HWC2::Error::BadConfig;
}
+ auto &hwc_config = hwc_configs_[conf];
+
static const int32_t kUmPerInch = 25400;
uint32_t mm_width = connector_->mm_width();
uint32_t mm_height = connector_->mm_height();
auto attribute = static_cast<HWC2::Attribute>(attribute_in);
switch (attribute) {
case HWC2::Attribute::Width:
- *value = mode->h_display();
+ *value = static_cast<int>(hwc_config.mode.h_display());
break;
case HWC2::Attribute::Height:
- *value = mode->v_display();
+ *value = static_cast<int>(hwc_config.mode.v_display());
break;
case HWC2::Attribute::VsyncPeriod:
// in nanoseconds
- *value = 1000.0 * 1000.0 * 1000.0 / mode->v_refresh();
+ *value = static_cast<int>(1E9 / hwc_config.mode.v_refresh());
break;
case HWC2::Attribute::DpiX:
// Dots per 1000 inches
- *value = mm_width ? (mode->h_display() * kUmPerInch) / mm_width : -1;
+ *value = mm_width ? static_cast<int>(hwc_config.mode.h_display() *
+ kUmPerInch / mm_width)
+ : -1;
break;
case HWC2::Attribute::DpiY:
// Dots per 1000 inches
- *value = mm_height ? (mode->v_display() * kUmPerInch) / mm_height : -1;
+ *value = mm_height ? static_cast<int>(hwc_config.mode.v_display() *
+ kUmPerInch / mm_height)
+ : -1;
break;
#if PLATFORM_SDK_VERSION > 29
case HWC2::Attribute::ConfigGroup:
- *value = 0; /* TODO: Add support for config groups */
+ /* Dispite ConfigGroup is a part of HWC2.4 API, framework
+ * able to request it even if service @2.1 is used */
+ *value = hwc_config.group_id;
break;
#endif
default:
return HWC2::Error::None;
}
+// NOLINTNEXTLINE (readability-function-cognitive-complexity): Fixme
HWC2::Error DrmHwcTwo::HwcDisplay::GetDisplayConfigs(uint32_t *num_configs,
hwc2_config_t *configs) {
- supported(__func__);
// Since this callback is normally invoked twice (once to get the count, and
// once to populate configs), we don't really want to read the edid
// redundantly. Instead, only update the modes on the first invocation. While
ALOGE("Failed to update display modes %d", ret);
return HWC2::Error::BadDisplay;
}
- }
- // Since the upper layers only look at vactive/hactive/refresh, height and
- // width, it doesn't differentiate interlaced from progressive and other
- // similar modes. Depending on the order of modes we return to SF, it could
- // end up choosing a suboptimal configuration and dropping the preferred
- // mode. To workaround this, don't offer interlaced modes to SF if there is
- // at least one non-interlaced alternative and only offer a single WxH@R
- // mode with at least the prefered mode from in DrmConnector::UpdateModes()
-
- // TODO(nobody): Remove the following block of code until AOSP handles all
- // modes
- std::vector<DrmMode> sel_modes;
-
- // Add the preferred mode first to be sure it's not dropped
- auto mode = std::find_if(connector_->modes().begin(),
- connector_->modes().end(), [&](DrmMode const &m) {
- return m.id() ==
- connector_->get_preferred_mode_id();
- });
- if (mode != connector_->modes().end())
- sel_modes.push_back(*mode);
-
- // Add the active mode if different from preferred mode
- if (connector_->active_mode().id() != connector_->get_preferred_mode_id())
- sel_modes.push_back(connector_->active_mode());
-
- // Cycle over the modes and filter out "similar" modes, keeping only the
- // first ones in the order given by DRM (from CEA ids and timings order)
- for (const DrmMode &mode : connector_->modes()) {
- // TODO(nobody): Remove this when 3D Attributes are in AOSP
- if (mode.flags() & DRM_MODE_FLAG_3D_MASK)
- continue;
+ hwc_configs_.clear();
+ preferred_config_id_ = 0;
+ int preferred_config_group_id_ = 0;
- // TODO(nobody): Remove this when the Interlaced attribute is in AOSP
- if (mode.flags() & DRM_MODE_FLAG_INTERLACE) {
- auto m = std::find_if(connector_->modes().begin(),
- connector_->modes().end(),
- [&mode](DrmMode const &m) {
- return !(m.flags() & DRM_MODE_FLAG_INTERLACE) &&
- m.h_display() == mode.h_display() &&
- m.v_display() == mode.v_display();
- });
- if (m == connector_->modes().end())
- sel_modes.push_back(mode);
+ if (connector_->modes().empty()) {
+ ALOGE("No modes reported by KMS");
+ return HWC2::Error::BadDisplay;
+ }
- continue;
+ int last_config_id = 1;
+ int last_group_id = 1;
+
+ /* Group modes */
+ for (const auto &mode : connector_->modes()) {
+ /* Find group for the new mode or create new group */
+ int group_found = 0;
+ for (auto &hwc_config : hwc_configs_) {
+ if (mode.h_display() == hwc_config.second.mode.h_display() &&
+ mode.v_display() == hwc_config.second.mode.v_display()) {
+ group_found = hwc_config.second.group_id;
+ }
+ }
+ if (group_found == 0) {
+ group_found = last_group_id++;
+ }
+
+ bool disabled = false;
+ if (mode.flags() & DRM_MODE_FLAG_3D_MASK) {
+ ALOGI("Disabling display mode %s (Modes with 3D flag aren't supported)",
+ mode.name().c_str());
+ disabled = true;
+ }
+
+ /* Add config */
+ hwc_configs_[last_config_id] = {
+ .id = last_config_id,
+ .group_id = group_found,
+ .mode = mode,
+ .disabled = disabled,
+ };
+
+ /* Chwck if the mode is preferred */
+ if ((mode.type() & DRM_MODE_TYPE_PREFERRED) != 0 &&
+ preferred_config_id_ == 0) {
+ preferred_config_id_ = last_config_id;
+ preferred_config_group_id_ = group_found;
+ }
+
+ last_config_id++;
}
- // Search for a similar WxH@R mode in the filtered list and drop it if
- // another mode with the same WxH@R has already been selected
- // TODO(nobody): Remove this when AOSP handles duplicates modes
- auto m = std::find_if(sel_modes.begin(), sel_modes.end(),
- [&mode](DrmMode const &m) {
- return m.h_display() == mode.h_display() &&
- m.v_display() == mode.v_display() &&
- m.v_refresh() == mode.v_refresh();
- });
- if (m == sel_modes.end())
- sel_modes.push_back(mode);
- }
+ /* We must have preferred mode. Set first mode as preferred
+ * in case KMS haven't reported anything. */
+ if (preferred_config_id_ == 0) {
+ preferred_config_id_ = 1;
+ preferred_config_group_id_ = 1;
+ }
- auto num_modes = static_cast<uint32_t>(sel_modes.size());
- if (!configs) {
- *num_configs = num_modes;
- return HWC2::Error::None;
+ for (int group = 1; group < last_group_id; group++) {
+ bool has_interlaced = false;
+ bool has_progressive = false;
+ for (auto &hwc_config : hwc_configs_) {
+ if (hwc_config.second.group_id != group || hwc_config.second.disabled) {
+ continue;
+ }
+
+ if (hwc_config.second.IsInterlaced()) {
+ has_interlaced = true;
+ } else {
+ has_progressive = true;
+ }
+ }
+
+ bool has_both = has_interlaced && has_progressive;
+ if (!has_both) {
+ continue;
+ }
+
+ bool group_contains_preferred_interlaced = false;
+ if (group == preferred_config_group_id_ &&
+ hwc_configs_[preferred_config_id_].IsInterlaced()) {
+ group_contains_preferred_interlaced = true;
+ }
+
+ for (auto &hwc_config : hwc_configs_) {
+ if (hwc_config.second.group_id != group || hwc_config.second.disabled) {
+ continue;
+ }
+
+ bool disable = group_contains_preferred_interlaced
+ ? !hwc_config.second.IsInterlaced()
+ : hwc_config.second.IsInterlaced();
+
+ if (disable) {
+ ALOGI(
+ "Group %i: Disabling display mode %s (This group should consist "
+ "of %s modes)",
+ group, hwc_config.second.mode.name().c_str(),
+ group_contains_preferred_interlaced ? "interlaced"
+ : "progressive");
+
+ hwc_config.second.disabled = true;
+ }
+ }
+ }
+
+ /* Group should not contain 2 modes with FPS delta less than ~1HZ
+ * otherwise android.graphics.cts.SetFrameRateTest CTS will fail
+ */
+ for (int m1 = 1; m1 < last_config_id; m1++) {
+ for (int m2 = 1; m2 < last_config_id; m2++) {
+ if (m1 != m2 &&
+ hwc_configs_[m1].group_id == hwc_configs_[m2].group_id &&
+ !hwc_configs_[m1].disabled && !hwc_configs_[m2].disabled &&
+ fabsf(hwc_configs_[m1].mode.v_refresh() -
+ hwc_configs_[m2].mode.v_refresh()) < 1.0) {
+ ALOGI(
+ "Group %i: Disabling display mode %s (Refresh rate value is "
+ "too close to existing mode %s)",
+ hwc_configs_[m2].group_id, hwc_configs_[m2].mode.name().c_str(),
+ hwc_configs_[m1].mode.name().c_str());
+
+ hwc_configs_[m2].disabled = true;
+ }
+ }
+ }
}
uint32_t idx = 0;
- for (const DrmMode &mode : sel_modes) {
- if (idx >= *num_configs)
- break;
- configs[idx++] = mode.id();
+ for (auto &hwc_config : hwc_configs_) {
+ if (hwc_config.second.disabled) {
+ continue;
+ }
+
+ if (configs != nullptr) {
+ if (idx >= *num_configs) {
+ break;
+ }
+ configs[idx] = hwc_config.second.id;
+ }
+
+ idx++;
}
*num_configs = idx;
return HWC2::Error::None;
}
HWC2::Error DrmHwcTwo::HwcDisplay::GetDisplayName(uint32_t *size, char *name) {
- supported(__func__);
std::ostringstream stream;
stream << "display-" << connector_->id();
std::string string = stream.str();
return HWC2::Error::None;
}
-HWC2::Error DrmHwcTwo::HwcDisplay::GetDisplayRequests(int32_t *display_requests,
- uint32_t *num_elements,
- hwc2_layer_t *layers,
- int32_t *layer_requests) {
- supported(__func__);
+HWC2::Error DrmHwcTwo::HwcDisplay::GetDisplayRequests(
+ int32_t * /*display_requests*/, uint32_t *num_elements,
+ hwc2_layer_t * /*layers*/, int32_t * /*layer_requests*/) {
// TODO(nobody): I think virtual display should request
// HWC2_DISPLAY_REQUEST_WRITE_CLIENT_TARGET_TO_OUTPUT here
- unsupported(__func__, display_requests, num_elements, layers, layer_requests);
*num_elements = 0;
return HWC2::Error::None;
}
HWC2::Error DrmHwcTwo::HwcDisplay::GetDisplayType(int32_t *type) {
- supported(__func__);
*type = static_cast<int32_t>(type_);
return HWC2::Error::None;
}
HWC2::Error DrmHwcTwo::HwcDisplay::GetDozeSupport(int32_t *support) {
- supported(__func__);
*support = 0;
return HWC2::Error::None;
}
HWC2::Error DrmHwcTwo::HwcDisplay::GetHdrCapabilities(
uint32_t *num_types, int32_t * /*types*/, float * /*max_luminance*/,
float * /*max_average_luminance*/, float * /*min_luminance*/) {
- supported(__func__);
*num_types = 0;
return HWC2::Error::None;
}
+/* Find API details at:
+ * https://cs.android.com/android/platform/superproject/+/android-11.0.0_r3:hardware/libhardware/include/hardware/hwcomposer2.h;l=1767
+ */
HWC2::Error DrmHwcTwo::HwcDisplay::GetReleaseFences(uint32_t *num_elements,
hwc2_layer_t *layers,
int32_t *fences) {
- supported(__func__);
uint32_t num_layers = 0;
for (std::pair<const hwc2_layer_t, DrmHwcTwo::HwcLayer> &l : layers_) {
}
layers[num_layers - 1] = l.first;
- fences[num_layers - 1] = l.second.take_release_fence();
+ fences[num_layers - 1] = l.second.release_fence_.Release();
}
*num_elements = num_layers;
return HWC2::Error::None;
}
-void DrmHwcTwo::HwcDisplay::AddFenceToPresentFence(int fd) {
- if (fd < 0)
- return;
-
- if (present_fence_.get() >= 0) {
- int old_fence = present_fence_.get();
- present_fence_.Set(sync_merge("dc_present", old_fence, fd));
- close(fd);
- } else {
- present_fence_.Set(fd);
- }
-}
-
-bool DrmHwcTwo::HwcDisplay::HardwareSupportsLayerType(
- HWC2::Composition comp_type) {
- return comp_type == HWC2::Composition::Device ||
- comp_type == HWC2::Composition::Cursor;
-}
-
-HWC2::Error DrmHwcTwo::HwcDisplay::CreateComposition(bool test) {
+HWC2::Error DrmHwcTwo::HwcDisplay::CreateComposition(AtomicCommitArgs &a_args) {
// order the layers by z-order
bool use_client_layer = false;
uint32_t client_z_order = UINT32_MAX;
for (std::pair<const uint32_t, DrmHwcTwo::HwcLayer *> &l : z_map) {
DrmHwcLayer layer;
l.second->PopulateDrmLayer(&layer);
- int ret = layer.ImportBuffer(importer_.get());
+ int ret = layer.ImportBuffer(drm_);
if (ret) {
ALOGE("Failed to import layer, ret=%d", ret);
return HWC2::Error::NoResources;
composition_layers.emplace_back(std::move(layer));
}
- auto composition = std::make_unique<DrmDisplayComposition>(crtc_,
+ auto composition = std::make_shared<DrmDisplayComposition>(crtc_,
planner_.get());
// TODO(nobody): Don't always assume geometry changed
int ret = composition->SetLayers(composition_layers.data(),
- composition_layers.size(), true);
+ composition_layers.size());
if (ret) {
ALOGE("Failed to set layers in the composition ret=%d", ret);
return HWC2::Error::BadLayer;
std::vector<DrmPlane *> overlay_planes(overlay_planes_);
ret = composition->Plan(&primary_planes, &overlay_planes);
if (ret) {
- ALOGE("Failed to plan the composition ret=%d", ret);
+ ALOGV("Failed to plan the composition ret=%d", ret);
return HWC2::Error::BadConfig;
}
- // Disable the planes we're not using
- for (auto i = primary_planes.begin(); i != primary_planes.end();) {
- composition->AddPlaneDisable(*i);
- i = primary_planes.erase(i);
- }
- for (auto i = overlay_planes.begin(); i != overlay_planes.end();) {
- composition->AddPlaneDisable(*i);
- i = overlay_planes.erase(i);
- }
+ a_args.composition = composition;
+ ret = compositor_.ExecuteAtomicCommit(a_args);
- if (test) {
- ret = compositor_.TestComposition(composition.get());
- } else {
- ret = compositor_.ApplyComposition(std::move(composition));
- AddFenceToPresentFence(compositor_.TakeOutFence());
- }
if (ret) {
- if (!test)
+ if (!a_args.test_only)
ALOGE("Failed to apply the frame composition ret=%d", ret);
return HWC2::Error::BadParameter;
}
return HWC2::Error::None;
}
+/* Find API details at:
+ * https://cs.android.com/android/platform/superproject/+/android-11.0.0_r3:hardware/libhardware/include/hardware/hwcomposer2.h;l=1805
+ */
HWC2::Error DrmHwcTwo::HwcDisplay::PresentDisplay(int32_t *present_fence) {
- supported(__func__);
HWC2::Error ret;
++total_stats_.total_frames_;
- ret = CreateComposition(false);
+ AtomicCommitArgs a_args{};
+ ret = CreateComposition(a_args);
+
if (ret != HWC2::Error::None)
++total_stats_.failed_kms_present_;
if (ret != HWC2::Error::None)
return ret;
- *present_fence = present_fence_.Release();
+ *present_fence = a_args.out_fence.Release();
++frame_no_;
return HWC2::Error::None;
}
HWC2::Error DrmHwcTwo::HwcDisplay::SetActiveConfig(hwc2_config_t config) {
- supported(__func__);
- auto mode = std::find_if(connector_->modes().begin(),
- connector_->modes().end(),
- [config](DrmMode const &m) {
- return m.id() == config;
- });
- if (mode == connector_->modes().end()) {
- ALOGE("Could not find active mode for %d", config);
- return HWC2::Error::BadConfig;
- }
+ int conf = static_cast<int>(config);
- auto composition = std::make_unique<DrmDisplayComposition>(crtc_,
- planner_.get());
- int ret = composition->SetDisplayMode(*mode);
- if (ret) {
+ if (hwc_configs_.count(conf) == 0) {
+ ALOGE("Could not find active mode for %d", conf);
return HWC2::Error::BadConfig;
}
- ret = compositor_.ApplyComposition(std::move(composition));
- if (ret) {
- ALOGE("Failed to queue dpms composition on %d", ret);
+
+ auto &mode = hwc_configs_[conf].mode;
+
+ AtomicCommitArgs a_args = {
+ .display_mode = mode,
+ .clear_active_composition = true,
+ };
+
+ int err = compositor_.ExecuteAtomicCommit(a_args);
+ if (err != 0) {
+ ALOGE("Failed to queue mode changing commit %d", err);
return HWC2::Error::BadConfig;
}
- connector_->set_active_mode(*mode);
+ active_config_id_ = conf;
// Setup the client layer's dimensions
hwc_rect_t display_frame = {.left = 0,
.top = 0,
- .right = static_cast<int>(mode->h_display()),
- .bottom = static_cast<int>(mode->v_display())};
+ .right = static_cast<int>(mode.h_display()),
+ .bottom = static_cast<int>(mode.v_display())};
client_layer_.SetLayerDisplayFrame(display_frame);
return HWC2::Error::None;
}
+/* Find API details at:
+ * https://cs.android.com/android/platform/superproject/+/android-11.0.0_r3:hardware/libhardware/include/hardware/hwcomposer2.h;l=1861
+ */
HWC2::Error DrmHwcTwo::HwcDisplay::SetClientTarget(buffer_handle_t target,
int32_t acquire_fence,
int32_t dataspace,
hwc_region_t /*damage*/) {
- supported(__func__);
- UniqueFd uf(acquire_fence);
-
client_layer_.set_buffer(target);
- client_layer_.set_acquire_fence(uf.get());
+ client_layer_.acquire_fence_ = UniqueFd(acquire_fence);
client_layer_.SetLayerDataspace(dataspace);
/* TODO: Do not update source_crop every call.
hwc_frect_t source_crop = {.left = 0.0F,
.top = 0.0F,
- .right = bo.width + 0.0F,
- .bottom = bo.height + 0.0F};
+ .right = static_cast<float>(bo.width),
+ .bottom = static_cast<float>(bo.height)};
client_layer_.SetLayerSourceCrop(source_crop);
return HWC2::Error::None;
}
HWC2::Error DrmHwcTwo::HwcDisplay::SetColorMode(int32_t mode) {
- supported(__func__);
-
if (mode < HAL_COLOR_MODE_NATIVE || mode > HAL_COLOR_MODE_BT2100_HLG)
return HWC2::Error::BadParameter;
HWC2::Error DrmHwcTwo::HwcDisplay::SetColorTransform(const float *matrix,
int32_t hint) {
- supported(__func__);
if (hint < HAL_COLOR_TRANSFORM_IDENTITY ||
hint > HAL_COLOR_TRANSFORM_CORRECT_TRITANOPIA)
return HWC2::Error::BadParameter;
return HWC2::Error::None;
}
-HWC2::Error DrmHwcTwo::HwcDisplay::SetOutputBuffer(buffer_handle_t buffer,
- int32_t release_fence) {
- supported(__func__);
+HWC2::Error DrmHwcTwo::HwcDisplay::SetOutputBuffer(buffer_handle_t /*buffer*/,
+ int32_t /*release_fence*/) {
// TODO(nobody): Need virtual display support
- return unsupported(__func__, buffer, release_fence);
+ return HWC2::Error::Unsupported;
}
HWC2::Error DrmHwcTwo::HwcDisplay::SetPowerMode(int32_t mode_in) {
- supported(__func__);
- uint64_t dpms_value = 0;
auto mode = static_cast<HWC2::PowerMode>(mode_in);
+ AtomicCommitArgs a_args{};
+
switch (mode) {
case HWC2::PowerMode::Off:
- dpms_value = DRM_MODE_DPMS_OFF;
+ a_args.active = false;
break;
case HWC2::PowerMode::On:
- dpms_value = DRM_MODE_DPMS_ON;
+ a_args.active = true;
break;
case HWC2::PowerMode::Doze:
case HWC2::PowerMode::DozeSuspend:
return HWC2::Error::BadParameter;
};
- auto composition = std::make_unique<DrmDisplayComposition>(crtc_,
- planner_.get());
- composition->SetDpmsMode(dpms_value);
- int ret = compositor_.ApplyComposition(std::move(composition));
- if (ret) {
- ALOGE("Failed to apply the dpms composition ret=%d", ret);
+ int err = compositor_.ExecuteAtomicCommit(a_args);
+ if (err) {
+ ALOGE("Failed to apply the dpms composition err=%d", err);
return HWC2::Error::BadParameter;
}
return HWC2::Error::None;
}
HWC2::Error DrmHwcTwo::HwcDisplay::SetVsyncEnabled(int32_t enabled) {
- supported(__func__);
vsync_worker_.VSyncControl(HWC2_VSYNC_ENABLE == enabled);
return HWC2::Error::None;
}
-void DrmHwcTwo::HwcDisplay::MarkValidated(
- std::map<uint32_t, DrmHwcTwo::HwcLayer *> &z_map, size_t client_first_z,
- size_t client_size) {
- for (std::pair<const uint32_t, DrmHwcTwo::HwcLayer *> &l : z_map) {
- if (l.first >= client_first_z && l.first < client_first_z + client_size)
- l.second->set_validated_type(HWC2::Composition::Client);
- else
- l.second->set_validated_type(HWC2::Composition::Device);
- }
-}
-
HWC2::Error DrmHwcTwo::HwcDisplay::ValidateDisplay(uint32_t *num_types,
uint32_t *num_requests) {
- supported(__func__);
-
return backend_->ValidateDisplay(this, num_types, num_requests);
}
+std::vector<DrmHwcTwo::HwcLayer *>
+DrmHwcTwo::HwcDisplay::GetOrderLayersByZPos() {
+ std::vector<DrmHwcTwo::HwcLayer *> ordered_layers;
+ ordered_layers.reserve(layers_.size());
+
+ for (auto &[handle, layer] : layers_) {
+ ordered_layers.emplace_back(&layer);
+ }
+
+ std::sort(std::begin(ordered_layers), std::end(ordered_layers),
+ [](const DrmHwcTwo::HwcLayer *lhs, const DrmHwcTwo::HwcLayer *rhs) {
+ return lhs->z_order() < rhs->z_order();
+ });
+
+ return ordered_layers;
+}
+
#if PLATFORM_SDK_VERSION > 29
HWC2::Error DrmHwcTwo::HwcDisplay::GetDisplayConnectionType(uint32_t *outType) {
if (connector_->internal())
HWC2::Error DrmHwcTwo::HwcDisplay::GetDisplayVsyncPeriod(
hwc2_vsync_period_t *outVsyncPeriod /* ns */) {
- supported(__func__);
- DrmMode const &mode = connector_->active_mode();
- if (mode.id() == 0)
- return HWC2::Error::BadConfig;
-
- *outVsyncPeriod = 1E9 / mode.v_refresh();
- return HWC2::Error::None;
+ return GetDisplayAttribute(active_config_id_, HWC2_ATTRIBUTE_VSYNC_PERIOD,
+ (int32_t *)(outVsyncPeriod));
}
HWC2::Error DrmHwcTwo::HwcDisplay::SetActiveConfigWithConstraints(
hwc2_config_t /*config*/,
hwc_vsync_period_change_constraints_t *vsyncPeriodChangeConstraints,
hwc_vsync_period_change_timeline_t *outTimeline) {
- supported(__func__);
-
if (vsyncPeriodChangeConstraints == nullptr || outTimeline == nullptr) {
return HWC2::Error::BadParameter;
}
}
HWC2::Error DrmHwcTwo::HwcDisplay::SetContentType(int32_t contentType) {
- supported(__func__);
-
if (contentType != HWC2_CONTENT_TYPE_NONE)
return HWC2::Error::Unsupported;
#if PLATFORM_SDK_VERSION > 28
HWC2::Error DrmHwcTwo::HwcDisplay::GetDisplayIdentificationData(
uint8_t *outPort, uint32_t *outDataSize, uint8_t *outData) {
- supported(__func__);
+ auto blob = connector_->GetEdidBlob();
- drmModePropertyBlobPtr blob = nullptr;
-
- if (connector_->GetEdidBlob(blob)) {
+ if (!blob) {
ALOGE("Failed to get edid property value.");
return HWC2::Error::Unsupported;
}
}
HWC2::Error DrmHwcTwo::HwcDisplay::GetDisplayCapabilities(
- uint32_t *outNumCapabilities, uint32_t *outCapabilities) {
- unsupported(__func__, outCapabilities);
-
+ uint32_t *outNumCapabilities, uint32_t * /*outCapabilities*/) {
if (outNumCapabilities == nullptr) {
return HWC2::Error::BadParameter;
}
#endif /* PLATFORM_SDK_VERSION > 27 */
-HWC2::Error DrmHwcTwo::HwcLayer::SetCursorPosition(int32_t x, int32_t y) {
- supported(__func__);
- cursor_x_ = x;
- cursor_y_ = y;
+HWC2::Error DrmHwcTwo::HwcLayer::SetCursorPosition(int32_t /*x*/,
+ int32_t /*y*/) {
return HWC2::Error::None;
}
HWC2::Error DrmHwcTwo::HwcLayer::SetLayerBlendMode(int32_t mode) {
- supported(__func__);
- blending_ = static_cast<HWC2::BlendMode>(mode);
+ switch (static_cast<HWC2::BlendMode>(mode)) {
+ case HWC2::BlendMode::None:
+ blending_ = DrmHwcBlending::kNone;
+ break;
+ case HWC2::BlendMode::Premultiplied:
+ blending_ = DrmHwcBlending::kPreMult;
+ break;
+ case HWC2::BlendMode::Coverage:
+ blending_ = DrmHwcBlending::kCoverage;
+ break;
+ default:
+ ALOGE("Unknown blending mode b=%d", blending_);
+ blending_ = DrmHwcBlending::kNone;
+ break;
+ }
return HWC2::Error::None;
}
+/* Find API details at:
+ * https://cs.android.com/android/platform/superproject/+/android-11.0.0_r3:hardware/libhardware/include/hardware/hwcomposer2.h;l=2314
+ */
HWC2::Error DrmHwcTwo::HwcLayer::SetLayerBuffer(buffer_handle_t buffer,
int32_t acquire_fence) {
- supported(__func__);
- UniqueFd uf(acquire_fence);
-
set_buffer(buffer);
- set_acquire_fence(uf.get());
+ acquire_fence_ = UniqueFd(acquire_fence);
return HWC2::Error::None;
}
-HWC2::Error DrmHwcTwo::HwcLayer::SetLayerColor(hwc_color_t color) {
+HWC2::Error DrmHwcTwo::HwcLayer::SetLayerColor(hwc_color_t /*color*/) {
// TODO(nobody): Put to client composition here?
- supported(__func__);
- layer_color_ = color;
return HWC2::Error::None;
}
}
HWC2::Error DrmHwcTwo::HwcLayer::SetLayerDataspace(int32_t dataspace) {
- supported(__func__);
- dataspace_ = static_cast<android_dataspace_t>(dataspace);
+ switch (dataspace & HAL_DATASPACE_STANDARD_MASK) {
+ case HAL_DATASPACE_STANDARD_BT709:
+ color_space_ = DrmHwcColorSpace::kItuRec709;
+ break;
+ case HAL_DATASPACE_STANDARD_BT601_625:
+ case HAL_DATASPACE_STANDARD_BT601_625_UNADJUSTED:
+ case HAL_DATASPACE_STANDARD_BT601_525:
+ case HAL_DATASPACE_STANDARD_BT601_525_UNADJUSTED:
+ color_space_ = DrmHwcColorSpace::kItuRec601;
+ break;
+ case HAL_DATASPACE_STANDARD_BT2020:
+ case HAL_DATASPACE_STANDARD_BT2020_CONSTANT_LUMINANCE:
+ color_space_ = DrmHwcColorSpace::kItuRec2020;
+ break;
+ default:
+ color_space_ = DrmHwcColorSpace::kUndefined;
+ }
+
+ switch (dataspace & HAL_DATASPACE_RANGE_MASK) {
+ case HAL_DATASPACE_RANGE_FULL:
+ sample_range_ = DrmHwcSampleRange::kFullRange;
+ break;
+ case HAL_DATASPACE_RANGE_LIMITED:
+ sample_range_ = DrmHwcSampleRange::kLimitedRange;
+ break;
+ default:
+ sample_range_ = DrmHwcSampleRange::kUndefined;
+ }
return HWC2::Error::None;
}
HWC2::Error DrmHwcTwo::HwcLayer::SetLayerDisplayFrame(hwc_rect_t frame) {
- supported(__func__);
display_frame_ = frame;
return HWC2::Error::None;
}
HWC2::Error DrmHwcTwo::HwcLayer::SetLayerPlaneAlpha(float alpha) {
- supported(__func__);
alpha_ = alpha;
return HWC2::Error::None;
}
HWC2::Error DrmHwcTwo::HwcLayer::SetLayerSidebandStream(
- const native_handle_t *stream) {
- supported(__func__);
+ const native_handle_t * /*stream*/) {
// TODO(nobody): We don't support sideband
- return unsupported(__func__, stream);
+ return HWC2::Error::Unsupported;
+ ;
}
HWC2::Error DrmHwcTwo::HwcLayer::SetLayerSourceCrop(hwc_frect_t crop) {
- supported(__func__);
source_crop_ = crop;
return HWC2::Error::None;
}
-HWC2::Error DrmHwcTwo::HwcLayer::SetLayerSurfaceDamage(hwc_region_t damage) {
- supported(__func__);
+HWC2::Error DrmHwcTwo::HwcLayer::SetLayerSurfaceDamage(
+ hwc_region_t /*damage*/) {
// TODO(nobody): We don't use surface damage, marking as unsupported
- unsupported(__func__, damage);
return HWC2::Error::None;
}
HWC2::Error DrmHwcTwo::HwcLayer::SetLayerTransform(int32_t transform) {
- supported(__func__);
- transform_ = static_cast<HWC2::Transform>(transform);
+ uint32_t l_transform = 0;
+
+ // 270* and 180* cannot be combined with flips. More specifically, they
+ // already contain both horizontal and vertical flips, so those fields are
+ // redundant in this case. 90* rotation can be combined with either horizontal
+ // flip or vertical flip, so treat it differently
+ if (transform == HWC_TRANSFORM_ROT_270) {
+ l_transform = DrmHwcTransform::kRotate270;
+ } else if (transform == HWC_TRANSFORM_ROT_180) {
+ l_transform = DrmHwcTransform::kRotate180;
+ } else {
+ if (transform & HWC_TRANSFORM_FLIP_H)
+ l_transform |= DrmHwcTransform::kFlipH;
+ if (transform & HWC_TRANSFORM_FLIP_V)
+ l_transform |= DrmHwcTransform::kFlipV;
+ if (transform & HWC_TRANSFORM_ROT_90)
+ l_transform |= DrmHwcTransform::kRotate90;
+ }
+
+ transform_ = static_cast<DrmHwcTransform>(l_transform);
return HWC2::Error::None;
}
-HWC2::Error DrmHwcTwo::HwcLayer::SetLayerVisibleRegion(hwc_region_t visible) {
- supported(__func__);
+HWC2::Error DrmHwcTwo::HwcLayer::SetLayerVisibleRegion(
+ hwc_region_t /*visible*/) {
// TODO(nobody): We don't use this information, marking as unsupported
- unsupported(__func__, visible);
return HWC2::Error::None;
}
HWC2::Error DrmHwcTwo::HwcLayer::SetLayerZOrder(uint32_t order) {
- supported(__func__);
z_order_ = order;
return HWC2::Error::None;
}
void DrmHwcTwo::HwcLayer::PopulateDrmLayer(DrmHwcLayer *layer) {
- supported(__func__);
- switch (blending_) {
- case HWC2::BlendMode::None:
- layer->blending = DrmHwcBlending::kNone;
- break;
- case HWC2::BlendMode::Premultiplied:
- layer->blending = DrmHwcBlending::kPreMult;
- break;
- case HWC2::BlendMode::Coverage:
- layer->blending = DrmHwcBlending::kCoverage;
- break;
- default:
- ALOGE("Unknown blending mode b=%d", blending_);
- layer->blending = DrmHwcBlending::kNone;
- break;
- }
-
- OutputFd release_fence = release_fence_output();
-
layer->sf_handle = buffer_;
- layer->acquire_fence = acquire_fence_.Release();
- layer->release_fence = std::move(release_fence);
- layer->SetDisplayFrame(display_frame_);
+ // TODO(rsglobal): Avoid extra fd duplication
+ layer->acquire_fence = UniqueFd(fcntl(acquire_fence_.Get(), F_DUPFD_CLOEXEC));
+ layer->display_frame = display_frame_;
layer->alpha = lround(65535.0F * alpha_);
- layer->SetSourceCrop(source_crop_);
- layer->SetTransform(static_cast<int32_t>(transform_));
- layer->dataspace = dataspace_;
+ layer->blending = blending_;
+ layer->source_crop = source_crop_;
+ layer->transform = transform_;
+ layer->color_space = color_space_;
+ layer->sample_range = sample_range_;
}
void DrmHwcTwo::HandleDisplayHotplug(hwc2_display_t displayid, int state) {
- const std::lock_guard<std::mutex> lock(hotplug_callback_lock);
-
- if (hotplug_callback_hook_ && hotplug_callback_data_)
- hotplug_callback_hook_(hotplug_callback_data_, displayid,
- state == DRM_MODE_CONNECTED
- ? HWC2_CONNECTION_CONNECTED
- : HWC2_CONNECTION_DISCONNECTED);
+ const std::lock_guard<std::mutex> lock(callback_lock_);
+
+ if (hotplug_callback_.first != nullptr &&
+ hotplug_callback_.second != nullptr) {
+ hotplug_callback_.first(hotplug_callback_.second, displayid,
+ state == DRM_MODE_CONNECTED
+ ? HWC2_CONNECTION_CONNECTED
+ : HWC2_CONNECTION_DISCONNECTED);
+ }
}
void DrmHwcTwo::HandleInitialHotplugState(DrmDevice *drmDevice) {
}
}
-void DrmHwcTwo::DrmHotplugHandler::HandleEvent(uint64_t timestamp_us) {
- for (const auto &conn : drm_->connectors()) {
- drmModeConnection old_state = conn->state();
- drmModeConnection cur_state = conn->UpdateModes()
- ? DRM_MODE_UNKNOWNCONNECTION
- : conn->state();
+void DrmHwcTwo::HandleHotplugUEvent() {
+ for (const auto &drm : resource_manager_.getDrmDevices()) {
+ for (const auto &conn : drm->connectors()) {
+ drmModeConnection old_state = conn->state();
+ drmModeConnection cur_state = conn->UpdateModes()
+ ? DRM_MODE_UNKNOWNCONNECTION
+ : conn->state();
- if (cur_state == old_state)
- continue;
+ if (cur_state == old_state)
+ continue;
- ALOGI("%s event @%" PRIu64 " for connector %u on display %d",
- cur_state == DRM_MODE_CONNECTED ? "Plug" : "Unplug", timestamp_us,
- conn->id(), conn->display());
-
- int display_id = conn->display();
- if (cur_state == DRM_MODE_CONNECTED) {
- auto &display = hwc2_->displays_.at(display_id);
- display.ChosePreferredConfig();
- } else {
- auto &display = hwc2_->displays_.at(display_id);
- display.ClearDisplay();
- }
+ ALOGI("%s event for connector %u on display %d",
+ cur_state == DRM_MODE_CONNECTED ? "Plug" : "Unplug", conn->id(),
+ conn->display());
- hwc2_->HandleDisplayHotplug(display_id, cur_state);
+ int display_id = conn->display();
+ if (cur_state == DRM_MODE_CONNECTED) {
+ auto &display = displays_.at(display_id);
+ display.ChosePreferredConfig();
+ } else {
+ auto &display = displays_.at(display_id);
+ display.ClearDisplay();
+ }
+
+ HandleDisplayHotplug(display_id, cur_state);
+ }
}
}
// static
int DrmHwcTwo::HookDevClose(hw_device_t * /*dev*/) {
- unsupported(__func__);
return 0;
}
void DrmHwcTwo::HookDevGetCapabilities(hwc2_device_t * /*dev*/,
uint32_t *out_count,
int32_t * /*out_capabilities*/) {
- supported(__func__);
*out_count = 0;
}
// static
hwc2_function_pointer_t DrmHwcTwo::HookDevGetFunction(
struct hwc2_device * /*dev*/, int32_t descriptor) {
- supported(__func__);
auto func = static_cast<HWC2::FunctionDescriptor>(descriptor);
switch (func) {
// Device functions
// static
int DrmHwcTwo::HookDevOpen(const struct hw_module_t *module, const char *name,
struct hw_device_t **dev) {
- supported(__func__);
if (strcmp(name, HWC_HARDWARE_COMPOSER) != 0) {
ALOGE("Invalid module name- %s", name);
return -EINVAL;
OSDN Git Service
