Evolution-x/hardware_interfaces
1
0
Fork 0
mirror of https://github.com/Evolution-X/hardware_interfaces synced 2026-02-01 11:36:00 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge "Revert "composer: adds BufferAhead for the LayerCommand.aidl""

Browse Source
This commit is contained in:
Ady Abraham
2022-02-09 21:53:45 +00:00
committed by Android (Google) Code Review
parent f5ad7c56c9 fac5544455
commit 55a87cc169
11 changed files with 0 additions and 156 deletions
Download Patch File Download Diff File Expand all files Collapse all files

44
graphics/composer/aidl/aidl_api/android.hardware.graphics.composer3/current/android/hardware/graphics/composer3/BufferAheadResult.aidl
View File

@@ -1,44 +0,0 @@
/**
* Copyright (c) 2022, The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
///////////////////////////////////////////////////////////////////////////////
// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
///////////////////////////////////////////////////////////////////////////////
// This file is a snapshot of an AIDL file. Do not edit it manually. There are
// two cases:
// 1). this is a frozen version file - do not edit this in any case.
// 2). this is a 'current' file. If you make a backwards compatible change to
// the interface (from the latest frozen version), the build system will
// prompt you to update this file with `m <name>-update-api`.
//
// You must not make a backward incompatible change to any AIDL file built
// with the aidl_interface module type with versions property set. The module
// type is used to build AIDL files in a way that they can be used across
// independently updatable components of the system. If a device is shipped
// with such a backward incompatible change, it has a high risk of breaking
// later when a module using the interface is updated, e.g., Mainline modules.
package android.hardware.graphics.composer3;
@VintfStability
parcelable BufferAheadResult {
long display;
android.hardware.graphics.composer3.BufferAheadResult.Layer[] layers;
@VintfStability
parcelable Layer {
long layer;
boolean presented;
}
}

1
graphics/composer/aidl/aidl_api/android.hardware.graphics.composer3/current/android/hardware/graphics/composer3/Capability.aidl
View File

@@ -39,5 +39,4 @@ enum Capability {
SKIP_CLIENT_COLOR_TRANSFORM = 2,
PRESENT_FENCE_IS_NOT_RELIABLE = 3,
SKIP_VALIDATE = 4,
BUFFER_AHEAD = 5,
}

1
graphics/composer/aidl/aidl_api/android.hardware.graphics.composer3/current/android/hardware/graphics/composer3/CommandResultPayload.aidl
View File

@@ -39,7 +39,6 @@ union CommandResultPayload {
android.hardware.graphics.composer3.DisplayRequest displayRequest;
android.hardware.graphics.composer3.PresentFence presentFence;
android.hardware.graphics.composer3.ReleaseFences releaseFences;
android.hardware.graphics.composer3.BufferAheadResult bufferAheadResult;
android.hardware.graphics.composer3.PresentOrValidate presentOrValidateResult;
android.hardware.graphics.composer3.ClientTargetPropertyWithNits clientTargetProperty;
}

1
graphics/composer/aidl/aidl_api/android.hardware.graphics.composer3/current/android/hardware/graphics/composer3/LayerCommand.aidl
View File

@@ -37,7 +37,6 @@ parcelable LayerCommand {
long layer;
@nullable android.hardware.graphics.common.Point cursorPosition;
@nullable android.hardware.graphics.composer3.Buffer buffer;
@nullable android.hardware.graphics.composer3.Buffer bufferAhead;
@nullable android.hardware.graphics.common.Rect[] damage;
@nullable android.hardware.graphics.composer3.ParcelableBlendMode blendMode;
@nullable android.hardware.graphics.composer3.Color color;

46
graphics/composer/aidl/android/hardware/graphics/composer3/BufferAheadResult.aidl
View File

@@ -1,46 +0,0 @@
/**
* Copyright (c) 2022, The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package android.hardware.graphics.composer3;
@VintfStability
parcelable BufferAheadResult {
/**
* The display which this commands refers to.
* @see IComposer.createDisplay
*/
long display;
@VintfStability
parcelable Layer {
/**
* The layer which this commands refers to.
* @see IComposer.createLayer
*/
long layer;
/**
* Represents whether BufferAhead was presented as part of the last
* present or not.
*/
boolean presented;
}
/**
* The layers which has BufferAheadResult populated.
*/
Layer[] layers;
}

5
graphics/composer/aidl/android/hardware/graphics/composer3/Capability.aidl
View File

@@ -57,9 +57,4 @@ enum Capability {
* validateDisplay step is needed.
*/
SKIP_VALIDATE = 4,
/**
* Specifies that a device is able to use the LayerCommand.bufferAhead
* when provided.
*/
BUFFER_AHEAD = 5
}

8
graphics/composer/aidl/android/hardware/graphics/composer3/CommandResultPayload.aidl
View File

@@ -16,7 +16,6 @@
package android.hardware.graphics.composer3;
import android.hardware.graphics.composer3.BufferAheadResult;
import android.hardware.graphics.composer3.ChangedCompositionTypes;
import android.hardware.graphics.composer3.ClientTargetPropertyWithNits;
import android.hardware.graphics.composer3.CommandError;
@@ -78,13 +77,6 @@ union CommandResultPayload {
*/
ReleaseFences releaseFences;
/**
* Represents the result of the LayerCommand.bufferAhead that was
* sent in the last presentDisplay call. That is, the presentDisplay
* call prior to this presentDisplay.
*/
BufferAheadResult bufferAheadResult;
/**
* Sets the state of PRESENT_OR_VALIDATE_DISPLAY command.
*/

24
graphics/composer/aidl/android/hardware/graphics/composer3/LayerCommand.aidl
View File

@@ -69,30 +69,6 @@ parcelable LayerCommand {
*/
@nullable Buffer buffer;
/**
* Sets a buffer handle to be displayed for this layer and a file descriptor
* referring to an acquire sync fence object, which must be signaled when it is
* safe to read from the given buffer.
*
* When bufferAhead is provided, the implementation should try to
* present it on the next scanout as long as its acquire sync fence
* is signaled by that time. Otherwise the bufferAhead should be dropped.
* This allows the client to set an
* unsignaled buffer on the layer without causing the entire display to miss
* an update if the buffer is not ready by the next scanout time.
*
* In case bufferAhead is dropped and LayerCommand.buffer is provided, LayerCommand.buffer
* should be used as the next layer buffer.
*
* The implementation is expected to populate the CommandResultPayload.bufferAheadResult
* with information about whether bufferAhead was presented or dropped.
* Since this information is not known at the current presentDisplay call
* of frame N (as the scanout happens after the call returns),
* the implementation should populate it when presentDisplay is
* called for frame N+1.
*/
@nullable Buffer bufferAhead;
/**
* Provides the region of the source buffer which has been modified since
* the last frame. This region does not need to be validated before

1
graphics/composer/aidl/android/hardware/graphics/composer3/vts/functional/VtsHalGraphicsComposer3_TargetTest.cpp
View File

@@ -984,7 +984,6 @@ class GraphicsComposerAidlCommandTest : public GraphicsComposerAidlTest {
const auto errors = mReader.takeErrors();
ASSERT_TRUE(mReader.takeErrors().empty());
ASSERT_TRUE(mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty());
ASSERT_TRUE(mReader.takeBufferAheadResultLayers(getPrimaryDisplayId()).empty());
ASSERT_NO_FATAL_FAILURE(GraphicsComposerAidlTest::TearDown());
}

20
graphics/composer/aidl/include/android/hardware/graphics/composer3/ComposerClientReader.h
View File

@@ -77,10 +77,6 @@ class ComposerClientReader {
parseSetClientTargetProperty(std::move(
result.get<CommandResultPayload::Tag::clientTargetProperty>()));
break;
case CommandResultPayload::Tag::bufferAheadResult:
parseSetBufferAheadResultLayers(
result.get<CommandResultPayload::Tag::bufferAheadResult>());
break;
}
}
}
@@ -172,16 +168,6 @@ class ComposerClientReader {
return std::move(data.clientTargetProperty);
}
std::vector<BufferAheadResult::Layer> takeBufferAheadResultLayers(int64_t display) {
const auto found = mReturnData.find(display);
if (found == mReturnData.end()) {
return {};
}
return std::move(found->second.bufferAheadResultLayers);
}
private:
void resetData() {
mErrors.clear();
@@ -220,18 +206,12 @@ class ComposerClientReader {
data.clientTargetProperty = std::move(clientTargetProperty);
}
void parseSetBufferAheadResultLayers(const BufferAheadResult& bufferAheadResult) {
auto& data = mReturnData[bufferAheadResult.display];
data.bufferAheadResultLayers = std::move(bufferAheadResult.layers);
}
struct ReturnData {
DisplayRequest displayRequests;
std::vector<ChangedCompositionLayer> changedLayers;
ndk::ScopedFileDescriptor presentFence;
std::vector<ReleaseFences::Layer> releasedLayers;
PresentOrValidate::Result presentOrValidateState;
std::vector<BufferAheadResult::Layer> bufferAheadResultLayers;
ClientTargetPropertyWithNits clientTargetProperty = {
.clientTargetProperty = {common::PixelFormat::RGBA_8888, Dataspace::UNKNOWN},

5
graphics/composer/aidl/include/android/hardware/graphics/composer3/ComposerClientWriter.h
View File

@@ -131,11 +131,6 @@ class ComposerClientWriter {
getLayerCommand(display, layer).buffer = getBuffer(slot, buffer, acquireFence);
}
void setLayerBufferAhead(int64_t display, int64_t layer, uint32_t slot,
const native_handle_t* buffer, int acquireFence) {
getLayerCommand(display, layer).bufferAhead = 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());
}