| /* |
| * 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 <stdint.h> |
| #include <sys/types.h> |
| |
| #include <utils/Errors.h> |
| |
| #include <gui/IGraphicBufferProducer.h> |
| #include <math/mat4.h> |
| |
| #ifndef NO_INPUT |
| #include <input/InputWindow.h> |
| #endif |
| |
| #include <gui/LayerMetadata.h> |
| #include <math/vec3.h> |
| #include <ui/GraphicTypes.h> |
| #include <ui/Rect.h> |
| #include <ui/Region.h> |
| |
| namespace android { |
| |
| class Parcel; |
| class ISurfaceComposerClient; |
| |
| struct client_cache_t { |
| wp<IBinder> token = nullptr; |
| uint64_t id; |
| |
| bool operator==(const client_cache_t& other) const { return id == other.id; } |
| |
| bool isValid() const { return token != nullptr; } |
| }; |
| |
| /* |
| * Used to communicate layer information between SurfaceFlinger and its clients. |
| */ |
| struct layer_state_t { |
| enum { |
| eLayerHidden = 0x01, // SURFACE_HIDDEN in SurfaceControl.java |
| eLayerOpaque = 0x02, // SURFACE_OPAQUE |
| eLayerSecure = 0x80, // SECURE |
| }; |
| |
| enum { |
| ePositionChanged = 0x00000001, |
| eLayerChanged = 0x00000002, |
| eSizeChanged = 0x00000004, |
| eAlphaChanged = 0x00000008, |
| eMatrixChanged = 0x00000010, |
| eTransparentRegionChanged = 0x00000020, |
| eFlagsChanged = 0x00000040, |
| eLayerStackChanged = 0x00000080, |
| eCropChanged_legacy = 0x00000100, |
| eDeferTransaction_legacy = 0x00000200, |
| eOverrideScalingModeChanged = 0x00000400, |
| eGeometryAppliesWithResize = 0x00000800, |
| eReparentChildren = 0x00001000, |
| eDetachChildren = 0x00002000, |
| eRelativeLayerChanged = 0x00004000, |
| eReparent = 0x00008000, |
| eColorChanged = 0x00010000, |
| eDestroySurface = 0x00020000, |
| eTransformChanged = 0x00040000, |
| eTransformToDisplayInverseChanged = 0x00080000, |
| eCropChanged = 0x00100000, |
| eBufferChanged = 0x00200000, |
| eAcquireFenceChanged = 0x00400000, |
| eDataspaceChanged = 0x00800000, |
| eHdrMetadataChanged = 0x01000000, |
| eSurfaceDamageRegionChanged = 0x02000000, |
| eApiChanged = 0x04000000, |
| eSidebandStreamChanged = 0x08000000, |
| eColorTransformChanged = 0x10000000, |
| eHasListenerCallbacksChanged = 0x20000000, |
| eInputInfoChanged = 0x40000000, |
| eCornerRadiusChanged = 0x80000000, |
| eFrameChanged = 0x1'00000000, |
| eCachedBufferChanged = 0x2'00000000, |
| eBackgroundColorChanged = 0x4'00000000, |
| eMetadataChanged = 0x8'00000000, |
| eColorSpaceAgnosticChanged = 0x10'00000000, |
| }; |
| |
| layer_state_t() |
| : what(0), |
| x(0), |
| y(0), |
| z(0), |
| w(0), |
| h(0), |
| layerStack(0), |
| alpha(0), |
| flags(0), |
| mask(0), |
| reserved(0), |
| crop_legacy(Rect::INVALID_RECT), |
| cornerRadius(0.0f), |
| frameNumber_legacy(0), |
| overrideScalingMode(-1), |
| transform(0), |
| transformToDisplayInverse(false), |
| crop(Rect::INVALID_RECT), |
| frame(Rect::INVALID_RECT), |
| dataspace(ui::Dataspace::UNKNOWN), |
| surfaceDamageRegion(), |
| api(-1), |
| colorTransform(mat4()), |
| hasListenerCallbacks(false), |
| bgColorAlpha(0), |
| bgColorDataspace(ui::Dataspace::UNKNOWN), |
| colorSpaceAgnostic(false) { |
| matrix.dsdx = matrix.dtdy = 1.0f; |
| matrix.dsdy = matrix.dtdx = 0.0f; |
| hdrMetadata.validTypes = 0; |
| } |
| |
| void merge(const layer_state_t& other); |
| status_t write(Parcel& output) const; |
| status_t read(const Parcel& input); |
| |
| struct matrix22_t { |
| float dsdx{0}; |
| float dtdx{0}; |
| float dtdy{0}; |
| float dsdy{0}; |
| }; |
| sp<IBinder> surface; |
| uint64_t what; |
| float x; |
| float y; |
| int32_t z; |
| uint32_t w; |
| uint32_t h; |
| uint32_t layerStack; |
| float alpha; |
| uint8_t flags; |
| uint8_t mask; |
| uint8_t reserved; |
| matrix22_t matrix; |
| Rect crop_legacy; |
| float cornerRadius; |
| sp<IBinder> barrierHandle_legacy; |
| sp<IBinder> reparentHandle; |
| uint64_t frameNumber_legacy; |
| int32_t overrideScalingMode; |
| |
| sp<IGraphicBufferProducer> barrierGbp_legacy; |
| |
| sp<IBinder> relativeLayerHandle; |
| |
| sp<IBinder> parentHandleForChild; |
| |
| half3 color; |
| |
| // non POD must be last. see write/read |
| Region transparentRegion; |
| |
| uint32_t transform; |
| bool transformToDisplayInverse; |
| Rect crop; |
| Rect frame; |
| sp<GraphicBuffer> buffer; |
| sp<Fence> acquireFence; |
| ui::Dataspace dataspace; |
| HdrMetadata hdrMetadata; |
| Region surfaceDamageRegion; |
| int32_t api; |
| sp<NativeHandle> sidebandStream; |
| mat4 colorTransform; |
| |
| bool hasListenerCallbacks; |
| #ifndef NO_INPUT |
| InputWindowInfo inputInfo; |
| #endif |
| |
| client_cache_t cachedBuffer; |
| |
| LayerMetadata metadata; |
| |
| // The following refer to the alpha, and dataspace, respectively of |
| // the background color layer |
| float bgColorAlpha; |
| ui::Dataspace bgColorDataspace; |
| |
| // A color space agnostic layer means the color of this layer can be |
| // interpreted in any color space. |
| bool colorSpaceAgnostic; |
| }; |
| |
| struct ComposerState { |
| sp<ISurfaceComposerClient> client; |
| layer_state_t state; |
| status_t write(Parcel& output) const; |
| status_t read(const Parcel& input); |
| }; |
| |
| struct DisplayState { |
| enum { |
| eOrientationDefault = 0, |
| eOrientation90 = 1, |
| eOrientation180 = 2, |
| eOrientation270 = 3, |
| eOrientationUnchanged = 4, |
| eOrientationSwapMask = 0x01 |
| }; |
| |
| enum { |
| eSurfaceChanged = 0x01, |
| eLayerStackChanged = 0x02, |
| eDisplayProjectionChanged = 0x04, |
| eDisplaySizeChanged = 0x08 |
| }; |
| |
| DisplayState(); |
| void merge(const DisplayState& other); |
| |
| uint32_t what; |
| sp<IBinder> token; |
| sp<IGraphicBufferProducer> surface; |
| uint32_t layerStack; |
| |
| // These states define how layers are projected onto the physical display. |
| // |
| // Layers are first clipped to `viewport'. They are then translated and |
| // scaled from `viewport' to `frame'. Finally, they are rotated according |
| // to `orientation', `width', and `height'. |
| // |
| // For example, assume viewport is Rect(0, 0, 200, 100), frame 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). |
| uint32_t orientation; |
| Rect viewport; |
| Rect frame; |
| |
| uint32_t width, height; |
| |
| status_t write(Parcel& output) const; |
| status_t read(const Parcel& input); |
| }; |
| |
| struct InputWindowCommands { |
| struct TransferTouchFocusCommand { |
| sp<IBinder> fromToken; |
| sp<IBinder> toToken; |
| }; |
| |
| std::vector<TransferTouchFocusCommand> transferTouchFocusCommands; |
| bool syncInputWindows{false}; |
| |
| void merge(const InputWindowCommands& other); |
| void clear(); |
| void write(Parcel& output) const; |
| void read(const Parcel& input); |
| }; |
| |
| static inline int compare_type(const ComposerState& lhs, const ComposerState& rhs) { |
| if (lhs.client < rhs.client) return -1; |
| if (lhs.client > rhs.client) return 1; |
| 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); |
| } |
| |
| }; // namespace android |
| |
| #endif // ANDROID_SF_LAYER_STATE_H |