substudy 0.5.2

Language-learning tools for working with parallel, bilingual subtitles and media files.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

//! Output a video as a series of short audio tracks, short enough to make
//! it easy to skip backwards a conversation with most MP3 players.

use std::{default::Default, io::Write};

use anyhow::Context as _;
use log::debug;

use crate::{
    export::Exporter,
    time::{seconds_to_hhmmss, Period},
    video::Id3Metadata,
    Result,
};

// Truncate a string to fit within the specified number of Unicode
// characters.
fn truncate(max: usize, s: &str) -> String {
    if s.chars().count() <= max {
        s.to_owned()
    } else {
        let mut result: String = s.chars().take(max - 1).collect();
        result.push_str("…");
        result
    }
}

// Should we merge two time periods into one?
fn should_merge(p1: Period, p2: Period) -> bool {
    if p1.duration() >= 30.0 {
        false
    } else {
        match p1.distance(p2) {
            None => true,
            Some(d) if d <= 5.0 => true,
            _ => false,
        }
    }
}

// A conversation.
#[derive(Debug)]
struct Conv {
    period: Period,
    text: String,
}

/// Export the video as a set of tracks.
pub fn export_tracks(exporter: &mut Exporter) -> Result<()> {
    let mut convs: Vec<Conv> = vec![];

    // Figure out how to combine subtitles into conversations.
    for sub in &exporter.foreign().subtitles.subtitles {
        if let Some(prev) = convs.last_mut() {
            if should_merge(prev.period, sub.period) {
                prev.period = prev.period.union(sub.period);
                prev.text.push_str("\n");
                prev.text.push_str(&sub.plain_text());
                continue;
            }
        }
        convs.push(Conv {
            period: sub.period,
            text: sub.plain_text(),
        });
    }

    // Add padding to each audio clip.
    for conv in convs.iter_mut() {
        conv.period = conv.period.grow(2.5, 2.5);
    }

    // Turn overlapping clips into seamless transitions.
    // TODO: Fade in/out when not a seamless transition.
    for i in 1..convs.len() {
        if convs[i].period.begin() < convs[i - 1].period.end() {
            let overlap =
                Period::new(convs[i].period.begin(), convs[i - 1].period.end())
                    .unwrap();
            let midpoint = overlap.midpoint();
            debug!(
                "Overlap: {:?} {:?} {:?} {}",
                &convs[i - 1],
                &convs[i],
                overlap,
                midpoint
            );
            convs[i - 1].period =
                Period::new(convs[i - 1].period.begin(), midpoint).unwrap();
            convs[i].period = Period::new(midpoint, convs[i].period.end()).unwrap();
            assert!(convs[i].period.begin() >= convs[i - 1].period.end());
        }
    }

    // Schedule exports and write our our m3u8 playlist (like m3u, but
    // UTF-8).
    //
    // TODO: Genre, artist, album, track title, track number.
    let foreign_lang = exporter.foreign().language;
    let mut playlist = vec![];
    for (i, conv) in convs.iter().enumerate() {
        debug!(
            "Conv: {:7.1} -> {:7.1} for {:7.1}",
            conv.period.begin(),
            conv.period.end(),
            conv.period.duration()
        );

        // Build our track name.
        let name = format!(
            "{} {}",
            seconds_to_hhmmss(conv.period.begin()),
            truncate(32, &conv.text).replace("\n", " ")
        );

        // Compute our metadata.
        let metadata = Id3Metadata {
            genre: Some("substudy".to_owned()),
            album: Some(exporter.file_stem().to_owned()),
            track_number: Some((i + 1, convs.len())),
            track_name: Some(name),
            lyrics: Some(conv.text.clone()),
            ..Default::default()
        };

        // Export as an audio file, and record the path in our playlist.
        let path =
            exporter.schedule_audio_export_ext(foreign_lang, conv.period, metadata);
        writeln!(playlist, "{}", &path)
            .context("error serializing playlist to memory")?;
    }
    exporter.export_data_file("playlist.m3u8", &playlist)?;

    // Extract our media files.
    exporter.finish_exports()?;

    Ok(())
}