make ImageRef/Mut dyn compatible and don't use generics in most functions

kbalt · kbalt · commit b1ae470d0870 · 2024-11-18T16:53:27.000+01:00
diff --git a/src/copy.rs b/src/copy.rs
@@ -1,8 +1,8 @@
 use crate::{verify_input_windows, ConvertError, ImageMut, ImageRef, ImageRefExt};
 
 #[inline(always)]
-pub(crate) fn copy_impl(src: &impl ImageRef, dst: &mut impl ImageMut) -> Result<(), ConvertError> {
-    verify_input_windows(&src, &dst)?;
+pub(crate) fn copy_impl(src: &dyn ImageRef, dst: &mut dyn ImageMut) -> Result<(), ConvertError> {
+    verify_input_windows(src, dst)?;
 
     assert_eq!(src.format(), dst.format());
 
@@ -31,11 +31,11 @@ pub(crate) fn copy_impl(src: &impl ImageRef, dst: &mut impl ImageMut) -> Result<
 
 #[inline(never)]
 #[doc(hidden)]
-pub fn copy(src: &impl ImageRef, dst: &mut impl ImageMut) -> Result<(), ConvertError> {
+pub fn copy(src: &dyn ImageRef, dst: &mut dyn ImageMut) -> Result<(), ConvertError> {
     #[cfg(all(feature = "unstable", any(target_arch = "x86", target_arch = "x86_64")))]
     if is_x86_feature_detected!("avx512f") && is_x86_feature_detected!("avx512bw") {
         #[target_feature(enable = "avx512f", enable = "avx512bw")]
-        unsafe fn call(src: &impl ImageRef, dst: &mut impl ImageMut) -> Result<(), ConvertError> {
+        unsafe fn call(src: &dyn ImageRef, dst: &mut dyn ImageMut) -> Result<(), ConvertError> {
             copy_impl(src, dst)
         }
 
@@ -48,7 +48,7 @@ pub fn copy(src: &impl ImageRef, dst: &mut impl ImageMut) -> Result<(), ConvertE
     #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
     if is_x86_feature_detected!("avx2") {
         #[target_feature(enable = "avx2")]
-        unsafe fn call(src: &impl ImageRef, dst: &mut impl ImageMut) -> Result<(), ConvertError> {
+        unsafe fn call(src: &dyn ImageRef, dst: &mut dyn ImageMut) -> Result<(), ConvertError> {
             copy_impl(src, dst)
         }
 
@@ -61,7 +61,7 @@ pub fn copy(src: &impl ImageRef, dst: &mut impl ImageMut) -> Result<(), ConvertE
     #[cfg(target_arch = "aarch64")]
     if crate::arch::is_aarch64_feature_detected!("neon") {
         #[target_feature(enable = "neon")]
-        unsafe fn call(src: &impl ImageRef, dst: &mut impl ImageMut) -> Result<(), ConvertError> {
+        unsafe fn call(src: &dyn ImageRef, dst: &mut dyn ImageMut) -> Result<(), ConvertError> {
             copy_impl(src, dst)
         }
 
diff --git a/src/crop.rs b/src/crop.rs
@@ -70,7 +70,7 @@ unsafe impl<T: ImageRef> ImageRef for Cropped<T> {
         self.1.height
     }
 
-    fn planes(&self) -> impl Iterator<Item = (&[u8], usize)> {
+    fn planes(&self) -> Box<dyn Iterator<Item = (&[u8], usize)> + '_> {
         use PixelFormat::*;
 
         match self.format() {
@@ -96,7 +96,7 @@ unsafe impl<T: ImageRef> ImageRef for Cropped<T> {
 }
 
 unsafe impl<T: ImageMut> ImageMut for Cropped<T> {
-    fn planes_mut(&mut self) -> impl Iterator<Item = (&mut [u8], usize)> {
+    fn planes_mut(&mut self) -> Box<dyn Iterator<Item = (&mut [u8], usize)> + '_> {
         use PixelFormat::*;
 
         let format = self.format();
@@ -162,14 +162,11 @@ impl<S> Iterator for ArrayIter<S> {
     }
 }
 
-fn crop_planes<const N: usize, S: AnySlice>(
+fn crop_planes<'s, const N: usize, S: AnySlice + 's>(
     plane_desc: [PlaneDesc; N],
     planes: [(S, usize); N],
     window: Window,
-) -> ArrayIter<(S, usize)>
-where
-    ArrayIter<(S, usize)>: From<[(S, usize); N]>,
-{
+) -> Box<dyn Iterator<Item = (S, usize)> + 's> {
     let mut out = [const { MaybeUninit::uninit() }; N];
 
     for ((plane_desc, (slice, stride)), out) in
@@ -185,5 +182,5 @@ where
         out.write((slice, stride));
     }
 
-    ArrayIter::from(out.map(|p| unsafe { p.assume_init() }))
+    Box::new(out.map(|p| unsafe { p.assume_init() }).into_iter())
 }
diff --git a/src/formats/i420/read.rs b/src/formats/i420/read.rs
@@ -20,7 +20,7 @@ pub(crate) struct I420Reader<'a, P: PrimitiveInternal> {
 }
 
 impl<'a, P: PrimitiveInternal> I420Reader<'a, P> {
-    pub(crate) fn new(src: &'a impl ImageRef) -> Result<Self, ConvertError> {
+    pub(crate) fn new(src: &'a dyn ImageRef) -> Result<Self, ConvertError> {
         src.bounds_check()?;
 
         let [(y, y_stride), (u, u_stride), (v, v_stride)] = read_planes(src.planes())?;
diff --git a/src/formats/i420/write.rs b/src/formats/i420/write.rs
@@ -31,7 +31,7 @@ where
     P: PrimitiveInternal,
     S: I420Src,
 {
-    pub(crate) fn write(dst: &'a mut impl ImageMut, i420_src: S) -> Result<(), ConvertError> {
+    pub(crate) fn write(dst: &'a mut dyn ImageMut, i420_src: S) -> Result<(), ConvertError> {
         dst.bounds_check()?;
 
         let dst_width = dst.width();
diff --git a/src/formats/i422/read.rs b/src/formats/i422/read.rs
@@ -20,7 +20,7 @@ pub(crate) struct I422Reader<'a, P: PrimitiveInternal> {
 }
 
 impl<'a, P: PrimitiveInternal> I422Reader<'a, P> {
-    pub(crate) fn new(src: &'a impl ImageRef) -> Result<Self, ConvertError> {
+    pub(crate) fn new(src: &'a dyn ImageRef) -> Result<Self, ConvertError> {
         src.bounds_check()?;
 
         let [(y, y_stride), (u, u_stride), (v, v_stride)] = read_planes(src.planes())?;
diff --git a/src/formats/i422/write.rs b/src/formats/i422/write.rs
@@ -31,7 +31,7 @@ where
     P: PrimitiveInternal,
     S: I422Src,
 {
-    pub(crate) fn write(dst: &'a mut impl ImageMut, i422_src: S) -> Result<(), ConvertError> {
+    pub(crate) fn write(dst: &'a mut dyn ImageMut, i422_src: S) -> Result<(), ConvertError> {
         dst.bounds_check()?;
 
         let dst_width = dst.width();
diff --git a/src/formats/i444/read.rs b/src/formats/i444/read.rs
@@ -20,7 +20,7 @@ pub(crate) struct I444Reader<'a, P: PrimitiveInternal> {
 }
 
 impl<'a, P: PrimitiveInternal> I444Reader<'a, P> {
-    pub(crate) fn new(src: &'a impl ImageRef) -> Result<Self, ConvertError> {
+    pub(crate) fn new(src: &'a dyn ImageRef) -> Result<Self, ConvertError> {
         src.bounds_check()?;
 
         let [(y, y_stride), (u, u_stride), (v, v_stride)] = read_planes(src.planes())?;
diff --git a/src/formats/i444/write.rs b/src/formats/i444/write.rs
@@ -31,7 +31,7 @@ where
     P: PrimitiveInternal,
     S: I444Src,
 {
-    pub(crate) fn write(dst: &'a mut impl ImageMut, i444_src: S) -> Result<(), ConvertError> {
+    pub(crate) fn write(dst: &'a mut dyn ImageMut, i444_src: S) -> Result<(), ConvertError> {
         dst.bounds_check()?;
 
         let dst_width = dst.width();
diff --git a/src/formats/nv12/read.rs b/src/formats/nv12/read.rs
@@ -18,7 +18,7 @@ pub(crate) struct NV12Reader<'a, P: PrimitiveInternal> {
 }
 
 impl<'a, P: PrimitiveInternal> NV12Reader<'a, P> {
-    pub(crate) fn new(src: &'a impl ImageRef) -> Result<Self, ConvertError> {
+    pub(crate) fn new(src: &'a dyn ImageRef) -> Result<Self, ConvertError> {
         src.bounds_check()?;
 
         let [(y, y_stride), (uv, uv_stride)] = read_planes(src.planes())?;
diff --git a/src/formats/nv12/write.rs b/src/formats/nv12/write.rs
@@ -29,7 +29,7 @@ where
     P: PrimitiveInternal,
     S: I420Src,
 {
-    pub(crate) fn write(dst: &'a mut impl ImageMut, i420_src: S) -> Result<(), ConvertError> {
+    pub(crate) fn write(dst: &'a mut dyn ImageMut, i420_src: S) -> Result<(), ConvertError> {
         dst.bounds_check()?;
 
         let dst_width = dst.width();
diff --git a/src/formats/rgb/read.rs b/src/formats/rgb/read.rs
@@ -16,7 +16,7 @@ pub(crate) struct RgbReader<'a, const REVERSE: bool, P: PrimitiveInternal> {
 }
 
 impl<'a, const REVERSE: bool, P: PrimitiveInternal> RgbReader<'a, REVERSE, P> {
-    pub(crate) fn new(src: &'a impl ImageRef) -> Result<Self, ConvertError> {
+    pub(crate) fn new(src: &'a dyn ImageRef) -> Result<Self, ConvertError> {
         src.bounds_check()?;
 
         let [(rgb, rgb_stride)] = read_planes(src.planes())?;
diff --git a/src/formats/rgb/write.rs b/src/formats/rgb/write.rs
@@ -26,7 +26,7 @@ where
     P: PrimitiveInternal,
     S: RgbaSrc,
 {
-    pub(crate) fn write(dst: &'a mut impl ImageMut, rgba_src: S) -> Result<(), ConvertError> {
+    pub(crate) fn write(dst: &'a mut dyn ImageMut, rgba_src: S) -> Result<(), ConvertError> {
         dst.bounds_check()?;
 
         let dst_width = dst.width();
diff --git a/src/formats/rgba/read.rs b/src/formats/rgba/read.rs
@@ -16,7 +16,7 @@ pub(crate) struct RgbaReader<'a, const REVERSE: bool, P: PrimitiveInternal> {
 }
 
 impl<'a, const REVERSE: bool, P: PrimitiveInternal> RgbaReader<'a, REVERSE, P> {
-    pub(crate) fn new(src: &'a impl ImageRef) -> Result<Self, ConvertError> {
+    pub(crate) fn new(src: &'a dyn ImageRef) -> Result<Self, ConvertError> {
         src.bounds_check()?;
 
         let [(rgba, rgba_stride)] = read_planes(src.planes())?;
diff --git a/src/formats/rgba/write.rs b/src/formats/rgba/write.rs
@@ -27,7 +27,7 @@ where
     P: PrimitiveInternal,
     S: RgbaSrc,
 {
-    pub(crate) fn write(dst: &'a mut impl ImageMut, rgba_src: S) -> Result<(), ConvertError> {
+    pub(crate) fn write(dst: &'a mut dyn ImageMut, rgba_src: S) -> Result<(), ConvertError> {
         dst.bounds_check()?;
 
         let dst_width = dst.width();
diff --git a/src/formats/yuyv/read.rs b/src/formats/yuyv/read.rs
@@ -15,7 +15,7 @@ pub(crate) struct YUYVReader<'a, P: PrimitiveInternal> {
 }
 
 impl<'a, P: PrimitiveInternal> YUYVReader<'a, P> {
-    pub(crate) fn new(src: &'a impl ImageRef) -> Result<Self, ConvertError> {
+    pub(crate) fn new(src: &'a dyn ImageRef) -> Result<Self, ConvertError> {
         src.bounds_check()?;
 
         let [(yuyv, yuyv_stride)] = read_planes(src.planes())?;
@@ -30,7 +30,7 @@ impl<'a, P: PrimitiveInternal> YUYVReader<'a, P> {
 
     unsafe fn read_yuyv<V: Vector>(&mut self, offset: usize) -> (V, V) {
         let yuyv00 = P::load::<V>(self.yuyv.add(offset));
-        let yuyv01 = P::load::<V>(self.yuyv.add(offset + V::LEN));
+        let yuyv01 = P::load::<V>(self.yuyv.add(offset + V::LEN * P::SIZE));
 
         yuyv00.unzip(yuyv01)
     }
diff --git a/src/formats/yuyv/write.rs b/src/formats/yuyv/write.rs
@@ -26,7 +26,7 @@ where
     P: PrimitiveInternal,
     S: I422Src,
 {
-    pub(crate) fn write(dst: &'a mut impl ImageMut, i422_src: S) -> Result<(), ConvertError> {
+    pub(crate) fn write(dst: &'a mut dyn ImageMut, i422_src: S) -> Result<(), ConvertError> {
         dst.bounds_check()?;
 
         let dst_width = dst.width();
diff --git a/src/image.rs b/src/image.rs
@@ -18,29 +18,6 @@ enum Buffer<S> {
     Split(Vec<S>),
 }
 
-enum BufferIter<T, U, I> {
-    Whole(T),
-    Split(U),
-
-    _Marker(fn() -> I),
-}
-
-impl<T, U, I> Iterator for BufferIter<T, U, I>
-where
-    T: Iterator<Item = I>,
-    U: Iterator<Item = I>,
-{
-    type Item = I;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        match self {
-            BufferIter::Whole(iter) => iter.next(),
-            BufferIter::Split(iter) => iter.next(),
-            BufferIter::_Marker(_) => unreachable!(),
-        }
-    }
-}
-
 /// Everything that can go wrong when constructing an [`Image`]
 #[derive(Debug, thiserror::Error)]
 pub enum ImageError {
@@ -130,9 +107,9 @@ unsafe impl<S: AsRef<[u8]>> ImageRef for Image<S> {
         self.height
     }
 
-    fn planes(&self) -> impl Iterator<Item = (&[u8], usize)> {
+    fn planes(&self) -> Box<dyn Iterator<Item = (&[u8], usize)> + '_> {
         match &self.buffer {
-            Buffer::Whole(buffer) => BufferIter::Whole(
+            Buffer::Whole(buffer) => Box::new(
                 infer(
                     self.format,
                     buffer.as_ref(),
@@ -142,7 +119,7 @@ unsafe impl<S: AsRef<[u8]>> ImageRef for Image<S> {
                 )
                 .zip(self.strides.iter().copied()),
             ),
-            Buffer::Split(planes) => BufferIter::Split(
+            Buffer::Split(planes) => Box::new(
                 planes
                     .iter()
                     .map(|p| p.as_ref())
@@ -156,9 +133,9 @@ unsafe impl<S: AsRef<[u8]>> ImageRef for Image<S> {
 }
 
 unsafe impl<S: AsRef<[u8]> + AsMut<[u8]>> ImageMut for Image<S> {
-    fn planes_mut(&mut self) -> impl Iterator<Item = (&mut [u8], usize)> {
+    fn planes_mut(&mut self) -> Box<dyn Iterator<Item = (&mut [u8], usize)> + '_> {
         match &mut self.buffer {
-            Buffer::Whole(buffer) => BufferIter::Whole(
+            Buffer::Whole(buffer) => Box::new(
                 infer(
                     self.format,
                     buffer.as_mut(),
@@ -168,7 +145,7 @@ unsafe impl<S: AsRef<[u8]> + AsMut<[u8]>> ImageMut for Image<S> {
                 )
                 .zip(self.strides.iter().copied()),
             ),
-            Buffer::Split(planes) => BufferIter::Split(
+            Buffer::Split(planes) => Box::new(
                 planes
                     .iter_mut()
                     .map(|plane| plane.as_mut())
diff --git a/src/image_traits.rs b/src/image_traits.rs
@@ -8,7 +8,7 @@ pub unsafe trait ImageRef {
     fn width(&self) -> usize;
     fn height(&self) -> usize;
     /// Returns an iterator yielding every plane with their associated stride
-    fn planes(&self) -> impl Iterator<Item = (&[u8], usize)>;
+    fn planes(&self) -> Box<dyn Iterator<Item = (&[u8], usize)> + '_>;
     fn color(&self) -> ColorInfo;
 }
 
@@ -17,7 +17,7 @@ pub unsafe trait ImageRef {
 /// Values returned must always be the same every call
 pub unsafe trait ImageMut: ImageRef {
     /// Returns an iterator yielding every plane with their associated stride
-    fn planes_mut(&mut self) -> impl Iterator<Item = (&mut [u8], usize)>;
+    fn planes_mut(&mut self) -> Box<dyn Iterator<Item = (&mut [u8], usize)> + '_>;
 }
 
 /// [`ImageRef`] extension methods
@@ -37,7 +37,7 @@ pub trait ImageRefExt: ImageRef {
     }
 }
 
-impl<T: ImageRef> ImageRefExt for T {}
+impl<T: ImageRef + ?Sized> ImageRefExt for T {}
 
 unsafe impl<T: ImageRef> ImageRef for &T {
     fn format(&self) -> PixelFormat {
@@ -52,7 +52,7 @@ unsafe impl<T: ImageRef> ImageRef for &T {
         <T as ImageRef>::height(self)
     }
 
-    fn planes(&self) -> impl Iterator<Item = (&[u8], usize)> {
+    fn planes(&self) -> Box<dyn Iterator<Item = (&[u8], usize)> + '_> {
         <T as ImageRef>::planes(self)
     }
 
@@ -74,7 +74,7 @@ unsafe impl<T: ImageRef> ImageRef for &mut T {
         <T as ImageRef>::height(self)
     }
 
-    fn planes(&self) -> impl Iterator<Item = (&[u8], usize)> {
+    fn planes(&self) -> Box<dyn Iterator<Item = (&[u8], usize)> + '_> {
         <T as ImageRef>::planes(self)
     }
 
@@ -84,7 +84,7 @@ unsafe impl<T: ImageRef> ImageRef for &mut T {
 }
 
 unsafe impl<T: ImageMut> ImageMut for &mut T {
-    fn planes_mut(&mut self) -> impl Iterator<Item = (&mut [u8], usize)> {
+    fn planes_mut(&mut self) -> Box<dyn Iterator<Item = (&mut [u8], usize)> + '_> {
         <T as ImageMut>::planes_mut(self)
     }
 }
diff --git a/src/lib.rs b/src/lib.rs
diff --git a/src/multi_thread.rs b/src/multi_thread.rs
diff --git a/src/resize.rs b/src/resize.rs
diff --git a/tests/visual_tests.rs b/tests/visual_tests.rs

Original file line number	Diff line number	Diff line change
`@@ -70,7 +70,7 @@ unsafe impl<T: ImageRef> ImageRef for Cropped<T> {`
`70`	`70`	`self.1.height`
`71`	`71`	`}`
`72`	`72`
`73`		`- fn planes(&self) -> impl Iterator<Item = (&[u8], usize)> {`
	`73`	`+ fn planes(&self) -> Box<dyn Iterator<Item = (&[u8], usize)> + '_> {`
`74`	`74`	`use PixelFormat::*;`
`75`	`75`
`76`	`76`	`match self.format() {`
`@@ -96,7 +96,7 @@ unsafe impl<T: ImageRef> ImageRef for Cropped<T> {`
`96`	`96`	`}`
`97`	`97`
`98`	`98`	`unsafe impl<T: ImageMut> ImageMut for Cropped<T> {`
`99`		`- fn planes_mut(&mut self) -> impl Iterator<Item = (&mut [u8], usize)> {`
	`99`	`+ fn planes_mut(&mut self) -> Box<dyn Iterator<Item = (&mut [u8], usize)> + '_> {`
`100`	`100`	`use PixelFormat::*;`
`101`	`101`
`102`	`102`	`let format = self.format();`
`@@ -162,14 +162,11 @@ impl<S> Iterator for ArrayIter<S> {`
`162`	`162`	`}`
`163`	`163`	`}`
`164`	`164`
`165`		`-fn crop_planes<const N: usize, S: AnySlice>(`
	`165`	`+fn crop_planes<'s, const N: usize, S: AnySlice + 's>(`
`166`	`166`	`plane_desc: [PlaneDesc; N],`
`167`	`167`	`planes: [(S, usize); N],`
`168`	`168`	`window: Window,`
`169`		`-) -> ArrayIter<(S, usize)>`
`170`		`-where`
`171`		`- ArrayIter<(S, usize)>: From<[(S, usize); N]>,`
`172`		`-{`
	`169`	`+) -> Box<dyn Iterator<Item = (S, usize)> + 's> {`
`173`	`170`	`let mut out = [const { MaybeUninit::uninit() }; N];`
`174`	`171`
`175`	`172`	`for ((plane_desc, (slice, stride)), out) in`
`@@ -185,5 +182,5 @@ where`
`185`	`182`	`out.write((slice, stride));`
`186`	`183`	`}`
`187`	`184`
`188`		`- ArrayIter::from(out.map(\|p\| unsafe { p.assume_init() }))`
	`185`	`+ Box::new(out.map(\|p\| unsafe { p.assume_init() }).into_iter())`
`189`	`186`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ pub(crate) struct I420Reader<'a, P: PrimitiveInternal> {`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`impl<'a, P: PrimitiveInternal> I420Reader<'a, P> {`
`23`		`- pub(crate) fn new(src: &'a impl ImageRef) -> Result<Self, ConvertError> {`
	`23`	`+ pub(crate) fn new(src: &'a dyn ImageRef) -> Result<Self, ConvertError> {`
`24`	`24`	`src.bounds_check()?;`
`25`	`25`
`26`	`26`	`let [(y, y_stride), (u, u_stride), (v, v_stride)] = read_planes(src.planes())?;`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ where`
`31`	`31`	`P: PrimitiveInternal,`
`32`	`32`	`S: I420Src,`
`33`	`33`	`{`
`34`		`- pub(crate) fn write(dst: &'a mut impl ImageMut, i420_src: S) -> Result<(), ConvertError> {`
	`34`	`+ pub(crate) fn write(dst: &'a mut dyn ImageMut, i420_src: S) -> Result<(), ConvertError> {`
`35`	`35`	`dst.bounds_check()?;`
`36`	`36`
`37`	`37`	`let dst_width = dst.width();`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ pub(crate) struct I444Reader<'a, P: PrimitiveInternal> {`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`impl<'a, P: PrimitiveInternal> I444Reader<'a, P> {`
`23`		`- pub(crate) fn new(src: &'a impl ImageRef) -> Result<Self, ConvertError> {`
	`23`	`+ pub(crate) fn new(src: &'a dyn ImageRef) -> Result<Self, ConvertError> {`
`24`	`24`	`src.bounds_check()?;`
`25`	`25`
`26`	`26`	`let [(y, y_stride), (u, u_stride), (v, v_stride)] = read_planes(src.planes())?;`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ pub(crate) struct NV12Reader<'a, P: PrimitiveInternal> {`
`18`	`18`	`}`
`19`	`19`
`20`	`20`	`impl<'a, P: PrimitiveInternal> NV12Reader<'a, P> {`
`21`		`- pub(crate) fn new(src: &'a impl ImageRef) -> Result<Self, ConvertError> {`
	`21`	`+ pub(crate) fn new(src: &'a dyn ImageRef) -> Result<Self, ConvertError> {`
`22`	`22`	`src.bounds_check()?;`
`23`	`23`
`24`	`24`	`let [(y, y_stride), (uv, uv_stride)] = read_planes(src.planes())?;`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ where`
`29`	`29`	`P: PrimitiveInternal,`
`30`	`30`	`S: I420Src,`
`31`	`31`	`{`
`32`		`- pub(crate) fn write(dst: &'a mut impl ImageMut, i420_src: S) -> Result<(), ConvertError> {`
	`32`	`+ pub(crate) fn write(dst: &'a mut dyn ImageMut, i420_src: S) -> Result<(), ConvertError> {`
`33`	`33`	`dst.bounds_check()?;`
`34`	`34`
`35`	`35`	`let dst_width = dst.width();`