services/surfaceflinger/CompositionEngine/src/Display.cpp - android_frameworks_native - Gitiles

 /*
  * Copyright 2019 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.
  */

 #include <android-base/stringprintf.h>
 #include <compositionengine/CompositionEngine.h>
 #include <compositionengine/CompositionRefreshArgs.h>
 #include <compositionengine/DisplayCreationArgs.h>
 #include <compositionengine/DisplaySurface.h>
 #include <compositionengine/LayerFE.h>
 #include <compositionengine/impl/Display.h>
 #include <compositionengine/impl/DisplayColorProfile.h>
 #include <compositionengine/impl/DumpHelpers.h>
 #include <compositionengine/impl/OutputLayer.h>
 #include <compositionengine/impl/RenderSurface.h>

 #include <utils/Trace.h>

 // TODO(b/129481165): remove the #pragma below and fix conversion issues
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wconversion"

 #include "DisplayHardware/HWComposer.h"

 // TODO(b/129481165): remove the #pragma below and fix conversion issues
 #pragma clang diagnostic pop // ignored "-Wconversion"

 #include "DisplayHardware/PowerAdvisor.h"

 namespace android::compositionengine::impl {

 std::shared_ptr<Display> createDisplay(
         const compositionengine::CompositionEngine& compositionEngine,
         const compositionengine::DisplayCreationArgs& args) {
     return createDisplayTemplated<Display>(compositionEngine, args);
 }

 Display::~Display() = default;

 void Display::setConfiguration(const compositionengine::DisplayCreationArgs& args) {
     mIsVirtual = !args.physical;
     mPowerAdvisor = args.powerAdvisor;
     editState().isSecure = args.isSecure;
     editState().displaySpace.bounds = Rect(args.pixels);
     setLayerStackFilter(args.layerStackId,
                         args.physical && args.physical->type == DisplayConnectionType::Internal);
     setName(args.name);
     mGpuVirtualDisplayIdGenerator = args.gpuVirtualDisplayIdGenerator;

     if (args.physical) {
         mId = args.physical->id;
     } else {
         std::optional<DisplayId> id;
         if (args.useHwcVirtualDisplays) {
             id = maybeAllocateDisplayIdForVirtualDisplay(args.pixels, args.pixelFormat);
         }
         if (!id) {
             id = mGpuVirtualDisplayIdGenerator->nextId();
         }
         LOG_ALWAYS_FATAL_IF(!id, "Failed to generate display ID");
         mId = *id;
     }
 }

 std::optional<DisplayId> Display::maybeAllocateDisplayIdForVirtualDisplay(
         ui::Size pixels, ui::PixelFormat pixelFormat) const {
     auto& hwc = getCompositionEngine().getHwComposer();
     return hwc.allocateVirtualDisplay(static_cast<uint32_t>(pixels.width),
                                       static_cast<uint32_t>(pixels.height), &pixelFormat);
 }

 bool Display::isValid() const {
     return Output::isValid() && mPowerAdvisor;
 }

 DisplayId Display::getId() const {
     return mId;
 }

 bool Display::isSecure() const {
     return getState().isSecure;
 }

 bool Display::isVirtual() const {
     return mIsVirtual;
 }

 std::optional<DisplayId> Display::getDisplayId() const {
     return mId;
 }

 void Display::setDisplayIdForTesting(DisplayId displayId) {
     mId = displayId;
 }

 void Display::disconnect() {
     if (mIsDisconnected) {
         return;
     }

     mIsDisconnected = true;
     if (const auto id = GpuVirtualDisplayId::tryCast(mId)) {
         mGpuVirtualDisplayIdGenerator->markUnused(*id);
         return;
     }
     const auto halDisplayId = HalDisplayId::tryCast(mId);
     LOG_FATAL_IF(!halDisplayId);
     getCompositionEngine().getHwComposer().disconnectDisplay(*halDisplayId);
 }

 void Display::setColorTransform(const compositionengine::CompositionRefreshArgs& args) {
     Output::setColorTransform(args);
     const auto halDisplayId = HalDisplayId::tryCast(mId);
     if (mIsDisconnected || !halDisplayId || CC_LIKELY(!args.colorTransformMatrix)) {
         return;
     }

     auto& hwc = getCompositionEngine().getHwComposer();
     status_t result = hwc.setColorTransform(*halDisplayId, *args.colorTransformMatrix);
     ALOGE_IF(result != NO_ERROR, "Failed to set color transform on display \"%s\": %d",
              to_string(mId).c_str(), result);
 }

 void Display::setColorProfile(const ColorProfile& colorProfile) {
     const ui::Dataspace targetDataspace =
             getDisplayColorProfile()->getTargetDataspace(colorProfile.mode, colorProfile.dataspace,
                                                          colorProfile.colorSpaceAgnosticDataspace);

     if (colorProfile.mode == getState().colorMode &&
         colorProfile.dataspace == getState().dataspace &&
         colorProfile.renderIntent == getState().renderIntent &&
         targetDataspace == getState().targetDataspace) {
         return;
     }

     if (mIsVirtual) {
         ALOGW("%s: Invalid operation on virtual display", __FUNCTION__);
         return;
     }

     Output::setColorProfile(colorProfile);

     const auto physicalId = PhysicalDisplayId::tryCast(mId);
     LOG_FATAL_IF(!physicalId);
     getCompositionEngine().getHwComposer().setActiveColorMode(*physicalId, colorProfile.mode,
                                                               colorProfile.renderIntent);
 }

 void Display::dump(std::string& out) const {
     using android::base::StringAppendF;

     StringAppendF(&out, "   Composition Display State: [\"%s\"]", getName().c_str());

     out.append("\n   ");
     dumpVal(out, "isVirtual", mIsVirtual);
     dumpVal(out, "DisplayId", to_string(mId));
     out.append("\n");

     Output::dumpBase(out);
 }

 void Display::createDisplayColorProfile(const DisplayColorProfileCreationArgs& args) {
     setDisplayColorProfile(compositionengine::impl::createDisplayColorProfile(args));
 }

 void Display::createRenderSurface(const RenderSurfaceCreationArgs& args) {
     setRenderSurface(
             compositionengine::impl::createRenderSurface(getCompositionEngine(), *this, args));
 }

 void Display::createClientCompositionCache(uint32_t cacheSize) {
     cacheClientCompositionRequests(cacheSize);
 }

 std::unique_ptr<compositionengine::OutputLayer> Display::createOutputLayer(
         const sp<compositionengine::LayerFE>& layerFE) const {
     auto outputLayer = impl::createOutputLayer(*this, layerFE);

     if (const auto halDisplayId = HalDisplayId::tryCast(mId);
         outputLayer && !mIsDisconnected && halDisplayId) {
         auto& hwc = getCompositionEngine().getHwComposer();
         // Note: For the moment we ensure it is safe to take a reference to the
         // HWComposer implementation by destroying all the OutputLayers (and
         // hence the HWC2::Layers they own) before setting a new HWComposer. See
         // for example SurfaceFlinger::updateVrFlinger().
         // TODO(b/121291683): Make this safer.
         auto hwcLayer =
                 std::shared_ptr<HWC2::Layer>(hwc.createLayer(*halDisplayId),
                                              [&hwc, id = *halDisplayId](HWC2::Layer* layer) {
                                                  hwc.destroyLayer(id, layer);
                                              });
         ALOGE_IF(!hwcLayer, "Failed to create a HWC layer for a HWC supported display %s",
                  getName().c_str());
         outputLayer->setHwcLayer(std::move(hwcLayer));
     }
     return outputLayer;
 }

 void Display::setReleasedLayers(const compositionengine::CompositionRefreshArgs& refreshArgs) {
     Output::setReleasedLayers(refreshArgs);

     if (mIsDisconnected || GpuVirtualDisplayId::tryCast(mId) ||
         refreshArgs.layersWithQueuedFrames.empty()) {
         return;
     }

     // For layers that are being removed from a HWC display, and that have
     // queued frames, add them to a a list of released layers so we can properly
     // set a fence.
     compositionengine::Output::ReleasedLayers releasedLayers;

     // Any non-null entries in the current list of layers are layers that are no
     // longer going to be visible
     for (auto* outputLayer : getOutputLayersOrderedByZ()) {
         if (!outputLayer) {
             continue;
         }

         compositionengine::LayerFE* layerFE = &outputLayer->getLayerFE();
         const bool hasQueuedFrames =
                 std::any_of(refreshArgs.layersWithQueuedFrames.cbegin(),
                             refreshArgs.layersWithQueuedFrames.cend(),
                             [layerFE](sp<compositionengine::LayerFE> layerWithQueuedFrames) {
                                 return layerFE == layerWithQueuedFrames.get();
                             });

         if (hasQueuedFrames) {
             releasedLayers.emplace_back(layerFE);
         }
     }

     setReleasedLayers(std::move(releasedLayers));
 }

 void Display::chooseCompositionStrategy() {
     ATRACE_CALL();
     ALOGV(__FUNCTION__);

     if (mIsDisconnected) {
         return;
     }

     // Default to the base settings -- client composition only.
     Output::chooseCompositionStrategy();

     // If we don't have a HWC display, then we are done.
     const auto halDisplayId = HalDisplayId::tryCast(mId);
     if (!halDisplayId) {
         return;
     }

     // Get any composition changes requested by the HWC device, and apply them.
     std::optional<android::HWComposer::DeviceRequestedChanges> changes;
     auto& hwc = getCompositionEngine().getHwComposer();
     if (status_t result =
                 hwc.getDeviceCompositionChanges(*halDisplayId, anyLayersRequireClientComposition(),
                                                 &changes);
         result != NO_ERROR) {
         ALOGE("chooseCompositionStrategy failed for %s: %d (%s)", getName().c_str(), result,
               strerror(-result));
         return;
     }
     if (changes) {
         applyChangedTypesToLayers(changes->changedTypes);
         applyDisplayRequests(changes->displayRequests);
         applyLayerRequestsToLayers(changes->layerRequests);
         applyClientTargetRequests(changes->clientTargetProperty);
     }

     // Determine what type of composition we are doing from the final state
     auto& state = editState();
     state.usesClientComposition = anyLayersRequireClientComposition();
     state.usesDeviceComposition = !allLayersRequireClientComposition();
 }

 bool Display::getSkipColorTransform() const {
     const auto& hwc = getCompositionEngine().getHwComposer();
     if (const auto halDisplayId = HalDisplayId::tryCast(mId)) {
         return hwc.hasDisplayCapability(*halDisplayId,
                                         hal::DisplayCapability::SKIP_CLIENT_COLOR_TRANSFORM);
     }

     return hwc.hasCapability(hal::Capability::SKIP_CLIENT_COLOR_TRANSFORM);
 }

 bool Display::anyLayersRequireClientComposition() const {
     const auto layers = getOutputLayersOrderedByZ();
     return std::any_of(layers.begin(), layers.end(),
                        [](const auto& layer) { return layer->requiresClientComposition(); });
 }

 bool Display::allLayersRequireClientComposition() const {
     const auto layers = getOutputLayersOrderedByZ();
     return std::all_of(layers.begin(), layers.end(),
                        [](const auto& layer) { return layer->requiresClientComposition(); });
 }

 void Display::applyChangedTypesToLayers(const ChangedTypes& changedTypes) {
     if (changedTypes.empty()) {
         return;
     }

     for (auto* layer : getOutputLayersOrderedByZ()) {
         auto hwcLayer = layer->getHwcLayer();
         if (!hwcLayer) {
             continue;
         }

         if (auto it = changedTypes.find(hwcLayer); it != changedTypes.end()) {
             layer->applyDeviceCompositionTypeChange(
                     static_cast<Hwc2::IComposerClient::Composition>(it->second));
         }
     }
 }

 void Display::applyDisplayRequests(const DisplayRequests& displayRequests) {
     auto& state = editState();
     state.flipClientTarget = (static_cast<uint32_t>(displayRequests) &
                               static_cast<uint32_t>(hal::DisplayRequest::FLIP_CLIENT_TARGET)) != 0;
     // Note: HWC2::DisplayRequest::WriteClientTargetToOutput is currently ignored.
 }

 void Display::applyLayerRequestsToLayers(const LayerRequests& layerRequests) {
     for (auto* layer : getOutputLayersOrderedByZ()) {
         layer->prepareForDeviceLayerRequests();

         auto hwcLayer = layer->getHwcLayer();
         if (!hwcLayer) {
             continue;
         }

         if (auto it = layerRequests.find(hwcLayer); it != layerRequests.end()) {
             layer->applyDeviceLayerRequest(
                     static_cast<Hwc2::IComposerClient::LayerRequest>(it->second));
         }
     }
 }

 void Display::applyClientTargetRequests(const ClientTargetProperty& clientTargetProperty) {
     if (clientTargetProperty.dataspace == ui::Dataspace::UNKNOWN) {
         return;
     }
     auto outputState = editState();
     outputState.dataspace = clientTargetProperty.dataspace;
     getRenderSurface()->setBufferDataspace(clientTargetProperty.dataspace);
     getRenderSurface()->setBufferPixelFormat(clientTargetProperty.pixelFormat);
 }

 compositionengine::Output::FrameFences Display::presentAndGetFrameFences() {
     auto fences = impl::Output::presentAndGetFrameFences();

     const auto halDisplayIdOpt = HalDisplayId::tryCast(mId);
     if (mIsDisconnected || !halDisplayIdOpt) {
         return fences;
     }

     auto& hwc = getCompositionEngine().getHwComposer();
     hwc.presentAndGetReleaseFences(*halDisplayIdOpt);

     fences.presentFence = hwc.getPresentFence(*halDisplayIdOpt);

     // TODO(b/121291683): Change HWComposer call to return entire map
     for (const auto* layer : getOutputLayersOrderedByZ()) {
         auto hwcLayer = layer->getHwcLayer();
         if (!hwcLayer) {
             continue;
         }

         fences.layerFences.emplace(hwcLayer, hwc.getLayerReleaseFence(*halDisplayIdOpt, hwcLayer));
     }

     hwc.clearReleaseFences(*halDisplayIdOpt);

     return fences;
 }

 void Display::setExpensiveRenderingExpected(bool enabled) {
     Output::setExpensiveRenderingExpected(enabled);

     if (mPowerAdvisor && !GpuVirtualDisplayId::tryCast(mId)) {
         mPowerAdvisor->setExpensiveRenderingExpected(mId, enabled);
     }
 }

 void Display::finishFrame(const compositionengine::CompositionRefreshArgs& refreshArgs) {
     // We only need to actually compose the display if:
     // 1) It is being handled by hardware composer, which may need this to
     //    keep its virtual display state machine in sync, or
     // 2) There is work to be done (the dirty region isn't empty)
     if (GpuVirtualDisplayId::tryCast(mId) &&
         getDirtyRegion(refreshArgs.repaintEverything).isEmpty()) {
         ALOGV("Skipping display composition");
         return;
     }

     impl::Output::finishFrame(refreshArgs);
 }

 } // namespace android::compositionengine::impl
	/*
	* Copyright 2019 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.
	*/

	#include <android-base/stringprintf.h>
	#include <compositionengine/CompositionEngine.h>
	#include <compositionengine/CompositionRefreshArgs.h>
	#include <compositionengine/DisplayCreationArgs.h>
	#include <compositionengine/DisplaySurface.h>
	#include <compositionengine/LayerFE.h>
	#include <compositionengine/impl/Display.h>
	#include <compositionengine/impl/DisplayColorProfile.h>
	#include <compositionengine/impl/DumpHelpers.h>
	#include <compositionengine/impl/OutputLayer.h>
	#include <compositionengine/impl/RenderSurface.h>

	#include <utils/Trace.h>

	// TODO(b/129481165): remove the #pragma below and fix conversion issues
	#pragma clang diagnostic push
	#pragma clang diagnostic ignored "-Wconversion"

	#include "DisplayHardware/HWComposer.h"

	// TODO(b/129481165): remove the #pragma below and fix conversion issues
	#pragma clang diagnostic pop // ignored "-Wconversion"

	#include "DisplayHardware/PowerAdvisor.h"

	namespace android::compositionengine::impl {

	std::shared_ptr<Display> createDisplay(
	const compositionengine::CompositionEngine& compositionEngine,
	const compositionengine::DisplayCreationArgs& args) {
	return createDisplayTemplated<Display>(compositionEngine, args);
	}

	Display::~Display() = default;

	void Display::setConfiguration(const compositionengine::DisplayCreationArgs& args) {
	mIsVirtual = !args.physical;
	mPowerAdvisor = args.powerAdvisor;
	editState().isSecure = args.isSecure;
	editState().displaySpace.bounds = Rect(args.pixels);
	setLayerStackFilter(args.layerStackId,
	args.physical && args.physical->type == DisplayConnectionType::Internal);
	setName(args.name);
	mGpuVirtualDisplayIdGenerator = args.gpuVirtualDisplayIdGenerator;

	if (args.physical) {
	mId = args.physical->id;
	} else {
	std::optional<DisplayId> id;
	if (args.useHwcVirtualDisplays) {
	id = maybeAllocateDisplayIdForVirtualDisplay(args.pixels, args.pixelFormat);
	}
	if (!id) {
	id = mGpuVirtualDisplayIdGenerator->nextId();
	}
	LOG_ALWAYS_FATAL_IF(!id, "Failed to generate display ID");
	mId = *id;
	}
	}

	std::optional<DisplayId> Display::maybeAllocateDisplayIdForVirtualDisplay(
	ui::Size pixels, ui::PixelFormat pixelFormat) const {
	auto& hwc = getCompositionEngine().getHwComposer();
	return hwc.allocateVirtualDisplay(static_cast<uint32_t>(pixels.width),
	static_cast<uint32_t>(pixels.height), &pixelFormat);
	}

	bool Display::isValid() const {
	return Output::isValid() && mPowerAdvisor;
	}

	DisplayId Display::getId() const {
	return mId;
	}

	bool Display::isSecure() const {
	return getState().isSecure;
	}

	bool Display::isVirtual() const {
	return mIsVirtual;
	}

	std::optional<DisplayId> Display::getDisplayId() const {
	return mId;
	}

	void Display::setDisplayIdForTesting(DisplayId displayId) {
	mId = displayId;
	}

	void Display::disconnect() {
	if (mIsDisconnected) {
	return;
	}

	mIsDisconnected = true;
	if (const auto id = GpuVirtualDisplayId::tryCast(mId)) {
	mGpuVirtualDisplayIdGenerator->markUnused(*id);
	return;
	}
	const auto halDisplayId = HalDisplayId::tryCast(mId);
	LOG_FATAL_IF(!halDisplayId);
	getCompositionEngine().getHwComposer().disconnectDisplay(*halDisplayId);
	}

	void Display::setColorTransform(const compositionengine::CompositionRefreshArgs& args) {
	Output::setColorTransform(args);
	const auto halDisplayId = HalDisplayId::tryCast(mId);
	if (mIsDisconnected \|\| !halDisplayId \|\| CC_LIKELY(!args.colorTransformMatrix)) {
	return;
	}

	auto& hwc = getCompositionEngine().getHwComposer();
	status_t result = hwc.setColorTransform(halDisplayId, args.colorTransformMatrix);
	ALOGE_IF(result != NO_ERROR, "Failed to set color transform on display \"%s\": %d",
	to_string(mId).c_str(), result);
	}

	void Display::setColorProfile(const ColorProfile& colorProfile) {
	const ui::Dataspace targetDataspace =
	getDisplayColorProfile()->getTargetDataspace(colorProfile.mode, colorProfile.dataspace,
	colorProfile.colorSpaceAgnosticDataspace);

	if (colorProfile.mode == getState().colorMode &&
	colorProfile.dataspace == getState().dataspace &&
	colorProfile.renderIntent == getState().renderIntent &&
	targetDataspace == getState().targetDataspace) {
	return;
	}

	if (mIsVirtual) {
	ALOGW("%s: Invalid operation on virtual display", __FUNCTION__);
	return;
	}

	Output::setColorProfile(colorProfile);

	const auto physicalId = PhysicalDisplayId::tryCast(mId);
	LOG_FATAL_IF(!physicalId);
	getCompositionEngine().getHwComposer().setActiveColorMode(*physicalId, colorProfile.mode,
	colorProfile.renderIntent);
	}

	void Display::dump(std::string& out) const {
	using android::base::StringAppendF;

	StringAppendF(&out, " Composition Display State: [\"%s\"]", getName().c_str());

	out.append("\n ");
	dumpVal(out, "isVirtual", mIsVirtual);
	dumpVal(out, "DisplayId", to_string(mId));
	out.append("\n");

	Output::dumpBase(out);
	}

	void Display::createDisplayColorProfile(const DisplayColorProfileCreationArgs& args) {
	setDisplayColorProfile(compositionengine::impl::createDisplayColorProfile(args));
	}

	void Display::createRenderSurface(const RenderSurfaceCreationArgs& args) {
	setRenderSurface(
	compositionengine::impl::createRenderSurface(getCompositionEngine(), *this, args));
	}

	void Display::createClientCompositionCache(uint32_t cacheSize) {
	cacheClientCompositionRequests(cacheSize);
	}

	std::unique_ptr<compositionengine::OutputLayer> Display::createOutputLayer(
	const sp<compositionengine::LayerFE>& layerFE) const {
	auto outputLayer = impl::createOutputLayer(*this, layerFE);

	if (const auto halDisplayId = HalDisplayId::tryCast(mId);
	outputLayer && !mIsDisconnected && halDisplayId) {
	auto& hwc = getCompositionEngine().getHwComposer();
	// Note: For the moment we ensure it is safe to take a reference to the
	// HWComposer implementation by destroying all the OutputLayers (and
	// hence the HWC2::Layers they own) before setting a new HWComposer. See
	// for example SurfaceFlinger::updateVrFlinger().
	// TODO(b/121291683): Make this safer.
	auto hwcLayer =
	std::shared_ptr<HWC2::Layer>(hwc.createLayer(*halDisplayId),
	[&hwc, id = halDisplayId](HWC2::Layer layer) {
	hwc.destroyLayer(id, layer);
	});
	ALOGE_IF(!hwcLayer, "Failed to create a HWC layer for a HWC supported display %s",
	getName().c_str());
	outputLayer->setHwcLayer(std::move(hwcLayer));
	}
	return outputLayer;
	}

	void Display::setReleasedLayers(const compositionengine::CompositionRefreshArgs& refreshArgs) {
	Output::setReleasedLayers(refreshArgs);

	if (mIsDisconnected \|\| GpuVirtualDisplayId::tryCast(mId) \|\|
	refreshArgs.layersWithQueuedFrames.empty()) {
	return;
	}

	// For layers that are being removed from a HWC display, and that have
	// queued frames, add them to a a list of released layers so we can properly
	// set a fence.
	compositionengine::Output::ReleasedLayers releasedLayers;

	// Any non-null entries in the current list of layers are layers that are no
	// longer going to be visible
	for (auto* outputLayer : getOutputLayersOrderedByZ()) {
	if (!outputLayer) {
	continue;
	}

	compositionengine::LayerFE* layerFE = &outputLayer->getLayerFE();
	const bool hasQueuedFrames =
	std::any_of(refreshArgs.layersWithQueuedFrames.cbegin(),
	refreshArgs.layersWithQueuedFrames.cend(),
	[layerFE](sp<compositionengine::LayerFE> layerWithQueuedFrames) {
	return layerFE == layerWithQueuedFrames.get();
	});

	if (hasQueuedFrames) {
	releasedLayers.emplace_back(layerFE);
	}
	}

	setReleasedLayers(std::move(releasedLayers));
	}

	void Display::chooseCompositionStrategy() {
	ATRACE_CALL();
	ALOGV(__FUNCTION__);

	if (mIsDisconnected) {
	return;
	}

	// Default to the base settings -- client composition only.
	Output::chooseCompositionStrategy();

	// If we don't have a HWC display, then we are done.
	const auto halDisplayId = HalDisplayId::tryCast(mId);
	if (!halDisplayId) {
	return;
	}

	// Get any composition changes requested by the HWC device, and apply them.
	std::optional<android::HWComposer::DeviceRequestedChanges> changes;
	auto& hwc = getCompositionEngine().getHwComposer();
	if (status_t result =
	hwc.getDeviceCompositionChanges(*halDisplayId, anyLayersRequireClientComposition(),
	&changes);
	result != NO_ERROR) {
	ALOGE("chooseCompositionStrategy failed for %s: %d (%s)", getName().c_str(), result,
	strerror(-result));
	return;
	}
	if (changes) {
	applyChangedTypesToLayers(changes->changedTypes);
	applyDisplayRequests(changes->displayRequests);
	applyLayerRequestsToLayers(changes->layerRequests);
	applyClientTargetRequests(changes->clientTargetProperty);
	}

	// Determine what type of composition we are doing from the final state
	auto& state = editState();
	state.usesClientComposition = anyLayersRequireClientComposition();
	state.usesDeviceComposition = !allLayersRequireClientComposition();
	}

	bool Display::getSkipColorTransform() const {
	const auto& hwc = getCompositionEngine().getHwComposer();
	if (const auto halDisplayId = HalDisplayId::tryCast(mId)) {
	return hwc.hasDisplayCapability(*halDisplayId,
	hal::DisplayCapability::SKIP_CLIENT_COLOR_TRANSFORM);
	}

	return hwc.hasCapability(hal::Capability::SKIP_CLIENT_COLOR_TRANSFORM);
	}

	bool Display::anyLayersRequireClientComposition() const {
	const auto layers = getOutputLayersOrderedByZ();
	return std::any_of(layers.begin(), layers.end(),
	[](const auto& layer) { return layer->requiresClientComposition(); });
	}

	bool Display::allLayersRequireClientComposition() const {
	const auto layers = getOutputLayersOrderedByZ();
	return std::all_of(layers.begin(), layers.end(),
	[](const auto& layer) { return layer->requiresClientComposition(); });
	}

	void Display::applyChangedTypesToLayers(const ChangedTypes& changedTypes) {
	if (changedTypes.empty()) {
	return;
	}

	for (auto* layer : getOutputLayersOrderedByZ()) {
	auto hwcLayer = layer->getHwcLayer();
	if (!hwcLayer) {
	continue;
	}

	if (auto it = changedTypes.find(hwcLayer); it != changedTypes.end()) {
	layer->applyDeviceCompositionTypeChange(
	static_cast<Hwc2::IComposerClient::Composition>(it->second));
	}
	}
	}

	void Display::applyDisplayRequests(const DisplayRequests& displayRequests) {
	auto& state = editState();
	state.flipClientTarget = (static_cast<uint32_t>(displayRequests) &
	static_cast<uint32_t>(hal::DisplayRequest::FLIP_CLIENT_TARGET)) != 0;
	// Note: HWC2::DisplayRequest::WriteClientTargetToOutput is currently ignored.
	}

	void Display::applyLayerRequestsToLayers(const LayerRequests& layerRequests) {
	for (auto* layer : getOutputLayersOrderedByZ()) {
	layer->prepareForDeviceLayerRequests();

	auto hwcLayer = layer->getHwcLayer();
	if (!hwcLayer) {
	continue;
	}

	if (auto it = layerRequests.find(hwcLayer); it != layerRequests.end()) {
	layer->applyDeviceLayerRequest(
	static_cast<Hwc2::IComposerClient::LayerRequest>(it->second));
	}
	}
	}

	void Display::applyClientTargetRequests(const ClientTargetProperty& clientTargetProperty) {
	if (clientTargetProperty.dataspace == ui::Dataspace::UNKNOWN) {
	return;
	}
	auto outputState = editState();
	outputState.dataspace = clientTargetProperty.dataspace;
	getRenderSurface()->setBufferDataspace(clientTargetProperty.dataspace);
	getRenderSurface()->setBufferPixelFormat(clientTargetProperty.pixelFormat);
	}

	compositionengine::Output::FrameFences Display::presentAndGetFrameFences() {
	auto fences = impl::Output::presentAndGetFrameFences();

	const auto halDisplayIdOpt = HalDisplayId::tryCast(mId);
	if (mIsDisconnected \|\| !halDisplayIdOpt) {
	return fences;
	}

	auto& hwc = getCompositionEngine().getHwComposer();
	hwc.presentAndGetReleaseFences(*halDisplayIdOpt);

	fences.presentFence = hwc.getPresentFence(*halDisplayIdOpt);

	// TODO(b/121291683): Change HWComposer call to return entire map
	for (const auto* layer : getOutputLayersOrderedByZ()) {
	auto hwcLayer = layer->getHwcLayer();
	if (!hwcLayer) {
	continue;
	}

	fences.layerFences.emplace(hwcLayer, hwc.getLayerReleaseFence(*halDisplayIdOpt, hwcLayer));
	}

	hwc.clearReleaseFences(*halDisplayIdOpt);

	return fences;
	}

	void Display::setExpensiveRenderingExpected(bool enabled) {
	Output::setExpensiveRenderingExpected(enabled);

	if (mPowerAdvisor && !GpuVirtualDisplayId::tryCast(mId)) {
	mPowerAdvisor->setExpensiveRenderingExpected(mId, enabled);
	}
	}

	void Display::finishFrame(const compositionengine::CompositionRefreshArgs& refreshArgs) {
	// We only need to actually compose the display if:
	// 1) It is being handled by hardware composer, which may need this to
	// keep its virtual display state machine in sync, or
	// 2) There is work to be done (the dirty region isn't empty)
	if (GpuVirtualDisplayId::tryCast(mId) &&
	getDirtyRegion(refreshArgs.repaintEverything).isEmpty()) {
	ALOGV("Skipping display composition");
	return;
	}

	impl::Output::finishFrame(refreshArgs);
	}

	} // namespace android::compositionengine::impl