blob: f5970cd89cfd297eb1a1f192df785c88bb775ef1 [file] [log] [blame]
/*
* Copyright (c) 2014 - 2018, 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 <cutils/properties.h>
#include <sync/sync.h>
#include <utils/constants.h>
#include <utils/debug.h>
#include <utils/utils.h>
#include <stdarg.h>
#include <sys/mman.h>
#include <map>
#include <string>
#include <vector>
#include "hwc_display_primary.h"
#include "hwc_debugger.h"
#define __CLASS__ "HWCDisplayPrimary"
namespace sdm {
DisplayError HWCDisplayPrimary::PMICInterface::Init() {
std::string str_lcd_bias("/sys/class/lcd_bias/secure_mode");
fd_lcd_bias_ = ::open(str_lcd_bias.c_str(), O_WRONLY);
if (fd_lcd_bias_ < 0) {
DLOGE("File '%s' could not be opened. errno = %d, desc = %s", str_lcd_bias.c_str(), errno,
strerror(errno));
return kErrorHardware;
}
std::string str_leds_wled("/sys/class/leds/wled/secure_mode");
fd_wled_ = ::open(str_leds_wled.c_str(), O_WRONLY);
if (fd_wled_ < 0) {
DLOGE("File '%s' could not be opened. errno = %d, desc = %s", str_leds_wled.c_str(), errno,
strerror(errno));
return kErrorHardware;
}
return kErrorNone;
}
void HWCDisplayPrimary::PMICInterface::Deinit() {
::close(fd_lcd_bias_);
::close(fd_wled_);
}
DisplayError HWCDisplayPrimary::PMICInterface::Notify(bool secure_display_start) {
std::string str_sd_start = secure_display_start ? std::to_string(1) : std::to_string(0);
ssize_t err = ::pwrite(fd_lcd_bias_, str_sd_start.c_str(), str_sd_start.length(), 0);
if (err <= 0) {
DLOGE("Write failed for lcd_bias, Error = %s", strerror(errno));
return kErrorHardware;
}
err = ::pwrite(fd_wled_, str_sd_start.c_str(), str_sd_start.length(), 0);
if (err <= 0) {
DLOGE("Write failed for wled, Error = %s", strerror(errno));
return kErrorHardware;
}
DLOGI("Successfully notifed about secure display %s to PMIC driver",
secure_display_start ? "start": "end");
return kErrorNone;
}
int HWCDisplayPrimary::Create(CoreInterface *core_intf, BufferAllocator *buffer_allocator,
HWCCallbacks *callbacks, qService::QService *qservice,
HWCDisplay **hwc_display) {
int status = 0;
uint32_t primary_width = 0;
uint32_t primary_height = 0;
HWCDisplay *hwc_display_primary =
new HWCDisplayPrimary(core_intf, buffer_allocator, callbacks, qservice);
status = hwc_display_primary->Init();
if (status) {
delete hwc_display_primary;
return status;
}
hwc_display_primary->GetMixerResolution(&primary_width, &primary_height);
int width = 0, height = 0;
HWCDebugHandler::Get()->GetProperty(FB_WIDTH_PROP, &width);
HWCDebugHandler::Get()->GetProperty(FB_HEIGHT_PROP, &height);
if (width > 0 && height > 0) {
primary_width = UINT32(width);
primary_height = UINT32(height);
}
status = hwc_display_primary->SetFrameBufferResolution(primary_width, primary_height);
if (status) {
Destroy(hwc_display_primary);
return status;
}
*hwc_display = hwc_display_primary;
return status;
}
void HWCDisplayPrimary::Destroy(HWCDisplay *hwc_display) {
hwc_display->Deinit();
delete hwc_display;
}
HWCDisplayPrimary::HWCDisplayPrimary(CoreInterface *core_intf, BufferAllocator *buffer_allocator,
HWCCallbacks *callbacks, qService::QService *qservice)
: HWCDisplay(core_intf, callbacks, kPrimary, HWC_DISPLAY_PRIMARY, true, qservice,
DISPLAY_CLASS_PRIMARY, buffer_allocator),
buffer_allocator_(buffer_allocator),
cpu_hint_(NULL) {
}
int HWCDisplayPrimary::Init() {
cpu_hint_ = new CPUHint();
if (cpu_hint_->Init(static_cast<HWCDebugHandler *>(HWCDebugHandler::Get())) != kErrorNone) {
delete cpu_hint_;
cpu_hint_ = NULL;
}
use_metadata_refresh_rate_ = true;
int disable_metadata_dynfps = 0;
HWCDebugHandler::Get()->GetProperty(DISABLE_METADATA_DYNAMIC_FPS_PROP, &disable_metadata_dynfps);
if (disable_metadata_dynfps) {
use_metadata_refresh_rate_ = false;
}
int status = HWCDisplay::Init();
if (status) {
return status;
}
color_mode_ = new HWCColorMode(display_intf_);
color_mode_->Init();
HWCDebugHandler::Get()->GetProperty(ENABLE_DEFAULT_COLOR_MODE, &default_mode_status_);
pmic_intf_ = new PMICInterface();
pmic_intf_->Init();
return status;
}
int HWCDisplayPrimary::Deinit() {
int status = HWCDisplay::Deinit();
if (status) {
return status;
}
pmic_intf_->Deinit();
delete pmic_intf_;
return 0;
}
void HWCDisplayPrimary::ProcessBootAnimCompleted() {
uint32_t numBootUpLayers = 0;
// TODO(user): Remove this hack
numBootUpLayers = static_cast<uint32_t>(Debug::GetBootAnimLayerCount());
if (numBootUpLayers == 0) {
numBootUpLayers = 2;
}
/* All other checks namely "init.svc.bootanim" or
* HWC_GEOMETRY_CHANGED fail in correctly identifying the
* exact bootup transition to homescreen
*/
char property[PROPERTY_VALUE_MAX];
bool isEncrypted = false;
bool main_class_services_started = false;
property_get("ro.crypto.state", property, "unencrypted");
if (!strcmp(property, "encrypted")) {
property_get("ro.crypto.type", property, "block");
if (!strcmp(property, "block")) {
isEncrypted = true;
property_get("vold.decrypt", property, "");
if (!strcmp(property, "trigger_restart_framework")) {
main_class_services_started = true;
}
}
}
if ((!isEncrypted || (isEncrypted && main_class_services_started)) &&
(layer_set_.size() > numBootUpLayers)) {
DLOGI("Applying default mode");
boot_animation_completed_ = true;
// Applying default mode after bootanimation is finished And
// If Data is Encrypted, it is ready for access.
if (display_intf_) {
display_intf_->ApplyDefaultDisplayMode();
RestoreColorTransform();
}
}
}
HWC2::Error HWCDisplayPrimary::Validate(uint32_t *out_num_types, uint32_t *out_num_requests) {
auto status = HWC2::Error::None;
DisplayError error = kErrorNone;
if (default_mode_status_ && !boot_animation_completed_) {
ProcessBootAnimCompleted();
}
if (display_paused_) {
MarkLayersForGPUBypass();
return status;
}
if (color_tranform_failed_) {
// Must fall back to client composition
MarkLayersForClientComposition();
}
if (config_pending_) {
if (display_intf_->SetActiveConfig(display_config_) != kErrorNone) {
DLOGW("Invalid display config %d", display_config_);
// Reset the display config with active config
display_intf_->GetActiveConfig(&display_config_);
}
}
// Fill in the remaining blanks in the layers and add them to the SDM layerstack
BuildLayerStack();
// Checks and replaces layer stack for solid fill
SolidFillPrepare();
bool pending_output_dump = dump_frame_count_ && dump_output_to_file_;
if (readback_buffer_queued_ || pending_output_dump) {
CloseFd(&output_buffer_.release_fence_fd);
// RHS values were set in FrameCaptureAsync() called from a binder thread. They are picked up
// here in a subsequent draw round. Readback is not allowed for any secure use case.
readback_configured_ = !layer_stack_.flags.secure_present;
if (readback_configured_) {
DisablePartialUpdateOneFrame();
layer_stack_.output_buffer = &output_buffer_;
layer_stack_.flags.post_processed_output = post_processed_output_;
}
}
uint32_t num_updating_layers = GetUpdatingLayersCount();
bool one_updating_layer = (num_updating_layers == 1);
if (num_updating_layers != 0) {
ToggleCPUHint(one_updating_layer);
}
uint32_t refresh_rate = GetOptimalRefreshRate(one_updating_layer);
bool final_rate = force_refresh_rate_ ? true : false;
error = display_intf_->SetRefreshRate(refresh_rate, final_rate);
if (error == kErrorNone) {
// On success, set current refresh rate to new refresh rate
current_refresh_rate_ = refresh_rate;
}
if (layer_set_.empty()) {
// Avoid flush for Command mode panel.
DisplayConfigFixedInfo display_config;
display_intf_->GetConfig(&display_config);
flush_ = !(display_config.is_cmdmode && secure_display_active_);
validated_ = true;
return status;
}
status = PrepareLayerStack(out_num_types, out_num_requests);
pending_commit_ = true;
return status;
}
HWC2::Error HWCDisplayPrimary::Present(int32_t *out_retire_fence) {
auto status = HWC2::Error::None;
if (display_paused_) {
// TODO(user): From old HWC implementation
// If we do not handle the frame set retireFenceFd to outbufAcquireFenceFd
// Revisit this when validating display_paused
DisplayError error = display_intf_->Flush();
validated_ = false;
if (error != kErrorNone) {
DLOGE("Flush failed. Error = %d", error);
}
} else {
status = HWCDisplay::CommitLayerStack();
if (status == HWC2::Error::None) {
HandleFrameOutput();
SolidFillCommit();
status = PostCommitLayerStack(out_retire_fence);
}
}
CloseFd(&output_buffer_.acquire_fence_fd);
pending_commit_ = false;
return status;
}
HWC2::Error HWCDisplayPrimary::GetColorModes(uint32_t *out_num_modes, ColorMode *out_modes) {
if (out_modes == nullptr) {
*out_num_modes = color_mode_->GetColorModeCount();
} else {
color_mode_->GetColorModes(out_num_modes, out_modes);
}
return HWC2::Error::None;
}
HWC2::Error HWCDisplayPrimary::GetRenderIntents(ColorMode mode, uint32_t *out_num_intents,
RenderIntent *out_intents) {
if (out_intents == nullptr) {
*out_num_intents = color_mode_->GetRenderIntentCount(mode);
} else {
color_mode_->GetRenderIntents(mode, out_num_intents, out_intents);
}
return HWC2::Error::None;
}
HWC2::Error HWCDisplayPrimary::SetColorMode(ColorMode mode) {
return SetColorModeWithRenderIntent(mode, RenderIntent::COLORIMETRIC);
}
HWC2::Error HWCDisplayPrimary::SetColorModeWithRenderIntent(ColorMode mode, RenderIntent intent) {
auto status = color_mode_->SetColorModeWithRenderIntent(mode, intent);
if (status != HWC2::Error::None) {
DLOGE("failed for mode = %d intent = %d", mode, intent);
return status;
}
callbacks_->Refresh(HWC_DISPLAY_PRIMARY);
validated_ = false;
auto working_color_space = color_mode_->GetWorkingColorSpace();
working_primaries_ = working_color_space.first;
working_transfer_ = working_color_space.second;
current_color_mode_ = color_mode_->GetCurrentColorMode();
return status;
}
HWC2::Error HWCDisplayPrimary::SetColorModeById(int32_t color_mode_id) {
auto status = color_mode_->SetColorModeById(color_mode_id);
if (status != HWC2::Error::None) {
DLOGE("failed for mode = %d", color_mode_id);
return status;
}
callbacks_->Refresh(HWC_DISPLAY_PRIMARY);
validated_ = false;
return status;
}
HWC2::Error HWCDisplayPrimary::RestoreColorTransform() {
auto status = color_mode_->RestoreColorTransform();
if (status != HWC2::Error::None) {
DLOGE("failed to RestoreColorTransform");
return status;
}
callbacks_->Refresh(HWC_DISPLAY_PRIMARY);
return status;
}
HWC2::Error HWCDisplayPrimary::SetColorTransform(const float *matrix,
android_color_transform_t hint) {
if (!matrix) {
return HWC2::Error::BadParameter;
}
auto status = color_mode_->SetColorTransform(matrix, hint);
if (status != HWC2::Error::None) {
DLOGE("failed for hint = %d", hint);
color_tranform_failed_ = true;
return status;
}
callbacks_->Refresh(HWC_DISPLAY_PRIMARY);
color_tranform_failed_ = false;
validated_ = false;
return status;
}
HWC2::Error HWCDisplayPrimary::SetReadbackBuffer(const native_handle_t *buffer,
int32_t acquire_fence,
bool post_processed_output) {
const private_handle_t *handle = reinterpret_cast<const private_handle_t *>(buffer);
if (!handle || (handle->fd < 0)) {
return HWC2::Error::BadParameter;
}
// Configure the output buffer as Readback buffer
output_buffer_.width = UINT32(handle->width);
output_buffer_.height = UINT32(handle->height);
output_buffer_.unaligned_width = UINT32(handle->unaligned_width);
output_buffer_.unaligned_height = UINT32(handle->unaligned_height);
output_buffer_.format = GetSDMFormat(handle->format, handle->flags);
output_buffer_.planes[0].fd = handle->fd;
output_buffer_.planes[0].stride = UINT32(handle->width);
output_buffer_.acquire_fence_fd = dup(acquire_fence);
output_buffer_.release_fence_fd = -1;
post_processed_output_ = post_processed_output;
readback_buffer_queued_ = true;
readback_configured_ = false;
validated_ = false;
return HWC2::Error::None;
}
HWC2::Error HWCDisplayPrimary::GetReadbackBufferFence(int32_t *release_fence) {
auto status = HWC2::Error::None;
if (readback_configured_ && (output_buffer_.release_fence_fd >= 0)) {
*release_fence = output_buffer_.release_fence_fd;
} else {
status = HWC2::Error::Unsupported;
*release_fence = -1;
}
post_processed_output_ = false;
readback_buffer_queued_ = false;
readback_configured_ = false;
output_buffer_ = {};
return status;
}
HWC2::Error HWCDisplayPrimary::PostCommitLayerStack(int32_t *out_retire_fence) {
auto status = HWCDisplay::PostCommitLayerStack(out_retire_fence);
if (status != HWC2::Error::None) {
return status;
}
if (pmic_notification_pending_) {
// Wait for current commit to complete
if (*out_retire_fence >= 0) {
int ret = sync_wait(*out_retire_fence, 1000);
if (ret < 0) {
DLOGE("sync_wait error errno = %d, desc = %s", errno, strerror(errno));
}
}
pmic_intf_->Notify(false /* secure_display_start */);
pmic_notification_pending_ = false;
}
return HWC2::Error::None;
}
int HWCDisplayPrimary::Perform(uint32_t operation, ...) {
va_list args;
va_start(args, operation);
int val = 0;
LayerSolidFill *solid_fill_color;
LayerRect *rect = NULL;
switch (operation) {
case SET_METADATA_DYN_REFRESH_RATE:
val = va_arg(args, int32_t);
SetMetaDataRefreshRateFlag(val);
break;
case SET_BINDER_DYN_REFRESH_RATE:
val = va_arg(args, int32_t);
ForceRefreshRate(UINT32(val));
break;
case SET_DISPLAY_MODE:
val = va_arg(args, int32_t);
SetDisplayMode(UINT32(val));
break;
case SET_QDCM_SOLID_FILL_INFO:
solid_fill_color = va_arg(args, LayerSolidFill*);
SetQDCMSolidFillInfo(true, *solid_fill_color);
break;
case UNSET_QDCM_SOLID_FILL_INFO:
solid_fill_color = va_arg(args, LayerSolidFill*);
SetQDCMSolidFillInfo(false, *solid_fill_color);
break;
case SET_QDCM_SOLID_FILL_RECT:
rect = va_arg(args, LayerRect*);
solid_fill_rect_ = *rect;
break;
default:
DLOGW("Invalid operation %d", operation);
va_end(args);
return -EINVAL;
}
va_end(args);
validated_ = false;
return 0;
}
DisplayError HWCDisplayPrimary::SetDisplayMode(uint32_t mode) {
DisplayError error = kErrorNone;
if (display_intf_) {
error = display_intf_->SetDisplayMode(mode);
}
return error;
}
void HWCDisplayPrimary::SetMetaDataRefreshRateFlag(bool enable) {
int disable_metadata_dynfps = 0;
HWCDebugHandler::Get()->GetProperty(DISABLE_METADATA_DYNAMIC_FPS_PROP, &disable_metadata_dynfps);
if (disable_metadata_dynfps) {
return;
}
use_metadata_refresh_rate_ = enable;
}
void HWCDisplayPrimary::SetQDCMSolidFillInfo(bool enable, const LayerSolidFill &color) {
solid_fill_enable_ = enable;
solid_fill_color_ = color;
}
void HWCDisplayPrimary::ToggleCPUHint(bool set) {
if (!cpu_hint_) {
return;
}
if (set) {
cpu_hint_->Set();
} else {
cpu_hint_->Reset();
}
}
void HWCDisplayPrimary::SetSecureDisplay(bool secure_display_active) {
if (secure_display_active_ != secure_display_active) {
// Skip Prepare and call Flush for null commit
DLOGI("SecureDisplay state changed from %d to %d Needs Flush!!", secure_display_active_,
secure_display_active);
secure_display_active_ = secure_display_active;
if (secure_display_active_) {
pmic_intf_->Notify(true /* secure_display_start */);
} else {
pmic_notification_pending_ = true;
}
// Avoid flush for Command mode panel.
DisplayConfigFixedInfo display_config;
display_intf_->GetConfig(&display_config);
skip_prepare_ = !display_config.is_cmdmode;
}
}
void HWCDisplayPrimary::ForceRefreshRate(uint32_t refresh_rate) {
if ((refresh_rate && (refresh_rate < min_refresh_rate_ || refresh_rate > max_refresh_rate_)) ||
force_refresh_rate_ == refresh_rate) {
// Cannot honor force refresh rate, as its beyond the range or new request is same
return;
}
force_refresh_rate_ = refresh_rate;
callbacks_->Refresh(HWC_DISPLAY_PRIMARY);
return;
}
uint32_t HWCDisplayPrimary::GetOptimalRefreshRate(bool one_updating_layer) {
if (force_refresh_rate_) {
return force_refresh_rate_;
} else if (use_metadata_refresh_rate_ && one_updating_layer && metadata_refresh_rate_) {
return metadata_refresh_rate_;
}
return max_refresh_rate_;
}
DisplayError HWCDisplayPrimary::Refresh() {
DisplayError error = kErrorNone;
callbacks_->Refresh(HWC_DISPLAY_PRIMARY);
return error;
}
void HWCDisplayPrimary::SetIdleTimeoutMs(uint32_t timeout_ms) {
display_intf_->SetIdleTimeoutMs(timeout_ms);
validated_ = false;
}
void HWCDisplayPrimary::HandleFrameOutput() {
if (readback_buffer_queued_) {
validated_ = false;
}
if (dump_output_to_file_) {
HandleFrameDump();
}
}
void HWCDisplayPrimary::HandleFrameDump() {
if (!readback_configured_) {
dump_frame_count_ = 0;
}
if (dump_frame_count_ && output_buffer_.release_fence_fd >= 0) {
int ret = sync_wait(output_buffer_.release_fence_fd, 1000);
::close(output_buffer_.release_fence_fd);
output_buffer_.release_fence_fd = -1;
if (ret < 0) {
DLOGE("sync_wait error errno = %d, desc = %s", errno, strerror(errno));
} else {
DumpOutputBuffer(output_buffer_info_, output_buffer_base_, layer_stack_.retire_fence_fd);
readback_buffer_queued_ = false;
validated_ = false;
}
}
if (0 == dump_frame_count_) {
dump_output_to_file_ = false;
// Unmap and Free buffer
if (munmap(output_buffer_base_, output_buffer_info_.alloc_buffer_info.size) != 0) {
DLOGE("unmap failed with err %d", errno);
}
if (buffer_allocator_->FreeBuffer(&output_buffer_info_) != 0) {
DLOGE("FreeBuffer failed");
}
readback_buffer_queued_ = false;
post_processed_output_ = false;
readback_configured_ = false;
output_buffer_ = {};
output_buffer_info_ = {};
output_buffer_base_ = nullptr;
}
}
HWC2::Error HWCDisplayPrimary::SetFrameDumpConfig(uint32_t count, uint32_t bit_mask_layer_type,
int32_t format, bool post_processed) {
HWCDisplay::SetFrameDumpConfig(count, bit_mask_layer_type, format, post_processed);
dump_output_to_file_ = bit_mask_layer_type & (1 << OUTPUT_LAYER_DUMP);
DLOGI("output_layer_dump_enable %d", dump_output_to_file_);
if (!count || !dump_output_to_file_) {
return HWC2::Error::None;
}
// Allocate and map output buffer
output_buffer_info_ = {};
if (post_processed) {
// To dump post-processed (DSPP) output, use Panel resolution.
GetPanelResolution(&output_buffer_info_.buffer_config.width,
&output_buffer_info_.buffer_config.height);
} else {
// To dump Layer Mixer output, use FrameBuffer resolution.
GetFrameBufferResolution(&output_buffer_info_.buffer_config.width,
&output_buffer_info_.buffer_config.height);
}
output_buffer_info_.buffer_config.format = GetSDMFormat(format, 0);
output_buffer_info_.buffer_config.buffer_count = 1;
if (buffer_allocator_->AllocateBuffer(&output_buffer_info_) != 0) {
DLOGE("Buffer allocation failed");
output_buffer_info_ = {};
return HWC2::Error::NoResources;
}
void *buffer = mmap(NULL, output_buffer_info_.alloc_buffer_info.size, PROT_READ | PROT_WRITE,
MAP_SHARED, output_buffer_info_.alloc_buffer_info.fd, 0);
if (buffer == MAP_FAILED) {
DLOGE("mmap failed with err %d", errno);
buffer_allocator_->FreeBuffer(&output_buffer_info_);
output_buffer_info_ = {};
return HWC2::Error::NoResources;
}
output_buffer_base_ = buffer;
const native_handle_t *handle = static_cast<native_handle_t *>(output_buffer_info_.private_data);
SetReadbackBuffer(handle, -1, post_processed);
return HWC2::Error::None;
}
int HWCDisplayPrimary::FrameCaptureAsync(const BufferInfo &output_buffer_info,
bool post_processed_output) {
// Note: This function is called in context of a binder thread and a lock is already held
if (output_buffer_info.alloc_buffer_info.fd < 0) {
DLOGE("Invalid fd %d", output_buffer_info.alloc_buffer_info.fd);
return -1;
}
auto panel_width = 0u;
auto panel_height = 0u;
auto fb_width = 0u;
auto fb_height = 0u;
GetPanelResolution(&panel_width, &panel_height);
GetFrameBufferResolution(&fb_width, &fb_height);
if (post_processed_output && (output_buffer_info.buffer_config.width < panel_width ||
output_buffer_info.buffer_config.height < panel_height)) {
DLOGE("Buffer dimensions should not be less than panel resolution");
return -1;
} else if (!post_processed_output && (output_buffer_info.buffer_config.width < fb_width ||
output_buffer_info.buffer_config.height < fb_height)) {
DLOGE("Buffer dimensions should not be less than FB resolution");
return -1;
}
const native_handle_t *buffer = static_cast<native_handle_t *>(output_buffer_info.private_data);
SetReadbackBuffer(buffer, -1, post_processed_output);
return 0;
}
bool HWCDisplayPrimary::GetFrameCaptureFence(int32_t *release_fence) {
return (GetReadbackBufferFence(release_fence) == HWC2::Error::None);
}
DisplayError HWCDisplayPrimary::SetDetailEnhancerConfig
(const DisplayDetailEnhancerData &de_data) {
DisplayError error = kErrorNotSupported;
if (display_intf_) {
error = display_intf_->SetDetailEnhancerData(de_data);
validated_ = false;
}
return error;
}
DisplayError HWCDisplayPrimary::ControlPartialUpdate(bool enable, uint32_t *pending) {
DisplayError error = kErrorNone;
if (display_intf_) {
error = display_intf_->ControlPartialUpdate(enable, pending);
validated_ = false;
}
return error;
}
DisplayError HWCDisplayPrimary::DisablePartialUpdateOneFrame() {
DisplayError error = kErrorNone;
if (display_intf_) {
error = display_intf_->DisablePartialUpdateOneFrame();
validated_ = false;
}
return error;
}
DisplayError HWCDisplayPrimary::SetMixerResolution(uint32_t width, uint32_t height) {
DisplayError error = display_intf_->SetMixerResolution(width, height);
validated_ = false;
return error;
}
DisplayError HWCDisplayPrimary::GetMixerResolution(uint32_t *width, uint32_t *height) {
return display_intf_->GetMixerResolution(width, height);
}
HWC2::Error HWCDisplayPrimary::ControlIdlePowerCollapse(bool enable, bool synchronous) {
DisplayError error = kErrorNone;
if (display_intf_) {
error = display_intf_->ControlIdlePowerCollapse(enable, synchronous);
validated_ = false;
}
return (error != kErrorNone) ? HWC2::Error::Unsupported : HWC2::Error::None;
}
} // namespace sdm