composer: cleanup CommandWriterBase and CommandReaderBase
These classes are used by both the client and the service, which
makes them confusing. This CL splits the logic for the client
and the service.
Bug: 208856704
Test: VTS
Change-Id: I6fa89858afeee9113ea8c810261d734163a95ec9
diff --git a/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/VtsHalGraphicsComposer3_ReadbackTest.cpp b/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/VtsHalGraphicsComposer3_ReadbackTest.cpp
index 8726043..34dea9e 100644
--- a/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/VtsHalGraphicsComposer3_ReadbackTest.cpp
+++ b/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/VtsHalGraphicsComposer3_ReadbackTest.cpp
@@ -167,8 +167,8 @@
int32_t mDisplayWidth;
int32_t mDisplayHeight;
std::vector<ColorMode> mTestColorModes;
- CommandWriterBase mWriter;
- CommandReaderBase mReader;
+ ComposerClientWriter mWriter;
+ ComposerClientReader mReader;
::android::sp<::android::GraphicBuffer> mGraphicBuffer;
std::unique_ptr<TestRenderEngine> mTestRenderEngine;
diff --git a/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/VtsHalGraphicsComposer3_TargetTest.cpp b/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/VtsHalGraphicsComposer3_TargetTest.cpp
index 20fffa9..c21a196 100644
--- a/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/VtsHalGraphicsComposer3_TargetTest.cpp
+++ b/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/VtsHalGraphicsComposer3_TargetTest.cpp
@@ -13,7 +13,8 @@
#include <android-base/properties.h>
#include <android/binder_manager.h>
#include <android/binder_process.h>
-#include <android/hardware/graphics/composer3/command-buffer.h>
+#include <android/hardware/graphics/composer3/ComposerClientReader.h>
+#include <android/hardware/graphics/composer3/ComposerClientWriter.h>
#include <binder/ProcessState.h>
#include <gtest/gtest.h>
#include <ui/GraphicBuffer.h>
@@ -1408,8 +1409,8 @@
}};
// clang-format on
- CommandWriterBase mWriter;
- CommandReaderBase mReader;
+ ComposerClientWriter mWriter;
+ ComposerClientReader mReader;
};
TEST_P(GraphicsComposerAidlCommandTest, SET_COLOR_TRANSFORM) {
diff --git a/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/composer-vts/ReadbackVts.cpp b/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/composer-vts/ReadbackVts.cpp
index a6954b4..4de2d71 100644
--- a/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/composer-vts/ReadbackVts.cpp
+++ b/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/composer-vts/ReadbackVts.cpp
@@ -32,7 +32,7 @@
const std::vector<Dataspace> ReadbackHelper::dataspaces = {common::Dataspace::SRGB,
common::Dataspace::DISPLAY_P3};
-void TestLayer::write(CommandWriterBase& writer) {
+void TestLayer::write(ComposerClientWriter& writer) {
writer.setLayerDisplayFrame(mDisplay, mLayer, mDisplayFrame);
writer.setLayerSourceCrop(mDisplay, mLayer, mSourceCrop);
writer.setLayerZOrder(mDisplay, mLayer, mZOrder);
@@ -253,7 +253,7 @@
EXPECT_EQ(::android::OK, status);
}
-void TestColorLayer::write(CommandWriterBase& writer) {
+void TestColorLayer::write(ComposerClientWriter& writer) {
TestLayer::write(writer);
writer.setLayerCompositionType(mDisplay, mLayer, Composition::SOLID_COLOR);
writer.setLayerColor(mDisplay, mLayer, mColor);
@@ -296,7 +296,7 @@
setSourceCrop({0, 0, (float)width, (float)height});
}
-void TestBufferLayer::write(CommandWriterBase& writer) {
+void TestBufferLayer::write(ComposerClientWriter& writer) {
TestLayer::write(writer);
writer.setLayerCompositionType(mDisplay, mLayer, mComposition);
writer.setLayerVisibleRegion(mDisplay, mLayer, std::vector<Rect>(1, mDisplayFrame));
@@ -345,11 +345,11 @@
ASSERT_EQ(::android::OK, mGraphicBuffer->initCheck());
}
-void TestBufferLayer::setDataspace(common::Dataspace dataspace, CommandWriterBase& writer) {
+void TestBufferLayer::setDataspace(common::Dataspace dataspace, ComposerClientWriter& writer) {
writer.setLayerDataspace(mDisplay, mLayer, dataspace);
}
-void TestBufferLayer::setToClientComposition(CommandWriterBase& writer) {
+void TestBufferLayer::setToClientComposition(ComposerClientWriter& writer) {
writer.setLayerCompositionType(mDisplay, mLayer, Composition::CLIENT);
}
diff --git a/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/composer-vts/include/ReadbackVts.h b/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/composer-vts/include/ReadbackVts.h
index d40e3d2..60a036e 100644
--- a/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/composer-vts/include/ReadbackVts.h
+++ b/graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/composer-vts/include/ReadbackVts.h
@@ -23,7 +23,8 @@
#include <GraphicsComposerCallback.h>
#include <aidl/android/hardware/graphics/composer3/IComposerClient.h>
#include <android-base/unique_fd.h>
-#include <android/hardware/graphics/composer3/command-buffer.h>
+#include <android/hardware/graphics/composer3/ComposerClientReader.h>
+#include <android/hardware/graphics/composer3/ComposerClientWriter.h>
#include <mapper-vts/2.1/MapperVts.h>
#include <renderengine/RenderEngine.h>
#include <ui/GraphicBuffer.h>
@@ -61,7 +62,7 @@
// call destroyLayers here
virtual ~TestLayer(){};
- virtual void write(CommandWriterBase& writer);
+ virtual void write(ComposerClientWriter& writer);
virtual LayerSettings toRenderEngineLayerSettings();
void setDisplayFrame(Rect frame) { mDisplayFrame = frame; }
@@ -105,7 +106,7 @@
TestColorLayer(const std::shared_ptr<IComposerClient>& client, int64_t display)
: TestLayer{client, display} {}
- void write(CommandWriterBase& writer) override;
+ void write(ComposerClientWriter& writer) override;
LayerSettings toRenderEngineLayerSettings() override;
@@ -123,7 +124,7 @@
uint32_t height, common::PixelFormat format,
Composition composition = Composition::DEVICE);
- void write(CommandWriterBase& writer) override;
+ void write(ComposerClientWriter& writer) override;
LayerSettings toRenderEngineLayerSettings() override;
@@ -131,9 +132,9 @@
void setBuffer(std::vector<Color> colors);
- void setDataspace(Dataspace dataspace, CommandWriterBase& writer);
+ void setDataspace(Dataspace dataspace, ComposerClientWriter& writer);
- void setToClientComposition(CommandWriterBase& writer);
+ void setToClientComposition(ComposerClientWriter& writer);
uint32_t getWidth() const { return mWidth; }
diff --git a/graphics/composer/aidl/include/android/hardware/graphics/composer3/ComposerClientReader.h b/graphics/composer/aidl/include/android/hardware/graphics/composer3/ComposerClientReader.h
new file mode 100644
index 0000000..1dc9145
--- /dev/null
+++ b/graphics/composer/aidl/include/android/hardware/graphics/composer3/ComposerClientReader.h
@@ -0,0 +1,319 @@
+/*
+ * Copyright 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include <inttypes.h>
+#include <string.h>
+
+#include <aidl/android/hardware/graphics/common/BlendMode.h>
+#include <aidl/android/hardware/graphics/composer3/ClientTargetProperty.h>
+#include <aidl/android/hardware/graphics/composer3/Color.h>
+#include <aidl/android/hardware/graphics/composer3/Composition.h>
+#include <aidl/android/hardware/graphics/composer3/FloatColor.h>
+#include <aidl/android/hardware/graphics/composer3/HandleIndex.h>
+#include <aidl/android/hardware/graphics/composer3/IComposer.h>
+#include <aidl/android/hardware/graphics/composer3/IComposerClient.h>
+#include <aidl/android/hardware/graphics/composer3/PerFrameMetadata.h>
+#include <aidl/android/hardware/graphics/composer3/PerFrameMetadataBlob.h>
+
+#include <aidl/android/hardware/graphics/composer3/CommandResultPayload.h>
+#include <aidl/android/hardware/graphics/composer3/DisplayCommand.h>
+
+#include <aidl/android/hardware/graphics/common/ColorTransform.h>
+#include <aidl/android/hardware/graphics/common/FRect.h>
+#include <aidl/android/hardware/graphics/common/Rect.h>
+#include <aidl/android/hardware/graphics/common/Transform.h>
+
+#include <log/log.h>
+#include <sync/sync.h>
+
+#include <aidlcommonsupport/NativeHandle.h>
+
+using aidl::android::hardware::graphics::common::BlendMode;
+using aidl::android::hardware::graphics::common::ColorTransform;
+using aidl::android::hardware::graphics::common::Dataspace;
+using aidl::android::hardware::graphics::common::FRect;
+using aidl::android::hardware::graphics::common::Rect;
+using aidl::android::hardware::graphics::common::Transform;
+
+using namespace aidl::android::hardware::graphics::composer3;
+
+using aidl::android::hardware::common::NativeHandle;
+
+namespace aidl::android::hardware::graphics::composer3 {
+
+class ComposerClientReader {
+ public:
+ ~ComposerClientReader() { resetData(); }
+
+ // Parse and execute commands from the command queue. The commands are
+ // actually return values from the server and will be saved in ReturnData.
+ void parse(const std::vector<CommandResultPayload>& results) {
+ resetData();
+
+ for (const auto& result : results) {
+ switch (result.getTag()) {
+ case CommandResultPayload::Tag::error:
+ parseSetError(result.get<CommandResultPayload::Tag::error>());
+ break;
+ case CommandResultPayload::Tag::changedCompositionTypes:
+ parseSetChangedCompositionTypes(
+ result.get<CommandResultPayload::Tag::changedCompositionTypes>());
+ break;
+ case CommandResultPayload::Tag::displayRequest:
+ parseSetDisplayRequests(
+ result.get<CommandResultPayload::Tag::displayRequest>());
+ break;
+ case CommandResultPayload::Tag::presentFence:
+ parseSetPresentFence(result.get<CommandResultPayload::Tag::presentFence>());
+ break;
+ case CommandResultPayload::Tag::releaseFences:
+ parseSetReleaseFences(result.get<CommandResultPayload::Tag::releaseFences>());
+ break;
+ case CommandResultPayload::Tag::presentOrValidateResult:
+ parseSetPresentOrValidateDisplayResult(
+ result.get<CommandResultPayload::Tag::presentOrValidateResult>());
+ break;
+ case CommandResultPayload::Tag::clientTargetProperty:
+ parseSetClientTargetProperty(
+ result.get<CommandResultPayload::Tag::clientTargetProperty>());
+ break;
+ }
+ }
+ }
+
+ std::vector<CommandError> takeErrors() { return std::move(mErrors); }
+
+ bool hasChanges(int64_t display, uint32_t* outNumChangedCompositionTypes,
+ uint32_t* outNumLayerRequestMasks) const {
+ auto found = mReturnData.find(display);
+ if (found == mReturnData.end()) {
+ *outNumChangedCompositionTypes = 0;
+ *outNumLayerRequestMasks = 0;
+ return false;
+ }
+
+ const ReturnData& data = found->second;
+
+ *outNumChangedCompositionTypes = static_cast<uint32_t>(data.compositionTypes.size());
+ *outNumLayerRequestMasks = static_cast<uint32_t>(data.requestMasks.size());
+
+ return !(data.compositionTypes.empty() && data.requestMasks.empty());
+ }
+
+ // Get and clear saved changed composition types.
+ void takeChangedCompositionTypes(int64_t display, std::vector<int64_t>* outLayers,
+ std::vector<Composition>* outTypes) {
+ auto found = mReturnData.find(display);
+ if (found == mReturnData.end()) {
+ outLayers->clear();
+ outTypes->clear();
+ return;
+ }
+
+ ReturnData& data = found->second;
+
+ *outLayers = std::move(data.changedLayers);
+ *outTypes = std::move(data.compositionTypes);
+ }
+
+ // Get and clear saved display requests.
+ void takeDisplayRequests(int64_t display, uint32_t* outDisplayRequestMask,
+ std::vector<int64_t>* outLayers,
+ std::vector<uint32_t>* outLayerRequestMasks) {
+ auto found = mReturnData.find(display);
+ if (found == mReturnData.end()) {
+ *outDisplayRequestMask = 0;
+ outLayers->clear();
+ outLayerRequestMasks->clear();
+ return;
+ }
+
+ ReturnData& data = found->second;
+
+ *outDisplayRequestMask = data.displayRequests;
+ *outLayers = std::move(data.requestedLayers);
+ *outLayerRequestMasks = std::move(data.requestMasks);
+ }
+
+ // Get and clear saved release fences.
+ void takeReleaseFences(int64_t display, std::vector<int64_t>* outLayers,
+ std::vector<int>* outReleaseFences) {
+ auto found = mReturnData.find(display);
+ if (found == mReturnData.end()) {
+ outLayers->clear();
+ outReleaseFences->clear();
+ return;
+ }
+
+ ReturnData& data = found->second;
+
+ *outLayers = std::move(data.releasedLayers);
+ *outReleaseFences = std::move(data.releaseFences);
+ }
+
+ // Get and clear saved present fence.
+ void takePresentFence(int64_t display, int* outPresentFence) {
+ auto found = mReturnData.find(display);
+ if (found == mReturnData.end()) {
+ *outPresentFence = -1;
+ return;
+ }
+
+ ReturnData& data = found->second;
+
+ *outPresentFence = data.presentFence;
+ data.presentFence = -1;
+ }
+
+ // Get what stage succeeded during PresentOrValidate: Present or Validate
+ void takePresentOrValidateStage(int64_t display, uint32_t* state) {
+ auto found = mReturnData.find(display);
+ if (found == mReturnData.end()) {
+ *state = static_cast<uint32_t>(-1);
+ return;
+ }
+ ReturnData& data = found->second;
+ *state = data.presentOrValidateState;
+ }
+
+ // Get the client target properties requested by hardware composer.
+ void takeClientTargetProperty(int64_t display, ClientTargetProperty* outClientTargetProperty,
+ float* outWhitePointNits) {
+ auto found = mReturnData.find(display);
+
+ // If not found, return the default values.
+ if (found == mReturnData.end()) {
+ outClientTargetProperty->pixelFormat = common::PixelFormat::RGBA_8888;
+ outClientTargetProperty->dataspace = Dataspace::UNKNOWN;
+ *outWhitePointNits = -1.f;
+ return;
+ }
+
+ ReturnData& data = found->second;
+ *outClientTargetProperty = data.clientTargetProperty;
+ *outWhitePointNits = data.clientTargetWhitePointNits;
+ }
+
+ private:
+ void 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();
+ }
+
+ void parseSetError(const CommandError& error) { mErrors.emplace_back(error); }
+
+ void parseSetChangedCompositionTypes(const ChangedCompositionTypes& changedCompositionTypes) {
+ auto& data = mReturnData[changedCompositionTypes.display];
+
+ data.changedLayers.reserve(changedCompositionTypes.layers.size());
+ data.compositionTypes.reserve(changedCompositionTypes.layers.size());
+ for (const auto& layer : changedCompositionTypes.layers) {
+ data.changedLayers.push_back(layer.layer);
+ data.compositionTypes.push_back(layer.composition);
+ }
+ }
+
+ void parseSetDisplayRequests(const DisplayRequest& displayRequest) {
+ auto& data = mReturnData[displayRequest.display];
+
+ data.displayRequests = displayRequest.mask;
+ data.requestedLayers.reserve(displayRequest.layerRequests.size());
+ data.requestMasks.reserve(displayRequest.layerRequests.size());
+ for (const auto& layerRequest : displayRequest.layerRequests) {
+ data.requestedLayers.push_back(layerRequest.layer);
+ data.requestMasks.push_back(layerRequest.mask);
+ }
+ }
+
+ void parseSetPresentFence(const PresentFence& presentFence) {
+ auto& data = mReturnData[presentFence.display];
+ if (data.presentFence >= 0) {
+ close(data.presentFence);
+ }
+ data.presentFence = dup(presentFence.fence.get());
+ }
+
+ void parseSetReleaseFences(const ReleaseFences& releaseFences) {
+ auto& data = mReturnData[releaseFences.display];
+ data.releasedLayers.reserve(releaseFences.layers.size());
+ data.releaseFences.reserve(releaseFences.layers.size());
+ for (const auto& layer : releaseFences.layers) {
+ data.releasedLayers.push_back(layer.layer);
+ data.releaseFences.push_back(dup(layer.fence.get()));
+ }
+ }
+
+ void parseSetPresentOrValidateDisplayResult(const PresentOrValidate& presentOrValidate) {
+ auto& data = mReturnData[presentOrValidate.display];
+ data.presentOrValidateState =
+ presentOrValidate.result == PresentOrValidate::Result::Presented ? 1 : 0;
+ }
+
+ void parseSetClientTargetProperty(const ClientTargetPropertyWithNits& clientTargetProperty) {
+ auto& data = mReturnData[clientTargetProperty.display];
+ data.clientTargetProperty.pixelFormat =
+ clientTargetProperty.clientTargetProperty.pixelFormat;
+ data.clientTargetProperty.dataspace = clientTargetProperty.clientTargetProperty.dataspace;
+ data.clientTargetWhitePointNits = clientTargetProperty.whitePointNits;
+ }
+
+ struct ReturnData {
+ int32_t displayRequests = 0;
+
+ std::vector<int64_t> changedLayers;
+ std::vector<Composition> compositionTypes;
+
+ std::vector<int64_t> requestedLayers;
+ std::vector<uint32_t> requestMasks;
+
+ int presentFence = -1;
+
+ std::vector<int64_t> releasedLayers;
+ std::vector<int> releaseFences;
+
+ uint32_t presentOrValidateState;
+
+ ClientTargetProperty clientTargetProperty{common::PixelFormat::RGBA_8888,
+ Dataspace::UNKNOWN};
+ float clientTargetWhitePointNits = -1.f;
+ };
+
+ std::vector<CommandError> mErrors;
+ std::unordered_map<int64_t, ReturnData> mReturnData;
+};
+
+} // namespace aidl::android::hardware::graphics::composer3
diff --git a/graphics/composer/aidl/include/android/hardware/graphics/composer3/ComposerClientWriter.h b/graphics/composer/aidl/include/android/hardware/graphics/composer3/ComposerClientWriter.h
new file mode 100644
index 0000000..bd03673
--- /dev/null
+++ b/graphics/composer/aidl/include/android/hardware/graphics/composer3/ComposerClientWriter.h
@@ -0,0 +1,272 @@
+/*
+ * Copyright 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include <inttypes.h>
+#include <string.h>
+
+#include <aidl/android/hardware/graphics/common/BlendMode.h>
+#include <aidl/android/hardware/graphics/composer3/Color.h>
+#include <aidl/android/hardware/graphics/composer3/Composition.h>
+#include <aidl/android/hardware/graphics/composer3/FloatColor.h>
+#include <aidl/android/hardware/graphics/composer3/HandleIndex.h>
+#include <aidl/android/hardware/graphics/composer3/IComposer.h>
+#include <aidl/android/hardware/graphics/composer3/IComposerClient.h>
+#include <aidl/android/hardware/graphics/composer3/PerFrameMetadata.h>
+#include <aidl/android/hardware/graphics/composer3/PerFrameMetadataBlob.h>
+
+#include <aidl/android/hardware/graphics/composer3/DisplayCommand.h>
+
+#include <aidl/android/hardware/graphics/common/ColorTransform.h>
+#include <aidl/android/hardware/graphics/common/FRect.h>
+#include <aidl/android/hardware/graphics/common/Rect.h>
+#include <aidl/android/hardware/graphics/common/Transform.h>
+
+#include <log/log.h>
+#include <sync/sync.h>
+
+#include <aidlcommonsupport/NativeHandle.h>
+
+using aidl::android::hardware::graphics::common::BlendMode;
+using aidl::android::hardware::graphics::common::ColorTransform;
+using aidl::android::hardware::graphics::common::Dataspace;
+using aidl::android::hardware::graphics::common::FRect;
+using aidl::android::hardware::graphics::common::Rect;
+using aidl::android::hardware::graphics::common::Transform;
+
+using namespace aidl::android::hardware::graphics::composer3;
+
+using aidl::android::hardware::common::NativeHandle;
+
+namespace aidl::android::hardware::graphics::composer3 {
+
+class ComposerClientWriter {
+ public:
+ ComposerClientWriter() { reset(); }
+
+ virtual ~ComposerClientWriter() { reset(); }
+
+ void reset() {
+ mDisplayCommand.reset();
+ mLayerCommand.reset();
+ mCommands.clear();
+ }
+
+ void setColorTransform(int64_t display, const float* matrix, ColorTransform hint) {
+ ColorTransformPayload colorTransformPayload;
+ colorTransformPayload.matrix.assign(matrix, matrix + 16);
+ colorTransformPayload.hint = hint;
+ getDisplayCommand(display).colorTransform.emplace(std::move(colorTransformPayload));
+ }
+
+ void setClientTarget(int64_t display, uint32_t slot, const native_handle_t* target,
+ int acquireFence, Dataspace dataspace, const std::vector<Rect>& damage) {
+ ClientTarget clientTargetCommand;
+ clientTargetCommand.buffer = getBuffer(slot, target, acquireFence);
+ clientTargetCommand.dataspace = dataspace;
+ clientTargetCommand.damage.assign(damage.begin(), damage.end());
+ getDisplayCommand(display).clientTarget.emplace(std::move(clientTargetCommand));
+ }
+
+ void setOutputBuffer(int64_t display, uint32_t slot, const native_handle_t* buffer,
+ int releaseFence) {
+ getDisplayCommand(display).virtualDisplayOutputBuffer.emplace(
+ getBuffer(slot, buffer, releaseFence));
+ }
+
+ void validateDisplay(int64_t display) { getDisplayCommand(display).validateDisplay = true; }
+
+ void presentOrvalidateDisplay(int64_t display) {
+ getDisplayCommand(display).presentOrValidateDisplay = true;
+ }
+
+ void acceptDisplayChanges(int64_t display) {
+ getDisplayCommand(display).acceptDisplayChanges = true;
+ }
+
+ void presentDisplay(int64_t display) { getDisplayCommand(display).presentDisplay = true; }
+
+ void setLayerCursorPosition(int64_t display, int64_t layer, int32_t x, int32_t y) {
+ common::Point cursorPosition;
+ cursorPosition.x = x;
+ cursorPosition.y = y;
+ getLayerCommand(display, layer).cursorPosition.emplace(std::move(cursorPosition));
+ }
+
+ void setLayerBuffer(int64_t display, int64_t layer, uint32_t slot,
+ const native_handle_t* buffer, int acquireFence) {
+ getLayerCommand(display, layer).buffer = getBuffer(slot, buffer, acquireFence);
+ }
+
+ void setLayerSurfaceDamage(int64_t display, int64_t layer, const std::vector<Rect>& damage) {
+ getLayerCommand(display, layer).damage.emplace(damage.begin(), damage.end());
+ }
+
+ void setLayerBlendMode(int64_t display, int64_t layer, BlendMode mode) {
+ ParcelableBlendMode parcelableBlendMode;
+ parcelableBlendMode.blendMode = mode;
+ getLayerCommand(display, layer).blendMode.emplace(std::move(parcelableBlendMode));
+ }
+
+ void setLayerColor(int64_t display, int64_t layer, Color color) {
+ getLayerCommand(display, layer).color.emplace(std::move(color));
+ }
+
+ void setLayerCompositionType(int64_t display, int64_t layer, Composition type) {
+ ParcelableComposition compositionPayload;
+ compositionPayload.composition = type;
+ getLayerCommand(display, layer).composition.emplace(std::move(compositionPayload));
+ }
+
+ void setLayerDataspace(int64_t display, int64_t layer, Dataspace dataspace) {
+ ParcelableDataspace dataspacePayload;
+ dataspacePayload.dataspace = dataspace;
+ getLayerCommand(display, layer).dataspace.emplace(std::move(dataspacePayload));
+ }
+
+ void setLayerDisplayFrame(int64_t display, int64_t layer, const Rect& frame) {
+ getLayerCommand(display, layer).displayFrame.emplace(frame);
+ }
+
+ void setLayerPlaneAlpha(int64_t display, int64_t layer, float alpha) {
+ PlaneAlpha planeAlpha;
+ planeAlpha.alpha = alpha;
+ getLayerCommand(display, layer).planeAlpha.emplace(std::move(planeAlpha));
+ }
+
+ void setLayerSidebandStream(int64_t display, int64_t layer, const native_handle_t* stream) {
+ NativeHandle handle;
+ if (stream) handle = ::android::dupToAidl(stream);
+ getLayerCommand(display, layer).sidebandStream.emplace(std::move(handle));
+ }
+
+ void setLayerSourceCrop(int64_t display, int64_t layer, const FRect& crop) {
+ getLayerCommand(display, layer).sourceCrop.emplace(crop);
+ }
+
+ void setLayerTransform(int64_t display, int64_t layer, Transform transform) {
+ ParcelableTransform transformPayload;
+ transformPayload.transform = transform;
+ getLayerCommand(display, layer).transform.emplace(std::move(transformPayload));
+ }
+
+ void setLayerVisibleRegion(int64_t display, int64_t layer, const std::vector<Rect>& visible) {
+ getLayerCommand(display, layer).visibleRegion.emplace(visible.begin(), visible.end());
+ }
+
+ void setLayerZOrder(int64_t display, int64_t layer, uint32_t z) {
+ ZOrder zorder;
+ zorder.z = z;
+ getLayerCommand(display, layer).z.emplace(std::move(zorder));
+ }
+
+ void setLayerPerFrameMetadata(int64_t display, int64_t layer,
+ const std::vector<PerFrameMetadata>& metadataVec) {
+ getLayerCommand(display, layer)
+ .perFrameMetadata.emplace(metadataVec.begin(), metadataVec.end());
+ }
+
+ void setLayerColorTransform(int64_t display, int64_t layer, const float* matrix) {
+ getLayerCommand(display, layer).colorTransform.emplace(matrix, matrix + 16);
+ }
+
+ void setLayerPerFrameMetadataBlobs(int64_t display, int64_t layer,
+ const std::vector<PerFrameMetadataBlob>& metadata) {
+ getLayerCommand(display, layer)
+ .perFrameMetadataBlob.emplace(metadata.begin(), metadata.end());
+ }
+
+ void setLayerFloatColor(int64_t display, int64_t layer, FloatColor color) {
+ getLayerCommand(display, layer).floatColor.emplace(color);
+ }
+
+ void setLayerGenericMetadata(int64_t display, int64_t layer, const std::string& key,
+ const bool mandatory, const std::vector<uint8_t>& value) {
+ GenericMetadata metadata;
+ metadata.key.name = key;
+ metadata.key.mandatory = mandatory;
+ metadata.value.assign(value.begin(), value.end());
+ getLayerCommand(display, layer).genericMetadata.emplace(std::move(metadata));
+ }
+
+ void setLayerWhitePointNits(int64_t display, int64_t layer, float whitePointNits) {
+ getLayerCommand(display, layer)
+ .whitePointNits.emplace(WhitePointNits{.nits = whitePointNits});
+ }
+
+ const std::vector<DisplayCommand>& getPendingCommands() {
+ flushLayerCommand();
+ flushDisplayCommand();
+ return mCommands;
+ }
+
+ private:
+ std::optional<DisplayCommand> mDisplayCommand;
+ std::optional<LayerCommand> mLayerCommand;
+ std::vector<DisplayCommand> mCommands;
+
+ Buffer getBuffer(int slot, const native_handle_t* bufferHandle, int fence) {
+ Buffer bufferCommand;
+ bufferCommand.slot = slot;
+ if (bufferHandle) bufferCommand.handle.emplace(::android::dupToAidl(bufferHandle));
+ if (fence > 0) bufferCommand.fence = ::ndk::ScopedFileDescriptor(fence);
+ return bufferCommand;
+ }
+
+ void flushLayerCommand() {
+ if (mLayerCommand.has_value()) {
+ mDisplayCommand->layers.emplace_back(std::move(*mLayerCommand));
+ mLayerCommand.reset();
+ }
+ }
+
+ void flushDisplayCommand() {
+ if (mDisplayCommand.has_value()) {
+ mCommands.emplace_back(std::move(*mDisplayCommand));
+ mDisplayCommand.reset();
+ }
+ }
+
+ DisplayCommand& getDisplayCommand(int64_t display) {
+ if (!mDisplayCommand.has_value() || mDisplayCommand->display != display) {
+ flushLayerCommand();
+ flushDisplayCommand();
+ mDisplayCommand.emplace();
+ mDisplayCommand->display = display;
+ }
+ return *mDisplayCommand;
+ }
+
+ LayerCommand& getLayerCommand(int64_t display, int64_t layer) {
+ getDisplayCommand(display);
+ if (!mLayerCommand.has_value() || mLayerCommand->layer != layer) {
+ flushLayerCommand();
+ mLayerCommand.emplace();
+ mLayerCommand->layer = layer;
+ }
+ return *mLayerCommand;
+ }
+};
+
+} // namespace aidl::android::hardware::graphics::composer3
diff --git a/graphics/composer/aidl/include/android/hardware/graphics/composer3/command-buffer.h b/graphics/composer/aidl/include/android/hardware/graphics/composer3/command-buffer.h
deleted file mode 100644
index fcf2a34..0000000
--- a/graphics/composer/aidl/include/android/hardware/graphics/composer3/command-buffer.h
+++ /dev/null
@@ -1,614 +0,0 @@
-/*
- * Copyright 2021 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <algorithm>
-#include <limits>
-#include <memory>
-#include <unordered_map>
-#include <unordered_set>
-#include <vector>
-
-#include <inttypes.h>
-#include <string.h>
-
-#include <aidl/android/hardware/graphics/common/BlendMode.h>
-#include <aidl/android/hardware/graphics/composer3/ClientTargetProperty.h>
-#include <aidl/android/hardware/graphics/composer3/Color.h>
-#include <aidl/android/hardware/graphics/composer3/Composition.h>
-#include <aidl/android/hardware/graphics/composer3/FloatColor.h>
-#include <aidl/android/hardware/graphics/composer3/HandleIndex.h>
-#include <aidl/android/hardware/graphics/composer3/IComposer.h>
-#include <aidl/android/hardware/graphics/composer3/IComposerClient.h>
-#include <aidl/android/hardware/graphics/composer3/PerFrameMetadata.h>
-#include <aidl/android/hardware/graphics/composer3/PerFrameMetadataBlob.h>
-
-#include <aidl/android/hardware/graphics/composer3/CommandResultPayload.h>
-#include <aidl/android/hardware/graphics/composer3/DisplayCommand.h>
-
-#include <aidl/android/hardware/graphics/common/ColorTransform.h>
-#include <aidl/android/hardware/graphics/common/FRect.h>
-#include <aidl/android/hardware/graphics/common/Rect.h>
-#include <aidl/android/hardware/graphics/common/Transform.h>
-
-#include <log/log.h>
-#include <sync/sync.h>
-
-#include <aidlcommonsupport/NativeHandle.h>
-
-using aidl::android::hardware::graphics::common::BlendMode;
-using aidl::android::hardware::graphics::common::ColorTransform;
-using aidl::android::hardware::graphics::common::Dataspace;
-using aidl::android::hardware::graphics::common::FRect;
-using aidl::android::hardware::graphics::common::Rect;
-using aidl::android::hardware::graphics::common::Transform;
-
-using namespace aidl::android::hardware::graphics::composer3;
-
-using aidl::android::hardware::common::NativeHandle;
-
-namespace aidl::android::hardware::graphics::composer3 {
-
-// This class helps build a command queue. Note that all sizes/lengths are in
-// units of uint32_t's.
-class CommandWriterBase {
- public:
- CommandWriterBase() { reset(); }
-
- virtual ~CommandWriterBase() { reset(); }
-
- void reset() {
- mDisplayCommand.reset();
- mLayerCommand.reset();
- mCommands.clear();
- mCommandsResults.clear();
- }
-
- void setError(int32_t index, int32_t errorCode) {
- CommandError error;
- error.commandIndex = index;
- error.errorCode = errorCode;
- mCommandsResults.emplace_back(std::move(error));
- }
-
- void setPresentOrValidateResult(int64_t display, PresentOrValidate::Result result) {
- PresentOrValidate presentOrValidate;
- presentOrValidate.display = display;
- presentOrValidate.result = result;
- mCommandsResults.emplace_back(std::move(presentOrValidate));
- }
-
- void setChangedCompositionTypes(int64_t display, const std::vector<int64_t>& layers,
- const std::vector<Composition>& types) {
- ChangedCompositionTypes changedCompositionTypes;
- changedCompositionTypes.display = display;
- changedCompositionTypes.layers.reserve(layers.size());
- for (int i = 0; i < layers.size(); i++) {
- auto layer = ChangedCompositionLayer{.layer = layers[i], .composition = types[i]};
- changedCompositionTypes.layers.emplace_back(std::move(layer));
- }
- mCommandsResults.emplace_back(std::move(changedCompositionTypes));
- }
-
- void setDisplayRequests(int64_t display, int32_t displayRequestMask,
- const std::vector<int64_t>& layers,
- const std::vector<int32_t>& layerRequestMasks) {
- DisplayRequest displayRequest;
- displayRequest.display = display;
- displayRequest.mask = displayRequestMask;
- displayRequest.layerRequests.reserve(layers.size());
- for (int i = 0; i < layers.size(); i++) {
- auto layerRequest =
- DisplayRequest::LayerRequest{.layer = layers[i], .mask = layerRequestMasks[i]};
- displayRequest.layerRequests.emplace_back(std::move(layerRequest));
- }
- mCommandsResults.emplace_back(std::move(displayRequest));
- }
-
- void setPresentFence(int64_t display, ::ndk::ScopedFileDescriptor presentFence) {
- if (presentFence.get() >= 0) {
- PresentFence presentFenceCommand;
- presentFenceCommand.fence = std::move(presentFence);
- presentFenceCommand.display = display;
- mCommandsResults.emplace_back(std::move(presentFenceCommand));
- } else {
- ALOGW("%s: invalid present fence %d", __func__, presentFence.get());
- }
- }
-
- void setReleaseFences(int64_t display, const std::vector<int64_t>& layers,
- std::vector<::ndk::ScopedFileDescriptor> releaseFences) {
- ReleaseFences releaseFencesCommand;
- releaseFencesCommand.display = display;
- for (int i = 0; i < layers.size(); i++) {
- if (releaseFences[i].get() >= 0) {
- ReleaseFences::Layer layer;
- layer.layer = layers[i];
- layer.fence = std::move(releaseFences[i]);
- releaseFencesCommand.layers.emplace_back(std::move(layer));
- } else {
- ALOGW("%s: invalid release fence %d", __func__, releaseFences[i].get());
- }
- }
- mCommandsResults.emplace_back(std::move(releaseFencesCommand));
- }
-
- void setClientTargetProperty(int64_t display, const ClientTargetProperty& clientTargetProperty,
- float whitePointNits) {
- ClientTargetPropertyWithNits clientTargetPropertyWithNits;
- clientTargetPropertyWithNits.display = display;
- clientTargetPropertyWithNits.clientTargetProperty = clientTargetProperty;
- clientTargetPropertyWithNits.whitePointNits = whitePointNits;
- mCommandsResults.emplace_back(std::move(clientTargetPropertyWithNits));
- }
-
- void setColorTransform(int64_t display, const float* matrix, ColorTransform hint) {
- ColorTransformPayload colorTransformPayload;
- colorTransformPayload.matrix.assign(matrix, matrix + 16);
- colorTransformPayload.hint = hint;
- getDisplayCommand(display).colorTransform.emplace(std::move(colorTransformPayload));
- }
-
- void setClientTarget(int64_t display, uint32_t slot, const native_handle_t* target,
- int acquireFence, Dataspace dataspace, const std::vector<Rect>& damage) {
- ClientTarget clientTargetCommand;
- clientTargetCommand.buffer = getBuffer(slot, target, acquireFence);
- clientTargetCommand.dataspace = dataspace;
- clientTargetCommand.damage.assign(damage.begin(), damage.end());
- getDisplayCommand(display).clientTarget.emplace(std::move(clientTargetCommand));
- }
-
- void setOutputBuffer(int64_t display, uint32_t slot, const native_handle_t* buffer,
- int releaseFence) {
- getDisplayCommand(display).virtualDisplayOutputBuffer.emplace(
- getBuffer(slot, buffer, releaseFence));
- }
-
- void validateDisplay(int64_t display) { getDisplayCommand(display).validateDisplay = true; }
-
- void presentOrvalidateDisplay(int64_t display) {
- getDisplayCommand(display).presentOrValidateDisplay = true;
- }
-
- void acceptDisplayChanges(int64_t display) {
- getDisplayCommand(display).acceptDisplayChanges = true;
- }
-
- void presentDisplay(int64_t display) { getDisplayCommand(display).presentDisplay = true; }
-
- void setLayerCursorPosition(int64_t display, int64_t layer, int32_t x, int32_t y) {
- common::Point cursorPosition;
- cursorPosition.x = x;
- cursorPosition.y = y;
- getLayerCommand(display, layer).cursorPosition.emplace(std::move(cursorPosition));
- }
-
- void setLayerBuffer(int64_t display, int64_t layer, uint32_t slot,
- const native_handle_t* buffer, int acquireFence) {
- getLayerCommand(display, layer).buffer = getBuffer(slot, buffer, acquireFence);
- }
-
- void setLayerSurfaceDamage(int64_t display, int64_t layer, const std::vector<Rect>& damage) {
- getLayerCommand(display, layer).damage.emplace(damage.begin(), damage.end());
- }
-
- void setLayerBlendMode(int64_t display, int64_t layer, BlendMode mode) {
- ParcelableBlendMode parcelableBlendMode;
- parcelableBlendMode.blendMode = mode;
- getLayerCommand(display, layer).blendMode.emplace(std::move(parcelableBlendMode));
- }
-
- void setLayerColor(int64_t display, int64_t layer, Color color) {
- getLayerCommand(display, layer).color.emplace(std::move(color));
- }
-
- void setLayerCompositionType(int64_t display, int64_t layer, Composition type) {
- ParcelableComposition compositionPayload;
- compositionPayload.composition = type;
- getLayerCommand(display, layer).composition.emplace(std::move(compositionPayload));
- }
-
- void setLayerDataspace(int64_t display, int64_t layer, Dataspace dataspace) {
- ParcelableDataspace dataspacePayload;
- dataspacePayload.dataspace = dataspace;
- getLayerCommand(display, layer).dataspace.emplace(std::move(dataspacePayload));
- }
-
- void setLayerDisplayFrame(int64_t display, int64_t layer, const Rect& frame) {
- getLayerCommand(display, layer).displayFrame.emplace(frame);
- }
-
- void setLayerPlaneAlpha(int64_t display, int64_t layer, float alpha) {
- PlaneAlpha planeAlpha;
- planeAlpha.alpha = alpha;
- getLayerCommand(display, layer).planeAlpha.emplace(std::move(planeAlpha));
- }
-
- void setLayerSidebandStream(int64_t display, int64_t layer, const native_handle_t* stream) {
- NativeHandle handle;
- if (stream) handle = ::android::dupToAidl(stream);
- getLayerCommand(display, layer).sidebandStream.emplace(std::move(handle));
- }
-
- void setLayerSourceCrop(int64_t display, int64_t layer, const FRect& crop) {
- getLayerCommand(display, layer).sourceCrop.emplace(crop);
- }
-
- void setLayerTransform(int64_t display, int64_t layer, Transform transform) {
- ParcelableTransform transformPayload;
- transformPayload.transform = transform;
- getLayerCommand(display, layer).transform.emplace(std::move(transformPayload));
- }
-
- void setLayerVisibleRegion(int64_t display, int64_t layer, const std::vector<Rect>& visible) {
- getLayerCommand(display, layer).visibleRegion.emplace(visible.begin(), visible.end());
- }
-
- void setLayerZOrder(int64_t display, int64_t layer, uint32_t z) {
- ZOrder zorder;
- zorder.z = z;
- getLayerCommand(display, layer).z.emplace(std::move(zorder));
- }
-
- void setLayerPerFrameMetadata(int64_t display, int64_t layer,
- const std::vector<PerFrameMetadata>& metadataVec) {
- getLayerCommand(display, layer)
- .perFrameMetadata.emplace(metadataVec.begin(), metadataVec.end());
- }
-
- void setLayerColorTransform(int64_t display, int64_t layer, const float* matrix) {
- getLayerCommand(display, layer).colorTransform.emplace(matrix, matrix + 16);
- }
-
- void setLayerPerFrameMetadataBlobs(int64_t display, int64_t layer,
- const std::vector<PerFrameMetadataBlob>& metadata) {
- getLayerCommand(display, layer)
- .perFrameMetadataBlob.emplace(metadata.begin(), metadata.end());
- }
-
- void setLayerFloatColor(int64_t display, int64_t layer, FloatColor color) {
- getLayerCommand(display, layer).floatColor.emplace(color);
- }
-
- void setLayerGenericMetadata(int64_t display, int64_t layer, const std::string& key,
- const bool mandatory, const std::vector<uint8_t>& value) {
- GenericMetadata metadata;
- metadata.key.name = key;
- metadata.key.mandatory = mandatory;
- metadata.value.assign(value.begin(), value.end());
- getLayerCommand(display, layer).genericMetadata.emplace(std::move(metadata));
- }
-
- void setLayerWhitePointNits(int64_t display, int64_t layer, float whitePointNits) {
- getLayerCommand(display, layer)
- .whitePointNits.emplace(WhitePointNits{.nits = whitePointNits});
- }
-
- const std::vector<DisplayCommand>& getPendingCommands() {
- flushLayerCommand();
- flushDisplayCommand();
- return mCommands;
- }
-
- std::vector<CommandResultPayload> getPendingCommandResults() {
- return std::move(mCommandsResults);
- }
-
- protected:
- Buffer getBuffer(int slot, const native_handle_t* bufferHandle, int fence) {
- Buffer bufferCommand;
- bufferCommand.slot = slot;
- if (bufferHandle) bufferCommand.handle.emplace(::android::dupToAidl(bufferHandle));
- if (fence > 0) bufferCommand.fence = ::ndk::ScopedFileDescriptor(fence);
- return bufferCommand;
- }
-
- std::optional<DisplayCommand> mDisplayCommand;
- std::optional<LayerCommand> mLayerCommand;
- std::vector<DisplayCommand> mCommands;
- std::vector<CommandResultPayload> mCommandsResults;
-
- private:
- void flushLayerCommand() {
- if (mLayerCommand.has_value()) {
- mDisplayCommand->layers.emplace_back(std::move(*mLayerCommand));
- mLayerCommand.reset();
- }
- }
-
- void flushDisplayCommand() {
- if (mDisplayCommand.has_value()) {
- mCommands.emplace_back(std::move(*mDisplayCommand));
- mDisplayCommand.reset();
- }
- }
-
- DisplayCommand& getDisplayCommand(int64_t display) {
- if (!mDisplayCommand.has_value() || mDisplayCommand->display != display) {
- flushLayerCommand();
- flushDisplayCommand();
- mDisplayCommand.emplace();
- mDisplayCommand->display = display;
- }
- return *mDisplayCommand;
- }
-
- LayerCommand& getLayerCommand(int64_t display, int64_t layer) {
- getDisplayCommand(display);
- if (!mLayerCommand.has_value() || mLayerCommand->layer != layer) {
- flushLayerCommand();
- mLayerCommand.emplace();
- mLayerCommand->layer = layer;
- }
- return *mLayerCommand;
- }
-};
-
-class CommandReaderBase {
- public:
- ~CommandReaderBase() { resetData(); }
-
- // Parse and execute commands from the command queue. The commands are
- // actually return values from the server and will be saved in ReturnData.
- void parse(const std::vector<CommandResultPayload>& results) {
- resetData();
-
- for (const auto& result : results) {
- switch (result.getTag()) {
- case CommandResultPayload::Tag::error:
- parseSetError(result.get<CommandResultPayload::Tag::error>());
- break;
- case CommandResultPayload::Tag::changedCompositionTypes:
- parseSetChangedCompositionTypes(
- result.get<CommandResultPayload::Tag::changedCompositionTypes>());
- break;
- case CommandResultPayload::Tag::displayRequest:
- parseSetDisplayRequests(
- result.get<CommandResultPayload::Tag::displayRequest>());
- break;
- case CommandResultPayload::Tag::presentFence:
- parseSetPresentFence(result.get<CommandResultPayload::Tag::presentFence>());
- break;
- case CommandResultPayload::Tag::releaseFences:
- parseSetReleaseFences(result.get<CommandResultPayload::Tag::releaseFences>());
- break;
- case CommandResultPayload::Tag::presentOrValidateResult:
- parseSetPresentOrValidateDisplayResult(
- result.get<CommandResultPayload::Tag::presentOrValidateResult>());
- break;
- case CommandResultPayload::Tag::clientTargetProperty:
- parseSetClientTargetProperty(
- result.get<CommandResultPayload::Tag::clientTargetProperty>());
- break;
- }
- }
- }
-
- std::vector<CommandError> takeErrors() { return std::move(mErrors); }
-
- bool hasChanges(int64_t display, uint32_t* outNumChangedCompositionTypes,
- uint32_t* outNumLayerRequestMasks) const {
- auto found = mReturnData.find(display);
- if (found == mReturnData.end()) {
- *outNumChangedCompositionTypes = 0;
- *outNumLayerRequestMasks = 0;
- return false;
- }
-
- const ReturnData& data = found->second;
-
- *outNumChangedCompositionTypes = static_cast<uint32_t>(data.compositionTypes.size());
- *outNumLayerRequestMasks = static_cast<uint32_t>(data.requestMasks.size());
-
- return !(data.compositionTypes.empty() && data.requestMasks.empty());
- }
-
- // Get and clear saved changed composition types.
- void takeChangedCompositionTypes(int64_t display, std::vector<int64_t>* outLayers,
- std::vector<Composition>* outTypes) {
- auto found = mReturnData.find(display);
- if (found == mReturnData.end()) {
- outLayers->clear();
- outTypes->clear();
- return;
- }
-
- ReturnData& data = found->second;
-
- *outLayers = std::move(data.changedLayers);
- *outTypes = std::move(data.compositionTypes);
- }
-
- // Get and clear saved display requests.
- void takeDisplayRequests(int64_t display, uint32_t* outDisplayRequestMask,
- std::vector<int64_t>* outLayers,
- std::vector<uint32_t>* outLayerRequestMasks) {
- auto found = mReturnData.find(display);
- if (found == mReturnData.end()) {
- *outDisplayRequestMask = 0;
- outLayers->clear();
- outLayerRequestMasks->clear();
- return;
- }
-
- ReturnData& data = found->second;
-
- *outDisplayRequestMask = data.displayRequests;
- *outLayers = std::move(data.requestedLayers);
- *outLayerRequestMasks = std::move(data.requestMasks);
- }
-
- // Get and clear saved release fences.
- void takeReleaseFences(int64_t display, std::vector<int64_t>* outLayers,
- std::vector<int>* outReleaseFences) {
- auto found = mReturnData.find(display);
- if (found == mReturnData.end()) {
- outLayers->clear();
- outReleaseFences->clear();
- return;
- }
-
- ReturnData& data = found->second;
-
- *outLayers = std::move(data.releasedLayers);
- *outReleaseFences = std::move(data.releaseFences);
- }
-
- // Get and clear saved present fence.
- void takePresentFence(int64_t display, int* outPresentFence) {
- auto found = mReturnData.find(display);
- if (found == mReturnData.end()) {
- *outPresentFence = -1;
- return;
- }
-
- ReturnData& data = found->second;
-
- *outPresentFence = data.presentFence;
- data.presentFence = -1;
- }
-
- // Get what stage succeeded during PresentOrValidate: Present or Validate
- void takePresentOrValidateStage(int64_t display, uint32_t* state) {
- auto found = mReturnData.find(display);
- if (found == mReturnData.end()) {
- *state = static_cast<uint32_t>(-1);
- return;
- }
- ReturnData& data = found->second;
- *state = data.presentOrValidateState;
- }
-
- // Get the client target properties requested by hardware composer.
- void takeClientTargetProperty(int64_t display, ClientTargetProperty* outClientTargetProperty,
- float* outWhitePointNits) {
- auto found = mReturnData.find(display);
-
- // If not found, return the default values.
- if (found == mReturnData.end()) {
- outClientTargetProperty->pixelFormat = common::PixelFormat::RGBA_8888;
- outClientTargetProperty->dataspace = Dataspace::UNKNOWN;
- *outWhitePointNits = -1.f;
- return;
- }
-
- ReturnData& data = found->second;
- *outClientTargetProperty = data.clientTargetProperty;
- *outWhitePointNits = data.clientTargetWhitePointNits;
- }
-
- private:
- void 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();
- }
-
- void parseSetError(const CommandError& error) { mErrors.emplace_back(error); }
-
- void parseSetChangedCompositionTypes(const ChangedCompositionTypes& changedCompositionTypes) {
- auto& data = mReturnData[changedCompositionTypes.display];
-
- data.changedLayers.reserve(changedCompositionTypes.layers.size());
- data.compositionTypes.reserve(changedCompositionTypes.layers.size());
- for (const auto& layer : changedCompositionTypes.layers) {
- data.changedLayers.push_back(layer.layer);
- data.compositionTypes.push_back(layer.composition);
- }
- }
-
- void parseSetDisplayRequests(const DisplayRequest& displayRequest) {
- auto& data = mReturnData[displayRequest.display];
-
- data.displayRequests = displayRequest.mask;
- data.requestedLayers.reserve(displayRequest.layerRequests.size());
- data.requestMasks.reserve(displayRequest.layerRequests.size());
- for (const auto& layerRequest : displayRequest.layerRequests) {
- data.requestedLayers.push_back(layerRequest.layer);
- data.requestMasks.push_back(layerRequest.mask);
- }
- }
-
- void parseSetPresentFence(const PresentFence& presentFence) {
- auto& data = mReturnData[presentFence.display];
- if (data.presentFence >= 0) {
- close(data.presentFence);
- }
- data.presentFence = dup(presentFence.fence.get());
- }
-
- void parseSetReleaseFences(const ReleaseFences& releaseFences) {
- auto& data = mReturnData[releaseFences.display];
- data.releasedLayers.reserve(releaseFences.layers.size());
- data.releaseFences.reserve(releaseFences.layers.size());
- for (const auto& layer : releaseFences.layers) {
- data.releasedLayers.push_back(layer.layer);
- data.releaseFences.push_back(dup(layer.fence.get()));
- }
- }
-
- void parseSetPresentOrValidateDisplayResult(const PresentOrValidate& presentOrValidate) {
- auto& data = mReturnData[presentOrValidate.display];
- data.presentOrValidateState =
- presentOrValidate.result == PresentOrValidate::Result::Presented ? 1 : 0;
- }
-
- void parseSetClientTargetProperty(const ClientTargetPropertyWithNits& clientTargetProperty) {
- auto& data = mReturnData[clientTargetProperty.display];
- data.clientTargetProperty.pixelFormat =
- clientTargetProperty.clientTargetProperty.pixelFormat;
- data.clientTargetProperty.dataspace = clientTargetProperty.clientTargetProperty.dataspace;
- data.clientTargetWhitePointNits = clientTargetProperty.whitePointNits;
- }
-
- struct ReturnData {
- int32_t displayRequests = 0;
-
- std::vector<int64_t> changedLayers;
- std::vector<Composition> compositionTypes;
-
- std::vector<int64_t> requestedLayers;
- std::vector<uint32_t> requestMasks;
-
- int presentFence = -1;
-
- std::vector<int64_t> releasedLayers;
- std::vector<int> releaseFences;
-
- uint32_t presentOrValidateState;
-
- ClientTargetProperty clientTargetProperty{common::PixelFormat::RGBA_8888,
- Dataspace::UNKNOWN};
- float clientTargetWhitePointNits = -1.f;
- };
-
- std::vector<CommandError> mErrors;
- std::unordered_map<int64_t, ReturnData> mReturnData;
-};
-
-} // namespace aidl::android::hardware::graphics::composer3