blob: 6c3bd917935ebcf55cf220989756a110e685f2f1 [file] [log] [blame]
* Copyright (C) 2007 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
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* See the License for the specific language governing permissions and
* limitations under the License.
#include "Transform.h"
#include <stdlib.h>
#include <unordered_map>
#include <math/mat4.h>
#include <binder/IBinder.h>
#include <gui/ISurfaceComposer.h>
#include <hardware/hwcomposer_defs.h>
#include <ui/GraphicTypes.h>
#include <ui/HdrCapabilities.h>
#include <ui/Region.h>
#include <utils/RefBase.h>
#include <utils/Mutex.h>
#include <utils/String8.h>
#include <utils/Timers.h>
#include "RenderArea.h"
#include "RenderEngine/Surface.h"
#include <memory>
struct ANativeWindow;
namespace android {
struct DisplayInfo;
class DisplaySurface;
class Fence;
class IGraphicBufferProducer;
class Layer;
class SurfaceFlinger;
class HWComposer;
class DisplayDevice : public LightRefBase<DisplayDevice>
constexpr static float sDefaultMinLumiance = 0.0;
constexpr static float sDefaultMaxLumiance = 500.0;
// region in layer-stack space
mutable Region dirtyRegion;
// region in screen space
Region undefinedRegion;
bool lastCompositionHadVisibleLayers;
enum DisplayType {
enum {
// clang-format off
const sp<SurfaceFlinger>& flinger,
DisplayType type,
int32_t hwcId,
bool isSecure,
const wp<IBinder>& displayToken,
const sp<ANativeWindow>& nativeWindow,
const sp<DisplaySurface>& displaySurface,
std::unique_ptr<RE::Surface> renderSurface,
int displayWidth,
int displayHeight,
bool hasWideColorGamut,
const HdrCapabilities& hdrCapabilities,
const int32_t supportedPerFrameMetadata,
const std::unordered_map<ui::ColorMode, std::vector<ui::RenderIntent>>& hwcColorModes,
int initialPowerMode);
// clang-format on
// whether this is a valid object. An invalid DisplayDevice is returned
// when an non existing id is requested
bool isValid() const;
// isSecure indicates whether this display can be trusted to display
// secure surfaces.
bool isSecure() const { return mIsSecure; }
// Flip the front and back buffers if the back buffer is "dirty". Might
// be instantaneous, might involve copying the frame buffer around.
void flip() const;
int getWidth() const;
int getHeight() const;
void setVisibleLayersSortedByZ(const Vector< sp<Layer> >& layers);
const Vector< sp<Layer> >& getVisibleLayersSortedByZ() const;
void setLayersNeedingFences(const Vector< sp<Layer> >& layers);
const Vector< sp<Layer> >& getLayersNeedingFences() const;
Region getDirtyRegion(bool repaintEverything) const;
void setLayerStack(uint32_t stack);
void setDisplaySize(const int newWidth, const int newHeight);
void setProjection(int orientation, const Rect& viewport, const Rect& frame);
int getOrientation() const { return mOrientation; }
uint32_t getOrientationTransform() const;
static uint32_t getPrimaryDisplayOrientationTransform();
const Transform& getTransform() const { return mGlobalTransform; }
const Rect getViewport() const { return mViewport; }
const Rect getFrame() const { return mFrame; }
const Rect& getScissor() const { return mScissor; }
bool needsFiltering() const { return mNeedsFiltering; }
uint32_t getLayerStack() const { return mLayerStack; }
int32_t getDisplayType() const { return mType; }
bool isPrimary() const { return mType == DISPLAY_PRIMARY; }
int32_t getHwcDisplayId() const { return mHwcDisplayId; }
const wp<IBinder>& getDisplayToken() const { return mDisplayToken; }
int32_t getSupportedPerFrameMetadata() const { return mSupportedPerFrameMetadata; }
// We pass in mustRecompose so we can keep VirtualDisplaySurface's state
// machine happy without actually queueing a buffer if nothing has changed
status_t beginFrame(bool mustRecompose) const;
status_t prepareFrame(HWComposer& hwc);
bool hasWideColorGamut() const { return mHasWideColorGamut; }
// Whether h/w composer has native support for specific HDR type.
bool hasHDR10Support() const { return mHasHdr10; }
bool hasHLGSupport() const { return mHasHLG; }
bool hasDolbyVisionSupport() const { return mHasDolbyVision; }
// Return true if the HDR dataspace is supported but
// there is no corresponding color mode.
bool hasLegacyHdrSupport(ui::Dataspace dataspace) const;
// The returned HdrCapabilities is the combination of HDR capabilities from
// hardware composer and RenderEngine. When the DisplayDevice supports wide
// color gamut, RenderEngine is able to simulate HDR support in Display P3
// color space for both PQ and HLG HDR contents. The minimum and maximum
// luminance will be set to sDefaultMinLumiance and sDefaultMaxLumiance
// respectively if hardware composer doesn't return meaningful values.
const HdrCapabilities& getHdrCapabilities() const { return mHdrCapabilities; }
// Return true if intent is supported by the display.
bool hasRenderIntent(ui::RenderIntent intent) const;
void getBestColorMode(ui::Dataspace dataspace, ui::RenderIntent intent,
ui::Dataspace* outDataspace, ui::ColorMode* outMode,
ui::RenderIntent* outIntent) const;
void swapBuffers(HWComposer& hwc) const;
// called after h/w composer has completed its set() call
void onSwapBuffersCompleted() const;
Rect getBounds() const {
return Rect(mDisplayWidth, mDisplayHeight);
inline Rect bounds() const { return getBounds(); }
void setDisplayName(const String8& displayName);
const String8& getDisplayName() const { return mDisplayName; }
bool makeCurrent() const;
void setViewportAndProjection() const;
const sp<Fence>& getClientTargetAcquireFence() const;
/* ------------------------------------------------------------------------
* Display power mode management.
int getPowerMode() const;
void setPowerMode(int mode);
bool isDisplayOn() const;
ui::ColorMode getActiveColorMode() const;
void setActiveColorMode(ui::ColorMode mode);
ui::RenderIntent getActiveRenderIntent() const;
void setActiveRenderIntent(ui::RenderIntent renderIntent);
android_color_transform_t getColorTransform() const;
void setColorTransform(const mat4& transform);
void setCompositionDataSpace(ui::Dataspace dataspace);
ui::Dataspace getCompositionDataSpace() const;
/* ------------------------------------------------------------------------
* Display active config management.
int getActiveConfig() const;
void setActiveConfig(int mode);
// release HWC resources (if any) for removable displays
void disconnect(HWComposer& hwc);
/* ------------------------------------------------------------------------
* Debugging
uint32_t getPageFlipCount() const;
void dump(String8& result) const;
* Constants, set during initialization
sp<SurfaceFlinger> mFlinger;
DisplayType mType;
int32_t mHwcDisplayId;
wp<IBinder> mDisplayToken;
// ANativeWindow this display is rendering into
sp<ANativeWindow> mNativeWindow;
sp<DisplaySurface> mDisplaySurface;
std::unique_ptr<RE::Surface> mSurface;
int mDisplayWidth;
int mDisplayHeight;
mutable uint32_t mPageFlipCount;
String8 mDisplayName;
bool mIsSecure;
* Can only accessed from the main thread, these members
* don't need synchronization.
// list of visible layers on that display
Vector< sp<Layer> > mVisibleLayersSortedByZ;
// list of layers needing fences
Vector< sp<Layer> > mLayersNeedingFences;
* Transaction state
static status_t orientationToTransfrom(int orientation,
int w, int h, Transform* tr);
// The identifier of the active layer stack for this display. Several displays
// can use the same layer stack: A z-ordered group of layers (sometimes called
// "surfaces"). Any given layer can only be on a single layer stack.
uint32_t mLayerStack;
int mOrientation;
static uint32_t sPrimaryDisplayOrientation;
// user-provided visible area of the layer stack
Rect mViewport;
// user-provided rectangle where mViewport gets mapped to
Rect mFrame;
// pre-computed scissor to apply to the display
Rect mScissor;
Transform mGlobalTransform;
bool mNeedsFiltering;
// Current power mode
int mPowerMode;
// Current active config
int mActiveConfig;
// current active color mode
ui::ColorMode mActiveColorMode = ui::ColorMode::NATIVE;
// Current active render intent.
ui::RenderIntent mActiveRenderIntent = ui::RenderIntent::COLORIMETRIC;
ui::Dataspace mCompositionDataSpace = ui::Dataspace::UNKNOWN;
// Current color transform
android_color_transform_t mColorTransform;
// Need to know if display is wide-color capable or not.
// Initialized by SurfaceFlinger when the DisplayDevice is created.
// Fed to RenderEngine during composition.
bool mHasWideColorGamut;
bool mHasHdr10;
bool mHasHLG;
bool mHasDolbyVision;
HdrCapabilities mHdrCapabilities;
const int32_t mSupportedPerFrameMetadata;
// Mappings from desired Dataspace/RenderIntent to the supported
// Dataspace/ColorMode/RenderIntent.
using ColorModeKey = uint64_t;
struct ColorModeValue {
ui::Dataspace dataspace;
ui::ColorMode colorMode;
ui::RenderIntent renderIntent;
static ColorModeKey getColorModeKey(ui::Dataspace dataspace, ui::RenderIntent intent) {
return (static_cast<uint64_t>(dataspace) << 32) | static_cast<uint32_t>(intent);
void populateColorModes(
const std::unordered_map<ui::ColorMode, std::vector<ui::RenderIntent>>& hwcColorModes);
void addColorMode(
const std::unordered_map<ui::ColorMode, std::vector<ui::RenderIntent>>& hwcColorModes,
const ui::ColorMode mode, const ui::RenderIntent intent);
std::unordered_map<ColorModeKey, ColorModeValue> mColorModes;
struct DisplayDeviceState {
DisplayDeviceState() = default;
DisplayDeviceState(DisplayDevice::DisplayType type, bool isSecure);
bool isValid() const { return type >= 0; }
bool isMainDisplay() const { return type == DisplayDevice::DISPLAY_PRIMARY; }
bool isVirtualDisplay() const { return type >= DisplayDevice::DISPLAY_VIRTUAL; }
static std::atomic<int32_t> nextDisplayId;
int32_t displayId = nextDisplayId++;
DisplayDevice::DisplayType type = DisplayDevice::DISPLAY_ID_INVALID;
sp<IGraphicBufferProducer> surface;
uint32_t layerStack = DisplayDevice::NO_LAYER_STACK;
Rect viewport;
Rect frame;
uint8_t orientation = 0;
uint32_t width = 0;
uint32_t height = 0;
String8 displayName;
bool isSecure = false;
class DisplayRenderArea : public RenderArea {
DisplayRenderArea(const sp<const DisplayDevice> device,
ISurfaceComposer::Rotation rotation = ISurfaceComposer::eRotateNone)
: DisplayRenderArea(device, device->getBounds(), device->getHeight(), device->getWidth(),
rotation) {}
DisplayRenderArea(const sp<const DisplayDevice> device, Rect sourceCrop, uint32_t reqHeight,
uint32_t reqWidth, ISurfaceComposer::Rotation rotation)
: RenderArea(reqHeight, reqWidth, CaptureFill::OPAQUE, rotation), mDevice(device),
mSourceCrop(sourceCrop) {}
const Transform& getTransform() const override { return mDevice->getTransform(); }
Rect getBounds() const override { return mDevice->getBounds(); }
int getHeight() const override { return mDevice->getHeight(); }
int getWidth() const override { return mDevice->getWidth(); }
bool isSecure() const override { return mDevice->isSecure(); }
bool needsFiltering() const override { return mDevice->needsFiltering(); }
Rect getSourceCrop() const override { return mSourceCrop; }
const sp<const DisplayDevice> mDevice;
const Rect mSourceCrop;
}; // namespace android