refactor: make OpusBackend trait use associated types for encoder/decoder types

Author: DCNick3

unsafe-libopus-tools/src/bin/opus_demo/cli.rs

@@ -8,7 +8,7 @@ use std::iter::Peekable;
 use std::path::PathBuf;
 use std::str::FromStr;
 use unsafe_libopus_tools::demo::{
-    CommonOptions, DecodeArgs, EncodeArgs, EncoderOptions, MAX_PACKET,
+    CommonOptions, DecodeArgs, EncodeArgs, EncoderOptions, OpusBackend, MAX_PACKET,
 };
 
 #[rustfmt::skip]
@@ -175,25 +175,6 @@ fn parse_decode_args<I: Iterator<Item = String>>(args: &mut ArgsCursor<I>) -> Re
     })
 }
 
-#[derive(Debug, Copy, Clone, Default)]
-pub enum Backend {
-    #[default]
-    RustLibOpus,
-    UpstreamLibOpus,
-}
-
-impl FromStr for Backend {
-    type Err = &'static str;
-
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        match s {
-            "unsafe" => Ok(Backend::RustLibOpus),
-            "upstream" => Ok(Backend::UpstreamLibOpus),
-            _ => Err("Invalid backend"),
-        }
-    }
-}
-
 #[derive(Debug, Copy, Clone)]
 pub enum Mode {
     EncodeDecode(EncodeArgs),
@@ -203,7 +184,7 @@ pub enum Mode {
 
 #[derive(Debug, Clone)]
 pub struct Cli {
-    pub backend: Backend,
+    pub backend: OpusBackend,
     pub mode: Mode,
     pub input: PathBuf,
     pub output: PathBuf,
@@ -236,7 +217,7 @@ impl Cli {
         let backend = if args.poke("-b")? {
             args.next().map_err(|_| "Missing backend".to_string())?
         } else {
-            Backend::default()
+            OpusBackend::default()
         };
 
         let mode = if args.poke("-e")? {

unsafe-libopus-tools/src/bin/opus_demo/main.rs

@@ -6,23 +6,18 @@
 
 mod cli;
 
-use crate::cli::{Backend, Cli, Mode};
+use crate::cli::{Cli, Mode};
 use unsafe_libopus::opus_get_version_string;
-use unsafe_libopus_tools::demo::UpstreamLibopusBackend;
 use unsafe_libopus_tools::demo::{
-    opus_demo_adjust_length, opus_demo_decode, opus_demo_encode, DecodeArgs, OpusBackend,
-    RustLibopusBackend,
+    opus_demo_adjust_length, opus_demo_decode, opus_demo_encode, DecodeArgs,
 };
 
 pub fn main() {
     let cli = Cli::parse();
 
     eprintln!("{}", opus_get_version_string());
 
-    let backend: &dyn OpusBackend = match cli.backend {
-        Backend::RustLibOpus => &RustLibopusBackend,
-        Backend::UpstreamLibOpus => &UpstreamLibopusBackend,
-    };
+    let backend = cli.backend;
 
     match cli.mode {
         Mode::EncodeDecode(args) => {

unsafe-libopus-tools/src/bin/run_vectors2.rs

@@ -16,8 +16,8 @@ use std::fmt::Display;
 use std::path::{Path, PathBuf};
 use std::time::Instant;
 use unsafe_libopus_tools::demo::{
-    opus_demo_decode, opus_demo_encode, Application, Channels, DecodeArgs, EncodeArgs,
-    RustLibopusBackend, SampleRate, UpstreamLibopusBackend,
+    opus_demo_decode, opus_demo_encode, Application, Channels, DecodeArgs, EncodeArgs, OpusBackend,
+    SampleRate,
 };
 use unsafe_libopus_tools::CompareResult;
 
@@ -158,9 +158,9 @@ fn run_test(
             };
 
             let upstream_decoded =
-                opus_demo_decode(&UpstreamLibopusBackend, &test_vector.encoded, decode_args);
+                opus_demo_decode(OpusBackend::Upstream, &test_vector.encoded, decode_args);
             let rust_decoded =
-                opus_demo_decode(&RustLibopusBackend, &test_vector.encoded, decode_args);
+                opus_demo_decode(OpusBackend::Rust, &test_vector.encoded, decode_args);
 
             if let Some(dump_directory) = dump_directory {
                 let name_base = format!(
@@ -206,9 +206,9 @@ fn run_test(
             };
 
             let (upstream_encoded, pre_skip) =
-                opus_demo_encode(&UpstreamLibopusBackend, &true_decoded, encode_args);
+                opus_demo_encode(OpusBackend::Upstream, &true_decoded, encode_args);
             let (rust_encoded, rust_pre_skip) =
-                opus_demo_encode(&RustLibopusBackend, &true_decoded, encode_args);
+                opus_demo_encode(OpusBackend::Rust, &true_decoded, encode_args);
             assert_eq!(rust_pre_skip, pre_skip);
 
             if let Some(dump_directory) = dump_directory {
@@ -227,9 +227,9 @@ fn run_test(
 
                 // decode & save decoded files
                 let upstream_decoded =
-                    opus_demo_decode(&UpstreamLibopusBackend, &upstream_encoded, decode_args);
+                    opus_demo_decode(OpusBackend::Upstream, &upstream_encoded, decode_args);
                 let rust_decoded =
-                    opus_demo_decode(&UpstreamLibopusBackend, &rust_encoded, decode_args);
+                    opus_demo_decode(OpusBackend::Upstream, &rust_encoded, decode_args);
 
                 std::fs::write(
                     dump_directory