/* * Copyright (C) 2008 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_SF_LAYER_STATE_H #define ANDROID_SF_LAYER_STATE_H #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace android { class Parcel; using gui::ISurfaceComposerClient; using gui::LayerMetadata; using gui::TrustedPresentationThresholds; struct client_cache_t { wp token = nullptr; uint64_t id; bool operator==(const client_cache_t& other) const { return id == other.id; } bool operator!=(const client_cache_t&) const = default; bool isValid() const { return token != nullptr; } }; class TrustedPresentationListener : public Parcelable { public: struct State { sp callbackInterface; int callbackId = -1; bool operator==(const State&) const = default; bool operator!=(const State&) const = default; }; void invoke(bool presentedWithinThresholds) { mState.callbackInterface->onTrustedPresentationChanged(mState.callbackId, presentedWithinThresholds); } void configure(State&& state) { mState = std::move(state); } const sp& getCallback() { return mState.callbackInterface; } void clear() { mState.callbackInterface = nullptr; mState.callbackId = -1; } status_t writeToParcel(Parcel* parcel) const; status_t readFromParcel(const Parcel* parcel); bool operator==(const TrustedPresentationListener& rhs) const { return mState == rhs.mState; } bool operator!=(const TrustedPresentationListener&) const = default; private: State mState; }; class BufferData : public Parcelable { public: virtual ~BufferData() = default; virtual bool hasBuffer() const { return buffer != nullptr; } virtual bool hasSameBuffer(const BufferData& other) const { return buffer == other.buffer && frameNumber == other.frameNumber; } virtual uint32_t getWidth() const { return buffer->getWidth(); } virtual uint32_t getHeight() const { return buffer->getHeight(); } Rect getBounds() const { return {0, 0, static_cast(getWidth()), static_cast(getHeight())}; } virtual uint64_t getId() const { return buffer->getId(); } virtual PixelFormat getPixelFormat() const { return buffer->getPixelFormat(); } virtual uint64_t getUsage() const { return buffer->getUsage(); } enum class BufferDataChange : uint32_t { fenceChanged = 0x01, frameNumberChanged = 0x02, cachedBufferChanged = 0x04, }; sp buffer; sp acquireFence; // Used by BlastBufferQueue to forward the framenumber generated by the // graphics producer. uint64_t frameNumber = 0; bool hasBarrier = false; uint64_t barrierFrameNumber = 0; uint32_t producerId = 0; // Listens to when the buffer is safe to be released. This is used for blast // layers only. The callback includes a release fence as well as the graphic // buffer id to identify the buffer. sp releaseBufferListener = nullptr; // Stores which endpoint the release information should be sent to. We don't want to send the // releaseCallbackId and release fence to all listeners so we store which listener the setBuffer // was called with. sp releaseBufferEndpoint; ftl::Flags flags; client_cache_t cachedBuffer; nsecs_t dequeueTime; // Generates the release callback id based on the buffer id and frame number. // This is used as an identifier when release callbacks are invoked. ReleaseCallbackId generateReleaseCallbackId() const; status_t writeToParcel(Parcel* parcel) const override; status_t readFromParcel(const Parcel* parcel) override; }; /* * Used to communicate layer information between SurfaceFlinger and its clients. */ struct layer_state_t { enum Permission { ACCESS_SURFACE_FLINGER = 0x1, ROTATE_SURFACE_FLINGER = 0x2, INTERNAL_SYSTEM_WINDOW = 0x4, }; enum { eLayerHidden = 0x01, // SURFACE_HIDDEN in SurfaceControl.java eLayerOpaque = 0x02, // SURFACE_OPAQUE eLayerSkipScreenshot = 0x40, // SKIP_SCREENSHOT eLayerSecure = 0x80, // SECURE // Queue up layer buffers instead of dropping the oldest buffer when this flag is // set. This blocks the client until all the buffers have been presented. If the buffers // have presentation timestamps, then we may drop buffers. eEnableBackpressure = 0x100, // ENABLE_BACKPRESSURE eLayerIsDisplayDecoration = 0x200, // DISPLAY_DECORATION // Ignore any destination frame set on the layer. This is used when the buffer scaling mode // is freeze and the destination frame is applied asynchronously with the buffer submission. // This is needed to maintain compatibility for SurfaceView scaling behavior. // See SurfaceView scaling behavior for more details. eIgnoreDestinationFrame = 0x400, eLayerIsRefreshRateIndicator = 0x800, // REFRESH_RATE_INDICATOR // Sets a property on this layer indicating that its visible region should be considered // when computing TrustedPresentation Thresholds. eCanOccludePresentation = 0x1000, // Indicates that the SurfaceControl should recover from buffer stuffing when // possible. This is the case when the SurfaceControl is the root SurfaceControl // owned by ViewRootImpl. eRecoverableFromBufferStuffing = 0x2000, }; enum { ePositionChanged = 0x00000001, eLayerChanged = 0x00000002, eTrustedPresentationInfoChanged = 0x00000004, eAlphaChanged = 0x00000008, eMatrixChanged = 0x00000010, eTransparentRegionChanged = 0x00000020, eFlagsChanged = 0x00000040, eLayerStackChanged = 0x00000080, eFlushJankData = 0x00000100, eCachingHintChanged = 0x00000200, eDimmingEnabledChanged = 0x00000400, eShadowRadiusChanged = 0x00000800, eLutsChanged = 0x00001000, eBufferCropChanged = 0x00002000, eRelativeLayerChanged = 0x00004000, eReparent = 0x00008000, eColorChanged = 0x00010000, eFrameRateCategoryChanged = 0x00020000, eBufferTransformChanged = 0x00040000, eTransformToDisplayInverseChanged = 0x00080000, eCropChanged = 0x00100000, eBufferChanged = 0x00200000, eDefaultFrameRateCompatibilityChanged = 0x00400000, eDataspaceChanged = 0x00800000, eHdrMetadataChanged = 0x01000000, eSurfaceDamageRegionChanged = 0x02000000, eApiChanged = 0x04000000, eSidebandStreamChanged = 0x08000000, eColorTransformChanged = 0x10000000, eHasListenerCallbacksChanged = 0x20000000, eInputInfoChanged = 0x40000000, eCornerRadiusChanged = 0x80000000, eDestinationFrameChanged = 0x1'00000000, eFrameRateSelectionStrategyChanged = 0x2'00000000, eBackgroundColorChanged = 0x4'00000000, eMetadataChanged = 0x8'00000000, eColorSpaceAgnosticChanged = 0x10'00000000, eFrameRateSelectionPriority = 0x20'00000000, eFrameRateChanged = 0x40'00000000, eBackgroundBlurRadiusChanged = 0x80'00000000, eProducerDisconnect = 0x100'00000000, eFixedTransformHintChanged = 0x200'00000000, eDesiredHdrHeadroomChanged = 0x400'00000000, eBlurRegionsChanged = 0x800'00000000, eAutoRefreshChanged = 0x1000'00000000, eStretchChanged = 0x2000'00000000, eTrustedOverlayChanged = 0x4000'00000000, eDropInputModeChanged = 0x8000'00000000, eExtendedRangeBrightnessChanged = 0x10000'00000000, eEdgeExtensionChanged = 0x20000'00000000, eBufferReleaseChannelChanged = 0x40000'00000000, ePictureProfileHandleChanged = 0x80000'00000000, eAppContentPriorityChanged = 0x100000'00000000, eClientDrawnCornerRadiusChanged = 0x200000'00000000, eBorderSettingsChanged = 0x400000'00000000, eBoxShadowSettingsChanged = 0x800000'00000000, eStopLayerChanged = 0x1000000'00000000, eBackgroundBlurScaleChanged = 0x2000000'00000000, eSystemContentPriorityChanged = 0x4000000'00000000, }; layer_state_t(); void merge(const layer_state_t& other); status_t write(Parcel& output) const; status_t read(const Parcel& input); // Compares two layer_state_t structs and returns a set of change flags describing all the // states that are different. uint64_t diff(const layer_state_t& other) const; bool hasBufferChanges() const; // Layer hierarchy updates. static constexpr uint64_t HIERARCHY_CHANGES = layer_state_t::eLayerChanged | layer_state_t::eRelativeLayerChanged | layer_state_t::eReparent | layer_state_t::eLayerStackChanged; // Geometry updates. static constexpr uint64_t GEOMETRY_CHANGES = layer_state_t::eBufferCropChanged | layer_state_t::eBufferTransformChanged | layer_state_t::eCornerRadiusChanged | layer_state_t::eClientDrawnCornerRadiusChanged | layer_state_t::eCropChanged | layer_state_t::eDestinationFrameChanged | layer_state_t::eMatrixChanged | layer_state_t::ePositionChanged | layer_state_t::eTransformToDisplayInverseChanged | layer_state_t::eTransparentRegionChanged | layer_state_t::eEdgeExtensionChanged; // Buffer and related updates. static constexpr uint64_t BUFFER_CHANGES = layer_state_t::eApiChanged | layer_state_t::eBufferChanged | layer_state_t::eBufferCropChanged | layer_state_t::eBufferTransformChanged | layer_state_t::eDataspaceChanged | layer_state_t::eSidebandStreamChanged | layer_state_t::eSurfaceDamageRegionChanged | layer_state_t::eTransformToDisplayInverseChanged | layer_state_t::eTransparentRegionChanged | layer_state_t::eExtendedRangeBrightnessChanged | layer_state_t::eDesiredHdrHeadroomChanged | layer_state_t::eLutsChanged; // Content updates. static constexpr uint64_t CONTENT_CHANGES = layer_state_t::BUFFER_CHANGES | layer_state_t::eAlphaChanged | layer_state_t::eAutoRefreshChanged | layer_state_t::eBackgroundBlurRadiusChanged | layer_state_t::eBackgroundBlurScaleChanged | layer_state_t::eBackgroundColorChanged | layer_state_t::eBlurRegionsChanged | layer_state_t::eColorChanged | layer_state_t::eColorSpaceAgnosticChanged | layer_state_t::eColorTransformChanged | layer_state_t::eCornerRadiusChanged | layer_state_t::eDimmingEnabledChanged | layer_state_t::eHdrMetadataChanged | layer_state_t::eShadowRadiusChanged | layer_state_t::eStretchChanged | layer_state_t::ePictureProfileHandleChanged | layer_state_t::eAppContentPriorityChanged | layer_state_t::eBorderSettingsChanged | layer_state_t::eBoxShadowSettingsChanged; // Changes which invalidates the layer's visible region in CE. static constexpr uint64_t CONTENT_DIRTY = layer_state_t::CONTENT_CHANGES | layer_state_t::GEOMETRY_CHANGES | layer_state_t::HIERARCHY_CHANGES; // Changes affecting child states. static constexpr uint64_t AFFECTS_CHILDREN = layer_state_t::GEOMETRY_CHANGES | layer_state_t::HIERARCHY_CHANGES | layer_state_t::eAlphaChanged | layer_state_t::eBackgroundBlurRadiusChanged | layer_state_t::eBackgroundBlurScaleChanged | layer_state_t::eBlurRegionsChanged | layer_state_t::eColorTransformChanged | layer_state_t::eCornerRadiusChanged | layer_state_t::eFlagsChanged | layer_state_t::eTrustedOverlayChanged | layer_state_t::eFrameRateChanged | layer_state_t::eFrameRateCategoryChanged | layer_state_t::eFrameRateSelectionStrategyChanged | layer_state_t::eFrameRateSelectionPriority | layer_state_t::eFixedTransformHintChanged | layer_state_t::eSystemContentPriorityChanged; // Changes affecting data sent to input. static constexpr uint64_t INPUT_CHANGES = layer_state_t::eAlphaChanged | layer_state_t::eInputInfoChanged | layer_state_t::eDropInputModeChanged | layer_state_t::eTrustedOverlayChanged | layer_state_t::eLayerStackChanged; // Changes that affect the visible region on a display. static constexpr uint64_t VISIBLE_REGION_CHANGES = layer_state_t::GEOMETRY_CHANGES | layer_state_t::HIERARCHY_CHANGES | layer_state_t::eAlphaChanged; // Changes that force GPU composition. static constexpr uint64_t COMPOSITION_EFFECTS = layer_state_t::eBackgroundBlurRadiusChanged | layer_state_t::eBackgroundBlurScaleChanged | layer_state_t::eBlurRegionsChanged | layer_state_t::eCornerRadiusChanged | layer_state_t::eShadowRadiusChanged | layer_state_t::eStretchChanged | layer_state_t::eBorderSettingsChanged | layer_state_t::eBoxShadowSettingsChanged; // Changes that affect the frame rate static constexpr uint64_t FRAME_RATE_CHANGES = layer_state_t::eFrameRateCategoryChanged | layer_state_t::eFrameRateSelectionStrategyChanged | layer_state_t::eFrameRateSelectionPriority | layer_state_t::eFrameRateChanged; bool hasValidBuffer() const; void sanitize(int32_t permissions); void updateTransparentRegion(const Region& transparentRegion); const Region& getTransparentRegion() const { return mNotDefCmpState.transparentRegion; } void updateSurfaceDamageRegion(const Region& surfaceDamageRegion); const Region& getSurfaceDamageRegion() const { return mNotDefCmpState.surfaceDamageRegion; } // Do not update state flags. Used to set up test state. void setSurfaceDamageRegion(Region&& surfaceDamageRegion) { mNotDefCmpState.surfaceDamageRegion = std::move(surfaceDamageRegion); } void updateRelativeLayer(const sp& relativeTo, int32_t z); void updateParentLayer(const sp& newParent); void updateInputWindowInfo(const gui::WindowInfo& info); const gui::WindowInfo& getWindowInfo() const { return mNotDefCmpState.windowInfo; } gui::WindowInfo* editWindowInfo() { return &mNotDefCmpState.windowInfo; } const sp& getParentSurfaceControlForChild() const { return mNotDefCmpState.parentSurfaceControlForChild; } const sp& getRelativeLayerSurfaceControl() const { return mNotDefCmpState.relativeLayerSurfaceControl; } bool operator==(const layer_state_t&) const = default; bool operator!=(const layer_state_t&) const = default; struct matrix22_t { float dsdx{0}; float dtdx{0}; float dtdy{0}; float dsdy{0}; status_t write(Parcel& output) const; status_t read(const Parcel& input); inline bool operator==(const matrix22_t& other) const { return std::tie(dsdx, dtdx, dtdy, dsdy) == std::tie(other.dsdx, other.dtdx, other.dtdy, other.dsdy); } inline bool operator!=(const matrix22_t& other) const { return !(*this == other); } }; sp surface; int32_t layerId; uint64_t what; float x; float y; int32_t z; ui::LayerStack layerStack = ui::DEFAULT_LAYER_STACK; uint32_t flags; uint32_t mask; uint8_t reserved; matrix22_t matrix; gui::CornerRadii cornerRadii; gui::CornerRadii clientDrawnCornerRadii; FloatRect clientDrawnCornerRadiusCrop; uint32_t backgroundBlurRadius; float backgroundBlurScale; half4 color; // non POD must be last. see write/read uint32_t bufferTransform; bool transformToDisplayInverse; FloatRect crop; std::shared_ptr bufferData = nullptr; ui::Dataspace dataspace; HdrMetadata hdrMetadata; int32_t api; sp sidebandStream; mat4 colorTransform; std::vector blurRegions; LayerMetadata metadata; // The following refer to the alpha, and dataspace, respectively of // the background color layer half4 bgColor; ui::Dataspace bgColorDataspace; // A color space agnostic layer means the color of this layer can be // interpreted in any color space. bool colorSpaceAgnostic; std::vector listeners; // Draws a shadow around the surface. float shadowRadius; // Draws an outline around the layer. gui::BorderSettings borderSettings; // Draws a sequence of box shadows under the layer. gui::BoxShadowSettings boxShadowSettings; // Priority of the layer assigned by Window Manager. int32_t frameRateSelectionPriority; // Layer frame rate and compatibility. See ANativeWindow_setFrameRate(). float frameRate; int8_t frameRateCompatibility; int8_t changeFrameRateStrategy; // Default frame rate compatibility used to set the layer refresh rate votetype. int8_t defaultFrameRateCompatibility; // Frame rate category to suggest what frame rate range a surface should run. int8_t frameRateCategory; bool frameRateCategorySmoothSwitchOnly; // Strategy of the layer for frame rate selection. int8_t frameRateSelectionStrategy; // Set by window manager indicating the layer and all its children are // in a different orientation than the display. The hint suggests that // the graphic producers should receive a transform hint as if the // display was in this orientation. When the display changes to match // the layer orientation, the graphic producer may not need to allocate // a buffer of a different size. -1 means the transform hint is not set, // otherwise the value will be a valid ui::Rotation. ui::Transform::RotationFlags fixedTransformHint; // Indicates that the consumer should acquire the next frame as soon as it // can and not wait for a frame to become available. This is only relevant // in shared buffer mode. bool autoRefresh; // An inherited state that indicates that this surface control and its children // should be trusted for input occlusion detection purposes gui::TrustedOverlay trustedOverlay; // Stretch effect to be applied to this layer StretchEffect stretchEffect; // Edge extension effect to be applied to this layer gui::EdgeExtensionParameters edgeExtensionParameters; Rect bufferCrop; Rect destinationFrame; // Force inputflinger to drop all input events for the layer and its children. gui::DropInputMode dropInputMode; bool dimmingEnabled; float currentHdrSdrRatio = 1.f; float desiredHdrSdrRatio = 1.f; // Enhance the quality of the buffer contents by configurating a picture processing pipeline // with values as specified by this picture profile. PictureProfileHandle pictureProfileHandle{PictureProfileHandle::NONE}; // A value indicating the significance of the layer's content to the app's desired user // experience. A higher value will result in more likelihood of getting access to limited // resources, such as picture processing hardware. int32_t appContentPriority = 0; // A value indicating the importance of the layer's content from the perspective of system // server. int32_t systemContentPriority = gui::ISystemContentPriorityConstants::Unset; gui::CachingHint cachingHint = gui::CachingHint::Enabled; TrustedPresentationThresholds trustedPresentationThresholds; TrustedPresentationListener trustedPresentationListener; std::shared_ptr bufferReleaseChannel; std::shared_ptr luts; protected: struct NotDefaultComparableState { Region transparentRegion; Region surfaceDamageRegion; gui::WindowInfo windowInfo; sp relativeLayerSurfaceControl; sp parentSurfaceControlForChild; bool operator==(const NotDefaultComparableState& rhs) const; bool operator!=(const NotDefaultComparableState& rhs) const = default; } mNotDefCmpState; }; class ComposerState { public: layer_state_t state; status_t write(Parcel& output) const; status_t read(const Parcel& input); bool operator==(const ComposerState&) const = default; bool operator!=(const ComposerState&) const = default; }; struct DisplayState { enum : uint32_t { eSurfaceChanged = 0x01, eLayerStackChanged = 0x02, eDisplayProjectionChanged = 0x04, eDisplaySizeChanged = 0x08, eFlagsChanged = 0x10, eAllChanged = ~0u }; // Not for direct use. Prefer constructor below for new displays. DisplayState(); DisplayState(sp token, ui::LayerStack layerStack) : what(eAllChanged), token(std::move(token)), layerStack(layerStack), layerStackSpaceRect(Rect::INVALID_RECT), orientedDisplaySpaceRect(Rect::INVALID_RECT) {} void merge(const DisplayState& other); void sanitize(int32_t permissions); uint32_t what = 0; uint32_t flags = 0; sp token; ui::LayerStack layerStack = ui::DEFAULT_LAYER_STACK; // These states define how layers are projected onto the physical or virtual display. // // Layers are first clipped to `layerStackSpaceRect'. They are then translated and // scaled from `layerStackSpaceRect' to `orientedDisplaySpaceRect'. Finally, they are rotated // according to `orientation', `width', and `height'. // // For example, assume layerStackSpaceRect is Rect(0, 0, 200, 100), orientedDisplaySpaceRect is // Rect(20, 10, 420, 210), and the size of the display is WxH. When orientation is 0, layers // will be scaled by a factor of 2 and translated by (20, 10). When orientation is 1, layers // will be additionally rotated by 90 degrees around the origin clockwise and translated by (W, // 0). // // Rect::INVALID_RECT sizes the space to the active resolution of the physical display, or the // default dimensions of the virtual display surface. // ui::Rotation orientation = ui::ROTATION_0; Rect layerStackSpaceRect = Rect::EMPTY_RECT; Rect orientedDisplaySpaceRect = Rect::EMPTY_RECT; // For physical displays, this is the resolution, which must match the active display mode. To // change the resolution, the client must first call SurfaceControl.setDesiredDisplayModeSpecs // with the new DesiredDisplayModeSpecs#defaultMode, then commit the matching width and height. // // For virtual displays, this is an optional resolution that overrides its default dimensions. // uint32_t width = 0; uint32_t height = 0; // For virtual displays, this is the sink surface into which the virtual display is rendered. sp surface; status_t write(Parcel& output) const; status_t read(const Parcel& input); bool operator==(const DisplayState&) const = default; bool operator!=(const DisplayState&) const = default; }; struct InputWindowCommands { using Listener = gui::IWindowInfosReportedListener; using ListenerSet = std::unordered_set, SpHash>; // Merges the passed in commands and returns true if there were any changes. bool merge(const InputWindowCommands& other); bool empty() const; void clear(); void addFocusRequest(const gui::FocusRequest& request) { focusRequests.push_back(request); } void addWindowInfosReportedListener(const sp& listener) { windowInfosReportedListeners.insert(listener); } ListenerSet&& releaseListeners() { return std::move(windowInfosReportedListeners); } status_t write(Parcel& output) const; status_t read(const Parcel& input); std::span getFocusRequests() const { return focusRequests; } const ListenerSet& getListeners() const { return windowInfosReportedListeners; } bool operator==(const InputWindowCommands&) const = default; bool operator!=(const InputWindowCommands&) const = default; private: std::vector focusRequests; ListenerSet windowInfosReportedListeners; }; static inline int compare_type(const ComposerState& lhs, const ComposerState& rhs) { if (lhs.state.surface < rhs.state.surface) return -1; if (lhs.state.surface > rhs.state.surface) return 1; return 0; } static inline int compare_type(const DisplayState& lhs, const DisplayState& rhs) { return compare_type(lhs.token, rhs.token); } static inline bool isFrameBarrierNewer(uint32_t producerIdA, uint64_t frameNumberA, uint32_t producerIdB, uint64_t frameNumberB) { return producerIdA > producerIdB || (producerIdA == producerIdB && frameNumberA > frameNumberB); } }; // namespace android #endif // ANDROID_SF_LAYER_STATE_H