summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--include/android/sensor.h1
-rw-r--r--include/gui/FrameTimestamps.h2
-rw-r--r--libs/gui/FrameTimestamps.cpp13
-rw-r--r--services/surfaceflinger/Android.mk5
-rw-r--r--services/surfaceflinger/DisplayHardware/ComposerHal.cpp759
-rw-r--r--services/surfaceflinger/DisplayHardware/ComposerHal.h186
-rw-r--r--services/surfaceflinger/DisplayHardware/HWC2.cpp33
7 files changed, 703 insertions, 296 deletions
diff --git a/include/android/sensor.h b/include/android/sensor.h
index b6a42ae34b..4a0081850f 100644
--- a/include/android/sensor.h
+++ b/include/android/sensor.h
@@ -397,6 +397,7 @@ int ASensorManager_destroyEventQueue(ASensorManager* manager, ASensorEventQueue*
/**
* Enable the selected sensor with a specified sampling period and max batch report latency.
* Returns a negative error code on failure.
+ * Note: To disable the selected sensor, use ASensorEventQueue_disableSensor() same as before.
*/
int ASensorEventQueue_registerSensor(ASensorEventQueue* queue, ASensor const* sensor,
int32_t samplingPeriodUs, int maxBatchReportLatencyUs);
diff --git a/include/gui/FrameTimestamps.h b/include/gui/FrameTimestamps.h
index a1d4e07597..8a3fa39956 100644
--- a/include/gui/FrameTimestamps.h
+++ b/include/gui/FrameTimestamps.h
@@ -199,6 +199,8 @@ private:
size_t mCompositionOffset{0};
size_t mRetireOffset{0};
size_t mReleaseOffset{0};
+
+ bool mProducerWantsEvents{false};
};
diff --git a/libs/gui/FrameTimestamps.cpp b/libs/gui/FrameTimestamps.cpp
index 6503e9cc47..c9b894833b 100644
--- a/libs/gui/FrameTimestamps.cpp
+++ b/libs/gui/FrameTimestamps.cpp
@@ -349,7 +349,7 @@ void ConsumerFrameEventHistory::addLatch(
uint64_t frameNumber, nsecs_t latchTime) {
FrameEvents* frame = getFrame(frameNumber, &mCompositionOffset);
if (frame == nullptr) {
- ALOGE("ConsumerFrameEventHistory::addLatch: Did not find frame.");
+ ALOGE_IF(mProducerWantsEvents, "addLatch: Did not find frame.");
return;
}
frame->latchTime = latchTime;
@@ -360,8 +360,8 @@ void ConsumerFrameEventHistory::addPreComposition(
uint64_t frameNumber, nsecs_t refreshStartTime) {
FrameEvents* frame = getFrame(frameNumber, &mCompositionOffset);
if (frame == nullptr) {
- ALOGE("ConsumerFrameEventHistory::addPreComposition: "
- "Did not find frame.");
+ ALOGE_IF(mProducerWantsEvents,
+ "addPreComposition: Did not find frame.");
return;
}
frame->lastRefreshStartTime = refreshStartTime;
@@ -377,8 +377,8 @@ void ConsumerFrameEventHistory::addPostComposition(uint64_t frameNumber,
const std::shared_ptr<FenceTime>& displayPresent) {
FrameEvents* frame = getFrame(frameNumber, &mCompositionOffset);
if (frame == nullptr) {
- ALOGE("ConsumerFrameEventHistory::addPostComposition: "
- "Did not find frame.");
+ ALOGE_IF(mProducerWantsEvents,
+ "addPostComposition: Did not find frame.");
return;
}
// Only get GPU and present info for the first composite.
@@ -397,7 +397,7 @@ void ConsumerFrameEventHistory::addRetire(
uint64_t frameNumber, const std::shared_ptr<FenceTime>& displayRetire) {
FrameEvents* frame = getFrame(frameNumber, &mRetireOffset);
if (frame == nullptr) {
- ALOGE("ConsumerFrameEventHistory::addRetire: Did not find frame.");
+ ALOGE_IF(mProducerWantsEvents, "addRetire: Did not find frame.");
return;
}
frame->addRetireCalled = true;
@@ -420,6 +420,7 @@ void ConsumerFrameEventHistory::addRelease(
void ConsumerFrameEventHistory::getFrameDelta(
FrameEventHistoryDelta* delta,
const std::array<FrameEvents, MAX_FRAME_HISTORY>::iterator& frame) {
+ mProducerWantsEvents = true;
size_t i = static_cast<size_t>(std::distance(mFrames.begin(), frame));
if (mFramesDirty[i].anyDirty()) {
delta->mDeltas.emplace_back(i, *frame, mFramesDirty[i]);
diff --git a/services/surfaceflinger/Android.mk b/services/surfaceflinger/Android.mk
index 20fe0fdbd3..4987a18294 100644
--- a/services/surfaceflinger/Android.mk
+++ b/services/surfaceflinger/Android.mk
@@ -42,6 +42,7 @@ LOCAL_MODULE := libsurfaceflinger
LOCAL_C_INCLUDES := \
frameworks/native/vulkan/include \
external/vulkan-validation-layers/libs/vkjson \
+ system/libhwbinder/fast_msgq/include \
LOCAL_CFLAGS := -DLOG_TAG=\"SurfaceFlinger\"
LOCAL_CFLAGS += -DGL_GLEXT_PROTOTYPES -DEGL_EGLEXT_PROTOTYPES
@@ -130,13 +131,14 @@ endif
LOCAL_CFLAGS += -fvisibility=hidden -Werror=format
-LOCAL_STATIC_LIBRARIES := libtrace_proto libvkjson
+LOCAL_STATIC_LIBRARIES := libhwcomposer-command-buffer libtrace_proto libvkjson
LOCAL_SHARED_LIBRARIES := \
android.hardware.graphics.allocator@2.0 \
android.hardware.graphics.composer@2.1 \
libcutils \
liblog \
libdl \
+ libfmq \
libhardware \
libhidlbase \
libhidltransport \
@@ -150,6 +152,7 @@ LOCAL_SHARED_LIBRARIES := \
libgui \
libpowermanager \
libvulkan \
+ libsync \
libprotobuf-cpp-lite \
libbase \
android.hardware.power@1.0
diff --git a/services/surfaceflinger/DisplayHardware/ComposerHal.cpp b/services/surfaceflinger/DisplayHardware/ComposerHal.cpp
index 06f67baf86..63fd1e8ebe 100644
--- a/services/surfaceflinger/DisplayHardware/ComposerHal.cpp
+++ b/services/surfaceflinger/DisplayHardware/ComposerHal.cpp
@@ -110,17 +110,29 @@ void assignFromHidlVec(std::vector<T>& vec, const hidl_vec<T>& data)
} // anonymous namespace
Composer::Composer()
+ : mWriter(kWriterInitialSize)
{
- mService = IComposer::getService("hwcomposer");
- if (mService == nullptr) {
+ mComposer = IComposer::getService("hwcomposer");
+ if (mComposer == nullptr) {
LOG_ALWAYS_FATAL("failed to get hwcomposer service");
}
+
+ mComposer->createClient(
+ [&](const auto& tmpError, const auto& tmpClient)
+ {
+ if (tmpError == Error::NONE) {
+ mClient = tmpClient;
+ }
+ });
+ if (mClient == nullptr) {
+ LOG_ALWAYS_FATAL("failed to create composer client");
+ }
}
-std::vector<IComposer::Capability> Composer::getCapabilities() const
+std::vector<IComposer::Capability> Composer::getCapabilities()
{
std::vector<IComposer::Capability> capabilities;
- mService->getCapabilities(
+ mComposer->getCapabilities(
[&](const auto& tmpCapabilities) {
assignFromHidlVec(capabilities, tmpCapabilities);
});
@@ -128,35 +140,36 @@ std::vector<IComposer::Capability> Composer::getCapabilities() const
return capabilities;
}
-std::string Composer::dumpDebugInfo() const
+std::string Composer::dumpDebugInfo()
{
std::string info;
- mService->dumpDebugInfo([&](const auto& tmpInfo) {
+ mComposer->dumpDebugInfo([&](const auto& tmpInfo) {
info = tmpInfo.c_str();
});
return info;
}
-void Composer::registerCallback(const sp<IComposerCallback>& callback) const
+void Composer::registerCallback(const sp<IComposerCallback>& callback)
{
- auto ret = mService->registerCallback(callback);
+ auto ret = mClient->registerCallback(callback);
if (!ret.getStatus().isOk()) {
ALOGE("failed to register IComposerCallback");
}
}
-uint32_t Composer::getMaxVirtualDisplayCount() const
+uint32_t Composer::getMaxVirtualDisplayCount()
{
- auto ret = mService->getMaxVirtualDisplayCount();
+ auto ret = mClient->getMaxVirtualDisplayCount();
return unwrapRet(ret, 0);
}
Error Composer::createVirtualDisplay(uint32_t width, uint32_t height,
- PixelFormat& format, Display& display) const
+ PixelFormat& format, Display& display)
{
+ const uint32_t bufferSlotCount = 1;
Error error = kDefaultError;
- mService->createVirtualDisplay(width, height, format,
+ mClient->createVirtualDisplay(width, height, format, bufferSlotCount,
[&](const auto& tmpError, const auto& tmpDisplay,
const auto& tmpFormat) {
error = tmpError;
@@ -171,22 +184,24 @@ Error Composer::createVirtualDisplay(uint32_t width, uint32_t height,
return error;
}
-Error Composer::destroyVirtualDisplay(Display display) const
+Error Composer::destroyVirtualDisplay(Display display)
{
- auto ret = mService->destroyVirtualDisplay(display);
+ auto ret = mClient->destroyVirtualDisplay(display);
return unwrapRet(ret);
}
-Error Composer::acceptDisplayChanges(Display display) const
+Error Composer::acceptDisplayChanges(Display display)
{
- auto ret = mService->acceptDisplayChanges(display);
- return unwrapRet(ret);
+ mWriter.selectDisplay(display);
+ mWriter.acceptDisplayChanges();
+ return Error::NONE;
}
-Error Composer::createLayer(Display display, Layer& layer) const
+Error Composer::createLayer(Display display, Layer& layer)
{
+ const uint32_t bufferSlotCount = 1;
Error error = kDefaultError;
- mService->createLayer(display,
+ mClient->createLayer(display, bufferSlotCount,
[&](const auto& tmpError, const auto& tmpLayer) {
error = tmpError;
if (error != Error::NONE) {
@@ -199,16 +214,16 @@ Error Composer::createLayer(Display display, Layer& layer) const
return error;
}
-Error Composer::destroyLayer(Display display, Layer layer) const
+Error Composer::destroyLayer(Display display, Layer layer)
{
- auto ret = mService->destroyLayer(display, layer);
+ auto ret = mClient->destroyLayer(display, layer);
return unwrapRet(ret);
}
-Error Composer::getActiveConfig(Display display, Config& config) const
+Error Composer::getActiveConfig(Display display, Config& config)
{
Error error = kDefaultError;
- mService->getActiveConfig(display,
+ mClient->getActiveConfig(display,
[&](const auto& tmpError, const auto& tmpConfig) {
error = tmpError;
if (error != Error::NONE) {
@@ -223,29 +238,17 @@ Error Composer::getActiveConfig(Display display, Config& config) const
Error Composer::getChangedCompositionTypes(Display display,
std::vector<Layer>& layers,
- std::vector<IComposer::Composition>& types) const
+ std::vector<IComposerClient::Composition>& types)
{
- Error error = kDefaultError;
- mService->getChangedCompositionTypes(display,
- [&](const auto& tmpError, const auto& tmpLayers,
- const auto& tmpTypes) {
- error = tmpError;
- if (error != Error::NONE) {
- return;
- }
-
- assignFromHidlVec(layers, tmpLayers);
- assignFromHidlVec(types, tmpTypes);
- });
-
- return error;
+ mReader.takeChangedCompositionTypes(display, layers, types);
+ return Error::NONE;
}
Error Composer::getColorModes(Display display,
- std::vector<ColorMode>& modes) const
+ std::vector<ColorMode>& modes)
{
Error error = kDefaultError;
- mService->getColorModes(display,
+ mClient->getColorModes(display,
[&](const auto& tmpError, const auto& tmpModes) {
error = tmpError;
if (error != Error::NONE) {
@@ -259,10 +262,10 @@ Error Composer::getColorModes(Display display,
}
Error Composer::getDisplayAttribute(Display display, Config config,
- IComposer::Attribute attribute, int32_t& value) const
+ IComposerClient::Attribute attribute, int32_t& value)
{
Error error = kDefaultError;
- mService->getDisplayAttribute(display, config, attribute,
+ mClient->getDisplayAttribute(display, config, attribute,
[&](const auto& tmpError, const auto& tmpValue) {
error = tmpError;
if (error != Error::NONE) {
@@ -276,10 +279,10 @@ Error Composer::getDisplayAttribute(Display display, Config config,
}
Error Composer::getDisplayConfigs(Display display,
- std::vector<Config>& configs) const
+ std::vector<Config>& configs)
{
Error error = kDefaultError;
- mService->getDisplayConfigs(display,
+ mClient->getDisplayConfigs(display,
[&](const auto& tmpError, const auto& tmpConfigs) {
error = tmpError;
if (error != Error::NONE) {
@@ -292,10 +295,10 @@ Error Composer::getDisplayConfigs(Display display,
return error;
}
-Error Composer::getDisplayName(Display display, std::string& name) const
+Error Composer::getDisplayName(Display display, std::string& name)
{
Error error = kDefaultError;
- mService->getDisplayName(display,
+ mClient->getDisplayName(display,
[&](const auto& tmpError, const auto& tmpName) {
error = tmpError;
if (error != Error::NONE) {
@@ -310,29 +313,17 @@ Error Composer::getDisplayName(Display display, std::string& name) const
Error Composer::getDisplayRequests(Display display,
uint32_t& displayRequestMask, std::vector<Layer>& layers,
- std::vector<uint32_t>& layerRequestMasks) const
+ std::vector<uint32_t>& layerRequestMasks)
{
- Error error = kDefaultError;
- mService->getDisplayRequests(display,
- [&](const auto& tmpError, const auto& tmpDisplayRequestMask,
- const auto& tmpLayers, const auto& tmpLayerRequestMasks) {
- error = tmpError;
- if (error != Error::NONE) {
- return;
- }
-
- displayRequestMask = tmpDisplayRequestMask;
- assignFromHidlVec(layers, tmpLayers);
- assignFromHidlVec(layerRequestMasks, tmpLayerRequestMasks);
- });
-
- return error;
+ mReader.takeDisplayRequests(display, displayRequestMask,
+ layers, layerRequestMasks);
+ return Error::NONE;
}
-Error Composer::getDisplayType(Display display, IComposer::DisplayType& type) const
+Error Composer::getDisplayType(Display display, IComposerClient::DisplayType& type)
{
Error error = kDefaultError;
- mService->getDisplayType(display,
+ mClient->getDisplayType(display,
[&](const auto& tmpError, const auto& tmpType) {
error = tmpError;
if (error != Error::NONE) {
@@ -345,10 +336,10 @@ Error Composer::getDisplayType(Display display, IComposer::DisplayType& type) co
return error;
}
-Error Composer::getDozeSupport(Display display, bool& support) const
+Error Composer::getDozeSupport(Display display, bool& support)
{
Error error = kDefaultError;
- mService->getDozeSupport(display,
+ mClient->getDozeSupport(display,
[&](const auto& tmpError, const auto& tmpSupport) {
error = tmpError;
if (error != Error::NONE) {
@@ -363,10 +354,10 @@ Error Composer::getDozeSupport(Display display, bool& support) const
Error Composer::getHdrCapabilities(Display display, std::vector<Hdr>& types,
float& maxLuminance, float& maxAverageLuminance,
- float& minLuminance) const
+ float& minLuminance)
{
Error error = kDefaultError;
- mService->getHdrCapabilities(display,
+ mClient->getHdrCapabilities(display,
[&](const auto& tmpError, const auto& tmpTypes,
const auto& tmpMaxLuminance,
const auto& tmpMaxAverageLuminance,
@@ -386,266 +377,574 @@ Error Composer::getHdrCapabilities(Display display, std::vector<Hdr>& types,
}
Error Composer::getReleaseFences(Display display, std::vector<Layer>& layers,
- std::vector<int>& releaseFences) const
+ std::vector<int>& releaseFences)
{
- Error error = kDefaultError;
- mService->getReleaseFences(display,
- [&](const auto& tmpError, const auto& tmpLayers,
- const auto& tmpReleaseFences) {
- error = tmpError;
- if (error != Error::NONE) {
- return;
- }
-
- if (static_cast<int>(tmpLayers.size()) !=
- tmpReleaseFences->numFds) {
- ALOGE("invalid releaseFences outputs: "
- "layer count %zu != fence count %d",
- tmpLayers.size(), tmpReleaseFences->numFds);
- error = Error::NO_RESOURCES;
- return;
- }
-
- // dup the file descriptors
- std::vector<int> tmpFds;
- tmpFds.reserve(tmpReleaseFences->numFds);
- for (int i = 0; i < tmpReleaseFences->numFds; i++) {
- int fd = dup(tmpReleaseFences->data[i]);
- if (fd < 0) {
- break;
- }
- tmpFds.push_back(fd);
- }
- if (static_cast<int>(tmpFds.size()) <
- tmpReleaseFences->numFds) {
- for (auto fd : tmpFds) {
- close(fd);
- }
-
- error = Error::NO_RESOURCES;
- return;
- }
-
- assignFromHidlVec(layers, tmpLayers);
- releaseFences = std::move(tmpFds);
- });
-
- return error;
+ mReader.takeReleaseFences(display, layers, releaseFences);
+ return Error::NONE;
}
-Error Composer::presentDisplay(Display display, int& presentFence) const
+Error Composer::presentDisplay(Display display, int& presentFence)
{
- Error error = kDefaultError;
- mService->presentDisplay(display,
- [&](const auto& tmpError, const auto& tmpPresentFence) {
- error = tmpError;
- if (error != Error::NONE) {
- return;
- }
+ mWriter.selectDisplay(display);
+ mWriter.presentDisplay();
- if (tmpPresentFence->numFds == 1) {
- int fd = dup(tmpPresentFence->data[0]);
- if (fd >= 0) {
- presentFence = fd;
- } else {
- error = Error::NO_RESOURCES;
- }
- } else {
- presentFence = -1;
- }
- });
+ Error error = execute();
+ if (error != Error::NONE) {
+ return error;
+ }
- return error;
+ mReader.takePresentFence(display, presentFence);
+
+ return Error::NONE;
}
-Error Composer::setActiveConfig(Display display, Config config) const
+Error Composer::setActiveConfig(Display display, Config config)
{
- auto ret = mService->setActiveConfig(display, config);
+ auto ret = mClient->setActiveConfig(display, config);
return unwrapRet(ret);
}
Error Composer::setClientTarget(Display display, const native_handle_t* target,
int acquireFence, Dataspace dataspace,
- const std::vector<IComposer::Rect>& damage) const
+ const std::vector<IComposerClient::Rect>& damage)
{
- BufferHandle tmpTarget(target);
- FenceHandle tmpAcquireFence(acquireFence, true);
-
- hidl_vec<IComposer::Rect> tmpDamage;
- tmpDamage.setToExternal(const_cast<IComposer::Rect*>(damage.data()),
- damage.size());
-
- auto ret = mService->setClientTarget(display, tmpTarget,
- tmpAcquireFence, dataspace, tmpDamage);
- return unwrapRet(ret);
+ mWriter.selectDisplay(display);
+ mWriter.setClientTarget(0, target, acquireFence, dataspace, damage);
+ return Error::NONE;
}
-Error Composer::setColorMode(Display display, ColorMode mode) const
+Error Composer::setColorMode(Display display, ColorMode mode)
{
- auto ret = mService->setColorMode(display, mode);
+ auto ret = mClient->setColorMode(display, mode);
return unwrapRet(ret);
}
Error Composer::setColorTransform(Display display, const float* matrix,
- ColorTransform hint) const
+ ColorTransform hint)
{
- hidl_vec<float> tmpMatrix;
- tmpMatrix.setToExternal(const_cast<float*>(matrix), 16);
-
- auto ret = mService->setColorTransform(display, tmpMatrix, hint);
- return unwrapRet(ret);
+ mWriter.selectDisplay(display);
+ mWriter.setColorTransform(matrix, hint);
+ return Error::NONE;
}
Error Composer::setOutputBuffer(Display display, const native_handle_t* buffer,
- int releaseFence) const
+ int releaseFence)
{
- BufferHandle tmpBuffer(buffer);
- FenceHandle tmpReleaseFence(releaseFence, false);
+ mWriter.selectDisplay(display);
+ mWriter.setOutputBuffer(0, buffer, dup(releaseFence));
+ return Error::NONE;
+}
- auto ret = mService->setOutputBuffer(display, tmpBuffer, tmpReleaseFence);
+Error Composer::setPowerMode(Display display, IComposerClient::PowerMode mode)
+{
+ auto ret = mClient->setPowerMode(display, mode);
return unwrapRet(ret);
}
-Error Composer::setPowerMode(Display display, IComposer::PowerMode mode) const
+Error Composer::setVsyncEnabled(Display display, IComposerClient::Vsync enabled)
{
- auto ret = mService->setPowerMode(display, mode);
+ auto ret = mClient->setVsyncEnabled(display, enabled);
return unwrapRet(ret);
}
-Error Composer::setVsyncEnabled(Display display, IComposer::Vsync enabled) const
+Error Composer::setClientTargetSlotCount(Display display)
{
- auto ret = mService->setVsyncEnabled(display, enabled);
+ const uint32_t bufferSlotCount = 1;
+ auto ret = mClient->setClientTargetSlotCount(display, bufferSlotCount);
return unwrapRet(ret);
}
-Error Composer::validateDisplay(Display display, uint32_t& numTypes, uint32_t&
- numRequests) const
+Error Composer::validateDisplay(Display display, uint32_t& numTypes,
+ uint32_t& numRequests)
{
- Error error = kDefaultError;
- mService->validateDisplay(display,
- [&](const auto& tmpError, const auto& tmpNumTypes,
- const auto& tmpNumRequests) {
- error = tmpError;
- if (error != Error::NONE) {
- return;
- }
+ mWriter.selectDisplay(display);
+ mWriter.validateDisplay();
- numTypes = tmpNumTypes;
- numRequests = tmpNumRequests;
- });
+ Error error = execute();
+ if (error != Error::NONE) {
+ return error;
+ }
- return error;
+ mReader.hasChanges(display, numTypes, numRequests);
+
+ return Error::NONE;
}
Error Composer::setCursorPosition(Display display, Layer layer,
- int32_t x, int32_t y) const
+ int32_t x, int32_t y)
{
- auto ret = mService->setCursorPosition(display, layer, x, y);
- return unwrapRet(ret);
+ mWriter.selectDisplay(display);
+ mWriter.selectLayer(layer);
+ mWriter.setLayerCursorPosition(x, y);
+ return Error::NONE;
}
Error Composer::setLayerBuffer(Display display, Layer layer,
- const native_handle_t* buffer, int acquireFence) const
+ const native_handle_t* buffer, int acquireFence)
{
- BufferHandle tmpBuffer(buffer);
- FenceHandle tmpAcquireFence(acquireFence, true);
-
- auto ret = mService->setLayerBuffer(display, layer,
- tmpBuffer, tmpAcquireFence);
- return unwrapRet(ret);
+ mWriter.selectDisplay(display);
+ mWriter.selectLayer(layer);
+ mWriter.setLayerBuffer(0, buffer, acquireFence);
+ return Error::NONE;
}
Error Composer::setLayerSurfaceDamage(Display display, Layer layer,
- const std::vector<IComposer::Rect>& damage) const
+ const std::vector<IComposerClient::Rect>& damage)
{
- hidl_vec<IComposer::Rect> tmpDamage;
- tmpDamage.setToExternal(const_cast<IComposer::Rect*>(damage.data()),
- damage.size());
-
- auto ret = mService->setLayerSurfaceDamage(display, layer, tmpDamage);
- return unwrapRet(ret);
+ mWriter.selectDisplay(display);
+ mWriter.selectLayer(layer);
+ mWriter.setLayerSurfaceDamage(damage);
+ return Error::NONE;
}
Error Composer::setLayerBlendMode(Display display, Layer layer,
- IComposer::BlendMode mode) const
+ IComposerClient::BlendMode mode)
{
- auto ret = mService->setLayerBlendMode(display, layer, mode);
- return unwrapRet(ret);
+ mWriter.selectDisplay(display);
+ mWriter.selectLayer(layer);
+ mWriter.setLayerBlendMode(mode);
+ return Error::NONE;
}
Error Composer::setLayerColor(Display display, Layer layer,
- const IComposer::Color& color) const
+ const IComposerClient::Color& color)
{
- auto ret = mService->setLayerColor(display, layer, color);
- return unwrapRet(ret);
+ mWriter.selectDisplay(display);
+ mWriter.selectLayer(layer);
+ mWriter.setLayerColor(color);
+ return Error::NONE;
}
Error Composer::setLayerCompositionType(Display display, Layer layer,
- IComposer::Composition type) const
+ IComposerClient::Composition type)
{
- auto ret = mService->setLayerCompositionType(display, layer, type);
- return unwrapRet(ret);
+ mWriter.selectDisplay(display);
+ mWriter.selectLayer(layer);
+ mWriter.setLayerCompositionType(type);
+ return Error::NONE;
}
Error Composer::setLayerDataspace(Display display, Layer layer,
- Dataspace dataspace) const
+ Dataspace dataspace)
{
- auto ret = mService->setLayerDataspace(display, layer, dataspace);
- return unwrapRet(ret);
+ mWriter.selectDisplay(display);
+ mWriter.selectLayer(layer);
+ mWriter.setLayerDataspace(dataspace);
+ return Error::NONE;
}
Error Composer::setLayerDisplayFrame(Display display, Layer layer,
- const IComposer::Rect& frame) const
+ const IComposerClient::Rect& frame)
{
- auto ret = mService->setLayerDisplayFrame(display, layer, frame);
- return unwrapRet(ret);
+ mWriter.selectDisplay(display);
+ mWriter.selectLayer(layer);
+ mWriter.setLayerDisplayFrame(frame);
+ return Error::NONE;
}
Error Composer::setLayerPlaneAlpha(Display display, Layer layer,
- float alpha) const
+ float alpha)
{
- auto ret = mService->setLayerPlaneAlpha(display, layer, alpha);
- return unwrapRet(ret);
+ mWriter.selectDisplay(display);
+ mWriter.selectLayer(layer);
+ mWriter.setLayerPlaneAlpha(alpha);
+ return Error::NONE;
}
Error Composer::setLayerSidebandStream(Display display, Layer layer,
- const native_handle_t* stream) const
+ const native_handle_t* stream)
{
- BufferHandle tmpStream(stream);
-
- auto ret = mService->setLayerSidebandStream(display, layer, tmpStream);
- return unwrapRet(ret);
+ mWriter.selectDisplay(display);
+ mWriter.selectLayer(layer);
+ mWriter.setLayerSidebandStream(stream);
+ return Error::NONE;
}
Error Composer::setLayerSourceCrop(Display display, Layer layer,
- const IComposer::FRect& crop) const
+ const IComposerClient::FRect& crop)
{
- auto ret = mService->setLayerSourceCrop(display, layer, crop);
- return unwrapRet(ret);
+ mWriter.selectDisplay(display);
+ mWriter.selectLayer(layer);
+ mWriter.setLayerSourceCrop(crop);
+ return Error::NONE;
}
Error Composer::setLayerTransform(Display display, Layer layer,
- Transform transform) const
+ Transform transform)
{
- auto ret = mService->setLayerTransform(display, layer, transform);
- return unwrapRet(ret);
+ mWriter.selectDisplay(display);
+ mWriter.selectLayer(layer);
+ mWriter.setLayerTransform(transform);
+ return Error::NONE;
}
Error Composer::setLayerVisibleRegion(Display display, Layer layer,
- const std::vector<IComposer::Rect>& visible) const
+ const std::vector<IComposerClient::Rect>& visible)
{
- hidl_vec<IComposer::Rect> tmpVisible;
- tmpVisible.setToExternal(const_cast<IComposer::Rect*>(visible.data()),
- visible.size());
+ mWriter.selectDisplay(display);
+ mWriter.selectLayer(layer);
+ mWriter.setLayerVisibleRegion(visible);
+ return Error::NONE;
+}
- auto ret = mService->setLayerVisibleRegion(display, layer, tmpVisible);
- return unwrapRet(ret);
+Error Composer::setLayerZOrder(Display display, Layer layer, uint32_t z)
+{
+ mWriter.selectDisplay(display);
+ mWriter.selectLayer(layer);
+ mWriter.setLayerZOrder(z);
+ return Error::NONE;
}
-Error Composer::setLayerZOrder(Display display, Layer layer, uint32_t z) const
+Error Composer::execute()
{
- auto ret = mService->setLayerZOrder(display, layer, z);
- return unwrapRet(ret);
+ // prepare input command queue
+ bool queueChanged = false;
+ uint32_t commandLength = 0;
+ hidl_vec<hidl_handle> commandHandles;
+ if (!mWriter.writeQueue(queueChanged, commandLength, commandHandles)) {
+ mWriter.reset();
+ return Error::NO_RESOURCES;
+ }
+
+ // set up new input command queue if necessary
+ if (queueChanged) {
+ auto ret = mClient->setInputCommandQueue(*mWriter.getMQDescriptor());
+ auto error = unwrapRet(ret);
+ if (error != Error::NONE) {
+ mWriter.reset();
+ return error;
+ }
+ }
+
+ Error error = kDefaultError;
+ mClient->executeCommands(commandLength, commandHandles,
+ [&](const auto& tmpError, const auto& tmpOutChanged,
+ const auto& tmpOutLength, const auto& tmpOutHandles)
+ {
+ error = tmpError;
+
+ // set up new output command queue if necessary
+ if (error == Error::NONE && tmpOutChanged) {
+ error = kDefaultError;
+ mClient->getOutputCommandQueue(
+ [&](const auto& tmpError,
+ const auto& tmpDescriptor)
+ {
+ error = tmpError;
+ if (error != Error::NONE) {
+ return;
+ }
+
+ mReader.setMQDescriptor(tmpDescriptor);
+ });
+ }
+
+ if (error != Error::NONE) {
+ return;
+ }
+
+ if (mReader.readQueue(tmpOutLength, tmpOutHandles)) {
+ error = mReader.parse();
+ mReader.reset();
+ } else {
+ error = Error::NO_RESOURCES;
+ }
+ });
+
+ if (error == Error::NONE) {
+ std::vector<CommandReader::CommandError> commandErrors =
+ mReader.takeErrors();
+
+ for (const auto& cmdErr : commandErrors) {
+ auto command = mWriter.getCommand(cmdErr.location);
+
+ if (command == IComposerClient::Command::VALIDATE_DISPLAY ||
+ command == IComposerClient::Command::PRESENT_DISPLAY) {
+ error = cmdErr.error;
+ } else {
+ ALOGW("command 0x%x generated error %d",
+ command, cmdErr.error);
+ }
+ }
+ }
+
+ mWriter.reset();
+
+ return error;
+}
+
+CommandReader::~CommandReader()
+{
+ resetData();
+}
+
+Error CommandReader::parse()
+{
+ resetData();
+
+ IComposerClient::Command command;
+ uint16_t length = 0;
+
+ while (!isEmpty()) {
+ if (!beginCommand(command, length)) {
+ break;
+ }
+
+ bool parsed = false;
+ switch (command) {
+ case IComposerClient::Command::SELECT_DISPLAY:
+ parsed = parseSelectDisplay(length);
+ break;
+ case IComposerClient::Command::SET_ERROR:
+ parsed = parseSetError(length);
+ break;
+ case IComposerClient::Command::SET_CHANGED_COMPOSITION_TYPES:
+ parsed = parseSetChangedCompositionTypes(length);
+ break;
+ case IComposerClient::Command::SET_DISPLAY_REQUESTS:
+ parsed = parseSetDisplayRequests(length);
+ break;
+ case IComposerClient::Command::SET_PRESENT_FENCE:
+ parsed = parseSetPresentFence(length);
+ break;
+ case IComposerClient::Command::SET_RELEASE_FENCES:
+ parsed = parseSetReleaseFences(length);
+ break;
+ default:
+ parsed = false;
+ break;
+ }
+
+ endCommand();
+
+ if (!parsed) {
+ ALOGE("failed to parse command 0x%x length %" PRIu16,
+ command, length);
+ break;
+ }
+ }
+
+ return isEmpty() ? Error::NONE : Error::NO_RESOURCES;
+}
+
+bool CommandReader::parseSelectDisplay(uint16_t length)
+{
+ if (length != CommandWriter::kSelectDisplayLength) {
+ return false;
+ }
+
+ mCurrentReturnData = &mReturnData[read64()];
+
+ return true;
+}
+
+bool CommandReader::parseSetError(uint16_t length)
+{
+ if (length != CommandWriter::kSetErrorLength) {
+ return false;
+ }
+
+ auto location = read();
+ auto error = static_cast<Error>(readSigned());
+
+ mErrors.emplace_back(CommandError{location, error});
+
+ return true;
+}
+
+bool CommandReader::parseSetChangedCompositionTypes(uint16_t length)
+{
+ // (layer id, composition type) pairs
+ if (length % 3 != 0 || !mCurrentReturnData) {
+ return false;
+ }
+
+ uint32_t count = length / 3;
+ mCurrentReturnData->changedLayers.reserve(count);
+ mCurrentReturnData->compositionTypes.reserve(count);
+ while (count > 0) {
+ auto layer = read64();
+ auto type = static_cast<IComposerClient::Composition>(readSigned());
+
+ mCurrentReturnData->changedLayers.push_back(layer);
+ mCurrentReturnData->compositionTypes.push_back(type);
+
+ count--;
+ }
+
+ return true;
+}
+
+bool CommandReader::parseSetDisplayRequests(uint16_t length)
+{
+ // display requests followed by (layer id, layer requests) pairs
+ if (length % 3 != 1 || !mCurrentReturnData) {
+ return false;
+ }
+
+ mCurrentReturnData->displayRequests = read();
+
+ uint32_t count = (length - 1) / 3;
+ mCurrentReturnData->requestedLayers.reserve(count);
+ mCurrentReturnData->requestMasks.reserve(count);
+ while (count > 0) {
+ auto layer = read64();
+ auto layerRequestMask = read();
+
+ mCurrentReturnData->requestedLayers.push_back(layer);
+ mCurrentReturnData->requestMasks.push_back(layerRequestMask);
+
+ count--;
+ }
+
+ return true;
+}
+
+bool CommandReader::parseSetPresentFence(uint16_t length)
+{
+ if (length != CommandWriter::kSetPresentFenceLength ||
+ !mCurrentReturnData) {
+ return false;
+ }
+
+ if (mCurrentReturnData->presentFence >= 0) {
+ close(mCurrentReturnData->presentFence);
+ }
+ mCurrentReturnData->presentFence = readFence();
+
+ return true;
+}
+
+bool CommandReader::parseSetReleaseFences(uint16_t length)
+{
+ // (layer id, release fence index) pairs
+ if (length % 3 != 0 || !mCurrentReturnData) {
+ return false;
+ }
+
+ uint32_t count = length / 3;
+ mCurrentReturnData->releasedLayers.reserve(count);
+ mCurrentReturnData->releaseFences.reserve(count);
+ while (count > 0) {
+ auto layer = read64();
+ auto fence = readFence();
+
+ mCurrentReturnData->releasedLayers.push_back(layer);
+ mCurrentReturnData->releaseFences.push_back(fence);
+
+ count--;
+ }
+
+ return true;
+}
+
+void CommandReader::resetData()
+{
+ mErrors.clear();
+
+ for (auto& data : mReturnData) {
+ if (data.second.presentFence >= 0) {
+ close(data.second.presentFence);
+ }
+ for (auto fence : data.second.releaseFences) {
+ if (fence >= 0) {
+ close(fence);
+ }
+ }
+ }
+
+ mReturnData.clear();
+ mCurrentReturnData = nullptr;
+}
+
+std::vector<CommandReader::CommandError> CommandReader::takeErrors()
+{
+ return std::move(mErrors);
+}
+
+bool CommandReader::hasChanges(Display display,
+ uint32_t& numChangedCompositionTypes,
+ uint32_t& numLayerRequestMasks) const
+{
+ auto found = mReturnData.find(display);
+ if (found == mReturnData.end()) {
+ numChangedCompositionTypes = 0;
+ numLayerRequestMasks = 0;
+ return false;
+ }
+
+ const ReturnData& data = found->second;
+
+ numChangedCompositionTypes = data.compositionTypes.size();
+ numLayerRequestMasks = data.requestMasks.size();
+
+ return !(data.compositionTypes.empty() && data.requestMasks.empty());
+}
+
+void CommandReader::takeChangedCompositionTypes(Display display,
+ std::vector<Layer>& layers,
+ std::vector<IComposerClient::Composition>& types)
+{
+ auto found = mReturnData.find(display);
+ if (found == mReturnData.end()) {
+ layers.clear();
+ types.clear();
+ return;
+ }
+
+ ReturnData& data = found->second;
+
+ layers = std::move(data.changedLayers);
+ types = std::move(data.compositionTypes);
+}
+
+void CommandReader::takeDisplayRequests(Display display,
+ uint32_t& displayRequestMask, std::vector<Layer>& layers,
+ std::vector<uint32_t>& layerRequestMasks)
+{
+ auto found = mReturnData.find(display);
+ if (found == mReturnData.end()) {
+ displayRequestMask = 0;
+ layers.clear();
+ layerRequestMasks.clear();
+ return;
+ }
+
+ ReturnData& data = found->second;
+
+ displayRequestMask = data.displayRequests;
+ layers = std::move(data.requestedLayers);
+ layerRequestMasks = std::move(data.requestMasks);
+}
+
+void CommandReader::takeReleaseFences(Display display,
+ std::vector<Layer>& layers, std::vector<int>& releaseFences)
+{
+ auto found = mReturnData.find(display);
+ if (found == mReturnData.end()) {
+ layers.clear();
+ releaseFences.clear();
+ return;
+ }
+
+ ReturnData& data = found->second;
+
+ layers = std::move(data.releasedLayers);
+ releaseFences = std::move(data.releaseFences);
+}
+
+void CommandReader::takePresentFence(Display display, int& presentFence)
+{
+ auto found = mReturnData.find(display);
+ if (found == mReturnData.end()) {
+ presentFence = -1;
+ return;
+ }
+
+ ReturnData& data = found->second;
+
+ presentFence = data.presentFence;
+ data.presentFence = -1;
}
} // namespace Hwc2
diff --git a/services/surfaceflinger/DisplayHardware/ComposerHal.h b/services/surfaceflinger/DisplayHardware/ComposerHal.h
index b8f7c201c4..2246f76670 100644
--- a/services/surfaceflinger/DisplayHardware/ComposerHal.h
+++ b/services/surfaceflinger/DisplayHardware/ComposerHal.h
@@ -17,11 +17,16 @@
#ifndef ANDROID_SF_COMPOSER_HAL_H
#define ANDROID_SF_COMPOSER_HAL_H
+#include <memory>
#include <string>
+#include <unordered_map>
+#include <utility>
#include <vector>
#include <android/hardware/graphics/composer/2.1/IComposer.h>
#include <utils/StrongPointer.h>
+#include <IComposerCommandBuffer.h>
+#include <MessageQueue.h>
namespace android {
@@ -36,102 +41,195 @@ using android::hardware::graphics::common::V1_0::Transform;
using android::hardware::graphics::composer::V2_1::IComposer;
using android::hardware::graphics::composer::V2_1::IComposerCallback;
+using android::hardware::graphics::composer::V2_1::IComposerClient;
using android::hardware::graphics::composer::V2_1::Error;
using android::hardware::graphics::composer::V2_1::Display;
using android::hardware::graphics::composer::V2_1::Layer;
using android::hardware::graphics::composer::V2_1::Config;
+using android::hardware::graphics::composer::V2_1::CommandWriter;
+using android::hardware::graphics::composer::V2_1::CommandReaderBase;
+
+using android::hardware::kSynchronizedReadWrite;
+using android::hardware::MessageQueue;
+using android::hardware::MQDescriptorSync;
+using android::hardware::hidl_vec;
+using android::hardware::hidl_handle;
+
+class CommandReader : public CommandReaderBase {
+public:
+ ~CommandReader();
+
+ // Parse and execute commands from the command queue. The commands are
+ // actually return values from the server and will be saved in ReturnData.
+ Error parse();
+
+ // Get and clear saved errors.
+ struct CommandError {
+ uint32_t location;
+ Error error;
+ };
+ std::vector<CommandError> takeErrors();
+
+ bool hasChanges(Display display, uint32_t& numChangedCompositionTypes,
+ uint32_t& numLayerRequestMasks) const;
+
+ // Get and clear saved changed composition types.
+ void takeChangedCompositionTypes(Display display,
+ std::vector<Layer>& layers,
+ std::vector<IComposerClient::Composition>& types);
+
+ // Get and clear saved display requests.
+ void takeDisplayRequests(Display display,
+ uint32_t& displayRequestMask, std::vector<Layer>& layers,
+ std::vector<uint32_t>& layerRequestMasks);
+
+ // Get and clear saved release fences.
+ void takeReleaseFences(Display display, std::vector<Layer>& layers,
+ std::vector<int>& releaseFences);
+
+ // Get and clear saved present fence.
+ void takePresentFence(Display display, int& presentFence);
+
+private:
+ void resetData();
+
+ bool parseSelectDisplay(uint16_t length);
+ bool parseSetError(uint16_t length);
+ bool parseSetChangedCompositionTypes(uint16_t length);
+ bool parseSetDisplayRequests(uint16_t length);
+ bool parseSetPresentFence(uint16_t length);
+ bool parseSetReleaseFences(uint16_t length);
+
+ struct ReturnData {
+ uint32_t displayRequests = 0;
+
+ std::vector<Layer> changedLayers;
+ std::vector<IComposerClient::Composition> compositionTypes;
+
+ std::vector<Layer> requestedLayers;
+ std::vector<uint32_t> requestMasks;
+
+ int presentFence = -1;
+
+ std::vector<Layer> releasedLayers;
+ std::vector<int> releaseFences;
+ };
+
+ std::vector<CommandError> mErrors;
+ std::unordered_map<Display, ReturnData> mReturnData;
+
+ // When SELECT_DISPLAY is parsed, this is updated to point to the
+ // display's return data in mReturnData. We use it to avoid repeated
+ // map lookups.
+ ReturnData* mCurrentReturnData;
+};
+
// Composer is a wrapper to IComposer, a proxy to server-side composer.
class Composer {
public:
Composer();
- std::vector<IComposer::Capability> getCapabilities() const;
- std::string dumpDebugInfo() const;
+ std::vector<IComposer::Capability> getCapabilities();
+ std::string dumpDebugInfo();
- void registerCallback(const sp<IComposerCallback>& callback) const;
+ void registerCallback(const sp<IComposerCallback>& callback);
- uint32_t getMaxVirtualDisplayCount() const;
+ uint32_t getMaxVirtualDisplayCount();
Error createVirtualDisplay(uint32_t width, uint32_t height,
- PixelFormat& format, Display& display) const;
- Error destroyVirtualDisplay(Display display) const;
+ PixelFormat& format, Display& display);
+ Error destroyVirtualDisplay(Display display);
- Error acceptDisplayChanges(Display display) const;
+ Error acceptDisplayChanges(Display display);
- Error createLayer(Display display, Layer& layer) const;
- Error destroyLayer(Display display, Layer layer) const;
+ Error createLayer(Display display, Layer& layer);
+ Error destroyLayer(Display display, Layer layer);
- Error getActiveConfig(Display display, Config& config) const;
+ Error getActiveConfig(Display display, Config& config);
Error getChangedCompositionTypes(Display display,
std::vector<Layer>& layers,
- std::vector<IComposer::Composition>& types) const;
- Error getColorModes(Display display, std::vector<ColorMode>& modes) const;
+ std::vector<IComposerClient::Composition>& types);
+ Error getColorModes(Display display, std::vector<ColorMode>& modes);
Error getDisplayAttribute(Display display, Config config,
- IComposer::Attribute attribute, int32_t& value) const;
+ IComposerClient::Attribute attribute, int32_t& value);
Error getDisplayConfigs(Display display,
- std::vector<Config>& configs) const;
- Error getDisplayName(Display display, std::string& name) const;
+ std::vector<Config>& configs);
+ Error getDisplayName(Display display, std::string& name);
Error getDisplayRequests(Display display, uint32_t& displayRequestMask,
std::vector<Layer>& layers,
- std::vector<uint32_t>& layerRequestMasks) const;
+ std::vector<uint32_t>& layerRequestMasks);
- Error getDisplayType(Display display, IComposer::DisplayType& type) const;
- Error getDozeSupport(Display display, bool& support) const;
+ Error getDisplayType(Display display, IComposerClient::DisplayType& type);
+ Error getDozeSupport(Display display, bool& support);
Error getHdrCapabilities(Display display, std::vector<Hdr>& types,
float& maxLuminance, float& maxAverageLuminance,
- float& minLuminance) const;
+ float& minLuminance);
Error getReleaseFences(Display display, std::vector<Layer>& layers,
- std::vector<int>& releaseFences) const;
+ std::vector<int>& releaseFences);
- Error presentDisplay(Display display, int& presentFence) const;
+ Error presentDisplay(Display display, int& presentFence);
- Error setActiveConfig(Display display, Config config) const;
+ Error setActiveConfig(Display display, Config config);
Error setClientTarget(Display display, const native_handle_t* target,
int acquireFence, Dataspace dataspace,
- const std::vector<IComposer::Rect>& damage) const;
- Error setColorMode(Display display, ColorMode mode) const;
+ const std::vector<IComposerClient::Rect>& damage);
+ Error setColorMode(Display display, ColorMode mode);
Error setColorTransform(Display display, const float* matrix,
- ColorTransform hint) const;
+ ColorTransform hint);
Error setOutputBuffer(Display display, const native_handle_t* buffer,
- int releaseFence) const;
- Error setPowerMode(Display display, IComposer::PowerMode mode) const;
- Error setVsyncEnabled(Display display, IComposer::Vsync enabled) const;
+ int releaseFence);
+ Error setPowerMode(Display display, IComposerClient::PowerMode mode);
+ Error setVsyncEnabled(Display display, IComposerClient::Vsync enabled);
+
+ Error setClientTargetSlotCount(Display display);
Error validateDisplay(Display display, uint32_t& numTypes,
- uint32_t& numRequests) const;
+ uint32_t& numRequests);
Error setCursorPosition(Display display, Layer layer,
- int32_t x, int32_t y) const;
+ int32_t x, int32_t y);
Error setLayerBuffer(Display display, Layer layer,
- const native_handle_t* buffer, int acquireFence) const;
+ const native_handle_t* buffer, int acquireFence);
Error setLayerSurfaceDamage(Display display, Layer layer,
- const std::vector<IComposer::Rect>& damage) const;
+ const std::vector<IComposerClient::Rect>& damage);
Error setLayerBlendMode(Display display, Layer layer,
- IComposer::BlendMode mode) const;
+ IComposerClient::BlendMode mode);
Error setLayerColor(Display display, Layer layer,
- const IComposer::Color& color) const;
+ const IComposerClient::Color& color);
Error setLayerCompositionType(Display display, Layer layer,
- IComposer::Composition type) const;
+ IComposerClient::Composition type);
Error setLayerDataspace(Display display, Layer layer,
- Dataspace dataspace) const;
+ Dataspace dataspace);
Error setLayerDisplayFrame(Display display, Layer layer,
- const IComposer::Rect& frame) const;
+ const IComposerClient::Rect& frame);
Error setLayerPlaneAlpha(Display display, Layer layer,
- float alpha) const;
+ float alpha);
Error setLayerSidebandStream(Display display, Layer layer,
- const native_handle_t* stream) const;
+ const native_handle_t* stream);
Error setLayerSourceCrop(Display display, Layer layer,
- const IComposer::FRect& crop) const;
+ const IComposerClient::FRect& crop);
Error setLayerTransform(Display display, Layer layer,
- Transform transform) const;
+ Transform transform);
Error setLayerVisibleRegion(Display display, Layer layer,
- const std::vector<IComposer::Rect>& visible) const;
- Error setLayerZOrder(Display display, Layer layer, uint32_t z) const;
+ const std::vector<IComposerClient::Rect>& visible);
+ Error setLayerZOrder(Display display, Layer layer, uint32_t z);
private:
- sp<IComposer> mService;
+ // Many public functions above simply write a command into the command
+ // queue to batch the calls. validateDisplay and presentDisplay will call
+ // this function to execute the command queue.
+ Error execute();
+
+ sp<IComposer> mComposer;
+ sp<IComposerClient> mClient;
+
+ // 64KiB minus a small space for metadata such as read/write pointers
+ static constexpr size_t kWriterInitialSize =
+ 64 * 1024 / sizeof(uint32_t) - 16;
+ CommandWriter mWriter;
+ CommandReader mReader;
};
} // namespace Hwc2
diff --git a/services/surfaceflinger/DisplayHardware/HWC2.cpp b/services/surfaceflinger/DisplayHardware/HWC2.cpp
index dd909aa229..10b0acfab2 100644
--- a/services/surfaceflinger/DisplayHardware/HWC2.cpp
+++ b/services/surfaceflinger/DisplayHardware/HWC2.cpp
@@ -286,6 +286,9 @@ void Device::callHotplug(std::shared_ptr<Display> display, Connection connected)
{
if (connected == Connection::Connected) {
if (!display->isConnected()) {
+#ifndef BYPASS_IHWC
+ mComposer->setClientTargetSlotCount(display->getId());
+#endif
display->loadConfigs();
display->setConnected(true);
}
@@ -650,7 +653,7 @@ Error Display::getChangedCompositionTypes(
&numElements, layerIds.data(), types.data());
#else
std::vector<Hwc2::Layer> layerIds;
- std::vector<Hwc2::IComposer::Composition> types;
+ std::vector<Hwc2::IComposerClient::Composition> types;
auto intError = mDevice.mComposer->getChangedCompositionTypes(mId,
layerIds, types);
uint32_t numElements = layerIds.size();
@@ -805,8 +808,8 @@ Error Display::getType(DisplayType* outType) const
int32_t intError = mDevice.mGetDisplayType(mDevice.mHwcDevice, mId,
&intType);
#else
- Hwc2::IComposer::DisplayType intType =
- Hwc2::IComposer::DisplayType::INVALID;
+ Hwc2::IComposerClient::DisplayType intType =
+ Hwc2::IComposerClient::DisplayType::INVALID;
auto intError = mDevice.mComposer->getDisplayType(mId, intType);
#endif
auto error = static_cast<Error>(intError);
@@ -970,7 +973,7 @@ Error Display::setClientTarget(buffer_handle_t target,
#else
auto intError = mDevice.mComposer->setClientTarget(mId, target, fenceFd,
static_cast<Hwc2::Dataspace>(dataspace),
- std::vector<Hwc2::IComposer::Rect>());
+ std::vector<Hwc2::IComposerClient::Rect>());
#endif
return static_cast<Error>(intError);
}
@@ -1020,7 +1023,7 @@ Error Display::setPowerMode(PowerMode mode)
auto intMode = static_cast<int32_t>(mode);
int32_t intError = mDevice.mSetPowerMode(mDevice.mHwcDevice, mId, intMode);
#else
- auto intMode = static_cast<Hwc2::IComposer::PowerMode>(mode);
+ auto intMode = static_cast<Hwc2::IComposerClient::PowerMode>(mode);
auto intError = mDevice.mComposer->setPowerMode(mId, intMode);
#endif
return static_cast<Error>(intError);
@@ -1033,7 +1036,7 @@ Error Display::setVsyncEnabled(Vsync enabled)
int32_t intError = mDevice.mSetVsyncEnabled(mDevice.mHwcDevice, mId,
intEnabled);
#else
- auto intEnabled = static_cast<Hwc2::IComposer::Vsync>(enabled);
+ auto intEnabled = static_cast<Hwc2::IComposerClient::Vsync>(enabled);
auto intError = mDevice.mComposer->setVsyncEnabled(mId, intEnabled);
#endif
return static_cast<Error>(intError);
@@ -1070,7 +1073,7 @@ int32_t Display::getAttribute(hwc2_config_t configId, Attribute attribute)
configId, static_cast<int32_t>(attribute), &value);
#else
auto intError = mDevice.mComposer->getDisplayAttribute(mId,
- configId, static_cast<Hwc2::IComposer::Attribute>(attribute),
+ configId, static_cast<Hwc2::IComposerClient::Attribute>(attribute),
value);
#endif
auto error = static_cast<Error>(intError);
@@ -1221,7 +1224,7 @@ Error Layer::setSurfaceDamage(const Region& damage)
mDisplayId, mId, {0, nullptr});
#else
intError = mDevice.mComposer->setLayerSurfaceDamage(mDisplayId,
- mId, std::vector<Hwc2::IComposer::Rect>());
+ mId, std::vector<Hwc2::IComposerClient::Rect>());
#endif
} else {
size_t rectCount = 0;
@@ -1230,7 +1233,7 @@ Error Layer::setSurfaceDamage(const Region& damage)
#ifdef BYPASS_IHWC
std::vector<hwc_rect_t> hwcRects;
#else
- std::vector<Hwc2::IComposer::Rect> hwcRects;
+ std::vector<Hwc2::IComposerClient::Rect> hwcRects;
#endif
for (size_t rect = 0; rect < rectCount; ++rect) {
hwcRects.push_back({rectArray[rect].left, rectArray[rect].top,
@@ -1260,7 +1263,7 @@ Error Layer::setBlendMode(BlendMode mode)
int32_t intError = mDevice.mSetLayerBlendMode(mDevice.mHwcDevice,
mDisplayId, mId, intMode);
#else
- auto intMode = static_cast<Hwc2::IComposer::BlendMode>(mode);
+ auto intMode = static_cast<Hwc2::IComposerClient::BlendMode>(mode);
auto intError = mDevice.mComposer->setLayerBlendMode(mDisplayId,
mId, intMode);
#endif
@@ -1273,7 +1276,7 @@ Error Layer::setColor(hwc_color_t color)
int32_t intError = mDevice.mSetLayerColor(mDevice.mHwcDevice, mDisplayId,
mId, color);
#else
- Hwc2::IComposer::Color hwcColor{color.r, color.g, color.b, color.a};
+ Hwc2::IComposerClient::Color hwcColor{color.r, color.g, color.b, color.a};
auto intError = mDevice.mComposer->setLayerColor(mDisplayId,
mId, hwcColor);
#endif
@@ -1287,7 +1290,7 @@ Error Layer::setCompositionType(Composition type)
int32_t intError = mDevice.mSetLayerCompositionType(mDevice.mHwcDevice,
mDisplayId, mId, intType);
#else
- auto intType = static_cast<Hwc2::IComposer::Composition>(type);
+ auto intType = static_cast<Hwc2::IComposerClient::Composition>(type);
auto intError = mDevice.mComposer->setLayerCompositionType(mDisplayId,
mId, intType);
#endif
@@ -1315,7 +1318,7 @@ Error Layer::setDisplayFrame(const Rect& frame)
int32_t intError = mDevice.mSetLayerDisplayFrame(mDevice.mHwcDevice,
mDisplayId, mId, hwcRect);
#else
- Hwc2::IComposer::Rect hwcRect{frame.left, frame.top,
+ Hwc2::IComposerClient::Rect hwcRect{frame.left, frame.top,
frame.right, frame.bottom};
auto intError = mDevice.mComposer->setLayerDisplayFrame(mDisplayId,
mId, hwcRect);
@@ -1359,7 +1362,7 @@ Error Layer::setSourceCrop(const FloatRect& crop)
int32_t intError = mDevice.mSetLayerSourceCrop(mDevice.mHwcDevice,
mDisplayId, mId, hwcRect);
#else
- Hwc2::IComposer::FRect hwcRect{
+ Hwc2::IComposerClient::FRect hwcRect{
crop.left, crop.top, crop.right, crop.bottom};
auto intError = mDevice.mComposer->setLayerSourceCrop(mDisplayId,
mId, hwcRect);
@@ -1389,7 +1392,7 @@ Error Layer::setVisibleRegion(const Region& region)
#ifdef BYPASS_IHWC
std::vector<hwc_rect_t> hwcRects;
#else
- std::vector<Hwc2::IComposer::Rect> hwcRects;
+ std::vector<Hwc2::IComposerClient::Rect> hwcRects;
#endif
for (size_t rect = 0; rect < rectCount; ++rect) {
hwcRects.push_back({rectArray[rect].left, rectArray[rect].top,
generated by cgit v1.2.3-59-g8ed1b (git 2.39.0) at 2025-10-20 22:17:35 +0000