Add local spoken passages with Google retrieval and isolated runtime setup

This commit is contained in:
karl committed 2026-10-13 20:18:44 +02:00
1 parent bc9459785d
commit dab703413e
55 files changed
+3633 -70

No files matched your search

@@ -0,0 +1,225 @@
//! Timeline contract uses actual CPU FFmpeg, without speech/model inference.
use anyhow::{Context, Result};
use searchi_media::{decode_audio, decode_audio_aligned, probe, AudioWindow};
use searchi_service::{FfmpegTools, MediaLimits};
use std::{path::Path, process::Command};
fn fixture(ffmpeg: &Path, args: &[&str], output: &Path) -> Result<()> {
let result = Command::new(ffmpeg)
.args([
"-nostdin",
"-hide_banner",
"-loglevel",
"error",
"-threads",
"1",
])
.args(args)
.arg(output)
.output()?;
anyhow::ensure!(
result.status.success(),
"Owned CPU media fixture failed: {}",
String::from_utf8_lossy(&result.stderr)
);
Ok(())
}
#[test]
#[ignore = "Requires verified CPU FFmpeg/FFprobe helpers; no model inference"]
fn positioned_audio_decodes_at_its_actual_file_timeline_origin() -> Result<()> {
assert_eq!(std::env::var("SEARCHI_FORCE_CPU")?, "1");
let tools = FfmpegTools {
ffmpeg: std::env::var_os("SEARCHI_TEST_FFMPEG")
.context("Set SEARCHI_TEST_FFMPEG")?
.into(),
ffprobe: std::env::var_os("SEARCHI_TEST_FFPROBE")
.context("Set SEARCHI_TEST_FFPROBE")?
.into(),
};
let directory = tempfile::tempdir()?;
let ordinary = directory.path().join("ordinary.wav");
let positioned = directory.path().join("positioned.mkv");
fixture(
&tools.ffmpeg,
&[
"-f",
"lavfi",
"-i",
"sine=frequency=440:sample_rate=16000:duration=2",
"-c:a",
"pcm_s16le",
],
&ordinary,
)?;
fixture(
&tools.ffmpeg,
&[
"-f",
"lavfi",
"-i",
"color=size=16x16:rate=1:duration=4",
"-itsoffset",
"2",
"-f",
"lavfi",
"-i",
"sine=frequency=440:sample_rate=16000:duration=2",
"-map",
"0:v:0",
"-map",
"1:a:0",
"-c:v",
"ffv1",
"-c:a",
"pcm_s16le",
"-threads",
"1",
],
&positioned,
)?;
let limits = MediaLimits::default();
let metadata = probe(&tools, &positioned, &limits)?;
assert_eq!(metadata.start_ms, 0);
assert_eq!(metadata.audio_start_ms, 2000);
assert_eq!(metadata.audio_end_ms, 4000);
let baseline = decode_audio(
&tools,
&ordinary,
AudioWindow {
start_ms: 0,
duration_ms: 2000,
},
&limits,
)?;
let actual = decode_audio(
&tools,
&positioned,
AudioWindow {
start_ms: metadata.audio_start_ms,
duration_ms: metadata.audio_end_ms - metadata.audio_start_ms,
},
&limits,
)?;
assert_eq!(baseline.len(), 32000);
let aligned = decode_audio_aligned(
&tools,
&positioned,
AudioWindow {
start_ms: 2000,
duration_ms: 2000,
},
&limits,
)?;
assert_eq!(aligned, baseline);
let whole = decode_audio_aligned(
&tools,
&positioned,
AudioWindow {
start_ms: 0,
duration_ms: 4000,
},
&limits,
)?;
assert_eq!(whole.len(), 64000);
assert!(whole[..32000].iter().all(|sample| *sample == 0.));
assert_eq!(&whole[32000..], baseline.as_slice());
assert_eq!(
actual, baseline,
"First decoded sample must represent the requested actual audio origin"
);
Ok(())
}
#[test]
#[ignore = "Requires verified CPU FFmpeg/FFprobe helpers; no model inference"]
fn aligned_decoder_preserves_internal_gap_seek_and_tail_source_clock() -> Result<()> {
assert_eq!(std::env::var("SEARCHI_FORCE_CPU")?, "1");
let tools = FfmpegTools {
ffmpeg: std::env::var_os("SEARCHI_TEST_FFMPEG")
.context("Set SEARCHI_TEST_FFMPEG")?
.into(),
ffprobe: std::env::var_os("SEARCHI_TEST_FFPROBE")
.context("Set SEARCHI_TEST_FFPROBE")?
.into(),
};
let directory = tempfile::tempdir()?;
let ordinary = directory.path().join("ramp.wav");
let gapped = directory.path().join("gapped.mka");
fixture(
&tools.ffmpeg,
&[
"-f",
"lavfi",
"-i",
"aevalsrc=0.1+0.1*t:s=16000:d=3",
"-c:a",
"pcm_s16le",
],
&ordinary,
)?;
// Three exact one-second frames carry PTS 0,2,3; the source clock has a one-second gap.
fixture(
&tools.ffmpeg,
&[
"-f",
"lavfi",
"-i",
"aevalsrc=0.1+0.1*t:s=16000:d=3",
"-af",
"asetnsamples=n=16000:p=0,asetpts=PTS+gte(T\\,1)/TB",
"-c:a",
"pcm_s16le",
],
&gapped,
)?;
let limits = MediaLimits::default();
let metadata = probe(&tools, &gapped, &limits)?;
assert_eq!(metadata.start_ms, 0);
assert_eq!(metadata.audio_start_ms, 0);
assert_eq!(metadata.audio_end_ms, 4000);
let source = decode_audio(
&tools,
&ordinary,
AudioWindow {
start_ms: 0,
duration_ms: 3000,
},
&limits,
)?;
assert_eq!(source.len(), 48000);
let mut expected = source[..16000].to_vec();
expected.extend(vec![0.; 16000]);
expected.extend_from_slice(&source[16000..]);
let whole = decode_audio_aligned(
&tools,
&gapped,
AudioWindow {
start_ms: 0,
duration_ms: 4000,
},
&limits,
)?;
assert_eq!(whole, expected);
let seek = decode_audio_aligned(
&tools,
&gapped,
AudioWindow {
start_ms: 1500,
duration_ms: 1500,
},
&limits,
)?;
assert_eq!(seek, &expected[24000..48000]);
let tail = decode_audio_aligned(
&tools,
&gapped,
AudioWindow {
start_ms: 3500,
duration_ms: 500,
},
&limits,
)?;
assert_eq!(tail, &expected[56000..64000]);
Ok(())
}