1 /* 2 * Copyright (c) 2014-2021, The Linux Foundation. All rights reserved. 3 * 4 * Redistribution and use in source and binary forms, with or without modification, are permitted 5 * provided that the following conditions are met: 6 * * Redistributions of source code must retain the above copyright notice, this list of 7 * conditions and the following disclaimer. 8 * * Redistributions in binary form must reproduce the above copyright notice, this list of 9 * conditions and the following disclaimer in the documentation and/or other materials provided 10 * with the distribution. 11 * * Neither the name of The Linux Foundation nor the names of its contributors may be used to 12 * endorse or promote products derived from this software without specific prior written 13 * permission. 14 * 15 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 16 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 17 * NON-INFRINGEMENT ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 19 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 20 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 21 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 22 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 23 */ 24 25 /*! @file layer_stack.h 26 @brief File for display layer stack structure which represents a drawing buffer. 27 28 @details Display layer is a drawing buffer object which will be blended with other drawing buffers 29 under blending rules. 30 */ 31 #ifndef __LAYER_STACK_H__ 32 #define __LAYER_STACK_H__ 33 34 #include <stdint.h> 35 #include <utils/constants.h> 36 #include <utils/fence.h> 37 38 #include <vector> 39 #include <utility> 40 #include <unordered_map> 41 #include <memory> 42 #include <bitset> 43 44 #include "layer_buffer.h" 45 #include "sdm_types.h" 46 47 namespace sdm { 48 49 /*! @brief This enum represents display layer blending types. 50 51 @sa Layer 52 */ 53 enum LayerBlending { 54 kBlendingPremultiplied, //!< Pixel color is expressed using premultiplied alpha in RGBA tuples. 55 //!< If plane alpha is less than 0xFF, apply modulation as well. 56 //!< pixel.rgb = src.rgb + dest.rgb x (1 - src.a) 57 58 kBlendingOpaque, //!< Pixel color is expressed using straight alpha in color tuples. It 59 //!< is constant blend operation. The layer would appear opaque if plane 60 //!< alpha is 0xFF. 61 62 kBlendingCoverage, //!< Pixel color is expressed using straight alpha in color tuples. If 63 //!< plane alpha is less than 0xff, apply modulation as well. 64 //!< pixel.rgb = src.rgb x src.a + dest.rgb x (1 - src.a) 65 }; 66 67 /*! @brief This enum represents display layer composition types. 68 69 @sa Layer 70 */ 71 enum LayerComposition { 72 /* ==== List of composition types set by SDM === */ 73 /* These composition types represent SDM composition decision for the layers which need to 74 be blended. Composition types are set during Prepare() by SDM. 75 Client can set default composition type to any of the below before calling into Prepare(), 76 however client's input value is ignored and does not play any role in composition decision. 77 */ 78 kCompositionGPU, //!< This layer will be drawn onto the target buffer by GPU. Display 79 //!< device will mark the layer for GPU composition if it can not 80 //!< handle composition for it. 81 //!< This composition type is used only if GPUTarget layer is provided 82 //!< in a composition cycle. 83 84 kCompositionStitch, //!< This layer will be drawn onto the target buffer by GPU. No blend 85 //!< required. 86 87 kCompositionSDE, //!< This layer will be composed by SDE. It must not be composed by 88 //!< GPU or Blit. 89 90 kCompositionCursor, // This cursor layer can receive async position updates irrespective of 91 // dedicated h/w cursor usage. It must not be composed by GPU or Blit 92 93 kCompositionNone, //!< This layer will not be composed by any hardware. 94 95 /* === List of composition types set by Client === */ 96 /* These composition types represent target buffer layers onto which GPU or Blit will draw if SDM 97 decide to have some or all layers drawn by respective composition engine. 98 Client must provide a target buffer layer, if respective composition type is not disabled by 99 an explicit call to SetCompositionState() method. If a composition type is not disabled, 100 providing a target buffer layer is optional. If SDM is unable to handle layers without support 101 of such a composition engine, Prepare() call will return failure. 102 */ 103 kCompositionGPUTarget, //!< This layer will hold result of composition for layers marked for 104 //!< GPU composition. 105 //!< If display device does not set any layer for GPU composition then 106 //!< this layer would be ignored. Else, this layer will be composed 107 //!< with other layers marked for SDE composition by SDE. 108 //!< Only one layer shall be marked as target buffer by the caller. 109 //!< GPU target layer shall be placed after all application layers 110 //!< in the layer stack. 111 112 kCompositionStitchTarget, //!< This layer will hold result of composition for layers marked fo 113 //!< Blit composition. 114 }; 115 116 enum LayerUpdate { 117 kSecurity, 118 kMetadataUpdate, 119 kSurfaceDamage, 120 kSurfaceInvalidate, 121 kClientCompRequest, 122 kColorTransformUpdate, 123 kLayerUpdateMax, 124 }; 125 126 /*! @brief This structure defines rotation and flip values for a display layer. 127 128 @sa Layer 129 */ 130 struct LayerTransform { 131 float rotation = 0.0f; //!< Left most pixel coordinate. 132 bool flip_horizontal = false; //!< Mirror reversal of the layer across a horizontal axis. 133 bool flip_vertical = false; //!< Mirror reversal of the layer across a vertical axis. 134 135 bool operator==(const LayerTransform& transform) const { 136 return (rotation == transform.rotation && flip_horizontal == transform.flip_horizontal && 137 flip_vertical == transform.flip_vertical); 138 } 139 140 bool operator!=(const LayerTransform& transform) const { 141 return !operator==(transform); 142 } 143 }; 144 145 /*! @brief This structure defines flags associated with a layer. The 1-bit flag can be set to ON(1) 146 or OFF(0). 147 148 @sa LayerBuffer 149 */ 150 struct LayerFlags { 151 union { 152 struct { 153 uint32_t skip : 1; //!< This flag shall be set by client to indicate that this layer 154 //!< will be handled by GPU. Display Device will not consider it 155 //!< for composition. 156 157 uint32_t updating : 1; //!< This flag shall be set by client to indicate that this is 158 //!< updating non-updating. so strategy manager will mark them for 159 //!< SDE/GPU composition respectively when the layer stack qualifies 160 //!< for cache based composition. 161 162 uint32_t solid_fill : 1; 163 //!< This flag shall be set by client to indicate that this layer 164 //!< is for solid fill without input buffer. Display Device will 165 //!< use SDE HW feature to achieve it. 166 167 uint32_t cursor : 1; //!< This flag shall be set by client to indicate that this layer 168 //!< is a cursor 169 //!< Display Device may handle this layer using HWCursor 170 171 uint32_t single_buffer : 1; //!< This flag shall be set by client to indicate that the layer 172 //!< uses only a single buffer that will not be swapped out 173 174 uint32_t color_transform : 1; //!< This flag will be set by SDM when the layer 175 //!< has a custom matrix 176 177 uint32_t is_game : 1; //!< This flag shall be set by client to indicate that this layer 178 //!< is a game layer. 179 180 uint32_t sde_preferred : 1; //! This flag shall be set by client to indicate that this layer 181 //! will be composed by display device, layer with this flag 182 //! will have highest priority. To be used by OEMs only. 183 }; 184 185 uint32_t flags = 0; //!< For initialization purpose only. 186 //!< Client shall not refer it directly. 187 }; 188 }; 189 190 /*! @brief This structure defines flags associated with the layer requests. The 1-bit flag can be 191 set to ON(1) or OFF(0). 192 193 @sa Layer 194 */ 195 struct LayerRequestFlags { 196 union { 197 struct { 198 uint32_t tone_map : 1; //!< This flag will be set by SDM when the layer needs tone map 199 uint32_t secure: 1; //!< This flag will be set by SDM when the layer must be secure 200 uint32_t flip_buffer: 1; //!< This flag will be set by SDM when the layer needs FBT flip 201 uint32_t dest_tone_map : 1; //!< This flag will be set by SDM when the layer needs 202 //!< destination tone map 203 uint32_t src_tone_map: 1; //!< This flag will be set by SDM when the layer needs 204 //!< source tone map. 205 }; 206 uint32_t request_flags = 0; //!< For initialization purpose only. 207 //!< Shall not be refered directly. 208 }; 209 }; 210 211 /*! @brief This structure defines LayerRequest. 212 Includes width/height/format of the LayerRequest. 213 214 SDM shall set the properties of LayerRequest to be used by the client 215 216 @sa LayerRequest 217 */ 218 struct LayerRequest { 219 LayerRequestFlags flags; // Flags associated with this request 220 LayerBufferFormat format = kFormatRGBA8888; // Requested format 221 uint32_t width = 0; // Requested unaligned width. 222 uint32_t height = 0; // Requested unalighed height 223 }; 224 225 /*! @brief This structure defines flags associated with a layer stack. The 1-bit flag can be set to 226 ON(1) or OFF(0). 227 228 @sa LayerBuffer 229 */ 230 struct LayerStackFlags { 231 union { 232 struct { 233 uint32_t geometry_changed : 1; //!< This flag shall be set by client to indicate that the 234 //!< layer set passed to Prepare() has changed by more than 235 //!< just the buffer handles and acquire fences. 236 237 uint32_t skip_present : 1; //!< This flag will be set to true, if the current layer 238 //!< stack contains skip layers. 239 240 uint32_t video_present : 1; //!< This flag will be set to true, if current layer stack 241 //!< contains video. 242 243 uint32_t secure_present : 1; //!< This flag will be set to true, if the current layer 244 //!< stack contains secure layers. 245 246 uint32_t animating : 1; //!< This flag shall be set by client to indicate that the 247 //!< current frame is animating.i 248 249 uint32_t attributes_changed : 1; 250 //!< This flag shall be set by client to indicate that the 251 //!< current frame has some properties changed and 252 //!< needs re-config. 253 254 uint32_t cursor_present : 1; //!< This flag will be set to true if the current layer 255 //!< stack contains cursor layer. 256 257 uint32_t single_buffered_layer_present : 1; //!< Set if stack has single buffered layer 258 259 uint32_t s3d_mode_present : 1; //!< This flag will be set to true, if the current layer 260 //!< stack contains s3d layer, and the layer stack can enter 261 //!< s3d mode. 262 263 uint32_t post_processed_output : 1; // If output_buffer should contain post processed output 264 // This applies only to primary displays currently 265 266 uint32_t hdr_present : 1; //!< Set if stack has HDR content 267 268 uint32_t fast_path : 1; //!< Preference for fast/slow path draw-cycle, set by client. 269 270 uint32_t mask_present : 1; //!< Set if layer stack has mask layers. 271 272 uint32_t config_changed : 1; //!< This flag indicates Display config must be validated. 273 274 uint32_t scaling_rgb_layer_present : 1; //!< This flag indicates scaling rgb layer presense 275 }; 276 277 uint32_t flags = 0; //!< For initialization purpose only. 278 //!< Client shall not refer it directly. 279 }; 280 }; 281 282 /*! @brief This structure defines a rectanglular area inside a display layer. 283 284 @sa LayerRectArray 285 */ 286 struct LayerRect { 287 float left = 0.0f; //!< Left-most pixel coordinate. 288 float top = 0.0f; //!< Top-most pixel coordinate. 289 float right = 0.0f; //!< Right-most pixel coordinate. 290 float bottom = 0.0f; //!< Bottom-most pixel coordinate. 291 292 LayerRect() = default; 293 LayerRectLayerRect294 LayerRect(float l, float t, float r, float b) : left(l), top(t), right(r), bottom(b) { } 295 296 bool operator==(const LayerRect& rect) const { 297 return left == rect.left && right == rect.right && top == rect.top && bottom == rect.bottom; 298 } 299 300 bool operator!=(const LayerRect& rect) const { 301 return !operator==(rect); 302 } 303 }; 304 305 /*! @brief This structure defines an array of display layer rectangles. 306 307 @sa LayerRect 308 */ 309 struct LayerRectArray { 310 LayerRect *rect = NULL; //!< Pointer to first element of array. 311 uint32_t count = 0; //!< Number of elements in the array. 312 }; 313 314 struct LayerStitchInfo { 315 LayerRect dst_rect = {}; //!< The target position where the frame will be 316 //!< rendered onto internal FrameBuffer. 317 318 LayerRect slice_rect = {}; //!< Target slice that this stitch rect belongs to. 319 }; 320 321 /*! @brief This structure defines solidfill structure. 322 323 @sa LayerSolidFill 324 */ 325 struct LayerSolidFill { 326 uint32_t bit_depth = 0; //!< Bit depth of solid fill colors 327 uint32_t red = 0; //!< Red value 328 uint32_t green = 0; //!< Green value 329 uint32_t blue = 0; //!< Blue value 330 uint32_t alpha = 0; //!< Alpha value 331 }; 332 333 struct LayerBufferMap { 334 std::unordered_map<uint64_t, std::shared_ptr<LayerBufferObject>> buffer_map; 335 }; 336 337 /*! @brief This structure defines display layer object which contains layer properties and a drawing 338 buffer. 339 340 @sa LayerArray 341 */ 342 struct Layer { 343 LayerBuffer input_buffer = {}; //!< Buffer to be composed. 344 //!< If this remains unchanged between two 345 //!< consecutive Prepare() calls and 346 //!< geometry_changed flag is not set for the 347 //!< second call, then the display device will 348 //!< assume that buffer content has not 349 //!< changed. 350 351 LayerComposition composition = kCompositionGPU; //!< Composition type which can be set by either 352 //!< the client or the display device. This value 353 //!< should be preserved between Prepare() and 354 //!< Commit() calls. 355 356 LayerRect src_rect = {}; //!< Rectangular area of the layer buffer to 357 //!< consider for composition. 358 359 LayerRect dst_rect = {}; //!< The target position where the frame will be 360 //!< displayed. Cropping rectangle is scaled to 361 //!< fit into this rectangle. The origin is the 362 //!< top-left corner of the screen. 363 364 LayerStitchInfo stitch_info = {}; //!< This structure defines all parameters needed 365 //!< for stitching like position to render, 366 //!< boundaries etc; 367 368 std::vector<LayerRect> visible_regions = {}; //!< Visible rectangular areas in screen space. 369 //!< The visible region includes areas overlapped 370 //!< by a translucent layer. 371 372 std::vector<LayerRect> dirty_regions = {}; //!< Rectangular areas in the current frames 373 //!< that have changed in comparison to 374 //!< previous frame. 375 376 LayerBlending blending = kBlendingPremultiplied; //!< Blending operation which need to be 377 //!< applied on the layer buffer during 378 //!< composition. 379 380 LayerTransform transform = {}; //!< Rotation/Flip operations which need to be 381 //!< applied to the layer buffer during 382 //!< composition. 383 384 uint8_t plane_alpha = 0xff; //!< Alpha value applied to the whole layer. 385 //!< Value of each pixel is computed as: 386 //!< if(kBlendingPremultiplied) { 387 //!< pixel.RGB = pixel.RGB * planeAlpha/255 388 //!< } 389 //!< pixel.a = pixel.a * planeAlpha 390 391 uint32_t frame_rate = 0; //!< Rate at which frames are being updated for 392 //!< this layer. 393 394 uint32_t solid_fill_color = 0; //!< TODO: Remove this field when fb support 395 //! is deprecated. 396 //!< Solid color used to fill the layer when 397 //!< no content is associated with the layer. 398 399 LayerFlags flags; //!< Flags associated with this layer. 400 401 LayerRequest request = {}; //!< o/p - request on this Layer by SDM. 402 403 Lut3d lut_3d = {}; //!< o/p - Populated by SDM when tone mapping is 404 //!< needed on this layer. 405 LayerSolidFill solid_fill_info = {}; //!< solid fill info along with depth. 406 std::shared_ptr<LayerBufferMap> buffer_map = nullptr; //!< Map of handle_id and fb_id. 407 float color_transform_matrix[kColorTransformMatrixSize] = { 1.0, 0.0, 0.0, 0.0, 408 0.0, 1.0, 0.0, 0.0, 409 0.0, 0.0, 1.0, 0.0, 410 0.0, 0.0, 0.0, 1.0 }; 411 std::bitset<kLayerUpdateMax> update_mask = 0; 412 }; 413 414 /*! @brief This structure defines the color space + transfer of a given layer. 415 416 @sa PrimariesTransfer 417 */ 418 419 struct PrimariesTransfer { 420 ColorPrimaries primaries = ColorPrimaries_BT709_5; 421 GammaTransfer transfer = Transfer_sRGB; 422 423 bool operator==(const PrimariesTransfer& blend_cs) const { 424 return ((primaries == blend_cs.primaries) && (transfer == blend_cs.transfer)); 425 } 426 }; 427 428 429 /*! @brief This structure defines a layer stack that contains layers which need to be composed and 430 rendered onto the target. 431 432 @sa DisplayInterface::Prepare 433 @sa DisplayInterface::Commit 434 */ 435 436 struct LayerStack { 437 std::vector<Layer *> layers = {}; //!< Vector of layer pointers. 438 439 shared_ptr<Fence> retire_fence = nullptr; 440 //!< File descriptor referring to a sync fence object which 441 //!< will be signaled when this composited frame has been 442 //!< replaced on screen by a subsequent frame on a physical 443 //!< display. The fence object is created and returned during 444 //!< Commit(). Client shall close the returned file 445 //!< descriptor. 446 //!< NOTE: This field applies to a physical display only. 447 448 LayerBuffer *output_buffer = NULL; //!< Pointer to the buffer where composed buffer would be 449 //!< rendered for virtual displays. 450 //!< NOTE: This field applies to a virtual display only. 451 452 LayerStackFlags flags; //!< Flags associated with this layer set. 453 454 455 PrimariesTransfer blend_cs = {}; //!< o/p - Blending color space of the frame, updated by SDM 456 457 uint64_t elapse_timestamp = 0; //!< system time until which display commit needs to be held 458 }; 459 460 } // namespace sdm 461 462 #endif // __LAYER_STACK_H__ 463 464