inline format args to please our pedantic overlords

examples/controls.rs

@@ -4,13 +4,13 @@ use v4l::prelude::*;
 
 fn main() -> io::Result<()> {
     let path = "/dev/video0";
-    println!("Using device: {}\n", path);
+    println!("Using device: {path}\n");
 
     let dev = Device::with_path(path)?;
     let controls = dev.query_controls()?;
 
     for control in controls {
-        println!("{}", control);
+        println!("{control}");
     }
 
     Ok(())

examples/device.rs

@@ -4,12 +4,12 @@ use v4l::prelude::*;
 
 fn main() -> io::Result<()> {
     let path = "/dev/video0";
-    println!("Using device: {}\n", path);
+    println!("Using device: {path}\n");
 
     let dev = Device::with_path(path)?;
 
     let caps = dev.query_caps()?;
-    println!("Device capabilities:\n{}", caps);
+    println!("Device capabilities:\n{caps}");
 
     let controls = dev.query_controls()?;
     println!("Device controls:");

examples/formats.rs

@@ -5,28 +5,28 @@ use v4l::video::Capture;
 
 fn main() -> io::Result<()> {
     let path = "/dev/video0";
-    println!("Using device: {}\n", path);
+    println!("Using device: {path}\n");
 
     let dev = Device::with_path(path)?;
 
     let format = dev.format()?;
-    println!("Active format:\n{}", format);
+    println!("Active format:\n{format}");
 
     let params = dev.params()?;
-    println!("Active parameters:\n{}", params);
+    println!("Active parameters:\n{params}");
 
     println!("Available formats:");
     for format in dev.enum_formats()? {
         println!("  {} ({})", format.fourcc, format.description);
 
         for framesize in dev.enum_framesizes(format.fourcc)? {
             for discrete in framesize.size.to_discrete() {
-                println!("    Size: {}", discrete);
+                println!("    Size: {discrete}");
 
                 for frameinterval in
                     dev.enum_frameintervals(framesize.fourcc, discrete.width, discrete.height)?
                 {
-                    println!("      Interval:  {}", frameinterval);
+                    println!("      Interval:  {frameinterval}");
                 }
             }
         }

examples/glium.rs

@@ -18,7 +18,7 @@ use v4l::{Format, FourCC};
 
 fn main() -> io::Result<()> {
     let path = "/dev/video0";
-    println!("Using device: {}\n", path);
+    println!("Using device: {path}\n");
 
     // Allocate 4 buffers by default
     let buffer_count = 4;
@@ -50,8 +50,8 @@ fn main() -> io::Result<()> {
         }
     }
 
-    println!("Active format:\n{}", format);
-    println!("Active parameters:\n{}", params);
+    println!("Active format:\n{format}");
+    println!("Active parameters:\n{params}");
 
     // Setup the GL display stuff
     let event_loop = glutin::event_loop::EventLoop::new();

examples/stream_capture_mmap.rs

@@ -8,7 +8,7 @@ use v4l::video::Capture;
 
 fn main() -> io::Result<()> {
     let path = "/dev/video0";
-    println!("Using device: {}\n", path);
+    println!("Using device: {path}\n");
 
     // Capture 4 frames by default
     let count = 4;
@@ -19,8 +19,8 @@ fn main() -> io::Result<()> {
     let dev = Device::with_path(path)?;
     let format = dev.format()?;
     let params = dev.params()?;
-    println!("Active format:\n{}", format);
-    println!("Active parameters:\n{}", params);
+    println!("Active format:\n{format}");
+    println!("Active parameters:\n{params}");
 
     // Setup a buffer stream and grab a frame, then print its data
     let mut stream = MmapStream::with_buffers(&dev, Type::VideoCapture, buffer_count)?;
@@ -54,7 +54,7 @@ fn main() -> io::Result<()> {
 
     println!();
     println!("FPS: {}", count as f64 / start.elapsed().as_secs_f64());
-    println!("MB/s: {}", megabytes_ps);
+    println!("MB/s: {megabytes_ps}");
 
     Ok(())
 }

examples/stream_capture_userptr.rs

@@ -8,7 +8,7 @@ use v4l::video::Capture;
 
 fn main() -> io::Result<()> {
     let path = "/dev/video0";
-    println!("Using device: {}\n", path);
+    println!("Using device: {path}\n");
 
     // Capture 4 frames by default
     let count = 4;
@@ -19,8 +19,8 @@ fn main() -> io::Result<()> {
     let dev = Device::with_path(path)?;
     let format = dev.format()?;
     let params = dev.params()?;
-    println!("Active format:\n{}", format);
-    println!("Active parameters:\n{}", params);
+    println!("Active format:\n{format}");
+    println!("Active parameters:\n{params}");
 
     // Setup a buffer stream and grab a frame, then print its data
     let mut stream = UserptrStream::with_buffers(&dev, Type::VideoCapture, buffer_count)?;
@@ -54,7 +54,7 @@ fn main() -> io::Result<()> {
 
     println!();
     println!("FPS: {}", count as f64 / start.elapsed().as_secs_f64());
-    println!("MB/s: {}", megabytes_ps);
+    println!("MB/s: {megabytes_ps}");
 
     Ok(())
 }

examples/stream_forward_mmap.rs

@@ -8,11 +8,11 @@ use v4l::video::{Capture, Output};
 
 fn main() -> io::Result<()> {
     let source = "/dev/video0";
-    println!("Using source device: {}\n", source);
+    println!("Using source device: {source}\n");
 
     // Determine which device to use
     let sink = "/dev/video1";
-    println!("Using sink device: {}\n", sink);
+    println!("Using sink device: {sink}\n");
 
     // Capture 4 frames by default
     let count = 4;
@@ -95,7 +95,7 @@ fn main() -> io::Result<()> {
 
     println!();
     println!("FPS: {}", count as f64 / start.elapsed().as_secs_f64());
-    println!("MB/s: {}", megabytes_ps);
+    println!("MB/s: {megabytes_ps}");
 
     Ok(())
 }

src/control.rs

@@ -112,10 +112,10 @@ impl fmt::Display for MenuItem {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             MenuItem::Name(name) => {
-                write!(f, "{}", name)?;
+                write!(f, "{name}")?;
             }
             MenuItem::Value(value) => {
-                write!(f, "{}", value)?;
+                write!(f, "{value}")?;
             }
         }
         Ok(())

src/format/fourcc.rs

@@ -42,7 +42,7 @@ impl fmt::Display for FourCC {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let string = str::from_utf8(&self.repr);
         if let Ok(string) = string {
-            write!(f, "{}", string)?;
+            write!(f, "{string}")?;
         }
         Ok(())
     }

src/frameinterval.rs

@@ -30,8 +30,8 @@ pub enum FrameIntervalEnum {
 impl fmt::Display for FrameIntervalEnum {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            FrameIntervalEnum::Discrete(val) => write!(f, "Discrete({})", val)?,
-            FrameIntervalEnum::Stepwise(val) => write!(f, "Stepwise({})", val)?,
+            FrameIntervalEnum::Discrete(val) => write!(f, "Discrete({val})")?,
+            FrameIntervalEnum::Stepwise(val) => write!(f, "Stepwise({val})")?,
         }
 
         Ok(())
@@ -56,7 +56,7 @@ impl TryFrom<v4l2_frmivalenum> for FrameIntervalEnum {
                         step: Fraction::from(desc.__bindgen_anon_1.stepwise.step),
                     })
                 }),
-                typ => Err(format!("Unknown frame size type: {}", typ)),
+                typ => Err(format!("Unknown frame size type: {typ}")),
             }
         }
     }

src/framesize.rs

@@ -52,8 +52,8 @@ impl FrameSizeEnum {
 impl fmt::Display for FrameSizeEnum {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            FrameSizeEnum::Discrete(val) => write!(f, "Discrete({})", val)?,
-            FrameSizeEnum::Stepwise(val) => write!(f, "Stepwise({})", val)?,
+            FrameSizeEnum::Discrete(val) => write!(f, "Discrete({val})")?,
+            FrameSizeEnum::Stepwise(val) => write!(f, "Stepwise({val})")?,
         }
 
         Ok(())
@@ -84,7 +84,7 @@ impl TryFrom<v4l2_frmsizeenum> for FrameSizeEnum {
                         step_height: desc.__bindgen_anon_1.stepwise.step_height,
                     })
                 }),
-                typ => Err(format!("Unknown frame size type: {}", typ)),
+                typ => Err(format!("Unknown frame size type: {typ}")),
             }
         }
     }

src/timestamp.rs

@@ -31,7 +31,7 @@ impl Timestamp {
 impl fmt::Display for Timestamp {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let floating: f64 = self.sec as f64 + self.usec as f64 / 1_000_000.0;
-        write!(f, "{} [s]", floating)
+        write!(f, "{floating} [s]")
     }
 }
 

src/v4l2/api.rs

@@ -47,7 +47,7 @@ mod detail {
             prot,
             flags,
             fd,
-            offset as i64,
+            offset,
         )
     }
     pub unsafe fn munmap(start: *mut std::os::raw::c_void, length: usize) -> std::os::raw::c_int {