428 lines
13 KiB
C++
428 lines
13 KiB
C++
/*
|
|
* Copyright (C) 2024 Amlogic Corporation.
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
#include <cstring>
|
|
#include <sys/ioctl.h>
|
|
#include <error.h>
|
|
#include <cinttypes>
|
|
#include <cerrno>
|
|
#include <vector>
|
|
#include <stdlib.h>
|
|
|
|
#include <drm_fourcc.h>
|
|
#include <BasicTypes.h>
|
|
#include <MesonLayer.h>
|
|
|
|
#include "V2DComposer.h"
|
|
#include "DispAdptLog.h"
|
|
|
|
V2DComposer::V2DComposer(int displayId, int devFd)
|
|
: IComposer() {
|
|
|
|
mEnable = false;
|
|
mDisplayID = displayId;
|
|
mDevFd = dup(devFd);
|
|
|
|
memset(&mVideoFramesInfo, 0, sizeof(mVideoFramesInfo));
|
|
mInputFbs.clear();
|
|
mOutputFb.reset();
|
|
}
|
|
|
|
V2DComposer::~V2DComposer() {
|
|
mInputFbs.clear();
|
|
mOutputFb.reset();
|
|
if (mDevFd >= 0)
|
|
close(mDevFd);
|
|
}
|
|
|
|
bool V2DComposer::isFbsSupport(
|
|
std::vector<std::shared_ptr<DrmFramebufferBase>> & fbs __unused,
|
|
std::vector<std::shared_ptr<DrmFramebufferBase>> & overlayfbs __unused,
|
|
int composeIdx __unused) {
|
|
return true;
|
|
}
|
|
|
|
int32_t V2DComposer::prepare() {
|
|
mOverlayFbs.clear();
|
|
|
|
return 0;
|
|
}
|
|
|
|
int32_t V2DComposer::addInputs(
|
|
std::vector<std::shared_ptr<DrmFramebufferBase>> & fbs,
|
|
std::vector<std::shared_ptr<DrmFramebufferBase>> & overlayfbs,
|
|
int composeIdx) {
|
|
mInputFbs = fbs;
|
|
mOverlayFbs = overlayfbs;
|
|
|
|
if (mInputFbs.empty())
|
|
return 0;
|
|
|
|
auto it = mInputFbs.begin();
|
|
if ((*it)->isRotated() || mInputFbs.size() > 1 || composeIdx > 0) {
|
|
if (mInputFbs.size() == 1) {
|
|
int32_t transform = (*it)->getTransform();
|
|
if (transform == TRANSFORM_FLIP_H || transform == TRANSFORM_FLIP_V ||
|
|
transform == TRANSFORM_ROT_180) {
|
|
DISPLAY_LOGV("V2DComposer(%d) %s transform %d VideoDisplay pass-through for 180 rotation or flip",
|
|
mDevFd, __func__, transform);
|
|
mInputFbs.clear();
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/* input fbs need do composition */
|
|
for (; it != mInputFbs.end(); it++) {
|
|
(*it)->setCompositionType(getType());
|
|
}
|
|
|
|
enable(true);
|
|
} else {
|
|
mInputFbs.clear();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int32_t V2DComposer::getOverlyFbs(
|
|
std::vector<std::shared_ptr<DrmFramebufferBase>> & overlays) {
|
|
overlays = mOverlayFbs;
|
|
return 0;
|
|
}
|
|
|
|
int32_t V2DComposer::setOutput(std::shared_ptr<DrmFramebufferBase> & fb,
|
|
int composeIdx) {
|
|
UNUSED(composeIdx);
|
|
UNUSED(fb);
|
|
return 0;
|
|
}
|
|
|
|
int32_t V2DComposer::start(int composeIdx) {
|
|
UNUSED(composeIdx);
|
|
|
|
int i = 0;
|
|
int ret = -1;
|
|
float alpha;
|
|
drm_rect_t crtcRect;
|
|
drm_rect_t srcRect;
|
|
frame_info_t * vFrameInfo;
|
|
int inputFbSize = 0;
|
|
MesonLayer* fb = nullptr;
|
|
int updateFrameCount = 0;
|
|
|
|
if (mInputFbs.empty()) {
|
|
DISPLAY_LOGV("V2DComposer(%d), input buffers is empty", mDevFd);
|
|
return 0;
|
|
}
|
|
|
|
if (needSkipRotationInComposer()) {
|
|
mOutputFb = std::static_pointer_cast<MesonLayer>(mInputFbs[0]);
|
|
DISPLAY_LOGV("V2DComposer(%d) %s DPSS pass-through, skip V2D composer, layerId %" PRIu64,
|
|
mDevFd, __func__, mOutputFb->getUniqueId());
|
|
return 0;
|
|
}
|
|
|
|
auto baseFb = mInputFbs[0];
|
|
if (baseFb->getCompositionType() != getType()) {
|
|
/* mInputFbs have only one element and it not rotated */
|
|
mOutputFb = std::static_pointer_cast<MesonLayer>(baseFb);
|
|
return 0;
|
|
}
|
|
|
|
if (!mEnable) {
|
|
DISPLAY_LOGE("V2DComposer(%d), composer not enable", mDevFd);
|
|
return 0;
|
|
}
|
|
|
|
if (!mOutputFb.get()) {
|
|
DISPLAY_LOGE("V2DComposer(%d), not create output buffer", mDevFd);
|
|
return 0;
|
|
}
|
|
|
|
if (mOutputFb->getFbType() != DRM_FB_VIDEO_COMPOSE_OUTPUT) {
|
|
mOutputFb = std::make_shared<MesonLayer>();
|
|
mOutputFb->setFbType(DRM_FB_VIDEO_COMPOSE_OUTPUT);
|
|
}
|
|
|
|
memset(&mVideoFramesInfo, 0, sizeof(mVideoFramesInfo));
|
|
mVideoFramesInfo.out_buffer.fd = -1;
|
|
mVideoFramesInfo.out_buffer.fence_fd = -1;
|
|
|
|
inputFbSize = mInputFbs.size();
|
|
for (i = 0; i < inputFbSize; i++) {
|
|
uint32_t width;
|
|
uint32_t height;
|
|
uint32_t format;
|
|
uint32_t stride;
|
|
|
|
MesonLayer* fb = (MesonLayer*) (mInputFbs[i].get());
|
|
if (mVideoFramesInfo.frame_count >= MAX_LAYER_COUNT) {
|
|
DISPLAY_LOGW("V2DComposer(%d) start, More than Max composition video "
|
|
"layers, skip %" PRIu64 ", !!!", mDevFd, fb->getUniqueId());
|
|
continue;
|
|
}
|
|
|
|
if (fb->getBufferFd() < 0) {
|
|
DISPLAY_LOGD("V2DComposer(%d) setframes layerId(%" PRIu64 ") type(%s) invalid fd",
|
|
mDevFd, fb->getUniqueId(), drmFbTypeToString(fb->getFbType()));
|
|
continue;
|
|
}
|
|
|
|
if (!fb->getVisible()) {
|
|
DISPLAY_LOGV("layer(%" PRIu64 ") invisible, don't composer", fb->getUniqueId());
|
|
continue;
|
|
}
|
|
|
|
if (fb->isFbUpdated())
|
|
updateFrameCount++;
|
|
|
|
vFrameInfo = &mVideoFramesInfo.input_buffer[mVideoFramesInfo.frame_count];
|
|
mVideoFramesInfo.frame_count++;
|
|
|
|
crtcRect = fb->getDisplayFrame();
|
|
srcRect = fb->getSourceCrop();
|
|
alpha = fb->getPlaneAlpha();
|
|
fb->getBufferInfo(width, height, stride, format);
|
|
|
|
vFrameInfo->fd = fb->getBufferFd();
|
|
vFrameInfo->fence_fd = fb->getAcquireFenceFd();
|
|
vFrameInfo->buffer_w = width;
|
|
vFrameInfo->buffer_h = height;
|
|
vFrameInfo->align_w = stride;
|
|
vFrameInfo->align_h = 0;
|
|
vFrameInfo->buffer_format = format;
|
|
vFrameInfo->dst_x = crtcRect.left;
|
|
vFrameInfo->dst_y = crtcRect.top;
|
|
vFrameInfo->dst_w = crtcRect.right - crtcRect.left;
|
|
vFrameInfo->dst_h = crtcRect.bottom - crtcRect.top;
|
|
vFrameInfo->crop_x = srcRect.left;
|
|
vFrameInfo->crop_y = srcRect.top;
|
|
vFrameInfo->crop_w = srcRect.right - srcRect.left;
|
|
vFrameInfo->crop_h = srcRect.bottom - srcRect.top;
|
|
vFrameInfo->zorder = fb->getZorder();
|
|
vFrameInfo->transform = fb->getTransform();
|
|
vFrameInfo->alpha = int32_t(alpha * (MAX_ALPHA_VALUE - MIN_ALPHA_VALUE) + MIN_ALPHA_VALUE);
|
|
|
|
DISPLAY_LOGV("V2DComposer(%d) setframes layerId(%" PRIu64 ") z(%d) type(%s) "
|
|
"fd(%d) wxh(%dx%d) alignW(%d) f(%d) t(%d) axis(%s) crop(%s)",
|
|
mDevFd, fb->getUniqueId(), vFrameInfo->zorder, drmFbTypeToString(fb->getFbType()),
|
|
vFrameInfo->fd, width, height, stride, format, vFrameInfo->transform,
|
|
crtcRect.toString().c_str(), srcRect.toString().c_str());
|
|
}
|
|
|
|
if (mVideoFramesInfo.frame_count == 0) {
|
|
DISPLAY_LOGV("V2DComposer(%d) has no frame count", mDevFd);
|
|
mOutputFb->setBufferInfo(-1, -1);
|
|
mOutputFb->setVisible(false);
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (updateFrameCount == 0) {
|
|
DISPLAY_LOGV("V2DComposer(%d) has no frame update", mDevFd);
|
|
mOutputFb->froceRefresh(false);
|
|
return -EINVAL;
|
|
}
|
|
|
|
ret = ioctl(mDevFd, V2D_IOCTL_SET_FRAMES, &mVideoFramesInfo);
|
|
for (int i = 0; i < mVideoFramesInfo.frame_count; i++) {
|
|
vFrameInfo = &mVideoFramesInfo.input_buffer[i];
|
|
if (vFrameInfo->fence_fd >= 0) {
|
|
close(vFrameInfo->fence_fd);
|
|
vFrameInfo->fence_fd = -1;
|
|
}
|
|
}
|
|
|
|
if (ret != 0) {
|
|
DISPLAY_LOGE("v2d composer ioctl error, %s(%d), mDevFd = %d",
|
|
strerror(errno), errno, mDevFd);
|
|
mOutputFb->setVisible(true);
|
|
return -1;
|
|
}
|
|
|
|
fillOutputFrameBuffer(mVideoFramesInfo.out_buffer);
|
|
|
|
mOutputFb->clearFlipData();
|
|
for (i = 0; i < (int)mInputFbs.size(); i++) {
|
|
fb = (MesonLayer *) (mInputFbs[i].get());
|
|
fb->setDiProcessorFd(-1);
|
|
std::map<uint64_t, meson_page_flip_data> fb_data = fb->getPageFlipData();
|
|
|
|
for (const auto& pair : fb_data) {
|
|
mOutputFb->setPageFlipData(
|
|
pair.first,
|
|
pair.second.context,
|
|
pair.second.callback,
|
|
fb->getBufferFd());
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
std::shared_ptr<DrmFramebufferBase> V2DComposer::getOutput(int composeIdx) {
|
|
UNUSED(composeIdx);
|
|
return mOutputFb;
|
|
}
|
|
|
|
int32_t V2DComposer::fillOutputFrameBuffer(frame_info_t & buffer) {
|
|
drm_rect_t crtcRect;
|
|
drm_rect_t srcRect;
|
|
|
|
crtcRect.left = buffer.dst_x;
|
|
crtcRect.top = buffer.dst_y;
|
|
crtcRect.right = buffer.dst_x + buffer.dst_w;
|
|
crtcRect.bottom = buffer.dst_y + buffer.dst_h;
|
|
srcRect.left = buffer.crop_x;
|
|
srcRect.top = buffer.crop_y;
|
|
srcRect.right = buffer.crop_x + buffer.crop_w;
|
|
srcRect.bottom = buffer.crop_y + buffer.crop_h;
|
|
|
|
mOutputFb->setCompositionType(getType());
|
|
mOutputFb->setUniqueId(0);
|
|
mOutputFb->setBufferInfo(buffer.fd, buffer.fence_fd);
|
|
mOutputFb->setBufferInfo(buffer.buffer_w,
|
|
buffer.buffer_h,
|
|
buffer.align_w,
|
|
DRM_FORMAT_NV21);
|
|
mOutputFb->setSourceCrop(srcRect);
|
|
mOutputFb->setDisplayFrame(crtcRect);
|
|
mOutputFb->setPlaneAlpha(1);
|
|
mOutputFb->setZorder(1);
|
|
mOutputFb->updateZorder();
|
|
mOutputFb->setVisible(true);
|
|
|
|
DISPLAY_LOGV("V2DComposer(%d) output buffer: fd:%d, fence_Fd:%d, "
|
|
"w/h:(%dx%d), alignW:%d, crop(%s) displayFrame(%s)",
|
|
mDevFd, buffer.fd, buffer.fence_fd, buffer.buffer_w, buffer.buffer_h,
|
|
buffer.align_w, srcRect.toString().c_str(), crtcRect.toString().c_str());
|
|
|
|
return 0;
|
|
}
|
|
|
|
int32_t V2DComposer::setReleaseFence() {
|
|
int fence = -1;
|
|
int32_t ret = 0;
|
|
|
|
if (needSkipRotationInComposer())
|
|
return ret;
|
|
|
|
if (!mOutputFb.get() || !mOutputFb->isFbUpdated() || (mOutputFb->getBufferFd() < 0))
|
|
return ret;
|
|
|
|
/* this fence from drm video plane */
|
|
fence = mOutputFb->getCurReleaseFence();
|
|
|
|
for (auto it = mInputFbs.begin(); it != mInputFbs.end(); it++) {
|
|
if ((*it)->getBufferFd() < 0)
|
|
continue;
|
|
|
|
int releaseFence = (fence >= 0 ? dup(fence) : -1);
|
|
DISPLAY_LOGV("V2DComposer(%d) set release fence %d for layerId %" PRIu64,
|
|
mDevFd, releaseFence, (*it)->getUniqueId());
|
|
(*it)->setCurReleaseFence(releaseFence);
|
|
}
|
|
|
|
if (fence < 0) {
|
|
mOutputFb->mUpdated = false;
|
|
return ret;
|
|
}
|
|
|
|
release_info_t info = {
|
|
.fd = mOutputFb->getBufferFd(),
|
|
.fence_fd = fence,
|
|
};
|
|
|
|
if (ioctl(mDevFd, V2D_IOCTL_SET_FENCE, &info) != 0) {
|
|
DISPLAY_LOGE("V2DComposer(%d) error, set release fence error, %s(%d)",
|
|
mDevFd, strerror(errno), errno);
|
|
ret = errno;
|
|
} else {
|
|
DISPLAY_LOGV("V2DComposer(%d) set release fence %d for fd %d to V2D",
|
|
mDevFd, info.fence_fd, info.fd);
|
|
}
|
|
|
|
if (fence >= 0)
|
|
close(fence);
|
|
|
|
mOutputFb->mUpdated = false;
|
|
|
|
return ret;
|
|
}
|
|
|
|
int32_t V2DComposer::enable(bool enable) {
|
|
if (enable && needSkipRotationInComposer()) {
|
|
if (mEnable) {
|
|
int32_t val = 0;
|
|
DISPLAY_LOGD("V2DComposer(%d) disable", mDevFd);
|
|
if (ioctl(mDevFd, V2D_IOCTL_SET_ENABLE, &val) != 0) {
|
|
DISPLAY_LOGE("%s V2DComposer(%d) error, %s(%d)",
|
|
__func__, mDevFd, strerror(errno), errno);
|
|
return -errno;
|
|
}
|
|
mEnable = false;
|
|
}
|
|
DISPLAY_LOGV("V2DComposer(%d) %s DPSS pass-through, skip V2D hardware enable.",
|
|
mDevFd, __func__);
|
|
return 1;
|
|
}
|
|
|
|
if (mEnable != enable) {
|
|
int32_t val = enable ? 1 : 0;
|
|
DISPLAY_LOGD("V2DComposer(%d) %s", mDevFd, enable ? "enable" : "disable");
|
|
if (ioctl(mDevFd, V2D_IOCTL_SET_ENABLE, &val) != 0) {
|
|
DISPLAY_LOGE("%s V2DComposer(%d) error, %s(%d)",
|
|
enable ? "enable" : "disable", mDevFd, strerror(errno), errno);
|
|
return -errno;
|
|
}
|
|
|
|
mEnable = enable;
|
|
|
|
if (mEnable) {
|
|
mOutputFb = std::make_shared<MesonLayer>();
|
|
mOutputFb->setFbType(DRM_FB_VIDEO_COMPOSE_OUTPUT);
|
|
}
|
|
}
|
|
|
|
if (!enable) {
|
|
/* Any disable() clears composer-held refs. Covers:
|
|
* (1) DPSS pass-through: first enable(true) returns early and mEnable stays false;
|
|
* later enable(false) does not enter mEnable!=enable, but must still clear
|
|
* mInputFbs / mOutputFb (output may alias input).
|
|
* (2) Normal path: true->false after ioctl also hits this block.
|
|
*/
|
|
mInputFbs.clear();
|
|
mOutputFb.reset();
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
bool V2DComposer::needSkipRotationInComposer() {
|
|
if (mInputFbs.size() != 1)
|
|
return false;
|
|
|
|
if ((*mInputFbs.begin())->isRotated()) {
|
|
if ((*mInputFbs.begin())->isDpssTransformFlagSet()) {
|
|
(*mInputFbs.begin())->setCompositionType(MESON_COMPOSITION_PLANE_HWCVIDEO);
|
|
return true;
|
|
} else {
|
|
(*mInputFbs.begin())->setCompositionType(getType());
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|