services/surfaceflinger/DisplayHardware/ComposerHal.cpp - SHIFTPHONES/android_frameworks_native - Gitiles

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

 #undef LOG_TAG
 #define LOG_TAG "HwcComposer"

 #include <inttypes.h>
 #include <log/log.h>

 #include "ComposerHal.h"

 namespace android {

 using hardware::Return;
 using hardware::hidl_vec;
 using hardware::hidl_handle;

 namespace Hwc2 {

 namespace {

 class BufferHandle {
 public:
     BufferHandle(const native_handle_t* buffer)
     {
         // nullptr is not a valid handle to HIDL
         mHandle = (buffer) ? buffer : native_handle_init(mStorage, 0, 0);
     }

     operator const hidl_handle&() const
     {
         return mHandle;
     }

 private:
     NATIVE_HANDLE_DECLARE_STORAGE(mStorage, 0, 0);
     hidl_handle mHandle;
 };

 class FenceHandle
 {
 public:
     FenceHandle(int fd, bool owned)
         : mOwned(owned)
     {
         native_handle_t* handle;
         if (fd >= 0) {
             handle = native_handle_init(mStorage, 1, 0);
             handle->data[0] = fd;
         } else {
             // nullptr is not a valid handle to HIDL
             handle = native_handle_init(mStorage, 0, 0);
         }
         mHandle = handle;
     }

     ~FenceHandle()
     {
         if (mOwned) {
             native_handle_close(mHandle);
         }
     }

     operator const hidl_handle&() const
     {
         return mHandle;
     }

 private:
     bool mOwned;
     NATIVE_HANDLE_DECLARE_STORAGE(mStorage, 1, 0);
     hidl_handle mHandle;
 };

 // assume NO_RESOURCES when Status::isOk returns false
 constexpr Error kDefaultError = Error::NO_RESOURCES;

 template<typename T, typename U>
 T unwrapRet(Return<T>& ret, const U& default_val)
 {
     return (ret.getStatus().isOk()) ? static_cast<T>(ret) :
         static_cast<T>(default_val);
 }

 Error unwrapRet(Return<Error>& ret)
 {
     return unwrapRet(ret, kDefaultError);
 }

 template<typename T>
 void assignFromHidlVec(std::vector<T>& vec, const hidl_vec<T>& data)
 {
     vec.clear();
     vec.insert(vec.begin(), &data[0], &data[data.size()]);
 }

 } // anonymous namespace

 Composer::Composer()
     : mWriter(kWriterInitialSize)
 {
     mComposer = IComposer::getService("hwcomposer");
     if (mComposer == nullptr) {
         LOG_ALWAYS_FATAL("failed to get hwcomposer service");
     }

     mComposer->createClient(
             [&](const auto& tmpError, const auto& tmpClient)
             {
                 if (tmpError == Error::NONE) {
                     mClient = tmpClient;
                 }
             });
     if (mClient == nullptr) {
         LOG_ALWAYS_FATAL("failed to create composer client");
     }
 }

 std::vector<IComposer::Capability> Composer::getCapabilities()
 {
     std::vector<IComposer::Capability> capabilities;
     mComposer->getCapabilities(
             [&](const auto& tmpCapabilities) {
                 assignFromHidlVec(capabilities, tmpCapabilities);
             });

     return capabilities;
 }

 std::string Composer::dumpDebugInfo()
 {
     std::string info;
     mComposer->dumpDebugInfo([&](const auto& tmpInfo) {
         info = tmpInfo.c_str();
     });

     return info;
 }

 void Composer::registerCallback(const sp<IComposerCallback>& callback)
 {
     auto ret = mClient->registerCallback(callback);
     if (!ret.getStatus().isOk()) {
         ALOGE("failed to register IComposerCallback");
     }
 }

 uint32_t Composer::getMaxVirtualDisplayCount()
 {
     auto ret = mClient->getMaxVirtualDisplayCount();
     return unwrapRet(ret, 0);
 }

 Error Composer::createVirtualDisplay(uint32_t width, uint32_t height,
             PixelFormat& format, Display& display)
 {
     const uint32_t bufferSlotCount = 1;
     Error error = kDefaultError;
     mClient->createVirtualDisplay(width, height, format, bufferSlotCount,
             [&](const auto& tmpError, const auto& tmpDisplay,
                 const auto& tmpFormat) {
                 error = tmpError;
                 if (error != Error::NONE) {
                     return;
                 }

                 display = tmpDisplay;
                 format = tmpFormat;
             });

     return error;
 }

 Error Composer::destroyVirtualDisplay(Display display)
 {
     auto ret = mClient->destroyVirtualDisplay(display);
     return unwrapRet(ret);
 }

 Error Composer::acceptDisplayChanges(Display display)
 {
     mWriter.selectDisplay(display);
     mWriter.acceptDisplayChanges();
     return Error::NONE;
 }

 Error Composer::createLayer(Display display, Layer& layer)
 {
     const uint32_t bufferSlotCount = 1;
     Error error = kDefaultError;
     mClient->createLayer(display, bufferSlotCount,
             [&](const auto& tmpError, const auto& tmpLayer) {
                 error = tmpError;
                 if (error != Error::NONE) {
                     return;
                 }

                 layer = tmpLayer;
             });

     return error;
 }

 Error Composer::destroyLayer(Display display, Layer layer)
 {
     auto ret = mClient->destroyLayer(display, layer);
     return unwrapRet(ret);
 }

 Error Composer::getActiveConfig(Display display, Config& config)
 {
     Error error = kDefaultError;
     mClient->getActiveConfig(display,
             [&](const auto& tmpError, const auto& tmpConfig) {
                 error = tmpError;
                 if (error != Error::NONE) {
                     return;
                 }

                 config = tmpConfig;
             });

     return error;
 }

 Error Composer::getChangedCompositionTypes(Display display,
         std::vector<Layer>& layers,
         std::vector<IComposerClient::Composition>& types)
 {
     mReader.takeChangedCompositionTypes(display, layers, types);
     return Error::NONE;
 }

 Error Composer::getColorModes(Display display,
         std::vector<ColorMode>& modes)
 {
     Error error = kDefaultError;
     mClient->getColorModes(display,
             [&](const auto& tmpError, const auto& tmpModes) {
                 error = tmpError;
                 if (error != Error::NONE) {
                     return;
                 }

                 assignFromHidlVec(modes, tmpModes);
             });

     return error;
 }

 Error Composer::getDisplayAttribute(Display display, Config config,
         IComposerClient::Attribute attribute, int32_t& value)
 {
     Error error = kDefaultError;
     mClient->getDisplayAttribute(display, config, attribute,
             [&](const auto& tmpError, const auto& tmpValue) {
                 error = tmpError;
                 if (error != Error::NONE) {
                     return;
                 }

                 value = tmpValue;
             });

     return error;
 }

 Error Composer::getDisplayConfigs(Display display,
         std::vector<Config>& configs)
 {
     Error error = kDefaultError;
     mClient->getDisplayConfigs(display,
             [&](const auto& tmpError, const auto& tmpConfigs) {
                 error = tmpError;
                 if (error != Error::NONE) {
                     return;
                 }

                 assignFromHidlVec(configs, tmpConfigs);
             });

     return error;
 }

 Error Composer::getDisplayName(Display display, std::string& name)
 {
     Error error = kDefaultError;
     mClient->getDisplayName(display,
             [&](const auto& tmpError, const auto& tmpName) {
                 error = tmpError;
                 if (error != Error::NONE) {
                     return;
                 }

                 name = tmpName.c_str();
             });

     return error;
 }

 Error Composer::getDisplayRequests(Display display,
         uint32_t& displayRequestMask, std::vector<Layer>& layers,
         std::vector<uint32_t>& layerRequestMasks)
 {
     mReader.takeDisplayRequests(display, displayRequestMask,
             layers, layerRequestMasks);
     return Error::NONE;
 }

 Error Composer::getDisplayType(Display display, IComposerClient::DisplayType& type)
 {
     Error error = kDefaultError;
     mClient->getDisplayType(display,
             [&](const auto& tmpError, const auto& tmpType) {
                 error = tmpError;
                 if (error != Error::NONE) {
                     return;
                 }

                 type = tmpType;
             });

     return error;
 }

 Error Composer::getDozeSupport(Display display, bool& support)
 {
     Error error = kDefaultError;
     mClient->getDozeSupport(display,
             [&](const auto& tmpError, const auto& tmpSupport) {
                 error = tmpError;
                 if (error != Error::NONE) {
                     return;
                 }

                 support = tmpSupport;
             });

     return error;
 }

 Error Composer::getHdrCapabilities(Display display, std::vector<Hdr>& types,
         float& maxLuminance, float& maxAverageLuminance,
         float& minLuminance)
 {
     Error error = kDefaultError;
     mClient->getHdrCapabilities(display,
             [&](const auto& tmpError, const auto& tmpTypes,
                 const auto& tmpMaxLuminance,
                 const auto& tmpMaxAverageLuminance,
                 const auto& tmpMinLuminance) {
                 error = tmpError;
                 if (error != Error::NONE) {
                     return;
                 }

                 assignFromHidlVec(types, tmpTypes);
                 maxLuminance = tmpMaxLuminance;
                 maxAverageLuminance = tmpMaxAverageLuminance;
                 minLuminance = tmpMinLuminance;
             });

     return error;
 }

 Error Composer::getReleaseFences(Display display, std::vector<Layer>& layers,
         std::vector<int>& releaseFences)
 {
     mReader.takeReleaseFences(display, layers, releaseFences);
     return Error::NONE;
 }

 Error Composer::presentDisplay(Display display, int& presentFence)
 {
     mWriter.selectDisplay(display);
     mWriter.presentDisplay();

     Error error = execute();
     if (error != Error::NONE) {
         return error;
     }

     mReader.takePresentFence(display, presentFence);

     return Error::NONE;
 }

 Error Composer::setActiveConfig(Display display, Config config)
 {
     auto ret = mClient->setActiveConfig(display, config);
     return unwrapRet(ret);
 }

 Error Composer::setClientTarget(Display display, const native_handle_t* target,
         int acquireFence, Dataspace dataspace,
         const std::vector<IComposerClient::Rect>& damage)
 {
     mWriter.selectDisplay(display);
     mWriter.setClientTarget(0, target, acquireFence, dataspace, damage);
     return Error::NONE;
 }

 Error Composer::setColorMode(Display display, ColorMode mode)
 {
     auto ret = mClient->setColorMode(display, mode);
     return unwrapRet(ret);
 }

 Error Composer::setColorTransform(Display display, const float* matrix,
         ColorTransform hint)
 {
     mWriter.selectDisplay(display);
     mWriter.setColorTransform(matrix, hint);
     return Error::NONE;
 }

 Error Composer::setOutputBuffer(Display display, const native_handle_t* buffer,
         int releaseFence)
 {
     mWriter.selectDisplay(display);
     mWriter.setOutputBuffer(0, buffer, dup(releaseFence));
     return Error::NONE;
 }

 Error Composer::setPowerMode(Display display, IComposerClient::PowerMode mode)
 {
     auto ret = mClient->setPowerMode(display, mode);
     return unwrapRet(ret);
 }

 Error Composer::setVsyncEnabled(Display display, IComposerClient::Vsync enabled)
 {
     auto ret = mClient->setVsyncEnabled(display, enabled);
     return unwrapRet(ret);
 }

 Error Composer::setClientTargetSlotCount(Display display)
 {
     const uint32_t bufferSlotCount = 1;
     auto ret = mClient->setClientTargetSlotCount(display, bufferSlotCount);
     return unwrapRet(ret);
 }

 Error Composer::validateDisplay(Display display, uint32_t& numTypes,
         uint32_t& numRequests)
 {
     mWriter.selectDisplay(display);
     mWriter.validateDisplay();

     Error error = execute();
     if (error != Error::NONE) {
         return error;
     }

     mReader.hasChanges(display, numTypes, numRequests);

     return Error::NONE;
 }

 Error Composer::setCursorPosition(Display display, Layer layer,
         int32_t x, int32_t y)
 {
     mWriter.selectDisplay(display);
     mWriter.selectLayer(layer);
     mWriter.setLayerCursorPosition(x, y);
     return Error::NONE;
 }

 Error Composer::setLayerBuffer(Display display, Layer layer,
         const native_handle_t* buffer, int acquireFence)
 {
     mWriter.selectDisplay(display);
     mWriter.selectLayer(layer);
     mWriter.setLayerBuffer(0, buffer, acquireFence);
     return Error::NONE;
 }

 Error Composer::setLayerSurfaceDamage(Display display, Layer layer,
         const std::vector<IComposerClient::Rect>& damage)
 {
     mWriter.selectDisplay(display);
     mWriter.selectLayer(layer);
     mWriter.setLayerSurfaceDamage(damage);
     return Error::NONE;
 }

 Error Composer::setLayerBlendMode(Display display, Layer layer,
         IComposerClient::BlendMode mode)
 {
     mWriter.selectDisplay(display);
     mWriter.selectLayer(layer);
     mWriter.setLayerBlendMode(mode);
     return Error::NONE;
 }

 Error Composer::setLayerColor(Display display, Layer layer,
         const IComposerClient::Color& color)
 {
     mWriter.selectDisplay(display);
     mWriter.selectLayer(layer);
     mWriter.setLayerColor(color);
     return Error::NONE;
 }

 Error Composer::setLayerCompositionType(Display display, Layer layer,
         IComposerClient::Composition type)
 {
     mWriter.selectDisplay(display);
     mWriter.selectLayer(layer);
     mWriter.setLayerCompositionType(type);
     return Error::NONE;
 }

 Error Composer::setLayerDataspace(Display display, Layer layer,
         Dataspace dataspace)
 {
     mWriter.selectDisplay(display);
     mWriter.selectLayer(layer);
     mWriter.setLayerDataspace(dataspace);
     return Error::NONE;
 }

 Error Composer::setLayerDisplayFrame(Display display, Layer layer,
         const IComposerClient::Rect& frame)
 {
     mWriter.selectDisplay(display);
     mWriter.selectLayer(layer);
     mWriter.setLayerDisplayFrame(frame);
     return Error::NONE;
 }

 Error Composer::setLayerPlaneAlpha(Display display, Layer layer,
         float alpha)
 {
     mWriter.selectDisplay(display);
     mWriter.selectLayer(layer);
     mWriter.setLayerPlaneAlpha(alpha);
     return Error::NONE;
 }

 Error Composer::setLayerSidebandStream(Display display, Layer layer,
         const native_handle_t* stream)
 {
     mWriter.selectDisplay(display);
     mWriter.selectLayer(layer);
     mWriter.setLayerSidebandStream(stream);
     return Error::NONE;
 }

 Error Composer::setLayerSourceCrop(Display display, Layer layer,
         const IComposerClient::FRect& crop)
 {
     mWriter.selectDisplay(display);
     mWriter.selectLayer(layer);
     mWriter.setLayerSourceCrop(crop);
     return Error::NONE;
 }

 Error Composer::setLayerTransform(Display display, Layer layer,
         Transform transform)
 {
     mWriter.selectDisplay(display);
     mWriter.selectLayer(layer);
     mWriter.setLayerTransform(transform);
     return Error::NONE;
 }

 Error Composer::setLayerVisibleRegion(Display display, Layer layer,
         const std::vector<IComposerClient::Rect>& visible)
 {
     mWriter.selectDisplay(display);
     mWriter.selectLayer(layer);
     mWriter.setLayerVisibleRegion(visible);
     return Error::NONE;
 }

 Error Composer::setLayerZOrder(Display display, Layer layer, uint32_t z)
 {
     mWriter.selectDisplay(display);
     mWriter.selectLayer(layer);
     mWriter.setLayerZOrder(z);
     return Error::NONE;
 }

 Error Composer::execute()
 {
     // prepare input command queue
     bool queueChanged = false;
     uint32_t commandLength = 0;
     hidl_vec<hidl_handle> commandHandles;
     if (!mWriter.writeQueue(queueChanged, commandLength, commandHandles)) {
         mWriter.reset();
         return Error::NO_RESOURCES;
     }

     // set up new input command queue if necessary
     if (queueChanged) {
         auto ret = mClient->setInputCommandQueue(*mWriter.getMQDescriptor());
         auto error = unwrapRet(ret);
         if (error != Error::NONE) {
             mWriter.reset();
             return error;
         }
     }

     Error error = kDefaultError;
     mClient->executeCommands(commandLength, commandHandles,
             [&](const auto& tmpError, const auto& tmpOutChanged,
                 const auto& tmpOutLength, const auto& tmpOutHandles)
             {
                 error = tmpError;

                 // set up new output command queue if necessary
                 if (error == Error::NONE && tmpOutChanged) {
                     error = kDefaultError;
                     mClient->getOutputCommandQueue(
                             [&](const auto& tmpError,
                                 const auto& tmpDescriptor)
                             {
                                 error = tmpError;
                                 if (error != Error::NONE) {
                                     return;
                                 }

                                 mReader.setMQDescriptor(tmpDescriptor);
                             });
                 }

                 if (error != Error::NONE) {
                     return;
                 }

                 if (mReader.readQueue(tmpOutLength, tmpOutHandles)) {
                     error = mReader.parse();
                     mReader.reset();
                 } else {
                     error = Error::NO_RESOURCES;
                 }
             });

     if (error == Error::NONE) {
         std::vector<CommandReader::CommandError> commandErrors =
             mReader.takeErrors();

         for (const auto& cmdErr : commandErrors) {
             auto command = mWriter.getCommand(cmdErr.location);

             if (command == IComposerClient::Command::VALIDATE_DISPLAY ||
                 command == IComposerClient::Command::PRESENT_DISPLAY) {
                 error = cmdErr.error;
             } else {
                 ALOGW("command 0x%x generated error %d",
                         command, cmdErr.error);
             }
         }
     }

     mWriter.reset();

     return error;
 }

 CommandReader::~CommandReader()
 {
     resetData();
 }

 Error CommandReader::parse()
 {
     resetData();

     IComposerClient::Command command;
     uint16_t length = 0;

     while (!isEmpty()) {
         if (!beginCommand(command, length)) {
             break;
         }

         bool parsed = false;
         switch (command) {
         case IComposerClient::Command::SELECT_DISPLAY:
             parsed = parseSelectDisplay(length);
             break;
         case IComposerClient::Command::SET_ERROR:
             parsed = parseSetError(length);
             break;
         case IComposerClient::Command::SET_CHANGED_COMPOSITION_TYPES:
             parsed = parseSetChangedCompositionTypes(length);
             break;
         case IComposerClient::Command::SET_DISPLAY_REQUESTS:
             parsed = parseSetDisplayRequests(length);
             break;
         case IComposerClient::Command::SET_PRESENT_FENCE:
             parsed = parseSetPresentFence(length);
             break;
         case IComposerClient::Command::SET_RELEASE_FENCES:
             parsed = parseSetReleaseFences(length);
             break;
         default:
             parsed = false;
             break;
         }

         endCommand();

         if (!parsed) {
             ALOGE("failed to parse command 0x%x length %" PRIu16,
                     command, length);
             break;
         }
     }

     return isEmpty() ? Error::NONE : Error::NO_RESOURCES;
 }

 bool CommandReader::parseSelectDisplay(uint16_t length)
 {
     if (length != CommandWriter::kSelectDisplayLength) {
         return false;
     }

     mCurrentReturnData = &mReturnData[read64()];

     return true;
 }

 bool CommandReader::parseSetError(uint16_t length)
 {
     if (length != CommandWriter::kSetErrorLength) {
         return false;
     }

     auto location = read();
     auto error = static_cast<Error>(readSigned());

     mErrors.emplace_back(CommandError{location, error});

     return true;
 }

 bool CommandReader::parseSetChangedCompositionTypes(uint16_t length)
 {
     // (layer id, composition type) pairs
     if (length % 3 != 0 || !mCurrentReturnData) {
         return false;
     }

     uint32_t count = length / 3;
     mCurrentReturnData->changedLayers.reserve(count);
     mCurrentReturnData->compositionTypes.reserve(count);
     while (count > 0) {
         auto layer = read64();
         auto type = static_cast<IComposerClient::Composition>(readSigned());

         mCurrentReturnData->changedLayers.push_back(layer);
         mCurrentReturnData->compositionTypes.push_back(type);

         count--;
     }

     return true;
 }

 bool CommandReader::parseSetDisplayRequests(uint16_t length)
 {
     // display requests followed by (layer id, layer requests) pairs
     if (length % 3 != 1 || !mCurrentReturnData) {
         return false;
     }

     mCurrentReturnData->displayRequests = read();

     uint32_t count = (length - 1) / 3;
     mCurrentReturnData->requestedLayers.reserve(count);
     mCurrentReturnData->requestMasks.reserve(count);
     while (count > 0) {
         auto layer = read64();
         auto layerRequestMask = read();

         mCurrentReturnData->requestedLayers.push_back(layer);
         mCurrentReturnData->requestMasks.push_back(layerRequestMask);

         count--;
     }

     return true;
 }

 bool CommandReader::parseSetPresentFence(uint16_t length)
 {
     if (length != CommandWriter::kSetPresentFenceLength ||
             !mCurrentReturnData) {
         return false;
     }

     if (mCurrentReturnData->presentFence >= 0) {
         close(mCurrentReturnData->presentFence);
     }
     mCurrentReturnData->presentFence = readFence();

     return true;
 }

 bool CommandReader::parseSetReleaseFences(uint16_t length)
 {
     // (layer id, release fence index) pairs
     if (length % 3 != 0 || !mCurrentReturnData) {
         return false;
     }

     uint32_t count = length / 3;
     mCurrentReturnData->releasedLayers.reserve(count);
     mCurrentReturnData->releaseFences.reserve(count);
     while (count > 0) {
         auto layer = read64();
         auto fence = readFence();

         mCurrentReturnData->releasedLayers.push_back(layer);
         mCurrentReturnData->releaseFences.push_back(fence);

         count--;
     }

     return true;
 }

 void CommandReader::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();
     mCurrentReturnData = nullptr;
 }

 std::vector<CommandReader::CommandError> CommandReader::takeErrors()
 {
     return std::move(mErrors);
 }

 bool CommandReader::hasChanges(Display display,
         uint32_t& numChangedCompositionTypes,
         uint32_t& numLayerRequestMasks) const
 {
     auto found = mReturnData.find(display);
     if (found == mReturnData.end()) {
         numChangedCompositionTypes = 0;
         numLayerRequestMasks = 0;
         return false;
     }

     const ReturnData& data = found->second;

     numChangedCompositionTypes = data.compositionTypes.size();
     numLayerRequestMasks = data.requestMasks.size();

     return !(data.compositionTypes.empty() && data.requestMasks.empty());
 }

 void CommandReader::takeChangedCompositionTypes(Display display,
         std::vector<Layer>& layers,
         std::vector<IComposerClient::Composition>& types)
 {
     auto found = mReturnData.find(display);
     if (found == mReturnData.end()) {
         layers.clear();
         types.clear();
         return;
     }

     ReturnData& data = found->second;

     layers = std::move(data.changedLayers);
     types = std::move(data.compositionTypes);
 }

 void CommandReader::takeDisplayRequests(Display display,
         uint32_t& displayRequestMask, std::vector<Layer>& layers,
         std::vector<uint32_t>& layerRequestMasks)
 {
     auto found = mReturnData.find(display);
     if (found == mReturnData.end()) {
         displayRequestMask = 0;
         layers.clear();
         layerRequestMasks.clear();
         return;
     }

     ReturnData& data = found->second;

     displayRequestMask = data.displayRequests;
     layers = std::move(data.requestedLayers);
     layerRequestMasks = std::move(data.requestMasks);
 }

 void CommandReader::takeReleaseFences(Display display,
         std::vector<Layer>& layers, std::vector<int>& releaseFences)
 {
     auto found = mReturnData.find(display);
     if (found == mReturnData.end()) {
         layers.clear();
         releaseFences.clear();
         return;
     }

     ReturnData& data = found->second;

     layers = std::move(data.releasedLayers);
     releaseFences = std::move(data.releaseFences);
 }

 void CommandReader::takePresentFence(Display display, int& presentFence)
 {
     auto found = mReturnData.find(display);
     if (found == mReturnData.end()) {
         presentFence = -1;
         return;
     }

     ReturnData& data = found->second;

     presentFence = data.presentFence;
     data.presentFence = -1;
 }

 } // namespace Hwc2

 } // namespace android
	/*
	* Copyright 2016 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.
	*/

	#undef LOG_TAG
	#define LOG_TAG "HwcComposer"

	#include <inttypes.h>
	#include <log/log.h>

	#include "ComposerHal.h"

	namespace android {

	using hardware::Return;
	using hardware::hidl_vec;
	using hardware::hidl_handle;

	namespace Hwc2 {

	namespace {

	class BufferHandle {
	public:
	BufferHandle(const native_handle_t* buffer)
	{
	// nullptr is not a valid handle to HIDL
	mHandle = (buffer) ? buffer : native_handle_init(mStorage, 0, 0);
	}

	operator const hidl_handle&() const
	{
	return mHandle;
	}

	private:
	NATIVE_HANDLE_DECLARE_STORAGE(mStorage, 0, 0);
	hidl_handle mHandle;
	};

	class FenceHandle
	{
	public:
	FenceHandle(int fd, bool owned)
	: mOwned(owned)
	{
	native_handle_t* handle;
	if (fd >= 0) {
	handle = native_handle_init(mStorage, 1, 0);
	handle->data[0] = fd;
	} else {
	// nullptr is not a valid handle to HIDL
	handle = native_handle_init(mStorage, 0, 0);
	}
	mHandle = handle;
	}

	~FenceHandle()
	{
	if (mOwned) {
	native_handle_close(mHandle);
	}
	}

	operator const hidl_handle&() const
	{
	return mHandle;
	}

	private:
	bool mOwned;
	NATIVE_HANDLE_DECLARE_STORAGE(mStorage, 1, 0);
	hidl_handle mHandle;
	};

	// assume NO_RESOURCES when Status::isOk returns false
	constexpr Error kDefaultError = Error::NO_RESOURCES;

	template<typename T, typename U>
	T unwrapRet(Return<T>& ret, const U& default_val)
	{
	return (ret.getStatus().isOk()) ? static_cast<T>(ret) :
	static_cast<T>(default_val);
	}

	Error unwrapRet(Return<Error>& ret)
	{
	return unwrapRet(ret, kDefaultError);
	}

	template<typename T>
	void assignFromHidlVec(std::vector<T>& vec, const hidl_vec<T>& data)
	{
	vec.clear();
	vec.insert(vec.begin(), &data[0], &data[data.size()]);
	}

	} // anonymous namespace

	Composer::Composer()
	: mWriter(kWriterInitialSize)
	{
	mComposer = IComposer::getService("hwcomposer");
	if (mComposer == nullptr) {
	LOG_ALWAYS_FATAL("failed to get hwcomposer service");
	}

	mComposer->createClient(
	[&](const auto& tmpError, const auto& tmpClient)
	{
	if (tmpError == Error::NONE) {
	mClient = tmpClient;
	}
	});
	if (mClient == nullptr) {
	LOG_ALWAYS_FATAL("failed to create composer client");
	}
	}

	std::vector<IComposer::Capability> Composer::getCapabilities()
	{
	std::vector<IComposer::Capability> capabilities;
	mComposer->getCapabilities(
	[&](const auto& tmpCapabilities) {
	assignFromHidlVec(capabilities, tmpCapabilities);
	});

	return capabilities;
	}

	std::string Composer::dumpDebugInfo()
	{
	std::string info;
	mComposer->dumpDebugInfo([&](const auto& tmpInfo) {
	info = tmpInfo.c_str();
	});

	return info;
	}

	void Composer::registerCallback(const sp<IComposerCallback>& callback)
	{
	auto ret = mClient->registerCallback(callback);
	if (!ret.getStatus().isOk()) {
	ALOGE("failed to register IComposerCallback");
	}
	}

	uint32_t Composer::getMaxVirtualDisplayCount()
	{
	auto ret = mClient->getMaxVirtualDisplayCount();
	return unwrapRet(ret, 0);
	}

	Error Composer::createVirtualDisplay(uint32_t width, uint32_t height,
	PixelFormat& format, Display& display)
	{
	const uint32_t bufferSlotCount = 1;
	Error error = kDefaultError;
	mClient->createVirtualDisplay(width, height, format, bufferSlotCount,
	[&](const auto& tmpError, const auto& tmpDisplay,
	const auto& tmpFormat) {
	error = tmpError;
	if (error != Error::NONE) {
	return;
	}

	display = tmpDisplay;
	format = tmpFormat;
	});

	return error;
	}

	Error Composer::destroyVirtualDisplay(Display display)
	{
	auto ret = mClient->destroyVirtualDisplay(display);
	return unwrapRet(ret);
	}

	Error Composer::acceptDisplayChanges(Display display)
	{
	mWriter.selectDisplay(display);
	mWriter.acceptDisplayChanges();
	return Error::NONE;
	}

	Error Composer::createLayer(Display display, Layer& layer)
	{
	const uint32_t bufferSlotCount = 1;
	Error error = kDefaultError;
	mClient->createLayer(display, bufferSlotCount,
	[&](const auto& tmpError, const auto& tmpLayer) {
	error = tmpError;
	if (error != Error::NONE) {
	return;
	}

	layer = tmpLayer;
	});

	return error;
	}

	Error Composer::destroyLayer(Display display, Layer layer)
	{
	auto ret = mClient->destroyLayer(display, layer);
	return unwrapRet(ret);
	}

	Error Composer::getActiveConfig(Display display, Config& config)
	{
	Error error = kDefaultError;
	mClient->getActiveConfig(display,
	[&](const auto& tmpError, const auto& tmpConfig) {
	error = tmpError;
	if (error != Error::NONE) {
	return;
	}

	config = tmpConfig;
	});

	return error;
	}

	Error Composer::getChangedCompositionTypes(Display display,
	std::vector<Layer>& layers,
	std::vector<IComposerClient::Composition>& types)
	{
	mReader.takeChangedCompositionTypes(display, layers, types);
	return Error::NONE;
	}

	Error Composer::getColorModes(Display display,
	std::vector<ColorMode>& modes)
	{
	Error error = kDefaultError;
	mClient->getColorModes(display,
	[&](const auto& tmpError, const auto& tmpModes) {
	error = tmpError;
	if (error != Error::NONE) {
	return;
	}

	assignFromHidlVec(modes, tmpModes);
	});

	return error;
	}

	Error Composer::getDisplayAttribute(Display display, Config config,
	IComposerClient::Attribute attribute, int32_t& value)
	{
	Error error = kDefaultError;
	mClient->getDisplayAttribute(display, config, attribute,
	[&](const auto& tmpError, const auto& tmpValue) {
	error = tmpError;
	if (error != Error::NONE) {
	return;
	}

	value = tmpValue;
	});

	return error;
	}

	Error Composer::getDisplayConfigs(Display display,
	std::vector<Config>& configs)
	{
	Error error = kDefaultError;
	mClient->getDisplayConfigs(display,
	[&](const auto& tmpError, const auto& tmpConfigs) {
	error = tmpError;
	if (error != Error::NONE) {
	return;
	}

	assignFromHidlVec(configs, tmpConfigs);
	});

	return error;
	}

	Error Composer::getDisplayName(Display display, std::string& name)
	{
	Error error = kDefaultError;
	mClient->getDisplayName(display,
	[&](const auto& tmpError, const auto& tmpName) {
	error = tmpError;
	if (error != Error::NONE) {
	return;
	}

	name = tmpName.c_str();
	});

	return error;
	}

	Error Composer::getDisplayRequests(Display display,
	uint32_t& displayRequestMask, std::vector<Layer>& layers,
	std::vector<uint32_t>& layerRequestMasks)
	{
	mReader.takeDisplayRequests(display, displayRequestMask,
	layers, layerRequestMasks);
	return Error::NONE;
	}

	Error Composer::getDisplayType(Display display, IComposerClient::DisplayType& type)
	{
	Error error = kDefaultError;
	mClient->getDisplayType(display,
	[&](const auto& tmpError, const auto& tmpType) {
	error = tmpError;
	if (error != Error::NONE) {
	return;
	}

	type = tmpType;
	});

	return error;
	}

	Error Composer::getDozeSupport(Display display, bool& support)
	{
	Error error = kDefaultError;
	mClient->getDozeSupport(display,
	[&](const auto& tmpError, const auto& tmpSupport) {
	error = tmpError;
	if (error != Error::NONE) {
	return;
	}

	support = tmpSupport;
	});

	return error;
	}

	Error Composer::getHdrCapabilities(Display display, std::vector<Hdr>& types,
	float& maxLuminance, float& maxAverageLuminance,
	float& minLuminance)
	{
	Error error = kDefaultError;
	mClient->getHdrCapabilities(display,
	[&](const auto& tmpError, const auto& tmpTypes,
	const auto& tmpMaxLuminance,
	const auto& tmpMaxAverageLuminance,
	const auto& tmpMinLuminance) {
	error = tmpError;
	if (error != Error::NONE) {
	return;
	}

	assignFromHidlVec(types, tmpTypes);
	maxLuminance = tmpMaxLuminance;
	maxAverageLuminance = tmpMaxAverageLuminance;
	minLuminance = tmpMinLuminance;
	});

	return error;
	}

	Error Composer::getReleaseFences(Display display, std::vector<Layer>& layers,
	std::vector<int>& releaseFences)
	{
	mReader.takeReleaseFences(display, layers, releaseFences);
	return Error::NONE;
	}

	Error Composer::presentDisplay(Display display, int& presentFence)
	{
	mWriter.selectDisplay(display);
	mWriter.presentDisplay();

	Error error = execute();
	if (error != Error::NONE) {
	return error;
	}

	mReader.takePresentFence(display, presentFence);

	return Error::NONE;
	}

	Error Composer::setActiveConfig(Display display, Config config)
	{
	auto ret = mClient->setActiveConfig(display, config);
	return unwrapRet(ret);
	}

	Error Composer::setClientTarget(Display display, const native_handle_t* target,
	int acquireFence, Dataspace dataspace,
	const std::vector<IComposerClient::Rect>& damage)
	{
	mWriter.selectDisplay(display);
	mWriter.setClientTarget(0, target, acquireFence, dataspace, damage);
	return Error::NONE;
	}

	Error Composer::setColorMode(Display display, ColorMode mode)
	{
	auto ret = mClient->setColorMode(display, mode);
	return unwrapRet(ret);
	}

	Error Composer::setColorTransform(Display display, const float* matrix,
	ColorTransform hint)
	{
	mWriter.selectDisplay(display);
	mWriter.setColorTransform(matrix, hint);
	return Error::NONE;
	}

	Error Composer::setOutputBuffer(Display display, const native_handle_t* buffer,
	int releaseFence)
	{
	mWriter.selectDisplay(display);
	mWriter.setOutputBuffer(0, buffer, dup(releaseFence));
	return Error::NONE;
	}

	Error Composer::setPowerMode(Display display, IComposerClient::PowerMode mode)
	{
	auto ret = mClient->setPowerMode(display, mode);
	return unwrapRet(ret);
	}

	Error Composer::setVsyncEnabled(Display display, IComposerClient::Vsync enabled)
	{
	auto ret = mClient->setVsyncEnabled(display, enabled);
	return unwrapRet(ret);
	}

	Error Composer::setClientTargetSlotCount(Display display)
	{
	const uint32_t bufferSlotCount = 1;
	auto ret = mClient->setClientTargetSlotCount(display, bufferSlotCount);
	return unwrapRet(ret);
	}

	Error Composer::validateDisplay(Display display, uint32_t& numTypes,
	uint32_t& numRequests)
	{
	mWriter.selectDisplay(display);
	mWriter.validateDisplay();

	Error error = execute();
	if (error != Error::NONE) {
	return error;
	}

	mReader.hasChanges(display, numTypes, numRequests);

	return Error::NONE;
	}

	Error Composer::setCursorPosition(Display display, Layer layer,
	int32_t x, int32_t y)
	{
	mWriter.selectDisplay(display);
	mWriter.selectLayer(layer);
	mWriter.setLayerCursorPosition(x, y);
	return Error::NONE;
	}

	Error Composer::setLayerBuffer(Display display, Layer layer,
	const native_handle_t* buffer, int acquireFence)
	{
	mWriter.selectDisplay(display);
	mWriter.selectLayer(layer);
	mWriter.setLayerBuffer(0, buffer, acquireFence);
	return Error::NONE;
	}

	Error Composer::setLayerSurfaceDamage(Display display, Layer layer,
	const std::vector<IComposerClient::Rect>& damage)
	{
	mWriter.selectDisplay(display);
	mWriter.selectLayer(layer);
	mWriter.setLayerSurfaceDamage(damage);
	return Error::NONE;
	}

	Error Composer::setLayerBlendMode(Display display, Layer layer,
	IComposerClient::BlendMode mode)
	{
	mWriter.selectDisplay(display);
	mWriter.selectLayer(layer);
	mWriter.setLayerBlendMode(mode);
	return Error::NONE;
	}

	Error Composer::setLayerColor(Display display, Layer layer,
	const IComposerClient::Color& color)
	{
	mWriter.selectDisplay(display);
	mWriter.selectLayer(layer);
	mWriter.setLayerColor(color);
	return Error::NONE;
	}

	Error Composer::setLayerCompositionType(Display display, Layer layer,
	IComposerClient::Composition type)
	{
	mWriter.selectDisplay(display);
	mWriter.selectLayer(layer);
	mWriter.setLayerCompositionType(type);
	return Error::NONE;
	}

	Error Composer::setLayerDataspace(Display display, Layer layer,
	Dataspace dataspace)
	{
	mWriter.selectDisplay(display);
	mWriter.selectLayer(layer);
	mWriter.setLayerDataspace(dataspace);
	return Error::NONE;
	}

	Error Composer::setLayerDisplayFrame(Display display, Layer layer,
	const IComposerClient::Rect& frame)
	{
	mWriter.selectDisplay(display);
	mWriter.selectLayer(layer);
	mWriter.setLayerDisplayFrame(frame);
	return Error::NONE;
	}

	Error Composer::setLayerPlaneAlpha(Display display, Layer layer,
	float alpha)
	{
	mWriter.selectDisplay(display);
	mWriter.selectLayer(layer);
	mWriter.setLayerPlaneAlpha(alpha);
	return Error::NONE;
	}

	Error Composer::setLayerSidebandStream(Display display, Layer layer,
	const native_handle_t* stream)
	{
	mWriter.selectDisplay(display);
	mWriter.selectLayer(layer);
	mWriter.setLayerSidebandStream(stream);
	return Error::NONE;
	}

	Error Composer::setLayerSourceCrop(Display display, Layer layer,
	const IComposerClient::FRect& crop)
	{
	mWriter.selectDisplay(display);
	mWriter.selectLayer(layer);
	mWriter.setLayerSourceCrop(crop);
	return Error::NONE;
	}

	Error Composer::setLayerTransform(Display display, Layer layer,
	Transform transform)
	{
	mWriter.selectDisplay(display);
	mWriter.selectLayer(layer);
	mWriter.setLayerTransform(transform);
	return Error::NONE;
	}

	Error Composer::setLayerVisibleRegion(Display display, Layer layer,
	const std::vector<IComposerClient::Rect>& visible)
	{
	mWriter.selectDisplay(display);
	mWriter.selectLayer(layer);
	mWriter.setLayerVisibleRegion(visible);
	return Error::NONE;
	}

	Error Composer::setLayerZOrder(Display display, Layer layer, uint32_t z)
	{
	mWriter.selectDisplay(display);
	mWriter.selectLayer(layer);
	mWriter.setLayerZOrder(z);
	return Error::NONE;
	}

	Error Composer::execute()
	{
	// prepare input command queue
	bool queueChanged = false;
	uint32_t commandLength = 0;
	hidl_vec<hidl_handle> commandHandles;
	if (!mWriter.writeQueue(queueChanged, commandLength, commandHandles)) {
	mWriter.reset();
	return Error::NO_RESOURCES;
	}

	// set up new input command queue if necessary
	if (queueChanged) {
	auto ret = mClient->setInputCommandQueue(*mWriter.getMQDescriptor());
	auto error = unwrapRet(ret);
	if (error != Error::NONE) {
	mWriter.reset();
	return error;
	}
	}

	Error error = kDefaultError;
	mClient->executeCommands(commandLength, commandHandles,
	[&](const auto& tmpError, const auto& tmpOutChanged,
	const auto& tmpOutLength, const auto& tmpOutHandles)
	{
	error = tmpError;

	// set up new output command queue if necessary
	if (error == Error::NONE && tmpOutChanged) {
	error = kDefaultError;
	mClient->getOutputCommandQueue(
	[&](const auto& tmpError,
	const auto& tmpDescriptor)
	{
	error = tmpError;
	if (error != Error::NONE) {
	return;
	}

	mReader.setMQDescriptor(tmpDescriptor);
	});
	}

	if (error != Error::NONE) {
	return;
	}

	if (mReader.readQueue(tmpOutLength, tmpOutHandles)) {
	error = mReader.parse();
	mReader.reset();
	} else {
	error = Error::NO_RESOURCES;
	}
	});

	if (error == Error::NONE) {
	std::vector<CommandReader::CommandError> commandErrors =
	mReader.takeErrors();

	for (const auto& cmdErr : commandErrors) {
	auto command = mWriter.getCommand(cmdErr.location);

	if (command == IComposerClient::Command::VALIDATE_DISPLAY \|\|
	command == IComposerClient::Command::PRESENT_DISPLAY) {
	error = cmdErr.error;
	} else {
	ALOGW("command 0x%x generated error %d",
	command, cmdErr.error);
	}
	}
	}

	mWriter.reset();

	return error;
	}

	CommandReader::~CommandReader()
	{
	resetData();
	}

	Error CommandReader::parse()
	{
	resetData();

	IComposerClient::Command command;
	uint16_t length = 0;

	while (!isEmpty()) {
	if (!beginCommand(command, length)) {
	break;
	}

	bool parsed = false;
	switch (command) {
	case IComposerClient::Command::SELECT_DISPLAY:
	parsed = parseSelectDisplay(length);
	break;
	case IComposerClient::Command::SET_ERROR:
	parsed = parseSetError(length);
	break;
	case IComposerClient::Command::SET_CHANGED_COMPOSITION_TYPES:
	parsed = parseSetChangedCompositionTypes(length);
	break;
	case IComposerClient::Command::SET_DISPLAY_REQUESTS:
	parsed = parseSetDisplayRequests(length);
	break;
	case IComposerClient::Command::SET_PRESENT_FENCE:
	parsed = parseSetPresentFence(length);
	break;
	case IComposerClient::Command::SET_RELEASE_FENCES:
	parsed = parseSetReleaseFences(length);
	break;
	default:
	parsed = false;
	break;
	}

	endCommand();

	if (!parsed) {
	ALOGE("failed to parse command 0x%x length %" PRIu16,
	command, length);
	break;
	}
	}

	return isEmpty() ? Error::NONE : Error::NO_RESOURCES;
	}

	bool CommandReader::parseSelectDisplay(uint16_t length)
	{
	if (length != CommandWriter::kSelectDisplayLength) {
	return false;
	}

	mCurrentReturnData = &mReturnData[read64()];

	return true;
	}

	bool CommandReader::parseSetError(uint16_t length)
	{
	if (length != CommandWriter::kSetErrorLength) {
	return false;
	}

	auto location = read();
	auto error = static_cast<Error>(readSigned());

	mErrors.emplace_back(CommandError{location, error});

	return true;
	}

	bool CommandReader::parseSetChangedCompositionTypes(uint16_t length)
	{
	// (layer id, composition type) pairs
	if (length % 3 != 0 \|\| !mCurrentReturnData) {
	return false;
	}

	uint32_t count = length / 3;
	mCurrentReturnData->changedLayers.reserve(count);
	mCurrentReturnData->compositionTypes.reserve(count);
	while (count > 0) {
	auto layer = read64();
	auto type = static_cast<IComposerClient::Composition>(readSigned());

	mCurrentReturnData->changedLayers.push_back(layer);
	mCurrentReturnData->compositionTypes.push_back(type);

	count--;
	}

	return true;
	}

	bool CommandReader::parseSetDisplayRequests(uint16_t length)
	{
	// display requests followed by (layer id, layer requests) pairs
	if (length % 3 != 1 \|\| !mCurrentReturnData) {
	return false;
	}

	mCurrentReturnData->displayRequests = read();

	uint32_t count = (length - 1) / 3;
	mCurrentReturnData->requestedLayers.reserve(count);
	mCurrentReturnData->requestMasks.reserve(count);
	while (count > 0) {
	auto layer = read64();
	auto layerRequestMask = read();

	mCurrentReturnData->requestedLayers.push_back(layer);
	mCurrentReturnData->requestMasks.push_back(layerRequestMask);

	count--;
	}

	return true;
	}

	bool CommandReader::parseSetPresentFence(uint16_t length)
	{
	if (length != CommandWriter::kSetPresentFenceLength \|\|
	!mCurrentReturnData) {
	return false;
	}

	if (mCurrentReturnData->presentFence >= 0) {
	close(mCurrentReturnData->presentFence);
	}
	mCurrentReturnData->presentFence = readFence();

	return true;
	}

	bool CommandReader::parseSetReleaseFences(uint16_t length)
	{
	// (layer id, release fence index) pairs
	if (length % 3 != 0 \|\| !mCurrentReturnData) {
	return false;
	}

	uint32_t count = length / 3;
	mCurrentReturnData->releasedLayers.reserve(count);
	mCurrentReturnData->releaseFences.reserve(count);
	while (count > 0) {
	auto layer = read64();
	auto fence = readFence();

	mCurrentReturnData->releasedLayers.push_back(layer);
	mCurrentReturnData->releaseFences.push_back(fence);

	count--;
	}

	return true;
	}

	void CommandReader::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();
	mCurrentReturnData = nullptr;
	}

	std::vector<CommandReader::CommandError> CommandReader::takeErrors()
	{
	return std::move(mErrors);
	}

	bool CommandReader::hasChanges(Display display,
	uint32_t& numChangedCompositionTypes,
	uint32_t& numLayerRequestMasks) const
	{
	auto found = mReturnData.find(display);
	if (found == mReturnData.end()) {
	numChangedCompositionTypes = 0;
	numLayerRequestMasks = 0;
	return false;
	}

	const ReturnData& data = found->second;

	numChangedCompositionTypes = data.compositionTypes.size();
	numLayerRequestMasks = data.requestMasks.size();

	return !(data.compositionTypes.empty() && data.requestMasks.empty());
	}

	void CommandReader::takeChangedCompositionTypes(Display display,
	std::vector<Layer>& layers,
	std::vector<IComposerClient::Composition>& types)
	{
	auto found = mReturnData.find(display);
	if (found == mReturnData.end()) {
	layers.clear();
	types.clear();
	return;
	}

	ReturnData& data = found->second;

	layers = std::move(data.changedLayers);
	types = std::move(data.compositionTypes);
	}

	void CommandReader::takeDisplayRequests(Display display,
	uint32_t& displayRequestMask, std::vector<Layer>& layers,
	std::vector<uint32_t>& layerRequestMasks)
	{
	auto found = mReturnData.find(display);
	if (found == mReturnData.end()) {
	displayRequestMask = 0;
	layers.clear();
	layerRequestMasks.clear();
	return;
	}

	ReturnData& data = found->second;

	displayRequestMask = data.displayRequests;
	layers = std::move(data.requestedLayers);
	layerRequestMasks = std::move(data.requestMasks);
	}

	void CommandReader::takeReleaseFences(Display display,
	std::vector<Layer>& layers, std::vector<int>& releaseFences)
	{
	auto found = mReturnData.find(display);
	if (found == mReturnData.end()) {
	layers.clear();
	releaseFences.clear();
	return;
	}

	ReturnData& data = found->second;

	layers = std::move(data.releasedLayers);
	releaseFences = std::move(data.releaseFences);
	}

	void CommandReader::takePresentFence(Display display, int& presentFence)
	{
	auto found = mReturnData.find(display);
	if (found == mReturnData.end()) {
	presentFence = -1;
	return;
	}

	ReturnData& data = found->second;

	presentFence = data.presentFence;
	data.presentFence = -1;
	}

	} // namespace Hwc2

	} // namespace android