pub enum CoordinatorRequest {
Show 28 variants
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,
image_source_transformation: CoordinateTransformation,
image_source: RectU,
display_destination: RectU,
control_handle: CoordinatorControlHandle,
},
SetLayerPrimaryAlpha {
layer_id: LayerId,
mode: AlphaMode,
val: f32,
control_handle: CoordinatorControlHandle,
},
SetLayerColorConfig {
layer_id: LayerId,
color: Color,
control_handle: CoordinatorControlHandle,
},
SetLayerImage2 {
layer_id: LayerId,
image_id: ImageId,
wait_event_id: EventId,
control_handle: CoordinatorControlHandle,
},
CheckConfig {
discard: bool,
responder: CoordinatorCheckConfigResponder,
},
DiscardConfig {
control_handle: CoordinatorControlHandle,
},
GetLatestAppliedConfigStamp {
responder: CoordinatorGetLatestAppliedConfigStampResponder,
},
ApplyConfig3 {
payload: CoordinatorApplyConfig3Request,
control_handle: CoordinatorControlHandle,
},
SetVsyncEventDelivery {
vsync_delivery_enabled: 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,
},
}Expand description
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. The channel closure epitaph will return one of 4 values:
- ZX_ERR_INVALID_ARGS: for trivially-verifiable client errors, such as providing an ID for a nonexistent image/layer/event, or a non-monotonically-increasing config stamp to ApplyConfig, etc.
- ZX_ERR_BAD_STATE: indicates that the client has violated other API invariants, such as reusing an event that hasn’t been signaled yet.
- ZX_ERR_NO_MEMORY: memory could not be allocated to satisfy the requested operation.
- ZX_ERR_INTERNAL: catch-all used for any error that is not listed above.
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().
Returns ZX_ERR_INVALID_ARGS for a variety of reasons, such as:
image_idis invalidbuffer_iddoes not refer to an already-imported buffer collectionimage_metadata.dimensionshave negative width/height, or exceed maximums ReturnsZX_ERR_NO_MEMORYif memory cannot be allocated for managing the image Additionally, this method delegates internally tofuchsia.hardware.display.engine/Engine, and will forward errors received fromImportImage()andImportImageForCapture().
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 draft 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.
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.
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.
CreateLayer
Creates a new layer.
Layers are not associated with a particular display, but they can only be shown on at most one display at any given time. A layer is considered in use from the time it is passed to SetDisplayLayers until a subsequent configuration is applied which does not include the layer or until its display is removed.
Fields
responder: CoordinatorCreateLayerResponderDestroyLayer
Destroys the given layer.
It is illegal to destroy a layer which does not exist or which is in use.
SetDisplayMode
Sets the mode for a display.
SetDisplayColorConversion
Set the color conversion applied to the display. The conversion is applied to to each pixel according to the formula:
(coefficients * (pixel + preoffsets)) + postoffsets
where pixel is a column vector consisting of the pixel’s 3 components.
coefficients is passed in row-major order. If the first entry of an array is NaN, the
array is treated as the identity element for the relevant operation.
Hardware that support color correction generally accept a limited range of coefficient
values. Coefficients in the range of [-2, 2] inclusive will be accepted by most
hardware. The hardware driver will clamp values that are outside its acceptable range.
preoffsets, postoffsets: Clients are encourged to produce color correction values that
do not depend on pre and post offsets since some hardware do not have support for that.
For cases where pre and post offset values need to be used, the range should be limited to
(-1, 1) exclusive as confirmed by CheckConfig API. Values outside this range will be
rejected.
Clients are encouraged to use the CheckConfig API to confirm support for correction and to validate their color correction input values.
This a stateful call. Once color conversion values have been succesfully applied via a call to ApplyConfig() they will remain in place until changed and another ApplyConfig() call is successful. If SetDisplayColorConversion() is called and then the config is discarded, then the last successfully applied state is restored.
Fields
control_handle: CoordinatorControlHandleSetDisplayLayers
Assigns a list of layers to be composited on a display.
SetLayerPrimaryConfig
Configures the layer as a primary layer with no image and the default config (no src_frame cropping, the identity transform, positioned in the top-left corner of the composed output, and no scaling).
See the documentation on SetLayerImage for details on how this method affects the layer’s contents.
It is illegal to pass an invalid layer id.
SetLayerPrimaryPosition
Sets the layer transform, scaling, and positioning.
CheckConfig() will return INVALID_CONFIG if any of the configuration validity conditions specified here is violated.
Calling this on a non-primary layer or passing an invalid transform is illegal.
Fields
image_source_transformation: CoordinateTransformationimage_source: RectUdisplay_destination: RectUcontrol_handle: CoordinatorControlHandleSetLayerPrimaryAlpha
Sets the alpha mode of the plane.
If mode == DISABLED, the layer is opaque and val is ignored.
If mode == PREMULTIPLIED or HW_MULTIPLY and val is NaN, the alpha
used when blending is determined by the per-pixel alpha channel.
If mode == PREMULTIPLIED or HW_MULTIPLY and val is not NaN, the
alpha used when blending is the product of val and any per-pixel
alpha. Additionally, if mode == PREMULTIPLIED, then the hardware
premultiplies the color channel with val before blending.
It is illegal to call this on a non-primary layer, to pass an
invalid mode, or to pass a value of val which is not NaN or
in the range [0, 1].
SetLayerColorConfig
Configures the layer as a solid color fill layer.
It is illegal to call this on an invalid layer.
SetLayerImage2
Sets the image for the layer’s draft configuration.
If wait_event_id corresponds to an imported event, the driver will wait for ZX_EVENT_SIGNALED on the object before presenting the image.
A layer’s applied image is the most recently applied image which either has no wait event or whose wait event has been signaled. Whenever a new image is applied, any older images which never got applied are dropped, and their signal events will be fired as soon as their wait events are signaled. The driver also does not have any concept like ‘target vsync’, meaning that if multiple images are applied within one vsync period, then only the last image will actually be displayed.
By default, the driver retains an applied image until a new image is applied. However, setting a layer’s ImageConfig with SetLayerPrimaryConfig resets the layer’s applied and waiting images, even if the new ImageConfig matches the old ImageConfig.
An image cannot be used for multiple layers simultaneously, nor can an image be given back to the display coordinator while it is still in use. An image is considered in use when it is part of a draft configuration or from when its configuration is applied until it is replaced by a subsequent configuration that is displayed (not merely applied).
It is illegal to call this with an invalid layer or image id, to call it on a color layer, or to call it with an image and layer whose ImageConfigs do not match. It is illegal to apply a configuration with an image layer that has no image (note that is is not illegal to validate such a configuration). It is illegal to reuse a wait event which another layer that has not been presented is waiting on.
Each layer can track a maximum of MAX_WAITING_IMAGES_PER_LAYER waiting images.
An image becomes “waiting” when it is the most recent image set to a layer that appears in
a config that is applied via ApplyConfig() or similar. To avoid exceeding the maximum,
the client can infer that the image is no longer waiting by:
- noting the config stamp when the config containing the layer/image is applied
- watching for that same (or later) config stamp to be returned by
CoordinatorListener.OnVsync().
Fields
control_handle: CoordinatorControlHandleCheckConfig
Validates the draft configuration.
Validation entails checking that the draft configuration can be used by the system’s display hardware.
Most SetX operations require verifying the draft configuration. The following operations do not require revalidation.
- SetLayerImage2()
DiscardConfig
Discard all draft configuration changes.
Fields
control_handle: CoordinatorControlHandleGetLatestAppliedConfigStamp
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 draft layer changes.
If no configuration was applied before, returns INVALID_CONFIG_STAMP_VALUE.
Fields
ApplyConfig3
Applies any draft changes to the current configuration. This will not apply draft changes to layers which are not on any display.
If the draft configuration cannot be applied, this call will silently
fail, so the client should ensure its configuration is valid by
calling [Coordinator.CheckConfig].
SetVsyncEventDelivery
Configures the client’s preferences for VSync event delivery.
VSync event delivery is disabled by default. Clients interested in receiving VSync events must explicitly enable their delivery.
AcknowledgeVsync
Acknowledges the receipt of one OnVsync message.
SetVirtconMode
Sets the visibility behavior of the virtcon.
This must only be called from the Virtcon client.
ImportBufferCollection
Import a sysmem buffer collection token. buffer_collection_id must not
already be in use.
Fields
buffer_collection_id: BufferCollectionIdbuffer_collection_token: ClientEnd<BufferCollectionTokenMarker>responder: CoordinatorImportBufferCollectionResponderReleaseBufferCollection
Release an imported buffer collection.
SetBufferCollectionConstraints
Takes an imported buffer collection and sets the constraints on it so that it can be imported with a specific config.
IsCaptureSupported
Returns true if Capture is supported on the platform.
Fields
responder: CoordinatorIsCaptureSupportedResponderStartCapture
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
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.
SetDisplayPower
Power off/on the display panel.
This call takes effect immediately. Clients don’t need to call
[Coordinator.ApplyConfig].
Fails with ZX_ERR_NOT_FOUND if display_id does not belong to a display
known by the Coordinator. This can happen if a client issues a call to
[Coordinator.SetDisplayPower] before it receives a notification that
the display was removed.
Fails with ZX_ERR_NOT_SUPPORTED if the display drivers or the hardware don’t support displays on and off.
Implementations§
Source§impl CoordinatorRequest
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, CoordinateTransformation, RectU, RectU, CoordinatorControlHandle)>
pub fn into_set_layer_primary_alpha( self, ) -> Option<(LayerId, AlphaMode, f32, CoordinatorControlHandle)>
pub fn into_set_layer_color_config( self, ) -> Option<(LayerId, Color, CoordinatorControlHandle)>
pub fn into_set_layer_image2( self, ) -> Option<(LayerId, ImageId, EventId, CoordinatorControlHandle)>
pub fn into_check_config( self, ) -> Option<(bool, CoordinatorCheckConfigResponder)>
pub fn into_discard_config(self) -> Option<CoordinatorControlHandle>
pub fn into_get_latest_applied_config_stamp( self, ) -> Option<CoordinatorGetLatestAppliedConfigStampResponder>
pub fn into_apply_config3( self, ) -> Option<(CoordinatorApplyConfig3Request, CoordinatorControlHandle)>
pub fn into_set_vsync_event_delivery( 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)>
Sourcepub fn method_name(&self) -> &'static str
pub fn method_name(&self) -> &'static str
Name of the method defined in FIDL