1 /* 2 * Copyright (c) 2014 - 2016, 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 42 namespace sdm { 43 44 /*! @brief This enum represents display layer blending types. 45 46 @sa Layer 47 */ 48 enum 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 */ 66 enum 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 If client does not provide a target buffer layer, SDM will assume that respective composition 106 engine is not available and will not mark any layer for such a composition. If SDM is unable 107 to handle layers without support of such a composition engine, Prepare() call will return 108 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 */ 132 struct 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 */ 152 struct 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 a layer stack. The 1-bit flag can be set to 183 ON(1) or OFF(0). 184 185 @sa LayerBuffer 186 */ 187 struct LayerStackFlags { 188 union { 189 struct { 190 uint32_t geometry_changed : 1; //!< This flag shall be set by client to indicate that the 191 //!< layer set passed to Prepare() has changed by more than 192 //!< just the buffer handles and acquire fences. 193 194 uint32_t skip_present : 1; //!< This flag will be set to true, if the current layer 195 //!< stack contains skip layers. 196 197 uint32_t video_present : 1; //!< This flag will be set to true, if current layer stack 198 //!< contains video. 199 200 uint32_t secure_present : 1; //!< This flag will be set to true, if the current layer 201 //!< stack contains secure layers. 202 203 uint32_t animating : 1; //!< This flag shall be set by client to indicate that the 204 //!< current frame is animating.i 205 206 uint32_t attributes_changed : 1; 207 //!< This flag shall be set by client to indicate that the 208 //!< current frame has some properties changed and 209 //!< needs re-config. 210 211 uint32_t cursor_present : 1; //!< This flag will be set to true if the current layer 212 //!< stack contains cursor layer. 213 214 uint32_t single_buffered_layer_present : 1; //!< Set if stack has single buffered layer 215 216 uint32_t s3d_mode_present : 1; //!< This flag will be set to true, if the current layer 217 //!< stack contains s3d layer, and the layer stack can enter 218 //!< s3d mode. 219 220 uint32_t post_processed_output : 1; // If output_buffer should contain post processed output 221 // This applies only to primary displays currently 222 }; 223 224 uint32_t flags = 0; //!< For initialization purpose only. 225 //!< Client shall not refer it directly. 226 }; 227 }; 228 229 /*! @brief This structure defines a rectanglular area inside a display layer. 230 231 @sa LayerRectArray 232 */ 233 struct LayerRect { 234 float left = 0.0f; //!< Left-most pixel coordinate. 235 float top = 0.0f; //!< Top-most pixel coordinate. 236 float right = 0.0f; //!< Right-most pixel coordinate. 237 float bottom = 0.0f; //!< Bottom-most pixel coordinate. 238 239 LayerRect() = default; 240 241 LayerRect(float l, float t, float r, float b) : left(l), top(t), right(r), bottom(b) { } 242 243 bool operator==(const LayerRect& rect) const { 244 return left == rect.left && right == rect.right && top == rect.top && bottom == rect.bottom; 245 } 246 247 bool operator!=(const LayerRect& rect) const { 248 return !operator==(rect); 249 } 250 }; 251 252 /*! @brief This structure defines an array of display layer rectangles. 253 254 @sa LayerRect 255 */ 256 struct LayerRectArray { 257 LayerRect *rect = NULL; //!< Pointer to first element of array. 258 uint32_t count = 0; //!< Number of elements in the array. 259 }; 260 261 /*! @brief This structure defines display layer object which contains layer properties and a drawing 262 buffer. 263 264 @sa LayerArray 265 */ 266 struct Layer { 267 LayerBuffer *input_buffer = NULL; //!< Pointer to the buffer to be composed. 268 //!< If this remains unchanged between two 269 //!< consecutive Prepare() calls and 270 //!< geometry_changed flag is not set for the 271 //!< second call, then the display device will 272 //!< assume that buffer content has not 273 //!< changed. 274 275 LayerComposition composition = kCompositionGPU; //!< Composition type which can be set by either 276 //!< the client or the display device. This value 277 //!< should be preserved between Prepare() and 278 //!< Commit() calls. 279 280 LayerRect src_rect = {}; //!< Rectangular area of the layer buffer to 281 //!< consider for composition. 282 283 LayerRect dst_rect = {}; //!< The target position where the frame will be 284 //!< displayed. Cropping rectangle is scaled to 285 //!< fit into this rectangle. The origin is the 286 //!< top-left corner of the screen. 287 288 std::vector<LayerRect> visible_regions = {}; //!< Visible rectangular areas in screen space. 289 //!< The visible region includes areas overlapped 290 //!< by a translucent layer. 291 292 std::vector<LayerRect> dirty_regions = {}; //!< Rectangular areas in the current frames 293 //!< that have changed in comparison to 294 //!< previous frame. 295 296 std::vector<LayerRect> blit_regions = {}; //!< Rectangular areas of this layer which need 297 //!< to be composed to blit target. Display 298 //!< device will update blit rectangles if a 299 //!< layer composition is set as hybrid. Nth blit 300 //!< rectangle shall be composed onto Nth blit 301 //!< target. 302 303 LayerBlending blending = kBlendingPremultiplied; //!< Blending operation which need to be 304 //!< applied on the layer buffer during 305 //!< composition. 306 307 LayerTransform transform = {}; //!< Rotation/Flip operations which need to be 308 //!< applied to the layer buffer during 309 //!< composition. 310 311 uint8_t plane_alpha = 0xff; //!< Alpha value applied to the whole layer. 312 //!< Value of each pixel is computed as: 313 //!< if(kBlendingPremultiplied) { 314 //!< pixel.RGB = pixel.RGB * planeAlpha/255 315 //!< } 316 //!< pixel.a = pixel.a * planeAlpha 317 318 uint32_t frame_rate = 0; //!< Rate at which frames are being updated for 319 //!< this layer. 320 321 uint32_t solid_fill_color = 0; //!< Solid color used to fill the layer when 322 //!< no content is associated with the layer. 323 324 LayerFlags flags; //!< Flags associated with this layer. 325 }; 326 327 /*! @brief This structure defines a layer stack that contains layers which need to be composed and 328 rendered onto the target. 329 330 @sa DisplayInterface::Prepare 331 @sa DisplayInterface::Commit 332 */ 333 struct LayerStack { 334 std::vector<Layer *> layers = {}; //!< Vector of layer pointers. 335 336 int retire_fence_fd = -1; //!< File descriptor referring to a sync fence object which 337 //!< will be signaled when this composited frame has been 338 //!< replaced on screen by a subsequent frame on a physical 339 //!< display. The fence object is created and returned during 340 //!< Commit(). Client shall close the returned file 341 //!< descriptor. 342 //!< NOTE: This field applies to a physical display only. 343 344 LayerBuffer *output_buffer = NULL; //!< Pointer to the buffer where composed buffer would be 345 //!< rendered for virtual displays. 346 //!< NOTE: This field applies to a virtual display only. 347 348 LayerStackFlags flags; //!< Flags associated with this layer set. 349 }; 350 351 } // namespace sdm 352 353 #endif // __LAYER_STACK_H__ 354 355
