wayland_bridge/
subcompositor.rs

1// Copyright 2018 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5use crate::client::Client;
6use crate::compositor::{
7    PlaceSubsurfaceParams, Surface, SurfaceCommand, SurfaceRelation, SurfaceRole,
8};
9use crate::display::Callback;
10use crate::object::{NewObjectExt, ObjectRef, RequestReceiver};
11use anyhow::{format_err, Error};
12use fuchsia_wayland_core as wl;
13use std::mem;
14use wayland_server_protocol::{
15    WlSubcompositor, WlSubcompositorRequest, WlSubsurface, WlSubsurfaceRequest,
16};
17
18/// An implementation of the wl_subcompositor global.
19///
20/// wl_subcompositor provides an interface for clients to defer some composition
21/// to the server. For example, a media player application may provide the
22/// compositor with one surface that contains the video frames and another
23/// surface that contains playback controls. Deferring this composition to the
24/// server allows for the server to make certain optimizations, such as mapping
25/// these surfaces to hardware layers on the display controller, if available.
26///
27/// Implementation Note: We currently implement the wl_subcompositor by creating
28/// new scenic ShapeNodes and placing them as children of the parent node. This
29/// makes for a simple implementation, but we don't support any alpha blending
30/// of subsurfaces (due to limitations in how Scenic handles these use cases).
31/// Scenic may be extended to handle these 2D composition use-cases, but without
32/// that we'll need to do some of our own blending here.
33pub struct Subcompositor;
34
35impl Subcompositor {
36    /// Creates a new `Subcompositor`.
37    pub fn new() -> Self {
38        Subcompositor
39    }
40}
41
42impl RequestReceiver<WlSubcompositor> for Subcompositor {
43    fn receive(
44        this: ObjectRef<Self>,
45        request: WlSubcompositorRequest,
46        client: &mut Client,
47    ) -> Result<(), Error> {
48        match request {
49            WlSubcompositorRequest::Destroy => {
50                client.delete_id(this.id())?;
51            }
52            WlSubcompositorRequest::GetSubsurface { id, surface, parent } => {
53                let subsurface = Subsurface::new(surface, parent);
54                let surface_ref = subsurface.surface_ref;
55                let parent_ref = subsurface.parent_ref;
56                subsurface.attach_to_parent(client)?;
57                let subsurface_ref = id.implement(client, subsurface)?;
58                surface_ref.get_mut(client)?.set_role(SurfaceRole::Subsurface(subsurface_ref))?;
59                parent_ref
60                    .get_mut(client)?
61                    .enqueue(SurfaceCommand::AddSubsurface(surface_ref, subsurface_ref));
62            }
63        }
64        Ok(())
65    }
66}
67
68/// Wayland subsurfaces may be in one of two modes, Sync (the default) or Desync.
69/// When a wl_subsurface is in sync mode, a wl_surface::commit will simply
70/// snapshot the set of pending state. This state will be applied (and changes
71/// will appear on screen) when its parent's surface is committed.
72///
73/// In contrast, a surface in Desync mode will schedule an update to pixels on
74/// screen in response to wl_surface::commit.
75#[derive(Debug, Copy, Clone, PartialEq)]
76pub enum SubsurfaceMode {
77    Sync,
78    Desync,
79}
80
81pub struct Subsurface {
82    /// A reference to the backing wl_surface for the subsurface.
83    surface_ref: ObjectRef<Surface>,
84
85    /// A reference to the backing wl_surface for the parents surface.
86    parent_ref: ObjectRef<Surface>,
87
88    /// The current mode of the surface.
89    ///
90    /// See `SubsurfaceMode` for more details.
91    mode: SubsurfaceMode,
92
93    /// When in sync mode, this is the set of commands that are pending our
94    /// parents commit.
95    ///
96    /// When in desync mode, this must be empty.
97    pending_commands: Vec<SurfaceCommand>,
98
99    /// When in sync mode, this is the set of wl_surface::frame callbacks that
100    /// are pending our parents commit.
101    ///
102    /// When in desync mode, this must be empty.
103    pending_callbacks: Vec<ObjectRef<Callback>>,
104}
105
106impl Subsurface {
107    pub fn new(surface: wl::ObjectId, parent: wl::ObjectId) -> Self {
108        Self {
109            surface_ref: surface.into(),
110            parent_ref: parent.into(),
111            mode: SubsurfaceMode::Sync,
112            pending_commands: Vec::new(),
113            pending_callbacks: Vec::new(),
114        }
115    }
116
117    /// Gets the associated wl_surface for this subsurface.
118    pub fn surface(&self) -> ObjectRef<Surface> {
119        self.surface_ref
120    }
121
122    /// Returns true iff this subsurface is running in synchronized mode.
123    pub fn is_sync(&self) -> bool {
124        self.mode == SubsurfaceMode::Sync
125    }
126
127    /// Adds some `SurfaceCommand`s to this surfaces pending state.
128    ///
129    /// This `pending state` is a set of operations that were committed with a
130    /// wl_surface::commit request, but are waiting for our parents state to
131    /// be committed.
132    ///
133    /// Subsurfaces in desync mode have no pending state, as their state is
134    /// applied immediately upon wl_surface::commit.
135    pub fn add_pending_commands(&mut self, mut commands: Vec<SurfaceCommand>) {
136        assert!(self.is_sync(), "Desync subsurfaces have no pending state");
137        self.pending_commands.append(&mut commands);
138    }
139
140    /// Extracts the set of pending `SurfaceCommand`s and frame Callbacks for
141    /// this subsurface, resetting both to empty vectors.
142    pub fn take_pending_state(&mut self) -> (Vec<SurfaceCommand>, Vec<ObjectRef<Callback>>) {
143        let commands = mem::replace(&mut self.pending_commands, Vec::new());
144        let callbacks = mem::replace(&mut self.pending_callbacks, Vec::new());
145        (commands, callbacks)
146    }
147
148    pub fn finalize_commit(&mut self, callbacks: &mut Vec<ObjectRef<Callback>>) -> bool {
149        if self.is_sync() {
150            // If we're in sync mode, we just defer the callbacks until our
151            // parents state is applied.
152            self.pending_callbacks.append(callbacks);
153            false
154        } else {
155            true
156        }
157    }
158
159    fn attach_to_parent(&self, client: &mut Client) -> Result<(), Error> {
160        let flatland = match self.parent_ref.get(client)?.flatland() {
161            Some(s) => s,
162            None => return Err(format_err!("Parent surface has no flatland instance!")),
163        };
164        self.surface_ref.get_mut(client)?.set_flatland(flatland.clone())?;
165
166        // Unwrap here since we have just determined both surfaces have a
167        // flatland instance, which is the only prerequisite for having a transform.
168        let parent_transform = self.parent_ref.get(client)?.transform().unwrap();
169        let child_transform = self.surface_ref.get(client)?.transform().unwrap();
170        flatland
171            .borrow()
172            .proxy()
173            .add_child(&parent_transform, &child_transform)
174            .expect("fidl error");
175
176        Ok(())
177    }
178
179    fn detach_from_parent(&self, client: &Client) -> Result<(), Error> {
180        if let Some(flatland) = self.parent_ref.get(client)?.flatland() {
181            // Unwrap here since we have just determined parent surface has a
182            // flatland instance, which is the only prerequisite for having a
183            // transform.
184            let parent_transform = *self.parent_ref.get(client)?.transform().unwrap();
185            if let Some(child_transform) = self.surface_ref.get(client)?.transform() {
186                flatland
187                    .borrow()
188                    .proxy()
189                    .remove_child(&parent_transform, &child_transform)
190                    .expect("fidl error");
191            }
192        }
193        Ok(())
194    }
195}
196
197impl RequestReceiver<WlSubsurface> for Subsurface {
198    fn receive(
199        this: ObjectRef<Self>,
200        request: WlSubsurfaceRequest,
201        client: &mut Client,
202    ) -> Result<(), Error> {
203        match request {
204            WlSubsurfaceRequest::Destroy => {
205                let parent_ref = {
206                    let subsurface = this.get(client)?;
207                    subsurface.detach_from_parent(client)?;
208                    subsurface.parent_ref
209                };
210                parent_ref.get_mut(client)?.detach_subsurface(this);
211                client.delete_id(this.id())?;
212            }
213            WlSubsurfaceRequest::SetPosition { x, y } => {
214                let surface_ref = this.get(client)?.surface_ref;
215                surface_ref.get_mut(client)?.enqueue(SurfaceCommand::SetPosition(x, y));
216            }
217            WlSubsurfaceRequest::PlaceAbove { sibling } => {
218                let parent_ref = this.get(client)?.parent_ref;
219                parent_ref.get_mut(client)?.enqueue(SurfaceCommand::PlaceSubsurface(
220                    PlaceSubsurfaceParams {
221                        subsurface: this,
222                        sibling: sibling.into(),
223                        relation: SurfaceRelation::Above,
224                    },
225                ));
226            }
227            WlSubsurfaceRequest::PlaceBelow { sibling } => {
228                let parent_ref = this.get(client)?.parent_ref;
229                parent_ref.get_mut(client)?.enqueue(SurfaceCommand::PlaceSubsurface(
230                    PlaceSubsurfaceParams {
231                        subsurface: this,
232                        sibling: sibling.into(),
233                        relation: SurfaceRelation::Below,
234                    },
235                ));
236            }
237            // Note that SetSync and SetDesync are not double buffered as is
238            // most state:
239            //
240            //   This state is applied when the parent surface's wl_surface
241            //   state is applied, regardless of the sub-surface's mode. As the
242            //   exception, set_sync and set_desync are effective immediately.
243            WlSubsurfaceRequest::SetSync => {
244                this.get_mut(client)?.mode = SubsurfaceMode::Sync;
245            }
246            WlSubsurfaceRequest::SetDesync => {
247                let (commands, callbacks, surface_ref) = {
248                    let this = this.get_mut(client)?;
249                    let (commands, callbacks) = this.take_pending_state();
250                    (commands, callbacks, this.surface_ref)
251                };
252                // TODO(tjdetwiler): We should instead schedule these callbacks
253                // on the wl_surface immediately. This needs a small refactor of
254                // wl_surface to make this possible.
255                assert!(callbacks.is_empty());
256                let surface = surface_ref.get_mut(client)?;
257                for command in commands {
258                    surface.enqueue(command);
259                }
260                this.get_mut(client)?.mode = SubsurfaceMode::Desync;
261            }
262        }
263        Ok(())
264    }
265}
wayland_bridge/subcompositor.rs

wayland_bridge/
subcompositor.rs
