carnelian/view/strategies/
display_direct.rs

1// Copyright 2021 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::app::strategies::framebuffer::{CoordinatorProxyPtr, DisplayId};
6use crate::app::{Config, MessageInternal};
7use crate::drawing::DisplayRotation;
8use crate::render::generic::{self, Backend};
9use crate::render::{Context as RenderContext, ContextInner};
10use crate::view::strategies::base::{ViewStrategy, ViewStrategyPtr};
11use crate::view::{
12    DisplayInfo, UserInputMessage, ViewAssistantContext, ViewAssistantPtr, ViewDetails,
13};
14use crate::{input, IntPoint, IntSize, Size, ViewKey};
15use anyhow::{bail, ensure, Context, Error};
16use async_trait::async_trait;
17use display_utils::{
18    BufferCollectionId, BufferId, EventId, ImageId as DisplayImageId, LayerId, PixelFormat,
19    INVALID_LAYER_ID,
20};
21use euclid::size2;
22use fidl_fuchsia_hardware_display::{
23    ConfigStamp, CoordinatorApplyConfig3Request, CoordinatorListenerRequest, CoordinatorProxy,
24    INVALID_CONFIG_STAMP_VALUE,
25};
26use fidl_fuchsia_hardware_display_types::{ImageBufferUsage, ImageMetadata, INVALID_DISP_ID};
27use fuchsia_async::{self as fasync};
28use fuchsia_framebuffer::sysmem::BufferCollectionAllocator;
29use fuchsia_framebuffer::{FrameSet, FrameUsage, ImageId};
30use fuchsia_trace::{duration, instant};
31use futures::channel::mpsc::UnboundedSender;
32use std::collections::{BTreeMap, BTreeSet, VecDeque};
33use std::sync::atomic::{AtomicU64, Ordering};
34use zx::{
35    self as zx, AsHandleRef, Event, HandleBased, MonotonicDuration, MonotonicInstant, Status,
36};
37
38type WaitEvents = BTreeMap<ImageId, (Event, EventId)>;
39
40struct BusyImage {
41    stamp: ConfigStamp,
42    view_key: ViewKey,
43    image_id: DisplayImageId,
44    collection_id: BufferCollectionId,
45}
46
47#[derive(Default)]
48struct CollectionIdGenerator {}
49
50impl Iterator for CollectionIdGenerator {
51    type Item = BufferCollectionId;
52
53    fn next(&mut self) -> Option<BufferCollectionId> {
54        static NEXT_ID_VALUE: AtomicU64 = AtomicU64::new(100);
55        // NEXT_ID_VALUE only increments so it only requires atomicity, and we
56        // can use Relaxed order.
57        let value = NEXT_ID_VALUE.fetch_add(1, Ordering::Relaxed);
58        // fetch_add wraps on overflow, which we'll use as a signal
59        // that this generator is out of ids.
60        if value == 0 {
61            None
62        } else {
63            Some(BufferCollectionId(value))
64        }
65    }
66}
67fn next_collection_id() -> BufferCollectionId {
68    CollectionIdGenerator::default().next().expect("collection_id")
69}
70
71#[derive(Default)]
72struct ImageIdGenerator {}
73
74impl Iterator for ImageIdGenerator {
75    type Item = u64;
76
77    fn next(&mut self) -> Option<u64> {
78        static NEXT_ID: AtomicU64 = AtomicU64::new(1);
79        // NEXT_ID only increments so it only requires atomicity, and we can
80        // use Relaxed order.
81        let id = NEXT_ID.fetch_add(1, Ordering::Relaxed);
82        // fetch_add wraps on overflow, which we'll use as a signal
83        // that this generator is out of ids.
84        if id == 0 {
85            None
86        } else {
87            Some(id)
88        }
89    }
90}
91fn next_image_id() -> u64 {
92    ImageIdGenerator::default().next().expect("image_id")
93}
94
95async fn create_and_import_event(
96    coordinator: &CoordinatorProxy,
97) -> Result<(Event, EventId), Error> {
98    let event = Event::create();
99
100    let their_event = event.duplicate_handle(zx::Rights::SAME_RIGHTS)?;
101    let event_id_value = event.get_koid()?.raw_koid();
102    let event_id = EventId(event_id_value);
103    coordinator.import_event(Event::from_handle(their_event.into_handle()), &event_id.into())?;
104    Ok((event, event_id))
105}
106
107fn size_from_info(info: &fidl_fuchsia_hardware_display::Info, mode_idx: usize) -> IntSize {
108    let mode = &info.modes[mode_idx];
109    size2(mode.active_area.width, mode.active_area.height).to_i32()
110}
111
112#[derive(Debug, Clone)]
113pub struct Display {
114    pub coordinator: CoordinatorProxyPtr,
115    pub display_id: DisplayId,
116    pub info: fidl_fuchsia_hardware_display::Info,
117    pub layer_id: LayerId,
118    pub mode_idx: usize,
119}
120
121impl Display {
122    pub async fn new(
123        coordinator: CoordinatorProxyPtr,
124        display_id: DisplayId,
125        info: fidl_fuchsia_hardware_display::Info,
126    ) -> Result<Self, Error> {
127        Ok(Self { coordinator, display_id, info, layer_id: INVALID_LAYER_ID, mode_idx: 0 })
128    }
129
130    pub fn set_mode(&mut self, mode_idx: usize) -> Result<(), Error> {
131        self.coordinator.set_display_mode(&self.info.id, &self.info.modes[mode_idx])?;
132        self.mode_idx = mode_idx;
133        Ok(())
134    }
135
136    pub async fn create_layer(&mut self) -> Result<(), Error> {
137        let result = self.coordinator.create_layer().await?;
138        match result {
139            Ok(layer_id) => {
140                self.layer_id = layer_id.into();
141                Ok(())
142            }
143            Err(status) => {
144                bail!("Display::new(): failed to create layer {}", Status::from_raw(status))
145            }
146        }
147    }
148
149    pub fn size(&self) -> IntSize {
150        size_from_info(&self.info, self.mode_idx)
151    }
152
153    pub fn pixel_format(&self) -> PixelFormat {
154        self.info.pixel_format[0].into()
155    }
156}
157
158struct DisplayResources {
159    pub frame_set: FrameSet,
160    pub image_indexes: BTreeMap<ImageId, u32>,
161    pub context: RenderContext,
162    pub wait_events: WaitEvents,
163    pub busy_images: VecDeque<BusyImage>,
164}
165
166const RENDER_FRAME_COUNT: usize = 2;
167
168pub(crate) struct DisplayDirectViewStrategy {
169    key: ViewKey,
170    display: Display,
171    app_sender: UnboundedSender<MessageInternal>,
172    display_rotation: DisplayRotation,
173    display_resources: Option<DisplayResources>,
174    drop_display_resources_task: Option<fasync::Task<()>>,
175    display_resource_release_delay: std::time::Duration,
176    vsync_phase: MonotonicInstant,
177    vsync_interval: MonotonicDuration,
178    mouse_cursor_position: Option<IntPoint>,
179    pub collection_id: BufferCollectionId,
180    render_frame_count: usize,
181    last_config_stamp: u64,
182    presented: Option<u64>,
183}
184
185impl DisplayDirectViewStrategy {
186    pub async fn new(
187        key: ViewKey,
188        coordinator: CoordinatorProxyPtr,
189        app_sender: UnboundedSender<MessageInternal>,
190        info: fidl_fuchsia_hardware_display::Info,
191        preferred_size: IntSize,
192    ) -> Result<ViewStrategyPtr, Error> {
193        let app_config = Config::get();
194        let collection_id = next_collection_id();
195        let render_frame_count = app_config.buffer_count.unwrap_or(RENDER_FRAME_COUNT);
196
197        // Find first mode with the preferred size. Use preferred mode if not found.
198        let mode_idx = info
199            .modes
200            .iter()
201            .position(|mode| {
202                let size = size2(mode.active_area.width, mode.active_area.height).to_i32();
203                size == preferred_size
204            })
205            .unwrap_or(0);
206
207        let mut display = Display::new(coordinator, info.id.into(), info).await?;
208
209        if mode_idx != 0 {
210            display.set_mode(mode_idx)?;
211        }
212        display.create_layer().await?;
213
214        let display_resources = Self::allocate_display_resources(
215            collection_id,
216            display.size(),
217            display.pixel_format(),
218            render_frame_count,
219            &display,
220        )
221        .await?;
222
223        app_sender.unbounded_send(MessageInternal::Render(key)).expect("unbounded_send");
224        app_sender.unbounded_send(MessageInternal::Focus(key, true)).expect("unbounded_send");
225
226        Ok(Box::new(Self {
227            key,
228            display,
229            app_sender,
230            display_rotation: app_config.display_rotation,
231            display_resources: Some(display_resources),
232            drop_display_resources_task: None,
233            display_resource_release_delay: app_config.display_resource_release_delay,
234            vsync_phase: MonotonicInstant::get(),
235            vsync_interval: MonotonicDuration::from_millis(16),
236            mouse_cursor_position: None,
237            collection_id,
238            render_frame_count,
239            last_config_stamp: INVALID_CONFIG_STAMP_VALUE,
240            presented: None,
241        }))
242    }
243
244    fn make_context(
245        &mut self,
246        view_details: &ViewDetails,
247        image_id: Option<ImageId>,
248    ) -> ViewAssistantContext {
249        let time_now = MonotonicInstant::get();
250        // |interval_offset| is the offset from |time_now| to the next multiple
251        // of vsync interval after vsync phase, possibly negative if in the past.
252        let mut interval_offset = MonotonicDuration::from_nanos(
253            (self.vsync_phase.into_nanos() - time_now.into_nanos())
254                % self.vsync_interval.into_nanos(),
255        );
256        // Unless |time_now| is exactly on the interval, adjust forward to the next
257        // vsync after |time_now|.
258        if interval_offset != MonotonicDuration::from_nanos(0) && self.vsync_phase < time_now {
259            interval_offset += self.vsync_interval;
260        }
261
262        let display_rotation = self.display_rotation;
263        let app_sender = self.app_sender.clone();
264        let mouse_cursor_position = self.mouse_cursor_position.clone();
265        let (image_index, actual_image_id) = image_id
266            .and_then(|available| {
267                Some((
268                    *self.display_resources().image_indexes.get(&available).expect("image_index"),
269                    available,
270                ))
271            })
272            .unwrap_or_default();
273
274        ViewAssistantContext {
275            key: view_details.key,
276            size: match display_rotation {
277                DisplayRotation::Deg0 | DisplayRotation::Deg180 => view_details.physical_size,
278                DisplayRotation::Deg90 | DisplayRotation::Deg270 => {
279                    size2(view_details.physical_size.height, view_details.physical_size.width)
280                }
281            },
282            metrics: view_details.metrics,
283            presentation_time: time_now + interval_offset,
284            buffer_count: None,
285            image_id: actual_image_id,
286            image_index: image_index,
287            app_sender,
288            mouse_cursor_position,
289            display_info: Some(DisplayInfo::from(&self.display.info)),
290        }
291    }
292
293    async fn allocate_display_resources(
294        collection_id: BufferCollectionId,
295        size: IntSize,
296        pixel_format: display_utils::PixelFormat,
297        render_frame_count: usize,
298        display: &Display,
299    ) -> Result<DisplayResources, Error> {
300        let app_config = Config::get();
301        let use_spinel = app_config.use_spinel;
302
303        ensure!(use_spinel == false, "Spinel support is disabled");
304
305        let display_rotation = app_config.display_rotation;
306        let unsize = size.floor().to_u32();
307
308        let usage = if use_spinel { FrameUsage::Gpu } else { FrameUsage::Cpu };
309        let mut buffer_allocator = BufferCollectionAllocator::new(
310            unsize.width,
311            unsize.height,
312            pixel_format.into(),
313            usage,
314            render_frame_count,
315        )?;
316
317        buffer_allocator.set_name(100, "CarnelianDirect")?;
318
319        let context_token = buffer_allocator.duplicate_token().await?;
320        let context = RenderContext {
321            inner: ContextInner::Forma(generic::Forma::new_context(
322                context_token,
323                unsize,
324                display_rotation,
325            )),
326        };
327
328        let coordinator_token = buffer_allocator.duplicate_token().await?;
329        // Sysmem token channels serve both sysmem(1) and sysmem2, so we can convert here until
330        // display has an import_buffer_collection that takes a sysmem2 token.
331        display
332            .coordinator
333            .import_buffer_collection(&collection_id.into(), coordinator_token)
334            .await?
335            .map_err(zx::Status::from_raw)?;
336        display
337            .coordinator
338            .set_buffer_collection_constraints(
339                &collection_id.into(),
340                &ImageBufferUsage {
341                    tiling_type: fidl_fuchsia_hardware_display_types::IMAGE_TILING_TYPE_LINEAR,
342                },
343            )
344            .await?
345            .map_err(zx::Status::from_raw)?;
346
347        let buffers = buffer_allocator
348            .allocate_buffers(true)
349            .await
350            .context(format!("view: {:?} allocate_buffers", display.display_id))?;
351
352        ensure!(
353            buffers.settings.as_ref().unwrap().image_format_constraints.is_some(),
354            "No image format constraints"
355        );
356        ensure!(
357            buffers
358                .settings
359                .as_ref()
360                .unwrap()
361                .image_format_constraints
362                .as_ref()
363                .unwrap()
364                .pixel_format_modifier
365                .is_some(),
366            "Sysmem will always set pixel_format_modifier"
367        );
368        ensure!(
369            buffers.buffers.as_ref().unwrap().len() == render_frame_count,
370            "Buffers do not match frame count"
371        );
372
373        let image_tiling_type = match buffers
374            .settings
375            .as_ref()
376            .unwrap()
377            .image_format_constraints
378            .as_ref()
379            .unwrap()
380            .pixel_format_modifier
381            .as_ref()
382            .unwrap()
383        {
384            fidl_fuchsia_images2::PixelFormatModifier::IntelI915XTiled => 1,
385            fidl_fuchsia_images2::PixelFormatModifier::IntelI915YTiled => 2,
386            _ => fidl_fuchsia_hardware_display_types::IMAGE_TILING_TYPE_LINEAR,
387        };
388
389        let image_metadata = ImageMetadata {
390            dimensions: fidl_fuchsia_math::SizeU { width: unsize.width, height: unsize.height },
391            tiling_type: image_tiling_type,
392        };
393
394        let mut image_ids = BTreeSet::new();
395        let mut image_indexes = BTreeMap::new();
396        let mut wait_events = WaitEvents::new();
397        let buffer_count = buffers.buffers.as_ref().unwrap().len();
398        for index in 0..buffer_count as usize {
399            let uindex = index as u32;
400            let image_id = next_image_id();
401            let display_image_id = DisplayImageId(image_id);
402            display
403                .coordinator
404                .import_image(
405                    &image_metadata,
406                    &BufferId::new(collection_id, uindex).into(),
407                    &display_image_id.into(),
408                )
409                .await
410                .context("FIDL coordinator import_image")?
411                .map_err(zx::Status::from_raw)
412                .context("import image error")?;
413
414            image_ids.insert(image_id as u64);
415            image_indexes.insert(image_id as u64, uindex);
416
417            let (event, event_id) = create_and_import_event(&display.coordinator).await?;
418            wait_events.insert(image_id as ImageId, (event, event_id));
419        }
420
421        let frame_set = FrameSet::new(collection_id, image_ids);
422
423        display.coordinator.set_layer_primary_config(&display.layer_id.into(), &image_metadata)?;
424
425        Ok(DisplayResources {
426            frame_set,
427            image_indexes,
428            context,
429            wait_events,
430            busy_images: VecDeque::new(),
431        })
432    }
433
434    async fn maybe_reallocate_display_resources(&mut self) -> Result<(), Error> {
435        if self.display_resources.is_none() {
436            instant!(
437                c"gfx",
438                c"DisplayDirectViewStrategy::allocate_display_resources",
439                fuchsia_trace::Scope::Process,
440                "" => ""
441            );
442            self.collection_id = next_collection_id();
443            self.presented = None;
444            self.display_resources = Some(
445                Self::allocate_display_resources(
446                    self.collection_id,
447                    self.display.size(),
448                    self.display.pixel_format(),
449                    self.render_frame_count,
450                    &self.display,
451                )
452                .await?,
453            );
454        }
455        Ok(())
456    }
457
458    fn display_resources(&mut self) -> &mut DisplayResources {
459        self.display_resources.as_mut().expect("display_resources")
460    }
461
462    fn update_image(
463        &mut self,
464        view_details: &ViewDetails,
465        view_assistant: &mut ViewAssistantPtr,
466        image: u64,
467    ) {
468        instant!(
469            c"gfx",
470            c"DisplayDirectViewStrategy::update_image",
471            fuchsia_trace::Scope::Process,
472            "image" => format!("{}", image).as_str()
473        );
474        let (event, _) = self.display_resources().wait_events.get(&image).expect("wait event");
475        let buffer_ready_event =
476            event.duplicate_handle(zx::Rights::SAME_RIGHTS).expect("duplicate_handle");
477        let direct_context = self.make_context(view_details, Some(image));
478
479        view_assistant
480            .render(&mut self.display_resources().context, buffer_ready_event, &direct_context)
481            .unwrap_or_else(|e| panic!("Update error: {:?}", e));
482    }
483
484    fn handle_vsync_parameters_changed(
485        &mut self,
486        phase: MonotonicInstant,
487        interval: MonotonicDuration,
488    ) {
489        self.vsync_phase = phase;
490        self.vsync_interval = interval;
491    }
492}
493
494#[async_trait(?Send)]
495impl ViewStrategy for DisplayDirectViewStrategy {
496    fn initial_metrics(&self) -> Size {
497        size2(1.0, 1.0)
498    }
499
500    fn initial_physical_size(&self) -> Size {
501        self.display.size().to_f32()
502    }
503
504    fn initial_logical_size(&self) -> Size {
505        self.display.size().to_f32()
506    }
507
508    fn create_view_assistant_context(&self, view_details: &ViewDetails) -> ViewAssistantContext {
509        ViewAssistantContext {
510            key: view_details.key,
511            size: match self.display_rotation {
512                DisplayRotation::Deg0 | DisplayRotation::Deg180 => view_details.physical_size,
513                DisplayRotation::Deg90 | DisplayRotation::Deg270 => {
514                    size2(view_details.physical_size.height, view_details.physical_size.width)
515                }
516            },
517            metrics: view_details.metrics,
518            presentation_time: Default::default(),
519            buffer_count: None,
520            image_id: Default::default(),
521            image_index: Default::default(),
522            app_sender: self.app_sender.clone(),
523            mouse_cursor_position: self.mouse_cursor_position.clone(),
524            display_info: Some(DisplayInfo::from(&self.display.info)),
525        }
526    }
527
528    fn setup(&mut self, view_details: &ViewDetails, view_assistant: &mut ViewAssistantPtr) {
529        if let Some(available) = self.display_resources().frame_set.get_available_image() {
530            let direct_context = self.make_context(view_details, Some(available));
531            view_assistant
532                .setup(&direct_context)
533                .unwrap_or_else(|e| panic!("Setup error: {:?}", e));
534            self.display_resources().frame_set.return_image(available);
535        }
536    }
537
538    async fn render(
539        &mut self,
540        view_details: &ViewDetails,
541        view_assistant: &mut ViewAssistantPtr,
542    ) -> bool {
543        duration!(c"gfx", c"DisplayDirectViewStrategy::update");
544        self.maybe_reallocate_display_resources()
545            .await
546            .expect("maybe_reallocate_display_resources");
547        if let Some(available) = self.display_resources().frame_set.get_available_image() {
548            self.update_image(view_details, view_assistant, available);
549            self.display_resources().frame_set.mark_prepared(available);
550            true
551        } else {
552            if self.render_frame_count == 1 {
553                if let Some(presented) = self.presented {
554                    self.update_image(view_details, view_assistant, presented);
555                    true
556                } else {
557                    false
558                }
559            } else {
560                false
561            }
562        }
563    }
564
565    fn present(&mut self, view_details: &ViewDetails) {
566        duration!(c"gfx", c"DisplayDirectViewStrategy::present");
567
568        if self.render_frame_count == 1 && self.presented.is_some() {
569            return;
570        }
571        if let Some(prepared) = self.display_resources().frame_set.prepared {
572            instant!(
573                c"gfx",
574                c"DisplayDirectViewStrategy::present",
575                fuchsia_trace::Scope::Process,
576                "prepared" => format!("{}", prepared).as_str()
577            );
578            let collection_id = self.collection_id;
579            let view_key = view_details.key;
580            self.display
581                .coordinator
582                .set_display_layers(
583                    &self.display.display_id.into(),
584                    &[self.display.layer_id.into()],
585                )
586                .expect("set_display_layers");
587
588            let (_, wait_event_id) =
589                *self.display_resources().wait_events.get(&prepared).expect("wait event");
590
591            let image_id = DisplayImageId(prepared);
592            self.display
593                .coordinator
594                .set_layer_image2(
595                    &self.display.layer_id.into(),
596                    &image_id.into(),
597                    &wait_event_id.into(),
598                )
599                .expect("Frame::present() set_layer_image2");
600
601            self.last_config_stamp += 1;
602            let stamp = ConfigStamp { value: self.last_config_stamp };
603            let req = CoordinatorApplyConfig3Request { stamp: Some(stamp), ..Default::default() };
604
605            self.display.coordinator.apply_config3(req).expect("Frame::present() apply_config");
606
607            self.display_resources().busy_images.push_back(BusyImage {
608                stamp,
609                view_key,
610                image_id,
611                collection_id,
612            });
613
614            self.display_resources().frame_set.mark_presented(prepared);
615            self.presented = Some(prepared);
616        }
617    }
618
619    fn handle_focus(
620        &mut self,
621        view_details: &ViewDetails,
622        view_assistant: &mut ViewAssistantPtr,
623        focus: bool,
624    ) {
625        let mut direct_context = self.make_context(view_details, None);
626        view_assistant
627            .handle_focus_event(&mut direct_context, focus)
628            .unwrap_or_else(|e| panic!("handle_focus error: {:?}", e));
629    }
630
631    fn convert_user_input_message(
632        &mut self,
633        _view_details: &ViewDetails,
634        _message: UserInputMessage,
635    ) -> Result<Vec<crate::input::Event>, Error> {
636        bail!("convert_user_input_message not used for display_direct.")
637    }
638
639    fn inspect_event(&mut self, view_details: &ViewDetails, event: &crate::input::Event) {
640        match &event.event_type {
641            input::EventType::Mouse(mouse_event) => {
642                self.mouse_cursor_position = Some(mouse_event.location);
643                self.app_sender
644                    .unbounded_send(MessageInternal::RequestRender(view_details.key))
645                    .expect("unbounded_send");
646            }
647            _ => (),
648        };
649    }
650
651    fn image_freed(&mut self, image_id: u64, collection_id: u32) {
652        if BufferCollectionId(collection_id as u64) == self.collection_id {
653            instant!(
654                c"gfx",
655                c"DisplayDirectViewStrategy::image_freed",
656                fuchsia_trace::Scope::Process,
657                "image_freed" => format!("{}", image_id).as_str()
658            );
659            if let Some(display_resources) = self.display_resources.as_mut() {
660                display_resources.frame_set.mark_done_presenting(image_id);
661            }
662        }
663    }
664
665    fn ownership_changed(&mut self, owned: bool) {
666        if !owned {
667            let timer = fasync::Timer::new(fuchsia_async::MonotonicInstant::after(
668                self.display_resource_release_delay.into(),
669            ));
670            let timer_sender = self.app_sender.clone();
671            let task = fasync::Task::local(async move {
672                timer.await;
673                timer_sender
674                    .unbounded_send(MessageInternal::DropDisplayResources)
675                    .expect("unbounded_send");
676            });
677            self.drop_display_resources_task = Some(task);
678        } else {
679            self.drop_display_resources_task = None;
680        }
681    }
682
683    fn drop_display_resources(&mut self) {
684        let task = self.drop_display_resources_task.take();
685        if task.is_some() {
686            instant!(
687                c"gfx",
688                c"DisplayDirectViewStrategy::drop_display_resources",
689                fuchsia_trace::Scope::Process,
690                "" => ""
691            );
692            self.display_resources = None;
693        }
694    }
695
696    async fn handle_display_coordinator_listener_request(
697        &mut self,
698        event: CoordinatorListenerRequest,
699    ) {
700        match event {
701            CoordinatorListenerRequest::OnVsync {
702                timestamp, cookie, applied_config_stamp, ..
703            } => {
704                duration!(c"gfx", c"DisplayDirectViewStrategy::OnVsync");
705                let vsync_interval = MonotonicDuration::from_nanos(
706                    1_000_000_000_000 / self.display.info.modes[0].refresh_rate_millihertz as i64,
707                );
708                self.handle_vsync_parameters_changed(
709                    MonotonicInstant::from_nanos(timestamp as i64),
710                    vsync_interval,
711                );
712                if cookie.value != INVALID_DISP_ID {
713                    self.display
714                        .coordinator
715                        .acknowledge_vsync(cookie.value)
716                        .expect("acknowledge_vsync");
717                }
718
719                let signal_sender = self.app_sender.clone();
720
721                // Busy images are stamped with monotonically increasing values (because the last
722                // stamp added to the deque is always greater than the previous).  So when we see a
723                // vsync stamp, all images with a *strictly-lesser* stamp are now available for
724                // reuse (images with an *equal* stamp are the ones currently displayed on-screen,
725                // so can't be reused yet).
726                if let Some(display_resources) = self.display_resources.as_mut() {
727                    let busy_images = &mut display_resources.busy_images;
728                    while !busy_images.is_empty() {
729                        let front = &busy_images.front().unwrap();
730                        if applied_config_stamp.value <= front.stamp.value {
731                            break;
732                        }
733
734                        signal_sender
735                            .unbounded_send(MessageInternal::ImageFreed(
736                                front.view_key,
737                                front.image_id.0,
738                                front.collection_id.0 as u32,
739                            ))
740                            .expect("unbounded_send");
741
742                        busy_images.pop_front();
743                    }
744                }
745
746                signal_sender
747                    .unbounded_send(MessageInternal::Render(self.key))
748                    .expect("unbounded_send");
749            }
750            CoordinatorListenerRequest::OnDisplaysChanged { .. } => {
751                eprintln!("Carnelian ignoring CoordinatorListenerRequest::OnDisplaysChanged");
752            }
753            CoordinatorListenerRequest::OnClientOwnershipChange { has_ownership, .. } => {
754                eprintln!("Carnelian ignoring CoordinatorListenerRequest::OnClientOwnershipChange (value: {})", has_ownership);
755            }
756            _ => (),
757        }
758    }
759
760    fn is_hosted_on_display(&self, display_id: DisplayId) -> bool {
761        self.display.display_id == display_id
762    }
763
764    fn close(&mut self) {
765        self.display
766            .coordinator
767            .release_buffer_collection(&self.collection_id.into())
768            .expect("release_buffer_collection");
769    }
770}
carnelian/view/strategies/display_direct.rs

carnelian/view/strategies/
display_direct.rs
