Remove DamageOutOfRange error

CHANGELOG.md

@@ -5,6 +5,8 @@
 - Added `Buffer::pixels_iter()` for iterating over each pixel with its associated `x`/`y` coordinate.
 - **Breaking:** Removed generic type parameters `D` and `W` from `Buffer<'_>` struct.
 - **Breaking:** Removed `Deref[Mut]` implementation on `Buffer<'_>`. Use `Buffer::pixels()` instead.
+- **Breaking:** Removed `DamageOutOfRange` error case. If the damage value is greater than the backend supports, it is instead clamped to an appropriate value.
+- Fixed `present_with_damage` with bounds out of range on Windows, Web and X11.
 
 # 0.4.7
 

src/backend_dispatch.rs

@@ -185,15 +185,6 @@ macro_rules! make_dispatch {
                 }
             }
 
-            fn present(self) -> Result<(), SoftBufferError> {
-                match self {
-                    $(
-                        $(#[$attr])*
-                        Self::$name(inner) => inner.present(),
-                    )*
-                }
-            }
-
             fn present_with_damage(self, damage: &[Rect]) -> Result<(), SoftBufferError> {
                 match self {
                     $(

src/backend_interface.rs

@@ -40,5 +40,4 @@ pub(crate) trait BufferInterface {
     fn pixels_mut(&mut self) -> &mut [u32];
     fn age(&self) -> u8;
     fn present_with_damage(self, damage: &[Rect]) -> Result<(), SoftBufferError>;
-    fn present(self) -> Result<(), SoftBufferError>;
 }

src/backends/android.rs

@@ -142,7 +142,17 @@ impl BufferInterface for BufferImpl<'_> {
     }
 
     // TODO: This function is pretty slow this way
-    fn present(mut self) -> Result<(), SoftBufferError> {
+    fn present_with_damage(mut self, damage: &[Rect]) -> Result<(), SoftBufferError> {
+        // TODO: Android requires the damage rect _at lock time_
+        // Since we're faking the backing buffer _anyway_, we could even fake the surface lock
+        // and lock it here (if it doesn't influence timings).
+        //
+        // Android seems to do this because the region can be expanded by the
+        // system, requesting the user to actually redraw a larger region.
+        // It's unclear if/when this is used, or if corruption/artifacts occur
+        // when the enlarged damage region is not re-rendered?
+        let _ = damage;
+
         let input_lines = self.buffer.chunks(self.native_window_buffer.width());
         for (output, input) in self
             .native_window_buffer
@@ -165,11 +175,4 @@ impl BufferInterface for BufferImpl<'_> {
         }
         Ok(())
     }
-
-    fn present_with_damage(self, _damage: &[Rect]) -> Result<(), SoftBufferError> {
-        // TODO: Android requires the damage rect _at lock time_
-        // Since we're faking the backing buffer _anyway_, we could even fake the surface lock
-        // and lock it here (if it doesn't influence timings).
-        self.present()
-    }
 }

src/backends/cg.rs

@@ -296,7 +296,7 @@ impl BufferInterface for BufferImpl<'_> {
         0
     }
 
-    fn present(self) -> Result<(), SoftBufferError> {
+    fn present_with_damage(self, _damage: &[Rect]) -> Result<(), SoftBufferError> {
         unsafe extern "C-unwind" fn release(
             _info: *mut c_void,
             data: NonNull<c_void>,
@@ -361,10 +361,6 @@ impl BufferInterface for BufferImpl<'_> {
         CATransaction::commit();
         Ok(())
     }
-
-    fn present_with_damage(self, _damage: &[Rect]) -> Result<(), SoftBufferError> {
-        self.present()
-    }
 }
 
 #[derive(Debug)]

src/backends/kms.rs

@@ -325,24 +325,23 @@ impl BufferInterface for BufferImpl<'_> {
 
     #[inline]
     fn present_with_damage(self, damage: &[crate::Rect]) -> Result<(), SoftBufferError> {
-        let rectangles = damage
+        let rectangles: Vec<_> = damage
             .iter()
-            .map(|&rect| {
-                let err = || SoftBufferError::DamageOutOfRange { rect };
-                Ok::<_, SoftBufferError>(ClipRect::new(
-                    rect.x.try_into().map_err(|_| err())?,
-                    rect.y.try_into().map_err(|_| err())?,
+            .map(|rect| {
+                ClipRect::new(
+                    rect.x.try_into().unwrap_or(u16::MAX),
+                    rect.y.try_into().unwrap_or(u16::MAX),
                     rect.x
                         .checked_add(rect.width.get())
                         .and_then(|x| x.try_into().ok())
-                        .ok_or_else(err)?,
+                        .unwrap_or(u16::MAX),
                     rect.y
                         .checked_add(rect.height.get())
-                        .and_then(|y| y.try_into().ok())
-                        .ok_or_else(err)?,
-                ))
+                        .and_then(|x| x.try_into().ok())
+                        .unwrap_or(u16::MAX),
+                )
             })
-            .collect::<Result<Vec<_>, _>>()?;
+            .collect();
 
         // Dirty the framebuffer with out damage rectangles.
         //
@@ -378,17 +377,6 @@ impl BufferInterface for BufferImpl<'_> {
 
         Ok(())
     }
-
-    #[inline]
-    fn present(self) -> Result<(), SoftBufferError> {
-        let (width, height) = self.size;
-        self.present_with_damage(&[crate::Rect {
-            x: 0,
-            y: 0,
-            width,
-            height,
-        }])
-    }
 }
 
 impl SharedBuffer {

src/backends/orbital.rs

@@ -176,7 +176,7 @@ impl BufferInterface for BufferImpl<'_> {
         }
     }
 
-    fn present(self) -> Result<(), SoftBufferError> {
+    fn present_with_damage(self, _damage: &[Rect]) -> Result<(), SoftBufferError> {
         match self.pixels {
             Pixels::Mapping(mapping) => {
                 drop(mapping);
@@ -190,10 +190,6 @@ impl BufferInterface for BufferImpl<'_> {
 
         Ok(())
     }
-
-    fn present_with_damage(self, _damage: &[Rect]) -> Result<(), SoftBufferError> {
-        self.present()
-    }
 }
 
 // Read the current width and size

src/backends/wayland/mod.rs

@@ -260,16 +260,14 @@ impl BufferInterface for BufferImpl<'_> {
             self.surface.damage(0, 0, i32::MAX, i32::MAX);
         } else {
             for rect in damage {
+                // Damage that falls outside the surface is ignored.
+                // https://wayland.freedesktop.org/docs/html/apa.html#protocol-spec-wl_surface
+                let x = rect.x.try_into().unwrap_or(i32::MAX);
+                let y = rect.y.try_into().unwrap_or(i32::MAX);
+                let width = rect.width.get().try_into().unwrap_or(i32::MAX);
+                let height = rect.height.get().try_into().unwrap_or(i32::MAX);
+
                 // Introduced in version 4, it is an error to use this request in version 3 or lower.
-                let (x, y, width, height) = (|| {
-                    Some((
-                        i32::try_from(rect.x).ok()?,
-                        i32::try_from(rect.y).ok()?,
-                        i32::try_from(rect.width.get()).ok()?,
-                        i32::try_from(rect.height.get()).ok()?,
-                    ))
-                })()
-                .ok_or(SoftBufferError::DamageOutOfRange { rect: *rect })?;
                 self.surface.damage_buffer(x, y, width, height);
             }
         }
@@ -284,17 +282,6 @@ impl BufferInterface for BufferImpl<'_> {
 
         Ok(())
     }
-
-    fn present(self) -> Result<(), SoftBufferError> {
-        let (width, height) = (self.width, self.height);
-        self.present_with_damage(&[Rect {
-            x: 0,
-            y: 0,
-            // We know width/height will be non-negative and non-zero.
-            width: (width as u32).try_into().unwrap(),
-            height: (height as u32).try_into().unwrap(),
-        }])
-    }
 }
 
 impl Dispatch<wl_registry::WlRegistry, GlobalListContents> for State {

src/backends/web.rs

@@ -331,20 +331,8 @@ impl BufferInterface for BufferImpl<'_> {
     }
 
     /// Push the buffer to the canvas.
-    fn present(self) -> Result<(), SoftBufferError> {
-        let (width, height) = self
-            .size
-            .expect("Must set size of surface before calling `present()`");
-        self.present_with_damage(&[Rect {
-            x: 0,
-            y: 0,
-            width,
-            height,
-        }])
-    }
-
     fn present_with_damage(self, damage: &[Rect]) -> Result<(), SoftBufferError> {
-        let (buffer_width, _buffer_height) = self
+        let (buffer_width, buffer_height) = self
             .size
             .expect("Must set size of surface before calling `present_with_damage()`");
 
@@ -370,8 +358,10 @@ impl BufferInterface for BufferImpl<'_> {
             .collect();
 
         debug_assert_eq!(
-            bitmap.len() as u32,
-            union_damage.width.get() * union_damage.height.get() * 4
+            bitmap.len(),
+            union_damage.width.get().min(buffer_width.get()) as usize
+                * union_damage.height.get().min(buffer_height.get()) as usize
+                * 4
         );
 
         #[cfg(target_feature = "atomics")]
@@ -394,14 +384,14 @@ impl BufferInterface for BufferImpl<'_> {
             let array = Uint8Array::new_with_length(bitmap.len() as u32);
             array.copy_from(&bitmap);
             let array = Uint8ClampedArray::new(&array);
-            ImageDataExt::new(array, union_damage.width.get())
+            ImageDataExt::new(array, union_damage.width.get().min(buffer_width.get()))
                 .map(JsValue::from)
                 .map(ImageData::unchecked_from_js)
         };
         #[cfg(not(target_feature = "atomics"))]
         let result = ImageData::new_with_u8_clamped_array(
             wasm_bindgen::Clamped(&bitmap),
-            union_damage.width.get(),
+            union_damage.width.get().min(buffer_width.get()),
         );
         // This should only throw an error if the buffer we pass's size is incorrect.
         let image_data = result.unwrap();
@@ -411,12 +401,12 @@ impl BufferInterface for BufferImpl<'_> {
             self.canvas
                 .put_image_data(
                     &image_data,
-                    union_damage.x.into(),
-                    union_damage.y.into(),
+                    union_damage.x.min(buffer_width.get()).into(),
+                    union_damage.y.min(buffer_height.get()).into(),
                     (rect.x - union_damage.x).into(),
                     (rect.y - union_damage.y).into(),
-                    rect.width.get().into(),
-                    rect.height.get().into(),
+                    rect.width.get().min(buffer_width.get()).into(),
+                    rect.height.get().min(buffer_height.get()).into(),
                 )
                 .unwrap();
         }

src/backends/win32.rs

@@ -271,38 +271,23 @@ impl BufferInterface for BufferImpl<'_> {
         }
     }
 
-    fn present(self) -> Result<(), SoftBufferError> {
-        let (width, height) = (self.buffer.width, self.buffer.height);
-        self.present_with_damage(&[Rect {
-            x: 0,
-            y: 0,
-            // We know width/height will be non-negative
-            width: width.try_into().unwrap(),
-            height: height.try_into().unwrap(),
-        }])
-    }
-
     fn present_with_damage(self, damage: &[Rect]) -> Result<(), SoftBufferError> {
         unsafe {
             for rect in damage.iter().copied() {
-                let (x, y, width, height) = (|| {
-                    Some((
-                        i32::try_from(rect.x).ok()?,
-                        i32::try_from(rect.y).ok()?,
-                        i32::try_from(rect.width.get()).ok()?,
-                        i32::try_from(rect.height.get()).ok()?,
-                    ))
-                })()
-                .ok_or(SoftBufferError::DamageOutOfRange { rect })?;
+                let x = rect.x.try_into().unwrap_or(i32::MAX);
+                let y = rect.y.try_into().unwrap_or(i32::MAX);
+                let width = rect.width.get().try_into().unwrap_or(i32::MAX);
+                let height = rect.height.get().try_into().unwrap_or(i32::MAX);
+
                 Gdi::BitBlt(
                     self.dc.0,
-                    x,
-                    y,
-                    width,
-                    height,
+                    x.min(self.buffer.width.get()),
+                    y.min(self.buffer.height.get()),
+                    width.min(self.buffer.width.get()),
+                    height.min(self.buffer.height.get()),
                     self.buffer.dc,
-                    x,
-                    y,
+                    x.min(self.buffer.width.get()),
+                    y.min(self.buffer.height.get()),
                     Gdi::SRCCOPY,
                 );
             }

src/backends/x11.rs

@@ -469,30 +469,25 @@ impl BufferInterface for BufferImpl<'_> {
                     damage
                         .iter()
                         .try_for_each(|rect| {
-                            let (src_x, src_y, dst_x, dst_y, width, height) = (|| {
-                                Some((
-                                    u16::try_from(rect.x).ok()?,
-                                    u16::try_from(rect.y).ok()?,
-                                    i16::try_from(rect.x).ok()?,
-                                    i16::try_from(rect.y).ok()?,
-                                    u16::try_from(rect.width.get()).ok()?,
-                                    u16::try_from(rect.height.get()).ok()?,
-                                ))
-                            })(
-                            )
-                            .ok_or(SoftBufferError::DamageOutOfRange { rect: *rect })?;
+                            let src_x = rect.x.try_into().unwrap_or(u16::MAX);
+                            let src_y = rect.y.try_into().unwrap_or(u16::MAX);
+                            let dst_x = rect.x.try_into().unwrap_or(i16::MAX);
+                            let dst_y = rect.y.try_into().unwrap_or(i16::MAX);
+                            let width = rect.width.get().try_into().unwrap_or(u16::MAX);
+                            let height = rect.height.get().try_into().unwrap_or(u16::MAX);
+
                             self.connection
                                 .shm_put_image(
                                     self.window,
                                     self.gc,
                                     surface_width.get(),
                                     surface_height.get(),
-                                    src_x,
-                                    src_y,
-                                    width,
-                                    height,
-                                    dst_x,
-                                    dst_y,
+                                    src_x.min(surface_width.get()),
+                                    src_y.min(surface_height.get()),
+                                    width.min(surface_width.get()),
+                                    height.min(surface_height.get()),
+                                    dst_x.min(surface_width.get() as i16),
+                                    dst_y.min(surface_height.get() as i16),
                                     self.depth,
                                     xproto::ImageFormat::Z_PIXMAP.into(),
                                     false,
@@ -516,18 +511,6 @@ impl BufferInterface for BufferImpl<'_> {
 
         Ok(())
     }
-
-    fn present(self) -> Result<(), SoftBufferError> {
-        let (width, height) = self
-            .size
-            .expect("Must set size of surface before calling `present()`");
-        self.present_with_damage(&[Rect {
-            x: 0,
-            y: 0,
-            width: width.into(),
-            height: height.into(),
-        }])
-    }
 }
 
 impl Buffer {