lyrics-transcriber 0.37.0__py3-none-any.whl → 0.39.0__py3-none-any.whl

lyrics_transcriber/output/cdgmaker/composer.py

@@ -8,6 +8,9 @@ import sys
 import tomllib
 from typing import NamedTuple, Self, TYPE_CHECKING, cast, Iterable, TypeVar
 from zipfile import ZipFile
+
+import ffmpeg
+
 if TYPE_CHECKING:
     from _typeshed import FileDescriptorOrPath, StrOrBytesPath
 
@@ -22,13 +25,30 @@ from .pack import *
 from .render import *
 from .utils import *
 
-
 import logging
+
 logger = logging.getLogger(__name__)
 
+ASS_REQUIREMENTS = True
+try:
+    import ass
+    from fontTools import ttLib
+
+    from datetime import timedelta
+except ImportError:
+    ASS_REQUIREMENTS = False
+
+MP4_REQUIREMENTS = True
+try:
+    import ffmpeg
+except ImportError:
+    MP4_REQUIREMENTS = False
+
+
 package_dir = Path(__file__).parent
 
-T = TypeVar('T')
+T = TypeVar("T")
+
 
 def batched(iterable: Iterable[T], n: int) -> Iterable[tuple[T, ...]]:
     "Batch data into tuples of length n. The last batch may be shorter."
@@ -40,9 +60,10 @@ def batched(iterable: Iterable[T], n: int) -> Iterable[tuple[T, ...]]:
             return
         yield batch
 
+
 def file_relative_to(
-        filepath: "StrOrBytesPath | Path",
-        *relative_to: "StrOrBytesPath | Path",
+    filepath: "StrOrBytesPath | Path",
+    *relative_to: "StrOrBytesPath | Path",
 ) -> Path:
     """
     Convert possibly relative filepath to absolute path, relative to any
@@ -99,6 +120,23 @@ def sync_to_cdg(cs: int) -> int:
     return cs * CDG_FPS // 100
 
 
+def cdg_to_sync(fs: int) -> int:
+    """
+    Convert CDG frame time to sync time to the nearest centisecond.
+
+    Parameters
+    ----------
+    fs : int
+        Time in CDG frames.
+
+    Returns
+    -------
+    int
+        Equivalent time in centiseconds (100ths of a second).
+    """
+    return fs * 100 // CDG_FPS
+
+
 @define
 class SyllableInfo:
     mask: Image.Image
@@ -160,12 +198,12 @@ class KaraokeComposer:
     BORDER = 1
     UNUSED_COLOR = (0, 0, 0)
 
-    #region Constructors
+    # region Constructors
     # SECTION Constructors
     def __init__(
-            self,
-            config: Settings,
-            relative_dir: "StrOrBytesPath | Path" = "",
+        self,
+        config: Settings,
+        relative_dir: "StrOrBytesPath | Path" = "",
     ):
         self.config = config
         self.relative_dir = Path(relative_dir)
@@ -201,15 +239,21 @@ class KaraokeComposer:
             self.UNUSED_COLOR,
         ]
         for singer in self.config.singers:
-            self.color_table.extend([
-                singer.inactive_fill,
-                singer.inactive_stroke,
-                singer.active_fill,
-                singer.active_stroke,
-            ])
-        self.color_table = list(pad(
-            self.color_table, 16, padvalue=self.UNUSED_COLOR,
-        ))
+            self.color_table.extend(
+                [
+                    singer.inactive_fill,
+                    singer.inactive_stroke,
+                    singer.active_fill,
+                    singer.active_stroke,
+                ]
+            )
+        self.color_table = list(
+            pad(
+                self.color_table,
+                16,
+                padvalue=self.UNUSED_COLOR,
+            )
+        )
         logger.debug(f"Color table: {self.color_table}")
 
         self.max_tile_height = 0
@@ -246,7 +290,7 @@ class KaraokeComposer:
                         )
                     ]
 
-                # logger.debug(f"singer {singer}: {syllables}")
+                logger.debug(f"singer {singer}: {syllables}")
                 lines.append(syllables)
                 line_singers.append(singer)
 
@@ -274,19 +318,21 @@ class KaraokeComposer:
             lyric_lines: list[LineInfo] = []
             sync_i = 0
             logger.debug(f"setting sync points for lyric {ci}")
-            for li, (line, singer, line_image, line_mask) in enumerate(zip(
-                lines, line_singers, line_images, line_masks,
-            )):
+            for li, (line, singer, line_image, line_mask) in enumerate(
+                zip(
+                    lines,
+                    line_singers,
+                    line_images,
+                    line_masks,
+                )
+            ):
                 # Center line horizontally
                 x = (CDG_SCREEN_WIDTH - line_image.width) // 2
                 # Place line on correct row
-                y = lyric.row * CDG_TILE_HEIGHT + (
-                    (li % lyric.lines_per_page)
-                    * lyric.line_tile_height * CDG_TILE_HEIGHT
-                )
+                y = lyric.row * CDG_TILE_HEIGHT + ((li % lyric.lines_per_page) * lyric.line_tile_height * CDG_TILE_HEIGHT)
 
                 # Get enough sync points for this line's syllables
-                line_sync = lyric.sync[sync_i:sync_i + len(line)]
+                line_sync = lyric.sync[sync_i : sync_i + len(line)]
                 sync_i += len(line)
                 if line_sync:
                     # The last syllable ends 0.45 seconds after it
@@ -303,11 +349,13 @@ class KaraokeComposer:
 
                 # Collect this line's syllables
                 syllables: list[SyllableInfo] = []
-                for si, (mask, syllable, (start, end)) in enumerate(zip(
-                    line_mask,
-                    line,
-                    it.pairwise(line_sync),
-                )):
+                for si, (mask, syllable, (start, end)) in enumerate(
+                    zip(
+                        line_mask,
+                        line,
+                        it.pairwise(line_sync),
+                    )
+                ):
                     # NOTE Left and right edges here are relative to the
                     # mask. They will be stored relative to the screen.
                     left_edge, right_edge = 0, 0
@@ -315,48 +363,46 @@ class KaraokeComposer:
                     if bbox is not None:
                         left_edge, _, right_edge, _ = bbox
 
-                    syllables.append(SyllableInfo(
-                        mask=mask,
-                        text=syllable,
-                        start_offset=sync_to_cdg(start),
-                        end_offset=sync_to_cdg(end),
-                        left_edge=left_edge + x,
-                        right_edge=right_edge + x,
+                    syllables.append(
+                        SyllableInfo(
+                            mask=mask,
+                            text=syllable,
+                            start_offset=sync_to_cdg(start),
+                            end_offset=sync_to_cdg(end),
+                            left_edge=left_edge + x,
+                            right_edge=right_edge + x,
+                            lyric_index=ci,
+                            line_index=li,
+                            syllable_index=si,
+                        )
+                    )
+
+                lyric_lines.append(
+                    LineInfo(
+                        image=line_image,
+                        text="".join(line),
+                        syllables=syllables,
+                        x=x,
+                        y=y,
+                        singer=singer,
                         lyric_index=ci,
                         line_index=li,
-                        syllable_index=si,
-                    ))
-
-                lyric_lines.append(LineInfo(
-                    image=line_image,
-                    text="".join(line),
-                    syllables=syllables,
-                    x=x,
-                    y=y,
-                    singer=singer,
-                    lyric_index=ci,
-                    line_index=li,
-                ))
+                    )
+                )
 
-            self.lyrics.append(LyricInfo(
-                lines=lyric_lines,
-                line_tile_height=tile_height,
-                lines_per_page=lyric.lines_per_page,
-                lyric_index=ci,
-            ))
+            self.lyrics.append(
+                LyricInfo(
+                    lines=lyric_lines,
+                    line_tile_height=tile_height,
+                    lines_per_page=lyric.lines_per_page,
+                    lyric_index=ci,
+                )
+            )
 
         # Add vertical offset to lines to vertically center them
-        max_height = max(
-            line.image.height
-            for lyric in self.lyrics
-            for line in lyric.lines
-        )
-        line_offset = (
-            self.max_tile_height * CDG_TILE_HEIGHT - max_height
-        ) // 2
-        logger.debug(
-            f"lines will be vertically offset by {line_offset} pixel(s)"
-        )
+        max_height = max(line.image.height for lyric in self.lyrics for line in lyric.lines)
+        line_offset = (self.max_tile_height * CDG_TILE_HEIGHT - max_height) // 2
+        logger.debug(f"lines will be vertically offset by {line_offset} pixel(s)")
         if line_offset:
             for lyric in self.lyrics:
                 for line in lyric.lines:
@@ -371,8 +417,8 @@ class KaraokeComposer:
 
     @classmethod
     def from_file(
-            cls,
-            file: "FileDescriptorOrPath",
+        cls,
+        file: "FileDescriptorOrPath",
     ) -> Self:
         converter = Converter(prefer_attrib_converters=True)
         relative_dir = Path(file).parent
@@ -384,22 +430,24 @@ class KaraokeComposer:
 
     @classmethod
     def from_string(
-            cls,
-            config: str,
-            relative_dir: "StrOrBytesPath | Path" = "",
+        cls,
+        config: str,
+        relative_dir: "StrOrBytesPath | Path" = "",
     ) -> Self:
         converter = Converter(prefer_attrib_converters=True)
         return cls(
             converter.structure(tomllib.loads(config), Settings),
             relative_dir=relative_dir,
         )
+
     # !SECTION
-    #endregion
+    # endregion
 
-    #region Set draw times
+    # region Set draw times
     # SECTION Set draw times
     # Gap between line draw/erase events = 1/6 second
     LINE_DRAW_ERASE_GAP = CDG_FPS // 6
+
     # TODO Make more values in these set-draw-times functions into named
     # constants
 
@@ -413,11 +461,7 @@ class KaraokeComposer:
 
             # The first page is drawn 3 seconds before the first
             # syllable
-            first_syllable = next(iter(
-                syllable_info
-                for line_info in lyric.lines
-                for syllable_info in line_info.syllables
-            ))
+            first_syllable = next(iter(syllable_info for line_info in lyric.lines for syllable_info in line_info.syllables))
             draw_time = first_syllable.start_offset - 900
             for i in range(lyric.lines_per_page):
                 if i < line_count:
@@ -425,11 +469,7 @@ class KaraokeComposer:
                     draw_time += self.LINE_DRAW_ERASE_GAP
 
             # For each pair of syllables
-            for last_wipe, wipe in it.pairwise(
-                syllable_info
-                for line_info in lyric.lines
-                for syllable_info in line_info.syllables
-            ):
+            for last_wipe, wipe in it.pairwise(syllable_info for line_info in lyric.lines for syllable_info in line_info.syllables):
                 # Skip if not on a line boundary
                 if wipe.line_index <= last_wipe.line_index:
                     continue
@@ -438,21 +478,24 @@ class KaraokeComposer:
                 match self.config.clear_mode:
                     case LyricClearMode.PAGE:
                         self._set_draw_times_page(
-                            last_wipe, wipe,
+                            last_wipe,
+                            wipe,
                             lyric=lyric,
                             line_draw=line_draw,
                             line_erase=line_erase,
                         )
                     case LyricClearMode.LINE_EAGER:
                         self._set_draw_times_line_eager(
-                            last_wipe, wipe,
+                            last_wipe,
+                            wipe,
                             lyric=lyric,
                             line_draw=line_draw,
                             line_erase=line_erase,
                         )
                     case LyricClearMode.LINE_DELAYED | _:
                         self._set_draw_times_line_delayed(
-                            last_wipe, wipe,
+                            last_wipe,
+                            wipe,
                             lyric=lyric,
                             line_draw=line_draw,
                             line_erase=line_erase,
@@ -470,25 +513,23 @@ class KaraokeComposer:
                 line_erase[end_line] = erase_time
                 erase_time += self.LINE_DRAW_ERASE_GAP
 
-            logger.debug(
-                f"lyric {lyric.lyric_index} draw times: {line_draw!r}"
-            )
-            logger.debug(
-                f"lyric {lyric.lyric_index} erase times: {line_erase!r}"
+            logger.debug(f"lyric {lyric.lyric_index} draw times: {line_draw!r}")
+            logger.debug(f"lyric {lyric.lyric_index} erase times: {line_erase!r}")
+            self.lyric_times.append(
+                LyricTimes(
+                    line_draw=line_draw,
+                    line_erase=line_erase,
+                )
             )
-            self.lyric_times.append(LyricTimes(
-                line_draw=line_draw,
-                line_erase=line_erase,
-            ))
         logger.info("draw times set")
 
     def _set_draw_times_page(
-            self,
-            last_wipe: SyllableInfo,
-            wipe: SyllableInfo,
-            lyric: LyricInfo,
-            line_draw: list[int],
-            line_erase: list[int],
+        self,
+        last_wipe: SyllableInfo,
+        wipe: SyllableInfo,
+        lyric: LyricInfo,
+        line_draw: list[int],
+        line_erase: list[int],
     ):
         line_count = len(lyric.lines)
         last_page = last_wipe.line_index // lyric.lines_per_page
@@ -516,10 +557,7 @@ class KaraokeComposer:
 
         # Warn the user if there's not likely to be enough time
         if minimum_time < 32:
-            logger.warning(
-                "not enough bandwidth to clear screen on lyric "
-                f"{wipe.lyric_index} line {wipe.line_index}"
-            )
+            logger.warning("not enough bandwidth to clear screen on lyric " f"{wipe.lyric_index} line {wipe.line_index}")
 
         # If there's not enough time between the end of the last line
         # and the start of this line, but there is enough time between
@@ -542,12 +580,12 @@ class KaraokeComposer:
                 page_draw_time += self.LINE_DRAW_ERASE_GAP
 
     def _set_draw_times_line_eager(
-            self,
-            last_wipe: SyllableInfo,
-            wipe: SyllableInfo,
-            lyric: LyricInfo,
-            line_draw: list[int],
-            line_erase: list[int],
+        self,
+        last_wipe: SyllableInfo,
+        wipe: SyllableInfo,
+        lyric: LyricInfo,
+        line_draw: list[int],
+        line_erase: list[int],
     ):
         line_count = len(lyric.lines)
         last_page = last_wipe.line_index // lyric.lines_per_page
@@ -614,12 +652,12 @@ class KaraokeComposer:
                     draw_time += self.LINE_DRAW_ERASE_GAP
 
     def _set_draw_times_line_delayed(
-            self,
-            last_wipe: SyllableInfo,
-            wipe: SyllableInfo,
-            lyric: LyricInfo,
-            line_draw: list[int],
-            line_erase: list[int],
+        self,
+        last_wipe: SyllableInfo,
+        wipe: SyllableInfo,
+        lyric: LyricInfo,
+        line_draw: list[int],
+        line_erase: list[int],
     ):
         line_count = len(lyric.lines)
         last_page = last_wipe.line_index // lyric.lines_per_page
@@ -649,9 +687,7 @@ class KaraokeComposer:
         )
         inter_wipe_time = wipe.start_offset - last_wipe_end
 
-        last_line_start_offset = lyric.lines[
-            last_wipe.line_index
-        ].syllables[0].start_offset
+        last_line_start_offset = lyric.lines[last_wipe.line_index].syllables[0].start_offset
 
         # The last line will be erased at the earlier of:
         # - 1/3 seconds after the start of this line
@@ -722,29 +758,26 @@ class KaraokeComposer:
             if j < line_count:
                 line_draw[j] = draw_time
                 draw_time += self.LINE_DRAW_ERASE_GAP
+
     # !SECTION
-    #endregion
+    # endregion
 
-    #region Compose words
+    # region Compose words
     # SECTION Compose words
     def compose(self):
         try:
             # NOTE Logistically, multiple simultaneous lyric sets doesn't
             # make sense if the lyrics are being cleared by page.
-            if (
-                self.config.clear_mode == LyricClearMode.PAGE
-                and len(self.lyrics) > 1
-            ):
-                raise RuntimeError(
-                    "page mode doesn't support more than one lyric set"
-                )
+            if self.config.clear_mode == LyricClearMode.PAGE and len(self.lyrics) > 1:
+                raise RuntimeError("page mode doesn't support more than one lyric set")
 
             logger.debug("loading song file")
-            song: AudioSegment = AudioSegment.from_file(
-                file_relative_to(self.config.file, self.relative_dir)
-            )
+            song: AudioSegment = AudioSegment.from_file(file_relative_to(self.config.file, self.relative_dir))
             logger.info("song file loaded")
 
+            self.lyric_packet_indices: set[int] = set()
+            self.instrumental_times: list[int] = []
+
             self.intro_delay = 0
             # Compose the intro
             # NOTE This also sets the intro delay for later.
@@ -752,14 +785,16 @@ class KaraokeComposer:
 
             lyric_states: list[LyricState] = []
             for lyric in self.lyrics:
-                lyric_states.append(LyricState(
-                    line_draw=0,
-                    line_erase=0,
-                    syllable_line=0,
-                    syllable_index=0,
-                    draw_queue=deque(),
-                    highlight_queue=deque(),
-                ))
+                lyric_states.append(
+                    LyricState(
+                        line_draw=0,
+                        line_erase=0,
+                        syllable_line=0,
+                        syllable_index=0,
+                        draw_queue=deque(),
+                        highlight_queue=deque(),
+                    )
+                )
 
             composer_state = ComposerState(
                 instrumental=0,
@@ -772,16 +807,11 @@ class KaraokeComposer:
             # intro, the screen should not be cleared. The way I'm detecting
             # this, however, is by (mostly) copy-pasting the code that
             # checks for instrumental sections. I shouldn't do it this way.
-            current_time = (
-                self.writer.packets_queued - self.sync_offset
-                - self.intro_delay
-            )
+            current_time = self.writer.packets_queued - self.sync_offset - self.intro_delay
             should_instrumental = False
             instrumental = None
             if composer_state.instrumental < len(self.config.instrumentals):
-                instrumental = self.config.instrumentals[
-                    composer_state.instrumental
-                ]
+                instrumental = self.config.instrumentals[composer_state.instrumental]
                 instrumental_time = sync_to_cdg(instrumental.sync)
                 # NOTE Normally, this part has code to handle waiting for a
                 # lyric to finish. If there's an instrumental this early,
@@ -791,11 +821,12 @@ class KaraokeComposer:
             if not should_instrumental:
                 logger.debug("instrumental intro is not present; clearing")
                 # Clear the screen
-                self.writer.queue_packets([
-                    *memory_preset_repeat(self.BACKGROUND),
-                    *load_color_table(self.color_table),
-                ])
-                logger.debug(f"loaded color table in compose: {self.color_table}")
+                self.writer.queue_packets(
+                    [
+                        *memory_preset_repeat(self.BACKGROUND),
+                        *load_color_table(self.color_table),
+                    ]
+                )
                 if self.config.border is not None:
                     self.writer.queue_packet(border_preset(self.BORDER))
             else:
@@ -815,9 +846,7 @@ class KaraokeComposer:
                     self.lyric_times,
                     lyric_states,
                 )
-            ) or (
-                composer_state.instrumental < len(self.config.instrumentals)
-            ):
+            ) or (composer_state.instrumental < len(self.config.instrumentals)):
                 for lyric, times, state in zip(
                     self.lyrics,
                     self.lyric_times,
@@ -837,15 +866,13 @@ class KaraokeComposer:
                 self.intro_delay * 1000 // CDG_FPS,
                 frame_rate=song.frame_rate,
             )
-            padded_song = intro_silence + song
+            self.audio = intro_silence + song
 
             # NOTE If video padding is not added to the end of the song, the
             # outro (or next instrumental section) begins immediately after
             # the end of the last syllable, which would be abrupt.
             if self.config.clear_mode == LyricClearMode.PAGE:
-                logger.debug(
-                    "clear mode is page; adding padding before outro"
-                )
+                logger.debug("clear mode is page; adding padding before outro")
                 self.writer.queue_packets([no_instruction()] * 3 * CDG_FPS)
 
             # Calculate video padding before outro
@@ -854,16 +881,12 @@ class KaraokeComposer:
             # - The end of the audio (with the padded intro)
             # - 8 seconds after the current video time
             end = max(
-                int(padded_song.duration_seconds * CDG_FPS),
+                int(self.audio.duration_seconds * CDG_FPS),
                 self.writer.packets_queued + OUTRO_DURATION,
             )
             logger.debug(f"song should be {end} frame(s) long")
-            padding_before_outro = (
-                (end - OUTRO_DURATION) - self.writer.packets_queued
-            )
-            logger.debug(
-                f"queueing {padding_before_outro} packets before outro"
-            )
+            padding_before_outro = (end - OUTRO_DURATION) - self.writer.packets_queued
+            logger.debug(f"queueing {padding_before_outro} packets before outro")
             self.writer.queue_packets([no_instruction()] * padding_before_outro)
 
             # Compose the outro (and thus, finish the video)
@@ -873,13 +896,10 @@ class KaraokeComposer:
             # Add audio padding to outro (and thus, finish the audio)
             logger.debug("padding outro of audio file")
             outro_silence: AudioSegment = AudioSegment.silent(
-                (
-                    (self.writer.packets_queued * 1000 // CDG_FPS)
-                    - int(padded_song.duration_seconds * 1000)
-                ),
+                ((self.writer.packets_queued * 1000 // CDG_FPS) - int(self.audio.duration_seconds * 1000)),
                 frame_rate=song.frame_rate,
             )
-            padded_song += outro_silence
+            self.audio += outro_silence
 
             # Write CDG and MP3 data to ZIP file
             outname = self.config.outname
@@ -889,18 +909,14 @@ class KaraokeComposer:
                 cdg_bytes = BytesIO()
                 logger.debug("writing cdg packets to stream")
                 self.writer.write_packets(cdg_bytes)
-                logger.debug(
-                    f"writing stream to zipfile as {outname}.cdg"
-                )
+                logger.debug(f"writing stream to zipfile as {outname}.cdg")
                 cdg_bytes.seek(0)
                 zipfile.writestr(f"{outname}.cdg", cdg_bytes.read())
 
                 mp3_bytes = BytesIO()
                 logger.debug("writing mp3 data to stream")
-                padded_song.export(mp3_bytes, format="mp3")
-                logger.debug(
-                    f"writing stream to zipfile as {outname}.mp3"
-                )
+                self.audio.export(mp3_bytes, format="mp3")
+                logger.debug(f"writing stream to zipfile as {outname}.mp3")
                 mp3_bytes.seek(0)
                 zipfile.writestr(f"{outname}.mp3", mp3_bytes.read())
             logger.info(f"karaoke files written to {zipfile_name}")
@@ -909,17 +925,14 @@ class KaraokeComposer:
             raise
 
     def _compose_lyric(
-            self,
-            lyric: LyricInfo,
-            times: LyricTimes,
-            state: LyricState,
-            lyric_states: list[LyricState],
-            composer_state: ComposerState,
+        self,
+        lyric: LyricInfo,
+        times: LyricTimes,
+        state: LyricState,
+        lyric_states: list[LyricState],
+        composer_state: ComposerState,
     ):
-        current_time = (
-            self.writer.packets_queued - self.sync_offset
-            - self.intro_delay
-        )
+        current_time = self.writer.packets_queued - self.sync_offset - self.intro_delay
 
         should_draw_this_line = False
         line_draw_info, line_draw_time = None, None
@@ -936,20 +949,12 @@ class KaraokeComposer:
             should_erase_this_line = current_time >= line_erase_time
 
         # If we're clearing lyrics by page and drawing a new line
-        if (
-            self.config.clear_mode == LyricClearMode.PAGE
-            and should_draw_this_line
-        ):
+        if self.config.clear_mode == LyricClearMode.PAGE and should_draw_this_line:
             composer_state.last_page = composer_state.this_page
-            composer_state.this_page = (
-                line_draw_info.line_index // lyric.lines_per_page
-            )
+            composer_state.this_page = line_draw_info.line_index // lyric.lines_per_page
             # If this line is the start of a new page
             if composer_state.this_page > composer_state.last_page:
-                logger.debug(
-                    f"going from page {composer_state.last_page} to "
-                    f"page {composer_state.this_page} in page mode"
-                )
+                logger.debug(f"going from page {composer_state.last_page} to " f"page {composer_state.this_page} in page mode")
                 # If we have not just cleared the screen
                 if not composer_state.just_cleared:
                     logger.debug("clearing screen on page transition")
@@ -959,6 +964,12 @@ class KaraokeComposer:
                     ]
                     if self.config.border is not None:
                         page_clear_packets.append(border_preset(self.BORDER))
+                    self.lyric_packet_indices.update(
+                        range(
+                            self.writer.packets_queued,
+                            self.writer.packets_queued + len(page_clear_packets),
+                        )
+                    )
                     self.writer.queue_packets(page_clear_packets)
                     composer_state.just_cleared = True
                     # Update the current frame time
@@ -969,37 +980,37 @@ class KaraokeComposer:
         # Queue the erasing of this line if necessary
         if should_erase_this_line:
             assert line_erase_info is not None
-            # logger.debug(
-            #     f"t={self.writer.packets_queued}: erasing lyric "
-            #     f"{line_erase_info.lyric_index} line "
-            #     f"{line_erase_info.line_index}"
-            # )
+            logger.debug(
+                f"t={self.writer.packets_queued}: erasing lyric " f"{line_erase_info.lyric_index} line " f"{line_erase_info.line_index}"
+            )
             if line_erase_info.text.strip():
-                state.draw_queue.extend(line_image_to_packets(
-                    line_erase_info.image,
-                    xy=(line_erase_info.x, line_erase_info.y),
-                    background=self.BACKGROUND,
-                    erase=True,
-                ))
+                state.draw_queue.extend(
+                    line_image_to_packets(
+                        line_erase_info.image,
+                        xy=(line_erase_info.x, line_erase_info.y),
+                        background=self.BACKGROUND,
+                        erase=True,
+                    )
+                )
             else:
                 logger.debug("line is blank; not erased")
             state.line_erase += 1
         # Queue the drawing of this line if necessary
         if should_draw_this_line:
             assert line_draw_info is not None
-            # logger.debug(
-            #     f"t={self.writer.packets_queued}: drawing lyric "
-            #     f"{line_draw_info.lyric_index} line "
-            #     f"{line_draw_info.line_index}"
-            # )
+            logger.debug(
+                f"t={self.writer.packets_queued}: drawing lyric " f"{line_draw_info.lyric_index} line " f"{line_draw_info.line_index}"
+            )
             if line_draw_info.text.strip():
-                state.draw_queue.extend(line_image_to_packets(
-                    line_draw_info.image,
-                    xy=(line_draw_info.x, line_draw_info.y),
-                    fill=line_draw_info.singer << 2 | 0,
-                    stroke=line_draw_info.singer << 2 | 1,
-                    background=self.BACKGROUND,
-                ))
+                state.draw_queue.extend(
+                    line_image_to_packets(
+                        line_draw_info.image,
+                        xy=(line_draw_info.x, line_draw_info.y),
+                        fill=line_draw_info.singer << 2 | 0,
+                        stroke=line_draw_info.singer << 2 | 1,
+                        background=self.BACKGROUND,
+                    )
+                )
             else:
                 logger.debug("line is blank; not drawn")
             state.line_draw += 1
@@ -1015,119 +1026,128 @@ class KaraokeComposer:
         should_highlight = False
         syllable_info = None
         if state.syllable_line < len(lyric.lines):
-            syllable_info = (
-                lyric.lines[state.syllable_line]
-                .syllables[state.syllable_index]
-            )
+            syllable_info = lyric.lines[state.syllable_line].syllables[state.syllable_index]
             should_highlight = current_time >= syllable_info.start_offset
         # If this syllable should be highlighted now
         if should_highlight:
             assert syllable_info is not None
             if syllable_info.text.strip():
                 # Add the highlight packets to the highlight queue
-                state.highlight_queue.extend(self._compose_highlight(
-                    lyric=lyric,
-                    syllable=syllable_info,
-                    current_time=current_time,
-                ))
+                state.highlight_queue.extend(
+                    self._compose_highlight(
+                        lyric=lyric,
+                        syllable=syllable_info,
+                        current_time=current_time,
+                    )
+                )
 
             # Advance to the next syllable
             state.syllable_index += 1
-            if state.syllable_index >= len(
-                lyric.lines[state.syllable_line].syllables
-            ):
+            if state.syllable_index >= len(lyric.lines[state.syllable_line].syllables):
                 state.syllable_index = 0
                 state.syllable_line += 1
 
         should_instrumental = False
         instrumental = None
         if composer_state.instrumental < len(self.config.instrumentals):
-            instrumental = self.config.instrumentals[
-                composer_state.instrumental
-            ]
+            instrumental = self.config.instrumentals[composer_state.instrumental]
+            # TODO Improve this code for waiting to start instrumentals!
+            # It's a mess!
             instrumental_time = sync_to_cdg(instrumental.sync)
+            # If instrumental time is to be interpreted as waiting for
+            # syllable to end
             if instrumental.wait:
-                syllable_iter = iter(
-                    syll
-                    for line_info in lyric.lines
-                    for syll in line_info.syllables
-                )
+                syllable_iter = iter(syll for line_info in lyric.lines for syll in line_info.syllables)
                 last_syllable = next(syllable_iter)
                 # Find first syllable on or after the instrumental time
-                while last_syllable.start_offset < instrumental_time:
-                    last_syllable = next(syllable_iter)
-                first_syllable = lyric.lines[
-                    last_syllable.line_index
-                ].syllables[0]
-                # If this line is being actively sung
-                if current_time >= first_syllable.start_offset:
-                    # If this is the last syllable in this line
-                    if last_syllable.syllable_index == len(
-                        lyric.lines[last_syllable.line_index].syllables
-                    ) - 1:
-                        instrumental_time = 0
-                        if times.line_erase:
-                            # Wait for this line to be erased
-                            instrumental_time = times.line_erase[
-                                last_syllable.line_index
-                            ]
-                        if not instrumental_time:
-                            # Add 1.5 seconds
-                            # XXX This is hardcoded.
-                            instrumental_time = last_syllable.end_offset + 450
-                    else:
-                        logger.debug(
-                            "forcing next instrumental not to wait; it "
-                            "does not occur at or before the end of this "
-                            "line"
-                        )
-                        instrumental.wait = False
+                while last_syllable is not None and last_syllable.start_offset < instrumental_time:
+                    last_syllable = next(syllable_iter, None)
+                # If syllable was not found
+                if last_syllable is None:
+                    # Make sure the instrumental won't play
+                    # FIXME This happens when the instrumental is
+                    # happening after some syllable in another lyric.
+                    # What's a better way to handle this?
+                    instrumental_time = float("inf")
+                # If syllable was found
+                else:
+                    first_syllable = lyric.lines[last_syllable.line_index].syllables[0]
+                    # If this line is being actively sung
+                    if current_time >= first_syllable.start_offset:
+                        # If this is the last syllable in this line
+                        if last_syllable.syllable_index == len(lyric.lines[last_syllable.line_index].syllables) - 1:
+                            instrumental_time = 0
+                            if times.line_erase:
+                                # Wait for this line to be erased
+                                instrumental_time = times.line_erase[last_syllable.line_index]
+                            if not instrumental_time:
+                                # Add 1.5 seconds
+                                # XXX This is hardcoded.
+                                instrumental_time = last_syllable.end_offset + 450
+                        else:
+                            logger.debug("forcing next instrumental not to " "wait; it does not occur at or before " "the end of this line")
+                            instrumental.wait = False
             should_instrumental = current_time >= instrumental_time
-
         # If there should be an instrumental section now
         if should_instrumental:
             assert instrumental is not None
-            logger.info("_compose_lyric: Time for an instrumental section")
+            logger.debug("time for an instrumental section")
             if instrumental.wait:
-                logger.info("_compose_lyric: This instrumental section waited for the previous line to finish")
+                logger.debug("this instrumental section waited for the previous " "line to finish")
             else:
-                logger.info("_compose_lyric: This instrumental did not wait for the previous line to finish")
+                logger.debug("this instrumental did not wait for the previous " "line to finish")
 
-            logger.debug("_compose_lyric: Purging all highlight/draw queues")
+            logger.debug("purging all highlight/draw queues")
             for st in lyric_states:
+                # If instrumental has waited for this syllable to end
                 if instrumental.wait:
-                    if st.highlight_queue:
-                        logger.warning("_compose_lyric: Unexpected items in highlight queue when instrumental waited")
+                    # There shouldn't be anything in the highlight queue
+                    assert not st.highlight_queue
+                    # If there's anything left in the draw queue
                     if st.draw_queue:
+                        # NOTE If the current lyric state has anything
+                        # left in the draw queue, it should be the
+                        # erasing of the current line.
                         if st == state:
-                            logger.debug("_compose_lyric: Queueing remaining draw packets for current state")
-                        else:
-                            logger.warning("_compose_lyric: Unexpected items in draw queue for non-current state")
+                            assert should_erase_this_line
+                        # Queue everything left in the draw queue
+                        # immediately
+                        self.lyric_packet_indices.update(
+                            range(
+                                self.writer.packets_queued,
+                                self.writer.packets_queued + len(st.draw_queue),
+                            )
+                        )
                         self.writer.queue_packets(st.draw_queue)
 
+                # Purge highlight/draw queues
                 st.highlight_queue.clear()
                 st.draw_queue.clear()
 
-            logger.debug("_compose_lyric: Determining instrumental end time")
+            # The instrumental should end when the next line is drawn by
+            # default
             if line_draw_time is not None:
                 instrumental_end = line_draw_time
             else:
+                # NOTE A value of None here means this instrumental will
+                # never end (and once the screen is drawn, it will not
+                # pause), unless there is another instrumental after
+                # this.
                 instrumental_end = None
-            logger.debug(f"_compose_lyric: instrumental_end={instrumental_end}")
 
             composer_state.instrumental += 1
             next_instrumental = None
             if composer_state.instrumental < len(self.config.instrumentals):
-                next_instrumental = self.config.instrumentals[
-                    composer_state.instrumental
-                ]
-
+                next_instrumental = self.config.instrumentals[composer_state.instrumental]
             should_clear = True
+            # If there is a next instrumental
             if next_instrumental is not None:
                 next_instrumental_time = sync_to_cdg(next_instrumental.sync)
-                logger.debug(f"_compose_lyric: next_instrumental_time={next_instrumental_time}")
+                # If the next instrumental is immediately after this one
                 if instrumental_end is None or next_instrumental_time <= instrumental_end:
+                    # This instrumental should end there
                     instrumental_end = next_instrumental_time
+                    # Don't clear the screen afterwards
                     should_clear = False
             else:
                 if line_draw_time is None:
@@ -1142,16 +1162,20 @@ class KaraokeComposer:
 
             if should_clear:
                 logger.debug("_compose_lyric: Clearing screen after instrumental")
-                self.writer.queue_packets([
-                    *memory_preset_repeat(self.BACKGROUND),
-                    *load_color_table(self.color_table),
-                ])
+                self.writer.queue_packets(
+                    [
+                        *memory_preset_repeat(self.BACKGROUND),
+                        *load_color_table(self.color_table),
+                    ]
+                )
                 logger.debug(f"_compose_lyric: Loaded color table: {self.color_table}")
                 if self.config.border is not None:
                     self.writer.queue_packet(border_preset(self.BORDER))
                 composer_state.just_cleared = True
             else:
-                logger.debug("_compose_lyric: Not clearing screen after instrumental")
+                logger.debug("not clearing screen after instrumental")
+            # Advance to the next instrumental section
+            instrumental = next_instrumental
             return
 
         composer_state.just_cleared = False
@@ -1164,9 +1188,14 @@ class KaraokeComposer:
                 group = state.highlight_queue.popleft()
             highlight_groups.append(list(pad(group, self.max_tile_height)))
         # NOTE This means the draw groups will only contain None.
-        draw_groups: list[list[CDGPacket | None]] = [
-            [None] * self.max_tile_height
-        ] * self.config.draw_bandwidth
+        draw_groups: list[list[CDGPacket | None]] = [[None] * self.max_tile_height] * self.config.draw_bandwidth
+
+        self.lyric_packet_indices.update(
+            range(
+                self.writer.packets_queued,
+                self.writer.packets_queued + len(list(it.chain(*highlight_groups, *draw_groups))),
+            )
+        )
 
         # Intersperse the highlight and draw groups and queue the
         # packets
@@ -1181,19 +1210,13 @@ class KaraokeComposer:
                 if state.draw_queue:
                     self.writer.queue_packet(state.draw_queue.popleft())
                     continue
-                self.writer.queue_packet(
-                    next(iter(
-                        st.draw_queue.popleft()
-                        for st in lyric_states
-                        if st.draw_queue
-                    ), no_instruction())
-                )
+                self.writer.queue_packet(next(iter(st.draw_queue.popleft() for st in lyric_states if st.draw_queue), no_instruction()))
 
     def _compose_highlight(
-            self,
-            lyric: LyricInfo,
-            syllable: SyllableInfo,
-            current_time: int,
+        self,
+        lyric: LyricInfo,
+        syllable: SyllableInfo,
+        current_time: int,
     ) -> list[list[CDGPacket]]:
         assert syllable is not None
         line_info = lyric.lines[syllable.line_index]
@@ -1209,37 +1232,34 @@ class KaraokeComposer:
         right_edge = syllable.right_edge
 
         # Calculate the length of each column group in frames
-        column_group_length = (
-            (self.config.draw_bandwidth + self.config.highlight_bandwidth)
-            * self.max_tile_height
-        ) * len(self.lyrics)
+        column_group_length = ((self.config.draw_bandwidth + self.config.highlight_bandwidth) * self.max_tile_height) * len(self.lyrics)
         # Calculate the number of column updates for this highlight
-        columns = (
-            (end_offset - start_offset) // column_group_length
-        ) * self.config.highlight_bandwidth
+        columns = ((end_offset - start_offset) // column_group_length) * self.config.highlight_bandwidth
 
         left_tile = left_edge // CDG_TILE_WIDTH
         right_tile = ceildiv(right_edge, CDG_TILE_WIDTH) - 1
         # The highlight must hit at least the edges of all the tiles
         # along it (not including the one before the left edge or the
         # one after the right edge)
-        highlight_progress = [
-            tile_index * CDG_TILE_WIDTH
-            for tile_index in range(left_tile + 1, right_tile + 1)
-        ]
+        highlight_progress = [tile_index * CDG_TILE_WIDTH for tile_index in range(left_tile + 1, right_tile + 1)]
         # If there aren't too many tile boundaries for the number of
         # column updates
         if columns - 1 >= len(highlight_progress):
             # Add enough highlight points for all the column updates...
             highlight_progress += sorted(
                 # ...which are evenly distributed within the range...
-                map(operator.itemgetter(0), distribute(
-                    range(1, columns), left_edge, right_edge,
-                )),
+                map(
+                    operator.itemgetter(0),
+                    distribute(
+                        range(1, columns),
+                        left_edge,
+                        right_edge,
+                    ),
+                ),
                 # ...prioritizing highlight points nearest to the middle
                 # of a tile
                 key=lambda n: abs(n % CDG_TILE_WIDTH - CDG_TILE_WIDTH // 2),
-            )[:columns - 1 - len(highlight_progress)]
+            )[: columns - 1 - len(highlight_progress)]
             # NOTE We need the length of this list to be the number of
             # columns minus 1, so that when the left and right edges are
             # included, there will be as many pairs as there are
@@ -1251,47 +1271,52 @@ class KaraokeComposer:
         # updates
         else:
             # Prepare the syllable text representation
-            syllable_text = ''.join(
+            syllable_text = "".join(
                 f"{{{syll.text}}}" if si == syllable.syllable_index else syll.text
                 for si, syll in enumerate(lyric.lines[syllable.line_index].syllables)
             )
-            
+
             # Warn the user
             logger.warning(
                 "Not enough time to highlight lyric %d line %d syllable %d. "
                 "Ideal duration is %d column(s); actual duration is %d column(s). "
                 "Syllable text: %s",
-                syllable.lyric_index, syllable.line_index, syllable.syllable_index,
-                columns, len(highlight_progress) + 1,
-                syllable_text
+                syllable.lyric_index,
+                syllable.line_index,
+                syllable.syllable_index,
+                columns,
+                len(highlight_progress) + 1,
+                syllable_text,
             )
 
         # Create the highlight packets
         return [
-            line_mask_to_packets(syllable.mask, (x, y), edges)
-            for edges in it.pairwise(
-                [left_edge] + highlight_progress + [right_edge]
-            )
+            line_mask_to_packets(syllable.mask, (x, y), edges) for edges in it.pairwise([left_edge] + highlight_progress + [right_edge])
         ]
+
     # !SECTION
-    #endregion
+    # endregion
 
-    #region Compose pictures
+    # region Compose pictures
     # SECTION Compose pictures
     def _compose_instrumental(
-            self,
-            instrumental: SettingsInstrumental,
-            end: int | None,
+        self,
+        instrumental: SettingsInstrumental,
+        end: int | None,
     ):
         logger.info(f"Composing instrumental section. End time: {end}")
         try:
-            self.writer.queue_packets([
-                *memory_preset_repeat(0),
-                # TODO Add option for borders in instrumentals
-                border_preset(0),
-            ])
+            logger.info("composing instrumental section")
+            self.instrumental_times.append(self.writer.packets_queued)
+            self.writer.queue_packets(
+                [
+                    *memory_preset_repeat(0),
+                    # TODO Add option for borders in instrumentals
+                    border_preset(0),
+                ]
+            )
 
-            logger.debug("Rendering instrumental text")
+            logger.debug("rendering instrumental text")
             text = instrumental.text.split("\n")
             instrumental_font = ImageFont.truetype(self.config.font, 20)
             text_images = render_lines(
@@ -1299,11 +1324,7 @@ class KaraokeComposer:
                 font=instrumental_font,
                 # NOTE If the instrumental shouldn't have a stroke, set the
                 # stroke width to 0 instead.
-                stroke_width=(
-                    self.config.stroke_width
-                    if instrumental.stroke is not None
-                    else 0
-                ),
+                stroke_width=(self.config.stroke_width if instrumental.stroke is not None else 0),
                 stroke_type=self.config.stroke_type,
             )
             text_width = max(image.width for image in text_images)
@@ -1313,47 +1334,21 @@ class KaraokeComposer:
 
             # Set X position of "text box"
             match instrumental.text_placement:
-                case (
-                    TextPlacement.TOP_LEFT
-                    | TextPlacement.MIDDLE_LEFT
-                    | TextPlacement.BOTTOM_LEFT
-                ):
+                case TextPlacement.TOP_LEFT | TextPlacement.MIDDLE_LEFT | TextPlacement.BOTTOM_LEFT:
                     text_x = CDG_TILE_WIDTH * 2
-                case (
-                    TextPlacement.TOP_MIDDLE
-                    | TextPlacement.MIDDLE
-                    | TextPlacement.BOTTOM_MIDDLE
-                ):
+                case TextPlacement.TOP_MIDDLE | TextPlacement.MIDDLE | TextPlacement.BOTTOM_MIDDLE:
                     text_x = (CDG_SCREEN_WIDTH - text_width) // 2
-                case (
-                    TextPlacement.TOP_RIGHT
-                    | TextPlacement.MIDDLE_RIGHT
-                    | TextPlacement.BOTTOM_RIGHT
-                ):
+                case TextPlacement.TOP_RIGHT | TextPlacement.MIDDLE_RIGHT | TextPlacement.BOTTOM_RIGHT:
                     text_x = CDG_SCREEN_WIDTH - CDG_TILE_WIDTH * 2 - text_width
             # Set Y position of "text box"
             match instrumental.text_placement:
-                case (
-                    TextPlacement.TOP_LEFT
-                    | TextPlacement.TOP_MIDDLE
-                    | TextPlacement.TOP_RIGHT
-                ):
+                case TextPlacement.TOP_LEFT | TextPlacement.TOP_MIDDLE | TextPlacement.TOP_RIGHT:
                     text_y = CDG_TILE_HEIGHT * 2
-                case (
-                    TextPlacement.MIDDLE_LEFT
-                    | TextPlacement.MIDDLE
-                    | TextPlacement.MIDDLE_RIGHT
-                ):
-                    text_y = (
-                        (CDG_SCREEN_HEIGHT - text_height) // 2
-                    ) // CDG_TILE_HEIGHT * CDG_TILE_HEIGHT
+                case TextPlacement.MIDDLE_LEFT | TextPlacement.MIDDLE | TextPlacement.MIDDLE_RIGHT:
+                    text_y = ((CDG_SCREEN_HEIGHT - text_height) // 2) // CDG_TILE_HEIGHT * CDG_TILE_HEIGHT
                     # Add offset to place text closer to middle of line
                     text_y += (line_height - max_height) // 2
-                case (
-                    TextPlacement.BOTTOM_LEFT
-                    | TextPlacement.BOTTOM_MIDDLE
-                    | TextPlacement.BOTTOM_RIGHT
-                ):
+                case TextPlacement.BOTTOM_LEFT | TextPlacement.BOTTOM_MIDDLE | TextPlacement.BOTTOM_RIGHT:
                     text_y = CDG_SCREEN_HEIGHT - CDG_TILE_HEIGHT * 2 - text_height
                     # Add offset to place text closer to bottom of line
                     text_y += line_height - max_height
@@ -1381,13 +1376,15 @@ class KaraokeComposer:
                     (x, y),
                 )
                 # Render text into packets
-                text_image_packets.extend(line_image_to_packets(
-                    image,
-                    xy=(x, y),
-                    fill=2,
-                    stroke=3,
-                    background=self.BACKGROUND,
-                ))
+                text_image_packets.extend(
+                    line_image_to_packets(
+                        image,
+                        xy=(x, y),
+                        fill=2,
+                        stroke=3,
+                        background=self.BACKGROUND,
+                    )
+                )
                 y += instrumental.line_tile_height * CDG_TILE_HEIGHT
 
             if instrumental.image is not None:
@@ -1411,21 +1408,25 @@ class KaraokeComposer:
 
             if instrumental.image is None:
                 logger.debug("no instrumental image; drawing simple screen")
-                color_table = list(pad(
-                    [
-                        instrumental.background or self.config.background,
-                        self.UNUSED_COLOR,
-                        instrumental.fill,
-                        instrumental.stroke or self.UNUSED_COLOR,
-                    ],
-                    8,
-                    padvalue=self.UNUSED_COLOR,
-                ))
+                color_table = list(
+                    pad(
+                        [
+                            instrumental.background or self.config.background,
+                            self.UNUSED_COLOR,
+                            instrumental.fill,
+                            instrumental.stroke or self.UNUSED_COLOR,
+                        ],
+                        8,
+                        padvalue=self.UNUSED_COLOR,
+                    )
+                )
                 # Set palette and draw text to screen
-                self.writer.queue_packets([
-                    load_color_table_lo(color_table),
-                    *text_image_packets,
-                ])
+                self.writer.queue_packets(
+                    [
+                        load_color_table_lo(color_table),
+                        *text_image_packets,
+                    ]
+                )
                 logger.debug(f"loaded color table in compose_instrumental: {color_table}")
             else:
                 # Queue palette packets
@@ -1433,38 +1434,34 @@ class KaraokeComposer:
                 if len(palette) < 8:
                     color_table = list(pad(palette, 8, padvalue=self.UNUSED_COLOR))
                     logger.debug(f"loaded color table in compose_instrumental: {color_table}")
-                    self.writer.queue_packet(load_color_table_lo(
-                        color_table,
-                    ))
+                    self.writer.queue_packet(
+                        load_color_table_lo(
+                            color_table,
+                        )
+                    )
                 else:
                     color_table = list(pad(palette, 16, padvalue=self.UNUSED_COLOR))
                     logger.debug(f"loaded color table in compose_instrumental: {color_table}")
-                    self.writer.queue_packets(load_color_table(
-                        color_table,
-                    ))
+                    self.writer.queue_packets(
+                        load_color_table(
+                            color_table,
+                        )
+                    )
 
                 logger.debug("drawing instrumental text")
                 # Queue text packets
                 self.writer.queue_packets(text_image_packets)
 
-                logger.debug(
-                    "rendering instrumental text over background image"
-                )
+                logger.debug("rendering instrumental text over background image")
                 # HACK To properly draw and layer everything, I need to
                 # create a version of the background image that has the text
                 # overlaid onto it, and is tile-aligned. This requires some
                 # juggling.
                 padleft = instrumental.x % CDG_TILE_WIDTH
-                padright = -(
-                    instrumental.x + background_image.width
-                ) % CDG_TILE_WIDTH
+                padright = -(instrumental.x + background_image.width) % CDG_TILE_WIDTH
                 padtop = instrumental.y % CDG_TILE_HEIGHT
-                padbottom = -(
-                    instrumental.y + background_image.height
-                ) % CDG_TILE_HEIGHT
-                logger.debug(
-                    f"padding L={padleft} R={padright} T={padtop} B={padbottom}"
-                )
+                padbottom = -(instrumental.y + background_image.height) % CDG_TILE_HEIGHT
+                logger.debug(f"padding L={padleft} R={padright} T={padtop} B={padbottom}")
                 # Create axis-aligned background image with proper size and
                 # palette
                 aligned_background_image = Image.new(
@@ -1490,17 +1487,16 @@ class KaraokeComposer:
                 packets = image_to_packets(
                     aligned_background_image,
                     (instrumental.x - padleft, instrumental.y - padtop),
-                    background=screen.crop((
-                        instrumental.x - padleft,
-                        instrumental.y - padtop,
-                        instrumental.x - padleft + aligned_background_image.width,
-                        instrumental.y - padtop + aligned_background_image.height,
-                    )),
-                )
-                logger.debug(
-                    "instrumental background image packed in "
-                    f"{len(list(it.chain(*packets.values())))} packet(s)"
+                    background=screen.crop(
+                        (
+                            instrumental.x - padleft,
+                            instrumental.y - padtop,
+                            instrumental.x - padleft + aligned_background_image.width,
+                            instrumental.y - padtop + aligned_background_image.height,
+                        )
+                    ),
                 )
+                logger.debug("instrumental background image packed in " f"{len(list(it.chain(*packets.values())))} packet(s)")
 
                 logger.debug("applying instrumental transition")
                 # Queue background image packets (and apply transition)
@@ -1508,35 +1504,30 @@ class KaraokeComposer:
                     for coord_packets in packets.values():
                         self.writer.queue_packets(coord_packets)
                 else:
-                    transition = Image.open(
-                        package_dir / "transitions" / f"{instrumental.transition}.png"
-                    )
+                    transition = Image.open(package_dir / "transitions" / f"{instrumental.transition}.png")
                     for coord in self._gradient_to_tile_positions(transition):
                         self.writer.queue_packets(packets.get(coord, []))
 
             if end is None:
-                logger.debug("this instrumental will last \"forever\"")
+                logger.debug('this instrumental will last "forever"')
                 return
 
             # Wait until 3 seconds before the next line should be drawn
-            current_time = (
-                self.writer.packets_queued - self.sync_offset
-                - self.intro_delay
-            )
+            current_time = self.writer.packets_queued - self.sync_offset - self.intro_delay
             preparation_time = 3 * CDG_FPS  # 3 seconds * 300 frames per second = 900 frames
             end_time = max(current_time, end - preparation_time)
             wait_time = end_time - current_time
-            
+
             logger.debug(f"waiting for {wait_time} frame(s) before showing next lyrics")
-            self.writer.queue_packets(
-                [no_instruction()] * wait_time
-            )
+            self.writer.queue_packets([no_instruction()] * wait_time)
 
             # Clear the screen for the next lyrics
-            self.writer.queue_packets([
-                *memory_preset_repeat(self.BACKGROUND),
-                *load_color_table(self.color_table),
-            ])
+            self.writer.queue_packets(
+                [
+                    *memory_preset_repeat(self.BACKGROUND),
+                    *load_color_table(self.color_table),
+                ]
+            )
             logger.debug(f"loaded color table in compose_instrumental: {self.color_table}")
             if self.config.border is not None:
                 self.writer.queue_packet(border_preset(self.BORDER))
@@ -1549,9 +1540,11 @@ class KaraokeComposer:
     def _compose_intro(self):
         # TODO Make it so the intro screen is not hardcoded
         logger.debug("composing intro")
-        self.writer.queue_packets([
-            *memory_preset_repeat(0),
-        ])
+        self.writer.queue_packets(
+            [
+                *memory_preset_repeat(0),
+            ]
+        )
 
         logger.debug("loading intro background image")
         # Load background image
@@ -1560,7 +1553,7 @@ class KaraokeComposer:
             [
                 self.config.background,  # background
                 self.config.border,  # border
-                self.config.title_color,   # title color
+                self.config.title_color,  # title color
                 self.config.artist_color,  # artist color
             ],
         )
@@ -1585,7 +1578,8 @@ class KaraokeComposer:
                 font=bigfont,
             ):
                 text_image.paste(
-                    image.point(lambda v: v and 2, "P"),  # Use index 2 for title color
+                    # Use index 2 for title color
+                    image.point(lambda v: v and 2, "P"),
                     ((text_image.width - image.width) // 2, y),
                     mask=image.point(lambda v: v and 255, "1"),
                 )
@@ -1604,7 +1598,8 @@ class KaraokeComposer:
                 font=smallfont,
             ):
                 text_image.paste(
-                    image.point(lambda v: v and 3, "P"),  # Use index 3 for artist color
+                    # Use index 3 for artist color
+                    image.point(lambda v: v and 3, "P"),
                     ((text_image.width - image.width) // 2, y),
                     mask=image.point(lambda v: v and 255, "1"),
                 )
@@ -1634,27 +1629,26 @@ class KaraokeComposer:
         if len(palette) < 8:
             color_table = list(pad(palette, 8, padvalue=self.UNUSED_COLOR))
             logger.debug(f"loaded color table in compose_intro: {color_table}")
-            self.writer.queue_packet(load_color_table_lo(
-                color_table,
-            ))
+            self.writer.queue_packet(
+                load_color_table_lo(
+                    color_table,
+                )
+            )
         else:
             color_table = list(pad(palette, 16, padvalue=self.UNUSED_COLOR))
             logger.debug(f"loaded color table in compose_intro: {color_table}")
-            self.writer.queue_packets(load_color_table(
-                color_table,
-            ))
+            self.writer.queue_packets(
+                load_color_table(
+                    color_table,
+                )
+            )
 
         # Render background image to packets
         packets = image_to_packets(background_image, (0, 0))
-        logger.debug(
-            "intro background image packed in "
-            f"{len(list(it.chain(*packets.values())))} packet(s)"
-        )
+        logger.debug("intro background image packed in " f"{len(list(it.chain(*packets.values())))} packet(s)")
 
         # Queue background image packets (and apply transition)
-        transition = Image.open(
-            package_dir / "transitions" / f"{self.config.title_screen_transition}.png"
-        )
+        transition = Image.open(package_dir / "transitions" / f"{self.config.title_screen_transition}.png")
         for coord in self._gradient_to_tile_positions(transition):
             self.writer.queue_packets(packets.get(coord, []))
 
@@ -1664,15 +1658,10 @@ class KaraokeComposer:
 
         # Queue the intro screen for 5 seconds
         end_time = INTRO_DURATION
-        self.writer.queue_packets(
-            [no_instruction()] * (end_time - self.writer.packets_queued)
-        )
+        self.writer.queue_packets([no_instruction()] * (end_time - self.writer.packets_queued))
 
         first_syllable_start_offset = min(
-            syllable.start_offset
-            for lyric in self.lyrics
-            for line in lyric.lines
-            for syllable in line.syllables
+            syllable.start_offset for lyric in self.lyrics for line in lyric.lines for syllable in line.syllables
         )
         logger.debug(f"first syllable starts at {first_syllable_start_offset}")
 
@@ -1681,7 +1670,9 @@ class KaraokeComposer:
         # Otherwise, don't add any silence
         if first_syllable_start_offset < MINIMUM_FIRST_SYLLABLE_TIME_FOR_NO_SILENCE:
             self.intro_delay = MINIMUM_FIRST_SYLLABLE_TIME_FOR_NO_SILENCE
-            logger.info(f"First syllable within {self.config.intro_duration_seconds + self.config.first_syllable_buffer_seconds} seconds. Adding {self.intro_delay} frames of silence.")
+            logger.info(
+                f"First syllable within {self.config.intro_duration_seconds + self.config.first_syllable_buffer_seconds} seconds. Adding {self.intro_delay} frames of silence."
+            )
         else:
             self.intro_delay = 0
             logger.info("First syllable after buffer period. No additional silence needed.")
@@ -1689,9 +1680,11 @@ class KaraokeComposer:
     def _compose_outro(self, end: int):
         # TODO Make it so the outro screen is not hardcoded
         logger.debug("composing outro")
-        self.writer.queue_packets([
-            *memory_preset_repeat(0),
-        ])
+        self.writer.queue_packets(
+            [
+                *memory_preset_repeat(0),
+            ]
+        )
 
         logger.debug("loading outro background image")
         # Load background image
@@ -1715,7 +1708,7 @@ class KaraokeComposer:
 
         # Render first line of outro text
         outro_text_line1 = self.config.outro_text_line1.replace("$artist", self.config.artist).replace("$title", self.config.title)
-        
+
         for image in render_lines(
             get_wrapped_text(
                 outro_text_line1,
@@ -1725,13 +1718,13 @@ class KaraokeComposer:
             font=smallfont,
         ):
             text_image.paste(
-                image.point(lambda v: v and 2, "P"),  # Use index 2 for line 1 color
+                # Use index 2 for line 1 color
+                image.point(lambda v: v and 2, "P"),
                 ((text_image.width - image.width) // 2, y),
                 mask=image.point(lambda v: v and 255, "1"),
             )
             y += int(smallfont.size)
 
-
         # Add vertical gap between title and artist using configured value
         y += self.config.outro_line1_line2_gap
 
@@ -1747,7 +1740,8 @@ class KaraokeComposer:
             font=smallfont,
         ):
             text_image.paste(
-                image.point(lambda v: v and 3, "P"),  # Use index 3 for line 2 color
+                # Use index 3 for line 2 color
+                image.point(lambda v: v and 3, "P"),
                 ((text_image.width - image.width) // 2, y),
                 mask=image.point(lambda v: v and 255, "1"),
             )
@@ -1770,44 +1764,31 @@ class KaraokeComposer:
         # Queue palette packets
         palette = list(batched(background_image.getpalette(), 3))
         if len(palette) < 8:
-            self.writer.queue_packet(load_color_table_lo(
-                list(pad(palette, 8, padvalue=self.UNUSED_COLOR))
-            ))
+            self.writer.queue_packet(load_color_table_lo(list(pad(palette, 8, padvalue=self.UNUSED_COLOR))))
         else:
-            self.writer.queue_packets(load_color_table(
-                list(pad(palette, 16, padvalue=self.UNUSED_COLOR))
-            ))
+            self.writer.queue_packets(load_color_table(list(pad(palette, 16, padvalue=self.UNUSED_COLOR))))
 
         # Render background image to packets
         packets = image_to_packets(background_image, (0, 0))
-        logger.debug(
-            "intro background image packed in "
-            f"{len(list(it.chain(*packets.values())))} packet(s)"
-        )
+        logger.debug("intro background image packed in " f"{len(list(it.chain(*packets.values())))} packet(s)")
 
         # Queue background image packets (and apply transition)
-        transition = Image.open(
-            package_dir / "transitions" / f"{self.config.outro_transition}.png"
-        )
+        transition = Image.open(package_dir / "transitions" / f"{self.config.outro_transition}.png")
         for coord in self._gradient_to_tile_positions(transition):
             self.writer.queue_packets(packets.get(coord, []))
 
-        self.writer.queue_packets(
-            [no_instruction()] * (end - self.writer.packets_queued)
-        )
+        self.writer.queue_packets([no_instruction()] * (end - self.writer.packets_queued))
 
     def _load_image(
-            self,
-            image_path: "StrOrBytesPath | Path",
-            partial_palette: list[RGBColor] | None = None,
+        self,
+        image_path: "StrOrBytesPath | Path",
+        partial_palette: list[RGBColor] | None = None,
     ):
         if partial_palette is None:
             partial_palette = []
 
         logger.debug("loading image")
-        image_rgba = Image.open(
-            file_relative_to(image_path, self.relative_dir)
-        ).convert("RGBA")
+        image_rgba = Image.open(file_relative_to(image_path, self.relative_dir)).convert("RGBA")
         image = image_rgba.convert("RGB")
 
         # REVIEW How many colors should I allow? Should I make this
@@ -1824,49 +1805,42 @@ class KaraokeComposer:
             dither=Image.Dither.FLOYDSTEINBERG,
         )
         # Further reduce colors to conform to 12-bit RGB palette
-        image.putpalette([
-            # HACK The RGB values of the colors that show up in CDG
-            # players are repdigits in hexadecimal - 0x00, 0x11, 0x22,
-            # 0x33, etc. This means that we can simply round each value
-            # to the nearest multiple of 0x11 (17 in decimal).
-            0x11 * round(v / 0x11)
-            for v in image.getpalette()
-        ])
+        image.putpalette(
+            [
+                # HACK The RGB values of the colors that show up in CDG
+                # players are repdigits in hexadecimal - 0x00, 0x11, 0x22,
+                # 0x33, etc. This means that we can simply round each value
+                # to the nearest multiple of 0x11 (17 in decimal).
+                0x11 * round(v / 0x11)
+                for v in image.getpalette()
+            ]
+        )
         image = image.quantize()
         logger.debug(f"image uses {max(image.getdata()) + 1} color(s)")
 
         if partial_palette:
-            logger.debug(
-                f"prepending {len(partial_palette)} color(s) to palette"
-            )
+            logger.debug(f"prepending {len(partial_palette)} color(s) to palette")
             # Add offset to color indices
             image.putdata(image.getdata(), offset=len(partial_palette))
             # Place other colors in palette
-            image.putpalette(
-                list(it.chain(*partial_palette)) + image.getpalette()
-            )
+            image.putpalette(list(it.chain(*partial_palette)) + image.getpalette())
 
-        logger.debug(
-            f"palette: {list(batched(image.getpalette(), 3))!r}"
-        )
+        logger.debug(f"palette: {list(batched(image.getpalette(), 3))!r}")
 
         logger.debug("masking out non-transparent parts of image")
         # Create mask for non-transparent parts of image
         # NOTE We allow alpha values from 128 to 255 (half-transparent
         # to opaque).
         mask = Image.new("1", image_rgba.size, 0)
-        mask.putdata([
-            0 if pixel >= 128 else 255
-            for pixel in image_rgba.getdata(band=3)
-        ])
+        mask.putdata([0 if pixel >= 128 else 255 for pixel in image_rgba.getdata(band=3)])
         # Set transparent parts of background to 0
         image.paste(Image.new("P", image.size, 0), mask=mask)
 
         return image
 
     def _gradient_to_tile_positions(
-            self,
-            image: Image.Image,
+        self,
+        image: Image.Image,
     ) -> list[tuple[int, int]]:
         """
         Convert an image of a gradient to an ordering of tile positions.
@@ -1897,23 +1871,354 @@ class KaraokeComposer:
             # is not done with reverse=True to preserve the sort's
             # stability.
             intensities[(tile_y, tile_x)] = -sum(
-                image.getpixel((
-                    tile_x * CDG_TILE_WIDTH + x,
-                    tile_y * CDG_TILE_HEIGHT + y,
-                ))
+                image.getpixel(
+                    (
+                        tile_x * CDG_TILE_WIDTH + x,
+                        tile_y * CDG_TILE_HEIGHT + y,
+                    )
+                )
                 for x in range(CDG_TILE_WIDTH)
                 for y in range(CDG_TILE_HEIGHT)
             )
         return sorted(intensities, key=intensities.get)
+
     # !SECTION
-    #endregion
+    # endregion
+
+    # region Create MP4
+    # SECTION Create MP4
+    def create_ass(self):
+        if not ASS_REQUIREMENTS:
+            raise RuntimeError("could not import requirements for creating ASS")
+
+        # Create ASS subtitle object
+        # (ASS = Advanced Sub Station. Get your mind out of the gutter.)
+        logger.debug("creating ASS subtitle object")
+        assdoc = ass.Document()
+        assdoc.fields.update(
+            Title="",
+            WrapStyle=2,
+            ScaledBorderAndShadow="yes",
+            Collisions="normal",
+            PlayResX=CDG_SCREEN_WIDTH,
+            PlayResY=CDG_SCREEN_HEIGHT,
+        )
 
-def main():
-    # TODO Make the logging level configurable from the command line
-    logging.basicConfig(level=logging.DEBUG)
+        # Load lyric font using fontTools
+        # NOTE We do this because we need some of the font's metadata.
+        logger.debug("loading metadata from font")
+        font = ttLib.TTFont(self.font.path)
+
+        # NOTE The ASS Style lines need the "fontname as used by
+        # Windows". The best name for this purpose is name 4, which
+        # Apple calls the "full name of the font". (Oh yeah, and Apple
+        # developed TrueType, the font format used here. Who knew?)
+        fontname = font["name"].getDebugName(4)
+
+        # NOTE PIL interprets a font's size as its "nominal size", or
+        # "em height". The ASS format interprets a font's size as its
+        # "actual size" - the area enclosing its highest and lowest
+        # points.
+        # Relative values for these sizes can be found/calculated from
+        # the font's headers, and the ratio between them is used to
+        # scale the lyric font size from nominal to actual.
+        nominal_size = cast(int, font["head"].unitsPerEm)
+        ascent = cast(int, font["hhea"].ascent)
+        descent = cast(int, font["hhea"].descent)
+        actual_size = ascent - descent
+        fontsize = self.config.font_size * actual_size / nominal_size
+        # HACK If I position each line at its proper Y position, it
+        # looks shifted down slightly. This should correct it, I think.
+        y_offset = self.config.font_size * (descent / 2) / nominal_size
+
+        # Create a style for each singer
+        for i, singer in enumerate(self.config.singers, 1):
+            logger.debug(f"creating ASS style for singer {i}")
+            assdoc.styles.append(
+                ass.Style(
+                    name=f"Singer{i}",
+                    fontname=fontname,
+                    fontsize=fontsize,
+                    primary_color=ass.line.Color(*singer.active_fill),
+                    secondary_color=ass.line.Color(*singer.inactive_fill),
+                    outline_color=ass.line.Color(*singer.inactive_stroke),
+                    back_color=ass.line.Color(*singer.active_stroke),
+                    border_style=1,  # outline + drop shadow
+                    outline=self.config.stroke_width,
+                    shadow=0,
+                    alignment=8,  # alignment point is at top middle
+                    margin_l=0,
+                    margin_r=0,
+                    margin_v=0,
+                )
+            )
+
+        offset = cdg_to_sync(self.intro_delay + self.sync_offset)
+        instrumental = 0
+        # Create events for each line sung in each lyric set
+        for ci, (lyric, times) in enumerate(
+            zip(
+                self.lyrics,
+                self.lyric_times,
+            )
+        ):
+            for li, line in enumerate(lyric.lines):
+                # Skip line if it has no syllables
+                if not line.syllables:
+                    continue
+                logger.debug(f"creating event for lyric {ci} line {li}")
+
+                # Get intended draw time of line
+                line_draw_time = cdg_to_sync(times.line_draw[li]) + offset
+                # XXX This is hardcoded, so as to not have the line's
+                # appearance clash with the intro.
+                line_draw_time = max(line_draw_time, 800)
+
+                # The upcoming instrumental section should be the first
+                # one after this line is drawn
+                while instrumental < len(self.instrumental_times) and (
+                    cdg_to_sync(self.instrumental_times[instrumental]) <= line_draw_time
+                ):
+                    instrumental += 1
+
+                # Get intended erase time of line, if possible
+                if times.line_erase:
+                    line_erase_time = cdg_to_sync(times.line_erase[li]) + offset
+                # If there are no erase times saved, then lyrics are
+                # being cleared by page instead of being erased
+                else:
+                    # Get first non-empty line of next page
+                    next_page_li = (li // lyric.lines_per_page + 1) * lyric.lines_per_page
+                    while next_page_li < len(lyric.lines):
+                        if lyric.lines[next_page_li].syllables:
+                            break
+                        next_page_li += 1
+
+                    # If there is a next page
+                    if next_page_li < len(lyric.lines):
+                        # Erase the current line when the next page is
+                        # drawn
+                        line_erase_time = cdg_to_sync(times.line_draw[next_page_li]) + offset
+                    # If there is no next page
+                    else:
+                        # Erase the current line after the last syllable
+                        # of this line is highlighted
+                        # XXX This is hardcoded.
+                        line_erase_time = cdg_to_sync(line.syllables[-1].end_offset) + offset + 200
+
+                    if instrumental < len(self.instrumental_times):
+                        # The current line should be erased before the
+                        # upcoming instrumental section
+                        line_erase_time = min(
+                            line_erase_time,
+                            cdg_to_sync(self.instrumental_times[instrumental]),
+                        )
+
+                text = ""
+                # Text is horizontally centered, and at the line's Y
+                x = CDG_SCREEN_WIDTH // 2
+                y = line.y + y_offset
+                text += f"{{\\pos({x},{y})}}"
+                # Text should fade in and out with the intended
+                # draw/erase timing
+                # NOTE This is in milliseconds for some reason, whereas
+                # every other timing value is in centiseconds.
+                fade = cdg_to_sync(self.LINE_DRAW_ERASE_GAP) * 10
+                text += f"{{\\fad({fade},{fade})}}"
+                # There should be a pause before the text is highlighted
+                line_start_offset = cdg_to_sync(line.syllables[0].start_offset) + offset
+                text += f"{{\\k{line_start_offset - line_draw_time}}}"
+                # Each syllable should be filled in for the specified
+                # duration
+                for syll in line.syllables:
+                    length = cdg_to_sync(syll.end_offset - syll.start_offset)
+                    text += f"{{\\kf{length}}}{syll.text}"
+
+                # Create a dialogue event for this line
+                assdoc.events.append(
+                    ass.Dialogue(
+                        layer=ci,
+                        # NOTE The line draw and erase times are in
+                        # centiseconds, so we need to multiply by 10 for
+                        # milliseconds.
+                        start=timedelta(milliseconds=line_draw_time * 10),
+                        end=timedelta(milliseconds=line_erase_time * 10),
+                        style=f"Singer{line.singer}",
+                        effect="karaoke",
+                        text=text,
+                    )
+                )
+
+        outname = self.config.outname
+        assfile_name = self.relative_dir / Path(f"{outname}.ass")
+        logger.debug(f"dumping ASS object to {assfile_name}")
+        # HACK If I don't specify "utf-8-sig" as the encoding, the
+        # python-ass module gives me a warning telling me to. This adds
+        # a "byte order mark" to the ASS file (seemingly unnecessarily).
+        with open(assfile_name, "w", encoding="utf-8-sig") as assfile:
+            assdoc.dump_file(assfile)
+        logger.info(f"ASS object dumped to {assfile_name}")
+
+    def create_mp4(self, height: int = 720, fps: int = 30):
+        if not MP4_REQUIREMENTS:
+            raise RuntimeError("could not import requirements for creating MP4")
+
+        outname = self.config.outname
+
+        # Create a "background plate" for the video
+        # NOTE The "background plate" will simply be the CDG file we've
+        # composed, but without the lyrics. We create this by replacing
+        # all lyric-drawing packets with no-instruction packets.
+        platecdg_name = self.relative_dir / Path(f"{outname}.plate.cdg")
+        logger.debug(f"writing plate CDG to {platecdg_name}")
+        with open(platecdg_name, "wb") as platecdg:
+            logger.debug("writing plate")
+            for i, packet in enumerate(self.writer.packets):
+                packet_to_write = packet
+                if i in self.lyric_packet_indices:
+                    packet_to_write = no_instruction()
+                self.writer.write_packet(platecdg, packet_to_write)
+        logger.info(f"plate CDG written to {platecdg_name}")
+
+        # Create an MP3 file for the audio
+        platemp3_name = self.relative_dir / Path(f"{outname}.plate.mp3")
+        logger.debug(f"writing plate MP3 to {platemp3_name}")
+        self.audio.export(platemp3_name, format="mp3")
+        logger.info(f"plate MP3 written to {platemp3_name}")
+
+        # Create a subtitle file for the HQ lyrics
+        self.create_ass()
+        assfile_name = self.relative_dir / Path(f"{outname}.ass")
+
+        logger.debug("building ffmpeg command for encoding MP4")
+        video = (
+            ffmpeg.input(platecdg_name).video
+            # Pad the end of the video by a few seconds
+            # HACK This ensures the last video frame isn't some CDG
+            # frame before the last one. This padding will also be cut
+            # later.
+            .filter_("tpad", stop_mode="clone", stop_duration=5)
+            # Set framerate
+            .filter_("fps", fps=fps)
+            # Scale video to resolution
+            .filter_(
+                "scale",
+                # HACK The libx264 codec requires the video dimensions
+                # to be divisible by 2. Here, the width is not only
+                # automatically calculated from the plate's aspect
+                # ratio, but truncated down to a multiple of 2.
+                w="trunc(oh*a/2)*2",
+                h=height // 2 * 2,
+                flags="neighbor",
+            )
+            # Burn in subtitles
+            .filter_("ass", filename=assfile_name)
+        )
+        audio = ffmpeg.input(platemp3_name)
+
+        mp4_name = self.relative_dir / Path(f"{outname}.mp4")
+        mp4 = ffmpeg.output(
+            video,
+            audio,
+            filename=mp4_name,
+            hide_banner=None,
+            loglevel="error",
+            stats=None,
+            # Video should use the H.264 codec, at a decent quality
+            vcodec="libx264",
+            pix_fmt="yuv420p",
+            crf=22,
+            preset="veryfast",
+            # Truncate to the length of the shortest input
+            # HACK This effectively removes the video padding that was
+            # added earlier, because the audio is shorter than the
+            # padded video.
+            shortest=None,
+        ).overwrite_output()
+        logger.debug(f"ffmpeg command: {mp4.compile()}")
+        mp4.run()
+
+        logger.debug("deleting plate CDG")
+        platecdg_name.unlink()
+        logger.info("plate CDG deleted")
+
+        logger.debug("deleting plate MP3")
+        platemp3_name.unlink()
+        logger.info("plate MP3 deleted")
+
+    # !SECTION
+    # endregion
 
-    kc = KaraokeComposer.from_file(sys.argv[1])
+
+def main():
+    from argparse import ArgumentParser, RawDescriptionHelpFormatter
+    import sys
+
+    parser = ArgumentParser(
+        prog="py -m cdgmaker",
+        description="Create custom CDG files for karaoke.",
+        epilog=("For a description of the config format, visit " "https://github.com/WinslowJosiah/cdgmaker"),
+        formatter_class=RawDescriptionHelpFormatter,
+    )
+    parser.add_argument(
+        "config",
+        help=".toml config file to create CDG files with",
+        metavar="FILE",
+        type=str,
+    )
+    parser.add_argument(
+        "-v",
+        "--verbose",
+        help="make logs more verbose (-v, -vv, etc.)",
+        action="count",
+        default=0,
+    )
+    parser.add_argument(
+        "-r",
+        "--render",
+        help="render MP4 video of created CDG file",
+        action="store_true",
+    )
+
+    # If there aren't any arguments to parse
+    if len(sys.argv) < 2:
+        # Print help message and exit with error
+        parser.print_help()
+        sys.exit(1)
+
+    # Overwrite the error handler to also print a help message
+    # HACK: This is what's known in the biz as a "monkey-patch". Don't
+    # worry if it doesn't make sense to you; it makes sense to argparse,
+    # and that's all that matters.
+    def custom_error_handler(_self: ArgumentParser):
+
+        def wrapper(message: str):
+            sys.stderr.write(f"{_self.prog}: error: {message}\n")
+            _self.print_help()
+            sys.exit(2)
+
+        return wrapper
+
+    parser.error = custom_error_handler(parser)
+
+    # Parse command line arguments
+    args = parser.parse_args()
+
+    # Set logging level based on verbosity
+    log_level = logging.ERROR
+    if not args.verbose:
+        log_level = logging.WARNING
+    elif args.verbose == 1:
+        log_level = logging.INFO
+    elif args.verbose >= 2:
+        log_level = logging.DEBUG
+    logging.basicConfig(level=log_level)
+
+    kc = KaraokeComposer.from_file(args.config)
     kc.compose()
+    if args.render:
+        kc.create_mp4(height=1080, fps=60)
+
 
 if __name__ == "__main__":
     main()