1 /* 2 * Copyright (c) 2014-2020, 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 181 uint32_t flags = 0; //!< For initialization purpose only. 182 //!< Client shall not refer it directly. 183 }; 184 }; 185 186 /*! @brief This structure defines flags associated with the layer requests. The 1-bit flag can be 187 set to ON(1) or OFF(0). 188 189 @sa Layer 190 */ 191 struct LayerRequestFlags { 192 union { 193 struct { 194 uint32_t tone_map : 1; //!< This flag will be set by SDM when the layer needs tone map 195 uint32_t secure: 1; //!< This flag will be set by SDM when the layer must be secure 196 uint32_t flip_buffer: 1; //!< This flag will be set by SDM when the layer needs FBT flip 197 uint32_t dest_tone_map : 1; //!< This flag will be set by SDM when the layer needs 198 //!< destination tone map 199 uint32_t src_tone_map: 1; //!< This flag will be set by SDM when the layer needs 200 //!< source tone map. 201 }; 202 uint32_t request_flags = 0; //!< For initialization purpose only. 203 //!< Shall not be refered directly. 204 }; 205 }; 206 207 /*! @brief This structure defines LayerRequest. 208 Includes width/height/format of the LayerRequest. 209 210 SDM shall set the properties of LayerRequest to be used by the client 211 212 @sa LayerRequest 213 */ 214 struct LayerRequest { 215 LayerRequestFlags flags; // Flags associated with this request 216 LayerBufferFormat format = kFormatRGBA8888; // Requested format 217 uint32_t width = 0; // Requested unaligned width. 218 uint32_t height = 0; // Requested unalighed height 219 }; 220 221 /*! @brief This structure defines flags associated with a layer stack. The 1-bit flag can be set to 222 ON(1) or OFF(0). 223 224 @sa LayerBuffer 225 */ 226 struct LayerStackFlags { 227 union { 228 struct { 229 uint32_t geometry_changed : 1; //!< This flag shall be set by client to indicate that the 230 //!< layer set passed to Prepare() has changed by more than 231 //!< just the buffer handles and acquire fences. 232 233 uint32_t skip_present : 1; //!< This flag will be set to true, if the current layer 234 //!< stack contains skip layers. 235 236 uint32_t video_present : 1; //!< This flag will be set to true, if current layer stack 237 //!< contains video. 238 239 uint32_t secure_present : 1; //!< This flag will be set to true, if the current layer 240 //!< stack contains secure layers. 241 242 uint32_t animating : 1; //!< This flag shall be set by client to indicate that the 243 //!< current frame is animating.i 244 245 uint32_t attributes_changed : 1; 246 //!< This flag shall be set by client to indicate that the 247 //!< current frame has some properties changed and 248 //!< needs re-config. 249 250 uint32_t cursor_present : 1; //!< This flag will be set to true if the current layer 251 //!< stack contains cursor layer. 252 253 uint32_t single_buffered_layer_present : 1; //!< Set if stack has single buffered layer 254 255 uint32_t s3d_mode_present : 1; //!< This flag will be set to true, if the current layer 256 //!< stack contains s3d layer, and the layer stack can enter 257 //!< s3d mode. 258 259 uint32_t post_processed_output : 1; // If output_buffer should contain post processed output 260 // This applies only to primary displays currently 261 262 uint32_t hdr_present : 1; //!< Set if stack has HDR content 263 264 uint32_t fast_path : 1; //!< Preference for fast/slow path draw-cycle, set by client. 265 266 uint32_t mask_present : 1; //!< Set if layer stack has mask layers. 267 268 uint32_t config_changed : 1; //!< This flag indicates Display config must be validated. 269 }; 270 271 uint32_t flags = 0; //!< For initialization purpose only. 272 //!< Client shall not refer it directly. 273 }; 274 }; 275 276 /*! @brief This structure defines a rectanglular area inside a display layer. 277 278 @sa LayerRectArray 279 */ 280 struct LayerRect { 281 float left = 0.0f; //!< Left-most pixel coordinate. 282 float top = 0.0f; //!< Top-most pixel coordinate. 283 float right = 0.0f; //!< Right-most pixel coordinate. 284 float bottom = 0.0f; //!< Bottom-most pixel coordinate. 285 286 LayerRect() = default; 287 LayerRectLayerRect288 LayerRect(float l, float t, float r, float b) : left(l), top(t), right(r), bottom(b) { } 289 290 bool operator==(const LayerRect& rect) const { 291 return left == rect.left && right == rect.right && top == rect.top && bottom == rect.bottom; 292 } 293 294 bool operator!=(const LayerRect& rect) const { 295 return !operator==(rect); 296 } 297 }; 298 299 /*! @brief This structure defines an array of display layer rectangles. 300 301 @sa LayerRect 302 */ 303 struct LayerRectArray { 304 LayerRect *rect = NULL; //!< Pointer to first element of array. 305 uint32_t count = 0; //!< Number of elements in the array. 306 }; 307 308 struct LayerStitchInfo { 309 LayerRect dst_rect = {}; //!< The target position where the frame will be 310 //!< rendered onto internal FrameBuffer. 311 312 LayerRect slice_rect = {}; //!< Target slice that this stitch rect belongs to. 313 }; 314 315 /*! @brief This structure defines solidfill structure. 316 317 @sa LayerSolidFill 318 */ 319 struct LayerSolidFill { 320 uint32_t bit_depth = 0; //!< Bit depth of solid fill colors 321 uint32_t red = 0; //!< Red value 322 uint32_t green = 0; //!< Green value 323 uint32_t blue = 0; //!< Blue value 324 uint32_t alpha = 0; //!< Alpha value 325 }; 326 327 struct LayerBufferMap { 328 std::unordered_map<uint64_t, std::shared_ptr<LayerBufferObject>> buffer_map; 329 }; 330 331 /*! @brief This structure defines display layer object which contains layer properties and a drawing 332 buffer. 333 334 @sa LayerArray 335 */ 336 struct Layer { 337 LayerBuffer input_buffer = {}; //!< Buffer to be composed. 338 //!< If this remains unchanged between two 339 //!< consecutive Prepare() calls and 340 //!< geometry_changed flag is not set for the 341 //!< second call, then the display device will 342 //!< assume that buffer content has not 343 //!< changed. 344 345 LayerComposition composition = kCompositionGPU; //!< Composition type which can be set by either 346 //!< the client or the display device. This value 347 //!< should be preserved between Prepare() and 348 //!< Commit() calls. 349 350 LayerRect src_rect = {}; //!< Rectangular area of the layer buffer to 351 //!< consider for composition. 352 353 LayerRect dst_rect = {}; //!< The target position where the frame will be 354 //!< displayed. Cropping rectangle is scaled to 355 //!< fit into this rectangle. The origin is the 356 //!< top-left corner of the screen. 357 358 LayerStitchInfo stitch_info = {}; //!< This structure defines all parameters needed 359 //!< for stitching like position to render, 360 //!< boundaries etc; 361 362 std::vector<LayerRect> visible_regions = {}; //!< Visible rectangular areas in screen space. 363 //!< The visible region includes areas overlapped 364 //!< by a translucent layer. 365 366 std::vector<LayerRect> dirty_regions = {}; //!< Rectangular areas in the current frames 367 //!< that have changed in comparison to 368 //!< previous frame. 369 370 LayerBlending blending = kBlendingPremultiplied; //!< Blending operation which need to be 371 //!< applied on the layer buffer during 372 //!< composition. 373 374 LayerTransform transform = {}; //!< Rotation/Flip operations which need to be 375 //!< applied to the layer buffer during 376 //!< composition. 377 378 uint8_t plane_alpha = 0xff; //!< Alpha value applied to the whole layer. 379 //!< Value of each pixel is computed as: 380 //!< if(kBlendingPremultiplied) { 381 //!< pixel.RGB = pixel.RGB * planeAlpha/255 382 //!< } 383 //!< pixel.a = pixel.a * planeAlpha 384 385 uint32_t frame_rate = 0; //!< Rate at which frames are being updated for 386 //!< this layer. 387 388 uint32_t solid_fill_color = 0; //!< TODO: Remove this field when fb support 389 //! is deprecated. 390 //!< Solid color used to fill the layer when 391 //!< no content is associated with the layer. 392 393 LayerFlags flags; //!< Flags associated with this layer. 394 395 LayerRequest request = {}; //!< o/p - request on this Layer by SDM. 396 397 Lut3d lut_3d = {}; //!< o/p - Populated by SDM when tone mapping is 398 //!< needed on this layer. 399 LayerSolidFill solid_fill_info = {}; //!< solid fill info along with depth. 400 std::shared_ptr<LayerBufferMap> buffer_map = nullptr; //!< Map of handle_id and fb_id. 401 float color_transform_matrix[kColorTransformMatrixSize] = { 1.0, 0.0, 0.0, 0.0, 402 0.0, 1.0, 0.0, 0.0, 403 0.0, 0.0, 1.0, 0.0, 404 0.0, 0.0, 0.0, 1.0 }; 405 std::bitset<kLayerUpdateMax> update_mask = 0; 406 }; 407 408 /*! @brief This structure defines the color space + transfer of a given layer. 409 410 @sa PrimariesTransfer 411 */ 412 413 struct PrimariesTransfer { 414 ColorPrimaries primaries = ColorPrimaries_BT709_5; 415 GammaTransfer transfer = Transfer_sRGB; 416 417 bool operator==(const PrimariesTransfer& blend_cs) const { 418 return ((primaries == blend_cs.primaries) && (transfer == blend_cs.transfer)); 419 } 420 }; 421 422 423 /*! @brief This structure defines a layer stack that contains layers which need to be composed and 424 rendered onto the target. 425 426 @sa DisplayInterface::Prepare 427 @sa DisplayInterface::Commit 428 */ 429 430 struct LayerStack { 431 std::vector<Layer *> layers = {}; //!< Vector of layer pointers. 432 433 shared_ptr<Fence> retire_fence = nullptr; 434 //!< File descriptor referring to a sync fence object which 435 //!< will be signaled when this composited frame has been 436 //!< replaced on screen by a subsequent frame on a physical 437 //!< display. The fence object is created and returned during 438 //!< Commit(). Client shall close the returned file 439 //!< descriptor. 440 //!< NOTE: This field applies to a physical display only. 441 442 LayerBuffer *output_buffer = NULL; //!< Pointer to the buffer where composed buffer would be 443 //!< rendered for virtual displays. 444 //!< NOTE: This field applies to a virtual display only. 445 446 LayerStackFlags flags; //!< Flags associated with this layer set. 447 448 449 PrimariesTransfer blend_cs = {}; //!< o/p - Blending color space of the frame, updated by SDM 450 451 uint64_t elapse_timestamp = 0; //!< system time until which display commit needs to be held 452 }; 453 454 } // namespace sdm 455 456 #endif // __LAYER_STACK_H__ 457 458