blob: 76ecf439fcbb8debd95d388aa603889b286d9fdf [file] [log] [blame]
/*
* Copyright 2022 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.
*/
#include "HostFrameComposer.h"
#include <EGL/egl.h>
#include <EGL/eglext.h>
#include <android-base/parseint.h>
#include <android-base/properties.h>
#include <android-base/strings.h>
#include <android-base/unique_fd.h>
#include <hardware/hwcomposer2.h>
#include <poll.h>
#include <sync/sync.h>
#include <ui/GraphicBuffer.h>
#include <ui/GraphicBufferAllocator.h>
#include <ui/GraphicBufferMapper.h>
#include <optional>
#include <tuple>
#include "../egl/goldfish_sync.h"
#include "Display.h"
#include "HostUtils.h"
#include "virtgpu_drm.h"
namespace aidl::android::hardware::graphics::composer3::impl {
namespace {
hwc_rect AsHwcRect(const common::Rect& rect) {
hwc_rect out;
out.left = rect.left;
out.top = rect.top;
out.right = rect.right;
out.bottom = rect.bottom;
return out;
}
hwc_frect AsHwcFrect(const common::FRect& rect) {
hwc_frect out;
out.left = rect.left;
out.top = rect.top;
out.right = rect.right;
out.bottom = rect.bottom;
return out;
}
hwc_color AsHwcColor(const Color& color) {
hwc_color out;
out.r = color.r;
out.g = color.g;
out.b = color.b;
out.a = color.a;
return out;
}
hwc_transform_t AsHwcTransform(const common::Transform& transform) {
switch (transform) {
case common::Transform::NONE:
return static_cast<hwc_transform_t>(0);
case common::Transform::FLIP_H:
return HWC_TRANSFORM_FLIP_H;
case common::Transform::FLIP_V:
return HWC_TRANSFORM_FLIP_V;
case common::Transform::ROT_90:
return HWC_TRANSFORM_ROT_90;
case common::Transform::ROT_180:
return HWC_TRANSFORM_ROT_180;
case common::Transform::ROT_270:
return HWC_TRANSFORM_ROT_270;
}
}
static bool isMinigbmFromProperty() {
static constexpr const auto kGrallocProp = "ro.hardware.gralloc";
const auto grallocProp = ::android::base::GetProperty(kGrallocProp, "");
DEBUG_LOG("%s: prop value is: %s", __FUNCTION__, grallocProp.c_str());
if (grallocProp == "minigbm") {
DEBUG_LOG("%s: Using minigbm, in minigbm mode.\n", __FUNCTION__);
return true;
} else {
DEBUG_LOG("%s: Is not using minigbm, in goldfish mode.\n", __FUNCTION__);
return false;
}
}
static bool useAngleFromProperty() {
static constexpr const auto kEglProp = "ro.hardware.egl";
const auto eglProp = ::android::base::GetProperty(kEglProp, "");
DEBUG_LOG("%s: prop value is: %s", __FUNCTION__, eglProp.c_str());
if (eglProp == "angle") {
DEBUG_LOG("%s: Using ANGLE.\n", __FUNCTION__);
return true;
} else {
DEBUG_LOG("%s: Not using ANGLE.\n", __FUNCTION__);
return false;
}
}
typedef struct compose_layer {
uint32_t cbHandle;
hwc2_composition_t composeMode;
hwc_rect_t displayFrame;
hwc_frect_t crop;
int32_t blendMode;
float alpha;
hwc_color_t color;
hwc_transform_t transform;
} ComposeLayer;
typedef struct compose_device {
uint32_t version;
uint32_t targetHandle;
uint32_t numLayers;
struct compose_layer layer[0];
} ComposeDevice;
typedef struct compose_device_v2 {
uint32_t version;
uint32_t displayId;
uint32_t targetHandle;
uint32_t numLayers;
struct compose_layer layer[0];
} ComposeDevice_v2;
class ComposeMsg {
public:
ComposeMsg(uint32_t layerCnt = 0)
: mData(sizeof(ComposeDevice) + layerCnt * sizeof(ComposeLayer)) {
mComposeDevice = reinterpret_cast<ComposeDevice*>(mData.data());
mLayerCnt = layerCnt;
}
ComposeDevice* get() { return mComposeDevice; }
uint32_t getLayerCnt() { return mLayerCnt; }
private:
std::vector<uint8_t> mData;
uint32_t mLayerCnt;
ComposeDevice* mComposeDevice;
};
class ComposeMsg_v2 {
public:
ComposeMsg_v2(uint32_t layerCnt = 0)
: mData(sizeof(ComposeDevice_v2) + layerCnt * sizeof(ComposeLayer)) {
mComposeDevice = reinterpret_cast<ComposeDevice_v2*>(mData.data());
mLayerCnt = layerCnt;
}
ComposeDevice_v2* get() { return mComposeDevice; }
uint32_t getLayerCnt() { return mLayerCnt; }
private:
std::vector<uint8_t> mData;
uint32_t mLayerCnt;
ComposeDevice_v2* mComposeDevice;
};
const native_handle_t* AllocateDisplayColorBuffer(int width, int height) {
const uint32_t layerCount = 1;
const uint64_t graphicBufferId = 0; // not used
buffer_handle_t handle;
uint32_t stride;
if (::android::GraphicBufferAllocator::get().allocate(
width, height, ::android::PIXEL_FORMAT_RGBA_8888, layerCount,
::android::GraphicBuffer::USAGE_HW_COMPOSER |
::android::GraphicBuffer::USAGE_HW_RENDER,
&handle, &stride, graphicBufferId, "EmuHWC2") == ::android::OK) {
return static_cast<const native_handle_t*>(handle);
} else {
return nullptr;
}
}
void FreeDisplayColorBuffer(const native_handle_t* h) {
::android::GraphicBufferAllocator::get().free(h);
}
} // namespace
HWC3::Error HostFrameComposer::init() {
mIsMinigbm = isMinigbmFromProperty();
mUseAngle = useAngleFromProperty();
if (mIsMinigbm) {
mDrmClient.emplace();
HWC3::Error error = mDrmClient->init();
if (error != HWC3::Error::None) {
ALOGE("%s: failed to initialize DrmClient", __FUNCTION__);
return error;
}
} else {
mSyncDeviceFd = goldfish_sync_open();
}
return HWC3::Error::None;
}
HWC3::Error HostFrameComposer::registerOnHotplugCallback(
const HotplugCallback& cb) {
if (mDrmClient) {
mDrmClient->registerOnHotplugCallback(cb);
}
return HWC3::Error::None;
}
HWC3::Error HostFrameComposer::unregisterOnHotplugCallback() {
if (mDrmClient) {
mDrmClient->unregisterOnHotplugCallback();
}
return HWC3::Error::None;
}
HWC3::Error HostFrameComposer::createHostComposerDisplayInfo(
Display* display, uint32_t hostDisplayId) {
HWC3::Error error = HWC3::Error::None;
int64_t displayId = display->getId();
int32_t displayConfigId;
int32_t displayWidth;
int32_t displayHeight;
error = display->getActiveConfig(&displayConfigId);
if (error != HWC3::Error::None) {
ALOGE("%s: display:%" PRIu64 " has no active config", __FUNCTION__,
displayId);
return error;
}
error = display->getDisplayAttribute(displayConfigId, DisplayAttribute::WIDTH,
&displayWidth);
if (error != HWC3::Error::None) {
ALOGE("%s: display:%" PRIu64 " failed to get width", __FUNCTION__,
displayId);
return error;
}
error = display->getDisplayAttribute(
displayConfigId, DisplayAttribute::HEIGHT, &displayHeight);
if (error != HWC3::Error::None) {
ALOGE("%s: display:%" PRIu64 " failed to get height", __FUNCTION__,
displayId);
return error;
}
HostComposerDisplayInfo& displayInfo = mDisplayInfos[displayId];
displayInfo.hostDisplayId = hostDisplayId;
if (displayInfo.compositionResultBuffer) {
FreeDisplayColorBuffer(displayInfo.compositionResultBuffer);
}
displayInfo.compositionResultBuffer =
AllocateDisplayColorBuffer(displayWidth, displayHeight);
if (displayInfo.compositionResultBuffer == nullptr) {
ALOGE("%s: display:%" PRIu64 " failed to create target buffer",
__FUNCTION__, displayId);
return HWC3::Error::NoResources;
}
if (mDrmClient) {
auto [drmBufferCreateError, drmBuffer] =
mDrmClient->create(displayInfo.compositionResultBuffer);
if (drmBufferCreateError != HWC3::Error::None) {
ALOGE("%s: display:%" PRIu64 " failed to create target drm buffer",
__FUNCTION__, displayId);
return HWC3::Error::NoResources;
}
displayInfo.compositionResultDrmBuffer = std::move(drmBuffer);
}
return HWC3::Error::None;
}
HWC3::Error HostFrameComposer::onDisplayCreate(Display* display) {
HWC3::Error error = HWC3::Error::None;
int64_t displayId = display->getId();
int32_t displayConfigId;
int32_t displayWidth;
int32_t displayHeight;
int32_t displayDpiX;
error = display->getActiveConfig(&displayConfigId);
if (error != HWC3::Error::None) {
ALOGE("%s: display:%" PRIu64 " has no active config", __FUNCTION__,
displayId);
return error;
}
error = display->getDisplayAttribute(displayConfigId, DisplayAttribute::WIDTH,
&displayWidth);
if (error != HWC3::Error::None) {
ALOGE("%s: display:%" PRIu64 " failed to get width", __FUNCTION__,
displayId);
return error;
}
error = display->getDisplayAttribute(
displayConfigId, DisplayAttribute::HEIGHT, &displayHeight);
if (error != HWC3::Error::None) {
ALOGE("%s: display:%" PRIu64 " failed to get height", __FUNCTION__,
displayId);
return error;
}
error = display->getDisplayAttribute(displayConfigId, DisplayAttribute::DPI_X,
&displayDpiX);
if (error != HWC3::Error::None) {
ALOGE("%s: display:%" PRIu64 " failed to get height", __FUNCTION__,
displayId);
return error;
}
uint32_t hostDisplayId = 0;
DEFINE_AND_VALIDATE_HOST_CONNECTION
if (displayId == 0) {
// Primary display:
hostCon->lock();
if (rcEnc->rcCreateDisplayById(rcEnc, displayId)) {
ALOGE("%s host failed to create display %" PRIu64, __func__, displayId);
hostCon->unlock();
return HWC3::Error::NoResources;
}
if (rcEnc->rcSetDisplayPoseDpi(rcEnc, displayId, -1, -1, displayWidth,
displayHeight, displayDpiX / 1000)) {
ALOGE("%s host failed to set display %" PRIu64, __func__, displayId);
hostCon->unlock();
return HWC3::Error::NoResources;
}
hostCon->unlock();
} else {
// Secondary display:
static constexpr const uint32_t kHostDisplayIdStart = 6;
uint32_t expectedHostDisplayId = kHostDisplayIdStart + displayId - 1;
uint32_t actualHostDisplayId = 0;
hostCon->lock();
rcEnc->rcDestroyDisplay(rcEnc, expectedHostDisplayId);
rcEnc->rcCreateDisplay(rcEnc, &actualHostDisplayId);
rcEnc->rcSetDisplayPose(rcEnc, actualHostDisplayId, -1, -1, displayWidth,
displayHeight);
hostCon->unlock();
if (actualHostDisplayId != expectedHostDisplayId) {
ALOGE(
"Something wrong with host displayId allocation, expected %d "
"but received %d",
expectedHostDisplayId, actualHostDisplayId);
}
hostDisplayId = actualHostDisplayId;
}
error = createHostComposerDisplayInfo(display, hostDisplayId);
if (error != HWC3::Error::None) {
ALOGE("%s failed to initialize host info for display:%" PRIu64,
__FUNCTION__, displayId);
return error;
}
std::optional<std::vector<uint8_t>> edid;
if (mDrmClient) {
edid = mDrmClient->getEdid(displayId);
if (edid) {
display->setEdid(*edid);
}
}
return HWC3::Error::None;
}
HWC3::Error HostFrameComposer::onDisplayDestroy(Display* display) {
int64_t displayId = display->getId();
auto it = mDisplayInfos.find(displayId);
if (it == mDisplayInfos.end()) {
ALOGE("%s: display:%" PRIu64 " missing display buffers?", __FUNCTION__,
displayId);
return HWC3::Error::BadDisplay;
}
HostComposerDisplayInfo& displayInfo = mDisplayInfos[displayId];
if (displayId != 0) {
DEFINE_AND_VALIDATE_HOST_CONNECTION
hostCon->lock();
rcEnc->rcDestroyDisplay(rcEnc, displayInfo.hostDisplayId);
hostCon->unlock();
}
FreeDisplayColorBuffer(displayInfo.compositionResultBuffer);
mDisplayInfos.erase(it);
return HWC3::Error::None;
}
HWC3::Error HostFrameComposer::onDisplayClientTargetSet(Display* display) {
int64_t displayId = display->getId();
auto it = mDisplayInfos.find(displayId);
if (it == mDisplayInfos.end()) {
ALOGE("%s: display:%" PRIu64 " missing display buffers?", __FUNCTION__,
displayId);
return HWC3::Error::BadDisplay;
}
HostComposerDisplayInfo& displayInfo = mDisplayInfos[displayId];
if (mIsMinigbm) {
FencedBuffer& clientTargetFencedBuffer = display->getClientTarget();
auto [drmBufferCreateError, drmBuffer] =
mDrmClient->create(clientTargetFencedBuffer.getBuffer());
if (drmBufferCreateError != HWC3::Error::None) {
ALOGE("%s: display:%" PRIu64 " failed to create client target drm buffer",
__FUNCTION__, displayId);
return HWC3::Error::NoResources;
}
displayInfo.clientTargetDrmBuffer = std::move(drmBuffer);
}
return HWC3::Error::None;
}
HWC3::Error HostFrameComposer::validateDisplay(Display* display,
DisplayChanges* outChanges) {
const auto& displayId = display->getId();
DEFINE_AND_VALIDATE_HOST_CONNECTION
hostCon->lock();
bool hostCompositionV1 = rcEnc->hasHostCompositionV1();
bool hostCompositionV2 = rcEnc->hasHostCompositionV2();
hostCon->unlock();
const std::vector<Layer*> layers = display->getOrderedLayers();
for (const auto& layer : layers) {
switch (layer->getCompositionType()) {
case Composition::INVALID:
// Log error for unused layers, layer leak?
ALOGE("%s layer:%" PRIu64 " CompositionType not set", __FUNCTION__,
layer->getId());
break;
case Composition::DISPLAY_DECORATION:
return HWC3::Error::Unsupported;
default:
break;
}
}
// If one layer requires a fall back to the client composition type, all
// layers will fall back to the client composition type.
bool fallBackToClient = (!hostCompositionV1 && !hostCompositionV2) ||
display->hasColorTransform();
if (!fallBackToClient) {
for (const auto& layer : layers) {
const auto& layerId = layer->getId();
const auto& layerCompositionType = layer->getCompositionType();
std::optional<Composition> layerFallBackTo = std::nullopt;
switch (layerCompositionType) {
case Composition::CLIENT:
case Composition::SIDEBAND:
ALOGI("%s: layer %" PRIu32 " CompositionType %d, fallback to client",
__FUNCTION__, static_cast<uint32_t>(layer->getId()),
layerCompositionType);
layerFallBackTo = Composition::CLIENT;
break;
case Composition::CURSOR:
ALOGI("%s: layer %" PRIu32 " CompositionType %d, fallback to device",
__FUNCTION__, static_cast<uint32_t>(layer->getId()),
layerCompositionType);
layerFallBackTo = Composition::DEVICE;
break;
case Composition::INVALID:
case Composition::DEVICE:
case Composition::SOLID_COLOR:
layerFallBackTo = std::nullopt;
break;
default:
ALOGE("%s: layer %" PRIu32 " has an unknown composition type: %d",
__FUNCTION__, static_cast<uint32_t>(layer->getId()),
layerCompositionType);
}
if (layerFallBackTo == Composition::CLIENT) {
fallBackToClient = true;
}
if (layerFallBackTo.has_value()) {
outChanges->addLayerCompositionChange(displayId, layerId,
*layerFallBackTo);
}
}
}
if (fallBackToClient) {
outChanges->clearLayerCompositionChanges();
for (auto& layer : layers) {
const auto& layerId = layer->getId();
if (layer->getCompositionType() == Composition::INVALID) {
continue;
}
if (layer->getCompositionType() != Composition::CLIENT) {
outChanges->addLayerCompositionChange(displayId, layerId,
Composition::CLIENT);
}
}
}
return HWC3::Error::None;
}
HWC3::Error HostFrameComposer::presentDisplay(
Display* display, ::android::base::unique_fd* outDisplayFence,
std::unordered_map<int64_t, ::android::base::unique_fd>* outLayerFences) {
auto displayId = display->getId();
auto displayInfoIt = mDisplayInfos.find(displayId);
if (displayInfoIt == mDisplayInfos.end()) {
ALOGE("%s: failed to find display buffers for display:%" PRIu64,
__FUNCTION__, displayId);
return HWC3::Error::BadDisplay;
}
HostComposerDisplayInfo& displayInfo = displayInfoIt->second;
HostConnection* hostCon;
ExtendedRCEncoderContext* rcEnc;
HWC3::Error error = getAndValidateHostConnection(&hostCon, &rcEnc);
if (error != HWC3::Error::None) {
return error;
}
hostCon->lock();
bool hostCompositionV1 = rcEnc->hasHostCompositionV1();
bool hostCompositionV2 = rcEnc->hasHostCompositionV2();
hostCon->unlock();
// Ff we supports v2, then discard v1
if (hostCompositionV2) {
hostCompositionV1 = false;
}
const std::vector<Layer*> layers = display->getOrderedLayers();
if (hostCompositionV2 || hostCompositionV1) {
uint32_t numLayer = 0;
for (auto layer : layers) {
if (layer->getCompositionType() == Composition::DEVICE ||
layer->getCompositionType() == Composition::SOLID_COLOR) {
numLayer++;
}
}
DEBUG_LOG("%s: presenting display:%" PRIu64 " with %d layers", __FUNCTION__,
displayId, static_cast<int>(layers.size()));
if (numLayer == 0) {
ALOGV(
"%s display has no layers to compose, flushing client target buffer.",
__FUNCTION__);
FencedBuffer& displayClientTarget = display->getClientTarget();
if (displayClientTarget.getBuffer() != nullptr) {
::android::base::unique_fd fence = displayClientTarget.getFence();
if (mIsMinigbm) {
auto [_, flushCompleteFence] = mDrmClient->flushToDisplay(
displayId, displayInfo.clientTargetDrmBuffer, fence);
*outDisplayFence = std::move(flushCompleteFence);
} else {
post(hostCon, rcEnc, displayClientTarget.getBuffer());
*outDisplayFence = std::move(fence);
}
}
return HWC3::Error::None;
}
std::unique_ptr<ComposeMsg> composeMsg;
std::unique_ptr<ComposeMsg_v2> composeMsgV2;
if (hostCompositionV1) {
composeMsg.reset(new ComposeMsg(numLayer));
} else {
composeMsgV2.reset(new ComposeMsg_v2(numLayer));
}
// Handle the composition
ComposeDevice* p;
ComposeDevice_v2* p2;
ComposeLayer* l;
if (hostCompositionV1) {
p = composeMsg->get();
l = p->layer;
} else {
p2 = composeMsgV2->get();
l = p2->layer;
}
std::vector<int64_t> releaseLayerIds;
for (auto layer : layers) {
// TODO: use local var composisitonType to store getCompositionType()
if (layer->getCompositionType() != Composition::DEVICE &&
layer->getCompositionType() != Composition::SOLID_COLOR) {
ALOGE("%s: Unsupported composition types %d layer %u", __FUNCTION__,
layer->getCompositionType(), (uint32_t)layer->getId());
continue;
}
// send layer composition command to host
if (layer->getCompositionType() == Composition::DEVICE) {
releaseLayerIds.emplace_back(layer->getId());
::android::base::unique_fd fence = layer->getBuffer().getFence();
if (fence.ok()) {
int err = sync_wait(fence.get(), 3000);
if (err < 0 && errno == ETIME) {
ALOGE("%s waited on fence %d for 3000 ms", __FUNCTION__,
fence.get());
}
} else {
ALOGV("%s: acquire fence not set for layer %u", __FUNCTION__,
(uint32_t)layer->getId());
}
const native_handle_t* cb = layer->getBuffer().getBuffer();
if (cb != nullptr) {
l->cbHandle = hostCon->grallocHelper()->getHostHandle(cb);
} else {
ALOGE("%s null buffer for layer %d", __FUNCTION__,
(uint32_t)layer->getId());
}
} else {
// solidcolor has no buffer
l->cbHandle = 0;
}
l->composeMode = (hwc2_composition_t)layer->getCompositionType();
l->displayFrame = AsHwcRect(layer->getDisplayFrame());
l->crop = AsHwcFrect(layer->getSourceCrop());
l->blendMode = static_cast<int32_t>(layer->getBlendMode());
l->alpha = layer->getPlaneAlpha();
l->color = AsHwcColor(layer->getColor());
l->transform = AsHwcTransform(layer->getTransform());
ALOGV(
" cb %d blendmode %d alpha %f %d %d %d %d z %d"
" composeMode %d, transform %d",
l->cbHandle, l->blendMode, l->alpha, l->displayFrame.left,
l->displayFrame.top, l->displayFrame.right, l->displayFrame.bottom,
layer->getZOrder(), l->composeMode, l->transform);
l++;
}
if (hostCompositionV1) {
p->version = 1;
p->targetHandle = hostCon->grallocHelper()->getHostHandle(
displayInfo.compositionResultBuffer);
p->numLayers = numLayer;
} else {
p2->version = 2;
p2->displayId = displayInfo.hostDisplayId;
p2->targetHandle = hostCon->grallocHelper()->getHostHandle(
displayInfo.compositionResultBuffer);
p2->numLayers = numLayer;
}
void* buffer;
uint32_t bufferSize;
if (hostCompositionV1) {
buffer = (void*)p;
bufferSize = sizeof(ComposeDevice) + numLayer * sizeof(ComposeLayer);
} else {
bufferSize = sizeof(ComposeDevice_v2) + numLayer * sizeof(ComposeLayer);
buffer = (void*)p2;
}
::android::base::unique_fd retire_fd;
hostCon->lock();
if (rcEnc->hasAsyncFrameCommands()) {
if (mIsMinigbm) {
rcEnc->rcComposeAsyncWithoutPost(rcEnc, bufferSize, buffer);
} else {
rcEnc->rcComposeAsync(rcEnc, bufferSize, buffer);
}
} else {
if (mIsMinigbm) {
rcEnc->rcComposeWithoutPost(rcEnc, bufferSize, buffer);
} else {
rcEnc->rcCompose(rcEnc, bufferSize, buffer);
}
}
hostCon->unlock();
// Send a retire fence and use it as the release fence for all layers,
// since media expects it
EGLint attribs[] = {EGL_SYNC_NATIVE_FENCE_ANDROID,
EGL_NO_NATIVE_FENCE_FD_ANDROID};
uint64_t sync_handle, thread_handle;
// We don't use rc command to sync if we are using ANGLE on the guest with
// virtio-gpu.
bool useRcCommandToSync = !(mUseAngle && mIsMinigbm);
if (useRcCommandToSync) {
hostCon->lock();
rcEnc->rcCreateSyncKHR(
rcEnc, EGL_SYNC_NATIVE_FENCE_ANDROID, attribs, 2 * sizeof(EGLint),
true /* destroy when signaled */, &sync_handle, &thread_handle);
hostCon->unlock();
}
if (mIsMinigbm) {
auto [_, fence] = mDrmClient->flushToDisplay(
displayId, displayInfo.compositionResultDrmBuffer, -1);
retire_fd = std::move(fence);
} else {
int fd;
goldfish_sync_queue_work(mSyncDeviceFd, sync_handle, thread_handle, &fd);
retire_fd = ::android::base::unique_fd(fd);
}
for (int64_t layerId : releaseLayerIds) {
(*outLayerFences)[layerId] =
::android::base::unique_fd(dup(retire_fd.get()));
}
*outDisplayFence = ::android::base::unique_fd(dup(retire_fd.get()));
if (useRcCommandToSync) {
hostCon->lock();
if (rcEnc->hasAsyncFrameCommands()) {
rcEnc->rcDestroySyncKHRAsync(rcEnc, sync_handle);
} else {
rcEnc->rcDestroySyncKHR(rcEnc, sync_handle);
}
hostCon->unlock();
}
} else {
// we set all layers Composition::CLIENT, so do nothing.
FencedBuffer& displayClientTarget = display->getClientTarget();
::android::base::unique_fd displayClientTargetFence =
displayClientTarget.getFence();
if (mIsMinigbm) {
auto [_, flushFence] = mDrmClient->flushToDisplay(
displayId, displayInfo.compositionResultDrmBuffer,
displayClientTargetFence);
*outDisplayFence = std::move(flushFence);
} else {
post(hostCon, rcEnc, displayClientTarget.getBuffer());
*outDisplayFence = std::move(displayClientTargetFence);
}
ALOGV("%s fallback to post, returns outRetireFence %d", __FUNCTION__,
outDisplayFence->get());
}
return HWC3::Error::None;
}
void HostFrameComposer::post(HostConnection* hostCon,
ExtendedRCEncoderContext* rcEnc,
buffer_handle_t h) {
assert(cb && "native_handle_t::from(h) failed");
hostCon->lock();
rcEnc->rcFBPost(rcEnc, hostCon->grallocHelper()->getHostHandle(h));
hostCon->flush();
hostCon->unlock();
}
HWC3::Error HostFrameComposer::onActiveConfigChange(Display* display) {
DEBUG_LOG("%s: display:%" PRIu64, __FUNCTION__, display->getId());
HWC3::Error error = createHostComposerDisplayInfo(display, display->getId());
if (error != HWC3::Error::None) {
ALOGE("%s failed to update host info for display:%" PRIu64, __FUNCTION__,
display->getId());
return error;
}
return HWC3::Error::None;
}
} // namespace aidl::android::hardware::graphics::composer3::impl