ext_image_copy_capture_v1

# ext_image_copy_capture_manager_v1

This object is a manager which offers requests to start capturing from a source.

Requests
- #
  create_session
  
  capture an image capture source
  
  struct ext_image_copy_capture_session_v1* ext_image_copy_capture_manager_v1_create_session(
  struct ext_image_copy_capture_manager_v1* ext_image_copy_capture_manager_v1,
  
  struct ext_image_capture_source_v1* source,
  
  uint32_t options
  )
  
  Create a capturing session for an image capture source. If the paint_cursors option is set, cursors shall be composited onto the captured frame. The cursor must not be composited onto the frame if this flag is not set. If the options bitfield is invalid, the invalid_option protocol error is sent.
- #
  create_pointer_cursor_session
  
  capture the pointer cursor of an image capture source
  
  struct ext_image_copy_capture_cursor_session_v1* ext_image_copy_capture_manager_v1_create_pointer_cursor_session(
  struct ext_image_copy_capture_manager_v1* ext_image_copy_capture_manager_v1,
  
  struct ext_image_capture_source_v1* source,
  
  struct wl_pointer* pointer
  )
  
  Create a cursor capturing session for the pointer of an image capture source.
- #
  destroy
  
  destroy the manager
  
  void ext_image_copy_capture_manager_v1_destroy(
  struct ext_image_copy_capture_manager_v1* ext_image_copy_capture_manager_v1
  )
  
  Destroy the manager object. Other objects created via this interface are unaffected.
Enums
- #
  error
  
  EXT_IMAGE_COPY_CAPTURE_MANAGER_V1_ERROR_INVALID_OPTION /* invalid option flag */
- #
  options
  
  EXT_IMAGE_COPY_CAPTURE_MANAGER_V1_OPTIONS_PAINT_CURSORS /* paint cursors onto captured frames */
# ext_image_copy_capture_session_v1

This object represents an active image copy capture session. After a capture session is created, buffer constraint events will be emitted from the compositor to tell the client which buffer types and formats are supported for reading from the session. The compositor may re-send buffer constraint events whenever they change. The advertise buffer constraints, the compositor must send in no particular order: zero or more shm_format and dmabuf_format events, zero or one dmabuf_device event, and exactly one buffer_size event. Then the compositor must send a done event. When the client has received all the buffer constraints, it can create a buffer accordingly, attach it to the capture session using the attach_buffer request, set the buffer damage using the damage_buffer request and then send the capture request.

Requests
- #
  create_frame
  
  create a frame
  
  struct ext_image_copy_capture_frame_v1* ext_image_copy_capture_session_v1_create_frame(
  struct ext_image_copy_capture_session_v1* ext_image_copy_capture_session_v1
  )
  
  Create a capture frame for this session. At most one frame object can exist for a given session at any time. If a client sends a create_frame request before a previous frame object has been destroyed, the duplicate_frame protocol error is raised.
- #
  destroy
  
  delete this object
  
  void ext_image_copy_capture_session_v1_destroy(
  struct ext_image_copy_capture_session_v1* ext_image_copy_capture_session_v1
  )
  
  Destroys the session. This request can be sent at any time by the client. This request doesn't affect ext_image_copy_capture_frame_v1 objects created by this object.
Events
- #
  buffer_size
  
  image capture source dimensions
  
  uint32_t width /* buffer width */
  
  uint32_t height /* buffer height */
  
  Provides the dimensions of the source image in buffer pixel coordinates. The client must attach buffers that match this size.
- #
  shm_format
  
  shm buffer format
  
  uint32_t format /* shm format */
  
  Provides the format that must be used for shared-memory buffers. This event may be emitted multiple times, in which case the client may choose any given format.
- #
  dmabuf_device
  
  dma-buf device
  
  struct wl_array* device /* device dev_t value */
  
  This event advertises the device buffers must be allocated on for dma-buf buffers. In general the device is a DRM node. The DRM node type (primary vs. render) is unspecified. Clients must not rely on the compositor sending a particular node type. Clients cannot check two devices for equality by comparing the dev_t value.
- #
  dmabuf_format
  
  dma-buf format
  
  uint32_t format /* drm format code */
  
  struct wl_array* modifiers /* drm format modifiers */
  
  Provides the format that must be used for dma-buf buffers. The client may choose any of the modifiers advertised in the array of 64-bit unsigned integers. This event may be emitted multiple times, in which case the client may choose any given format.
- #
  done
  
  all constraints have been sent
  
  This event is sent once when all buffer constraint events have been sent. The compositor must always end a batch of buffer constraint events with this event, regardless of whether it sends the initial constraints or an update.
- #
  stopped
  
  session is no longer available
  
  This event indicates that the capture session has stopped and is no longer available. This can happen in a number of cases, e.g. when the underlying source is destroyed, if the user decides to end the image capture, or if an unrecoverable runtime error has occurred. The client should destroy the session after receiving this event.
Enums
- #
  error
  
  EXT_IMAGE_COPY_CAPTURE_SESSION_V1_ERROR_DUPLICATE_FRAME /* create_frame sent before destroying previous frame */
# ext_image_copy_capture_frame_v1

This object represents an image capture frame. The client should attach a buffer, damage the buffer, and then send a capture request. If the capture is successful, the compositor must send the frame metadata (transform, damage, presentation_time in any order) followed by the ready event. If the capture fails, the compositor must send the failed event.

Requests
- #
  destroy
  
  destroy this object
  
  void ext_image_copy_capture_frame_v1_destroy(
  struct ext_image_copy_capture_frame_v1* ext_image_copy_capture_frame_v1
  )
  
  Destroys the session. This request can be sent at any time by the client.
- #
  attach_buffer
  
  attach buffer to session
  
  void ext_image_copy_capture_frame_v1_attach_buffer(
  struct ext_image_copy_capture_frame_v1* ext_image_copy_capture_frame_v1,
  
  struct wl_buffer* buffer
  )
  
  Attach a buffer to the session. The wl_buffer.release request is unused. The new buffer replaces any previously attached buffer. This request must not be sent after capture, or else the already_captured protocol error is raised.
- #
  damage_buffer
  
  damage buffer
  
  void ext_image_copy_capture_frame_v1_damage_buffer(
  struct ext_image_copy_capture_frame_v1* ext_image_copy_capture_frame_v1,
  
  int32_t x, /* region x coordinate */
  
  int32_t y, /* region y coordinate */
  
  int32_t width, /* region width */
  
  int32_t height /* region height */
  )
  
  Apply damage to the buffer which is to be captured next. This request may be sent multiple times to describe a region. The client indicates the accumulated damage since this wl_buffer was last captured. During capture, the compositor will update the buffer with at least the union of the region passed by the client and the region advertised by ext_image_copy_capture_frame_v1.damage. When a wl_buffer is captured for the first time, or when the client doesn't track damage, the client must damage the whole buffer. This is for optimisation purposes. The compositor may use this information to reduce copying. These coordinates originate from the upper left corner of the buffer. If x or y are strictly negative, or if width or height are negative or zero, the invalid_buffer_damage protocol error is raised. This request must not be sent after capture, or else the already_captured protocol error is raised.
- #
  capture
  
  capture a frame
  
  void ext_image_copy_capture_frame_v1_capture(
  struct ext_image_copy_capture_frame_v1* ext_image_copy_capture_frame_v1
  )
  
  Capture a frame. Unless this is the first successful captured frame performed in this session, the compositor may wait an indefinite amount of time for the source content to change before performing the copy. This request may only be sent once, or else the already_captured protocol error is raised. A buffer must be attached before this request is sent, or else the no_buffer protocol error is raised.
Events
- #
  transform
  
  buffer transform
  
  uint32_t transform
  
  This event is sent before the ready event and holds the transform that the compositor has applied to the buffer contents.
- #
  damage
  
  buffer damaged region
  
  int32_t x /* damage x coordinate */
  
  int32_t y /* damage y coordinate */
  
  int32_t width /* damage width */
  
  int32_t height /* damage height */
  
  This event is sent before the ready event. It may be generated multiple times to describe a region. The first captured frame in a session will always carry full damage. Subsequent frames' damaged regions describe which parts of the buffer have changed since the last ready event. These coordinates originate in the upper left corner of the buffer.
- #
  presentation_time
  
  presentation time of the frame
  
  uint32_t tv_sec_hi /* high 32 bits of the seconds part of the timestamp */
  
  uint32_t tv_sec_lo /* low 32 bits of the seconds part of the timestamp */
  
  uint32_t tv_nsec /* nanoseconds part of the timestamp */
  
  This event indicates the time at which the frame is presented to the output in system monotonic time. This event is sent before the ready event. The timestamp is expressed as tv_sec_hi, tv_sec_lo, tv_nsec triples, each component being an unsigned 32-bit value. Whole seconds are in tv_sec which is a 64-bit value combined from tv_sec_hi and tv_sec_lo, and the additional fractional part in tv_nsec as nanoseconds. Hence, for valid timestamps tv_nsec must be in [0, 999999999].
- #
  ready
  
  frame is available for reading
  
  Called as soon as the frame is copied, indicating it is available for reading. The buffer may be re-used by the client after this event. After receiving this event, the client must destroy the object.
- #
  failed
  
  capture failed
  
  uint32_t reason
  
  This event indicates that the attempted frame copy has failed. After receiving this event, the client must destroy the object.
Enums
- #
  error
  
  EXT_IMAGE_COPY_CAPTURE_FRAME_V1_ERROR_NO_BUFFER /* capture sent without attach_buffer */
  
  EXT_IMAGE_COPY_CAPTURE_FRAME_V1_ERROR_INVALID_BUFFER_DAMAGE /* invalid buffer damage */
  
  EXT_IMAGE_COPY_CAPTURE_FRAME_V1_ERROR_ALREADY_CAPTURED /* capture request has been sent */
- #
  failure_reason
  
  EXT_IMAGE_COPY_CAPTURE_FRAME_V1_FAILURE_REASON_UNKNOWN
  
  EXT_IMAGE_COPY_CAPTURE_FRAME_V1_FAILURE_REASON_BUFFER_CONSTRAINTS
  
  EXT_IMAGE_COPY_CAPTURE_FRAME_V1_FAILURE_REASON_STOPPED
# ext_image_copy_capture_cursor_session_v1

This object represents a cursor capture session. It extends the base capture session with cursor-specific metadata.

Requests
- #
  destroy
  
  delete this object
  
  void ext_image_copy_capture_cursor_session_v1_destroy(
  struct ext_image_copy_capture_cursor_session_v1* ext_image_copy_capture_cursor_session_v1
  )
  
  Destroys the session. This request can be sent at any time by the client. This request doesn't affect ext_image_copy_capture_frame_v1 objects created by this object.
- #
  get_capture_session
  
  get image copy captuerer session
  
  struct ext_image_copy_capture_session_v1* ext_image_copy_capture_cursor_session_v1_get_capture_session(
  struct ext_image_copy_capture_cursor_session_v1* ext_image_copy_capture_cursor_session_v1
  )
  
  Gets the image copy capture session for this cursor session. The session will produce frames of the cursor image. The compositor may pause the session when the cursor leaves the captured area. This request must not be sent more than once, or else the duplicate_session protocol error is raised.
Events
- #
  enter
  
  cursor entered captured area
  
  Sent when a cursor enters the captured area. It shall be generated before the "position" and "hotspot" events when and only when a cursor enters the area. The cursor enters the captured area when the cursor image intersects with the captured area. Note, this is different from e.g. wl_pointer.enter.
- #
  leave
  
  cursor left captured area
  
  Sent when a cursor leaves the captured area. No "position" or "hotspot" event is generated for the cursor until the cursor enters the captured area again.
- #
  position
  
  position changed
  
  int32_t x /* position x coordinates */
  
  int32_t y /* position y coordinates */
  
  Cursors outside the image capture source do not get captured and no event will be generated for them. The given position is the position of the cursor's hotspot and it is relative to the main buffer's top left corner in transformed buffer pixel coordinates. The coordinates may be negative or greater than the main buffer size.
- #
  hotspot
  
  hotspot changed
  
  int32_t x /* hotspot x coordinates */
  
  int32_t y /* hotspot y coordinates */
  
  The hotspot describes the offset between the cursor image and the position of the input device. The given coordinates are the hotspot's offset from the origin in buffer coordinates. Clients should not apply the hotspot immediately: the hotspot becomes effective when the next ext_image_copy_capture_frame_v1.ready event is received. Compositors may delay this event until the client captures a new frame.
Enums
- #
  error
  
  EXT_IMAGE_COPY_CAPTURE_CURSOR_SESSION_V1_ERROR_DUPLICATE_SESSION /* get_captuerer_session sent twice */

Copyright Info

Copyright © 2021-2023 Andri Yngvason Copyright © 2024 Simon Ser Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice (including the next paragraph) shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

ext_image_copy_capture_v1

# ext_image_copy_capture_manager_v1

Requests

Enums

# ext_image_copy_capture_session_v1

Requests

Events

Enums

# ext_image_copy_capture_frame_v1

Requests

Events

Enums

# ext_image_copy_capture_cursor_session_v1

Requests

Events

Enums

Copyright Info