cargo fmt cargo clippy

Author: marci1175

src/avif/encoding.rs

@@ -1,53 +1,65 @@
 //! Provides AV1 encoding for higher data efficiency via [`ravif`].
 
 use image::GenericImageView;
-use ravif::{Encoder, Img, EncodedImage};
+use ravif::{EncodedImage, Encoder, Img};
 
-/// 
+///
 /// Encodes a **formatted** image with the AV1 format.
-/// 
+///
 /// **If you are looking to encode a [`crate::cam::Webcam::get_frame`]'s returned frame [`encode_raw_image`] is the one to use.**
-/// 
+///
 /// # Behavior
 /// The **formatted** image is re-encoded with the settings the user passes in with the [`Encoder`] argument.
 /// The encoded image ([`ravif::EncodedImage`]) is returned from the image.
-/// 
+///
 /// # Error
 /// Will return an error if the image format could not be guessed correctly or if the image had incorrect proerties (Eg.: Invalid size).
-/// 
+///
 pub fn encode_image(encoder: Encoder, image: &[u8]) -> anyhow::Result<EncodedImage> {
     //Parse image from bytes
     let parsed_image = image::load_from_memory(image)?;
 
     //Iter over the pixels
-    let colors = parsed_image.pixels().map(|(_, _, color)| {
-        ravif::RGB8::new(color.0[0], color.0[1], color.0[2])
-    }).collect::<Vec<ravif::RGB8>>();
+    let colors = parsed_image
+        .pixels()
+        .map(|(_, _, color)| ravif::RGB8::new(color.0[0], color.0[1], color.0[2]))
+        .collect::<Vec<ravif::RGB8>>();
 
     //Encode image
-    let encoded_image: EncodedImage = encoder.encode_rgb(Img::new(colors.as_slice(), parsed_image.width() as usize, parsed_image.height() as usize))?;
-    
+    let encoded_image: EncodedImage = encoder.encode_rgb(Img::new(
+        colors.as_slice(),
+        parsed_image.width() as usize,
+        parsed_image.height() as usize,
+    ))?;
+
     Ok(encoded_image)
 }
 
-/// 
+///
 /// Encodes a raw image with the AV1 format
-/// 
+///
 /// # Behavior
 /// The image is encoded with the settings the user passes in with the [`Encoder`] argument.
 /// The encoded image ([`EncodedImage`]) is returned from the raw image.
-/// 
+///
 /// # Error
 /// If the image had incorrect proerties (Eg.: Invalid size).
-/// 
-pub fn encode_raw_image(encoder: Encoder, image: &[u8], width: usize, height: usize) -> anyhow::Result<EncodedImage> {
+///
+pub fn encode_raw_image(
+    encoder: Encoder,
+    image: &[u8],
+    width: usize,
+    height: usize,
+) -> anyhow::Result<EncodedImage> {
     //Iter over the raw pixels
-    let colors = image.chunks_exact(3).map(|chunk| {
-        ravif::RGB8::new(chunk[0], chunk[1], chunk[2])
-    }).collect::<Vec<ravif::RGB8>>();
+    let colors = image
+        .chunks_exact(3)
+        .map(|chunk| ravif::RGB8::new(chunk[0], chunk[1], chunk[2]))
+        .collect::<Vec<ravif::RGB8>>();
 
     //Encode image
-    let encoded_image: EncodedImage = encoder.encode_rgb(Img::new(colors.as_slice(), width, height))?;
-    
+    let encoded_image: EncodedImage =
+        encoder.encode_rgb(Img::new(colors.as_slice(), width, height))?;
+
     Ok(encoded_image)
 }

src/cam/mod.rs

@@ -18,18 +18,18 @@ pub struct Webcam(VideoCapture);
 impl Webcam {
     ///
     /// Create new ```Webcam``` instance with api preference and camera index.
-    /// 
+    ///
     /// **If you want to use the default api_preference you should use ```new_def(i32)``` instead**
-    /// 
+    ///
     /// # Behavior
     /// Creates a new webcam instance with a set index and an [api_preference](https://docs.rs/opencv/0.93.4/opencv/videoio/enum.VideoCaptureAPIs.html).
-    /// 
+    ///
     /// # Error
     /// Returns an error if the inpt device could not be found based on the camera_idx, or if the api preference was invalid.
-    /// 
+    ///
     /// # Information
     /// API preference consts are available at the [opencv documentation](https://docs.rs/opencv/latest/opencv/index.html). Some exmaples for this const are: ```CAP_MSMF```, ```CAP_V4L```.
-    /// 
+    ///
     pub fn new(camera_idx: i32, api_preference: i32) -> anyhow::Result<Self> {
         let video_capture_handle = VideoCapture::new(camera_idx, api_preference)?;
 
@@ -40,17 +40,17 @@ impl Webcam {
         Ok(Self(video_capture_handle))
     }
 
-    /// 
+    ///
     /// Create new ```Webcam``` instance with automatic camera detection.
-    /// 
+    ///
     /// **If you have more than one camera you should use the [`Self::new_def`] function to define which camera you are wanting to use.**
-    /// 
+    ///
     /// # Behavior
     /// Creates a new [`Webcam`] instance while automaticly detecting the camera input.
     ///
     /// # Error
     /// This returns an error if it could not find the input device.
-    /// 
+    ///
     pub fn new_def_auto_detect() -> anyhow::Result<Self> {
         let video_capture_handle = VideoCapture::new_def(CAP_ANY)?;
 
@@ -63,10 +63,10 @@ impl Webcam {
 
     ///
     /// Create new ```Webcam``` instance with api preference and camera index.
-    /// 
+    ///
     /// # Behavior
     /// Creates a new webcam instance with a set index and the default ```api_preference``` ([`CAP_ANY`]).
-    /// 
+    ///
     /// # Error
     /// Returns an error if the inpt device could not be found based on the camera_idx.
     pub fn new_def(camera_idx: i32) -> anyhow::Result<Self> {
@@ -79,13 +79,13 @@ impl Webcam {
         Ok(Self(video_capture_handle))
     }
 
-    /// 
-    /// Requests a frame from the [`Webcam`] instance. 
-    /// 
+    ///
+    /// Requests a frame from the [`Webcam`] instance.
+    ///
     /// # Behavior
     /// Reads an image out of the ```VideoCapture``` buffer, this removes the bytes of the image from the buffer.
     /// Returns a tuple of the raw image bytes and the size of the image.
-    /// 
+    ///
     /// # Information
     /// Please note the image's bytes returned by this function are automaticly converted from [BRG8](https://learn.microsoft.com/en-us/windows/win32/wic/-wic-codec-native-pixel-formats#rgbbgr-color-model) (Which is returned by opencv by default) to RGB8
     ///
@@ -95,7 +95,7 @@ impl Webcam {
     ///     * the color format conversion failed.
     ///     * there was some kind of error when getting the image bytes / the size of the image from the [`Mat`].
     ///     * the Webcam instance was invalid. (It got released before requesting this frame)
-    /// 
+    ///
     pub fn get_frame(&mut self) -> anyhow::Result<(Vec<u8>, Size_<i32>)> {
         //Create frame which will be overwritten
         let mut frame = Mat::default();
@@ -116,15 +116,15 @@ impl Webcam {
         ))
     }
 
-    /// 
+    ///
     /// Get the backend api's name.
     ///
     /// # Behavior
     /// Gets the backend api's name.
-    /// 
+    ///
     /// # Error
     /// Returns an error if it failed to get the backend api's name.
-    /// 
+    ///
     pub fn get_backend_name(&self) -> anyhow::Result<String> {
         Ok(self.0.get_backend_name()?)
     }
@@ -134,14 +134,14 @@ impl Webcam {
     ///
     /// # Behavior
     /// This function releases the [`Webcam`]'s underlying [`VideoCapture`] instance.
-    /// 
+    ///
     /// # Information
     /// The underlying [`VideoCapture`] instance is invalidated, thus requesting frames on this [`Webcam`] instance will be unsuccessful.
     ///
     /// # Error
     /// Returns an error if it could not invalidate the instance.
-    /// 
+    ///
     pub fn release(&mut self) -> anyhow::Result<()> {
         Ok(self.0.release()?)
     }
-}
+}

src/lib.rs

@@ -34,4 +34,4 @@ pub mod opus;
 pub mod cam;
 
 #[cfg(feature = "av1")]
-pub mod avif;
+pub mod avif;

src/tests.rs

@@ -3,18 +3,21 @@
 
 #[cfg(test)]
 mod tests {
-    use std::{fs, thread::sleep, time::Duration};
+    use std::{thread::sleep, time::Duration};
 
     use cpal::traits::{DeviceTrait, StreamTrait};
     use opus::Channels;
     use ravif::Encoder;
     use tokio::sync::oneshot;
 
     use crate::{
-        avif::encoding::{encode_image, encode_raw_image}, cam, io::{self, playback::stream_audio, record::record_audio_with_interrupt}, opus::{
+        avif::encoding::encode_raw_image,
+        cam,
+        io::{self, playback::stream_audio, record::record_audio_with_interrupt},
+        opus::{
             decode::{create_opus_decoder, decode_samples_opus},
             encode::{create_opus_encoder, encode_samples_opus},
-        }
+        },
     };
 
     #[test]
@@ -23,9 +26,15 @@ mod tests {
         let (bytes, size) = webcam.get_frame().unwrap();
 
         let encoder = Encoder::new().with_speed(3);
-        let encoded = encode_raw_image(encoder.clone(), &bytes, size.width as usize, size.height as usize).unwrap();
-        
-        fs::write("asdsad.avif", encoded.avif_file);
+        let encoded = encode_raw_image(
+            encoder.clone(),
+            &bytes,
+            size.width as usize,
+            size.height as usize,
+        )
+        .unwrap();
+
+        assert_ne!(encoded.avif_file.len(), 0)
     }
 
     #[test]
@@ -134,4 +143,4 @@ mod tests {
 
         sleep(Duration::from_secs(3));
     }
-}
+}