472 lines
13 KiB
Python
Executable file
472 lines
13 KiB
Python
Executable file
#!/usr/bin/env python3
|
||
# vim: tabstop=4 shiftwidth=4 expandtab
|
||
|
||
"""See jugendhackt/config.ini for some config file documentation."""
|
||
|
||
import os
|
||
import sys
|
||
import subprocess
|
||
import argparse
|
||
import ssl
|
||
from configparser import ConfigParser
|
||
from pathlib import PurePath
|
||
import platform
|
||
|
||
from PIL import ImageFont
|
||
import schedulelib
|
||
|
||
ssl._create_default_https_context = ssl._create_unverified_context
|
||
|
||
FRAME_WIDTH = 1920
|
||
|
||
|
||
class TextConfig:
|
||
inpoint: float
|
||
outpoint: float
|
||
x: int
|
||
y: int
|
||
|
||
fontfile_path: str
|
||
fontsize: int
|
||
fontcolor: str
|
||
bordercolor: str = None # border is added, if a color is set
|
||
|
||
def uses_fontfile(self):
|
||
return self.fontfile_path is not None
|
||
|
||
def parse(self, cparser_sect, default_fontfile, default_fontcolor):
|
||
self.inpoint = cparser_sect.getfloat("in")
|
||
self.outpoint = cparser_sect.getfloat("out")
|
||
self.x = cparser_sect.getint("x")
|
||
self.y = cparser_sect.getint("y")
|
||
self.w = cparser_sect.getint("w")
|
||
|
||
self.fontcolor = cparser_sect.get("fontcolor", default_fontcolor)
|
||
|
||
fontfile = cparser_sect.get("fontfile", default_fontfile)
|
||
self.fontfile_path = str(PurePath(args.project, fontfile).as_posix())
|
||
|
||
if not os.path.exists(self.fontfile_path):
|
||
error("Font file {} in Project Path is missing".format(self.fontfile_path))
|
||
|
||
self.fontsize = cparser_sect.getint("fontsize")
|
||
self.bordercolor = cparser_sect.get("bordercolor", None)
|
||
|
||
def fit_text(self, text: str) -> str:
|
||
if not text:
|
||
return ""
|
||
|
||
font = ImageFont.truetype(
|
||
self.fontfile_path, size=self.fontsize, encoding="unic"
|
||
)
|
||
|
||
fitted = "\n".join(fit_text(text, self.w or (FRAME_WIDTH - self.x - 100), font))
|
||
print(repr(fitted))
|
||
return fitted
|
||
|
||
def get_ffmpeg_filter(self, inout_type: str, fade_time: float, text: str):
|
||
if not text:
|
||
return ""
|
||
|
||
filter_str = ""
|
||
filter_str += "drawtext=enable='between({},{},{})':fix_bounds=true:text_align=C:x={}:y={}".format(
|
||
inout_type, self.inpoint, self.outpoint, self.x, self.y
|
||
)
|
||
if self.w:
|
||
filter_str += f":boxw={self.w}"
|
||
|
||
filter_str += ":fontfile='{}':fontsize={}:fontcolor={}:text={}".format(
|
||
self.fontfile_path, self.fontsize, self.fontcolor, ffmpeg_escape_str(text)
|
||
)
|
||
|
||
if self.bordercolor is not None:
|
||
filter_str += ":borderw={}:bordercolor={}".format(
|
||
self.fontsize / 30, self.bordercolor
|
||
)
|
||
|
||
if fade_time > 0:
|
||
filter_str += ":alpha='if(lt(t,{fade_in_start_time}),0,if(lt(t,{fade_in_end_time}),(t-{fade_in_start_time})/{fade_duration},if(lt(t,{fade_out_start_time}),1,if(lt(t,{fade_out_end_time}),({fade_duration}-(t-{fade_out_start_time}))/{fade_duration},0))))'".format(
|
||
fade_in_start_time=self.inpoint,
|
||
fade_in_end_time=self.inpoint + fade_time,
|
||
fade_out_start_time=self.outpoint - fade_time,
|
||
fade_out_end_time=self.outpoint,
|
||
fade_duration=fade_time,
|
||
)
|
||
|
||
filter_str += ","
|
||
|
||
return filter_str[:-1]
|
||
|
||
|
||
class Config:
|
||
schedule: str
|
||
template_file: str # video background
|
||
alpha: bool = False
|
||
prores: bool = False
|
||
inout_type: str = "t" # in and out time format: t for seconds, n for frame number
|
||
fade_duration: float = 0 # fade duration in seconds, 0 to disable
|
||
|
||
fileext: str
|
||
|
||
title: TextConfig
|
||
speaker: TextConfig
|
||
text: TextConfig
|
||
extra_text: str = "" # additional text
|
||
|
||
|
||
def parse_config(filename) -> Config:
|
||
if not os.path.exists(filename):
|
||
error("config.ini file in Project Path is missing")
|
||
|
||
conf = Config()
|
||
|
||
cparser = ConfigParser()
|
||
cparser.read(filename)
|
||
|
||
meta = cparser["meta"]
|
||
conf.schedule = meta.get("schedule")
|
||
infile = PurePath(args.project, meta.get("template"))
|
||
conf.template_file = str(infile)
|
||
conf.alpha = meta.getboolean("alpha", conf.alpha)
|
||
conf.prores = meta.getboolean("prores", conf.prores)
|
||
conf.inout_type = meta.get("inout_type", conf.inout_type)
|
||
conf.fade_duration = meta.getfloat("fade_duration", conf.fade_duration)
|
||
|
||
defaults = cparser["default"]
|
||
default_fontfile = defaults.get("fontfile", None)
|
||
default_fontcolor = defaults.get("fontcolor", "#ffffff")
|
||
|
||
conf.title = TextConfig()
|
||
conf.title.parse(cparser["title"], default_fontfile, default_fontcolor)
|
||
conf.speaker = TextConfig()
|
||
conf.speaker.parse(cparser["speaker"], default_fontfile, default_fontcolor)
|
||
conf.text = TextConfig()
|
||
conf.text.parse(cparser["text"], default_fontfile, default_fontcolor)
|
||
|
||
conf.extra_text = cparser["text"].get("text", "")
|
||
|
||
conf.fileext = infile.suffix
|
||
|
||
if not os.path.exists(conf.template_file):
|
||
error("Template file {} in Project Path is missing".format(conf.template_file))
|
||
|
||
if conf.alpha and conf.fileext != ".mov":
|
||
error("Alpha can only be rendered with .mov source files")
|
||
|
||
if not args.project:
|
||
error("The Project Path is a required argument")
|
||
|
||
if not args.debug and not conf.schedule:
|
||
error("Either specify --debug or supply a schedule in config.ini")
|
||
|
||
return conf
|
||
|
||
|
||
def error(err_str):
|
||
print("##################################################")
|
||
print(err_str)
|
||
print("##################################################")
|
||
print()
|
||
parser.print_help()
|
||
sys.exit(1)
|
||
|
||
|
||
def describe_event(event):
|
||
return "#{}: {}".format(event["id"], event["title"])
|
||
|
||
|
||
def event_print(event, message):
|
||
print("{} – {}".format(describe_event(event), message))
|
||
|
||
|
||
def fit_text(string: str, max_width: int, font: ImageFont) -> list[str]:
|
||
"""Break text into array of strings which fit certain a width (in pixels) for the specified font."""
|
||
|
||
split_line = [x.strip() for x in string.split()]
|
||
lines = []
|
||
w = 0
|
||
line = []
|
||
for word in split_line:
|
||
new_line = line + [word.rstrip(":")]
|
||
w = font.getlength(" ".join(new_line))
|
||
if w > max_width:
|
||
lines.append(" ".join(line))
|
||
line = []
|
||
|
||
line.append(word.rstrip(":"))
|
||
|
||
if word.endswith(":"):
|
||
lines.append(" ".join(line))
|
||
line = []
|
||
|
||
if line:
|
||
lines.append(" ".join(line))
|
||
|
||
return lines
|
||
|
||
|
||
def ffmpeg_escape_str(text: str) -> str:
|
||
# Escape according to https://ffmpeg.org/ffmpeg-filters.html#Notes-on-filtergraph-escaping
|
||
# and don't put the string in quotes afterwards!
|
||
text = text.replace(",", r"\,")
|
||
text = text.replace(":", r"\\:")
|
||
text = text.replace("'", r"\\\'")
|
||
|
||
return text
|
||
|
||
|
||
def enqueue_job(conf: Config, event):
|
||
event_id = str(event["id"])
|
||
|
||
outfile = str(PurePath(args.project, event_id + ".ts"))
|
||
outfile_mov = str(PurePath(args.project, event_id + ".mov"))
|
||
outfile_mkv = str(PurePath(args.project, event_id + ".mkv"))
|
||
|
||
if event_id in args.skip:
|
||
event_print(event, "skipping " + str(event["id"]))
|
||
return
|
||
if (os.path.exists(outfile) or os.path.exists(outfile_mov) or os.path.exists(outfile_mkv)) and not args.force:
|
||
event_print(event, "file exist, skipping " + str(event["id"]))
|
||
return
|
||
|
||
event_title = str(event["title"])
|
||
event_personnames = str(event["personnames"])
|
||
|
||
title = conf.title.fit_text(event_title)
|
||
speakers = conf.speaker.fit_text(event_personnames)
|
||
extra_text = conf.text.fit_text(conf.extra_text)
|
||
|
||
if args.debug:
|
||
print("Title: ", title)
|
||
print("Speaker: ", speakers)
|
||
|
||
if platform.system() == "Windows":
|
||
ffmpeg_path = "./ffmpeg.exe"
|
||
else:
|
||
ffmpeg_path = "ffmpeg"
|
||
|
||
videofilters = [
|
||
conf.title.get_ffmpeg_filter(conf.inout_type, conf.fade_duration, title),
|
||
conf.speaker.get_ffmpeg_filter(conf.inout_type, conf.fade_duration, speakers),
|
||
conf.text.get_ffmpeg_filter(conf.inout_type, conf.fade_duration, extra_text),
|
||
]
|
||
videofilter = ",".join(x for x in videofilters if len(x) > 0)
|
||
|
||
cmd = [ffmpeg_path, "-y", "-i", conf.template_file, "-vf", videofilter]
|
||
|
||
if conf.fileext == ".mov" and conf.alpha:
|
||
if conf.prores:
|
||
cmd += [
|
||
"-vcodec",
|
||
"prores_ks",
|
||
"-pix_fmt",
|
||
"yuva444p10le",
|
||
"-profile:v",
|
||
"4444",
|
||
"-shortest",
|
||
"-movflags",
|
||
"faststart",
|
||
"-f",
|
||
"mov",
|
||
outfile_mov,
|
||
]
|
||
else:
|
||
cmd += [
|
||
"-shortest",
|
||
"-c:v",
|
||
"qtrle",
|
||
"-movflags",
|
||
"faststart",
|
||
"-f",
|
||
"mov",
|
||
outfile_mov,
|
||
]
|
||
elif conf.fileext == ".mkv":
|
||
cmd += [
|
||
"-map",
|
||
"0:0",
|
||
"-c:v",
|
||
"libsvtav1",
|
||
"-preset",
|
||
"8",
|
||
"-b:v",
|
||
"10M",
|
||
"-aspect",
|
||
"16:9",
|
||
"-map",
|
||
"0:1",
|
||
"-c:a",
|
||
"libopus",
|
||
"-b:a",
|
||
"196k",
|
||
"-shortest",
|
||
"-f",
|
||
"matroska",
|
||
outfile_mkv,
|
||
]
|
||
else:
|
||
cmd += [
|
||
"-map",
|
||
"0:0",
|
||
"-c:v",
|
||
"mpeg2video",
|
||
"-q:v",
|
||
"2",
|
||
"-aspect",
|
||
"16:9",
|
||
"-map",
|
||
"0:1",
|
||
"-c:a",
|
||
"mp2",
|
||
"-b:a",
|
||
"384k",
|
||
"-shortest",
|
||
"-f",
|
||
"mpegts",
|
||
outfile,
|
||
]
|
||
|
||
if args.debug:
|
||
print(cmd)
|
||
|
||
subprocess.check_call(
|
||
cmd,
|
||
stderr=subprocess.STDOUT,
|
||
stdout=subprocess.DEVNULL,
|
||
)
|
||
|
||
return event_id
|
||
|
||
|
||
if __name__ == "__main__":
|
||
# Parse arguments
|
||
parser = argparse.ArgumentParser(
|
||
description="C3VOC Intro-Outro-Generator - Variant which renders only using video filters in ffmpeg",
|
||
usage="./make-ffmpeg.py yourproject/",
|
||
formatter_class=argparse.RawTextHelpFormatter,
|
||
)
|
||
|
||
parser.add_argument(
|
||
"project",
|
||
action="store",
|
||
metavar="Project folder",
|
||
type=str,
|
||
help="""
|
||
Path to your project folder
|
||
""",
|
||
)
|
||
|
||
parser.add_argument(
|
||
"--debug",
|
||
action="store_true",
|
||
default=False,
|
||
help="""
|
||
Run script in debug mode and render with placeholder texts,
|
||
not parsing or accessing a schedule.
|
||
This argument must not be used together with --id
|
||
Usage: ./make-ffmpeg.py yourproject/ --debug
|
||
""",
|
||
)
|
||
|
||
parser.add_argument(
|
||
"--id",
|
||
dest="ids",
|
||
nargs="+",
|
||
action="store",
|
||
type=int,
|
||
help="""
|
||
Only render the given ID(s) from your projects schedule.
|
||
This argument must not be used together with --debug
|
||
Usage: ./make-adobe-after-effects.py yourproject/ --id 4711 0815 4223 1337
|
||
""",
|
||
)
|
||
|
||
parser.add_argument(
|
||
"--room",
|
||
dest="rooms",
|
||
nargs="+",
|
||
action="store",
|
||
type=str,
|
||
help="""
|
||
Only render the given room(s) from your projects schedule.
|
||
This argument must not be used together with --debug
|
||
Usage: ./make-adobe-after-effects.py yourproject/ --room "HfG_Studio" "ZKM_Vortragssaal"
|
||
""",
|
||
)
|
||
|
||
parser.add_argument(
|
||
"--skip",
|
||
nargs="+",
|
||
action="store",
|
||
type=str,
|
||
help="""
|
||
Skip ID(s) not needed to be rendered.
|
||
Usage: ./make-ffmpeg.py yourproject/ --skip 4711 0815 4223 1337
|
||
""",
|
||
)
|
||
|
||
parser.add_argument(
|
||
"--force",
|
||
action="store_true",
|
||
default=False,
|
||
help="""
|
||
Force render if file exists.
|
||
""",
|
||
)
|
||
|
||
args = parser.parse_args()
|
||
|
||
if args.skip is None:
|
||
args.skip = []
|
||
|
||
config = parse_config(PurePath(args.project, "config.ini"))
|
||
|
||
if args.debug:
|
||
persons = [
|
||
"Thomas Roth",
|
||
"Dmitry Nedospasov",
|
||
"Josh Datko",
|
||
]
|
||
events = [
|
||
{
|
||
"id": "debug",
|
||
"title": "wallet.fail and the longest talk title to test if the template is big enough",
|
||
"subtitle": "Hacking the most popular cryptocurrency hardware wallets",
|
||
"persons": persons,
|
||
"personnames": ", ".join(persons),
|
||
"room": "Borg",
|
||
}
|
||
]
|
||
|
||
else:
|
||
events = list(schedulelib.events(config.schedule))
|
||
|
||
if args.ids:
|
||
if len(args.ids) == 1:
|
||
print("enqueuing {} job".format(len(args.ids)))
|
||
else:
|
||
print("enqueuing {} jobs".format(len(args.ids)))
|
||
else:
|
||
if len(events) == 1:
|
||
print("enqueuing {} job".format(len(events)))
|
||
else:
|
||
print("enqueuing {} jobs".format(len(events)))
|
||
|
||
for event in events:
|
||
if args.ids and event["id"] not in args.ids:
|
||
continue
|
||
|
||
if args.rooms and event["room"] not in args.rooms:
|
||
print("skipping room %s (%s)" % (event["room"], event["title"]))
|
||
continue
|
||
|
||
event_print(event, "enqueued as " + str(event["id"]))
|
||
|
||
job_id = enqueue_job(config, event)
|
||
if not job_id:
|
||
event_print(
|
||
event, "job was not enqueued successfully, skipping postprocessing"
|
||
)
|
||
continue
|
||
|
||
print("all done")
|