aria/feresaria
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
610478f8c78a6e287a5c5e34f2f62ca7c926e303
feresaria/portal/src/recorder.rs
T

930 lines
33 KiB
Rust
Raw Blame History

use std::collections::HashMap;
use std::fs::{File, OpenOptions};
use std::io::{Read, Write};
use std::os::fd::AsRawFd;
use std::os::unix::fs::OpenOptionsExt;
use std::path::{Path, PathBuf};
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
use std::time::{Duration, Instant};
use crate::recording::{Audio, Recording};
use futures_util::StreamExt;
use gstreamer as gst;
use gstreamer::prelude::*;
use tokio::sync::watch;
use zbus::zvariant::{OwnedFd, OwnedObjectPath, OwnedValue, Value};
use zbus::{Connection, Proxy};
type Options = HashMap<String, OwnedValue>;
const DESKTOP: &str = "org.freedesktop.portal.Desktop";
const DESKTOP_PATH: &str = "/org/freedesktop/portal/desktop";
pub fn event(state: &str, message: Option<&str>, path: Option<&Path>) {
let value = serde_json::json!({"state": state, "message": message, "path": path});
let mut stdout = std::io::stdout().lock();
let _ = writeln!(stdout, "{value}");
let _ = stdout.flush();
}
fn option_string(value: String) -> OwnedValue {
OwnedValue::try_from(Value::from(value)).unwrap()
}
async fn request<B: serde::Serialize + zbus::zvariant::DynamicType>(
connection: &Connection,
method: &str,
token: &str,
body: &B,
stop: &mut watch::Receiver<bool>,
) -> Result<Option<Options>, String> {
let sender = connection
.unique_name()
.ok_or("No D-Bus identity")?
.as_str()[1..]
.replace('.', "_");
let path = format!("{DESKTOP_PATH}/request/{sender}/{token}");
let request = Proxy::new(
connection,
DESKTOP,
path.as_str(),
"org.freedesktop.portal.Request",
)
.await
.map_err(|e| e.to_string())?;
let mut responses = request
.receive_signal("Response")
.await
.map_err(|e| e.to_string())?;
let portal = Proxy::new(
connection,
DESKTOP,
DESKTOP_PATH,
"org.freedesktop.portal.ScreenCast",
)
.await
.map_err(|e| e.to_string())?;
let returned: OwnedObjectPath = portal
.call(method, body)
.await
.map_err(|e| format!("Screen recording portal unavailable: {e}"))?;
if returned.as_str() != path {
return Err("Unexpected portal request handle".into());
}
if *stop.borrow() {
let _: Result<(), _> = request.call("Close", &()).await;
return Ok(None);
}
tokio::select! {
_ = stop.changed() => {
let _: Result<(), _> = request.call("Close", &()).await;
Ok(None)
}
signal = tokio::time::timeout(Duration::from_secs(125), responses.next()) => {
let signal = signal.map_err(|_| "Display selection timed out")?.ok_or("Portal disconnected")?;
let (code, options): (u32, Options) = signal.body().deserialize().map_err(|e| e.to_string())?;
match code { 0 => Ok(Some(options)), 1 => Ok(None), _ => Err("Screen recording request failed".into()) }
}
}
}
pub async fn run() -> Result<(), String> {
gst::init().map_err(|e| e.to_string())?;
for factory in [
"pipewiresrc",
"queue",
"videoconvert",
"vp8enc",
"webmmux",
"fdsink",
] {
if gst::ElementFactory::find(factory).is_none() {
return Err(format!(
"Recording needs the GStreamer {factory} plugin. See the recording installation guide."
));
}
}
let output = output_directory()?;
let (stop_send, mut stop) = watch::channel(false);
std::thread::spawn(move || {
let _ = std::io::stdin().read(&mut [0u8]);
let _ = stop_send.send(true);
});
let connection = Connection::session().await.map_err(|e| e.to_string())?;
let token = |step| format!("ferese_record_{}_{step}", std::process::id());
let Some(created) = request(
&connection,
"CreateSession",
&token(0),
&(HashMap::from([
("handle_token", option_string(token(0))),
("session_handle_token", option_string(token(0))),
]),),
&mut stop,
)
.await?
else {
event("cancelled", None, None);
return Ok(());
};
let handle = created
.get("session_handle")
.ok_or("Portal returned no session")?;
// The public portal historically returns this path as a D-Bus string.
let handle = OwnedObjectPath::try_from(
String::try_from(handle.try_clone().map_err(|e| e.to_string())?)
.map_err(|e| e.to_string())?,
)
.map_err(|e| e.to_string())?;
// Older/foreign backends keep their normal sharing indicator. Only Ferese
// can verify this helper's identity and that its parent owns a bar stop button.
let native = matches!(
tokio::time::timeout(Duration::from_secs(3), async {
let control = Proxy::new(
&connection,
"org.freedesktop.impl.portal.desktop.ferese",
"/org/ferese/ScreenRecorder",
"org.ferese.ScreenRecorder",
)
.await?;
control
.call::<_, _, ()>("UseBarControls", &(handle.clone(),))
.await
})
.await,
Ok(Ok(()))
);
let session = Proxy::new(
&connection,
DESKTOP,
handle.as_str(),
"org.freedesktop.portal.Session",
)
.await
.map_err(|e| e.to_string())?;
let result = record_session(
&connection,
&session,
&handle,
&token,
&output,
&mut stop,
native,
)
.await;
let _: Result<(), _> = session.call("Close", &()).await;
match result {
Ok(Some(path)) => event("saved", None, Some(&path)),
Ok(None) => event("cancelled", None, None),
Err(e) => return Err(e),
}
Ok(())
}
async fn record_session(
connection: &Connection,
session: &Proxy<'_>,
handle: &OwnedObjectPath,
token: &impl Fn(u8) -> String,
output: &Path,
stop: &mut watch::Receiver<bool>,
native: bool,
) -> Result<Option<PathBuf>, String> {
let mut closed = session
.receive_signal("Closed")
.await
.map_err(|e| e.to_string())?;
if request(
connection,
"SelectSources",
&token(1),
&(
handle,
HashMap::from([
("handle_token", option_string(token(1))),
("types", 1u32.into()),
("multiple", false.into()),
("cursor_mode", 2u32.into()),
]),
),
stop,
)
.await?
.is_none()
{
return Ok(None);
}
event("selecting", None, None);
let Some(started) = request(
connection,
"Start",
&token(2),
&(
handle,
"",
HashMap::from([("handle_token", option_string(token(2)))]),
),
stop,
)
.await?
else {
return Ok(None);
};
let streams: Vec<(u32, Options)> = started
.get("streams")
.ok_or("Portal returned no video stream")?
.try_clone()
.map_err(|e| e.to_string())?
.try_into()
.map_err(|e: zbus::zvariant::Error| e.to_string())?;
if streams.len() != 1 {
return Err("Recording requires exactly one display".into());
}
let recording = if native {
let control = Proxy::new(
connection,
"org.freedesktop.impl.portal.desktop.ferese",
"/org/ferese/ScreenRecorder",
"org.ferese.ScreenRecorder",
)
.await
.map_err(|e| e.to_string())?;
let options: String = tokio::time::timeout(
Duration::from_secs(3),
control.call("RecordingOptions", &(handle,)),
)
.await
.map_err(|_| "Recording options timed out")?
.map_err(|e| {
format!(
"Cannot read recording options; update the Ferese portal and recorder together: {e}"
)
})?;
serde_json::from_str::<Recording>(&options).map_err(|e| e.to_string())?
} else {
Recording::default()
};
let portal = Proxy::new(
connection,
DESKTOP,
DESKTOP_PATH,
"org.freedesktop.portal.ScreenCast",
)
.await
.map_err(|e| e.to_string())?;
let remote: OwnedFd = portal
.call("OpenPipeWireRemote", &(handle, Options::new()))
.await
.map_err(|e| e.to_string())?;
if *stop.borrow() {
return Ok(None);
}
let stop_capture = Arc::new(AtomicBool::new(*stop.borrow()));
let worker_stop = stop_capture.clone();
let node = streams[0].0;
let output = output.to_owned();
let mut worker = tokio::task::spawn_blocking(move || {
let source = gst::ElementFactory::make("pipewiresrc")
.property("fd", remote.as_raw_fd())
.property("path", node.to_string())
.property("do-timestamp", true)
// Keep queued frames valid when the portal revokes PipeWire buffers.
.property("always-copy", true)
.build()
.map_err(|e| e.to_string())?;
let audio = audio_sources(recording.audio)?;
let result = encode(source, audio, recording.crop, &output, worker_stop);
drop(remote);
result
});
let result = tokio::select! {
result = &mut worker => result,
_ = stop.changed() => { stop_capture.store(true, Ordering::Relaxed); worker.await },
_ = closed.next() => { stop_capture.store(true, Ordering::Relaxed); worker.await },
};
result.map_err(|e| e.to_string())?.map(Some)
}
fn output_directory() -> Result<PathBuf, String> {
let args: Vec<_> = std::env::args_os().skip(1).collect();
match args.as_slice() {
[] => dirs::video_dir()
.or_else(|| dirs::home_dir().map(|p| p.join("Videos")))
.map(|p| p.join("Ferese"))
.ok_or("Cannot find your Videos folder".into()),
[flag, path] if flag == "--output-dir" => Ok(PathBuf::from(path)),
_ => Err("Usage: ferese-record [--output-dir DIRECTORY]".into()),
}
}
fn recording_file(directory: &Path) -> Result<(File, PathBuf, PathBuf), String> {
std::fs::create_dir_all(directory)
.map_err(|e| format!("Cannot create recording folder: {e}"))?;
let name = format!(
"Recording-{}-{}",
jiff::Zoned::now().strftime("%Y-%m-%d_%H-%M-%S"),
std::process::id()
);
for suffix in 0..100 {
let final_path = directory.join(format!("{name}-{suffix}.webm"));
let partial = final_path.with_extension("webm.part");
if final_path.exists() {
continue;
}
match OpenOptions::new()
.write(true)
.create_new(true)
.mode(0o600)
.open(&partial)
{
Ok(file) => return Ok((file, partial, final_path)),
Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => continue,
Err(e) => return Err(format!("Cannot save recording: {e}")),
}
}
Err("Cannot choose a unique recording filename".into())
}
fn audio_sources(audio: Audio) -> Result<Vec<gst::Element>, String> {
let devices: &[&str] = match audio {
Audio::Off => &[],
Audio::System => &["@DEFAULT_MONITOR@"],
Audio::Microphone => &["@DEFAULT_SOURCE@"],
Audio::Both => &["@DEFAULT_MONITOR@", "@DEFAULT_SOURCE@"],
};
devices.iter().map(|device| {
gst::ElementFactory::make("pulsesrc")
.property("device", *device)
.property("client-name", "Ferese Screen Recorder")
.property("do-timestamp", true)
.property("provide-clock", false)
.build().map_err(|e| format!("Cannot record {}. Install the GStreamer audio plugins and run PipeWire-Pulse or PulseAudio: {e}", audio.label()))
}).collect()
}
fn element(factory: &str) -> Result<gst::Element, String> {
gst::ElementFactory::make(factory)
.build()
.map_err(|e| format!("Recording needs the GStreamer {factory} plugin: {e}"))
}
fn encode(
source: gst::Element,
audio: Vec<gst::Element>,
crop: Option<crate::recording::Crop>,
output: &Path,
stop: Arc<AtomicBool>,
) -> Result<PathBuf, String> {
if let Some(crop) = crop {
crop.validate()?;
}
let (file, partial, destination) = recording_file(output)?;
let pipeline = gst::Pipeline::new();
let result = (|| {
let queue = gst::ElementFactory::make("queue")
.property("max-size-buffers", 4u32)
.property("max-size-bytes", 0u32)
.property("max-size-time", 0u64)
.property_from_str("leaky", "downstream")
.build()
.map_err(|e| e.to_string())?;
let convert = gst::ElementFactory::make("videoconvert")
.build()
.map_err(|e| e.to_string())?;
let encoder = gst::ElementFactory::make("vp8enc")
.property("deadline", 1i64)
.property("cpu-used", 8i32)
.property("threads", 4i32)
.property("target-bitrate", 8_000_000i32)
.property("keyframe-max-dist", 60i32)
.build()
.map_err(|e| e.to_string())?;
let mux = gst::ElementFactory::make("webmmux")
.build()
.map_err(|e| e.to_string())?;
let sink = gst::ElementFactory::make("fdsink")
.property("fd", file.as_raw_fd())
.property("sync", false)
.build()
.map_err(|e| e.to_string())?;
pipeline
.add_many([&source, &queue, &convert, &encoder, &mux, &sink])
.map_err(|e| e.to_string())?;
if let Some(crop) = crop {
let filter = gst::ElementFactory::make("videocrop")
.property("left", crop.left)
.property("top", crop.top)
.property("right", crop.right)
.property("bottom", crop.bottom)
.build()
.map_err(|e| e.to_string())?;
pipeline.add(&filter).map_err(|e| e.to_string())?;
gst::Element::link_many([&source, &queue, &filter, &convert, &encoder, &mux, &sink])
.map_err(|e| e.to_string())?;
} else {
gst::Element::link_many([&source, &queue, &convert, &encoder, &mux, &sink])
.map_err(|e| e.to_string())?;
}
let mut audio_inputs = Vec::new();
let audio_seen = Arc::new(AtomicBool::new(audio.is_empty()));
if !audio.is_empty() {
let mixer = element("audiomixer")?;
let convert = element("audioconvert")?;
let resample = element("audioresample")?;
let encoder = element("opusenc")?;
let audio_queue = element("queue")?;
pipeline
.add_many([&mixer, &convert, &resample, &encoder, &audio_queue])
.map_err(|e| e.to_string())?;
gst::Element::link_many([&mixer, &convert, &resample, &encoder, &audio_queue, &mux])
.map_err(|e| e.to_string())?;
let seen = audio_seen.clone();
audio_queue
.static_pad("src")
.ok_or("Audio encoder has no output")?
.add_probe(gst::PadProbeType::BUFFER, move |_, info| {
if info.buffer().is_some_and(|b| b.size() > 0) {
seen.store(true, Ordering::Relaxed);
}
gst::PadProbeReturn::Ok
});
for source in audio {
let queue = element("queue")?;
let convert = element("audioconvert")?;
let resample = element("audioresample")?;
let caps = gst::ElementFactory::make("capsfilter")
.property(
"caps",
gst::Caps::builder("audio/x-raw")
.field("rate", 48_000i32)
.field("channels", 2i32)
.build(),
)
.build()
.map_err(|e| e.to_string())?;
pipeline
.add_many([&source, &queue, &convert, &resample, &caps])
.map_err(|e| e.to_string())?;
gst::Element::link_many([&source, &queue, &convert, &resample, &caps, &mixer])
.map_err(|e| e.to_string())?;
audio_inputs.push((source, queue));
}
}
let ended = stop.clone();
source
.static_pad("src")
.ok_or("Capture has no video output")?
.add_probe(gst::PadProbeType::EVENT_DOWNSTREAM, move |_, info| {
if info
.event()
.is_some_and(|event| matches!(event.view(), gst::EventView::Eos(_)))
{
ended.store(true, Ordering::Relaxed);
}
gst::PadProbeReturn::Ok
});
let announced = Arc::new(AtomicBool::new(false));
let notice = announced.clone();
source
.static_pad("src")
.ok_or("Capture has no video output")?
.add_probe(gst::PadProbeType::BUFFER, move |_, info| {
if info.buffer().is_some_and(|b| b.size() > 0)
&& !notice.swap(true, Ordering::Relaxed)
{
event("recording", None, None);
}
gst::PadProbeReturn::Ok
});
pipeline
.set_state(gst::State::Playing)
.map_err(|e| e.to_string())?;
let bus = pipeline.bus().ok_or("Encoder has no message bus")?;
let mut finishing = None;
let started = Instant::now();
let mut failure = None;
loop {
if stop.load(Ordering::Relaxed) && finishing.is_none() {
event("saving", None, None);
finishing = Some(Instant::now());
// Inject after the capture source: it may already have disappeared
// when the portal closes on lock or monitor removal.
let _ = queue
.static_pad("sink")
.ok_or("Encoder queue has no input")?
.send_event(gst::event::Eos::new());
for (source, queue) in &audio_inputs {
// Audio devices are still alive when video is revoked.
// Let each source order EOS after its own startup events and
// buffers; injecting into its queue can race late caps.
if !source.send_event(gst::event::Eos::new()) {
let _ = queue
.static_pad("sink")
.ok_or("Audio queue has no input")?
.send_event(gst::event::Eos::new());
}
}
}
if finishing.is_some_and(|t: Instant| t.elapsed() > Duration::from_secs(10)) {
return Err(failure.unwrap_or("Finishing the recording timed out".into()));
}
if !announced.load(Ordering::Relaxed) && started.elapsed() > Duration::from_secs(15) {
return Err("No video frames arrived from the selected display".into());
}
if !audio_seen.load(Ordering::Relaxed) && started.elapsed() > Duration::from_secs(15) {
failure = Some("No audio arrived from the selected audio source".into());
stop.store(true, Ordering::Relaxed);
}
let Some(message) = bus.timed_pop(gst::ClockTime::from_mseconds(50)) else {
continue;
};
match message.view() {
gst::MessageView::Eos(_) => {
if !announced.load(Ordering::Relaxed) {
return Err("Recording ended before receiving video".into());
}
if !audio_seen.load(Ordering::Relaxed) {
return Err("Recording ended before receiving audio".into());
}
if let Some(failure) = failure {
return Err(failure);
}
return Ok(());
}
gst::MessageView::Error(error) => {
failure = Some(format!("Recording interrupted: {}", error.error()));
stop.store(true, Ordering::Relaxed);
}
_ => (),
}
}
})();
let _ = pipeline.set_state(gst::State::Null);
result.map_err(|e| format!("{e}. Incomplete file: {}", partial.display()))?;
file.sync_all()
.map_err(|e| format!("Cannot finish saving {}: {e}", partial.display()))?;
std::fs::rename(&partial, &destination)
.map_err(|e| format!("Cannot finish saving {}: {e}", partial.display()))?;
Ok(destination)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn filenames_do_not_overwrite_existing_recordings() {
let directory = tempfile::tempdir().unwrap();
let (_, first, _) = recording_file(directory.path()).unwrap();
let (_, second, _) = recording_file(directory.path()).unwrap();
assert_ne!(first, second);
use std::os::unix::fs::PermissionsExt;
assert_eq!(
std::fs::metadata(first).unwrap().permissions().mode() & 0o777,
0o600
);
}
#[test]
#[ignore = "requires an explicitly provided temporary PipeWire test node"]
fn encoder_finishes_pipewire_stream() {
gst::init().unwrap();
let node = std::env::var("FERESE_TEST_RECORD_NODE").expect("temporary test node required");
let directory = tempfile::tempdir().unwrap();
let source = gst::ElementFactory::make("pipewiresrc")
.property("path", node)
.property("do-timestamp", true)
// Keep queued frames valid when the portal revokes PipeWire buffers.
.property("always-copy", true)
.build()
.unwrap();
let stop = Arc::new(AtomicBool::new(false));
let request_stop = stop.clone();
let stopper = std::thread::spawn(move || {
std::thread::sleep(Duration::from_secs(3));
request_stop.store(true, Ordering::Relaxed);
});
let result = encode(source, Vec::new(), None, directory.path(), stop);
stopper.join().unwrap();
assert_video_decodes(&result.unwrap());
}
#[test]
#[ignore = "requires GStreamer video plugins"]
fn encoder_finishes_a_real_webm() {
gst::init().unwrap();
let directory = tempfile::tempdir().unwrap();
let source = gst::ElementFactory::make("videotestsrc")
.property("num-buffers", 90i32)
.property("is-live", true)
.build()
.unwrap();
let stop = Arc::new(AtomicBool::new(false));
let request_stop = stop.clone();
let stopper = std::thread::spawn(move || {
std::thread::sleep(Duration::from_millis(350));
request_stop.store(true, Ordering::Relaxed);
});
let path = encode(source, Vec::new(), None, directory.path(), stop).unwrap();
stopper.join().unwrap();
let data = std::fs::read(&path).unwrap();
assert_eq!(&data[..4], &[0x1a, 0x45, 0xdf, 0xa3]);
assert!(data.len() > 1000);
assert_video_decodes(&path);
}
#[test]
#[ignore = "requires GStreamer video and audio plugins"]
fn encoder_saves_cropped_video_and_mixed_audio_when_stopped() {
assert_cropped_audio_recording(false, 2, None);
}
#[test]
#[ignore = "requires GStreamer video and audio plugins"]
fn video_eos_finishes_live_audio_without_waiting_for_the_user() {
// Models the portal ending video on lock or monitor removal while the
// audio devices remain available. Every track must finish together.
assert_cropped_audio_recording(true, 1, None);
}
#[test]
#[ignore = "requires an explicitly provided isolated PulseAudio test server"]
fn encoder_captures_isolated_system_and_microphone_audio() {
// The isolated fixture plays 440 Hz on the default output and 660 Hz
// on the default microphone. Both tones must survive combined capture.
let server = std::env::var("FERESE_TEST_RECORD_PULSE_SERVER")
.expect("isolated audio server required");
assert_eq!(std::env::var("PULSE_SERVER").unwrap(), server);
let socket = Path::new(
server
.strip_prefix("unix:")
.expect("explicit Unix socket required"),
);
assert!(socket.starts_with(std::env::temp_dir()));
for audio in [
Audio::System,
Audio::Microphone,
Audio::Both,
Audio::Both,
Audio::Both,
] {
assert_cropped_audio_recording(false, 0, Some(audio));
}
}
fn assert_cropped_audio_recording(
video_eos: bool,
audio_count: usize,
selected_audio: Option<Audio>,
) {
use crate::recording::Crop;
use std::sync::Mutex;
gst::init().unwrap();
let directory = tempfile::tempdir().unwrap();
let video = gst::ElementFactory::make("videotestsrc")
.property("is-live", true)
.property("num-buffers", if video_eos { 18i32 } else { -1i32 })
.build()
.unwrap();
let audio = if let Some(selected_audio) = selected_audio {
audio_sources(selected_audio).unwrap()
} else {
(0..audio_count)
.map(|index| {
gst::ElementFactory::make("audiotestsrc")
.property("is-live", true)
.property("freq", 440. + index as f64 * 220.)
.property("volume", 0.2f64)
.build()
.unwrap()
})
.collect()
};
let stop = Arc::new(AtomicBool::new(false));
let request_stop = stop.clone();
let stopper = (!video_eos).then(|| {
std::thread::spawn(move || {
std::thread::sleep(Duration::from_millis(700));
request_stop.store(true, Ordering::Relaxed);
})
});
let started = Instant::now();
// videotestsrc negotiates 320x240. Crop before RGB conversion, including
// odd edge offsets, and verify the saved stream's negotiated dimensions.
let path = encode(
video,
audio,
Some(Crop {
left: 13,
top: 17,
right: 106,
bottom: 94,
}),
directory.path(),
stop,
)
.unwrap();
if let Some(stopper) = stopper {
stopper.join().unwrap();
}
assert!(started.elapsed() < Duration::from_secs(5));
assert!(!path.with_extension("webm.part").exists());
let decoder = gst::parse::launch(
"filesrc name=input ! matroskademux name=demux \
demux.video_0 ! queue ! vp8dec ! fakesink name=video \
demux.audio_0 ! queue ! opusdec ! audioconvert ! \
audio/x-raw,format=S16LE,rate=48000,channels=1 ! fakesink name=audio",
)
.unwrap()
.downcast::<gst::Pipeline>()
.unwrap();
decoder
.by_name("input")
.unwrap()
.set_property("location", path.to_str().unwrap());
let geometry = Arc::new(Mutex::new(None));
let observed = geometry.clone();
decoder
.by_name("video")
.unwrap()
.static_pad("sink")
.unwrap()
.add_probe(gst::PadProbeType::BUFFER, move |pad, _| {
let caps = pad.current_caps().unwrap();
let structure = caps.structure(0).unwrap();
*observed.lock().unwrap() = Some((
structure.get::<i32>("width").unwrap(),
structure.get::<i32>("height").unwrap(),
));
gst::PadProbeReturn::Ok
});
let samples = Arc::new(Mutex::new(Vec::new()));
let observed = samples.clone();
decoder
.by_name("audio")
.unwrap()
.static_pad("sink")
.unwrap()
.add_probe(gst::PadProbeType::BUFFER, move |_, info| {
let buffer = info.buffer().unwrap();
let data = buffer.map_readable().unwrap();
observed.lock().unwrap().extend(
data.as_slice()
.chunks_exact(2)
.map(|sample| i16::from_le_bytes([sample[0], sample[1]])),
);
gst::PadProbeReturn::Ok
});
decoder.set_state(gst::State::Playing).unwrap();
let result = decoder.bus().unwrap().timed_pop_filtered(
gst::ClockTime::from_seconds(5),
&[gst::MessageType::Eos, gst::MessageType::Error],
);
decoder.set_state(gst::State::Null).unwrap();
assert!(
matches!(
result.as_ref().map(|m| m.view()),
Some(gst::MessageView::Eos(_))
),
"Saved recording did not decode: {result:?}"
);
assert_eq!(*geometry.lock().unwrap(), Some((201, 129)));
let samples = samples.lock().unwrap();
assert!(samples.len() >= 4800, "Less than 100 ms of decoded audio");
let frequencies = match selected_audio {
Some(Audio::System) => vec![440.],
Some(Audio::Microphone) => vec![660.],
Some(Audio::Both) => vec![440., 660.],
Some(Audio::Off) => unreachable!("These tests require audio"),
None => (0..audio_count)
.map(|index| 440. + index as f64 * 220.)
.collect(),
};
for frequency in frequencies {
let amplitude = tone_amplitude(&samples, frequency);
assert!(
amplitude > 0.05,
"Missing {frequency} Hz source in {selected_audio:?} recording: amplitude {amplitude:.4}"
);
}
}
fn tone_amplitude(samples: &[i16], frequency: f64) -> f64 {
// Analyze the middle half to avoid device startup and encoder padding.
// A Hann window limits leakage from the other tone and codec noise.
let samples = &samples[samples.len() / 4..samples.len() * 3 / 4];
let mut real = 0.;
let mut imaginary = 0.;
let mut weight = 0.;
for (index, sample) in samples.iter().enumerate() {
let window = 0.5
- 0.5 * (std::f64::consts::TAU * index as f64 / (samples.len() - 1) as f64).cos();
let angle = std::f64::consts::TAU * frequency * index as f64 / 48_000.;
let sample = *sample as f64 / i16::MAX as f64 * window;
real += sample * angle.cos();
imaginary += sample * angle.sin();
weight += window;
}
2. * real.hypot(imaginary) / weight
}
#[test]
fn frequency_check_rejects_a_mix_with_either_source_missing() {
let tone = |frequency: f64| {
(0..24_000)
.map(|index| {
(0.2 * i16::MAX as f64
* (std::f64::consts::TAU * frequency * index as f64 / 48_000.).sin())
as i16
})
.collect::<Vec<_>>()
};
let system = tone(440.);
let microphone = tone(660.);
let both = system
.iter()
.zip(&microphone)
.map(|(a, b)| a + b)
.collect::<Vec<_>>();
assert!(tone_amplitude(&both, 440.) > 0.05);
assert!(tone_amplitude(&both, 660.) > 0.05);
assert!(tone_amplitude(&microphone, 440.) < 0.01);
assert!(tone_amplitude(&system, 660.) < 0.01);
}
fn assert_video_decodes(path: &Path) {
let decoder = gst::parse::launch("filesrc name=input ! matroskademux ! vp8dec ! fakesink")
.unwrap()
.downcast::<gst::Pipeline>()
.unwrap();
decoder
.by_name("input")
.unwrap()
.set_property("location", path.to_str().unwrap());
decoder.set_state(gst::State::Playing).unwrap();
let message = decoder.bus().unwrap().timed_pop_filtered(
gst::ClockTime::from_seconds(10),
&[gst::MessageType::Eos, gst::MessageType::Error],
);
let duration = decoder.query_duration::<gst::ClockTime>();
decoder.set_state(gst::State::Null).unwrap();
assert!(
duration.is_some_and(|d| d > gst::ClockTime::from_mseconds(100)),
"Invalid saved duration: {duration:?}"
);
assert!(
matches!(
message.as_ref().map(|m| m.view()),
Some(gst::MessageView::Eos(_))
),
"Saved video did not decode: {message:?}"
);
}
}
Reference in new issue View Git Blame Copy Permalink