[mtl] basic error handling for the Oldest acquire method

Author: kvark

src/backend/metal/src/command.rs

@@ -1785,8 +1785,9 @@ impl RawCommandQueue<Backend> for CommandQueue {
 
         for (swapchain, index) in swapchains {
             debug!("presenting frame {}", index);
-            let drawable = swapchain.borrow().take_drawable(index);
-            command_buffer.present_drawable(&drawable);
+            if let Ok(drawable) = swapchain.borrow().take_drawable(index) {
+                command_buffer.present_drawable(&drawable);
+            }
         }
 
         command_buffer.commit();

src/backend/metal/src/window.rs

@@ -44,6 +44,12 @@ impl Drop for SurfaceInner {
     }
 }
 
+#[derive(Debug)]
+struct FrameNotFound {
+    drawable: metal::Drawable,
+    texture: metal::Texture,
+}
+
 
 impl SurfaceInner {
     pub fn new(view: *mut Object, layer: CAMetalLayer) -> Self {
@@ -61,7 +67,7 @@ impl SurfaceInner {
         }
     }
 
-    fn next_frame<'a>(&self, frames: &'a [Frame]) -> Result<(usize, MutexGuard<'a, FrameInner>), ()> {
+    fn next_frame<'a>(&self, frames: &'a [Frame]) -> Result<(usize, MutexGuard<'a, FrameInner>), FrameNotFound> {
         let layer_ref = self.render_layer.lock();
         autoreleasepool(|| { // for the drawable
             let (drawable, texture_temp): (&metal::DrawableRef, &metal::TextureRef) = unsafe {
@@ -79,7 +85,10 @@ impl SurfaceInner {
                     debug!("next is frame[{}]", index);
                     Ok((index, frame))
                 }
-                None => Err(()),
+                None => Err(FrameNotFound {
+                    drawable: drawable.to_owned(),
+                    texture: texture_temp.to_owned(),
+                }),
             }
         })
     }
@@ -105,6 +114,9 @@ struct FrameInner {
     /// If there is `None`, `available == false` means that the frame has already
     /// been acquired and the `drawable` will appear at some point.
     available: bool,
+    /// Stays true for as long as the drawable is circulating through the
+    /// CAMetalLayer's frame queue.
+    linked: bool,
     last_frame: usize,
 }
 
@@ -152,16 +164,23 @@ impl Drop for Swapchain {
 impl Swapchain {
     /// Returns the drawable for the specified swapchain image index,
     /// marks the index as free for future use.
-    pub(crate) fn take_drawable(&self, index: hal::SwapImageIndex) -> metal::Drawable {
+    pub(crate) fn take_drawable(&self, index: hal::SwapImageIndex) -> Result<metal::Drawable, ()> {
         let mut frame = self
             .frames[index as usize]
             .inner
             .lock();
-        assert!(!frame.available);
-        frame.available = true;
-        frame.drawable
-            .take()
-            .expect("Drawable has not been acquired!")
+        assert!(!frame.available && frame.linked);
+
+        match frame.drawable.take() {
+            Some(drawable) => {
+                frame.available = true;
+                Ok(drawable)
+            }
+            None => {
+                frame.linked = false;
+                Err(())
+            }
+        }
     }
 
     fn signal_sync(&self, sync: hal::FrameSync<Backend>) {
@@ -199,10 +218,21 @@ impl SwapchainImage {
         }
         // wait for new frames to come until we meet the chosen one
         let mut count = 1;
-        while self.surface.next_frame(&self.frames).unwrap().0 != self.index as usize {
-            count += 1;
-        }
-        debug!("Swapchain image is ready after {} frames", count);
+        loop {
+            match self.surface.next_frame(&self.frames) {
+                Ok((index, _)) if index == self.index as usize => {
+                    debug!("Swapchain image is ready after {} frames", count);
+                    break
+                }
+                Ok(_) => {
+                    count += 1;
+                }
+                Err(_e) => {
+                    debug!("Swapchain drawables are changed");
+                    break
+                }
+            }
+        }        
         count
     }
 }
@@ -323,6 +353,7 @@ impl Device {
                     inner: Mutex::new(FrameInner {
                         drawable,
                         available: true,
+                        linked: true,
                         last_frame: 0,
                     }),
                     texture: texture.to_owned(),
@@ -413,6 +444,9 @@ impl hal::Swapchain<Backend> for Swapchain {
                 }
 
                 let frame = self.frames[oldest_index].inner.lock();
+                if !frame.linked {
+                    return Err(hal::AcquireError::OutOfDate);
+                }
                 (oldest_index, frame)
             }
         };