Enum fidl_fuchsia_hardware_display::CoordinatorRequest

pub enum CoordinatorRequest {
    ImportImage {
        image_metadata: ImageMetadata,
        buffer_id: BufferId,
        image_id: ImageId,
        responder: CoordinatorImportImageResponder,
    },
    ReleaseImage {
        image_id: ImageId,
        control_handle: CoordinatorControlHandle,
    },
    ImportEvent {
        event: Event,
        id: EventId,
        control_handle: CoordinatorControlHandle,
    },
    ReleaseEvent {
        id: EventId,
        control_handle: CoordinatorControlHandle,
    },
    CreateLayer {
        responder: CoordinatorCreateLayerResponder,
    },
    DestroyLayer {
        layer_id: LayerId,
        control_handle: CoordinatorControlHandle,
    },
    SetDisplayMode {
        display_id: DisplayId,
        mode: Mode,
        control_handle: CoordinatorControlHandle,
    },
    SetDisplayColorConversion {
        display_id: DisplayId,
        preoffsets: [f32; 3],
        coefficients: [f32; 9],
        postoffsets: [f32; 3],
        control_handle: CoordinatorControlHandle,
    },
    SetDisplayLayers {
        display_id: DisplayId,
        layer_ids: Vec<LayerId>,
        control_handle: CoordinatorControlHandle,
    },
    SetLayerPrimaryConfig {
        layer_id: LayerId,
        image_metadata: ImageMetadata,
        control_handle: CoordinatorControlHandle,
    },
    SetLayerPrimaryPosition {
        layer_id: LayerId,
        transform: Transform,
        src_frame: Frame,
        dest_frame: Frame,
        control_handle: CoordinatorControlHandle,
    },
    SetLayerPrimaryAlpha {
        layer_id: LayerId,
        mode: AlphaMode,
        val: f32,
        control_handle: CoordinatorControlHandle,
    },
    SetLayerColorConfig {
        layer_id: LayerId,
        pixel_format: PixelFormat,
        color_bytes: Vec<u8>,
        control_handle: CoordinatorControlHandle,
    },
    SetLayerImage {
        layer_id: LayerId,
        image_id: ImageId,
        wait_event_id: EventId,
        signal_event_id: EventId,
        control_handle: CoordinatorControlHandle,
    },
    CheckConfig {
        discard: bool,
        responder: CoordinatorCheckConfigResponder,
    },
    ApplyConfig {
        control_handle: CoordinatorControlHandle,
    },
    GetLatestAppliedConfigStamp {
        responder: CoordinatorGetLatestAppliedConfigStampResponder,
    },
    ApplyConfig2 {
        signal_fences: Vec<Event>,
        control_handle: CoordinatorControlHandle,
    },
    EnableVsync {
        enable: bool,
        control_handle: CoordinatorControlHandle,
    },
    AcknowledgeVsync {
        cookie: u64,
        control_handle: CoordinatorControlHandle,
    },
    SetVirtconMode {
        mode: VirtconMode,
        control_handle: CoordinatorControlHandle,
    },
    ImportBufferCollection {
        buffer_collection_id: BufferCollectionId,
        buffer_collection_token: ClientEnd<BufferCollectionTokenMarker>,
        responder: CoordinatorImportBufferCollectionResponder,
    },
    ReleaseBufferCollection {
        buffer_collection_id: BufferCollectionId,
        control_handle: CoordinatorControlHandle,
    },
    SetBufferCollectionConstraints {
        buffer_collection_id: BufferCollectionId,
        buffer_usage: ImageBufferUsage,
        responder: CoordinatorSetBufferCollectionConstraintsResponder,
    },
    IsCaptureSupported {
        responder: CoordinatorIsCaptureSupportedResponder,
    },
    StartCapture {
        signal_event_id: EventId,
        image_id: ImageId,
        responder: CoordinatorStartCaptureResponder,
    },
    SetMinimumRgb {
        minimum_rgb: u8,
        responder: CoordinatorSetMinimumRgbResponder,
    },
    SetDisplayPower {
        display_id: DisplayId,
        power_on: bool,
        responder: CoordinatorSetDisplayPowerResponder,
    },
}

Interface for accessing the display hardware.

A display configuration can be separated into two parts: the layer layout and the layer contents. The layout includes all parts of a configuration other than the image handles. The active configuration is composed of the most recently applied layout and an active image from each layer - see SetLayerImage for details on how the active image is defined. Note the requirement that each layer has an active image. Whenever a new active configuration is available, it is immediately given to the hardware. This allows the layout and each layer’s contents to advance independently when possible.

Performing illegal actions on the interface will result in the interface being closed.

Variants

ImportImage

Imports a Buffer-Collection backed image.

image_metadata must be compatible with the arguments passed to [fuchsia.hardware.display/Coordinator.SetBufferCollectionConstraints] on the buffer_collection_id.

Returns ZX_ERR_NOT_SUPPORTED if the display hardware doesn’t support image_config. Returns ZX_ERR_ALREADY_EXISTS if image_id was used in a successful ImportImage() without a corresponding ReleaseImage().

Fields

image_metadata: ImageMetadata

buffer_id: BufferId

image_id: ImageId

responder: CoordinatorImportImageResponder

ReleaseImage

Releases an imported image.

image_id must be already imported by [fuchsia.hardware.display/Coordinator.ImportImage].

The image must not be the capture target of an ongoing capture specified in [fuchsia.hardware.display/Coordinator.StartCapture].

When an image is released, it is immediately removed from any pending or active configurations, and any fences associated with the image are dropped. The resources associated with the image will be released as soon as the image is no longer in use.

Fields

image_id: ImageId

control_handle: CoordinatorControlHandle

ImportEvent

Imports an event into the driver and associates it with the given id.

It is illegal for id to be equal to INVALID_DISP_ID, and it is undefined to import one event with two different ids or to import two different events with the same id (note that ids map well to koids).

If a client is reusing events, they must clear the signal before referencing the id again.

Fields

event: Event

id: EventId

control_handle: CoordinatorControlHandle

ReleaseEvent

Releases the event imported with the given id.

If any images are currently using the given event, the event will still be waited up or signaled as appropriate before its resources are released. It is an error to reuse an ID while the active config has references to it.

Fields

id: EventId

control_handle: CoordinatorControlHandle

CreateLayer

Fields

responder: CoordinatorCreateLayerResponder

DestroyLayer

Fields

layer_id: LayerId

control_handle: CoordinatorControlHandle

SetDisplayMode

Fields

display_id: DisplayId

mode: Mode

control_handle: CoordinatorControlHandle

SetDisplayColorConversion

Fields

display_id: DisplayId

preoffsets: [f32; 3]

coefficients: [f32; 9]

postoffsets: [f32; 3]

control_handle: CoordinatorControlHandle

SetDisplayLayers

Fields

display_id: DisplayId

layer_ids: Vec<LayerId>

control_handle: CoordinatorControlHandle

SetLayerPrimaryConfig

Fields

layer_id: LayerId

image_metadata: ImageMetadata

control_handle: CoordinatorControlHandle

SetLayerPrimaryPosition

Fields

layer_id: LayerId

transform: Transform

src_frame: Frame

dest_frame: Frame

control_handle: CoordinatorControlHandle

SetLayerPrimaryAlpha

Fields

layer_id: LayerId

mode: AlphaMode

val: f32

control_handle: CoordinatorControlHandle

SetLayerColorConfig

Fields

layer_id: LayerId

pixel_format: PixelFormat

color_bytes: Vec<u8>

control_handle: CoordinatorControlHandle

SetLayerImage

Fields

layer_id: LayerId

image_id: ImageId

wait_event_id: EventId

signal_event_id: EventId

control_handle: CoordinatorControlHandle

CheckConfig

Fields

discard: bool

responder: CoordinatorCheckConfigResponder

ApplyConfig

Fields

control_handle: CoordinatorControlHandle

GetLatestAppliedConfigStamp

Gets the stamp provided with the latest configuration the client submitted (by calling ApplyConfig()) and the display core driver accepted; the display configuration may not have been rendered yet because of pending image availability or pending layer changes. If no configuration was applied before, returns INVALID_CONFIG_STAMP_VALUE.

Fields

responder: CoordinatorGetLatestAppliedConfigStampResponder

ApplyConfig2

Applies any pending changes to the current configuration. This will not apply pending changes to layers which are not on any display.

For each event in signal_fences, once the pending configuration is applied to and contents are displayed on all the displays connected to the Coordinator, it will be signaled immediately.

Arguments

signal_fences: Stores all fence events that will be signaled once the configuration is applied.

Error handling

If the input is invalid, for example:
    - `signal_fences` contains invalid events
or the pending configuration cannot be applied, this call will
silently fail, so the client should ensure its configuration is
valid with CheckConfig().

Fields

signal_fences: Vec<Event>

control_handle: CoordinatorControlHandle

EnableVsync

Fields

enable: bool

control_handle: CoordinatorControlHandle

AcknowledgeVsync

Fields

cookie: u64

control_handle: CoordinatorControlHandle

SetVirtconMode

Sets the visibility behavior of the virtcon.

This must only be called from the Virtcon client.

Fields

mode: VirtconMode

control_handle: CoordinatorControlHandle

ImportBufferCollection

Fields

buffer_collection_id: BufferCollectionId

buffer_collection_token: ClientEnd<BufferCollectionTokenMarker>

responder: CoordinatorImportBufferCollectionResponder

ReleaseBufferCollection

Fields

buffer_collection_id: BufferCollectionId

control_handle: CoordinatorControlHandle

SetBufferCollectionConstraints

Fields

buffer_collection_id: BufferCollectionId

buffer_usage: ImageBufferUsage

responder: CoordinatorSetBufferCollectionConstraintsResponder

IsCaptureSupported

Returns true if Capture is supported on the platform.

Fields

responder: CoordinatorIsCaptureSupportedResponder

StartCapture

Starts capture. Client must provide a valid signal_event_id and image_id. signal_event_id must have been imported into the driver using ImportEvent FIDL API. Image_id is the id from ImportImageForCapture. The client will get notified once capture is complete via signal_event_id. Returns ZX_ERR_NOT_SUPPORTED if coordinator does not support capture

Fields

signal_event_id: EventId

image_id: ImageId

responder: CoordinatorStartCaptureResponder

SetMinimumRgb

Set the minimum value of rgb channels. Valid range [0 255] inclusive. Returns ZX_ERR_NOT_SUPPORTED when the display hardware does not support this feature. This API is meant to address backlight bleeding that may occur on some hardware that have a specific type of panel and hardware assembly. The evolution of this API is highly hardware and product dependant and therefore as products evolve, this API may change or support for this API may become non-existent. Therefore, this API should be used with caution.

Unlike other calls in this API, SetMiniumRgb is applied immediately, and does not wait for ApplyConfig(). It is, however, still stateful.

Fields

minimum_rgb: u8

responder: CoordinatorSetMinimumRgbResponder

SetDisplayPower

Power off/on the display panel.

This function takes effect immediately. Clients don’t need to call ApplyConfig() to commit this command.

Once a display is turned off, it will not deliver vsync events, which may include the vsync event for the most recently applied config.

Staged display control commands (e.g. SetDisplayLayer) will not be affected. They are still applied to the display device when client calls ApplyConfig(), but the contents will be shown on display panel only after client powers on the display again.

Newly added displays are turned on by default.

Returns ZX_ERR_NOT_FOUND if display_id is invalid when Coordinator handles this method. Returns ZX_ERR_NOT_SUPPORTED if the display driver IC doesn’t support turning on/off displays.

Fields

display_id: DisplayId

power_on: bool

responder: CoordinatorSetDisplayPowerResponder

Implementations

impl CoordinatorRequest

pub fn into_import_image( self ) -> Option<(ImageMetadata, BufferId, ImageId, CoordinatorImportImageResponder)>

pub fn into_release_image(self) -> Option<(ImageId, CoordinatorControlHandle)>

pub fn into_import_event( self ) -> Option<(Event, EventId, CoordinatorControlHandle)>

pub fn into_release_event(self) -> Option<(EventId, CoordinatorControlHandle)>

pub fn into_create_layer(self) -> Option<CoordinatorCreateLayerResponder>

pub fn into_destroy_layer(self) -> Option<(LayerId, CoordinatorControlHandle)>

pub fn into_set_display_mode( self ) -> Option<(DisplayId, Mode, CoordinatorControlHandle)>

pub fn into_set_display_color_conversion( self ) -> Option<(DisplayId, [f32; 3], [f32; 9], [f32; 3], CoordinatorControlHandle)>

pub fn into_set_display_layers( self ) -> Option<(DisplayId, Vec<LayerId>, CoordinatorControlHandle)>

pub fn into_set_layer_primary_config( self ) -> Option<(LayerId, ImageMetadata, CoordinatorControlHandle)>

pub fn into_set_layer_primary_position( self ) -> Option<(LayerId, Transform, Frame, Frame, CoordinatorControlHandle)>

pub fn into_set_layer_primary_alpha( self ) -> Option<(LayerId, AlphaMode, f32, CoordinatorControlHandle)>

pub fn into_set_layer_color_config( self ) -> Option<(LayerId, PixelFormat, Vec<u8>, CoordinatorControlHandle)>

pub fn into_set_layer_image( self ) -> Option<(LayerId, ImageId, EventId, EventId, CoordinatorControlHandle)>

pub fn into_check_config( self ) -> Option<(bool, CoordinatorCheckConfigResponder)>

pub fn into_apply_config(self) -> Option<CoordinatorControlHandle>

pub fn into_get_latest_applied_config_stamp( self ) -> Option<CoordinatorGetLatestAppliedConfigStampResponder>

pub fn into_apply_config2( self ) -> Option<(Vec<Event>, CoordinatorControlHandle)>

pub fn into_enable_vsync(self) -> Option<(bool, CoordinatorControlHandle)>

pub fn into_acknowledge_vsync(self) -> Option<(u64, CoordinatorControlHandle)>

pub fn into_set_virtcon_mode( self ) -> Option<(VirtconMode, CoordinatorControlHandle)>

pub fn into_import_buffer_collection( self ) -> Option<(BufferCollectionId, ClientEnd<BufferCollectionTokenMarker>, CoordinatorImportBufferCollectionResponder)>

pub fn into_release_buffer_collection( self ) -> Option<(BufferCollectionId, CoordinatorControlHandle)>

pub fn into_set_buffer_collection_constraints( self ) -> Option<(BufferCollectionId, ImageBufferUsage, CoordinatorSetBufferCollectionConstraintsResponder)>

pub fn into_is_capture_supported( self ) -> Option<CoordinatorIsCaptureSupportedResponder>

pub fn into_start_capture( self ) -> Option<(EventId, ImageId, CoordinatorStartCaptureResponder)>

pub fn into_set_minimum_rgb( self ) -> Option<(u8, CoordinatorSetMinimumRgbResponder)>

pub fn into_set_display_power( self ) -> Option<(DisplayId, bool, CoordinatorSetDisplayPowerResponder)>

pub fn method_name(&self) -> &'static str

Name of the method defined in FIDL

Trait Implementations

impl Debug for CoordinatorRequest

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.