106 lines
3.6 KiB
Rust
106 lines
3.6 KiB
Rust
extern crate gst;
|
|
|
|
use std::sync::mpsc;
|
|
use itertools::Itertools;
|
|
|
|
use config;
|
|
|
|
pub struct RecordingPipeline {
|
|
pipeline : gst::Pipeline,
|
|
mainloop : gst::MainLoop,
|
|
bus_receiver : mpsc::Receiver<gst::Message>,
|
|
appsink : gst::AppSink,
|
|
}
|
|
|
|
|
|
impl RecordingPipeline {
|
|
pub fn new(record_config : &config::Config) -> RecordingPipeline {
|
|
let pipeline_str = format!("alsasrc device={} ! audio/x-raw,rate={},channels=2 ! \
|
|
queue ! tee name=apptee ! audioconvert ! flacenc ! filesink location={}/{}.flac \
|
|
apptee. ! queue ! audioconvert ! appsink name=appsink0 caps=\"audio/x-raw,format=F32LE,channels=2\"",
|
|
record_config.audio.alsa_device,
|
|
record_config.audio.rate,
|
|
record_config.output.directory,
|
|
record_config.output.prefix);
|
|
|
|
println!("{}", pipeline_str);
|
|
|
|
let pipeline = gst::Pipeline::new_from_str(&pipeline_str).unwrap();
|
|
let mainloop = gst::MainLoop::new();
|
|
let mut bus = pipeline.bus().expect("Couldn't get bus from pipeline");
|
|
let bus_receiver = bus.receiver();
|
|
let appsink_element = pipeline
|
|
.get_by_name("appsink0")
|
|
.expect("Couldn't get appsink from pipeline");
|
|
let appsink = gst::AppSink::new_from_element(appsink_element);
|
|
|
|
RecordingPipeline {
|
|
pipeline : pipeline,
|
|
mainloop : mainloop,
|
|
bus_receiver : bus_receiver,
|
|
appsink : appsink,
|
|
}
|
|
}
|
|
|
|
|
|
pub fn start(&mut self) {
|
|
self.mainloop.spawn();
|
|
self.pipeline.play();
|
|
}
|
|
|
|
|
|
pub fn stop(&mut self) {
|
|
self.pipeline.set_null_state();
|
|
self.mainloop.quit();
|
|
}
|
|
|
|
|
|
pub fn handle_events(&mut self) -> bool {
|
|
while let Ok(msg) = self.bus_receiver.try_recv() {
|
|
match msg.parse() {
|
|
gst::Message::StateChangedParsed { ref old, ref new, .. } => {
|
|
println!("element `{}` changed from {:?} to {:?}",
|
|
msg.src_name(), old, new);
|
|
}
|
|
gst::Message::ErrorParsed {ref error, ref debug, .. } => {
|
|
println!("error msg from element `{}`: {}, {}. Quitting",
|
|
msg.src_name(), error.message(), debug);
|
|
return false;
|
|
}
|
|
_ => {
|
|
println!("msg of type `{}` from element `{}`",
|
|
msg.type_name(), msg.src_name());
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
pub fn get_max_samples(&mut self) -> Result<(f32, f32), &str>{
|
|
match self.appsink.try_recv() {
|
|
Ok(gst::appsink::Message::NewSample(sample))
|
|
| Ok(gst::appsink::Message::NewPreroll(sample)) => {
|
|
if let Some(buffer) = sample.buffer() {
|
|
let (max0, max1) = buffer.map_read(|mapping| {
|
|
mapping.iter::<f32>().tuples().fold((0.0f32, 0.0f32), |(acc0, acc1), (sample0, sample1)| {
|
|
(acc0.max(sample0.abs()), acc1.max(sample1.abs()))
|
|
})
|
|
}).unwrap();
|
|
return Ok((max0, max1));
|
|
}
|
|
return Err("Unable to access samples");
|
|
}
|
|
Ok(gst::appsink::Message::Eos) => {
|
|
return Err("Got no sample when polling. EOS");
|
|
}
|
|
Err(mpsc::TryRecvError::Empty) => {
|
|
return Ok((0.0f32,0.0f32));
|
|
}
|
|
Err(mpsc::TryRecvError::Disconnected) => {
|
|
return Err("Appsink got disconnected")
|
|
}
|
|
}
|
|
}
|
|
}
|