| /* |
| * Copyright 2015 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #ifndef ANDROID_HARDWARE_HWCOMPOSER2_H |
| #define ANDROID_HARDWARE_HWCOMPOSER2_H |
| |
| #include <sys/cdefs.h> |
| |
| #include <hardware/hardware.h> |
| |
| #include "hwcomposer_defs.h" |
| |
| __BEGIN_DECLS |
| |
| /* |
| * Enums |
| * |
| * For most of these enums, there is an invalid value defined to be 0. This is |
| * an attempt to catch uninitialized fields, and these values should not be |
| * used. |
| */ |
| |
| /* Display attributes queryable through getDisplayAttribute */ |
| typedef enum { |
| HWC2_ATTRIBUTE_INVALID = 0, |
| |
| /* Dimensions in pixels */ |
| HWC2_ATTRIBUTE_WIDTH = 1, |
| HWC2_ATTRIBUTE_HEIGHT = 2, |
| |
| /* Vsync period in nanoseconds */ |
| HWC2_ATTRIBUTE_VSYNC_PERIOD = 3, |
| |
| /* Dots per thousand inches (DPI * 1000). Scaling by 1000 allows these |
| * numbers to be stored in an int32_t without losing too much precision. If |
| * the DPI for a configuration is unavailable or is considered unreliable, |
| * the device may return -1 instead */ |
| HWC2_ATTRIBUTE_DPI_X = 4, |
| HWC2_ATTRIBUTE_DPI_Y = 5, |
| |
| /* The configuration group this config is associated to. |
| * Switching between configurations within the same group may be done seamlessly |
| * in some conditions via setActiveConfigWithConstraints. */ |
| HWC2_ATTRIBUTE_CONFIG_GROUP = 7, |
| } hwc2_attribute_t; |
| |
| /* Blend modes, settable per layer */ |
| typedef enum { |
| HWC2_BLEND_MODE_INVALID = 0, |
| |
| /* colorOut = colorSrc */ |
| HWC2_BLEND_MODE_NONE = 1, |
| |
| /* colorOut = colorSrc + colorDst * (1 - alphaSrc) */ |
| HWC2_BLEND_MODE_PREMULTIPLIED = 2, |
| |
| /* colorOut = colorSrc * alphaSrc + colorDst * (1 - alphaSrc) */ |
| HWC2_BLEND_MODE_COVERAGE = 3, |
| } hwc2_blend_mode_t; |
| |
| /* See the 'Callbacks' section for more detailed descriptions of what these |
| * functions do */ |
| typedef enum { |
| HWC2_CALLBACK_INVALID = 0, |
| HWC2_CALLBACK_HOTPLUG = 1, |
| HWC2_CALLBACK_REFRESH = 2, |
| HWC2_CALLBACK_VSYNC = 3, |
| HWC2_CALLBACK_VSYNC_2_4 = 4, |
| HWC2_CALLBACK_VSYNC_PERIOD_TIMING_CHANGED = 5, |
| HWC2_CALLBACK_SEAMLESS_POSSIBLE = 6, |
| } hwc2_callback_descriptor_t; |
| |
| /* Optional capabilities which may be supported by some devices. The particular |
| * set of supported capabilities for a given device may be retrieved using |
| * getCapabilities. */ |
| typedef enum { |
| HWC2_CAPABILITY_INVALID = 0, |
| |
| /* Specifies that the device supports sideband stream layers, for which |
| * buffer content updates and other synchronization will not be provided |
| * through the usual validate/present cycle and must be handled by an |
| * external implementation-defined mechanism. Only changes to layer state |
| * (such as position, size, etc.) need to be performed through the |
| * validate/present cycle. */ |
| HWC2_CAPABILITY_SIDEBAND_STREAM = 1, |
| |
| /* Specifies that the device will apply a color transform even when either |
| * the client or the device has chosen that all layers should be composed by |
| * the client. This will prevent the client from applying the color |
| * transform during its composition step. */ |
| HWC2_CAPABILITY_SKIP_CLIENT_COLOR_TRANSFORM = 2, |
| |
| /* Specifies that the present fence must not be used as an accurate |
| * representation of the actual present time of a frame. |
| * This capability must never be set by HWC2 devices. |
| * This capability may be set for HWC1 devices that use the |
| * HWC2On1Adapter where emulation of the present fence using the retire |
| * fence is not feasible. |
| * In the future, CTS tests will require present time to be reliable. |
| */ |
| HWC2_CAPABILITY_PRESENT_FENCE_IS_NOT_RELIABLE = 3, |
| |
| /* Specifies that a device is able to skip the validateDisplay call before |
| * receiving a call to presentDisplay. The client will always skip |
| * validateDisplay and try to call presentDisplay regardless of the changes |
| * in the properties of the layers. If the device returns anything else than |
| * HWC2_ERROR_NONE, it will call validateDisplay then presentDisplay again. |
| * For this capability to be worthwhile the device implementation of |
| * presentDisplay should fail as fast as possible in the case a |
| * validateDisplay step is needed. |
| */ |
| HWC2_CAPABILITY_SKIP_VALIDATE = 4, |
| } hwc2_capability_t; |
| |
| /* Possible composition types for a given layer */ |
| typedef enum { |
| HWC2_COMPOSITION_INVALID = 0, |
| |
| /* The client will composite this layer into the client target buffer |
| * (provided to the device through setClientTarget). |
| * |
| * The device must not request any composition type changes for layers of |
| * this type. */ |
| HWC2_COMPOSITION_CLIENT = 1, |
| |
| /* The device will handle the composition of this layer through a hardware |
| * overlay or other similar means. |
| * |
| * Upon validateDisplay, the device may request a change from this type to |
| * HWC2_COMPOSITION_CLIENT. */ |
| HWC2_COMPOSITION_DEVICE = 2, |
| |
| /* The device will render this layer using the color set through |
| * setLayerColor. If this functionality is not supported on a layer that the |
| * client sets to HWC2_COMPOSITION_SOLID_COLOR, the device must request that |
| * the composition type of that layer is changed to HWC2_COMPOSITION_CLIENT |
| * upon the next call to validateDisplay. |
| * |
| * Upon validateDisplay, the device may request a change from this type to |
| * HWC2_COMPOSITION_CLIENT. */ |
| HWC2_COMPOSITION_SOLID_COLOR = 3, |
| |
| /* Similar to DEVICE, but the position of this layer may also be set |
| * asynchronously through setCursorPosition. If this functionality is not |
| * supported on a layer that the client sets to HWC2_COMPOSITION_CURSOR, the |
| * device must request that the composition type of that layer is changed to |
| * HWC2_COMPOSITION_CLIENT upon the next call to validateDisplay. |
| * |
| * Upon validateDisplay, the device may request a change from this type to |
| * either HWC2_COMPOSITION_DEVICE or HWC2_COMPOSITION_CLIENT. Changing to |
| * HWC2_COMPOSITION_DEVICE will prevent the use of setCursorPosition but |
| * still permit the device to composite the layer. */ |
| HWC2_COMPOSITION_CURSOR = 4, |
| |
| /* The device will handle the composition of this layer, as well as its |
| * buffer updates and content synchronization. Only supported on devices |
| * which provide HWC2_CAPABILITY_SIDEBAND_STREAM. |
| * |
| * Upon validateDisplay, the device may request a change from this type to |
| * either HWC2_COMPOSITION_DEVICE or HWC2_COMPOSITION_CLIENT, but it is |
| * unlikely that content will display correctly in these cases. */ |
| HWC2_COMPOSITION_SIDEBAND = 5, |
| } hwc2_composition_t; |
| |
| /* Possible connection options from the hotplug callback */ |
| typedef enum { |
| HWC2_CONNECTION_INVALID = 0, |
| |
| /* The display has been connected */ |
| HWC2_CONNECTION_CONNECTED = 1, |
| |
| /* The display has been disconnected */ |
| HWC2_CONNECTION_DISCONNECTED = 2, |
| } hwc2_connection_t; |
| |
| /* Display requests returned by getDisplayRequests */ |
| typedef enum { |
| /* Instructs the client to provide a new client target buffer, even if no |
| * layers are marked for client composition. */ |
| HWC2_DISPLAY_REQUEST_FLIP_CLIENT_TARGET = 1 << 0, |
| |
| /* Instructs the client to write the result of client composition directly |
| * into the virtual display output buffer. If any of the layers are not |
| * marked as HWC2_COMPOSITION_CLIENT or the given display is not a virtual |
| * display, this request has no effect. */ |
| HWC2_DISPLAY_REQUEST_WRITE_CLIENT_TARGET_TO_OUTPUT = 1 << 1, |
| } hwc2_display_request_t; |
| |
| /* Display types returned by getDisplayType */ |
| typedef enum { |
| HWC2_DISPLAY_TYPE_INVALID = 0, |
| |
| /* All physical displays, including both internal displays and hotpluggable |
| * external displays */ |
| HWC2_DISPLAY_TYPE_PHYSICAL = 1, |
| |
| /* Virtual displays created by createVirtualDisplay */ |
| HWC2_DISPLAY_TYPE_VIRTUAL = 2, |
| } hwc2_display_type_t; |
| |
| /* Physical display types returned by getDisplayConnectionType */ |
| typedef enum { |
| HWC2_DISPLAY_CONNECTION_TYPE_INTERNAL = 0, |
| HWC2_DISPLAY_CONNECTION_TYPE_EXTERNAL = 1, |
| } hwc2_display_connection_type_t; |
| |
| /* Return codes from all functions */ |
| typedef enum { |
| HWC2_ERROR_NONE = 0, |
| HWC2_ERROR_BAD_CONFIG, |
| HWC2_ERROR_BAD_DISPLAY, |
| HWC2_ERROR_BAD_LAYER, |
| HWC2_ERROR_BAD_PARAMETER, |
| HWC2_ERROR_HAS_CHANGES, |
| HWC2_ERROR_NO_RESOURCES, |
| HWC2_ERROR_NOT_VALIDATED, |
| HWC2_ERROR_UNSUPPORTED, |
| HWC2_ERROR_SEAMLESS_NOT_ALLOWED, |
| HWC2_ERROR_SEAMLESS_NOT_POSSIBLE, |
| } hwc2_error_t; |
| |
| /* Function descriptors for use with getFunction */ |
| typedef enum { |
| HWC2_FUNCTION_INVALID = 0, |
| HWC2_FUNCTION_ACCEPT_DISPLAY_CHANGES, |
| HWC2_FUNCTION_CREATE_LAYER, |
| HWC2_FUNCTION_CREATE_VIRTUAL_DISPLAY, |
| HWC2_FUNCTION_DESTROY_LAYER, |
| HWC2_FUNCTION_DESTROY_VIRTUAL_DISPLAY, |
| HWC2_FUNCTION_DUMP, |
| HWC2_FUNCTION_GET_ACTIVE_CONFIG, |
| HWC2_FUNCTION_GET_CHANGED_COMPOSITION_TYPES, |
| HWC2_FUNCTION_GET_CLIENT_TARGET_SUPPORT, |
| HWC2_FUNCTION_GET_COLOR_MODES, |
| HWC2_FUNCTION_GET_DISPLAY_ATTRIBUTE, |
| HWC2_FUNCTION_GET_DISPLAY_CONFIGS, |
| HWC2_FUNCTION_GET_DISPLAY_NAME, |
| HWC2_FUNCTION_GET_DISPLAY_REQUESTS, |
| HWC2_FUNCTION_GET_DISPLAY_TYPE, |
| HWC2_FUNCTION_GET_DOZE_SUPPORT, |
| HWC2_FUNCTION_GET_HDR_CAPABILITIES, |
| HWC2_FUNCTION_GET_MAX_VIRTUAL_DISPLAY_COUNT, |
| HWC2_FUNCTION_GET_RELEASE_FENCES, |
| HWC2_FUNCTION_PRESENT_DISPLAY, |
| HWC2_FUNCTION_REGISTER_CALLBACK, |
| HWC2_FUNCTION_SET_ACTIVE_CONFIG, |
| HWC2_FUNCTION_SET_CLIENT_TARGET, |
| HWC2_FUNCTION_SET_COLOR_MODE, |
| HWC2_FUNCTION_SET_COLOR_TRANSFORM, |
| HWC2_FUNCTION_SET_CURSOR_POSITION, |
| HWC2_FUNCTION_SET_LAYER_BLEND_MODE, |
| HWC2_FUNCTION_SET_LAYER_BUFFER, |
| HWC2_FUNCTION_SET_LAYER_COLOR, |
| HWC2_FUNCTION_SET_LAYER_COMPOSITION_TYPE, |
| HWC2_FUNCTION_SET_LAYER_DATASPACE, |
| HWC2_FUNCTION_SET_LAYER_DISPLAY_FRAME, |
| HWC2_FUNCTION_SET_LAYER_PLANE_ALPHA, |
| HWC2_FUNCTION_SET_LAYER_SIDEBAND_STREAM, |
| HWC2_FUNCTION_SET_LAYER_SOURCE_CROP, |
| HWC2_FUNCTION_SET_LAYER_SURFACE_DAMAGE, |
| HWC2_FUNCTION_SET_LAYER_TRANSFORM, |
| HWC2_FUNCTION_SET_LAYER_VISIBLE_REGION, |
| HWC2_FUNCTION_SET_LAYER_Z_ORDER, |
| HWC2_FUNCTION_SET_OUTPUT_BUFFER, |
| HWC2_FUNCTION_SET_POWER_MODE, |
| HWC2_FUNCTION_SET_VSYNC_ENABLED, |
| HWC2_FUNCTION_VALIDATE_DISPLAY, |
| HWC2_FUNCTION_SET_LAYER_FLOAT_COLOR, |
| HWC2_FUNCTION_SET_LAYER_PER_FRAME_METADATA, |
| HWC2_FUNCTION_GET_PER_FRAME_METADATA_KEYS, |
| HWC2_FUNCTION_SET_READBACK_BUFFER, |
| HWC2_FUNCTION_GET_READBACK_BUFFER_ATTRIBUTES, |
| HWC2_FUNCTION_GET_READBACK_BUFFER_FENCE, |
| HWC2_FUNCTION_GET_RENDER_INTENTS, |
| HWC2_FUNCTION_SET_COLOR_MODE_WITH_RENDER_INTENT, |
| HWC2_FUNCTION_GET_DATASPACE_SATURATION_MATRIX, |
| |
| // composer 2.3 |
| HWC2_FUNCTION_GET_DISPLAY_IDENTIFICATION_DATA, |
| HWC2_FUNCTION_GET_DISPLAY_CAPABILITIES, |
| HWC2_FUNCTION_SET_LAYER_COLOR_TRANSFORM, |
| HWC2_FUNCTION_GET_DISPLAYED_CONTENT_SAMPLING_ATTRIBUTES, |
| HWC2_FUNCTION_SET_DISPLAYED_CONTENT_SAMPLING_ENABLED, |
| HWC2_FUNCTION_GET_DISPLAYED_CONTENT_SAMPLE, |
| HWC2_FUNCTION_SET_LAYER_PER_FRAME_METADATA_BLOBS, |
| HWC2_FUNCTION_GET_DISPLAY_BRIGHTNESS_SUPPORT, |
| HWC2_FUNCTION_SET_DISPLAY_BRIGHTNESS, |
| |
| // composer 2.4 |
| HWC2_FUNCTION_GET_DISPLAY_CONNECTION_TYPE, |
| HWC2_FUNCTION_GET_DISPLAY_VSYNC_PERIOD, |
| HWC2_FUNCTION_SET_ACTIVE_CONFIG_WITH_CONSTRAINTS, |
| HWC2_FUNCTION_SET_AUTO_LOW_LATENCY_MODE, |
| HWC2_FUNCTION_GET_SUPPORTED_CONTENT_TYPES, |
| HWC2_FUNCTION_SET_CONTENT_TYPE, |
| HWC2_FUNCTION_GET_CLIENT_TARGET_PROPERTY, |
| HWC2_FUNCTION_SET_LAYER_GENERIC_METADATA, |
| HWC2_FUNCTION_GET_LAYER_GENERIC_METADATA_KEY, |
| } hwc2_function_descriptor_t; |
| |
| /* Layer requests returned from getDisplayRequests */ |
| typedef enum { |
| /* The client should clear its target with transparent pixels where this |
| * layer would be. The client may ignore this request if the layer must be |
| * blended. */ |
| HWC2_LAYER_REQUEST_CLEAR_CLIENT_TARGET = 1 << 0, |
| } hwc2_layer_request_t; |
| |
| /* Power modes for use with setPowerMode */ |
| typedef enum { |
| /* The display is fully off (blanked) */ |
| HWC2_POWER_MODE_OFF = 0, |
| |
| /* These are optional low power modes. getDozeSupport may be called to |
| * determine whether a given display supports these modes. */ |
| |
| /* The display is turned on and configured in a low power state that is |
| * suitable for presenting ambient information to the user, possibly with |
| * lower fidelity than HWC2_POWER_MODE_ON, but with greater efficiency. */ |
| HWC2_POWER_MODE_DOZE = 1, |
| |
| /* The display is configured as in HWC2_POWER_MODE_DOZE but may stop |
| * applying display updates from the client. This is effectively a hint to |
| * the device that drawing to the display has been suspended and that the |
| * the device should remain on in a low power state and continue displaying |
| * its current contents indefinitely until the power mode changes. |
| * |
| * This mode may also be used as a signal to enable hardware-based doze |
| * functionality. In this case, the device is free to take over the display |
| * and manage it autonomously to implement a low power always-on display. */ |
| HWC2_POWER_MODE_DOZE_SUSPEND = 3, |
| |
| /* The display is fully on */ |
| HWC2_POWER_MODE_ON = 2, |
| } hwc2_power_mode_t; |
| |
| typedef enum { |
| HWC2_CONTENT_TYPE_NONE = 0, |
| HWC2_CONTENT_TYPE_GRAPHICS = 1, |
| HWC2_CONTENT_TYPE_PHOTO = 2, |
| HWC2_CONTENT_TYPE_CINEMA = 3, |
| HWC2_CONTENT_TYPE_GAME = 4, |
| } hwc2_content_type_t; |
| |
| /* Vsync values passed to setVsyncEnabled */ |
| typedef enum { |
| HWC2_VSYNC_INVALID = 0, |
| |
| /* Enable vsync */ |
| HWC2_VSYNC_ENABLE = 1, |
| |
| /* Disable vsync */ |
| HWC2_VSYNC_DISABLE = 2, |
| } hwc2_vsync_t; |
| |
| /* MUST match HIDL's V2_2::IComposerClient::PerFrameMetadataKey */ |
| typedef enum { |
| /* SMPTE ST 2084:2014. |
| * Coordinates defined in CIE 1931 xy chromaticity space |
| */ |
| HWC2_DISPLAY_RED_PRIMARY_X = 0, |
| HWC2_DISPLAY_RED_PRIMARY_Y = 1, |
| HWC2_DISPLAY_GREEN_PRIMARY_X = 2, |
| HWC2_DISPLAY_GREEN_PRIMARY_Y = 3, |
| HWC2_DISPLAY_BLUE_PRIMARY_X = 4, |
| HWC2_DISPLAY_BLUE_PRIMARY_Y = 5, |
| HWC2_WHITE_POINT_X = 6, |
| HWC2_WHITE_POINT_Y = 7, |
| /* SMPTE ST 2084:2014. |
| * Units: nits |
| * max as defined by ST 2048: 10,000 nits |
| */ |
| HWC2_MAX_LUMINANCE = 8, |
| HWC2_MIN_LUMINANCE = 9, |
| |
| /* CTA 861.3 |
| * Units: nits |
| */ |
| HWC2_MAX_CONTENT_LIGHT_LEVEL = 10, |
| HWC2_MAX_FRAME_AVERAGE_LIGHT_LEVEL = 11, |
| } hwc2_per_frame_metadata_key_t; |
| |
| /* SetDisplayedContentSampling values passed to setDisplayedContentSamplingEnabled */ |
| typedef enum { |
| HWC2_DISPLAYED_CONTENT_SAMPLING_INVALID = 0, |
| |
| /* Enable displayed content sampling */ |
| HWC2_DISPLAYED_CONTENT_SAMPLING_ENABLE = 1, |
| |
| /* Disable displayed content sampling */ |
| HWC2_DISPLAYED_CONTENT_SAMPLING_DISABLE = 2, |
| } hwc2_displayed_content_sampling_t; |
| |
| typedef enum { |
| HWC2_FORMAT_COMPONENT_0 = 1 << 0, /* The first component (eg, for RGBA_8888, this is R) */ |
| HWC2_FORMAT_COMPONENT_1 = 1 << 1, /* The second component (eg, for RGBA_8888, this is G) */ |
| HWC2_FORMAT_COMPONENT_2 = 1 << 2, /* The third component (eg, for RGBA_8888, this is B) */ |
| HWC2_FORMAT_COMPONENT_3 = 1 << 3, /* The fourth component (eg, for RGBA_8888, this is A) */ |
| } hwc2_format_color_component_t; |
| |
| /* Optional display capabilities which may be supported by some displays. |
| * The particular set of supported capabilities for a given display may be |
| * retrieved using getDisplayCapabilities. */ |
| typedef enum { |
| HWC2_DISPLAY_CAPABILITY_INVALID = 0, |
| |
| /** |
| * Specifies that the display must apply a color transform even when either |
| * the client or the device has chosen that all layers should be composed by |
| * the client. This prevents the client from applying the color transform |
| * during its composition step. |
| * If getDisplayCapabilities is supported, the global capability |
| * HWC2_CAPABILITY_SKIP_CLIENT_COLOR_TRANSFORM is ignored. |
| * If getDisplayCapabilities is not supported, and the global capability |
| * HWC2_CAPABILITY_SKIP_CLIENT_COLOR_TRANSFORM is returned by getCapabilities, |
| * then all displays must be treated as having |
| * HWC2_DISPLAY_CAPABILITY_SKIP_CLIENT_COLOR_TRANSFORM. |
| */ |
| HWC2_DISPLAY_CAPABILITY_SKIP_CLIENT_COLOR_TRANSFORM = 1, |
| |
| /** |
| * Specifies that the display supports PowerMode::DOZE and |
| * PowerMode::DOZE_SUSPEND. DOZE_SUSPEND may not provide any benefit |
| * over DOZE (see the definition of PowerMode for more information), |
| * but if both DOZE and DOZE_SUSPEND are no different from |
| * PowerMode::ON, the device must not claim support. |
| * HWC2_DISPLAY_CAPABILITY_DOZE must be returned by getDisplayCapabilities |
| * when getDozeSupport indicates the display supports PowerMode::DOZE and |
| * PowerMode::DOZE_SUSPEND. |
| */ |
| HWC2_DISPLAY_CAPABILITY_DOZE = 2, |
| |
| /** |
| * Specified that the display supports brightness operations. |
| */ |
| HWC2_DISPLAY_CAPABILITY_BRIGHTNESS = 3, |
| |
| /** |
| * Specifies that the display supports a low latency mode. If the connection |
| * to the display is via HDMI, this specifies whether Auto Low Latency Mode |
| * is supported. If, instead, there is an internal connection to the display, |
| * then this specifies that the display has some other custom low latency |
| * mode. |
| */ |
| HWC2_DISPLAY_CAPABILITY_AUTO_LOW_LATENCY_MODE = 5, |
| } hwc2_display_capability_t; |
| |
| /* |
| * Stringification Functions |
| */ |
| |
| #ifdef HWC2_INCLUDE_STRINGIFICATION |
| |
| static inline const char* getAttributeName(hwc2_attribute_t attribute) { |
| switch (attribute) { |
| case HWC2_ATTRIBUTE_INVALID: return "Invalid"; |
| case HWC2_ATTRIBUTE_WIDTH: return "Width"; |
| case HWC2_ATTRIBUTE_HEIGHT: return "Height"; |
| case HWC2_ATTRIBUTE_VSYNC_PERIOD: return "VsyncPeriod"; |
| case HWC2_ATTRIBUTE_DPI_X: return "DpiX"; |
| case HWC2_ATTRIBUTE_DPI_Y: return "DpiY"; |
| case HWC2_ATTRIBUTE_CONFIG_GROUP: return "ConfigGroup"; |
| default: return "Unknown"; |
| } |
| } |
| |
| static inline const char* getBlendModeName(hwc2_blend_mode_t mode) { |
| switch (mode) { |
| case HWC2_BLEND_MODE_INVALID: return "Invalid"; |
| case HWC2_BLEND_MODE_NONE: return "None"; |
| case HWC2_BLEND_MODE_PREMULTIPLIED: return "Premultiplied"; |
| case HWC2_BLEND_MODE_COVERAGE: return "Coverage"; |
| default: return "Unknown"; |
| } |
| } |
| |
| static inline const char* getCallbackDescriptorName( |
| hwc2_callback_descriptor_t desc) { |
| switch (desc) { |
| case HWC2_CALLBACK_INVALID: return "Invalid"; |
| case HWC2_CALLBACK_HOTPLUG: return "Hotplug"; |
| case HWC2_CALLBACK_REFRESH: return "Refresh"; |
| case HWC2_CALLBACK_VSYNC: return "Vsync"; |
| case HWC2_CALLBACK_VSYNC_2_4: return "Vsync2.4"; |
| case HWC2_CALLBACK_VSYNC_PERIOD_TIMING_CHANGED: return "VsyncPeriodTimingChanged"; |
| case HWC2_CALLBACK_SEAMLESS_POSSIBLE: return "SeamlessPossible"; |
| default: return "Unknown"; |
| } |
| } |
| |
| static inline const char* getCapabilityName(hwc2_capability_t capability) { |
| switch (capability) { |
| case HWC2_CAPABILITY_INVALID: return "Invalid"; |
| case HWC2_CAPABILITY_SIDEBAND_STREAM: return "SidebandStream"; |
| case HWC2_CAPABILITY_SKIP_CLIENT_COLOR_TRANSFORM: |
| return "SkipClientColorTransform"; |
| case HWC2_CAPABILITY_PRESENT_FENCE_IS_NOT_RELIABLE: |
| return "PresentFenceIsNotReliable"; |
| default: return "Unknown"; |
| } |
| } |
| |
| static inline const char* getCompositionName(hwc2_composition_t composition) { |
| switch (composition) { |
| case HWC2_COMPOSITION_INVALID: return "Invalid"; |
| case HWC2_COMPOSITION_CLIENT: return "Client"; |
| case HWC2_COMPOSITION_DEVICE: return "Device"; |
| case HWC2_COMPOSITION_SOLID_COLOR: return "SolidColor"; |
| case HWC2_COMPOSITION_CURSOR: return "Cursor"; |
| case HWC2_COMPOSITION_SIDEBAND: return "Sideband"; |
| default: return "Unknown"; |
| } |
| } |
| |
| static inline const char* getConnectionName(hwc2_connection_t connection) { |
| switch (connection) { |
| case HWC2_CONNECTION_INVALID: return "Invalid"; |
| case HWC2_CONNECTION_CONNECTED: return "Connected"; |
| case HWC2_CONNECTION_DISCONNECTED: return "Disconnected"; |
| default: return "Unknown"; |
| } |
| } |
| |
| static inline const char* getDisplayRequestName( |
| hwc2_display_request_t request) { |
| switch (__BIONIC_CAST(static_cast, int, request)) { |
| case 0: return "None"; |
| case HWC2_DISPLAY_REQUEST_FLIP_CLIENT_TARGET: return "FlipClientTarget"; |
| case HWC2_DISPLAY_REQUEST_WRITE_CLIENT_TARGET_TO_OUTPUT: |
| return "WriteClientTargetToOutput"; |
| case HWC2_DISPLAY_REQUEST_FLIP_CLIENT_TARGET | |
| HWC2_DISPLAY_REQUEST_WRITE_CLIENT_TARGET_TO_OUTPUT: |
| return "FlipClientTarget|WriteClientTargetToOutput"; |
| default: return "Unknown"; |
| } |
| } |
| |
| static inline const char* getDisplayTypeName(hwc2_display_type_t type) { |
| switch (type) { |
| case HWC2_DISPLAY_TYPE_INVALID: return "Invalid"; |
| case HWC2_DISPLAY_TYPE_PHYSICAL: return "Physical"; |
| case HWC2_DISPLAY_TYPE_VIRTUAL: return "Virtual"; |
| default: return "Unknown"; |
| } |
| } |
| |
| static inline const char* getDisplayConnectionTypeName(hwc2_display_connection_type_t type) { |
| switch (type) { |
| case HWC2_DISPLAY_CONNECTION_TYPE_INTERNAL: return "Internal"; |
| case HWC2_DISPLAY_CONNECTION_TYPE_EXTERNAL: return "External"; |
| default: return "Unknown"; |
| } |
| } |
| |
| static inline const char* getErrorName(hwc2_error_t error) { |
| switch (error) { |
| case HWC2_ERROR_NONE: return "None"; |
| case HWC2_ERROR_BAD_CONFIG: return "BadConfig"; |
| case HWC2_ERROR_BAD_DISPLAY: return "BadDisplay"; |
| case HWC2_ERROR_BAD_LAYER: return "BadLayer"; |
| case HWC2_ERROR_BAD_PARAMETER: return "BadParameter"; |
| case HWC2_ERROR_HAS_CHANGES: return "HasChanges"; |
| case HWC2_ERROR_NO_RESOURCES: return "NoResources"; |
| case HWC2_ERROR_NOT_VALIDATED: return "NotValidated"; |
| case HWC2_ERROR_UNSUPPORTED: return "Unsupported"; |
| case HWC2_ERROR_SEAMLESS_NOT_ALLOWED: return "SeamlessNotAllowed"; |
| case HWC2_ERROR_SEAMLESS_NOT_POSSIBLE: return "SeamlessNotPossible"; |
| default: return "Unknown"; |
| } |
| } |
| |
| static inline const char* getFunctionDescriptorName( |
| hwc2_function_descriptor_t desc) { |
| switch (desc) { |
| case HWC2_FUNCTION_INVALID: return "Invalid"; |
| case HWC2_FUNCTION_ACCEPT_DISPLAY_CHANGES: |
| return "AcceptDisplayChanges"; |
| case HWC2_FUNCTION_CREATE_LAYER: return "CreateLayer"; |
| case HWC2_FUNCTION_CREATE_VIRTUAL_DISPLAY: |
| return "CreateVirtualDisplay"; |
| case HWC2_FUNCTION_DESTROY_LAYER: return "DestroyLayer"; |
| case HWC2_FUNCTION_DESTROY_VIRTUAL_DISPLAY: |
| return "DestroyVirtualDisplay"; |
| case HWC2_FUNCTION_DUMP: return "Dump"; |
| case HWC2_FUNCTION_GET_ACTIVE_CONFIG: return "GetActiveConfig"; |
| case HWC2_FUNCTION_GET_CHANGED_COMPOSITION_TYPES: |
| return "GetChangedCompositionTypes"; |
| case HWC2_FUNCTION_GET_CLIENT_TARGET_SUPPORT: |
| return "GetClientTargetSupport"; |
| case HWC2_FUNCTION_GET_COLOR_MODES: return "GetColorModes"; |
| case HWC2_FUNCTION_GET_DISPLAY_ATTRIBUTE: return "GetDisplayAttribute"; |
| case HWC2_FUNCTION_GET_DISPLAY_CONFIGS: return "GetDisplayConfigs"; |
| case HWC2_FUNCTION_GET_DISPLAY_NAME: return "GetDisplayName"; |
| case HWC2_FUNCTION_GET_DISPLAY_REQUESTS: return "GetDisplayRequests"; |
| case HWC2_FUNCTION_GET_DISPLAY_TYPE: return "GetDisplayType"; |
| case HWC2_FUNCTION_GET_DOZE_SUPPORT: return "GetDozeSupport"; |
| case HWC2_FUNCTION_GET_HDR_CAPABILITIES: return "GetHdrCapabilities"; |
| case HWC2_FUNCTION_GET_MAX_VIRTUAL_DISPLAY_COUNT: |
| return "GetMaxVirtualDisplayCount"; |
| case HWC2_FUNCTION_GET_RELEASE_FENCES: return "GetReleaseFences"; |
| case HWC2_FUNCTION_PRESENT_DISPLAY: return "PresentDisplay"; |
| case HWC2_FUNCTION_REGISTER_CALLBACK: return "RegisterCallback"; |
| case HWC2_FUNCTION_SET_ACTIVE_CONFIG: return "SetActiveConfig"; |
| case HWC2_FUNCTION_SET_CLIENT_TARGET: return "SetClientTarget"; |
| case HWC2_FUNCTION_SET_COLOR_MODE: return "SetColorMode"; |
| case HWC2_FUNCTION_SET_COLOR_TRANSFORM: return "SetColorTransform"; |
| case HWC2_FUNCTION_SET_CURSOR_POSITION: return "SetCursorPosition"; |
| case HWC2_FUNCTION_SET_LAYER_BLEND_MODE: return "SetLayerBlendMode"; |
| case HWC2_FUNCTION_SET_LAYER_BUFFER: return "SetLayerBuffer"; |
| case HWC2_FUNCTION_SET_LAYER_COLOR: return "SetLayerColor"; |
| case HWC2_FUNCTION_SET_LAYER_COMPOSITION_TYPE: |
| return "SetLayerCompositionType"; |
| case HWC2_FUNCTION_SET_LAYER_DATASPACE: return "SetLayerDataspace"; |
| case HWC2_FUNCTION_SET_LAYER_DISPLAY_FRAME: |
| return "SetLayerDisplayFrame"; |
| case HWC2_FUNCTION_SET_LAYER_PLANE_ALPHA: return "SetLayerPlaneAlpha"; |
| case HWC2_FUNCTION_SET_LAYER_SIDEBAND_STREAM: |
| return "SetLayerSidebandStream"; |
| case HWC2_FUNCTION_SET_LAYER_SOURCE_CROP: return "SetLayerSourceCrop"; |
| case HWC2_FUNCTION_SET_LAYER_SURFACE_DAMAGE: |
| return "SetLayerSurfaceDamage"; |
| case HWC2_FUNCTION_SET_LAYER_TRANSFORM: return "SetLayerTransform"; |
| case HWC2_FUNCTION_SET_LAYER_VISIBLE_REGION: |
| return "SetLayerVisibleRegion"; |
| case HWC2_FUNCTION_SET_LAYER_Z_ORDER: return "SetLayerZOrder"; |
| case HWC2_FUNCTION_SET_OUTPUT_BUFFER: return "SetOutputBuffer"; |
| case HWC2_FUNCTION_SET_POWER_MODE: return "SetPowerMode"; |
| case HWC2_FUNCTION_SET_VSYNC_ENABLED: return "SetVsyncEnabled"; |
| case HWC2_FUNCTION_VALIDATE_DISPLAY: return "ValidateDisplay"; |
| case HWC2_FUNCTION_SET_LAYER_FLOAT_COLOR: return "SetLayerFloatColor"; |
| case HWC2_FUNCTION_SET_LAYER_PER_FRAME_METADATA: return "SetLayerPerFrameMetadata"; |
| case HWC2_FUNCTION_GET_PER_FRAME_METADATA_KEYS: return "GetPerFrameMetadataKeys"; |
| case HWC2_FUNCTION_SET_READBACK_BUFFER: return "SetReadbackBuffer"; |
| case HWC2_FUNCTION_GET_READBACK_BUFFER_ATTRIBUTES: return "GetReadbackBufferAttributes"; |
| case HWC2_FUNCTION_GET_READBACK_BUFFER_FENCE: return "GetReadbackBufferFence"; |
| case HWC2_FUNCTION_GET_RENDER_INTENTS: return "GetRenderIntents"; |
| case HWC2_FUNCTION_SET_COLOR_MODE_WITH_RENDER_INTENT: return "SetColorModeWithRenderIntent"; |
| case HWC2_FUNCTION_GET_DATASPACE_SATURATION_MATRIX: return "GetDataspaceSaturationMatrix"; |
| |
| // composer 2.3 |
| case HWC2_FUNCTION_GET_DISPLAY_IDENTIFICATION_DATA: return "GetDisplayIdentificationData"; |
| case HWC2_FUNCTION_GET_DISPLAY_CAPABILITIES: return "GetDisplayCapabilities"; |
| case HWC2_FUNCTION_SET_LAYER_COLOR_TRANSFORM: return "SetLayerColorTransform"; |
| case HWC2_FUNCTION_GET_DISPLAYED_CONTENT_SAMPLING_ATTRIBUTES: return "GetDisplayedContentSamplingAttributes"; |
| case HWC2_FUNCTION_SET_DISPLAYED_CONTENT_SAMPLING_ENABLED: return "SetDisplayedContentSamplingEnabled"; |
| case HWC2_FUNCTION_GET_DISPLAYED_CONTENT_SAMPLE: return "GetDisplayedContentSample"; |
| case HWC2_FUNCTION_SET_LAYER_PER_FRAME_METADATA_BLOBS: return "SetLayerPerFrameMetadataBlobs"; |
| case HWC2_FUNCTION_GET_DISPLAY_BRIGHTNESS_SUPPORT: return "GetDisplayBrightnessSupport"; |
| case HWC2_FUNCTION_SET_DISPLAY_BRIGHTNESS: return "SetDisplayBrightness"; |
| |
| // composer 2.4 |
| case HWC2_FUNCTION_GET_DISPLAY_CONNECTION_TYPE: return "GetDisplayConnectionType"; |
| case HWC2_FUNCTION_GET_DISPLAY_VSYNC_PERIOD: return "GetDisplayVsyncPeriod"; |
| case HWC2_FUNCTION_SET_ACTIVE_CONFIG_WITH_CONSTRAINTS: return "SetActiveConfigWithConstraints"; |
| case HWC2_FUNCTION_SET_AUTO_LOW_LATENCY_MODE: return "SetAutoLowLatencyMode"; |
| case HWC2_FUNCTION_GET_SUPPORTED_CONTENT_TYPES: return "GetSupportedContentTypes"; |
| case HWC2_FUNCTION_SET_CONTENT_TYPE: return "SetContentType"; |
| case HWC2_FUNCTION_GET_CLIENT_TARGET_PROPERTY: return "GetClientTargetProperty"; |
| case HWC2_FUNCTION_SET_LAYER_GENERIC_METADATA: return "SetLayerGenericMetadata"; |
| case HWC2_FUNCTION_GET_LAYER_GENERIC_METADATA_KEY: return "GetLayerGenericMetadataKey"; |
| |
| default: return "Unknown"; |
| } |
| } |
| |
| static inline const char* getLayerRequestName(hwc2_layer_request_t request) { |
| switch (__BIONIC_CAST(static_cast, int, request)) { |
| case 0: return "None"; |
| case HWC2_LAYER_REQUEST_CLEAR_CLIENT_TARGET: return "ClearClientTarget"; |
| default: return "Unknown"; |
| } |
| } |
| |
| static inline const char* getPowerModeName(hwc2_power_mode_t mode) { |
| switch (mode) { |
| case HWC2_POWER_MODE_OFF: return "Off"; |
| case HWC2_POWER_MODE_DOZE_SUSPEND: return "DozeSuspend"; |
| case HWC2_POWER_MODE_DOZE: return "Doze"; |
| case HWC2_POWER_MODE_ON: return "On"; |
| default: return "Unknown"; |
| } |
| } |
| |
| static inline const char* getContentTypeName(hwc2_content_type_t contentType) { |
| switch(contentType) { |
| case HWC2_CONTENT_TYPE_NONE: return "None"; |
| case HWC2_CONTENT_TYPE_GRAPHICS: return "Graphics"; |
| case HWC2_CONTENT_TYPE_PHOTO: return "Photo"; |
| case HWC2_CONTENT_TYPE_CINEMA: return "Cinema"; |
| case HWC2_CONTENT_TYPE_GAME: return "Game"; |
| default: return "Unknown"; |
| } |
| } |
| |
| static inline const char* getTransformName(hwc_transform_t transform) { |
| switch (__BIONIC_CAST(static_cast, int, transform)) { |
| case 0: return "None"; |
| case HWC_TRANSFORM_FLIP_H: return "FlipH"; |
| case HWC_TRANSFORM_FLIP_V: return "FlipV"; |
| case HWC_TRANSFORM_ROT_90: return "Rotate90"; |
| case HWC_TRANSFORM_ROT_180: return "Rotate180"; |
| case HWC_TRANSFORM_ROT_270: return "Rotate270"; |
| case HWC_TRANSFORM_FLIP_H_ROT_90: return "FlipHRotate90"; |
| case HWC_TRANSFORM_FLIP_V_ROT_90: return "FlipVRotate90"; |
| default: return "Unknown"; |
| } |
| } |
| |
| static inline const char* getVsyncName(hwc2_vsync_t vsync) { |
| switch (vsync) { |
| case HWC2_VSYNC_INVALID: return "Invalid"; |
| case HWC2_VSYNC_ENABLE: return "Enable"; |
| case HWC2_VSYNC_DISABLE: return "Disable"; |
| default: return "Unknown"; |
| } |
| } |
| |
| static inline const char* getDisplayedContentSamplingName( |
| hwc2_displayed_content_sampling_t sampling) { |
| switch (sampling) { |
| case HWC2_DISPLAYED_CONTENT_SAMPLING_INVALID: return "Invalid"; |
| case HWC2_DISPLAYED_CONTENT_SAMPLING_ENABLE: return "Enable"; |
| case HWC2_DISPLAYED_CONTENT_SAMPLING_DISABLE: return "Disable"; |
| default: return "Unknown"; |
| } |
| } |
| |
| static inline const char* getFormatColorComponentName(hwc2_format_color_component_t component) { |
| switch (component) { |
| case HWC2_FORMAT_COMPONENT_0: return "FirstComponent"; |
| case HWC2_FORMAT_COMPONENT_1: return "SecondComponent"; |
| case HWC2_FORMAT_COMPONENT_2: return "ThirdComponent"; |
| case HWC2_FORMAT_COMPONENT_3: return "FourthComponent"; |
| default: return "Unknown"; |
| } |
| } |
| |
| static inline const char* getDisplayCapabilityName(hwc2_display_capability_t capability) { |
| switch (capability) { |
| case HWC2_DISPLAY_CAPABILITY_INVALID: return "Invalid"; |
| case HWC2_DISPLAY_CAPABILITY_SKIP_CLIENT_COLOR_TRANSFORM: |
| return "SkipClientColorTransform"; |
| case HWC2_DISPLAY_CAPABILITY_DOZE: |
| return "Doze"; |
| case HWC2_DISPLAY_CAPABILITY_BRIGHTNESS: |
| return "Brightness"; |
| case HWC2_DISPLAY_CAPABILITY_AUTO_LOW_LATENCY_MODE: |
| return "AutoLowLatencyMode"; |
| default: |
| return "Unknown"; |
| } |
| } |
| |
| #define TO_STRING(E, T, printer) \ |
| inline std::string to_string(E value) { return printer(value); } \ |
| inline std::string to_string(T value) { return to_string(static_cast<E>(value)); } |
| #else // !HWC2_INCLUDE_STRINGIFICATION |
| #define TO_STRING(name, printer) |
| #endif // HWC2_INCLUDE_STRINGIFICATION |
| |
| /* |
| * C++11 features |
| */ |
| |
| #ifdef HWC2_USE_CPP11 |
| __END_DECLS |
| |
| #ifdef HWC2_INCLUDE_STRINGIFICATION |
| #include <string> |
| #endif |
| |
| namespace HWC2 { |
| |
| enum class Attribute : int32_t { |
| Invalid = HWC2_ATTRIBUTE_INVALID, |
| Width = HWC2_ATTRIBUTE_WIDTH, |
| Height = HWC2_ATTRIBUTE_HEIGHT, |
| VsyncPeriod = HWC2_ATTRIBUTE_VSYNC_PERIOD, |
| DpiX = HWC2_ATTRIBUTE_DPI_X, |
| DpiY = HWC2_ATTRIBUTE_DPI_Y, |
| ConfigGroup = HWC2_ATTRIBUTE_CONFIG_GROUP, |
| }; |
| TO_STRING(hwc2_attribute_t, Attribute, getAttributeName) |
| |
| enum class BlendMode : int32_t { |
| Invalid = HWC2_BLEND_MODE_INVALID, |
| None = HWC2_BLEND_MODE_NONE, |
| Premultiplied = HWC2_BLEND_MODE_PREMULTIPLIED, |
| Coverage = HWC2_BLEND_MODE_COVERAGE, |
| }; |
| TO_STRING(hwc2_blend_mode_t, BlendMode, getBlendModeName) |
| |
| enum class Callback : int32_t { |
| Invalid = HWC2_CALLBACK_INVALID, |
| Hotplug = HWC2_CALLBACK_HOTPLUG, |
| Refresh = HWC2_CALLBACK_REFRESH, |
| Vsync = HWC2_CALLBACK_VSYNC, |
| Vsync_2_4 = HWC2_CALLBACK_VSYNC_2_4, |
| VsyncPeriodTimingChanged = HWC2_CALLBACK_VSYNC_PERIOD_TIMING_CHANGED, |
| SeamlessPossible = HWC2_CALLBACK_SEAMLESS_POSSIBLE, |
| }; |
| TO_STRING(hwc2_callback_descriptor_t, Callback, getCallbackDescriptorName) |
| |
| enum class Capability : int32_t { |
| Invalid = HWC2_CAPABILITY_INVALID, |
| SidebandStream = HWC2_CAPABILITY_SIDEBAND_STREAM, |
| SkipClientColorTransform = HWC2_CAPABILITY_SKIP_CLIENT_COLOR_TRANSFORM, |
| PresentFenceIsNotReliable = HWC2_CAPABILITY_PRESENT_FENCE_IS_NOT_RELIABLE, |
| SkipValidate = HWC2_CAPABILITY_SKIP_VALIDATE, |
| }; |
| TO_STRING(hwc2_capability_t, Capability, getCapabilityName) |
| |
| enum class Composition : int32_t { |
| Invalid = HWC2_COMPOSITION_INVALID, |
| Client = HWC2_COMPOSITION_CLIENT, |
| Device = HWC2_COMPOSITION_DEVICE, |
| SolidColor = HWC2_COMPOSITION_SOLID_COLOR, |
| Cursor = HWC2_COMPOSITION_CURSOR, |
| Sideband = HWC2_COMPOSITION_SIDEBAND, |
| }; |
| TO_STRING(hwc2_composition_t, Composition, getCompositionName) |
| |
| enum class Connection : int32_t { |
| Invalid = HWC2_CONNECTION_INVALID, |
| Connected = HWC2_CONNECTION_CONNECTED, |
| Disconnected = HWC2_CONNECTION_DISCONNECTED, |
| }; |
| TO_STRING(hwc2_connection_t, Connection, getConnectionName) |
| |
| enum class DisplayRequest : int32_t { |
| FlipClientTarget = HWC2_DISPLAY_REQUEST_FLIP_CLIENT_TARGET, |
| WriteClientTargetToOutput = |
| HWC2_DISPLAY_REQUEST_WRITE_CLIENT_TARGET_TO_OUTPUT, |
| }; |
| TO_STRING(hwc2_display_request_t, DisplayRequest, getDisplayRequestName) |
| |
| enum class DisplayType : int32_t { |
| Invalid = HWC2_DISPLAY_TYPE_INVALID, |
| Physical = HWC2_DISPLAY_TYPE_PHYSICAL, |
| Virtual = HWC2_DISPLAY_TYPE_VIRTUAL, |
| }; |
| TO_STRING(hwc2_display_type_t, DisplayType, getDisplayTypeName) |
| |
| enum class DisplayConnectionType : uint32_t { |
| Internal = HWC2_DISPLAY_CONNECTION_TYPE_INTERNAL, |
| External = HWC2_DISPLAY_CONNECTION_TYPE_EXTERNAL, |
| }; |
| TO_STRING(hwc2_display_connection_type_t, DisplayConnectionType, getDisplayConnectionTypeName) |
| |
| enum class Error : int32_t { |
| None = HWC2_ERROR_NONE, |
| BadConfig = HWC2_ERROR_BAD_CONFIG, |
| BadDisplay = HWC2_ERROR_BAD_DISPLAY, |
| BadLayer = HWC2_ERROR_BAD_LAYER, |
| BadParameter = HWC2_ERROR_BAD_PARAMETER, |
| HasChanges = HWC2_ERROR_HAS_CHANGES, |
| NoResources = HWC2_ERROR_NO_RESOURCES, |
| NotValidated = HWC2_ERROR_NOT_VALIDATED, |
| Unsupported = HWC2_ERROR_UNSUPPORTED, |
| SeamlessNotAllowed = HWC2_ERROR_SEAMLESS_NOT_ALLOWED, |
| SeamlessNotPossible = HWC2_ERROR_SEAMLESS_NOT_POSSIBLE, |
| }; |
| TO_STRING(hwc2_error_t, Error, getErrorName) |
| |
| enum class FunctionDescriptor : int32_t { |
| Invalid = HWC2_FUNCTION_INVALID, |
| AcceptDisplayChanges = HWC2_FUNCTION_ACCEPT_DISPLAY_CHANGES, |
| CreateLayer = HWC2_FUNCTION_CREATE_LAYER, |
| CreateVirtualDisplay = HWC2_FUNCTION_CREATE_VIRTUAL_DISPLAY, |
| DestroyLayer = HWC2_FUNCTION_DESTROY_LAYER, |
| DestroyVirtualDisplay = HWC2_FUNCTION_DESTROY_VIRTUAL_DISPLAY, |
| Dump = HWC2_FUNCTION_DUMP, |
| GetActiveConfig = HWC2_FUNCTION_GET_ACTIVE_CONFIG, |
| GetChangedCompositionTypes = HWC2_FUNCTION_GET_CHANGED_COMPOSITION_TYPES, |
| GetClientTargetSupport = HWC2_FUNCTION_GET_CLIENT_TARGET_SUPPORT, |
| GetColorModes = HWC2_FUNCTION_GET_COLOR_MODES, |
| GetDisplayAttribute = HWC2_FUNCTION_GET_DISPLAY_ATTRIBUTE, |
| GetDisplayConfigs = HWC2_FUNCTION_GET_DISPLAY_CONFIGS, |
| GetDisplayName = HWC2_FUNCTION_GET_DISPLAY_NAME, |
| GetDisplayRequests = HWC2_FUNCTION_GET_DISPLAY_REQUESTS, |
| GetDisplayType = HWC2_FUNCTION_GET_DISPLAY_TYPE, |
| GetDozeSupport = HWC2_FUNCTION_GET_DOZE_SUPPORT, |
| GetHdrCapabilities = HWC2_FUNCTION_GET_HDR_CAPABILITIES, |
| GetMaxVirtualDisplayCount = HWC2_FUNCTION_GET_MAX_VIRTUAL_DISPLAY_COUNT, |
| GetReleaseFences = HWC2_FUNCTION_GET_RELEASE_FENCES, |
| PresentDisplay = HWC2_FUNCTION_PRESENT_DISPLAY, |
| RegisterCallback = HWC2_FUNCTION_REGISTER_CALLBACK, |
| SetActiveConfig = HWC2_FUNCTION_SET_ACTIVE_CONFIG, |
| SetClientTarget = HWC2_FUNCTION_SET_CLIENT_TARGET, |
| SetColorMode = HWC2_FUNCTION_SET_COLOR_MODE, |
| SetColorTransform = HWC2_FUNCTION_SET_COLOR_TRANSFORM, |
| SetCursorPosition = HWC2_FUNCTION_SET_CURSOR_POSITION, |
| SetLayerBlendMode = HWC2_FUNCTION_SET_LAYER_BLEND_MODE, |
| SetLayerBuffer = HWC2_FUNCTION_SET_LAYER_BUFFER, |
| SetLayerColor = HWC2_FUNCTION_SET_LAYER_COLOR, |
| SetLayerCompositionType = HWC2_FUNCTION_SET_LAYER_COMPOSITION_TYPE, |
| SetLayerDataspace = HWC2_FUNCTION_SET_LAYER_DATASPACE, |
| SetLayerDisplayFrame = HWC2_FUNCTION_SET_LAYER_DISPLAY_FRAME, |
| SetLayerPlaneAlpha = HWC2_FUNCTION_SET_LAYER_PLANE_ALPHA, |
| SetLayerSidebandStream = HWC2_FUNCTION_SET_LAYER_SIDEBAND_STREAM, |
| SetLayerSourceCrop = HWC2_FUNCTION_SET_LAYER_SOURCE_CROP, |
| SetLayerSurfaceDamage = HWC2_FUNCTION_SET_LAYER_SURFACE_DAMAGE, |
| SetLayerTransform = HWC2_FUNCTION_SET_LAYER_TRANSFORM, |
| SetLayerVisibleRegion = HWC2_FUNCTION_SET_LAYER_VISIBLE_REGION, |
| SetLayerZOrder = HWC2_FUNCTION_SET_LAYER_Z_ORDER, |
| SetOutputBuffer = HWC2_FUNCTION_SET_OUTPUT_BUFFER, |
| SetPowerMode = HWC2_FUNCTION_SET_POWER_MODE, |
| SetVsyncEnabled = HWC2_FUNCTION_SET_VSYNC_ENABLED, |
| ValidateDisplay = HWC2_FUNCTION_VALIDATE_DISPLAY, |
| SetLayerFloatColor = HWC2_FUNCTION_SET_LAYER_FLOAT_COLOR, |
| SetLayerPerFrameMetadata = HWC2_FUNCTION_SET_LAYER_PER_FRAME_METADATA, |
| GetPerFrameMetadataKeys = HWC2_FUNCTION_GET_PER_FRAME_METADATA_KEYS, |
| SetReadbackBuffer = HWC2_FUNCTION_SET_READBACK_BUFFER, |
| GetReadbackBufferAttributes = HWC2_FUNCTION_GET_READBACK_BUFFER_ATTRIBUTES, |
| GetReadbackBufferFence = HWC2_FUNCTION_GET_READBACK_BUFFER_FENCE, |
| GetRenderIntents = HWC2_FUNCTION_GET_RENDER_INTENTS, |
| SetColorModeWithRenderIntent = HWC2_FUNCTION_SET_COLOR_MODE_WITH_RENDER_INTENT, |
| GetDataspaceSaturationMatrix = HWC2_FUNCTION_GET_DATASPACE_SATURATION_MATRIX, |
| |
| // composer 2.3 |
| GetDisplayIdentificationData = HWC2_FUNCTION_GET_DISPLAY_IDENTIFICATION_DATA, |
| GetDisplayCapabilities = HWC2_FUNCTION_GET_DISPLAY_CAPABILITIES, |
| SetLayerColorTransform = HWC2_FUNCTION_SET_LAYER_COLOR_TRANSFORM, |
| GetDisplayedContentSamplingAttributes = HWC2_FUNCTION_GET_DISPLAYED_CONTENT_SAMPLING_ATTRIBUTES, |
| SetDisplayedContentSamplingEnabled = HWC2_FUNCTION_SET_DISPLAYED_CONTENT_SAMPLING_ENABLED, |
| GetDisplayedContentSample = HWC2_FUNCTION_GET_DISPLAYED_CONTENT_SAMPLE, |
| SetLayerPerFrameMetadataBlobs = HWC2_FUNCTION_SET_LAYER_PER_FRAME_METADATA_BLOBS, |
| GetDisplayBrightnessSupport = HWC2_FUNCTION_GET_DISPLAY_BRIGHTNESS_SUPPORT, |
| SetDisplayBrightness = HWC2_FUNCTION_SET_DISPLAY_BRIGHTNESS, |
| |
| // composer 2.4 |
| GetDisplayConnectionType = HWC2_FUNCTION_GET_DISPLAY_CONNECTION_TYPE, |
| GetDisplayVsyncPeriod = HWC2_FUNCTION_GET_DISPLAY_VSYNC_PERIOD, |
| SetActiveConfigWithConstraints = HWC2_FUNCTION_SET_ACTIVE_CONFIG_WITH_CONSTRAINTS, |
| SetAutoLowLatencyMode = HWC2_FUNCTION_SET_AUTO_LOW_LATENCY_MODE, |
| GetSupportedContentTypes = HWC2_FUNCTION_GET_SUPPORTED_CONTENT_TYPES, |
| SetContentType = HWC2_FUNCTION_SET_CONTENT_TYPE, |
| GetClientTargetProperty = HWC2_FUNCTION_GET_CLIENT_TARGET_PROPERTY, |
| SetLayerGenericMetadata = HWC2_FUNCTION_SET_LAYER_GENERIC_METADATA, |
| GetLayerGenericMetadataKey = HWC2_FUNCTION_GET_LAYER_GENERIC_METADATA_KEY, |
| }; |
| TO_STRING(hwc2_function_descriptor_t, FunctionDescriptor, |
| getFunctionDescriptorName) |
| |
| enum class LayerRequest : int32_t { |
| ClearClientTarget = HWC2_LAYER_REQUEST_CLEAR_CLIENT_TARGET, |
| }; |
| TO_STRING(hwc2_layer_request_t, LayerRequest, getLayerRequestName) |
| |
| enum class PowerMode : int32_t { |
| Off = HWC2_POWER_MODE_OFF, |
| DozeSuspend = HWC2_POWER_MODE_DOZE_SUSPEND, |
| Doze = HWC2_POWER_MODE_DOZE, |
| On = HWC2_POWER_MODE_ON, |
| }; |
| TO_STRING(hwc2_power_mode_t, PowerMode, getPowerModeName) |
| |
| enum class ContentType : int32_t { |
| None = HWC2_CONTENT_TYPE_NONE, |
| Graphics = HWC2_CONTENT_TYPE_GRAPHICS, |
| Photo = HWC2_CONTENT_TYPE_PHOTO, |
| Cinema = HWC2_CONTENT_TYPE_CINEMA, |
| Game = HWC2_CONTENT_TYPE_GAME, |
| }; |
| TO_STRING(hwc2_content_type_t, ContentType, getContentTypeName) |
| |
| enum class Transform : int32_t { |
| None = 0, |
| FlipH = HWC_TRANSFORM_FLIP_H, |
| FlipV = HWC_TRANSFORM_FLIP_V, |
| Rotate90 = HWC_TRANSFORM_ROT_90, |
| Rotate180 = HWC_TRANSFORM_ROT_180, |
| Rotate270 = HWC_TRANSFORM_ROT_270, |
| FlipHRotate90 = HWC_TRANSFORM_FLIP_H_ROT_90, |
| FlipVRotate90 = HWC_TRANSFORM_FLIP_V_ROT_90, |
| }; |
| TO_STRING(hwc_transform_t, Transform, getTransformName) |
| |
| enum class Vsync : int32_t { |
| Invalid = HWC2_VSYNC_INVALID, |
| Enable = HWC2_VSYNC_ENABLE, |
| Disable = HWC2_VSYNC_DISABLE, |
| }; |
| TO_STRING(hwc2_vsync_t, Vsync, getVsyncName) |
| |
| enum class DisplayCapability : int32_t { |
| Invalid = HWC2_DISPLAY_CAPABILITY_INVALID, |
| SkipClientColorTransform = HWC2_DISPLAY_CAPABILITY_SKIP_CLIENT_COLOR_TRANSFORM, |
| Doze = HWC2_DISPLAY_CAPABILITY_DOZE, |
| Brightness = HWC2_DISPLAY_CAPABILITY_BRIGHTNESS, |
| AutoLowLatencyMode = HWC2_DISPLAY_CAPABILITY_AUTO_LOW_LATENCY_MODE, |
| }; |
| TO_STRING(hwc2_display_capability_t, DisplayCapability, getDisplayCapabilityName) |
| |
| } // namespace HWC2 |
| |
| __BEGIN_DECLS |
| #endif // HWC2_USE_CPP11 |
| |
| /* |
| * Typedefs |
| */ |
| |
| typedef void (*hwc2_function_pointer_t)(); |
| |
| typedef void* hwc2_callback_data_t; |
| typedef uint32_t hwc2_config_t; |
| typedef uint64_t hwc2_display_t; |
| typedef uint64_t hwc2_layer_t; |
| typedef uint32_t hwc2_vsync_period_t; |
| |
| /* |
| * Device Struct |
| */ |
| |
| typedef struct hwc2_device { |
| /* Must be the first member of this struct, since a pointer to this struct |
| * will be generated by casting from a hw_device_t* */ |
| struct hw_device_t common; |
| |
| /* getCapabilities(..., outCount, outCapabilities) |
| * |
| * Provides a list of capabilities (described in the definition of |
| * hwc2_capability_t above) supported by this device. This list must |
| * not change after the device has been loaded. |
| * |
| * Parameters: |
| * outCount - if outCapabilities was NULL, the number of capabilities |
| * which would have been returned; if outCapabilities was not NULL, |
| * the number of capabilities returned, which must not exceed the |
| * value stored in outCount prior to the call |
| * outCapabilities - a list of capabilities supported by this device; may |
| * be NULL, in which case this function must write into outCount the |
| * number of capabilities which would have been written into |
| * outCapabilities |
| */ |
| void (*getCapabilities)(struct hwc2_device* device, uint32_t* outCount, |
| int32_t* /*hwc2_capability_t*/ outCapabilities); |
| |
| /* getFunction(..., descriptor) |
| * |
| * Returns a function pointer which implements the requested description. |
| * |
| * Parameters: |
| * descriptor - the function to return |
| * |
| * Returns either a function pointer implementing the requested descriptor |
| * or NULL if the described function is not supported by this device. |
| */ |
| hwc2_function_pointer_t (*getFunction)(struct hwc2_device* device, |
| int32_t /*hwc2_function_descriptor_t*/ descriptor); |
| } hwc2_device_t; |
| |
| static inline int hwc2_open(const struct hw_module_t* module, |
| hwc2_device_t** device) { |
| return module->methods->open(module, HWC_HARDWARE_COMPOSER, |
| TO_HW_DEVICE_T_OPEN(device)); |
| } |
| |
| static inline int hwc2_close(hwc2_device_t* device) { |
| return device->common.close(&device->common); |
| } |
| |
| /* |
| * Callbacks |
| * |
| * All of these callbacks take as their first parameter the callbackData which |
| * was provided at the time of callback registration, so this parameter is |
| * omitted from the described parameter lists. |
| */ |
| |
| /* hotplug(..., display, connected) |
| * Descriptor: HWC2_CALLBACK_HOTPLUG |
| * Will be provided to all HWC2 devices |
| * |
| * Notifies the client that the given display has either been connected or |
| * disconnected. Every active display (even a built-in physical display) must |
| * trigger at least one hotplug notification, even if it only occurs immediately |
| * after callback registration. |
| * |
| * The client may call back into the device on the same thread to query display |
| * properties (such as width, height, and vsync period), and other threads may |
| * call into the device while the callback is in progress. The device must |
| * serialize calls to this callback such that only one thread is calling it at a |
| * time. |
| * |
| * Displays which have been connected are assumed to be in HWC2_POWER_MODE_OFF, |
| * and the vsync callback should not be called for a display until vsync has |
| * been enabled with setVsyncEnabled. |
| * |
| * Parameters: |
| * display - the display which has been hotplugged |
| * connected - whether the display has been connected or disconnected |
| */ |
| typedef void (*HWC2_PFN_HOTPLUG)(hwc2_callback_data_t callbackData, |
| hwc2_display_t display, int32_t /*hwc2_connection_t*/ connected); |
| |
| /* refresh(..., display) |
| * Descriptor: HWC2_CALLBACK_REFRESH |
| * Will be provided to all HWC2 devices |
| * |
| * Notifies the client to trigger a screen refresh. This forces all layer state |
| * for this display to be resent, and the display to be validated and presented, |
| * even if there have been no changes. |
| * |
| * This refresh will occur some time after the callback is initiated, but not |
| * necessarily before it returns. This thread, however, is guaranteed not to |
| * call back into the device, thus it is safe to trigger this callback from |
| * other functions which call into the device. |
| * |
| * Parameters: |
| * display - the display to refresh |
| */ |
| typedef void (*HWC2_PFN_REFRESH)(hwc2_callback_data_t callbackData, |
| hwc2_display_t display); |
| |
| /* vsync(..., display, timestamp) |
| * Descriptor: HWC2_CALLBACK_VSYNC |
| * Will be provided to all HWC2 devices |
| * |
| * Notifies the client that a vsync event has occurred. This callback must |
| * only be triggered when vsync is enabled for this display (through |
| * setVsyncEnabled). |
| * |
| * This callback should be triggered from a thread of at least |
| * HAL_PRIORITY_URGENT_DISPLAY with as little latency as possible, typically |
| * less than 0.5 ms. This thread is guaranteed not to call back into the device. |
| * |
| * Parameters: |
| * display - the display which has received a vsync event |
| * timestamp - the CLOCK_MONOTONIC time at which the vsync event occurred, in |
| * nanoseconds |
| */ |
| typedef void (*HWC2_PFN_VSYNC)(hwc2_callback_data_t callbackData, |
| hwc2_display_t display, int64_t timestamp); |
| |
| /* vsync_2_4(..., display, timestamp, vsyncPeriodNanos) |
| * Descriptor: HWC2_CALLBACK_VSYNC_2_4 |
| * Required for HWC2 devices for composer 2.4 |
| * |
| * Notifies the client that a vsync event has occurred. This callback must |
| * only be triggered when vsync is enabled for this display (through |
| * setVsyncEnabled). |
| * |
| * This callback should be triggered from a thread of at least |
| * HAL_PRIORITY_URGENT_DISPLAY with as little latency as possible, typically |
| * less than 0.5 ms. This thread is guaranteed not to call back into the device. |
| * |
| * Parameters: |
| * display - the display which has received a vsync event |
| * timestamp - the CLOCK_MONOTONIC time at which the vsync event occurred, in |
| * nanoseconds |
| * vsyncPeriodNanos - the display vsync period in nanoseconds i.e. the next onVsync2_4 is |
| * expected to be called vsyncPeriod nanoseconds after this call. |
| */ |
| typedef void (*HWC2_PFN_VSYNC_2_4)(hwc2_callback_data_t callbackData, |
| hwc2_display_t display, int64_t timestamp, hwc2_vsync_period_t vsyncPeriodNanos); |
| |
| /* vsyncPeriodTimingChanged(..., display, updated_timeline) |
| * Descriptor: HWC2_CALLBACK_VSYNC_PERIOD_TIMING_CHANGED |
| * Optional for HWC2 devices for composer 2.4 |
| * |
| * Notifies the client that the previously reported timing for vsync period change has been |
| * updated. This may occur if the composer missed the deadline for changing the vsync period |
| * or the client submitted a refresh frame too late. |
| * |
| * This callback should be triggered from a thread of at least |
| * HAL_PRIORITY_URGENT_DISPLAY with as little latency as possible, typically |
| * less than 0.5 ms. This thread is guaranteed not to call back into the device. |
| * |
| * Parameters: |
| * display - the display which has received a vsync event |
| * updated_timeline - new timeline for the vsync period change |
| */ |
| typedef void (*HWC2_PFN_VSYNC_PERIOD_TIMING_CHANGED)(hwc2_callback_data_t callbackData, |
| hwc2_display_t display, hwc_vsync_period_change_timeline_t* updated_timeline); |
| |
| /* SeamlessPossible(..., display) |
| * Descriptor: HWC2_CALLBACK_SEAMLESS_POSSIBLE |
| * Optional for HWC2 devices for composer 2.4 |
| * |
| * Notifies the client that the conditions which previously led to returning SEAMLESS_NOT_POSSIBLE |
| * from setActiveConfigWithConstraints have changed and now seamless may be possible. Client should |
| * retry calling setActiveConfigWithConstraints. |
| * |
| * |
| * Parameters: |
| * display - a display setActiveConfigWithConstraints previously failed with |
| * SEAMLESS_NOT_POSSIBLE. |
| */ |
| typedef void (*HWC2_PFN_SEAMLESS_POSSIBLE)(hwc2_callback_data_t callbackData, |
| hwc2_display_t display); |
| |
| /* |
| * Device Functions |
| * |
| * All of these functions take as their first parameter a device pointer, so |
| * this parameter is omitted from the described parameter lists. |
| */ |
| |
| /* createVirtualDisplay(..., width, height, format, outDisplay) |
| * Descriptor: HWC2_FUNCTION_CREATE_VIRTUAL_DISPLAY |
| * Must be provided by all HWC2 devices |
| * |
| * Creates a new virtual display with the given width and height. The format |
| * passed into this function is the default format requested by the consumer of |
| * the virtual display output buffers. If a different format will be returned by |
| * the device, it should be returned in this parameter so it can be set properly |
| * when handing the buffers to the consumer. |
| * |
| * The display will be assumed to be on from the time the first frame is |
| * presented until the display is destroyed. |
| * |
| * Parameters: |
| * width - width in pixels |
| * height - height in pixels |
| * format - prior to the call, the default output buffer format selected by |
| * the consumer; after the call, the format the device will produce |
| * outDisplay - the newly-created virtual display; pointer will be non-NULL |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_UNSUPPORTED - the width or height is too large for the device to |
| * be able to create a virtual display |
| * HWC2_ERROR_NO_RESOURCES - the device is unable to create a new virtual |
| * display at this time |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_CREATE_VIRTUAL_DISPLAY)( |
| hwc2_device_t* device, uint32_t width, uint32_t height, |
| int32_t* /*android_pixel_format_t*/ format, hwc2_display_t* outDisplay); |
| |
| /* destroyVirtualDisplay(..., display) |
| * Descriptor: HWC2_FUNCTION_DESTROY_VIRTUAL_DISPLAY |
| * Must be provided by all HWC2 devices |
| * |
| * Destroys a virtual display. After this call all resources consumed by this |
| * display may be freed by the device and any operations performed on this |
| * display should fail. |
| * |
| * Parameters: |
| * display - the virtual display to destroy |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in |
| * HWC2_ERROR_BAD_PARAMETER - the display handle which was passed in does not |
| * refer to a virtual display |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_DESTROY_VIRTUAL_DISPLAY)( |
| hwc2_device_t* device, hwc2_display_t display); |
| |
| /* dump(..., outSize, outBuffer) |
| * Descriptor: HWC2_FUNCTION_DUMP |
| * Must be provided by all HWC2 devices |
| * |
| * Retrieves implementation-defined debug information, which will be displayed |
| * during, for example, `dumpsys SurfaceFlinger`. |
| * |
| * If called with outBuffer == NULL, the device should store a copy of the |
| * desired output and return its length in bytes in outSize. If the device |
| * already has a stored copy, that copy should be purged and replaced with a |
| * fresh copy. |
| * |
| * If called with outBuffer != NULL, the device should copy its stored version |
| * of the output into outBuffer and store how many bytes of data it copied into |
| * outSize. Prior to this call, the client will have populated outSize with the |
| * maximum number of bytes outBuffer can hold. The device must not write more |
| * than this amount into outBuffer. If the device does not currently have a |
| * stored copy, then it should return 0 in outSize. |
| * |
| * Any data written into outBuffer need not be null-terminated. |
| * |
| * Parameters: |
| * outSize - if outBuffer was NULL, the number of bytes needed to copy the |
| * device's stored output; if outBuffer was not NULL, the number of bytes |
| * written into it, which must not exceed the value stored in outSize |
| * prior to the call; pointer will be non-NULL |
| * outBuffer - the buffer to write the dump output into; may be NULL as |
| * described above; data written into this buffer need not be |
| * null-terminated |
| */ |
| typedef void (*HWC2_PFN_DUMP)(hwc2_device_t* device, uint32_t* outSize, |
| char* outBuffer); |
| |
| /* getMaxVirtualDisplayCount(...) |
| * Descriptor: HWC2_FUNCTION_GET_MAX_VIRTUAL_DISPLAY_COUNT |
| * Must be provided by all HWC2 devices |
| * |
| * Returns the maximum number of virtual displays supported by this device |
| * (which may be 0). The client will not attempt to create more than this many |
| * virtual displays on this device. This number must not change for the lifetime |
| * of the device. |
| */ |
| typedef uint32_t (*HWC2_PFN_GET_MAX_VIRTUAL_DISPLAY_COUNT)( |
| hwc2_device_t* device); |
| |
| /* registerCallback(..., descriptor, callbackData, pointer) |
| * Descriptor: HWC2_FUNCTION_REGISTER_CALLBACK |
| * Must be provided by all HWC2 devices |
| * |
| * Provides a callback for the device to call. All callbacks take a callbackData |
| * item as the first parameter, so this value should be stored with the callback |
| * for later use. The callbackData may differ from one callback to another. If |
| * this function is called multiple times with the same descriptor, later |
| * callbacks replace earlier ones. |
| * |
| * Parameters: |
| * descriptor - which callback should be set |
| * callBackdata - opaque data which must be passed back through the callback |
| * pointer - a non-NULL function pointer corresponding to the descriptor |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_PARAMETER - descriptor was invalid |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_REGISTER_CALLBACK)( |
| hwc2_device_t* device, |
| int32_t /*hwc2_callback_descriptor_t*/ descriptor, |
| hwc2_callback_data_t callbackData, hwc2_function_pointer_t pointer); |
| |
| /* getDataspaceSaturationMatrix(..., dataspace, outMatrix) |
| * Descriptor: HWC2_FUNCTION_GET_DATASPACE_SATURATION_MATRIX |
| * Provided by HWC2 devices which don't return nullptr function pointer. |
| * |
| * Get the saturation matrix of the specified dataspace. The saturation matrix |
| * can be used to approximate the dataspace saturation operation performed by |
| * the HWC2 device when non-colorimetric mapping is allowed. It is to be |
| * applied on linear pixel values. |
| * |
| * Parameters: |
| * dataspace - the dataspace to query for |
| * outMatrix - a column-major 4x4 matrix (16 floats). It must be an identity |
| * matrix unless dataspace is HAL_DATASPACE_SRGB_LINEAR. |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_PARAMETER - dataspace was invalid |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_GET_DATASPACE_SATURATION_MATRIX)( |
| hwc2_device_t* device, int32_t /*android_dataspace_t*/ dataspace, |
| float* outMatrix); |
| |
| /* |
| * Display Functions |
| * |
| * All of these functions take as their first two parameters a device pointer |
| * and a display handle, so these parameters are omitted from the described |
| * parameter lists. |
| */ |
| |
| /* acceptDisplayChanges(...) |
| * Descriptor: HWC2_FUNCTION_ACCEPT_DISPLAY_CHANGES |
| * Must be provided by all HWC2 devices |
| * |
| * Accepts the changes required by the device from the previous validateDisplay |
| * call (which may be queried using getChangedCompositionTypes) and revalidates |
| * the display. This function is equivalent to requesting the changed types from |
| * getChangedCompositionTypes, setting those types on the corresponding layers, |
| * and then calling validateDisplay again. |
| * |
| * After this call it must be valid to present this display. Calling this after |
| * validateDisplay returns 0 changes must succeed with HWC2_ERROR_NONE, but |
| * should have no other effect. |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in |
| * HWC2_ERROR_NOT_VALIDATED - validateDisplay has not been called |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_ACCEPT_DISPLAY_CHANGES)( |
| hwc2_device_t* device, hwc2_display_t display); |
| |
| /* createLayer(..., outLayer) |
| * Descriptor: HWC2_FUNCTION_CREATE_LAYER |
| * Must be provided by all HWC2 devices |
| * |
| * Creates a new layer on the given display. |
| * |
| * Parameters: |
| * outLayer - the handle of the new layer; pointer will be non-NULL |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in |
| * HWC2_ERROR_NO_RESOURCES - the device was unable to create this layer |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_CREATE_LAYER)(hwc2_device_t* device, |
| hwc2_display_t display, hwc2_layer_t* outLayer); |
| |
| /* destroyLayer(..., layer) |
| * Descriptor: HWC2_FUNCTION_DESTROY_LAYER |
| * Must be provided by all HWC2 devices |
| * |
| * Destroys the given layer. |
| * |
| * Parameters: |
| * layer - the handle of the layer to destroy |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in |
| * HWC2_ERROR_BAD_LAYER - an invalid layer handle was passed in |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_DESTROY_LAYER)( |
| hwc2_device_t* device, hwc2_display_t display, hwc2_layer_t layer); |
| |
| /* getActiveConfig(..., outConfig) |
| * Descriptor: HWC2_FUNCTION_GET_ACTIVE_CONFIG |
| * Must be provided by all HWC2 devices |
| * |
| * Retrieves which display configuration is currently active. |
| * |
| * If no display configuration is currently active, this function must return |
| * HWC2_ERROR_BAD_CONFIG and place no configuration handle in outConfig. It is |
| * the responsibility of the client to call setActiveConfig with a valid |
| * configuration before attempting to present anything on the display. |
| * |
| * Parameters: |
| * outConfig - the currently active display configuration; pointer will be |
| * non-NULL |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in |
| * HWC2_ERROR_BAD_CONFIG - no configuration is currently active |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_GET_ACTIVE_CONFIG)( |
| hwc2_device_t* device, hwc2_display_t display, |
| hwc2_config_t* outConfig); |
| |
| /* getChangedCompositionTypes(..., outNumElements, outLayers, outTypes) |
| * Descriptor: HWC2_FUNCTION_GET_CHANGED_COMPOSITION_TYPES |
| * Must be provided by all HWC2 devices |
| * |
| * Retrieves the layers for which the device requires a different composition |
| * type than had been set prior to the last call to validateDisplay. The client |
| * will either update its state with these types and call acceptDisplayChanges, |
| * or will set new types and attempt to validate the display again. |
| * |
| * outLayers and outTypes may be NULL to retrieve the number of elements which |
| * will be returned. The number of elements returned must be the same as the |
| * value returned in outNumTypes from the last call to validateDisplay. |
| * |
| * Parameters: |
| * outNumElements - if outLayers or outTypes were NULL, the number of layers |
| * and types which would have been returned; if both were non-NULL, the |
| * number of elements returned in outLayers and outTypes, which must not |
| * exceed the value stored in outNumElements prior to the call; pointer |
| * will be non-NULL |
| * outLayers - an array of layer handles |
| * outTypes - an array of composition types, each corresponding to an element |
| * of outLayers |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in |
| * HWC2_ERROR_NOT_VALIDATED - validateDisplay has not been called for this |
| * display |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_GET_CHANGED_COMPOSITION_TYPES)( |
| hwc2_device_t* device, hwc2_display_t display, |
| uint32_t* outNumElements, hwc2_layer_t* outLayers, |
| int32_t* /*hwc2_composition_t*/ outTypes); |
| |
| /* getClientTargetSupport(..., width, height, format, dataspace) |
| * Descriptor: HWC2_FUNCTION_GET_CLIENT_TARGET_SUPPORT |
| * Must be provided by all HWC2 devices |
| * |
| * Returns whether a client target with the given properties can be handled by |
| * the device. |
| * |
| * The valid formats can be found in android_pixel_format_t in |
| * <system/graphics.h>. |
| * |
| * For more about dataspaces, see setLayerDataspace. |
| * |
| * This function must return true for a client target with width and height |
| * equal to the active display configuration dimensions, |
| * HAL_PIXEL_FORMAT_RGBA_8888, and HAL_DATASPACE_UNKNOWN. It is not required to |
| * return true for any other configuration. |
| * |
| * Parameters: |
| * width - client target width in pixels |
| * height - client target height in pixels |
| * format - client target format |
| * dataspace - client target dataspace, as described in setLayerDataspace |
| * |
| * Returns HWC2_ERROR_NONE if the given configuration is supported or one of the |
| * following errors: |
| * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in |
| * HWC2_ERROR_UNSUPPORTED - the given configuration is not supported |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_GET_CLIENT_TARGET_SUPPORT)( |
| hwc2_device_t* device, hwc2_display_t display, uint32_t width, |
| uint32_t height, int32_t /*android_pixel_format_t*/ format, |
| int32_t /*android_dataspace_t*/ dataspace); |
| |
| /* getColorModes(..., outNumModes, outModes) |
| * Descriptor: HWC2_FUNCTION_GET_COLOR_MODES |
| * Must be provided by all HWC2 devices |
| * |
| * Returns the color modes supported on this display. |
| * |
| * The valid color modes can be found in android_color_mode_t in |
| * <system/graphics.h>. All HWC2 devices must support at least |
| * HAL_COLOR_MODE_NATIVE. |
| * |
| * outNumModes may be NULL to retrieve the number of modes which will be |
| * returned. |
| * |
| * Parameters: |
| * outNumModes - if outModes was NULL, the number of modes which would have |
| * been returned; if outModes was not NULL, the number of modes returned, |
| * which must not exceed the value stored in outNumModes prior to the |
| * call; pointer will be non-NULL |
| * outModes - an array of color modes |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_GET_COLOR_MODES)( |
| hwc2_device_t* device, hwc2_display_t display, uint32_t* outNumModes, |
| int32_t* /*android_color_mode_t*/ outModes); |
| |
| /* getRenderIntents(..., mode, outNumIntents, outIntents) |
| * Descriptor: HWC2_FUNCTION_GET_RENDER_INTENTS |
| * Provided by HWC2 devices which don't return nullptr function pointer. |
| * |
| * Returns the render intents supported on this display. |
| * |
| * The valid render intents can be found in android_render_intent_v1_1_t in |
| * <system/graphics.h>. All HWC2 devices must support at least |
| * HAL_RENDER_INTENT_COLORIMETRIC. |
| * |
| * outNumIntents may be NULL to retrieve the number of intents which will be |
| * returned. |
| * |
| * Parameters: |
| * mode - the color mode to query the render intents for |
| * outNumIntents - if outIntents was NULL, the number of intents which would |
| * have been returned; if outIntents was not NULL, the number of intents |
| * returned, which must not exceed the value stored in outNumIntents |
| * prior to the call; pointer will be non-NULL |
| * outIntents - an array of render intents |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_GET_RENDER_INTENTS)( |
| hwc2_device_t* device, hwc2_display_t display, int32_t mode, |
| uint32_t* outNumIntents, |
| int32_t* /*android_render_intent_v1_1_t*/ outIntents); |
| |
| /* getDisplayAttribute(..., config, attribute, outValue) |
| * Descriptor: HWC2_FUNCTION_GET_DISPLAY_ATTRIBUTE |
| * Must be provided by all HWC2 devices |
| * |
| * Returns a display attribute value for a particular display configuration. |
| * |
| * Any attribute which is not supported or for which the value is unknown by the |
| * device must return a value of -1. |
| * |
| * Parameters: |
| * config - the display configuration for which to return attribute values |
| * attribute - the attribute to query |
| * outValue - the value of the attribute; the pointer will be non-NULL |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in |
| * HWC2_ERROR_BAD_CONFIG - config does not name a valid configuration for this |
| * display |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_GET_DISPLAY_ATTRIBUTE)( |
| hwc2_device_t* device, hwc2_display_t display, hwc2_config_t config, |
| int32_t /*hwc2_attribute_t*/ attribute, int32_t* outValue); |
| |
| /* getDisplayConfigs(..., outNumConfigs, outConfigs) |
| * Descriptor: HWC2_FUNCTION_GET_DISPLAY_CONFIGS |
| * Must be provided by all HWC2 devices |
| * |
| * Returns handles for all of the valid display configurations on this display. |
| * |
| * outConfigs may be NULL to retrieve the number of elements which will be |
| * returned. |
| * |
| * Parameters: |
| * outNumConfigs - if outConfigs was NULL, the number of configurations which |
| * would have been returned; if outConfigs was not NULL, the number of |
| * configurations returned, which must not exceed the value stored in |
| * outNumConfigs prior to the call; pointer will be non-NULL |
| * outConfigs - an array of configuration handles |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_GET_DISPLAY_CONFIGS)( |
| hwc2_device_t* device, hwc2_display_t display, uint32_t* outNumConfigs, |
| hwc2_config_t* outConfigs); |
| |
| /* getDisplayName(..., outSize, outName) |
| * Descriptor: HWC2_FUNCTION_GET_DISPLAY_NAME |
| * Must be provided by all HWC2 devices |
| * |
| * Returns a human-readable version of the display's name. |
| * |
| * outName may be NULL to retrieve the length of the name. |
| * |
| * Parameters: |
| * outSize - if outName was NULL, the number of bytes needed to return the |
| * name if outName was not NULL, the number of bytes written into it, |
| * which must not exceed the value stored in outSize prior to the call; |
| * pointer will be non-NULL |
| * outName - the display's name |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_GET_DISPLAY_NAME)( |
| hwc2_device_t* device, hwc2_display_t display, uint32_t* outSize, |
| char* outName); |
| |
| /* getDisplayRequests(..., outDisplayRequests, outNumElements, outLayers, |
| * outLayerRequests) |
| * Descriptor: HWC2_FUNCTION_GET_DISPLAY_REQUESTS |
| * Must be provided by all HWC2 devices |
| * |
| * Returns the display requests and the layer requests required for the last |
| * validated configuration. |
| * |
| * Display requests provide information about how the client should handle the |
| * client target. Layer requests provide information about how the client |
| * should handle an individual layer. |
| * |
| * If outLayers or outLayerRequests is NULL, the required number of layers and |
| * requests must be returned in outNumElements, but this number may also be |
| * obtained from validateDisplay as outNumRequests (outNumElements must be equal |
| * to the value returned in outNumRequests from the last call to |
| * validateDisplay). |
| * |
| * Parameters: |
| * outDisplayRequests - the display requests for the current validated state |
| * outNumElements - if outLayers or outLayerRequests were NULL, the number of |
| * elements which would have been returned, which must be equal to the |
| * value returned in outNumRequests from the last validateDisplay call on |
| * this display; if both were not NULL, the number of elements in |
| * outLayers and outLayerRequests, which must not exceed the value stored |
| * in outNumElements prior to the call; pointer will be non-NULL |
| * outLayers - an array of layers which all have at least one request |
| * outLayerRequests - the requests corresponding to each element of outLayers |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in |
| * HWC2_ERROR_NOT_VALIDATED - validateDisplay has not been called for this |
| * display |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_GET_DISPLAY_REQUESTS)( |
| hwc2_device_t* device, hwc2_display_t display, |
| int32_t* /*hwc2_display_request_t*/ outDisplayRequests, |
| uint32_t* outNumElements, hwc2_layer_t* outLayers, |
| int32_t* /*hwc2_layer_request_t*/ outLayerRequests); |
| |
| /* getDisplayType(..., outType) |
| * Descriptor: HWC2_FUNCTION_GET_DISPLAY_TYPE |
| * Must be provided by all HWC2 devices |
| * |
| * Returns whether the given display is a physical or virtual display. |
| * |
| * Parameters: |
| * outType - the type of the display; pointer will be non-NULL |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_GET_DISPLAY_TYPE)( |
| hwc2_device_t* device, hwc2_display_t display, |
| int32_t* /*hwc2_display_type_t*/ outType); |
| |
| /* getDisplayIdentificationData(..., outPort, outDataSize, outData) |
| * Descriptor: HWC2_FUNCTION_GET_DISPLAY_IDENTIFICATION_DATA |
| * Optional for HWC2 devices |
| * |
| * If supported, getDisplayIdentificationData returns the port and data that |
| * describe a physical display. The port is a unique number that identifies a |
| * physical connector (e.g. eDP, HDMI) for display output. The data blob is |
| * parsed to determine its format, typically EDID 1.3 as specified in VESA |
| * E-EDID Standard Release A Revision 1. |
| * |
| * Devices for which display identification is unsupported must return null when |
| * getFunction is called with HWC2_FUNCTION_GET_DISPLAY_IDENTIFICATION_DATA. |
| * |
| * Parameters: |
| * outPort - the connector to which the display is connected; |
| * pointer will be non-NULL |
| * outDataSize - if outData is NULL, the size in bytes of the data which would |
| * have been returned; if outData is not NULL, the size of outData, which |
| * must not exceed the value stored in outDataSize prior to the call; |
| * pointer will be non-NULL |
| * outData - the EDID 1.3 blob identifying the display |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_GET_DISPLAY_IDENTIFICATION_DATA)( |
| hwc2_device_t* device, hwc2_display_t display, uint8_t* outPort, |
| uint32_t* outDataSize, uint8_t* outData); |
| |
| /* getDozeSupport(..., outSupport) |
| * Descriptor: HWC2_FUNCTION_GET_DOZE_SUPPORT |
| * Must be provided by all HWC2 devices |
| * |
| * Returns whether the given display supports HWC2_POWER_MODE_DOZE and |
| * HWC2_POWER_MODE_DOZE_SUSPEND. DOZE_SUSPEND may not provide any benefit over |
| * DOZE (see the definition of hwc2_power_mode_t for more information), but if |
| * both DOZE and DOZE_SUSPEND are no different from HWC2_POWER_MODE_ON, the |
| * device should not claim support. |
| * |
| * Parameters: |
| * outSupport - whether the display supports doze modes (1 for yes, 0 for no); |
| * pointer will be non-NULL |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_GET_DOZE_SUPPORT)( |
| hwc2_device_t* device, hwc2_display_t display, int32_t* outSupport); |
| |
| /* getHdrCapabilities(..., outNumTypes, outTypes, outMaxLuminance, |
| * outMaxAverageLuminance, outMinLuminance) |
| * Descriptor: HWC2_FUNCTION_GET_HDR_CAPABILITIES |
| * Must be provided by all HWC2 devices |
| * |
| * Returns the high dynamic range (HDR) capabilities of the given display, which |
| * are invariant with regard to the active configuration. |
| * |
| * Displays which are not HDR-capable must return no types in outTypes and set |
| * outNumTypes to 0. |
| * |
| * If outTypes is NULL, the required number of HDR types must be returned in |
| * outNumTypes. |
| * |
| * Parameters: |
| * outNumTypes - if outTypes was NULL, the number of types which would have |
| * been returned; if it was not NULL, the number of types stored in |
| * outTypes, which must not exceed the value stored in outNumTypes prior |
| * to the call; pointer will be non-NULL |
| * outTypes - an array of HDR types, may have 0 elements if the display is not |
| * HDR-capable |
| * outMaxLuminance - the desired content maximum luminance for this display in |
| * cd/m^2; pointer will be non-NULL |
| * outMaxAverageLuminance - the desired content maximum frame-average |
| * luminance for this display in cd/m^2; pointer will be non-NULL |
| * outMinLuminance - the desired content minimum luminance for this display in |
| * cd/m^2; pointer will be non-NULL |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_GET_HDR_CAPABILITIES)( |
| hwc2_device_t* device, hwc2_display_t display, uint32_t* outNumTypes, |
| int32_t* /*android_hdr_t*/ outTypes, float* outMaxLuminance, |
| float* outMaxAverageLuminance, float* outMinLuminance); |
| |
| /* getReleaseFences(..., outNumElements, outLayers, outFences) |
| * Descriptor: HWC2_FUNCTION_GET_RELEASE_FENCES |
| * Must be provided by all HWC2 devices |
| * |
| * Retrieves the release fences for device layers on this display which will |
| * receive new buffer contents this frame. |
| * |
| * A release fence is a file descriptor referring to a sync fence object which |
| * will be signaled after the device has finished reading from the buffer |
| * presented in the prior frame. This indicates that it is safe to start writing |
| * to the buffer again. If a given layer's fence is not returned from this |
| * function, it will be assumed that the buffer presented on the previous frame |
| * is ready to be written. |
| * |
| * The fences returned by this function should be unique for each layer (even if |
| * they point to the same underlying sync object), and ownership of the fences |
| * is transferred to the client, which is responsible for closing them. |
| * |
| * If outLayers or outFences is NULL, the required number of layers and fences |
| * must be returned in outNumElements. |
| * |
| * Parameters: |
| * outNumElements - if outLayers or outFences were NULL, the number of |
| * elements which would have been returned; if both were not NULL, the |
| * number of elements in outLayers and outFences, which must not exceed |
| * the value stored in outNumElements prior to the call; pointer will be |
| * non-NULL |
| * outLayers - an array of layer handles |
| * outFences - an array of sync fence file descriptors as described above, |
| * each corresponding to an element of outLayers |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_GET_RELEASE_FENCES)( |
| hwc2_device_t* device, hwc2_display_t display, uint32_t* outNumElements, |
| hwc2_layer_t* outLayers, int32_t* outFences); |
| |
| /* presentDisplay(..., outPresentFence) |
| * Descriptor: HWC2_FUNCTION_PRESENT_DISPLAY |
| * Must be provided by all HWC2 devices |
| * |
| * Presents the current display contents on the screen (or in the case of |
| * virtual displays, into the output buffer). |
| * |
| * Prior to calling this function, the display must be successfully validated |
| * with validateDisplay. Note that setLayerBuffer and setLayerSurfaceDamage |
| * specifically do not count as layer state, so if there are no other changes |
| * to the layer state (or to the buffer's properties as described in |
| * setLayerBuffer), then it is safe to call this function without first |
| * validating the display. |
| * |
| * If this call succeeds, outPresentFence will be populated with a file |
| * descriptor referring to a present sync fence object. For physical displays, |
| * this fence will be signaled at the vsync when the result of composition of |
| * this frame starts to appear (for video-mode panels) or starts to transfer to |
| * panel memory (for command-mode panels). For virtual displays, this fence will |
| * be signaled when writes to the output buffer have completed and it is safe to |
| * read from it. |
| * |
| * Parameters: |
| * outPresentFence - a sync fence file descriptor as described above; pointer |
| * will be non-NULL |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in |
| * HWC2_ERROR_NO_RESOURCES - no valid output buffer has been set for a virtual |
| * display |
| * HWC2_ERROR_NOT_VALIDATED - validateDisplay has not successfully been called |
| * for this display |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_PRESENT_DISPLAY)( |
| hwc2_device_t* device, hwc2_display_t display, |
| int32_t* outPresentFence); |
| |
| /* setActiveConfig(..., config) |
| * Descriptor: HWC2_FUNCTION_SET_ACTIVE_CONFIG |
| * Must be provided by all HWC2 devices |
| * |
| * Sets the active configuration for this display. Upon returning, the given |
| * display configuration should be active and remain so until either this |
| * function is called again or the display is disconnected. |
| * |
| * Parameters: |
| * config - the new display configuration |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in |
| * HWC2_ERROR_BAD_CONFIG - the configuration handle passed in is not valid for |
| * this display |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_ACTIVE_CONFIG)( |
| hwc2_device_t* device, hwc2_display_t display, hwc2_config_t config); |
| |
| /* setClientTarget(..., target, acquireFence, dataspace, damage) |
| * Descriptor: HWC2_FUNCTION_SET_CLIENT_TARGET |
| * Must be provided by all HWC2 devices |
| * |
| * Sets the buffer handle which will receive the output of client composition. |
| * Layers marked as HWC2_COMPOSITION_CLIENT will be composited into this buffer |
| * prior to the call to presentDisplay, and layers not marked as |
| * HWC2_COMPOSITION_CLIENT should be composited with this buffer by the device. |
| * |
| * The buffer handle provided may be null if no layers are being composited by |
| * the client. This must not result in an error (unless an invalid display |
| * handle is also provided). |
| * |
| * Also provides a file descriptor referring to an acquire sync fence object, |
| * which will be signaled when it is safe to read from the client target buffer. |
| * If it is already safe to read from this buffer, -1 may be passed instead. |
| * The device must ensure that it is safe for the client to close this file |
| * descriptor at any point after this function is called. |
| * |
| * For more about dataspaces, see setLayerDataspace. |
| * |
| * The damage parameter describes a surface damage region as defined in the |
| * description of setLayerSurfaceDamage. |
| * |
| * Will be called before presentDisplay if any of the layers are marked as |
| * HWC2_COMPOSITION_CLIENT. If no layers are so marked, then it is not |
| * necessary to call this function. It is not necessary to call validateDisplay |
| * after changing the target through this function. |
| * |
| * Parameters: |
| * target - the new target buffer |
| * acquireFence - a sync fence file descriptor as described above |
| * dataspace - the dataspace of the buffer, as described in setLayerDataspace |
| * damage - the surface damage region |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in |
| * HWC2_ERROR_BAD_PARAMETER - the new target handle was invalid |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_CLIENT_TARGET)( |
| hwc2_device_t* device, hwc2_display_t display, buffer_handle_t target, |
| int32_t acquireFence, int32_t /*android_dataspace_t*/ dataspace, |
| hwc_region_t damage); |
| |
| /* setColorMode(..., mode) |
| * Descriptor: HWC2_FUNCTION_SET_COLOR_MODE |
| * Must be provided by all HWC2 devices |
| * |
| * Sets the color mode of the given display. |
| * |
| * This must be called outside of validateDisplay/presentDisplay, and it takes |
| * effect on next presentDisplay. |
| * |
| * The valid color modes can be found in android_color_mode_t in |
| * <system/graphics.h>. All HWC2 devices must support at least |
| * HAL_COLOR_MODE_NATIVE, and displays are assumed to be in this mode upon |
| * hotplug. |
| * |
| * Parameters: |
| * mode - the mode to set |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in |
| * HWC2_ERROR_BAD_PARAMETER - mode is not a valid color mode |
| * HWC2_ERROR_UNSUPPORTED - mode is not supported on this display |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_COLOR_MODE)( |
| hwc2_device_t* device, hwc2_display_t display, |
| int32_t /*android_color_mode_t*/ mode); |
| |
| /* setColorModeWithIntent(..., mode, intent) |
| * Descriptor: HWC2_FUNCTION_SET_COLOR_MODE_WITH_RENDER_INTENT |
| * Provided by HWC2 devices which don't return nullptr function pointer. |
| * |
| * This must be called outside of validateDisplay/presentDisplay, and it takes |
| * effect on next presentDisplay. |
| * |
| * The valid color modes and render intents can be found in |
| * android_color_mode_t and android_render_intent_v1_1_t in |
| * <system/graphics.h>. All HWC2 devices must support at least |
| * HAL_COLOR_MODE_NATIVE and HAL_RENDER_INTENT_COLORIMETRIC, and displays are |
| * assumed to be in this mode and intent upon hotplug. |
| * |
| * Parameters: |
| * mode - the mode to set |
| * intent - the intent to set |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in |
| * HWC2_ERROR_BAD_PARAMETER - mode/intent is not a valid color mode or |
| * render intent |
| * HWC2_ERROR_UNSUPPORTED - mode or intent is not supported on this display |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_COLOR_MODE_WITH_RENDER_INTENT)( |
| hwc2_device_t* device, hwc2_display_t display, |
| int32_t /*android_color_mode_t*/ mode, |
| int32_t /*android_render_intent_v1_1_t */ intent); |
| |
| /* setColorTransform(..., matrix, hint) |
| * Descriptor: HWC2_FUNCTION_SET_COLOR_TRANSFORM |
| * Must be provided by all HWC2 devices |
| * |
| * Sets a color transform which will be applied after composition. |
| * |
| * If hint is not HAL_COLOR_TRANSFORM_ARBITRARY, then the device may use the |
| * hint to apply the desired color transform instead of using the color matrix |
| * directly. |
| * |
| * If the device is not capable of either using the hint or the matrix to apply |
| * the desired color transform, it should force all layers to client composition |
| * during validateDisplay. |
| * |
| * If HWC2_CAPABILITY_SKIP_CLIENT_COLOR_TRANSFORM is present, then the client |
| * will never apply the color transform during client composition, even if all |
| * layers are being composed by the client. |
| * |
| * The matrix provided is an affine color transformation of the following form: |
| * |
| * |r.r r.g r.b 0| |
| * |g.r g.g g.b 0| |
| * |b.r b.g b.b 0| |
| * |Tr Tg Tb 1| |
| * |
| * This matrix will be provided in row-major form: {r.r, r.g, r.b, 0, g.r, ...}. |
| * |
| * Given a matrix of this form and an input color [R_in, G_in, B_in], the output |
| * color [R_out, G_out, B_out] will be: |
| * |
| * R_out = R_in * r.r + G_in * g.r + B_in * b.r + Tr |
| * G_out = R_in * r.g + G_in * g.g + B_in * b.g + Tg |
| * B_out = R_in * r.b + G_in * g.b + B_in * b.b + Tb |
| * |
| * Parameters: |
| * matrix - a 4x4 transform matrix (16 floats) as described above |
| * hint - a hint value which may be used instead of the given matrix unless it |
| * is HAL_COLOR_TRANSFORM_ARBITRARY |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in |
| * HWC2_ERROR_BAD_PARAMETER - hint is not a valid color transform hint |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_COLOR_TRANSFORM)( |
| hwc2_device_t* device, hwc2_display_t display, const float* matrix, |
| int32_t /*android_color_transform_t*/ hint); |
| |
| /* getPerFrameMetadataKeys(..., outKeys) |
| * Descriptor: HWC2_FUNCTION_GET_PER_FRAME_METADATA_KEYS |
| * Optional for HWC2 devices |
| * |
| * If supported (getFunction(HWC2_FUNCTION_GET_PER_FRAME_METADATA_KEYS) is non-null), |
| * getPerFrameMetadataKeys returns the list of supported PerFrameMetadataKeys |
| * which are invariant with regard to the active configuration. |
| * |
| * Devices which are not HDR-capable, must return null when getFunction is called |
| * with HWC2_FUNCTION_GET_PER_FRAME_METADATA_KEYS. |
| * |
| * If outKeys is NULL, the required number of PerFrameMetadataKey keys |
| * must be returned in outNumKeys. |
| * |
| * Parameters: |
| * outNumKeys - if outKeys is NULL, the number of keys which would have |
| * been returned; if outKeys is not NULL, the number of keys stored in |
| * outKeys, which must not exceed the value stored in outNumKeys prior |
| * to the call; pointer will be non-NULL |
| * outKeys - an array of hwc2_per_frame_metadata_key_t keys |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_GET_PER_FRAME_METADATA_KEYS)( |
| hwc2_device_t* device, hwc2_display_t display, uint32_t* outNumKeys, |
| int32_t* /*hwc2_per_frame_metadata_key_t*/ outKeys); |
| |
| /* setOutputBuffer(..., buffer, releaseFence) |
| * Descriptor: HWC2_FUNCTION_SET_OUTPUT_BUFFER |
| * Must be provided by all HWC2 devices |
| * |
| * Sets the output buffer for a virtual display. That is, the buffer to which |
| * the composition result will be written. |
| * |
| * Also provides a file descriptor referring to a release sync fence object, |
| * which will be signaled when it is safe to write to the output buffer. If it |
| * is already safe to write to the output buffer, -1 may be passed instead. The |
| * device must ensure that it is safe for the client to close this file |
| * descriptor at any point after this function is called. |
| * |
| * Must be called at least once before presentDisplay, but does not have any |
| * interaction with layer state or display validation. |
| * |
| * Parameters: |
| * buffer - the new output buffer |
| * releaseFence - a sync fence file descriptor as described above |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in |
| * HWC2_ERROR_BAD_PARAMETER - the new output buffer handle was invalid |
| * HWC2_ERROR_UNSUPPORTED - display does not refer to a virtual display |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_OUTPUT_BUFFER)( |
| hwc2_device_t* device, hwc2_display_t display, buffer_handle_t buffer, |
| int32_t releaseFence); |
| |
| /* setPowerMode(..., mode) |
| * Descriptor: HWC2_FUNCTION_SET_POWER_MODE |
| * Must be provided by all HWC2 devices |
| * |
| * Sets the power mode of the given display. The transition must be complete |
| * when this function returns. It is valid to call this function multiple times |
| * with the same power mode. |
| * |
| * All displays must support HWC2_POWER_MODE_ON and HWC2_POWER_MODE_OFF. Whether |
| * a display supports HWC2_POWER_MODE_DOZE or HWC2_POWER_MODE_DOZE_SUSPEND may |
| * be queried using getDozeSupport. |
| * |
| * Parameters: |
| * mode - the new power mode |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in |
| * HWC2_ERROR_BAD_PARAMETER - mode was not a valid power mode |
| * HWC2_ERROR_UNSUPPORTED - mode was a valid power mode, but is not supported |
| * on this display |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_POWER_MODE)( |
| hwc2_device_t* device, hwc2_display_t display, |
| int32_t /*hwc2_power_mode_t*/ mode); |
| |
| /* getReadbackBufferAttributes(..., outFormat, outDataspace) |
| * Optional for HWC2 devices |
| * |
| * Returns the format which should be used when allocating a buffer for use by |
| * device readback as well as the dataspace in which its contents should be |
| * interpreted. |
| * |
| * If readback is not supported by this HWC implementation, this call will also |
| * be able to return HWC2_ERROR_UNSUPPORTED so we can fall back to another method. |
| * Returning NULL to a getFunction request for this function will also indicate |
| * that readback is not supported. |
| * |
| * The width and height of this buffer will be those of the currently-active |
| * display configuration, and the usage flags will consist of the following: |
| * BufferUsage::CPU_READ | BufferUsage::GPU_TEXTURE | |
| * BufferUsage::COMPOSER_OUTPUT |
| * |
| * The format and dataspace provided must be sufficient such that if a |
| * correctly-configured buffer is passed into setReadbackBuffer, filled by |
| * the device, and then displayed by the client as a full-screen buffer, the |
| * output of the display remains the same (subject to the note about protected |
| * content in the description of setReadbackBuffer). |
| * |
| * If the active configuration or color mode of this display has changed since |
| * the previous call to this function, it will be called again prior to setting |
| * a readback buffer such that the returned format and dataspace can be updated |
| * accordingly. |
| * |
| * Parameters: |
| * outFormat - the format the client should use when allocating a device |
| * readback buffer; pointer will be non-NULL |
| * outDataspace - the dataspace the client will use when interpreting the |
| * contents of a device readback buffer; pointer will be non-NULL |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in |
| * |
| * See also: |
| * setReadbackBuffer |
| * getReadbackBufferFence |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_GET_READBACK_BUFFER_ATTRIBUTES)( |
| hwc2_device_t* device, hwc2_display_t display, |
| int32_t* /*android_pixel_format_t*/ outFormat, |
| int32_t* /*android_dataspace_t*/ outDataspace); |
| |
| /* getReadbackBufferFence(..., outFence) |
| * Optional for HWC2 devices |
| * |
| * Returns an acquire sync fence file descriptor which will signal when the |
| * buffer provided to setReadbackBuffer has been filled by the device and is |
| * safe for the client to read. |
| * |
| * If it is already safe to read from this buffer, -1 may be returned instead. |
| * The client takes ownership of this file descriptor and is responsible for |
| * closing it when it is no longer needed. |
| * |
| * This function will be called immediately after the composition cycle being |
| * captured into the readback buffer. The complete ordering of a readback buffer |
| * capture is as follows: |
| * |
| * getReadbackBufferAttributes |
| * // Readback buffer is allocated |
| * // Many frames may pass |
| * |
| * setReadbackBuffer |
| * validateDisplay |
| * presentDisplay |
| * getReadbackBufferFence |
| * // Implicitly wait on the acquire fence before accessing the buffer |
| * |
| * Parameters: |
| * outFence - a sync fence file descriptor as described above; pointer |
| * will be non-NULL |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in |
| * HWC2_ERROR_NO_RESOURCES - the readback operation was successful, but |
| * resulted in a different validate result than would have occurred |
| * without readback |
| * HWC2_ERROR_UNSUPPORTED - the readback operation was unsuccessful because |
| * of resource constraints, the presence of protected content, or other |
| * reasons; -1 must be returned in outFence |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_GET_READBACK_BUFFER_FENCE)( |
| hwc2_device_t* device, hwc2_display_t display, |
| int32_t* outFence); |
| |
| /* setReadbackBuffer(..., buffer, releaseFence) |
| * Optional for HWC2 devices |
| * |
| * Sets the readback buffer to be filled with the contents of the next |
| * composition performed for this display (i.e., the contents present at the |
| * time of the next validateDisplay/presentDisplay cycle). |
| * |
| * This buffer will have been allocated as described in |
| * getReadbackBufferAttributes and will be interpreted as being in the dataspace |
| * provided by the same. |
| * |
| * If there is hardware protected content on the display at the time of the next |
| * composition, the area of the readback buffer covered by such content must be |
| * completely black. Any areas of the buffer not covered by such content may |
| * optionally be black as well. |
| * |
| * The release fence file descriptor provided works identically to the one |
| * described for setOutputBuffer. |
| * |
| * This function will not be called between any call to validateDisplay and a |
| * subsequent call to presentDisplay. |
| * |
| * Parameters: |
| * buffer - the new readback buffer |
| * releaseFence - a sync fence file descriptor as described in setOutputBuffer |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in |
| * HWC2_ERROR_BAD_PARAMETER - the new readback buffer handle was invalid |
| * |
| * See also: |
| * getReadbackBufferAttributes |
| * getReadbackBufferFence |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_READBACK_BUFFER)( |
| hwc2_device_t* device, hwc2_display_t display, |
| buffer_handle_t buffer, int32_t releaseFence); |
| |
| /* setVsyncEnabled(..., enabled) |
| * Descriptor: HWC2_FUNCTION_SET_VSYNC_ENABLED |
| * Must be provided by all HWC2 devices |
| * |
| * Enables or disables the vsync signal for the given display. Virtual displays |
| * never generate vsync callbacks, and any attempt to enable vsync for a virtual |
| * display though this function must return HWC2_ERROR_NONE and have no other |
| * effect. |
| * |
| * Parameters: |
| * enabled - whether to enable or disable vsync |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in |
| * HWC2_ERROR_BAD_PARAMETER - enabled was an invalid value |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_VSYNC_ENABLED)( |
| hwc2_device_t* device, hwc2_display_t display, |
| int32_t /*hwc2_vsync_t*/ enabled); |
| |
| /* validateDisplay(..., outNumTypes, outNumRequests) |
| * Descriptor: HWC2_FUNCTION_VALIDATE_DISPLAY |
| * Must be provided by all HWC2 devices |
| * |
| * Instructs the device to inspect all of the layer state and determine if |
| * there are any composition type changes necessary before presenting the |
| * display. Permitted changes are described in the definition of |
| * hwc2_composition_t above. |
| * |
| * Also returns the number of layer requests required |
| * by the given layer configuration. |
| * |
| * Parameters: |
| * outNumTypes - the number of composition type changes required by the |
| * device; if greater than 0, the client must either set and validate new |
| * types, or call acceptDisplayChanges to accept the changes returned by |
| * getChangedCompositionTypes; must be the same as the number of changes |
| * returned by getChangedCompositionTypes (see the declaration of that |
| * function for more information); pointer will be non-NULL |
| * outNumRequests - the number of layer requests required by this layer |
| * configuration; must be equal to the number of layer requests returned |
| * by getDisplayRequests (see the declaration of that function for |
| * more information); pointer will be non-NULL |
| * |
| * Returns HWC2_ERROR_NONE if no changes are necessary and it is safe to present |
| * the display using the current layer state. Otherwise returns one of the |
| * following errors: |
| * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in |
| * HWC2_ERROR_HAS_CHANGES - outNumTypes was greater than 0 (see parameter list |
| * for more information) |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_VALIDATE_DISPLAY)( |
| hwc2_device_t* device, hwc2_display_t display, |
| uint32_t* outNumTypes, uint32_t* outNumRequests); |
| |
| /* |
| * Layer Functions |
| * |
| * These are functions which operate on layers, but which do not modify state |
| * that must be validated before use. See also 'Layer State Functions' below. |
| * |
| * All of these functions take as their first three parameters a device pointer, |
| * a display handle for the display which contains the layer, and a layer |
| * handle, so these parameters are omitted from the described parameter lists. |
| */ |
| |
| /* setCursorPosition(..., x, y) |
| * Descriptor: HWC2_FUNCTION_SET_CURSOR_POSITION |
| * Must be provided by all HWC2 devices |
| * |
| * Asynchonously sets the position of a cursor layer. |
| * |
| * Prior to validateDisplay, a layer may be marked as HWC2_COMPOSITION_CURSOR. |
| * If validation succeeds (i.e., the device does not request a composition |
| * change for that layer), then once a buffer has been set for the layer and it |
| * has been presented, its position may be set by this function at any time |
| * between presentDisplay and any subsequent validateDisplay calls for this |
| * display. |
| * |
| * Once validateDisplay is called, this function will not be called again until |
| * the validate/present sequence is completed. |
| * |
| * May be called from any thread so long as it is not interleaved with the |
| * validate/present sequence as described above. |
| * |
| * Parameters: |
| * x - the new x coordinate (in pixels from the left of the screen) |
| * y - the new y coordinate (in pixels from the top of the screen) |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in |
| * HWC2_ERROR_BAD_LAYER - the layer is invalid or is not currently marked as |
| * HWC2_COMPOSITION_CURSOR |
| * HWC2_ERROR_NOT_VALIDATED - the device is currently in the middle of the |
| * validate/present sequence |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_CURSOR_POSITION)( |
| hwc2_device_t* device, hwc2_display_t display, hwc2_layer_t layer, |
| int32_t x, int32_t y); |
| |
| /* setLayerBuffer(..., buffer, acquireFence) |
| * Descriptor: HWC2_FUNCTION_SET_LAYER_BUFFER |
| * Must be provided by all HWC2 devices |
| * |
| * Sets the buffer handle to be displayed for this layer. If the buffer |
| * properties set at allocation time (width, height, format, and usage) have not |
| * changed since the previous frame, it is not necessary to call validateDisplay |
| * before calling presentDisplay unless new state needs to be validated in the |
| * interim. |
| * |
| * Also provides a file descriptor referring to an acquire sync fence object, |
| * which will be signaled when it is safe to read from the given buffer. If it |
| * is already safe to read from the buffer, -1 may be passed instead. The |
| * device must ensure that it is safe for the client to close this file |
| * descriptor at any point after this function is called. |
| * |
| * This function must return HWC2_ERROR_NONE and have no other effect if called |
| * for a layer with a composition type of HWC2_COMPOSITION_SOLID_COLOR (because |
| * it has no buffer) or HWC2_COMPOSITION_SIDEBAND or HWC2_COMPOSITION_CLIENT |
| * (because synchronization and buffer updates for these layers are handled |
| * elsewhere). |
| * |
| * Parameters: |
| * buffer - the buffer handle to set |
| * acquireFence - a sync fence file descriptor as described above |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_LAYER - an invalid layer handle was passed in |
| * HWC2_ERROR_BAD_PARAMETER - the buffer handle passed in was invalid |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_LAYER_BUFFER)( |
| hwc2_device_t* device, hwc2_display_t display, hwc2_layer_t layer, |
| buffer_handle_t buffer, int32_t acquireFence); |
| |
| /* setLayerSurfaceDamage(..., damage) |
| * Descriptor: HWC2_FUNCTION_SET_LAYER_SURFACE_DAMAGE |
| * Must be provided by all HWC2 devices |
| * |
| * Provides the region of the source buffer which has been modified since the |
| * last frame. This region does not need to be validated before calling |
| * presentDisplay. |
| * |
| * Once set through this function, the damage region remains the same until a |
| * subsequent call to this function. |
| * |
| * If damage.numRects > 0, then it may be assumed that any portion of the source |
| * buffer not covered by one of the rects has not been modified this frame. If |
| * damage.numRects == 0, then the whole source buffer must be treated as if it |
| * has been modified. |
| * |
| * If the layer's contents are not modified relative to the prior frame, damage |
| * will contain exactly one empty rect([0, 0, 0, 0]). |
| * |
| * The damage rects are relative to the pre-transformed buffer, and their origin |
| * is the top-left corner. They will not exceed the dimensions of the latched |
| * buffer. |
| * |
| * Parameters: |
| * damage - the new surface damage region |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_LAYER - an invalid layer handle was passed in |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_LAYER_SURFACE_DAMAGE)( |
| hwc2_device_t* device, hwc2_display_t display, hwc2_layer_t layer, |
| hwc_region_t damage); |
| |
| /* setLayerPerFrameMetadata(..., numMetadata, metadata) |
| * Descriptor: HWC2_FUNCTION_SET_LAYER_PER_FRAME_METADATA |
| * Optional for HWC2 devices |
| * |
| * If supported (getFunction(HWC2_FUNCTION_SET_LAYER_PER_FRAME_METADATA) is |
| * non-null), sets the metadata for the given display for all following |
| * frames. |
| * |
| * Upon returning from this function, the metadata change must have |
| * fully taken effect. |
| * |
| * This function will only be called if getPerFrameMetadataKeys is non-NULL |
| * and returns at least one key. |
| * |
| * Parameters: |
| * numElements is the number of elements in each of the keys and metadata arrays |
| * keys is a pointer to the array of keys. |
| * outMetadata is a pointer to the corresponding array of metadata. |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in |
| * HWC2_ERROR_BAD_PARAMETER - metadata is not valid |
| * HWC2_ERROR_UNSUPPORTED - metadata is not supported on this display |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_LAYER_PER_FRAME_METADATA)( |
| hwc2_device_t* device, hwc2_display_t display, hwc2_layer_t layer, |
| uint32_t numElements, const int32_t* /*hw2_per_frame_metadata_key_t*/ keys, |
| const float* metadata); |
| |
| /* setLayerPerFrameMetadataBlobs(...,numElements, keys, sizes, blobs) |
| * Descriptor: HWC2_FUNCTION_SET_LAYER_PER_FRAME_METADATA_BLOBS |
| * Optional for HWC2 devices |
| * |
| * If supported, (getFunction(HWC2_FUNCTION_SET_LAYER_PER_FRAME_METADATA_BLOBS) |
| * is non-null), sets the metadata for the given display and layer. |
| * |
| * Upon returning from this function, the metadata change must have fully taken |
| * effect. |
| * |
| * This function must only be called if getPerFrameMetadataKeys is non-NULL |
| * and returns at least one key that corresponds to a blob type. |
| * |
| * Current valid blob type keys are: HDR10_PLUS_SEI |
| * |
| * Parameters: |
| * numElements is the number of elements in each of the keys, sizes, and |
| * metadata arrays |
| * keys is a pointer to an array of keys. Current valid keys are those listed |
| * above as valid blob type keys. |
| * sizes is a pointer to an array of unsigned ints specifying the sizes of |
| * each metadata blob |
| * metadata is a pointer to a blob of data holding all blobs contiguously in |
| * memory |
| * |
| * Returns HWC2_ERROR_NONE or one of the following erros: |
| * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in |
| * HWC2_ERROR_BAD_PARAMETER - sizes of keys and metadata parameters does |
| * not match numElements, numElements < 0, or keys contains a |
| * non-valid key (see above for current valid blob type keys). |
| * HWC2_ERROR_UNSUPPORTED - metadata is not supported on this display |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_LAYER_PER_FRAME_METADATA_BLOBS)( |
| hwc2_device_t* device, hwc2_display_t display, hwc2_layer_t layer, |
| uint32_t numElements, const int32_t* keys, const uint32_t* sizes, |
| const uint8_t* metadata); |
| /* |
| * Layer State Functions |
| * |
| * These functions modify the state of a given layer. They do not take effect |
| * until the display configuration is successfully validated with |
| * validateDisplay and the display contents are presented with presentDisplay. |
| * |
| * All of these functions take as their first three parameters a device pointer, |
| * a display handle for the display which contains the layer, and a layer |
| * handle, so these parameters are omitted from the described parameter lists. |
| */ |
| |
| /* setLayerBlendMode(..., mode) |
| * Descriptor: HWC2_FUNCTION_SET_LAYER_BLEND_MODE |
| * Must be provided by all HWC2 devices |
| * |
| * Sets the blend mode of the given layer. |
| * |
| * Parameters: |
| * mode - the new blend mode |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_LAYER - an invalid layer handle was passed in |
| * HWC2_ERROR_BAD_PARAMETER - an invalid blend mode was passed in |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_LAYER_BLEND_MODE)( |
| hwc2_device_t* device, hwc2_display_t display, hwc2_layer_t layer, |
| int32_t /*hwc2_blend_mode_t*/ mode); |
| |
| /* setLayerColor(..., color) |
| * Descriptor: HWC2_FUNCTION_SET_LAYER_COLOR |
| * Must be provided by all HWC2 devices |
| * |
| * Sets the color of the given layer. If the composition type of the layer is |
| * not HWC2_COMPOSITION_SOLID_COLOR, this call must return HWC2_ERROR_NONE and |
| * have no other effect. |
| * |
| * Parameters: |
| * color - the new color |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_LAYER - an invalid layer handle was passed in |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_LAYER_COLOR)( |
| hwc2_device_t* device, hwc2_display_t display, hwc2_layer_t layer, |
| hwc_color_t color); |
| |
| /* setLayerFloatColor(..., color) |
| * Descriptor: HWC2_FUNCTION_SET_LAYER_FLOAT_COLOR |
| * Provided by HWC2 devices which don't return nullptr function pointer. |
| * |
| * Sets the color of the given layer. If the composition type of the layer is |
| * not HWC2_COMPOSITION_SOLID_COLOR, this call must return HWC2_ERROR_NONE and |
| * have no other effect. |
| * |
| * Parameters: |
| * color - the new color in float type, rage is [0.0, 1.0], the colorspace is |
| * defined by the dataspace that gets set by calling setLayerDataspace. |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_LAYER - an invalid layer handle was passed in |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_LAYER_FLOAT_COLOR)( |
| hwc2_device_t* device, hwc2_display_t display, hwc2_layer_t layer, |
| hwc_float_color_t color); |
| |
| /* setLayerCompositionType(..., type) |
| * Descriptor: HWC2_FUNCTION_SET_LAYER_COMPOSITION_TYPE |
| * Must be provided by all HWC2 devices |
| * |
| * Sets the desired composition type of the given layer. During validateDisplay, |
| * the device may request changes to the composition types of any of the layers |
| * as described in the definition of hwc2_composition_t above. |
| * |
| * Parameters: |
| * type - the new composition type |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_LAYER - an invalid layer handle was passed in |
| * HWC2_ERROR_BAD_PARAMETER - an invalid composition type was passed in |
| * HWC2_ERROR_UNSUPPORTED - a valid composition type was passed in, but it is |
| * not supported by this device |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_LAYER_COMPOSITION_TYPE)( |
| hwc2_device_t* device, hwc2_display_t display, hwc2_layer_t layer, |
| int32_t /*hwc2_composition_t*/ type); |
| |
| /* setLayerDataspace(..., dataspace) |
| * Descriptor: HWC2_FUNCTION_SET_LAYER_DATASPACE |
| * Must be provided by all HWC2 devices |
| * |
| * Sets the dataspace that the current buffer on this layer is in. |
| * |
| * The dataspace provides more information about how to interpret the buffer |
| * contents, such as the encoding standard and color transform. |
| * |
| * See the values of android_dataspace_t in <system/graphics.h> for more |
| * information. |
| * |
| * Parameters: |
| * dataspace - the new dataspace |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_LAYER - an invalid layer handle was passed in |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_LAYER_DATASPACE)( |
| hwc2_device_t* device, hwc2_display_t display, hwc2_layer_t layer, |
| int32_t /*android_dataspace_t*/ dataspace); |
| |
| /* setLayerDisplayFrame(..., frame) |
| * Descriptor: HWC2_FUNCTION_SET_LAYER_DISPLAY_FRAME |
| * Must be provided by all HWC2 devices |
| * |
| * Sets the display frame (the portion of the display covered by a layer) of the |
| * given layer. This frame will not exceed the display dimensions. |
| * |
| * Parameters: |
| * frame - the new display frame |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_LAYER - an invalid layer handle was passed in |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_LAYER_DISPLAY_FRAME)( |
| hwc2_device_t* device, hwc2_display_t display, hwc2_layer_t layer, |
| hwc_rect_t frame); |
| |
| /* setLayerPlaneAlpha(..., alpha) |
| * Descriptor: HWC2_FUNCTION_SET_LAYER_PLANE_ALPHA |
| * Must be provided by all HWC2 devices |
| * |
| * Sets an alpha value (a floating point value in the range [0.0, 1.0]) which |
| * will be applied to the whole layer. It can be conceptualized as a |
| * preprocessing step which applies the following function: |
| * if (blendMode == HWC2_BLEND_MODE_PREMULTIPLIED) |
| * out.rgb = in.rgb * planeAlpha |
| * out.a = in.a * planeAlpha |
| * |
| * If the device does not support this operation on a layer which is marked |
| * HWC2_COMPOSITION_DEVICE, it must request a composition type change to |
| * HWC2_COMPOSITION_CLIENT upon the next validateDisplay call. |
| * |
| * Parameters: |
| * alpha - the plane alpha value to apply |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_LAYER - an invalid layer handle was passed in |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_LAYER_PLANE_ALPHA)( |
| hwc2_device_t* device, hwc2_display_t display, hwc2_layer_t layer, |
| float alpha); |
| |
| /* setLayerSidebandStream(..., stream) |
| * Descriptor: HWC2_FUNCTION_SET_LAYER_SIDEBAND_STREAM |
| * Provided by HWC2 devices which support HWC2_CAPABILITY_SIDEBAND_STREAM |
| * |
| * Sets the sideband stream for this layer. If the composition type of the given |
| * layer is not HWC2_COMPOSITION_SIDEBAND, this call must return HWC2_ERROR_NONE |
| * and have no other effect. |
| * |
| * Parameters: |
| * stream - the new sideband stream |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_LAYER - an invalid layer handle was passed in |
| * HWC2_ERROR_BAD_PARAMETER - an invalid sideband stream was passed in |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_LAYER_SIDEBAND_STREAM)( |
| hwc2_device_t* device, hwc2_display_t display, hwc2_layer_t layer, |
| const native_handle_t* stream); |
| |
| /* setLayerSourceCrop(..., crop) |
| * Descriptor: HWC2_FUNCTION_SET_LAYER_SOURCE_CROP |
| * Must be provided by all HWC2 devices |
| * |
| * Sets the source crop (the portion of the source buffer which will fill the |
| * display frame) of the given layer. This crop rectangle will not exceed the |
| * dimensions of the latched buffer. |
| * |
| * If the device is not capable of supporting a true float source crop (i.e., it |
| * will truncate or round the floats to integers), it should set this layer to |
| * HWC2_COMPOSITION_CLIENT when crop is non-integral for the most accurate |
| * rendering. |
| * |
| * If the device cannot support float source crops, but still wants to handle |
| * the layer, it should use the following code (or similar) to convert to |
| * an integer crop: |
| * intCrop.left = (int) ceilf(crop.left); |
| * intCrop.top = (int) ceilf(crop.top); |
| * intCrop.right = (int) floorf(crop.right); |
| * intCrop.bottom = (int) floorf(crop.bottom); |
| * |
| * Parameters: |
| * crop - the new source crop |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_LAYER - an invalid layer handle was passed in |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_LAYER_SOURCE_CROP)( |
| hwc2_device_t* device, hwc2_display_t display, hwc2_layer_t layer, |
| hwc_frect_t crop); |
| |
| /* setLayerTransform(..., transform) |
| * Descriptor: HWC2_FUNCTION_SET_LAYER_TRANSFORM |
| * Must be provided by all HWC2 devices |
| * |
| * Sets the transform (rotation/flip) of the given layer. |
| * |
| * Parameters: |
| * transform - the new transform |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_LAYER - an invalid layer handle was passed in |
| * HWC2_ERROR_BAD_PARAMETER - an invalid transform was passed in |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_LAYER_TRANSFORM)( |
| hwc2_device_t* device, hwc2_display_t display, hwc2_layer_t layer, |
| int32_t /*hwc_transform_t*/ transform); |
| |
| /* setLayerVisibleRegion(..., visible) |
| * Descriptor: HWC2_FUNCTION_SET_LAYER_VISIBLE_REGION |
| * Must be provided by all HWC2 devices |
| * |
| * Specifies the portion of the layer that is visible, including portions under |
| * translucent areas of other layers. The region is in screen space, and will |
| * not exceed the dimensions of the screen. |
| * |
| * Parameters: |
| * visible - the new visible region, in screen space |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_LAYER - an invalid layer handle was passed in |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_LAYER_VISIBLE_REGION)( |
| hwc2_device_t* device, hwc2_display_t display, hwc2_layer_t layer, |
| hwc_region_t visible); |
| |
| /* setLayerZOrder(..., z) |
| * Descriptor: HWC2_FUNCTION_SET_LAYER_Z_ORDER |
| * Must be provided by all HWC2 devices |
| * |
| * Sets the desired Z order (height) of the given layer. A layer with a greater |
| * Z value occludes a layer with a lesser Z value. |
| * |
| * Parameters: |
| * z - the new Z order |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_LAYER - an invalid layer handle was passed in |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_LAYER_Z_ORDER)( |
| hwc2_device_t* device, hwc2_display_t display, hwc2_layer_t layer, |
| uint32_t z); |
| |
| /* setLayerColorTransform(..., matrix) |
| * Descriptor: HWC2_FUNCTION_SET_LAYER_COLOR_TRANSFORM |
| * Optional by all HWC2 devices |
| * |
| * Sets a matrix for color transform which will be applied on this layer |
| * before composition. |
| * |
| * If the device is not capable of apply the matrix on this layer, it must force |
| * this layer to client composition during VALIDATE_DISPLAY. |
| * |
| * The matrix provided is an affine color transformation of the following form: |
| * |
| * |r.r r.g r.b 0| |
| * |g.r g.g g.b 0| |
| * |b.r b.g b.b 0| |
| * |Tr Tg Tb 1| |
| * |
| * This matrix must be provided in row-major form: |
| * |
| * {r.r, r.g, r.b, 0, g.r, ...}. |
| * |
| * Given a matrix of this form and an input color [R_in, G_in, B_in], |
| * the input color must first be converted to linear space |
| * [R_linear, G_linear, B_linear], then the output linear color |
| * [R_out_linear, G_out_linear, B_out_linear] will be: |
| * |
| * R_out_linear = R_linear * r.r + G_linear * g.r + B_linear * b.r + Tr |
| * G_out_linear = R_linear * r.g + G_linear * g.g + B_linear * b.g + Tg |
| * B_out_linear = R_linear * r.b + G_linear * g.b + B_linear * b.b + Tb |
| * |
| * [R_out_linear, G_out_linear, B_out_linear] must then be converted to |
| * gamma space: [R_out, G_out, B_out] before blending. |
| * |
| * Parameters: |
| * matrix - a 4x4 transform matrix (16 floats) as described above |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in |
| * HWC2_ERROR_BAD_LAYER - an invalid layer handle was passed in |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_LAYER_COLOR_TRANSFORM)( |
| hwc2_device_t* device, hwc2_display_t display, hwc2_layer_t layer, |
| const float* matrix); |
| |
| /* getDisplayedContentSamplingAttributes(..., |
| * format, dataspace, supported_components, max_frames) |
| * Descriptor: HWC2_FUNCTION_GET_DISPLAYED_CONTENT_SAMPLING_ATTRIBUTES |
| * Optional by all HWC2 devices |
| * |
| * Query for what types of color sampling the hardware supports. |
| * |
| * Parameters: |
| * format - The format of the sampled pixels; pointer will be non-NULL |
| * dataspace - The dataspace of the sampled pixels; pointer will be non-NULL |
| * supported_components - The mask of which components can be sampled; pointer |
| * will be non-NULL |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY when an invalid display was passed in, or |
| * HWC2_ERROR_UNSUPPORTED when there is no efficient way to sample. |
| */ |
| typedef int32_t (*HWC2_PFN_GET_DISPLAYED_CONTENT_SAMPLING_ATTRIBUTES)( |
| hwc2_device_t* device, hwc2_display_t display, |
| int32_t* /* android_pixel_format_t */ format, |
| int32_t* /* android_dataspace_t */ dataspace, |
| uint8_t* /* mask of android_component_t */ supported_components); |
| |
| /* setDisplayedContentSamplingEnabled(..., enabled) |
| * Descriptor: HWC2_FUNCTION_SET_DISPLAYED_CONTENT_SAMPLING_ENABLED |
| * Optional by all HWC2 devices |
| * |
| * Enables or disables the collection of color content statistics |
| * on this display. |
| * |
| * Sampling occurs on the contents of the final composition on this display |
| * (i.e., the contents presented on screen). |
| * |
| * Sampling support is optional, and is set to DISABLE by default. |
| * On each call to ENABLE, all collected statistics will be reset. |
| * |
| * Sample data can be queried via getDisplayedContentSample(). |
| * |
| * Parameters: |
| * enabled - indicates whether to enable or disable sampling. |
| * component_mask - The mask of which components should be sampled. |
| * If zero, all supported components are to be enabled. |
| * max_frames - is the maximum number of frames that should be stored before |
| * discard. The sample represents the most-recently posted frames. |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY when an invalid display handle was passed in, |
| * HWC2_ERROR_BAD_PARAMETER when enabled was an invalid value, or |
| * HWC2_ERROR_NO_RESOURCES when the requested ringbuffer size via max_frames |
| * was not available. |
| * HWC2_ERROR_UNSUPPORTED when there is no efficient way to sample. |
| */ |
| typedef int32_t (*HWC2_PFN_SET_DISPLAYED_CONTENT_SAMPLING_ENABLED)( |
| hwc2_device_t* device, hwc2_display_t display, |
| int32_t /*hwc2_displayed_content_sampling_t*/ enabled, |
| uint8_t /* mask of android_component_t */ component_mask, |
| uint64_t max_frames); |
| |
| /* getDisplayedContentSample(..., component, max_frames, timestamp, |
| * samples_size, samples, frame_count) |
| * Descriptor: HWC2_FUNCTION_GET_DISPLAYED_CONTENT_SAMPLE |
| * Optional by all HWC2 devices |
| * |
| * Collects the results of display content color sampling for display. |
| * |
| * Collection of data can occur whether the sampling is in ENABLE or |
| * DISABLE state. |
| * |
| * Parameters: |
| * max_frames - is the maximum number of frames that should be represented in |
| * the sample. The sample represents the most-recently posted frames. |
| * If max_frames is 0, all frames are to be represented by the sample. |
| * timestamp - is the timestamp after which any frames were posted that should |
| * be included in the sample. Timestamp is CLOCK_MONOTONIC. |
| * If timestamp is 0, do not filter from the sample by time. |
| * frame_count - The number of frames represented by this sample; pointer will |
| * be non-NULL. |
| * samples_size - The sizes of the color histogram representing the color |
| * sampling. Sample_sizes are indexed in the same order as |
| * HWC2_FORMAT_COMPONENT_. |
| * samples - The arrays of data corresponding to the sampling data. Samples are |
| * indexed in the same order as HWC2_FORMAT_COMPONENT_. |
| * The size of each sample is the samples_size for the same index. |
| * Each components sample is an array that is to be filled with the |
| * evenly-weighted buckets of a histogram counting how many times a pixel |
| * of the given component was displayed onscreen. Caller owns the data and |
| * pointer may be NULL to query samples_size. |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY when an invalid display was passed in, or |
| * HWC2_ERROR_UNSUPPORTED when there is no efficient way to sample, or |
| * HWC2_ERROR_BAD_PARAMETER when the component is not supported by the hardware. |
| */ |
| typedef int32_t (*HWC2_PFN_GET_DISPLAYED_CONTENT_SAMPLE)( |
| hwc2_device_t* device, hwc2_display_t display, |
| uint64_t max_frames, uint64_t timestamp, |
| uint64_t* frame_count, int32_t samples_size[4], uint64_t* samples[4]); |
| |
| /* getDisplayCapabilities(..., outCapabilities) |
| * Descriptor: HWC2_FUNCTION_GET_DISPLAY_CAPABILITIES |
| * Required for HWC2 devices for composer 2.3 |
| * Optional for HWC2 devices for composer 2.1 and 2.2 |
| * |
| * getDisplayCapabilities returns a list of supported capabilities |
| * (as described in the definition of Capability above). |
| * This list must not change after initialization. |
| * |
| * Parameters: |
| * outNumCapabilities - if outCapabilities was nullptr, returns the number of capabilities |
| * if outCapabilities was not nullptr, returns the number of capabilities stored in |
| * outCapabilities, which must not exceed the value stored in outNumCapabilities prior |
| * to the call; pointer will be non-NULL |
| * outCapabilities - a list of supported capabilities. |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_GET_DISPLAY_CAPABILITIES)( |
| hwc2_device_t* device, hwc2_display_t display, uint32_t* outNumCapabilities, |
| uint32_t* outCapabilities); |
| |
| /* Use getDisplayCapabilities instead. If brightness is supported, must return |
| * DisplayCapability::BRIGHTNESS as one of the display capabilities via getDisplayCapabilities. |
| * Only use getDisplayCapabilities as the source of truth to query brightness support. |
| * |
| * getDisplayBrightnessSupport(displayToken) |
| * Descriptor: HWC2_FUNCTION_GET_DISPLAY_BRIGHTNESS_SUPPORT |
| * Required for HWC2 devices for composer 2.3 |
| * Optional for HWC2 devices for composer 2.1 and 2.2 |
| * |
| * getDisplayBrightnessSupport returns whether brightness operations are supported on a display. |
| * |
| * Parameters: |
| * outSupport - whether the display supports operations. |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY when the display is invalid. |
| */ |
| typedef int32_t /*hwc_error_t*/ (*HWC2_PFN_GET_DISPLAY_BRIGHTNESS_SUPPORT)(hwc2_device_t* device, |
| hwc2_display_t display, bool* outSupport); |
| |
| /* setDisplayBrightness(displayToken, brightnesss) |
| * Descriptor: HWC2_FUNCTION_SET_DISPLAY_BRIGHTNESS |
| * Required for HWC2 devices for composer 2.3 |
| * Optional for HWC2 devices for composer 2.1 and 2.2 |
| * |
| * setDisplayBrightness sets the brightness of a display. |
| * |
| * Parameters: |
| * brightness - a number between 0.0f (minimum brightness) and 1.0f (maximum brightness), or |
| * -1.0f to turn the backlight off. |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY when the display is invalid, or |
| * HWC2_ERROR_UNSUPPORTED when brightness operations are not supported, or |
| * HWC2_ERROR_BAD_PARAMETER when the brightness is invalid, or |
| * HWC2_ERROR_NO_RESOURCES when the brightness cannot be applied. |
| */ |
| typedef int32_t /*hwc_error_t*/ (*HWC2_PFN_SET_DISPLAY_BRIGHTNESS)(hwc2_device_t* device, |
| hwc2_display_t display, float brightness); |
| |
| /* Composer 2.4 additions */ |
| |
| /* getDisplayConnectionType(..., outType) |
| * Descriptor: HWC2_FUNCTION_GET_DISPLAY_CONNECTION_TYPE |
| * Optional for all HWC2 devices |
| * |
| * Returns whether the given physical display is internal or external. |
| * |
| * Parameters: |
| * outType - the connection type of the display; pointer will be non-NULL |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY when the display is invalid or virtual. |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_GET_DISPLAY_CONNECTION_TYPE)( |
| hwc2_device_t* device, hwc2_display_t display, |
| uint32_t* /*hwc2_display_connection_type_t*/ outType); |
| |
| /* getDisplayVsyncPeriod(..., outVsyncPeriods) |
| * Descriptor: HWC2_FUNCTION_GET_DISPLAY_VSYNC_PERIOD |
| * Required for HWC2 devices for composer 2.4 |
| * |
| * Retrieves which vsync period the display is currently using. |
| * |
| * If no display configuration is currently active, this function must |
| * return BAD_CONFIG. If a vsync period is about to change due to a |
| * setActiveConfigWithConstraints call, this function must return the current vsync period |
| * until the change has taken place. |
| * |
| * Parameters: |
| * outVsyncPeriod - the current vsync period of the display. |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in |
| * HWC2_ERROR_BAD_CONFIG - no configuration is currently active |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_GET_DISPLAY_VSYNC_PERIOD)( |
| hwc2_device_t* device, hwc2_display_t display, hwc2_vsync_period_t* outVsyncPeriod); |
| |
| /* setActiveConfigWithConstraints(..., |
| * config, |
| * vsyncPeriodChangeConstraints, |
| * outTimeline) |
| * Descriptor: HWC2_FUNCTION_SET_ACTIVE_CONFIG_WITH_CONSTRAINTS |
| * Required for HWC2 devices for composer 2.4 |
| * |
| * Sets the active configuration and the refresh rate for this display. |
| * If the new config shares the same config group as the current config, |
| * only the vsync period shall change. |
| * Upon returning, the given display configuration, except vsync period, must be active and |
| * remain so until either this function is called again or the display is disconnected. |
| * When the display starts to refresh at the new vsync period, onVsync_2_4 callback must be |
| * called with the new vsync period. |
| * |
| * Parameters: |
| * config - the new display configuration. |
| * vsyncPeriodChangeConstraints - constraints required for changing vsync period: |
| * desiredTimeNanos - the time in CLOCK_MONOTONIC after |
| * which the vsync period may change |
| * (i.e., the vsync period must not change |
| * before this time). |
| * seamlessRequired - if true, requires that the vsync period |
| * change must happen seamlessly without |
| * a noticeable visual artifact. |
| * When the conditions change and it may be |
| * possible to change the vsync period |
| * seamlessly, HWC2_CALLBACK_SEAMLESS_POSSIBLE |
| * callback must be called to indicate that |
| * caller should retry. |
| * outTimeline - the timeline for the vsync period change. |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in. |
| * HWC2_ERROR_BAD_CONFIG - an invalid configuration handle passed in. |
| * HWC2_ERROR_SEAMLESS_NOT_ALLOWED - when seamlessRequired was true but config provided doesn't |
| * share the same config group as the current config. |
| * HWC2_ERROR_SEAMLESS_NOT_POSSIBLE - when seamlessRequired was true but the display cannot |
| * achieve the vsync period change without a noticeable |
| * visual artifact. |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_SET_ACTIVE_CONFIG_WITH_CONSTRAINTS)( |
| hwc2_device_t* device, hwc2_display_t display, hwc2_config_t config, |
| hwc_vsync_period_change_constraints_t* vsyncPeriodChangeConstraints, |
| hwc_vsync_period_change_timeline_t* outTimeline); |
| |
| /* setAutoLowLatencyMode(displayToken, on) |
| * Descriptor: HWC2_FUNCTION_SET_AUTO_LOW_LATENCY_MODE |
| * Optional for HWC2 devices |
| * |
| * setAutoLowLatencyMode requests that the display goes into low latency mode. If the display |
| * is connected via HDMI 2.1, then Auto Low Latency Mode should be triggered. If the display is |
| * internally connected, then a custom low latency mode should be triggered (if available). |
| * |
| * Parameters: |
| * on - indicates whether to turn low latency mode on (=true) or off (=false) |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY - when the display is invalid, or |
| * HWC2_ERROR_UNSUPPORTED - when the display does not support any low latency mode |
| */ |
| typedef int32_t /*hwc_error_t*/ (*HWC2_PFN_SET_AUTO_LOW_LATENCY_MODE)(hwc2_device_t* device, |
| hwc2_display_t display, bool on); |
| |
| /* getSupportedContentTypes(..., outSupportedContentTypes) |
| * Descriptor: HWC2_FUNCTION_GET_SUPPORTED_CONTENT_TYPES |
| * Optional for HWC2 devices |
| * |
| * getSupportedContentTypes returns a list of supported content types |
| * (as described in the definition of ContentType above). |
| * This list must not change after initialization. |
| * |
| * Parameters: |
| * outNumSupportedContentTypes - if outSupportedContentTypes was nullptr, returns the number |
| * of supported content types; if outSupportedContentTypes was not nullptr, returns the |
| * number of capabilities stored in outSupportedContentTypes, which must not exceed the |
| * value stored in outNumSupportedContentTypes prior to the call; pointer will be non-NULL |
| * outSupportedContentTypes - a list of supported content types. |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in |
| */ |
| typedef int32_t /*hwc_error_t*/ (*HWC2_PFN_GET_SUPPORTED_CONTENT_TYPES)(hwc2_device_t* device, |
| hwc2_display_t display, uint32_t* outNumSupportedContentTypes, uint32_t* outSupportedContentTypes); |
| |
| /* setContentType(displayToken, contentType) |
| * Descriptor: HWC2_FUNCTION_SET_CONTENT_TYPE |
| * Optional for HWC2 devices |
| * |
| * setContentType instructs the display that the content being shown is of the given contentType |
| * (one of GRAPHICS, PHOTO, CINEMA, GAME). |
| * |
| * According to the HDMI 1.4 specification, supporting all content types is optional. Whether |
| * the display supports a given content type is reported by getSupportedContentTypes. |
| * |
| * Parameters: |
| * contentType - the type of content that is currently being shown on the display |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY - when the display is invalid, or |
| * HWC2_ERROR_UNSUPPORTED - when the given content type is a valid content type, but is not |
| * supported on this display, or |
| * HWC2_ERROR_BAD_PARAMETER - when the given content type is invalid |
| */ |
| typedef int32_t /*hwc_error_t*/ (*HWC2_PFN_SET_CONTENT_TYPE)(hwc2_device_t* device, |
| hwc2_display_t display, int32_t /* hwc2_content_type_t */ contentType); |
| |
| /* getClientTargetProperty(..., outClientTargetProperty) |
| * Descriptor: HWC2_FUNCTION_GET_CLIENT_TARGET_PROPERTY |
| * Optional for HWC2 devices |
| * |
| * Retrieves the client target properties for which the hardware composer |
| * requests after the last call to validateDisplay. The client must set the |
| * properties of the client target to match the returned values. |
| * When this API is implemented, if client composition is needed, the hardware |
| * composer must return meaningful client target property with dataspace not |
| * setting to UNKNOWN. |
| * When the returned dataspace is set to UNKNOWN, it means hardware composer |
| * requests nothing, the client must ignore the returned client target property |
| * structrue. |
| * |
| * Parameters: |
| * outClientTargetProperty - the client target properties that hardware |
| * composer requests. If dataspace field is set to UNKNOWN, it means |
| * the hardware composer requests nothing, the client must ignore the |
| * returned client target property structure. |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in |
| * HWC2_ERROR_NOT_VALIDATED - validateDisplay has not been called for this |
| * display |
| */ |
| typedef int32_t /*hwc2_error_t*/ (*HWC2_PFN_GET_CLIENT_TARGET_PROPERTY)( |
| hwc2_device_t* device, hwc2_display_t display, |
| hwc_client_target_property_t* outClientTargetProperty); |
| |
| /* setLayerGenericMetadata(..., keyLength, key, mandatory, valueLength, value) |
| * Descriptor: HWC2_FUNCTION_SET_LAYER_GENERIC_METADATA |
| * Optional for HWC2 devices for composer 2.4+ |
| * |
| * setLayerGenericMetadata sets a piece of generic metadata for the given layer. |
| * If this function is called twice with the same key but different values, the |
| * newer value must override the older one. Calling this function with |
| * valueLength == 0 must reset that key's metadata as if it had not been set. |
| * |
| * A given piece of metadata may either be mandatory or a hint (non-mandatory) |
| * as indicated by the `mandatory` parameter. Mandatory metadata may affect the |
| * composition result, which is to say that it may cause a visible change in the |
| * final image. By contrast, hints may only affect the composition strategy, |
| * such as which layers are composited by the client, but must not cause a |
| * visible change in the final image. |
| * |
| * This implies that if the device does not understand a given key: |
| * - If the key is marked as mandatory, it must mark this layer for client |
| * composition in order to ensure the correct composition result |
| * - If the key is a hint, the metadata provided may be ignored |
| * |
| * Parameters: |
| * keyLength - the length of the key parameter |
| * key - the metadata key |
| * mandatory - indicates whether this particular key represents mandatory |
| * metadata or a hint, as described above |
| * valueLength - the length of the value parameter |
| * value - the metadata value |
| * |
| * Returns HWC2_ERROR_NONE or one of the following errors: |
| * HWC2_ERROR_BAD_DISPLAY - an invalid display handle was passed in |
| * HWC2_ERROR_BAD_LAYER - an invalid layer handle was passed in |
| * HWC2_ERROR_BAD_PARAMETER - an unsupported key was passed in, or the value |
| * does not conform to the expected format for the key |
| */ |
| typedef int32_t /*hwc_error_t*/ (*HWC2_PFN_SET_LAYER_GENERIC_METADATA)(hwc2_device_t* device, |
| hwc2_display_t display, hwc2_layer_t layer, uint32_t keyLength, const char* key, |
| bool mandatory, uint32_t valueLength, const uint8_t* value); |
| |
| /* getLayerGenericMetadataKey(..., keyIndex, outKeyLength, outKey, outMandatory) |
| * Descriptor: HWC2_FUNCTION_GET_LAYER_GENERIC_METADATA_KEY |
| * Optional for HWC2 devices for composer 2.4+ |
| * |
| * getLayerGenericMetadataKey allows the client to query which metadata keys are |
| * supported by the composer implementation. Only keys in this list will be |
| * passed into setLayerGenericMetadata. Additionally, the key names in this list |
| * must meet the following requirements: |
| * - Must be specified in reverse domain name notation |
| * - Must not start with 'com.android' or 'android' |
| * - Must be unique within the returned list of keys |
| * - Must correspond to a matching HIDL struct type, which defines the structure |
| * of its values. For example, the key 'com.example.V1-3.Foo' should |
| * correspond to a value of type com.example@1.3::Foo, which is defined in a |
| * vendor HAL extension |
| * |
| * Client code which calls this function will look similar to this: |
| * |
| * struct Key { |
| * std::string name; |
| * bool mandatory; |
| * } |
| * |
| * std::vector<Key> keys; |
| * uint32_t index = 0; |
| * uint32_t keyLength = 0; |
| * while (true) { |
| * getLayerGenericMetadataKey(device, index, &keyLength, nullptr, nullptr); |
| * if (keyLength == 0) break; |
| * |
| * Key key; |
| * key.name.resize(keyLength); |
| * getLayerGenericMetadataKey(device, index, &keyLength, key.name.data(), &key.mandatory); |
| * keys.push_back(key); |
| * |
| * ++index; |
| * } |
| * |
| * Parameters: |
| * keyIndex - the index of the key to retrieve. For values beyond the end of |
| * the list of supported keys, outKeyLength should return 0, and the |
| * client may assume that if the length is 0 for keyIndex N, then it is |
| * also 0 for all keyIndex values > N. |
| * outKeyLength - if outKey was nullptr, returns the length of the key to |
| * allow the client to allocate an appropriately-sized buffer; if outKey |
| * was not nullptr, returns the length of the returned key, which must not |
| * exceed the value stored in outKeyLength prior to the call; pointer will |
| * be non-null |
| * outKey - the key at the given index, or nullptr to query the key's length |
| * outMandatory - whether the given metadata is mandatory or not (see |
| * setLayerGenericMetadata for more information), may be nullptr |
| */ |
| typedef void (*HWC2_PFN_GET_LAYER_GENERIC_METADATA_KEY)(hwc2_device_t* device, uint32_t keyIndex, |
| uint32_t* outKeyLength, char* outKey, bool* outMandatory); |
| |
| __END_DECLS |
| |
| #endif |
