Move PluginLoader to audio_processor

So it can be used in offline-pipeline.

BUG=b:340217962
TEST=bazel test //...

Change-Id: If5ff5cd82cd3b3474b9f2309d1b9d46874a108df
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/third_party/adhd/+/5534472
Tested-by: Li-Yu Yu <[email protected]>
Reviewed-by: Chih-Yang Hsia <[email protected]>
Commit-Queue: Li-Yu Yu <[email protected]>
Tested-by: [email protected] <[email protected]>

Author: afq984

audio_processor/src/processors/plugin/loader.rs

@@ -0,0 +1,91 @@
+// Copyright 2024 The ChromiumOS Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+use anyhow::anyhow;
+use anyhow::Context;
+
+use crate::processors::ChunkWrapper;
+use crate::processors::DynamicPluginProcessor;
+use crate::processors::SpeexResampler;
+use crate::AudioProcessor;
+use crate::ProcessorVec;
+use crate::Shape;
+
+// TODO(aaronyu): This is the wrong abstraction. We should have an API to
+// chain processors with incompatible shapes and rates easily instead,
+// when we have something that looks more like a graph.
+pub struct PluginLoader<'a> {
+    pub path: &'a str,
+    pub constructor: &'a str,
+    pub channels: usize,
+    pub outer_rate: usize,
+    pub inner_rate: usize,
+    pub outer_block_size: usize,
+    pub inner_block_size: usize,
+    pub allow_chunk_wrapper: bool,
+}
+
+impl<'a> PluginLoader<'a> {
+    pub fn load_and_wrap(self) -> anyhow::Result<ProcessorVec> {
+        let processor = DynamicPluginProcessor::new(
+            self.path,
+            self.constructor,
+            self.inner_block_size,
+            self.channels,
+            self.inner_rate,
+        )
+        .with_context(|| "DynamicPluginProcessor::new failed")?;
+
+        let maybe_wrapped_processor: Box<dyn AudioProcessor<I = f32, O = f32> + Send> = if self
+            .outer_block_size
+            * self.inner_rate
+            != self.inner_block_size * self.outer_rate
+        {
+            // The block size after resampling needs wrapping.
+            if !self.allow_chunk_wrapper {
+                return Err(anyhow!("ChunkWrapper is not allowed but required: outer rate={}, block_size={}; inner rate={}, block_size={}", self.outer_rate, self.outer_block_size, self.inner_rate, self.inner_block_size));
+            }
+            Box::new(ChunkWrapper::new(
+                processor,
+                self.inner_block_size,
+                self.channels,
+                self.channels,
+            ))
+        } else {
+            Box::new(processor)
+        };
+
+        let processors = if self.outer_rate == self.inner_rate {
+            vec![maybe_wrapped_processor]
+        } else {
+            vec![
+                Box::new(
+                    SpeexResampler::new(
+                        Shape {
+                            channels: self.channels,
+                            frames: self.outer_block_size,
+                        },
+                        self.outer_rate,
+                        self.inner_rate,
+                    )
+                    .with_context(|| "failed to create 1st wrapping resampler")?,
+                ),
+                maybe_wrapped_processor,
+                Box::new(
+                    SpeexResampler::new(
+                        Shape {
+                            channels: self.channels,
+                            frames: self.outer_block_size * self.inner_rate / self.outer_rate,
+                        },
+                        self.inner_rate,
+                        self.outer_rate,
+                    )
+                    .with_context(|| "failed to create 2nd wrapping resampler")?,
+                ),
+            ]
+        };
+
+        Ok(processors)
+    }
+}

audio_processor/src/processors/plugin/mod.rs

@@ -12,3 +12,5 @@ mod export;
 pub use export::export_plugin;
 mod processor;
 pub use processor::*;
+mod loader;
+pub use loader::*;

cras/src/server/rust/src/cras_processor.rs

@@ -8,18 +8,15 @@ use std::ptr::NonNull;
 use std::sync::atomic::AtomicUsize;
 use std::sync::atomic::Ordering;
 
-use anyhow::anyhow;
 use anyhow::bail;
 use anyhow::Context;
 use audio_processor::processors::binding::plugin_processor;
 use audio_processor::processors::export_plugin;
 use audio_processor::processors::CheckShape;
-use audio_processor::processors::ChunkWrapper;
-use audio_processor::processors::DynamicPluginProcessor;
 use audio_processor::processors::NegateAudioProcessor;
+use audio_processor::processors::PluginLoader;
 use audio_processor::processors::PluginProcessor;
 use audio_processor::processors::ShuffleChannels;
-use audio_processor::processors::SpeexResampler;
 use audio_processor::processors::ThreadedProcessor;
 use audio_processor::AudioProcessor;
 use audio_processor::Pipeline;
@@ -304,84 +301,6 @@ impl CrasProcessor {
     }
 }
 
-// TODO(aaronyu): This is the wrong abstraction. We should have an API to
-// chain processors with incompatible shapes and rates easily instead,
-// when we have something that looks more like a graph.
-struct PluginLoader<'a> {
-    path: &'a str,
-    constructor: &'a str,
-    channels: usize,
-    outer_rate: usize,
-    inner_rate: usize,
-    outer_block_size: usize,
-    inner_block_size: usize,
-    allow_chunk_wrapper: bool,
-}
-
-impl<'a> PluginLoader<'a> {
-    fn load_and_wrap(self) -> anyhow::Result<ProcessorVec> {
-        let processor = DynamicPluginProcessor::new(
-            self.path,
-            self.constructor,
-            self.inner_block_size,
-            self.channels,
-            self.inner_rate,
-        )
-        .with_context(|| "DynamicPluginProcessor::new failed")?;
-
-        let maybe_wrapped_processor: Box<dyn AudioProcessor<I = f32, O = f32> + Send> = if self
-            .outer_block_size
-            * self.inner_rate
-            != self.inner_block_size * self.outer_rate
-        {
-            // The block size after resampling needs wrapping.
-            if !self.allow_chunk_wrapper {
-                return Err(anyhow!("ChunkWrapper is not allowed but required: outer rate={}, block_size={}; inner rate={}, block_size={}", self.outer_rate, self.outer_block_size, self.inner_rate, self.inner_block_size));
-            }
-            Box::new(ChunkWrapper::new(
-                processor,
-                self.inner_block_size,
-                self.channels,
-                self.channels,
-            ))
-        } else {
-            Box::new(processor)
-        };
-
-        let processors = if self.outer_rate == self.inner_rate {
-            vec![maybe_wrapped_processor]
-        } else {
-            vec![
-                Box::new(
-                    SpeexResampler::new(
-                        Shape {
-                            channels: self.channels,
-                            frames: self.outer_block_size,
-                        },
-                        self.outer_rate,
-                        self.inner_rate,
-                    )
-                    .with_context(|| "failed to create 1st wrapping resampler")?,
-                ),
-                maybe_wrapped_processor,
-                Box::new(
-                    SpeexResampler::new(
-                        Shape {
-                            channels: self.channels,
-                            frames: self.outer_block_size * self.inner_rate / self.outer_rate,
-                        },
-                        self.inner_rate,
-                        self.outer_rate,
-                    )
-                    .with_context(|| "failed to create 2nd wrapping resampler")?,
-                ),
-            ]
-        };
-
-        Ok(processors)
-    }
-}
-
 impl Drop for CrasProcessor {
     fn drop(&mut self) {
         log::info!("CrasProcessor #{} dropped", self.id);