Merge branch 'master' into yuv2rgb_perf

Author: jnnks

.gitattributes

@@ -4,6 +4,7 @@
 *.jpg filter=lfs diff=lfs merge=lfs -text
 *.jpeg filter=lfs diff=lfs merge=lfs -text
 *.dll filter=lfs diff=lfs merge=lfs -text
+*.bmp filter=lfs diff=lfs merge=lfs -text
 *.cpp linguist-detectable=false
 *.h linguist-detectable=false
 *.asm linguist-detectable=false

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 }
@@ -224,10 +224,7 @@ fn try_compile_nasm(cc_build_command: &mut Build, root: &str) {
     let target = Target::from_env();
 
     let Some(config) = NasmConfiguration::find(target) else {
-        println!(
-            "No NASM configuration found for target, not using any assembly.\nTarget: {:?}",
-            target
-        );
+        println!("No NASM configuration found for target, not using any assembly.\nTarget: {target:?}");
         return;
     };
 
@@ -295,9 +292,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

@@ -49,8 +49,8 @@
 //! ```
 
 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::yuv2rgb::{write_rgb8_f32x8_par, write_rgba8_f32x8, write_rgba8_scalar};
+// use crate::formats::yuv2rgb::{write_rgb8_f32x8, write_rgb8_f32x8_par, write_rgb8_scalar, write_rgb8_scalar, write_rgba8_f32x8, write_rgba8_scalar_par};
 use crate::formats::{YUVSlices, YUVSource};
 use crate::{Error, OpenH264API, Timestamp};
 use openh264_sys2::{
@@ -296,7 +296,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()?;
@@ -348,7 +348,7 @@ impl Decoder {
                     packet.as_ptr(),
                     packet.len() as i32,
                     from_mut(&mut dst).cast(),
-                    &mut buffer_info,
+                    &raw mut buffer_info,
                 )
                 .ok()?;
         }
@@ -388,7 +388,7 @@ impl Decoder {
 
             if let Some(image) = unsafe { DecodedYUV::from_raw_open264_ptrs(&dst, &buffer_info) } {
                 frames.push(image);
-            };
+            }
         }
 
         Ok(frames)
@@ -420,7 +420,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
     }
 
@@ -445,7 +445,9 @@ 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))
         }
     }
@@ -604,25 +606,13 @@ impl DecodedYUV<'_> {
             wanted,
             target.len()
         );
-
-        for y in 0..dim.1 {
-            for x in 0..dim.0 {
-                let base_tgt = (y * dim.0 + x) * 4;
-                let base_y = y * strides.0 + x;
-                let base_u = (y / 2 * strides.1) + (x / 2);
-                let base_v = (y / 2 * strides.2) + (x / 2);
-
-                let rgb_pixel = &mut target[base_tgt..base_tgt + 4];
-
-                let y: f32 = self.y[base_y].into();
-                let u: f32 = self.u[base_u].into();
-                let v: f32 = self.v[base_v].into();
-
-                rgb_pixel[0] = 1.402f32.mul_add(v - 128.0, y) as u8;
-                rgb_pixel[1] = 0.714f32.mul_add(-(v - 128.0), 0.344f32.mul_add(-(u - 128.0), y)) as u8;
-                rgb_pixel[2] = 1.772f32.mul_add(u - 128.0, y) as u8;
-                rgb_pixel[3] = 255;
-            }
+        // for f32x8 math, image needs to:
+        //   - have a width divisible by 8
+        //   - have at least two rows
+        if dim.0 % 8 == 0 && dim.1 >= 2 {
+            write_rgba8_f32x8(self.y, self.u, self.v, dim, strides, target);
+        } else {
+            write_rgba8_scalar(self.y, self.u, self.v, dim, strides, target);
         }
     }
 }

openh264/src/encoder.rs

@@ -696,7 +696,9 @@ 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 +723,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 +778,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 +809,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 +895,7 @@ impl<'a> EncodedBitStream<'a> {
                         return Err(Error::msg(&format!("failed to write: {e}")));
                     }
                     _ => {}
-                };
+                }
             }
         }
         Ok(())