732 lines
24 KiB
C++
Executable File
732 lines
24 KiB
C++
Executable File
/*
|
||
* Copyright (C) 2018 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 LOG_TAG "hwc-resource-manager"
|
||
|
||
#include "resources/resourcemanager.h"
|
||
#include "drmlayer.h"
|
||
|
||
#include <cutils/properties.h>
|
||
#include <log/log.h>
|
||
#include <sstream>
|
||
#include <string>
|
||
|
||
#include <drm_fourcc.h>
|
||
#include <xf86drm.h>
|
||
#include <xf86drmMode.h>
|
||
|
||
#include <utils/Trace.h>
|
||
|
||
#include <rga.h>
|
||
|
||
//XML prase
|
||
#include <tinyxml2.h>
|
||
|
||
namespace android {
|
||
|
||
#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
|
||
|
||
// define from hardware/rockchip/libgralloc/bifrost/src/mali_gralloc_usages.h
|
||
#ifndef RK_GRALLOC_USAGE_WITHIN_4G
|
||
#define RK_GRALLOC_USAGE_WITHIN_4G (1ULL << 56)
|
||
#endif
|
||
|
||
#ifndef RK_GRALLOC_USAGE_STRIDE_ALIGN_16
|
||
#define RK_GRALLOC_USAGE_STRIDE_ALIGN_16 (1ULL << 57)
|
||
#endif
|
||
|
||
/* Gralloc 4.0 中, 表征 "调用 alloc() 的 client 要求分配的 buffer 不是 AFBC 格式".
|
||
*/
|
||
#ifndef MALI_GRALLOC_USAGE_NO_AFBC
|
||
#define MALI_GRALLOC_USAGE_NO_AFBC (1ULL << 29)
|
||
#endif
|
||
|
||
#define WB_BUFFERQUEUE_MAX_SIZE 4
|
||
|
||
ResourceManager::ResourceManager() :
|
||
num_displays_(0) {
|
||
drmGralloc_ = DrmGralloc::getInstance();
|
||
}
|
||
|
||
int ResourceManager::Init(DrmHwcTwo *hwc2) {
|
||
hwc2_ = hwc2;
|
||
int ret = AddDrmDevice();
|
||
if(ret){
|
||
ALOGE("Failed to AddDrmDevice ");
|
||
}
|
||
|
||
if (!num_displays_) {
|
||
ALOGE("Failed to initialize any displays");
|
||
return ret ? -EINVAL : ret;
|
||
}
|
||
|
||
|
||
fb0_fd = open("/dev/graphics/fb0", O_RDWR, 0);
|
||
if(fb0_fd < 0){
|
||
ALOGE("Open fb0 fail in %s",__FUNCTION__);
|
||
}
|
||
|
||
DrmDevice *drm = drms_.front().get();
|
||
for(auto &crtc : drm->crtcs()){
|
||
mapDrmDisplayCompositor_.insert(
|
||
std::pair<int, std::shared_ptr<DrmDisplayCompositor>>(crtc->id(),std::make_shared<DrmDisplayCompositor>()));
|
||
HWC2_ALOGI("Create DrmDisplayCompositor crtc=%d",crtc->id());
|
||
}
|
||
|
||
displays_ = drm->GetDisplays();
|
||
if(displays_.size() == 0){
|
||
ALOGE("Failed to initialize any displays");
|
||
return ret ? -EINVAL : ret;
|
||
}
|
||
|
||
// 更新全局平台版本信息
|
||
gSetSocId(drm->getSocId());
|
||
// 更新全局 kernel drm 版本信息
|
||
gSetDrmVersion(drm->getDrmVersion());
|
||
|
||
// 更新配置
|
||
InitProperty();
|
||
return 0;
|
||
}
|
||
|
||
int ResourceManager::AddDrmDevice() {
|
||
std::unique_ptr<DrmDevice> drm = std::make_unique<DrmDevice>();
|
||
int displays_added, ret;
|
||
std::tie(ret, displays_added) = drm->Init(num_displays_);
|
||
if (ret < 0)
|
||
return ret;
|
||
|
||
//Get soc id
|
||
soc_id_ = drm->getSocId();
|
||
//DrmVersion
|
||
drmVersion_ = drm->getDrmVersion();
|
||
drmGralloc_->set_drm_version(dup(drm->fd()),drmVersion_);
|
||
|
||
std::shared_ptr<Importer> importer;
|
||
importer.reset(Importer::CreateInstance(drm.get()));
|
||
if (!importer) {
|
||
ALOGE("Failed to create importer instance");
|
||
return -ENODEV;
|
||
}
|
||
importers_.push_back(std::move(importer));
|
||
drms_.push_back(std::move(drm));
|
||
num_displays_ += displays_added;
|
||
return ret;
|
||
}
|
||
|
||
DrmConnector *ResourceManager::AvailableWritebackConnector(int display) {
|
||
DrmDevice *drm_device = GetDrmDevice(display);
|
||
DrmConnector *writeback_conn = NULL;
|
||
if (drm_device) {
|
||
writeback_conn = drm_device->AvailableWritebackConnector(display);
|
||
if (writeback_conn)
|
||
return writeback_conn;
|
||
}
|
||
for (auto &drm : drms_) {
|
||
if (drm.get() == drm_device)
|
||
continue;
|
||
writeback_conn = drm->AvailableWritebackConnector(display);
|
||
if (writeback_conn)
|
||
return writeback_conn;
|
||
}
|
||
return writeback_conn;
|
||
}
|
||
|
||
int ResourceManager::InitProperty() {
|
||
char property_value[PROPERTY_VALUE_MAX];
|
||
property_get("vendor.hwc.enable_composition_drop_mode", property_value, "0");
|
||
mCompositionDropMode_ = atoi(property_value) != 0;
|
||
|
||
property_get("vendor.hwc.enable_dynamic_display_mode", property_value, "0");
|
||
mDynamicDisplayMode_ = atoi(property_value) > 0;
|
||
|
||
property_get("vendor.hwc.enable_sideband_stream_2_mode", property_value, "0");
|
||
mSidebandStream2Mode_ = atoi(property_value) > 0;
|
||
|
||
property_get("vendor.hwc.video_buf_cache_max_size", property_value, "0");
|
||
mCacheBufferLimitSize_ = atoi(property_value);
|
||
|
||
return 0;
|
||
}
|
||
|
||
bool ResourceManager::IsCompositionDropMode() const {
|
||
return mCompositionDropMode_;
|
||
}
|
||
|
||
bool ResourceManager::IsDynamicDisplayMode() const {
|
||
return mDynamicDisplayMode_;
|
||
}
|
||
|
||
bool ResourceManager::IsSidebandStream2Mode() const {
|
||
// RK3528 默认开启 Sideband2.0支持
|
||
if(gIsRK3528()){
|
||
return true;
|
||
}
|
||
return mSidebandStream2Mode_;
|
||
}
|
||
|
||
int ResourceManager::GetCacheBufferLimitSize() const{
|
||
return mCacheBufferLimitSize_;
|
||
}
|
||
|
||
DrmDevice *ResourceManager::GetDrmDevice(int display) {
|
||
for (auto &drm : drms_) {
|
||
if (drm->HandlesDisplay(display & ~DRM_CONNECTOR_SPILT_MODE_MASK))
|
||
return drm.get();
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
std::shared_ptr<Importer> ResourceManager::GetImporter(int display) {
|
||
for (unsigned int i = 0; i < drms_.size(); i++) {
|
||
if (drms_[i]->HandlesDisplay(display & ~DRM_CONNECTOR_SPILT_MODE_MASK))
|
||
return importers_[i];
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
std::shared_ptr<DrmDisplayCompositor> ResourceManager::GetDrmDisplayCompositor(DrmCrtc* crtc){
|
||
if(!crtc){
|
||
HWC2_ALOGE("crtc is null");
|
||
return NULL;
|
||
}
|
||
|
||
if(mapDrmDisplayCompositor_.size() == 0){
|
||
HWC2_ALOGE("mapDrmDisplayCompositor_.size()=0");
|
||
return NULL;
|
||
}
|
||
|
||
auto pairDrmDisplayCompositor = mapDrmDisplayCompositor_.find(crtc->id());
|
||
return pairDrmDisplayCompositor->second;
|
||
}
|
||
|
||
int ResourceManager::GetWBDisplay() const {
|
||
std::unique_lock<std::recursive_mutex> lock(mRecursiveMutex);
|
||
return iWriteBackDisplayId_;
|
||
}
|
||
|
||
bool ResourceManager::isWBMode() const {
|
||
std::unique_lock<std::recursive_mutex> lock(mRecursiveMutex);
|
||
return bEnableWriteBackRef_ > 0;
|
||
}
|
||
|
||
const DrmMode& ResourceManager::GetWBMode() const {
|
||
std::unique_lock<std::recursive_mutex> lock(mRecursiveMutex);
|
||
return mWBMode_;
|
||
}
|
||
|
||
bool ResourceManager::IsDisableHwVirtualDisplay(){
|
||
std::unique_lock<std::recursive_mutex> lock(mRecursiveMutex);
|
||
return mVDMode_ == HWC2_DISABLE_HW_VIRTUAL_DISPLAY;
|
||
}
|
||
|
||
bool ResourceManager::IsWriteBackByVop(){
|
||
std::unique_lock<std::recursive_mutex> lock(mRecursiveMutex);
|
||
return mVDMode_ == HWC2_HW_VIRTUAL_DISPLAY_USE_VOP;
|
||
}
|
||
|
||
bool ResourceManager::IsWriteBackByRga(){
|
||
std::unique_lock<std::recursive_mutex> lock(mRecursiveMutex);
|
||
return mVDMode_ == HWC2_HW_VIRTUAL_DISPLAY_USE_RGA;
|
||
}
|
||
|
||
HwVirtualDisplayMode_t ResourceManager::ChooseWriteBackMode(int display){
|
||
std::unique_lock<std::recursive_mutex> lock(mRecursiveMutex);
|
||
// 2. 获取待 WriteBack display状态，状态异常则直接关闭 WriteBack 模式
|
||
DrmDevice *drmDevice = GetDrmDevice(display);
|
||
DrmConnector *writeBackConn = drmDevice->GetConnectorForDisplay(display);
|
||
if(!writeBackConn){
|
||
HWC2_ALOGE("display=%d WriteBackConn is NULL", display);
|
||
return HWC2_DISABLE_HW_VIRTUAL_DISPLAY;
|
||
}
|
||
|
||
if(writeBackConn->state() != DRM_MODE_CONNECTED){
|
||
HWC2_ALOGE("display=%d WriteBackConn state isn't connected(%d)",
|
||
display, writeBackConn->state());
|
||
return HWC2_DISABLE_HW_VIRTUAL_DISPLAY;
|
||
}
|
||
|
||
// 3. 获取待 WriteBack 当前分辨率，用于申请 WriteBackBuffer
|
||
// 4. WriteBack 硬件要求 16对齐，否则超出部分会直接丢弃
|
||
mWBMode_ = writeBackConn->current_mode();
|
||
if(mWBMode_.width() > 4096 || mWBMode_.height() > 2160){
|
||
HWC2_ALOGI("Primary resolution=%dx%d, use WriteBack by RGA", mWBMode_.width(), mWBMode_.height());
|
||
return HWC2_HW_VIRTUAL_DISPLAY_USE_RGA;
|
||
}
|
||
|
||
HWC2_ALOGI("Primary resolution=%dx%d, use WriteBack by Vop WriteBack", mWBMode_.width(), mWBMode_.height());
|
||
return HWC2_HW_VIRTUAL_DISPLAY_USE_VOP;
|
||
}
|
||
|
||
// 使用 Vop 作为 WriteBack 内容输出单元
|
||
int ResourceManager::WriteBackUseVop(int display){
|
||
std::unique_lock<std::recursive_mutex> lock(mRecursiveMutex);
|
||
iWBWidth_ = ALIGN_DOWN(mWBMode_.width(),16);
|
||
iWBHeight_ = mWBMode_.height();
|
||
iWBFormat_ = HAL_PIXEL_FORMAT_YCrCb_NV12;
|
||
|
||
// 5. 创建 WriteBackBuffer BufferQueue，并且申请 WB Buffer.
|
||
if(mWriteBackBQ_ == NULL){
|
||
mWriteBackBQ_ = std::make_shared<DrmBufferQueue>(WB_BUFFERQUEUE_MAX_SIZE);
|
||
mNextWriteBackBuffer_
|
||
= mWriteBackBQ_->DequeueDrmBuffer(iWBWidth_,
|
||
iWBHeight_,
|
||
iWBFormat_,
|
||
RK_GRALLOC_USAGE_STRIDE_ALIGN_16 |
|
||
MALI_GRALLOC_USAGE_NO_AFBC,
|
||
"WriteBackBuffer");
|
||
if(!mNextWriteBackBuffer_->initCheck()){
|
||
HWC2_ALOGE("display=%d WBBuffer Dequeue fail, w=%d h=%d format=%d",
|
||
display,
|
||
iWBWidth_,
|
||
iWBHeight_,
|
||
iWBFormat_);
|
||
return -1;
|
||
}
|
||
}
|
||
|
||
bEnableWriteBackRef_++;
|
||
iWriteBackDisplayId_ = display;
|
||
return 0;
|
||
}
|
||
|
||
// 使用 Rga 作为 WriteBack 内容输出单元
|
||
int ResourceManager::WriteBackUseRga(int display){
|
||
// 利用 RGA 进行 WriteBack, RGA alpha blend 要求点对点，不允许缩放
|
||
// 故要求申请内存与系统UI分辨率一致
|
||
if(hwc2_->GetDisplayCtxPtr(display) != NULL){
|
||
hwc2_drm_display_t* dpy_ctx = hwc2_->GetDisplayCtxPtr(display);
|
||
iWBWidth_ = dpy_ctx->framebuffer_width;
|
||
iWBHeight_ = dpy_ctx->framebuffer_height;
|
||
iWBFormat_ = HAL_PIXEL_FORMAT_RGBA_8888;
|
||
}else{
|
||
iWBWidth_ = mWBMode_.h_display();
|
||
iWBHeight_ = mWBMode_.v_display();
|
||
iWBFormat_ = HAL_PIXEL_FORMAT_RGBA_8888;
|
||
}
|
||
|
||
// 5. 创建 WriteBackBuffer BufferQueue，并且申请 WB Buffer.
|
||
if(mWriteBackBQ_ == NULL){
|
||
mWriteBackBQ_ = std::make_shared<DrmBufferQueue>();
|
||
|
||
mNextWriteBackBuffer_
|
||
= mWriteBackBQ_->DequeueDrmBuffer(iWBWidth_,
|
||
iWBHeight_,
|
||
iWBFormat_,
|
||
RK_GRALLOC_USAGE_STRIDE_ALIGN_16 |
|
||
MALI_GRALLOC_USAGE_NO_AFBC,
|
||
"WriteBackBuffer");
|
||
if(!mNextWriteBackBuffer_->initCheck()){
|
||
HWC2_ALOGE("display=%d WBBuffer Dequeue fail, w=%d h=%d format=%d",
|
||
display,
|
||
iWBWidth_,
|
||
iWBHeight_,
|
||
iWBFormat_);
|
||
return -1;
|
||
}
|
||
}
|
||
|
||
bEnableWriteBackRef_++;
|
||
iWriteBackDisplayId_ = display;
|
||
return 0;
|
||
}
|
||
|
||
int ResourceManager::EnableWriteBackMode(int display){
|
||
std::unique_lock<std::recursive_mutex> lock(mRecursiveMutex);
|
||
|
||
// 1. 检查 WB 模块是否已经被绑定
|
||
if(bEnableWriteBackRef_ > 0){
|
||
if(iWriteBackDisplayId_ != display){
|
||
HWC2_ALOGE("WriteBack has bind display %d, so display=%d WB request can't handle.",
|
||
iWriteBackDisplayId_, display);
|
||
return -1;
|
||
}else{
|
||
bEnableWriteBackRef_++;
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
// 2. 根据 primary 分辨率模式选择 WriteBack 模式
|
||
mVDMode_ = ChooseWriteBackMode(display);
|
||
switch(mVDMode_){
|
||
case HWC2_HW_VIRTUAL_DISPLAY_USE_VOP:
|
||
return WriteBackUseVop(display);
|
||
case HWC2_HW_VIRTUAL_DISPLAY_USE_RGA:
|
||
return WriteBackUseRga(display);
|
||
case HWC2_DISABLE_HW_VIRTUAL_DISPLAY:
|
||
default:
|
||
HWC2_ALOGE("display=%d can't find any suitable WriteBack mode, roll back to GLES display, VDMode=%d",
|
||
display, mVDMode_);
|
||
return -1;
|
||
}
|
||
|
||
return -1;
|
||
}
|
||
|
||
|
||
int ResourceManager::UpdateWriteBackResolutionUseVop(int display){
|
||
std::unique_lock<std::recursive_mutex> lock(mRecursiveMutex);
|
||
|
||
// 2. 获取待 WriteBack display状态，状态异常则直接关闭 WriteBack 模式
|
||
DrmDevice *drmDevice = GetDrmDevice(display);
|
||
DrmConnector *writeBackConn = drmDevice->GetConnectorForDisplay(display);
|
||
if(!writeBackConn){
|
||
HWC2_ALOGE("display=%d WriteBackConn is NULL", display);
|
||
return -1;
|
||
}
|
||
|
||
if(writeBackConn->state() != DRM_MODE_CONNECTED){
|
||
HWC2_ALOGE("display=%d WriteBackConn state isn't connected(%d)",
|
||
display, writeBackConn->state());
|
||
return -1;
|
||
}
|
||
|
||
// 3. 获取待 WriteBack 当前分辨率，用于申请 WriteBackBuffer
|
||
DrmMode currentMode = writeBackConn->current_mode();
|
||
mWBMode_ = currentMode;
|
||
int tempWBWidth = ALIGN_DOWN(mWBMode_.width(),16);
|
||
int tempWBHeight = mWBMode_.height();
|
||
if(tempWBWidth == iWBWidth_ &&
|
||
tempWBHeight == iWBHeight_){
|
||
return 0;
|
||
}else{
|
||
HWC2_ALOGI("display=%d update WriteBack resolution(%dx%d)=>(%dx%d)",
|
||
display, iWBWidth_, iWBHeight_,
|
||
currentMode.width(), currentMode.height());
|
||
}
|
||
|
||
iWBWidth_ = tempWBWidth;
|
||
iWBHeight_ = tempWBHeight;
|
||
iWBFormat_ = HAL_PIXEL_FORMAT_YCrCb_NV12;
|
||
|
||
// 4. 创建 WriteBackBuffer BufferQueue，并且申请 WB Buffer.
|
||
if(mWriteBackBQ_ == NULL){
|
||
mWriteBackBQ_ = std::make_shared<DrmBufferQueue>(WB_BUFFERQUEUE_MAX_SIZE);
|
||
}
|
||
|
||
mNextWriteBackBuffer_
|
||
= mWriteBackBQ_->DequeueDrmBuffer(iWBWidth_,
|
||
iWBHeight_,
|
||
iWBFormat_,
|
||
RK_GRALLOC_USAGE_STRIDE_ALIGN_16 |
|
||
MALI_GRALLOC_USAGE_NO_AFBC,
|
||
"WriteBackBuffer");
|
||
if(!mNextWriteBackBuffer_->initCheck()){
|
||
HWC2_ALOGE("display=%d WBBuffer Dequeue fail, w=%d h=%d format=%d",
|
||
display, iWBWidth_, iWBHeight_, iWBFormat_);
|
||
return -1;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
int ResourceManager::UpdateWriteBackResolution(int display){
|
||
std::unique_lock<std::recursive_mutex> lock(mRecursiveMutex);
|
||
|
||
// 1. 检查 WB 模块是否已经被绑定
|
||
if(bEnableWriteBackRef_ > 0){
|
||
if(iWriteBackDisplayId_ != display){
|
||
HWC2_ALOGE("WriteBack has bind display %d, so display=%d WB request can't handle.",
|
||
iWriteBackDisplayId_, display);
|
||
return -1;
|
||
}
|
||
}
|
||
|
||
// 根据 WriteBack mode 处理 update WriteBack resolution 请求
|
||
switch(mVDMode_){
|
||
case HWC2_HW_VIRTUAL_DISPLAY_USE_VOP:
|
||
return UpdateWriteBackResolutionUseVop(display);
|
||
case HWC2_HW_VIRTUAL_DISPLAY_USE_RGA:
|
||
// RGA 模式不需要考虑分辨率切换的场景
|
||
return 0;
|
||
case HWC2_DISABLE_HW_VIRTUAL_DISPLAY:
|
||
default:
|
||
HWC2_ALOGE("display=%d can't find any suitable WriteBack mode, VDMode=%d ", display, mVDMode_);
|
||
return -1;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
int ResourceManager::DisableWriteBackMode(int display){
|
||
std::unique_lock<std::recursive_mutex> lock(mRecursiveMutex);
|
||
if(display != iWriteBackDisplayId_)
|
||
return 0;
|
||
|
||
bEnableWriteBackRef_--;
|
||
if(bEnableWriteBackRef_ <= 0){
|
||
iWriteBackDisplayId_ = -1;
|
||
mFinishBufferQueue_.clear();
|
||
mVDMode_ = HWC2_DISABLE_HW_VIRTUAL_DISPLAY;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
std::shared_ptr<DrmBuffer> ResourceManager::GetResetWBBuffer(){
|
||
std::unique_lock<std::recursive_mutex> lock(mRecursiveMutex);
|
||
if(mResetBackBuffer_ == NULL){
|
||
mResetBackBuffer_ = std::make_shared<DrmBuffer>(640,
|
||
360,
|
||
HAL_PIXEL_FORMAT_YCrCb_NV12,
|
||
RK_GRALLOC_USAGE_STRIDE_ALIGN_16 |
|
||
RK_GRALLOC_USAGE_WITHIN_4G,
|
||
"WBResetBuffer");
|
||
if(mResetBackBuffer_->Init()){
|
||
HWC2_ALOGE("DrmBuffer Init fail, w=%d h=%d format=%d name=%s",
|
||
640, 360, HAL_PIXEL_FORMAT_YCrCb_NV12, "WBResetBuffer");
|
||
mResetBackBuffer_ = NULL;
|
||
return NULL;
|
||
}
|
||
|
||
rga_buffer_t src;
|
||
im_rect src_rect;
|
||
|
||
memset(&src, 0x0, sizeof(rga_buffer_t));
|
||
memset(&src_rect, 0x0, sizeof(im_rect));
|
||
|
||
// Set src buffer info
|
||
src.fd = mResetBackBuffer_->GetFd();
|
||
src.width = mResetBackBuffer_->GetWidth();
|
||
src.height = mResetBackBuffer_->GetHeight();
|
||
src.wstride = mResetBackBuffer_->GetStride();
|
||
src.hstride = mResetBackBuffer_->GetHeightStride();
|
||
src.format = mResetBackBuffer_->GetFormat();
|
||
|
||
// Set src rect info
|
||
src_rect.x = 0;
|
||
src_rect.y = 0;
|
||
src_rect.width = src.width ;
|
||
src_rect.height = src.height;
|
||
|
||
src.color_space_mode = IM_RGB_TO_YUV_BT601_LIMIT;
|
||
|
||
// Set Dataspace
|
||
// if((buffer.mBufferInfo_.uDataSpace_ & HAL_DATASPACE_STANDARD_BT709) == HAL_DATASPACE_STANDARD_BT709){
|
||
// dst.color_space_mode = IM_YUV_TO_RGB_BT709_LIMIT;
|
||
// SVEP_ALOGD_IF("color_space_mode = BT709 dataspace=0x%" PRIx64,buffer.mBufferInfo_.uDataSpace_);
|
||
// }else{
|
||
// SVEP_ALOGD_IF("color_space_mode = BT601 dataspace=0x%" PRIx64,buffer.mBufferInfo_.uDataSpace_);
|
||
// }
|
||
|
||
IM_STATUS im_state;
|
||
|
||
// Call Im2d 格式转换
|
||
im_state = imfill(src, src_rect, 0x0);
|
||
|
||
if(im_state != IM_STATUS_SUCCESS){
|
||
HWC2_ALOGE("call im2d reset Fail!");
|
||
}
|
||
}
|
||
return mResetBackBuffer_;
|
||
}
|
||
std::shared_ptr<DrmBuffer> ResourceManager::GetNextWBBuffer(){
|
||
std::unique_lock<std::recursive_mutex> lock(mRecursiveMutex);
|
||
return mNextWriteBackBuffer_;
|
||
}
|
||
|
||
std::shared_ptr<DrmBuffer> ResourceManager::GetDrawingWBBuffer(){
|
||
std::unique_lock<std::recursive_mutex> lock(mRecursiveMutex);
|
||
return mDrawingWriteBackBuffer_;;
|
||
}
|
||
|
||
int ResourceManager::GetFinishWBBufferSize(){
|
||
std::unique_lock<std::recursive_mutex> lock(mRecursiveMutex);
|
||
return mFinishBufferQueue_.size();
|
||
}
|
||
|
||
int ResourceManager::OutputWBBuffer(int display_id,
|
||
rga_buffer_t &dst,
|
||
im_rect &dst_rect,
|
||
int32_t *retire_fence,
|
||
uint64_t *last_frame_no){
|
||
|
||
ATRACE_CALL();
|
||
std::unique_lock<std::recursive_mutex> lock(mRecursiveMutex);
|
||
if(mFinishBufferQueue_.size() == 0){
|
||
HWC2_ALOGE("mFinishBufferQueue_ size is 0");
|
||
return -1;
|
||
}
|
||
|
||
std::shared_ptr<DrmBuffer> output_buffer = NULL;
|
||
uint64_t output_frame_no = 0;
|
||
std::queue<PAIR_ID_BUFFER> tmp_bufferqueue;
|
||
for(auto &FinishBufferPair : mFinishBufferQueue_){
|
||
if(FinishBufferPair.first > *last_frame_no){
|
||
output_buffer = FinishBufferPair.second;
|
||
output_frame_no = FinishBufferPair.first;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if(output_buffer == NULL && mFinishBufferQueue_.size() >0){
|
||
output_buffer = mFinishBufferQueue_.back().second;
|
||
output_frame_no = mFinishBufferQueue_.back().first;
|
||
HWC2_ALOGW("VDS may output a same image frame_no=%" PRIu64 " Last_frame_no=%" PRIu64 , output_frame_no, *last_frame_no);
|
||
}
|
||
|
||
if(output_buffer == NULL){
|
||
HWC2_ALOGE("output_buffer is NULL");
|
||
return -1;
|
||
}
|
||
|
||
HWC2_ALOGD_IF_DEBUG("WB: display=%d frame_no=%" PRIu64 " id=%" PRIu64 " queue.size=%zu" ,
|
||
display_id, output_frame_no, output_buffer->GetId(),mFinishBufferQueue_.size());
|
||
|
||
output_buffer->WaitFinishFence();
|
||
// 添加调试接口，抓打印WriteBack Buffer
|
||
char value[PROPERTY_VALUE_MAX];
|
||
property_get("debug.wb.dump", value, "0");
|
||
if(atoi(value) > 0){
|
||
output_buffer->DumpData();
|
||
}
|
||
|
||
rga_buffer_t src;
|
||
rga_buffer_t pat;
|
||
im_rect src_rect;
|
||
im_rect pat_rect;
|
||
|
||
memset(&src, 0x0, sizeof(rga_buffer_t));
|
||
memset(&pat, 0x0, sizeof(rga_buffer_t));
|
||
memset(&src_rect, 0x0, sizeof(im_rect));
|
||
memset(&src_rect, 0x0, sizeof(im_rect));
|
||
|
||
// Set src buffer info
|
||
src.fd = output_buffer->GetFd();
|
||
src.width = output_buffer->GetWidth();
|
||
src.height = output_buffer->GetHeight();
|
||
src.wstride = output_buffer->GetStride();
|
||
src.hstride = output_buffer->GetHeightStride();
|
||
src.format = output_buffer->GetFormat();
|
||
|
||
// 由于WriteBack仅支持BGR888(B:G:R little endian)，故需要使用RGA做格式转换
|
||
if(src.format == HAL_PIXEL_FORMAT_RGB_888)
|
||
src.format = RK_FORMAT_BGR_888;
|
||
// 由于WriteBack仅支持BGR565(B:G:R little endian)，故需要使用RGA做格式转换
|
||
if(src.format == HAL_PIXEL_FORMAT_RGB_565)
|
||
src.format = RK_FORMAT_BGR_565;
|
||
|
||
|
||
// Set src rect info
|
||
src_rect.x = 0;
|
||
src_rect.y = 0;
|
||
src_rect.width = output_buffer->GetWidth();
|
||
src_rect.height = output_buffer->GetHeight();
|
||
|
||
// Set Dataspace
|
||
// if((srcBuffer.mBufferInfo_.uDataSpace_ & HAL_DATASPACE_STANDARD_BT709) == HAL_DATASPACE_STANDARD_BT709){
|
||
// dst.color_space_mode = IM_YUV_TO_RGB_BT709_LIMIT;
|
||
// SVEP_ALOGD_IF("color_space_mode = BT709 dataspace=0x%" PRIx64,srcBuffer.mBufferInfo_.uDataSpace_);
|
||
// }else{
|
||
// SVEP_ALOGD_IF("color_space_mode = BT601 dataspace=0x%" PRIx64,srcBuffer.mBufferInfo_.uDataSpace_);
|
||
// }
|
||
|
||
IM_STATUS im_state;
|
||
|
||
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, IM_SYNC);
|
||
|
||
if(im_state == IM_STATUS_SUCCESS){
|
||
HWC2_ALOGD_IF_VERBOSE("call im2d convert to rgb888 Success");
|
||
*retire_fence = -1;
|
||
}else{
|
||
HWC2_ALOGD_IF_DEBUG("call im2d fail, ret=%d Error=%s", im_state, imStrError(im_state));
|
||
*retire_fence = -1;
|
||
return -1;
|
||
}
|
||
|
||
*last_frame_no = output_frame_no;
|
||
|
||
return 0;
|
||
}
|
||
|
||
int ResourceManager::SwapWBBuffer(uint64_t frame_no){
|
||
|
||
ATRACE_CALL();
|
||
std::unique_lock<std::recursive_mutex> lock(mRecursiveMutex);
|
||
if(bEnableWriteBackRef_ <= 0){
|
||
HWC2_ALOGE("");
|
||
return -1;
|
||
}
|
||
|
||
// 1. Drawing 切换为 Finish 状态, 并 push 进队列
|
||
if(mDrawingWriteBackBuffer_ != NULL){
|
||
mFinishBufferQueue_.push_back(PAIR_ID_BUFFER{frame_no, mDrawingWriteBackBuffer_});
|
||
HWC2_ALOGD_IF_VERBOSE("WB: frame_no=%" PRIu64 " id=%" PRIu64 " queue.size=%zu" ,frame_no, mDrawingWriteBackBuffer_->GetId(),mFinishBufferQueue_.size());
|
||
// 环形缓冲区，若达到环形缓冲区最大尺寸，则需要丢掉最旧的一帧缓存
|
||
if(mFinishBufferQueue_.size() > (WB_BUFFERQUEUE_MAX_SIZE - 1)){
|
||
auto last_buffer_pair = mFinishBufferQueue_.begin();
|
||
mFinishBufferQueue_.erase(last_buffer_pair);
|
||
HWC2_ALOGD_IF_WARN("WB: lost frame_no=%" PRIu64 " id=%" PRIu64 " queue.size=%zu" ,
|
||
last_buffer_pair->first,
|
||
((last_buffer_pair->second != NULL) ? last_buffer_pair->second->GetId() : -1),
|
||
mFinishBufferQueue_.size());
|
||
|
||
}
|
||
}
|
||
// 2. Next 切换为 Drawing 状态
|
||
mDrawingWriteBackBuffer_ = mNextWriteBackBuffer_;
|
||
if(mWriteBackBQ_->QueueBuffer(mNextWriteBackBuffer_)){
|
||
HWC2_ALOGE("display=%d WBBuffer Queue fail, w=%d h=%d format=%d",
|
||
iWriteBackDisplayId_,
|
||
iWBWidth_,
|
||
iWBHeight_,
|
||
iWBFormat_);
|
||
return -1;
|
||
}
|
||
|
||
// 3. 申请 Next Buffer
|
||
std::shared_ptr<DrmBuffer> next
|
||
= mWriteBackBQ_->DequeueDrmBuffer(iWBWidth_,
|
||
iWBHeight_,
|
||
iWBFormat_,
|
||
RK_GRALLOC_USAGE_STRIDE_ALIGN_16 |
|
||
MALI_GRALLOC_USAGE_NO_AFBC,
|
||
"WriteBackBuffer");
|
||
if(!next->initCheck()){
|
||
HWC2_ALOGE("display=%d WBBuffer Dequeue fail, w=%d h=%d format=%d",
|
||
iWriteBackDisplayId_,
|
||
iWBWidth_,
|
||
iWBHeight_,
|
||
iWBFormat_);
|
||
return -1;
|
||
}
|
||
|
||
HWC2_ALOGD_IF_INFO("display=%d success, w=%d h=%d format=%d",
|
||
iWriteBackDisplayId_,
|
||
iWBWidth_,
|
||
iWBHeight_,
|
||
iWBFormat_);
|
||
|
||
mNextWriteBackBuffer_ = next;
|
||
return 0;
|
||
}
|
||
} // namespace android
|