tequilaOS/platform_hardware_interfaces
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Revert "Mark layers with color transform client composition if not implemented."

Browse source 
This reverts commit c53ea9f5f8.

Reason for revert: Breaks some display output
Bug: 129945273
Bug: 115554640

Merged-In: If70a148ae6ad673b5dd03143b3f1ed73eaa1290f
Change-Id: If70a148ae6ad673b5dd03143b3f1ed73eaa1290f
This commit is contained in:
Andrew Chant 2019-04-04 17:40:21 +00:00 committed by Peiyong Lin
parent f2005a3e7a
commit 6f5a48f7af
2 changed files with 6 additions and 123 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

28
graphics/composer/2.1/utils/passthrough/include/composer-passthrough/2.1/HwcHal.h
View file

@ -162,7 +162,6 @@ class HwcHalImpl : public Hal {
Error destroyLayer(Display display, Layer layer) override {
int32_t err = mDispatch.destroyLayer(mDevice, display, layer);
onLayerDestroyed(display, layer);
return static_cast<Error>(err);
}
@ -328,7 +327,6 @@ class HwcHalImpl : public Hal {
std::vector<IComposerClient::Composition>* outCompositionTypes,
uint32_t* outDisplayRequestMask, std::vector<Layer>* outRequestedLayers,
std::vector<uint32_t>* outRequestMasks) override {
onBeforeValidateDisplay(display);
uint32_t typesCount = 0;
uint32_t reqsCount = 0;
int32_t err = mDispatch.validateDisplay(mDevice, display, &typesCount, &reqsCount);
@ -337,15 +335,17 @@ class HwcHalImpl : public Hal {
return static_cast<Error>(err);
}
err = getChangedCompositionTypes(display, &typesCount, nullptr, nullptr);
err = mDispatch.getChangedCompositionTypes(mDevice, display, &typesCount, nullptr, nullptr);
if (err != HWC2_ERROR_NONE) {
return static_cast<Error>(err);
}
std::vector<Layer> changedLayers(typesCount);
std::vector<IComposerClient::Composition> compositionTypes(typesCount);
err = getChangedCompositionTypes(display, &typesCount, changedLayers.data(),
compositionTypes.data());
err = mDispatch.getChangedCompositionTypes(
mDevice, display, &typesCount, changedLayers.data(),
reinterpret_cast<std::underlying_type<IComposerClient::Composition>::type*>(
compositionTypes.data()));
if (err != HWC2_ERROR_NONE) {
return static_cast<Error>(err);
}
@ -578,15 +578,6 @@ class HwcHalImpl : public Hal {
return true;
}
virtual int32_t getChangedCompositionTypes(Display display, uint32_t* outTypesCount,
Layer* outChangedLayers,
IComposerClient::Composition* outCompositionTypes) {
return getChangedCompositionTypesInternal(display, outTypesCount, outChangedLayers,
outCompositionTypes);
}
virtual void onLayerDestroyed(Display /* display */, Layer /* layer */) {}
virtual void onBeforeValidateDisplay(Display /* display */) {}
static void hotplugHook(hwc2_callback_data_t callbackData, hwc2_display_t display,
int32_t connected) {
auto hal = static_cast<HwcHalImpl*>(callbackData);
@ -605,15 +596,6 @@ class HwcHalImpl : public Hal {
hal->mEventCallback->onVsync(display, timestamp);
}
int32_t getChangedCompositionTypesInternal(Display display, uint32_t* outTypesCount,
Layer* outChangedLayers,
IComposerClient::Composition* outCompositionTypes) {
return mDispatch.getChangedCompositionTypes(
mDevice, display, outTypesCount, outChangedLayers,
reinterpret_cast<std::underlying_type<IComposerClient::Composition>::type*>(
outCompositionTypes));
}
hwc2_device_t* mDevice = nullptr;
std::unordered_set<hwc2_capability_t> mCapabilities;

101
graphics/composer/2.3/utils/passthrough/include/composer-passthrough/2.3/HwcHal.h
View file

@ -42,20 +42,6 @@ using common::V1_2::PixelFormat;
using V2_1::Display;
using V2_1::Error;
namespace {
bool isIdentityMatrix(const float* matrix) {
if (matrix[0] == 1.0 && matrix[1] == 0.0 && matrix[2] == 0.0 && matrix[3] == 0.0 &&
matrix[4] == 0.0 && matrix[5] == 1.0 && matrix[6] == 0.0 && matrix[7] == 0.0 &&
matrix[8] == 0.0 && matrix[9] == 0.0 && matrix[10] == 1.0 && matrix[11] == 0.0 &&
matrix[12] == 0.0 && matrix[13] == 0.0 && matrix[14] == 0.0 && matrix[15] == 1.0) {
return true;
}
return false;
}
} // namespace
// HwcHalImpl implements V2_*::hal::ComposerHal on top of hwcomposer2
template <typename Hal>
class HwcHalImpl : public V2_2::passthrough::detail::HwcHalImpl<Hal> {
@ -144,16 +130,6 @@ class HwcHalImpl : public V2_2::passthrough::detail::HwcHalImpl<Hal> {
Error setLayerColorTransform(Display display, Layer layer, const float* matrix) override {
if (!mDispatch.setLayerColorTransform) {
if (isIdentityMatrix(matrix)) {
// If an identity matrix is set, then we can remove the layer from client
// composition list.
mClientCompositionLayers[display].erase(layer);
return Error::UNSUPPORTED;
}
// if setLayerColorTransform is not implemented, per spec we want to make sure the
// layer marked as client composition, and thus we maintain a list, and mark all these
// layers as client composition later before validate the display.
mClientCompositionLayers[display].insert(layer);
return Error::UNSUPPORTED;
}
int32_t err = mDispatch.setLayerColorTransform(mDevice, display, layer, matrix);
@ -318,79 +294,7 @@ class HwcHalImpl : public V2_2::passthrough::detail::HwcHalImpl<Hal> {
return true;
}
int32_t getChangedCompositionTypes(Display display, uint32_t* outTypesCount,
Layer* outChangedLayers,
IComposerClient::Composition* outCompositionTypes) override {
if (outChangedLayers == nullptr && outCompositionTypes == nullptr) {
uint32_t typesCount = 0;
int32_t error = BaseType2_1::getChangedCompositionTypesInternal(display, &typesCount,
nullptr, nullptr);
if (error != HWC2_ERROR_NONE) {
return error;
}
mChangedLayersCache[display].reserve(typesCount);
mCompositionTypesCache[display].reserve(typesCount);
error = BaseType2_1::getChangedCompositionTypesInternal(
display, &typesCount, mChangedLayersCache[display].data(),
mCompositionTypesCache[display].data());
if (error != HWC2_ERROR_NONE) {
return error;
}
for (Layer layer : mClientCompositionLayers[display]) {
bool exist = false;
for (uint32_t i = 0; i < typesCount; ++i) {
if (mChangedLayersCache[display][i] == layer) {
exist = true;
break;
}
}
if (!exist) {
mChangedLayersCache[display].push_back(layer);
mCompositionTypesCache[display].push_back(IComposerClient::Composition::CLIENT);
}
}
*outTypesCount = mChangedLayersCache[display].size();
return error;
}
for (uint32_t i = 0; i < *outTypesCount; ++i) {
if (outChangedLayers != nullptr) {
outChangedLayers[i] = mChangedLayersCache[display][i];
}
if (outCompositionTypes != nullptr) {
outCompositionTypes[i] = mCompositionTypesCache[display][i];
}
}
return HWC2_ERROR_NONE;
}
void onLayerDestroyed(Display display, Layer layer) override {
if (mClientCompositionLayers.find(display) == mClientCompositionLayers.end()) {
return;
}
mClientCompositionLayers[display].erase(layer);
}
void onBeforeValidateDisplay(Display display) override {
if (mClientCompositionLayers.find(display) == mClientCompositionLayers.end()) {
return;
}
// clear the cache proactively so that we don't hold too much memory over time.
mChangedLayersCache[display].clear();
mCompositionTypesCache[display].clear();
// SET_LAYER_COLOR_TRANSFORM is optional, and thus if it's not implemented, we need to
// follow the spec to make sure those layers marked as client composition before validate
// the display.
if (!mDispatch.setLayerColorTransform) {
for (Layer layer : mClientCompositionLayers[display]) {
BaseType2_1::setLayerCompositionType(
display, layer, static_cast<int32_t>(IComposerClient::Composition::CLIENT));
}
}
}
private:
private:
struct {
HWC2_PFN_GET_DISPLAY_IDENTIFICATION_DATA getDisplayIdentificationData;
HWC2_PFN_SET_LAYER_COLOR_TRANSFORM setLayerColorTransform;
@ -414,9 +318,6 @@ class HwcHalImpl : public V2_2::passthrough::detail::HwcHalImpl<Hal> {
using BaseType2_2::getRenderIntents;
using BaseType2_2::setColorMode_2_2;
using BaseType2_2::setLayerPerFrameMetadata;
std::map<Display, std::set<Layer>> mClientCompositionLayers;
std::map<Display, std::vector<Layer>> mChangedLayersCache;
std::map<Display, std::vector<IComposerClient::Composition>> mCompositionTypesCache;
};
} // namespace detail