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

lyrics_transcriber/cli/cli_main.py

@@ -68,6 +68,12 @@ def create_arg_parser() -> argparse.ArgumentParser:
         type=Path,
         help="JSON file containing output style configurations for CDG and video generation",
     )
+    output_group.add_argument(
+        "--subtitle_offset",
+        type=int,
+        default=0,
+        help="Offset subtitle timing by N milliseconds (positive or negative). Default: 0",
+    )
 
     # Feature control group
     feature_group = parser.add_argument_group("Feature Control")
@@ -143,6 +149,7 @@ def create_configs(args: argparse.Namespace, env_config: Dict[str, str]) -> tupl
         output_dir=str(args.output_dir) if args.output_dir else os.getcwd(),
         cache_dir=str(args.cache_dir),
         video_resolution=args.video_resolution,
+        subtitle_offset_ms=args.subtitle_offset,
         fetch_lyrics=not args.skip_lyrics_fetch,
         run_transcription=not args.skip_transcription,
         run_correction=not args.skip_correction,

lyrics_transcriber/core/config.py

@@ -43,3 +43,4 @@ class OutputConfig:
     generate_cdg: bool = True
     render_video: bool = True
     video_resolution: str = "360p"
+    subtitle_offset_ms: int = 0

lyrics_transcriber/output/cdg.py

@@ -9,6 +9,7 @@ import os
 import zipfile
 import shutil
 
+from lyrics_transcriber.output.cdgmaker.cdg import CDG_VISIBLE_WIDTH
 from lyrics_transcriber.output.cdgmaker.composer import KaraokeComposer
 from lyrics_transcriber.output.cdgmaker.render import get_wrapped_text
 from lyrics_transcriber.types import LyricsSegment
@@ -110,7 +111,7 @@ class CDGGenerator:
                 # Convert time from seconds to centiseconds
                 timestamp = int(word.start_time * 100)
                 lyrics_data.append({"timestamp": timestamp, "text": word.text.upper()})  # CDG format expects uppercase text
-                # self.logger.debug(f"Added lyric: timestamp {timestamp}, text '{word.text}'")
+                self.logger.debug(f"Added lyric: timestamp {timestamp}, text '{word.text}'")
 
         # Sort by timestamp to ensure correct order
         lyrics_data.sort(key=lambda x: x["timestamp"])
@@ -125,7 +126,7 @@ class CDGGenerator:
         cdg_styles: dict,
     ) -> str:
         """Create TOML configuration file for CDG generation."""
-        safe_filename = self._get_safe_filename(artist, title, "Karaoke CDG", "toml")
+        safe_filename = self._get_safe_filename(artist, title, "Karaoke", "toml")
         toml_file = os.path.join(self.output_dir, safe_filename)
         self.logger.debug(f"Generating TOML file: {toml_file}")
 
@@ -160,7 +161,7 @@ class CDGGenerator:
             title=title,
             artist=artist,
             audio_file=audio_file,
-            output_name=f"{artist} - {title} (Karaoke CDG)",
+            output_name=f"{artist} - {title} (Karaoke)",
             sync_times=sync_times,
             instrumentals=instrumentals,
             formatted_lyrics=formatted_lyrics,
@@ -189,11 +190,11 @@ class CDGGenerator:
         """Compose CDG using KaraokeComposer."""
         kc = KaraokeComposer.from_file(toml_file)
         kc.compose()
-        kc.create_mp4(height=1080, fps=30)
+        # kc.create_mp4(height=1080, fps=30)
 
     def _find_cdg_zip(self, artist: str, title: str) -> str:
         """Find the generated CDG ZIP file."""
-        safe_filename = self._get_safe_filename(artist, title, "Karaoke CDG", "zip")
+        safe_filename = self._get_safe_filename(artist, title, "Karaoke", "zip")
         output_zip = os.path.join(self.output_dir, safe_filename)
 
         self.logger.info(f"Looking for CDG ZIP file in output directory: {output_zip}")
@@ -215,12 +216,12 @@ class CDGGenerator:
 
     def _get_cdg_path(self, artist: str, title: str) -> str:
         """Get the path to the CDG file."""
-        safe_filename = self._get_safe_filename(artist, title, "Karaoke CDG", "cdg")
+        safe_filename = self._get_safe_filename(artist, title, "Karaoke", "cdg")
         return os.path.join(self.output_dir, safe_filename)
 
     def _get_mp3_path(self, artist: str, title: str) -> str:
         """Get the path to the MP3 file."""
-        safe_filename = self._get_safe_filename(artist, title, "Karaoke CDG", "mp3")
+        safe_filename = self._get_safe_filename(artist, title, "Karaoke", "mp3")
         return os.path.join(self.output_dir, safe_filename)
 
     def _verify_output_files(self, cdg_file: str, mp3_file: str) -> None:
@@ -338,20 +339,20 @@ class CDGGenerator:
         formatted_lyrics = []
 
         for i, lyric in enumerate(lyrics_data):
-            # self.logger.debug(f"Processing lyric {i}: timestamp {lyric['timestamp']}, text '{lyric['text']}'")
+            self.logger.debug(f"Processing lyric {i}: timestamp {lyric['timestamp']}, text '{lyric['text']}'")
 
             if i == 0 or lyric["timestamp"] - lyrics_data[i - 1]["timestamp"] >= cdg_styles["lead_in_threshold"]:
                 lead_in_start = lyric["timestamp"] - cdg_styles["lead_in_total"]
-                # self.logger.debug(f"Adding lead-in before lyric {i} at timestamp {lead_in_start}")
+                self.logger.debug(f"Adding lead-in before lyric {i} at timestamp {lead_in_start}")
                 for j, symbol in enumerate(cdg_styles["lead_in_symbols"]):
                     sync_time = lead_in_start + j * cdg_styles["lead_in_duration"]
                     sync_times.append(sync_time)
                     formatted_lyrics.append(symbol)
-                    # self.logger.debug(f"  Added lead-in symbol {j+1}: '{symbol}' at {sync_time}")
+                    self.logger.debug(f"  Added lead-in symbol {j+1}: '{symbol}' at {sync_time}")
 
             sync_times.append(lyric["timestamp"])
             formatted_lyrics.append(lyric["text"])
-            # self.logger.debug(f"Added lyric: '{lyric['text']}' at {lyric['timestamp']}")
+            self.logger.debug(f"Added lyric: '{lyric['text']}' at {lyric['timestamp']}")
 
         formatted_text = self.format_lyrics(
             formatted_lyrics,
@@ -375,7 +376,7 @@ class CDGGenerator:
         cdg_styles: dict,
     ) -> dict:
         """Create TOML data structure."""
-        safe_output_name = self._get_safe_filename(artist, title, "Karaoke CDG")
+        safe_output_name = self._get_safe_filename(artist, title, "Karaoke")
         return {
             "title": title,
             "artist": artist,
@@ -473,24 +474,29 @@ class CDGGenerator:
         page_number = 1
 
         for i, text in enumerate(lyrics_data):
-            # self.logger.debug(f"Processing text {i}: '{text}' (sync time: {sync_times[i]})")
+            self.logger.debug(f"format_lyrics: Processing text {i}: '{text}' (sync time: {sync_times[i]})")
 
             if text.startswith("/"):
                 if current_line:
-                    wrapped_lines = get_wrapped_text(current_line.strip(), font, self.cdg_visible_width).split("\n")
+                    wrapped_lines = get_wrapped_text(current_line.strip(), font, CDG_VISIBLE_WIDTH).split("\n")
                     for wrapped_line in wrapped_lines:
                         formatted_lyrics.append(wrapped_line)
                         lines_on_page += 1
-                        # self.logger.debug(f"Added wrapped line: '{wrapped_line}'. Lines on page: {lines_on_page}")
+                        self.logger.debug(f"format_lyrics: Added wrapped line: '{wrapped_line}'. Lines on page: {lines_on_page}")
+                        # Add empty line after punctuation immediately
+                        if wrapped_line.endswith(("!", "?", ".")) and not wrapped_line == "~":
+                            formatted_lyrics.append("~")
+                            lines_on_page += 1
+                            self.logger.debug(f"format_lyrics: Added empty line after punctuation. Lines on page now: {lines_on_page}")
                         if lines_on_page == 4:
                             lines_on_page = 0
                             page_number += 1
-                            # self.logger.debug(f"Page full. New page number: {page_number}")
+                            self.logger.debug(f"format_lyrics: Page full. New page number: {page_number}")
                     current_line = ""
                 text = text[1:]
 
             current_line += text + " "
-            # self.logger.debug(f"Current line: '{current_line}'")
+            self.logger.debug(f"format_lyrics: Current line: '{current_line}'")
 
             is_last_before_instrumental = any(
                 inst["sync"] > sync_times[i] and (i == len(sync_times) - 1 or sync_times[i + 1] > inst["sync"]) for inst in instrumentals
@@ -498,33 +504,103 @@ class CDGGenerator:
 
             if is_last_before_instrumental or i == len(lyrics_data) - 1:
                 if current_line:
-                    wrapped_lines = get_wrapped_text(current_line.strip(), font, self.cdg_visible_width).split("\n")
+                    wrapped_lines = get_wrapped_text(current_line.strip(), font, CDG_VISIBLE_WIDTH).split("\n")
                     for wrapped_line in wrapped_lines:
                         formatted_lyrics.append(wrapped_line)
                         lines_on_page += 1
-                        # self.logger.debug(f"Added wrapped line at end of section: '{wrapped_line}'. Lines on page: {lines_on_page}")
+                        self.logger.debug(
+                            f"format_lyrics: Added wrapped line at end of section: '{wrapped_line}'. Lines on page: {lines_on_page}"
+                        )
                         if lines_on_page == 4:
                             lines_on_page = 0
                             page_number += 1
-                            # self.logger.debug(f"Page full. New page number: {page_number}")
+                            self.logger.debug(f"format_lyrics: Page full. New page number: {page_number}")
                     current_line = ""
 
                 if is_last_before_instrumental:
-                    blank_lines_needed = 4 - lines_on_page
-                    if blank_lines_needed < 4:
-                        formatted_lyrics.extend(["~"] * blank_lines_needed)
-                        # self.logger.debug(f"Added {blank_lines_needed} empty lines before instrumental. Lines on page was {lines_on_page}")
+                    self.logger.debug(f"format_lyrics: is_last_before_instrumental: True lines_on_page: {lines_on_page}")
+                    # Calculate remaining lines needed to reach next full page
+                    remaining_lines = 4 - (lines_on_page % 4) if lines_on_page % 4 != 0 else 0
+                    if remaining_lines > 0:
+                        formatted_lyrics.extend(["~"] * remaining_lines)
+                        self.logger.debug(f"format_lyrics: Added {remaining_lines} empty lines to complete current page")
+
+                    # Reset the counter and increment page
                     lines_on_page = 0
                     page_number += 1
-                    # self.logger.debug(f"Reset lines_on_page to 0. New page number: {page_number}")
-
-        final_lyrics = []
-        for line in formatted_lyrics:
-            final_lyrics.append(line)
-            if line.endswith(("!", "?", ".")) and not line == "~":
-                final_lyrics.append("~")
-                # self.logger.debug("Added empty line after punctuation")
-
-        result = "\n".join(final_lyrics)
-        # self.logger.debug(f"Final formatted lyrics:\n{result}")
-        return result
+                    self.logger.debug(f"format_lyrics: Reset lines_on_page to 0. New page number: {page_number}")
+
+        return "\n".join(formatted_lyrics)
+
+    def generate_cdg_from_lrc(
+        self,
+        lrc_file: str,
+        audio_file: str,
+        title: str,
+        artist: str,
+        cdg_styles: dict,
+    ) -> Tuple[str, str, str]:
+        """Generate a CDG file from an LRC file and audio file.
+
+        Args:
+            lrc_file: Path to the LRC file
+            audio_file: Path to the audio file
+            title: Title of the song
+            artist: Artist name
+            cdg_styles: Dictionary containing CDG style parameters
+
+        Returns:
+            Tuple containing paths to (cdg_file, mp3_file, zip_file)
+        """
+        self._validate_and_setup_font(cdg_styles)
+
+        # Parse LRC file and convert to lyrics_data format
+        lyrics_data = self._parse_lrc(lrc_file)
+
+        toml_file = self._create_toml_file(
+            audio_file=audio_file,
+            title=title,
+            artist=artist,
+            lyrics_data=lyrics_data,
+            cdg_styles=cdg_styles,
+        )
+
+        try:
+            self._compose_cdg(toml_file)
+            output_zip = self._find_cdg_zip(artist, title)
+            self._extract_cdg_files(output_zip)
+
+            cdg_file = self._get_cdg_path(artist, title)
+            mp3_file = self._get_mp3_path(artist, title)
+
+            self._verify_output_files(cdg_file, mp3_file)
+
+            self.logger.info("CDG file generated successfully")
+            return cdg_file, mp3_file, output_zip
+
+        except Exception as e:
+            self.logger.error(f"Error composing CDG: {e}")
+            raise
+
+    def _parse_lrc(self, lrc_file: str) -> List[dict]:
+        """Parse LRC file and extract timestamps and lyrics."""
+        with open(lrc_file, "r", encoding="utf-8") as f:
+            content = f.read()
+
+        # Extract timestamps and lyrics
+        pattern = r"\[(\d{2}):(\d{2})\.(\d{3})\](\d+:)?(/?.*)"
+        matches = re.findall(pattern, content)
+
+        if not matches:
+            raise ValueError(f"No valid lyrics found in the LRC file: {lrc_file}")
+
+        lyrics = []
+        for match in matches:
+            minutes, seconds, milliseconds = map(int, match[:3])
+            timestamp = (minutes * 60 + seconds) * 100 + int(milliseconds / 10)  # Convert to centiseconds
+            text = match[4].strip().upper()
+            if text:  # Only add non-empty lyrics
+                lyrics.append({"timestamp": timestamp, "text": text})
+
+        self.logger.info(f"Found {len(lyrics)} lyric lines")
+        return lyrics

lyrics_transcriber/output/cdgmaker/composer.py

@@ -1097,27 +1097,16 @@ class KaraokeComposer:
             else:
                 logger.debug("this instrumental did not wait for the previous " "line to finish")
 
-            logger.debug("purging all highlight/draw queues")
+            logger.debug("_compose_lyric: Purging all highlight/draw queues")
             for st in lyric_states:
-                # If instrumental has waited for this syllable to end
                 if instrumental.wait:
-                    # 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.highlight_queue:
+                        logger.warning("_compose_lyric: Unexpected items in highlight queue when instrumental waited")
                     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:
-                            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),
-                            )
-                        )
+                            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")
                         self.writer.queue_packets(st.draw_queue)
 
                 # Purge highlight/draw queues

lyrics_transcriber/output/generator.py

@@ -78,6 +78,7 @@ class OutputGenerator:
                 font_size=self.font_size,
                 line_height=self.line_height,
                 styles=self.config.styles,
+                subtitle_offset_ms=self.config.subtitle_offset_ms,
                 logger=self.logger,
             )
 
@@ -161,12 +162,12 @@ class OutputGenerator:
             "720p": (1280, 720),
             "360p": (640, 360),
         }
-        
+
         if resolution not in resolution_map:
             raise ValueError("Invalid video_resolution value. Must be one of: 4k, 1080p, 720p, 360p")
-            
+
         resolution_dims = resolution_map[resolution]
-        
+
         # Default font sizes for each resolution
         default_font_sizes = {
             "4k": 250,
@@ -174,13 +175,13 @@ class OutputGenerator:
             "720p": 100,
             "360p": 40,
         }
-        
+
         # Get font size from styles if available, otherwise use default
         font_size = self.config.styles.get("karaoke", {}).get("font_size", default_font_sizes[resolution])
-        
+
         # Line height matches font size for all except 360p
         line_height = 50 if resolution == "360p" else font_size
-        
+
         return resolution_dims, font_size, line_height
 
     def write_corrections_data(self, correction_result: CorrectionResult, output_prefix: str) -> str:

lyrics_transcriber/output/lrc_to_cdg.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+
+import logging
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from lyrics_transcriber.output.cdg import CDGGenerator
+
+logger = logging.getLogger(__name__)
+
+
+def cli_main():
+    """Command-line interface entry point for the lrc2cdg tool."""
+    logging.basicConfig(level=logging.DEBUG, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+
+    parser = argparse.ArgumentParser(description="Convert LRC file to CDG")
+    parser.add_argument("lrc_file", help="Path to the LRC file")
+    parser.add_argument("audio_file", help="Path to the audio file")
+    parser.add_argument("--title", required=True, help="Title of the song")
+    parser.add_argument("--artist", required=True, help="Artist of the song")
+    parser.add_argument("--style_params_json", required=True, help="Path to JSON file containing CDG style configuration")
+
+    args = parser.parse_args()
+
+    try:
+        with open(args.style_params_json, "r") as f:
+            style_params = json.loads(f.read())
+            cdg_styles = style_params["cdg"]
+    except FileNotFoundError:
+        logger.error(f"Style configuration file not found: {args.style_params_json}")
+        sys.exit(1)
+    except json.JSONDecodeError as e:
+        logger.error(f"Invalid JSON in style configuration file: {e}")
+        sys.exit(1)
+
+    try:
+        output_dir = str(Path(args.lrc_file).parent)
+        generator = CDGGenerator(output_dir=output_dir, logger=logger)
+
+        cdg_file, mp3_file, zip_file = generator.generate_cdg_from_lrc(
+            lrc_file=args.lrc_file,
+            audio_file=args.audio_file,
+            title=args.title,
+            artist=args.artist,
+            cdg_styles=cdg_styles,
+        )
+
+        logger.info(f"Generated files:\nCDG: {cdg_file}\nMP3: {mp3_file}\nZIP: {zip_file}")
+
+    except ValueError as e:
+        logger.error(f"Invalid style configuration: {e}")
+        sys.exit(1)
+    except Exception as e:
+        logger.error(f"Error generating CDG: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    cli_main()

lyrics_transcriber/output/subtitles.py

@@ -5,7 +5,7 @@ import subprocess
 import json
 
 from lyrics_transcriber.output.ass.section_screen import SectionScreen
-from lyrics_transcriber.types import LyricsSegment
+from lyrics_transcriber.types import LyricsSegment, Word
 from lyrics_transcriber.output.ass import LyricsScreen, LyricsLine
 from lyrics_transcriber.output.ass.ass import ASS
 from lyrics_transcriber.output.ass.style import Style
@@ -25,6 +25,7 @@ class SubtitlesGenerator:
         font_size: int,
         line_height: int,
         styles: dict,
+        subtitle_offset_ms: int = 0,
         logger: Optional[logging.Logger] = None,
     ):
         """Initialize SubtitleGenerator.
@@ -34,12 +35,15 @@ class SubtitlesGenerator:
             video_resolution: Tuple of (width, height) for video resolution
             font_size: Font size for subtitles
             line_height: Line height for subtitle positioning
+            styles: Dictionary of style configurations
+            subtitle_offset_ms: Offset for subtitle timing in milliseconds
             logger: Optional logger instance
         """
         self.output_dir = output_dir
         self.video_resolution = video_resolution
         self.font_size = font_size
         self.styles = styles
+        self.subtitle_offset_ms = subtitle_offset_ms
         self.config = ScreenConfig(line_height=line_height, video_width=video_resolution[0], video_height=video_resolution[1])
         self.logger = logger or logging.getLogger(__name__)
 
@@ -91,6 +95,30 @@ class SubtitlesGenerator:
         """Create screens from segments with detailed logging."""
         self.logger.debug("Creating screens from segments")
 
+        # Apply timing offset to segments if needed
+        if self.subtitle_offset_ms != 0:
+            self.logger.info(f"Subtitle offset: {self.subtitle_offset_ms}ms")
+
+            offset_seconds = self.subtitle_offset_ms / 1000.0
+            segments = [
+                LyricsSegment(
+                    text=seg.text,
+                    words=[
+                        Word(
+                            text=word.text,
+                            start_time=max(0, word.start_time + offset_seconds),
+                            end_time=word.end_time + offset_seconds,
+                            confidence=word.confidence,
+                        )
+                        for word in seg.words
+                    ],
+                    start_time=max(0, seg.start_time + offset_seconds),
+                    end_time=seg.end_time + offset_seconds,
+                )
+                for seg in segments
+            ]
+            self.logger.info(f"Applied {self.subtitle_offset_ms}ms offset to segment timings")
+
         # Create section screens and get instrumental boundaries
         section_screens = self._create_section_screens(segments, song_duration)
         instrumental_times = self._get_instrumental_times(section_screens)

{lyrics_transcriber-0.39.0.dist-info → lyrics_transcriber-0.41.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: lyrics-transcriber
-Version: 0.39.0
+Version: 0.41.0
 Summary: Automatically create synchronised lyrics files in ASS and MidiCo LRC formats with word-level timestamps, using Whisper and lyrics from Genius and Spotify
 License: MIT
 Author: Andrew Beveridge

{lyrics_transcriber-0.39.0.dist-info → lyrics_transcriber-0.41.0.dist-info}/RECORD

@@ -1,8 +1,8 @@
 lyrics_transcriber/__init__.py,sha256=JpdjDK1MH_Be2XiSQWnb4i5Bbil1uPMA_KcuDZ3cyUI,240
 lyrics_transcriber/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lyrics_transcriber/cli/cli_main.py,sha256=I4YXULnIA_H9ESmXdEspOcidY2n24KdUkOTDZb7r680,9967
+lyrics_transcriber/cli/cli_main.py,sha256=MDgjIlgmKDfv3z6nK_j7TJKtcijfuLrB06hDMXXaZQY,10211
 lyrics_transcriber/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lyrics_transcriber/core/config.py,sha256=yR0hG4BFEgyzd1hdb27t5B2RI7eYdAvQ9w9RUnoIpuY,1197
+lyrics_transcriber/core/config.py,sha256=euwOOtuNbXy4-a1xs8QKdjcf5jXZQle0zf6X1Wthurw,1229
 lyrics_transcriber/core/controller.py,sha256=YKz-_nV-h2grXfQrNafDiK35uNitiLVA-z9BmMOkq-w,19540
 lyrics_transcriber/correction/anchor_sequence.py,sha256=YpKyY24Va5i4JgzP9ssqlOIkaYu060KaldiehbfgTdk,22200
 lyrics_transcriber/correction/corrector.py,sha256=r6AmdVl_JbOIbNgNk5aDHy-5vdw5-cayspUGht_844A,13494
@@ -81,10 +81,10 @@ lyrics_transcriber/output/ass/lyrics_screen.py,sha256=gRzUsDMLEtZZPuv77xk7M0FzCp
 lyrics_transcriber/output/ass/section_detector.py,sha256=TsSf4E0fleC-Tzd5KK6q4m-wjGiu6TvGDtHdR6sUqvc,3922
 lyrics_transcriber/output/ass/section_screen.py,sha256=QeUaIeDXs_Es33W5aqyVSaZzMwUx-b60vbAww3aQfls,4185
 lyrics_transcriber/output/ass/style.py,sha256=ty3IGorlOZ_Q-TxeA02hNb5Pb0mA755dOb8bqKr1k7U,6880
-lyrics_transcriber/output/cdg.py,sha256=gWyFUAsG9xNTENWQdPTZDIWrr8jNHZgH2U4bA3iN9dM,21950
+lyrics_transcriber/output/cdg.py,sha256=Kx8_luGUQbrAlbzGKKNQTPTSGkN48oqOBIH6CYzNlMI,24894
 lyrics_transcriber/output/cdgmaker/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lyrics_transcriber/output/cdgmaker/cdg.py,sha256=nBqkw0JOois-NI27CkwHblLuBaoL-sHyJb2SntX7m8s,6733
-lyrics_transcriber/output/cdgmaker/composer.py,sha256=l04-wnUZMo5NUhgd5Ji-QqYwy-j3esqZCT-Qohll7bk,91250
+lyrics_transcriber/output/cdgmaker/composer.py,sha256=gWziaLnCo8iV7Igp7yFn5oFUVctRDtkLlcfx6O-f98Y,90780
 lyrics_transcriber/output/cdgmaker/config.py,sha256=dOsOaPg9XawR3sWdTBoQiYn7urQWafV2KzedhI6BHYU,4043
 lyrics_transcriber/output/cdgmaker/images/instrumental.png,sha256=EKUcJJGj95ceNqw7M-O9ltX4HZIaCaSKjJucKVDTSb8,14834
 lyrics_transcriber/output/cdgmaker/images/intro.png,sha256=XeN6i8aKaQObfRwcgHT8ajQAJIDVjXEd7C5tu7DtriU,17603
@@ -111,11 +111,12 @@ lyrics_transcriber/output/fonts/Zurich_Cn_BT_Bold.ttf,sha256=WNG5LOQ-uGUF_WWT5aQ
 lyrics_transcriber/output/fonts/arial.ttf,sha256=NcDzVZ2NtWnjbDEJW4pg1EFkPZX1kTneQOI_ragZuDM,275572
 lyrics_transcriber/output/fonts/georgia.ttf,sha256=fQuyDGMrtZ6BoIhfVzvSFz9x9zIE3pBY_raM4DIicHI,142964
 lyrics_transcriber/output/fonts/verdana.ttf,sha256=lu0UlJyktzks_yNbnEHVXBJTgqu-DA08K53WaJfK4Ms,139640
-lyrics_transcriber/output/generator.py,sha256=TzgYjppsGKev5Fg-q7JtjTAiTkuKOBE8Ssaf6ZoAwQA,8294
+lyrics_transcriber/output/generator.py,sha256=FdXoyxp62jmkvOCaS1ixnRI9ek08ts1QeA8qxss_REY,8309
+lyrics_transcriber/output/lrc_to_cdg.py,sha256=2pi5tvreD_ADAR4RF5yVwj7OJ4Pf5Zo_EJ7rt4iH3k0,2063
 lyrics_transcriber/output/lyrics_file.py,sha256=_KQyQjCOMIwQdQ0115uEAUIjQWTRmShkSfQuINPKxaw,3741
 lyrics_transcriber/output/plain_text.py,sha256=3mYKq0BLYz1rGBD6ROjG2dn6BPuzbn5dxIQbWZVi4ao,3689
 lyrics_transcriber/output/segment_resizer.py,sha256=b553FCdcjYAl9T1IA5K6ya0pcn1-irD5spmxSc26wnI,17143
-lyrics_transcriber/output/subtitles.py,sha256=BQy7N_2zdBBWEiHL0NWFz3ZgAerWqQvTLALgxxK3Etk,16920
+lyrics_transcriber/output/subtitles.py,sha256=jrvg0Tn8W-lRmlGNwnrMMzJB6xdEfI0ZoNLer5zWKJk,18170
 lyrics_transcriber/output/video.py,sha256=ghb53OF6BNZy1VudKQvogPBA27eXfN8FHX9C72aGsm0,9095
 lyrics_transcriber/review/__init__.py,sha256=_3Eqw-uXZhOZwo6_sHZLhP9vxAVkLF9EBXduUvPdLjQ,57
 lyrics_transcriber/review/server.py,sha256=5Cfy3aS-h2c6bZU0wkrDZ9ATIkjndNWbxVJjQ89PFJE,5981
@@ -125,8 +126,8 @@ lyrics_transcriber/transcribers/audioshake.py,sha256=QzKGimVa6BovlvYFj35CbGpaGeP
 lyrics_transcriber/transcribers/base_transcriber.py,sha256=yPzUWPTCGmzE97H5Rz6g61e-qEGL77ZzUoiBOmswhts,5973
 lyrics_transcriber/transcribers/whisper.py,sha256=P0kas2_oX16MO1-Qy7U5gl5KQN-RuUIJZz7LsEFLUiE,12906
 lyrics_transcriber/types.py,sha256=xGf3hkTRcGZTTAjMVIev2i2DOU6co0QGpW8NxvaBQAA,16759
-lyrics_transcriber-0.39.0.dist-info/LICENSE,sha256=BiPihPDxhxIPEx6yAxVfAljD5Bhm_XG2teCbPEj_m0Y,1069
-lyrics_transcriber-0.39.0.dist-info/METADATA,sha256=9YYI3pAEcVVzJkjENCSchgEnp_M5MOUFrSjRhfpwVRk,5891
-lyrics_transcriber-0.39.0.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-lyrics_transcriber-0.39.0.dist-info/entry_points.txt,sha256=SoGPp-kikJ9tPNF8vnjcnCyBrNWCW7AbaoZs1dIbXCo,162
-lyrics_transcriber-0.39.0.dist-info/RECORD,,
+lyrics_transcriber-0.41.0.dist-info/LICENSE,sha256=BiPihPDxhxIPEx6yAxVfAljD5Bhm_XG2teCbPEj_m0Y,1069
+lyrics_transcriber-0.41.0.dist-info/METADATA,sha256=civcml2WAL40CDoeC8zOI76uVoIGkGXe4oyvwWSEZGc,5891
+lyrics_transcriber-0.41.0.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+lyrics_transcriber-0.41.0.dist-info/entry_points.txt,sha256=kcp-bSFkCACAEA0t166Kek0HpaJUXRo5SlF5tVrqNBU,216
+lyrics_transcriber-0.41.0.dist-info/RECORD,,

{lyrics_transcriber-0.39.0.dist-info → lyrics_transcriber-0.41.0.dist-info}/entry_points.txt

@@ -1,5 +1,6 @@
 [console_scripts]
 cdgmaker=lyrics_transcriber.output.cdgmaker.composer:main
+lrc2cdg=lyrics_transcriber.output.lrc_to_cdg:cli_main
 lyrics-transcriber=lyrics_transcriber.cli.cli_main:main
 test-cov=tests.conftest:main