1 /* 2 * Copyright 2015 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef ANDROID_HARDWARE_HWCOMPOSER2_H 18 #define ANDROID_HARDWARE_HWCOMPOSER2_H 19 20 #include <sys/cdefs.h> 21 22 #include <hardware/hardware.h> 23 24 #include "hwcomposer_defs.h" 25 26 __BEGIN_DECLS 27 28 /* 29 * Enums 30 * 31 * For most of these enums, there is an invalid value defined to be 0. This is 32 * an attempt to catch uninitialized fields, and these values should not be 33 * used. 34 */ 35 36 /* Display attributes queryable through getDisplayAttribute */ 37 typedef enum { 38 HWC2_ATTRIBUTE_INVALID = 0, 39 40 /* Dimensions in pixels */ 41 HWC2_ATTRIBUTE_WIDTH = 1, 42 HWC2_ATTRIBUTE_HEIGHT = 2, 43 44 /* Vsync period in nanoseconds */ 45 HWC2_ATTRIBUTE_VSYNC_PERIOD = 3, 46 47 /* Dots per thousand inches (DPI * 1000). Scaling by 1000 allows these 48 * numbers to be stored in an int32_t without losing too much precision. If 49 * the DPI for a configuration is unavailable or is considered unreliable, 50 * the device may return -1 instead */ 51 HWC2_ATTRIBUTE_DPI_X = 4, 52 HWC2_ATTRIBUTE_DPI_Y = 5, 53 } hwc2_attribute_t; 54 55 /* Blend modes, settable per layer */ 56 typedef enum { 57 HWC2_BLEND_MODE_INVALID = 0, 58 59 /* colorOut = colorSrc */ 60 HWC2_BLEND_MODE_NONE = 1, 61 62 /* colorOut = colorSrc + colorDst * (1 - alphaSrc) */ 63 HWC2_BLEND_MODE_PREMULTIPLIED = 2, 64 65 /* colorOut = colorSrc * alphaSrc + colorDst * (1 - alphaSrc) */ 66 HWC2_BLEND_MODE_COVERAGE = 3, 67 } hwc2_blend_mode_t; 68 69 /* See the 'Callbacks' section for more detailed descriptions of what these 70 * functions do */ 71 typedef enum { 72 HWC2_CALLBACK_INVALID = 0, 73 HWC2_CALLBACK_HOTPLUG = 1, 74 HWC2_CALLBACK_REFRESH = 2, 75 HWC2_CALLBACK_VSYNC = 3, 76 } hwc2_callback_descriptor_t; 77 78 /* Optional capabilities which may be supported by some devices. The particular 79 * set of supported capabilities for a given device may be retrieved using 80 * getCapabilities. */ 81 typedef enum { 82 HWC2_CAPABILITY_INVALID = 0, 83 84 /* Specifies that the device supports sideband stream layers, for which 85 * buffer content updates and other synchronization will not be provided 86 * through the usual validate/present cycle and must be handled by an 87 * external implementation-defined mechanism. Only changes to layer state 88 * (such as position, size, etc.) need to be performed through the 89 * validate/present cycle. */ 90 HWC2_CAPABILITY_SIDEBAND_STREAM = 1, 91 92 /* Specifies that the device will apply a color transform even when either 93 * the client or the device has chosen that all layers should be composed by 94 * the client. This will prevent the client from applying the color 95 * transform during its composition step. */ 96 HWC2_CAPABILITY_SKIP_CLIENT_COLOR_TRANSFORM = 2, 97 98 /* Specifies that the present fence must not be used as an accurate 99 * representation of the actual present time of a frame. 100 * This capability must never be set by HWC2 devices. 101 * This capability may be set for HWC1 devices that use the 102 * HWC2On1Adapter where emulation of the present fence using the retire 103 * fence is not feasible. 104 * In the future, CTS tests will require present time to be reliable. 105 */ 106 HWC2_CAPABILITY_PRESENT_FENCE_IS_NOT_RELIABLE = 3, 107 108 /* Specifies that a device is able to skip the validateDisplay call before 109 * receiving a call to presentDisplay. The client will always skip 110 * validateDisplay and try to call presentDisplay regardless of the changes 111 * in the properties of the layers. If the device returns anything else than 112 * HWC2_ERROR_NONE, it will call validateDisplay then presentDisplay again. 113 * For this capability to be worthwhile the device implementation of 114 * presentDisplay should fail as fast as possible in the case a 115 * validateDisplay step is needed. 116 */ 117 HWC2_CAPABILITY_SKIP_VALIDATE= 4, 118 } hwc2_capability_t; 119 120 /* Possible composition types for a given layer */ 121 typedef enum { 122 HWC2_COMPOSITION_INVALID = 0, 123 124 /* The client will composite this layer into the client target buffer 125 * (provided to the device through setClientTarget). 126 * 127 * The device must not request any composition type changes for layers of 128 * this type. */ 129 HWC2_COMPOSITION_CLIENT = 1, 130 131 /* The device will handle the composition of this layer through a hardware 132 * overlay or other similar means. 133 * 134 * Upon validateDisplay, the device may request a change from this type to 135 * HWC2_COMPOSITION_CLIENT. */ 136 HWC2_COMPOSITION_DEVICE = 2, 137 138 /* The device will render this layer using the color set through 139 * setLayerColor. If this functionality is not supported on a layer that the 140 * client sets to HWC2_COMPOSITION_SOLID_COLOR, the device must request that 141 * the composition type of that layer is changed to HWC2_COMPOSITION_CLIENT 142 * upon the next call to validateDisplay. 143 * 144 * Upon validateDisplay, the device may request a change from this type to 145 * HWC2_COMPOSITION_CLIENT. */ 146 HWC2_COMPOSITION_SOLID_COLOR = 3, 147 148 /* Similar to DEVICE, but the position of this layer may also be set 149 * asynchronously through setCursorPosition. If this functionality is not 150 * supported on a layer that the client sets to HWC2_COMPOSITION_CURSOR, the 151 * device must request that the composition type of that layer is changed to 152 * HWC2_COMPOSITION_CLIENT upon the next call to validateDisplay. 153 * 154 * Upon validateDisplay, the device may request a change from this type to 155 * either HWC2_COMPOSITION_DEVICE or HWC2_COMPOSITION_CLIENT. Changing to 156 * HWC2_COMPOSITION_DEVICE will prevent the use of setCursorPosition but 157 * still permit the device to composite the layer. */ 158 HWC2_COMPOSITION_CURSOR = 4, 159 160 /* The device will handle the composition of this layer, as well as its 161 * buffer updates and content synchronization. Only supported on devices 162 * which provide HWC2_CAPABILITY_SIDEBAND_STREAM. 163 * 164 * Upon validateDisplay, the device may request a change from this type to 165 * either HWC2_COMPOSITION_DEVICE or HWC2_COMPOSITION_CLIENT, but it is 166 * unlikely that content will display correctly in these cases. */ 167 HWC2_COMPOSITION_SIDEBAND = 5, 168 } hwc2_composition_t; 169 170 /* Possible connection options from the hotplug callback */ 171 typedef enum { 172 HWC2_CONNECTION_INVALID = 0, 173 174 /* The display has been connected */ 175 HWC2_CONNECTION_CONNECTED = 1, 176 177 /* The display has been disconnected */ 178 HWC2_CONNECTION_DISCONNECTED = 2, 179 } hwc2_connection_t; 180 181 /* Display requests returned by getDisplayRequests */ 182 typedef enum { 183 /* Instructs the client to provide a new client target buffer, even if no 184 * layers are marked for client composition. */ 185 HWC2_DISPLAY_REQUEST_FLIP_CLIENT_TARGET = 1 << 0, 186 187 /* Instructs the client to write the result of client composition directly 188 * into the virtual display output buffer. If any of the layers are not 189 * marked as HWC2_COMPOSITION_CLIENT or the given display is not a virtual 190 * display, this request has no effect. */ 191 HWC2_DISPLAY_REQUEST_WRITE_CLIENT_TARGET_TO_OUTPUT = 1 << 1, 192 } hwc2_display_request_t; 193 194 /* Display types returned by getDisplayType */ 195 typedef enum { 196 HWC2_DISPLAY_TYPE_INVALID = 0, 197 198 /* All physical displays, including both internal displays and hotpluggable 199 * external displays */ 200 HWC2_DISPLAY_TYPE_PHYSICAL = 1, 201 202 /* Virtual displays created by createVirtualDisplay */ 203 HWC2_DISPLAY_TYPE_VIRTUAL = 2, 204 } hwc2_display_type_t; 205 206 /* Return codes from all functions */ 207 typedef enum { 208 HWC2_ERROR_NONE = 0, 209 HWC2_ERROR_BAD_CONFIG, 210 HWC2_ERROR_BAD_DISPLAY, 211 HWC2_ERROR_BAD_LAYER, 212 HWC2_ERROR_BAD_PARAMETER, 213 HWC2_ERROR_HAS_CHANGES, 214 HWC2_ERROR_NO_RESOURCES, 215 HWC2_ERROR_NOT_VALIDATED, 216 HWC2_ERROR_UNSUPPORTED, 217 } hwc2_error_t; 218 219 /* Function descriptors for use with getFunction */ 220 typedef enum { 221 HWC2_FUNCTION_INVALID = 0, 222 HWC2_FUNCTION_ACCEPT_DISPLAY_CHANGES, 223 HWC2_FUNCTION_CREATE_LAYER, 224 HWC2_FUNCTION_CREATE_VIRTUAL_DISPLAY, 225 HWC2_FUNCTION_DESTROY_LAYER, 226 HWC2_FUNCTION_DESTROY_VIRTUAL_DISPLAY, 227 HWC2_FUNCTION_DUMP, 228 HWC2_FUNCTION_GET_ACTIVE_CONFIG, 229 HWC2_FUNCTION_GET_CHANGED_COMPOSITION_TYPES, 230 HWC2_FUNCTION_GET_CLIENT_TARGET_SUPPORT, 231 HWC2_FUNCTION_GET_COLOR_MODES, 232 HWC2_FUNCTION_GET_DISPLAY_ATTRIBUTE, 233 HWC2_FUNCTION_GET_DISPLAY_CONFIGS, 234 HWC2_FUNCTION_GET_DISPLAY_NAME, 235 HWC2_FUNCTION_GET_DISPLAY_REQUESTS, 236 HWC2_FUNCTION_GET_DISPLAY_TYPE, 237 HWC2_FUNCTION_GET_DOZE_SUPPORT, 238 HWC2_FUNCTION_GET_HDR_CAPABILITIES, 239 HWC2_FUNCTION_GET_MAX_VIRTUAL_DISPLAY_COUNT, 240 HWC2_FUNCTION_GET_RELEASE_FENCES, 241 HWC2_FUNCTION_PRESENT_DISPLAY, 242 HWC2_FUNCTION_REGISTER_CALLBACK, 243 HWC2_FUNCTION_SET_ACTIVE_CONFIG, 244 HWC2_FUNCTION_SET_CLIENT_TARGET, 245 HWC2_FUNCTION_SET_COLOR_MODE, 246 HWC2_FUNCTION_SET_COLOR_TRANSFORM, 247 HWC2_FUNCTION_SET_CURSOR_POSITION, 248 HWC2_FUNCTION_SET_LAYER_BLEND_MODE, 249 HWC2_FUNCTION_SET_LAYER_BUFFER, 250 HWC2_FUNCTION_SET_LAYER_COLOR, 251 HWC2_FUNCTION_SET_LAYER_COMPOSITION_TYPE, 252 HWC2_FUNCTION_SET_LAYER_DATASPACE, 253 HWC2_FUNCTION_SET_LAYER_DISPLAY_FRAME, 254 HWC2_FUNCTION_SET_LAYER_PLANE_ALPHA, 255 HWC2_FUNCTION_SET_LAYER_SIDEBAND_STREAM, 256 HWC2_FUNCTION_SET_LAYER_SOURCE_CROP, 257 HWC2_FUNCTION_SET_LAYER_SURFACE_DAMAGE, 258 HWC2_FUNCTION_SET_LAYER_TRANSFORM, 259 HWC2_FUNCTION_SET_LAYER_VISIBLE_REGION, 260 HWC2_FUNCTION_SET_LAYER_Z_ORDER, 261 HWC2_FUNCTION_SET_OUTPUT_BUFFER, 262 HWC2_FUNCTION_SET_POWER_MODE, 263 HWC2_FUNCTION_SET_VSYNC_ENABLED, 264 HWC2_FUNCTION_VALIDATE_DISPLAY, 265 } hwc2_function_descriptor_t; 266 267 /* Layer requests returned from getDisplayRequests */ 268 typedef enum { 269 /* The client should clear its target with transparent pixels where this 270 * layer would be. The client may ignore this request if the layer must be 271 * blended. */ 272 HWC2_LAYER_REQUEST_CLEAR_CLIENT_TARGET = 1 << 0, 273 } hwc2_layer_request_t; 274 275 /* Power modes for use with setPowerMode */ 276 typedef enum { 277 /* The display is fully off (blanked) */ 278 HWC2_POWER_MODE_OFF = 0, 279 280 /* These are optional low power modes. getDozeSupport may be called to 281 * determine whether a given display supports these modes. */ 282 283 /* The display is turned on and configured in a low power state that is 284 * suitable for presenting ambient information to the user, possibly with 285 * lower fidelity than HWC2_POWER_MODE_ON, but with greater efficiency. */ 286 HWC2_POWER_MODE_DOZE = 1, 287 288 /* The display is configured as in HWC2_POWER_MODE_DOZE but may stop 289 * applying display updates from the client. This is effectively a hint to 290 * the device that drawing to the display has been suspended and that the 291 * the device should remain on in a low power state and continue displaying 292 * its current contents indefinitely until the power mode changes. 293 * 294 * This mode may also be used as a signal to enable hardware-based doze 295 * functionality. In this case, the device is free to take over the display 296 * and manage it autonomously to implement a low power always-on display. */ 297 HWC2_POWER_MODE_DOZE_SUSPEND = 3, 298 299 /* The display is fully on */ 300 HWC2_POWER_MODE_ON = 2, 301 } hwc2_power_mode_t; 302 303 /* Vsync values passed to setVsyncEnabled */ 304 typedef enum { 305 HWC2_VSYNC_INVALID = 0, 306 307 /* Enable vsync */ 308 HWC2_VSYNC_ENABLE = 1, 309 310 /* Disable vsync */ 311 HWC2_VSYNC_DISABLE = 2, 312 } hwc2_vsync_t; 313 314 /* 315 * Stringification Functions 316 */ 317 318 #ifdef HWC2_INCLUDE_STRINGIFICATION 319 320 static inline const char* getAttributeName(hwc2_attribute_t attribute) { 321 switch (attribute) { 322 case HWC2_ATTRIBUTE_INVALID: return "Invalid"; 323 case HWC2_ATTRIBUTE_WIDTH: return "Width"; 324 case HWC2_ATTRIBUTE_HEIGHT: return "Height"; 325 case HWC2_ATTRIBUTE_VSYNC_PERIOD: return "VsyncPeriod"; 326 case HWC2_ATTRIBUTE_DPI_X: return "DpiX"; 327 case HWC2_ATTRIBUTE_DPI_Y: return "DpiY"; 328 default: return "Unknown"; 329 } 330 } 331 332 static inline const char* getBlendModeName(hwc2_blend_mode_t mode) { 333 switch (mode) { 334 case HWC2_BLEND_MODE_INVALID: return "Invalid"; 335 case HWC2_BLEND_MODE_NONE: return "None"; 336 case HWC2_BLEND_MODE_PREMULTIPLIED: return "Premultiplied"; 337 case HWC2_BLEND_MODE_COVERAGE: return "Coverage"; 338 default: return "Unknown"; 339 } 340 } 341 342 static inline const char* getCallbackDescriptorName( 343 hwc2_callback_descriptor_t desc) { 344 switch (desc) { 345 case HWC2_CALLBACK_INVALID: return "Invalid"; 346 case HWC2_CALLBACK_HOTPLUG: return "Hotplug"; 347 case HWC2_CALLBACK_REFRESH: return "Refresh"; 348 case HWC2_CALLBACK_VSYNC: return "Vsync"; 349 default: return "Unknown"; 350 } 351 } 352 353 static inline const char* getCapabilityName(hwc2_capability_t capability) { 354 switch (capability) { 355 case HWC2_CAPABILITY_INVALID: return "Invalid"; 356 case HWC2_CAPABILITY_SIDEBAND_STREAM: return "SidebandStream"; 357 case HWC2_CAPABILITY_SKIP_CLIENT_COLOR_TRANSFORM: 358 return "SkipClientColorTransform"; 359 case HWC2_CAPABILITY_PRESENT_FENCE_IS_NOT_RELIABLE: 360 return "PresentFenceIsNotReliable"; 361 default: return "Unknown"; 362 } 363 } 364 365 static inline const char* getCompositionName(hwc2_composition_t composition) { 366 switch (composition) { 367 case HWC2_COMPOSITION_INVALID: return "Invalid"; 368 case HWC2_COMPOSITION_CLIENT: return "Client"; 369 case HWC2_COMPOSITION_DEVICE: return "Device"; 370 case HWC2_COMPOSITION_SOLID_COLOR: return "SolidColor"; 371 case HWC2_COMPOSITION_CURSOR: return "Cursor"; 372 case HWC2_COMPOSITION_SIDEBAND: return "Sideband"; 373 default: return "Unknown"; 374 } 375 } 376 377 static inline const char* getConnectionName(hwc2_connection_t connection) { 378 switch (connection) { 379 case HWC2_CONNECTION_INVALID: return "Invalid"; 380 case HWC2_CONNECTION_CONNECTED: return "Connected"; 381 case HWC2_CONNECTION_DISCONNECTED: return "Disconnected"; 382 default: return "Unknown"; 383 } 384 } 385 386 static inline const char* getDisplayRequestName( 387 hwc2_display_request_t request) { 388 switch (__BIONIC_CAST(static_cast, int, request)) { 389 case 0: return "None"; 390 case HWC2_DISPLAY_REQUEST_FLIP_CLIENT_TARGET: return "FlipClientTarget"; 391 case HWC2_DISPLAY_REQUEST_WRITE_CLIENT_TARGET_TO_OUTPUT: 392 return "WriteClientTargetToOutput"; 393 case HWC2_DISPLAY_REQUEST_FLIP_CLIENT_TARGET | 394 HWC2_DISPLAY_REQUEST_WRITE_CLIENT_TARGET_TO_OUTPUT: 395 return "FlipClientTarget|WriteClientTargetToOutput"; 396 default: return "Unknown"; 397 } 398 } 399 400 static inline const char* getDisplayTypeName(hwc2_display_type_t type) { 401 switch (type) { 402 case HWC2_DISPLAY_TYPE_INVALID: return "Invalid"; 403 case HWC2_DISPLAY_TYPE_PHYSICAL: return "Physical"; 404 case HWC2_DISPLAY_TYPE_VIRTUAL: return "Virtual"; 405 default: return "Unknown"; 406 } 407 } 408 409 static inline const char* getErrorName(hwc2_error_t error) { 410 switch (error) { 411 case HWC2_ERROR_NONE: return "None"; 412 case HWC2_ERROR_BAD_CONFIG: return "BadConfig"; 413 case HWC2_ERROR_BAD_DISPLAY: return "BadDisplay"; 414 case HWC2_ERROR_BAD_LAYER: return "BadLayer"; 415 case HWC2_ERROR_BAD_PARAMETER: return "BadParameter"; 416 case HWC2_ERROR_HAS_CHANGES: return "HasChanges"; 417 case HWC2_ERROR_NO_RESOURCES: return "NoResources"; 418 case HWC2_ERROR_NOT_VALIDATED: return "NotValidated"; 419 case HWC2_ERROR_UNSUPPORTED: return "Unsupported"; 420 default: return "Unknown"; 421 } 422 } 423 424 static inline const char* getFunctionDescriptorName( 425 hwc2_function_descriptor_t desc) { 426 switch (desc) { 427 case HWC2_FUNCTION_INVALID: return "Invalid"; 428 case HWC2_FUNCTION_ACCEPT_DISPLAY_CHANGES: 429 return "AcceptDisplayChanges"; 430 case HWC2_FUNCTION_CREATE_LAYER: return "CreateLayer"; 431 case HWC2_FUNCTION_CREATE_VIRTUAL_DISPLAY: 432 return "CreateVirtualDisplay"; 433 case HWC2_FUNCTION_DESTROY_LAYER: return "DestroyLayer"; 434 case HWC2_FUNCTION_DESTROY_VIRTUAL_DISPLAY: 435 return "DestroyVirtualDisplay"; 436 case HWC2_FUNCTION_DUMP: return "Dump"; 437 case HWC2_FUNCTION_GET_ACTIVE_CONFIG: return "GetActiveConfig"; 438 case HWC2_FUNCTION_GET_CHANGED_COMPOSITION_TYPES: 439 return "GetChangedCompositionTypes"; 440 case HWC2_FUNCTION_GET_CLIENT_TARGET_SUPPORT: 441 return "GetClientTargetSupport"; 442 case HWC2_FUNCTION_GET_COLOR_MODES: return "GetColorModes"; 443 case HWC2_FUNCTION_GET_DISPLAY_ATTRIBUTE: return "GetDisplayAttribute"; 444 case HWC2_FUNCTION_GET_DISPLAY_CONFIGS: return "GetDisplayConfigs"; 445 case HWC2_FUNCTION_GET_DISPLAY_NAME: return "GetDisplayName"; 446 case HWC2_FUNCTION_GET_DISPLAY_REQUESTS: return "GetDisplayRequests"; 447 case HWC2_FUNCTION_GET_DISPLAY_TYPE: return "GetDisplayType"; 448 case HWC2_FUNCTION_GET_DOZE_SUPPORT: return "GetDozeSupport"; 449 case HWC2_FUNCTION_GET_HDR_CAPABILITIES: return "GetHdrCapabilities"; 450 case HWC2_FUNCTION_GET_MAX_VIRTUAL_DISPLAY_COUNT: 451 return "GetMaxVirtualDisplayCount"; 452 case HWC2_FUNCTION_GET_RELEASE_FENCES: return "GetReleaseFences"; 453 case HWC2_FUNCTION_PRESENT_DISPLAY: return "PresentDisplay"; 454 case HWC2_FUNCTION_REGISTER_CALLBACK: return "RegisterCallback"; 455 case HWC2_FUNCTION_SET_ACTIVE_CONFIG: return "SetActiveConfig"; 456 case HWC2_FUNCTION_SET_CLIENT_TARGET: return "SetClientTarget"; 457 case HWC2_FUNCTION_SET_COLOR_MODE: return "SetColorMode"; 458 case HWC2_FUNCTION_SET_COLOR_TRANSFORM: return "SetColorTransform"; 459 case HWC2_FUNCTION_SET_CURSOR_POSITION: return "SetCursorPosition"; 460 case HWC2_FUNCTION_SET_LAYER_BLEND_MODE: return "SetLayerBlendMode"; 461 case HWC2_FUNCTION_SET_LAYER_BUFFER: return "SetLayerBuffer"; 462 case HWC2_FUNCTION_SET_LAYER_COLOR: return "SetLayerColor"; 463 case HWC2_FUNCTION_SET_LAYER_COMPOSITION_TYPE: 464 return "SetLayerCompositionType"; 465 case HWC2_FUNCTION_SET_LAYER_DATASPACE: return "SetLayerDataspace"; 466 case HWC2_FUNCTION_SET_LAYER_DISPLAY_FRAME: 467 return "SetLayerDisplayFrame"; 468 case HWC2_FUNCTION_SET_LAYER_PLANE_ALPHA: return "SetLayerPlaneAlpha"; 469 case HWC2_FUNCTION_SET_LAYER_SIDEBAND_STREAM: 470 return "SetLayerSidebandStream"; 471 case HWC2_FUNCTION_SET_LAYER_SOURCE_CROP: return "SetLayerSourceCrop"; 472 case HWC2_FUNCTION_SET_LAYER_SURFACE_DAMAGE: 473 return "SetLayerSurfaceDamage"; 474 case HWC2_FUNCTION_SET_LAYER_TRANSFORM: return "SetLayerTransform"; 475 case HWC2_FUNCTION_SET_LAYER_VISIBLE_REGION: 476 return "SetLayerVisibleRegion"; 477 case HWC2_FUNCTION_SET_LAYER_Z_ORDER: return "SetLayerZOrder"; 478 case HWC2_FUNCTION_SET_OUTPUT_BUFFER: return "SetOutputBuffer"; 479 case HWC2_FUNCTION_SET_POWER_MODE: return "SetPowerMode"; 480 case HWC2_FUNCTION_SET_VSYNC_ENABLED: return "SetVsyncEnabled"; 481 case HWC2_FUNCTION_VALIDATE_DISPLAY: return "ValidateDisplay"; 482 default: return "Unknown"; 483 } 484 } 485 486 static inline const char* getLayerRequestName(hwc2_layer_request_t request) { 487 switch (__BIONIC_CAST(static_cast, int, request)) { 488 case 0: return "None"; 489 case HWC2_LAYER_REQUEST_CLEAR_CLIENT_TARGET: return "ClearClientTarget"; 490 default: return "Unknown"; 491 } 492 } 493 494 static inline const char* getPowerModeName(hwc2_power_mode_t mode) { 495 switch (mode) { 496 case HWC2_POWER_MODE_OFF: return "Off"; 497 case HWC2_POWER_MODE_DOZE_SUSPEND: return "DozeSuspend"; 498 case HWC2_POWER_MODE_DOZE: return "Doze"; 499 case HWC2_POWER_MODE_ON: return "On"; 500 default: return "Unknown"; 501 } 502 } 503 504 static inline const char* getTransformName(hwc_transform_t transform) { 505 switch (__BIONIC_CAST(static_cast, int, transform)) { 506 case 0: return "None"; 507 case HWC_TRANSFORM_FLIP_H: return "FlipH"; 508 case HWC_TRANSFORM_FLIP_V: return "FlipV"; 509 case HWC_TRANSFORM_ROT_90: return "Rotate90"; 510 case HWC_TRANSFORM_ROT_180: return "Rotate180"; 511 case HWC_TRANSFORM_ROT_270: return "Rotate270"; 512 case HWC_TRANSFORM_FLIP_H_ROT_90: return "FlipHRotate90"; 513 case HWC_TRANSFORM_FLIP_V_ROT_90: return "FlipVRotate90"; 514 default: return "Unknown"; 515 } 516 } 517 518 static inline const char* getVsyncName(hwc2_vsync_t vsync) { 519 switch (vsync) { 520 case HWC2_VSYNC_INVALID: return "Invalid"; 521 case HWC2_VSYNC_ENABLE: return "Enable"; 522 case HWC2_VSYNC_DISABLE: return "Disable"; 523 default: return "Unknown"; 524 } 525 } 526 527 #define TO_STRING(E, T, printer) \ 528 inline std::string to_string(E value) { return printer(value); } \ 529 inline std::string to_string(T value) { return to_string(static_cast<E>(value)); } 530 #else // !HWC2_INCLUDE_STRINGIFICATION 531 #define TO_STRING(name, printer) 532 #endif // HWC2_INCLUDE_STRINGIFICATION 533 534 /* 535 * C++11 features 536 */ 537 538 #ifdef HWC2_USE_CPP11 539 __END_DECLS 540 541 #ifdef HWC2_INCLUDE_STRINGIFICATION 542 #include <string> 543 #endif 544 545 namespace HWC2 { 546 547 enum class Attribute : int32_t { 548 Invalid = HWC2_ATTRIBUTE_INVALID, 549 Width = HWC2_ATTRIBUTE_WIDTH, 550 Height = HWC2_ATTRIBUTE_HEIGHT, 551 VsyncPeriod = HWC2_ATTRIBUTE_VSYNC_PERIOD, 552 DpiX = HWC2_ATTRIBUTE_DPI_X, 553 DpiY = HWC2_ATTRIBUTE_DPI_Y, 554 }; 555 TO_STRING(hwc2_attribute_t, Attribute, getAttributeName) 556 557 enum class BlendMode : int32_t { 558 Invalid = HWC2_BLEND_MODE_INVALID, 559 None = HWC2_BLEND_MODE_NONE, 560 Premultiplied = HWC2_BLEND_MODE_PREMULTIPLIED, 561 Coverage = HWC2_BLEND_MODE_COVERAGE, 562 }; 563 TO_STRING(hwc2_blend_mode_t, BlendMode, getBlendModeName) 564 565 enum class Callback : int32_t { 566 Invalid = HWC2_CALLBACK_INVALID, 567 Hotplug = HWC2_CALLBACK_HOTPLUG, 568 Refresh = HWC2_CALLBACK_REFRESH, 569 Vsync = HWC2_CALLBACK_VSYNC, 570 }; 571 TO_STRING(hwc2_callback_descriptor_t, Callback, getCallbackDescriptorName) 572 573 enum class Capability : int32_t { 574 Invalid = HWC2_CAPABILITY_INVALID, 575 SidebandStream = HWC2_CAPABILITY_SIDEBAND_STREAM, 576 SkipClientColorTransform = HWC2_CAPABILITY_SKIP_CLIENT_COLOR_TRANSFORM, 577 PresentFenceIsNotReliable = HWC2_CAPABILITY_PRESENT_FENCE_IS_NOT_RELIABLE, 578 SkipValidate = HWC2_CAPABILITY_SKIP_VALIDATE, 579 }; 580 TO_STRING(hwc2_capability_t, Capability, getCapabilityName) 581 582 enum class Composition : int32_t { 583 Invalid = HWC2_COMPOSITION_INVALID, 584 Client = HWC2_COMPOSITION_CLIENT, 585 Device = HWC2_COMPOSITION_DEVICE, 586 SolidColor = HWC2_COMPOSITION_SOLID_COLOR, 587 Cursor = HWC2_COMPOSITION_CURSOR, 588 Sideband = HWC2_COMPOSITION_SIDEBAND, 589 }; 590 TO_STRING(hwc2_composition_t, Composition, getCompositionName) 591 592 enum class Connection : int32_t { 593 Invalid = HWC2_CONNECTION_INVALID, 594 Connected = HWC2_CONNECTION_CONNECTED, 595 Disconnected = HWC2_CONNECTION_DISCONNECTED, 596 }; 597 TO_STRING(hwc2_connection_t, Connection, getConnectionName) 598 599 enum class DisplayRequest : int32_t { 600 FlipClientTarget = HWC2_DISPLAY_REQUEST_FLIP_CLIENT_TARGET, 601 WriteClientTargetToOutput = 602 HWC2_DISPLAY_REQUEST_WRITE_CLIENT_TARGET_TO_OUTPUT, 603 }; 604 TO_STRING(hwc2_display_request_t, DisplayRequest, getDisplayRequestName) 605 606 enum class DisplayType : int32_t { 607 Invalid = HWC2_DISPLAY_TYPE_INVALID, 608 Physical = HWC2_DISPLAY_TYPE_PHYSICAL, 609 Virtual = HWC2_DISPLAY_TYPE_VIRTUAL, 610 }; 611 TO_STRING(hwc2_display_type_t, DisplayType, getDisplayTypeName) 612 613 enum class Error : int32_t { 614 None = HWC2_ERROR_NONE, 615 BadConfig = HWC2_ERROR_BAD_CONFIG, 616 BadDisplay = HWC2_ERROR_BAD_DISPLAY, 617 BadLayer = HWC2_ERROR_BAD_LAYER, 618 BadParameter = HWC2_ERROR_BAD_PARAMETER, 619 HasChanges = HWC2_ERROR_HAS_CHANGES, 620 NoResources = HWC2_ERROR_NO_RESOURCES, 621 NotValidated = HWC2_ERROR_NOT_VALIDATED, 622 Unsupported = HWC2_ERROR_UNSUPPORTED, 623 }; 624 TO_STRING(hwc2_error_t, Error, getErrorName) 625 626 enum class FunctionDescriptor : int32_t { 627 Invalid = HWC2_FUNCTION_INVALID, 628 AcceptDisplayChanges = HWC2_FUNCTION_ACCEPT_DISPLAY_CHANGES, 629 CreateLayer = HWC2_FUNCTION_CREATE_LAYER, 630 CreateVirtualDisplay = HWC2_FUNCTION_CREATE_VIRTUAL_DISPLAY, 631 DestroyLayer = HWC2_FUNCTION_DESTROY_LAYER, 632 DestroyVirtualDisplay = HWC2_FUNCTION_DESTROY_VIRTUAL_DISPLAY, 633 Dump = HWC2_FUNCTION_DUMP, 634 GetActiveConfig = HWC2_FUNCTION_GET_ACTIVE_CONFIG, 635 GetChangedCompositionTypes = HWC2_FUNCTION_GET_CHANGED_COMPOSITION_TYPES, 636 GetClientTargetSupport = HWC2_FUNCTION_GET_CLIENT_TARGET_SUPPORT, 637 GetColorModes = HWC2_FUNCTION_GET_COLOR_MODES, 638 GetDisplayAttribute = HWC2_FUNCTION_GET_DISPLAY_ATTRIBUTE, 639 GetDisplayConfigs = HWC2_FUNCTION_GET_DISPLAY_CONFIGS, 640 GetDisplayName = HWC2_FUNCTION_GET_DISPLAY_NAME, 641 GetDisplayRequests = HWC2_FUNCTION_GET_DISPLAY_REQUESTS, 642 GetDisplayType = HWC2_FUNCTION_GET_DISPLAY_TYPE, 643 GetDozeSupport = HWC2_FUNCTION_GET_DOZE_SUPPORT, 644 GetHdrCapabilities = HWC2_FUNCTION_GET_HDR_CAPABILITIES, 645 GetMaxVirtualDisplayCount = HWC2_FUNCTION_GET_MAX_VIRTUAL_DISPLAY_COUNT, 646 GetReleaseFences = HWC2_FUNCTION_GET_RELEASE_FENCES, 647 PresentDisplay = HWC2_FUNCTION_PRESENT_DISPLAY, 648 RegisterCallback = HWC2_FUNCTION_REGISTER_CALLBACK, 649 SetActiveConfig = HWC2_FUNCTION_SET_ACTIVE_CONFIG, 650 SetClientTarget = HWC2_FUNCTION_SET_CLIENT_TARGET, 651 SetColorMode = HWC2_FUNCTION_SET_COLOR_MODE, 652 SetColorTransform = HWC2_FUNCTION_SET_COLOR_TRANSFORM, 653 SetCursorPosition = HWC2_FUNCTION_SET_CURSOR_POSITION, 654 SetLayerBlendMode = HWC2_FUNCTION_SET_LAYER_BLEND_MODE, 655 SetLayerBuffer = HWC2_FUNCTION_SET_LAYER_BUFFER, 656 SetLayerColor = HWC2_FUNCTION_SET_LAYER_COLOR, 657 SetLayerCompositionType = HWC2_FUNCTION_SET_LAYER_COMPOSITION_TYPE, 658 SetLayerDataspace = HWC2_FUNCTION_SET_LAYER_DATASPACE, 659 SetLayerDisplayFrame = HWC2_FUNCTION_SET_LAYER_DISPLAY_FRAME, 660 SetLayerPlaneAlpha = HWC2_FUNCTION_SET_LAYER_PLANE_ALPHA, 661 SetLayerSidebandStream = HWC2_FUNCTION_SET_LAYER_SIDEBAND_STREAM, 662 SetLayerSourceCrop = HWC2_FUNCTION_SET_LAYER_SOURCE_CROP, 663 SetLayerSurfaceDamage = HWC2_FUNCTION_SET_LAYER_SURFACE_DAMAGE, 664 SetLayerTransform = HWC2_FUNCTION_SET_LAYER_TRANSFORM, 665 SetLayerVisibleRegion = HWC2_FUNCTION_SET_LAYER_VISIBLE_REGION, 666 SetLayerZOrder = HWC2_FUNCTION_SET_LAYER_Z_ORDER, 667 SetOutputBuffer = HWC2_FUNCTION_SET_OUTPUT_BUFFER, 668 SetPowerMode = HWC2_FUNCTION_SET_POWER_MODE, 669 SetVsyncEnabled = HWC2_FUNCTION_SET_VSYNC_ENABLED, 670 ValidateDisplay = HWC2_FUNCTION_VALIDATE_DISPLAY, 671 }; 672 TO_STRING(hwc2_function_descriptor_t, FunctionDescriptor, 673 getFunctionDescriptorName) 674 675 enum class LayerRequest : int32_t { 676 ClearClientTarget = HWC2_LAYER_REQUEST_CLEAR_CLIENT_TARGET, 677 }; 678 TO_STRING(hwc2_layer_request_t, LayerRequest, getLayerRequestName) 679 680 enum class PowerMode : int32_t { 681 Off = HWC2_POWER_MODE_OFF, 682 DozeSuspend = HWC2_POWER_MODE_DOZE_SUSPEND, 683 Doze = HWC2_POWER_MODE_DOZE, 684 On = HWC2_POWER_MODE_ON, 685 }; 686 TO_STRING(hwc2_power_mode_t, PowerMode, getPowerModeName) 687 688 enum class Transform : int32_t { 689 None = 0, 690 FlipH = HWC_TRANSFORM_FLIP_H, 691 FlipV = HWC_TRANSFORM_FLIP_V, 692 Rotate90 = HWC_TRANSFORM_ROT_90, 693 Rotate180 = HWC_TRANSFORM_ROT_180, 694 Rotate270 = HWC_TRANSFORM_ROT_270, 695 FlipHRotate90 = HWC_TRANSFORM_FLIP_H_ROT_90, 696 FlipVRotate90 = HWC_TRANSFORM_FLIP_V_ROT_90, 697 }; 698 TO_STRING(hwc_transform_t, Transform, getTransformName) 699 700 enum class Vsync : int32_t { 701 Invalid = HWC2_VSYNC_INVALID, 702 Enable = HWC2_VSYNC_ENABLE, 703 Disable = HWC2_VSYNC_DISABLE, 704 }; 705 TO_STRING(hwc2_vsync_t, Vsync, getVsyncName) 706 707 } // namespace HWC2 708 709 __BEGIN_DECLS 710 #endif // HWC2_USE_CPP11 711 712 /* 713 * Typedefs 714 */ 715 716 typedef void (*hwc2_function_pointer_t)(); 717 718 typedef void* hwc2_callback_data_t; 719 typedef uint32_t hwc2_config_t; 720 typedef uint64_t hwc2_display_t; 721 typedef uint64_t hwc2_layer_t; 722 723 /* 724 * Device Struct 725 */ 726 727 typedef struct hwc2_device { 728 /* Must be the first member of this struct, since a pointer to this struct 729 * will be generated by casting from a hw_device_t* */ 730 struct hw_device_t common; 731 732 /* getCapabilities(..., outCount, outCapabilities) 733 * 734 * Provides a list of capabilities (described in the definition of 735 * hwc2_capability_t above) supported by this device. This list must 736 * not change after the device has been loaded. 737 * 738 * Parameters: 739 * outCount - if outCapabilities was NULL, the number of capabilities 740 * which would have been returned; if outCapabilities was not NULL, 741 * the number of capabilities returned, which must not exceed the 742 * value stored in outCount prior to the call 743 * outCapabilities - a list of capabilities supported by this device; may 744 * be NULL, in which case this function must write into outCount the 745 * number of capabilities which would have been written into 746 * outCapabilities 747 */ 748 void (*getCapabilities)(struct hwc2_device* device, uint32_t* outCount, 749 int32_t* /*hwc2_capability_t*/ outCapabilities); 750 751 /* getFunction(..., descriptor) 752 * 753 * Returns a function pointer which implements the requested description. 754 * 755 * Parameters: 756 * descriptor - the function to return 757 * 758 * Returns either a function pointer implementing the requested descriptor 759 * or NULL if the described function is not supported by this device. 760 */ 761 hwc2_function_pointer_t (*getFunction)(struct hwc2_device* device, 762 int32_t /*hwc2_function_descriptor_t*/ descriptor); 763 } hwc2_device_t; 764 765 static inline int hwc2_open(const struct hw_module_t* module, 766 hwc2_device_t** device) { 767 return module->methods->open(module, HWC_HARDWARE_COMPOSER, 768 TO_HW_DEVICE_T_OPEN(device)); 769 } 770 771 static inline int hwc2_close(hwc2_device_t* device) { 772 return device->common.close(&device->common); 773 } 774 775 /* 776 * Callbacks 777 * 778 * All of these callbacks take as their first parameter the callbackData which 779 * was provided at the time of callback registration, so this parameter is 780 * omitted from the described parameter lists. 781 */ 782 783 /* hotplug(..., display, connected) 784 * Descriptor: HWC2_CALLBACK_HOTPLUG 785 * Will be provided to all HWC2 devices 786 * 787 * Notifies the client that the given display has either been connected or 788 * disconnected. Every active display (even a built-in physical display) must 789 * trigger at least one hotplug notification, even if it only occurs immediately 790 * after callback registration. 791 * 792 * The client may call back into the device on the same thread to query display 793 * properties (such as width, height, and vsync period), and other threads may 794 * call into the device while the callback is in progress. The device must 795 * serialize calls to this callback such that only one thread is calling it at a 796 * time. 797 * 798 * Displays which have been connected are assumed to be in HWC2_POWER_MODE_OFF, 799 * and the vsync callback should not be called for a display until vsync has 800 * been enabled with setVsyncEnabled. 801 * 802 * Parameters: 803 * display - the display which has been hotplugged 804 * connected - whether the display has been connected or disconnected 805 */ 806 typedef void (*HWC2_PFN_HOTPLUG)(hwc2_callback_data_t callbackData, 807 hwc2_display_t display, int32_t /*hwc2_connection_t*/ connected); 808 809 /* refresh(..., display) 810 * Descriptor: HWC2_CALLBACK_REFRESH 811 * Will be provided to all HWC2 devices 812 * 813 * Notifies the client to trigger a screen refresh. This forces all layer state 814 * for this display to be resent, and the display to be validated and presented, 815 * even if there have been no changes. 816 * 817 * This refresh will occur some time after the callback is initiated, but not 818 * necessarily before it returns. This thread, however, is guaranteed not to 819 * call back into the device, thus it is safe to trigger this callback from 820 * other functions which call into the device. 821 * 822 * Parameters: 823 * display - the display to refresh 824 */ 825 typedef void (*HWC2_PFN_REFRESH)(hwc2_callback_data_t callbackData, 826 hwc2_display_t display); 827 828 /* vsync(..., display, timestamp) 829 * Descriptor: HWC2_CALLBACK_VSYNC 830 * Will be provided to all HWC2 devices 831 * 832 * Notifies the client that a vsync event has occurred. This callback must 833 * only be triggered when vsync is enabled for this display (through 834 * setVsyncEnabled). 835 * 836 * This callback should be triggered from a thread of at least 837 * HAL_PRIORITY_URGENT_DISPLAY with as little latency as possible, typically 838 * less than 0.5 ms. This thread is guaranteed not to call back into the device. 839 * 840 * Parameters: 841 * display - the display which has received a vsync event 842 * timestamp - the CLOCK_MONOTONIC time at which the vsync event occurred, in 843 * nanoseconds 844 */ 845 typedef void (*HWC2_PFN_VSYNC)(hwc2_callback_data_t callbackData, 846 hwc2_display_t display, int64_t timestamp); 847 848 /* 849 * Device Functions 850 * 851 * All of these functions take as their first parameter a device pointer, so 852 * this parameter is omitted from the described parameter lists. 853 */ 854 855 /* createVirtualDisplay(..., width, height, format, outDisplay) 856 * Descriptor: HWC2_FUNCTION_CREATE_VIRTUAL_DISPLAY 857 * Must be provided by all HWC2 devices 858 * 859 * Creates a new virtual display with the given width and height. The format 860 * passed into this function is the default format requested by the consumer of 861 * the virtual display output buffers. If a different format will be returned by 862 * the device, it should be returned in this parameter so it can be set properly 863 * when handing the buffers to the consumer. 864 * 865 * The display will be assumed to be on from the time the first frame is 866 * presented until the display is destroyed. 867 * 868 * Parameters: 869 * width - width in pixels 870 * height - height in pixels 871 * format - prior to the call, the default output buffer format selected by 872 * the consumer; after the call, the format the device will produce 873 * outDisplay - the newly-created virtual display; pointer will be non-NULL 874 * 875 * Returns HWC2_ERROR_NONE or one of the following errors: 876 * HWC2_ERROR_UNSUPPORTED - the width or height is too large for the device to 877 * be able to create a virtual display 878 * HWC2_ERROR_NO_RESOURCES - the device is unable to create a new virtual 879 * display at this time 880 */ 881 typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_CREATE_VIRTUAL_DISPLAY)( 882 hwc2_device_t* device, uint32_t width, uint32_t height, 883 int32_t* /*android_pixel_format_t*/ format, hwc2_display_t* outDisplay); 884 885 /* destroyVirtualDisplay(..., display) 886 * Descriptor: HWC2_FUNCTION_DESTROY_VIRTUAL_DISPLAY 887 * Must be provided by all HWC2 devices 888 * 889 * Destroys a virtual display. After this call all resources consumed by this 890 * display may be freed by the device and any operations performed on this 891 * display should fail. 892 * 893 * Parameters: 894 * display - the virtual display to destroy 895 * 896 * Returns HWC2_ERROR_NONE or one of the following errors: 897 * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in 898 * HWC2_ERROR_BAD_PARAMETER - the display handle which was passed in does not 899 * refer to a virtual display 900 */ 901 typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_DESTROY_VIRTUAL_DISPLAY)( 902 hwc2_device_t* device, hwc2_display_t display); 903 904 /* dump(..., outSize, outBuffer) 905 * Descriptor: HWC2_FUNCTION_DUMP 906 * Must be provided by all HWC2 devices 907 * 908 * Retrieves implementation-defined debug information, which will be displayed 909 * during, for example, `dumpsys SurfaceFlinger`. 910 * 911 * If called with outBuffer == NULL, the device should store a copy of the 912 * desired output and return its length in bytes in outSize. If the device 913 * already has a stored copy, that copy should be purged and replaced with a 914 * fresh copy. 915 * 916 * If called with outBuffer != NULL, the device should copy its stored version 917 * of the output into outBuffer and store how many bytes of data it copied into 918 * outSize. Prior to this call, the client will have populated outSize with the 919 * maximum number of bytes outBuffer can hold. The device must not write more 920 * than this amount into outBuffer. If the device does not currently have a 921 * stored copy, then it should return 0 in outSize. 922 * 923 * Any data written into outBuffer need not be null-terminated. 924 * 925 * Parameters: 926 * outSize - if outBuffer was NULL, the number of bytes needed to copy the 927 * device's stored output; if outBuffer was not NULL, the number of bytes 928 * written into it, which must not exceed the value stored in outSize 929 * prior to the call; pointer will be non-NULL 930 * outBuffer - the buffer to write the dump output into; may be NULL as 931 * described above; data written into this buffer need not be 932 * null-terminated 933 */ 934 typedef void (*HWC2_PFN_DUMP)(hwc2_device_t* device, uint32_t* outSize, 935 char* outBuffer); 936 937 /* getMaxVirtualDisplayCount(...) 938 * Descriptor: HWC2_FUNCTION_GET_MAX_VIRTUAL_DISPLAY_COUNT 939 * Must be provided by all HWC2 devices 940 * 941 * Returns the maximum number of virtual displays supported by this device 942 * (which may be 0). The client will not attempt to create more than this many 943 * virtual displays on this device. This number must not change for the lifetime 944 * of the device. 945 */ 946 typedef uint32_t (*HWC2_PFN_GET_MAX_VIRTUAL_DISPLAY_COUNT)( 947 hwc2_device_t* device); 948 949 /* registerCallback(..., descriptor, callbackData, pointer) 950 * Descriptor: HWC2_FUNCTION_REGISTER_CALLBACK 951 * Must be provided by all HWC2 devices 952 * 953 * Provides a callback for the device to call. All callbacks take a callbackData 954 * item as the first parameter, so this value should be stored with the callback 955 * for later use. The callbackData may differ from one callback to another. If 956 * this function is called multiple times with the same descriptor, later 957 * callbacks replace earlier ones. 958 * 959 * Parameters: 960 * descriptor - which callback should be set 961 * callBackdata - opaque data which must be passed back through the callback 962 * pointer - a non-NULL function pointer corresponding to the descriptor 963 * 964 * Returns HWC2_ERROR_NONE or one of the following errors: 965 * HWC2_ERROR_BAD_PARAMETER - descriptor was invalid 966 */ 967 typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_REGISTER_CALLBACK)( 968 hwc2_device_t* device, 969 int32_t /*hwc2_callback_descriptor_t*/ descriptor, 970 hwc2_callback_data_t callbackData, hwc2_function_pointer_t pointer); 971 972 /* 973 * Display Functions 974 * 975 * All of these functions take as their first two parameters a device pointer 976 * and a display handle, so these parameters are omitted from the described 977 * parameter lists. 978 */ 979 980 /* acceptDisplayChanges(...) 981 * Descriptor: HWC2_FUNCTION_ACCEPT_DISPLAY_CHANGES 982 * Must be provided by all HWC2 devices 983 * 984 * Accepts the changes required by the device from the previous validateDisplay 985 * call (which may be queried using getChangedCompositionTypes) and revalidates 986 * the display. This function is equivalent to requesting the changed types from 987 * getChangedCompositionTypes, setting those types on the corresponding layers, 988 * and then calling validateDisplay again. 989 * 990 * After this call it must be valid to present this display. Calling this after 991 * validateDisplay returns 0 changes must succeed with HWC2_ERROR_NONE, but 992 * should have no other effect. 993 * 994 * Returns HWC2_ERROR_NONE or one of the following errors: 995 * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in 996 * HWC2_ERROR_NOT_VALIDATED - validateDisplay has not been called 997 */ 998 typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_ACCEPT_DISPLAY_CHANGES)( 999 hwc2_device_t* device, hwc2_display_t display); 1000 1001 /* createLayer(..., outLayer) 1002 * Descriptor: HWC2_FUNCTION_CREATE_LAYER 1003 * Must be provided by all HWC2 devices 1004 * 1005 * Creates a new layer on the given display. 1006 * 1007 * Parameters: 1008 * outLayer - the handle of the new layer; pointer will be non-NULL 1009 * 1010 * Returns HWC2_ERROR_NONE or one of the following errors: 1011 * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in 1012 * HWC2_ERROR_NO_RESOURCES - the device was unable to create this layer 1013 */ 1014 typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_CREATE_LAYER)(hwc2_device_t* device, 1015 hwc2_display_t display, hwc2_layer_t* outLayer); 1016 1017 /* destroyLayer(..., layer) 1018 * Descriptor: HWC2_FUNCTION_DESTROY_LAYER 1019 * Must be provided by all HWC2 devices 1020 * 1021 * Destroys the given layer. 1022 * 1023 * Parameters: 1024 * layer - the handle of the layer to destroy 1025 * 1026 * Returns HWC2_ERROR_NONE or one of the following errors: 1027 * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in 1028 * HWC2_ERROR_BAD_LAYER - an invalid layer handle was passed in 1029 */ 1030 typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_DESTROY_LAYER)( 1031 hwc2_device_t* device, hwc2_display_t display, hwc2_layer_t layer); 1032 1033 /* getActiveConfig(..., outConfig) 1034 * Descriptor: HWC2_FUNCTION_GET_ACTIVE_CONFIG 1035 * Must be provided by all HWC2 devices 1036 * 1037 * Retrieves which display configuration is currently active. 1038 * 1039 * If no display configuration is currently active, this function must return 1040 * HWC2_ERROR_BAD_CONFIG and place no configuration handle in outConfig. It is 1041 * the responsibility of the client to call setActiveConfig with a valid 1042 * configuration before attempting to present anything on the display. 1043 * 1044 * Parameters: 1045 * outConfig - the currently active display configuration; pointer will be 1046 * non-NULL 1047 * 1048 * Returns HWC2_ERROR_NONE or one of the following errors: 1049 * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in 1050 * HWC2_ERROR_BAD_CONFIG - no configuration is currently active 1051 */ 1052 typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_GET_ACTIVE_CONFIG)( 1053 hwc2_device_t* device, hwc2_display_t display, 1054 hwc2_config_t* outConfig); 1055 1056 /* getChangedCompositionTypes(..., outNumElements, outLayers, outTypes) 1057 * Descriptor: HWC2_FUNCTION_GET_CHANGED_COMPOSITION_TYPES 1058 * Must be provided by all HWC2 devices 1059 * 1060 * Retrieves the layers for which the device requires a different composition 1061 * type than had been set prior to the last call to validateDisplay. The client 1062 * will either update its state with these types and call acceptDisplayChanges, 1063 * or will set new types and attempt to validate the display again. 1064 * 1065 * outLayers and outTypes may be NULL to retrieve the number of elements which 1066 * will be returned. The number of elements returned must be the same as the 1067 * value returned in outNumTypes from the last call to validateDisplay. 1068 * 1069 * Parameters: 1070 * outNumElements - if outLayers or outTypes were NULL, the number of layers 1071 * and types which would have been returned; if both were non-NULL, the 1072 * number of elements returned in outLayers and outTypes, which must not 1073 * exceed the value stored in outNumElements prior to the call; pointer 1074 * will be non-NULL 1075 * outLayers - an array of layer handles 1076 * outTypes - an array of composition types, each corresponding to an element 1077 * of outLayers 1078 * 1079 * Returns HWC2_ERROR_NONE or one of the following errors: 1080 * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in 1081 * HWC2_ERROR_NOT_VALIDATED - validateDisplay has not been called for this 1082 * display 1083 */ 1084 typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_GET_CHANGED_COMPOSITION_TYPES)( 1085 hwc2_device_t* device, hwc2_display_t display, 1086 uint32_t* outNumElements, hwc2_layer_t* outLayers, 1087 int32_t* /*hwc2_composition_t*/ outTypes); 1088 1089 /* getClientTargetSupport(..., width, height, format, dataspace) 1090 * Descriptor: HWC2_FUNCTION_GET_CLIENT_TARGET_SUPPORT 1091 * Must be provided by all HWC2 devices 1092 * 1093 * Returns whether a client target with the given properties can be handled by 1094 * the device. 1095 * 1096 * The valid formats can be found in android_pixel_format_t in 1097 * <system/graphics.h>. 1098 * 1099 * For more about dataspaces, see setLayerDataspace. 1100 * 1101 * This function must return true for a client target with width and height 1102 * equal to the active display configuration dimensions, 1103 * HAL_PIXEL_FORMAT_RGBA_8888, and HAL_DATASPACE_UNKNOWN. It is not required to 1104 * return true for any other configuration. 1105 * 1106 * Parameters: 1107 * width - client target width in pixels 1108 * height - client target height in pixels 1109 * format - client target format 1110 * dataspace - client target dataspace, as described in setLayerDataspace 1111 * 1112 * Returns HWC2_ERROR_NONE if the given configuration is supported or one of the 1113 * following errors: 1114 * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in 1115 * HWC2_ERROR_UNSUPPORTED - the given configuration is not supported 1116 */ 1117 typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_GET_CLIENT_TARGET_SUPPORT)( 1118 hwc2_device_t* device, hwc2_display_t display, uint32_t width, 1119 uint32_t height, int32_t /*android_pixel_format_t*/ format, 1120 int32_t /*android_dataspace_t*/ dataspace); 1121 1122 /* getColorModes(..., outNumModes, outModes) 1123 * Descriptor: HWC2_FUNCTION_GET_COLOR_MODES 1124 * Must be provided by all HWC2 devices 1125 * 1126 * Returns the color modes supported on this display. 1127 * 1128 * The valid color modes can be found in android_color_mode_t in 1129 * <system/graphics.h>. All HWC2 devices must support at least 1130 * HAL_COLOR_MODE_NATIVE. 1131 * 1132 * outNumModes may be NULL to retrieve the number of modes which will be 1133 * returned. 1134 * 1135 * Parameters: 1136 * outNumModes - if outModes was NULL, the number of modes which would have 1137 * been returned; if outModes was not NULL, the number of modes returned, 1138 * which must not exceed the value stored in outNumModes prior to the 1139 * call; pointer will be non-NULL 1140 * outModes - an array of color modes 1141 * 1142 * Returns HWC2_ERROR_NONE or one of the following errors: 1143 * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in 1144 */ 1145 typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_GET_COLOR_MODES)( 1146 hwc2_device_t* device, hwc2_display_t display, uint32_t* outNumModes, 1147 int32_t* /*android_color_mode_t*/ outModes); 1148 1149 /* getDisplayAttribute(..., config, attribute, outValue) 1150 * Descriptor: HWC2_FUNCTION_GET_DISPLAY_ATTRIBUTE 1151 * Must be provided by all HWC2 devices 1152 * 1153 * Returns a display attribute value for a particular display configuration. 1154 * 1155 * Any attribute which is not supported or for which the value is unknown by the 1156 * device must return a value of -1. 1157 * 1158 * Parameters: 1159 * config - the display configuration for which to return attribute values 1160 * attribute - the attribute to query 1161 * outValue - the value of the attribute; the pointer will be non-NULL 1162 * 1163 * Returns HWC2_ERROR_NONE or one of the following errors: 1164 * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in 1165 * HWC2_ERROR_BAD_CONFIG - config does not name a valid configuration for this 1166 * display 1167 */ 1168 typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_GET_DISPLAY_ATTRIBUTE)( 1169 hwc2_device_t* device, hwc2_display_t display, hwc2_config_t config, 1170 int32_t /*hwc2_attribute_t*/ attribute, int32_t* outValue); 1171 1172 /* getDisplayConfigs(..., outNumConfigs, outConfigs) 1173 * Descriptor: HWC2_FUNCTION_GET_DISPLAY_CONFIGS 1174 * Must be provided by all HWC2 devices 1175 * 1176 * Returns handles for all of the valid display configurations on this display. 1177 * 1178 * outConfigs may be NULL to retrieve the number of elements which will be 1179 * returned. 1180 * 1181 * Parameters: 1182 * outNumConfigs - if outConfigs was NULL, the number of configurations which 1183 * would have been returned; if outConfigs was not NULL, the number of 1184 * configurations returned, which must not exceed the value stored in 1185 * outNumConfigs prior to the call; pointer will be non-NULL 1186 * outConfigs - an array of configuration handles 1187 * 1188 * Returns HWC2_ERROR_NONE or one of the following errors: 1189 * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in 1190 */ 1191 typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_GET_DISPLAY_CONFIGS)( 1192 hwc2_device_t* device, hwc2_display_t display, uint32_t* outNumConfigs, 1193 hwc2_config_t* outConfigs); 1194 1195 /* getDisplayName(..., outSize, outName) 1196 * Descriptor: HWC2_FUNCTION_GET_DISPLAY_NAME 1197 * Must be provided by all HWC2 devices 1198 * 1199 * Returns a human-readable version of the display's name. 1200 * 1201 * outName may be NULL to retrieve the length of the name. 1202 * 1203 * Parameters: 1204 * outSize - if outName was NULL, the number of bytes needed to return the 1205 * name if outName was not NULL, the number of bytes written into it, 1206 * which must not exceed the value stored in outSize prior to the call; 1207 * pointer will be non-NULL 1208 * outName - the display's name 1209 * 1210 * Returns HWC2_ERROR_NONE or one of the following errors: 1211 * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in 1212 */ 1213 typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_GET_DISPLAY_NAME)( 1214 hwc2_device_t* device, hwc2_display_t display, uint32_t* outSize, 1215 char* outName); 1216 1217 /* getDisplayRequests(..., outDisplayRequests, outNumElements, outLayers, 1218 * outLayerRequests) 1219 * Descriptor: HWC2_FUNCTION_GET_DISPLAY_REQUESTS 1220 * Must be provided by all HWC2 devices 1221 * 1222 * Returns the display requests and the layer requests required for the last 1223 * validated configuration. 1224 * 1225 * Display requests provide information about how the client should handle the 1226 * client target. Layer requests provide information about how the client 1227 * should handle an individual layer. 1228 * 1229 * If outLayers or outLayerRequests is NULL, the required number of layers and 1230 * requests must be returned in outNumElements, but this number may also be 1231 * obtained from validateDisplay as outNumRequests (outNumElements must be equal 1232 * to the value returned in outNumRequests from the last call to 1233 * validateDisplay). 1234 * 1235 * Parameters: 1236 * outDisplayRequests - the display requests for the current validated state 1237 * outNumElements - if outLayers or outLayerRequests were NULL, the number of 1238 * elements which would have been returned, which must be equal to the 1239 * value returned in outNumRequests from the last validateDisplay call on 1240 * this display; if both were not NULL, the number of elements in 1241 * outLayers and outLayerRequests, which must not exceed the value stored 1242 * in outNumElements prior to the call; pointer will be non-NULL 1243 * outLayers - an array of layers which all have at least one request 1244 * outLayerRequests - the requests corresponding to each element of outLayers 1245 * 1246 * Returns HWC2_ERROR_NONE or one of the following errors: 1247 * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in 1248 * HWC2_ERROR_NOT_VALIDATED - validateDisplay has not been called for this 1249 * display 1250 */ 1251 typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_GET_DISPLAY_REQUESTS)( 1252 hwc2_device_t* device, hwc2_display_t display, 1253 int32_t* /*hwc2_display_request_t*/ outDisplayRequests, 1254 uint32_t* outNumElements, hwc2_layer_t* outLayers, 1255 int32_t* /*hwc2_layer_request_t*/ outLayerRequests); 1256 1257 /* getDisplayType(..., outType) 1258 * Descriptor: HWC2_FUNCTION_GET_DISPLAY_TYPE 1259 * Must be provided by all HWC2 devices 1260 * 1261 * Returns whether the given display is a physical or virtual display. 1262 * 1263 * Parameters: 1264 * outType - the type of the display; pointer will be non-NULL 1265 * 1266 * Returns HWC2_ERROR_NONE or one of the following errors: 1267 * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in 1268 */ 1269 typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_GET_DISPLAY_TYPE)( 1270 hwc2_device_t* device, hwc2_display_t display, 1271 int32_t* /*hwc2_display_type_t*/ outType); 1272 1273 /* getDozeSupport(..., outSupport) 1274 * Descriptor: HWC2_FUNCTION_GET_DOZE_SUPPORT 1275 * Must be provided by all HWC2 devices 1276 * 1277 * Returns whether the given display supports HWC2_POWER_MODE_DOZE and 1278 * HWC2_POWER_MODE_DOZE_SUSPEND. DOZE_SUSPEND may not provide any benefit over 1279 * DOZE (see the definition of hwc2_power_mode_t for more information), but if 1280 * both DOZE and DOZE_SUSPEND are no different from HWC2_POWER_MODE_ON, the 1281 * device should not claim support. 1282 * 1283 * Parameters: 1284 * outSupport - whether the display supports doze modes (1 for yes, 0 for no); 1285 * pointer will be non-NULL 1286 * 1287 * Returns HWC2_ERROR_NONE or one of the following errors: 1288 * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in 1289 */ 1290 typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_GET_DOZE_SUPPORT)( 1291 hwc2_device_t* device, hwc2_display_t display, int32_t* outSupport); 1292 1293 /* getHdrCapabilities(..., outNumTypes, outTypes, outMaxLuminance, 1294 * outMaxAverageLuminance, outMinLuminance) 1295 * Descriptor: HWC2_FUNCTION_GET_HDR_CAPABILITIES 1296 * Must be provided by all HWC2 devices 1297 * 1298 * Returns the high dynamic range (HDR) capabilities of the given display, which 1299 * are invariant with regard to the active configuration. 1300 * 1301 * Displays which are not HDR-capable must return no types in outTypes and set 1302 * outNumTypes to 0. 1303 * 1304 * If outTypes is NULL, the required number of HDR types must be returned in 1305 * outNumTypes. 1306 * 1307 * Parameters: 1308 * outNumTypes - if outTypes was NULL, the number of types which would have 1309 * been returned; if it was not NULL, the number of types stored in 1310 * outTypes, which must not exceed the value stored in outNumTypes prior 1311 * to the call; pointer will be non-NULL 1312 * outTypes - an array of HDR types, may have 0 elements if the display is not 1313 * HDR-capable 1314 * outMaxLuminance - the desired content maximum luminance for this display in 1315 * cd/m^2; pointer will be non-NULL 1316 * outMaxAverageLuminance - the desired content maximum frame-average 1317 * luminance for this display in cd/m^2; pointer will be non-NULL 1318 * outMinLuminance - the desired content minimum luminance for this display in 1319 * cd/m^2; pointer will be non-NULL 1320 * 1321 * Returns HWC2_ERROR_NONE or one of the following errors: 1322 * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in 1323 */ 1324 typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_GET_HDR_CAPABILITIES)( 1325 hwc2_device_t* device, hwc2_display_t display, uint32_t* outNumTypes, 1326 int32_t* /*android_hdr_t*/ outTypes, float* outMaxLuminance, 1327 float* outMaxAverageLuminance, float* outMinLuminance); 1328 1329 /* getReleaseFences(..., outNumElements, outLayers, outFences) 1330 * Descriptor: HWC2_FUNCTION_GET_RELEASE_FENCES 1331 * Must be provided by all HWC2 devices 1332 * 1333 * Retrieves the release fences for device layers on this display which will 1334 * receive new buffer contents this frame. 1335 * 1336 * A release fence is a file descriptor referring to a sync fence object which 1337 * will be signaled after the device has finished reading from the buffer 1338 * presented in the prior frame. This indicates that it is safe to start writing 1339 * to the buffer again. If a given layer's fence is not returned from this 1340 * function, it will be assumed that the buffer presented on the previous frame 1341 * is ready to be written. 1342 * 1343 * The fences returned by this function should be unique for each layer (even if 1344 * they point to the same underlying sync object), and ownership of the fences 1345 * is transferred to the client, which is responsible for closing them. 1346 * 1347 * If outLayers or outFences is NULL, the required number of layers and fences 1348 * must be returned in outNumElements. 1349 * 1350 * Parameters: 1351 * outNumElements - if outLayers or outFences were NULL, the number of 1352 * elements which would have been returned; if both were not NULL, the 1353 * number of elements in outLayers and outFences, which must not exceed 1354 * the value stored in outNumElements prior to the call; pointer will be 1355 * non-NULL 1356 * outLayers - an array of layer handles 1357 * outFences - an array of sync fence file descriptors as described above, 1358 * each corresponding to an element of outLayers 1359 * 1360 * Returns HWC2_ERROR_NONE or one of the following errors: 1361 * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in 1362 */ 1363 typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_GET_RELEASE_FENCES)( 1364 hwc2_device_t* device, hwc2_display_t display, uint32_t* outNumElements, 1365 hwc2_layer_t* outLayers, int32_t* outFences); 1366 1367 /* presentDisplay(..., outPresentFence) 1368 * Descriptor: HWC2_FUNCTION_PRESENT_DISPLAY 1369 * Must be provided by all HWC2 devices 1370 * 1371 * Presents the current display contents on the screen (or in the case of 1372 * virtual displays, into the output buffer). 1373 * 1374 * Prior to calling this function, the display must be successfully validated 1375 * with validateDisplay. Note that setLayerBuffer and setLayerSurfaceDamage 1376 * specifically do not count as layer state, so if there are no other changes 1377 * to the layer state (or to the buffer's properties as described in 1378 * setLayerBuffer), then it is safe to call this function without first 1379 * validating the display. 1380 * 1381 * If this call succeeds, outPresentFence will be populated with a file 1382 * descriptor referring to a present sync fence object. For physical displays, 1383 * this fence will be signaled at the vsync when the result of composition of 1384 * this frame starts to appear (for video-mode panels) or starts to transfer to 1385 * panel memory (for command-mode panels). For virtual displays, this fence will 1386 * be signaled when writes to the output buffer have completed and it is safe to 1387 * read from it. 1388 * 1389 * Parameters: 1390 * outPresentFence - a sync fence file descriptor as described above; pointer 1391 * will be non-NULL 1392 * 1393 * Returns HWC2_ERROR_NONE or one of the following errors: 1394 * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in 1395 * HWC2_ERROR_NO_RESOURCES - no valid output buffer has been set for a virtual 1396 * display 1397 * HWC2_ERROR_NOT_VALIDATED - validateDisplay has not successfully been called 1398 * for this display 1399 */ 1400 typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_PRESENT_DISPLAY)( 1401 hwc2_device_t* device, hwc2_display_t display, 1402 int32_t* outPresentFence); 1403 1404 /* setActiveConfig(..., config) 1405 * Descriptor: HWC2_FUNCTION_SET_ACTIVE_CONFIG 1406 * Must be provided by all HWC2 devices 1407 * 1408 * Sets the active configuration for this display. Upon returning, the given 1409 * display configuration should be active and remain so until either this 1410 * function is called again or the display is disconnected. 1411 * 1412 * Parameters: 1413 * config - the new display configuration 1414 * 1415 * Returns HWC2_ERROR_NONE or one of the following errors: 1416 * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in 1417 * HWC2_ERROR_BAD_CONFIG - the configuration handle passed in is not valid for 1418 * this display 1419 */ 1420 typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_ACTIVE_CONFIG)( 1421 hwc2_device_t* device, hwc2_display_t display, hwc2_config_t config); 1422 1423 /* setClientTarget(..., target, acquireFence, dataspace, damage) 1424 * Descriptor: HWC2_FUNCTION_SET_CLIENT_TARGET 1425 * Must be provided by all HWC2 devices 1426 * 1427 * Sets the buffer handle which will receive the output of client composition. 1428 * Layers marked as HWC2_COMPOSITION_CLIENT will be composited into this buffer 1429 * prior to the call to presentDisplay, and layers not marked as 1430 * HWC2_COMPOSITION_CLIENT should be composited with this buffer by the device. 1431 * 1432 * The buffer handle provided may be null if no layers are being composited by 1433 * the client. This must not result in an error (unless an invalid display 1434 * handle is also provided). 1435 * 1436 * Also provides a file descriptor referring to an acquire sync fence object, 1437 * which will be signaled when it is safe to read from the client target buffer. 1438 * If it is already safe to read from this buffer, -1 may be passed instead. 1439 * The device must ensure that it is safe for the client to close this file 1440 * descriptor at any point after this function is called. 1441 * 1442 * For more about dataspaces, see setLayerDataspace. 1443 * 1444 * The damage parameter describes a surface damage region as defined in the 1445 * description of setLayerSurfaceDamage. 1446 * 1447 * Will be called before presentDisplay if any of the layers are marked as 1448 * HWC2_COMPOSITION_CLIENT. If no layers are so marked, then it is not 1449 * necessary to call this function. It is not necessary to call validateDisplay 1450 * after changing the target through this function. 1451 * 1452 * Parameters: 1453 * target - the new target buffer 1454 * acquireFence - a sync fence file descriptor as described above 1455 * dataspace - the dataspace of the buffer, as described in setLayerDataspace 1456 * damage - the surface damage region 1457 * 1458 * Returns HWC2_ERROR_NONE or one of the following errors: 1459 * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in 1460 * HWC2_ERROR_BAD_PARAMETER - the new target handle was invalid 1461 */ 1462 typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_CLIENT_TARGET)( 1463 hwc2_device_t* device, hwc2_display_t display, buffer_handle_t target, 1464 int32_t acquireFence, int32_t /*android_dataspace_t*/ dataspace, 1465 hwc_region_t damage); 1466 1467 /* setColorMode(..., mode) 1468 * Descriptor: HWC2_FUNCTION_SET_COLOR_MODE 1469 * Must be provided by all HWC2 devices 1470 * 1471 * Sets the color mode of the given display. 1472 * 1473 * Upon returning from this function, the color mode change must have fully 1474 * taken effect. 1475 * 1476 * The valid color modes can be found in android_color_mode_t in 1477 * <system/graphics.h>. All HWC2 devices must support at least 1478 * HAL_COLOR_MODE_NATIVE, and displays are assumed to be in this mode upon 1479 * hotplug. 1480 * 1481 * Parameters: 1482 * mode - the mode to set 1483 * 1484 * Returns HWC2_ERROR_NONE or one of the following errors: 1485 * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in 1486 * HWC2_ERROR_BAD_PARAMETER - mode is not a valid color mode 1487 * HWC2_ERROR_UNSUPPORTED - mode is not supported on this display 1488 */ 1489 typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_COLOR_MODE)( 1490 hwc2_device_t* device, hwc2_display_t display, 1491 int32_t /*android_color_mode_t*/ mode); 1492 1493 /* setColorTransform(..., matrix, hint) 1494 * Descriptor: HWC2_FUNCTION_SET_COLOR_TRANSFORM 1495 * Must be provided by all HWC2 devices 1496 * 1497 * Sets a color transform which will be applied after composition. 1498 * 1499 * If hint is not HAL_COLOR_TRANSFORM_ARBITRARY, then the device may use the 1500 * hint to apply the desired color transform instead of using the color matrix 1501 * directly. 1502 * 1503 * If the device is not capable of either using the hint or the matrix to apply 1504 * the desired color transform, it should force all layers to client composition 1505 * during validateDisplay. 1506 * 1507 * If HWC2_CAPABILITY_SKIP_CLIENT_COLOR_TRANSFORM is present, then the client 1508 * will never apply the color transform during client composition, even if all 1509 * layers are being composed by the client. 1510 * 1511 * The matrix provided is an affine color transformation of the following form: 1512 * 1513 * |r.r r.g r.b 0| 1514 * |g.r g.g g.b 0| 1515 * |b.r b.g b.b 0| 1516 * |Tr Tg Tb 1| 1517 * 1518 * This matrix will be provided in row-major form: {r.r, r.g, r.b, 0, g.r, ...}. 1519 * 1520 * Given a matrix of this form and an input color [R_in, G_in, B_in], the output 1521 * color [R_out, G_out, B_out] will be: 1522 * 1523 * R_out = R_in * r.r + G_in * g.r + B_in * b.r + Tr 1524 * G_out = R_in * r.g + G_in * g.g + B_in * b.g + Tg 1525 * B_out = R_in * r.b + G_in * g.b + B_in * b.b + Tb 1526 * 1527 * Parameters: 1528 * matrix - a 4x4 transform matrix (16 floats) as described above 1529 * hint - a hint value which may be used instead of the given matrix unless it 1530 * is HAL_COLOR_TRANSFORM_ARBITRARY 1531 * 1532 * Returns HWC2_ERROR_NONE or one of the following errors: 1533 * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in 1534 * HWC2_ERROR_BAD_PARAMETER - hint is not a valid color transform hint 1535 */ 1536 typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_COLOR_TRANSFORM)( 1537 hwc2_device_t* device, hwc2_display_t display, const float* matrix, 1538 int32_t /*android_color_transform_t*/ hint); 1539 1540 /* setOutputBuffer(..., buffer, releaseFence) 1541 * Descriptor: HWC2_FUNCTION_SET_OUTPUT_BUFFER 1542 * Must be provided by all HWC2 devices 1543 * 1544 * Sets the output buffer for a virtual display. That is, the buffer to which 1545 * the composition result will be written. 1546 * 1547 * Also provides a file descriptor referring to a release sync fence object, 1548 * which will be signaled when it is safe to write to the output buffer. If it 1549 * is already safe to write to the output buffer, -1 may be passed instead. The 1550 * device must ensure that it is safe for the client to close this file 1551 * descriptor at any point after this function is called. 1552 * 1553 * Must be called at least once before presentDisplay, but does not have any 1554 * interaction with layer state or display validation. 1555 * 1556 * Parameters: 1557 * buffer - the new output buffer 1558 * releaseFence - a sync fence file descriptor as described above 1559 * 1560 * Returns HWC2_ERROR_NONE or one of the following errors: 1561 * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in 1562 * HWC2_ERROR_BAD_PARAMETER - the new output buffer handle was invalid 1563 * HWC2_ERROR_UNSUPPORTED - display does not refer to a virtual display 1564 */ 1565 typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_OUTPUT_BUFFER)( 1566 hwc2_device_t* device, hwc2_display_t display, buffer_handle_t buffer, 1567 int32_t releaseFence); 1568 1569 /* setPowerMode(..., mode) 1570 * Descriptor: HWC2_FUNCTION_SET_POWER_MODE 1571 * Must be provided by all HWC2 devices 1572 * 1573 * Sets the power mode of the given display. The transition must be complete 1574 * when this function returns. It is valid to call this function multiple times 1575 * with the same power mode. 1576 * 1577 * All displays must support HWC2_POWER_MODE_ON and HWC2_POWER_MODE_OFF. Whether 1578 * a display supports HWC2_POWER_MODE_DOZE or HWC2_POWER_MODE_DOZE_SUSPEND may 1579 * be queried using getDozeSupport. 1580 * 1581 * Parameters: 1582 * mode - the new power mode 1583 * 1584 * Returns HWC2_ERROR_NONE or one of the following errors: 1585 * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in 1586 * HWC2_ERROR_BAD_PARAMETER - mode was not a valid power mode 1587 * HWC2_ERROR_UNSUPPORTED - mode was a valid power mode, but is not supported 1588 * on this display 1589 */ 1590 typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_POWER_MODE)( 1591 hwc2_device_t* device, hwc2_display_t display, 1592 int32_t /*hwc2_power_mode_t*/ mode); 1593 1594 /* setVsyncEnabled(..., enabled) 1595 * Descriptor: HWC2_FUNCTION_SET_VSYNC_ENABLED 1596 * Must be provided by all HWC2 devices 1597 * 1598 * Enables or disables the vsync signal for the given display. Virtual displays 1599 * never generate vsync callbacks, and any attempt to enable vsync for a virtual 1600 * display though this function must return HWC2_ERROR_NONE and have no other 1601 * effect. 1602 * 1603 * Parameters: 1604 * enabled - whether to enable or disable vsync 1605 * 1606 * Returns HWC2_ERROR_NONE or one of the following errors: 1607 * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in 1608 * HWC2_ERROR_BAD_PARAMETER - enabled was an invalid value 1609 */ 1610 typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_VSYNC_ENABLED)( 1611 hwc2_device_t* device, hwc2_display_t display, 1612 int32_t /*hwc2_vsync_t*/ enabled); 1613 1614 /* validateDisplay(..., outNumTypes, outNumRequests) 1615 * Descriptor: HWC2_FUNCTION_VALIDATE_DISPLAY 1616 * Must be provided by all HWC2 devices 1617 * 1618 * Instructs the device to inspect all of the layer state and determine if 1619 * there are any composition type changes necessary before presenting the 1620 * display. Permitted changes are described in the definition of 1621 * hwc2_composition_t above. 1622 * 1623 * Also returns the number of layer requests required 1624 * by the given layer configuration. 1625 * 1626 * Parameters: 1627 * outNumTypes - the number of composition type changes required by the 1628 * device; if greater than 0, the client must either set and validate new 1629 * types, or call acceptDisplayChanges to accept the changes returned by 1630 * getChangedCompositionTypes; must be the same as the number of changes 1631 * returned by getChangedCompositionTypes (see the declaration of that 1632 * function for more information); pointer will be non-NULL 1633 * outNumRequests - the number of layer requests required by this layer 1634 * configuration; must be equal to the number of layer requests returned 1635 * by getDisplayRequests (see the declaration of that function for 1636 * more information); pointer will be non-NULL 1637 * 1638 * Returns HWC2_ERROR_NONE if no changes are necessary and it is safe to present 1639 * the display using the current layer state. Otherwise returns one of the 1640 * following errors: 1641 * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in 1642 * HWC2_ERROR_HAS_CHANGES - outNumTypes was greater than 0 (see parameter list 1643 * for more information) 1644 */ 1645 typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_VALIDATE_DISPLAY)( 1646 hwc2_device_t* device, hwc2_display_t display, 1647 uint32_t* outNumTypes, uint32_t* outNumRequests); 1648 1649 /* 1650 * Layer Functions 1651 * 1652 * These are functions which operate on layers, but which do not modify state 1653 * that must be validated before use. See also 'Layer State Functions' below. 1654 * 1655 * All of these functions take as their first three parameters a device pointer, 1656 * a display handle for the display which contains the layer, and a layer 1657 * handle, so these parameters are omitted from the described parameter lists. 1658 */ 1659 1660 /* setCursorPosition(..., x, y) 1661 * Descriptor: HWC2_FUNCTION_SET_CURSOR_POSITION 1662 * Must be provided by all HWC2 devices 1663 * 1664 * Asynchonously sets the position of a cursor layer. 1665 * 1666 * Prior to validateDisplay, a layer may be marked as HWC2_COMPOSITION_CURSOR. 1667 * If validation succeeds (i.e., the device does not request a composition 1668 * change for that layer), then once a buffer has been set for the layer and it 1669 * has been presented, its position may be set by this function at any time 1670 * between presentDisplay and any subsequent validateDisplay calls for this 1671 * display. 1672 * 1673 * Once validateDisplay is called, this function will not be called again until 1674 * the validate/present sequence is completed. 1675 * 1676 * May be called from any thread so long as it is not interleaved with the 1677 * validate/present sequence as described above. 1678 * 1679 * Parameters: 1680 * x - the new x coordinate (in pixels from the left of the screen) 1681 * y - the new y coordinate (in pixels from the top of the screen) 1682 * 1683 * Returns HWC2_ERROR_NONE or one of the following errors: 1684 * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in 1685 * HWC2_ERROR_BAD_LAYER - the layer is invalid or is not currently marked as 1686 * HWC2_COMPOSITION_CURSOR 1687 * HWC2_ERROR_NOT_VALIDATED - the device is currently in the middle of the 1688 * validate/present sequence 1689 */ 1690 typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_CURSOR_POSITION)( 1691 hwc2_device_t* device, hwc2_display_t display, hwc2_layer_t layer, 1692 int32_t x, int32_t y); 1693 1694 /* setLayerBuffer(..., buffer, acquireFence) 1695 * Descriptor: HWC2_FUNCTION_SET_LAYER_BUFFER 1696 * Must be provided by all HWC2 devices 1697 * 1698 * Sets the buffer handle to be displayed for this layer. If the buffer 1699 * properties set at allocation time (width, height, format, and usage) have not 1700 * changed since the previous frame, it is not necessary to call validateDisplay 1701 * before calling presentDisplay unless new state needs to be validated in the 1702 * interim. 1703 * 1704 * Also provides a file descriptor referring to an acquire sync fence object, 1705 * which will be signaled when it is safe to read from the given buffer. If it 1706 * is already safe to read from the buffer, -1 may be passed instead. The 1707 * device must ensure that it is safe for the client to close this file 1708 * descriptor at any point after this function is called. 1709 * 1710 * This function must return HWC2_ERROR_NONE and have no other effect if called 1711 * for a layer with a composition type of HWC2_COMPOSITION_SOLID_COLOR (because 1712 * it has no buffer) or HWC2_COMPOSITION_SIDEBAND or HWC2_COMPOSITION_CLIENT 1713 * (because synchronization and buffer updates for these layers are handled 1714 * elsewhere). 1715 * 1716 * Parameters: 1717 * buffer - the buffer handle to set 1718 * acquireFence - a sync fence file descriptor as described above 1719 * 1720 * Returns HWC2_ERROR_NONE or one of the following errors: 1721 * HWC2_ERROR_BAD_LAYER - an invalid layer handle was passed in 1722 * HWC2_ERROR_BAD_PARAMETER - the buffer handle passed in was invalid 1723 */ 1724 typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_LAYER_BUFFER)( 1725 hwc2_device_t* device, hwc2_display_t display, hwc2_layer_t layer, 1726 buffer_handle_t buffer, int32_t acquireFence); 1727 1728 /* setLayerSurfaceDamage(..., damage) 1729 * Descriptor: HWC2_FUNCTION_SET_LAYER_SURFACE_DAMAGE 1730 * Must be provided by all HWC2 devices 1731 * 1732 * Provides the region of the source buffer which has been modified since the 1733 * last frame. This region does not need to be validated before calling 1734 * presentDisplay. 1735 * 1736 * Once set through this function, the damage region remains the same until a 1737 * subsequent call to this function. 1738 * 1739 * If damage.numRects > 0, then it may be assumed that any portion of the source 1740 * buffer not covered by one of the rects has not been modified this frame. If 1741 * damage.numRects == 0, then the whole source buffer must be treated as if it 1742 * has been modified. 1743 * 1744 * If the layer's contents are not modified relative to the prior frame, damage 1745 * will contain exactly one empty rect([0, 0, 0, 0]). 1746 * 1747 * The damage rects are relative to the pre-transformed buffer, and their origin 1748 * is the top-left corner. They will not exceed the dimensions of the latched 1749 * buffer. 1750 * 1751 * Parameters: 1752 * damage - the new surface damage region 1753 * 1754 * Returns HWC2_ERROR_NONE or one of the following errors: 1755 * HWC2_ERROR_BAD_LAYER - an invalid layer handle was passed in 1756 */ 1757 typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_LAYER_SURFACE_DAMAGE)( 1758 hwc2_device_t* device, hwc2_display_t display, hwc2_layer_t layer, 1759 hwc_region_t damage); 1760 1761 /* 1762 * Layer State Functions 1763 * 1764 * These functions modify the state of a given layer. They do not take effect 1765 * until the display configuration is successfully validated with 1766 * validateDisplay and the display contents are presented with presentDisplay. 1767 * 1768 * All of these functions take as their first three parameters a device pointer, 1769 * a display handle for the display which contains the layer, and a layer 1770 * handle, so these parameters are omitted from the described parameter lists. 1771 */ 1772 1773 /* setLayerBlendMode(..., mode) 1774 * Descriptor: HWC2_FUNCTION_SET_LAYER_BLEND_MODE 1775 * Must be provided by all HWC2 devices 1776 * 1777 * Sets the blend mode of the given layer. 1778 * 1779 * Parameters: 1780 * mode - the new blend mode 1781 * 1782 * Returns HWC2_ERROR_NONE or one of the following errors: 1783 * HWC2_ERROR_BAD_LAYER - an invalid layer handle was passed in 1784 * HWC2_ERROR_BAD_PARAMETER - an invalid blend mode was passed in 1785 */ 1786 typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_LAYER_BLEND_MODE)( 1787 hwc2_device_t* device, hwc2_display_t display, hwc2_layer_t layer, 1788 int32_t /*hwc2_blend_mode_t*/ mode); 1789 1790 /* setLayerColor(..., color) 1791 * Descriptor: HWC2_FUNCTION_SET_LAYER_COLOR 1792 * Must be provided by all HWC2 devices 1793 * 1794 * Sets the color of the given layer. If the composition type of the layer is 1795 * not HWC2_COMPOSITION_SOLID_COLOR, this call must return HWC2_ERROR_NONE and 1796 * have no other effect. 1797 * 1798 * Parameters: 1799 * color - the new color 1800 * 1801 * Returns HWC2_ERROR_NONE or one of the following errors: 1802 * HWC2_ERROR_BAD_LAYER - an invalid layer handle was passed in 1803 */ 1804 typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_LAYER_COLOR)( 1805 hwc2_device_t* device, hwc2_display_t display, hwc2_layer_t layer, 1806 hwc_color_t color); 1807 1808 /* setLayerCompositionType(..., type) 1809 * Descriptor: HWC2_FUNCTION_SET_LAYER_COMPOSITION_TYPE 1810 * Must be provided by all HWC2 devices 1811 * 1812 * Sets the desired composition type of the given layer. During validateDisplay, 1813 * the device may request changes to the composition types of any of the layers 1814 * as described in the definition of hwc2_composition_t above. 1815 * 1816 * Parameters: 1817 * type - the new composition type 1818 * 1819 * Returns HWC2_ERROR_NONE or one of the following errors: 1820 * HWC2_ERROR_BAD_LAYER - an invalid layer handle was passed in 1821 * HWC2_ERROR_BAD_PARAMETER - an invalid composition type was passed in 1822 * HWC2_ERROR_UNSUPPORTED - a valid composition type was passed in, but it is 1823 * not supported by this device 1824 */ 1825 typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_LAYER_COMPOSITION_TYPE)( 1826 hwc2_device_t* device, hwc2_display_t display, hwc2_layer_t layer, 1827 int32_t /*hwc2_composition_t*/ type); 1828 1829 /* setLayerDataspace(..., dataspace) 1830 * Descriptor: HWC2_FUNCTION_SET_LAYER_DATASPACE 1831 * Must be provided by all HWC2 devices 1832 * 1833 * Sets the dataspace that the current buffer on this layer is in. 1834 * 1835 * The dataspace provides more information about how to interpret the buffer 1836 * contents, such as the encoding standard and color transform. 1837 * 1838 * See the values of android_dataspace_t in <system/graphics.h> for more 1839 * information. 1840 * 1841 * Parameters: 1842 * dataspace - the new dataspace 1843 * 1844 * Returns HWC2_ERROR_NONE or one of the following errors: 1845 * HWC2_ERROR_BAD_LAYER - an invalid layer handle was passed in 1846 */ 1847 typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_LAYER_DATASPACE)( 1848 hwc2_device_t* device, hwc2_display_t display, hwc2_layer_t layer, 1849 int32_t /*android_dataspace_t*/ dataspace); 1850 1851 /* setLayerDisplayFrame(..., frame) 1852 * Descriptor: HWC2_FUNCTION_SET_LAYER_DISPLAY_FRAME 1853 * Must be provided by all HWC2 devices 1854 * 1855 * Sets the display frame (the portion of the display covered by a layer) of the 1856 * given layer. This frame will not exceed the display dimensions. 1857 * 1858 * Parameters: 1859 * frame - the new display frame 1860 * 1861 * Returns HWC2_ERROR_NONE or one of the following errors: 1862 * HWC2_ERROR_BAD_LAYER - an invalid layer handle was passed in 1863 */ 1864 typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_LAYER_DISPLAY_FRAME)( 1865 hwc2_device_t* device, hwc2_display_t display, hwc2_layer_t layer, 1866 hwc_rect_t frame); 1867 1868 /* setLayerPlaneAlpha(..., alpha) 1869 * Descriptor: HWC2_FUNCTION_SET_LAYER_PLANE_ALPHA 1870 * Must be provided by all HWC2 devices 1871 * 1872 * Sets an alpha value (a floating point value in the range [0.0, 1.0]) which 1873 * will be applied to the whole layer. It can be conceptualized as a 1874 * preprocessing step which applies the following function: 1875 * if (blendMode == HWC2_BLEND_MODE_PREMULTIPLIED) 1876 * out.rgb = in.rgb * planeAlpha 1877 * out.a = in.a * planeAlpha 1878 * 1879 * If the device does not support this operation on a layer which is marked 1880 * HWC2_COMPOSITION_DEVICE, it must request a composition type change to 1881 * HWC2_COMPOSITION_CLIENT upon the next validateDisplay call. 1882 * 1883 * Parameters: 1884 * alpha - the plane alpha value to apply 1885 * 1886 * Returns HWC2_ERROR_NONE or one of the following errors: 1887 * HWC2_ERROR_BAD_LAYER - an invalid layer handle was passed in 1888 */ 1889 typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_LAYER_PLANE_ALPHA)( 1890 hwc2_device_t* device, hwc2_display_t display, hwc2_layer_t layer, 1891 float alpha); 1892 1893 /* setLayerSidebandStream(..., stream) 1894 * Descriptor: HWC2_FUNCTION_SET_LAYER_SIDEBAND_STREAM 1895 * Provided by HWC2 devices which support HWC2_CAPABILITY_SIDEBAND_STREAM 1896 * 1897 * Sets the sideband stream for this layer. If the composition type of the given 1898 * layer is not HWC2_COMPOSITION_SIDEBAND, this call must return HWC2_ERROR_NONE 1899 * and have no other effect. 1900 * 1901 * Parameters: 1902 * stream - the new sideband stream 1903 * 1904 * Returns HWC2_ERROR_NONE or one of the following errors: 1905 * HWC2_ERROR_BAD_LAYER - an invalid layer handle was passed in 1906 * HWC2_ERROR_BAD_PARAMETER - an invalid sideband stream was passed in 1907 */ 1908 typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_LAYER_SIDEBAND_STREAM)( 1909 hwc2_device_t* device, hwc2_display_t display, hwc2_layer_t layer, 1910 const native_handle_t* stream); 1911 1912 /* setLayerSourceCrop(..., crop) 1913 * Descriptor: HWC2_FUNCTION_SET_LAYER_SOURCE_CROP 1914 * Must be provided by all HWC2 devices 1915 * 1916 * Sets the source crop (the portion of the source buffer which will fill the 1917 * display frame) of the given layer. This crop rectangle will not exceed the 1918 * dimensions of the latched buffer. 1919 * 1920 * If the device is not capable of supporting a true float source crop (i.e., it 1921 * will truncate or round the floats to integers), it should set this layer to 1922 * HWC2_COMPOSITION_CLIENT when crop is non-integral for the most accurate 1923 * rendering. 1924 * 1925 * If the device cannot support float source crops, but still wants to handle 1926 * the layer, it should use the following code (or similar) to convert to 1927 * an integer crop: 1928 * intCrop.left = (int) ceilf(crop.left); 1929 * intCrop.top = (int) ceilf(crop.top); 1930 * intCrop.right = (int) floorf(crop.right); 1931 * intCrop.bottom = (int) floorf(crop.bottom); 1932 * 1933 * Parameters: 1934 * crop - the new source crop 1935 * 1936 * Returns HWC2_ERROR_NONE or one of the following errors: 1937 * HWC2_ERROR_BAD_LAYER - an invalid layer handle was passed in 1938 */ 1939 typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_LAYER_SOURCE_CROP)( 1940 hwc2_device_t* device, hwc2_display_t display, hwc2_layer_t layer, 1941 hwc_frect_t crop); 1942 1943 /* setLayerTransform(..., transform) 1944 * Descriptor: HWC2_FUNCTION_SET_LAYER_TRANSFORM 1945 * Must be provided by all HWC2 devices 1946 * 1947 * Sets the transform (rotation/flip) of the given layer. 1948 * 1949 * Parameters: 1950 * transform - the new transform 1951 * 1952 * Returns HWC2_ERROR_NONE or one of the following errors: 1953 * HWC2_ERROR_BAD_LAYER - an invalid layer handle was passed in 1954 * HWC2_ERROR_BAD_PARAMETER - an invalid transform was passed in 1955 */ 1956 typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_LAYER_TRANSFORM)( 1957 hwc2_device_t* device, hwc2_display_t display, hwc2_layer_t layer, 1958 int32_t /*hwc_transform_t*/ transform); 1959 1960 /* setLayerVisibleRegion(..., visible) 1961 * Descriptor: HWC2_FUNCTION_SET_LAYER_VISIBLE_REGION 1962 * Must be provided by all HWC2 devices 1963 * 1964 * Specifies the portion of the layer that is visible, including portions under 1965 * translucent areas of other layers. The region is in screen space, and will 1966 * not exceed the dimensions of the screen. 1967 * 1968 * Parameters: 1969 * visible - the new visible region, in screen space 1970 * 1971 * Returns HWC2_ERROR_NONE or one of the following errors: 1972 * HWC2_ERROR_BAD_LAYER - an invalid layer handle was passed in 1973 */ 1974 typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_LAYER_VISIBLE_REGION)( 1975 hwc2_device_t* device, hwc2_display_t display, hwc2_layer_t layer, 1976 hwc_region_t visible); 1977 1978 /* setLayerZOrder(..., z) 1979 * Descriptor: HWC2_FUNCTION_SET_LAYER_Z_ORDER 1980 * Must be provided by all HWC2 devices 1981 * 1982 * Sets the desired Z order (height) of the given layer. A layer with a greater 1983 * Z value occludes a layer with a lesser Z value. 1984 * 1985 * Parameters: 1986 * z - the new Z order 1987 * 1988 * Returns HWC2_ERROR_NONE or one of the following errors: 1989 * HWC2_ERROR_BAD_LAYER - an invalid layer handle was passed in 1990 */ 1991 typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_LAYER_Z_ORDER)( 1992 hwc2_device_t* device, hwc2_display_t display, hwc2_layer_t layer, 1993 uint32_t z); 1994 1995 __END_DECLS 1996 1997 #endif 1998