kde_output_device_v2

# kde_output_device_v2

An output device describes a display device available to the compositor. output_device is similar to wl_output, but focuses on output configuration management. A client can query all global output_device objects to enlist all available display devices, even those that may currently not be represented by the compositor as a wl_output. The client sends configuration changes to the server through the outputconfiguration interface, and the server applies the configuration changes to the hardware and signals changes to the output devices accordingly. This object is published as global during start up for every available display devices, or when one later becomes available, for example by being hotplugged via a physical connector. Warning! The protocol described in this file is a desktop environment implementation detail. Regular clients must not use this protocol. Backward incompatible changes may be added without bumping the major version of the extension.

Events
- #
  geometry
  
  geometric properties of the output
  
  int32_t x /* x position within the global compositor space */
  
  int32_t y /* y position within the global compositor space */
  
  int32_t physical_width /* width in millimeters of the output */
  
  int32_t physical_height /* height in millimeters of the output */
  
  int32_t subpixel /* subpixel orientation of the output */
  
  const char* make /* textual description of the manufacturer */
  
  const char* model /* textual description of the model */
  
  int32_t transform /* transform that maps framebuffer to output */
  
  The geometry event describes geometric properties of the output. The event is sent when binding to the output object and whenever any of the properties change.
- #
  current_mode
  
  current mode
  
  struct kde_output_device_mode_v2* mode
  
  This event describes the mode currently in use for this head. It is only sent if the output is enabled.
- #
  mode
  
  advertise available output modes and current one
  
  struct kde_output_device_mode_v2* mode
  
  The mode event describes an available mode for the output. When the client binds to the output_device object, the server sends this event once for every available mode the output_device can be operated by. There will always be at least one event sent out on initial binding, which represents the current mode. Later if an output changes, its mode event is sent again for the eventual added modes and lastly the current mode. In other words, the current mode is always represented by the latest event sent with the current flag set. The size of a mode is given in physical hardware units of the output device. This is not necessarily the same as the output size in the global compositor space. For instance, the output may be scaled, as described in kde_output_device_v2.scale, or transformed, as described in kde_output_device_v2.transform.
- #
  done
  
  sent all information about output
  
  This event is sent after all other properties have been sent on binding to the output object as well as after any other output property change have been applied later on. This allows to see changes to the output properties as atomic, even if multiple events successively announce them.
- #
  scale
  
  output scaling properties
  
  wl_fixed_t factor /* scaling factor of output */
  
  This event contains scaling geometry information that is not in the geometry event. It may be sent after binding the output object or if the output scale changes later. If it is not sent, the client should assume a scale of 1. A scale larger than 1 means that the compositor will automatically scale surface buffers by this amount when rendering. This is used for high resolution displays where applications rendering at the native resolution would be too small to be legible. It is intended that scaling aware clients track the current output of a surface, and if it is on a scaled output it should use wl_surface.set_buffer_scale with the scale of the output. That way the compositor can avoid scaling the surface, and the client can supply a higher detail image.
- #
  edid
  
  advertise EDID data for the output
  
  const char* raw /* base64-encoded EDID string */
  
  The edid event encapsulates the EDID data for the outputdevice. The event is sent when binding to the output object. The EDID data may be empty, in which case this event is sent anyway. If the EDID information is empty, you can fall back to the name et al. properties of the outputdevice.
- #
  enabled
  
  output is enabled or disabled
  
  int32_t enabled /* output enabled state */
  
  The enabled event notifies whether this output is currently enabled and used for displaying content by the server. The event is sent when binding to the output object and whenever later on an output changes its state by becoming enabled or disabled.
- #
  uuid
  
  A unique id for this outputdevice
  
  const char* uuid /* output devices ID */
  
  The uuid can be used to identify the output. It's controlled by the server entirely. The server should make sure the uuid is persistent across restarts. An empty uuid is considered invalid.
- #
  serial_number
  
  Serial Number
  
  const char* serialNumber /* textual representation of serial number */
  
  Serial ID of the monitor, sent on startup before the first done event.
- #
  eisa_id
  
  EISA ID
  
  const char* eisaId /* textual representation of EISA identifier */
  
  EISA ID of the monitor, sent on startup before the first done event.
- #
  capabilities
  
  capability flags
  
  uint32_t flags
  
  What capabilities this device has, sent on startup before the first done event.
- #
  overscan
  
  overscan
  
  uint32_t overscan /* amount of overscan of the monitor */
  
  Overscan value of the monitor in percent, sent on startup before the first done event.
- #
  vrr_policy
  
  Variable Refresh Rate Policy
  
  uint32_t vrr_policy
  
  What policy the compositor will employ regarding its use of variable refresh rate.
- #
  rgb_range
  
  RGB range
  
  uint32_t rgb_range
  
  What rgb range the compositor is using for this output
- #
  name
  
  Output's name
  
  const char* name
  
  Name of the output, it's useful to cross-reference to an zxdg_output_v1 and ultimately QScreen
- #
  high_dynamic_range
  
  if HDR is enabled
  
  uint32_t hdr_enabled /* 1 if enabled, 0 if disabled */
  
  Whether or not high dynamic range is enabled for this output
- #
  sdr_brightness
  
  the brightness of sdr if hdr is enabled
  
  uint32_t sdr_brightness
  
  If high dynamic range is used, this value defines the brightness in nits for content that's in standard dynamic range format. Note that while the value is in nits, that doesn't necessarily translate to the same brightness on the screen.
- #
  wide_color_gamut
  
  if WCG is enabled
  
  uint32_t wcg_enabled /* 1 if enabled, 0 if disabled */
  
  Whether or not the use of a wide color gamut is enabled for this output
- #
  auto_rotate_policy
  
  describes when auto rotate is used
  
  uint32_t policy
- #
  icc_profile_path
  
  describes when auto rotate is used
  
  const char* profile_path
- #
  brightness_metadata
  
  metadata about the screen's brightness limits
  
  uint32_t max_peak_brightness /* in nits */
  
  uint32_t max_frame_average_brightness /* in nits */
  
  uint32_t min_brightness /* in 0.0001 nits */
- #
  brightness_overrides
  
  overrides for the screen's brightness limits
  
  int32_t max_peak_brightness /* -1 for no override, positive values are the brightness in nits */
  
  int32_t max_average_brightness /* -1 for no override, positive values are the brightness in nits */
  
  int32_t min_brightness /* -1 for no override, positive values are the brightness in 0.0001 nits */
- #
  sdr_gamut_wideness
  
  describes which gamut is assumed for sRGB applications
  
  uint32_t gamut_wideness /* 0 means rec.709 primaries, 10000 means native primaries */
  
  This can be used to provide the colors users assume sRGB applications should have based on the default experience on many modern sRGB screens.
- #
  color_profile_source
  
  describes which source the compositor uses for the color profile on an output
  
  uint32_t source
- #
  brightness
  
  brightness multiplier
  
  uint32_t brightness /* brightness in 0-10000 */
  
  This is the brightness modifier of the output. It doesn't specify any absolute values, but is merely a multiplier on top of other brightness values, like sdr_brightness and brightness_metadata. 0 is the minimum brightness (not completely dark) and 10000 is the maximum brightness. This is currently only supported / meaningful while HDR is active.
Enums
- #
  subpixel
  
  subpixel geometry information
  
  KDE_OUTPUT_DEVICE_V2_SUBPIXEL_UNKNOWN
  
  KDE_OUTPUT_DEVICE_V2_SUBPIXEL_NONE
  
  KDE_OUTPUT_DEVICE_V2_SUBPIXEL_HORIZONTAL_RGB
  
  KDE_OUTPUT_DEVICE_V2_SUBPIXEL_HORIZONTAL_BGR
  
  KDE_OUTPUT_DEVICE_V2_SUBPIXEL_VERTICAL_RGB
  
  KDE_OUTPUT_DEVICE_V2_SUBPIXEL_VERTICAL_BGR
  
  This enumeration describes how the physical pixels on an output are laid out.
- #
  transform
  
  transform from framebuffer to output
  
  KDE_OUTPUT_DEVICE_V2_TRANSFORM_NORMAL
  
  KDE_OUTPUT_DEVICE_V2_TRANSFORM_90
  
  KDE_OUTPUT_DEVICE_V2_TRANSFORM_180
  
  KDE_OUTPUT_DEVICE_V2_TRANSFORM_270
  
  KDE_OUTPUT_DEVICE_V2_TRANSFORM_FLIPPED
  
  KDE_OUTPUT_DEVICE_V2_TRANSFORM_FLIPPED_90
  
  KDE_OUTPUT_DEVICE_V2_TRANSFORM_FLIPPED_180
  
  KDE_OUTPUT_DEVICE_V2_TRANSFORM_FLIPPED_270
  
  This describes the transform, that a compositor will apply to a surface to compensate for the rotation or mirroring of an output device. The flipped values correspond to an initial flip around a vertical axis followed by rotation. The purpose is mainly to allow clients to render accordingly and tell the compositor, so that for fullscreen surfaces, the compositor is still able to scan out directly client surfaces.
- #
  capability
  
  describes capabilities of the outputdevice
  
  KDE_OUTPUT_DEVICE_V2_CAPABILITY_OVERSCAN /* if this output_device can use overscan */
  
  KDE_OUTPUT_DEVICE_V2_CAPABILITY_VRR /* if this outputdevice supports variable refresh rate */
  
  KDE_OUTPUT_DEVICE_V2_CAPABILITY_RGB_RANGE /* if setting the rgb range is possible */
  
  KDE_OUTPUT_DEVICE_V2_CAPABILITY_HIGH_DYNAMIC_RANGE /* if this outputdevice supports high dynamic range */
  
  KDE_OUTPUT_DEVICE_V2_CAPABILITY_WIDE_COLOR_GAMUT /* if this outputdevice supports a wide color gamut */
  
  KDE_OUTPUT_DEVICE_V2_CAPABILITY_AUTO_ROTATE /* if this outputdevice supports autorotation */
  
  KDE_OUTPUT_DEVICE_V2_CAPABILITY_ICC_PROFILE /* if this outputdevice supports icc profiles */
  
  KDE_OUTPUT_DEVICE_V2_CAPABILITY_BRIGHTNESS /* if this outputdevice supports the brightness setting */
  
  Describes what capabilities this device has.
- #
  vrr_policy
  
  describes vrr policy
  
  KDE_OUTPUT_DEVICE_V2_VRR_POLICY_NEVER
  
  KDE_OUTPUT_DEVICE_V2_VRR_POLICY_ALWAYS
  
  KDE_OUTPUT_DEVICE_V2_VRR_POLICY_AUTOMATIC
  
  Describes when the compositor may employ variable refresh rate
- #
  rgb_range
  
  describes RGB range policy
  
  KDE_OUTPUT_DEVICE_V2_RGB_RANGE_AUTOMATIC
  
  KDE_OUTPUT_DEVICE_V2_RGB_RANGE_FULL
  
  KDE_OUTPUT_DEVICE_V2_RGB_RANGE_LIMITED
  
  Whether full or limited color range should be used
- #
  auto_rotate_policy
  
  describes when auto rotate should be used
  
  KDE_OUTPUT_DEVICE_V2_AUTO_ROTATE_POLICY_NEVER
  
  KDE_OUTPUT_DEVICE_V2_AUTO_ROTATE_POLICY_IN_TABLET_MODE
  
  KDE_OUTPUT_DEVICE_V2_AUTO_ROTATE_POLICY_ALWAYS
- #
  color_profile_source
  
  which source the compositor should use for the color profile on an output
  
  KDE_OUTPUT_DEVICE_V2_COLOR_PROFILE_SOURCE_SRGB
  
  KDE_OUTPUT_DEVICE_V2_COLOR_PROFILE_SOURCE_ICC
  
  KDE_OUTPUT_DEVICE_V2_COLOR_PROFILE_SOURCE_EDID
# kde_output_device_mode_v2

This object describes an output mode. Some heads don't support output modes, in which case modes won't be advertised. Properties sent via this interface are applied atomically via the kde_output_device.done event. No guarantees are made regarding the order in which properties are sent.

Events
- #
  size
  
  mode size
  
  int32_t width /* width of the mode in hardware units */
  
  int32_t height /* height of the mode in hardware units */
  
  This event describes the mode size. The size is given in physical hardware units of the output device. This is not necessarily the same as the output size in the global compositor space. For instance, the output may be scaled or transformed.
- #
  refresh
  
  mode refresh rate
  
  int32_t refresh /* vertical refresh rate in mHz */
  
  This event describes the mode's fixed vertical refresh rate. It is only sent if the mode has a fixed refresh rate.
- #
  preferred
  
  mode is preferred
  
  This event advertises this mode as preferred.
- #
  removed
  
  the mode has been destroyed
  
  The compositor will destroy the object immediately after sending this event, so it will become invalid and the client should release any resources associated with it.

Copyright Info

SPDX-FileCopyrightText: 2008-2011 Kristian Høgsberg SPDX-FileCopyrightText: 2010-2011 Intel Corporation SPDX-FileCopyrightText: 2012-2013 Collabora, Ltd. SPDX-FileCopyrightText: 2015 Sebastian Kügler <sebas@kde.org> SPDX-FileCopyrightText: 2021 Méven Car <meven.car@enioka.com> SPDX-License-Identifier: MIT-CMU

kde_output_device_v2

# kde_output_device_v2

Events

Enums

# kde_output_device_mode_v2

Events

Copyright Info