4825 lines
181 KiB
C++
Executable File
4825 lines
181 KiB
C++
Executable File
/*
|
||
* Copyright (C) 2016 The Android Open Source Project
|
||
*
|
||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||
* you may not use this file except in compliance with the License.
|
||
* You may obtain a copy of the License at
|
||
*
|
||
* http://www.apache.org/licenses/LICENSE-2.0
|
||
*
|
||
* Unless required by applicable law or agreed to in writing, software
|
||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
* See the License for the specific language governing permissions and
|
||
* limitations under the License.
|
||
*/
|
||
|
||
#define ATRACE_TAG ATRACE_TAG_GRAPHICS
|
||
#define LOG_TAG "hwc-drm-two"
|
||
|
||
#include "drmhwctwo.h"
|
||
#include "drmdisplaycomposition.h"
|
||
#include "drmlayer.h"
|
||
#include "platform.h"
|
||
#include "vsyncworker.h"
|
||
#include "rockchip/utils/drmdebug.h"
|
||
#include "rockchip/drmgralloc.h"
|
||
#include <im2d.hpp>
|
||
#include <drm_fourcc.h>
|
||
#include <rga.h>
|
||
|
||
#include <inttypes.h>
|
||
#include <string>
|
||
|
||
#include <cutils/properties.h>
|
||
#include <hardware/hardware.h>
|
||
#include <hardware/hwcomposer2.h>
|
||
#include <log/log.h>
|
||
#include <utils/Trace.h>
|
||
|
||
#include <linux/fb.h>
|
||
|
||
|
||
#define hwcMIN(x, y) (((x) <= (y)) ? (x) : (y))
|
||
#define hwcMAX(x, y) (((x) >= (y)) ? (x) : (y))
|
||
|
||
#ifndef IS_ALIGN
|
||
#define IS_ALIGN(val, align) (((val) & (align - 1)) == 0)
|
||
#endif
|
||
|
||
#ifndef ALIGN
|
||
#define ALIGN(value, base) (((value) + ((base)-1)) & ~((base)-1))
|
||
#endif
|
||
|
||
#ifndef ALIGN_DOWN
|
||
#define ALIGN_DOWN(value, base) (value & (~(base - 1)))
|
||
#endif
|
||
|
||
namespace android {
|
||
|
||
static inline long __currentTime(){
|
||
struct timeval tp;
|
||
gettimeofday(&tp, NULL);
|
||
return static_cast<long>(tp.tv_sec) * 1000000 + tp.tv_usec;
|
||
}
|
||
#define ALOGD_HWC2_DRM_LAYER_INFO(log_level, drmHwcLayers) \
|
||
if(LogLevel(log_level)){ \
|
||
String8 output; \
|
||
for(auto &drmHwcLayer : drmHwcLayers) {\
|
||
drmHwcLayer.DumpInfo(output); \
|
||
ALOGD_IF(LogLevel(log_level),"%s",output.string()); \
|
||
output.clear(); \
|
||
}\
|
||
}
|
||
|
||
class DrmVsyncCallback : public VsyncCallback {
|
||
public:
|
||
DrmVsyncCallback(hwc2_callback_data_t data, hwc2_function_pointer_t hook)
|
||
: data_(data), hook_(hook) {
|
||
}
|
||
|
||
void Callback(int display, int64_t timestamp) {
|
||
auto hook = reinterpret_cast<HWC2_PFN_VSYNC>(hook_);
|
||
if(hook){
|
||
hook(data_, display, timestamp);
|
||
}
|
||
}
|
||
|
||
private:
|
||
hwc2_callback_data_t data_;
|
||
hwc2_function_pointer_t hook_;
|
||
};
|
||
|
||
class DrmInvalidateCallback : public InvalidateCallback {
|
||
public:
|
||
DrmInvalidateCallback(hwc2_callback_data_t data, hwc2_function_pointer_t hook)
|
||
: data_(data), hook_(hook) {
|
||
}
|
||
|
||
void Callback(int display) {
|
||
auto hook = reinterpret_cast<HWC2_PFN_REFRESH>(hook_);
|
||
if(hook){
|
||
hook(data_, display);
|
||
}
|
||
}
|
||
|
||
private:
|
||
hwc2_callback_data_t data_;
|
||
hwc2_function_pointer_t hook_;
|
||
};
|
||
|
||
|
||
DrmHwcTwo::DrmHwcTwo()
|
||
: resource_manager_(ResourceManager::getInstance()) {
|
||
common.tag = HARDWARE_DEVICE_TAG;
|
||
common.version = HWC_DEVICE_API_VERSION_2_0;
|
||
common.close = HookDevClose;
|
||
getCapabilities = HookDevGetCapabilities;
|
||
getFunction = HookDevGetFunction;
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::CreateDisplay(hwc2_display_t displ,
|
||
HWC2::DisplayType type) {
|
||
HWC2_ALOGD_IF_VERBOSE("display-id=%" PRIu64 " type=%s" , displ,
|
||
(type == HWC2::DisplayType::Physical ? "Physical" : "Virtual"));
|
||
|
||
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");
|
||
return HWC2::Error::NoResources;
|
||
}
|
||
displays_.emplace(std::piecewise_construct, std::forward_as_tuple(displ),
|
||
std::forward_as_tuple(resource_manager_, drm, importer,
|
||
displ, type));
|
||
|
||
displays_.at(displ).Init();
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::Init() {
|
||
HWC2_ALOGD_IF_VERBOSE();
|
||
int rv = resource_manager_->Init(this);
|
||
if (rv) {
|
||
ALOGE("Can't initialize the resource manager %d", rv);
|
||
return HWC2::Error::NoResources;
|
||
}
|
||
|
||
HWC2::Error ret = HWC2::Error::None;
|
||
for (auto &map_display : resource_manager_->getDisplays()) {
|
||
ret = CreateDisplay(map_display.second, HWC2::DisplayType::Physical);
|
||
if (ret != HWC2::Error::None) {
|
||
ALOGE("Failed to create display %d with error %d", map_display.second, ret);
|
||
return ret;
|
||
}
|
||
}
|
||
|
||
auto &drmDevices = resource_manager_->GetDrmDevices();
|
||
for (auto &device : drmDevices) {
|
||
device->RegisterHotplugHandler(new DrmHotplugHandler(this, device.get()));
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
hwc2_drm_display_t* DrmHwcTwo::GetDisplayCtxPtr(hwc2_display_t display_id){
|
||
if(displays_.count(display_id)){
|
||
auto &display = displays_.at(display_id);
|
||
return display.GetDisplayCtxPtr();
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
template <typename... Args>
|
||
static inline HWC2::Error unsupported(char const *func, Args... /*args*/) {
|
||
ALOGV("Unsupported function: %s", func);
|
||
return HWC2::Error::Unsupported;
|
||
}
|
||
|
||
static inline void supported(char const *func) {
|
||
ALOGV("Supported function: %s", func);
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::CreateVirtualDisplay(uint32_t width, uint32_t height,
|
||
int32_t *format,
|
||
hwc2_display_t *display) {
|
||
HWC2_ALOGD_IF_VERBOSE("w=%u,h=%u,f=%d",width,height,*format);
|
||
HWC2::Error ret = HWC2::Error::None;
|
||
int physical_display_num = resource_manager_->getDisplayCount();
|
||
int virtual_display_id = physical_display_num + mVirtualDisplayCount_;
|
||
if(!displays_.count(virtual_display_id)){
|
||
char value[PROPERTY_VALUE_MAX];
|
||
property_get("vendor.hwc.virtual_display_write_back_id", value, "0");
|
||
int write_back_id = atoi(value);
|
||
DrmDevice *drm = resource_manager_->GetDrmDevice(write_back_id);
|
||
std::shared_ptr<Importer> importer = resource_manager_->GetImporter(write_back_id);
|
||
if (!drm || !importer) {
|
||
ALOGE("Failed to get a valid drmresource and importer");
|
||
return HWC2::Error::NoResources;
|
||
}
|
||
displays_.emplace(std::piecewise_construct, std::forward_as_tuple(virtual_display_id),
|
||
std::forward_as_tuple(resource_manager_, drm, importer,
|
||
virtual_display_id,
|
||
HWC2::DisplayType::Virtual));
|
||
displays_.at(virtual_display_id).InitVirtual();
|
||
*display = virtual_display_id;
|
||
*format = HAL_PIXEL_FORMAT_RGBA_8888;
|
||
mVirtualDisplayCount_++;
|
||
resource_manager_->EnableWriteBackMode(write_back_id);
|
||
HWC2_ALOGI("Support VDS: w=%u,h=%u,f=%d display-id=%d",width,height,*format,virtual_display_id);
|
||
auto &display = resource_manager_->GetHwc2()->displays_.at(0);
|
||
display.InvalidateControl(30,-1);
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
return HWC2::Error::NoResources;
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::DestroyVirtualDisplay(hwc2_display_t display) {
|
||
|
||
HWC2_ALOGD_IF_VERBOSE();
|
||
auto virtual_display = displays_.find(display);
|
||
if(virtual_display != displays_.end()){
|
||
displays_.erase(virtual_display);
|
||
resource_manager_->DisableWriteBackMode(resource_manager_->GetWBDisplay());
|
||
HWC2_ALOGI("VDS: display-id=%" PRIu64 , display);
|
||
mVirtualDisplayCount_--;
|
||
auto &display = resource_manager_->GetHwc2()->displays_.at(0);
|
||
display.InvalidateControl(30,0);
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
return HWC2::Error::BadDisplay;
|
||
}
|
||
|
||
void DrmHwcTwo::Dump(uint32_t *size, char *buffer) {
|
||
if (buffer != nullptr) {
|
||
auto copiedBytes = mDumpString.copy(buffer, *size);
|
||
*size = static_cast<uint32_t>(copiedBytes);
|
||
return;
|
||
}
|
||
String8 output;
|
||
|
||
char acVersion[50] = {0};
|
||
strcpy(acVersion,GHWC_VERSION);
|
||
|
||
output.appendFormat("-- HWC2 Version %s by bin.li@rock-chips.com --\n",acVersion);
|
||
for(auto &map_disp: displays_){
|
||
output.append("\n");
|
||
if((map_disp.second.DumpDisplayInfo(output)) < 0)
|
||
continue;
|
||
}
|
||
mDumpString = output.string();
|
||
*size = static_cast<uint32_t>(mDumpString.size());
|
||
return;
|
||
}
|
||
|
||
uint32_t DrmHwcTwo::GetMaxVirtualDisplayCount() {
|
||
HWC2_ALOGI();
|
||
|
||
// DSI 固件不支持 HW VirtualDisplay.
|
||
if(hwc_get_int_property("ro.vendor.rk_sdk","0") == 0){
|
||
HWC2_ALOGI("Maybe GSI SDK, to disable HW VirtualDisplay\n");
|
||
return 0;
|
||
}
|
||
|
||
char value[PROPERTY_VALUE_MAX];
|
||
property_get("vendor.hwc.max_virtual_display_count", value, "5");
|
||
return atoi(value);
|
||
}
|
||
|
||
static bool isValid(HWC2::Callback descriptor) {
|
||
switch (descriptor) {
|
||
case HWC2::Callback::Hotplug: // Fall-through
|
||
case HWC2::Callback::Refresh: // Fall-through
|
||
case HWC2::Callback::Vsync: return true;
|
||
default: return false;
|
||
}
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::RegisterCallback(int32_t descriptor,
|
||
hwc2_callback_data_t data,
|
||
hwc2_function_pointer_t function) {
|
||
HWC2_ALOGD_IF_VERBOSE();
|
||
|
||
auto callback = static_cast<HWC2::Callback>(descriptor);
|
||
|
||
if (!isValid(callback)) {
|
||
return HWC2::Error::BadParameter;
|
||
}
|
||
|
||
if (!function) {
|
||
callbacks_.erase(callback);
|
||
switch (callback) {
|
||
case HWC2::Callback::Vsync: {
|
||
for (std::pair<const hwc2_display_t, DrmHwcTwo::HwcDisplay> &d :
|
||
displays_)
|
||
d.second.UnregisterVsyncCallback();
|
||
break;
|
||
}
|
||
case HWC2::Callback::Refresh: {
|
||
for (std::pair<const hwc2_display_t, DrmHwcTwo::HwcDisplay> &d :
|
||
displays_)
|
||
d.second.UnregisterInvalidateCallback();
|
||
break;
|
||
}
|
||
default:
|
||
break;
|
||
}
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
callbacks_.emplace(callback, HwcCallback(data, function));
|
||
|
||
switch (callback) {
|
||
case HWC2::Callback::Hotplug: {
|
||
auto hotplug = reinterpret_cast<HWC2_PFN_HOTPLUG>(function);
|
||
hotplug(data, HWC_DISPLAY_PRIMARY,
|
||
static_cast<int32_t>(HWC2::Connection::Connected));
|
||
// 主屏已经向SurfaceFlinger注册
|
||
mHasRegisterDisplay_.insert(HWC_DISPLAY_PRIMARY);
|
||
auto &drmDevices = resource_manager_->GetDrmDevices();
|
||
for (auto &device : drmDevices)
|
||
HandleInitialHotplugState(device.get());
|
||
break;
|
||
}
|
||
case HWC2::Callback::Vsync: {
|
||
for (std::pair<const hwc2_display_t, DrmHwcTwo::HwcDisplay> &d :
|
||
displays_)
|
||
d.second.RegisterVsyncCallback(data, function);
|
||
break;
|
||
}
|
||
case HWC2::Callback::Refresh: {
|
||
for (std::pair<const hwc2_display_t, DrmHwcTwo::HwcDisplay> &d :
|
||
displays_)
|
||
d.second.RegisterInvalidateCallback(data, function);
|
||
break;
|
||
}
|
||
default:
|
||
break;
|
||
}
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
DrmHwcTwo::HwcDisplay::HwcDisplay(ResourceManager *resource_manager,
|
||
DrmDevice *drm,
|
||
std::shared_ptr<Importer> importer,
|
||
hwc2_display_t handle, HWC2::DisplayType type)
|
||
: resource_manager_(resource_manager),
|
||
drm_(drm),
|
||
importer_(importer),
|
||
handle_(handle),
|
||
type_(type),
|
||
client_layer_(UINT32_MAX,drm),
|
||
output_layer_(UINT32_MAX,drm),
|
||
init_success_(false){
|
||
}
|
||
|
||
int DrmHwcTwo::HwcDisplay::ClearDisplay() {
|
||
if(!init_success_){
|
||
HWC2_ALOGE("display=%" PRIu64 " init_success_=%d skip.", handle_, init_success_);
|
||
return -1;
|
||
}
|
||
|
||
if(connector_ != NULL &&
|
||
connector_->hwc_state() != HwcConnnectorStete::RELEASE_CRTC){
|
||
compositor_->ClearDisplay();
|
||
}
|
||
|
||
HWC2_ALOGD_IF_VERBOSE("display-id=%" PRIu64,handle_);
|
||
return 0;
|
||
}
|
||
|
||
int DrmHwcTwo::HwcDisplay::ActiveModeChange(bool change) {
|
||
HWC2_ALOGD_IF_VERBOSE("display-id=%" PRIu64,handle_);
|
||
bActiveModeChange_ = change;
|
||
return 0;
|
||
}
|
||
|
||
bool DrmHwcTwo::HwcDisplay::IsActiveModeChange() {
|
||
HWC2_ALOGD_IF_VERBOSE("display-id=%" PRIu64,handle_);
|
||
return bActiveModeChange_;
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::HwcDisplay::Init() {
|
||
|
||
HWC2_ALOGD_IF_VERBOSE("display-id=%" PRIu64,handle_);
|
||
|
||
int display = static_cast<int>(handle_);
|
||
|
||
if(sync_timeline_.isValid()){
|
||
HWC2_ALOGD_IF_INFO("sync_timeline_ fd = %d isValid", sync_timeline_.getFd());
|
||
}
|
||
|
||
connector_ = drm_->GetConnectorForDisplay(display);
|
||
if (!connector_) {
|
||
ALOGE("Failed to get connector for display %d", display);
|
||
return HWC2::Error::BadDisplay;
|
||
}
|
||
|
||
int ret = vsync_worker_.Init(drm_, display);
|
||
if (ret) {
|
||
ALOGE("Failed to create event worker for d=%d %d\n", display, ret);
|
||
return HWC2::Error::BadDisplay;
|
||
}
|
||
|
||
ret = invalidate_worker_.Init(display);
|
||
if (ret) {
|
||
ALOGE("Failed to create invalidate worker for d=%d %d\n", display, ret);
|
||
return HWC2::Error::BadDisplay;
|
||
}
|
||
|
||
if(connector_->state() != DRM_MODE_CONNECTED){
|
||
ALOGI("Connector %u type=%s, type_id=%d, state is DRM_MODE_DISCONNECTED, skip init.\n",
|
||
connector_->id(),
|
||
drm_->connector_type_str(connector_->type()),
|
||
connector_->type_id());
|
||
return HWC2::Error::NoResources;
|
||
}
|
||
|
||
// RK3528 HDMI/TV互斥模式要求，若HDMI已连接，则 TV不注册
|
||
if(gIsRK3528() && connector_->type() == DRM_MODE_CONNECTOR_TV){
|
||
DrmConnector* primary = drm_->GetConnectorForDisplay(HWC_DISPLAY_PRIMARY);
|
||
if(primary && primary->state() == DRM_MODE_CONNECTED){
|
||
ret = drm_->ReleaseDpyRes(handle_);
|
||
if (ret) {
|
||
HWC2_ALOGE("Failed to ReleaseDpyRes for display=%d %d\n", display, ret);
|
||
return HWC2::Error::NoResources;
|
||
}
|
||
return HWC2::Error::None;
|
||
}
|
||
}
|
||
|
||
UpdateDisplayMode();
|
||
ret = drm_->BindDpyRes(handle_);
|
||
if (ret) {
|
||
HWC2_ALOGE("Failed to BindDpyRes for display=%d %d\n", display, ret);
|
||
return HWC2::Error::NoResources;
|
||
}
|
||
UpdateDisplayInfo();
|
||
|
||
ret = drm_->UpdateDisplayGamma(handle_);
|
||
if (ret) {
|
||
HWC2_ALOGE("Failed to UpdateDisplayGamma for display=%d %d\n", display, ret);
|
||
}
|
||
|
||
ret = drm_->UpdateDisplay3DLut(handle_);
|
||
if (ret) {
|
||
HWC2_ALOGE("Failed to UpdateDisplay3DLut for display=%d %d\n", display, ret);
|
||
}
|
||
|
||
crtc_ = drm_->GetCrtcForDisplay(display);
|
||
if (!crtc_) {
|
||
ALOGE("Failed to get crtc for display %d", display);
|
||
return HWC2::Error::BadDisplay;
|
||
}
|
||
|
||
// VRR
|
||
ret = connector_->UpdateModes();
|
||
if(ret){
|
||
ALOGE("Failed to update display modes %d", ret);
|
||
return HWC2::Error::BadDisplay;
|
||
}
|
||
bVrrDisplay_ = crtc_->is_vrr();
|
||
|
||
// 更新 hotplug 状态
|
||
connector_->update_hotplug_state();
|
||
|
||
planner_ = Planner::CreateInstance(drm_);
|
||
if (!planner_) {
|
||
ALOGE("Failed to create planner instance for composition");
|
||
return HWC2::Error::NoResources;
|
||
}
|
||
|
||
compositor_ = resource_manager_->GetDrmDisplayCompositor(crtc_);
|
||
ret = compositor_->Init(resource_manager_, display);
|
||
if (ret) {
|
||
ALOGE("Failed display compositor init for display %d (%d)", display, ret);
|
||
return HWC2::Error::NoResources;
|
||
}
|
||
|
||
// CropSpilt must to
|
||
if(connector_->isCropSpilt()){
|
||
std::unique_ptr<DrmDisplayComposition> composition = compositor_->CreateComposition();
|
||
composition->Init(drm_, crtc_, importer_.get(), planner_.get(), frame_no_, handle_);
|
||
composition->SetDpmsMode(DRM_MODE_DPMS_ON);
|
||
ret = compositor_->QueueComposition(std::move(composition));
|
||
if (ret) {
|
||
HWC2_ALOGE("Failed to apply the dpms composition ret=%d", ret);
|
||
}
|
||
}
|
||
|
||
// soc_id
|
||
ctx_.soc_id = resource_manager_->getSocId();
|
||
// display_id
|
||
ctx_.display_id = display;
|
||
// display-type
|
||
ctx_.display_type = connector_->type();
|
||
// vop aclk
|
||
ctx_.aclk = crtc_->get_aclk();
|
||
// Baseparameter Info
|
||
ctx_.baseparameter_info = connector_->baseparameter_info();
|
||
// Standard Switch Resolution Mode
|
||
ctx_.bStandardSwitchResolution = hwc_get_bool_property("vendor.hwc.enable_display_configs","false");
|
||
|
||
HWC2::Error error = ChosePreferredConfig();
|
||
if(error != HWC2::Error::None){
|
||
ALOGE("Failed to chose prefererd config for display %d (%d)", display, error);
|
||
return error;
|
||
}
|
||
|
||
init_success_ = true;
|
||
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
|
||
HWC2::Error DrmHwcTwo::HwcDisplay::InitVirtual() {
|
||
|
||
HWC2_ALOGD_IF_VERBOSE("display-id=%" PRIu64 " type=%s",handle_,
|
||
(type_ == HWC2::DisplayType::Physical ? "Physical" : "Virtual"));
|
||
|
||
int display = static_cast<int>(handle_);
|
||
|
||
connector_ = drm_->GetWritebackConnectorForDisplay(0);
|
||
if (!connector_) {
|
||
ALOGE("Failed to get connector for display %d", display);
|
||
return HWC2::Error::BadDisplay;
|
||
}
|
||
|
||
init_success_ = true;
|
||
frame_no_ = 0;
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::HwcDisplay::CheckStateAndReinit(bool clear_layer) {
|
||
|
||
HWC2_ALOGD_IF_VERBOSE("display-id=%" PRIu64,handle_);
|
||
|
||
int display = static_cast<int>(handle_);
|
||
|
||
connector_ = drm_->GetConnectorForDisplay(display);
|
||
if (!connector_) {
|
||
ALOGE("Failed to get connector for display %d", display);
|
||
return HWC2::Error::BadDisplay;
|
||
}
|
||
|
||
if(connector_->state() != DRM_MODE_CONNECTED){
|
||
ALOGI("Connector %u type=%s, type_id=%d, state is DRM_MODE_DISCONNECTED, skip init.\n",
|
||
connector_->id(),drm_->connector_type_str(connector_->type()),connector_->type_id());
|
||
return HWC2::Error::NoResources;
|
||
}
|
||
|
||
UpdateDisplayMode();
|
||
int ret = drm_->BindDpyRes(handle_);
|
||
if (ret) {
|
||
HWC2_ALOGE("Failed to BindDpyRes for display=%d %d\n", display, ret);
|
||
return HWC2::Error::NoResources;
|
||
}
|
||
|
||
UpdateDisplayInfo();
|
||
|
||
crtc_ = drm_->GetCrtcForDisplay(display);
|
||
if (!crtc_) {
|
||
ALOGE("Failed to get crtc for display %d", display);
|
||
return HWC2::Error::BadDisplay;
|
||
}
|
||
|
||
bVrrDisplay_ = crtc_->is_vrr();
|
||
|
||
ret = drm_->UpdateDisplayGamma(handle_);
|
||
if (ret) {
|
||
HWC2_ALOGE("Failed to UpdateDisplayGamma for display=%d %d\n", display, ret);
|
||
}
|
||
|
||
ret = drm_->UpdateDisplay3DLut(handle_);
|
||
if (ret) {
|
||
HWC2_ALOGE("Failed to UpdateDisplay3DLut for display=%d %d\n", display, ret);
|
||
}
|
||
|
||
// Reset HwcLayer resource
|
||
if(clear_layer && handle_ != HWC_DISPLAY_PRIMARY){
|
||
// Clear Layers
|
||
for(auto &map_layer : layers_){
|
||
map_layer.second.clear();
|
||
}
|
||
// Bug: #359894
|
||
// layers_ not clear may cause error log:
|
||
// "E hwc-platform-drm-generic: ImportBuffer fail fd=7,w=-1,h=-1,bo->format=AB24 ..."
|
||
layers_.clear();
|
||
// Clear Client Target Layer
|
||
client_layer_.clear();
|
||
}
|
||
|
||
compositor_ = resource_manager_->GetDrmDisplayCompositor(crtc_);
|
||
ret = compositor_->Init(resource_manager_, display);
|
||
if (ret) {
|
||
ALOGE("Failed display compositor init for display %d (%d)", display, ret);
|
||
return HWC2::Error::NoResources;
|
||
}
|
||
|
||
if(init_success_){
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
planner_ = Planner::CreateInstance(drm_);
|
||
if (!planner_) {
|
||
ALOGE("Failed to create planner instance for composition");
|
||
return HWC2::Error::NoResources;
|
||
}
|
||
|
||
// soc_id
|
||
ctx_.soc_id = resource_manager_->getSocId();
|
||
// display_id
|
||
ctx_.display_id = display;
|
||
// display-type
|
||
ctx_.display_type = connector_->type();
|
||
// vop aclk
|
||
ctx_.aclk = crtc_->get_aclk();
|
||
// Baseparameter Info
|
||
ctx_.baseparameter_info = connector_->baseparameter_info();
|
||
// Standard Switch Resolution Mode
|
||
ctx_.bStandardSwitchResolution = hwc_get_bool_property("vendor.hwc.enable_display_configs","false");
|
||
|
||
HWC2::Error error = ChosePreferredConfig();
|
||
if(error != HWC2::Error::None){
|
||
ALOGE("Failed to chose prefererd config for display %d (%d)", display, error);
|
||
return error;
|
||
}
|
||
|
||
init_success_ = true;
|
||
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
|
||
HWC2::Error DrmHwcTwo::HwcDisplay::CheckDisplayState(){
|
||
HWC2_ALOGD_IF_VERBOSE("display-id=%" PRIu64,handle_);
|
||
int display = static_cast<int>(handle_);
|
||
|
||
if(!init_success_){
|
||
ALOGE_IF(LogLevel(DBG_ERROR),"Display %d not init success! %s,line=%d", display,
|
||
__FUNCTION__, __LINE__);
|
||
return HWC2::Error::BadDisplay;
|
||
}
|
||
|
||
connector_ = drm_->GetConnectorForDisplay(display);
|
||
if (!connector_) {
|
||
ALOGE_IF(LogLevel(DBG_ERROR),"Failed to get connector for display %d, %s,line=%d",
|
||
display, __FUNCTION__, __LINE__);
|
||
return HWC2::Error::BadDisplay;
|
||
}
|
||
|
||
if(connector_->state() != DRM_MODE_CONNECTED){
|
||
ALOGE_IF(LogLevel(DBG_ERROR),"Connector %u type=%s, type_id=%d, state is DRM_MODE_DISCONNECTED, skip init, %s,line=%d\n",
|
||
connector_->id(),drm_->connector_type_str(connector_->type()),connector_->type_id(),
|
||
__FUNCTION__, __LINE__);
|
||
return HWC2::Error::NoResources;
|
||
}
|
||
|
||
crtc_ = drm_->GetCrtcForDisplay(display);
|
||
if (!crtc_) {
|
||
ALOGE_IF(LogLevel(DBG_ERROR),"Failed to get crtc for display %d, %s,line=%d", display,
|
||
__FUNCTION__, __LINE__);
|
||
return HWC2::Error::BadDisplay;
|
||
}
|
||
|
||
if(!layers_.size()){
|
||
ALOGE_IF(LogLevel(DBG_ERROR),"display %d layer size is %zu, %s,line=%d", display, layers_.size(),
|
||
__FUNCTION__, __LINE__);
|
||
return HWC2::Error::BadLayer;
|
||
}
|
||
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
|
||
HWC2::Error DrmHwcTwo::HwcDisplay::ChosePreferredConfig() {
|
||
HWC2_ALOGD_IF_VERBOSE("display-id=%" PRIu64,handle_);
|
||
// Fetch the number of modes from the display
|
||
uint32_t num_configs;
|
||
HWC2::Error err = GetDisplayConfigs(&num_configs, NULL);
|
||
if (err != HWC2::Error::None || !num_configs)
|
||
return err;
|
||
|
||
err = SetActiveConfig(connector_->active_mode().id());
|
||
return err;
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::HwcDisplay::RegisterVsyncCallback(
|
||
hwc2_callback_data_t data, hwc2_function_pointer_t func) {
|
||
HWC2_ALOGD_IF_VERBOSE("display-id=%" PRIu64,handle_);
|
||
auto callback = std::make_shared<DrmVsyncCallback>(data, func);
|
||
vsync_worker_.RegisterCallback(std::move(callback));
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::HwcDisplay::RegisterInvalidateCallback(
|
||
hwc2_callback_data_t data, hwc2_function_pointer_t func) {
|
||
HWC2_ALOGD_IF_VERBOSE("display-id=%" PRIu64,handle_);
|
||
auto callback = std::make_shared<DrmInvalidateCallback>(data, func);
|
||
invalidate_worker_.RegisterCallback(std::move(callback));
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::HwcDisplay::UnregisterVsyncCallback() {
|
||
HWC2_ALOGD_IF_VERBOSE("display-id=%" PRIu64,handle_);;
|
||
vsync_worker_.RegisterCallback(NULL);
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::HwcDisplay::UnregisterInvalidateCallback() {
|
||
HWC2_ALOGD_IF_VERBOSE("display-id=%" PRIu64,handle_);
|
||
invalidate_worker_.RegisterCallback(NULL);
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
|
||
HWC2::Error DrmHwcTwo::HwcDisplay::AcceptDisplayChanges() {
|
||
HWC2_ALOGD_IF_VERBOSE("display-id=%" PRIu64,handle_);
|
||
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) {
|
||
layers_.emplace(static_cast<hwc2_layer_t>(layer_idx_), HwcLayer(layer_idx_, drm_));
|
||
*layer = static_cast<hwc2_layer_t>(layer_idx_);
|
||
++layer_idx_;
|
||
HWC2_ALOGD_IF_VERBOSE("display-id=%" PRIu64 ", layer-id=%" PRIu64,handle_,*layer);
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::HwcDisplay::DestroyLayer(hwc2_layer_t layer) {
|
||
HWC2_ALOGD_IF_VERBOSE("display-id=%" PRIu64 ", layer-id=%" PRIu64,handle_,layer);
|
||
auto map_layer = layers_.find(layer);
|
||
if (map_layer != layers_.end()){
|
||
map_layer->second.clear();
|
||
layers_.erase(layer);
|
||
return HWC2::Error::None;
|
||
}else{
|
||
return HWC2::Error::BadLayer;
|
||
}
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::HwcDisplay::GetActiveConfig(hwc2_config_t *config) {
|
||
HWC2_ALOGD_IF_VERBOSE("display-id=%" PRIu64 ,handle_);
|
||
|
||
if(ctx_.bStandardSwitchResolution){
|
||
DrmMode const &mode = connector_->active_mode();
|
||
if (mode.id() == 0)
|
||
return HWC2::Error::BadConfig;
|
||
|
||
DrmMode const &best_mode = connector_->best_mode();
|
||
|
||
|
||
if(connector_->isHorizontalSpilt()){
|
||
ctx_.framebuffer_width = best_mode.h_display() / 2;
|
||
ctx_.framebuffer_height = best_mode.v_display();
|
||
}else{
|
||
ctx_.framebuffer_width = best_mode.h_display();
|
||
ctx_.framebuffer_height = best_mode.v_display();
|
||
}
|
||
|
||
*config = mode.id();
|
||
}else{
|
||
*config = 0;
|
||
}
|
||
HWC2_ALOGD_IF_VERBOSE("display-id=%" PRIu64 " config-id=%d" ,handle_,*config);
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::HwcDisplay::GetChangedCompositionTypes(
|
||
uint32_t *num_elements, hwc2_layer_t *layers, int32_t *types) {
|
||
HWC2_ALOGD_IF_VERBOSE("display-id=%" PRIu64,handle_);
|
||
uint32_t num_changes = 0;
|
||
for (std::pair<const hwc2_layer_t, DrmHwcTwo::HwcLayer> &l : layers_) {
|
||
if (l.second.type_changed()) {
|
||
if (layers && num_changes < *num_elements)
|
||
layers[num_changes] = l.first;
|
||
if (types && num_changes < *num_elements)
|
||
types[num_changes] = static_cast<int32_t>(l.second.validated_type());
|
||
++num_changes;
|
||
}
|
||
}
|
||
if (!layers && !types)
|
||
*num_elements = num_changes;
|
||
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::HwcDisplay::GetClientTargetSupport(uint32_t width,
|
||
uint32_t height,
|
||
int32_t /*format*/,
|
||
int32_t dataspace) {
|
||
HWC2_ALOGD_IF_VERBOSE("display-id=%" PRIu64,handle_);
|
||
std::pair<uint32_t, uint32_t> min = drm_->min_resolution();
|
||
std::pair<uint32_t, uint32_t> max = drm_->max_resolution();
|
||
|
||
if (width < min.first || height < min.second)
|
||
return HWC2::Error::Unsupported;
|
||
|
||
if (width > max.first || height > max.second)
|
||
return HWC2::Error::Unsupported;
|
||
|
||
if (dataspace != HAL_DATASPACE_UNKNOWN &&
|
||
dataspace != HAL_DATASPACE_STANDARD_UNSPECIFIED)
|
||
return HWC2::Error::Unsupported;
|
||
|
||
// TODO: Validate format can be handled by either GL or planes
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::HwcDisplay::GetColorModes(uint32_t *num_modes,
|
||
int32_t *modes) {
|
||
HWC2_ALOGD_IF_VERBOSE("display-id=%" PRIu64,handle_);
|
||
if (!modes)
|
||
*num_modes = 1;
|
||
|
||
if (modes)
|
||
*modes = HAL_COLOR_MODE_NATIVE;
|
||
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::HwcDisplay::GetDisplayAttribute(hwc2_config_t config,
|
||
int32_t attribute_in,
|
||
int32_t *value) {
|
||
HWC2_ALOGD_IF_VERBOSE("display-id=%" PRIu64,handle_);
|
||
|
||
if(ctx_.bStandardSwitchResolution){
|
||
auto mode = std::find_if(sf_modes_.begin(),
|
||
sf_modes_.end(),
|
||
[config](DrmMode const &m) {
|
||
return m.id() == config;
|
||
});
|
||
if (mode == sf_modes_.end()) {
|
||
ALOGE("Could not find active mode for %d", config);
|
||
return HWC2::Error::BadConfig;
|
||
}
|
||
|
||
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();
|
||
break;
|
||
case HWC2::Attribute::Height:
|
||
*value = mode->v_display();
|
||
break;
|
||
case HWC2::Attribute::VsyncPeriod:
|
||
// in nanoseconds
|
||
*value = 1000 * 1000 * 1000 / mode->v_refresh();
|
||
break;
|
||
case HWC2::Attribute::DpiX:
|
||
// Dots per 1000 inches
|
||
*value = mm_width ? (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;
|
||
break;
|
||
default:
|
||
*value = -1;
|
||
return HWC2::Error::BadConfig;
|
||
}
|
||
}else{
|
||
|
||
static const int32_t kUmPerInch = 25400;
|
||
uint32_t mm_width = connector_->mm_width();
|
||
uint32_t mm_height = connector_->mm_height();
|
||
int w = ctx_.framebuffer_width;
|
||
int h = ctx_.framebuffer_height;
|
||
int vrefresh = ctx_.vrefresh;
|
||
// VRR
|
||
const std::vector<int> vrr_mode = connector_->vrr_modes();
|
||
if (bVrrDisplay_ && vrr_mode.size() > 1
|
||
&& config < vrr_mode.size()) {
|
||
vrefresh = vrr_mode[config];
|
||
}
|
||
auto attribute = static_cast<HWC2::Attribute>(attribute_in);
|
||
switch (attribute) {
|
||
case HWC2::Attribute::Width:
|
||
*value = w;
|
||
break;
|
||
case HWC2::Attribute::Height:
|
||
*value = h;
|
||
break;
|
||
case HWC2::Attribute::VsyncPeriod:
|
||
// in nanoseconds
|
||
*value = 1000 * 1000 * 1000 / vrefresh;
|
||
break;
|
||
case HWC2::Attribute::DpiX:
|
||
// Dots per 1000 inches
|
||
*value = mm_width ? (w * kUmPerInch) / mm_width : -1;
|
||
break;
|
||
case HWC2::Attribute::DpiY:
|
||
// Dots per 1000 inches
|
||
*value = mm_height ? (h * kUmPerInch) / mm_height : -1;
|
||
break;
|
||
default:
|
||
*value = -1;
|
||
return HWC2::Error::BadConfig;
|
||
}
|
||
}
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::HwcDisplay::GetDisplayConfigs(uint32_t *num_configs,
|
||
hwc2_config_t *configs) {
|
||
HWC2_ALOGD_IF_VERBOSE("display-id=%" PRIu64,handle_);
|
||
// 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
|
||
// it's possible this will result in stale modes, it'll all come out in the
|
||
// wash when we try to set the active config later.
|
||
if (!configs) {
|
||
if (!connector_->ModesReady()) {
|
||
int ret = connector_->UpdateModes();
|
||
if(ret){
|
||
ALOGE("Failed to update display modes %d", ret);
|
||
return HWC2::Error::BadDisplay;
|
||
}
|
||
}
|
||
}
|
||
if(ctx_.bStandardSwitchResolution){
|
||
// 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: 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 preferred_mode = std::find_if(connector_->modes().begin(),
|
||
connector_->modes().end(), [&](DrmMode const &m) {
|
||
return m.id() ==
|
||
connector_->get_preferred_mode_id();
|
||
});
|
||
if (preferred_mode != connector_->modes().end())
|
||
sel_modes.push_back(*preferred_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: Remove this when 3D Attributes are in AOSP
|
||
if (mode.flags() & DRM_MODE_FLAG_3D_MASK)
|
||
continue;
|
||
|
||
// TODO: 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);
|
||
|
||
continue;
|
||
}
|
||
|
||
// 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: 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);
|
||
}
|
||
|
||
auto num_modes = static_cast<uint32_t>(sel_modes.size());
|
||
sf_modes_.swap(sel_modes);
|
||
if (!configs) {
|
||
*num_configs = num_modes;
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
uint32_t idx = 0;
|
||
for (const DrmMode &mode : sel_modes) {
|
||
if (idx >= *num_configs)
|
||
break;
|
||
configs[idx++] = mode.id();
|
||
}
|
||
|
||
|
||
*num_configs = sf_modes_.size();
|
||
}else{
|
||
UpdateDisplayInfo();
|
||
const DrmMode best_mode = connector_->active_mode();
|
||
|
||
char framebuffer_size[PROPERTY_VALUE_MAX];
|
||
uint32_t width = 0, height = 0 , vrefresh = 0;
|
||
|
||
connector_->GetFramebufferInfo(handle_, &width, &height, &vrefresh);
|
||
|
||
if (width && height) {
|
||
ctx_.framebuffer_width = width;
|
||
ctx_.framebuffer_height = height;
|
||
ctx_.vrefresh = vrefresh ? vrefresh : 60;
|
||
} else if (best_mode.h_display() && best_mode.v_display() && best_mode.v_refresh()) {
|
||
ctx_.framebuffer_width = best_mode.h_display();
|
||
ctx_.framebuffer_height = best_mode.v_display();
|
||
ctx_.vrefresh = best_mode.v_refresh();
|
||
/*
|
||
* RK3588：Limit to 4096x2160 if large than 2160p
|
||
* Other: Limit to 1920x1080 if large than 2160p
|
||
*/
|
||
if(isRK3588(resource_manager_->getSocId())){
|
||
if (ctx_.framebuffer_height >= 2160 && ctx_.framebuffer_width >= ctx_.framebuffer_height) {
|
||
ctx_.framebuffer_width = ctx_.framebuffer_width * (2160.0 / ctx_.framebuffer_height);
|
||
ctx_.framebuffer_height = 2160;
|
||
}
|
||
}else{
|
||
if (ctx_.framebuffer_height >= 2160 && ctx_.framebuffer_width >= ctx_.framebuffer_height) {
|
||
ctx_.framebuffer_width = ctx_.framebuffer_width * (1080.0 / ctx_.framebuffer_height);
|
||
ctx_.framebuffer_height = 1080;
|
||
}
|
||
}
|
||
} else {
|
||
ctx_.framebuffer_width = 1920;
|
||
ctx_.framebuffer_height = 1080;
|
||
ctx_.vrefresh = 60;
|
||
ALOGE("Failed to find available display mode for display %" PRIu64 "\n", handle_);
|
||
}
|
||
|
||
if(connector_->isHorizontalSpilt()){
|
||
ctx_.rel_xres = best_mode.h_display() / DRM_CONNECTOR_SPILT_RATIO;
|
||
ctx_.rel_yres = best_mode.v_display();
|
||
ctx_.framebuffer_width = ctx_.framebuffer_width / DRM_CONNECTOR_SPILT_RATIO;
|
||
if(handle_ >= DRM_CONNECTOR_SPILT_MODE_MASK){
|
||
ctx_.rel_xoffset = best_mode.h_display() / DRM_CONNECTOR_SPILT_RATIO;
|
||
ctx_.rel_yoffset = 0;//best_mode.v_display() / 2;
|
||
}
|
||
}else if(connector_->isCropSpilt()){
|
||
int32_t fb_w = 0, fb_h = 0;
|
||
connector_->getCropSpiltFb(&fb_w, &fb_h);
|
||
ctx_.framebuffer_width = fb_w;
|
||
ctx_.framebuffer_height = fb_h;
|
||
ctx_.rel_xres = best_mode.h_display();
|
||
ctx_.rel_yres = best_mode.v_display();
|
||
}else{
|
||
ctx_.rel_xres = best_mode.h_display();
|
||
ctx_.rel_yres = best_mode.v_display();
|
||
}
|
||
|
||
// 动态可变刷新率要求将刷新率上报
|
||
if(best_mode.v_refresh() > 0){
|
||
ctx_.vrefresh = best_mode.v_refresh();
|
||
}
|
||
|
||
// AFBC limit
|
||
if(handle_ == HWC_DISPLAY_PRIMARY){
|
||
bool disable_afbdc = false;
|
||
|
||
if(isRK356x(resource_manager_->getSocId())){
|
||
if(ctx_.framebuffer_width % 4 != 0){
|
||
disable_afbdc = true;
|
||
HWC2_ALOGI("RK356x primary framebuffer size %dx%d not support AFBC, to disable AFBC\n",
|
||
ctx_.framebuffer_width,ctx_.framebuffer_height);
|
||
}
|
||
}
|
||
if(hwc_get_int_property("ro.vendor.rk_sdk","0") == 0){
|
||
disable_afbdc = true;
|
||
HWC2_ALOGI("Maybe GSI SDK, to disable AFBC\n");
|
||
}
|
||
if(disable_afbdc){
|
||
property_set( "vendor.gralloc.no_afbc_for_fb_target_layer", "1");
|
||
}
|
||
}
|
||
|
||
const std::vector<int> vrr_mode = connector_->vrr_modes();
|
||
if(bVrrDisplay_ && vrr_mode.size() > 1){
|
||
if (!configs) {
|
||
*num_configs = vrr_mode.size();
|
||
return HWC2::Error::None;
|
||
}
|
||
*num_configs = vrr_mode.size();
|
||
|
||
for(int index = 0 ; index <= vrr_mode.size(); index++){
|
||
configs[index] = index;
|
||
}
|
||
}else{
|
||
if (!configs) {
|
||
*num_configs = 1;
|
||
return HWC2::Error::None;
|
||
}
|
||
*num_configs = 1;
|
||
configs[0] = 0;
|
||
}
|
||
}
|
||
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::HwcDisplay::GetDisplayName(uint32_t *size, char *name) {
|
||
HWC2_ALOGD_IF_VERBOSE("display-id=%" PRIu64,handle_);
|
||
std::ostringstream stream;
|
||
stream << "display-" << connector_->id();
|
||
std::string string = stream.str();
|
||
size_t length = string.length();
|
||
if (!name) {
|
||
*size = length;
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
*size = std::min<uint32_t>(static_cast<uint32_t>(length - 1), *size);
|
||
strncpy(name, string.c_str(), *size);
|
||
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) {
|
||
HWC2_ALOGD_IF_VERBOSE("display-id=%" PRIu64,handle_);
|
||
|
||
uint32_t num_request = 0;
|
||
if(hwc_get_int_property("ro.vendor.rk_sdk","0") == 0){
|
||
HWC2_ALOGD_IF_INFO("Maybe GSI SDK, to disable AFBC\n");
|
||
if (!layers || !layer_requests){
|
||
*num_elements = num_request;
|
||
return HWC2::Error::None;
|
||
}else{
|
||
*display_requests = 0;
|
||
return HWC2::Error::None;
|
||
}
|
||
}
|
||
|
||
// RK3528 Mali 不支持AFBC
|
||
if(gIsRK3528()){
|
||
if (!layers || !layer_requests){
|
||
*num_elements = num_request;
|
||
return HWC2::Error::None;
|
||
}else{
|
||
*display_requests = 0;
|
||
return HWC2::Error::None;
|
||
}
|
||
}
|
||
|
||
// TODO: I think virtual display should request
|
||
// HWC2_DISPLAY_REQUEST_WRITE_CLIENT_TARGET_TO_OUTPUT here
|
||
uint32_t client_layer_id = false;
|
||
for (std::pair<const hwc2_layer_t, DrmHwcTwo::HwcLayer> &l : layers_) {
|
||
if (l.second.validated_type() == HWC2::Composition::Client) {
|
||
client_layer_id = l.first;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if(client_layer_id > 0 && validate_success_ && !client_layer_.isAfbc()){
|
||
num_request++;
|
||
if(display_requests){
|
||
// RK: Reuse HWC2_DISPLAY_REQUEST_FLIP_CLIENT_TARGET definition to
|
||
// implement ClientTarget feature.
|
||
*display_requests = HWC2_DISPLAY_REQUEST_FLIP_CLIENT_TARGET;
|
||
}
|
||
}else{
|
||
*display_requests = 0;
|
||
}
|
||
|
||
if (!layers || !layer_requests)
|
||
*num_elements = num_request;
|
||
else{
|
||
layers[0] = client_layer_id;
|
||
layer_requests[0] = 0;
|
||
}
|
||
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::HwcDisplay::GetDisplayType(int32_t *type) {
|
||
HWC2_ALOGD_IF_VERBOSE("display-id=%" PRIu64,handle_);
|
||
*type = static_cast<int32_t>(type_);
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::HwcDisplay::GetDozeSupport(int32_t *support) {
|
||
HWC2_ALOGD_IF_VERBOSE("display-id=%" PRIu64,handle_);
|
||
*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) {
|
||
HWC2_ALOGD_IF_VERBOSE("display-id=%" PRIu64,handle_);
|
||
|
||
int display = static_cast<int>(handle_);
|
||
int HdrIndex = 0;
|
||
|
||
if (!connector_) {
|
||
ALOGE("%s:Failed to get connector for display %d line=%d", __FUNCTION__,display,__LINE__);
|
||
return HWC2::Error::None;
|
||
}
|
||
if(!connector_->ModesReady()){
|
||
int ret = connector_->UpdateModes();
|
||
if (ret) {
|
||
ALOGE("Failed to update display modes %d", ret);
|
||
return HWC2::Error::None;
|
||
}
|
||
}
|
||
const std::vector<DrmHdr> hdr_support_list = connector_->get_hdr_support_list();
|
||
|
||
if(types == NULL){
|
||
*num_types = hdr_support_list.size();
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
for(const DrmHdr &hdr_mode : hdr_support_list){
|
||
types[HdrIndex] = hdr_mode.drmHdrType;
|
||
*max_luminance = hdr_mode.outMaxLuminance;
|
||
*max_average_luminance = hdr_mode.outMaxAverageLuminance;
|
||
*min_luminance = hdr_mode.outMinLuminance;
|
||
HdrIndex++;
|
||
}
|
||
*num_types = hdr_support_list.size();
|
||
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::HwcDisplay::GetReleaseFences(uint32_t *num_elements,
|
||
hwc2_layer_t *layers,
|
||
int32_t *fences) {
|
||
HWC2_ALOGD_IF_VERBOSE("display-id=%" PRIu64,handle_);
|
||
|
||
uint32_t num_layers = 0;
|
||
|
||
for (std::pair<const hwc2_layer_t, DrmHwcTwo::HwcLayer> &l : layers_) {
|
||
++num_layers;
|
||
if (layers == NULL || fences == NULL) {
|
||
continue;
|
||
} else if (num_layers > *num_elements) {
|
||
ALOGW("Overflow num_elements %d/%d", num_layers, *num_elements);
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
layers[num_layers - 1] = l.first;
|
||
fences[num_layers - 1] = l.second.release_fence()->isValid() ? dup(l.second.release_fence()->getFd()) : -1;
|
||
if(LogLevel(DBG_VERBOSE))
|
||
HWC2_ALOGD_IF_VERBOSE("Check Layer %" PRIu64 " Release(%d) %s Info: size=%d act=%d signal=%d err=%d",
|
||
l.first,l.second.release_fence()->isValid(),l.second.release_fence()->getName().c_str(),
|
||
l.second.release_fence()->getSize(), l.second.release_fence()->getActiveCount(),
|
||
l.second.release_fence()->getSignaledCount(), l.second.release_fence()->getErrorCount());
|
||
// HWC2_ALOGD_IF_DEBUG("GetReleaseFences [%" PRIu64 "][%d]",layers[num_layers - 1],fences[num_layers - 1]);
|
||
// the new fence semantics for a frame n by returning the fence from frame n-1. For frame 0,
|
||
// the adapter returns NO_FENCE.
|
||
}
|
||
*num_elements = num_layers;
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
void DrmHwcTwo::HwcDisplay::AddFenceToRetireFence(int fd) {
|
||
HWC2_ALOGD_IF_VERBOSE("display-id=%" PRIu64,handle_);
|
||
|
||
char acBuf[32];
|
||
int retire_fence_fd = -1;
|
||
if (fd < 0){
|
||
// Collet all layer releaseFence
|
||
const sp<ReleaseFence> client_rf = client_layer_.back_release_fence();
|
||
if(client_rf->isValid()){
|
||
retire_fence_fd = dup(client_rf->getFd());
|
||
sprintf(acBuf,"RTD%" PRIu64 "-FN%d-%d", handle_, frame_no_, 0);
|
||
}
|
||
for (std::pair<const hwc2_layer_t, DrmHwcTwo::HwcLayer> &hwc2layer : layers_) {
|
||
if(hwc2layer.second.validated_type() != HWC2::Composition::Device)
|
||
continue;
|
||
// the new fence semantics for a frame n by returning the fence from frame n-1. For frame 0,
|
||
// the adapter returns NO_FENCE.
|
||
const sp<ReleaseFence> rf = hwc2layer.second.back_release_fence();
|
||
if (rf->isValid()){
|
||
// cur_retire_fence is null
|
||
if(retire_fence_fd > 0){
|
||
sprintf(acBuf,"RTD%" PRIu64 "-FN%d-%" PRIu64,handle_, frame_no_, hwc2layer.first);
|
||
int retire_fence_merge = rf->merge(retire_fence_fd, acBuf);
|
||
if(retire_fence_merge > 0){
|
||
close(retire_fence_fd);
|
||
retire_fence_fd = retire_fence_merge;
|
||
HWC2_ALOGD_IF_DEBUG("RetireFence(%d) %s frame = %d merge %s sucess!", retire_fence_fd, acBuf, frame_no_, rf->getName().c_str());
|
||
}else{
|
||
HWC2_ALOGE("RetireFence(%d) %s frame = %d merge %s faile!", retire_fence_fd, acBuf,frame_no_, rf->getName().c_str());
|
||
}
|
||
}else{
|
||
retire_fence_fd = dup(rf->getFd());
|
||
continue;
|
||
}
|
||
}
|
||
}
|
||
}else{
|
||
retire_fence_fd = fd;
|
||
}
|
||
d_retire_fence_.add(retire_fence_fd, acBuf);
|
||
return;
|
||
}
|
||
|
||
bool SortByZpos(const DrmHwcLayer &drmHwcLayer1, const DrmHwcLayer &drmHwcLayer2){
|
||
return drmHwcLayer1.iZpos_ < drmHwcLayer2.iZpos_;
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::HwcDisplay::ModifyHwcLayerDisplayFrame(bool only_fb_scale) {
|
||
|
||
bool need_overscan_by_scale = false;
|
||
// RK3588 不支持Overscan
|
||
if(gIsRK3588()){
|
||
need_overscan_by_scale = true;
|
||
}
|
||
|
||
// 隔行扫描分辨率overscan效果比较差
|
||
if(connector_ &&
|
||
connector_->current_mode().id() > 0 &&
|
||
connector_->current_mode().interlaced() > 0){
|
||
need_overscan_by_scale = true;
|
||
}
|
||
|
||
// 使能 scale
|
||
if(need_overscan_by_scale){
|
||
|
||
for(auto &drmLayer : drm_hwc_layers_){
|
||
if(only_fb_scale && !drmLayer.bFbTarget_)
|
||
continue;
|
||
drmLayer.ModifyDisplayFrameForOverscan(&ctx_);
|
||
}
|
||
}
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::HwcDisplay::InitDrmHwcLayer() {
|
||
drm_hwc_layers_.clear();
|
||
|
||
// now that they're ordered by z, add them to the composition
|
||
for (auto &hwc2layer : layers_) {
|
||
drm_hwc_layers_.emplace_back();
|
||
DrmHwcLayer &drmHwclayer = drm_hwc_layers_.back();
|
||
hwc2layer.second.PopulateDrmLayer(hwc2layer.first, &drmHwclayer, &ctx_, frame_no_);
|
||
}
|
||
|
||
std::sort(drm_hwc_layers_.begin(),drm_hwc_layers_.end(),SortByZpos);
|
||
|
||
uint32_t client_id = 0;
|
||
drm_hwc_layers_.emplace_back();
|
||
DrmHwcLayer &client_target_layer = drm_hwc_layers_.back();
|
||
client_layer_.PopulateFB(client_id, &client_target_layer, &ctx_, frame_no_, true);
|
||
#ifdef USE_LIBPQ
|
||
if(handle_ == 0){
|
||
int ret = client_layer_.DoPq(true, &client_target_layer, &ctx_);
|
||
if(ret){
|
||
HWC2_ALOGE("ClientLayer DoPq fail, ret = %d", ret);
|
||
}
|
||
}
|
||
#endif
|
||
|
||
ALOGD_HWC2_DRM_LAYER_INFO((DBG_INFO),drm_hwc_layers_);
|
||
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
|
||
|
||
HWC2::Error DrmHwcTwo::HwcDisplay::ValidatePlanes() {
|
||
HWC2_ALOGD_IF_VERBOSE("display-id=%" PRIu64,handle_);
|
||
int ret;
|
||
|
||
InitDrmHwcLayer();
|
||
|
||
// 需要修改 HwcLayer display frame 的情况列举：
|
||
// 1. RK3588 不支持Overscan
|
||
// 2. 隔行扫描分辨率 overscan 效果较差
|
||
// 3. RK3528 运营商版本需要提供视频显示区域修改接口
|
||
ModifyHwcLayerDisplayFrame(false);
|
||
|
||
std::vector<DrmHwcLayer *> layers;
|
||
layers.reserve(drm_hwc_layers_.size());
|
||
for(size_t i = 0; i < drm_hwc_layers_.size(); ++i){
|
||
layers.push_back(&drm_hwc_layers_[i]);
|
||
}
|
||
|
||
std::vector<PlaneGroup *> plane_groups;
|
||
DrmDevice *drm = crtc_->getDrmDevice();
|
||
plane_groups.clear();
|
||
std::vector<PlaneGroup *> all_plane_groups = drm->GetPlaneGroups();
|
||
for(auto &plane_group : all_plane_groups){
|
||
if(plane_group->acquire(1 << crtc_->pipe(), handle_)){
|
||
plane_groups.push_back(plane_group);
|
||
}
|
||
}
|
||
|
||
std::tie(ret,
|
||
composition_planes_) = planner_->TryHwcPolicy(layers, plane_groups, crtc_,
|
||
static_screen_opt_ ||
|
||
force_gles_ ||
|
||
connector_->isCropSpilt());
|
||
if (ret){
|
||
ALOGE("First, GLES policy fail ret=%d", ret);
|
||
return HWC2::Error::BadConfig;
|
||
}
|
||
|
||
for (auto &drm_hwc_layer : drm_hwc_layers_) {
|
||
if(drm_hwc_layer.bFbTarget_){
|
||
if(drm_hwc_layer.bAfbcd_)
|
||
client_layer_.EnableAfbc();
|
||
else
|
||
client_layer_.DisableAfbc();
|
||
continue;
|
||
}
|
||
if(drm_hwc_layer.bMatch_){
|
||
auto map_hwc2layer = layers_.find(drm_hwc_layer.uId_);
|
||
map_hwc2layer->second.set_validated_type(HWC2::Composition::Device);
|
||
if(drm_hwc_layer.bUseSr_){
|
||
ALOGD_IF(LogLevel(DBG_INFO),"[%.4" PRIu32 "]=Device-Sr : %s",drm_hwc_layer.uId_,drm_hwc_layer.sLayerName_.c_str());
|
||
}else if(drm_hwc_layer.bUseMemc_){
|
||
ALOGD_IF(LogLevel(DBG_INFO),"[%.4" PRIu32 "]=Device-Memc : %s",drm_hwc_layer.uId_,drm_hwc_layer.sLayerName_.c_str());
|
||
}else{
|
||
ALOGD_IF(LogLevel(DBG_INFO),"[%.4" PRIu32 "]=Device : %s",drm_hwc_layer.uId_,drm_hwc_layer.sLayerName_.c_str());
|
||
}
|
||
}else{
|
||
auto map_hwc2layer = layers_.find(drm_hwc_layer.uId_);
|
||
map_hwc2layer->second.set_validated_type(HWC2::Composition::Client);
|
||
ALOGD_IF(LogLevel(DBG_INFO),"[%.4" PRIu32 "]=Client : %s",drm_hwc_layer.uId_,drm_hwc_layer.sLayerName_.c_str());
|
||
}
|
||
}
|
||
#if (defined USE_LIBSR) || (defined USE_LIBSVEP_MEMC)
|
||
// Update svep state.
|
||
UpdateSvepState();
|
||
#endif
|
||
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
void DrmHwcTwo::HwcDisplay::UpdateSvepState() {
|
||
|
||
// 只有主屏可以开启SVEP模式，其他屏幕不需要更新SVEP状态
|
||
if(handle_ > 0)
|
||
return;
|
||
|
||
bool exist_svep_layer = std::any_of(drm_hwc_layers_.begin(), drm_hwc_layers_.end(),
|
||
[](const auto& drm_hwc_layer) {
|
||
return drm_hwc_layer.bUseSr_ || drm_hwc_layer.bUseMemc_;
|
||
});
|
||
|
||
if(exist_svep_layer != bLastSvepState_){
|
||
|
||
// story last_svep_state
|
||
bLastSvepState_ = exist_svep_layer;
|
||
if(exist_svep_layer){
|
||
property_set("vendor.hwc.svep_state","1");
|
||
}else{
|
||
property_set("vendor.hwc.svep_state","0");
|
||
}
|
||
|
||
// update ddr state
|
||
int fd_ddr_state = open("/sys/class/devfreq/dmc/system_status", O_WRONLY);
|
||
if (fd_ddr_state < 0) {
|
||
HWC2_ALOGD_IF_DEBUG("failed to open /sys/class/devfreq/dmc/system_status ret =%d", fd_ddr_state);
|
||
}else{
|
||
if(exist_svep_layer){
|
||
// S 状态是专门提供给SVEP的场景变频, 进入SVEP场景变频
|
||
write(fd_ddr_state, "S", sizeof(char));
|
||
}else{
|
||
// s 状态是专门提供给SVEP的场景变频, 退出SVEP场景变频
|
||
write(fd_ddr_state, "s", sizeof(char));
|
||
}
|
||
close(fd_ddr_state);
|
||
}
|
||
}
|
||
return ;
|
||
}
|
||
|
||
hwc2_drm_display_t* DrmHwcTwo::HwcDisplay::GetDisplayCtxPtr(){
|
||
return &ctx_;
|
||
}
|
||
|
||
int DrmHwcTwo::HwcDisplay::ImportBuffers() {
|
||
int ret = 0;
|
||
// 匹配 DrmPlane 图层，请求获取 GemHandle
|
||
bool use_client_layer = false;
|
||
for (std::pair<const hwc2_layer_t, DrmHwcTwo::HwcLayer> &l : layers_){
|
||
if(l.second.sf_type() == HWC2::Composition::Client){
|
||
use_client_layer = true;
|
||
}
|
||
for (auto &drm_hwc_layer : drm_hwc_layers_) {
|
||
// 如果图层没有采用Overlay,则不需要获取GemHandle
|
||
if(!drm_hwc_layer.bMatch_)
|
||
continue;
|
||
#if (defined USE_LIBSR) || (defined USE_LIBSVEP_MEMC)
|
||
// 如果是超分处理后的图层，已经更新了GemHandle参数，则不再获取GemHandle
|
||
if(drm_hwc_layer.bUseSr_)
|
||
continue;
|
||
// 如果是超分处理后的图层，已经更新了GemHandle参数，则不再获取GemHandle
|
||
if(drm_hwc_layer.bUseMemc_)
|
||
continue;
|
||
#endif
|
||
// 如果是超分处理后的图层，已经更新了GemHandle参数，则不再获取GemHandle
|
||
if(drm_hwc_layer.bUseRga_)
|
||
continue;
|
||
|
||
// SidebandStream 不需要获取GemHandle
|
||
if(drm_hwc_layer.bSidebandStreamLayer_)
|
||
continue;
|
||
|
||
if(drm_hwc_layer.uId_ == l.first){
|
||
ret = l.second.initOrGetGemhanleFromCache(&drm_hwc_layer);
|
||
if (ret) {
|
||
ALOGE("Failed to get_gemhanle layer-id=%" PRIu64 ", ret=%d", l.first, ret);
|
||
return ret;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 若存在 GPU 合成, 则 ClientLayer 请求获取 GemHandle
|
||
if(use_client_layer){
|
||
for (auto &drm_hwc_layer : drm_hwc_layers_) {
|
||
if(drm_hwc_layer.bFbTarget_){
|
||
uint32_t client_id = 0;
|
||
client_layer_.PopulateFB(client_id, &drm_hwc_layer, &ctx_, frame_no_, false);
|
||
ret = client_layer_.initOrGetGemhanleFromCache(&drm_hwc_layer);
|
||
if (ret) {
|
||
ALOGE("Failed to get_gemhanle client_layer, ret=%d", ret);
|
||
return ret;
|
||
}
|
||
#ifdef USE_LIBPQ
|
||
if(handle_ == 0){
|
||
ret = client_layer_.DoPq(false, &drm_hwc_layer, &ctx_);
|
||
if(ret){
|
||
HWC2_ALOGE("ClientLayer DoPq fail, ret = %d", ret);
|
||
}
|
||
}
|
||
#endif
|
||
}
|
||
}
|
||
ModifyHwcLayerDisplayFrame(true);
|
||
}
|
||
|
||
|
||
// 所有匹配 DrmPlane 图层，请求 Import 获取 FbId
|
||
for (auto &drm_hwc_layer : drm_hwc_layers_) {
|
||
if(!use_client_layer && drm_hwc_layer.bFbTarget_)
|
||
continue;
|
||
// 若不是Overlay图层则不进行ImportBuffer
|
||
if(!drm_hwc_layer.bMatch_)
|
||
continue;
|
||
|
||
// SidebandStream 图层不需要执行 import 操作
|
||
if(drm_hwc_layer.bSidebandStreamLayer_)
|
||
continue;
|
||
// 执行ImportBuffer,获取FbId
|
||
ret = drm_hwc_layer.ImportBuffer(importer_.get());
|
||
if (ret) {
|
||
ALOGE("Failed to import layer, ret=%d", ret);
|
||
return ret;
|
||
}
|
||
}
|
||
|
||
return ret;
|
||
}
|
||
|
||
|
||
HWC2::Error DrmHwcTwo::HwcDisplay::CreateComposition() {
|
||
HWC2_ALOGD_IF_VERBOSE("display-id=%" PRIu64,handle_);
|
||
int ret;
|
||
|
||
std::vector<DrmCompositionDisplayLayersMap> layers_map;
|
||
layers_map.emplace_back();
|
||
DrmCompositionDisplayLayersMap &map = layers_map.back();
|
||
map.display = static_cast<int>(handle_);
|
||
map.geometry_changed = true;
|
||
|
||
ret = ImportBuffers();
|
||
if(ret){
|
||
HWC2_ALOGE("Failed to ImportBuffers, ret=%d", ret);
|
||
return HWC2::Error::NoResources;
|
||
}
|
||
|
||
for (auto &drm_hwc_layer : drm_hwc_layers_) {
|
||
if(drm_hwc_layer.bMatch_)
|
||
map.layers.emplace_back(std::move(drm_hwc_layer));
|
||
}
|
||
|
||
std::unique_ptr<DrmDisplayComposition> composition = compositor_->CreateComposition();
|
||
composition->Init(drm_, crtc_, importer_.get(), planner_.get(), frame_no_, handle_);
|
||
|
||
// TODO: Don't always assume geometry changed
|
||
ret = composition->SetLayers(map.layers.data(), map.layers.size(), true);
|
||
if (ret) {
|
||
ALOGE("Failed to set layers in the composition ret=%d", ret);
|
||
return HWC2::Error::BadLayer;
|
||
}
|
||
for(auto &composition_plane :composition_planes_)
|
||
ret = composition->AddPlaneComposition(std::move(composition_plane));
|
||
|
||
ret = composition->DisableUnusedPlanes();
|
||
if (ret) {
|
||
ALOGE("Failed to plan the composition ret=%d", ret);
|
||
return HWC2::Error::BadConfig;
|
||
}
|
||
|
||
// 利用 vendor.hwc.disable_releaseFence 属性强制关闭ReleaseFence，主要用于调试
|
||
char value[PROPERTY_VALUE_MAX];
|
||
property_get("vendor.hwc.disable_releaseFence", value, "0");
|
||
if(atoi(value) == 0){
|
||
ret = composition->CreateAndAssignReleaseFences(sync_timeline_);
|
||
for (std::pair<const hwc2_layer_t, DrmHwcTwo::HwcLayer> &l : layers_){
|
||
if(l.second.sf_type() == HWC2::Composition::Device){
|
||
sp<ReleaseFence> rf = composition->GetReleaseFence(l.first);
|
||
l.second.set_release_fence(rf);
|
||
}else{
|
||
l.second.set_release_fence(ReleaseFence::NO_FENCE);
|
||
}
|
||
}
|
||
sp<ReleaseFence> rf = composition->GetReleaseFence(0);
|
||
client_layer_.set_release_fence(rf);
|
||
AddFenceToRetireFence(composition->take_out_fence());
|
||
}
|
||
|
||
// 配置 HDR mode
|
||
composition->SetDisplayHdrMode(ctx_.hdr_mode, ctx_.dataspace);
|
||
|
||
// 配置丢帧模式
|
||
composition->SetDropMode(resource_manager_->IsCompositionDropMode());
|
||
|
||
ret = compositor_->QueueComposition(std::move(composition));
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::HwcDisplay::PresentVirtualDisplay(int32_t *retire_fence) {
|
||
ATRACE_CALL();
|
||
|
||
HWC2_ALOGD_IF_VERBOSE("display-id=%" PRIu64,handle_);
|
||
|
||
*retire_fence = -1;
|
||
// 若虚拟屏图层数为0，则不做任何处理
|
||
if(!layers_.size()){
|
||
HWC2_ALOGD_IF_INFO("display %" PRIu64 " layer size is %zu", handle_, layers_.size());
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
if(bUseWriteBack_ &&
|
||
resource_manager_->isWBMode() &&
|
||
!resource_manager_->IsDisableHwVirtualDisplay()){
|
||
if(resource_manager_->isWBMode()){
|
||
const std::shared_ptr<LayerInfoCache>
|
||
bufferinfo = output_layer_.GetBufferInfo();
|
||
|
||
// 每个目标的Buffer都需要初始化YUV数据
|
||
if(!mHasResetBufferId_.count(bufferinfo->uBufferId_)){
|
||
rga_buffer_t src;
|
||
rga_buffer_t dst;
|
||
rga_buffer_t pat;
|
||
im_rect src_rect;
|
||
im_rect dst_rect;
|
||
im_rect pat_rect;
|
||
|
||
memset(&src, 0x0, sizeof(rga_buffer_t));
|
||
memset(&dst, 0x0, sizeof(rga_buffer_t));
|
||
memset(&pat, 0x0, sizeof(rga_buffer_t));
|
||
memset(&src_rect, 0x0, sizeof(im_rect));
|
||
memset(&dst_rect, 0x0, sizeof(im_rect));
|
||
memset(&pat_rect, 0x0, sizeof(im_rect));
|
||
|
||
std::shared_ptr<DrmBuffer> resetBuffer = resource_manager_->GetResetWBBuffer();
|
||
|
||
// Set src buffer info
|
||
src.fd = resetBuffer->GetFd();
|
||
src.width = resetBuffer->GetWidth();
|
||
src.height = resetBuffer->GetHeight();
|
||
src.wstride = resetBuffer->GetStride();
|
||
src.hstride = resetBuffer->GetHeightStride();
|
||
src.format = resetBuffer->GetFormat();
|
||
|
||
// Set src rect info
|
||
src_rect.x = 0;
|
||
src_rect.y = 0;
|
||
src_rect.width = resetBuffer->GetWidth();
|
||
src_rect.height = resetBuffer->GetHeight();
|
||
|
||
// Set dst buffer info
|
||
dst.fd = bufferinfo->iFd_;
|
||
dst.width = bufferinfo->iWidth_;
|
||
dst.height = bufferinfo->iHeight_;
|
||
dst.wstride = bufferinfo->iStride_;
|
||
dst.hstride = bufferinfo->iHeightStride_;
|
||
// 虚拟屏的格式通常为 HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED
|
||
// 由 Gralloc 决定具体格式，对应格式需要查询 uFourccFormat_ 才能确定
|
||
// 实际申请格式，由于RGA不支持Fourcc格式，所以要做个转换。
|
||
switch (bufferinfo->uFourccFormat_) {
|
||
case DRM_FORMAT_BGR888:
|
||
dst.format = HAL_PIXEL_FORMAT_RGB_888;
|
||
break;
|
||
case DRM_FORMAT_ARGB8888:
|
||
dst.format = HAL_PIXEL_FORMAT_BGRA_8888;
|
||
break;
|
||
case DRM_FORMAT_XBGR8888:
|
||
// dst.format = HAL_PIXEL_FORMAT_RGBX_8888;
|
||
dst.format = HAL_PIXEL_FORMAT_BGRA_8888;
|
||
break;
|
||
case DRM_FORMAT_ABGR8888:
|
||
dst.format = HAL_PIXEL_FORMAT_RGBA_8888;
|
||
break;
|
||
case DRM_FORMAT_ABGR2101010:
|
||
dst.format = HAL_PIXEL_FORMAT_RGBA_1010102;
|
||
break;
|
||
//Fix color error in NenaMark2 and Taiji
|
||
case DRM_FORMAT_BGR565:
|
||
dst.format = HAL_PIXEL_FORMAT_RGB_565;
|
||
break;
|
||
case DRM_FORMAT_YVU420:
|
||
dst.format = HAL_PIXEL_FORMAT_YV12;
|
||
break;
|
||
case DRM_FORMAT_NV12:
|
||
dst.format = HAL_PIXEL_FORMAT_YCrCb_NV12;
|
||
break;
|
||
case DRM_FORMAT_NV12_10:
|
||
dst.format = HAL_PIXEL_FORMAT_YCrCb_NV12_10;
|
||
break;
|
||
default:
|
||
ALOGE("Cannot convert uFourccFormat_=%c%c%c%c to hal format, use default format nv12.",
|
||
bufferinfo->uFourccFormat_, bufferinfo->uFourccFormat_ >> 8,
|
||
bufferinfo->uFourccFormat_ >> 16, bufferinfo->uFourccFormat_ >> 24);
|
||
dst.format = HAL_PIXEL_FORMAT_YCrCb_NV12;
|
||
}
|
||
|
||
dst_rect.x = 0;
|
||
dst_rect.y = 0;
|
||
dst_rect.width = bufferinfo->iWidth_;
|
||
dst_rect.height = bufferinfo->iHeight_;
|
||
|
||
dst_rect.x = ALIGN_DOWN( dst_rect.x, 2);
|
||
dst_rect.y = ALIGN_DOWN( dst_rect.y, 2);
|
||
dst_rect.width = ALIGN_DOWN( dst_rect.width, 2);
|
||
dst_rect.height = ALIGN_DOWN( dst_rect.height, 2);
|
||
|
||
if(AFBC_FORMAT_MOD_BLOCK_SIZE_16x16 == (bufferinfo->uModifier_ & AFBC_FORMAT_MOD_BLOCK_SIZE_16x16)){
|
||
dst.rd_mode = IM_FBC_MODE;
|
||
}
|
||
|
||
IM_STATUS im_state = IM_STATUS_NOERROR;;
|
||
|
||
im_opt_t imOpt;
|
||
memset(&imOpt, 0x00, sizeof(im_opt_t));
|
||
imOpt.core = IM_SCHEDULER_RGA3_CORE0 | IM_SCHEDULER_RGA3_CORE1;
|
||
|
||
// Call Im2d 格式转换
|
||
im_state = improcess(src, dst, pat, src_rect, dst_rect, pat_rect, 0, NULL, &imOpt, 0);
|
||
|
||
if(im_state == IM_STATUS_SUCCESS){
|
||
HWC2_ALOGD_IF_DEBUG("call im2d reset Success");
|
||
mHasResetBufferId_.insert(bufferinfo->uBufferId_);
|
||
}else{
|
||
HWC2_ALOGE("call im2d reset fail, ret=%d Error=%s", im_state, imStrError(im_state));
|
||
}
|
||
}
|
||
|
||
rga_buffer_t dst;
|
||
im_rect dst_rect;
|
||
|
||
memset(&dst, 0x00, sizeof(rga_buffer_t));
|
||
memset(&dst_rect, 0x00, sizeof(im_rect));
|
||
|
||
// Set dst buffer info
|
||
dst.fd = bufferinfo->iFd_;
|
||
dst.width = bufferinfo->iWidth_;
|
||
dst.height = bufferinfo->iHeight_;
|
||
dst.wstride = bufferinfo->iStride_;
|
||
dst.hstride = bufferinfo->iHeightStride_;
|
||
// 虚拟屏的格式通常为 HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED
|
||
// 由 Gralloc 决定具体格式，对应格式需要查询 uFourccFormat_ 才能确定
|
||
// 实际申请格式，由于RGA不支持Fourcc格式，所以垚做个转换。
|
||
switch (bufferinfo->uFourccFormat_) {
|
||
case DRM_FORMAT_BGR888:
|
||
dst.format = HAL_PIXEL_FORMAT_RGB_888;
|
||
break;
|
||
case DRM_FORMAT_ARGB8888:
|
||
dst.format = HAL_PIXEL_FORMAT_BGRA_8888;
|
||
break;
|
||
case DRM_FORMAT_XBGR8888:
|
||
// dst.format = HAL_PIXEL_FORMAT_RGBX_8888;
|
||
dst.format = HAL_PIXEL_FORMAT_BGRA_8888;
|
||
break;
|
||
case DRM_FORMAT_ABGR8888:
|
||
dst.format = HAL_PIXEL_FORMAT_RGBA_8888;
|
||
break;
|
||
case DRM_FORMAT_ABGR2101010:
|
||
dst.format = HAL_PIXEL_FORMAT_RGBA_1010102;
|
||
break;
|
||
//Fix color error in NenaMark2 and Taiji
|
||
case DRM_FORMAT_BGR565:
|
||
dst.format = HAL_PIXEL_FORMAT_RGB_565;
|
||
break;
|
||
case DRM_FORMAT_YVU420:
|
||
dst.format = HAL_PIXEL_FORMAT_YV12;
|
||
break;
|
||
case DRM_FORMAT_NV12:
|
||
dst.format = HAL_PIXEL_FORMAT_YCrCb_NV12;
|
||
break;
|
||
case DRM_FORMAT_NV12_10:
|
||
dst.format = HAL_PIXEL_FORMAT_YCrCb_NV12_10;
|
||
break;
|
||
default:
|
||
ALOGE("Cannot convert uFourccFormat_=%c%c%c%c to hal format, use default format nv12.",
|
||
bufferinfo->uFourccFormat_, bufferinfo->uFourccFormat_ >> 8,
|
||
bufferinfo->uFourccFormat_ >> 16, bufferinfo->uFourccFormat_ >> 24);
|
||
dst.format = HAL_PIXEL_FORMAT_YCrCb_NV12;
|
||
}
|
||
|
||
// 为了确保录屏数据宽高比一致，故需要对目标的区域做修正
|
||
DrmMode wbMode = resource_manager_->GetWBMode();
|
||
if(wbMode.width() != bufferinfo->iWidth_ ||
|
||
wbMode.height() != bufferinfo->iHeight_){
|
||
if((wbMode.width() * 1.0 / bufferinfo->iWidth_) >
|
||
(wbMode.height() * 1.0 / bufferinfo->iHeight_)){
|
||
dst_rect.width = bufferinfo->iWidth_;
|
||
dst_rect.height = (int)(bufferinfo->iWidth_ * wbMode.height() / (wbMode.width() * 1.0));
|
||
dst_rect.x = 0;
|
||
dst_rect.y = (bufferinfo->iHeight_ - dst_rect.height) / 2;
|
||
}else{
|
||
dst_rect.width = (int)((bufferinfo->iHeight_) * wbMode.width() / (wbMode.height() * 1.0));
|
||
dst_rect.height = bufferinfo->iHeight_;
|
||
dst_rect.x = (bufferinfo->iWidth_ - dst_rect.width) / 2;
|
||
dst_rect.y = 0;
|
||
}
|
||
}else{
|
||
dst_rect.x = 0;
|
||
dst_rect.y = 0;
|
||
dst_rect.width = bufferinfo->iWidth_;
|
||
dst_rect.height = bufferinfo->iHeight_;
|
||
}
|
||
|
||
dst_rect.x = ALIGN_DOWN( dst_rect.x, 2);
|
||
dst_rect.y = ALIGN_DOWN( dst_rect.y, 2);
|
||
dst_rect.width = ALIGN_DOWN( dst_rect.width, 2);
|
||
dst_rect.height = ALIGN_DOWN( dst_rect.height, 2);
|
||
|
||
if(AFBC_FORMAT_MOD_BLOCK_SIZE_16x16 == (bufferinfo->uModifier_ & AFBC_FORMAT_MOD_BLOCK_SIZE_16x16)){
|
||
dst.rd_mode = IM_FBC_MODE;
|
||
}
|
||
|
||
int ret = resource_manager_->OutputWBBuffer((int)handle_, dst, dst_rect, retire_fence, &wb_frame_no_);
|
||
if(ret){
|
||
HWC2_ALOGE("OutputWBBuffer fail!");
|
||
}
|
||
|
||
// 添加调试接口，抓打印传递给SurfaceFlinger的 Buffer
|
||
char value[PROPERTY_VALUE_MAX];
|
||
property_get("debug.wb.dump", value, "0");
|
||
if(atoi(value) > 0) {
|
||
output_layer_.DumpData();
|
||
}
|
||
}
|
||
}else{
|
||
if(client_layer_.acquire_fence() != NULL){
|
||
if(client_layer_.acquire_fence()->wait(1500)){
|
||
HWC2_ALOGE("WB client layer wait acquirefence 1500ms timeout!");
|
||
}
|
||
}
|
||
}
|
||
|
||
++frame_no_;
|
||
return HWC2::Error::None;
|
||
}
|
||
HWC2::Error DrmHwcTwo::HwcDisplay::PresentDisplay(int32_t *retire_fence) {
|
||
ATRACE_CALL();
|
||
|
||
if(isVirtual()){
|
||
return PresentVirtualDisplay(retire_fence);;
|
||
}
|
||
|
||
int32_t merge_retire_fence = -1;
|
||
// 拼接主屏需要遍历其他拼接子屏幕
|
||
if(connector_->IsSpiltPrimary()){
|
||
DoMirrorDisplay(&merge_retire_fence);
|
||
}
|
||
|
||
if(!init_success_){
|
||
HWC2_ALOGD_IF_ERR("init_success_=%d skip.",init_success_);
|
||
*retire_fence = merge_retire_fence;
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
DumpAllLayerData();
|
||
|
||
HWC2::Error ret;
|
||
ret = CheckDisplayState();
|
||
if(ret != HWC2::Error::None ||
|
||
!validate_success_ ||
|
||
connector_->type() == DRM_MODE_CONNECTOR_VIRTUAL){
|
||
ALOGE_IF(LogLevel(DBG_ERROR),"Check display %" PRIu64 " state fail %s, %s,line=%d", handle_,
|
||
validate_success_? "" : "or validate fail.",__FUNCTION__, __LINE__);
|
||
if(ret == HWC2::Error::BadLayer){
|
||
ClearDisplay();
|
||
}
|
||
}else{
|
||
ret = CreateComposition();
|
||
if (ret == HWC2::Error::BadLayer) {
|
||
// Can we really have no client or device layers?
|
||
*retire_fence = merge_retire_fence;
|
||
return HWC2::Error::None;
|
||
}
|
||
}
|
||
|
||
if(merge_retire_fence > 0){
|
||
if(d_retire_fence_.get()->isValid()){
|
||
char acBuf[32];
|
||
sprintf(acBuf,"RTD%" PRIu64 "M-FN%d-%d", handle_, frame_no_, 0);
|
||
sp<ReleaseFence> rt = sp<ReleaseFence>(new ReleaseFence(merge_retire_fence, acBuf));
|
||
*retire_fence = rt->merge(d_retire_fence_.get()->getFd(), acBuf);
|
||
}else{
|
||
*retire_fence = merge_retire_fence;
|
||
}
|
||
}else{
|
||
// The retire fence returned here is for the last frame, so return it and
|
||
// promote the next retire fence
|
||
*retire_fence = d_retire_fence_.get()->isValid() ? dup(d_retire_fence_.get()->getFd()) : -1;
|
||
if(LogLevel(DBG_DEBUG)){
|
||
HWC2_ALOGD_IF_DEBUG("Return RetireFence(%d) %s frame = %d Info: size=%d act=%d signal=%d err=%d",
|
||
d_retire_fence_.get()->isValid(),
|
||
d_retire_fence_.get()->getName().c_str(), frame_no_,
|
||
d_retire_fence_.get()->getSize(),d_retire_fence_.get()->getActiveCount(),
|
||
d_retire_fence_.get()->getSignaledCount(),d_retire_fence_.get()->getErrorCount());
|
||
}
|
||
}
|
||
|
||
++frame_no_;
|
||
|
||
UpdateTimerState(!static_screen_opt_);
|
||
|
||
if(IsActiveModeChange())
|
||
drm_->FlipResolutionSwitchHandler((int)handle_);
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::HwcDisplay::SetActiveConfig(hwc2_config_t config) {
|
||
HWC2_ALOGD_IF_VERBOSE("display-id=%" PRIu64 " config=%d",handle_,config);
|
||
if(ctx_.bStandardSwitchResolution){
|
||
auto mode = std::find_if(sf_modes_.begin(),
|
||
sf_modes_.end(),
|
||
[config](DrmMode const &m) {
|
||
return m.id() == config;
|
||
});
|
||
if (mode == sf_modes_.end()) {
|
||
ALOGE("Could not find active mode for %d", config);
|
||
return HWC2::Error::BadConfig;
|
||
}
|
||
|
||
// std::unique_ptr<DrmDisplayComposition> composition = compositor_
|
||
// .CreateComposition();
|
||
// composition->Init(drm_, crtc_, importer_.get(), planner_.get(), frame_no_);
|
||
// int ret = composition->SetDisplayMode(*mode);
|
||
// ret = compositor_.QueueComposition(std::move(composition));
|
||
// if (ret) {
|
||
// ALOGE("Failed to queue dpms composition on %d", ret);
|
||
// return HWC2::Error::BadConfig;
|
||
// }
|
||
connector_->set_best_mode(*mode);
|
||
|
||
connector_->set_current_mode(*mode);
|
||
ctx_.rel_xres = (*mode).h_display();
|
||
ctx_.rel_yres = (*mode).v_display();
|
||
|
||
// 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())};
|
||
client_layer_.SetLayerDisplayFrame(display_frame);
|
||
hwc_frect_t source_crop = {.left = 0.0f,
|
||
.top = 0.0f,
|
||
.right = mode->h_display() + 0.0f,
|
||
.bottom = mode->v_display() + 0.0f};
|
||
client_layer_.SetLayerSourceCrop(source_crop);
|
||
|
||
drm_->UpdateDisplayMode(handle_);
|
||
// SetDisplayModeInfo cost 2.5ms - 5ms, a A few cases cost 10ms - 20ms
|
||
connector_->SetDisplayModeInfo(handle_);
|
||
}else{
|
||
if(connector_->isCropSpilt()){
|
||
int32_t srcX, srcY, srcW, srcH;
|
||
connector_->getCropInfo(&srcX, &srcY, &srcW, &srcH);
|
||
hwc_rect_t display_frame = {.left = 0,
|
||
.top = 0,
|
||
.right = static_cast<int>(ctx_.framebuffer_width),
|
||
.bottom = static_cast<int>(ctx_.framebuffer_height)};
|
||
client_layer_.SetLayerDisplayFrame(display_frame);
|
||
hwc_frect_t source_crop = {.left = srcX + 0.0f,
|
||
.top = srcY + 0.0f,
|
||
.right = srcX + srcW + 0.0f,
|
||
.bottom = srcY + srcH + 0.0f};
|
||
client_layer_.SetLayerSourceCrop(source_crop);
|
||
|
||
}else{
|
||
// Setup the client layer's dimensions
|
||
hwc_rect_t display_frame = {.left = 0,
|
||
.top = 0,
|
||
.right = static_cast<int>(ctx_.framebuffer_width),
|
||
.bottom = static_cast<int>(ctx_.framebuffer_height)};
|
||
client_layer_.SetLayerDisplayFrame(display_frame);
|
||
hwc_frect_t source_crop = {.left = 0.0f,
|
||
.top = 0.0f,
|
||
.right = ctx_.framebuffer_width + 0.0f,
|
||
.bottom = ctx_.framebuffer_height + 0.0f};
|
||
client_layer_.SetLayerSourceCrop(source_crop);
|
||
}
|
||
// VRR
|
||
UpdateRefreshRate(config);
|
||
}
|
||
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::HwcDisplay::UpdateRefreshRate(hwc2_config_t config) {
|
||
HWC2_ALOGD_IF_VERBOSE("display-id=%" PRIu64 " config=%d", handle_, config);
|
||
if(!bVrrDisplay_)
|
||
return HWC2::Error::None;
|
||
|
||
const std::vector<int> vrr_mode = connector_->vrr_modes();
|
||
if(config < vrr_mode.size()){
|
||
int refresh_rate = vrr_mode[config];
|
||
int ret = drm_->UpdateVrrRefreshRate(handle_, refresh_rate);
|
||
if(ret){
|
||
HWC2_ALOGE("display=%" PRIu64 " config=%d refresh_rate=%d UpdateVrrRefreshRate fail!",
|
||
handle_, config, refresh_rate);
|
||
return HWC2::Error::BadConfig;
|
||
}
|
||
}
|
||
|
||
return HWC2::Error::BadConfig;
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::HwcDisplay::SetClientTarget(buffer_handle_t target,
|
||
int32_t acquire_fence,
|
||
int32_t dataspace,
|
||
hwc_region_t /*damage*/) {
|
||
HWC2_ALOGD_IF_VERBOSE("display-id=%" PRIu64 ", Buffer=%p, acq_fence=%d, dataspace=%x",
|
||
handle_,target,acquire_fence,dataspace);
|
||
|
||
// 动态切换刷新率过程中SurfaceFlinger会出现 SetClientTarget target=null的情况
|
||
// 为了避免错误日志打印，故暂时对这种情况进行规避；
|
||
if(target == NULL){
|
||
HWC2_ALOGW("Buffer is NULL, skip SetClientTarget");
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
client_layer_.CacheBufferInfo(target);
|
||
client_layer_.set_acquire_fence(sp<AcquireFence>(new AcquireFence(acquire_fence)));
|
||
client_layer_.SetLayerDataspace(dataspace);
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::HwcDisplay::SetColorMode(int32_t mode) {
|
||
HWC2_ALOGD_IF_VERBOSE("display-id=%" PRIu64 ", mode=%x",handle_,mode);
|
||
|
||
if (mode != HAL_COLOR_MODE_NATIVE)
|
||
return HWC2::Error::BadParameter;
|
||
|
||
color_mode_ = mode;
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::HwcDisplay::SetColorTransform(const float *matrix,
|
||
int32_t hint) {
|
||
HWC2_ALOGD_IF_VERBOSE("display-id=%" PRIu64 ", hint=%x",handle_,hint);
|
||
// TODO: Force client composition if we get this
|
||
// hint definition from android_color_transform_t in system/core/libsystem/include/system/graphics-base-v1.0.h
|
||
force_gles_ = (hint > 0);
|
||
unsupported(__func__, matrix, hint);
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::HwcDisplay::SetOutputBuffer(buffer_handle_t buffer,
|
||
int32_t release_fence) {
|
||
HWC2_ALOGD_IF_VERBOSE("display-id=%" PRIu64 ", buffer=%p, rel_fence=%d",handle_,buffer,release_fence);
|
||
// TODO: Need virtual display support
|
||
output_layer_.set_output_buffer(buffer);
|
||
if(release_fence > 0){
|
||
/* release_fence will be close in this file hardware/interfaces/
|
||
* graphics/composer/2.1/utils/passthrough/include/composer-passthrough/2.1/HwcHal.h+319
|
||
* int32_t err = mDispatch.setOutputBuffer(mDevice, display, buffer, releaseFence);
|
||
* // unlike in setClientTarget, releaseFence is owned by us
|
||
* if (err == HWC2_ERROR_NONE && releaseFence >= 0) {
|
||
* close(releaseFence);
|
||
* }
|
||
*/
|
||
int32_t new_release_fence = dup(release_fence);
|
||
String8 output;
|
||
output.appendFormat("%s-F%" PRIu32 "-Fd%d",__FUNCTION__,frame_no_,new_release_fence);
|
||
sp<ReleaseFence> release = sp<ReleaseFence>(new ReleaseFence(new_release_fence, output.c_str()));
|
||
output_layer_.set_release_fence(release);
|
||
HWC2_ALOGD_IF_DEBUG("Release=%d(%d) %s Info: size=%d act=%d signal=%d err=%d",
|
||
release->getFd(),release->isValid(),release->getName().c_str(),
|
||
release->getSize(), release->getActiveCount(),
|
||
release->getSignaledCount(), release->getErrorCount());
|
||
}
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::HwcDisplay::SyncPowerMode() {
|
||
HWC2_ALOGD_IF_VERBOSE("display-id=%" PRIu64 " bNeedSyncPMState_=%d",handle_, bNeedSyncPMState_);
|
||
|
||
if(!init_success_){
|
||
HWC2_ALOGE("init_success_=%d skip.",init_success_);
|
||
return HWC2::Error::BadDisplay;
|
||
}
|
||
|
||
if(!bNeedSyncPMState_){
|
||
HWC2_ALOGI("bNeedSyncPMState_=%d don't need to sync PowerMode state.",bNeedSyncPMState_);
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
HWC2::Error error = SetPowerMode((int32_t)mPowerMode_);
|
||
if(error != HWC2::Error::None){
|
||
HWC2_ALOGE("SetPowerMode fail %d", error);
|
||
return error;
|
||
}
|
||
|
||
bNeedSyncPMState_ = false;
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::HwcDisplay::SetPowerMode(int32_t mode_in) {
|
||
HWC2_ALOGD_IF_VERBOSE("display-id=%" PRIu64 ", mode_in=%d",handle_,mode_in);
|
||
|
||
// 拼接屏幕主屏需要更新拼接副屏的电源状态
|
||
if(connector_->IsSpiltPrimary()){
|
||
for (auto &conn : drm_->connectors()) {
|
||
if(!conn->isCropSpilt()){
|
||
continue;
|
||
}
|
||
int display_id = conn->display();
|
||
if(!conn->IsSpiltPrimary()){
|
||
auto &display = resource_manager_->GetHwc2()->displays_.at(display_id);
|
||
display.SetPowerMode(mode_in);
|
||
}
|
||
}
|
||
}
|
||
|
||
uint64_t dpms_value = 0;
|
||
mPowerMode_ = static_cast<HWC2::PowerMode>(mode_in);
|
||
switch (mPowerMode_) {
|
||
case HWC2::PowerMode::Off:
|
||
dpms_value = DRM_MODE_DPMS_OFF;
|
||
break;
|
||
case HWC2::PowerMode::On:
|
||
dpms_value = DRM_MODE_DPMS_ON;
|
||
break;
|
||
case HWC2::PowerMode::Doze:
|
||
case HWC2::PowerMode::DozeSuspend:
|
||
ALOGI("Power mode %d is unsupported\n", mPowerMode_);
|
||
return HWC2::Error::Unsupported;
|
||
default:
|
||
ALOGI("Power mode %d is BadParameter\n", mPowerMode_);
|
||
return HWC2::Error::BadParameter;
|
||
};
|
||
|
||
if(!init_success_){
|
||
bNeedSyncPMState_ = true;
|
||
HWC2_ALOGE("init_success_=%d skip.",init_success_);
|
||
return HWC2::Error::BadDisplay;
|
||
}
|
||
|
||
std::unique_ptr<DrmDisplayComposition> composition = compositor_->CreateComposition();
|
||
composition->Init(drm_, crtc_, importer_.get(), planner_.get(), frame_no_, handle_);
|
||
composition->SetDpmsMode(dpms_value);
|
||
int ret = compositor_->QueueComposition(std::move(composition));
|
||
if (ret) {
|
||
ALOGE("Failed to apply the dpms composition ret=%d", ret);
|
||
return HWC2::Error::BadParameter;
|
||
}
|
||
|
||
int fb0_fd = resource_manager_->getFb0Fd();
|
||
if(fb0_fd<=0)
|
||
ALOGE_IF(LogLevel(DBG_ERROR),"%s,line=%d fb0_fd = %d can't operation /dev/graphics/fb0 node.",
|
||
__FUNCTION__,__LINE__,fb0_fd);
|
||
int fb_blank = 0;
|
||
if(dpms_value == DRM_MODE_DPMS_OFF)
|
||
fb_blank = FB_BLANK_POWERDOWN;
|
||
else if(dpms_value == DRM_MODE_DPMS_ON)
|
||
fb_blank = FB_BLANK_UNBLANK;
|
||
else
|
||
ALOGE("dpmsValue is invalid value= %" PRIu64 "",dpms_value);
|
||
|
||
if(fb_blank != fb_blanked && fb0_fd > 0){
|
||
int err = ioctl(fb0_fd, FBIOBLANK, fb_blank);
|
||
ALOGD_IF(LogLevel(DBG_DEBUG),"%s Notice fb_blank to fb=%d", __FUNCTION__, fb_blank);
|
||
if (err < 0) {
|
||
ALOGE("fb_blank ioctl failed(%d) display=%" PRIu64 ",fb_blank=%d,dpmsValue=%" PRIu64 "",
|
||
errno,handle_,fb_blank,dpms_value);
|
||
}
|
||
}
|
||
|
||
fb_blanked = fb_blank;
|
||
|
||
if(dpms_value == DRM_MODE_DPMS_OFF){
|
||
ClearDisplay();
|
||
ret = drm_->ReleaseDpyRes(handle_, DmcuReleaseByPowerMode);
|
||
if (ret) {
|
||
HWC2_ALOGE("Failed to ReleaseDpyRes for display=%" PRIu64 " %d\n", handle_, ret);
|
||
}
|
||
if(isRK3566(resource_manager_->getSocId())){
|
||
int display_id = drm_->GetCommitMirrorDisplayId();
|
||
DrmConnector *extend = drm_->GetConnectorForDisplay(display_id);
|
||
if(extend != NULL){
|
||
int extend_display_id = extend->display();
|
||
auto &display = resource_manager_->GetHwc2()->displays_.at(extend_display_id);
|
||
display.ClearDisplay();
|
||
ret = drm_->ReleaseDpyRes(extend_display_id);
|
||
if (ret) {
|
||
HWC2_ALOGE("Failed to ReleaseDpyRes for display=%d %d\n", extend_display_id, ret);
|
||
}
|
||
}
|
||
}
|
||
}else{
|
||
if(connector_->hotplug()){
|
||
ret = connector_->UpdateModes();
|
||
if (ret) {
|
||
HWC2_ALOGE("Failed to UpdateModes for display=%" PRIu64 " ret=%d\n", handle_, ret);
|
||
}
|
||
}
|
||
HoplugEventTmeline();
|
||
ret = UpdateDisplayMode();
|
||
if (ret) {
|
||
HWC2_ALOGE("Failed to UpdateDisplayMode for display=%" PRIu64 " ret=%d\n", handle_, ret);
|
||
}
|
||
ret = drm_->BindDpyRes(handle_);
|
||
if (ret) {
|
||
HWC2_ALOGE("Failed to BindDpyRes for display=%" PRIu64 " ret=%d\n", handle_, ret);
|
||
}
|
||
UpdateDisplayInfo();
|
||
if(isRK3566(resource_manager_->getSocId())){
|
||
ALOGD_IF(LogLevel(DBG_DEBUG),"SetPowerMode display-id=%" PRIu64 ",soc is rk3566" ,handle_);
|
||
int display_id = drm_->GetCommitMirrorDisplayId();
|
||
DrmConnector *extend = drm_->GetConnectorForDisplay(display_id);
|
||
if(extend != NULL){
|
||
int extend_display_id = extend->display();
|
||
ret = drm_->BindDpyRes(extend_display_id);
|
||
if (ret) {
|
||
HWC2_ALOGE("Failed to BindDpyRes for display=%d ret=%d\n", extend_display_id, ret);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::HwcDisplay::SetVsyncEnabled(int32_t enabled) {
|
||
HWC2_ALOGD_IF_VERBOSE("display-id=%" PRIu64 ", enable=%d",handle_,enabled);
|
||
vsync_worker_.VSyncControl(HWC2_VSYNC_ENABLE == enabled);
|
||
return HWC2::Error::None;
|
||
}
|
||
HWC2::Error DrmHwcTwo::HwcDisplay::ValidateVirtualDisplay(uint32_t *num_types,
|
||
uint32_t *num_requests) {
|
||
if(LogLevel(DBG_INFO)){
|
||
DumpDisplayLayersInfo();
|
||
}
|
||
|
||
if(!layers_.size()){
|
||
HWC2_ALOGI("display %" PRIu64 " layer size is %zu, %s,line=%d", handle_, layers_.size(),
|
||
__FUNCTION__, __LINE__);
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
// 强制设置系统刷新为30帧
|
||
InvalidateControl(30,-1);
|
||
|
||
bUseWriteBack_ = true;
|
||
|
||
// 提供仅 Sideband 模式下开启 hw Virtual Display 功能接口
|
||
char value[PROPERTY_VALUE_MAX];
|
||
property_get("vendor.hwc.only_sideband_use_wb", value, "0");
|
||
if(atoi(value) > 0){
|
||
bUseWriteBack_ = false;
|
||
bool exist_sideband_stream = false;
|
||
// 只有存在 SidebandStream 的录屏才会使用 WriteBack;
|
||
for (std::pair<const hwc2_layer_t, DrmHwcTwo::HwcLayer> &l : layers_) {
|
||
DrmHwcTwo::HwcLayer &layer = l.second;
|
||
if(layer.sf_type() == HWC2::Composition::Sideband){
|
||
exist_sideband_stream = true;
|
||
}
|
||
}
|
||
|
||
if(exist_sideband_stream){
|
||
bUseWriteBack_ = true;
|
||
}
|
||
}
|
||
|
||
HWC2_ALOGI("frame_no_ = %d", frame_no_);
|
||
|
||
// 获取 WriteBack id
|
||
int WBDisplayId = resource_manager_->GetWBDisplay();
|
||
// 检查是否正确使能 Hw Virtual Display 功能
|
||
if(WBDisplayId >= 0 &&
|
||
resource_manager_->isWBMode() &&
|
||
!resource_manager_->IsDisableHwVirtualDisplay()){
|
||
DrmConnector *connector = drm_->GetConnectorForDisplay(WBDisplayId);
|
||
if (!connector) {
|
||
HWC2_ALOGD_IF_DEBUG("Failed to get WB connector for display=%" PRIu64 " wb-display %d frame_no=%d", handle_, WBDisplayId, frame_no_);
|
||
bUseWriteBack_ = false;
|
||
}else{
|
||
if(connector->state() != DRM_MODE_CONNECTED){
|
||
HWC2_ALOGD_IF_DEBUG("WB Connector %u type=%s, type_id=%d, state is DRM_MODE_DISCONNECTED,"
|
||
" skip init. display=%" PRIu64 " wb-display %d frame_no=%d",
|
||
connector->id(),drm_->connector_type_str(connector->type()),connector->type_id(),
|
||
handle_, WBDisplayId, frame_no_);;
|
||
bUseWriteBack_ = false;
|
||
}
|
||
|
||
DrmCrtc *crtc = drm_->GetCrtcForDisplay(WBDisplayId);
|
||
if (!crtc) {
|
||
HWC2_ALOGD_IF_DEBUG("Failed to get crtc for display=%" PRIu64 " wb-display %d frame_no=%d", handle_, WBDisplayId, frame_no_);
|
||
bUseWriteBack_ = false;
|
||
}
|
||
|
||
if(resource_manager_->GetFinishWBBufferSize() == 0){
|
||
HWC2_ALOGD_IF_DEBUG("WB buffer not ready, display=%" PRIu64 " wb-display %d frame_no=%d", handle_, WBDisplayId, frame_no_);
|
||
bUseWriteBack_ = false;
|
||
}
|
||
}
|
||
}else{
|
||
bUseWriteBack_ = false;
|
||
HWC2_ALOGD_IF_DEBUG("WB display %d is invalid, disable HW VDS.", WBDisplayId);
|
||
}
|
||
|
||
for (std::pair<const hwc2_layer_t, DrmHwcTwo::HwcLayer> &l : layers_) {
|
||
DrmHwcTwo::HwcLayer &layer = l.second;
|
||
if(bUseWriteBack_){
|
||
layer.set_validated_type(HWC2::Composition::Device);
|
||
}else{
|
||
layer.set_validated_type(HWC2::Composition::Client);
|
||
}
|
||
++*num_types;
|
||
}
|
||
*num_requests = 0;
|
||
|
||
return HWC2::Error::None;
|
||
}
|
||
HWC2::Error DrmHwcTwo::HwcDisplay::ValidateDisplay(uint32_t *num_types,
|
||
uint32_t *num_requests) {
|
||
ATRACE_CALL();
|
||
HWC2_ALOGD_IF_VERBOSE("display-id=%" PRIu64 ,handle_);
|
||
|
||
// 虚拟屏
|
||
if(isVirtual()){
|
||
return ValidateVirtualDisplay(num_types, num_requests);;
|
||
}
|
||
|
||
if(LogLevel(DBG_DEBUG))
|
||
DumpDisplayLayersInfo();
|
||
|
||
if(!init_success_){
|
||
HWC2_ALOGD_IF_ERR("init_success_=%d skip.",init_success_);
|
||
if(connector_->IsSpiltPrimary()){
|
||
for (std::pair<const hwc2_layer_t, DrmHwcTwo::HwcLayer> &l : layers_){
|
||
l.second.set_validated_type(HWC2::Composition::Client);
|
||
}
|
||
}else{
|
||
for (std::pair<const hwc2_layer_t, DrmHwcTwo::HwcLayer> &l : layers_){
|
||
l.second.set_validated_type(l.second.sf_type());
|
||
}
|
||
}
|
||
return HWC2::Error::None;
|
||
}
|
||
// Enable/disable debug log
|
||
UpdateLogLevel();
|
||
UpdateBCSH();
|
||
UpdateHdmiOutputFormat();
|
||
UpdateOverscan();
|
||
if(!ctx_.bStandardSwitchResolution){
|
||
UpdateDisplayMode();
|
||
drm_->UpdateDisplayMode(handle_);
|
||
if(isRK3566(resource_manager_->getSocId())){
|
||
int display_id = drm_->GetCommitMirrorDisplayId();
|
||
drm_->UpdateDisplayMode(display_id);
|
||
}
|
||
UpdateDisplayInfo();
|
||
}
|
||
|
||
// 虚拟屏幕
|
||
if(connector_->type() == DRM_MODE_CONNECTOR_VIRTUAL){
|
||
for (std::pair<const hwc2_layer_t, DrmHwcTwo::HwcLayer> &l : layers_){
|
||
l.second.set_validated_type(l.second.sf_type());
|
||
}
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
// update sideband mode
|
||
UpdateSidebandMode();
|
||
|
||
*num_types = 0;
|
||
*num_requests = 0;
|
||
|
||
HWC2::Error ret;
|
||
|
||
for (std::pair<const hwc2_layer_t, DrmHwcTwo::HwcLayer> &l : layers_){
|
||
if(gIsRK3528()){
|
||
l.second.set_validated_type(HWC2::Composition::Device);
|
||
}else{
|
||
l.second.set_validated_type(HWC2::Composition::Client);
|
||
}
|
||
}
|
||
|
||
ret = CheckDisplayState();
|
||
if(ret != HWC2::Error::None){
|
||
ALOGE_IF(LogLevel(DBG_ERROR),"Check display %" PRIu64 " state fail, %s,line=%d", handle_,
|
||
__FUNCTION__, __LINE__);
|
||
composition_planes_.clear();
|
||
validate_success_ = false;
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
ret = ValidatePlanes();
|
||
if (ret != HWC2::Error::None){
|
||
ALOGE("%s fail , ret = %d,line = %d",__FUNCTION__,ret,__LINE__);
|
||
validate_success_ = false;
|
||
return HWC2::Error::BadConfig;
|
||
}
|
||
|
||
SwitchHdrMode();
|
||
// Static screen opt
|
||
UpdateTimerEnable();
|
||
// Enable Self-refresh mode.
|
||
SelfRefreshEnable();
|
||
for (std::pair<const hwc2_layer_t, DrmHwcTwo::HwcLayer> &l : layers_) {
|
||
DrmHwcTwo::HwcLayer &layer = l.second;
|
||
// We can only handle layers of Device type, send everything else to SF
|
||
if (layer.validated_type() != HWC2::Composition::Device) {
|
||
layer.set_validated_type(HWC2::Composition::Client);
|
||
++*num_types;
|
||
}
|
||
}
|
||
|
||
if(!client_layer_.isAfbc()){
|
||
++(*num_requests);
|
||
}
|
||
validate_success_ = true;
|
||
return *num_types ? HWC2::Error::HasChanges : HWC2::Error::None;
|
||
}
|
||
|
||
#ifdef ANDROID_S
|
||
HWC2::Error DrmHwcTwo::HwcDisplay::GetDisplayConnectionType(uint32_t *outType) {
|
||
if (connector_->internal())
|
||
*outType = static_cast<uint32_t>(HWC2::DisplayConnectionType::Internal);
|
||
else if (connector_->external())
|
||
*outType = static_cast<uint32_t>(HWC2::DisplayConnectionType::External);
|
||
else
|
||
return HWC2::Error::BadConfig;
|
||
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
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;
|
||
}
|
||
#endif //ANDROID_S
|
||
|
||
HWC2::Error DrmHwcTwo::HwcLayer::SetCursorPosition(int32_t x, int32_t y) {
|
||
HWC2_ALOGD_IF_VERBOSE("layer-id=%d"", x=%d, y=%d" ,id_,x,y);
|
||
mCurrentState.cursor_x_ = x;
|
||
mCurrentState.cursor_y_ = y;
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
int DrmHwcTwo::HwcDisplay::DumpDisplayInfo(String8 &output){
|
||
|
||
output.appendFormat(" DisplayId=%" PRIu64 ", Connector %u, Type = %s-%u, Connector state = %s\n",handle_,
|
||
connector_->id(),
|
||
isVirtual() ? "Virtual" : drm_->connector_type_str(connector_->type()),
|
||
connector_->type_id(),
|
||
connector_->state() == DRM_MODE_CONNECTED ? "DRM_MODE_CONNECTED" : "DRM_MODE_DISCONNECTED");
|
||
|
||
if(connector_->state() != DRM_MODE_CONNECTED)
|
||
return -1;
|
||
|
||
DrmMode const &active_mode = connector_->active_mode();
|
||
if (active_mode.id() == 0){
|
||
return -1;
|
||
}
|
||
|
||
output.appendFormat(" NumHwLayers=%zu, activeModeId=%u, %s%c%.2f, colorMode = %d, bStandardSwitchResolution=%d\n",
|
||
get_layers().size(),
|
||
active_mode.id(), active_mode.name().c_str(),'p' ,active_mode.v_refresh(),
|
||
color_mode_,ctx_.bStandardSwitchResolution);
|
||
if(sf_modes_.size() > 0){
|
||
uint32_t idx = 0;
|
||
|
||
for (const DrmMode &mode : sf_modes_) {
|
||
if(active_mode.id() == mode.id())
|
||
output.appendFormat(" Config[%2u] = %s%c%.2f mode-id=%d (active)\n",idx, mode.name().c_str(), 'p' , mode.v_refresh(),mode.id());
|
||
else
|
||
output.appendFormat(" Config[%2u] = %s%c%.2f mode-id=%d \n",idx, mode.name().c_str(), 'p' , mode.v_refresh(),mode.id());
|
||
idx++;
|
||
}
|
||
}
|
||
|
||
output.append(
|
||
"------+-----+-----------+-----------+--------------------+-------------+------------+--------------------------------+------------------------+------------+--------+------------\n"
|
||
" id | z | sf-type | hwc-type | handle | transform | blnd | source crop (l,t,r,b) | frame | dataspace | mFps | name \n"
|
||
"------+-----+-----------+-----------+--------------------+-------------+------------+--------------------------------+------------------------+------------+--------+------------\n");
|
||
for (uint32_t z_order = 0; z_order <= layers_.size(); z_order++) {
|
||
for (auto &map_layer : layers_) {
|
||
HwcLayer &layer = map_layer.second;
|
||
if(layer.z_order() == z_order){
|
||
layer.DumpLayerInfo(output);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
output.append("------+-----+-----------+-----------+--------------------+-------------+------------+--------------------------------+------------------------+------------+--------+------------\n");
|
||
output.append("DrmHwcLayer Dump:\n");
|
||
|
||
for(auto &drmHwcLayer : drm_hwc_layers_)
|
||
drmHwcLayer.DumpInfo(output);
|
||
|
||
return 0;
|
||
}
|
||
|
||
int DrmHwcTwo::HwcDisplay::DumpDisplayLayersInfo(String8 &output){
|
||
|
||
output.appendFormat(" DisplayId=%" PRIu64 ", Connector %u, Type = %s-%u, Connector state = %s , frame_no = %d\n",handle_,
|
||
connector_->id(),
|
||
isVirtual() ? "Virtual" : drm_->connector_type_str(connector_->type()),
|
||
connector_->type_id(),
|
||
connector_->state() == DRM_MODE_CONNECTED ? "DRM_MODE_CONNECTED" : "DRM_MODE_DISCONNECTED",
|
||
frame_no_);
|
||
|
||
output.append(
|
||
"------+-----+-----------+-----------+--------------------+-------------+------------+--------------------------------+------------------------+------------+--------+------------\n"
|
||
" id | z | req-type | fina-type | handle | transform | blnd | source crop (l,t,r,b) | frame | dataspace | mFps | name \n"
|
||
"------+-----+-----------+-----------+--------------------+-------------+------------+--------------------------------+------------------------+------------+--------+------------\n");
|
||
for (uint32_t z_order = 0; z_order <= layers_.size(); z_order++) {
|
||
for (auto &map_layer : layers_) {
|
||
HwcLayer &layer = map_layer.second;
|
||
if(layer.z_order() == z_order){
|
||
layer.DumpLayerInfo(output);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
output.append("------+-----+-----------+-----------+--------------------+-------------+------------+--------------------------------+------------------------+------------+--------+------------\n");
|
||
return 0;
|
||
}
|
||
|
||
int DrmHwcTwo::HwcDisplay::DumpDisplayLayersInfo(){
|
||
String8 output;
|
||
output.appendFormat(" DisplayId=%" PRIu64 ", Connector %u, Type = %s-%u, Connector state = %s , frame_no = %d\n",handle_,
|
||
connector_->id(),
|
||
isVirtual() ? "Virtual" : drm_->connector_type_str(connector_->type()),
|
||
connector_->type_id(),
|
||
connector_->state() == DRM_MODE_CONNECTED ? "DRM_MODE_CONNECTED" : "DRM_MODE_DISCONNECTED",
|
||
frame_no_);
|
||
|
||
output.append(
|
||
"------+-----+-----------+-----------+--------------------+-------------+------------+--------------------------------+------------------------+------------+--------+------------\n"
|
||
" id | z | sf-type | hwc-type | handle | transform | blnd | source crop (l,t,r,b) | frame | dataspace | mFps | name \n"
|
||
"------+-----+-----------+-----------+--------------------+-------------+------------+--------------------------------+------------------------+------------+--------+------------\n");
|
||
ALOGD("%s",output.string());
|
||
for (uint32_t z_order = 0; z_order <= layers_.size(); z_order++) {
|
||
for (auto &map_layer : layers_) {
|
||
HwcLayer &layer = map_layer.second;
|
||
if(layer.z_order() == z_order){
|
||
output.clear();
|
||
layer.DumpLayerInfo(output);
|
||
ALOGD("%s",output.string());
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
output.clear();
|
||
output.append("------+-----+-----------+-----------+--------------------+-------------+------------+--------------------------------+------------------------+------------+--------+------------\n");
|
||
ALOGD("%s",output.string());
|
||
return 0;
|
||
}
|
||
int DrmHwcTwo::HwcDisplay::DumpAllLayerData(){
|
||
char pro_value[PROPERTY_VALUE_MAX];
|
||
property_get( PROPERTY_TYPE ".dump",pro_value,0);
|
||
if(!strcmp(pro_value,"true")){
|
||
for (auto &map_layer : layers_) {
|
||
HwcLayer &layer = map_layer.second;
|
||
layer.DumpData();
|
||
}
|
||
if(client_layer_.buffer() != NULL)
|
||
client_layer_.DumpData();
|
||
|
||
for(auto &drm_layer : drm_hwc_layers_){
|
||
if(drm_layer.bUseSr_ && drm_layer.pSrBuffer_){
|
||
drm_layer.pSrBuffer_->DumpData();
|
||
}
|
||
}
|
||
for(auto &drm_layer : drm_hwc_layers_){
|
||
if(drm_layer.bUseRga_ && drm_layer.pRgaBuffer_){
|
||
drm_layer.pRgaBuffer_->DumpData();
|
||
}
|
||
}
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
int DrmHwcTwo::HwcDisplay::HoplugEventTmeline(){
|
||
ctx_.hotplug_timeline++;
|
||
return 0;
|
||
}
|
||
|
||
int DrmHwcTwo::HwcDisplay::UpdateDisplayMode(){
|
||
|
||
if(!ctx_.bStandardSwitchResolution){
|
||
int timeline;
|
||
int display_id = static_cast<int>(handle_);
|
||
timeline = property_get_int32("vendor.display.timeline", -1);
|
||
if(timeline && timeline == ctx_.display_timeline && ctx_.hotplug_timeline == drm_->timeline())
|
||
return 0;
|
||
ctx_.display_timeline = timeline;
|
||
ctx_.hotplug_timeline = drm_->timeline();
|
||
int ret = connector_->UpdateDisplayMode(display_id, timeline);
|
||
if(!ret){
|
||
const DrmMode best_mode = connector_->best_mode();
|
||
connector_->set_current_mode(best_mode);
|
||
// will change display resolution, to clear all display.
|
||
if(!(connector_->current_mode() == connector_->active_mode())){
|
||
ClearDisplay();
|
||
// 标识 Display mode 发生改变
|
||
ActiveModeChange(true);
|
||
}
|
||
}
|
||
|
||
if(isRK3566(resource_manager_->getSocId())){
|
||
bool mirror_mode = true;
|
||
display_id = drm_->GetCommitMirrorDisplayId();
|
||
DrmConnector *conn_mirror = drm_->GetConnectorForDisplay(display_id);
|
||
if(!conn_mirror || conn_mirror->state() != DRM_MODE_CONNECTED){
|
||
ALOGI_IF(LogLevel(DBG_DEBUG),"%s,line=%d disable bCommitMirrorMode",__FUNCTION__,__LINE__);
|
||
mirror_mode = false;
|
||
}
|
||
|
||
if(mirror_mode){
|
||
ret = conn_mirror->UpdateDisplayMode(display_id, timeline);
|
||
if(!ret){
|
||
const DrmMode best_mode = conn_mirror->best_mode();
|
||
conn_mirror->set_current_mode(best_mode);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
int DrmHwcTwo::HwcDisplay::UpdateDisplayInfo(){
|
||
if(!ctx_.bStandardSwitchResolution){
|
||
const DrmMode active_mode = connector_->active_mode();
|
||
if(connector_->isHorizontalSpilt()){
|
||
ctx_.rel_xres = active_mode.h_display() / DRM_CONNECTOR_SPILT_RATIO;
|
||
ctx_.rel_yres = active_mode.v_display();
|
||
if(handle_ >= DRM_CONNECTOR_SPILT_MODE_MASK){
|
||
ctx_.rel_xoffset = active_mode.h_display() / DRM_CONNECTOR_SPILT_RATIO;
|
||
ctx_.rel_yoffset = 0;//best_mode.v_display() / 2;
|
||
}
|
||
}else if(connector_->isCropSpilt()){
|
||
ctx_.rel_xres = active_mode.h_display();
|
||
ctx_.rel_yres = active_mode.v_display();
|
||
}else{
|
||
ctx_.rel_xres = active_mode.h_display();
|
||
ctx_.rel_yres = active_mode.v_display();
|
||
}
|
||
ctx_.dclk = active_mode.clock();
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
int DrmHwcTwo::HwcDisplay::UpdateOverscan(){
|
||
connector_->UpdateOverscan(handle_, ctx_.overscan_value);
|
||
return 0;
|
||
}
|
||
|
||
int DrmHwcTwo::HwcDisplay::UpdateHdmiOutputFormat(){
|
||
int timeline = 0;
|
||
|
||
timeline = property_get_int32( "vendor.display.timeline", -1);
|
||
/*
|
||
* force update propetry when timeline is zero or not exist.
|
||
*/
|
||
if (timeline && timeline == ctx_.display_timeline && ctx_.hotplug_timeline == drm_->timeline())
|
||
return 0;
|
||
|
||
connector_->UpdateOutputFormat(handle_, timeline);
|
||
|
||
if(isRK3566(resource_manager_->getSocId())){
|
||
bool mirror_mode = true;
|
||
int display_id = drm_->GetCommitMirrorDisplayId();
|
||
DrmConnector *conn_mirror = drm_->GetConnectorForDisplay(display_id);
|
||
if(!conn_mirror || conn_mirror->state() != DRM_MODE_CONNECTED){
|
||
ALOGI_IF(LogLevel(DBG_DEBUG),"%s,line=%d disable bCommitMirrorMode",__FUNCTION__,__LINE__);
|
||
mirror_mode = false;
|
||
}
|
||
|
||
if(mirror_mode){
|
||
conn_mirror->UpdateOutputFormat(display_id, timeline);
|
||
}
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
int DrmHwcTwo::HwcDisplay::UpdateBCSH(){
|
||
|
||
int timeline = property_get_int32("vendor.display.timeline", -1);
|
||
/*
|
||
* force update propetry when timeline is zero or not exist.
|
||
*/
|
||
if (timeline && timeline == ctx_.bcsh_timeline)
|
||
return 0;
|
||
connector_->UpdateBCSH(handle_,timeline);
|
||
|
||
if(isRK3566(resource_manager_->getSocId())){
|
||
bool mirror_mode = true;
|
||
int display_id = drm_->GetCommitMirrorDisplayId();
|
||
DrmConnector *conn_mirror = drm_->GetConnectorForDisplay(display_id);
|
||
if(!conn_mirror || conn_mirror->state() != DRM_MODE_CONNECTED){
|
||
ALOGI_IF(LogLevel(DBG_DEBUG),"%s,line=%d disable bCommitMirrorMode",__FUNCTION__,__LINE__);
|
||
mirror_mode = false;
|
||
}
|
||
if(mirror_mode){
|
||
conn_mirror->UpdateBCSH(display_id,timeline);
|
||
}
|
||
}
|
||
|
||
ctx_.bcsh_timeline = timeline;
|
||
|
||
return 0;
|
||
}
|
||
bool DrmHwcTwo::HwcDisplay::DisableHdrModeRK3588(){
|
||
DrmMode active_mode = connector_->active_mode();
|
||
// 如果是8K分辨率模式，HDR片源没有走 overlay 策略，则关闭HDR
|
||
// 主要原因是VOP硬件限制，要求最底层为 HDR dataspace，GPU合成输出为SDR，
|
||
// 不满足条件，则需要关闭HDR模式
|
||
if(active_mode.id() > 0 && active_mode.is_8k_mode()){
|
||
for(auto &drmHwcLayer : drm_hwc_layers_){
|
||
if(drmHwcLayer.bHdr_){
|
||
// 没有被硬件图层匹配，则说明使用GPU合成
|
||
if(!drmHwcLayer.bMatch_){
|
||
HWC2_ALOGD_IF_DEBUG("HDR video compose by GLES on 8k resolution, Fource Disable HDR mode.");
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
bool DrmHwcTwo::HwcDisplay::DisableHdrMode(){
|
||
bool exist_hdr_layer = false;
|
||
int hdr_area_ratio = 0;
|
||
|
||
for(auto &drmHwcLayer : drm_hwc_layers_){
|
||
if(drmHwcLayer.bHdr_){
|
||
exist_hdr_layer = true;
|
||
int src_w = (int)(drmHwcLayer.source_crop.right - drmHwcLayer.source_crop.left);
|
||
int src_h = (int)(drmHwcLayer.source_crop.bottom - drmHwcLayer.source_crop.top);
|
||
int src_area_size = src_w * src_h;
|
||
int dis_w = drmHwcLayer.display_frame.right - drmHwcLayer.display_frame.left;
|
||
int dis_h = drmHwcLayer.display_frame.bottom - drmHwcLayer.display_frame.top;
|
||
int dis_area_size = dis_w * dis_h;
|
||
// 视频缩小倍数*10，*10的原因是 vendor.hwc.hdr_video_area 为整型，不支持浮点数
|
||
hdr_area_ratio = dis_area_size * 10 / src_area_size;
|
||
int screen_size = ctx_.rel_xres * ctx_.rel_yres;
|
||
// 视频占屏幕面积*10，取缩小倍数与视频占用屏幕面积较大值，实现与操作
|
||
// 即需要同时满足视频缩小60%，屏占60%才关闭HDR模式
|
||
if(hdr_area_ratio < (dis_area_size * 10 / screen_size))
|
||
hdr_area_ratio = dis_area_size * 10 / screen_size;
|
||
}
|
||
}
|
||
|
||
if(exist_hdr_layer){
|
||
// 存在 HDR图层，判断是否存在强制关闭HDR属性，若存在则关闭HDR模式
|
||
char value[PROPERTY_VALUE_MAX];
|
||
property_get("persist.vendor.hwc.hdr_force_disable", value, "0");
|
||
if(atoi(value) > 0){
|
||
if(ctx_.hdr_mode != DRM_HWC_SDR){
|
||
HWC2_ALOGD_IF_DEBUG("Exit HDR mode success");
|
||
property_set("vendor.hwc.hdr_state","FORCE-NORMAL");
|
||
}
|
||
HWC2_ALOGD_IF_DEBUG("Fource Disable HDR mode.");
|
||
return true;
|
||
}
|
||
|
||
// 存在 HDR图层，判断HDR视频的屏幕占比与缩放倍率，满足条件则关闭HDR模式
|
||
property_get("persist.vendor.hwc.hdr_video_area", value, "6");
|
||
if(atoi(value) > hdr_area_ratio){
|
||
if(ctx_.hdr_mode != DRM_HWC_SDR){
|
||
HWC2_ALOGD_IF_DEBUG("Exit HDR mode success");
|
||
property_set("vendor.hwc.hdr_state","FORCE-NORMAL");
|
||
}
|
||
HWC2_ALOGD_IF_DEBUG("Force Disable HDR mode.");
|
||
return true;
|
||
}
|
||
}
|
||
|
||
if(!exist_hdr_layer && ctx_.hdr_mode != DRM_HWC_SDR){
|
||
ALOGD_IF(LogLevel(DBG_DEBUG),"Exit HDR mode success");
|
||
property_set("vendor.hwc.hdr_state","NORMAL");
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
int DrmHwcTwo::HwcDisplay::EnableMetadataHdrMode(DrmHwcLayer& hdrLayer){
|
||
HWC2_ALOGD_IF_INFO("Id=%d Name=%s ", hdrLayer.uId_, hdrLayer.sLayerName_.c_str());
|
||
|
||
if(ctx_.display_type == DRM_MODE_CONNECTOR_TV){
|
||
HWC2_ALOGD_IF_INFO("RK3528 TV unsupport HDR2SDR, Id=%d Name=%s eDataSpace_=0x%x eotf=%d",
|
||
hdrLayer.uId_, hdrLayer.sLayerName_.c_str(),
|
||
hdrLayer.eDataSpace_,
|
||
hdrLayer.uEOTF);
|
||
return -1;
|
||
}
|
||
|
||
if(hdrLayer.bSideband2_){
|
||
HWC2_ALOGD_IF_ERR("Sideband2 layer skip, Id=%d Name=%s zpos=%d match=%d",
|
||
hdrLayer.uId_, hdrLayer.sLayerName_.c_str(), hdrLayer.iZpos_, hdrLayer.bMatch_);
|
||
return -1;
|
||
}
|
||
|
||
// Next hdr zpos must be 0
|
||
if(hdrLayer.iZpos_ > 0){
|
||
HWC2_ALOGD_IF_ERR("Next hdr zpos must be 0, Id=%d Name=%s zpos=%d",
|
||
hdrLayer.uId_, hdrLayer.sLayerName_.c_str(), hdrLayer.iZpos_);
|
||
return -1;
|
||
}
|
||
|
||
if(!hdrLayer.bMatch_){
|
||
HWC2_ALOGD_IF_ERR("Next hdr not overlay, Id=%d Name=%s zpos=%d match=%d",
|
||
hdrLayer.uId_, hdrLayer.sLayerName_.c_str(), hdrLayer.iZpos_, hdrLayer.bMatch_);
|
||
return -1;
|
||
}
|
||
|
||
|
||
// 算法解析库是否存在
|
||
DrmHdrParser* dhp = DrmHdrParser::Get();
|
||
if(dhp == NULL){
|
||
HWC2_ALOGD_IF_ERR("Fail to get DrmHdrParser, use SDR mode, Id=%d Name=%s ", hdrLayer.uId_, hdrLayer.sLayerName_.c_str());
|
||
return -1;
|
||
}
|
||
|
||
// 显示器是否支持HDR
|
||
bool is_hdr_display = connector_->is_hdmi_support_hdr();
|
||
// 是否为 HDR 片源
|
||
bool is_input_hdr = hdrLayer.bHdr_;
|
||
// 2:自动模式: 电视支持 HDR模式播放HDR视频则切换HDR模式，否则使用SDR模式
|
||
// 1:HDR模式: 等同自动模式
|
||
// 0:SDR模式: 电视强制使用SDR模式，HDR片源也采用SDR显示
|
||
int user_hdr_mode = hwc_get_int_property("persist.sys.vivid.hdr_mode", "2");
|
||
// 可能存在模式：SDR2SDR,HDR2SDR,SDR2HDR,HDR2HDR
|
||
bool is_output_hdr = false;
|
||
// 2:自动模式: 电视支持 HDR模式播放HDR视频则切换HDR模式，否则使用SDR模式
|
||
// 1:HDR模式: 电视支持 HDR模式则强制使用HDR模式，SDR片源也采用HDR模式输出
|
||
if((user_hdr_mode == 2 && is_hdr_display && is_input_hdr) ||
|
||
(user_hdr_mode == 1 && is_hdr_display && is_input_hdr)){
|
||
is_output_hdr = true;
|
||
}else{
|
||
is_output_hdr = false;
|
||
}
|
||
|
||
// 如果输入是 SDR 且输出为SDR,则不需要进行任何处理
|
||
if(is_input_hdr == false && is_output_hdr == false){
|
||
HWC2_ALOGD_IF_INFO("Use SDR2SDR mode.");
|
||
return -1;
|
||
}
|
||
|
||
|
||
DrmGralloc* gralloc = DrmGralloc::getInstance();
|
||
if(gralloc == NULL){
|
||
HWC2_ALOGD_IF_INFO("DrmGralloc is null, Use SDR2SDR mode.");
|
||
return -1;
|
||
}
|
||
|
||
// debug 打印耗时
|
||
long t0 = __currentTime();
|
||
|
||
// 用于判断是否存在 metadata 信息
|
||
bool codec_meta_exist = false;
|
||
// 获取存储 metadata 信息的offset
|
||
int64_t offset = gralloc->hwc_get_offset_of_dynamic_hdr_metadata(hdrLayer.sf_handle);
|
||
if(offset < 0){
|
||
HWC2_ALOGD_IF_ERR("Fail to get hdr metadata offset, Id=%d Name=%s ", hdrLayer.uId_, hdrLayer.sLayerName_.c_str());
|
||
}
|
||
// offset > 0 则认为存在 Metadata
|
||
codec_meta_exist = offset > 0;
|
||
HWC2_ALOGD_IF_INFO("dynamic_hdr_metadata offset=%" PRIi64, offset);
|
||
|
||
// 初始化参数
|
||
memset(&hdrLayer.metadataHdrParam_, 0x00, sizeof(rk_hdr_parser_params_t));
|
||
// 如果输出模式为HDR
|
||
if(is_output_hdr){
|
||
// Android bt2020 or bt709
|
||
switch(hdrLayer.eDataSpace_ & HAL_DATASPACE_STANDARD_MASK){
|
||
case HAL_DATASPACE_STANDARD_BT2020:
|
||
case HAL_DATASPACE_STANDARD_BT2020_CONSTANT_LUMINANCE :
|
||
hdrLayer.metadataHdrParam_.hdr_hdmi_meta.color_prim = COLOR_PRIM_BT2020;
|
||
break;
|
||
default:
|
||
hdrLayer.metadataHdrParam_.hdr_hdmi_meta.color_prim = COLOR_PRIM_BT709;
|
||
break;
|
||
}
|
||
|
||
// 片源为 HLG，且电视支持 HLG ，则选择 HLG bypass 模式
|
||
if(hdrLayer.uEOTF == HLG && connector_->isSupportHLG()){
|
||
hdrLayer.metadataHdrParam_.hdr_hdmi_meta.eotf = SINK_EOTF_HLG;
|
||
// 片源为 HDR10，且电视支持 HDR10 ，则选择 HDR10 bypass 模式
|
||
}else if(hdrLayer.uEOTF == SMPTE_ST2084 && connector_->isSupportSt2084()){
|
||
hdrLayer.metadataHdrParam_.hdr_hdmi_meta.eotf = SINK_EOTF_ST2084;
|
||
// 若没有匹配的 HDR 模式，则优先使用 HDR10 输出
|
||
}else{
|
||
if(connector_->isSupportSt2084()){
|
||
hdrLayer.metadataHdrParam_.hdr_hdmi_meta.eotf = SINK_EOTF_ST2084;
|
||
}else if(connector_->isSupportHLG()){
|
||
hdrLayer.metadataHdrParam_.hdr_hdmi_meta.eotf = SINK_EOTF_HLG;
|
||
}
|
||
}
|
||
// hdr10 最小亮度应该是0.05,算法提供接口是要求外部数值 0.05*100=5
|
||
hdrLayer.metadataHdrParam_.hdr_hdmi_meta.dst_min = 5;
|
||
hdrLayer.metadataHdrParam_.hdr_hdmi_meta.dst_max = hwc_get_int_property("persist.sys.vivid.max_brightness", "1000") * 100;
|
||
}else{
|
||
hdrLayer.metadataHdrParam_.hdr_hdmi_meta.color_prim = COLOR_PRIM_BT709;
|
||
hdrLayer.metadataHdrParam_.hdr_hdmi_meta.eotf = SINK_EOTF_GAMMA_SDR;
|
||
hdrLayer.metadataHdrParam_.hdr_hdmi_meta.dst_min = 10;
|
||
hdrLayer.metadataHdrParam_.hdr_hdmi_meta.dst_max = hwc_get_int_property("persist.sys.vivid.max_brightness", "100") * 100;
|
||
}
|
||
|
||
void *cpu_addr = NULL;
|
||
if(codec_meta_exist){
|
||
// 获取Medata地址
|
||
cpu_addr = gralloc->hwc_get_handle_lock(hdrLayer.sf_handle, hdrLayer.iWidth_, hdrLayer.iHeight_);
|
||
if(cpu_addr == NULL){
|
||
HWC2_ALOGD_IF_ERR("Fail to lock dma buffer, Id=%d Name=%s ", hdrLayer.uId_, hdrLayer.sLayerName_.c_str());
|
||
hdrLayer.metadataHdrParam_.codec_meta_exist = false;
|
||
hdrLayer.metadataHdrParam_.p_hdr_codec_meta = NULL;
|
||
}else{
|
||
uint16_t *u16_cpu_metadata = (uint16_t *)((uint8_t *)cpu_addr + offset);
|
||
hdrLayer.metadataHdrParam_.codec_meta_exist = codec_meta_exist;
|
||
hdrLayer.metadataHdrParam_.p_hdr_codec_meta = (RkMetaHdrHeader*)u16_cpu_metadata;
|
||
|
||
// 如果当前设置 hdr 显示模式为 HLG bypass，则需要检测 HLG 片源是否为 dynamic Hdr
|
||
// 若为 dynamic Hdr，则需要将输出模式修改为 Hdr10,若不支持Hdr10,则输出SDR
|
||
// 原因是目前 VOP3 是参考 VividHdr标准实现，标准内部没有支持 dynamic hlg hdr 直出模式
|
||
if(hdrLayer.uEOTF == HLG &&
|
||
hdrLayer.metadataHdrParam_.hdr_hdmi_meta.eotf == SINK_EOTF_HLG){
|
||
int ret = dhp->MetadataHdrparserFormat(&hdrLayer.metadataHdrParam_,
|
||
&hdrLayer.metadataHdrFmtInfo_);
|
||
if(ret){
|
||
HWC2_ALOGD_IF_ERR("MetadataHdrparserFormat, Id=%d Name=%s ", hdrLayer.uId_, hdrLayer.sLayerName_.c_str());
|
||
hdrLayer.metadataHdrParam_.hdr_hdmi_meta.eotf = SINK_EOTF_ST2084;
|
||
}else{
|
||
if(hdrLayer.metadataHdrFmtInfo_.hdr_format == HDRVIVID){
|
||
if(connector_->isSupportSt2084()){
|
||
hdrLayer.metadataHdrParam_.hdr_hdmi_meta.eotf = SINK_EOTF_ST2084;
|
||
HWC2_ALOGD_IF_INFO("Id=%d Name=%s is HLG dynamic, convert to HDR10.", hdrLayer.uId_, hdrLayer.sLayerName_.c_str());
|
||
}else{
|
||
hdrLayer.metadataHdrParam_.hdr_hdmi_meta.eotf = SINK_EOTF_GAMMA_SDR;
|
||
HWC2_ALOGD_IF_INFO("Id=%d Name=%s is HLG dynamic, convert to SDR.", hdrLayer.uId_, hdrLayer.sLayerName_.c_str());
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}else{
|
||
// Metadata 不存在，则使用 Android Dataspace
|
||
hdrLayer.metadataHdrParam_.codec_meta_exist = false;
|
||
hdrLayer.metadataHdrParam_.p_hdr_codec_meta = NULL;
|
||
|
||
// Android bt2020 or bt709
|
||
switch(hdrLayer.eDataSpace_ & HAL_DATASPACE_STANDARD_MASK){
|
||
case HAL_DATASPACE_STANDARD_BT2020:
|
||
case HAL_DATASPACE_STANDARD_BT2020_CONSTANT_LUMINANCE :
|
||
hdrLayer.metadataHdrParam_.hdr_dataspace_info.color_prim = COLOR_PRIM_BT2020;
|
||
break;
|
||
default:
|
||
hdrLayer.metadataHdrParam_.hdr_dataspace_info.color_prim = COLOR_PRIM_BT709;
|
||
break;
|
||
}
|
||
|
||
// Android st2084 / HLG / SDR
|
||
switch(hdrLayer.eDataSpace_ & HAL_DATASPACE_TRANSFER_MASK){
|
||
case HAL_DATASPACE_TRANSFER_ST2084:
|
||
hdrLayer.metadataHdrParam_.hdr_dataspace_info.eotf = SINK_EOTF_ST2084;
|
||
break;
|
||
case HAL_DATASPACE_TRANSFER_HLG :
|
||
hdrLayer.metadataHdrParam_.hdr_dataspace_info.eotf = SINK_EOTF_HLG;
|
||
break;
|
||
default:
|
||
hdrLayer.metadataHdrParam_.hdr_dataspace_info.eotf = SINK_EOTF_GAMMA_SDR;
|
||
break;
|
||
}
|
||
|
||
// Android full / limit range
|
||
switch(hdrLayer.eDataSpace_ & HAL_DATASPACE_RANGE_MASK){
|
||
case HAL_DATASPACE_RANGE_FULL:
|
||
hdrLayer.metadataHdrParam_.hdr_dataspace_info.range = RANGE_FULL;
|
||
break;
|
||
case HAL_DATASPACE_RANGE_LIMITED :
|
||
hdrLayer.metadataHdrParam_.hdr_dataspace_info.range = RANGE_LIMITED;
|
||
break;
|
||
default:
|
||
hdrLayer.metadataHdrParam_.hdr_dataspace_info.range = RANGE_LIMITED;
|
||
break;
|
||
}
|
||
}
|
||
|
||
hdrLayer.metadataHdrParam_.hdr_user_cfg.hdr_pq_max_y_mode = 0;
|
||
hdrLayer.metadataHdrParam_.hdr_user_cfg.hdr_dst_gamma = 2.2;
|
||
hdrLayer.metadataHdrParam_.hdr_user_cfg.s2h_sm_ratio = 1.0;
|
||
hdrLayer.metadataHdrParam_.hdr_user_cfg.s2h_scale_ratio = 1.0;
|
||
hdrLayer.metadataHdrParam_.hdr_user_cfg.s2h_sdr_color_space = 2;
|
||
hdrLayer.metadataHdrParam_.hdr_user_cfg.hdr_debug_cfg.print_input_meta = 0;
|
||
hdrLayer.metadataHdrParam_.hdr_user_cfg.hdr_debug_cfg.hdr_log_level = 0;
|
||
|
||
if(hwc_get_int_property("vendor.hwc.vivid_hdr_debug", "0") > 0){
|
||
hdrLayer.uEOTF = hwc_get_int_property("vendor.hwc.vivid_layer_eotf", "0");
|
||
hdrLayer.metadataHdrParam_.codec_meta_exist = hwc_get_bool_property("vendor.hwc.vivid_codec_meta_exist", "true");
|
||
hdrLayer.metadataHdrParam_.hdr_hdmi_meta.color_prim = hwc_get_int_property("vendor.hwc.vivid_color_prim", "0");
|
||
hdrLayer.metadataHdrParam_.hdr_hdmi_meta.eotf = hwc_get_int_property("vendor.hwc.vivid_eotf", "0");
|
||
hdrLayer.metadataHdrParam_.hdr_hdmi_meta.red_x = hwc_get_int_property("vendor.hwc.vivid_red_x", "0");
|
||
hdrLayer.metadataHdrParam_.hdr_hdmi_meta.red_y = hwc_get_int_property("vendor.hwc.vivid_red_y", "0");
|
||
hdrLayer.metadataHdrParam_.hdr_hdmi_meta.green_x = hwc_get_int_property("vendor.hwc.vivid_green_x", "0");
|
||
hdrLayer.metadataHdrParam_.hdr_hdmi_meta.green_y = hwc_get_int_property("vendor.hwc.vivid_green_y", "0");
|
||
hdrLayer.metadataHdrParam_.hdr_hdmi_meta.white_point_x = hwc_get_int_property("vendor.hwc.vivid_white_point_x", "0");
|
||
hdrLayer.metadataHdrParam_.hdr_hdmi_meta.white_point_y = hwc_get_int_property("vendor.hwc.vivid_white_point_y", "0");
|
||
hdrLayer.metadataHdrParam_.hdr_hdmi_meta.dst_min = hwc_get_int_property("vendor.hwc.vivid_dst_min", "10");
|
||
hdrLayer.metadataHdrParam_.hdr_hdmi_meta.dst_max = hwc_get_int_property("vendor.hwc.vivid_dst_max", "10000");
|
||
|
||
hdrLayer.metadataHdrParam_.hdr_dataspace_info.color_prim = hwc_get_int_property("vendor.hwc.vivid_dataspace_pri", "0");
|
||
hdrLayer.metadataHdrParam_.hdr_dataspace_info.eotf = hwc_get_int_property("vendor.hwc.vivid_dataspace_eotf", "0");
|
||
hdrLayer.metadataHdrParam_.hdr_dataspace_info.range = hwc_get_int_property("vendor.hwc.vivid_dataspace_range", "0");
|
||
|
||
hdrLayer.metadataHdrParam_.hdr_user_cfg.hdr_pq_max_y_mode = hwc_get_int_property("vendor.hwc.vivid_hdr_pq_max_y_mode", "0");
|
||
hdrLayer.metadataHdrParam_.hdr_user_cfg.hdr_dst_gamma = (hwc_get_int_property("vendor.hwc.vivid_hdr_dst_gamma", "22") * 1.0 / 10);
|
||
hdrLayer.metadataHdrParam_.hdr_user_cfg.s2h_sm_ratio = hwc_get_int_property("vendor.hwc.vivid_s2h_sm_ratio", "10") * 1.0 / 10;
|
||
hdrLayer.metadataHdrParam_.hdr_user_cfg.s2h_scale_ratio = hwc_get_int_property("vendor.hwc.vivid_s2h_scale_ratio", "10") * 1.0 / 10;
|
||
hdrLayer.metadataHdrParam_.hdr_user_cfg.s2h_sdr_color_space = hwc_get_int_property("vendor.hwc.vivid_s2h_sdr_color_space", "2");
|
||
hdrLayer.metadataHdrParam_.hdr_user_cfg.hdr_debug_cfg.print_input_meta = hwc_get_int_property("vendor.hwc.vivid_print_input_meta", "1");
|
||
hdrLayer.metadataHdrParam_.hdr_user_cfg.hdr_debug_cfg.hdr_log_level = hwc_get_int_property("vendor.hwc.vivid_hdr_log_level", "7");
|
||
}
|
||
|
||
HWC2_ALOGD_IF_INFO("hdr_hdmi_meta: user_hdr_mode(%d) layer eDataSpace=0x%x eotf=%d => codec_meta_exist(%d) hdr_dataspace_info: color_prim=%d eotf=%d range=%d",
|
||
user_hdr_mode,
|
||
hdrLayer.eDataSpace_,
|
||
hdrLayer.uEOTF,
|
||
hdrLayer.metadataHdrParam_.codec_meta_exist,
|
||
hdrLayer.metadataHdrParam_.hdr_dataspace_info.color_prim,
|
||
hdrLayer.metadataHdrParam_.hdr_dataspace_info.eotf,
|
||
hdrLayer.metadataHdrParam_.hdr_dataspace_info.range);
|
||
HWC2_ALOGD_IF_INFO("hdr_hdmi_meta: color_prim=%d eotf=%d red_x=%d red_y=%d green_x=%d green_y=%d white_point_x=%d white_point_y=%d dst_min=%d dst_max=%d",
|
||
hdrLayer.metadataHdrParam_.hdr_hdmi_meta.color_prim,
|
||
hdrLayer.metadataHdrParam_.hdr_hdmi_meta.eotf,
|
||
hdrLayer.metadataHdrParam_.hdr_hdmi_meta.red_x,
|
||
hdrLayer.metadataHdrParam_.hdr_hdmi_meta.red_y,
|
||
hdrLayer.metadataHdrParam_.hdr_hdmi_meta.green_x,
|
||
hdrLayer.metadataHdrParam_.hdr_hdmi_meta.green_y,
|
||
hdrLayer.metadataHdrParam_.hdr_hdmi_meta.white_point_x,
|
||
hdrLayer.metadataHdrParam_.hdr_hdmi_meta.white_point_y,
|
||
hdrLayer.metadataHdrParam_.hdr_hdmi_meta.dst_min,
|
||
hdrLayer.metadataHdrParam_.hdr_hdmi_meta.dst_max);
|
||
|
||
HWC2_ALOGD_IF_INFO("hdr_user_cfg: hdr_pq_max_y_mode=%d hdr_dst_gamma=%f s2h_sm_ratio=%f s2h_scale_ratio=%f s2h_sdr_color_space=%d print_input_meta=%d hdr_log_level=%d",
|
||
hdrLayer.metadataHdrParam_.hdr_user_cfg.hdr_pq_max_y_mode,
|
||
hdrLayer.metadataHdrParam_.hdr_user_cfg.hdr_dst_gamma,
|
||
hdrLayer.metadataHdrParam_.hdr_user_cfg.s2h_sm_ratio,
|
||
hdrLayer.metadataHdrParam_.hdr_user_cfg.s2h_scale_ratio,
|
||
hdrLayer.metadataHdrParam_.hdr_user_cfg.s2h_sdr_color_space,
|
||
hdrLayer.metadataHdrParam_.hdr_user_cfg.hdr_debug_cfg.print_input_meta,
|
||
hdrLayer.metadataHdrParam_.hdr_user_cfg.hdr_debug_cfg.hdr_log_level);
|
||
|
||
int ret = dhp->MetadataHdrParser(&hdrLayer.metadataHdrParam_);
|
||
if(ret){
|
||
HWC2_ALOGD_IF_ERR("Fail to call MetadataHdrParser ret=%d Id=%d Name=%s ",
|
||
ret,
|
||
hdrLayer.uId_,
|
||
hdrLayer.sLayerName_.c_str());
|
||
if(cpu_addr != NULL)
|
||
gralloc->hwc_get_handle_unlock(hdrLayer.sf_handle);
|
||
return ret;
|
||
}
|
||
|
||
if(cpu_addr != NULL)
|
||
gralloc->hwc_get_handle_unlock(hdrLayer.sf_handle);
|
||
|
||
hdrLayer.IsMetadataHdr_ = true;
|
||
ctx_.hdr_mode = DRM_HWC_METADATA_HDR;
|
||
ctx_.dataspace = hdrLayer.eDataSpace_;
|
||
HWC2_ALOGD_IF_INFO("Use HdrParser mode.");
|
||
return 0;
|
||
}
|
||
|
||
int DrmHwcTwo::HwcDisplay::EnableHdrMode(DrmHwcLayer& hdrLayer){
|
||
HWC2_ALOGD_IF_INFO("Id=%d Name=%s ", hdrLayer.uId_, hdrLayer.sLayerName_.c_str());
|
||
if(connector_->is_hdmi_support_hdr()){
|
||
if(ctx_.hdr_mode != DRM_HWC_HDR10){
|
||
ALOGD_IF(LogLevel(DBG_DEBUG),"Enable HDR mode success");
|
||
ctx_.hdr_mode = DRM_HWC_HDR10;
|
||
ctx_.dataspace = hdrLayer.eDataSpace_;
|
||
property_set("vendor.hwc.hdr_state","HDR");
|
||
}
|
||
return 0;
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
|
||
int DrmHwcTwo::HwcDisplay::UpdateSidebandMode(){
|
||
|
||
if(handle_ > 0){
|
||
return 0;
|
||
}
|
||
|
||
// UpdateSideband state
|
||
DrmVideoProducer* dvp = DrmVideoProducer::getInstance();
|
||
if(!dvp->IsValid()){
|
||
return -1;
|
||
}
|
||
|
||
// 判断是否存在Sideband图层，并保存tunnel_id信息
|
||
int tunnel_id = 0;
|
||
for (std::pair<const hwc2_layer_t, DrmHwcTwo::HwcLayer> &l : layers_){
|
||
if(l.second.isSidebandLayer()){
|
||
tunnel_id = l.second.getTunnelId();
|
||
}
|
||
}
|
||
|
||
// 若存在合法 tunnel_id
|
||
if(tunnel_id > 0){
|
||
if(tunnel_id != iLastTunnelId_){
|
||
if(iLastTunnelId_ > 0){
|
||
// tunnel id 不一致则先断开连接旧连接
|
||
int ret = dvp->DestoryConnection((int(handle_) + 1000), iLastTunnelId_);
|
||
if(ret){
|
||
HWC2_ALOGD_IF_ERR("DestoryConnection display=%" PRIu64 " tunnel-id=%d fail ret=%d", handle_, iLastTunnelId_, ret);
|
||
}else{
|
||
HWC2_ALOGD_IF_INFO("DestoryConnection display=%" PRIu64 " tunnel-id=%d success ret=%d", handle_, iLastTunnelId_, ret);
|
||
}
|
||
}
|
||
// 创建新连接
|
||
int ret = dvp->CreateConnection((int(handle_) + 1000), tunnel_id);
|
||
if(ret){
|
||
HWC2_ALOGD_IF_ERR("CreateConnection display=%" PRIu64 " fail tunnel-id=%d ret=%d", handle_, tunnel_id, ret);
|
||
}else{
|
||
HWC2_ALOGD_IF_INFO("CreateConnection display=%" PRIu64 " tunnel-id=%d success ret=%d", handle_, tunnel_id, ret);
|
||
}
|
||
iLastTunnelId_ = tunnel_id;
|
||
}
|
||
}else{
|
||
if(iLastTunnelId_ > 0){
|
||
// tunnel id 不一致则先断开连接旧连接
|
||
int ret = dvp->DestoryConnection((int(handle_) + 1000), iLastTunnelId_);
|
||
if(ret){
|
||
HWC2_ALOGD_IF_ERR("DestoryConnection display=%" PRIu64 " tunnel-id=%d fail ret=%d", handle_, iLastTunnelId_, ret);
|
||
}else{
|
||
HWC2_ALOGD_IF_INFO("DestoryConnection display=%" PRIu64 " tunnel-id=%d success ret=%d", handle_, iLastTunnelId_, ret);
|
||
iLastTunnelId_ = 0;
|
||
}
|
||
}
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
int DrmHwcTwo::HwcDisplay::SwitchHdrMode(){
|
||
// 需要HDR模式,找到 HDR layer,判断当前采用HDR模式
|
||
for(auto &drmHwcLayer : drm_hwc_layers_){
|
||
if(drmHwcLayer.bYuv_){
|
||
// RK3528 HDR 模式特殊处理
|
||
if(gIsRK3528()){
|
||
if(EnableMetadataHdrMode(drmHwcLayer) == 0){
|
||
return 0;
|
||
}
|
||
// 其他平台的 HDR 模式处理
|
||
}else{
|
||
if(drmHwcLayer.bHdr_){
|
||
// 其他平台通用的判断是否需要进入HDR模式逻辑
|
||
if(DisableHdrMode()){
|
||
ctx_.hdr_mode = DRM_HWC_SDR;
|
||
ctx_.dataspace = HAL_DATASPACE_UNKNOWN;
|
||
return 0;
|
||
}
|
||
// RK3588 平台特殊的判断逻辑
|
||
if(DisableHdrModeRK3588()){
|
||
ctx_.hdr_mode = DRM_HWC_SDR;
|
||
ctx_.dataspace = HAL_DATASPACE_UNKNOWN;
|
||
return 0;
|
||
}
|
||
|
||
if(!EnableHdrMode(drmHwcLayer)){
|
||
return 0;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
ctx_.hdr_mode = DRM_HWC_SDR;
|
||
ctx_.dataspace = HAL_DATASPACE_UNKNOWN;
|
||
return 0;
|
||
}
|
||
|
||
int DrmHwcTwo::HwcDisplay::UpdateTimerEnable(){
|
||
bool enable_timer = true;
|
||
for(auto &drmHwcLayer : drm_hwc_layers_){
|
||
// Video
|
||
if(drmHwcLayer.bYuv_){
|
||
ALOGD_IF(LogLevel(DBG_DEBUG),"Yuv %s timer!",static_screen_timer_enable_ ? "Enable" : "Disable");
|
||
enable_timer = false;
|
||
break;
|
||
}
|
||
|
||
#if (defined USE_LIBSR) || (defined USE_LIBSVEP_MEMC)
|
||
// Sr
|
||
if(drmHwcLayer.bUseSr_){
|
||
ALOGD_IF(LogLevel(DBG_DEBUG),"Sr %s timer!",static_screen_timer_enable_ ? "Enable" : "Disable");
|
||
enable_timer = false;
|
||
break;
|
||
}
|
||
// Memc
|
||
if(drmHwcLayer.bUseMemc_){
|
||
ALOGD_IF(LogLevel(DBG_DEBUG),"Sr %s timer!",static_screen_timer_enable_ ? "Enable" : "Disable");
|
||
enable_timer = false;
|
||
break;
|
||
}
|
||
#endif
|
||
|
||
// Sideband
|
||
if(drmHwcLayer.bSidebandStreamLayer_){
|
||
enable_timer = false;
|
||
break;
|
||
}
|
||
|
||
// Surface w/h is larger than FB
|
||
int crop_w = static_cast<int>(drmHwcLayer.source_crop.right - drmHwcLayer.source_crop.left);
|
||
int crop_h = static_cast<int>(drmHwcLayer.source_crop.bottom - drmHwcLayer.source_crop.top);
|
||
if(crop_w * crop_h > ctx_.framebuffer_width * ctx_.framebuffer_height){
|
||
ALOGD_IF(LogLevel(DBG_DEBUG),"LargeSurface %s timer!",static_screen_timer_enable_ ? "Enable" : "Disable");
|
||
enable_timer = false;
|
||
break;
|
||
}
|
||
}
|
||
static_screen_timer_enable_ = enable_timer;
|
||
return 0;
|
||
}
|
||
int DrmHwcTwo::HwcDisplay::SelfRefreshEnable(){
|
||
bool enable_self_refresh = false;
|
||
int self_fps = 10;
|
||
for(auto &drmHwcLayer : drm_hwc_layers_){
|
||
|
||
#if (defined USE_LIBSR) || (defined USE_LIBSVEP_MEMC)
|
||
// Sr
|
||
if(drmHwcLayer.bUseSr_){
|
||
HWC2_ALOGD_IF_DEBUG("Sr Enable SelfRefresh!");
|
||
enable_self_refresh = true;
|
||
self_fps = 10;
|
||
break;
|
||
}
|
||
// MEMC
|
||
if(drmHwcLayer.bUseMemc_){
|
||
HWC2_ALOGD_IF_DEBUG("Memc Enable SelfRefresh!");
|
||
enable_self_refresh = true;
|
||
self_fps = 60;
|
||
break;
|
||
}
|
||
#endif
|
||
|
||
if(drmHwcLayer.bAccelerateLayer_ && !drmHwcLayer.bMatch_){
|
||
enable_self_refresh = true;
|
||
self_fps = 30;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if(resource_manager_->isWBMode()){
|
||
if(self_fps < 30)
|
||
self_fps = 30;
|
||
}
|
||
|
||
if(enable_self_refresh){
|
||
InvalidateControl(self_fps,-1);
|
||
}
|
||
return 0 ;
|
||
}
|
||
|
||
int DrmHwcTwo::HwcDisplay::UpdateTimerState(bool gles_comp){
|
||
struct itimerval tv = {{0,0},{0,0}};
|
||
|
||
if (static_screen_timer_enable_ && gles_comp) {
|
||
int interval_value = hwc_get_int_property( "vendor.hwc.static_screen_opt_time", "2500");
|
||
interval_value = interval_value > 5000? 5000:interval_value;
|
||
interval_value = interval_value < 250? 250:interval_value;
|
||
tv.it_value.tv_sec = interval_value / 1000;
|
||
tv.it_value.tv_usec=( interval_value % 1000) * 1000;
|
||
HWC2_ALOGD_IF_VERBOSE("reset timer! interval_value = %d",interval_value);
|
||
} else {
|
||
static_screen_opt_=false;
|
||
tv.it_value.tv_usec = 0;
|
||
ALOGD_IF(LogLevel(DBG_DEBUG),"close timer!");
|
||
}
|
||
setitimer(ITIMER_REAL, &tv, NULL);
|
||
return 0;
|
||
}
|
||
|
||
int DrmHwcTwo::HwcDisplay::EntreStaticScreen(uint64_t refresh, int refresh_cnt){
|
||
static_screen_opt_=true;
|
||
invalidate_worker_.InvalidateControl(refresh, refresh_cnt);
|
||
return 0;
|
||
}
|
||
|
||
int DrmHwcTwo::HwcDisplay::InvalidateControl(uint64_t refresh, int refresh_cnt){
|
||
invalidate_worker_.InvalidateControl(refresh, refresh_cnt);
|
||
return 0;
|
||
}
|
||
|
||
int DrmHwcTwo::HwcDisplay::DoMirrorDisplay(int32_t *retire_fence){
|
||
if(!connector_->isCropSpilt()){
|
||
return 0;
|
||
}
|
||
|
||
if(!connector_->IsSpiltPrimary()){
|
||
return 0;
|
||
}
|
||
|
||
int32_t merge_rt_fence = -1;
|
||
int32_t display_cnt = 1;
|
||
for (auto &conn : drm_->connectors()) {
|
||
if(!conn->isCropSpilt()){
|
||
continue;
|
||
}
|
||
int display_id = conn->display();
|
||
if(!conn->IsSpiltPrimary()){
|
||
auto &display = resource_manager_->GetHwc2()->displays_.at(display_id);
|
||
if (conn->state() == DRM_MODE_CONNECTED) {
|
||
static hwc2_layer_t layer_id = 0;
|
||
if(display.has_layer(layer_id)){
|
||
}else{
|
||
display.CreateLayer(&layer_id);
|
||
}
|
||
HwcLayer &layer = display.get_layer(layer_id);
|
||
hwc_rect_t frame = {0,0,1920,1080};
|
||
layer.SetLayerDisplayFrame(frame);
|
||
hwc_frect_t crop = {0.0, 0.0, 1920.0, 1080.0};
|
||
layer.SetLayerSourceCrop(crop);
|
||
layer.SetLayerZOrder(0);
|
||
layer.SetLayerBlendMode(HWC2_BLEND_MODE_NONE);
|
||
layer.SetLayerPlaneAlpha(1.0);
|
||
layer.SetLayerCompositionType(HWC2_COMPOSITION_DEVICE);
|
||
// layer.SetLayerBuffer(NULL,-1);
|
||
layer.SetLayerTransform(0);
|
||
uint32_t num_types;
|
||
uint32_t num_requests;
|
||
display.ValidateDisplay(&num_types,&num_requests);
|
||
// display.GetChangedCompositionTypes();
|
||
// display.GetDisplayRequests();
|
||
display.AcceptDisplayChanges();
|
||
hwc_region_t damage;
|
||
display.SetClientTarget(client_layer_.buffer(),
|
||
dup(client_layer_.acquire_fence()->getFd()),
|
||
0,
|
||
damage);
|
||
int32_t rt_fence;
|
||
display.PresentDisplay(&rt_fence);
|
||
if(merge_rt_fence > 0){
|
||
char acBuf[32];
|
||
sprintf(acBuf,"RTD%" PRIu64 "M-FN%d-%d", handle_, frame_no_, display_cnt++);
|
||
sp<ReleaseFence> rt = sp<ReleaseFence>(new ReleaseFence(rt_fence, acBuf));
|
||
if(rt->isValid()){
|
||
sprintf(acBuf,"RTD%" PRIu64 "M-FN%d-%d",handle_, frame_no_, display_cnt++);
|
||
int32_t merge_rt_fence_temp = merge_rt_fence;
|
||
merge_rt_fence = rt->merge(merge_rt_fence, acBuf);
|
||
close(merge_rt_fence_temp);
|
||
}else{
|
||
HWC2_ALOGE("connector %u type=%s, type_id=%d is MirrorDisplay get retireFence fail.\n",
|
||
conn->id(),
|
||
drm_->connector_type_str(conn->type()),
|
||
conn->type_id());
|
||
}
|
||
}else{
|
||
merge_rt_fence = rt_fence;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
*retire_fence = merge_rt_fence;
|
||
return 0;
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::HwcLayer::SetLayerBlendMode(int32_t mode) {
|
||
HWC2_ALOGD_IF_VERBOSE("layer-id=%d"", blend=%d" ,id_,mode);
|
||
mCurrentState.blending_ = static_cast<HWC2::BlendMode>(mode);
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::HwcLayer::SetLayerBuffer(buffer_handle_t buffer,
|
||
int32_t acquire_fence) {
|
||
HWC2_ALOGD_IF_VERBOSE("layer-id=%d"", buffer=%p, acq_fence=%d" ,id_,buffer,acquire_fence);
|
||
//Deleting the following logic may cause the problem that the handle cannot be updated
|
||
// The buffer and acquire_fence are handled elsewhere
|
||
// if (sf_type_ == HWC2::Composition::Client ||
|
||
// sf_type_ == HWC2::Composition::Sideband ||
|
||
// sf_type_ == HWC2::Composition::SolidColor)
|
||
// return HWC2::Error::None;
|
||
if (mCurrentState.sf_type_ == HWC2::Composition::Sideband){
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
// 应用端可能会不销毁 Surface ，直接将Sideband图层修改为一般图层，故需要重置Sideband相关配置
|
||
bSideband2_ = false;
|
||
bSideband2Valid_ = false;
|
||
sidebandStreamHandle_ = NULL;
|
||
|
||
// 部分video不希望使用cache逻辑，因为可能会导致oom问题
|
||
bool need_cache = true;
|
||
ResourceManager* rm = ResourceManager::getInstance();
|
||
int buffer_limit_size = rm->GetCacheBufferLimitSize();
|
||
if(buffer_limit_size > 0){
|
||
int format = drmGralloc_->hwc_get_handle_attibute(buffer,ATT_FORMAT);
|
||
uint32_t fourcc = drmGralloc_->hwc_get_handle_fourcc_format(buffer);
|
||
if(drmGralloc_->is_yuv_format(format, fourcc)){
|
||
int width = drmGralloc_->hwc_get_handle_attibute(buffer_,ATT_WIDTH);
|
||
int height = drmGralloc_->hwc_get_handle_attibute(buffer_,ATT_HEIGHT);
|
||
if( width * height > buffer_limit_size){
|
||
need_cache = false;
|
||
}
|
||
}
|
||
}
|
||
|
||
if(need_cache){
|
||
CacheBufferInfo(buffer);
|
||
}else{
|
||
NoCacheBufferInfo(buffer);
|
||
}
|
||
acquire_fence_ = sp<AcquireFence>(new AcquireFence(acquire_fence));
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::HwcLayer::SetLayerColor(hwc_color_t color) {
|
||
HWC2_ALOGD_IF_VERBOSE("layer-id=%d"", color [r,g,b,a]=[%d,%d,%d,%d]" ,id_,color.r,color.g,color.b,color.a);
|
||
// TODO: Punt to client composition here?
|
||
mCurrentState.color_ = color;
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::HwcLayer::SetLayerCompositionType(int32_t type) {
|
||
HWC2_ALOGD_IF_VERBOSE("layer-id=%d"", type=0x%x" ,id_,type);
|
||
mCurrentState.sf_type_ = static_cast<HWC2::Composition>(type);
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::HwcLayer::SetLayerDataspace(int32_t dataspace) {
|
||
HWC2_ALOGD_IF_VERBOSE("layer-id=%d"", dataspace=0x%x" ,id_,dataspace);
|
||
mCurrentState.dataspace_ = static_cast<android_dataspace_t>(dataspace);
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::HwcLayer::SetLayerDisplayFrame(hwc_rect_t frame) {
|
||
HWC2_ALOGD_IF_VERBOSE("layer-id=%d"", frame=[%d,%d,%d,%d]" ,id_,frame.left,frame.top,frame.right,frame.bottom);
|
||
mCurrentState.display_frame_ = frame;
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::HwcLayer::SetLayerPlaneAlpha(float alpha) {
|
||
HWC2_ALOGD_IF_VERBOSE("layer-id=%d"", alpha=%f" ,id_,alpha);
|
||
mCurrentState.alpha_ = alpha;
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::HwcLayer::SetLayerSidebandStream(
|
||
const native_handle_t *stream) {
|
||
HWC2_ALOGD_IF_VERBOSE("layer-id=%d stream=%p",id_, stream);
|
||
ResourceManager* rm = ResourceManager::getInstance();
|
||
if(rm->IsSidebandStream2Mode()){
|
||
if(stream != NULL){
|
||
vt_sideband_data_t *sbi = (vt_sideband_data_t *)(stream->data);
|
||
// 如果 Tunnel Id 有效，并且是未连接状态，则创建连接
|
||
if(sbi->tunnel_id != mSidebandInfo_.tunnel_id){
|
||
HWC2_ALOGD_IF_DEBUG("SidebandStream: layer-id=%d. version=%d numFds=%d numInts=%d",
|
||
id_,
|
||
stream->version,
|
||
stream->numFds,
|
||
stream->numInts);
|
||
HWC2_ALOGD_IF_DEBUG("SidebandStream: version=%d sizeof=%zu tunnel-id=%d session-id=%" PRIu64 " crop[%d,%d,%d,%d] "
|
||
" w=%d h=%d ws=%d hs=%d bs=%d f=%d transform=%d size=%d modifier=%d"
|
||
" usage=0x%" PRIx64 " dataSpace=0x%" PRIx64 " afbc=%d fps=%" PRIu64 "",
|
||
stream->data[0],
|
||
sizeof(vt_sideband_data_t),
|
||
sbi->tunnel_id,
|
||
sbi->session_id,
|
||
sbi->crop.left,
|
||
sbi->crop.top,
|
||
sbi->crop.right,
|
||
sbi->crop.bottom,
|
||
sbi->width,
|
||
sbi->height,
|
||
sbi->hor_stride,
|
||
sbi->ver_stride,
|
||
sbi->byte_stride,
|
||
sbi->format,
|
||
sbi->transform,
|
||
sbi->size,
|
||
sbi->modifier,
|
||
sbi->usage,
|
||
sbi->data_space,
|
||
sbi->is_afbc,
|
||
sbi->fps);
|
||
bSideband2Valid_=true;
|
||
memcpy(&mSidebandInfo_, sbi, sizeof(vt_sideband_data_t));
|
||
}
|
||
// sbi->tunnel_id 不等于0才认为是有效的Sideband 2.0 handle
|
||
if(sbi->tunnel_id != 0){
|
||
sidebandStreamHandle_ = stream;
|
||
}else{// 否则设置为NULL
|
||
sidebandStreamHandle_ = NULL;
|
||
}
|
||
}
|
||
bSideband2_ = true;
|
||
}else{
|
||
setSidebandStream(stream);
|
||
}
|
||
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::HwcLayer::SetLayerSourceCrop(hwc_frect_t crop) {
|
||
HWC2_ALOGD_IF_VERBOSE("layer-id=%d"", frame=[%f,%f,%f,%f]" ,id_,crop.left,crop.top,crop.right,crop.bottom);
|
||
mCurrentState.source_crop_ = crop;
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::HwcLayer::SetLayerSurfaceDamage(hwc_region_t damage) {
|
||
HWC2_ALOGD_IF_VERBOSE("layer-id=%d",id_);
|
||
// TODO: We don't use surface damage, marking as unsupported
|
||
unsupported(__func__, damage);
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::HwcLayer::SetLayerTransform(int32_t transform) {
|
||
HWC2_ALOGD_IF_VERBOSE("layer-id=%d" ", transform=%x",id_,transform);
|
||
mCurrentState.transform_ = static_cast<HWC2::Transform>(transform);
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::HwcLayer::SetLayerVisibleRegion(hwc_region_t visible) {
|
||
HWC2_ALOGD_IF_VERBOSE("layer-id=%d",id_);
|
||
// TODO: We don't use this information, marking as unsupported
|
||
unsupported(__func__, visible);
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
HWC2::Error DrmHwcTwo::HwcLayer::SetLayerZOrder(uint32_t order) {
|
||
HWC2_ALOGD_IF_VERBOSE("layer-id=%d" ", z=%d",id_,order);
|
||
mCurrentState.z_order_ = order;
|
||
return HWC2::Error::None;
|
||
}
|
||
|
||
|
||
void DrmHwcTwo::HwcLayer::PopulateSidebandLayer(DrmHwcLayer *drmHwcLayer,
|
||
hwc2_drm_display_t* ctx) {
|
||
// sideband layer
|
||
if(bSideband2_){
|
||
if(bSideband2Valid_){
|
||
drmHwcLayer->iTunnelId_ = mSidebandInfo_.tunnel_id;
|
||
drmHwcLayer->bSidebandStreamLayer_ = true;
|
||
drmHwcLayer->sf_handle = NULL;
|
||
drmHwcLayer->SetDisplayFrame(mCurrentState.display_frame_, ctx);
|
||
|
||
hwc_frect source_crop;
|
||
source_crop.left = mSidebandInfo_.crop.left;
|
||
source_crop.top = mSidebandInfo_.crop.top;
|
||
source_crop.right = mSidebandInfo_.crop.right;
|
||
source_crop.bottom = mSidebandInfo_.crop.bottom;
|
||
drmHwcLayer->SetSourceCrop(source_crop);
|
||
|
||
drmHwcLayer->SetTransform(mCurrentState.transform_);
|
||
// Commit mirror function
|
||
drmHwcLayer->SetDisplayFrameMirror(mCurrentState.display_frame_);
|
||
|
||
drmHwcLayer->iFd_ = -1;
|
||
drmHwcLayer->iWidth_ = mSidebandInfo_.crop.right - mSidebandInfo_.crop.left;
|
||
drmHwcLayer->iHeight_ = mSidebandInfo_.crop.bottom - mSidebandInfo_.crop.top;
|
||
drmHwcLayer->iStride_ = mSidebandInfo_.crop.right - mSidebandInfo_.crop.left;;
|
||
drmHwcLayer->iFormat_ = mSidebandInfo_.format;
|
||
drmHwcLayer->iUsage = mSidebandInfo_.usage;
|
||
drmHwcLayer->iHeightStride_ = mSidebandInfo_.crop.bottom - mSidebandInfo_.crop.top;
|
||
drmHwcLayer->uFourccFormat_ = drmGralloc_->hwc_get_fourcc_from_hal_format(mSidebandInfo_.format);
|
||
drmHwcLayer->bSideband2_ = true;
|
||
// 通过 Sideband Handle is_afbc 来判断图层是否为AFBC压缩格式
|
||
drmHwcLayer->uModifier_ = (mSidebandInfo_.is_afbc > 0) ? AFBC_FORMAT_MOD_BLOCK_SIZE_16x16 : 0;
|
||
drmHwcLayer->uGemHandle_ = 0;
|
||
drmHwcLayer->sLayerName_ = std::string("SidebandStream-2.0");
|
||
drmHwcLayer->eDataSpace_ = (android_dataspace_t)mSidebandInfo_.data_space;
|
||
}else{
|
||
drmHwcLayer->iFd_ = -1;
|
||
drmHwcLayer->iWidth_ = -1;
|
||
drmHwcLayer->iHeight_ = -1;
|
||
drmHwcLayer->iStride_ = -1;
|
||
drmHwcLayer->iFormat_ = -1;
|
||
drmHwcLayer->iUsage = 0;
|
||
drmHwcLayer->iHeightStride_ = -1;
|
||
drmHwcLayer->uFourccFormat_ = 0x20202020; //0x20 is space
|
||
drmHwcLayer->uModifier_ = 0;
|
||
drmHwcLayer->uGemHandle_ = 0;
|
||
drmHwcLayer->sLayerName_.clear();
|
||
}
|
||
}else{
|
||
drmHwcLayer->bSidebandStreamLayer_ = true;
|
||
drmHwcLayer->sf_handle = mCurrentState.sidebandStreamHandle_;
|
||
drmHwcLayer->SetDisplayFrame(mCurrentState.display_frame_, ctx);
|
||
|
||
hwc_frect source_crop;
|
||
source_crop.top = 0;
|
||
source_crop.left = 0;
|
||
source_crop.right = pBufferInfo_->iWidth_;
|
||
source_crop.bottom = pBufferInfo_->iHeight_;
|
||
drmHwcLayer->SetSourceCrop(source_crop);
|
||
|
||
drmHwcLayer->SetTransform(mCurrentState.transform_);
|
||
// Commit mirror function
|
||
drmHwcLayer->SetDisplayFrameMirror(mCurrentState.display_frame_);
|
||
|
||
if(mCurrentState.sidebandStreamHandle_){
|
||
drmHwcLayer->iFd_ = pBufferInfo_->iFd_.get();
|
||
drmHwcLayer->iWidth_ = pBufferInfo_->iWidth_;
|
||
drmHwcLayer->iHeight_ = pBufferInfo_->iHeight_;
|
||
drmHwcLayer->iStride_ = pBufferInfo_->iStride_;
|
||
drmHwcLayer->iFormat_ = pBufferInfo_->iFormat_;
|
||
drmHwcLayer->iUsage = pBufferInfo_->iUsage_;
|
||
drmHwcLayer->iHeightStride_ = pBufferInfo_->iHeightStride_;
|
||
drmHwcLayer->iByteStride_ = pBufferInfo_->iByteStride_;
|
||
drmHwcLayer->uFourccFormat_ = pBufferInfo_->uFourccFormat_;
|
||
drmHwcLayer->uModifier_ = pBufferInfo_->uModifier_;
|
||
drmHwcLayer->sLayerName_ = pBufferInfo_->sLayerName_;
|
||
}else{
|
||
drmHwcLayer->iFd_ = -1;
|
||
drmHwcLayer->iWidth_ = -1;
|
||
drmHwcLayer->iHeight_ = -1;
|
||
drmHwcLayer->iStride_ = -1;
|
||
drmHwcLayer->iFormat_ = -1;
|
||
drmHwcLayer->iUsage = 0;
|
||
drmHwcLayer->iHeightStride_ = -1;
|
||
drmHwcLayer->uFourccFormat_ = 0x20202020; //0x20 is space
|
||
drmHwcLayer->uModifier_ = 0;
|
||
drmHwcLayer->uGemHandle_ = 0;
|
||
drmHwcLayer->sLayerName_.clear();
|
||
}
|
||
}
|
||
|
||
drmHwcLayer->Init();
|
||
return;
|
||
}
|
||
|
||
void DrmHwcTwo::HwcLayer::PopulateNormalLayer(DrmHwcLayer *drmHwcLayer,
|
||
hwc2_drm_display_t* ctx) {
|
||
drmHwcLayer->SetDisplayFrame(mCurrentState.display_frame_, ctx);
|
||
drmHwcLayer->SetSourceCrop(mCurrentState.source_crop_);
|
||
drmHwcLayer->SetTransform(mCurrentState.transform_);
|
||
// Commit mirror function
|
||
drmHwcLayer->SetDisplayFrameMirror(mCurrentState.display_frame_);
|
||
|
||
if(buffer_){
|
||
drmHwcLayer->sf_handle = pBufferInfo_->native_buffer_;
|
||
drmHwcLayer->uBufferId_ = pBufferInfo_->uBufferId_;
|
||
drmHwcLayer->iFd_ = pBufferInfo_->iFd_.get();
|
||
drmHwcLayer->iWidth_ = pBufferInfo_->iWidth_;
|
||
drmHwcLayer->iHeight_ = pBufferInfo_->iHeight_;
|
||
drmHwcLayer->iStride_ = pBufferInfo_->iStride_;
|
||
drmHwcLayer->iSize_ = pBufferInfo_->iSize_;
|
||
drmHwcLayer->iFormat_ = pBufferInfo_->iFormat_;
|
||
drmHwcLayer->iUsage = pBufferInfo_->iUsage_;
|
||
drmHwcLayer->iHeightStride_ = pBufferInfo_->iHeightStride_;
|
||
drmHwcLayer->iByteStride_ = pBufferInfo_->iByteStride_;
|
||
drmHwcLayer->uFourccFormat_ = pBufferInfo_->uFourccFormat_;
|
||
drmHwcLayer->uModifier_ = pBufferInfo_->uModifier_;
|
||
drmHwcLayer->sLayerName_ = pBufferInfo_->sLayerName_;
|
||
drmHwcLayer->uByteStridePlanes_ = pBufferInfo_->uByteStridePlanes_;
|
||
}else{
|
||
drmHwcLayer->iFd_ = -1;
|
||
drmHwcLayer->iWidth_ = -1;
|
||
drmHwcLayer->iHeight_ = -1;
|
||
drmHwcLayer->iStride_ = -1;
|
||
drmHwcLayer->iSize_ = -1;
|
||
drmHwcLayer->iFormat_ = -1;
|
||
drmHwcLayer->iUsage = 0;
|
||
drmHwcLayer->iHeightStride_ = -1;
|
||
drmHwcLayer->uFourccFormat_ = 0x20202020; //0x20 is space
|
||
drmHwcLayer->uModifier_ = 0;
|
||
drmHwcLayer->uGemHandle_ = 0;
|
||
drmHwcLayer->sLayerName_.clear();
|
||
drmHwcLayer->uByteStridePlanes_.clear();
|
||
}
|
||
drmHwcLayer->Init();
|
||
return;
|
||
}
|
||
|
||
void DrmHwcTwo::HwcLayer::PopulateDrmLayer(hwc2_layer_t layer_id, DrmHwcLayer *drmHwcLayer,
|
||
hwc2_drm_display_t* ctx, uint32_t frame_no) {
|
||
drmHwcLayer->uId_ = layer_id;
|
||
drmHwcLayer->iZpos_ = mCurrentState.z_order_;
|
||
drmHwcLayer->uFrameNo_ = frame_no;
|
||
drmHwcLayer->bFbTarget_ = false;
|
||
drmHwcLayer->bSkipLayer_ = false;
|
||
drmHwcLayer->bUse_ = true;
|
||
drmHwcLayer->eDataSpace_ = mCurrentState.dataspace_;
|
||
drmHwcLayer->alpha = static_cast<uint16_t>(255.0f * mCurrentState.alpha_ + 0.5f);
|
||
drmHwcLayer->sf_composition = sf_type();
|
||
drmHwcLayer->iBestPlaneType = 0;
|
||
drmHwcLayer->bSidebandStreamLayer_ = false;
|
||
drmHwcLayer->bMatch_ = false;
|
||
drmHwcLayer->IsMetadataHdr_ = false;
|
||
drmHwcLayer->bSideband2_ = false;
|
||
drmHwcLayer->fRealFps_ = GetRealFps();
|
||
drmHwcLayer->fRealMaxFps_ = GetRealMaxFps();
|
||
|
||
#ifdef RK3528
|
||
// RK3528 仅 VOP支持AFBC格式，如果遇到以下两个问题需要启用解码预缩小功能：
|
||
// 1. AFBC格式无法Overlay，需要启用预缩小关闭AFBC并缩小;
|
||
// 2. 视频缩放倍率超过VOP硬件限制，需要启用预缩小减少后端缩小倍数；
|
||
drmHwcLayer->bNeedPreScale_ = false;
|
||
drmHwcLayer->bIsPreScale_ = false;
|
||
#endif
|
||
|
||
drmHwcLayer->acquire_fence = acquire_fence_;
|
||
|
||
drmHwcLayer->iFbWidth_ = ctx->framebuffer_width;
|
||
drmHwcLayer->iFbHeight_ = ctx->framebuffer_height;
|
||
|
||
drmHwcLayer->uAclk_ = ctx->aclk;
|
||
drmHwcLayer->uDclk_ = ctx->dclk;
|
||
drmHwcLayer->SetBlend(mCurrentState.blending_);
|
||
// SidebandStream layer
|
||
if(sidebandStreamHandle_ != NULL){
|
||
PopulateSidebandLayer(drmHwcLayer, ctx);
|
||
}else{
|
||
PopulateNormalLayer(drmHwcLayer, ctx);
|
||
}
|
||
#ifdef RK3528
|
||
if(gIsRK3528()){
|
||
// 调试命令
|
||
int enable_prescale_video = hwc_get_int_property("debug.hwc.enable_prescale_video", "0");
|
||
if(enable_prescale_video > 0 && drmHwcLayer->bYuv_){
|
||
metadata_for_rkvdec_scaling_t* metadata = NULL;
|
||
drmGralloc_->lock_rkvdec_scaling_metadata(buffer_, &metadata);
|
||
HWC2_ALOGD_IF_INFO("lock_rkvdec_scaling_metadata buffer_=%p metadata=%p", buffer_, metadata);
|
||
if(metadata != NULL){
|
||
metadata->requestMask = enable_prescale_video;
|
||
if(metadata->replyMask > 0){
|
||
memcpy(&(drmHwcLayer->mMetadata_), metadata, sizeof(metadata_for_rkvdec_scaling_t));
|
||
drmHwcLayer->bNeedPreScale_ = true;
|
||
drmHwcLayer->bIsPreScale_ = true;
|
||
|
||
hwc_frect source_crop;
|
||
source_crop.top = metadata->srcTop;
|
||
source_crop.left = metadata->srcLeft;
|
||
source_crop.right = metadata->srcRight;
|
||
source_crop.bottom = metadata->srcBottom;
|
||
drmHwcLayer->SetSourceCrop(source_crop);
|
||
|
||
drmHwcLayer->iWidth_ = metadata->width;
|
||
drmHwcLayer->iHeight_ = metadata->height;
|
||
drmHwcLayer->iStride_ = metadata->pixel_stride;
|
||
drmHwcLayer->iFormat_ = metadata->format;
|
||
drmHwcLayer->iUsage = metadata->usage;
|
||
drmHwcLayer->iByteStride_ = metadata->byteStride[0];
|
||
drmHwcLayer->uModifier_ = metadata->modifier;
|
||
drmHwcLayer->uFourccFormat_ = drmGralloc_->hwc_get_fourcc_from_hal_format(metadata->format);
|
||
drmHwcLayer->Init();
|
||
}
|
||
|
||
// 打印参数
|
||
HWC2_ALOGD_IF_INFO("Name=%s metadata = %p", pBufferInfo_->sLayerName_.c_str(), metadata);
|
||
HWC2_ALOGD_IF_INFO("version=0x%" PRIx64 " requestMask=0x%" PRIx64" "
|
||
"replyMask=0x%" PRIx64 " BufferId=0x%" PRIx64,
|
||
metadata->version,
|
||
metadata->requestMask,
|
||
metadata->replyMask,
|
||
drmHwcLayer->uBufferId_);
|
||
HWC2_ALOGD_IF_INFO("w=%d h=%d s=%d f=%d m=0x%" PRIx64 " usage=0x%x ",
|
||
metadata->width,
|
||
metadata->height,
|
||
metadata->pixel_stride,
|
||
metadata->format,
|
||
metadata->modifier,
|
||
metadata->usage);
|
||
HWC2_ALOGD_IF_INFO("crop=(%d,%d,%d,%d) ", metadata->srcLeft,
|
||
metadata->srcTop,
|
||
metadata->srcRight,
|
||
metadata->srcBottom);
|
||
HWC2_ALOGD_IF_INFO("layer_cnt=%d offset=%d,%d,%d,%d byteStride=%d,%d,%d,%d) ",
|
||
metadata->layer_cnt,
|
||
metadata->offset[0],
|
||
metadata->offset[1],
|
||
metadata->offset[2],
|
||
metadata->offset[3],
|
||
metadata->byteStride[0],
|
||
metadata->byteStride[1],
|
||
metadata->byteStride[2],
|
||
metadata->byteStride[3]);
|
||
|
||
drmGralloc_->unlock_rkvdec_scaling_metadata(buffer_);
|
||
}
|
||
}
|
||
}
|
||
#endif
|
||
return;
|
||
}
|
||
|
||
void DrmHwcTwo::HwcLayer::PopulateFB(hwc2_layer_t layer_id, DrmHwcLayer *drmHwcLayer,
|
||
hwc2_drm_display_t* ctx, uint32_t frame_no, bool validate) {
|
||
drmHwcLayer->uId_ = layer_id;
|
||
drmHwcLayer->uFrameNo_ = frame_no;
|
||
drmHwcLayer->bFbTarget_ = true;
|
||
drmHwcLayer->bUse_ = true;
|
||
drmHwcLayer->bSkipLayer_ = false;
|
||
drmHwcLayer->blending = DrmHwcBlending::kPreMult;
|
||
drmHwcLayer->iZpos_ = mCurrentState.z_order_;
|
||
drmHwcLayer->alpha = static_cast<uint16_t>(255.0f * mCurrentState.alpha_ + 0.5f);
|
||
drmHwcLayer->iBestPlaneType = 0;
|
||
|
||
if(!validate){
|
||
drmHwcLayer->sf_handle = buffer_;
|
||
drmHwcLayer->acquire_fence = acquire_fence_;
|
||
}else{
|
||
// Commit mirror function
|
||
drmHwcLayer->SetDisplayFrameMirror(mCurrentState.display_frame_);
|
||
drmHwcLayer->bMatch_ = false;
|
||
}
|
||
|
||
drmHwcLayer->iFbWidth_ = ctx->framebuffer_width;
|
||
drmHwcLayer->iFbHeight_ = ctx->framebuffer_height;
|
||
|
||
drmHwcLayer->uAclk_ = ctx->aclk;
|
||
drmHwcLayer->uDclk_ = ctx->dclk;
|
||
|
||
drmHwcLayer->SetDisplayFrame(mCurrentState.display_frame_, ctx);
|
||
drmHwcLayer->SetSourceCrop(mCurrentState.source_crop_);
|
||
drmHwcLayer->SetTransform(mCurrentState.transform_);
|
||
|
||
if(buffer_ && !validate){
|
||
drmHwcLayer->iFd_ = pBufferInfo_->iFd_.get();
|
||
drmHwcLayer->iWidth_ = pBufferInfo_->iWidth_;
|
||
drmHwcLayer->iHeight_ = pBufferInfo_->iHeight_;
|
||
drmHwcLayer->iStride_ = pBufferInfo_->iStride_;
|
||
drmHwcLayer->iSize_ = pBufferInfo_->iSize_;
|
||
drmHwcLayer->iFormat_ = pBufferInfo_->iFormat_;
|
||
drmHwcLayer->iUsage = pBufferInfo_->iUsage_;
|
||
drmHwcLayer->iHeightStride_ = pBufferInfo_->iHeightStride_;
|
||
drmHwcLayer->iByteStride_ = pBufferInfo_->iByteStride_;
|
||
drmHwcLayer->uFourccFormat_ = pBufferInfo_->uFourccFormat_;
|
||
drmHwcLayer->uModifier_ = pBufferInfo_->uModifier_;
|
||
drmHwcLayer->sLayerName_ = pBufferInfo_->sLayerName_;
|
||
}else{
|
||
drmHwcLayer->iFd_ = -1;
|
||
drmHwcLayer->iWidth_ = -1;
|
||
drmHwcLayer->iHeight_ = -1;
|
||
drmHwcLayer->iStride_ = -1;
|
||
// 由于 validate 没有实际的handle, 故此处的size通过crop信息预估,格式为 RGBA
|
||
drmHwcLayer->iSize_ = (mCurrentState.source_crop_.right - mCurrentState.source_crop_.left) *
|
||
(mCurrentState.source_crop_.bottom - mCurrentState.source_crop_.top) * 4;
|
||
drmHwcLayer->iFormat_ = -1;
|
||
drmHwcLayer->iUsage = 0;
|
||
drmHwcLayer->iHeightStride_ = -1;
|
||
drmHwcLayer->uFourccFormat_ = DRM_FORMAT_ABGR8888; // fb target default DRM_FORMAT_ABGR8888
|
||
drmHwcLayer->uModifier_ = 0;
|
||
drmHwcLayer->uGemHandle_ = 0;
|
||
drmHwcLayer->sLayerName_ = std::string("FramebufferSurface");
|
||
}
|
||
|
||
drmHwcLayer->Init();
|
||
return;
|
||
}
|
||
|
||
|
||
#ifdef USE_LIBPQ
|
||
int DrmHwcTwo::HwcLayer::DoPq(bool validate, DrmHwcLayer *drmHwcLayer, hwc2_drm_display_t* ctx){
|
||
char value[PROPERTY_VALUE_MAX];
|
||
property_get("persist.vendor.tvinput.rkpq.mode", value, "0");
|
||
bool pq_mode_enable = atoi(value) > 0;
|
||
|
||
if(pq_mode_enable == 1){
|
||
static bool use_pq_fb = false;
|
||
|
||
if(validate){
|
||
if(bufferQueue_ == NULL){
|
||
bufferQueue_ = std::make_shared<DrmBufferQueue>();
|
||
}
|
||
if(pq_ == NULL){
|
||
pq_ = Pq::Get();
|
||
if(pq_ != NULL){
|
||
bPqReady_ = true;
|
||
HWC2_ALOGI("Pq module ready. to enable PqMode.");
|
||
}
|
||
} else {
|
||
bPqReady_ = true;
|
||
HWC2_ALOGI("Pq module ready. to enable PqMode.");
|
||
}
|
||
if(bPqReady_){
|
||
// 1. Init Ctx
|
||
int ret = pq_->InitCtx(pqCtx_);
|
||
if(ret){
|
||
HWC2_ALOGE("Pq ctx init fail");
|
||
return ret;
|
||
}
|
||
// 2. Set buffer Info
|
||
PqImageInfo src;
|
||
src.mBufferInfo_.iFd_ = 1;
|
||
src.mBufferInfo_.iWidth_ = drmHwcLayer->iFbWidth_;
|
||
src.mBufferInfo_.iHeight_ = drmHwcLayer->iFbHeight_;
|
||
src.mBufferInfo_.iFormat_ = HAL_PIXEL_FORMAT_RGBA_8888;
|
||
// src.mBufferInfo_.iSize_ = drmHwcLayer->iFbWidth_ * drmHwcLayer->iFbHeight_ * 4;
|
||
src.mBufferInfo_.iStride_ = drmHwcLayer->iFbWidth_;
|
||
src.mBufferInfo_.uBufferId_ = 0x1;
|
||
|
||
src.mCrop_.iLeft_ = (int)drmHwcLayer->source_crop.left;
|
||
src.mCrop_.iTop_ = (int)drmHwcLayer->source_crop.top;
|
||
src.mCrop_.iRight_ = (int)drmHwcLayer->source_crop.right;
|
||
src.mCrop_.iBottom_= (int)drmHwcLayer->source_crop.bottom;
|
||
|
||
ret = pq_->SetSrcImage(pqCtx_, src);
|
||
if(ret){
|
||
printf("pq SetSrcImage fail\n");
|
||
return ret;
|
||
}
|
||
use_pq_fb = true;
|
||
}
|
||
}else if(use_pq_fb){
|
||
use_pq_fb = false;
|
||
if(bufferQueue_ == NULL){
|
||
bufferQueue_ = std::make_shared<DrmBufferQueue>();
|
||
}
|
||
if(pq_ == NULL){
|
||
pq_ = Pq::Get();
|
||
if(pq_ != NULL){
|
||
bPqReady_ = true;
|
||
HWC2_ALOGI("pq module ready. to enable pqMode.");
|
||
}
|
||
}
|
||
if(bPqReady_){
|
||
// 1. Init Ctx
|
||
int ret = pq_->InitCtx(pqCtx_);
|
||
if(ret){
|
||
HWC2_ALOGE("Pq ctx init fail");
|
||
return ret;
|
||
}
|
||
// 2. Set buffer Info
|
||
PqImageInfo src;
|
||
src.mBufferInfo_.iFd_ = drmHwcLayer->iFd_;
|
||
src.mBufferInfo_.iWidth_ = drmHwcLayer->iWidth_;
|
||
src.mBufferInfo_.iHeight_ = drmHwcLayer->iHeight_;
|
||
src.mBufferInfo_.iFormat_ = drmHwcLayer->iFormat_;
|
||
src.mBufferInfo_.iStride_ = drmHwcLayer->iStride_;
|
||
// src.mBufferInfo_.iSize_ = drmHwcLayer->iSize_;
|
||
src.mBufferInfo_.uBufferId_ = drmHwcLayer->uBufferId_;
|
||
src.mBufferInfo_.uDataSpace_ = (uint64_t)drmHwcLayer->eDataSpace_;
|
||
|
||
src.mCrop_.iLeft_ = (int)drmHwcLayer->source_crop.left;
|
||
src.mCrop_.iTop_ = (int)drmHwcLayer->source_crop.top;
|
||
src.mCrop_.iRight_ = (int)drmHwcLayer->source_crop.right;
|
||
src.mCrop_.iBottom_= (int)drmHwcLayer->source_crop.bottom;
|
||
|
||
ret = pq_->SetSrcImage(pqCtx_, src);
|
||
if(ret){
|
||
printf("Pq SetSrcImage fail\n");
|
||
return ret;
|
||
}
|
||
|
||
// 4. Alloc Dst buffer
|
||
std::shared_ptr<DrmBuffer> dst_buffer;
|
||
dst_buffer = bufferQueue_->DequeueDrmBuffer(ctx->framebuffer_width,
|
||
ctx->framebuffer_height,
|
||
HAL_PIXEL_FORMAT_YCBCR_444_888,
|
||
// PQ 算法要求 256 对齐，Gralloc可用的只有256奇数倍对齐
|
||
// 暂时按照 256 奇数倍对齐，后续查看情况
|
||
// TODO: 最终PQ库内部修改为64对齐即可
|
||
RK_GRALLOC_USAGE_STRIDE_ALIGN_64 |
|
||
MALI_GRALLOC_USAGE_NO_AFBC,
|
||
"PQ-FB-target");
|
||
|
||
if(dst_buffer == NULL){
|
||
HWC2_ALOGD_IF_DEBUG("DequeueDrmBuffer fail!, skip this policy.");
|
||
return -1;
|
||
}
|
||
|
||
// 5. Set buffer Info
|
||
PqImageInfo dst;
|
||
dst.mBufferInfo_.iFd_ = dst_buffer->GetFd();
|
||
dst.mBufferInfo_.iWidth_ = dst_buffer->GetWidth();
|
||
dst.mBufferInfo_.iHeight_ = dst_buffer->GetHeight();
|
||
dst.mBufferInfo_.iFormat_ = dst_buffer->GetFormat();
|
||
dst.mBufferInfo_.iStride_ = dst_buffer->GetStride();
|
||
dst.mBufferInfo_.uBufferId_ = dst_buffer->GetBufferId();
|
||
|
||
dst.mCrop_.iLeft_ = (int)drmHwcLayer->source_crop.left;
|
||
dst.mCrop_.iTop_ = (int)drmHwcLayer->source_crop.top;
|
||
dst.mCrop_.iRight_ = (int)drmHwcLayer->source_crop.right;
|
||
dst.mCrop_.iBottom_= (int)drmHwcLayer->source_crop.bottom;
|
||
|
||
dst.mCrop_.iLeft_ = 0;
|
||
dst.mCrop_.iTop_ = 0;
|
||
dst.mCrop_.iRight_ = ctx->framebuffer_width;
|
||
dst.mCrop_.iBottom_= ctx->framebuffer_height;
|
||
|
||
ret = pq_->SetDstImage(pqCtx_, dst);
|
||
if(ret){
|
||
printf("Pq SetSrcImage fail\n");
|
||
bufferQueue_->QueueBuffer(dst_buffer);
|
||
return ret;
|
||
}
|
||
|
||
hwc_frect_t source_crop;
|
||
source_crop.left = 0;
|
||
source_crop.top = 0;
|
||
source_crop.right = ctx->framebuffer_width;
|
||
source_crop.bottom = ctx->framebuffer_height;
|
||
drmHwcLayer->UpdateAndStoreInfoFromDrmBuffer(dst_buffer->GetHandle(),
|
||
dst_buffer->GetFd(),
|
||
dst_buffer->GetFormat(),
|
||
dst_buffer->GetWidth(),
|
||
dst_buffer->GetHeight(),
|
||
dst_buffer->GetStride(),
|
||
dst_buffer->GetHeightStride(),
|
||
dst_buffer->GetByteStride(),
|
||
dst_buffer->GetSize(),
|
||
dst_buffer->GetUsage(),
|
||
dst_buffer->GetFourccFormat(),
|
||
dst_buffer->GetModifier(),
|
||
dst_buffer->GetByteStridePlanes(),
|
||
dst_buffer->GetName(),
|
||
source_crop,
|
||
dst_buffer->GetBufferId(),
|
||
dst_buffer->GetGemHandle(),
|
||
drmHwcLayer->transform);
|
||
if(drmHwcLayer->acquire_fence->isValid()){
|
||
ret = drmHwcLayer->acquire_fence->wait(1500);
|
||
if(ret){
|
||
HWC2_ALOGE("wait Fb-Target 1500ms timeout, ret=%d",ret);
|
||
drmHwcLayer->bUsePq_ = false;
|
||
bufferQueue_->QueueBuffer(dst_buffer);
|
||
return ret;
|
||
}
|
||
}
|
||
int output_fence = 0;
|
||
ret = pq_->RunAsync(pqCtx_, &output_fence);
|
||
if(ret){
|
||
HWC2_ALOGD_IF_DEBUG("RunAsync fail!");
|
||
drmHwcLayer->bUsePq_ = false;
|
||
bufferQueue_->QueueBuffer(dst_buffer);
|
||
return ret;
|
||
}
|
||
dst_buffer->SetFinishFence(dup(output_fence));
|
||
drmHwcLayer->acquire_fence = sp<AcquireFence>(new AcquireFence(output_fence));
|
||
|
||
property_get("vendor.dump", value, "false");
|
||
if(!strcmp(value, "true")){
|
||
drmHwcLayer->acquire_fence->wait();
|
||
dst_buffer->DumpData();
|
||
}
|
||
bufferQueue_->QueueBuffer(dst_buffer);
|
||
}
|
||
}
|
||
drmHwcLayer->uFourccFormat_ = DRM_FORMAT_NV24;
|
||
} else {
|
||
if(bPqReady_) {
|
||
pq_->DeInit();
|
||
bPqReady_ = false;
|
||
}
|
||
}
|
||
drmHwcLayer->Init();
|
||
if(gIsDrmVerison6_1()){
|
||
drmHwcLayer->uColorSpace.colorspace_kernel_6_1_.color_encoding_ = DRM_COLOR_YCBCR_BT601;
|
||
drmHwcLayer->uColorSpace.colorspace_kernel_6_1_.color_range_ = DRM_COLOR_YCBCR_FULL_RANGE;
|
||
}else{
|
||
drmHwcLayer->uColorSpace.colorspace_kernel_510_ = V4L2_COLORSPACE_JPEG;
|
||
}
|
||
return 0;
|
||
}
|
||
#endif
|
||
void DrmHwcTwo::HwcLayer::DumpLayerInfo(String8 &output) {
|
||
|
||
output.appendFormat( " %04" PRIu32 " | %03" PRIu32 " | %9s | %9s | %-18.18" PRIxPTR " |"
|
||
" %-11.11s | %-10.10s |%7.1f,%7.1f,%7.1f,%7.1f |%5d,%5d,%5d,%5d |"
|
||
" %10x | %5.1f | %s | 0x%" PRIx64 "\n",
|
||
id_,
|
||
mCurrentState.z_order_,
|
||
to_string(mCurrentState.sf_type_).c_str(),
|
||
to_string(mCurrentState.validated_type_).c_str(),
|
||
intptr_t(buffer_),
|
||
to_string(mCurrentState.transform_).c_str(),
|
||
to_string(mCurrentState.blending_).c_str(),
|
||
mCurrentState.source_crop_.left,
|
||
mCurrentState.source_crop_.top,
|
||
mCurrentState.source_crop_.right,
|
||
mCurrentState.source_crop_.bottom,
|
||
mCurrentState.display_frame_.left,
|
||
mCurrentState.display_frame_.top,
|
||
mCurrentState.display_frame_.right,
|
||
mCurrentState.display_frame_.bottom,
|
||
mCurrentState.dataspace_,
|
||
GetFps(),
|
||
layer_name_.c_str(),
|
||
pBufferInfo_ != NULL ? pBufferInfo_->uBufferId_ : -1);
|
||
return;
|
||
}
|
||
int DrmHwcTwo::HwcLayer::DumpData() {
|
||
if(!buffer_)
|
||
ALOGI_IF(LogLevel(DBG_INFO),"%s,line=%d LayerId=%u Buffer is null.",__FUNCTION__,__LINE__,id_);
|
||
|
||
void* cpu_addr = NULL;
|
||
static int frame_cnt =0;
|
||
int width, height, stride, byte_stride, size;
|
||
int ret = 0;
|
||
width = drmGralloc_->hwc_get_handle_attibute(buffer_,ATT_WIDTH);
|
||
height = drmGralloc_->hwc_get_handle_attibute(buffer_,ATT_HEIGHT);
|
||
stride = drmGralloc_->hwc_get_handle_attibute(buffer_,ATT_STRIDE);
|
||
size = drmGralloc_->hwc_get_handle_attibute(buffer_,ATT_SIZE);
|
||
byte_stride = drmGralloc_->hwc_get_handle_attibute(buffer_,ATT_BYTE_STRIDE);
|
||
|
||
cpu_addr = drmGralloc_->hwc_get_handle_lock(buffer_,width,height);
|
||
if(cpu_addr == NULL) {
|
||
ALOGE("%s, line = %d, LayerId = %u, lock fail", __FUNCTION__, __LINE__, id_);
|
||
return -1;
|
||
}
|
||
|
||
FILE * pfile = NULL;
|
||
char data_name[100] ;
|
||
system("mkdir /data/dump/ && chmod /data/dump/ 777 ");
|
||
sprintf(data_name,"/data/dump/%d_%5.5s_id-%d_%dx%d_z-%d.bin",
|
||
frame_cnt++,layer_name_.size() < 5 ? "unset" : layer_name_.c_str(),
|
||
id_,stride,height,mCurrentState.z_order_);
|
||
|
||
pfile = fopen(data_name,"wb");
|
||
if(pfile)
|
||
{
|
||
fwrite((const void *)cpu_addr,(size_t)(size),1,pfile);
|
||
fflush(pfile);
|
||
fclose(pfile);
|
||
ALOGD(" dump surface layer_id=%d ,data_name %s,w:%d,h:%d,stride :%d,size=%d,cpu_addr=%p",
|
||
id_,data_name,width,height,byte_stride,size,cpu_addr);
|
||
}
|
||
else
|
||
{
|
||
ALOGE("Open %s fail", data_name);
|
||
ALOGD(" dump surface layer_id=%d ,data_name %s,w:%d,h:%d,stride :%d,size=%d,cpu_addr=%p",
|
||
id_,data_name,width,height,byte_stride,size,cpu_addr);
|
||
}
|
||
|
||
ret = drmGralloc_->hwc_get_handle_unlock(buffer_);
|
||
if(ret){
|
||
ALOGE("%s,line=%d, LayerId=%u, unlock fail ret = %d ",__FUNCTION__,__LINE__,id_,ret);
|
||
return ret;
|
||
}
|
||
|
||
return ret;
|
||
|
||
}
|
||
|
||
bool DrmHwcTwo::IsHasRegisterDisplayId(hwc2_display_t displayid){
|
||
return mHasRegisterDisplay_.count(displayid) > 0;
|
||
}
|
||
|
||
void DrmHwcTwo::HandleDisplayHotplug(hwc2_display_t displayid, int state) {
|
||
auto cb = callbacks_.find(HWC2::Callback::Hotplug);
|
||
if (cb == callbacks_.end())
|
||
return;
|
||
|
||
if(isRK3566(resource_manager_->getSocId())){
|
||
if(displayid != HWC_DISPLAY_PRIMARY){
|
||
auto &drmDevices = resource_manager_->GetDrmDevices();
|
||
for (auto &device : drmDevices) {
|
||
if(state==DRM_MODE_CONNECTED)
|
||
device->SetCommitMirrorDisplayId(displayid);
|
||
else
|
||
device->SetCommitMirrorDisplayId(-1);
|
||
}
|
||
ALOGD_IF(LogLevel(DBG_DEBUG),"HandleDisplayHotplug skip display-id=%" PRIu64 " state=%d",displayid,state);
|
||
return;
|
||
}
|
||
}
|
||
|
||
if(displayid == HWC_DISPLAY_PRIMARY && state == HWC2_CONNECTION_DISCONNECTED)
|
||
return;
|
||
|
||
auto hotplug = reinterpret_cast<HWC2_PFN_HOTPLUG>(cb->second.func);
|
||
hotplug(cb->second.data, displayid,
|
||
(state == DRM_MODE_CONNECTED ? HWC2_CONNECTION_CONNECTED
|
||
: HWC2_CONNECTION_DISCONNECTED));
|
||
// 通过 mHasRegisterDisplay_ 记录已经向 SurfaceFlinger 注册的 display-id
|
||
if(state == DRM_MODE_CONNECTED)
|
||
mHasRegisterDisplay_.insert(displayid);
|
||
else{
|
||
mHasRegisterDisplay_.erase(displayid);
|
||
}
|
||
}
|
||
|
||
void DrmHwcTwo::HandleInitialHotplugState(DrmDevice *drmDevice) {
|
||
// RK3528 HDMI/TV互斥模式要求，若HDMI已连接，则 TV不注册
|
||
if(gIsRK3528()){
|
||
drmDevice->FlipHotplugEventForInit();
|
||
return;
|
||
}
|
||
|
||
for (auto &conn : drmDevice->connectors()) {
|
||
if (conn->state() != DRM_MODE_CONNECTED)
|
||
continue;
|
||
for (auto &crtc : drmDevice->crtc()) {
|
||
if(conn->display() != crtc->display())
|
||
continue;
|
||
// HWC_DISPLAY_PRIMARY display have been hotplug
|
||
if(conn->display() == HWC_DISPLAY_PRIMARY){
|
||
// SpiltDisplay Hotplug
|
||
if(conn->isHorizontalSpilt()){
|
||
HandleDisplayHotplug((conn->GetSpiltModeId()), conn->state());
|
||
ALOGI("HWC2 Init: SF register connector %u type=%s, type_id=%d SpiltDisplay=%d\n",
|
||
conn->id(),drmDevice->connector_type_str(conn->type()),conn->type_id(),conn->GetSpiltModeId());
|
||
}
|
||
continue;
|
||
}
|
||
// SpiltDisplay Hotplug
|
||
if(conn->isCropSpilt()){
|
||
if(conn->IsSpiltPrimary()){
|
||
HandleDisplayHotplug(conn->display(), conn->state());
|
||
ALOGI("HWC2 Init: SF register connector %u type=%s, type_id=%d display-id=%d\n",
|
||
conn->id(),drmDevice->connector_type_str(conn->type()),conn->type_id(),conn->display());
|
||
continue;
|
||
}else{
|
||
// CropSpilt
|
||
HWC2_ALOGI("HWC2 Init: not to register connector %u type=%s, type_id=%d isCropSpilt=%d\n",
|
||
conn->id(),drmDevice->connector_type_str(conn->type()),
|
||
conn->type_id(),
|
||
conn->isCropSpilt());
|
||
continue;
|
||
}
|
||
}
|
||
|
||
ALOGI("HWC2 Init: SF register connector %u type=%s, type_id=%d \n",
|
||
conn->id(),drmDevice->connector_type_str(conn->type()),conn->type_id());
|
||
HandleDisplayHotplug(conn->display(), conn->state());
|
||
// SpiltDisplay Hotplug
|
||
if(conn->isHorizontalSpilt()){
|
||
HandleDisplayHotplug((conn->GetSpiltModeId()), conn->state());
|
||
ALOGI("HWC2 Init: SF register connector %u type=%s, type_id=%d SpiltDisplay=%d\n",
|
||
conn->id(),drmDevice->connector_type_str(conn->type()),conn->type_id(),conn->GetSpiltModeId());
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void DrmHwcTwo::DrmHotplugHandler::HdmiTvOnlyOne(PLUG_EVENT_TYPE hdmi_hotplug_state){
|
||
if(!gIsRK3528())
|
||
return;
|
||
|
||
// RK3528 HDMI拔出，则需要注册 TV 到 SurfaceFlinger
|
||
if(hdmi_hotplug_state == DRM_HOTPLUG_UNPLUG_EVENT){
|
||
for (auto &conn : drm_->connectors()) {
|
||
if(conn->type() == DRM_MODE_CONNECTOR_TV){
|
||
drmModeConnection cur_state = conn->state();
|
||
if(cur_state == DRM_MODE_CONNECTED){
|
||
int display_id = conn->display();
|
||
auto &display = hwc2_->displays_.at(display_id);
|
||
int ret = (int32_t)display.HoplugEventTmeline();
|
||
ret |= (int32_t)display.UpdateDisplayMode();
|
||
ret |= (int32_t)display.CheckStateAndReinit(!hwc2_->IsHasRegisterDisplayId(display_id));
|
||
ret |= (int32_t)display.ChosePreferredConfig();
|
||
if(ret != 0){
|
||
HWC2_ALOGE("hwc_hotplug: %s connector %u type=%s type_id=%d state is error, skip hotplug.",
|
||
cur_state == DRM_MODE_CONNECTED ? "Plug" : "Unplug",
|
||
conn->id(),drm_->connector_type_str(conn->type()), conn->type_id());
|
||
}else{
|
||
HWC2_ALOGI("hwc_hotplug: %s connector %u type=%s type_id=%d send hotplug event to SF.",
|
||
cur_state == DRM_MODE_CONNECTED ? "Plug" : "Unplug",
|
||
conn->id(),drm_->connector_type_str(conn->type()),conn->type_id());
|
||
hwc2_->HandleDisplayHotplug(display_id, cur_state);
|
||
display.SyncPowerMode();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
// RK3528 HDMI接入，则需要销毁 TV 到 SurfaceFlinger
|
||
}else{
|
||
// 检查HDMI连接状态
|
||
bool hdmi_conneted = false;
|
||
for (auto &conn : drm_->connectors()) {
|
||
if(conn->type() == DRM_MODE_CONNECTOR_HDMIA){
|
||
hdmi_conneted = (conn->state() == DRM_MODE_CONNECTED);
|
||
}
|
||
}
|
||
// 若HDMI已连接，则需要销毁 TV display
|
||
if(hdmi_conneted){
|
||
for (auto &conn : drm_->connectors()) {
|
||
if(conn->type() == DRM_MODE_CONNECTOR_TV){
|
||
int display_id = conn->display();
|
||
auto &display = hwc2_->displays_.at(display_id);
|
||
display.SetPowerMode(HWC2_POWER_MODE_OFF);
|
||
HWC2_ALOGI("hwc_hotplug: Unplug connector %u type=%s type_id=%d send unhotplug event to SF.",
|
||
conn->id(),drm_->connector_type_str(conn->type()),conn->type_id());
|
||
hwc2_->HandleDisplayHotplug(display_id, DRM_MODE_DISCONNECTED);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return ;
|
||
}
|
||
|
||
|
||
void DrmHwcTwo::DrmHotplugHandler::HandleEvent(uint64_t timestamp_us) {
|
||
int32_t ret = 0;
|
||
bool primary_change = true;
|
||
PLUG_EVENT_TYPE event_type = DRM_HOTPLUG_NONE;
|
||
for (auto &conn : drm_->connectors()) {
|
||
ret = 0;
|
||
// RK3528 TV 不需要处理TV的热插拔事件
|
||
if(gIsRK3528() && conn->type() == DRM_MODE_CONNECTOR_TV){
|
||
ALOGI("hwc_hotplug: RK3528 not handle type=%s-%d hotplug event.\n",
|
||
drm_->connector_type_str(conn->type()), conn->type_id());
|
||
continue;
|
||
}
|
||
|
||
drmModeConnection old_state = conn->hotplug_state();
|
||
conn->ResetModesReady();
|
||
conn->UpdateModes();
|
||
conn->update_hotplug_state();
|
||
drmModeConnection cur_state = conn->hotplug_state();
|
||
if(!conn->ModesReady())
|
||
continue;
|
||
if (cur_state == old_state)
|
||
continue;
|
||
|
||
// 当前状态为未连接，则为拔出事件
|
||
if(cur_state == DRM_MODE_DISCONNECTED){
|
||
event_type = DRM_HOTPLUG_UNPLUG_EVENT;
|
||
}else{
|
||
event_type = DRM_HOTPLUG_PLUG_EVENT;
|
||
}
|
||
|
||
ALOGI("hwc_hotplug: %s event @%" PRIu64 " for connector %u type=%s, type_id=%d\n",
|
||
cur_state == DRM_MODE_CONNECTED ? "Plug" : "Unplug", timestamp_us, conn->id(),
|
||
drm_->connector_type_str(conn->type()),conn->type_id());
|
||
|
||
// RK3528 HDMI/TV 互斥功能需要提前处理 TV display
|
||
if(gIsRK3528() && conn->type() == DRM_MODE_CONNECTOR_HDMIA)
|
||
HdmiTvOnlyOne(event_type);
|
||
|
||
int display_id = conn->display();
|
||
primary_change = (display_id == 0);
|
||
auto &display = hwc2_->displays_.at(display_id);
|
||
if (cur_state == DRM_MODE_CONNECTED) {
|
||
ret |= (int32_t)display.HoplugEventTmeline();
|
||
ret |= (int32_t)display.UpdateDisplayMode();
|
||
ret |= (int32_t)display.CheckStateAndReinit(!hwc2_->IsHasRegisterDisplayId(display_id));
|
||
ret |= (int32_t)display.ChosePreferredConfig();
|
||
if(ret != 0){
|
||
HWC2_ALOGE("hwc_hotplug: %s connector %u type=%s type_id=%d state is error, skip hotplug.",
|
||
cur_state == DRM_MODE_CONNECTED ? "Plug" : "Unplug",
|
||
conn->id(),drm_->connector_type_str(conn->type()),conn->type_id());
|
||
}else if(conn->isCropSpilt()){
|
||
HWC2_ALOGI("hwc_hotplug: %s connector %u type=%s type_id=%d isCropSpilt skip hotplug.",
|
||
cur_state == DRM_MODE_CONNECTED ? "Plug" : "Unplug",
|
||
conn->id(),drm_->connector_type_str(conn->type()),conn->type_id());
|
||
display.SetPowerMode(HWC2_POWER_MODE_ON);
|
||
}else{
|
||
HWC2_ALOGI("hwc_hotplug: %s connector %u type=%s type_id=%d send hotplug event to SF.",
|
||
cur_state == DRM_MODE_CONNECTED ? "Plug" : "Unplug",
|
||
conn->id(),drm_->connector_type_str(conn->type()),conn->type_id());
|
||
hwc2_->HandleDisplayHotplug(display_id, cur_state);
|
||
display.SyncPowerMode();
|
||
}
|
||
}else{
|
||
ret |= (int32_t)display.ClearDisplay();
|
||
ret |= (int32_t)drm_->ReleaseDpyRes(display_id);
|
||
if(ret != 0){
|
||
HWC2_ALOGE("hwc_hotplug: %s connector %u type=%s type_id=%d state is error, skip hotplug.",
|
||
cur_state == DRM_MODE_CONNECTED ? "Plug" : "Unplug",
|
||
conn->id(),drm_->connector_type_str(conn->type()),conn->type_id());
|
||
}else if(conn->isCropSpilt()){
|
||
HWC2_ALOGI("hwc_hotplug: %s connector %u type=%s type_id=%d isCropSpilt skip hotplug.",
|
||
cur_state == DRM_MODE_CONNECTED ? "Plug" : "Unplug",
|
||
conn->id(),drm_->connector_type_str(conn->type()),conn->type_id());
|
||
// display.SetPowerMode(HWC2_POWER_MODE_OFF);
|
||
}else{
|
||
HWC2_ALOGI("hwc_hotplug: %s connector %u type=%s type_id=%d send hotplug event to SF.",
|
||
cur_state == DRM_MODE_CONNECTED ? "Plug" : "Unplug",
|
||
conn->id(),drm_->connector_type_str(conn->type()),conn->type_id());
|
||
hwc2_->HandleDisplayHotplug(display_id, cur_state);
|
||
}
|
||
}
|
||
|
||
// SpiltDisplay Hoplug.
|
||
ret = 0;
|
||
if(conn->isHorizontalSpilt()){
|
||
display_id = conn->GetSpiltModeId();
|
||
auto &spilt_display = hwc2_->displays_.at(display_id);
|
||
if (cur_state == DRM_MODE_CONNECTED) {
|
||
ret |= (int32_t)spilt_display.HoplugEventTmeline();
|
||
ret |= (int32_t)spilt_display.UpdateDisplayMode();
|
||
ret |= (int32_t)spilt_display.CheckStateAndReinit(!hwc2_->IsHasRegisterDisplayId(display_id));
|
||
ret |= (int32_t)spilt_display.ChosePreferredConfig();
|
||
if(ret != 0){
|
||
HWC2_ALOGE("hwc_hotplug: %s connector %u type=%s type_id=%d state is error, skip hotplug.",
|
||
cur_state == DRM_MODE_CONNECTED ? "Plug" : "Unplug",
|
||
conn->id(),drm_->connector_type_str(conn->type()),conn->type_id());
|
||
}else{
|
||
HWC2_ALOGI("hwc_hotplug: %s connector %u type=%s type_id=%d send hotplug event to SF.",
|
||
cur_state == DRM_MODE_CONNECTED ? "Plug" : "Unplug",
|
||
conn->id(),drm_->connector_type_str(conn->type()),conn->type_id());
|
||
hwc2_->HandleDisplayHotplug(display_id, cur_state);
|
||
spilt_display.SyncPowerMode();
|
||
}
|
||
}else{
|
||
ret |= (int32_t)spilt_display.ClearDisplay();
|
||
ret |= (int32_t)drm_->ReleaseDpyRes(display_id);
|
||
if(ret != 0){
|
||
HWC2_ALOGE("hwc_hotplug: %s connector %u type=%s type_id=%d state is error, skip hotplug.",
|
||
cur_state == DRM_MODE_CONNECTED ? "Plug" : "Unplug",
|
||
conn->id(),drm_->connector_type_str(conn->type()),conn->type_id());
|
||
}else{
|
||
HWC2_ALOGI("hwc_hotplug: %s connector %u type=%s type_id=%d send hotplug event to SF.",
|
||
cur_state == DRM_MODE_CONNECTED ? "Plug" : "Unplug",
|
||
conn->id(),drm_->connector_type_str(conn->type()),conn->type_id());
|
||
hwc2_->HandleDisplayHotplug(display_id, cur_state);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
if(primary_change){
|
||
for (auto &conn : drm_->connectors()) {
|
||
// RK3528 不需要此功能
|
||
if(gIsRK3528()){
|
||
continue;
|
||
}
|
||
// 多屏拼接不需要重新注册屏幕
|
||
if(conn->isCropSpilt()){
|
||
continue;
|
||
}
|
||
int display_id = conn->display();
|
||
drmModeConnection state = conn->state();
|
||
if (display_id != 0 && state == DRM_MODE_CONNECTED) {
|
||
HWC2_ALOGI("hwc_hotplug: primary_change Plug connector %u type=%s type_id=%d send hotplug event to SF.",
|
||
conn->id(),drm_->connector_type_str(conn->type()),conn->type_id());
|
||
hwc2_->HandleDisplayHotplug(display_id, state);
|
||
}
|
||
}
|
||
}
|
||
|
||
// 拔出事件，说明存在crtc资源释放
|
||
if(event_type == DRM_HOTPLUG_UNPLUG_EVENT){
|
||
for (auto &conn : drm_->connectors()) {
|
||
// 多屏拼接不需要重新注册屏幕
|
||
if(conn->isCropSpilt()){
|
||
continue;
|
||
}
|
||
ret = 0;
|
||
drmModeConnection cur_state = conn->state();
|
||
HwcConnnectorStete cur_hwc_state = conn->hwc_state();
|
||
if(cur_state == DRM_MODE_CONNECTED){
|
||
if(conn->hwc_state_change_and_plug()){
|
||
int display_id = conn->display();
|
||
auto &display = hwc2_->displays_.at(display_id);
|
||
ret |= (int32_t)display.HoplugEventTmeline();
|
||
ret |= (int32_t)display.UpdateDisplayMode();
|
||
ret |= (int32_t)display.CheckStateAndReinit(!hwc2_->IsHasRegisterDisplayId(display_id));
|
||
ret |= (int32_t)display.ChosePreferredConfig();
|
||
if(ret != 0){
|
||
HWC2_ALOGE("hwc_hotplug: %s connector %u type=%s type_id=%d state is error, skip hotplug.",
|
||
cur_state == DRM_MODE_CONNECTED ? "Plug" : "Unplug",
|
||
conn->id(),drm_->connector_type_str(conn->type()), conn->type_id());
|
||
}else{
|
||
HWC2_ALOGI("hwc_hotplug: %s connector %u type=%s type_id=%d send hotplug event to SF.",
|
||
cur_state == DRM_MODE_CONNECTED ? "Plug" : "Unplug",
|
||
conn->id(),drm_->connector_type_str(conn->type()),conn->type_id());
|
||
hwc2_->HandleDisplayHotplug(display_id, cur_state);
|
||
display.SyncPowerMode();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
auto &display = hwc2_->displays_.at(0);
|
||
display.InvalidateControl(5,20);
|
||
|
||
return;
|
||
}
|
||
|
||
void DrmHwcTwo::DrmHotplugHandler::HandleResolutionSwitchEvent(int display_id) {
|
||
// 若系统没有设置为动态更新模式的话，则不进行分辨率更新
|
||
ResourceManager* rm = ResourceManager::getInstance();
|
||
if(!rm->IsDynamicDisplayMode()){
|
||
return;
|
||
}
|
||
|
||
DrmConnector *connector = drm_->GetConnectorForDisplay(display_id);
|
||
if (!connector) {
|
||
ALOGE("Failed to get connector for display %d", display_id);
|
||
return;
|
||
}
|
||
|
||
auto &display = hwc2_->displays_.at(display_id);
|
||
HWC2::Error error = display.ChosePreferredConfig();
|
||
if(error != HWC2::Error::None){
|
||
HWC2_ALOGE("hwc_resolution_switch: connector %u type=%s, type_id=%d ChosePreferredConfig fail.\n",
|
||
connector->id(),
|
||
drm_->connector_type_str(connector->type()),
|
||
connector->type_id());
|
||
return;
|
||
}
|
||
|
||
if(display.IsActiveModeChange()){
|
||
HWC2_ALOGI("hwc_resolution_switch: connector %u type=%s, type_id=%d\n",
|
||
connector->id(),
|
||
drm_->connector_type_str(connector->type()),
|
||
connector->type_id());
|
||
hwc2_->HandleDisplayHotplug(display_id, DRM_MODE_CONNECTED);
|
||
auto &primary = hwc2_->displays_.at(0);
|
||
primary.InvalidateControl(5,20);
|
||
display.ActiveModeChange(false);
|
||
}
|
||
|
||
return;
|
||
}
|
||
|
||
|
||
// static
|
||
int DrmHwcTwo::HookDevClose(hw_device_t * /*dev*/) {
|
||
unsupported(__func__);
|
||
return 0;
|
||
}
|
||
|
||
// static
|
||
void DrmHwcTwo::HookDevGetCapabilities(hwc2_device_t * /*dev*/,
|
||
uint32_t *out_count,
|
||
int32_t * out_capabilities) {
|
||
|
||
if(out_capabilities == NULL){
|
||
*out_count = 1;
|
||
return;
|
||
}
|
||
|
||
out_capabilities[0] = static_cast<int32_t>(HWC2::Capability::SidebandStream);
|
||
}
|
||
|
||
// 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
|
||
case HWC2::FunctionDescriptor::CreateVirtualDisplay:
|
||
return ToHook<HWC2_PFN_CREATE_VIRTUAL_DISPLAY>(
|
||
DeviceHook<int32_t, decltype(&DrmHwcTwo::CreateVirtualDisplay),
|
||
&DrmHwcTwo::CreateVirtualDisplay, uint32_t, uint32_t,
|
||
int32_t *, hwc2_display_t *>);
|
||
case HWC2::FunctionDescriptor::DestroyVirtualDisplay:
|
||
return ToHook<HWC2_PFN_DESTROY_VIRTUAL_DISPLAY>(
|
||
DeviceHook<int32_t, decltype(&DrmHwcTwo::DestroyVirtualDisplay),
|
||
&DrmHwcTwo::DestroyVirtualDisplay, hwc2_display_t>);
|
||
case HWC2::FunctionDescriptor::Dump:
|
||
return ToHook<HWC2_PFN_DUMP>(
|
||
DeviceHook<void, decltype(&DrmHwcTwo::Dump), &DrmHwcTwo::Dump,
|
||
uint32_t *, char *>);
|
||
case HWC2::FunctionDescriptor::GetMaxVirtualDisplayCount:
|
||
return ToHook<HWC2_PFN_GET_MAX_VIRTUAL_DISPLAY_COUNT>(
|
||
DeviceHook<uint32_t, decltype(&DrmHwcTwo::GetMaxVirtualDisplayCount),
|
||
&DrmHwcTwo::GetMaxVirtualDisplayCount>);
|
||
case HWC2::FunctionDescriptor::RegisterCallback:
|
||
return ToHook<HWC2_PFN_REGISTER_CALLBACK>(
|
||
DeviceHook<int32_t, decltype(&DrmHwcTwo::RegisterCallback),
|
||
&DrmHwcTwo::RegisterCallback, int32_t,
|
||
hwc2_callback_data_t, hwc2_function_pointer_t>);
|
||
|
||
// Display functions
|
||
case HWC2::FunctionDescriptor::AcceptDisplayChanges:
|
||
return ToHook<HWC2_PFN_ACCEPT_DISPLAY_CHANGES>(
|
||
DisplayHook<decltype(&HwcDisplay::AcceptDisplayChanges),
|
||
&HwcDisplay::AcceptDisplayChanges>);
|
||
case HWC2::FunctionDescriptor::CreateLayer:
|
||
return ToHook<HWC2_PFN_CREATE_LAYER>(
|
||
DisplayHook<decltype(&HwcDisplay::CreateLayer),
|
||
&HwcDisplay::CreateLayer, hwc2_layer_t *>);
|
||
case HWC2::FunctionDescriptor::DestroyLayer:
|
||
return ToHook<HWC2_PFN_DESTROY_LAYER>(
|
||
DisplayHook<decltype(&HwcDisplay::DestroyLayer),
|
||
&HwcDisplay::DestroyLayer, hwc2_layer_t>);
|
||
case HWC2::FunctionDescriptor::GetActiveConfig:
|
||
return ToHook<HWC2_PFN_GET_ACTIVE_CONFIG>(
|
||
DisplayHook<decltype(&HwcDisplay::GetActiveConfig),
|
||
&HwcDisplay::GetActiveConfig, hwc2_config_t *>);
|
||
case HWC2::FunctionDescriptor::GetChangedCompositionTypes:
|
||
return ToHook<HWC2_PFN_GET_CHANGED_COMPOSITION_TYPES>(
|
||
DisplayHook<decltype(&HwcDisplay::GetChangedCompositionTypes),
|
||
&HwcDisplay::GetChangedCompositionTypes, uint32_t *,
|
||
hwc2_layer_t *, int32_t *>);
|
||
case HWC2::FunctionDescriptor::GetClientTargetSupport:
|
||
return ToHook<HWC2_PFN_GET_CLIENT_TARGET_SUPPORT>(
|
||
DisplayHook<decltype(&HwcDisplay::GetClientTargetSupport),
|
||
&HwcDisplay::GetClientTargetSupport, uint32_t, uint32_t,
|
||
int32_t, int32_t>);
|
||
case HWC2::FunctionDescriptor::GetColorModes:
|
||
return ToHook<HWC2_PFN_GET_COLOR_MODES>(
|
||
DisplayHook<decltype(&HwcDisplay::GetColorModes),
|
||
&HwcDisplay::GetColorModes, uint32_t *, int32_t *>);
|
||
case HWC2::FunctionDescriptor::GetDisplayAttribute:
|
||
return ToHook<HWC2_PFN_GET_DISPLAY_ATTRIBUTE>(
|
||
DisplayHook<decltype(&HwcDisplay::GetDisplayAttribute),
|
||
&HwcDisplay::GetDisplayAttribute, hwc2_config_t, int32_t,
|
||
int32_t *>);
|
||
case HWC2::FunctionDescriptor::GetDisplayConfigs:
|
||
return ToHook<HWC2_PFN_GET_DISPLAY_CONFIGS>(
|
||
DisplayHook<decltype(&HwcDisplay::GetDisplayConfigs),
|
||
&HwcDisplay::GetDisplayConfigs, uint32_t *,
|
||
hwc2_config_t *>);
|
||
case HWC2::FunctionDescriptor::GetDisplayName:
|
||
return ToHook<HWC2_PFN_GET_DISPLAY_NAME>(
|
||
DisplayHook<decltype(&HwcDisplay::GetDisplayName),
|
||
&HwcDisplay::GetDisplayName, uint32_t *, char *>);
|
||
case HWC2::FunctionDescriptor::GetDisplayRequests:
|
||
return ToHook<HWC2_PFN_GET_DISPLAY_REQUESTS>(
|
||
DisplayHook<decltype(&HwcDisplay::GetDisplayRequests),
|
||
&HwcDisplay::GetDisplayRequests, int32_t *, uint32_t *,
|
||
hwc2_layer_t *, int32_t *>);
|
||
case HWC2::FunctionDescriptor::GetDisplayType:
|
||
return ToHook<HWC2_PFN_GET_DISPLAY_TYPE>(
|
||
DisplayHook<decltype(&HwcDisplay::GetDisplayType),
|
||
&HwcDisplay::GetDisplayType, int32_t *>);
|
||
case HWC2::FunctionDescriptor::GetDozeSupport:
|
||
return ToHook<HWC2_PFN_GET_DOZE_SUPPORT>(
|
||
DisplayHook<decltype(&HwcDisplay::GetDozeSupport),
|
||
&HwcDisplay::GetDozeSupport, int32_t *>);
|
||
case HWC2::FunctionDescriptor::GetHdrCapabilities:
|
||
return ToHook<HWC2_PFN_GET_HDR_CAPABILITIES>(
|
||
DisplayHook<decltype(&HwcDisplay::GetHdrCapabilities),
|
||
&HwcDisplay::GetHdrCapabilities, uint32_t *, int32_t *,
|
||
float *, float *, float *>);
|
||
case HWC2::FunctionDescriptor::GetReleaseFences:
|
||
return ToHook<HWC2_PFN_GET_RELEASE_FENCES>(
|
||
DisplayHook<decltype(&HwcDisplay::GetReleaseFences),
|
||
&HwcDisplay::GetReleaseFences, uint32_t *, hwc2_layer_t *,
|
||
int32_t *>);
|
||
case HWC2::FunctionDescriptor::PresentDisplay:
|
||
return ToHook<HWC2_PFN_PRESENT_DISPLAY>(
|
||
DisplayHook<decltype(&HwcDisplay::PresentDisplay),
|
||
&HwcDisplay::PresentDisplay, int32_t *>);
|
||
case HWC2::FunctionDescriptor::SetActiveConfig:
|
||
return ToHook<HWC2_PFN_SET_ACTIVE_CONFIG>(
|
||
DisplayHook<decltype(&HwcDisplay::SetActiveConfig),
|
||
&HwcDisplay::SetActiveConfig, hwc2_config_t>);
|
||
case HWC2::FunctionDescriptor::SetClientTarget:
|
||
return ToHook<HWC2_PFN_SET_CLIENT_TARGET>(
|
||
DisplayHook<decltype(&HwcDisplay::SetClientTarget),
|
||
&HwcDisplay::SetClientTarget, buffer_handle_t, int32_t,
|
||
int32_t, hwc_region_t>);
|
||
case HWC2::FunctionDescriptor::SetColorMode:
|
||
return ToHook<HWC2_PFN_SET_COLOR_MODE>(
|
||
DisplayHook<decltype(&HwcDisplay::SetColorMode),
|
||
&HwcDisplay::SetColorMode, int32_t>);
|
||
case HWC2::FunctionDescriptor::SetColorTransform:
|
||
return ToHook<HWC2_PFN_SET_COLOR_TRANSFORM>(
|
||
DisplayHook<decltype(&HwcDisplay::SetColorTransform),
|
||
&HwcDisplay::SetColorTransform, const float *, int32_t>);
|
||
case HWC2::FunctionDescriptor::SetOutputBuffer:
|
||
return ToHook<HWC2_PFN_SET_OUTPUT_BUFFER>(
|
||
DisplayHook<decltype(&HwcDisplay::SetOutputBuffer),
|
||
&HwcDisplay::SetOutputBuffer, buffer_handle_t, int32_t>);
|
||
case HWC2::FunctionDescriptor::SetPowerMode:
|
||
return ToHook<HWC2_PFN_SET_POWER_MODE>(
|
||
DisplayHook<decltype(&HwcDisplay::SetPowerMode),
|
||
&HwcDisplay::SetPowerMode, int32_t>);
|
||
case HWC2::FunctionDescriptor::SetVsyncEnabled:
|
||
return ToHook<HWC2_PFN_SET_VSYNC_ENABLED>(
|
||
DisplayHook<decltype(&HwcDisplay::SetVsyncEnabled),
|
||
&HwcDisplay::SetVsyncEnabled, int32_t>);
|
||
case HWC2::FunctionDescriptor::ValidateDisplay:
|
||
return ToHook<HWC2_PFN_VALIDATE_DISPLAY>(
|
||
DisplayHook<decltype(&HwcDisplay::ValidateDisplay),
|
||
&HwcDisplay::ValidateDisplay, uint32_t *, uint32_t *>);
|
||
|
||
#ifdef ANDROID_S
|
||
case HWC2::FunctionDescriptor::GetDisplayConnectionType:
|
||
return ToHook<HWC2_PFN_GET_DISPLAY_CONNECTION_TYPE>(
|
||
DisplayHook<decltype(&HwcDisplay::GetDisplayConnectionType),
|
||
&HwcDisplay::GetDisplayConnectionType, uint32_t *>);
|
||
case HWC2::FunctionDescriptor::GetDisplayVsyncPeriod:
|
||
return ToHook<HWC2_PFN_GET_DISPLAY_VSYNC_PERIOD>(
|
||
DisplayHook<decltype(&HwcDisplay::GetDisplayVsyncPeriod),
|
||
&HwcDisplay::GetDisplayVsyncPeriod,
|
||
hwc2_vsync_period_t *>);
|
||
#endif //ANDROID_S
|
||
|
||
// Layer functions
|
||
case HWC2::FunctionDescriptor::SetCursorPosition:
|
||
return ToHook<HWC2_PFN_SET_CURSOR_POSITION>(
|
||
LayerHook<decltype(&HwcLayer::SetCursorPosition),
|
||
&HwcLayer::SetCursorPosition, int32_t, int32_t>);
|
||
case HWC2::FunctionDescriptor::SetLayerBlendMode:
|
||
return ToHook<HWC2_PFN_SET_LAYER_BLEND_MODE>(
|
||
LayerHook<decltype(&HwcLayer::SetLayerBlendMode),
|
||
&HwcLayer::SetLayerBlendMode, int32_t>);
|
||
case HWC2::FunctionDescriptor::SetLayerBuffer:
|
||
return ToHook<HWC2_PFN_SET_LAYER_BUFFER>(
|
||
LayerHook<decltype(&HwcLayer::SetLayerBuffer),
|
||
&HwcLayer::SetLayerBuffer, buffer_handle_t, int32_t>);
|
||
case HWC2::FunctionDescriptor::SetLayerColor:
|
||
return ToHook<HWC2_PFN_SET_LAYER_COLOR>(
|
||
LayerHook<decltype(&HwcLayer::SetLayerColor),
|
||
&HwcLayer::SetLayerColor, hwc_color_t>);
|
||
case HWC2::FunctionDescriptor::SetLayerCompositionType:
|
||
return ToHook<HWC2_PFN_SET_LAYER_COMPOSITION_TYPE>(
|
||
LayerHook<decltype(&HwcLayer::SetLayerCompositionType),
|
||
&HwcLayer::SetLayerCompositionType, int32_t>);
|
||
case HWC2::FunctionDescriptor::SetLayerDataspace:
|
||
return ToHook<HWC2_PFN_SET_LAYER_DATASPACE>(
|
||
LayerHook<decltype(&HwcLayer::SetLayerDataspace),
|
||
&HwcLayer::SetLayerDataspace, int32_t>);
|
||
case HWC2::FunctionDescriptor::SetLayerDisplayFrame:
|
||
return ToHook<HWC2_PFN_SET_LAYER_DISPLAY_FRAME>(
|
||
LayerHook<decltype(&HwcLayer::SetLayerDisplayFrame),
|
||
&HwcLayer::SetLayerDisplayFrame, hwc_rect_t>);
|
||
case HWC2::FunctionDescriptor::SetLayerPlaneAlpha:
|
||
return ToHook<HWC2_PFN_SET_LAYER_PLANE_ALPHA>(
|
||
LayerHook<decltype(&HwcLayer::SetLayerPlaneAlpha),
|
||
&HwcLayer::SetLayerPlaneAlpha, float>);
|
||
case HWC2::FunctionDescriptor::SetLayerSidebandStream:
|
||
return ToHook<HWC2_PFN_SET_LAYER_SIDEBAND_STREAM>(
|
||
LayerHook<decltype(&HwcLayer::SetLayerSidebandStream),
|
||
&HwcLayer::SetLayerSidebandStream,
|
||
const native_handle_t *>);
|
||
case HWC2::FunctionDescriptor::SetLayerSourceCrop:
|
||
return ToHook<HWC2_PFN_SET_LAYER_SOURCE_CROP>(
|
||
LayerHook<decltype(&HwcLayer::SetLayerSourceCrop),
|
||
&HwcLayer::SetLayerSourceCrop, hwc_frect_t>);
|
||
case HWC2::FunctionDescriptor::SetLayerSurfaceDamage:
|
||
return ToHook<HWC2_PFN_SET_LAYER_SURFACE_DAMAGE>(
|
||
LayerHook<decltype(&HwcLayer::SetLayerSurfaceDamage),
|
||
&HwcLayer::SetLayerSurfaceDamage, hwc_region_t>);
|
||
case HWC2::FunctionDescriptor::SetLayerTransform:
|
||
return ToHook<HWC2_PFN_SET_LAYER_TRANSFORM>(
|
||
LayerHook<decltype(&HwcLayer::SetLayerTransform),
|
||
&HwcLayer::SetLayerTransform, int32_t>);
|
||
case HWC2::FunctionDescriptor::SetLayerVisibleRegion:
|
||
return ToHook<HWC2_PFN_SET_LAYER_VISIBLE_REGION>(
|
||
LayerHook<decltype(&HwcLayer::SetLayerVisibleRegion),
|
||
&HwcLayer::SetLayerVisibleRegion, hwc_region_t>);
|
||
case HWC2::FunctionDescriptor::SetLayerZOrder:
|
||
return ToHook<HWC2_PFN_SET_LAYER_Z_ORDER>(
|
||
LayerHook<decltype(&HwcLayer::SetLayerZOrder),
|
||
&HwcLayer::SetLayerZOrder, uint32_t>);
|
||
case HWC2::FunctionDescriptor::Invalid:
|
||
default:
|
||
return NULL;
|
||
}
|
||
}
|
||
|
||
// static
|
||
int DrmHwcTwo::HookDevOpen(const struct hw_module_t *module, const char *name,
|
||
struct hw_device_t **dev) {
|
||
if (strcmp(name, HWC_HARDWARE_COMPOSER)) {
|
||
ALOGE("Invalid module name- %s", name);
|
||
return -EINVAL;
|
||
}
|
||
InitDebugModule();
|
||
|
||
std::unique_ptr<DrmHwcTwo> ctx(new DrmHwcTwo());
|
||
if (!ctx) {
|
||
ALOGE("Failed to allocate DrmHwcTwo");
|
||
return -ENOMEM;
|
||
}
|
||
|
||
HWC2::Error err = ctx->Init();
|
||
if (err != HWC2::Error::None) {
|
||
ALOGE("Failed to initialize DrmHwcTwo err=%d\n", err);
|
||
return -EINVAL;
|
||
}
|
||
|
||
g_ctx = ctx.get();
|
||
|
||
signal(SIGALRM, StaticScreenOptHandler);
|
||
|
||
property_set("vendor.hwc.hdr_state","NORMAL");
|
||
|
||
ctx->common.module = const_cast<hw_module_t *>(module);
|
||
*dev = &ctx->common;
|
||
ctx.release();
|
||
|
||
return 0;
|
||
}
|
||
} // namespace android
|
||
|
||
static struct hw_module_methods_t hwc2_module_methods = {
|
||
.open = android::DrmHwcTwo::HookDevOpen,
|
||
};
|
||
|
||
hw_module_t HAL_MODULE_INFO_SYM = {
|
||
.tag = HARDWARE_MODULE_TAG,
|
||
.module_api_version = HARDWARE_MODULE_API_VERSION(2, 0),
|
||
.id = HWC_HARDWARE_MODULE_ID,
|
||
.name = "DrmHwcTwo module",
|
||
.author = "The Android Open Source Project",
|
||
.methods = &hwc2_module_methods,
|
||
.dso = NULL,
|
||
.reserved = {0},
|
||
};
|