surfaceflinger: update for IComposer changes
The new IComposer introduces IComposerClient to manage resources and
replaces most state changing functions by a "command buffer" to batch
calls.
Test: builds and boots
Change-Id: Idd1060f83fab28330e7119ff0f5a5bda5429811a
diff --git a/services/surfaceflinger/Android.mk b/services/surfaceflinger/Android.mk
index 20fe0fd..4987a18 100644
--- a/services/surfaceflinger/Android.mk
+++ b/services/surfaceflinger/Android.mk
@@ -42,6 +42,7 @@
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 @@
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 @@
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 06f67ba..63fd1e8 100644
--- a/services/surfaceflinger/DisplayHardware/ComposerHal.cpp
+++ b/services/surfaceflinger/DisplayHardware/ComposerHal.cpp
@@ -110,17 +110,29 @@
} // 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 @@
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 @@
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 @@
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::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::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::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 @@
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::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 @@
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::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::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)
{
+ mWriter.selectDisplay(display);
+ mWriter.validateDisplay();
+
+ Error error = execute();
+ if (error != Error::NONE) {
+ return error;
+ }
+
+ mReader.hasChanges(display, numTypes, numRequests);
+
+ return Error::NONE;
+}
+
+Error Composer::setCursorPosition(Display display, Layer layer,
+ int32_t x, int32_t y)
+{
+ 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)
+{
+ mWriter.selectDisplay(display);
+ mWriter.selectLayer(layer);
+ mWriter.setLayerBuffer(0, buffer, acquireFence);
+ return Error::NONE;
+}
+
+Error Composer::setLayerSurfaceDamage(Display display, Layer layer,
+ const std::vector<IComposerClient::Rect>& damage)
+{
+ mWriter.selectDisplay(display);
+ mWriter.selectLayer(layer);
+ mWriter.setLayerSurfaceDamage(damage);
+ return Error::NONE;
+}
+
+Error Composer::setLayerBlendMode(Display display, Layer layer,
+ IComposerClient::BlendMode mode)
+{
+ mWriter.selectDisplay(display);
+ mWriter.selectLayer(layer);
+ mWriter.setLayerBlendMode(mode);
+ return Error::NONE;
+}
+
+Error Composer::setLayerColor(Display display, Layer layer,
+ const IComposerClient::Color& color)
+{
+ mWriter.selectDisplay(display);
+ mWriter.selectLayer(layer);
+ mWriter.setLayerColor(color);
+ return Error::NONE;
+}
+
+Error Composer::setLayerCompositionType(Display display, Layer layer,
+ IComposerClient::Composition type)
+{
+ mWriter.selectDisplay(display);
+ mWriter.selectLayer(layer);
+ mWriter.setLayerCompositionType(type);
+ return Error::NONE;
+}
+
+Error Composer::setLayerDataspace(Display display, Layer layer,
+ Dataspace dataspace)
+{
+ mWriter.selectDisplay(display);
+ mWriter.selectLayer(layer);
+ mWriter.setLayerDataspace(dataspace);
+ return Error::NONE;
+}
+
+Error Composer::setLayerDisplayFrame(Display display, Layer layer,
+ const IComposerClient::Rect& frame)
+{
+ mWriter.selectDisplay(display);
+ mWriter.selectLayer(layer);
+ mWriter.setLayerDisplayFrame(frame);
+ return Error::NONE;
+}
+
+Error Composer::setLayerPlaneAlpha(Display display, Layer layer,
+ float alpha)
+{
+ mWriter.selectDisplay(display);
+ mWriter.selectLayer(layer);
+ mWriter.setLayerPlaneAlpha(alpha);
+ return Error::NONE;
+}
+
+Error Composer::setLayerSidebandStream(Display display, Layer layer,
+ const native_handle_t* stream)
+{
+ mWriter.selectDisplay(display);
+ mWriter.selectLayer(layer);
+ mWriter.setLayerSidebandStream(stream);
+ return Error::NONE;
+}
+
+Error Composer::setLayerSourceCrop(Display display, Layer layer,
+ const IComposerClient::FRect& crop)
+{
+ mWriter.selectDisplay(display);
+ mWriter.selectLayer(layer);
+ mWriter.setLayerSourceCrop(crop);
+ return Error::NONE;
+}
+
+Error Composer::setLayerTransform(Display display, Layer layer,
+ Transform transform)
+{
+ mWriter.selectDisplay(display);
+ mWriter.selectLayer(layer);
+ mWriter.setLayerTransform(transform);
+ return Error::NONE;
+}
+
+Error Composer::setLayerVisibleRegion(Display display, Layer layer,
+ const std::vector<IComposerClient::Rect>& visible)
+{
+ mWriter.selectDisplay(display);
+ mWriter.selectLayer(layer);
+ mWriter.setLayerVisibleRegion(visible);
+ return Error::NONE;
+}
+
+Error Composer::setLayerZOrder(Display display, Layer layer, uint32_t z)
+{
+ mWriter.selectDisplay(display);
+ mWriter.selectLayer(layer);
+ mWriter.setLayerZOrder(z);
+ return Error::NONE;
+}
+
+Error Composer::execute()
+{
+ // 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;
- mService->validateDisplay(display,
- [&](const auto& tmpError, const auto& tmpNumTypes,
- const auto& tmpNumRequests) {
+ 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;
}
- numTypes = tmpNumTypes;
- numRequests = tmpNumRequests;
+ 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;
}
-Error Composer::setCursorPosition(Display display, Layer layer,
- int32_t x, int32_t y) const
+CommandReader::~CommandReader()
{
- auto ret = mService->setCursorPosition(display, layer, x, y);
- return unwrapRet(ret);
+ resetData();
}
-Error Composer::setLayerBuffer(Display display, Layer layer,
- const native_handle_t* buffer, int acquireFence) const
+Error CommandReader::parse()
{
- BufferHandle tmpBuffer(buffer);
- FenceHandle tmpAcquireFence(acquireFence, true);
+ resetData();
- auto ret = mService->setLayerBuffer(display, layer,
- tmpBuffer, tmpAcquireFence);
- return unwrapRet(ret);
+ 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;
}
-Error Composer::setLayerSurfaceDamage(Display display, Layer layer,
- const std::vector<IComposer::Rect>& damage) const
+bool CommandReader::parseSelectDisplay(uint16_t length)
{
- hidl_vec<IComposer::Rect> tmpDamage;
- tmpDamage.setToExternal(const_cast<IComposer::Rect*>(damage.data()),
- damage.size());
+ if (length != CommandWriter::kSelectDisplayLength) {
+ return false;
+ }
- auto ret = mService->setLayerSurfaceDamage(display, layer, tmpDamage);
- return unwrapRet(ret);
+ mCurrentReturnData = &mReturnData[read64()];
+
+ return true;
}
-Error Composer::setLayerBlendMode(Display display, Layer layer,
- IComposer::BlendMode mode) const
+bool CommandReader::parseSetError(uint16_t length)
{
- auto ret = mService->setLayerBlendMode(display, layer, mode);
- return unwrapRet(ret);
+ if (length != CommandWriter::kSetErrorLength) {
+ return false;
+ }
+
+ auto location = read();
+ auto error = static_cast<Error>(readSigned());
+
+ mErrors.emplace_back(CommandError{location, error});
+
+ return true;
}
-Error Composer::setLayerColor(Display display, Layer layer,
- const IComposer::Color& color) const
+bool CommandReader::parseSetChangedCompositionTypes(uint16_t length)
{
- auto ret = mService->setLayerColor(display, layer, color);
- return unwrapRet(ret);
+ // (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;
}
-Error Composer::setLayerCompositionType(Display display, Layer layer,
- IComposer::Composition type) const
+bool CommandReader::parseSetDisplayRequests(uint16_t length)
{
- auto ret = mService->setLayerCompositionType(display, layer, type);
- return unwrapRet(ret);
+ // 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;
}
-Error Composer::setLayerDataspace(Display display, Layer layer,
- Dataspace dataspace) const
+bool CommandReader::parseSetPresentFence(uint16_t length)
{
- auto ret = mService->setLayerDataspace(display, layer, dataspace);
- return unwrapRet(ret);
+ if (length != CommandWriter::kSetPresentFenceLength ||
+ !mCurrentReturnData) {
+ return false;
+ }
+
+ if (mCurrentReturnData->presentFence >= 0) {
+ close(mCurrentReturnData->presentFence);
+ }
+ mCurrentReturnData->presentFence = readFence();
+
+ return true;
}
-Error Composer::setLayerDisplayFrame(Display display, Layer layer,
- const IComposer::Rect& frame) const
+bool CommandReader::parseSetReleaseFences(uint16_t length)
{
- auto ret = mService->setLayerDisplayFrame(display, layer, frame);
- return unwrapRet(ret);
+ // (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;
}
-Error Composer::setLayerPlaneAlpha(Display display, Layer layer,
- float alpha) const
+void CommandReader::resetData()
{
- auto ret = mService->setLayerPlaneAlpha(display, layer, alpha);
- return unwrapRet(ret);
+ 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;
}
-Error Composer::setLayerSidebandStream(Display display, Layer layer,
- const native_handle_t* stream) const
+std::vector<CommandReader::CommandError> CommandReader::takeErrors()
{
- BufferHandle tmpStream(stream);
-
- auto ret = mService->setLayerSidebandStream(display, layer, tmpStream);
- return unwrapRet(ret);
+ return std::move(mErrors);
}
-Error Composer::setLayerSourceCrop(Display display, Layer layer,
- const IComposer::FRect& crop) const
+bool CommandReader::hasChanges(Display display,
+ uint32_t& numChangedCompositionTypes,
+ uint32_t& numLayerRequestMasks) const
{
- auto ret = mService->setLayerSourceCrop(display, layer, crop);
- return unwrapRet(ret);
+ 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());
}
-Error Composer::setLayerTransform(Display display, Layer layer,
- Transform transform) const
+void CommandReader::takeChangedCompositionTypes(Display display,
+ std::vector<Layer>& layers,
+ std::vector<IComposerClient::Composition>& types)
{
- auto ret = mService->setLayerTransform(display, layer, transform);
- return unwrapRet(ret);
+ 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);
}
-Error Composer::setLayerVisibleRegion(Display display, Layer layer,
- const std::vector<IComposer::Rect>& visible) const
+void CommandReader::takeDisplayRequests(Display display,
+ uint32_t& displayRequestMask, std::vector<Layer>& layers,
+ std::vector<uint32_t>& layerRequestMasks)
{
- hidl_vec<IComposer::Rect> tmpVisible;
- tmpVisible.setToExternal(const_cast<IComposer::Rect*>(visible.data()),
- visible.size());
+ auto found = mReturnData.find(display);
+ if (found == mReturnData.end()) {
+ displayRequestMask = 0;
+ layers.clear();
+ layerRequestMasks.clear();
+ return;
+ }
- auto ret = mService->setLayerVisibleRegion(display, layer, tmpVisible);
- return unwrapRet(ret);
+ ReturnData& data = found->second;
+
+ displayRequestMask = data.displayRequests;
+ layers = std::move(data.requestedLayers);
+ layerRequestMasks = std::move(data.requestMasks);
}
-Error Composer::setLayerZOrder(Display display, Layer layer, uint32_t z) const
+void CommandReader::takeReleaseFences(Display display,
+ std::vector<Layer>& layers, std::vector<int>& releaseFences)
{
- auto ret = mService->setLayerZOrder(display, layer, z);
- return unwrapRet(ret);
+ 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 b8f7c20..2246f76 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::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 dd909aa..10b0acf 100644
--- a/services/surfaceflinger/DisplayHardware/HWC2.cpp
+++ b/services/surfaceflinger/DisplayHardware/HWC2.cpp
@@ -286,6 +286,9 @@
{
if (connected == Connection::Connected) {
if (!display->isConnected()) {
+#ifndef BYPASS_IHWC
+ mComposer->setClientTargetSlotCount(display->getId());
+#endif
display->loadConfigs();
display->setConnected(true);
}
@@ -650,7 +653,7 @@
&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 @@
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 @@
#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 @@
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 @@
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 @@
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 @@
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 @@
#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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
#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,