Run cargo clippy --fix

Author: Charlie-Zheng

openh264-sys2/build.rs

@@ -75,7 +75,7 @@ impl Target {
             "unix" => TargetFamily::Unix,
             "windows" => TargetFamily::Windows,
             "wasm" => TargetFamily::Wasm,
-            _ => panic!("Unknown target family: {}", family),
+            _ => panic!("Unknown target family: {family}"),
         };
         let os = match os.as_str() {
             "windows" => TargetOs::Windows,
@@ -87,7 +87,7 @@ impl Target {
             "dragonfly" => TargetOs::Dragonfly,
             "openbsd" => TargetOs::Openbsd,
             "netbsd" => TargetOs::Netbsd,
-            _ => panic!("Unknown target os: {}", os),
+            _ => panic!("Unknown target os: {os}"),
         };
         let arch = match arch.as_str() {
             "x86" => TargetArch::X86,
@@ -99,15 +99,15 @@ impl Target {
             "powerpc64" => TargetArch::Powerpc64,
             "s390x" => TargetArch::S390x,
             "wasm32" => TargetArch::Wasm32,
-            _ => panic!("Unknown target arch: {}", arch),
+            _ => panic!("Unknown target arch: {arch}"),
         };
         let env = match env.as_str() {
             "" => TargetEnv::NoEnv,
             "gnu" => TargetEnv::Gnu,
             "msvc" => TargetEnv::Msvc,
             "musl" => TargetEnv::Musl,
             "sgx" => TargetEnv::Sgx,
-            _ => panic!("Unknown target env: {}", env),
+            _ => panic!("Unknown target env: {env}"),
         };
 
         Self { family, os, arch, env }
@@ -225,8 +225,7 @@ fn try_compile_nasm(cc_build_command: &mut Build, root: &str) {
 
     let Some(config) = NasmConfiguration::find(target) else {
         println!(
-            "No NASM configuration found for target, not using any assembly.\nTarget: {:?}",
-            target
+            "No NASM configuration found for target, not using any assembly.\nTarget: {target:?}"
         );
         return;
     };
@@ -295,9 +294,9 @@ fn compile_and_add_openh264_static_lib(name: &str, root: &str, includes: &[&str]
         cc_build.include(include);
     }
 
-    cc_build.compile(format!("openh264_{}", name).as_str());
+    cc_build.compile(format!("openh264_{name}").as_str());
 
-    println!("cargo:rustc-link-lib=static=openh264_{}", name);
+    println!("cargo:rustc-link-lib=static=openh264_{name}");
 }
 
 fn main() {

openh264-sys2/src/error.rs

@@ -33,7 +33,7 @@ impl Display for Error {
             #[cfg(feature = "libloading")]
             Error::LibLoading(x) => x.fmt(f),
             Error::Io(x) => x.fmt(f),
-            Error::InvalidHash(x) => format!("Invalid hash: {}", x).fmt(f),
+            Error::InvalidHash(x) => format!("Invalid hash: {x}").fmt(f),
             _ => "".fmt(f),
         }
     }

openh264/src/decoder.rs

@@ -295,7 +295,7 @@ impl Decoder {
 
         #[rustfmt::skip]
         unsafe {
-            raw_api.initialize(&config.params).ok()?;
+            raw_api.initialize(&raw const config.params).ok()?;
             raw_api.set_option(DECODER_OPTION_TRACE_LEVEL, addr_of_mut!(config.debug).cast()).ok()?;
             raw_api.set_option(DECODER_OPTION_NUM_OF_THREADS, addr_of_mut!(config.num_threads).cast()).ok()?;
             raw_api.set_option(DECODER_OPTION_ERROR_CON_IDC, addr_of_mut!(config.error_concealment).cast()).ok()?;
@@ -347,7 +347,7 @@ impl Decoder {
                     packet.as_ptr(),
                     packet.len() as i32,
                     from_mut(&mut dst).cast(),
-                    &mut buffer_info,
+                    &raw mut buffer_info,
                 )
                 .ok()?;
         }
@@ -387,7 +387,7 @@ impl Decoder {
 
             if let Some(image) = unsafe { DecodedYUV::from_raw_open264_ptrs(&dst, &buffer_info) } {
                 frames.push(image);
-            };
+            }
         }
 
         Ok(frames)
@@ -419,7 +419,7 @@ impl Decoder {
     /// # Ok(())
     /// # }
     /// ```
-    pub unsafe fn raw_api(&mut self) -> &mut DecoderRawAPI {
+    pub const unsafe fn raw_api(&mut self) -> &mut DecoderRawAPI {
         &mut self.raw_api
     }
 
@@ -444,7 +444,7 @@ impl Decoder {
         let mut buffer_info = SBufferInfo::default();
 
         unsafe {
-            self.raw_api().flush_frame(from_mut(&mut dst).cast(), &mut buffer_info).ok()?;
+            self.raw_api().flush_frame(from_mut(&mut dst).cast(), &raw mut buffer_info).ok()?;
             Ok((dst, buffer_info))
         }
     }

openh264/src/encoder.rs

@@ -696,7 +696,7 @@ impl Encoder {
         };
 
         unsafe {
-            self.raw_api.encode_frame(&source, &mut self.bit_stream_info).ok()?;
+            self.raw_api.encode_frame(&raw const source, &raw mut self.bit_stream_info).ok()?;
         }
 
         Ok(EncodedBitStream {
@@ -721,7 +721,7 @@ impl Encoder {
 
         let mut params = SEncParamExt::default();
 
-        unsafe { self.raw_api.get_default_params(&mut params).ok()? };
+        unsafe { self.raw_api.get_default_params(&raw mut params).ok()? };
 
         params.iPicWidth = width as c_int; // If we do .into() instead, could this fail to compile on some platforms?
         params.iPicHeight = height as c_int; // If we do .into() instead, could this fail to compile on some platforms?
@@ -776,7 +776,7 @@ impl Encoder {
         unsafe {
             if self.previous_dimensions.is_none() {
                 // First time we call initialize_ext
-                self.raw_api.initialize_ext(&params).ok()?;
+                self.raw_api.initialize_ext(&raw const params).ok()?;
                 self.raw_api.set_option(ENCODER_OPTION_TRACE_LEVEL, addr_of_mut!(self.config.debug).cast()).ok()?;
                 self.raw_api.set_option(ENCODER_OPTION_DATAFORMAT, addr_of_mut!(self.config.data_format).cast()).ok()?;
             } else {
@@ -807,7 +807,7 @@ impl Encoder {
     /// # Safety
     ///
     /// You must not set parameters the encoder relies on, we recommend checking the source.
-    pub unsafe fn raw_api(&mut self) -> &mut EncoderRawAPI {
+    pub const unsafe fn raw_api(&mut self) -> &mut EncoderRawAPI {
         &mut self.raw_api
     }
 }
@@ -893,7 +893,7 @@ impl<'a> EncodedBitStream<'a> {
                         return Err(Error::msg(&format!("failed to write: {e}")));
                     }
                     _ => {}
-                };
+                }
             }
         }
         Ok(())

openh264/src/formats/yuv2rgb.rs

@@ -20,11 +20,11 @@ macro_rules! f32x8_from_slice_with_blocksize {
     }};
 }
 
-pub(crate) const Y_MUL: f32 = 255.0 / 219.0;
-pub(crate) const RV_MUL: f32 = 255.0 / 224.0 * 1.402;
-pub(crate) const GV_MUL: f32 = -255.0 / 224.0 * 1.402 * 0.299 / 0.687;
-pub(crate) const GU_MUL: f32 = -255.0 / 224.0 * 1.772 * 0.114 / 0.587;
-pub(crate) const BU_MUL: f32 = 255.0 / 224.0 * 1.772;
+const Y_MUL: f32 = 255.0 / 219.0;
+const RV_MUL: f32 = 255.0 / 224.0 * 1.402;
+const GV_MUL: f32 = -255.0 / 224.0 * 1.402 * 0.299 / 0.687;
+const GU_MUL: f32 = -255.0 / 224.0 * 1.772 * 0.114 / 0.587;
+const BU_MUL: f32 = 255.0 / 224.0 * 1.772;
 
 /// Write RGB8 data from YUV420 using scalar (non SIMD) math.
 pub fn write_rgb8_scalar(
@@ -46,9 +46,9 @@ pub fn write_rgb8_scalar(
 
             // Convert limited range YUV to RGB
             // https://en.wikipedia.org/wiki/YCbCr#ITU-R_BT.601_conversion
-            let y_mul = Y_MUL * (y_plane[base_y] as f32 - 16.0);
-            let u = u_plane[base_u] as f32 - 128.0;
-            let v = v_plane[base_v] as f32 - 128.0;
+            let y_mul = Y_MUL * (f32::from(y_plane[base_y]) - 16.0);
+            let u = f32::from(u_plane[base_u]) - 128.0;
+            let v = f32::from(v_plane[base_v]) - 128.0;
 
             rgb_pixel[0] = RV_MUL.mul_add(v, y_mul) as u8;
             rgb_pixel[1] = GV_MUL.mul_add(v, GU_MUL.mul_add(u, y_mul)) as u8;
@@ -188,9 +188,9 @@ pub fn write_rgba8_scalar(
 
             // Convert limited range YUV to RGB
             // https://en.wikipedia.org/wiki/YCbCr#ITU-R_BT.601_conversion
-            let y_mul = Y_MUL * (y_plane[base_y] as f32 - 16.0);
-            let u = u_plane[base_u] as f32 - 128.0;
-            let v = v_plane[base_v] as f32 - 128.0;
+            let y_mul = Y_MUL * (f32::from(y_plane[base_y]) - 16.0);
+            let u = f32::from(u_plane[base_u]) - 128.0;
+            let v = f32::from(v_plane[base_v]) - 128.0;
 
             rgb_pixel[0] = RV_MUL.mul_add(v, y_mul) as u8;
             rgb_pixel[1] = GV_MUL.mul_add(v, GU_MUL.mul_add(u, y_mul)) as u8;