A bit of cleanup.

Author: ralfbiedert

openh264-sys2/src/lib.rs

@@ -52,18 +52,18 @@ pub trait API {
 #[cfg(feature = "libloading")]
 pub mod libloading {
     pub use crate::generated::fns_libloading::*;
-    use crate::{ISVCDecoder, ISVCEncoder, OpenH264Version, SDecoderCapability};
+    use crate::{API, ISVCDecoder, ISVCEncoder, OpenH264Version, SDecoderCapability};
     use std::os::raw::{c_int, c_long};
 
     #[rustfmt::skip]
     impl super::API for APILoader {
-        unsafe fn WelsCreateSVCEncoder(&self, ppEncoder: *mut *mut ISVCEncoder) -> c_int { APILoader::WelsCreateSVCEncoder(self, ppEncoder) }
-        unsafe fn WelsDestroySVCEncoder(&self, pEncoder: *mut ISVCEncoder) { APILoader::WelsDestroySVCEncoder(self, pEncoder) }
-        unsafe fn WelsGetDecoderCapability(&self, pDecCapability: *mut SDecoderCapability) -> c_int { APILoader::WelsGetDecoderCapability(self, pDecCapability) }
-        unsafe fn WelsCreateDecoder(&self, ppDecoder: *mut *mut ISVCDecoder) -> c_long { APILoader::WelsCreateDecoder(self, ppDecoder) }
-        unsafe fn WelsDestroyDecoder(&self, pDecoder: *mut ISVCDecoder) { APILoader::WelsDestroyDecoder(self, pDecoder) }
-        unsafe fn WelsGetCodecVersion(&self) -> OpenH264Version { APILoader::WelsGetCodecVersion(self) }
-        unsafe fn WelsGetCodecVersionEx(&self, pVersion: *mut OpenH264Version) {APILoader::WelsGetCodecVersionEx(self, pVersion) }
+        unsafe fn WelsCreateSVCEncoder(&self, ppEncoder: *mut *mut ISVCEncoder) -> c_int { unsafe { APILoader::WelsCreateSVCEncoder(self, ppEncoder) } }
+        unsafe fn WelsDestroySVCEncoder(&self, pEncoder: *mut ISVCEncoder) { unsafe { APILoader::WelsDestroySVCEncoder(self, pEncoder) } }
+        unsafe fn WelsGetDecoderCapability(&self, pDecCapability: *mut SDecoderCapability) -> c_int { unsafe { APILoader::WelsGetDecoderCapability(self, pDecCapability) } }
+        unsafe fn WelsCreateDecoder(&self, ppDecoder: *mut *mut ISVCDecoder) -> c_long { unsafe { APILoader::WelsCreateDecoder(self, ppDecoder) } }
+        unsafe fn WelsDestroyDecoder(&self, pDecoder: *mut ISVCDecoder) { unsafe { APILoader::WelsDestroyDecoder(self, pDecoder) } }
+        unsafe fn WelsGetCodecVersion(&self) -> OpenH264Version { unsafe { APILoader::WelsGetCodecVersion(self) } }
+        unsafe fn WelsGetCodecVersionEx(&self, pVersion: *mut OpenH264Version) { unsafe { APILoader::WelsGetCodecVersionEx(self, pVersion) } }
     }
 }
 

openh264/src/decoder.rs

@@ -49,10 +49,9 @@
 //! ```
 
 use crate::error::NativeErrorExt;
-use crate::formats::yuv2rgb::write_rgb8_f32x8_par;
-// use crate::formats::yuv2rgb::{write_rgb8_f32x8, write_rgb8_f32x8_par, write_rgb8_scalar, write_rgb8_scalar_par};
-use crate::formats::YUVSource;
 use crate::formats::yuv2rgb::{write_rgb8_f32x8, write_rgb8_scalar, write_rgba8_f32x8, write_rgba8_scalar};
+// use crate::formats::yuv2rgb::{write_rgb8_f32x8, write_rgb8_f32x8_par, write_rgb8_scalar, write_rgb8_scalar_par};
+use crate::formats::{YUVSlices, YUVSource};
 use crate::{Error, OpenH264API, Timestamp};
 use openh264_sys2::{
     API, DECODER_OPTION, DECODER_OPTION_ERROR_CON_IDC, DECODER_OPTION_NUM_OF_FRAMES_REMAINING_IN_BUFFER,
@@ -523,7 +522,7 @@ impl DecodedYUV<'_> {
     /// Cut the YUV buffer into vertical sections.
     ///
     /// The slices do not overlap. If N does not divide the buffer, then the last YUVSlice has fewer pixel rows.
-    pub fn split<const N: usize>(&self) -> [YUVSlices; N] {
+    pub fn split<const N: usize>(&'_ self) -> [YUVSlices<'_>; N] {
         if N == 1 {
             return [YUVSlices::new((self.y, self.u, self.v), self.dimensions(), self.strides()); N];
         }
@@ -653,8 +652,8 @@ mod test {
     use openh264_sys2::SSysMEMBuffer;
 
     use crate::{
-        formats::{YUVSlices, YUVSource},
         Timestamp,
+        formats::{YUVSlices, YUVSource},
     };
 
     use super::DecodedYUV;
@@ -727,11 +726,11 @@ mod test {
             v_plane.extend_from_slice(slice.v());
         }
 
-        assert_eq!(buf.y.len(), y_plane.len());
-        assert_eq!(buf.y, y_plane);
-        assert_eq!(buf.u.len(), u_plane.len());
-        assert_eq!(buf.u, u_plane);
-        assert_eq!(buf.v.len(), v_plane.len());
-        assert_eq!(buf.v, v_plane);
+        assert_eq!(buf.y().len(), y_plane.len());
+        assert_eq!(buf.y(), y_plane);
+        assert_eq!(buf.u().len(), u_plane.len());
+        assert_eq!(buf.u(), u_plane);
+        assert_eq!(buf.v().len(), v_plane.len());
+        assert_eq!(buf.v(), v_plane);
     }
 }

openh264/src/formats/yuv.rs

@@ -188,7 +188,7 @@ impl YUVSource for YUVBuffer {
 
 /// Convenience wrapper if you already have YUV-sliced data from some other place.
 #[must_use]
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, Debug)]
 pub struct YUVSlices<'a> {
     dimensions: (usize, usize),
     yuv: (&'a [u8], &'a [u8], &'a [u8]),

openh264/src/formats/yuv2rgb.rs

@@ -433,13 +433,10 @@ fn write_rgba8_f32x8_row(y_row: &[u8], u_row: &[u8], v_row: &[u8], width: usize,
 }
 #[cfg(test)]
 mod test {
-    use crate::decoder::{Decoder, DecoderConfig};
-    use crate::formats::yuv2rgb::{write_rgb8_f32x8, write_rgb8_f32x8_par, write_rgb8_scalar, write_rgb8_scalar_par};
-    use crate::formats::YUVSource;
     use crate::OpenH264API;
     use crate::decoder::{Decoder, DecoderConfig};
     use crate::formats::YUVSource;
-    use crate::formats::yuv2rgb::{write_rgb8_f32x8, write_rgb8_scalar, write_rgba8_scalar};
+    use crate::formats::yuv2rgb::{write_rgb8_f32x8, write_rgb8_f32x8_par, write_rgb8_scalar, write_rgb8_scalar_par};
 
     #[test]
     fn write_rgb8_scalar_range() {