BPI/BPI-CM9-Linux
6
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
818cb714e3504578f68bc0a214df1ba8a0ec1edd
BPI-CM9-Linux/aml-comp/vendor/amlogic/meson_display/composition/CompositionStrategyBase.cpp
T

1893 lines
66 KiB
C++
Raw Normal View History

Import complete source tree
2026-08-13 11:28:40 +08:00
/*
* Copyright (c) 2018 Amlogic, Inc. All rights reserved.
*
* This source code is subject to the terms and conditions defined in the
* file 'LICENSE' which is part of this source code package.
*
* Description:
*/
#define LOG_NDEBUG 1
#include <algorithm>
#include "CompositionStrategyBase.h"
#include <DrmTypes.h>
#include <fcntl.h>
#include <DebugHelper.h>
/* Constructor function */
CompositionStrategyBase::CompositionStrategyBase() {
init();
mOsdPlaneNum = 0;
mVideoPlaneNum = 0;
mVideoComposerNum = 0;
mScaleValue = 0;
mCompositionFlag = 0;
memset(&mOsdDisplayFrame, 0, sizeof(mOsdDisplayFrame));
}
/* Clean FrameBuffer, Composer and Plane. */
void CompositionStrategyBase::init() {
/* Reset Flags */
mHDRMode = false;
mHideSecureLayer = false;
mForceClientComposer = false;
mForceVideoComposer = false;
mHaveClient = false;
mInsideVideoFbsFlag = false;
mIsSideBandDisable = false;
mMosaicEnabled = false;
m4Mosaic = false;
mIsVideoComposerV2D = false;
mHideVideoForHdcpDev = false;
/*crtc scale info.*/
mDisplayRefFb.reset();
//memset(&mOsdDisplayFrame, 0, sizeof(mOsdDisplayFrame));
mCrtc.reset();
/* Clean FrameBuffer */
mFramebuffers.clear();
/* Clean Composer */
mDummyComposer.reset();
mClientComposer.reset();
mVideoComposers.clear();
mOtherComposers.clear();
/* Clean Plane */
mOsdPlanes.clear();
mHwcVideoPlanes.clear();
mOtherPlanes.clear();
/* Clean Composition members */
mComposer.reset();
mOverlayFbs.clear();
mComposerFbs.clear();
mVideoComposerFbs.clear();
mDisplayPairs.clear();
mMinComposerZorder = INVALID_ZORDER;
mMaxComposerZorder = INVALID_ZORDER;
mMinVideoZorder = INVALID_ZORDER;
mMaxVideoZorder = INVALID_ZORDER;
mDumpStr.clear();
}
int CompositionStrategyBase::deleteFbFromVectorFbs(
std::vector<std::shared_ptr<DrmFramebufferBase>> & inputFbs,
std::shared_ptr<DrmFramebufferBase> & fb) {
std::vector<std::shared_ptr<DrmFramebufferBase>>::iterator itErase;
if (!fb.get())
return 0;
/* remove from list */
itErase = std::find(inputFbs.begin(), inputFbs.end(), fb);
if (itErase != inputFbs.end()) {
inputFbs.erase(itErase);
return 0;
}
return 1;
}
int CompositionStrategyBase::chooseVideoFbsBaseNoOverlap(
std::vector<std::shared_ptr<DrmFramebufferBase>> & inputVideoFbs,
std::vector<std::shared_ptr<DrmFramebufferBase>> & outputVideoFbs) {
drm_rect_t dispFrame, dispFrame1;
bool is_overlap;
std::shared_ptr<DrmFramebufferBase> fb, fb1;
for (auto it = inputVideoFbs.begin(); it != inputVideoFbs.end(); it++) {
fb = *it;
is_overlap = false;
/* find one that did not overlap with others */
dispFrame = fb->getDisplayFrame();
for (auto it1 = it; it1 != inputVideoFbs.end(); it1++) {
fb1 = *it1;
if (fb == fb1)
continue;
dispFrame1 = fb1->getDisplayFrame();
if (std::max(0, std::min(dispFrame.right, dispFrame1.right) -
std::max(dispFrame.left, dispFrame1.left)) *
std::max(0, std::min(dispFrame.bottom, dispFrame1.bottom) -
std::max(dispFrame.top, dispFrame1.top)) != 0) {
is_overlap = true;
break;
}
}
if (!is_overlap) {
MESON_LOGV("[%s] Layer(%s) buffer is not overlap with others",
__func__, fb->getDebugInfo());
outputVideoFbs.push_back(fb);
}
}
return 0;
}
int CompositionStrategyBase::chooseOneVideoFbBaseBiggestWindow(
std::vector<std::shared_ptr<DrmFramebufferBase>> & inputVideoFbs,
std::shared_ptr<DrmFramebufferBase> & outputVideoFb) {
drm_rect_t dispFrame;
std::shared_ptr<DrmFramebufferBase> fb = nullptr;
std::shared_ptr<DrmFramebufferBase> large_fb = nullptr;
int region = 0, max_region = 0;
outputVideoFb.reset();
if (inputVideoFbs.empty())
return 0;
for (auto it = inputVideoFbs.begin(); it != inputVideoFbs.end(); it++) {
fb = *it;
dispFrame = fb->getDisplayFrame();
region = (dispFrame.right - dispFrame.left) * (dispFrame.bottom - dispFrame.top);
if (!large_fb) {
large_fb = fb;
max_region = region;
continue;
}
/* find the largest the frame */
if (region > max_region) {
large_fb = fb;
max_region = region;
} else if (region == max_region) {
if (fb->getZorder() > large_fb->getZorder())
large_fb = fb;
}
}
outputVideoFb = large_fb;
dispFrame = large_fb->getDisplayFrame();
MESON_LOGV("[%s] Layer(%s) return large region buffer (%d %d %d %d)",
__func__, large_fb->getDebugInfo(),
dispFrame.left, dispFrame.top, dispFrame.right, dispFrame.bottom);
return 0;
}
int CompositionStrategyBase::chooseOneVideoFbBaseVideoType(
std::vector<std::shared_ptr<DrmFramebufferBase>> & inputVideoFbs,
std::shared_ptr<DrmFramebufferBase> & outputVideoFb) {
int video_type;
std::vector<std::shared_ptr<DrmFramebufferBase>> fbs;
std::vector<MESON_VIDEO_TYPE> video_types {MESON_VIDEO_8K, MESON_VIDEO_DI_POST,
MESON_VIDEO_SECURE, MESON_VIDEO_DV, MESON_VIDEO_4K, MESON_VIDEO_AFBC,
MESON_VIDEO_HDR, MESON_VIDEO_HDR10_PLUS, MESON_VIDEO_HLG};
for (auto it = inputVideoFbs.begin(); it != inputVideoFbs.end(); it++) {
video_type = (*it)->getVideoType();
if (video_type > 0) fbs.push_back(*it);
MESON_LOGV("[%s] Layer(%s) videoType:0x%x",
__func__, (*it)->getDebugInfo(), video_type);
}
if (!fbs.empty()) {
auto type_it = video_types.begin();
for (; type_it != video_types.end(); type_it++) {
bool have_type = false;
for (auto fbIt = fbs.begin(); fbIt != fbs.end(); fbIt++) {
video_type = (*fbIt)->getVideoType();
if ((video_type & *type_it) == *type_it) {
have_type = true;
break;
}
}
if (have_type) {
for (auto fbIt = fbs.begin(); fbIt != fbs.end();) {
video_type = (*fbIt)->getVideoType();
if ((video_type & *type_it) == *type_it)
fbIt++;
else
fbs.erase(fbIt);
}
}
if (fbs.size() == 1)
break;
}
}
outputVideoFb.reset();
if (fbs.size() == 1) {
outputVideoFb = fbs[0];
} else if (fbs.size() >= 1) {
chooseOneVideoFbBaseBiggestWindow(fbs, outputVideoFb);
}
if (outputVideoFb.get())
MESON_LOGV("[%s] choose the fb (%s), videoType:0x%x",
__func__, outputVideoFb->getDebugInfo(),
outputVideoFb->getVideoType());
return 0;
}
bool CompositionStrategyBase::chooseOneVideoFbBasePriority(
std::vector<std::shared_ptr<DrmFramebufferBase>> & inputVideoFbs,
std::shared_ptr<DrmFramebufferBase> & outputVideoFb) {
std::vector<uint32_t> videoPrioritys;
if (inputVideoFbs.empty())
return false;
for (auto it = inputVideoFbs.begin(); it != inputVideoFbs.end(); it ++) {
videoPrioritys.push_back((*it)->getVideoPriority() & 0xFFFF);
}
if (videoPrioritys.size() <= 1)
return false;
std::sort(videoPrioritys.begin(), videoPrioritys.end());
if (std::find((++videoPrioritys.begin()), videoPrioritys.end(),
*(videoPrioritys.begin())) != videoPrioritys.end()) {
return false;
}
std::map<uint32_t, std::shared_ptr<DrmFramebufferBase>, std::less<uint32_t>> bufferPrioritys;
for (auto it = inputVideoFbs.begin(); it != inputVideoFbs.end(); it ++) {
bufferPrioritys.insert(make_pair((*it)->getVideoPriority(), *it));
}
outputVideoFb = bufferPrioritys.begin()->second;
return true;
}
int CompositionStrategyBase::chooseOneVideoFb(
std::shared_ptr<DrmFramebufferBase> & outputVideoFb,
bool bVideoCompose) {
std::vector<std::shared_ptr<DrmFramebufferBase>> noOverlayFbs;
outputVideoFb.reset();
// no Video Fbs
if (mVideoComposerFbs.empty())
return -EINVAL;
if (!bVideoCompose) {
chooseOneVideoFbBaseVideoType(mVideoComposerFbs, outputVideoFb);
if (!outputVideoFb.get())
chooseOneVideoFbBaseBiggestWindow(mVideoComposerFbs, outputVideoFb);
} else {
bool bHavePriority = chooseOneVideoFbBasePriority(mVideoComposerFbs, outputVideoFb);
if (!bHavePriority) {
chooseVideoFbsBaseNoOverlap(mVideoComposerFbs, noOverlayFbs);
/* at least one buffer in noOverlayFbs vector */
if (noOverlayFbs.size() == 1) {
outputVideoFb = *noOverlayFbs.begin();
} else {
chooseOneVideoFbBaseVideoType(noOverlayFbs, outputVideoFb);
if (!outputVideoFb.get()) {
chooseOneVideoFbBaseBiggestWindow(noOverlayFbs, outputVideoFb);
}
}
}
}
if (outputVideoFb.get()) {
MESON_LOGV("[%s]: choose the fb (%s)", __func__, outputVideoFb->getDebugInfo());
deleteFbFromVectorFbs(mVideoComposerFbs, outputVideoFb);
}
return 0;
}
/*TODO: only one legacy sideband supported now if hw support sideband video */
int CompositionStrategyBase::chooseVideoFbFromLegacySideband(
std::vector<std::shared_ptr<DrmFramebufferBase>> & sidebandFbs,
std::shared_ptr<DrmFramebufferBase> & outputVideoFb) {
outputVideoFb = nullptr;
if (sidebandFbs.empty())
return 0;
auto it = sidebandFbs.begin();
if (!mIsSideBandDisable) {
outputVideoFb = (*it);
it ++;
}
for (; it != sidebandFbs.end(); it ++) {
MESON_LOGD("%s, too many legacy sideband, skip (%s)",
__func__, (*it)->getDebugInfo());
(*it)->setCompositionType(MESON_COMPOSITION_DUMMY);
}
return 0;
}
/*
* If all the 4 video meet the following requirements, then all of then can send to vd1.
* 1. each video is within its own 1/4 window
* 2. The horizontal border distance from each video to its 1/4 window must be equal
* 3. 4 video must be all afbc
* 4. The distance to the border must be a multiple of 8
* 5. only support when refresh rate <= 60hz
*/
bool CompositionStrategyBase::checkAndHandle4Mosaic(uint32_t videoZorder) {
if (!mMosaicEnabled)
return false;
// first check if hwc video plane (VD1) support mosaic feature
HwDisplayPlaneBase *plane = (HwDisplayPlaneBase *)(mHwcVideoPlanes[0].get());
if (!plane)
return false;
if (plane->isSupportMosaic() == false)
return false;
// mosaic need disable when output refresh rate > 60hz
if (mDisplayMode.refreshRate > DEFAULT_REFRESH_RATE)
return false;
// check 4 video playback
if (mVideoComposerFbs.empty() || mVideoComposerFbs.size() != 4)
return false;
std::shared_ptr<DrmFramebufferBase> fb;
uint32_t halfWidth = mDisplayMode.pixelW/2;
uint32_t halfHeight = mDisplayMode.pixelH/2;
// 2*2 mosaic check
int leftWindow = 0;
int topWindow = 0;
for (auto it = mVideoComposerFbs.begin(); it != mVideoComposerFbs.end(); it++) {
fb = *it;
drm_rect_t displayFrame = fb->getDisplayFrame();
uint32_t frameWidth = displayFrame.right - displayFrame.left;
uint32_t frameHeight = displayFrame.bottom - displayFrame.top;
// check all afbc
if (!(fb->getVideoType() & MESON_VIDEO_AFBC))
return false;
// check if the width and height <= 1/2 vinfo */
if (frameWidth > halfWidth || frameHeight > halfHeight)
return false;
// check the border distance
if (displayFrame.left < halfWidth) {
leftWindow++;
if (displayFrame.left != halfWidth - displayFrame.right)
return false;
// check border distance
if (displayFrame.left % 8 != 0)
return false;
} else {
if (displayFrame.left - halfWidth != mDisplayMode.pixelW - displayFrame.right)
return false;
// check border distance
if ((displayFrame.left - halfWidth) % 8 != 0)
return false;
}
if (displayFrame.top < halfHeight) {
topWindow++;
}
}
// check each video within its own 1/4 window
if (topWindow != leftWindow)
return false;
m4Mosaic = true;
/*set video composer*/
std::vector<std::shared_ptr<DrmFramebufferBase>> nofbs;
auto composer = mVideoComposers[0];
composer->prepare();
composer->addInputs(mVideoComposerFbs, nofbs, 0);
/*-----set buffer to displaypair------*/
mDisplayPairs.push_back(DisplayPair{
(uint32_t)mOsdPlaneNum, videoZorder, composer, mVideoComposerFbs, mHwcVideoPlanes[0]});
mHwcVideoPlanes.erase(mHwcVideoPlanes.begin());
mVideoComposers.erase(mVideoComposers.begin());
return true;
}
int CompositionStrategyBase:: processVideoFbs() {
bool bVideoCompose = false;
int videoFbNum = 0;
uint32_t usedPlanes = 0;
uint32_t minVideoZ = INVALID_ZORDER;
uint32_t maxVideoZ = INVALID_ZORDER;
uint32_t fbZorder = INVALID_ZORDER;
meson_composition_t compositionType = MESON_COMPOSITION_DUMMY;
drm_fb_type_t fbType = DRM_FB_UNDEFINED;
std::shared_ptr<DrmFramebufferBase> fb = nullptr;
std::vector<std::shared_ptr<DrmFramebufferBase>> sidebandFbs;
for (auto fbIt = mFramebuffers.begin(); fbIt != mFramebuffers.end(); ++fbIt) {
bool bSideband = false;
fb = fbIt->second;
/* skip dummy */
compositionType = (meson_composition_t)fb->getCompositionType();
if (compositionType == MESON_COMPOSITION_DUMMY)
continue;
fbType = fb->getFbType();
fbZorder = fb->getZorder();
switch (fbType) {
case DRM_FB_VIDEO_OVERLAY:
case DRM_FB_VIDEO_SIDEBAND:
case DRM_FB_VIDEO_SIDEBAND_TV:
bSideband = true;
[[clang::fallthrough]];
case DRM_FB_VIDEO_DMABUF:
case DRM_FB_VIDEO_UVM_DMA:
case DRM_FB_VIDEO_TUNNEL_SIDEBAND:
if (mHideVideoForHdcpDev) {
fb->setCompositionType(MESON_COMPOSITION_DUMMY);
break;
}
if (mVideoPlaneNum != 0) {
if (bSideband) {
sidebandFbs.push_back(fb);
} else if (fb->isBufferValidate()) {
mVideoComposerFbs.push_back(fb);
} else {
fb->setCompositionType(MESON_COMPOSITION_DUMMY);
continue;
}
} else {
fb->setCompositionType(MESON_COMPOSITION_DUMMY);
continue;
}
videoFbNum++;
if (minVideoZ == INVALID_ZORDER || fbZorder < minVideoZ)
minVideoZ = fbZorder;
if (maxVideoZ == INVALID_ZORDER || fbZorder > maxVideoZ)
maxVideoZ = fbZorder;
break;
default:
break;
};
}
/*
* Composition: only 1 + .. + N mode now
* For vd1:
* 1. sideband.
* 2. special video types: AFBC/DV/HDR/HDR10/HLG/SECURE/DIPOST.
* 3. no overlap & biggest one.
* For the last vd:
* 1. compose always happened on the last vd.
* 2. the last vd compose always output fullscreen buffer.
* 3. vd1 should on top of vd2 when have video composed.
*/
videoFbNum = (sidebandFbs.size() > 0 ? 1 : 0) + (videoFbNum - sidebandFbs.size());
bVideoCompose = videoFbNum > mVideoPlaneNum ? true : false;
if (!bVideoCompose) {
/*clear hold buffer resource*/
auto it = mVideoComposers.begin();
for (; it != mVideoComposers.end(); it++)
(*it)->prepare();
/* do not disable composer in here,
* disable composer need after disable video plane */
}
if (videoFbNum == 0) return 0;
fb.reset();
chooseVideoFbFromLegacySideband(sidebandFbs, fb);
sidebandFbs.clear();
if (fb.get()) {
/* have legacy sideband video need to display */
if (mVideoPlaneNum == 1) {
mDisplayPairs.push_back(DisplayPair{
(uint32_t)mOsdPlaneNum, fb->getZorder(), nullptr, {fb}, mHwcVideoPlanes[0]});
fb->setCompositionType(MESON_COMPOSITION_PLANE_HWCVIDEO);
if (mVideoComposerFbs.size() > 0) {
for (auto it = mVideoComposerFbs.begin(); it != mVideoComposerFbs.end(); it++)
(*it)->setCompositionType(MESON_COMPOSITION_DUMMY);
}
mHwcVideoPlanes.erase(mHwcVideoPlanes.begin());
return 0;
}
} else if (checkAndHandle4Mosaic(minVideoZ)) {
/* there are no legacy sideband video */
return 0;
} else if (mForceVideoComposer) {
/*set video to composer, only support V2D composer */
std::vector<std::shared_ptr<DrmFramebufferBase>> nofbs;
auto composer = mVideoComposers[0];
composer->prepare();
composer->addInputs(mVideoComposerFbs, nofbs, 1);
/*-----set buffer to displaypair------*/
mDisplayPairs.push_back(DisplayPair{(uint32_t)mOsdPlaneNum,
minVideoZ, composer, mVideoComposerFbs, mHwcVideoPlanes[0]});
mHwcVideoPlanes.erase(mHwcVideoPlanes.begin());
mVideoComposers.erase(mVideoComposers.begin());
return 0;
}
for (int i = 0; i < videoFbNum; i++) {
std::vector<std::shared_ptr<DrmFramebufferBase>> nofbs;
std::vector<std::shared_ptr<DrmFramebufferBase>> inputFbs;
std::shared_ptr<IComposer> composer = nullptr;
if (mIsVideoComposerV2D) {
composer = mVideoComposers[usedPlanes];
composer->prepare();
}
usedPlanes++;
/* Fbs set to the last hwcVideoPlane */
if (i >= mVideoPlaneNum - 1) {
if (mVideoComposerFbs.size() > 0) {
if (bVideoCompose) {
/* make sure Z-Order of the last VD is the minimum */
fbZorder = minVideoZ;
if (!composer.get()) {
/* composer is MESON_COMPOSITION_DI*/
composer = mVideoComposers[0];
composer->prepare();
}
/*set dicomposer and get output video.*/
composer->addInputs(mVideoComposerFbs, nofbs, i);
/*-----set buffer to displaypair------*/
mDisplayPairs.push_back(DisplayPair{(uint32_t)mOsdPlaneNum + i,
fbZorder, composer, mVideoComposerFbs, mHwcVideoPlanes[i]});
} else {
fb = *mVideoComposerFbs.begin();
fbZorder = fb->getZorder();
fb->setCompositionType(MESON_COMPOSITION_PLANE_HWCVIDEO);
inputFbs.push_back(fb);
if (composer.get())
composer->addInputs(inputFbs, nofbs);
/*-----set buffer to displaypair------*/
mDisplayPairs.push_back(DisplayPair{(uint32_t)mOsdPlaneNum + i,
fbZorder, composer, inputFbs, mHwcVideoPlanes[i]});
}
}
break;
}
if (!fb.get()) {
chooseOneVideoFb(fb, bVideoCompose);
if (!fb.get())
return 0;
}
fb->setCompositionType(MESON_COMPOSITION_PLANE_HWCVIDEO);
if (bVideoCompose) {
/* make sure Z-Order of the last VD is the minimum */
fbZorder = fb->getZorder() + 1;
} else {
fbZorder = fb->getZorder();
}
inputFbs.push_back(fb);
if (composer.get())
composer->addInputs(inputFbs, nofbs);
mDisplayPairs.push_back(DisplayPair{
(uint32_t)mOsdPlaneNum + i, fbZorder, composer, inputFbs, mHwcVideoPlanes[i]});
fb.reset();
}
/* removed used planes from mHwcVideoPlanes */
for (uint32_t i = 0; i < usedPlanes; i++)
mHwcVideoPlanes.erase(mHwcVideoPlanes.begin());
/* removed used videoComposer from mVideoComposers */
if (mIsVideoComposerV2D) {
for (uint32_t i = 0; i < usedPlanes; i++)
mVideoComposers.erase(mVideoComposers.begin());
} else if (bVideoCompose) {
mVideoComposers.clear();
} else {
// nothing to do;
}
return 0;
}
/* Apply flag with secure and forceClient Fbs. */
int CompositionStrategyBase::applyCompositionFlags() {
if (!mHideSecureLayer && !mForceClientComposer) {
return 0;
}
std::shared_ptr<DrmFramebufferBase> fb;
auto fbIt = mFramebuffers.begin();
for (; fbIt != mFramebuffers.end(); ++fbIt) {
fb = fbIt->second;
if (fb->getCompositionType() == MESON_COMPOSITION_UNDETERMINED) {
if (mHideSecureLayer && fb->getSecureFlag()) {
fb->setCompositionType(MESON_COMPOSITION_DUMMY);
} else if (mForceClientComposer) {
fb->setCompositionType(MESON_COMPOSITION_CLIENT);
}
}
}
return 0;
}
int CompositionStrategyBase::processGfxFbs() {
/* Remove dummy and video Fbs for later osd composition.
* Pickout OSD Fbs.
* Save client flag.
*/
pickoutOsdFbs();
if (!mInsideVideoFbsFlag) {
handleOsdComposition();
} else {
handleOsdCompositionWithVideo();
}
/* record overlayFbs and start to compose */
if (mComposer.get()) {
mComposer->prepare();
mComposer->addInputs(mComposerFbs, mOverlayFbs);
}
return 0;
}
/* Delete dummy and video Fbs, then pickout OSD Fbs. */
int CompositionStrategyBase::pickoutOsdFbs() {
std::shared_ptr<DrmFramebufferBase> fb;
std::vector<std::shared_ptr<DrmFramebufferBase>> dummyFbs;
bool bRemove = false;
bool bClientLayer = false;
bool mHaveVirLayer = false;
uint32_t fbZorder = -1;
meson_composition_t compositionType = MESON_COMPOSITION_DUMMY;
auto fbIt = mFramebuffers.begin();
for (; fbIt != mFramebuffers.end(); ) {
fb = fbIt->second;
bRemove = false;
bClientLayer = false;
if (!fb->isBufferValidate())
fb->setCompositionType(MESON_COMPOSITION_DUMMY);
compositionType = (meson_composition_t)fb->getCompositionType();
fbZorder = fb->getZorder();
switch (compositionType) {
case MESON_COMPOSITION_DUMMY:
dummyFbs.push_back(fb);
bRemove = true;
break;
case MESON_COMPOSITION_PLANE_HWCVIDEO:
case MESON_COMPOSITION_DI:
case MESON_COMPOSITION_V2D:
MESON_LOGV("collect overlay fb (%s)", fb->getDebugInfo());
mOverlayFbs.push_back(fb);
bRemove = true;
break;
case MESON_COMPOSITION_CLIENT:
mHaveClient = true;
bClientLayer = true;
[[clang::fallthrough]];
case MESON_COMPOSITION_UNDETERMINED:
{
if (mOsdPlaneNum == 0) {
fb->setCompositionType(MESON_COMPOSITION_DUMMY);
dummyFbs.push_back(fb);
bRemove = true;
break;
}
if (bClientLayer || !hasPlaneSupport(fb)) {
if (mMinComposerZorder == INVALID_ZORDER ||
mMaxComposerZorder == INVALID_ZORDER) {
mMinComposerZorder = fbZorder;
mMaxComposerZorder = fbZorder;
} else {
if (mMinComposerZorder > fbZorder)
mMinComposerZorder = fbZorder;
if (mMaxComposerZorder < fbZorder)
mMaxComposerZorder = fbZorder;
}
}
}
break;
default:
MESON_LOGE("Unknown composition type %s",
compositionTypeToString(fb->getCompositionType()));
bRemove = true;
break;
}
if (bRemove)
fbIt = mFramebuffers.erase(fbIt);
else
++ fbIt;
}
if (dummyFbs.size() > 0) {
std::vector<std::shared_ptr<DrmFramebufferBase>> dummyOverlayFbs;
if (mDummyComposer.get())
mDummyComposer->addInputs(dummyFbs, dummyOverlayFbs);
}
/* Only support one legacy video in current times. */
#if ENABLE_LEGACY_VIDEO
if (!mOverlayFbs.empty() && !mFramebuffers.empty()) {
auto osdFbIt = mFramebuffers.begin();
uint32_t minOsdFbZorder = osdFbIt->second->getZorder();
/* Current only input one Legacy video fb. */
std::shared_ptr<DrmFramebufferBase> legacyVideoFb = *(mOverlayFbs.begin());
if (legacyVideoFb->getZorder() > minOsdFbZorder) {
mMinComposerZorder = mFramebuffers.begin()->second->getZorder();
/* Legacy video is always on the bottom.
* SO, all fbs below legacyVideo zorder need to compose.
* Set maxClientZorder = legacyVideoZorder
*/
if (mMaxComposerZorder == INVALID_ZORDER || legacyVideoFb->getZorder() > mMaxComposerZorder) {
mMaxComposerZorder = legacyVideoFb->getZorder();
}
}
}
#else // If only one legacy video in current times, don't need to check inside video flag.
/* 1. check mInsideVideoFbsFlag = false
* 2. for HDR mode, adjust compose range.
*/
if (!mOverlayFbs.empty() && !mFramebuffers.empty()) {
bool bVideoCompose = mOverlayFbs.size() > 2 ? true : false;
auto uiFbIt = mFramebuffers.begin();
uint32_t uiFbMinZorder = uiFbIt->second->getZorder();
uiFbIt = mFramebuffers.end();
uiFbIt --;
uint32_t uiFbMaxZorder = uiFbIt->second->getZorder();
int videoOnTop = 0;
for (auto videoFbIt = mOverlayFbs.begin(); videoFbIt != mOverlayFbs.end(); ) {
std::shared_ptr<DrmFramebufferBase> videoFb = *videoFbIt;
fbZorder = videoFb->getZorder();
if (fbZorder >= uiFbMinZorder && fbZorder <= uiFbMaxZorder) {
if (mHDRMode || bVideoCompose) {
/* For hdr composition: it's hw limit.
* video should top or bottom.
* when video layer is not top, make all the lower framebuffers composed.
* For fixed planemode, video is always bottom.
*/
mMinComposerZorder = mFramebuffers.begin()->second->getZorder();
if (mMaxComposerZorder == INVALID_ZORDER || fbZorder > mMaxComposerZorder) {
mMaxComposerZorder = fbZorder;
}
} else {
mInsideVideoFbsFlag = true;
}
++videoFbIt;
} else {
/*only one video on top of ui */
if (fbZorder > uiFbMaxZorder) {
if (videoOnTop >= 1 || bVideoCompose) {
++videoFbIt;
continue;
}
videoOnTop ++;
}
MESON_LOGV("%s remove overlay fb (%s)", __func__, videoFb->getDebugInfo());
videoFbIt = mOverlayFbs.erase(videoFbIt);
}
}
}
#endif
return 0;
}
bool CompositionStrategyBase::hasPlaneSupport(std::shared_ptr<DrmFramebufferBase> fb) {
for (const auto& plane : mOsdPlanes) {
if (plane && plane->isFbSupport(fb)) {
return true;
}
}
return false;
}
bool CompositionStrategyBase::tryAllocate(int idx, const std::vector<std::shared_ptr<DrmFramebufferBase>>& layers,
std::vector<std::shared_ptr<HwDisplayPlaneBase>>& planes, std::vector<bool>& usablePlanes,
std::unordered_map<uint32_t, uint32_t>& results) {
if (idx == layers.size()) {
return true;
}
const auto& curLayer = layers[idx];
for (int i = 0; i < planes.size(); ++i) {
if (!usablePlanes[i] && planes[i]->isFbSupport(curLayer)) {
usablePlanes[i] = true;
results[curLayer->getZorder()] = planes[i]->getId();
if (tryAllocate(idx + 1, layers, planes, usablePlanes, results)) {
return true;
}
results.erase(curLayer->getZorder());
usablePlanes[i] = false;
}
}
return false;
}
void CompositionStrategyBase::decidePlaneAssignment() {
mLayerAssignment.clear();
if (mFramebuffers.empty()) {
MESON_LOGV("%s No framebuffers available for plane assignment", __func__);
return;
}
while (true) {
std::vector<std::shared_ptr<DrmFramebufferBase>> targetLayers;
std::vector<std::shared_ptr<HwDisplayPlaneBase>> availablePlanes;
//Step1: Collect layers that require device composition into targetLayers.
if (mMinComposerZorder == INVALID_ZORDER && mMaxComposerZorder == INVALID_ZORDER) {
targetLayers.reserve(mFramebuffers.size());
for (const auto& [zorder, buf] : mFramebuffers) {
targetLayers.push_back(buf);
}
} else {
for (const auto& [zorder, buf] : mFramebuffers) {
if (zorder < mMinComposerZorder || zorder > mMaxComposerZorder) {
targetLayers.push_back(buf);
}
}
}
//Step2: Collect available planes based on whether client composition is required;
//if client composition is involved, reserve the primary plane.
bool hasClient = mMinComposerZorder != INVALID_ZORDER && mMaxComposerZorder != INVALID_ZORDER;
for (const auto& plane : mOsdPlanes) {
if (hasClient) {
if (!(plane->getCapabilities() & PLANE_PRIMARY)) {
availablePlanes.push_back(plane);
}
} else {
availablePlanes.push_back(plane);
}
}
//Step3: Attempt to assign the layer to a plane. If successful, break the loop;
//otherwise, expand the search scope and retry.
std::vector<bool> usablePlanes(availablePlanes.size(), false);
if (tryAllocate(0, targetLayers, availablePlanes, usablePlanes, mLayerAssignment)) {
break;
}
//Step4 :Fall back to client composition for more layers if plane assignment fails.
bool expanded = false;
if (mMinComposerZorder == INVALID_ZORDER || mMaxComposerZorder == INVALID_ZORDER) {
mMinComposerZorder = mFramebuffers.begin()->first;
mMaxComposerZorder = mFramebuffers.begin()->first;
expanded = true;
} else {
auto itUpper = mFramebuffers.upper_bound(mMaxComposerZorder);
auto itLower = mFramebuffers.lower_bound(mMinComposerZorder);
//Since the whiteboard layer is on top, prioritize expanding
//the client-side compositing range downward.
if (itLower != mFramebuffers.begin()) {
--itLower;
mMinComposerZorder = itLower->first;
expanded = true;
} else if (itUpper != mFramebuffers.end()){
mMaxComposerZorder = itUpper->first;
expanded = true;
}
}
if (!expanded) {
// Fallback solution: full GPU composition.
mMinComposerZorder = mFramebuffers.begin()->first;
mMaxComposerZorder = mFramebuffers.rbegin()->first;
mLayerAssignment.clear();
MESON_LOGV("%s: Final fallback to full GPU composition", __func__);
break;
}
}
if (mMaxComposerZorder != INVALID_ZORDER &&
mMinComposerZorder != INVALID_ZORDER) {
/*will use compose fb as reffb.*/
return ;
}
/*select base fb and set base scale info.*/
int32_t minXOffset = -1, minYOffset = -1;
int32_t compositionTargetW = 0, compositionTargetH = 0;
for (auto it = mFramebuffers.begin(); it != mFramebuffers.end(); it++) {
drm_rect_t dispFrame = it->second->getDisplayFrame();
if (minXOffset == -1 || minXOffset > dispFrame.left)
minXOffset = dispFrame.left;
if (minYOffset == -1 || minYOffset > dispFrame.top)
minYOffset = dispFrame.top;
if (dispFrame.right > compositionTargetW)
compositionTargetW = dispFrame.right;
if (dispFrame.bottom > compositionTargetH)
compositionTargetH = dispFrame.bottom;
}
/*choose base fb, the scale is smallest bigger.*/
compositionTargetW = compositionTargetW - minXOffset;
compositionTargetH = compositionTargetH - minYOffset;
drm_rect_t scaleInput = {0, 0,
OSD_SCALER_INPUT_MAX_WIDTH, OSD_SCALER_INPUT_MAX_HEIGHT};
drm_rect_t scaleOutput = {0, 0, compositionTargetW, compositionTargetH};
if (1 == mFramebuffers.size()) {
if (!mDisplayRefFb)
mDisplayRefFb = mFramebuffers.begin()->second;
} else {
/*choose the scale > targetW/MAX_INPUT*/
for (auto it = mFramebuffers.begin(); it != mFramebuffers.end(); it++) {
std::shared_ptr<DrmFramebufferBase> fb = it->second;
drm_rect_t dispFrame = fb->getDisplayFrame();
drm_rect_t sourceCrop = fb->getSourceCrop();
drm_rect_t refDispFrame;
drm_rect_t refSourceCrop;
int32_t ret = compareFbScale(sourceCrop, dispFrame, scaleInput, scaleOutput);
if (0 == ret) {
mDisplayRefFb = fb;
break;
} else if (1 == ret) {
if (!mDisplayRefFb)
mDisplayRefFb = fb;
else {
refDispFrame = mDisplayRefFb->getDisplayFrame();
refSourceCrop = mDisplayRefFb->getSourceCrop();
if (-1 == compareFbScale(sourceCrop, dispFrame,
refSourceCrop, refDispFrame)) {
mDisplayRefFb = fb;
}
}
}
}
}
/*no suitable fb, we need do composition*/
if (!mDisplayRefFb) {
/* All Scale Fbs and no default composer range, select begin Fbs to composer. */
mMinComposerZorder = mFramebuffers.begin()->second->getZorder();
mMaxComposerZorder = mMinComposerZorder;
} else {
/*set display offset, the offset will be updated when commit() if reffb is composed*/
mOsdDisplayFrame.crtc_display_x = minXOffset;
mOsdDisplayFrame.crtc_display_y = minYOffset;
}
}
/*Count below, inside and up client Fbs number.
********************************************************************
** *
** |----------------------- *
** upClientNum--{----------------------- *
** |----------------------- *
** ----maxClientZorder----| *
** -----------------------} --insideClientNum *
** ----minClientZorder----| *
** |----------------------- *
** belowClientNum--{----------------------- *
** |----------------------- *
** *
********************************************************************
*/
int CompositionStrategyBase::countComposerFbs(int &belowClientNum, int &upClientNum, int &insideClientNum) {
uint32_t fbZorder = -1;
if (mMinComposerZorder == INVALID_ZORDER) {
belowClientNum = 0;
upClientNum = 0;
insideClientNum = 0;
return 0;
}
std::shared_ptr<DrmFramebufferBase> fb;
auto fbIt = mFramebuffers.begin();
for (; fbIt != mFramebuffers.end(); ++fbIt) {
fb = fbIt->second;
fbZorder = fb->getZorder();
if (fbZorder < mMinComposerZorder)
belowClientNum++;
else if (fbZorder > mMaxComposerZorder)
upClientNum++;
else
insideClientNum++;
}
return 1;
}
int CompositionStrategyBase::confirmComposerRange() {
std::shared_ptr<DrmFramebufferBase> fb;
uint32_t osdFbsNum = mFramebuffers.size();
uint32_t osdPlanesNum = mOsdPlanes.size();
int belowClientNum = 0;
int upClientNum = 0;
int insideClientNum = 0;
if (osdFbsNum == 0 || osdPlanesNum == 0) {
return 0;
}
int ret = countComposerFbs(belowClientNum, upClientNum, insideClientNum);
UNUSED(ret);
if (osdFbsNum > osdPlanesNum) { // CASE 1: osdFbsNum > osdPlanesNum , need compose more fbs.*/
/* CASE 1_1: mMinComposerZorder != INVALID_ZORDER, need do compose. */
int minNeedComposedFbs = osdFbsNum - insideClientNum - osdPlanesNum + 1; // minimum OSD Fbs need to be composered
if (mMinComposerZorder != INVALID_ZORDER) {
/* If minNeedComposedFbs = 0, use client range to compose */
if (minNeedComposedFbs > 0) {
/* compose more fbs from minimum zorder first. */
auto fbIt = mFramebuffers.begin();
if (belowClientNum > 0 && minNeedComposedFbs <= belowClientNum) {
int noComposedFbs = belowClientNum - minNeedComposedFbs;
if (noComposedFbs > 0) {
for (; fbIt != mFramebuffers.end(); ++fbIt) {
noComposedFbs -- ;
if (noComposedFbs < 0)
break;
}
}
minNeedComposedFbs = 0;
} else {
minNeedComposedFbs -= belowClientNum;
}
/* confirm the minimum zorder value. */
if (fbIt != mFramebuffers.end())
mMinComposerZorder = fbIt->second->getZorder();
/* compose fb from maximum zorder. */
if (minNeedComposedFbs > 0) {
MESON_ASSERT(upClientNum > 0, "upClientNum should > 0.");
fbIt = mFramebuffers.upper_bound(mMaxComposerZorder);
for (; fbIt != mFramebuffers.end(); ++ fbIt) {
minNeedComposedFbs --;
if (minNeedComposedFbs <= 0)
break;
}
/* we can confirm the maximum zorder value. */
if (fbIt != mFramebuffers.end())
mMaxComposerZorder = fbIt->second->getZorder();
}
}
} else {
/* CASE 1_2: no fb set to compose before, free to choose new fbs to compose */
int countComposerFbs = 0;
for (auto it = mFramebuffers.begin(); it != mFramebuffers.end(); ++it) {
fb = it->second;
countComposerFbs++;
if (countComposerFbs == minNeedComposedFbs) {
mMaxComposerZorder = fb->getZorder();
mMinComposerZorder = (mFramebuffers.begin()->second)->getZorder();
break;
}
}
}
}
return 0;
}
int32_t CompositionStrategyBase::compareFbScale(
drm_rect_t & aSrc,
drm_rect_t & aDst,
drm_rect_t & bSrc,
drm_rect_t & bDst) {
int32_t aDisplayWidth = aDst.right - aDst.left;
int32_t aDisplayHeight = aDst.bottom - aDst.top;
int32_t aSrcWidth = aSrc.right - aSrc.left;
int32_t aSrcHeight = aSrc.bottom - aSrc.top;
int32_t bDisplayWidth = bDst.right - bDst.left;
int32_t bDisplayHeight = bDst.bottom - bDst.top;
int32_t bSrcWidth = bSrc.right - bSrc.left;
int32_t bSrcHeight = bSrc.bottom - bSrc.top;
int widthCompare = aDisplayWidth*bSrcWidth - bDisplayWidth*aSrcWidth;
int heightCompare = aDisplayHeight *bSrcHeight - bDisplayHeight * aSrcHeight;
if (widthCompare == 0 && heightCompare == 0)
return 0;
else if (widthCompare > 0 && heightCompare > 0)
return 1;
else {
//MESON_LOGW("compareFbScale failed %d ,%d, %d, %d",
//widthCompare, heightCompare,
//bDisplayWidth, bDisplayHeight);
return -1;
}
}
/* Set DisplayPairs between UI(OSD) Fbs with plane. */
int CompositionStrategyBase::setOsdFbs2PlanePairs() {
if (mFramebuffers.size() == 0)
return 0;
std::shared_ptr<HwDisplayPlaneBase> osdTemp;
for (uint32_t i = 1; i < mOsdPlanes.size(); i++) {
if (mOsdPlanes[i]->getCapabilities() & PLANE_PRIMARY) {
osdTemp = mOsdPlanes[0];
mOsdPlanes[0] = mOsdPlanes[i];
mOsdPlanes[i] = osdTemp;
break;
}
}
uint32_t usedPlanes = 0;
if (mDisplayRefFb.get()) {
/*baseFb always post to din0*/
mDisplayPairs.push_back(
DisplayPair{usedPlanes, mDisplayRefFb->getZorder(), nullptr, {mDisplayRefFb}, mOsdPlanes[usedPlanes]});
/* Not composed fb, set to osd composition. */
if (mDisplayRefFb->getCompositionType() == MESON_COMPOSITION_UNDETERMINED)
mDisplayRefFb->setCompositionType(MESON_COMPOSITION_PLANE_OSD);
}
for (auto fbIt = mFramebuffers.begin(); fbIt != mFramebuffers.end(); ++fbIt) {
std::shared_ptr<DrmFramebufferBase> fb = fbIt->second;
if (fb == mDisplayRefFb)
continue;
/* fb is unscaled or is represent of composer output,
* we pick primary display.
*/
/* Pick any available plane */
if (usedPlanes != mOsdPlanes.size() - 1) {
usedPlanes++;
}
std::shared_ptr<HwDisplayPlaneBase> targetPlane = nullptr;
auto it = mLayerAssignment.find(fb->getZorder());
if (it != mLayerAssignment.end()) {
uint32_t targetId = it->second;
auto planeIt = std::find_if(mOsdPlanes.begin(), mOsdPlanes.end(),
[targetId](const auto& p) { return p->getId() == targetId; });
if (planeIt != mOsdPlanes.end()) {
targetPlane = *planeIt;
}
}
if (targetPlane != nullptr) {
mDisplayPairs.push_back(
DisplayPair{usedPlanes, fb->getZorder(), nullptr, {fb}, targetPlane});
} else {
MESON_LOGD("%s: Skip adding FB (Zorder: %u) to DisplayPairs", __func__, fb->getZorder());
}
/* Not composed fb, set to osd composition. */
if (fb->getCompositionType() == MESON_COMPOSITION_UNDETERMINED)
fb->setCompositionType(MESON_COMPOSITION_PLANE_OSD);
}
/* removed used planes from mOsdPlanes */
for (uint32_t i = 0; i <= usedPlanes; i++) {
mOsdPlanes.erase(mOsdPlanes.begin());
}
return 0;
}
/* Select composer */
int CompositionStrategyBase::selectComposer() {
if (mComposerFbs.size() == 0) {
if (mClientComposer.get())
mClientComposer->prepare();
return 0;
}
if (!mHaveClient) {
auto composerIt = mOtherComposers.begin();
for (; composerIt != mOtherComposers.end(); ++composerIt) {
if ((*composerIt)->isFbsSupport(mComposerFbs, mOverlayFbs)) {
mComposer = *composerIt;
break;
}
}
}
if (mComposer.get() == NULL)
mComposer = mClientComposer;
if (!mComposer.get())
return 0;
/* set composed fb composition type */
for (auto it = mComposerFbs.begin(); it != mComposerFbs.end(); ++it) {
(*it)->setCompositionType(mComposer->getType());
}
return 0;
}
/* Find out which fb need to compose and push DisplayPair */
int CompositionStrategyBase::fillComposerFbs() {
std::shared_ptr<DrmFramebufferBase> fb;
if (mMaxComposerZorder != INVALID_ZORDER &&
mMinComposerZorder != INVALID_ZORDER) {
auto fbIt = mFramebuffers.begin();
auto lastComposeFbIt = mFramebuffers.end();
while (fbIt != mFramebuffers.end()) {
fb = fbIt->second;
if (IS_FB_COMPOSED(fb)) {
mComposerFbs.push_back(fb);
if (lastComposeFbIt != mFramebuffers.end()) {
mFramebuffers.erase(lastComposeFbIt);
}
lastComposeFbIt = fbIt;
}
++ fbIt;
}
MESON_ASSERT(lastComposeFbIt != mFramebuffers.end(), "no last composer fb !");
MESON_ASSERT(mDisplayRefFb.get() == NULL, "reffb should be NULL.");
mDisplayRefFb = lastComposeFbIt->second;
}
for (auto videoFbIt = mOverlayFbs.begin(); videoFbIt != mOverlayFbs.end();) {
std::shared_ptr<DrmFramebufferBase> videoFb = *videoFbIt;
if (IS_FB_COMPOSED(videoFb)) {
++videoFbIt;
} else {
MESON_LOGV("%s remove overlay fb (%s)", __func__, videoFb->getDebugInfo());
videoFbIt = mOverlayFbs.erase(videoFbIt);
}
}
return 0;
}
/* Update present zorder.
* If videoZ ~ (mMinComposerZorder, mMaxComposerZorder), set maxVideoZ = maxVideoZ - 1
*/
void CompositionStrategyBase::handleOverlayVideoZorder() {
auto it = mDisplayPairs.begin();
for (; it != mDisplayPairs.end(); ++it) {
auto fbIt = it->fbs.begin();
for (; fbIt != it->fbs.end(); fbIt++) {
if (IS_FB_COMPOSED((*fbIt))) {
it->presentZorder = it->presentZorder - 1;
}
}
}
}
void CompositionStrategyBase::handleVPUOddScaleLimit() {
drm_rect_t sourceCrop = {0, 0, 0,0};
uint32_t fbZorder = 0;
if (!(mCrtc->getWrFlag() & (1 << (int32_t) MesonDrmWrId::GFCD_ODD_SIZE))) {
return;
}
if (mFramebuffers.size() <= 1) {
return;
}
int deviceNum = 0;
int clientNum = 0;
bool oddInput = false;
std::shared_ptr<DrmFramebufferBase> scaleFb;
for (auto fbIt = mFramebuffers.begin(); fbIt != mFramebuffers.end(); ++fbIt) {
auto fb = fbIt->second;
sourceCrop = fb->getSourceCrop();
if ((sourceCrop.right - sourceCrop.left) % 2 != 0) {
oddInput = true;
}
// osdComposed layers
fbZorder = fb->getZorder();
if (fbZorder < mMinComposerZorder || fbZorder > mMaxComposerZorder) {
scaleFb = fb;
deviceNum++;
} else {
clientNum++;
}
}
// no device Composition or no odd input , no need check
if (deviceNum == 0 || !oddInput) {
return;
}
drm_rect_t scaleInput = {0,0,0,0};
drm_rect_t scaleOutput = {0, 0, 0,0};
// has Client composition
if (clientNum != 0) {
// input width is not odd
if (!scaleFb) {
sourceCrop = scaleFb->getSourceCrop();
if ((sourceCrop.right - sourceCrop.left) % 2 == 0) {
return;
}
}
scaleInput = {0, 0, mOsdDisplayFrame.framebuffer_w, mOsdDisplayFrame.framebuffer_h};
scaleOutput = {mOsdDisplayFrame.crtc_display_x, mOsdDisplayFrame.crtc_display_y,
mOsdDisplayFrame.crtc_display_w, mOsdDisplayFrame.crtc_display_h};
// all device compostion
} else {
auto firstIt = mFramebuffers.begin();
auto secondIt = std::next(firstIt);
if (secondIt == mFramebuffers.end()) {
return;
}
scaleInput = secondIt->second->getSourceCrop();
scaleOutput = secondIt->second->getDisplayFrame();
scaleFb = firstIt->second;
}
// need check the scale limit
drm_rect_t scaleDispFrame = scaleFb->getDisplayFrame();
sourceCrop = scaleFb->getSourceCrop();
auto scaleRet = compareFbScale(sourceCrop, scaleDispFrame, scaleInput, scaleOutput);
// force to Client compose
if (scaleRet != 0) {
for (auto fbIt = mFramebuffers.begin(); fbIt != mFramebuffers.end(); ++fbIt) {
auto fb = fbIt->second;
fbZorder = fb->getZorder();
if (mMinComposerZorder == INVALID_ZORDER || mMinComposerZorder > fbZorder) {
mMinComposerZorder = fbZorder;
}
if (mMaxComposerZorder == INVALID_ZORDER || mMaxComposerZorder < fbZorder) {
mMaxComposerZorder = fbZorder;
}
}
}
}
/*
* Scale Limitation:
* 1. VPU only support composed 2 non afbc osd layers
* 2. For afbc layers, exp_h = SourceFrame_height * 1/3 * 1.1;
* when DisplayFrame_height < exp_h then only support two layers.
*/
void CompositionStrategyBase::handleVPUScaleLimit() {
uint32_t nonAfbcFbsNumb = 0;
uint32_t limitCount = 0;
int belowClientNum = 0;
int upClientNum = 0;
int insideClientNum = 0;
std::shared_ptr<DrmFramebufferBase> fb;
for (auto fbIt = mFramebuffers.begin(); fbIt != mFramebuffers.end(); ++fbIt) {
fb = fbIt->second;
float scaleLimit = DebugHelper::getInstance().getScaleLimit();
if (scaleLimit == 0)
scaleLimit = OSD_SCALER_INPUT_MARGIN / OSD_SCALER_INPUT_FACTOR;
drm_rect_t dispFrame = fb->getDisplayFrame();
drm_rect_t sourceCrop = fb->getSourceCrop();
uint32_t fbZorder = fb->getZorder();
float expHeight = (sourceCrop.bottom - sourceCrop.top) * scaleLimit;
float dispHeight = (dispFrame.bottom - dispFrame.top) * mScaleValue;
/* osdComposed layers */
if (fbZorder < mMinComposerZorder || fbZorder > mMaxComposerZorder) {
/* it is non afbc layer */
if (!fb->isAfbcBuffer()) {
nonAfbcFbsNumb++;
}
if (expHeight > dispHeight) {
limitCount++;
if (fbZorder > mMaxComposerZorder)
upClientNum++;
else
belowClientNum++;
}
} else {
insideClientNum++;
}
}
/* minus one layer for VPU composer */
if (limitCount >= 1 || nonAfbcFbsNumb > 2) {
if (upClientNum > 0) {
auto fbIt = mFramebuffers.upper_bound(mMaxComposerZorder);
if (fbIt != mFramebuffers.end())
mMaxComposerZorder = fbIt->second->getZorder();
} else if (belowClientNum > 0) {
if (mMinComposerZorder == INVALID_ZORDER) {
/* free to select one */
mMinComposerZorder = mFramebuffers.begin()->second->getZorder();
mMaxComposerZorder = mMinComposerZorder;
} else {
auto fbIt = mFramebuffers.lower_bound(mMinComposerZorder);
if (fbIt != mFramebuffers.begin() && fbIt != mFramebuffers.end()) {
fbIt--;
mMinComposerZorder = fbIt->second->getZorder();
}
}
}
}
}
/*
Limitation:
1. scale input should smaller than 1080P.
2. din0 should input the base fb.
*/
void CompositionStrategyBase::handleVPULimit(bool video) {
UNUSED(video);
//MESON_ASSERT(video == false, "handleVPULimit havenot support video");
if (mFramebuffers.size() == 0)
return ;
handleVPUScaleLimit();
handleVPUOddScaleLimit();
}
void CompositionStrategyBase::handleDisplayLayerZorder() {
int topVideoNum = 0;
uint32_t maxOsdZorder = INVALID_ZORDER;
for (auto it = mDisplayPairs.begin(); it != mDisplayPairs.end(); ++it) {
std::shared_ptr<HwDisplayPlaneBase> plane = it->plane;
if (OSD_PLANE == plane->getType()) {
if (maxOsdZorder == INVALID_ZORDER) {
maxOsdZorder = it->presentZorder;
} else {
if (maxOsdZorder < it->presentZorder)
maxOsdZorder = it->presentZorder;
}
it->presentZorder = it->presentZorder + OSD_FB_BEGIN_ZORDER; // osd zorder: 65 - 128
}
}
for (auto it = mDisplayPairs.begin(); it != mDisplayPairs.end(); ++it) {
std::shared_ptr<HwDisplayPlaneBase> plane = it->plane;
std::shared_ptr<DrmFramebufferBase> fb = *(it->fbs.begin());
if (HWC_VIDEO_PLANE == plane->getType() ||
DRM_VIDEO_PLANE == plane->getType()) {
if (fb->getZorder() > maxOsdZorder && topVideoNum != 1) {
it->presentZorder = it->presentZorder + TOP_VIDEO_FB_BEGIN_ZORDER; // top video zorder: 129 - 192
topVideoNum++;
} else {
it->presentZorder = it->presentZorder + BOTTOM_VIDEO_FB_BEGIN_ZORDER; // bottom video zorder: 1 - 64
}
#if ENABLE_LEGACY_VIDEO
/* legacy video need on bottom */
if (it->presentZorder >= TOP_VIDEO_FB_BEGIN_ZORDER)
it->presentZorder -= (TOP_VIDEO_FB_BEGIN_ZORDER - BOTTOM_VIDEO_FB_BEGIN_ZORDER);
#else
/* keep top video when only one video commit
* tmp solution for SWPL-116333
* */
if (mDisplayPairs.size() == 1)
it->presentZorder = it->presentZorder + TOP_VIDEO_FB_BEGIN_ZORDER;
#if KEEP_VIDEO_BOTTOM
if (it->presentZorder >= TOP_VIDEO_FB_BEGIN_ZORDER)
it->presentZorder -= (TOP_VIDEO_FB_BEGIN_ZORDER - BOTTOM_VIDEO_FB_BEGIN_ZORDER);
#endif
#endif
}
}
}
/* Handle OSD Fbs and set OsdFbs2Plane pairs. */
int CompositionStrategyBase::handleOsdComposition() {
/* Step 1:
* Judge whether compose or not.
* If need to compose, confirm max/min client zorder.
*/
confirmComposerRange();
handleVPULimit(false);
decidePlaneAssignment();
/* Step 2:
* Push composers to cache mComposerFbs to build OSD2Plane pair.
*/
fillComposerFbs();
/* Step 3:
* Select composer.
*/
selectComposer();
/* Step 4:
* Set DisplayPairs between OSD Fbs with plane.
*/
setOsdFbs2PlanePairs();
return 0;
}
int CompositionStrategyBase::handleOsdCompositionWithVideo() {
std::shared_ptr<DrmFramebufferBase> fb;
/* STEP 1: handle two video fbs. */
if (mOverlayFbs.size() > 1) {
MESON_ASSERT(mOverlayFbs.size() <= 3, "Only support 3 video layers now.");
/* CASE VIDEO_1: have two video fbs between ui fbs. */
/* Calculate max/min video zorder. */
mMinVideoZorder = INVALID_ZORDER;
mMaxVideoZorder = INVALID_ZORDER;
auto videoIt = mOverlayFbs.begin();
for (; videoIt != mOverlayFbs.end(); ++ videoIt) {
fb = *videoIt;
uint32_t fbZorder = fb->getZorder();
if (mMinVideoZorder == INVALID_ZORDER) {
mMinVideoZorder = fbZorder;
mMaxVideoZorder = fbZorder;
} else {
if (mMinVideoZorder > fbZorder)
mMinVideoZorder = fbZorder;
if (mMaxVideoZorder < fbZorder)
mMaxVideoZorder = fbZorder;
}
}
/* Judge whether double video are neighbour or not */
bool bNeighbourVideo = true;
auto fbIt = mFramebuffers.lower_bound(mMinVideoZorder);
for (; fbIt != mFramebuffers.end(); ++ fbIt) {
if (fbIt->second->getZorder() > mMinVideoZorder && fbIt->second->getZorder() < mMaxVideoZorder) {
bNeighbourVideo = false;
break;
}
}
if (!bNeighbourVideo) {
/* CASE VIDEO_1_1: two video fbs are not neighbour. */
if (mMinComposerZorder != INVALID_ZORDER) {
/* CASE VIDEO_1_1_1: have default compose range */
/* Change compose range to cover two video fbs. */
/*
case 1: Both up and below client has video |case 2_1: Only up client has video |case 2_2: Only below client has video
maxClientZorder from 5-->7 | maxClientZorder from 5-->7 | maxClientZorder not change
minClientZorder from 4-->3 | minClientZorder not change | minClientZorder from 4-->3
zorder: 8 -- osd --------- | 8 -- osd --------- | 8 -- osd ---------
7 -- maxVideo ---- maxClient(composer) | 7 -- maxVideo ---- maxClient(composer) | 7 -- client osd -- maxClient(composer)
6 -- osd --------- | 6 -- osd --------- | 6 -- maxVideo ----
5 -- client osd -- | 5 -- client osd -- | 5 -- client osd --
4 -- client osd -- | 4 -- client osd -- | 4 -- client osd --
3 -- osd --------- minClient(composer) | 3 -- minVideo ---- | 3 -- osd --------- minClient(composer)
2 -- minVideo ---- | 2 -- client osd -- minClient(composer) | 2 -- minVideo ----
1 -- osd --------- | 1 -- osd --------- | 1 -- osd ---------
*/
if (mMinComposerZorder > mMinVideoZorder) {
mMinComposerZorder = mMinVideoZorder + 1; // +1 to not compose the video
}
if (mMaxComposerZorder < mMaxVideoZorder) {
mMaxComposerZorder = mMaxVideoZorder;
}
} else {
/* CASE VIDEO_1_1_2:no default compose range
* Compose the fbs below minVideoZ, so the minVideoZ will be bottom.
* CASE: two video inside osd ui without client(default) range
* set maxClientZorder = 2
* set minClientZorder = 1
* zorder: 5 -- osd -------
* 4 -- maxVideo --
* 3 -- osd -------
* 2 -- minVideo -- maxClient(composer)
* 1 -- osd ------- minClient(composer)
*/
mMaxComposerZorder = mMinVideoZorder;
mMinComposerZorder = mFramebuffers.begin()->first;
}
/* goto case VIDEO_2 */
} else {
/* CASE VIDEO_1_2: two video fbs are neighbour, treat as one video. */
/* goto case VIDEO_2 */
}
}
/* STEP 2: now only one video fb or two neighbour video fbs.
* pick ui fbs to compose.
*/
confirmComposerRange();
handleVPULimit(true);
decidePlaneAssignment();
/* Push composers to cache mComposerFbs to build OSD2Plane pair. */
fillComposerFbs();
/* Step 3:
* Select composer.
*/
selectComposer();
setOsdFbs2PlanePairs();
return 0;
}
/* The public setup interface.
* layers: UI(include OSD and VIDEO) layer from SurfaceFlinger.
* composers: Composer style.
* planes: Get OSD and VIDEO planes from HwDisplayManager.
*/
void CompositionStrategyBase::setup(
std::vector<std::shared_ptr<DrmFramebufferBase>> & layers,
std::vector<std::shared_ptr<IComposer>> & composers,
std::vector<std::shared_ptr<HwDisplayPlaneBase>> & planes,
std::shared_ptr<HwDisplayCrtcBase> & crtc,
uint32_t reqFlag,
float scaleValue,
drm_mode_info_t mode) {
init();
mCrtc = crtc;
mCompositionFlag = reqFlag;
mScaleValue = scaleValue;
mDisplayMode = mode;
#if OSD_OUTPUT_ONE_CHANNEL
mHDRMode = true;
#else
if (reqFlag & COMPOSE_WITH_HDR_VIDEO) {
mHDRMode = true;
}
#endif
if (reqFlag & COMPOSE_HIDE_SECURE_FB) {
mHideSecureLayer = true;
}
if (reqFlag & COMPOSE_FORCE_CLIENT) {
mForceClientComposer = true;
}
#if ENABLE_GFX_HRR
if (mDisplayMode.refreshRate > 165.0f) {
mForceClientComposer = true;
}
#else
if (mDisplayMode.refreshRate > DEFAULT_REFRESH_RATE) {
mForceClientComposer = true;
}
#endif
if (reqFlag & COMPOSE_DISABLE_SIDEBAND) {
mIsSideBandDisable = true;
}
if (reqFlag & COMPOSE_ENABLE_MOSAIC_MODE) {
mMosaicEnabled = true;
}
if (reqFlag & COMPOSE_FORCE_VIDEO) {
mForceVideoComposer = true;
}
if (mCompositionFlag & COMPOSE_HIDE_VIDEO_FOR_HDCP_DEV) {
mHideVideoForHdcpDev = true;
}
/* add layers */
auto layerIt = layers.begin();
for (; layerIt != layers.end(); ++layerIt) {
std::shared_ptr<DrmFramebufferBase> layer = *layerIt;
mFramebuffers.insert(make_pair(layer->getZorder(), layer));
}
/* collect composers */
auto composerIt = composers.begin();
for (; composerIt != composers.end(); ++composerIt) {
std::shared_ptr<IComposer> composer = *composerIt;
switch (composer->getType()) {
case MESON_COMPOSITION_DUMMY:
if (mDummyComposer == NULL)
mDummyComposer = composer;
break;
case MESON_COMPOSITION_CLIENT:
if (mClientComposer == NULL)
mClientComposer = composer;
break;
case MESON_COMPOSITION_DI:
if (mVideoComposers.empty())
mVideoComposers.push_back(composer);
break;
case MESON_COMPOSITION_V2D:
mIsVideoComposerV2D = true;
mVideoComposers.push_back(composer);
break;
default:
mOtherComposers.push_back(composer);
break;
}
}
/* collect planes */
auto planeIt = planes.begin();
for (; planeIt != planes.end(); ++planeIt) {
std::shared_ptr<HwDisplayPlaneBase> plane = *planeIt;
if (!plane->isAvailable()) {
mOtherPlanes.push_back(plane);
continue;
}
switch (plane->getType()) {
case OSD_PLANE:
mOsdPlanes.push_back(plane);
break;
case DRM_VIDEO_PLANE:
case HWC_VIDEO_PLANE:
mHwcVideoPlanes.push_back(plane);
break;
default:
mOtherPlanes.push_back(plane);
break;
}
}
mVideoPlaneNum = mHwcVideoPlanes.size();
mVideoComposerNum = mVideoComposers.size();
mOsdPlaneNum = mOsdPlanes.size();
if (mIsVideoComposerV2D)
MESON_ASSERT(mVideoPlaneNum == mVideoComposerNum, "video composer count error !!!");
}
void CompositionStrategyBase::updateComposition() {
mDumpStr.clear();
}
/* Decide to choose which Fbs and how to build OsdFbs2Plane pairs. */
int CompositionStrategyBase::decideComposition() {
int ret = 0;
if (mFramebuffers.empty()) {
MESON_LOGV("No layers to compose, exit.");
if (mClientComposer != NULL) {
std::shared_ptr<DrmFramebufferBase> fb = nullptr;
mClientComposer->prepare();
mClientComposer->setOutput(fb, 1);
}
fillDebugInfoStr();
return ret;
}
/* handle VIDEO fbs. */
processVideoFbs();
/* handle HDR mode, hide secure layer, and force client. */
applyCompositionFlags();
/* handle graphic fbs.*/
processGfxFbs();
mDisplayPairs.sort();
handleOverlayVideoZorder();
handleDisplayLayerZorder();
fillDebugInfoStr();
return ret;
}
/* debug info for composition strategy */
void CompositionStrategyBase::fillDebugInfoStr() {
/* replace composer output with din0 Pair. */
std::shared_ptr<DrmFramebufferBase> composerOutput;
if (mComposer.get()) {
mComposer->start();
composerOutput = mComposer->getOutput();
}
for (auto displayIt = mDisplayPairs.begin(); displayIt != mDisplayPairs.end(); ++displayIt) {
uint32_t presentZorder = displayIt->presentZorder;
std::shared_ptr<DrmFramebufferBase> fb = *(displayIt->fbs.begin());
std::shared_ptr<HwDisplayPlaneBase> plane = displayIt->plane;
int blankFlag = (mHideSecureLayer && fb->getSecureFlag()) ?
BLANK_FOR_SECURE_CONTENT : UNBLANK;
meson_composition_t compType = fb->getCompositionType();
if (composerOutput.get() &&
compType == mComposer->getType()) {
presentZorder = mMaxComposerZorder + OSD_FB_BEGIN_ZORDER;
bool bDumpPlane = true;
for (auto it = mComposerFbs.begin(); it != mComposerFbs.end(); ++it) {
if (bDumpPlane) {
dumpFbAndPlane(*it, plane, presentZorder, blankFlag);
bDumpPlane = false;
} else {
dumpComposedFb(*it);
}
}
} else if (compType == MESON_COMPOSITION_DI || compType == MESON_COMPOSITION_V2D) {
bool bDumpVideoComposerBuffer = false;
for (auto it = displayIt->fbs.begin(); it != displayIt->fbs.end(); ++it) {
if (!bDumpVideoComposerBuffer) {
dumpFbAndPlane(*it, plane, presentZorder, blankFlag);
bDumpVideoComposerBuffer = true;
} else {
dumpComposedFb(*it);
}
}
} else {
dumpFbAndPlane(fb, plane, presentZorder, blankFlag);
}
}
/* Blank un-used plane. */
auto planeIt = mHwcVideoPlanes.begin();
for (; planeIt != mHwcVideoPlanes.end(); ++planeIt)
mOtherPlanes.push_back(*planeIt);
planeIt = mOsdPlanes.begin();
for (; planeIt != mOsdPlanes.end(); ++planeIt)
mOtherPlanes.push_back(*planeIt);
planeIt = mOtherPlanes.begin();
for (; planeIt != mOtherPlanes.end(); ++planeIt)
dumpUnusedPlane(*planeIt, BLANK_FOR_NO_CONTENT);
}
int CompositionStrategyBase::getDisplayPair(std::list<DisplayPair> & displayPairs) {
displayPairs = mDisplayPairs;
return 0;
}
void CompositionStrategyBase::dump(std::string & dumpstr) {
char str[64] = {0};
snprintf(str, 63, "Composition (%s):(0x%x)\n", getName(), mCompositionFlag);
dumpstr.append(str);
dumpstr.append("--------------------------------------------------------------\n");
dumpstr.append("| FbZ | Comp Type | Plane | PlaneZ | BlankStat |\n");
dumpstr.append(mDumpStr);
dumpstr.append("--------------------------------------------------------------\n");
}
Reference in New Issue Copy Permalink