lyrics-transcriber 0.30.0__py3-none-any.whl → 0.32.1__py3-none-any.whl

lyrics_transcriber/output/ass/lyrics_screen.py

@@ -0,0 +1,252 @@
+from dataclasses import dataclass
+from typing import List, Optional, Tuple
+import logging
+from datetime import timedelta
+
+from lyrics_transcriber.output.ass.style import Style
+from lyrics_transcriber.output.ass.event import Event
+from lyrics_transcriber.output.ass.lyrics_line import LyricsLine
+from lyrics_transcriber.output.ass.config import ScreenConfig, LineTimingInfo, LineState
+
+
+class PositionStrategy:
+    """Handles calculation of vertical positions for lines."""
+
+    def __init__(self, video_size: Tuple[int, int], config: ScreenConfig):
+        self.video_size = video_size
+        self.config = config
+
+    def calculate_line_positions(self) -> List[int]:
+        """Calculate vertical positions for all possible lines."""
+        return PositionCalculator.calculate_line_positions(self.config)
+
+
+class PositionCalculator:
+    """Shared position calculation logic."""
+
+    @staticmethod
+    def calculate_first_line_position(config: ScreenConfig) -> int:
+        """Calculate vertical position of first line."""
+        total_height = config.max_visible_lines * config.line_height
+        return config.top_padding + (config.video_height - total_height - config.top_padding) // 4
+
+    @staticmethod
+    def calculate_line_positions(config: ScreenConfig) -> List[int]:
+        """Calculate vertical positions for all possible lines."""
+        first_pos = PositionCalculator.calculate_first_line_position(config)
+        return [first_pos + (i * config.line_height) for i in range(config.max_visible_lines)]
+
+    @staticmethod
+    def position_to_line_index(y_position: int, config: ScreenConfig) -> int:
+        """Convert y-position to 0-based line index."""
+        first_pos = PositionCalculator.calculate_first_line_position(config)
+        return (y_position - first_pos) // config.line_height
+
+    @staticmethod
+    def line_index_to_position(index: int, config: ScreenConfig) -> int:
+        """Convert 0-based line index to y-position."""
+        first_pos = PositionCalculator.calculate_first_line_position(config)
+        return first_pos + (index * config.line_height)
+
+
+class TimingStrategy:
+    """Handles calculation of line timings during screen transitions."""
+
+    def __init__(self, config: ScreenConfig, logger: Optional[logging.Logger] = None):
+        self.config = config
+        self.logger = logger or logging.getLogger(__name__)
+
+    def calculate_line_timings(
+        self,
+        current_lines: List[LyricsLine],
+        previous_active_lines: Optional[List[Tuple[float, int, str]]] = None,
+        previous_instrumental_end: Optional[float] = None,
+    ) -> List[LineTimingInfo]:
+        """Calculate timing information for each line in the screen."""
+        previous_active_lines = previous_active_lines or []
+
+        # If no previous lines, determine appropriate start time
+        if not previous_active_lines:
+            if previous_instrumental_end is not None:
+                # For post-instrumental, start right after the instrumental
+                return self._calculate_simultaneous_timings(current_lines, fade_in_start=previous_instrumental_end)
+            else:
+                # For first screen, start at 0
+                return self._calculate_simultaneous_timings(current_lines, fade_in_start=0.0)
+
+        # Create a map of position -> clear time from previous lines
+        position_clear_times = {}
+        for end_time, y_position, text in previous_active_lines:
+            # Clear time is now just when the fade out ends
+            clear_time = end_time + (self.config.fade_out_ms / 1000)
+            position_clear_times[y_position] = clear_time
+
+            # Add buffer time for the position above the active line
+            # Use the end time without fade for the line above to give more reading time
+            line_index = PositionCalculator.position_to_line_index(y_position, self.config)
+            # fmt: off
+            if line_index > 0:  # If not the top line
+                position_above = PositionCalculator.line_index_to_position(line_index - 1, self.config)
+                position_clear_times[position_above] = max(
+                    position_clear_times.get(position_above, 0),
+                    end_time  # Use end time without fade for position above
+                )
+            # fmt: on
+
+            self.logger.debug(f"    Position {line_index + 1} occupied by '{text}' until {clear_time:.2f}s")
+
+        # Calculate timings for each line
+        timings = []
+        positions = PositionCalculator.calculate_line_positions(self.config)
+        for i, (line, position) in enumerate(zip(current_lines, positions)):
+            # Fade in as soon as the position is available
+            fade_in_time = position_clear_times.get(position, 0)
+
+            # Calculate remaining timing information
+            end_time = line.segment.end_time + self.config.post_roll_time
+            fade_out_time = end_time + (self.config.fade_out_ms / 1000)
+            # Clear time is now just the fade out time
+            clear_time = fade_out_time
+
+            # fmt: off
+            timing = LineTimingInfo(
+                fade_in_time=fade_in_time,
+                end_time=end_time,
+                fade_out_time=fade_out_time,
+                clear_time=clear_time
+            )
+            # fmt: on
+            timings.append(timing)
+
+            line_index = PositionCalculator.position_to_line_index(position, self.config)
+            self.logger.debug(
+                f"    Line {line_index + 1}: '{line.segment.text}' "
+                f"fades in at {fade_in_time:.2f}s "
+                f"(position available at {position_clear_times.get(position, 0):.2f}s)"
+            )
+
+        return timings
+
+    def _calculate_simultaneous_timings(self, lines: List[LyricsLine], fade_in_start: float) -> List[LineTimingInfo]:
+        """Calculate timings for screens where all lines appear together."""
+        return [
+            LineTimingInfo(
+                fade_in_time=fade_in_start,
+                end_time=line.segment.end_time + self.config.post_roll_time,
+                fade_out_time=line.segment.end_time + self.config.post_roll_time + (self.config.fade_out_ms / 1000),
+                clear_time=line.segment.end_time + self.config.post_roll_time + (self.config.fade_out_ms / 1000),
+            )
+            for line in lines
+        ]
+
+
+@dataclass
+class LyricsScreen:
+    """Represents a screen of lyrics (multiple lines)."""
+
+    video_size: Tuple[int, int]
+    line_height: int
+    lines: List[LyricsLine] = None  # Make lines optional
+    logger: Optional[logging.Logger] = None
+    post_instrumental: bool = False
+    config: Optional[ScreenConfig] = None
+
+    def __post_init__(self):
+        if self.logger is None:
+            self.logger = logging.getLogger(__name__)
+        if self.config is None:
+            self.config = ScreenConfig(line_height=self.line_height)
+        else:
+            # Ensure line_height is consistent
+            self.config.line_height = self.line_height
+
+        # Initialize empty lines list if None
+        if self.lines is None:
+            self.lines = []
+
+        # Update video height in config
+        self.config.video_width = self.video_size[0]
+        self.config.video_height = self.video_size[1]
+
+        # Initialize strategies
+        self.position_strategy = PositionStrategy(self.video_size, self.config)
+        self.timing_strategy = TimingStrategy(self.config, self.logger)
+
+    def as_ass_events(
+        self,
+        style: Style,
+        previous_active_lines: Optional[List[Tuple[float, int, str]]] = None,
+        previous_instrumental_end: Optional[float] = None,
+    ) -> Tuple[List[Event], List[Tuple[float, int, str]]]:
+        """Convert screen to ASS events. Returns (events, active_lines)."""
+        events = []
+        active_lines = []
+        previous_active_lines = previous_active_lines or []
+
+        # Find the latest end time from previous lines
+        previous_end_time = None
+        if previous_active_lines:
+            previous_end_time = max(end_time for end_time, _, _ in previous_active_lines)
+
+        # Log active lines from previous screen
+        if previous_active_lines:
+            self.logger.debug("  Active lines from previous screen:")
+            for end, pos, text in previous_active_lines:
+                # Convert y-position back to line index (0-based)
+                line_index = PositionCalculator.position_to_line_index(pos, self.config)
+                clear_time = end + (self.config.fade_out_ms / 1000)
+                self.logger.debug(
+                    f"    Line {line_index + 1}: '{text}' "
+                    f"(ends {end:.2f}s, fade out {end + (self.config.fade_out_ms / 1000):.2f}s, clear {clear_time:.2f}s)"
+                )
+
+        # Calculate positions and timings
+        positions = self.position_strategy.calculate_line_positions()
+        # fmt: off
+        timings = self.timing_strategy.calculate_line_timings(
+            current_lines=self.lines,
+            previous_active_lines=previous_active_lines,
+            previous_instrumental_end=previous_instrumental_end
+        )
+        # fmt: on
+
+        # Create line states and events
+        for i, (line, timing) in enumerate(zip(self.lines, timings)):
+            y_position = positions[i]
+
+            # Create line state
+            line_state = LineState(text=line.segment.text, timing=timing, y_position=y_position)
+
+            # Create ASS events with previous end time info
+            # fmt: off
+            line_events = line.create_ass_events(
+                state=line_state, 
+                style=style, 
+                config=self.config,
+                previous_end_time=previous_end_time
+            )
+            # fmt: on
+            events.extend(line_events)
+
+            # Track this line's end time for the next screen
+            previous_end_time = timing.end_time
+            active_lines.append((timing.end_time, y_position, line.segment.text))
+
+            # Log line placement with index
+            self.logger.debug(f"    Line {i + 1}: '{line.segment.text}'")
+
+        return events, active_lines
+
+    @property
+    def start_ts(self) -> timedelta:
+        """Get screen start timestamp."""
+        return timedelta(seconds=min(line.segment.start_time for line in self.lines))
+
+    @property
+    def end_ts(self) -> timedelta:
+        """Get screen end timestamp."""
+        latest_ts = max(line.segment.end_time for line in self.lines)
+        return timedelta(seconds=latest_ts + self.config.post_roll_time)
+
+    def __str__(self):
+        return "\n".join([f"{self.start_ts} - {self.end_ts}:", *[f"\t{line}" for line in self.lines]])

lyrics_transcriber/output/ass/section_detector.py

@@ -0,0 +1,89 @@
+from typing import List, Optional, Tuple
+import logging
+
+from lyrics_transcriber.types import LyricsSegment
+from lyrics_transcriber.output.ass import LyricsScreen, SectionScreen
+
+
+class SectionDetector:
+    """Detects and creates section screens between lyrics."""
+
+    def __init__(self, gap_threshold: float = 10.0, logger: Optional[logging.Logger] = None):
+        self.gap_threshold = gap_threshold
+        self.logger = logger or logging.getLogger(__name__)
+        self.intro_padding = 0.0  # No padding for intro
+        self.outro_padding = 5.0  # End 5s before song ends
+        self.instrumental_start_padding = 1.0  # Start 1s after previous segment
+        self.instrumental_end_padding = 5.0  # End 5s before next segment
+
+    def process_segments(
+        self, segments: List[LyricsSegment], video_size: Tuple[int, int], line_height: int, song_duration: float
+    ) -> List[LyricsScreen]:
+        """Process segments and insert section screens where appropriate.
+
+        Args:
+            segments: List of lyric segments
+            video_size: Tuple of (width, height) for video resolution
+            line_height: Height of each line in pixels
+            song_duration: Total duration of the song in seconds
+        """
+        if not segments:
+            return []
+
+        screens: List[LyricsScreen] = []
+
+        # Check for intro
+        if segments[0].start_time >= self.gap_threshold:
+            self.logger.debug(f"Detected intro section: 0.0 - {segments[0].start_time:.2f}s")
+            screens.append(
+                SectionScreen(
+                    section_type="INTRO",
+                    start_time=0.0,
+                    end_time=segments[0].start_time - self.intro_padding,
+                    video_size=video_size,
+                    line_height=line_height,
+                    logger=self.logger,
+                )
+            )
+
+        # Check for instrumental sections between segments
+        for i in range(len(segments) - 1):
+            gap = segments[i + 1].start_time - segments[i].end_time
+            if gap >= self.gap_threshold:
+                instrumental_start = segments[i].end_time + self.instrumental_start_padding
+                instrumental_end = segments[i + 1].start_time - self.instrumental_end_padding
+
+                # Only create section if there's meaningful duration after padding
+                if instrumental_end > instrumental_start:
+                    self.logger.debug(f"Detected instrumental section: {instrumental_start:.2f} - {instrumental_end:.2f}s")
+                    screens.append(
+                        SectionScreen(
+                            section_type="INSTRUMENTAL",
+                            start_time=instrumental_start,
+                            end_time=instrumental_end,
+                            video_size=video_size,
+                            line_height=line_height,
+                            logger=self.logger,
+                        )
+                    )
+
+        # Check for outro
+        if segments:  # Only add outro if there are segments
+            last_segment = segments[-1]
+            outro_duration = song_duration - last_segment.end_time
+            if outro_duration >= self.gap_threshold:
+                outro_start = last_segment.end_time + self.instrumental_start_padding
+                outro_end = song_duration - self.outro_padding  # End 5s before song ends
+                self.logger.debug(f"Detected outro section: {outro_start:.2f}s - {outro_end:.2f}s")
+                screens.append(
+                    SectionScreen(
+                        section_type="OUTRO",
+                        start_time=outro_start,
+                        end_time=outro_end,
+                        video_size=video_size,
+                        line_height=line_height,
+                        logger=self.logger,
+                    )
+                )
+
+        return screens

lyrics_transcriber/output/ass/section_screen.py

@@ -0,0 +1,106 @@
+from dataclasses import dataclass
+from typing import List, Optional, Literal, Tuple
+import logging
+from datetime import timedelta
+
+from lyrics_transcriber.output.ass.style import Style
+from lyrics_transcriber.output.ass.event import Event
+from lyrics_transcriber.output.ass.lyrics_screen import ScreenConfig
+
+
+@dataclass
+class SectionScreen:
+    """Special screen for instrumental sections."""
+
+    section_type: Literal["INTRO", "OUTRO", "INSTRUMENTAL"]
+    start_time: float
+    end_time: float
+    video_size: Tuple[int, int]
+    line_height: int
+    logger: Optional[logging.Logger] = None
+    config: Optional[ScreenConfig] = None
+
+    def __post_init__(self):
+        self._initialize_logger_and_config()
+        self._calculate_duration()
+        self._adjust_timing()
+        self._create_text()
+
+    def _initialize_logger_and_config(self):
+        """Initialize logger and config with defaults if not provided."""
+        if self.logger is None:
+            self.logger = logging.getLogger(__name__)
+        if self.config is None:
+            self.config = ScreenConfig(line_height=self.line_height)
+        
+        self.config.video_width = self.video_size[0]
+        self.config.video_height = self.video_size[1]
+
+    def _calculate_duration(self):
+        """Calculate duration before any timing adjustments."""
+        self.original_duration = round(self.end_time - self.start_time)
+
+    def _adjust_timing(self):
+        """Apply timing adjustments based on section type."""
+        if self.section_type == "INTRO":
+            self.start_time = 1.0  # Start after 1 second
+            self.end_time = self.end_time - 5.0  # End 5 seconds before next section
+
+    def _create_text(self):
+        """Create the section text with duration."""
+        self.text = f"♪ {self.section_type} ({self.original_duration} seconds) ♪"
+
+    def _calculate_start_time(self, previous_active_lines: Optional[List[Tuple[float, int, str]]] = None) -> float:
+        """Calculate start time accounting for previous lines."""
+        start_time = self.start_time
+        if previous_active_lines:
+            latest_end = max(end + (self.config.fade_out_ms / 1000) for end, _, _ in previous_active_lines)
+            start_time = max(start_time, latest_end)
+        return start_time
+
+    def _calculate_vertical_position(self) -> int:
+        """Calculate vertical position for centered text."""
+        return (self.video_size[1] - self.line_height) // 2
+
+    def _create_event(self, style: Style, start_time: float) -> Event:
+        """Create an ASS event with proper formatting."""
+        event = Event()
+        event.type = "Dialogue"
+        event.Layer = 0
+        event.Style = style
+        event.Start = start_time
+        event.End = self.end_time
+        event.MarginV = self._calculate_vertical_position()
+
+        # Add karaoke timing for the entire duration
+        duration = int((self.end_time - start_time) * 100)  # Convert to centiseconds
+        event.Text = f"{{\\fad({self.config.fade_in_ms},{self.config.fade_out_ms})}}" f"{{\\an8}}{{\\K{duration}}}{self.text}"
+        return event
+
+    def as_ass_events(
+        self,
+        style: Style,
+        previous_active_lines: Optional[List[Tuple[float, int, str]]] = None,
+        previous_instrumental_end: Optional[float] = None,
+    ) -> Tuple[List[Event], List[Tuple[float, int, str]]]:
+        """Create ASS events for section markers with karaoke highlighting."""
+        self.logger.debug(f"Creating section marker event for {self.section_type}")
+
+        start_time = self._calculate_start_time(previous_active_lines)
+        event = self._create_event(style, start_time)
+
+        self.logger.debug(f"Created section event: {event.Text} ({event.Start}s - {event.End}s)")
+        return [event], []  # No active lines to track for sections
+
+    @property
+    def start_ts(self) -> timedelta:
+        """Get start timestamp."""
+        return timedelta(seconds=self.start_time)
+
+    @property
+    def end_ts(self) -> timedelta:
+        """Get end timestamp."""
+        return timedelta(seconds=self.end_time)
+
+    def __str__(self):
+        return f"{self.section_type} {self.start_ts} - {self.end_ts}"

lyrics_transcriber/output/ass/style.py

@@ -0,0 +1,187 @@
+from lyrics_transcriber.output.ass.formatters import Formatters
+from lyrics_transcriber.output.ass.constants import ALIGN_BOTTOM_CENTER
+
+
+class Style:
+    aliases = {}
+    formatters = None
+    order = [
+        "Name",
+        "Fontname",
+        "Fontpath",
+        "Fontsize",
+        "PrimaryColour",
+        "SecondaryColour",
+        "OutlineColour",
+        "BackColour",
+        "Bold",
+        "Italic",
+        "Underline",
+        "StrikeOut",
+        "ScaleX",
+        "ScaleY",
+        "Spacing",
+        "Angle",
+        "BorderStyle",
+        "Outline",
+        "Shadow",
+        "Alignment",
+        "MarginL",
+        "MarginR",
+        "MarginV",
+        "Encoding",
+    ]
+
+    # Constructor
+    def __init__(self):
+        self.type = None
+        self.fake = False
+
+        self.Name = ""
+        self.Fontname = ""
+        self.Fontpath = ""
+        self.Fontsize = 1.0
+        self.PrimaryColour = (255, 255, 255, 255)
+        self.SecondaryColour = (255, 255, 255, 255)
+        self.OutlineColour = (255, 255, 255, 255)
+        self.BackColour = (255, 255, 255, 255)
+        self.Bold = False
+        self.Italic = False
+        self.Underline = False
+        self.StrikeOut = False
+        self.ScaleX = 100
+        self.ScaleY = 100
+        self.Spacing = 0
+        self.Angle = 0.0
+        self.BorderStyle = 1
+        self.Outline = 0
+        self.Shadow = 0
+        self.Alignment = ALIGN_BOTTOM_CENTER
+        self.MarginL = 0
+        self.MarginR = 0
+        self.MarginV = 0
+        self.Encoding = 0
+
+    def set(self, attribute_name, value, *args):
+        if hasattr(self, attribute_name):
+            if not attribute_name[0].isupper():
+                return
+        elif attribute_name in self.aliases:
+            attribute_name = self.aliases[attribute_name]
+        else:
+            return
+
+        setattr(self, attribute_name, self.formatters[attribute_name][0](value, *args))
+
+    def get(self, attribute_name, *args):
+        if hasattr(self, attribute_name):
+            if not attribute_name[0].isupper():
+                return None
+        elif attribute_name in self.aliases:
+            attribute_name = self.aliases[attribute_name]
+        else:
+            return None
+
+        return self.formatters[attribute_name][1](getattr(self, attribute_name), *args)
+
+    def copy(self, other=None):
+        if other is None:
+            # Creating a new style
+            other = self.__class__()
+            target = other
+            source = self
+        else:
+            # Copying into existing style
+            target = other  # This was the issue - we had target and source swapped
+            source = self
+
+        # Copy all attributes
+        target.type = source.type
+        target.fake = source.fake  # Also need to copy the fake flag
+
+        target.Name = source.Name
+        target.Fontname = source.Fontname
+        target.Fontpath = source.Fontpath
+        target.Fontsize = source.Fontsize
+        target.PrimaryColour = source.PrimaryColour
+        target.SecondaryColour = source.SecondaryColour
+        target.OutlineColour = source.OutlineColour
+        target.BackColour = source.BackColour
+        target.Bold = source.Bold
+        target.Italic = source.Italic
+        target.Underline = source.Underline
+        target.StrikeOut = source.StrikeOut
+        target.ScaleX = source.ScaleX
+        target.ScaleY = source.ScaleY
+        target.Spacing = source.Spacing
+        target.Angle = source.Angle
+        target.BorderStyle = source.BorderStyle
+        target.Outline = source.Outline
+        target.Shadow = source.Shadow
+        target.Alignment = source.Alignment
+        target.MarginL = source.MarginL
+        target.MarginR = source.MarginR
+        target.MarginV = source.MarginV
+        target.Encoding = source.Encoding
+
+        return target
+
+    def equals(self, other, names_can_differ=False):
+        return (
+            self.type == other.type
+            and not self.fake
+            and not other.fake
+            and not other.fake
+            and (names_can_differ or self.Name == other.Name)
+            and self.Fontname == other.Fontname
+            and self.Fontpath == other.Fontpath
+            and self.Fontsize == other.Fontsize
+            and self.PrimaryColour == other.PrimaryColour
+            and self.SecondaryColour == other.SecondaryColour
+            and self.OutlineColour == other.OutlineColour
+            and self.BackColour == other.BackColour
+            and self.Bold == other.Bold
+            and self.Italic == other.Italic
+            and self.Underline == other.Underline
+            and self.StrikeOut == other.StrikeOut
+            and self.ScaleX == other.ScaleX
+            and self.ScaleY == other.ScaleY
+            and self.Spacing == other.Spacing
+            and self.Angle == other.Angle
+            and self.BorderStyle == other.BorderStyle
+            and self.Outline == other.Outline
+            and self.Shadow == other.Shadow
+            and self.Alignment == other.Alignment
+            and self.MarginL == other.MarginL
+            and self.MarginR == other.MarginR
+            and self.MarginV == other.MarginV
+            and self.Encoding == other.Encoding
+        )
+
+
+Style.formatters = {
+    "Name": (Formatters.same, Formatters.same),
+    "Fontname": (Formatters.same, Formatters.same),
+    "Fontpath": (Formatters.same, Formatters.same),
+    "Fontsize": (Formatters.str_to_number, Formatters.number_to_str),
+    "PrimaryColour": (Formatters.str_to_color, Formatters.color_to_str),
+    "SecondaryColour": (Formatters.str_to_color, Formatters.color_to_str),
+    "OutlineColour": (Formatters.str_to_color, Formatters.color_to_str),
+    "BackColour": (Formatters.str_to_color, Formatters.color_to_str),
+    "Bold": (Formatters.str_to_n1bool, Formatters.n1bool_to_str),
+    "Italic": (Formatters.str_to_n1bool, Formatters.n1bool_to_str),
+    "Underline": (Formatters.str_to_n1bool, Formatters.n1bool_to_str),
+    "StrikeOut": (Formatters.str_to_n1bool, Formatters.n1bool_to_str),
+    "ScaleX": (Formatters.str_to_integer, Formatters.integer_to_str),
+    "ScaleY": (Formatters.str_to_integer, Formatters.integer_to_str),
+    "Spacing": (Formatters.str_to_integer, Formatters.integer_to_str),
+    "Angle": (Formatters.str_to_number, Formatters.number_to_str),
+    "BorderStyle": (Formatters.str_to_integer, Formatters.integer_to_str),
+    "Outline": (Formatters.str_to_integer, Formatters.integer_to_str),
+    "Shadow": (Formatters.str_to_integer, Formatters.integer_to_str),
+    "Alignment": (Formatters.str_to_integer, Formatters.integer_to_str),
+    "MarginL": (Formatters.str_to_integer, Formatters.integer_to_str),
+    "MarginR": (Formatters.str_to_integer, Formatters.integer_to_str),
+    "MarginV": (Formatters.str_to_integer, Formatters.integer_to_str),
+    "Encoding": (Formatters.str_to_integer, Formatters.integer_to_str),
+}