karaoke-gen 0.57.0__py3-none-any.whl → 0.71.23__py3-none-any.whl

karaoke_gen/pipeline/stages/render.py

@@ -0,0 +1,165 @@
+"""
+Video rendering pipeline stage.
+
+This stage handles:
+- Rendering karaoke video with synchronized lyrics
+- Using the OutputGenerator from lyrics_transcriber
+- Combining audio, video, and synchronized lyrics
+
+This stage runs after transcription is complete and corrections
+have been applied.
+"""
+import logging
+import os
+from typing import Any, Dict, List, Optional
+
+from karaoke_gen.pipeline.base import PipelineStage, StageResult, StageStatus
+from karaoke_gen.pipeline.context import PipelineContext
+
+
+class RenderStage(PipelineStage):
+    """
+    Video rendering stage.
+    
+    Renders the karaoke video with synchronized lyrics overlay.
+    Uses OutputGenerator from lyrics_transcriber.
+    """
+    
+    def __init__(
+        self,
+        logger: Optional[logging.Logger] = None,
+        render_bounding_boxes: bool = False,
+    ):
+        """
+        Initialize the render stage.
+        
+        Args:
+            logger: Logger instance
+            render_bounding_boxes: If True, render debug bounding boxes
+        """
+        self.logger = logger or logging.getLogger(__name__)
+        self.render_bounding_boxes = render_bounding_boxes
+    
+    @property
+    def name(self) -> str:
+        return "render"
+    
+    @property
+    def required_inputs(self) -> List[str]:
+        # Requires transcription output
+        return ["transcription"]
+    
+    @property
+    def optional_inputs(self) -> List[str]:
+        return ["separation"]
+    
+    @property
+    def output_keys(self) -> List[str]:
+        return [
+            "with_vocals_video_path",  # Path to rendered video with vocals
+            "lrc_path",                 # Path to LRC file
+            "ass_path",                 # Path to ASS subtitle file
+        ]
+    
+    async def execute(self, context: PipelineContext) -> StageResult:
+        """
+        Execute video rendering.
+        
+        Args:
+            context: Pipeline context with transcription outputs
+            
+        Returns:
+            StageResult with rendered video path
+        """
+        import time
+        start_time = time.time()
+        
+        try:
+            context.update_progress(self.name, 0, "Starting video rendering")
+            context.log("INFO", f"Rendering video for: {context.artist} - {context.title}")
+            
+            # Get transcription outputs
+            transcription = context.stage_outputs.get("transcription", {})
+            corrections_result = transcription.get("corrections_result")
+            
+            if not corrections_result:
+                context.log("WARNING", "No corrections result available for rendering")
+                return StageResult(
+                    status=StageStatus.SKIPPED,
+                    outputs={},
+                    error_message="No corrections result available",
+                )
+            
+            # Import OutputGenerator
+            from lyrics_transcriber import OutputGenerator, OutputConfig
+            
+            # Build output config
+            output_config = OutputConfig(
+                output_dir=context.output_dir,
+                cache_dir=os.path.join(context.output_dir, "cache"),
+                video_resolution="4k",  # Default to 4K
+            )
+            
+            # Apply style params if available
+            if context.style_params:
+                output_config = self._apply_style_params(output_config, context.style_params)
+            
+            context.update_progress(self.name, 20, "Initializing video generator")
+            
+            # Create OutputGenerator
+            generator = OutputGenerator(
+                config=output_config,
+                logger=self.logger,
+            )
+            
+            context.update_progress(self.name, 40, "Rendering video with lyrics")
+            
+            # Generate video
+            result = generator.generate_video(
+                result=corrections_result,
+                output_prefix=context.base_name,
+                audio_file=context.input_audio_path,
+            )
+            
+            outputs = {}
+            
+            if result:
+                outputs["with_vocals_video_path"] = result.get("video_path")
+                outputs["lrc_path"] = result.get("lrc_path")
+                outputs["ass_path"] = result.get("ass_path")
+            
+            context.update_progress(self.name, 100, "Video rendering complete")
+            
+            duration = time.time() - start_time
+            context.log("INFO", f"Video rendering completed in {duration:.1f}s")
+            
+            return StageResult(
+                status=StageStatus.COMPLETED,
+                outputs=outputs,
+                duration_seconds=duration,
+            )
+            
+        except Exception as e:
+            duration = time.time() - start_time
+            context.log("ERROR", f"Video rendering failed: {str(e)}")
+            return StageResult(
+                status=StageStatus.FAILED,
+                error_message=str(e),
+                error_details={"exception_type": type(e).__name__},
+                duration_seconds=duration,
+            )
+    
+    def _apply_style_params(self, config, style_params: Dict[str, Any]):
+        """Apply style parameters to output config."""
+        # Apply karaoke style settings if present
+        karaoke_params = style_params.get("karaoke", {})
+        
+        if karaoke_params.get("background_image"):
+            config.background_image = karaoke_params["background_image"]
+        
+        if karaoke_params.get("font_path"):
+            config.font_path = karaoke_params["font_path"]
+        
+        # Add more style mappings as needed
+        
+        return config

karaoke_gen/pipeline/stages/screens.py

@@ -0,0 +1,139 @@
+"""
+Title and end screen generation pipeline stage.
+
+This stage handles the generation of:
+- Title screen video (intro)
+- End screen video (outro)
+- Corresponding PNG/JPG images
+
+These are generated using the video_generator module.
+"""
+import logging
+import os
+from typing import Any, Dict, List, Optional
+
+from karaoke_gen.pipeline.base import PipelineStage, StageResult, StageStatus
+from karaoke_gen.pipeline.context import PipelineContext
+
+
+class ScreensStage(PipelineStage):
+    """
+    Title and end screen generation stage.
+    
+    Generates title and end screen videos/images using configured
+    style parameters.
+    """
+    
+    def __init__(
+        self,
+        output_png: bool = True,
+        output_jpg: bool = True,
+        logger: Optional[logging.Logger] = None,
+    ):
+        """
+        Initialize the screens stage.
+        
+        Args:
+            output_png: Generate PNG format images
+            output_jpg: Generate JPG format images
+            logger: Logger instance
+        """
+        self.output_png = output_png
+        self.output_jpg = output_jpg
+        self.logger = logger or logging.getLogger(__name__)
+    
+    @property
+    def name(self) -> str:
+        return "screens"
+    
+    @property
+    def required_inputs(self) -> List[str]:
+        return []
+    
+    @property
+    def output_keys(self) -> List[str]:
+        return [
+            "title_video_path",    # Path to title screen video
+            "title_png_path",      # Path to title screen PNG
+            "title_jpg_path",      # Path to title screen JPG
+            "end_video_path",      # Path to end screen video
+            "end_png_path",        # Path to end screen PNG
+            "end_jpg_path",        # Path to end screen JPG
+        ]
+    
+    async def execute(self, context: PipelineContext) -> StageResult:
+        """
+        Execute screen generation.
+        
+        Args:
+            context: Pipeline context with style params
+            
+        Returns:
+            StageResult with screen file paths
+        """
+        import time
+        start_time = time.time()
+        
+        try:
+            context.update_progress(self.name, 0, "Generating title and end screens")
+            context.log("INFO", f"Generating screens for: {context.artist} - {context.title}")
+            
+            from karaoke_gen.video_generator import VideoGenerator
+            
+            # Create video generator
+            generator = VideoGenerator(
+                artist=context.artist,
+                title=context.title,
+                output_dir=context.output_dir,
+                style_params=context.style_params,
+                logger=self.logger,
+            )
+            
+            outputs = {}
+            
+            context.update_progress(self.name, 25, "Generating title screen")
+            
+            # Generate title screen
+            title_result = generator.generate_title_screen(
+                output_png=self.output_png,
+                output_jpg=self.output_jpg,
+            )
+            
+            if title_result:
+                outputs["title_video_path"] = title_result.get("video_path")
+                outputs["title_png_path"] = title_result.get("png_path")
+                outputs["title_jpg_path"] = title_result.get("jpg_path")
+            
+            context.update_progress(self.name, 75, "Generating end screen")
+            
+            # Generate end screen
+            end_result = generator.generate_end_screen(
+                output_png=self.output_png,
+                output_jpg=self.output_jpg,
+            )
+            
+            if end_result:
+                outputs["end_video_path"] = end_result.get("video_path")
+                outputs["end_png_path"] = end_result.get("png_path")
+                outputs["end_jpg_path"] = end_result.get("jpg_path")
+            
+            context.update_progress(self.name, 100, "Screen generation complete")
+            
+            duration = time.time() - start_time
+            context.log("INFO", f"Screen generation completed in {duration:.1f}s")
+            
+            return StageResult(
+                status=StageStatus.COMPLETED,
+                outputs=outputs,
+                duration_seconds=duration,
+            )
+            
+        except Exception as e:
+            duration = time.time() - start_time
+            context.log("ERROR", f"Screen generation failed: {str(e)}")
+            return StageResult(
+                status=StageStatus.FAILED,
+                error_message=str(e),
+                error_details={"exception_type": type(e).__name__},
+                duration_seconds=duration,
+            )

karaoke_gen/pipeline/stages/separation.py

@@ -0,0 +1,191 @@
+"""
+Audio separation pipeline stage.
+
+This stage handles the separation of audio into stems:
+- Clean instrumental (vocals removed)
+- Vocals
+- Backing vocals and lead vocals (optional)
+- Other stems (drums, bass, guitar, etc.)
+- Combined instrumental with backing vocals
+
+The stage delegates to AudioProcessor but provides a consistent
+pipeline interface.
+"""
+import logging
+import os
+from typing import Any, Dict, List, Optional
+
+from karaoke_gen.pipeline.base import PipelineStage, StageResult, StageStatus
+from karaoke_gen.pipeline.context import PipelineContext
+
+
+class SeparationStage(PipelineStage):
+    """
+    Audio separation stage.
+    
+    Separates audio into stems using configured models.
+    Supports both local processing and remote API.
+    """
+    
+    def __init__(
+        self,
+        model_file_dir: str = "/tmp/audio-separator-models/",
+        lossless_output_format: str = "flac",
+        clean_instrumental_model: str = "model_bs_roformer_ep_317_sdr_12.9755.ckpt",
+        backing_vocals_models: Optional[List[str]] = None,
+        other_stems_models: Optional[List[str]] = None,
+        logger: Optional[logging.Logger] = None,
+        log_level: int = logging.INFO,
+        skip_separation: bool = False,
+    ):
+        """
+        Initialize the separation stage.
+        
+        Args:
+            model_file_dir: Directory for model files
+            lossless_output_format: Output format (flac, wav, etc.)
+            clean_instrumental_model: Model for clean instrumental separation
+            backing_vocals_models: Models for backing vocals separation
+            other_stems_models: Models for other stems (drums, bass, etc.)
+            logger: Logger instance
+            log_level: Logging level
+            skip_separation: If True, skip separation (for testing)
+        """
+        self.model_file_dir = model_file_dir
+        self.lossless_output_format = lossless_output_format
+        self.clean_instrumental_model = clean_instrumental_model
+        self.backing_vocals_models = backing_vocals_models or [
+            "mel_band_roformer_karaoke_aufr33_viperx_sdr_10.1956.ckpt"
+        ]
+        self.other_stems_models = other_stems_models or ["htdemucs_6s.yaml"]
+        self.logger = logger or logging.getLogger(__name__)
+        self.log_level = log_level
+        self.skip_separation = skip_separation
+    
+    @property
+    def name(self) -> str:
+        return "separation"
+    
+    @property
+    def required_inputs(self) -> List[str]:
+        # No required inputs from other stages - uses context.input_audio_path
+        return []
+    
+    @property
+    def output_keys(self) -> List[str]:
+        return [
+            "clean_instrumental",  # Dict with 'instrumental' and 'vocals' paths
+            "other_stems",         # Dict mapping model -> stems dict
+            "backing_vocals",      # Dict mapping model -> backing/lead vocals
+            "combined_instrumentals",  # Dict mapping model -> combined path
+        ]
+    
+    async def execute(self, context: PipelineContext) -> StageResult:
+        """
+        Execute audio separation.
+        
+        Args:
+            context: Pipeline context with input audio path
+            
+        Returns:
+            StageResult with separated stem paths
+        """
+        import time
+        start_time = time.time()
+        
+        try:
+            context.update_progress(self.name, 0, "Starting audio separation")
+            context.log("INFO", f"Separating audio: {context.input_audio_path}")
+            
+            if self.skip_separation:
+                context.log("INFO", "Skipping audio separation (skip_separation=True)")
+                return StageResult(
+                    status=StageStatus.SKIPPED,
+                    outputs={},
+                )
+            
+            # Create AudioProcessor instance
+            from karaoke_gen.audio_processor import AudioProcessor
+            
+            processor = AudioProcessor(
+                logger=self.logger,
+                log_level=self.log_level,
+                log_formatter=None,
+                model_file_dir=self.model_file_dir,
+                lossless_output_format=self.lossless_output_format,
+                clean_instrumental_model=self.clean_instrumental_model,
+                backing_vocals_models=self.backing_vocals_models,
+                other_stems_models=self.other_stems_models,
+                ffmpeg_base_command="ffmpeg -y -hide_banner -nostats -loglevel error",
+            )
+            
+            context.update_progress(self.name, 10, "Processing audio separation")
+            
+            # Run the separation
+            result = processor.process_audio_separation(
+                audio_file=context.input_audio_path,
+                artist_title=context.base_name,
+                track_output_dir=context.output_dir,
+            )
+            
+            context.update_progress(self.name, 90, "Audio separation complete")
+            
+            duration = time.time() - start_time
+            context.log("INFO", f"Audio separation completed in {duration:.1f}s")
+            
+            return StageResult(
+                status=StageStatus.COMPLETED,
+                outputs=result,
+                duration_seconds=duration,
+            )
+            
+        except Exception as e:
+            duration = time.time() - start_time
+            context.log("ERROR", f"Audio separation failed: {str(e)}")
+            return StageResult(
+                status=StageStatus.FAILED,
+                error_message=str(e),
+                error_details={"exception_type": type(e).__name__},
+                duration_seconds=duration,
+            )
+    
+    def apply_countdown_padding(
+        self,
+        context: PipelineContext,
+        separation_result: Dict[str, Any],
+        padding_seconds: float,
+    ) -> Dict[str, Any]:
+        """
+        Apply countdown padding to instrumental files.
+        
+        This is called after transcription determines the padding amount
+        needed to synchronize with padded vocals.
+        
+        Args:
+            context: Pipeline context
+            separation_result: Original separation result
+            padding_seconds: Amount of padding to apply
+            
+        Returns:
+            Updated separation result with padded file paths
+        """
+        from karaoke_gen.audio_processor import AudioProcessor
+        
+        processor = AudioProcessor(
+            logger=self.logger,
+            log_level=self.log_level,
+            log_formatter=None,
+            model_file_dir=self.model_file_dir,
+            lossless_output_format=self.lossless_output_format,
+            clean_instrumental_model=self.clean_instrumental_model,
+            backing_vocals_models=self.backing_vocals_models,
+            other_stems_models=self.other_stems_models,
+            ffmpeg_base_command="ffmpeg -y -hide_banner -nostats -loglevel error",
+        )
+        
+        return processor.apply_countdown_padding_to_instrumentals(
+            separation_result=separation_result,
+            padding_seconds=padding_seconds,
+            artist_title=context.base_name,
+            track_output_dir=context.output_dir,
+        )

karaoke_gen/pipeline/stages/transcription.py

@@ -0,0 +1,191 @@
+"""
+Lyrics transcription pipeline stage.
+
+This stage handles:
+- Transcription of lyrics from audio (using AudioShake API)
+- Fetching lyrics from online sources (Genius, Spotify, etc.)
+- Synchronization of lyrics with audio timing
+- Generation of LRC, ASS, and corrected text files
+
+Note: Video rendering is handled by the RenderStage, not here.
+"""
+import logging
+import os
+from typing import Any, Dict, List, Optional
+
+from karaoke_gen.pipeline.base import PipelineStage, StageResult, StageStatus
+from karaoke_gen.pipeline.context import PipelineContext
+
+
+class TranscriptionStage(PipelineStage):
+    """
+    Lyrics transcription stage.
+    
+    Transcribes and synchronizes lyrics from audio.
+    Does NOT render video - that's handled by RenderStage.
+    """
+    
+    def __init__(
+        self,
+        style_params_json: Optional[str] = None,
+        lyrics_file: Optional[str] = None,
+        skip_transcription: bool = False,
+        skip_transcription_review: bool = False,
+        subtitle_offset_ms: int = 0,
+        lyrics_artist: Optional[str] = None,
+        lyrics_title: Optional[str] = None,
+        logger: Optional[logging.Logger] = None,
+    ):
+        """
+        Initialize the transcription stage.
+        
+        Args:
+            style_params_json: Path to style parameters JSON file
+            lyrics_file: Path to existing lyrics file (optional)
+            skip_transcription: If True, skip automatic transcription
+            skip_transcription_review: If True, skip interactive review
+            subtitle_offset_ms: Offset for subtitle timing in milliseconds
+            lyrics_artist: Override artist name for lyrics search
+            lyrics_title: Override title for lyrics search
+            logger: Logger instance
+        """
+        self.style_params_json = style_params_json
+        self.lyrics_file = lyrics_file
+        self.skip_transcription = skip_transcription
+        self.skip_transcription_review = skip_transcription_review
+        self.subtitle_offset_ms = subtitle_offset_ms
+        self.lyrics_artist = lyrics_artist
+        self.lyrics_title = lyrics_title
+        self.logger = logger or logging.getLogger(__name__)
+    
+    @property
+    def name(self) -> str:
+        return "transcription"
+    
+    @property
+    def required_inputs(self) -> List[str]:
+        # No required inputs from other stages - uses context.input_audio_path
+        return []
+    
+    @property
+    def optional_inputs(self) -> List[str]:
+        # Can use separation output for vocals-only transcription
+        return ["separation"]
+    
+    @property
+    def output_keys(self) -> List[str]:
+        return [
+            "lrc_filepath",        # Path to LRC lyrics file
+            "ass_filepath",        # Path to ASS subtitle file
+            "corrected_txt_path",  # Path to corrected text file
+            "corrections_result",  # Full corrections JSON data
+            "countdown_padding_seconds",  # Countdown padding applied (if any)
+        ]
+    
+    async def execute(self, context: PipelineContext) -> StageResult:
+        """
+        Execute lyrics transcription.
+        
+        Args:
+            context: Pipeline context with input audio path
+            
+        Returns:
+            StageResult with lyrics file paths
+        """
+        import time
+        start_time = time.time()
+        
+        try:
+            context.update_progress(self.name, 0, "Starting lyrics transcription")
+            context.log("INFO", f"Transcribing lyrics for: {context.artist} - {context.title}")
+            
+            if self.skip_transcription:
+                context.log("INFO", "Skipping transcription (skip_transcription=True)")
+                return StageResult(
+                    status=StageStatus.SKIPPED,
+                    outputs={},
+                )
+            
+            # Get style params from context or use instance value
+            style_params_json = self.style_params_json
+            if not style_params_json and context.style_params:
+                # Write style params to temp file
+                import json
+                import tempfile
+                with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
+                    json.dump(context.style_params, f)
+                    style_params_json = f.name
+                    context.add_temp_path(style_params_json)
+            
+            # Create LyricsProcessor instance
+            # Note: render_video=False because we handle rendering in RenderStage
+            from karaoke_gen.lyrics_processor import LyricsProcessor
+            
+            processor = LyricsProcessor(
+                logger=self.logger,
+                style_params_json=style_params_json,
+                lyrics_file=self.lyrics_file,
+                skip_transcription=self.skip_transcription,
+                skip_transcription_review=self.skip_transcription_review,
+                render_video=False,  # Don't render video here
+                subtitle_offset_ms=self.subtitle_offset_ms,
+            )
+            
+            context.update_progress(self.name, 20, "Running transcription")
+            
+            # Run transcription
+            result = processor.transcribe_lyrics(
+                input_audio_wav=context.input_audio_path,
+                artist=context.artist,
+                title=context.title,
+                track_output_dir=context.output_dir,
+                lyrics_artist=self.lyrics_artist or context.artist,
+                lyrics_title=self.lyrics_title or context.title,
+            )
+            
+            # Build output dictionary
+            outputs = {}
+            
+            if result.get("lrc_filepath"):
+                outputs["lrc_filepath"] = result["lrc_filepath"]
+                
+            if result.get("ass_filepath"):
+                outputs["ass_filepath"] = result["ass_filepath"]
+                
+            if result.get("corrected_txt_path"):
+                outputs["corrected_txt_path"] = result["corrected_txt_path"]
+                
+            # Get corrections data if available
+            if hasattr(processor, 'corrections_result'):
+                outputs["corrections_result"] = processor.corrections_result
+                
+            # Check for countdown padding
+            lyrics_dir = os.path.join(context.output_dir, "lyrics")
+            countdown_file = os.path.join(lyrics_dir, "countdown_padding_seconds.txt")
+            if os.path.exists(countdown_file):
+                with open(countdown_file, 'r') as f:
+                    try:
+                        outputs["countdown_padding_seconds"] = float(f.read().strip())
+                    except ValueError:
+                        pass
+            
+            context.update_progress(self.name, 100, "Transcription complete")
+            
+            duration = time.time() - start_time
+            context.log("INFO", f"Lyrics transcription completed in {duration:.1f}s")
+            
+            return StageResult(
+                status=StageStatus.COMPLETED,
+                outputs=outputs,
+                duration_seconds=duration,
+            )
+            
+        except Exception as e:
+            duration = time.time() - start_time
+            context.log("ERROR", f"Lyrics transcription failed: {str(e)}")
+            return StageResult(
+                status=StageStatus.FAILED,
+                error_message=str(e),
+                error_details={"exception_type": type(e).__name__},
+                duration_seconds=duration,
+            )