feat #14740: merge mic and output transcripts

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
This commit is contained in:
hauke
2026-11-05 15:21:01 +01:00
co-authored by Claude Sonnet 5
parent d82a5b9e30
commit 61bf18e47f
2 changed files with 527 additions and 0 deletions
+526
View File
@@ -0,0 +1,526 @@
//! Pure merge of the two per-call transcripts — the mic track (always the
//! local user) and the output track (the remote side, diarized into raw
//! speaker ids) — into one time-ordered conversation. Does no I/O; callers
//! feed in words already produced by transcription and consume the
//! resulting [`Segment`]s.
use std::cmp::Ordering;
use std::collections::BTreeMap;
use crate::model::{Segment, Speaker, Word};
/// Longest gap, in seconds, that still belongs to the same segment. A gap
/// strictly greater than this starts a new segment while grouping a track's
/// words (step 2); a gap at most this long lets two same-speaker segments
/// that ended up adjacent after sorting be merged back together (step 4).
const MAX_GAP_SECONDS: f64 = 1.5;
/// One word already attributed to a [`Speaker`], in the shape the grouping
/// step needs (the mic track's own `speaker` field is never consulted —
/// mic words are always [`Speaker::Me`]).
struct WordEvent {
speaker: Speaker,
start: f64,
end: f64,
text: String,
}
/// Merges the mic track and the output track into one time-ordered list of
/// segments.
///
/// 1. Mic words become [`Speaker::Me`] (their own `speaker` field is
/// ignored). Output words become [`Speaker::Remote`], numbered from 1 by
/// first appearance (in time order) of the raw `speaker` id; `None`
/// counts as one id like any other.
/// 2. Per track, consecutive words from the same speaker are grouped into a
/// segment, splitting on a pause longer than 1.5 s.
/// 3. Both tracks' segments are sorted by `start` (stable; ties put the mic
/// first, then remote speakers in ascending number order).
/// 4. Segments left adjacent in that sorted list are merged when they share
/// a speaker and the gap between them is at most 1.5 s.
/// 5. A segment's text is its words' text, trimmed and joined with single
/// spaces, skipping words whose trimmed text is empty.
///
/// A track's words need not arrive sorted; they are stably sorted by
/// `start` first. A NaN `start`/`end` is treated as `0.0` for ordering so
/// malformed input never panics.
pub fn merge(mic: &[Word], out: &[Word]) -> Vec<Segment> {
let mic_events: Vec<WordEvent> = sort_words(mic)
.into_iter()
.map(|w| WordEvent {
speaker: Speaker::Me,
start: w.start,
end: w.end,
text: w.text,
})
.collect();
let out_events: Vec<WordEvent> = {
let mut seen_ids: Vec<Option<String>> = Vec::new();
sort_words(out)
.into_iter()
.map(|w| {
let number = match seen_ids.iter().position(|id| id == &w.speaker) {
Some(index) => index,
None => {
seen_ids.push(w.speaker.clone());
seen_ids.len() - 1
}
} as u32
+ 1;
WordEvent {
speaker: Speaker::Remote(number),
start: w.start,
end: w.end,
text: w.text,
}
})
.collect()
};
let mut segments = group_segments(&mic_events);
segments.extend(group_segments(&out_events));
segments.sort_by(cmp_for_merge_order);
merge_adjacent(segments)
}
/// The renamed label for `speaker`, or its [`Speaker::default_label`] if it
/// was never renamed, or the rename is present but blank.
pub fn label(speaker: &Speaker, names: &BTreeMap<String, String>) -> String {
match names.get(&speaker.key()) {
Some(name) if !name.trim().is_empty() => name.clone(),
_ => speaker.default_label(),
}
}
/// Orders by `start` (NaN treated as `0.0`), then — for ties — puts the mic
/// first and orders remote speakers by ascending number.
fn cmp_for_merge_order(a: &Segment, b: &Segment) -> Ordering {
order_key(a.start)
.total_cmp(&order_key(b.start))
.then_with(|| speaker_rank(a.speaker).cmp(&speaker_rank(b.speaker)))
}
fn speaker_rank(speaker: Speaker) -> (u8, u32) {
match speaker {
Speaker::Me => (0, 0),
Speaker::Remote(n) => (1, n),
}
}
/// `start`/`end` values ordered as-is, except NaN sorts as `0.0`.
fn order_key(value: f64) -> f64 {
if value.is_nan() {
0.0
} else {
value
}
}
fn sort_words(words: &[Word]) -> Vec<Word> {
let mut sorted = words.to_vec();
sorted.sort_by(|a, b| order_key(a.start).total_cmp(&order_key(b.start)));
sorted
}
/// Accumulates one segment's words while grouping a track.
struct Building {
speaker: Speaker,
start: f64,
/// Max end seen across the segment's words so far (words need not be
/// sorted by end, only by start).
max_end: f64,
/// End of the literal previous word, used for the pause-split check —
/// deliberately not `max_end`, so an earlier long word does not paper
/// over a real pause after a later, shorter one.
prev_word_end: f64,
texts: Vec<String>,
}
impl Building {
fn start_new(event: &WordEvent) -> Self {
let mut texts = Vec::new();
push_text(&mut texts, &event.text);
Building {
speaker: event.speaker,
start: event.start,
max_end: event.end,
prev_word_end: event.end,
texts,
}
}
fn extend(&mut self, event: &WordEvent) {
self.max_end = self.max_end.max(event.end);
self.prev_word_end = event.end;
push_text(&mut self.texts, &event.text);
}
fn finish(self) -> Segment {
Segment {
speaker: self.speaker,
start: self.start,
end: self.max_end,
text: self.texts.join(" "),
}
}
}
fn push_text(texts: &mut Vec<String>, raw: &str) {
let trimmed = raw.trim();
if !trimmed.is_empty() {
texts.push(trimmed.to_string());
}
}
/// Groups a single track's words (already sorted by `start`) into segments,
/// splitting whenever the speaker changes or the pause since the previous
/// word exceeds [`MAX_GAP_SECONDS`].
fn group_segments(events: &[WordEvent]) -> Vec<Segment> {
let mut result = Vec::new();
let mut current: Option<Building> = None;
for event in events {
let continues = current.as_ref().is_some_and(|building| {
building.speaker == event.speaker
&& event.start - building.prev_word_end <= MAX_GAP_SECONDS
});
if continues {
current.as_mut().unwrap().extend(event);
} else {
if let Some(building) = current.take() {
result.push(building.finish());
}
current = Some(Building::start_new(event));
}
}
if let Some(building) = current {
result.push(building.finish());
}
result
}
/// Merges segments left adjacent after sorting when they share a speaker
/// and the gap between them is at most [`MAX_GAP_SECONDS`]. Unlike the
/// per-track grouping in [`group_segments`], the gap here is measured
/// against the previous segment's recorded `end` (its words' max end), so a
/// pause that only looked long at the word level can still be closed back
/// up once segments are considered as a whole.
fn merge_adjacent(segments: Vec<Segment>) -> Vec<Segment> {
let mut merged: Vec<Segment> = Vec::with_capacity(segments.len());
for segment in segments {
let should_merge = merged.last().is_some_and(|last: &Segment| {
last.speaker == segment.speaker && segment.start - last.end <= MAX_GAP_SECONDS
});
if should_merge {
let last = merged.last_mut().expect("just checked non-empty");
last.end = last.end.max(segment.end);
last.text = join_text(&last.text, &segment.text);
} else {
merged.push(segment);
}
}
merged
}
fn join_text(a: &str, b: &str) -> String {
match (a.is_empty(), b.is_empty()) {
(true, true) => String::new(),
(true, false) => b.to_string(),
(false, true) => a.to_string(),
(false, false) => format!("{a} {b}"),
}
}
#[cfg(test)]
mod tests {
use super::{label, merge};
use crate::model::{Segment, Speaker, Word};
use std::collections::BTreeMap;
fn w(text: &str, start: f64, end: f64, speaker: Option<&str>) -> Word {
Word {
text: text.to_string(),
start,
end,
speaker: speaker.map(str::to_string),
}
}
#[test]
fn interleaves_by_time() {
let mic = vec![
w("hallo", 0.0, 1.0, None),
w("wie gehts", 1.0, 2.0, None),
w("tschuess", 4.5, 6.0, None),
];
let out = vec![w("mir gehts gut", 2.5, 4.0, Some("SPEAKER_00"))];
assert_eq!(
merge(&mic, &out),
vec![
Segment {
speaker: Speaker::Me,
start: 0.0,
end: 2.0,
text: "hallo wie gehts".to_string(),
},
Segment {
speaker: Speaker::Remote(1),
start: 2.5,
end: 4.0,
text: "mir gehts gut".to_string(),
},
Segment {
speaker: Speaker::Me,
start: 4.5,
end: 6.0,
text: "tschuess".to_string(),
},
]
);
}
#[test]
fn numbers_remote_speakers_by_first_appearance() {
let out = vec![
w("drei", 0.0, 1.0, Some("SPEAKER_03")),
w("null", 5.0, 6.0, Some("SPEAKER_00")),
];
assert_eq!(
merge(&[], &out),
vec![
Segment {
speaker: Speaker::Remote(1),
start: 0.0,
end: 1.0,
text: "drei".to_string(),
},
Segment {
speaker: Speaker::Remote(2),
start: 5.0,
end: 6.0,
text: "null".to_string(),
},
]
);
}
#[test]
fn splits_same_speaker_on_long_pause() {
let mic = vec![
w("eins", 0.0, 1.0, None),
// Gap since the previous word is 2.0 s, over the 1.5 s limit.
w("zwei", 3.0, 4.0, None),
];
assert_eq!(
merge(&mic, &[]),
vec![
Segment {
speaker: Speaker::Me,
start: 0.0,
end: 1.0,
text: "eins".to_string(),
},
Segment {
speaker: Speaker::Me,
start: 3.0,
end: 4.0,
text: "zwei".to_string(),
},
]
);
}
#[test]
fn null_speaker_ids_are_one_remote() {
let out = vec![w("a", 0.0, 1.0, None), w("b", 1.0, 2.0, None)];
assert_eq!(
merge(&[], &out),
vec![Segment {
speaker: Speaker::Remote(1),
start: 0.0,
end: 2.0,
text: "a b".to_string(),
}]
);
}
#[test]
fn empty_tracks() {
assert_eq!(merge(&[], &[]), Vec::<Segment>::new());
let mic = vec![w("hallo", 0.0, 1.0, None)];
assert_eq!(
merge(&mic, &[]),
vec![Segment {
speaker: Speaker::Me,
start: 0.0,
end: 1.0,
text: "hallo".to_string(),
}]
);
let out = vec![w("hi", 0.0, 1.0, Some("SPEAKER_00"))];
assert_eq!(
merge(&[], &out),
vec![Segment {
speaker: Speaker::Remote(1),
start: 0.0,
end: 1.0,
text: "hi".to_string(),
}]
);
}
#[test]
fn label_uses_renames() {
let mut names = BTreeMap::new();
names.insert("remote:1".to_string(), "Frau Müller".to_string());
assert_eq!(label(&Speaker::Remote(1), &names), "Frau Müller");
assert_eq!(label(&Speaker::Me, &names), "Ich");
}
#[test]
fn label_blank_rename_falls_back_to_default() {
let mut names = BTreeMap::new();
names.insert("remote:2".to_string(), " ".to_string());
assert_eq!(label(&Speaker::Remote(2), &names), "Sprecher 2");
}
#[test]
fn ties_at_same_start_put_mic_first() {
let mic = vec![w("hallo", 0.0, 1.0, None)];
let out = vec![w("hi", 0.0, 1.0, Some("SPEAKER_00"))];
let segments = merge(&mic, &out);
assert_eq!(segments[0].speaker, Speaker::Me);
assert_eq!(segments[1].speaker, Speaker::Remote(1));
}
#[test]
fn unsorted_input_words_are_handled() {
let mic = vec![w("zwei", 1.0, 2.0, None), w("eins", 0.0, 1.0, None)];
assert_eq!(
merge(&mic, &[]),
vec![Segment {
speaker: Speaker::Me,
start: 0.0,
end: 2.0,
text: "eins zwei".to_string(),
}]
);
}
#[test]
fn nan_timestamps_do_not_panic_and_sort_as_zero() {
// A NaN start/end must not make `merge` panic, and for ordering
// purposes it is treated as 0.0 — so this word, despite textually
// "arriving" after the 5.0 s one, sorts before it.
let mic = vec![
w("spaet", 5.0, 5.5, None),
w("nan", f64::NAN, f64::NAN, None),
];
let segments = merge(&mic, &[]);
assert_eq!(segments.len(), 2);
assert_eq!(segments[0].text, "nan");
assert_eq!(segments[1].text, "spaet");
}
#[test]
fn empty_text_words_are_skipped_but_still_count_for_timing() {
let mic = vec![
w("hallo", 0.0, 1.0, None),
w(" ", 1.0, 1.4, None),
w("welt", 1.4, 2.0, None),
];
assert_eq!(
merge(&mic, &[]),
vec![Segment {
speaker: Speaker::Me,
start: 0.0,
end: 2.0,
text: "hallo welt".to_string(),
}]
);
}
#[test]
fn interleaved_other_speaker_prevents_merge() {
// Remote(1) at 0-1, Remote(2) at 1.2-2, Remote(1) again at 2.2-3:
// the second Remote(1) run is not adjacent (in the sorted list) to
// the first, so it must stay a separate segment even though the
// gap alone would be small enough to merge.
let out = vec![
w("a", 0.0, 1.0, Some("SPEAKER_00")),
w("b", 1.2, 2.0, Some("SPEAKER_01")),
w("c", 2.2, 3.0, Some("SPEAKER_00")),
];
assert_eq!(
merge(&[], &out),
vec![
Segment {
speaker: Speaker::Remote(1),
start: 0.0,
end: 1.0,
text: "a".to_string(),
},
Segment {
speaker: Speaker::Remote(2),
start: 1.2,
end: 2.0,
text: "b".to_string(),
},
Segment {
speaker: Speaker::Remote(1),
start: 2.2,
end: 3.0,
text: "c".to_string(),
},
]
);
}
#[test]
fn step_four_merges_using_segment_end_not_last_word_end() {
// w1 overlaps far past w2: the segment's recorded end (max of its
// words) is 5.0, even though the literal previous word (w2) ends
// at 2.0. The pause check in step 2 uses the literal previous
// word's end, so w3 (start 6.0) splits off into its own segment
// (6.0 - 2.0 = 4.0 > 1.5). But step 4 re-checks adjacent segments
// using the *segment's* end (5.0), so 6.0 - 5.0 = 1.0 <= 1.5 merges
// them back together.
let mic = vec![
w("w1", 0.0, 5.0, None),
w("w2", 1.0, 2.0, None),
w("w3", 6.0, 7.0, None),
];
assert_eq!(
merge(&mic, &[]),
vec![Segment {
speaker: Speaker::Me,
start: 0.0,
end: 7.0,
text: "w1 w2 w3".to_string(),
}]
);
}
}