| /* |
| * 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 <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 = static_cast<uint8_t>(color.r * 255.0f); |
| out.g = static_cast<uint8_t>(color.g * 255.0f); |
| out.b = static_cast<uint8_t>(color.b * 255.0f); |
| out.a = static_cast<uint8_t>(color.a * 255.0f); |
| 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; |
| } |
| } |
| |
| 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; |
| }; |
| |
| } // namespace |
| |
| HWC3::Error HostFrameComposer::init() { |
| mIsMinigbm = isMinigbmFromProperty(); |
| |
| 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; |
| displayInfo.swapchain = DrmSwapchain::create( |
| static_cast<uint32_t>(displayWidth), static_cast<uint32_t>(displayHeight), |
| ::android::GraphicBuffer::USAGE_HW_COMPOSER | ::android::GraphicBuffer::USAGE_HW_RENDER, |
| mDrmClient ? &mDrmClient.value() : nullptr); |
| if (!displayInfo.swapchain) { |
| ALOGE("%s: display:%" PRIu64 " failed to allocate swapchain", __FUNCTION__, displayId); |
| return HWC3::Error::NoResources; |
| } |
| return HWC3::Error::None; |
| } |
| |
| HWC3::Error HostFrameComposer::onDisplayCreate(Display* display) { |
| HWC3::Error error = HWC3::Error::None; |
| |
| const uint32_t displayId = static_cast<uint32_t>(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:%" PRIu32 " has no active config", __FUNCTION__, displayId); |
| return error; |
| } |
| |
| error = display->getDisplayAttribute(displayConfigId, DisplayAttribute::WIDTH, &displayWidth); |
| if (error != HWC3::Error::None) { |
| ALOGE("%s: display:%" PRIu32 " failed to get width", __FUNCTION__, displayId); |
| return error; |
| } |
| |
| error = display->getDisplayAttribute(displayConfigId, DisplayAttribute::HEIGHT, &displayHeight); |
| if (error != HWC3::Error::None) { |
| ALOGE("%s: display:%" PRIu32 " failed to get height", __FUNCTION__, displayId); |
| return error; |
| } |
| |
| error = display->getDisplayAttribute(displayConfigId, DisplayAttribute::DPI_X, &displayDpiX); |
| if (error != HWC3::Error::None) { |
| ALOGE("%s: display:%" PRIu32 " 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 %" PRIu32, __func__, displayId); |
| hostCon->unlock(); |
| return HWC3::Error::NoResources; |
| } |
| if (rcEnc->rcSetDisplayPoseDpi( |
| rcEnc, displayId, -1, -1, static_cast<uint32_t>(displayWidth), |
| static_cast<uint32_t>(displayHeight), static_cast<uint32_t>(displayDpiX / 1000))) { |
| ALOGE("%s host failed to set display %" PRIu32, __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, |
| static_cast<uint32_t>(displayWidth), |
| static_cast<uint32_t>(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:%" PRIu32, __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(); |
| } |
| |
| 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); |
| std::unordered_map<Layer*, Composition> changes; |
| |
| if (!fallBackToClient) { |
| for (const auto& layer : layers) { |
| const auto& layerCompositionType = layer->getCompositionType(); |
| const auto layerCompositionTypeString = toString(layerCompositionType); |
| |
| std::optional<Composition> layerFallBackTo = std::nullopt; |
| switch (layerCompositionType) { |
| case Composition::CLIENT: |
| case Composition::SIDEBAND: |
| ALOGV("%s: layer %" PRIu32 " CompositionType %s, fallback to client", |
| __FUNCTION__, static_cast<uint32_t>(layer->getId()), |
| layerCompositionTypeString.c_str()); |
| layerFallBackTo = Composition::CLIENT; |
| break; |
| case Composition::CURSOR: |
| ALOGV("%s: layer %" PRIu32 " CompositionType %s, fallback to device", |
| __FUNCTION__, static_cast<uint32_t>(layer->getId()), |
| layerCompositionTypeString.c_str()); |
| 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: %s", __FUNCTION__, |
| static_cast<uint32_t>(layer->getId()), layerCompositionTypeString.c_str()); |
| } |
| if (layerFallBackTo == Composition::CLIENT) { |
| fallBackToClient = true; |
| } |
| if (layerFallBackTo.has_value()) { |
| changes.emplace(layer, layerFallBackTo.value()); |
| } |
| } |
| } |
| |
| if (fallBackToClient) { |
| changes.clear(); |
| for (auto& layer : layers) { |
| if (layer->getCompositionType() == Composition::INVALID) { |
| continue; |
| } |
| if (layer->getCompositionType() != Composition::CLIENT) { |
| changes.emplace(layer, Composition::CLIENT); |
| } |
| } |
| } |
| |
| outChanges->clearLayerCompositionChanges(); |
| for (auto& [layer, newCompositionType] : changes) { |
| layer->logCompositionFallbackIfChanged(newCompositionType); |
| outChanges->addLayerCompositionChange(displayId, layer->getId(), newCompositionType); |
| } |
| |
| 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) { |
| const uint32_t displayId = static_cast<uint32_t>(display->getId()); |
| auto displayInfoIt = mDisplayInfos.find(displayId); |
| if (displayInfoIt == mDisplayInfos.end()) { |
| ALOGE("%s: failed to find display buffers for display:%" PRIu32, __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; |
| } |
| *outDisplayFence = ::android::base::unique_fd(); |
| hostCon->lock(); |
| bool hostCompositionV1 = rcEnc->hasHostCompositionV1(); |
| bool hostCompositionV2 = rcEnc->hasHostCompositionV2(); |
| hostCon->unlock(); |
| |
| // Ff we supports v2, then discard v1 |
| if (hostCompositionV2) { |
| hostCompositionV1 = false; |
| } |
| |
| auto compositionResult = displayInfo.swapchain->getNextImage(); |
| compositionResult->wait(); |
| |
| 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:%" PRIu32 " 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, displayInfo.hostDisplayId, 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) { |
| const auto& layerCompositionType = layer->getCompositionType(); |
| const auto layerCompositionTypeString = toString(layerCompositionType); |
| |
| // TODO: use local var composisitonType to store getCompositionType() |
| if (layerCompositionType != Composition::DEVICE && |
| layerCompositionType != Composition::SOLID_COLOR) { |
| ALOGE("%s: Unsupported composition type %s layer %u", __FUNCTION__, |
| layerCompositionTypeString.c_str(), (uint32_t)layer->getId()); |
| continue; |
| } |
| // send layer composition command to host |
| if (layerCompositionType == 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)layerCompositionType; |
| 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(compositionResult->getBuffer()); |
| p->numLayers = numLayer; |
| } else { |
| p2->version = 2; |
| p2->displayId = displayInfo.hostDisplayId; |
| p2->targetHandle = |
| hostCon->grallocHelper()->getHostHandle(compositionResult->getBuffer()); |
| 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 virtio-gpu, which is |
| // proxied by minigbm. |
| bool useRcCommandToSync = !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, compositionResult->getDrmBuffer(), -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, compositionResult->getDrmBuffer(), displayClientTargetFence); |
| *outDisplayFence = std::move(flushFence); |
| } else { |
| post(hostCon, rcEnc, displayInfo.hostDisplayId, displayClientTarget.getBuffer()); |
| *outDisplayFence = std::move(displayClientTargetFence); |
| } |
| ALOGV("%s fallback to post, returns outRetireFence %d", __FUNCTION__, |
| outDisplayFence->get()); |
| } |
| compositionResult->markAsInUse(outDisplayFence->ok() |
| ? ::android::base::unique_fd(dup(*outDisplayFence)) |
| : ::android::base::unique_fd()); |
| return HWC3::Error::None; |
| } |
| |
| void HostFrameComposer::post(HostConnection* hostCon, ExtendedRCEncoderContext* rcEnc, |
| uint32_t hostDisplayId, buffer_handle_t h) { |
| assert(cb && "native_handle_t::from(h) failed"); |
| |
| hostCon->lock(); |
| rcEnc->rcSetDisplayColorBuffer( |
| rcEnc, hostDisplayId, |
| hostCon->grallocHelper()->getHostHandle(h)); |
| rcEnc->rcFBPost(rcEnc, hostCon->grallocHelper()->getHostHandle(h)); |
| hostCon->flush(); |
| hostCon->unlock(); |
| } |
| |
| HWC3::Error HostFrameComposer::onActiveConfigChange(Display* display) { |
| const uint32_t displayId = static_cast<uint32_t>(display->getId()); |
| DEBUG_LOG("%s: display:%" PRIu32, __FUNCTION__, displayId); |
| HWC3::Error error = createHostComposerDisplayInfo(display, displayId); |
| if (error != HWC3::Error::None) { |
| ALOGE("%s failed to update host info for display:%" PRIu32, __FUNCTION__, displayId); |
| return error; |
| } |
| return HWC3::Error::None; |
| } |
| |
| } // namespace aidl::android::hardware::graphics::composer3::impl |
