Updates to dependencies and Rust edition 2024

Author: shssoichiro

Cargo.lock

@@ -1,8 +1,8 @@
 [package]
 name = "av1an-core"
 version = "0.5.2"
-rust-version = "1.88"
-edition = "2021"
+rust-version = "1.89"
+edition = "2024"
 description = """
 Cross-platform command-line AV1 / VP9 / HEVC / H264 encoding framework with per scene quality encoding [Core library]
 """
@@ -17,14 +17,14 @@ readme = "../README.md"
 [dependencies]
 anyhow = { workspace = true }
 arrayvec = "0.7.2"
-av-decoders = { version = "0.8.2", features = ["vapoursynth"] }
+av-decoders = { version = "0.9.1", features = ["vapoursynth"] }
 av-format = "0.7.0"
 av-ivf = "0.5.0"
-av-scenechange = { version = "0.21.1", default-features = false, features = [
+av-scenechange = { version = "0.23.0", default-features = false, features = [
     "asm",
     "vapoursynth",
 ] }
-av1-grain = { version = "0.2.5", default-features = false, features = [
+av1-grain = { version = "0.4.1", default-features = false, features = [
     "create",
 ] }
 cfg-if = "1.0.4"
@@ -43,7 +43,7 @@ plotters = { version = "0.3.1", default-features = false, features = [
     "svg_backend",
     "line_series",
 ] }
-rand = "0.9.2"
+rand = "0.10.0"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 simdutf8 = "0.1.3"
@@ -53,8 +53,8 @@ smallvec = { version = "1.15.1", default-features = false, features = [
     "union",
 ] }
 strsim = "0.11.0"
-strum = { version = "0.27.2", features = ["derive"] }
-sysinfo = "0.37.2"
+strum = { version = "0.28.0", features = ["derive"] }
+sysinfo = "0.38.4"
 textwrap = "0.16.0"
 thiserror = "2.0.18"
 tracing = { workspace = true }
@@ -78,6 +78,9 @@ tempfile = { workspace = true }
 [features]
 default = []
 
+[lints.rust]
+unsafe_op_in_unsafe_fn = "allow"
+
 [lints.clippy]
 # Performance
 clear_with_drain = "warn"

av1an-core/Cargo.toml

@@ -172,12 +172,17 @@ impl Broker<'_> {
                             }
 
                             while let Ok(mut chunk) = rx.recv() {
-                                if terminations_requested.load(Ordering::SeqCst) == 0 {
-                                    if let Err(e) = queue.encode_chunk(&mut chunk, worker_id, &terminations_requested, total_chunks) {
-                                            error!("[chunk {index}] {e}", index = chunk.index);
-                                        tx.send(()).expect("should send successfully");
-                                        return Err(());
-                                    }
+                                if terminations_requested.load(Ordering::SeqCst) == 0
+                                    && let Err(e) = queue.encode_chunk(
+                                        &mut chunk,
+                                        worker_id,
+                                        &terminations_requested,
+                                        total_chunks,
+                                    )
+                                {
+                                    error!("[chunk {index}] {e}", index = chunk.index);
+                                    tx.send(()).expect("should send successfully");
+                                    return Err(());
                                 }
                             }
                             Ok(())
@@ -249,12 +254,11 @@ impl Broker<'_> {
             }
 
             if chunk.target_quality.params_copied
-                && chunk.tq_cq.is_some()
                 && chunk.target_quality.probing_rate == 1
                 && self.project.args.ffmpeg_filter_args.is_empty()
                 && chunk.proxy.is_none()
+                && let Some(optimal_q) = chunk.tq_cq
             {
-                let optimal_q = chunk.tq_cq.expect("tq_cq is some");
                 let extension = match self.project.args.encoder {
                     crate::encoder::Encoder::x264 => "264",
                     crate::encoder::Encoder::x265 => "hevc",

av1an-core/src/broker.rs

@@ -7,7 +7,13 @@ use av1_grain::{generate_photon_noise_params, write_grain_table, NoiseGenArgs};
 use serde::{Deserialize, Serialize};
 use tracing::debug;
 
-use crate::{encoder::Encoder, settings::insert_noise_table_params, Input, TargetQuality};
+use crate::{
+    encoder::Encoder,
+    settings::insert_noise_table_params,
+    ColorRange,
+    Input,
+    TargetQuality,
+};
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Chunk {
@@ -56,6 +62,7 @@ impl Chunk {
         &mut self,
         photon_noise: Option<u8>,
         chroma_noise: bool,
+        color_range: Option<ColorRange>,
     ) -> anyhow::Result<()> {
         if let Some(strength) = photon_noise {
             let iso_setting = u32::from(strength) * 100;
@@ -78,6 +85,7 @@ impl Chunk {
                     height,
                     transfer_function,
                     chroma_grain: chroma_noise,
+                    full_range: matches!(color_range, Some(ColorRange::Full)),
                     random_seed: None,
                 });
                 write_grain_table(&grain_table, &[params])?;

av1an-core/src/chunk/mod.rs

@@ -159,7 +159,7 @@ fn apply_photon_noise_args_with_noise() -> anyhow::Result<()> {
         ignore_frame_mismatch: false,
     };
 
-    ch.apply_photon_noise_args(Some(8), true)?;
+    ch.apply_photon_noise_args(Some(8), true, None)?;
     assert!(ch.video_params.iter().any(|p| p.contains("fgs-table")));
     Ok(())
 }
@@ -197,7 +197,7 @@ fn apply_photon_noise_args_no_noise() -> anyhow::Result<()> {
         ignore_frame_mismatch: false,
     };
 
-    ch.apply_photon_noise_args(None, false)?;
+    ch.apply_photon_noise_args(None, false, None)?;
     assert!(!ch.video_params.iter().any(|p| p.contains("fgs-table")));
     Ok(())
 }
@@ -235,6 +235,6 @@ fn apply_photon_noise_args_unsupported_encoder() -> anyhow::Result<()> {
         ignore_frame_mismatch: false,
     };
 
-    assert!(ch.apply_photon_noise_args(Some(8), true).is_err());
+    assert!(ch.apply_photon_noise_args(Some(8), true, None).is_err());
     Ok(())
 }

av1an-core/src/chunk/tests.rs

@@ -238,8 +238,8 @@ impl Av1anContext {
         {
             self.vs_script = Some(cache_vs_input(&self.args.input)?);
         }
-        if let Some(proxy) = &self.args.proxy {
-            if proxy.is_vapoursynth()
+        if let Some(proxy) = &self.args.proxy
+            && (proxy.is_vapoursynth()
                 || (proxy.is_video()
                     && matches!(
                         self.args.chunk_method,
@@ -248,10 +248,9 @@ impl Av1anContext {
                             | ChunkMethod::DGDECNV
                             | ChunkMethod::BESTSOURCE
                     )
-                    && !self.args.resume)
-            {
-                self.vs_proxy_script = Some(cache_vs_input(proxy)?);
-            }
+                    && !self.args.resume))
+        {
+            self.vs_proxy_script = Some(cache_vs_input(proxy)?);
         }
 
         let clip_info = self.args.input.clip_info()?;
@@ -488,10 +487,10 @@ impl Av1anContext {
                      {temp}",
                     temp = self.args.temp
                 );
-            } else if !self.args.keep {
-                if let Err(e) = fs::remove_dir_all(&self.args.temp) {
-                    warn!("Failed to delete temp directory: {e}");
-                }
+            } else if !self.args.keep
+                && let Err(e) = fs::remove_dir_all(&self.args.temp)
+            {
+                warn!("Failed to delete temp directory: {e}");
             }
 
             Ok(())
@@ -749,17 +748,16 @@ impl Av1anContext {
                         enc_stderr.push_str(line);
                         enc_stderr.push('\n');
 
-                        if current_pass == chunk.passes {
-                            if let Some(new) = chunk.encoder.parse_encoded_frames(line) {
-                                if new > frame {
-                                    if self.args.verbosity == Verbosity::Normal {
-                                        inc_bar(new - frame);
-                                    } else if self.args.verbosity == Verbosity::Verbose {
-                                        inc_mp_bar(new - frame);
-                                    }
-                                    frame = new;
-                                }
+                        if current_pass == chunk.passes
+                            && let Some(new) = chunk.encoder.parse_encoded_frames(line)
+                            && new > frame
+                        {
+                            if self.args.verbosity == Verbosity::Normal {
+                                inc_bar(new - frame);
+                            } else if self.args.verbosity == Verbosity::Verbose {
+                                inc_mp_bar(new - frame);
                             }
+                            frame = new;
                         }
                     }
 
@@ -993,9 +991,11 @@ impl Av1anContext {
             tq_cq: None,
             ignore_frame_mismatch: self.args.ignore_frame_mismatch,
         };
+        let color_range = self.args.input.clip_info()?.color_range;
         chunk.apply_photon_noise_args(
             overrides.map_or(self.args.photon_noise, |ovr| ovr.photon_noise),
             self.args.chroma_noise,
+            color_range,
         )?;
         if chunk.target_quality.target.is_some() {
             chunk.tq_cq = Some(chunk.target_quality.per_shot_target_quality(
@@ -1104,6 +1104,7 @@ impl Av1anContext {
             tq_cq: None,
             ignore_frame_mismatch: self.args.ignore_frame_mismatch,
         };
+        let color_range = self.args.input.clip_info()?.color_range;
         chunk.apply_photon_noise_args(
             scene
                 .zone_overrides
@@ -1113,6 +1114,7 @@ impl Av1anContext {
                 .zone_overrides
                 .as_ref()
                 .map_or(self.args.chroma_noise, |ovr| ovr.chroma_noise),
+            color_range,
         )?;
         Ok(chunk)
     }
@@ -1343,9 +1345,11 @@ impl Av1anContext {
             tq_cq: None,
             ignore_frame_mismatch: self.args.ignore_frame_mismatch,
         };
+        let color_range = self.args.input.clip_info()?.color_range;
         chunk.apply_photon_noise_args(
             overrides.map_or(self.args.photon_noise, |ovr| ovr.photon_noise),
             self.args.chroma_noise,
+            color_range,
         )?;
         Ok(chunk)
     }

av1an-core/src/context.rs

@@ -12,7 +12,7 @@ use serde::{Deserialize, Serialize};
 use tracing::warn;
 use vapoursynth::format::PresetFormat;
 
-use crate::{into_array, into_vec, ClipInfo, InputPixelFormat};
+use crate::{into_array, into_vec, ClipInfo, ColorRange, InputPixelFormat};
 
 #[inline]
 pub fn compose_ffmpeg_pipe<S: Into<String>>(
@@ -47,6 +47,7 @@ struct FfProbeStreamInfo {
     pub width:          u32,
     pub height:         u32,
     pub pix_fmt:        String,
+    pub color_range:    Option<String>,
     pub color_transfer: Option<String>,
     pub avg_frame_rate: String,
     pub nb_frames:      Option<String>,
@@ -62,7 +63,7 @@ pub fn get_clip_info(source: &Path) -> anyhow::Result<ClipInfo> {
         .arg("-print_format")
         .arg("json")
         .arg("-show_entries")
-        .arg("stream=width,height,pix_fmt,avg_frame_rate,nb_frames,color_transfer")
+        .arg("stream=width,height,pix_fmt,avg_frame_rate,nb_frames,color_range,color_transfer")
         .arg(source)
         .output()?
         .stdout;
@@ -71,24 +72,49 @@ pub fn get_clip_info(source: &Path) -> anyhow::Result<ClipInfo> {
         .streams
         .first()
         .ok_or_else(|| anyhow::anyhow!("no video streams found in source file"))?;
+    let format = FFPixelFormat::from_str(&stream_info.pix_fmt)?;
+    let color_range = stream_info.color_range.as_deref().map_or_else(
+        || infer_color_range_from_pix_fmt(format),
+        parse_ffprobe_color_range,
+    );
 
     Ok(ClipInfo {
-        format_info:              InputPixelFormat::FFmpeg {
-            format: FFPixelFormat::from_str(&stream_info.pix_fmt)?,
+        format_info: InputPixelFormat::FFmpeg {
+            format,
         },
-        frame_rate:               parse_frame_rate(&stream_info.avg_frame_rate)?,
-        resolution:               (stream_info.width, stream_info.height),
+        frame_rate: parse_frame_rate(&stream_info.avg_frame_rate)?,
+        resolution: (stream_info.width, stream_info.height),
+        color_range,
         transfer_characteristics: match stream_info.color_transfer.as_deref() {
             Some("smpte2084") => av1_grain::TransferFunction::SMPTE2084,
             _ => av1_grain::TransferFunction::BT1886,
         },
-        num_frames:               match stream_info.nb_frames.as_deref().map(str::parse) {
+        num_frames: match stream_info.nb_frames.as_deref().map(str::parse) {
             Some(Ok(nb_frames)) => nb_frames,
             _ => get_num_frames(source)?,
         },
     })
 }
 
+#[inline]
+const fn infer_color_range_from_pix_fmt(pix_fmt: FFPixelFormat) -> Option<ColorRange> {
+    match pix_fmt {
+        FFPixelFormat::YUVJ420P | FFPixelFormat::YUVJ422P | FFPixelFormat::YUVJ444P => {
+            Some(ColorRange::Full)
+        },
+        _ => None,
+    }
+}
+
+#[inline]
+fn parse_ffprobe_color_range(color_range: &str) -> Option<ColorRange> {
+    match color_range {
+        "pc" | "jpeg" | "full" => Some(ColorRange::Full),
+        "tv" | "mpeg" | "limited" => Some(ColorRange::Limited),
+        _ => None,
+    }
+}
+
 /// Get frame count using FFmpeg
 #[inline]
 pub fn get_num_frames(source: &Path) -> anyhow::Result<usize> {
@@ -461,3 +487,39 @@ impl FromStr for FFPixelFormat {
         })
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parse_ffprobe_color_range_aliases() {
+        assert_eq!(parse_ffprobe_color_range("pc"), Some(ColorRange::Full));
+        assert_eq!(parse_ffprobe_color_range("jpeg"), Some(ColorRange::Full));
+        assert_eq!(parse_ffprobe_color_range("full"), Some(ColorRange::Full));
+        assert_eq!(parse_ffprobe_color_range("tv"), Some(ColorRange::Limited));
+        assert_eq!(parse_ffprobe_color_range("mpeg"), Some(ColorRange::Limited));
+        assert_eq!(
+            parse_ffprobe_color_range("limited"),
+            Some(ColorRange::Limited)
+        );
+        assert_eq!(parse_ffprobe_color_range("unknown"), None);
+    }
+
+    #[test]
+    fn infer_color_range_from_legacy_jpeg_formats() {
+        assert_eq!(
+            infer_color_range_from_pix_fmt(FFPixelFormat::YUVJ420P),
+            Some(ColorRange::Full)
+        );
+        assert_eq!(
+            infer_color_range_from_pix_fmt(FFPixelFormat::YUVJ422P),
+            Some(ColorRange::Full)
+        );
+        assert_eq!(
+            infer_color_range_from_pix_fmt(FFPixelFormat::YUVJ444P),
+            Some(ColorRange::Full)
+        );
+        assert_eq!(infer_color_range_from_pix_fmt(FFPixelFormat::YUV420P), None);
+    }
+}