Add lyrics to the bottom of video

If you provide `lyrics_file` to your midi.json, it'll load the LRC file
and parse the lyrics to be used on-screen. Do keep in mind that it's
currently programmed to assume each line is in chronological order, and
doesn't support multiple timestamps for repeated lines.

I would really like to support coloured text, but LRC files are by far
the simplest format to work with, and I absolutely do not fancy parsing
XML or other, more complicated formats (for now)!

Author: moonfloof

lyrics-example.lrc

@@ -0,0 +1,4 @@
+[00:01.00] This is a lyric
+[00:02.50]
+[00:03.00] And it changes!
+[02:05.00]

midi-example.json

@@ -3,6 +3,7 @@
 	"midi_file": "midi-file.mid",
 	"video_file_out": "./song/output.mp4",
 	"use_gradients": true,
+	"lyrics_file": "./lyrics-example.lrc",
 	"channels": {
 		"DRUMS": {
 			"order": 0,

src/data/lyrics.rs

@@ -0,0 +1,61 @@
+#[derive(Debug)]
+pub struct LyricLine {
+	time_start: f64,
+	time_end: f64,
+	text: String,
+}
+
+#[derive(Debug)]
+pub struct Lyrics {
+	lines: Vec<LyricLine>,
+}
+
+impl Lyrics {
+	pub fn new(path: &Option<String>) -> Option<Self> {
+		if path.is_none() {
+			return None;
+		}
+
+		let file = std::fs::read_to_string(path.as_ref().unwrap());
+		if file.is_err() {
+			panic!("Could not load lyrics file");
+		}
+		let file = file.unwrap();
+		let lines_raw = file.lines();
+
+		let mut lines: Vec<LyricLine> = vec![];
+		let re = regex::Regex::new(r"^\[(\d\d):(\d\d.\d\d)\](.*)$").unwrap();
+		for haystack in lines_raw {
+			if let Some(capture) = re.captures(haystack) {
+				let (_, [minute, second, lyric]) = capture.extract();
+				let time_mins = minute.parse::<f64>().unwrap();
+				let time_secs = second.parse::<f64>().unwrap();
+				let time = (time_mins * 60.0) + time_secs;
+				if lines.len() > 0 {
+					let len = lines.len();
+					lines[len - 1].time_end = time;
+				}
+				if lyric.is_empty() {
+					continue;
+				}
+				lines.push(LyricLine {
+					time_start: time,
+					time_end: 999999.0,
+					text: lyric.trim().to_uppercase().to_owned(),
+				});
+			}
+		}
+
+		Some(Lyrics { lines })
+	}
+
+	pub fn find_line(&self, time: f64) -> Option<&str> {
+		for line in &self.lines {
+			if line.time_start <= time && line.time_end >= time {
+				return Some(&line.text);
+			}
+		}
+
+		None
+	}
+}

src/data/midi.rs

@@ -1,11 +1,12 @@
 use super::{
 	channel::SongError,
 	defaults::{default_output, default_true},
+	lyrics::Lyrics,
 	video::Encoding,
 };
 use crate::{
-	display::{draw, RGB},
-	SCREEN_FRAME_RATE, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_DURATION_SECS
+	display::{draw, font::FONT_SEPARATION, RGB},
+	SCREEN_DURATION_SECS, SCREEN_FRAME_RATE, SCREEN_HEIGHT, SCREEN_WIDTH,
 };
 use image::RgbImage;
 use midly::{
@@ -87,6 +88,8 @@ pub struct MidiSongConfig {
 
 	#[serde(default = "default_true")]
 	pub use_gradients: bool,
+
+	pub lyrics_file: Option<String>,
 }
 
 #[derive(Debug)]
@@ -100,6 +103,7 @@ pub struct MidiSong {
 	pub config: MidiSongConfig,
 	pub channels: HashMap<usize, MidiChannel>,
 	pub channels_vec: Vec<MidiChannel>,
+	pub lyrics: Option<Lyrics>,
 }
 
 impl MidiSong {
@@ -113,6 +117,7 @@ impl MidiSong {
 			seconds_per_frame: *SCREEN_DURATION_SECS,
 			channels: HashMap::new(),
 			channels_vec: Vec::with_capacity(16),
+			lyrics: Lyrics::new(&config.lyrics_file),
 			config,
 		}
 	}
@@ -308,9 +313,22 @@ impl MidiSong {
 	}
 
 	pub fn draw(&mut self, frame: &mut RgbImage, encoding: &mut Encoding) -> Result<(), SongError> {
-		let channel_height = *SCREEN_HEIGHT / self.channels_vec.len() as u32;
+		let mut channel_height = *SCREEN_HEIGHT / self.channels_vec.len() as u32;
 		let channel_width = *SCREEN_WIDTH;
 
+		if let Some(lyrics) = &self.lyrics {
+			let y = *SCREEN_HEIGHT - 11;
+			channel_height = y / self.channels_vec.len() as u32;
+			draw::rect(frame, 0, y, *SCREEN_WIDTH, *SCREEN_HEIGHT, [0, 0, 0]);
+
+			if let Some(line) = lyrics.find_line(self.playhead_secs + (*SCREEN_DURATION_SECS / 2.0))
+			{
+				let x =
+					((*SCREEN_WIDTH - (line.len() as u32 * FONT_SEPARATION)) as f64 / 2.0) as u32;
+				draw::text(frame, x, y + 1, &line);
+			}
+		}
+
 		let x_min = 0;
 		let x_min_f = x_min as f64;
 		let x_max = x_min + channel_width - 1;

src/data/mod.rs

@@ -1,6 +1,7 @@
 pub mod channel;
 pub mod cli;
 pub mod defaults;
+pub mod lyrics;
 pub mod midi;
 pub mod song;
 pub mod video;

src/data/window.rs

@@ -1,15 +1,15 @@
-use std::{fs::File, io::BufReader};
-use serde::Deserialize;
-use crate::Args;
 use super::defaults::default_five;
+use crate::Args;
+use serde::Deserialize;
+use std::{fs::File, io::BufReader};
 
 #[derive(Deserialize, Clone, Debug)]
 pub struct Window {
 	pub width: u32,
 	pub height: u32,
 	pub scale: u32,
 	pub frame_rate: usize,
-	
+
 	#[serde(default = "default_five")]
 	pub duration_secs: f64,
 }
@@ -62,4 +62,4 @@ impl Window {
 
 		serde_json::from_reader(rdr).unwrap()
 	}
-}
+}

src/main.rs

@@ -1,5 +1,7 @@
 use clap::Parser;
-use data::{channel::SongError, song::Song, window::Window, cli::Args, video::Encoding, midi::MidiSong};
+use data::{
+	channel::SongError, cli::Args, midi::MidiSong, song::Song, video::Encoding, window::Window,
+};
 use image::RgbImage;
 use indicatif::{ProgressBar, ProgressStyle};
 use lazy_static::lazy_static;
@@ -65,7 +67,9 @@ fn encode_midi(cmd: &Args) {
 	let mut encoding = Encoding::new(&midi.config.video_file_out);
 	let mut frame = RgbImage::new(*SCREEN_WIDTH, *SCREEN_HEIGHT);
 
-	let pb = generate_progressbar(((midi.get_song_duration() + (*SCREEN_DURATION_SECS / 2.0)) * 1000.0) as u64);
+	let pb = generate_progressbar(
+		((midi.get_song_duration() + (*SCREEN_DURATION_SECS / 2.0)) * 1000.0) as u64,
+	);
 
 	// Step 2: Render waveforms
 	println!("\nStarting render");