msrd0/render_video
1
0
Fork 0
Code Issues Pull requests Releases 7 Activity Actions

Compare commits

base: msrd0:677c35a6fdadf1cf951acf1502d1fb5c35435d2a
Branches Tags
msrd0:main
msrd0:overlay_vaapi
msrd0:graph2dot
msrd0:240624
msrd0:240527
msrd0:240517
msrd0:231212
msrd0:231114
msrd0:231031
msrd0:231030
..
compare: msrd0:7b1681d85dc876a8f3c320166935ae1ae0950867
Branches Tags
msrd0:main
msrd0:overlay_vaapi
msrd0:graph2dot
msrd0:240624
msrd0:240527
msrd0:240517
msrd0:231212
msrd0:231114
msrd0:231031
msrd0:231030

No commits in common. "677c35a6fdadf1cf951acf1502d1fb5c35435d2a" and "7b1681d85dc876a8f3c320166935ae1ae0950867" have entirely different histories.
677c35a6fd ... 7b1681d85d

7 changed files with 49 additions and 494 deletions
Show stats Expand all files Collapse all files

9
230101/project.toml
View file

@ -7,13 +7,9 @@ date = "230101"
[source]
files = ["C01.mp4", "C02.mp4", "C03.mp4"]
stereo = false
start = "1"
start = "2"
end = "12"
fast = [["6", "8"], ["10", "11"]]
questions = [
["1.5", "3", "Hallo liebes Publikum. Ich habe leider meine Frage vergessen. Bitte entschuldigt die Störung."],
["3.5", "5", "Ah jetzt weiß ich es wieder. Meine Frage war: Was war meine Frage?"]
]
fast = [["5", "7"], ["9", "11"]]
[source.metadata]
source_duration = "12.53000"
@ -26,6 +22,5 @@ source_sample_rate = 48000
preprocessed = false
asked_start_end = true
asked_fast = true
asked_questions = true
rendered = false
transcoded = []

3
Cargo.toml
View file

@ -10,10 +10,7 @@ license = "EPL-2.0"
[dependencies]
anyhow = "1.0"
camino = "1.1"
console = "0.15"
clap = { version = "4.4", features = ["derive"] }
fontconfig = "0.8"
harfbuzz_rs = "2.0"
indexmap = "2.2"
rational = "1.5"
serde = { version = "1.0.188", features = ["derive"] }

6
src/iotro.rs
View file

@ -7,7 +7,7 @@ use std::{
str::FromStr
};
use svgwriter::{
tags::{Group, Rect, TagWithPresentationAttributes as _, Text},
tags::{Group, Rect, TagWithPresentationAttributes, Text},
Graphic
};
@ -134,14 +134,14 @@ impl Debug for Language<'_> {
}
#[repr(u16)]
pub(crate) enum FontSize {
enum FontSize {
Huge = 72,
Large = 56,
Big = 44
}
#[repr(u16)]
pub(crate) enum FontWeight {
enum FontWeight {
Normal = 400,
SemiBold = 500,
Bold = 700

138
src/main.rs
View file

@ -3,19 +3,16 @@
#![forbid(elided_lifetimes_in_paths, unsafe_code)]
mod iotro;
mod question;
mod render;
mod time;
use self::{
iotro::Language,
question::Question,
use crate::{
render::{ffmpeg::FfmpegOutputFormat, Renderer},
time::{parse_date, parse_time, Date, Time}
};
use camino::Utf8PathBuf as PathBuf;
use clap::Parser;
use console::style;
use iotro::Language;
use rational::Rational;
use serde::{Deserialize, Serialize};
use serde_with::{serde_as, DisplayFromStr};
@ -172,15 +169,9 @@ struct ProjectSource {
start: Option<Time>,
#[serde_as(as = "Option<DisplayFromStr>")]
end: Option<Time>,
#[serde(default)]
#[serde_as(as = "Vec<(DisplayFromStr, DisplayFromStr)>")]
fast: Vec<(Time, Time)>,
#[serde(default)]
#[serde_as(as = "Vec<(DisplayFromStr, DisplayFromStr, _)>")]
questions: Vec<(Time, Time, String)>,
metadata: Option<ProjectSourceMetadata>
}
@ -204,25 +195,10 @@ struct ProjectSourceMetadata {
#[derive(Default, Deserialize, Serialize)]
struct ProjectProgress {
#[serde(default)]
preprocessed: bool,
#[serde(default)]
asked_start_end: bool,
#[serde(default)]
asked_fast: bool,
#[serde(default)]
asked_questions: bool,
#[serde(default)]
rendered_assets: bool,
#[serde(default)]
rendered: bool,
#[serde(default)]
transcoded: BTreeSet<Resolution>
}
@ -230,44 +206,29 @@ fn ask(question: impl Display) -> String {
let mut stdout = io::stdout().lock();
let mut stdin = io::stdin().lock();
write!(
stdout,
"{} {} ",
style(question).bold().magenta(),
style(">").cyan()
)
.unwrap();
stdout.flush().unwrap();
writeln!(stdout, "{question}").unwrap();
let mut line = String::new();
write!(stdout, "> ").unwrap();
stdout.flush().unwrap();
stdin.read_line(&mut line).unwrap();
line.trim().to_owned()
}
fn ask_time(question: impl Display + Copy) -> Time {
fn ask_time(question: impl Display) -> Time {
let mut stdout = io::stdout().lock();
let mut stdin = io::stdin().lock();
writeln!(stdout, "{question}").unwrap();
let mut line = String::new();
loop {
line.clear();
write!(
stdout,
"{} {} ",
style(question).bold().magenta(),
style(">").cyan()
)
.unwrap();
write!(stdout, "> ").unwrap();
stdout.flush().unwrap();
stdin.read_line(&mut line).unwrap();
let line = line.trim();
match parse_time(line) {
Ok(time) => return time,
Err(err) => writeln!(
stdout,
"{} {line:?}: {err}",
style("Invalid Input").bold().red()
)
.unwrap()
Err(err) => writeln!(stdout, "Invalid Input {line:?}: {err}").unwrap()
}
}
}
@ -311,14 +272,10 @@ fn main() {
print!("I found the following source files:");
for f in &files {
print!(" {}", style(f).bold().yellow());
print!(" {f}");
}
println!();
println!(
"{} Which source files would you like to use? (specify multiple files separated by whitespace)",
style("?").bold().yellow()
);
files = ask("files")
files = ask("Which source files would you like to use? (specify multiple files separated by whitespace)")
.split_ascii_whitespace()
.map(String::from)
.collect();
@ -338,7 +295,6 @@ fn main() {
start: None,
end: None,
fast: Vec::new(),
questions: Vec::new(),
metadata: None
},
progress: Default::default()
@ -358,21 +314,14 @@ fn main() {
fs::write(&project_path, toml::to_string(&project).unwrap().as_bytes()).unwrap();
}
println!();
println!(
" {} Preprocessed video: {}",
style("==>").bold().cyan(),
style(recording).bold().yellow()
);
// ask the user about start and end times
if !project.progress.asked_start_end {
println!(
"{} What is the first/last second you want included?",
style("?").bold().yellow()
);
project.source.start = Some(ask_time("first"));
project.source.end = Some(ask_time("last "));
project.source.start = Some(ask_time(format_args!(
"Please take a look at the file {recording} and tell me the first second you want included"
)));
project.source.end = Some(ask_time(format_args!(
"Please take a look at the file {recording} and tell me the last second you want included"
)));
project.progress.asked_start_end = true;
fs::write(&project_path, toml::to_string(&project).unwrap().as_bytes()).unwrap();
@ -380,16 +329,16 @@ fn main() {
// ask the user about fast forward times
if !project.progress.asked_fast {
println!(
"{} Which sections of the video do you want fast-forwarded? (0 to finish)",
style("?").bold().yellow()
);
loop {
let start = ask_time("from");
let start = ask_time(format_args!(
"Please take a look at the file {recording} and tell me the first second you want fast-forwarded. You may reply with `0` if there are no more fast-forward sections"
));
if start.seconds == 0 && start.micros == 0 {
break;
}
let end = ask_time("to ");
let end = ask_time(format_args!(
"Please tell me the last second you want fast-forwarded"
));
project.source.fast.push((start, end));
}
project.progress.asked_fast = true;
@ -397,34 +346,6 @@ fn main() {
fs::write(&project_path, toml::to_string(&project).unwrap().as_bytes()).unwrap();
}
// ask the user about questions from the audience that should be subtitled
if !project.progress.asked_questions {
println!(
"{} In which sections of the video were questions asked you want subtitles for? (0 to finish)",
style("?").bold().yellow()
);
loop {
let start = ask_time("from");
if start.seconds == 0 && start.micros == 0 {
break;
}
let end = ask_time("to ");
let text = ask("text");
project.source.questions.push((start, end, text));
}
project.progress.asked_questions = true;
fs::write(&project_path, toml::to_string(&project).unwrap().as_bytes()).unwrap();
}
// render the assets
if !project.progress.rendered_assets {
renderer.render_assets(&project).unwrap();
project.progress.rendered_assets = true;
fs::write(&project_path, toml::to_string(&project).unwrap().as_bytes()).unwrap();
}
// render the video
let mut videos = Vec::new();
videos.push(if project.progress.rendered {
@ -457,18 +378,9 @@ fn main() {
}
}
println!();
println!(
" {} {}",
style("==>").bold().cyan(),
style("DONE :)").bold()
);
println!("\x1B[1m ==> DONE :)\x1B[0m");
println!(" Videos:");
for v in &videos {
println!(
" {} {}",
style("->").bold().cyan(),
style(v).bold().yellow()
);
println!(" -> {v}");
}
}

152
src/question.rs
View file

@ -1,152 +0,0 @@
use crate::{iotro::Language, Resolution};
use fontconfig::Fontconfig;
use harfbuzz_rs::{Face, Font, Owned, UnicodeBuffer};
use std::sync::OnceLock;
use svgwriter::{
tags::{Group, Path, Rect, TSpan, TagWithPresentationAttributes as _, Text},
Data, Graphic, Transform
};
pub(crate) struct Question {
res: Resolution,
g: Group
}
impl Question {
pub(crate) fn new(res: Resolution, lang: &Language<'_>, str: &str) -> Self {
static FONT: OnceLock<Owned<Font<'static>>> = OnceLock::new();
let font = FONT.get_or_init(|| {
let fc = Fontconfig::new().unwrap();
let font_path = fc.find("Noto Sans", None).unwrap().path;
let face = Face::from_file(font_path, 0).unwrap();
Font::new(face)
});
let upem = font.face().upem();
// constants
let border_r = 12;
let font_size = 44;
let line_height = font_size * 6 / 5;
let padding = font_size / 2;
let margin_x = 240;
let margin_y = padding * 3 / 2;
let question_offset = 64;
let question_width = 240;
// calculated
let box_width = 1920 - 2 * margin_x;
let text_width = box_width - 2 * padding;
// calculates the width of the given string
let width_of = |s: &str| {
let width: i32 =
harfbuzz_rs::shape(font, UnicodeBuffer::new().add_str(s), &[])
.get_glyph_positions()
.iter()
.map(|glyph_pos| glyph_pos.x_advance)
.sum();
(width * font_size) / upem as i32
};
let space_width = width_of(" ");
// lay out the text
let mut text = Text::new()
.with_dominant_baseline("hanging")
.with_transform(
Transform::new().translate(padding, padding + font_size / 2 + border_r)
);
let words = str.split_whitespace();
let mut text_height = 0;
let mut text_x = 0;
for word in words {
let word_width = width_of(word);
if text_x + word_width > text_width {
text_x = 0;
text_height += line_height;
}
text.push(
TSpan::new()
.with_x(text_x)
.with_y(text_height)
.append(word.to_owned())
);
text_x += word_width + space_width;
}
text_height += font_size;
// calculated
let box_height = text_height + 2 * padding + font_size / 2 + border_r;
let mut g = Group::new()
.with_fill("white")
.with_font_family("Noto Sans")
.with_font_size(font_size)
.with_transform(
Transform::new().translate(margin_x, 1080 - margin_y - box_height)
);
let mut outline = Data::new();
outline.move_by(border_r, 0).horiz_line_to(question_offset);
outline
.vert_line_by(-font_size / 2)
.arc_by(border_r, border_r, 0, false, true, border_r, -border_r)
.horiz_line_by(question_width)
.arc_by(border_r, border_r, 0, false, true, border_r, border_r)
.vert_line_by(font_size)
.arc_by(border_r, border_r, 0, false, true, -border_r, border_r)
.horiz_line_by(-question_width)
.arc_by(border_r, border_r, 0, false, true, -border_r, -border_r)
.vert_line_by(-font_size / 2)
.move_by(question_width + 2 * border_r, 0);
outline
.horiz_line_to(box_width - border_r)
.arc_by(border_r, border_r, 0, false, true, border_r, border_r)
.vert_line_by(box_height - 2 * border_r)
.arc_by(border_r, border_r, 0, false, true, -border_r, border_r)
.horiz_line_to(border_r)
.arc_by(border_r, border_r, 0, false, true, -border_r, -border_r)
.vert_line_to(border_r)
.arc_by(border_r, border_r, 0, false, true, border_r, -border_r);
g.push(
Path::new()
.with_stroke("#fff")
.with_stroke_width(3)
.with_fill("#000")
.with_fill_opacity(".3")
.with_d(outline)
);
g.push(
Text::new()
.with_x(question_offset + question_width / 2 + border_r)
.with_y(0)
.with_dominant_baseline("middle")
.with_text_anchor("middle")
.with_font_weight(600)
.append("Question")
);
g.push(text);
Self { res, g }
}
pub(crate) fn finish(self) -> Graphic {
let mut svg = Graphic::new();
svg.set_width(self.res.width());
svg.set_height(self.res.height());
svg.set_view_box("0 0 1920 1080");
svg.push(self.g);
svg
}
}
#[cfg(test)]
#[test]
fn question() {
let svg = Question::new(
Resolution::FullHD,
&Language::default(),
"Hallo Welt! Dies ist eine sehr kluge Frage aus dem Publikum. Die Frage ist nämlich: Was ist eigentlich die Frage?".into()
)
.finish();
std::fs::write("question.svg", svg.to_string_pretty()).unwrap();
}

49
src/render/filter.rs
View file

@ -19,7 +19,6 @@ pub(crate) enum Filter {
overlay_input: Cow<'static, str>,
x: Cow<'static, str>,
y: Cow<'static, str>,
repeatlast: bool,
output: Cow<'static, str>
},
@ -38,22 +37,6 @@ pub(crate) enum Filter {
output: Cow<'static, str>
},
/// Fade only video using the alpha channel.
FadeAlpha {
input: Cow<'static, str>,
direction: &'static str,
start: Time,
duration: Time,
output: Cow<'static, str>
},
/// Offset the PTS of the video by the amount of seconds.
VideoOffset {
input: Cow<'static, str>,
seconds: Time,
output: Cow<'static, str>
},
/// Generate silence. The video is copied.
GenerateSilence {
video: Cow<'static, str>,
@ -94,13 +77,11 @@ impl Filter {
overlay_input,
x,
y,
repeatlast,
output
} => {
let repeatlast: u8 = (*repeatlast).into();
writeln!(
complex,
"{}{}overlay=x={x}:y={y}:repeatlast={repeatlast}:eval=init{};",
"{}{}overlay=x={x}:y={y}{};",
channel('v', video_input),
channel('v', overlay_input),
channel('v', output)
@ -148,34 +129,6 @@ impl Filter {
)?;
},
Self::FadeAlpha {
input,
direction,
start,
duration,
output
} => {
writeln!(
complex,
"{}fade={direction}:st={start}:d={duration}:alpha=1{};",
channel('v', input),
channel('v', output)
)?;
},
Self::VideoOffset {
input,
seconds,
output
} => {
writeln!(
complex,
"{}setpts=PTS+{seconds}/TB{};",
channel('v', input),
channel('v', output)
)?;
},
Self::GenerateSilence { video, output } => {
writeln!(
complex,

186
src/render/mod.rs
View file

@ -7,14 +7,12 @@ use self::{
};
use crate::{
iotro::{intro, outro},
question::Question,
render::ffmpeg::{Ffmpeg, FfmpegInput},
time::{format_date, format_time, Time},
time::{format_date, Time},
Project, ProjectLecture, ProjectSourceMetadata, Resolution
};
use anyhow::{bail, Context};
use camino::{Utf8Path as Path, Utf8PathBuf as PathBuf};
use console::style;
use std::{
borrow::Cow,
collections::VecDeque,
@ -35,10 +33,6 @@ const TRANSITION_LEN: Time = Time {
seconds: 0,
micros: 200_000
};
const QUESTION_FADE_LEN: Time = Time {
seconds: 0,
micros: 400_000
};
const FF_MULTIPLIER: usize = 8;
// logo sizes at full hd, will be scaled to source resolution
const FF_LOGO_SIZE: usize = 128;
@ -157,13 +151,14 @@ fn svg2mkv(
ffmpeg.run()
}
fn svg2png(svg: &Path, png: &Path, width: usize, height: usize) -> anyhow::Result<()> {
fn svg2png(svg: &Path, png: &Path, size: usize) -> anyhow::Result<()> {
let mut cmd = cmd();
let size = size.to_string();
cmd.arg("inkscape")
.arg("-w")
.arg(width.to_string())
.arg(&size)
.arg("-h")
.arg(height.to_string());
.arg(&size);
cmd.arg(svg).arg("-o").arg(png);
let status = cmd.status()?;
@ -222,14 +217,6 @@ impl<'a> Renderer<'a> {
self.target.join("outro.mkv")
}
fn question_svg(&self, q_idx: usize) -> PathBuf {
self.target.join(format!("question{q_idx}.svg"))
}
fn question_png(&self, q_idx: usize) -> PathBuf {
self.target.join(format!("question{q_idx}.png"))
}
pub(crate) fn preprocess(&self, project: &mut Project) -> anyhow::Result<()> {
assert!(!project.progress.preprocessed);
@ -240,13 +227,7 @@ impl<'a> Renderer<'a> {
}
drop(file);
println!();
println!(
" {} {}",
style("==>").bold().cyan(),
style("Concatenating Video and Normalising Audio ...").bold()
);
println!("\x1B[1m ==> Concatenating Video and Normalising Audio ...\x1B[0m");
let source_sample_rate =
ffprobe_audio("stream=sample_rate", &recording_txt)?.parse()?;
let recording_mkv = self.recording_mkv();
@ -278,26 +259,15 @@ impl<'a> Renderer<'a> {
source_res,
source_sample_rate
});
Ok(())
}
/// Prepare assets like intro, outro and questions.
pub(crate) fn render_assets(&self, project: &Project) -> anyhow::Result<()> {
let metadata = project.source.metadata.as_ref().unwrap();
println!();
println!(
" {} {}",
style("==>").bold().cyan(),
style("Preparing assets ...").bold()
);
println!("\x1B[1m ==> Preparing assets ...\x1B[0m");
// render intro to svg then mp4
let intro_svg = self.target.join("intro.svg");
fs::write(
&intro_svg,
intro(metadata.source_res, &project.lecture)
intro(source_res, &project.lecture)
.to_string_pretty()
.into_bytes()
)?;
@ -308,7 +278,7 @@ impl<'a> Renderer<'a> {
let outro_svg = self.target.join("outro.svg");
fs::write(
&outro_svg,
outro(&project.lecture.lang, metadata.source_res)
outro(&project.lecture.lang, source_res)
.to_string_pretty()
.into_bytes()
)?;
@ -322,8 +292,7 @@ impl<'a> Renderer<'a> {
include_bytes!(concat!(env!("CARGO_MANIFEST_DIR"), "/assets/logo.svg"))
)?;
let logo_png = self.target.join("logo.png");
let logo_size = LOGO_SIZE * metadata.source_res.width() / 1920;
svg2png(&logo_svg, &logo_png, logo_size, logo_size)?;
svg2png(&logo_svg, &logo_png, LOGO_SIZE * source_res.width() / 1920)?;
// copy fastforward then render to png
let fastforward_svg = self.target.join("fastforward.svg");
@ -335,31 +304,12 @@ impl<'a> Renderer<'a> {
))
)?;
let fastforward_png = self.target.join("fastforward.png");
let ff_logo_size = FF_LOGO_SIZE * metadata.source_res.width() / 1920;
svg2png(
&fastforward_svg,
&fastforward_png,
ff_logo_size,
ff_logo_size
FF_LOGO_SIZE * source_res.width() / 1920
)?;
// write questions then render to png
for (q_idx, (_, _, q_text)) in project.source.questions.iter().enumerate() {
let q = Question::new(metadata.source_res, &project.lecture.lang, q_text)
.finish()
.to_string_pretty()
.into_bytes();
let q_svg = self.question_svg(q_idx);
let q_png = self.question_png(q_idx);
fs::write(&q_svg, q)?;
svg2png(
&q_svg,
&q_png,
metadata.source_res.width(),
metadata.source_res.height()
)?;
}
Ok(())
}
@ -399,24 +349,21 @@ impl<'a> Renderer<'a> {
let mut part3: Cow<'static, str> = outro.into();
// the recording is fun because of all the fast forwarding
let mut part2 = VecDeque::<Cow<'static, str>>::new();
let mut part2_ts = VecDeque::new();
let mut part2 = VecDeque::new();
let mut part2_start_of_the_end = None;
let mut part2_end_of_the_start = None;
// ok so ff is fun. we will add the ff'ed section as well as the part between
// the previous ff'ed section and our new section, unless we are the first.
// the previous ff'ed section and our new section, unless we are the first
project.source.fast.sort();
for (i, (ff_st, ff_end)) in project.source.fast.iter().rev().enumerate() {
if let Some(prev_end) = part2_end_of_the_start {
let duration = prev_end - *ff_end;
let recffbetween = ffmpeg.add_input(FfmpegInput {
start: Some(*ff_end),
duration: Some(duration),
duration: Some(prev_end - *ff_end),
..FfmpegInput::new(rec_file.clone())
});
part2.push_front(recffbetween.into());
part2_ts.push_front(Some((*ff_end, duration)));
} else {
part2_start_of_the_end = Some(*ff_end);
}
@ -436,7 +383,6 @@ impl<'a> Renderer<'a> {
output: recff.clone().into()
});
part2.push_front(recff.into());
part2_ts.push_front(None);
}
// if the recording was not ff'ed, perform a normal trim
@ -451,112 +397,23 @@ impl<'a> Renderer<'a> {
..FfmpegInput::new(rec_file.clone())
});
part2.push_back(rectrim.into());
part2_ts.push_back(Some((start, part2_last_part_duration)));
}
// otherwise add the first and last parts separately
else {
let duration = part2_end_of_the_start.unwrap() - start;
let rectrimst = ffmpeg.add_input(FfmpegInput {
start: Some(start),
duration: Some(duration),
duration: Some(part2_end_of_the_start.unwrap() - start),
..FfmpegInput::new(rec_file.clone())
});
part2.push_front(rectrimst.into());
part2_ts.push_front(Some((start, duration)));
let part2_start_of_the_end = part2_start_of_the_end.unwrap();
part2_last_part_duration = end - part2_start_of_the_end;
part2_last_part_duration = end - part2_start_of_the_end.unwrap();
let rectrimend = ffmpeg.add_input(FfmpegInput {
start: Some(part2_start_of_the_end),
start: Some(part2_start_of_the_end.unwrap()),
duration: Some(part2_last_part_duration),
..FfmpegInput::new(rec_file.clone())
});
part2.push_back(rectrimend.into());
part2_ts.push_back(Some((part2_start_of_the_end, part2_last_part_duration)));
}
// ok now we have a bunch of parts and a bunch of questions that want to get
// overlayed over those parts.
project.source.questions.sort();
let mut q_idx = 0;
for (i, ts) in part2_ts.iter().enumerate() {
let Some((start, duration)) = ts else {
continue;
};
loop {
if q_idx >= project.source.questions.len() {
break;
}
let (q_start, q_end, _) = &project.source.questions[q_idx];
if q_start < start {
bail!(
"Question starting at {} did not fit into the video",
format_time(*q_start)
);
}
if q_start >= start && *q_end <= *start + *duration {
// add the question as input to ffmpeg
let q_inp = ffmpeg.add_input(FfmpegInput {
loop_input: true,
fps: Some(project.source.metadata.as_ref().unwrap().source_fps),
duration: Some(*q_end - *q_start),
..FfmpegInput::new(self.question_png(q_idx))
});
// fade in the question
let q_fadein = format!("q{q_idx}fin");
ffmpeg.add_filter(Filter::FadeAlpha {
input: q_inp.into(),
direction: "in",
start: Time {
seconds: 0,
micros: 0
},
duration: QUESTION_FADE_LEN,
output: q_fadein.clone().into()
});
// fade out the question
let q_fadeout = format!("q{q_idx}fout");
ffmpeg.add_filter(Filter::FadeAlpha {
input: q_fadein.into(),
direction: "out",
start: *q_end - *q_start - QUESTION_FADE_LEN,
duration: QUESTION_FADE_LEN,
output: q_fadeout.clone().into()
});
// move the question to the correct timestamp
let q_pts = format!("q{q_idx}pts");
ffmpeg.add_filter(Filter::VideoOffset {
input: q_fadeout.into(),
seconds: *q_start - *start,
output: q_pts.clone().into()
});
// overlay the part in question
let q_overlay = format!("q{q_idx}o");
ffmpeg.add_filter(Filter::Overlay {
video_input: part2[i].clone(),
overlay_input: q_pts.into(),
x: "0".into(),
y: "0".into(),
repeatlast: false,
output: q_overlay.clone().into()
});
part2[i] = q_overlay.into();
q_idx += 1;
continue;
}
break;
}
}
if q_idx < project.source.questions.len() {
bail!(
"Question starting at {} did not fit into the video before it was over",
format_time(project.source.questions[q_idx].0)
);
}
// fade out the intro
@ -634,7 +491,6 @@ impl<'a> Renderer<'a> {
overlay_input: logoalpha.into(),
x: format!("main_w-overlay_w-{overlay_off_x}").into(),
y: format!("main_h-overlay_h-{overlay_off_y}").into(),
repeatlast: true,
output: overlay.into()
});
@ -652,13 +508,7 @@ impl<'a> Renderer<'a> {
) -> anyhow::Result<PathBuf> {
let input = self.video_file_output();
let output = self.video_file_res(res);
println!();
println!(
" {} {}",
style("==>").bold().cyan(),
style(format!("Rescaling to {}p", res.height())).bold()
);
println!("\x1B[1m ==> Rescaling to {}p\x1B[0m", res.height());
let mut ffmpeg = Ffmpeg::new(FfmpegOutput {
video_bitrate: Some(res.bitrate()),