1 /* 2 * Copyright (c) 2014 - 2017, 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 37 #include <vector> 38 #include <utility> 39 #include <unordered_map> 40 41 #include "layer_buffer.h" 42 #include "sdm_types.h" 43 44 namespace sdm { 45 46 /*! @brief This enum represents display layer blending types. 47 48 @sa Layer 49 */ 50 enum LayerBlending { 51 kBlendingPremultiplied, //!< Pixel color is expressed using premultiplied alpha in RGBA tuples. 52 //!< If plane alpha is less than 0xFF, apply modulation as well. 53 //!< pixel.rgb = src.rgb + dest.rgb x (1 - src.a) 54 55 kBlendingOpaque, //!< Pixel color is expressed using straight alpha in color tuples. It 56 //!< is constant blend operation. The layer would appear opaque if plane 57 //!< alpha is 0xFF. 58 59 kBlendingCoverage, //!< Pixel color is expressed using straight alpha in color tuples. If 60 //!< plane alpha is less than 0xff, apply modulation as well. 61 //!< pixel.rgb = src.rgb x src.a + dest.rgb x (1 - src.a) 62 }; 63 64 /*! @brief This enum represents display layer composition types. 65 66 @sa Layer 67 */ 68 enum LayerComposition { 69 /* ==== List of composition types set by SDM === */ 70 /* These composition types represent SDM composition decision for the layers which need to 71 be blended. Composition types are set during Prepare() by SDM. 72 Client can set default composition type to any of the below before calling into Prepare(), 73 however client's input value is ignored and does not play any role in composition decision. 74 */ 75 kCompositionGPU, //!< This layer will be drawn onto the target buffer by GPU. Display 76 //!< device will mark the layer for GPU composition if it can not 77 //!< handle composition for it. 78 //!< This composition type is used only if GPUTarget layer is provided 79 //!< in a composition cycle. 80 81 kCompositionGPUS3D, //!< This layer will be drawn onto the target buffer in s3d mode by GPU. 82 //!< Display device will mark the layer for GPU composition if it can 83 //!< not handle composition for it. 84 //!< This composition type is used only if GPUTarget layer is provided 85 //!< in a composition cycle. 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 kCompositionHybrid, //!< This layer will be drawn by a blit engine and SDE together. 94 //!< Display device will split the layer, update the blit rectangle 95 //!< that need to be composed by a blit engine and update original 96 //!< source rectangle that will be composed by SDE. 97 //!< This composition type is used only if GPUTarget and BlitTarget 98 //!< layers are provided in a composition cycle. 99 100 kCompositionBlit, //!< This layer will be composed using Blit Engine. 101 //!< This composition type is used only if BlitTarget layer is provided 102 //!< in a composition cycle. 103 104 /* === List of composition types set by Client === */ 105 /* These composition types represent target buffer layers onto which GPU or Blit will draw if SDM 106 decide to have some or all layers drawn by respective composition engine. 107 Client must provide a target buffer layer, if respective composition type is not disabled by 108 an explicit call to SetCompositionState() method. If a composition type is not disabled, 109 providing a target buffer layer is optional. If SDM is unable to handle layers without support 110 of such a composition engine, Prepare() call will return failure. 111 */ 112 kCompositionGPUTarget, //!< This layer will hold result of composition for layers marked for 113 //!< GPU composition. 114 //!< If display device does not set any layer for GPU composition then 115 //!< this layer would be ignored. Else, this layer will be composed 116 //!< with other layers marked for SDE composition by SDE. 117 //!< Only one layer shall be marked as target buffer by the caller. 118 //!< GPU target layer shall be placed after all application layers 119 //!< in the layer stack. 120 121 kCompositionBlitTarget, //!< This layer will hold result of composition for blit rectangles 122 //!< from the layers marked for hybrid composition. Nth blit rectangle 123 //!< in a layer shall be composed onto Nth blit target. 124 //!< If display device does not set any layer for hybrid composition 125 //!< then this would be ignored. 126 //!< Blit target layers shall be placed after GPUTarget in the layer 127 //!< stack. 128 }; 129 130 /*! @brief This structure defines rotation and flip values for a display layer. 131 132 @sa Layer 133 */ 134 struct LayerTransform { 135 float rotation = 0.0f; //!< Left most pixel coordinate. 136 bool flip_horizontal = false; //!< Mirror reversal of the layer across a horizontal axis. 137 bool flip_vertical = false; //!< Mirror reversal of the layer across a vertical axis. 138 139 bool operator==(const LayerTransform& transform) const { 140 return (rotation == transform.rotation && flip_horizontal == transform.flip_horizontal && 141 flip_vertical == transform.flip_vertical); 142 } 143 144 bool operator!=(const LayerTransform& transform) const { 145 return !operator==(transform); 146 } 147 }; 148 149 /*! @brief This structure defines flags associated with a layer. The 1-bit flag can be set to ON(1) 150 or OFF(0). 151 152 @sa LayerBuffer 153 */ 154 struct LayerFlags { 155 union { 156 struct { 157 uint32_t skip : 1; //!< This flag shall be set by client to indicate that this layer 158 //!< will be handled by GPU. Display Device will not consider it 159 //!< for composition. 160 161 uint32_t updating : 1; //!< This flag shall be set by client to indicate that this is 162 //!< updating non-updating. so strategy manager will mark them for 163 //!< SDE/GPU composition respectively when the layer stack qualifies 164 //!< for cache based composition. 165 166 uint32_t solid_fill : 1; 167 //!< This flag shall be set by client to indicate that this layer 168 //!< is for solid fill without input buffer. Display Device will 169 //!< use SDE HW feature to achieve it. 170 171 uint32_t cursor : 1; //!< This flag shall be set by client to indicate that this layer 172 //!< is a cursor 173 //!< Display Device may handle this layer using HWCursor 174 175 uint32_t single_buffer : 1; //!< This flag shall be set by client to indicate that the layer 176 //!< uses only a single buffer that will not be swapped out 177 }; 178 179 uint32_t flags = 0; //!< For initialization purpose only. 180 //!< Client shall not refer it directly. 181 }; 182 }; 183 184 /*! @brief This structure defines flags associated with the layer requests. The 1-bit flag can be 185 set to ON(1) or OFF(0). 186 187 @sa Layer 188 */ 189 struct LayerRequestFlags { 190 union { 191 struct { 192 uint32_t tone_map : 1; //!< This flag will be set by SDM when the layer needs tone map 193 uint32_t secure: 1; //!< This flag will be set by SDM when the layer must be secure 194 uint32_t flip_buffer: 1; //!< This flag will be set by SDM when the layer needs FBT flip 195 }; 196 uint32_t request_flags = 0; //!< For initialization purpose only. 197 //!< Shall not be refered directly. 198 }; 199 }; 200 201 /*! @brief This structure defines LayerRequest. 202 Includes width/height/format of the LayerRequest. 203 204 SDM shall set the properties of LayerRequest to be used by the client 205 206 @sa LayerRequest 207 */ 208 struct LayerRequest { 209 LayerRequestFlags flags; // Flags associated with this request 210 LayerBufferFormat format = kFormatRGBA8888; // Requested format 211 uint32_t width = 0; // Requested unaligned width. 212 uint32_t height = 0; // Requested unalighed height 213 }; 214 215 /*! @brief This structure defines flags associated with a layer stack. The 1-bit flag can be set to 216 ON(1) or OFF(0). 217 218 @sa LayerBuffer 219 */ 220 struct LayerStackFlags { 221 union { 222 struct { 223 uint32_t geometry_changed : 1; //!< This flag shall be set by client to indicate that the 224 //!< layer set passed to Prepare() has changed by more than 225 //!< just the buffer handles and acquire fences. 226 227 uint32_t skip_present : 1; //!< This flag will be set to true, if the current layer 228 //!< stack contains skip layers. 229 230 uint32_t video_present : 1; //!< This flag will be set to true, if current layer stack 231 //!< contains video. 232 233 uint32_t secure_present : 1; //!< This flag will be set to true, if the current layer 234 //!< stack contains secure layers. 235 236 uint32_t animating : 1; //!< This flag shall be set by client to indicate that the 237 //!< current frame is animating.i 238 239 uint32_t attributes_changed : 1; 240 //!< This flag shall be set by client to indicate that the 241 //!< current frame has some properties changed and 242 //!< needs re-config. 243 244 uint32_t cursor_present : 1; //!< This flag will be set to true if the current layer 245 //!< stack contains cursor layer. 246 247 uint32_t single_buffered_layer_present : 1; //!< Set if stack has single buffered layer 248 249 uint32_t s3d_mode_present : 1; //!< This flag will be set to true, if the current layer 250 //!< stack contains s3d layer, and the layer stack can enter 251 //!< s3d mode. 252 253 uint32_t post_processed_output : 1; // If output_buffer should contain post processed output 254 // This applies only to primary displays currently 255 256 uint32_t hdr_present : 1; //!< Set if stack has HDR content 257 }; 258 259 uint32_t flags = 0; //!< For initialization purpose only. 260 //!< Client shall not refer it directly. 261 }; 262 }; 263 264 /*! @brief This structure defines a rectanglular area inside a display layer. 265 266 @sa LayerRectArray 267 */ 268 struct LayerRect { 269 float left = 0.0f; //!< Left-most pixel coordinate. 270 float top = 0.0f; //!< Top-most pixel coordinate. 271 float right = 0.0f; //!< Right-most pixel coordinate. 272 float bottom = 0.0f; //!< Bottom-most pixel coordinate. 273 274 LayerRect() = default; 275 LayerRectLayerRect276 LayerRect(float l, float t, float r, float b) : left(l), top(t), right(r), bottom(b) { } 277 278 bool operator==(const LayerRect& rect) const { 279 return left == rect.left && right == rect.right && top == rect.top && bottom == rect.bottom; 280 } 281 282 bool operator!=(const LayerRect& rect) const { 283 return !operator==(rect); 284 } 285 }; 286 287 /*! @brief This structure defines an array of display layer rectangles. 288 289 @sa LayerRect 290 */ 291 struct LayerRectArray { 292 LayerRect *rect = NULL; //!< Pointer to first element of array. 293 uint32_t count = 0; //!< Number of elements in the array. 294 }; 295 296 /*! @brief This structure defines solidfill structure. 297 298 @sa LayerSolidFill 299 */ 300 struct LayerSolidFill { 301 uint32_t bit_depth = 0; //!< Bit depth of solid fill colors 302 uint32_t red = 0; //!< Red value 303 uint32_t green = 0; //!< Green value 304 uint32_t blue = 0; //!< Blue value 305 uint32_t alpha = 0; //!< Alpha value 306 }; 307 308 struct LayerBufferMap { 309 std::unordered_map<uint64_t, std::shared_ptr<LayerBufferObject>> buffer_map; 310 }; 311 312 /*! @brief This structure defines display layer object which contains layer properties and a drawing 313 buffer. 314 315 @sa LayerArray 316 */ 317 struct Layer { 318 LayerBuffer input_buffer = {}; //!< Buffer to be composed. 319 //!< If this remains unchanged between two 320 //!< consecutive Prepare() calls and 321 //!< geometry_changed flag is not set for the 322 //!< second call, then the display device will 323 //!< assume that buffer content has not 324 //!< changed. 325 326 LayerComposition composition = kCompositionGPU; //!< Composition type which can be set by either 327 //!< the client or the display device. This value 328 //!< should be preserved between Prepare() and 329 //!< Commit() calls. 330 331 LayerRect src_rect = {}; //!< Rectangular area of the layer buffer to 332 //!< consider for composition. 333 334 LayerRect dst_rect = {}; //!< The target position where the frame will be 335 //!< displayed. Cropping rectangle is scaled to 336 //!< fit into this rectangle. The origin is the 337 //!< top-left corner of the screen. 338 339 std::vector<LayerRect> visible_regions = {}; //!< Visible rectangular areas in screen space. 340 //!< The visible region includes areas overlapped 341 //!< by a translucent layer. 342 343 std::vector<LayerRect> dirty_regions = {}; //!< Rectangular areas in the current frames 344 //!< that have changed in comparison to 345 //!< previous frame. 346 347 std::vector<LayerRect> blit_regions = {}; //!< Rectangular areas of this layer which need 348 //!< to be composed to blit target. Display 349 //!< device will update blit rectangles if a 350 //!< layer composition is set as hybrid. Nth blit 351 //!< rectangle shall be composed onto Nth blit 352 //!< target. 353 354 LayerBlending blending = kBlendingPremultiplied; //!< Blending operation which need to be 355 //!< applied on the layer buffer during 356 //!< composition. 357 358 LayerTransform transform = {}; //!< Rotation/Flip operations which need to be 359 //!< applied to the layer buffer during 360 //!< composition. 361 362 uint8_t plane_alpha = 0xff; //!< Alpha value applied to the whole layer. 363 //!< Value of each pixel is computed as: 364 //!< if(kBlendingPremultiplied) { 365 //!< pixel.RGB = pixel.RGB * planeAlpha/255 366 //!< } 367 //!< pixel.a = pixel.a * planeAlpha 368 369 uint32_t frame_rate = 0; //!< Rate at which frames are being updated for 370 //!< this layer. 371 372 uint32_t solid_fill_color = 0; //!< TODO: Remove this field when fb support 373 //! is deprecated. 374 //!< Solid color used to fill the layer when 375 //!< no content is associated with the layer. 376 377 LayerFlags flags; //!< Flags associated with this layer. 378 379 LayerRequest request = {}; //!< o/p - request on this Layer by SDM. 380 381 Lut3d lut_3d = {}; //!< o/p - Populated by SDM when tone mapping is 382 //!< needed on this layer. 383 LayerSolidFill solid_fill_info = {}; //!< solid fill info along with depth. 384 std::shared_ptr<LayerBufferMap> buffer_map = nullptr; //!< Map of handle_id and fb_id. 385 }; 386 387 /*! @brief This structure defines a layer stack that contains layers which need to be composed and 388 rendered onto the target. 389 390 @sa DisplayInterface::Prepare 391 @sa DisplayInterface::Commit 392 */ 393 394 typedef std::pair<ColorPrimaries, GammaTransfer> PrimariesTransfer; 395 396 struct LayerStack { 397 std::vector<Layer *> layers = {}; //!< Vector of layer pointers. 398 399 int retire_fence_fd = -1; //!< File descriptor referring to a sync fence object which 400 //!< will be signaled when this composited frame has been 401 //!< replaced on screen by a subsequent frame on a physical 402 //!< display. The fence object is created and returned during 403 //!< Commit(). Client shall close the returned file 404 //!< descriptor. 405 //!< NOTE: This field applies to a physical display only. 406 407 LayerBuffer *output_buffer = NULL; //!< Pointer to the buffer where composed buffer would be 408 //!< rendered for virtual displays. 409 //!< NOTE: This field applies to a virtual display only. 410 411 LayerStackFlags flags; //!< Flags associated with this layer set. 412 413 PrimariesTransfer blend_cs = {ColorPrimaries_BT709_5, Transfer_sRGB}; 414 //!< o/p - Blending color space updated by SDM 415 }; 416 417 } // namespace sdm 418 419 #endif // __LAYER_STACK_H__ 420 421