play,check: Update app dependencies.

Update to latest versions with a MSRV <= 1.85.

Author: pdeljanov

symphonia-check/Cargo.toml

@@ -12,7 +12,7 @@ rust-version.workspace = true
 version.workspace = true
 
 [dependencies]
-clap = "3.1.0"
+clap = "4.6.0"
 log = { workspace = true, features = ["release_max_level_info"] }
-pretty_env_logger = "0.4"
+pretty_env_logger = "0.5"
 symphonia = { version = "0.6.0-alpha.1", path = "../symphonia", features = ["all"] }

symphonia-check/src/main.rs

@@ -13,7 +13,7 @@
 #![allow(clippy::needless_update)]
 
 use std::fs::File;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 use std::process::{Command, Stdio};
 
 use symphonia::core::audio::GenericAudioBufferRef;
@@ -25,7 +25,7 @@ use symphonia::core::formats::{FormatOptions, FormatReader, TrackType};
 use symphonia::core::io::{MediaSourceStream, ReadOnlySource};
 use symphonia::core::meta::MetadataOptions;
 
-use clap::Arg;
+use clap::{Arg, ArgAction};
 use log::warn;
 
 /// The absolute maximum allowable sample delta. Around 2^-17 (-102.4dB).
@@ -66,7 +66,7 @@ struct TestResult {
     ref_unchecked_samples: u64,
 }
 
-fn build_ffmpeg_command(path: &str, gapless: bool) -> Command {
+fn build_ffmpeg_command(path: &Path, gapless: bool) -> Command {
     let mut cmd = Command::new("ffmpeg");
 
     // Gapless argument must come before everything else.
@@ -91,15 +91,15 @@ fn build_ffmpeg_command(path: &str, gapless: bool) -> Command {
     cmd
 }
 
-fn build_flac_command(path: &str) -> Command {
+fn build_flac_command(path: &Path) -> Command {
     let mut cmd = Command::new("flac");
 
     cmd.arg("--stdout").arg("-d").arg(path).stdout(Stdio::piped()).stderr(Stdio::null());
 
     cmd
 }
 
-fn build_mpg123_command(path: &str, gapless: bool) -> Command {
+fn build_mpg123_command(path: &Path, gapless: bool) -> Command {
     let mut cmd = Command::new("mpg123");
 
     if !gapless {
@@ -111,7 +111,7 @@ fn build_mpg123_command(path: &str, gapless: bool) -> Command {
     cmd
 }
 
-fn build_oggdec_command(path: &str) -> Command {
+fn build_oggdec_command(path: &Path) -> Command {
     let mut cmd = Command::new("oggdec");
     cmd.arg(path).arg("-o").arg("-").stdout(Stdio::piped()).stderr(Stdio::null());
     cmd
@@ -122,7 +122,7 @@ struct RefProcess {
 }
 
 impl RefProcess {
-    fn try_spawn(decoder: RefDecoder, gapless: bool, path: &str) -> Result<RefProcess> {
+    fn try_spawn(decoder: RefDecoder, gapless: bool, path: &Path) -> Result<RefProcess> {
         let mut cmd = match decoder {
             RefDecoder::Ffmpeg => build_ffmpeg_command(path, gapless),
             RefDecoder::Flac => build_flac_command(path),
@@ -343,7 +343,7 @@ fn run_check(
     Ok(())
 }
 
-fn run_test(path: &str, opts: &TestOptions, result: &mut TestResult) -> Result<()> {
+fn run_test(path: &Path, opts: &TestOptions, result: &mut TestResult) -> Result<()> {
     // 1. Start the reference decoder process.
     let mut ref_process = RefProcess::try_spawn(opts.ref_decoder, opts.gapless, path)?;
 
@@ -354,7 +354,7 @@ fn run_test(path: &str, opts: &TestOptions, result: &mut TestResult) -> Result<(
     let mut ref_inst = DecoderInstance::try_open(ref_mss, Default::default(), Default::default())?;
 
     // 3. Instantiate a Symphonia decoder for the test target.
-    let tgt_ms = Box::new(File::open(Path::new(path))?);
+    let tgt_ms = Box::new(File::open(path)?);
     let tgt_mss = MediaSourceStream::new(tgt_ms, Default::default());
 
     let tgt_fmt_opts = Default::default();
@@ -373,34 +373,57 @@ fn main() {
         .version("1.0")
         .author("Philip Deljanov <philip.deljanov@gmail.com>")
         .about("Check Symphonia output with a reference decoding")
-        .arg(Arg::new("samples").long("samples").help("Print failures per sample"))
+        .arg(
+            Arg::new("samples")
+                .long("samples")
+                .action(ArgAction::SetTrue)
+                .help("Print failures per sample"),
+        )
         .arg(
             Arg::new("stop-after-fail")
                 .long("first-fail")
                 .short('f')
+                .action(ArgAction::SetTrue)
                 .help("Stop testing after the first failed packet"),
         )
-        .arg(Arg::new("quiet").long("quiet").short('q').help("Only print test results"))
+        .arg(
+            Arg::new("quiet")
+                .long("quiet")
+                .short('q')
+                .action(ArgAction::SetTrue)
+                .help("Only print test results"),
+        )
         .arg(
             Arg::new("keep-going")
                 .long("keep-going")
+                .action(ArgAction::SetTrue)
                 .help("Continue after a decode error (may cause many failures)"),
         )
         .arg(
             Arg::new("decoder")
                 .long("ref")
-                .takes_value(true)
-                .possible_values(["ffmpeg", "flac", "mpg123", "oggdec"])
+                .value_parser(["ffmpeg", "flac", "mpg123", "oggdec"])
                 .default_value("ffmpeg")
                 .help("Specify a particular decoder to be used as the reference"),
         )
-        .arg(Arg::new("no-gapless").long("no-gapless").help("Disable gapless decoding"))
-        .arg(Arg::new("INPUT").help("The input file path").required(true).index(1))
+        .arg(
+            Arg::new("no-gapless")
+                .long("no-gapless")
+                .action(ArgAction::SetTrue)
+                .help("Disable gapless decoding"),
+        )
+        .arg(
+            Arg::new("INPUT")
+                .help("The input file path")
+                .value_parser(clap::value_parser!(PathBuf))
+                .required(true)
+                .index(1),
+        )
         .get_matches();
 
-    let path = matches.value_of("INPUT").unwrap();
+    let path = matches.get_one::<PathBuf>("INPUT").expect("path is a required argument");
 
-    let ref_decoder = match matches.value_of("decoder").unwrap() {
+    let ref_decoder = match matches.get_one("decoder").copied().unwrap() {
         "ffmpeg" => RefDecoder::Ffmpeg,
         "flac" => RefDecoder::Flac,
         "mpg123" => RefDecoder::Mpg123,
@@ -414,17 +437,17 @@ fn main() {
 
     let opts = TestOptions {
         ref_decoder,
-        is_per_sample: matches.is_present("samples"),
-        is_quiet: matches.is_present("quiet"),
-        stop_after_fail: matches.is_present("stop-after-fail"),
-        keep_going: matches.is_present("keep-going"),
-        gapless: !matches.is_present("no-gapless"),
+        is_per_sample: matches.get_flag("samples"),
+        is_quiet: matches.get_flag("quiet"),
+        stop_after_fail: matches.get_flag("stop-after-fail"),
+        keep_going: matches.get_flag("keep-going"),
+        gapless: !matches.get_flag("no-gapless"),
         ..Default::default()
     };
 
     let mut res: TestResult = Default::default();
 
-    println!("Input Path: {path}");
+    println!("Input Path: {}", path.to_string_lossy());
     println!();
 
     if let Err(err) = run_test(path, &opts, &mut res) {

symphonia-core/Cargo.toml

@@ -46,6 +46,6 @@ optional = true
 default-features = false
 
 [dev-dependencies.rand]
-version = "0.9.2"
-features = ["small_rng"]
+version = "0.10.0"
+
 default-features = false

symphonia-core/src/io/bit.rs

@@ -1382,7 +1382,7 @@ impl FiniteBitStream for BitReaderRtl<'_> {
 
 #[cfg(test)]
 mod tests {
-    use rand::{RngCore, SeedableRng};
+    use rand::{Rng, SeedableRng};
 
     use super::vlc::{BitOrder, Codebook, CodebookBuilder, Entry8x8};
     use super::{BitReaderLtr, ReadBitsLtr};

symphonia-play/Cargo.toml

@@ -20,18 +20,18 @@ exp-subtitle-codecs = ["symphonia/exp-subtitle-codecs"]
 default = ["exp-subtitle-codecs", "exp-video-codecs"]
 
 [dependencies]
-clap = "3.1.0"
+clap = "4.6.0"
 lazy_static = { workspace = true }
 log = { workspace = true, features = ["release_max_level_info"] }
-pretty_env_logger = "0.4"
+pretty_env_logger = "0.5"
 symphonia = { version = "0.6.0-alpha.1", path = "../symphonia", features = ["all"] }
 
 [target.'cfg(target_os = "linux")'.dependencies]
 libpulse-binding = "2.5.0"
 libpulse-simple-binding = "2.5.0"
 
 [target.'cfg(not(target_os = "linux"))'.dependencies]
-cpal = "0.13.3"
-rb = "0.3.2"
+cpal = "0.17.3"
+rb = "0.4.1"
 rubato = "0.14.1"
 smallvec = { workspace = true }

symphonia-play/src/main.rs

@@ -26,7 +26,7 @@ use symphonia::core::io::{MediaSource, MediaSourceStream, ReadOnlySource};
 use symphonia::core::meta::{MetadataOptions, Visual};
 use symphonia::core::units::{Duration, Time, Timestamp};
 
-use clap::{Arg, ArgMatches};
+use clap::{Arg, ArgAction, ArgMatches};
 use log::{error, info, warn};
 
 mod output;
@@ -55,7 +55,7 @@ fn main() {
                 .value_name("TIME")
                 .value_parser(clap::value_parser!(f64))
                 .help("Seek to the time in seconds")
-                .conflicts_with_all(&[
+                .conflicts_with_all([
                     "seek-ts",
                     "decode-only",
                     "probe-only",
@@ -71,13 +71,7 @@ fn main() {
                 .value_parser(clap::value_parser!(i64))
                 .allow_hyphen_values(true)
                 .help("Seek to the timestamp in timebase units")
-                .conflicts_with_all(&[
-                    "seek",
-                    "decode-only",
-                    "probe-only",
-                    "verify",
-                    "verify-only",
-                ]),
+                .conflicts_with_all(["seek", "decode-only", "probe-only", "verify", "verify-only"]),
         )
         .arg(
             Arg::new("track")
@@ -90,34 +84,47 @@ fn main() {
         .arg(
             Arg::new("decode-only")
                 .long("decode-only")
+                .action(ArgAction::SetTrue)
                 .help("Decode, but do not play the audio")
-                .conflicts_with_all(&["probe-only", "verify-only", "verify"]),
+                .conflicts_with_all(["probe-only", "verify-only", "verify"]),
         )
         .arg(
             Arg::new("probe-only")
                 .long("probe-only")
+                .action(ArgAction::SetTrue)
                 .help("Only probe the input for metadata")
-                .conflicts_with_all(&["decode-only", "verify-only"]),
+                .conflicts_with_all(["decode-only", "verify-only"]),
         )
         .arg(
             Arg::new("verify-only")
                 .long("verify-only")
+                .action(ArgAction::SetTrue)
                 .help("Verify the decoded audio is valid, but do not play the audio")
-                .conflicts_with_all(&["verify"]),
+                .conflicts_with_all(["verify"]),
         )
         .arg(
             Arg::new("verify")
                 .long("verify")
                 .short('v')
+                .action(ArgAction::SetTrue)
                 .help("Verify the decoded audio is valid during playback"),
         )
-        .arg(Arg::new("no-progress").long("no-progress").help("Do not display playback progress"))
         .arg(
-            Arg::new("no-gapless").long("no-gapless").help("Disable gapless decoding and playback"),
+            Arg::new("no-progress")
+                .long("no-progress")
+                .action(ArgAction::SetTrue)
+                .help("Do not display playback progress"),
+        )
+        .arg(
+            Arg::new("no-gapless")
+                .long("no-gapless")
+                .action(ArgAction::SetTrue)
+                .help("Disable gapless decoding and playback"),
         )
         .arg(
             Arg::new("dump-visuals")
                 .long("dump-visuals")
+                .action(ArgAction::SetTrue)
                 .help("Dump all visuals to the current working directory"),
         )
         .arg(
@@ -177,7 +184,7 @@ fn run(args: &ArgMatches) -> Result<i32> {
     match symphonia::default::get_probe().probe(&hint, mss, fmt_opts, meta_opts) {
         Ok(mut format) => {
             // Dump visuals if requested.
-            if args.is_present("dump-visuals") {
+            if args.get_flag("dump-visuals") {
                 let name = match path.file_name() {
                     Some(name) if name != "-" => name,
                     _ => OsStr::new("NoName"),
@@ -189,20 +196,20 @@ fn run(args: &ArgMatches) -> Result<i32> {
             // Get the value of the track number option, if provided.
             let track_num = args.get_one::<usize>("track").copied();
 
-            let dec_opts = AudioDecoderOptions::default().gapless(!args.is_present("no-gapless"));
+            let dec_opts = AudioDecoderOptions::default().gapless(!args.get_flag("no-gapless"));
 
             // Select the operating mode.
-            if args.is_present("probe-only") {
+            if args.get_flag("probe-only") {
                 // Probe-only mode only prints information about the format, tracks, metadata, etc.
                 ui::print_format(path, &mut format);
                 Ok(0)
             }
-            else if args.is_present("verify-only") {
+            else if args.get_flag("verify-only") {
                 // Verify-only mode decodes and verifies the audio, but does not play it.
                 let opts = DecodeOptions { dec_opts: dec_opts.verify(true), track_num };
                 decode_only(format, opts)
             }
-            else if args.is_present("decode-only") {
+            else if args.get_flag("decode-only") {
                 // Decode-only mode decodes the audio, but does not play or verify it.
                 let opts = DecodeOptions { dec_opts: dec_opts.verify(false), track_num };
 
@@ -224,10 +231,10 @@ fn run(args: &ArgMatches) -> Result<i32> {
 
                 // Setup playback options.
                 let opts = PlayOptions {
-                    decoder_opts: dec_opts.verify(args.is_present("verify")),
+                    decoder_opts: dec_opts.verify(args.get_flag("verify")),
                     track_num,
                     seek_pos,
-                    no_progress: args.is_present("no-progress"),
+                    no_progress: args.get_flag("no-progress"),
                 };
 
                 // Play it!