Your Android phone and your Windows PC, working as one. Local-first, end-to-end encrypted, no account.
// SPDX-License-Identifier: GPL-3.0-or-later
//! Voice recordings received from a paired phone (docs/protocol/recorder.md):
//! naming by date and time without overwriting, optional Media Foundation
//! conversion (`M4A` kept as recorded, `MP3`, `WAV`, or `FLAC`), marker sidecar
//! files (`<stem>.markers.txt`), and the Windows notification on completion.
#![allow(unsafe_code)]
use crate::i18n::tr;
use std::{
fs,
path::{Path, PathBuf},
sync::Mutex,
time::{Instant, SystemTime},
};
use nectarlink_core::{RecordingMarker, Transfer, TransferState};
#[cfg(windows)]
use windows::{
Win32::{
Media::MediaFoundation::{
IMFAttributes, IMFMediaType, IMFSample, IMFSourceReader, MF_MT_AUDIO_AVG_BYTES_PER_SECOND,
MF_MT_AUDIO_BITS_PER_SAMPLE, MF_MT_AUDIO_NUM_CHANNELS, MF_MT_AUDIO_SAMPLES_PER_SECOND,
MF_MT_MAJOR_TYPE, MF_MT_SUBTYPE, MF_SOURCE_READER_FIRST_AUDIO_STREAM,
MF_SOURCE_READERF_ENDOFSTREAM, MF_TRANSCODE_CONTAINERTYPE, MFAudioFormat_FLAC, MFAudioFormat_MP3,
MFAudioFormat_PCM, MFCreateAttributes, MFCreateMediaType, MFCreateSinkWriterFromURL,
MFCreateSourceReaderFromURL, MFMediaType_Audio, MFT_ENUM_FLAG_ALL, MFTranscodeContainerType_MP3,
MFTranscodeGetAudioOutputAvailableTypes,
},
System::SystemInformation::GetLocalTime,
},
core::{HSTRING, Interface},
};
#[cfg(windows)]
use crate::win::h264::ensure_mf_started;
use crate::{
core_host,
settings::{RecordingFormat, Settings},
transfers::{ACTION_OPEN, ACTION_SHOW, TOAST_GROUP},
win::toast::{self, Toast},
};
#[derive(Debug, Default)]
struct RuntimeConfig {
folder: Option<PathBuf>,
format: RecordingFormat,
updated_at: Option<SystemTime>,
}
static CONFIG: Mutex<RuntimeConfig> =
Mutex::new(RuntimeConfig { folder: None, format: RecordingFormat::M4a, updated_at: None });
/// Initializes the in-memory recording preferences from loaded settings.
pub fn init(settings: &Settings) {
let mut cfg = CONFIG.lock().unwrap_or_else(|e| e.into_inner());
cfg.folder = settings.recordings_folder.clone();
cfg.format = settings.recordings_format;
cfg.updated_at = Some(SystemTime::now());
}
pub fn set_folder(folder: Option<PathBuf>) {
let mut cfg = CONFIG.lock().unwrap_or_else(|e| e.into_inner());
cfg.folder = folder;
cfg.updated_at = Some(SystemTime::now());
}
pub fn set_format(format: RecordingFormat) {
let mut cfg = CONFIG.lock().unwrap_or_else(|e| e.into_inner());
cfg.format = format;
cfg.updated_at = Some(SystemTime::now());
}
/// Default folder: `Documents\Nectarlink Recordings`.
pub fn default_folder() -> PathBuf {
dirs::document_dir()
.unwrap_or_else(|| core_host::host().data_dir.join("recordings"))
.join("Nectarlink Recordings")
}
/// The folder where recordings go right now (`configured` if set, otherwise
/// `Documents\Nectarlink Recordings`).
pub fn effective_folder(configured: Option<&Path>) -> PathBuf {
configured.filter(|p| !p.as_os_str().is_empty()).map(Path::to_path_buf).unwrap_or_else(default_folder)
}
fn active_config() -> (PathBuf, RecordingFormat) {
let data_dir = &core_host::host().data_dir;
let settings_path = data_dir.join("desktop-settings.json");
let disk_mtime = fs::metadata(&settings_path).and_then(|m| m.modified()).ok();
let cfg = CONFIG.lock().unwrap_or_else(|e| e.into_inner());
let disk_is_newer = match (disk_mtime, cfg.updated_at) {
(Some(m), Some(u)) => m > u,
(Some(_), None) => true,
_ => false,
};
if disk_is_newer {
drop(cfg);
let loaded = Settings::load(data_dir);
let folder = effective_folder(loaded.recordings_folder.as_deref());
return (folder, loaded.recordings_format);
}
(effective_folder(cfg.folder.as_deref()), cfg.format)
}
/// Formats a recording's base name (`Recording 2026-10-07 14.32`).
pub fn format_recording_stem(year: u16, month: u16, day: u16, hour: u16, minute: u16) -> String {
format!("Recording {year:04}-{month:02}-{day:02} {hour:02}.{minute:02}")
}
/// Base name for a recording saved right now, in local time.
#[cfg(windows)]
pub fn current_recording_stem() -> String {
// SAFETY: GetLocalTime always succeeds and writes a SYSTEMTIME struct.
let st = unsafe { GetLocalTime() };
format_recording_stem(st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute)
}
#[cfg(not(windows))]
pub fn current_recording_stem() -> String {
// SAFETY: `libc::time` and `libc::localtime_r` are thread-safe POSIX calls
// operating on stack-allocated `time_t` and `tm` values.
unsafe {
let mut t: libc::time_t = 0;
libc::time(&mut t);
let mut tm = std::mem::zeroed::<libc::tm>();
libc::localtime_r(&t, &mut tm);
format_recording_stem(
(tm.tm_year + 1900) as u16,
(tm.tm_mon + 1) as u16,
tm.tm_mday as u16,
tm.tm_hour as u16,
tm.tm_min as u16,
)
}
}
/// The name the phone gave a recording (`Recording 2026-10-07 14.32`, from
/// when it started), so one that waited for the PC keeps its own time.
/// `None` for anything else.
pub fn stem_from_phone(name: &str) -> Option<String> {
let stem = Path::new(name).file_stem()?.to_str()?;
// The phone's own " (2)" for two in a minute goes; this folder numbers its own.
let stem = stem.rsplit_once(" (").filter(|(_, n)| n.ends_with(')')).map_or(stem, |(s, _)| s);
let time = stem.strip_prefix("Recording ")?;
let ok = time.len() == "2026-10-07 14.32".len()
&& time.chars().enumerate().all(|(i, c)| match i {
4 | 7 => c == '-',
10 => c == ' ',
13 => c == '.',
_ => c.is_ascii_digit(),
});
ok.then(|| stem.to_owned())
}
/// Picks `dir/<stem>.<ext>`, or `dir/<stem> (2).<ext>` and so on if either the
/// audio file or its `.markers.txt` companion already exists. Never overwrites.
pub fn unique_recording_path(dir: &Path, stem: &str, ext: &str) -> PathBuf {
let ext = ext.trim_start_matches('.');
let first = dir.join(format!("{stem}.{ext}"));
let first_markers = dir.join(format!("{stem}.markers.txt"));
if !first.exists() && !first_markers.exists() {
return first;
}
(2..)
.map(|n| {
let candidate_stem = format!("{stem} ({n})");
(dir.join(format!("{candidate_stem}.{ext}")), dir.join(format!("{candidate_stem}.markers.txt")))
})
.find(|(audio, markers)| !audio.exists() && !markers.exists())
.map(|(audio, _)| audio)
.unwrap_or_else(|| first)
}
/// Companion marker file path next to `audio_path` (`<stem>.markers.txt`).
pub fn markers_path_for(audio_path: &Path) -> PathBuf {
let stem = audio_path.file_stem().and_then(|s| s.to_str()).unwrap_or("Recording");
audio_path.with_file_name(format!("{stem}.markers.txt"))
}
/// Formats recording markers as human-readable lines (`MM:SS.mmm <label>`).
pub fn format_markers(markers: &[RecordingMarker]) -> String {
let mut out = String::new();
for (i, m) in markers.iter().enumerate() {
let ts = format_timestamp_ms(m.at_ms);
match m.label.as_deref().map(str::trim).filter(|l| !l.is_empty()) {
Some(label) => out.push_str(&format!("{ts} {label}\n")),
None => out.push_str(&format!("{ts} Marker {}\n", i + 1)),
}
}
out
}
fn format_timestamp_ms(ms: u64) -> String {
let total_secs = ms / 1000;
let millis = ms % 1000;
let hours = total_secs / 3600;
let mins = (total_secs % 3600) / 60;
let secs = total_secs % 60;
if hours > 0 {
format!("{hours:02}:{mins:02}:{secs:02}.{millis:03}")
} else {
format!("{mins:02}:{secs:02}.{millis:03}")
}
}
/// Moves or converts a received `.m4a` recording into `dest_dir` under `stem`
/// in `format`, falling back to keeping the original `.m4a` if conversion
/// fails, and writes `<stem>.markers.txt` when `markers` is non-empty.
pub fn save_received_recording(
src_m4a: &Path,
dest_dir: &Path,
stem: &str,
format: RecordingFormat,
markers: &[RecordingMarker],
) -> std::io::Result<PathBuf> {
fs::create_dir_all(dest_dir)?;
let final_path = match format {
RecordingFormat::M4a => {
let dest = unique_recording_path(dest_dir, stem, "m4a");
move_file(src_m4a, &dest)?;
dest
}
RecordingFormat::Mp3 | RecordingFormat::Wav | RecordingFormat::Flac => {
let dest = unique_recording_path(dest_dir, stem, format.as_str());
match convert_audio(src_m4a, &dest, format) {
Ok(()) if dest.exists() && fs::metadata(&dest).is_ok_and(|m| m.len() > 0) => {
let _ = fs::remove_file(src_m4a);
dest
}
Ok(()) => {
let _ = fs::remove_file(&dest);
tracing::warn!(format = %format.as_str(), "converted audio was empty; keeping original .m4a");
let fallback = unique_recording_path(dest_dir, stem, "m4a");
move_file(src_m4a, &fallback)?;
fallback
}
Err(e) => {
let _ = fs::remove_file(&dest);
tracing::warn!(error = %e, format = %format.as_str(), "audio conversion failed; keeping original .m4a");
let fallback = unique_recording_path(dest_dir, stem, "m4a");
move_file(src_m4a, &fallback)?;
fallback
}
}
}
};
if !markers.is_empty() {
let markers_file = markers_path_for(&final_path);
if let Err(e) = fs::write(&markers_file, format_markers(markers)) {
tracing::warn!(error = %e, "can't write recording markers file");
}
}
Ok(final_path)
}
fn move_file(src: &Path, dest: &Path) -> std::io::Result<()> {
if fs::rename(src, dest).is_ok() {
return Ok(());
}
fs::copy(src, dest)?;
let _ = fs::remove_file(src);
Ok(())
}
/// ffmpeg arguments that convert `src` into `dest` in `format`. The paths
/// are arguments of their own (never parsed by a shell), and a relative path
/// starting with `-` gets `./` so ffmpeg can't take it for an option.
#[cfg(target_os = "linux")]
pub(crate) fn ffmpeg_args(src: &Path, dest: &Path, format: RecordingFormat) -> Vec<std::ffi::OsString> {
fn not_an_option(path: &Path) -> std::ffi::OsString {
if path.to_string_lossy().starts_with('-') { Path::new(".").join(path).into() } else { path.into() }
}
let codec: &[&str] = match format {
RecordingFormat::M4a => &["-c", "copy"],
RecordingFormat::Mp3 => &["-c:a", "libmp3lame", "-q:a", "2"],
RecordingFormat::Wav => &["-c:a", "pcm_s16le"],
RecordingFormat::Flac => &["-c:a", "flac"],
};
let mut args: Vec<std::ffi::OsString> =
["-nostdin", "-v", "error", "-y", "-i"].into_iter().map(Into::into).collect();
args.push(not_an_option(src));
args.extend(codec.iter().map(Into::into));
args.push(not_an_option(dest));
args
}
/// Converts `src` (`.m4a`) to `dest` in `format` with ffmpeg on Linux.
#[cfg(target_os = "linux")]
pub fn convert_audio(src: &Path, dest: &Path, format: RecordingFormat) -> std::io::Result<()> {
if matches!(format, RecordingFormat::M4a) {
fs::copy(src, dest)?;
return Ok(());
}
let status = std::process::Command::new("ffmpeg")
.args(ffmpeg_args(src, dest, format))
.stdin(std::process::Stdio::null())
.stdout(std::process::Stdio::null())
.stderr(std::process::Stdio::null())
.status()
.map_err(|e| {
if e.kind() == std::io::ErrorKind::NotFound {
std::io::Error::other("converting recordings needs ffmpeg")
} else {
e
}
})?;
if status.success() { Ok(()) } else { Err(std::io::Error::other(format!("ffmpeg exited with {status}"))) }
}
#[cfg(not(any(windows, target_os = "linux")))]
pub fn convert_audio(_src: &Path, _dest: &Path, _format: RecordingFormat) -> Result<(), String> {
Err("audio conversion via Media Foundation is only supported on Windows".into())
}
#[cfg(windows)]
/// Converts `src` (`.m4a`) to `dest` in `format` (`Mp3`, `Wav`, or `Flac`)
/// using Windows Media Foundation.
pub fn convert_audio(src: &Path, dest: &Path, format: RecordingFormat) -> windows::core::Result<()> {
ensure_mf_started()?;
let stream_idx = MF_SOURCE_READER_FIRST_AUDIO_STREAM.0 as u32;
// SAFETY: Media Foundation COM interfaces with owned parameters.
unsafe {
let reader: IMFSourceReader = MFCreateSourceReaderFromURL(&HSTRING::from(src.as_os_str()), None)?;
let pcm_req: IMFMediaType = MFCreateMediaType()?;
pcm_req.SetGUID(&MF_MT_MAJOR_TYPE, &MFMediaType_Audio)?;
pcm_req.SetGUID(&MF_MT_SUBTYPE, &MFAudioFormat_PCM)?;
pcm_req.SetUINT32(&MF_MT_AUDIO_BITS_PER_SAMPLE, 16)?;
reader.SetCurrentMediaType(stream_idx, None, &pcm_req)?;
let pcm_type: IMFMediaType = reader.GetCurrentMediaType(stream_idx)?;
let sample_rate = pcm_type.GetUINT32(&MF_MT_AUDIO_SAMPLES_PER_SECOND)?;
let channels = pcm_type.GetUINT32(&MF_MT_AUDIO_NUM_CHANNELS)?;
match format {
RecordingFormat::M4a => {
fs::copy(src, dest).map_err(|e| {
windows::core::Error::from_hresult(windows::core::HRESULT::from_win32(
e.raw_os_error().unwrap_or(1) as u32,
))
})?;
Ok(())
}
RecordingFormat::Wav => write_decoded_wav(&reader, stream_idx, sample_rate, channels, dest),
RecordingFormat::Mp3 => {
transcode_with_sink_writer(&reader, stream_idx, &pcm_type, sample_rate, channels, dest, true)
}
RecordingFormat::Flac => {
transcode_with_sink_writer(&reader, stream_idx, &pcm_type, sample_rate, channels, dest, false)
}
}
}
}
#[cfg(windows)]
unsafe fn write_decoded_wav(
reader: &IMFSourceReader,
stream_idx: u32,
sample_rate: u32,
channels: u32,
dest: &Path,
) -> windows::core::Result<()> {
let mut pcm_bytes = Vec::new();
loop {
let mut flags = 0u32;
let mut sample: Option<IMFSample> = None;
// SAFETY: valid out-pointers for ReadSample.
unsafe {
reader.ReadSample(stream_idx, 0, None, Some(&mut flags), None, Some(&mut sample))?;
}
if flags & (MF_SOURCE_READERF_ENDOFSTREAM.0 as u32) != 0 {
break;
}
if let Some(sample) = sample {
// SAFETY: buffer is locked while copied and unlocked immediately.
unsafe {
let buffer = sample.ConvertToContiguousBuffer()?;
let mut ptr = std::ptr::null_mut();
let mut len = 0u32;
buffer.Lock(&mut ptr, None, Some(&mut len))?;
if !ptr.is_null() && len > 0 {
pcm_bytes.extend_from_slice(std::slice::from_raw_parts(ptr, len as usize));
}
buffer.Unlock()?;
}
}
}
let ch = u16::try_from(channels.clamp(1, 2)).unwrap_or(1);
let block_align = ch * 2;
let byte_rate = sample_rate * u32::from(block_align);
let data_len = u32::try_from(pcm_bytes.len()).unwrap_or(u32::MAX);
let mut wav = Vec::with_capacity(44 + pcm_bytes.len());
wav.extend_from_slice(b"RIFF");
wav.extend_from_slice(&36u32.saturating_add(data_len).to_le_bytes());
wav.extend_from_slice(b"WAVEfmt ");
wav.extend_from_slice(&16u32.to_le_bytes());
wav.extend_from_slice(&1u16.to_le_bytes()); // PCM
wav.extend_from_slice(&ch.to_le_bytes());
wav.extend_from_slice(&sample_rate.to_le_bytes());
wav.extend_from_slice(&byte_rate.to_le_bytes());
wav.extend_from_slice(&block_align.to_le_bytes());
wav.extend_from_slice(&16u16.to_le_bytes());
wav.extend_from_slice(b"data");
wav.extend_from_slice(&data_len.to_le_bytes());
wav.extend_from_slice(&pcm_bytes);
fs::write(dest, wav).map_err(|_| windows::core::Error::from_thread())
}
#[cfg(windows)]
unsafe fn transcode_with_sink_writer(
reader: &IMFSourceReader,
stream_idx: u32,
pcm_type: &IMFMediaType,
sample_rate: u32,
channels: u32,
dest: &Path,
mp3: bool,
) -> windows::core::Result<()> {
let subtype = if mp3 { MFAudioFormat_MP3 } else { MFAudioFormat_FLAC };
// SAFETY: Media Foundation sink writer setup and sample loop.
unsafe {
let out_type = choose_encoder_output_type(&subtype, sample_rate, channels, mp3)?;
let mut attrs: Option<IMFAttributes> = None;
if mp3 {
MFCreateAttributes(&mut attrs, 1)?;
if let Some(a) = &attrs {
a.SetGUID(&MF_TRANSCODE_CONTAINERTYPE, &MFTranscodeContainerType_MP3)?;
}
}
let writer = MFCreateSinkWriterFromURL(&HSTRING::from(dest.as_os_str()), None, attrs.as_ref())?;
let out_stream = writer.AddStream(&out_type)?;
writer.SetInputMediaType(out_stream, pcm_type, None)?;
writer.BeginWriting()?;
loop {
let mut flags = 0u32;
let mut timestamp = 0i64;
let mut sample: Option<IMFSample> = None;
reader.ReadSample(
stream_idx,
0,
None,
Some(&mut flags),
Some(&mut timestamp),
Some(&mut sample),
)?;
if flags & (MF_SOURCE_READERF_ENDOFSTREAM.0 as u32) != 0 {
break;
}
if let Some(sample) = sample {
let _ = sample.SetSampleTime(timestamp);
writer.WriteSample(out_stream, &sample)?;
}
}
writer.Finalize()?;
}
Ok(())
}
#[cfg(windows)]
unsafe fn choose_encoder_output_type(
subtype: &windows::core::GUID,
sample_rate: u32,
channels: u32,
mp3: bool,
) -> windows::core::Result<IMFMediaType> {
// SAFETY: queries Media Foundation's registered audio encoder output types.
unsafe {
if let Ok(collection) =
MFTranscodeGetAudioOutputAvailableTypes(subtype, MFT_ENUM_FLAG_ALL.0 as u32, None)
{
let count = collection.GetElementCount().unwrap_or(0);
let mut best: Option<(IMFMediaType, u32)> = None;
for i in 0..count {
let Ok(unk) = collection.GetElement(i) else { continue };
let Ok(mt) = unk.cast::<IMFMediaType>() else { continue };
let Ok(sr) = mt.GetUINT32(&MF_MT_AUDIO_SAMPLES_PER_SECOND) else { continue };
let Ok(ch) = mt.GetUINT32(&MF_MT_AUDIO_NUM_CHANNELS) else { continue };
if sr != sample_rate || ch != channels {
continue;
}
if !mp3
&& let Ok(bits) = mt.GetUINT32(&MF_MT_AUDIO_BITS_PER_SAMPLE)
&& bits != 16
{
continue;
}
let byterate = mt.GetUINT32(&MF_MT_AUDIO_AVG_BYTES_PER_SECOND).unwrap_or(16_000);
// Prefer ~128 kbps (16000 B/s) for MP3.
let dist = byterate.abs_diff(16_000);
if best.as_ref().is_none_or(|(_, best_dist)| dist < *best_dist) {
best = Some((mt, dist));
}
}
if let Some((chosen, _)) = best {
return Ok(chosen);
}
}
let mt: IMFMediaType = MFCreateMediaType()?;
mt.SetGUID(&MF_MT_MAJOR_TYPE, &MFMediaType_Audio)?;
mt.SetGUID(&MF_MT_SUBTYPE, subtype)?;
mt.SetUINT32(&MF_MT_AUDIO_SAMPLES_PER_SECOND, sample_rate)?;
mt.SetUINT32(&MF_MT_AUDIO_NUM_CHANNELS, channels)?;
if mp3 {
mt.SetUINT32(&MF_MT_AUDIO_AVG_BYTES_PER_SECOND, 16_000)?;
} else {
mt.SetUINT32(&MF_MT_AUDIO_BITS_PER_SAMPLE, 16)?;
}
Ok(mt)
}
}
/// Handles a completed incoming voice recording transfer off the UI thread:
/// moves/converts the file into the Recordings folder, writes markers when
/// present, updates the transfer entry in Home, and posts the Windows toast.
pub fn on_done(transfer: Transfer) {
let TransferState::Done { ref saved } = transfer.state else { return };
let Some(src) = saved.first().cloned() else { return };
let (dest_dir, format) = active_config();
let stem = transfer.names.first().and_then(|n| stem_from_phone(n)).unwrap_or_else(current_recording_stem);
core_host::spawn(async move {
let markers = transfer.markers.clone();
let src_for_job = src.clone();
let dir_for_job = dest_dir.clone();
let result = tokio::task::spawn_blocking(move || {
save_received_recording(&src_for_job, &dir_for_job, &stem, format, &markers)
})
.await;
let final_path = match result {
Ok(Ok(path)) => path,
Ok(Err(e)) => {
tracing::warn!(error = %e, "couldn't move or convert recording; keeping received path");
src
}
Err(e) => {
tracing::warn!(error = %e, "recording task panicked");
src
}
};
let file_name = final_path
.file_name()
.and_then(|n| n.to_str())
.map(str::to_owned)
.unwrap_or_else(|| "Recording.m4a".into());
let mut updated = transfer.clone();
updated.names = vec![file_name.clone()];
if let Ok(meta) = fs::metadata(&final_path) {
updated.total = meta.len();
updated.done = meta.len();
}
updated.state = TransferState::Done { saved: vec![final_path.clone()] };
let total_bytes = updated.total;
core_host::host().hub.update(|s| s.update_transfer(updated, Instant::now()));
if let Some(node) = core_host::node() {
let final_path_str = final_path.to_string_lossy();
let detail = match transfer.markers.len() {
0 => String::new(),
1 => "1 marker".to_owned(),
n => format!("{n} markers"),
};
node.update_timeline_by_ref(
&transfer.id,
nectarlink_core::TimelineKind::Recording,
&file_name,
&detail,
&final_path_str,
total_bytes,
);
}
let device = core_host::host()
.hub
.read(|s| s.name_of(&transfer.device))
.unwrap_or_else(|| "your phone".into());
let body = if transfer.markers.is_empty() {
file_name
} else if transfer.markers.len() == 1 {
format!("{file_name} · 1 marker")
} else {
format!("{file_name} · {} markers", transfer.markers.len())
};
toast::show(Toast {
device: TOAST_GROUP.into(),
key: final_path.to_string_lossy().into_owned(),
title: tr!("Recordings", "Recording from %1 saved", device),
body,
attribution: "NectarLink".into(),
icon: None,
image: None,
actions: vec![(ACTION_OPEN.into(), "Open".into()), (ACTION_SHOW.into(), "Show in folder".into())],
reply: None,
silent: false,
progress: None,
call: false,
});
});
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn recordings_keep_the_phones_time() {
assert_eq!(
stem_from_phone("Recording 2026-10-07 14.32.m4a").as_deref(),
Some("Recording 2026-10-07 14.32")
);
assert_eq!(
stem_from_phone("Recording 2026-10-07 14.32 (2).m4a").as_deref(),
Some("Recording 2026-10-07 14.32")
);
assert_eq!(stem_from_phone("Recording ../../x.m4a"), None);
assert_eq!(stem_from_phone("Voice 2026-10-07 14.32.m4a"), None);
assert_eq!(stem_from_phone("Recording 2026-10-07 14.32 extra.m4a"), None);
}
/// Builds a valid 48 kHz mono AAC-LC `.m4a` file for Media Foundation tests.
#[allow(dead_code)]
fn test_m4a(duration_secs: u32) -> Vec<u8> {
const AAC_FRAME: [u8; 6] = [0x01, 0x48, 0x00, 0x84, 0x21, 0x7E];
const SAMPLE_RATE: u32 = 48_000;
let num_frames = (duration_secs.max(1) * SAMPLE_RATE).div_ceil(1024).max(1);
let total_samples = num_frames * 1024;
fn mp4_box(fourcc: &[u8; 4], payload: &[u8]) -> Vec<u8> {
let len = (8 + payload.len()) as u32;
let mut out = Vec::with_capacity(len as usize);
out.extend_from_slice(&len.to_be_bytes());
out.extend_from_slice(fourcc);
out.extend_from_slice(payload);
out
}
fn full_box(fourcc: &[u8; 4], version: u8, flags: u32, body: &[u8]) -> Vec<u8> {
let mut payload = Vec::with_capacity(4 + body.len());
payload.push(version);
payload.extend_from_slice(&flags.to_be_bytes()[1..4]);
payload.extend_from_slice(body);
mp4_box(fourcc, &payload)
}
let mut ftyp_body = Vec::new();
ftyp_body.extend_from_slice(b"M4A ");
ftyp_body.extend_from_slice(&0u32.to_be_bytes());
ftyp_body.extend_from_slice(b"M4A mp42isom\0\0\0\0");
let ftyp = mp4_box(b"ftyp", &ftyp_body);
let build_moov = |chunk_offset: u32| -> Vec<u8> {
let mut mvhd = Vec::new();
mvhd.extend_from_slice(&0u32.to_be_bytes());
mvhd.extend_from_slice(&0u32.to_be_bytes());
mvhd.extend_from_slice(&SAMPLE_RATE.to_be_bytes());
mvhd.extend_from_slice(&total_samples.to_be_bytes());
mvhd.extend_from_slice(&0x0001_0000u32.to_be_bytes());
mvhd.extend_from_slice(&0x0100u16.to_be_bytes());
mvhd.extend_from_slice(&[0u8; 10]);
for &m in &[0x0001_0000u32, 0, 0, 0, 0x0001_0000, 0, 0, 0, 0x4000_0000] {
mvhd.extend_from_slice(&m.to_be_bytes());
}
mvhd.extend_from_slice(&[0u8; 24]);
mvhd.extend_from_slice(&2u32.to_be_bytes());
let mvhd_box = full_box(b"mvhd", 0, 0, &mvhd);
let mut tkhd = Vec::new();
tkhd.extend_from_slice(&0u32.to_be_bytes());
tkhd.extend_from_slice(&0u32.to_be_bytes());
tkhd.extend_from_slice(&1u32.to_be_bytes());
tkhd.extend_from_slice(&0u32.to_be_bytes());
tkhd.extend_from_slice(&total_samples.to_be_bytes());
tkhd.extend_from_slice(&[0u8; 8]);
tkhd.extend_from_slice(&0u16.to_be_bytes());
tkhd.extend_from_slice(&0u16.to_be_bytes());
tkhd.extend_from_slice(&0x0100u16.to_be_bytes());
tkhd.extend_from_slice(&0u16.to_be_bytes());
for &m in &[0x0001_0000u32, 0, 0, 0, 0x0001_0000, 0, 0, 0, 0x4000_0000] {
tkhd.extend_from_slice(&m.to_be_bytes());
}
tkhd.extend_from_slice(&0u32.to_be_bytes());
tkhd.extend_from_slice(&0u32.to_be_bytes());
let tkhd_box = full_box(b"tkhd", 0, 3, &tkhd);
let mut mdhd = Vec::new();
mdhd.extend_from_slice(&0u32.to_be_bytes());
mdhd.extend_from_slice(&0u32.to_be_bytes());
mdhd.extend_from_slice(&SAMPLE_RATE.to_be_bytes());
mdhd.extend_from_slice(&total_samples.to_be_bytes());
mdhd.extend_from_slice(&0x55c4u16.to_be_bytes());
mdhd.extend_from_slice(&0u16.to_be_bytes());
let mdhd_box = full_box(b"mdhd", 0, 0, &mdhd);
let mut hdlr = Vec::new();
hdlr.extend_from_slice(&0u32.to_be_bytes());
hdlr.extend_from_slice(b"soun");
hdlr.extend_from_slice(&[0u8; 12]);
hdlr.extend_from_slice(b"SoundHandler\0");
let hdlr_box = full_box(b"hdlr", 0, 0, &hdlr);
let smhd_box = full_box(b"smhd", 0, 0, &[0u8; 4]);
let url_box = full_box(b"url ", 0, 1, &[]);
let mut dref = Vec::new();
dref.extend_from_slice(&1u32.to_be_bytes());
dref.extend_from_slice(&url_box);
let dinf_box = mp4_box(b"dinf", &full_box(b"dref", 0, 0, &dref));
let esds_body: [u8; 27] = [
0x03, 25, 0x00, 0x01, 0x00, 0x04, 17, 0x40, 0x15, 0x00, 0x00, 0x00, 0x00, 0x01, 0xF4, 0x00,
0x00, 0x01, 0xF4, 0x00, 0x05, 2, 0x11, 0x88, 0x06, 1, 0x02,
];
let esds_box = full_box(b"esds", 0, 0, &esds_body);
let mut mp4a = Vec::new();
mp4a.extend_from_slice(&[0u8; 6]);
mp4a.extend_from_slice(&1u16.to_be_bytes());
mp4a.extend_from_slice(&[0u8; 8]);
mp4a.extend_from_slice(&1u16.to_be_bytes());
mp4a.extend_from_slice(&16u16.to_be_bytes());
mp4a.extend_from_slice(&0u16.to_be_bytes());
mp4a.extend_from_slice(&0u16.to_be_bytes());
mp4a.extend_from_slice(&(SAMPLE_RATE << 16).to_be_bytes());
mp4a.extend_from_slice(&esds_box);
let mp4a_box = mp4_box(b"mp4a", &mp4a);
let mut stsd = Vec::new();
stsd.extend_from_slice(&1u32.to_be_bytes());
stsd.extend_from_slice(&mp4a_box);
let stsd_box = full_box(b"stsd", 0, 0, &stsd);
let mut stts = Vec::new();
stts.extend_from_slice(&1u32.to_be_bytes());
stts.extend_from_slice(&num_frames.to_be_bytes());
stts.extend_from_slice(&1024u32.to_be_bytes());
let stts_box = full_box(b"stts", 0, 0, &stts);
let mut stsc = Vec::new();
stsc.extend_from_slice(&1u32.to_be_bytes());
stsc.extend_from_slice(&1u32.to_be_bytes());
stsc.extend_from_slice(&num_frames.to_be_bytes());
stsc.extend_from_slice(&1u32.to_be_bytes());
let stsc_box = full_box(b"stsc", 0, 0, &stsc);
let mut stsz = Vec::new();
stsz.extend_from_slice(&(AAC_FRAME.len() as u32).to_be_bytes());
stsz.extend_from_slice(&num_frames.to_be_bytes());
let stsz_box = full_box(b"stsz", 0, 0, &stsz);
let mut stco = Vec::new();
stco.extend_from_slice(&1u32.to_be_bytes());
stco.extend_from_slice(&chunk_offset.to_be_bytes());
let stco_box = full_box(b"stco", 0, 0, &stco);
let mut stbl_body = Vec::new();
stbl_body.extend_from_slice(&stsd_box);
stbl_body.extend_from_slice(&stts_box);
stbl_body.extend_from_slice(&stsc_box);
stbl_body.extend_from_slice(&stsz_box);
stbl_body.extend_from_slice(&stco_box);
let stbl_box = mp4_box(b"stbl", &stbl_body);
let mut minf_body = Vec::new();
minf_body.extend_from_slice(&smhd_box);
minf_body.extend_from_slice(&dinf_box);
minf_body.extend_from_slice(&stbl_box);
let minf_box = mp4_box(b"minf", &minf_body);
let mut mdia_body = Vec::new();
mdia_body.extend_from_slice(&mdhd_box);
mdia_body.extend_from_slice(&hdlr_box);
mdia_body.extend_from_slice(&minf_box);
let mdia_box = mp4_box(b"mdia", &mdia_body);
let mut trak_body = Vec::new();
trak_body.extend_from_slice(&tkhd_box);
trak_body.extend_from_slice(&mdia_box);
let trak_box = mp4_box(b"trak", &trak_body);
let mut moov_body = Vec::new();
moov_body.extend_from_slice(&mvhd_box);
moov_body.extend_from_slice(&trak_box);
mp4_box(b"moov", &moov_body)
};
let moov_len = build_moov(0).len();
let chunk_offset = (ftyp.len() + moov_len + 8) as u32;
let moov = build_moov(chunk_offset);
let mdat_payload = AAC_FRAME.repeat(num_frames as usize);
let mdat = mp4_box(b"mdat", &mdat_payload);
let mut out = Vec::with_capacity(ftyp.len() + moov.len() + mdat.len());
out.extend_from_slice(&ftyp);
out.extend_from_slice(&moov);
out.extend_from_slice(&mdat);
out
}
#[test]
fn naming_and_collision_avoidance_never_overwrite() {
let dir = tempfile::tempdir().unwrap();
let stem = format_recording_stem(2026, 10, 7, 14, 32);
assert_eq!(stem, "Recording 2026-10-07 14.32");
let p1 = unique_recording_path(dir.path(), &stem, "m4a");
assert_eq!(p1, dir.path().join("Recording 2026-10-07 14.32.m4a"));
fs::write(&p1, b"first").unwrap();
let p2 = unique_recording_path(dir.path(), &stem, "m4a");
assert_eq!(p2, dir.path().join("Recording 2026-10-07 14.32 (2).m4a"));
fs::write(&p2, b"second").unwrap();
// Even if only the marker file for (3) exists, (3) is skipped so it isn't overwritten.
fs::write(dir.path().join("Recording 2026-10-07 14.32 (3).markers.txt"), b"m").unwrap();
let p4 = unique_recording_path(dir.path(), &stem, "m4a");
assert_eq!(p4, dir.path().join("Recording 2026-10-07 14.32 (4).m4a"));
}
#[test]
fn marker_files_format_timestamps_and_labels() {
let markers = vec![
RecordingMarker { at_ms: 1_250, label: Some("Intro".into()) },
RecordingMarker { at_ms: 65_000, label: None },
RecordingMarker { at_ms: 3_661_005, label: Some("Wrap-up".into()) },
];
let text = format_markers(&markers);
assert_eq!(text, "00:01.250 Intro\n01:05.000 Marker 2\n01:01:01.005 Wrap-up\n");
let stem = current_recording_stem();
assert!(stem.starts_with("Recording "));
assert_eq!(stem_from_phone(&format!("{stem}.m4a")).as_deref(), Some(stem.as_str()));
#[cfg(target_os = "linux")]
{
let args = ffmpeg_args(
Path::new("-odd name!.m4a"),
Path::new("/tmp/out it's.mp3"),
RecordingFormat::Mp3,
);
let args: Vec<String> = args.iter().map(|a| a.to_string_lossy().into_owned()).collect();
assert_eq!(args[..5], ["-nostdin", "-v", "error", "-y", "-i"]);
assert_eq!(args[5], "./-odd name!.m4a", "a path can't be read as an option");
assert!(args.windows(2).any(|w| w == ["-c:a", "libmp3lame"]));
assert_eq!(
args.last().map(String::as_str),
Some("/tmp/out it's.mp3"),
"names are passed as they are"
);
}
}
#[cfg(any(windows, target_os = "linux"))]
#[test]
fn media_foundation_converts_m4a_to_m4a_mp3_wav_and_flac_with_markers() {
let dir = tempfile::tempdir().unwrap();
let stem = "Recording 2026-10-07 14.32";
let markers = vec![
RecordingMarker { at_ms: 500, label: Some("Start".into()) },
RecordingMarker { at_ms: 1_500, label: None },
];
for format in
[RecordingFormat::M4a, RecordingFormat::Mp3, RecordingFormat::Wav, RecordingFormat::Flac]
{
let src = dir.path().join(format!("incoming-{}.m4a", format.as_str()));
fs::write(&src, test_m4a(2)).unwrap();
let out_dir = dir.path().join(format.as_str());
let saved = save_received_recording(&src, &out_dir, stem, format, &markers).unwrap();
assert!(!src.exists(), "temporary incoming file is removed for {}", format.as_str());
assert_eq!(
saved.extension().and_then(|e| e.to_str()),
Some(format.as_str()),
"saved in requested format {}",
format.as_str()
);
let bytes = fs::read(&saved).unwrap();
assert!(bytes.len() > 100, "{} output has non-trivial size ({} B)", format.as_str(), bytes.len());
match format {
RecordingFormat::M4a => assert_eq!(&bytes[4..8], b"ftyp"),
RecordingFormat::Wav => {
assert_eq!(&bytes[0..4], b"RIFF");
assert_eq!(&bytes[8..12], b"WAVE");
}
RecordingFormat::Flac => assert_eq!(&bytes[0..4], b"fLaC"),
RecordingFormat::Mp3 => {
// Either ID3 tag or MP3 frame sync (0xFF 0xFB / 0xF3 / 0xF2).
assert!(
&bytes[0..3] == b"ID3" || (bytes[0] == 0xFF && (bytes[1] & 0xE0) == 0xE0),
"valid MP3 header: {:02X?}",
&bytes[..4]
);
}
}
let marker_path = markers_path_for(&saved);
assert!(marker_path.exists(), "marker file written next to {}", saved.display());
assert_eq!(fs::read_to_string(&marker_path).unwrap(), "00:00.500 Start\n00:01.500 Marker 2\n");
}
}
}