203 lines
8.4 KiB
C++
203 lines
8.4 KiB
C++
/*
|
|
* Copyright 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.
|
|
*/
|
|
|
|
#ifndef ANDROID_HWC_DISPLAY_H
|
|
#define ANDROID_HWC_DISPLAY_H
|
|
|
|
#include <aidl/android/hardware/graphics/common/DisplayDecorationSupport.h>
|
|
#include <aidl/android/hardware/graphics/composer3/ColorMode.h>
|
|
#include <aidl/android/hardware/graphics/composer3/ContentType.h>
|
|
#include <aidl/android/hardware/graphics/composer3/DisplayAttribute.h>
|
|
#include <aidl/android/hardware/graphics/composer3/DisplayCapability.h>
|
|
#include <aidl/android/hardware/graphics/composer3/DisplayConnectionType.h>
|
|
#include <aidl/android/hardware/graphics/composer3/DisplayContentSample.h>
|
|
#include <aidl/android/hardware/graphics/composer3/DisplayIdentification.h>
|
|
#include <aidl/android/hardware/graphics/composer3/HdrCapabilities.h>
|
|
#include <aidl/android/hardware/graphics/composer3/PerFrameMetadataKey.h>
|
|
#include <aidl/android/hardware/graphics/composer3/PowerMode.h>
|
|
#include <aidl/android/hardware/graphics/composer3/ReadbackBufferAttributes.h>
|
|
#include <aidl/android/hardware/graphics/composer3/RenderIntent.h>
|
|
#include <aidl/android/hardware/graphics/composer3/VsyncPeriodChangeConstraints.h>
|
|
#include <aidl/android/hardware/graphics/composer3/VsyncPeriodChangeTimeline.h>
|
|
#include <android-base/unique_fd.h>
|
|
|
|
#include <array>
|
|
#include <mutex>
|
|
#include <optional>
|
|
#include <thread>
|
|
#include <unordered_map>
|
|
#include <unordered_set>
|
|
#include <vector>
|
|
|
|
#include "Common.h"
|
|
#include "DisplayChanges.h"
|
|
#include "DisplayConfig.h"
|
|
#include "DisplayFinder.h"
|
|
#include "FencedBuffer.h"
|
|
#include "FrameComposer.h"
|
|
#include "Layer.h"
|
|
#include "Time.h"
|
|
#include "VsyncThread.h"
|
|
|
|
namespace aidl::android::hardware::graphics::composer3::impl {
|
|
|
|
class FrameComposer;
|
|
|
|
class Display {
|
|
public:
|
|
Display(FrameComposer* composer, int64_t id);
|
|
~Display();
|
|
|
|
Display(const Display& display) = delete;
|
|
Display& operator=(const Display& display) = delete;
|
|
|
|
Display(Display&& display) = delete;
|
|
Display& operator=(Display&& display) = delete;
|
|
|
|
HWC3::Error init(
|
|
const std::vector<DisplayConfig>& configs, int32_t activeConfigId,
|
|
const std::optional<std::vector<uint8_t>>& edid = std::nullopt);
|
|
|
|
HWC3::Error updateParameters(
|
|
uint32_t width, uint32_t height, uint32_t dpiX, uint32_t dpiY,
|
|
uint32_t refreshRateHz,
|
|
const std::optional<std::vector<uint8_t>>& edid = std::nullopt);
|
|
|
|
// HWComposer3 interface.
|
|
HWC3::Error createLayer(int64_t* outLayerId);
|
|
HWC3::Error destroyLayer(int64_t layerId);
|
|
HWC3::Error getActiveConfig(int32_t* outConfigId);
|
|
HWC3::Error getDisplayAttribute(int32_t configId, DisplayAttribute attribute,
|
|
int32_t* outValue);
|
|
HWC3::Error getColorModes(std::vector<ColorMode>* outColorModes);
|
|
HWC3::Error getDisplayCapabilities(std::vector<DisplayCapability>* caps);
|
|
HWC3::Error getDisplayConfigs(std::vector<int32_t>* configs);
|
|
HWC3::Error getDisplayConnectionType(DisplayConnectionType* outType);
|
|
HWC3::Error getDisplayIdentificationData(
|
|
DisplayIdentification* outIdentification);
|
|
HWC3::Error getDisplayName(std::string* outName);
|
|
HWC3::Error getDisplayVsyncPeriod(int32_t* outVsyncPeriod);
|
|
HWC3::Error getDisplayedContentSample(int64_t maxFrames, int64_t timestamp,
|
|
DisplayContentSample* samples);
|
|
HWC3::Error getDisplayedContentSamplingAttributes(
|
|
DisplayContentSamplingAttributes* outAttributes);
|
|
HWC3::Error getDisplayPhysicalOrientation(common::Transform* outOrientation);
|
|
HWC3::Error getHdrCapabilities(HdrCapabilities* outCapabilities);
|
|
HWC3::Error getPerFrameMetadataKeys(
|
|
std::vector<PerFrameMetadataKey>* outKeys);
|
|
HWC3::Error getReadbackBufferAttributes(ReadbackBufferAttributes* attrs);
|
|
HWC3::Error getReadbackBufferFence(ndk::ScopedFileDescriptor* acquireFence);
|
|
HWC3::Error getRenderIntents(ColorMode mode,
|
|
std::vector<RenderIntent>* intents);
|
|
HWC3::Error getSupportedContentTypes(std::vector<ContentType>* types);
|
|
HWC3::Error getDecorationSupport(
|
|
std::optional<common::DisplayDecorationSupport>* support);
|
|
HWC3::Error registerCallback(
|
|
const std::shared_ptr<IComposerCallback>& callback);
|
|
HWC3::Error setActiveConfig(int32_t configId);
|
|
HWC3::Error setActiveConfigWithConstraints(
|
|
int32_t config, const VsyncPeriodChangeConstraints& constraints,
|
|
VsyncPeriodChangeTimeline* outTimeline);
|
|
HWC3::Error setBootConfig(int32_t configId);
|
|
HWC3::Error clearBootConfig();
|
|
HWC3::Error getPreferredBootConfig(int32_t* outConfigId);
|
|
HWC3::Error setAutoLowLatencyMode(bool on);
|
|
HWC3::Error setColorMode(ColorMode mode, RenderIntent intent);
|
|
HWC3::Error setContentType(ContentType contentType);
|
|
HWC3::Error setDisplayedContentSamplingEnabled(
|
|
bool enable, FormatColorComponent componentMask, int64_t maxFrames);
|
|
HWC3::Error setPowerMode(PowerMode mode);
|
|
HWC3::Error setReadbackBuffer(const buffer_handle_t buffer,
|
|
const ndk::ScopedFileDescriptor& releaseFence);
|
|
HWC3::Error setVsyncEnabled(bool enabled);
|
|
HWC3::Error setIdleTimerEnabled(int32_t timeoutMs);
|
|
HWC3::Error setColorTransform(const std::vector<float>& transform);
|
|
HWC3::Error setBrightness(float brightness);
|
|
HWC3::Error setClientTarget(buffer_handle_t buffer,
|
|
const ndk::ScopedFileDescriptor& fence,
|
|
common::Dataspace dataspace,
|
|
const std::vector<common::Rect>& damage);
|
|
HWC3::Error setOutputBuffer(buffer_handle_t buffer,
|
|
const ndk::ScopedFileDescriptor& fence);
|
|
HWC3::Error setExpectedPresentTime(
|
|
const std::optional<ClockMonotonicTimestamp>& expectedPresentTime);
|
|
HWC3::Error validate(DisplayChanges* outChanges);
|
|
HWC3::Error acceptChanges();
|
|
HWC3::Error present(
|
|
::android::base::unique_fd* outDisplayFence,
|
|
std::unordered_map<int64_t, ::android::base::unique_fd>* outLayerFences);
|
|
|
|
// Non HWCComposer3 interface.
|
|
int64_t getId() const { return mId; }
|
|
|
|
Layer* getLayer(int64_t layerHandle);
|
|
|
|
HWC3::Error setEdid(std::vector<uint8_t> edid);
|
|
|
|
bool hasColorTransform() const { return mColorTransform.has_value(); }
|
|
std::array<float, 16> getColorTransform() const { return *mColorTransform; }
|
|
|
|
FencedBuffer& getClientTarget() { return mClientTarget; }
|
|
buffer_handle_t waitAndGetClientTargetBuffer();
|
|
|
|
const std::vector<Layer*>& getOrderedLayers() { return mOrderedLayers; }
|
|
|
|
private:
|
|
bool hasConfig(int32_t configId) const;
|
|
DisplayConfig* getConfig(int32_t configId);
|
|
|
|
std::optional<int32_t> getBootConfigId();
|
|
|
|
void setLegacyEdid();
|
|
|
|
// The state of this display should only be modified from
|
|
// SurfaceFlinger's main loop, with the exception of when dump is
|
|
// called. To prevent a bad state from crashing us during a dump
|
|
// call, all public calls into Display must acquire this mutex.
|
|
mutable std::recursive_mutex mStateMutex;
|
|
|
|
FrameComposer* mComposer = nullptr;
|
|
const int64_t mId;
|
|
std::string mName;
|
|
PowerMode mPowerMode = PowerMode::OFF;
|
|
VsyncThread mVsyncThread;
|
|
FencedBuffer mClientTarget;
|
|
FencedBuffer mReadbackBuffer;
|
|
// Will only be non-null after the Display has been validated and
|
|
// before it has been accepted.
|
|
enum class PresentFlowState {
|
|
WAITING_FOR_VALIDATE,
|
|
WAITING_FOR_ACCEPT,
|
|
WAITING_FOR_PRESENT,
|
|
};
|
|
PresentFlowState mPresentFlowState = PresentFlowState::WAITING_FOR_VALIDATE;
|
|
DisplayChanges mPendingChanges;
|
|
std::optional<TimePoint> mExpectedPresentTime;
|
|
std::unordered_map<int64_t, std::unique_ptr<Layer>> mLayers;
|
|
// Ordered layers available after validate().
|
|
std::vector<Layer*> mOrderedLayers;
|
|
std::optional<int32_t> mActiveConfigId;
|
|
std::unordered_map<int32_t, DisplayConfig> mConfigs;
|
|
std::unordered_set<ColorMode> mColorModes = {ColorMode::NATIVE};
|
|
ColorMode mActiveColorMode = ColorMode::NATIVE;
|
|
std::optional<std::array<float, 16>> mColorTransform;
|
|
std::vector<uint8_t> mEdid;
|
|
};
|
|
|
|
} // namespace aidl::android::hardware::graphics::composer3::impl
|
|
|
|
#endif
|