mii/maudio-router
1
0
Fork 0
mirror of https://github.com/mii443/maudio-router.git synced 2025-08-22 16:05:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

Update local_test.yaml and resampling.rs, and modify VirtualDevice

Browse Source
This commit is contained in:
mii443
2024-02-15 13:03:21 +09:00
parent e08bce3a25
commit 9ca9316342
4 changed files with 200 additions and 61 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
local_test.yaml
View File

@ -8,7 +8,7 @@ routes:
virtual_device: "mic"
device:
local:
name: "VoiceMeeter Output (VB-Audio VoiceMeeter VAIO)"
name: "VoiceMeeter Aux Output (VB-Audio VoiceMeeter AUX VAIO)"
output:
- name: "Speaker"
input:

21
src/audio/resampling.rs
View File

@ -1,12 +1,18 @@
use rubato::{Resampler, SincFixedIn, SincInterpolationParameters, SincInterpolationType, WindowFunction};
use rubato::{
Resampler, SincFixedIn, SincInterpolationParameters, SincInterpolationType, WindowFunction,
};
pub fn resampling(current_sample_rate: u32, target_sample_rate: u32, data: Vec<Vec<f32>>) -> Vec<Vec<f32>> {
pub fn resampling(
current_sample_rate: u32,
target_sample_rate: u32,
data: Vec<Vec<f32>>,
) -> Vec<Vec<f32>> {
let params = SincInterpolationParameters {
sinc_len: 256,
sinc_len: 8,
f_cutoff: 0.95,
interpolation: SincInterpolationType::Linear,
oversampling_factor: 128,
window: WindowFunction::BlackmanHarris2,
oversampling_factor: 64,
window: WindowFunction::Hann2,
};
let mut resampler = SincFixedIn::<f32>::new(
@ -14,8 +20,9 @@ pub fn resampling(current_sample_rate: u32, target_sample_rate: u32, data: Vec<V
2.0,
params,
data[0].len(),
data.len()
).unwrap();
data.len(),
)
.unwrap();
resampler.process(&data, None).unwrap()
}

203
src/commands/run.rs
View File

@ -1,6 +1,13 @@
use std::{io::Read, sync::{Arc, Mutex}};
use std::{
cmp::min,
io::Read,
sync::{Arc, Mutex},
};
use cpal::{traits::{DeviceTrait, HostTrait, StreamTrait}, Device};
use cpal::{
traits::{DeviceTrait, HostTrait, StreamTrait},
Device,
};
use crate::{args::Run, device::virtual_device::VirtualDevice};
@ -59,14 +66,21 @@ pub fn run(run: Run) {
// create virtual devices
let mut virtual_devices = Vec::new();
for virtual_device in config.virtual_devices {
let device = crate::device::virtual_device::VirtualDevice::new(virtual_device.name, virtual_device.channels, virtual_device.sample_rate);
let device = crate::device::virtual_device::VirtualDevice::new(
virtual_device.name,
virtual_device.channels,
virtual_device.sample_rate,
);
virtual_devices.push(Arc::new(Mutex::new(device)));
}
for input_route in &config.routes.input {
println!("Input: {}", input_route.name);
println!(" Virtual device: {}", input_route.virtual_device);
if virtual_devices.iter().any(|device| device.lock().unwrap().name == input_route.virtual_device) {
if virtual_devices
.iter()
.any(|device| device.lock().unwrap().name == input_route.virtual_device)
{
println!(" Found");
} else {
println!(" Not found");
@ -97,7 +111,10 @@ pub fn run(run: Run) {
for output_route in &config.routes.output {
println!("Output: {}", output_route.name);
println!(" Virtual device: {}", output_route.input.virtual_device);
if virtual_devices.iter().any(|device| device.lock().unwrap().name == output_route.input.virtual_device) {
if virtual_devices
.iter()
.any(|device| device.lock().unwrap().name == output_route.input.virtual_device)
{
println!(" Found");
} else {
println!(" Not found");
@ -138,46 +155,80 @@ pub fn run(run: Run) {
let channels = config.channels();
let sample_rate = config.sample_rate().0;
let virtual_devices = virtual_devices.iter().filter(|device| device.lock().unwrap().name == input_route.virtual_device).cloned().collect::<Vec<_>>()[0].clone();
let virtual_devices = virtual_devices
.iter()
.filter(|device| device.lock().unwrap().name == input_route.virtual_device)
.cloned()
.collect::<Vec<_>>()[0]
.clone();
let stream = match config.sample_format() {
cpal::SampleFormat::I8 => device.build_input_stream(
&config.into(),
{
move |data: &[i8], _| input_callback(data, channels.into(), sample_rate, virtual_devices.clone())
move |data: &[i8], _| {
input_callback(
data,
channels.into(),
sample_rate,
virtual_devices.clone(),
)
}
},
move |err| eprintln!("An error occurred on the input stream: {}", err),
None
None,
),
cpal::SampleFormat::I16 => device.build_input_stream(
&config.into(),
{
move |data: &[i16], _| input_callback(data, channels.into(), sample_rate, virtual_devices.clone())
move |data: &[i16], _| {
input_callback(
data,
channels.into(),
sample_rate,
virtual_devices.clone(),
)
}
},
move |err| eprintln!("An error occurred on the input stream: {}", err),
None
None,
),
cpal::SampleFormat::I32 => device.build_input_stream(
&config.into(),
{
move |data: &[i32], _| input_callback(data, channels.into(), sample_rate, virtual_devices.clone())
move |data: &[i32], _| {
input_callback(
data,
channels.into(),
sample_rate,
virtual_devices.clone(),
)
}
},
move |err| eprintln!("An error occurred on the input stream: {}", err),
None
None,
),
cpal::SampleFormat::F32 => device.build_input_stream(
&config.into(),
{
move |data: &[f32], _| input_callback(data, channels.into(), sample_rate, virtual_devices.clone())
move |data: &[f32], _| {
input_callback(
data,
channels.into(),
sample_rate,
virtual_devices.clone(),
)
}
},
move |err| eprintln!("An error occurred on the input stream: {}", err),
None
None,
),
sample_format => {
eprintln!("Unsupported sample format: {:?}", sample_format);
return;
}
}.unwrap();
}
.unwrap();
stream.play().unwrap();
streams.push(stream);
@ -200,47 +251,87 @@ pub fn run(run: Run) {
let channels = config.channels();
let sample_rate = config.sample_rate().0;
let virtual_device = virtual_devices.iter().filter(|device| device.lock().unwrap().name == output_route.input.virtual_device).cloned().collect::<Vec<_>>()[0].clone();
let virtual_device = virtual_devices
.iter()
.filter(|device| {
device.lock().unwrap().name == output_route.input.virtual_device
})
.cloned()
.collect::<Vec<_>>()[0]
.clone();
let index = virtual_device.lock().unwrap().add_output();
let stream = match config.sample_format() {
cpal::SampleFormat::I8 => device.build_output_stream(
&config.into(),
{
move |data: &mut [i8], _| output_callback(data, channels.into(), sample_rate, virtual_device.clone(), index)
move |data: &mut [i8], _| {
output_callback(
data,
channels.into(),
sample_rate,
virtual_device.clone(),
index,
)
}
},
move |err| eprintln!("An error occurred on the output stream: {}", err),
None
None,
),
cpal::SampleFormat::I16 => device.build_output_stream(
&config.into(),
{
move |data: &mut [i16], _| output_callback(data, channels.into(), sample_rate, virtual_device.clone(), index)
move |data: &mut [i16], _| {
output_callback(
data,
channels.into(),
sample_rate,
virtual_device.clone(),
index,
)
}
},
move |err| eprintln!("An error occurred on the output stream: {}", err),
None
None,
),
cpal::SampleFormat::I32 => device.build_output_stream(
&config.into(),
{
move |data: &mut [i32], _| output_callback(data, channels.into(), sample_rate, virtual_device.clone(), index)
move |data: &mut [i32], _| {
output_callback(
data,
channels.into(),
sample_rate,
virtual_device.clone(),
index,
)
}
},
move |err| eprintln!("An error occurred on the output stream: {}", err),
None
None,
),
cpal::SampleFormat::F32 => device.build_output_stream(
&config.into(),
{
move |data: &mut [f32], _| output_callback(data, channels.into(), sample_rate, virtual_device.clone(), index)
move |data: &mut [f32], _| {
output_callback(
data,
channels.into(),
sample_rate,
virtual_device.clone(),
index,
)
}
},
move |err| eprintln!("An error occurred on the output stream: {}", err),
None
None,
),
sample_format => {
eprintln!("Unsupported sample format: {:?}", sample_format);
return;
}
}.unwrap();
}
.unwrap();
stream.play().unwrap();
streams.push(stream);
@ -251,31 +342,52 @@ pub fn run(run: Run) {
}
}
std::thread::sleep(std::time::Duration::from_secs(10));
loop {
std::thread::sleep(std::time::Duration::from_secs(1000));
}
}
fn input_callback<T>(data: &[T], channels: usize, sample_rate: u32, virtual_device: Arc<Mutex<VirtualDevice>>)
where
T: Clone + num::cast::ToPrimitive
fn input_callback<T>(
data: &[T],
channels: usize,
sample_rate: u32,
virtual_device: Arc<Mutex<VirtualDevice>>,
) where
T: Clone + num::cast::ToPrimitive,
{
let data: Vec<f32> = data.iter().map(|d| d.to_f32().unwrap()).collect();
let audio_data = reshape_audio_data(&data, channels);
let audio_data = crate::audio::resampling::resampling(sample_rate, virtual_device.lock().unwrap().sample_rate, audio_data);
for (i, buffer) in audio_data.iter().enumerate() {
virtual_device.lock().unwrap().write_input(i as u8, buffer.clone());
}
let audio_data = crate::audio::resampling::resampling(
sample_rate,
virtual_device.lock().unwrap().sample_rate,
audio_data,
);
virtual_device
.lock()
.unwrap()
.write_input_multiple_channels(&audio_data);
}
fn output_callback<T>(data: &mut [T], channels: usize, sample_rate: u32, virtual_device: Arc<Mutex<VirtualDevice>>, index: usize)
where
T: Clone + num::cast::FromPrimitive
fn output_callback<T>(
data: &mut [T],
channels: usize,
sample_rate: u32,
virtual_device: Arc<Mutex<VirtualDevice>>,
index: usize,
) where
T: Clone + num::cast::FromPrimitive,
{
let mut audio_data = vec![];
for i in 0..channels {
audio_data.push(virtual_device.lock().unwrap().take_output(index, i as u8, data.len() / channels).unwrap_or(vec![0.; data.len() / channels]));
}
let audio_data = crate::audio::resampling::resampling(virtual_device.lock().unwrap().sample_rate, sample_rate, audio_data);
let mut virtual_device = virtual_device.lock().unwrap();
let vd_channels = virtual_device.channels;
let mut audio_data = virtual_device
.take_output(
index,
min(channels as u8, vd_channels),
data.len() / channels,
)
.unwrap_or(vec![vec![0.; data.len() / channels]; channels]);
let audio_data =
crate::audio::resampling::resampling(virtual_device.sample_rate, sample_rate, audio_data);
let mut audio_data = to_flat_audio_data(&audio_data);
let data_len = data.len();
@ -284,7 +396,10 @@ where
audio_data.extend(vec![0.0; data_len - audio_data_len]);
}
let audio_data: Vec<T> = audio_data.iter().map(|d| T::from_f32(*d).unwrap()).collect();
let audio_data: Vec<T> = audio_data
.iter()
.map(|d| T::from_f32(*d).unwrap())
.collect();
data.clone_from_slice(&audio_data);
}
}

35
src/device/virtual_device.rs
View File

@ -27,25 +27,37 @@ impl VirtualDevice {
self.output_index.len() - 1
}
pub fn take_output(&mut self, index: usize, channel: u8, take_size: usize) -> Option<Vec<f32>> {
println!("Min index: {}", self.get_min_index());
let mut buffer = Vec::with_capacity(take_size);
pub fn take_output(
&mut self,
index: usize,
channels: u8,
take_size: usize,
) -> Option<Vec<Vec<f32>>> {
let mut buffer = vec![Vec::with_capacity(take_size); channels as usize];
let start = self.output_index[index];
let end = start + take_size;
if end > self.output_buffer[channel as usize].len() {
return None;
for channel in 0..channels {
if end > self.output_buffer[channel as usize].len() {
return None;
}
if start >= self.output_buffer[channel as usize].len() {
return None;
}
}
for i in start..end {
buffer.push(self.output_buffer[channel as usize][i]);
for channel in 0..channels {
buffer[channel as usize].push(self.output_buffer[channel as usize][i]);
}
}
self.output_index[index] = end;
let min = self.get_min_index();
if min != 0 {
for i in 0..self.channels as usize {
self.output_buffer[i].drain(0..min);
let len = self.output_buffer[i].len();
self.output_buffer[i].drain(0..(if len < min { len } else { min }));
}
for i in 0..self.output_index.len() {
self.output_index[i] -= min;
@ -55,8 +67,13 @@ impl VirtualDevice {
Some(buffer)
}
pub fn write_input_multiple_channels(&mut self, buffer: &[Vec<f32>]) {
(0..self.channels as usize).for_each(|i| {
self.output_buffer[i].extend(buffer[i].iter());
});
}
pub fn write_input(&mut self, channel: u8, buffer: Vec<f32>) {
println!("Buffer size: {}", self.output_buffer[channel as usize].len());
self.output_buffer[channel as usize].extend(buffer);
}
}
}