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