karaoke-gen 0.63.1__tar.gz → 0.65.0__tar.gz

{karaoke_gen-0.63.1 → karaoke_gen-0.65.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: karaoke-gen
-Version: 0.63.1
+Version: 0.65.0
 Summary: Generate karaoke videos with synchronized lyrics. Handles the entire process from downloading audio and lyrics to creating the final video with title screens.
 License: MIT
 License-File: LICENSE
@@ -26,7 +26,7 @@ Requires-Dist: google-auth-httplib2
 Requires-Dist: google-auth-oauthlib
 Requires-Dist: kbputils (>=0.0.16,<0.0.17)
 Requires-Dist: lyrics-converter (>=0.2.1)
-Requires-Dist: lyrics-transcriber (>=0.69)
+Requires-Dist: lyrics-transcriber (>=0.72)
 Requires-Dist: lyricsgenius (>=3)
 Requires-Dist: matplotlib (>=3)
 Requires-Dist: modal (>=1.0.5,<2.0.0)

{karaoke_gen-0.63.1 → karaoke_gen-0.65.0}/karaoke_gen/audio_processor.py

@@ -52,6 +52,60 @@ class AudioProcessor:
             self.logger.info(f"File already exists, skipping creation: {file_path}")
         return exists
 
+    def pad_audio_file(self, input_audio, output_audio, padding_seconds):
+        """
+        Add silence to the start of an audio file using ffmpeg.
+        
+        This ensures the instrumental tracks are synchronized with vocals when
+        countdown padding has been applied by the LyricsTranscriber.
+        
+        Args:
+            input_audio: Path to input audio file
+            output_audio: Path for output padded audio file
+            padding_seconds: Amount of silence to add in seconds (e.g., 3.0)
+        
+        Raises:
+            Exception: If ffmpeg command fails
+        """
+        self.logger.info(f"Padding audio file with {padding_seconds}s of silence: {input_audio}")
+        
+        # Use ffmpeg to prepend silence to the audio file
+        # This matches the approach used in LyricsTranscriber for vocal padding
+        cmd = [
+            "ffmpeg",
+            "-y",  # Overwrite output file
+            "-hide_banner",
+            "-loglevel", "error",
+            "-f", "lavfi",
+            "-t", str(padding_seconds),
+            "-i", f"anullsrc=channel_layout=stereo:sample_rate=44100",
+            "-i", input_audio,
+            "-filter_complex", "[0:a][1:a]concat=n=2:v=0:a=1[out]",
+            "-map", "[out]",
+            "-c:a", self.lossless_output_format.lower(),
+            output_audio,
+        ]
+        
+        try:
+            import subprocess
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=300,  # 5 minute timeout
+                check=True
+            )
+            self.logger.info(f"Successfully padded audio file: {output_audio}")
+            
+        except subprocess.CalledProcessError as e:
+            error_msg = f"Failed to pad audio file {input_audio}: {e.stderr}"
+            self.logger.error(error_msg)
+            raise Exception(error_msg)
+        except subprocess.TimeoutExpired:
+            error_msg = f"Timeout while padding audio file {input_audio}"
+            self.logger.error(error_msg)
+            raise Exception(error_msg)
+
     def separate_audio(self, audio_file, model_name, artist_title, track_output_dir, instrumental_path, vocals_path):
         if audio_file is None or not os.path.isfile(audio_file):
             raise Exception("Error: Invalid audio source provided.")
@@ -717,3 +771,68 @@ class AudioProcessor:
 
         self.logger.info(f"Normalized audio saved, replacing: {output_path}")
         self.logger.debug(f"Original peak: {peak_amplitude} dB, Applied gain: {gain_db} dB")
+
+    def apply_countdown_padding_to_instrumentals(self, separation_result, padding_seconds, artist_title, track_output_dir):
+        """
+        Apply countdown padding to all instrumental audio files.
+        
+        When LyricsTranscriber adds countdown padding to vocals, this method ensures
+        all instrumental tracks are padded by the same amount to maintain synchronization.
+        
+        Args:
+            separation_result: Dictionary containing paths to separated audio files
+            padding_seconds: Amount of padding to apply (e.g., 3.0)
+            artist_title: Artist and title string for naming padded files
+            track_output_dir: Output directory for padded files
+            
+        Returns:
+            Dictionary with updated paths to padded instrumental files
+        """
+        self.logger.info(
+            f"Applying {padding_seconds}s countdown padding to all instrumental files to match vocal padding"
+        )
+        
+        padded_result = {
+            "clean_instrumental": {},
+            "other_stems": {},
+            "backing_vocals": {},
+            "combined_instrumentals": {},
+        }
+        
+        # Pad clean instrumental
+        if "clean_instrumental" in separation_result and separation_result["clean_instrumental"].get("instrumental"):
+            original_instrumental = separation_result["clean_instrumental"]["instrumental"]
+            
+            # Insert "Padded" before the file extension
+            base, ext = os.path.splitext(original_instrumental)
+            padded_instrumental = f"{base} (Padded){ext}"
+            
+            if not self._file_exists(padded_instrumental):
+                self.logger.info(f"Padding clean instrumental: {original_instrumental}")
+                self.pad_audio_file(original_instrumental, padded_instrumental, padding_seconds)
+            
+            padded_result["clean_instrumental"]["instrumental"] = padded_instrumental
+            padded_result["clean_instrumental"]["vocals"] = separation_result["clean_instrumental"].get("vocals")
+        
+        # Pad combined instrumentals (instrumental + backing vocals)
+        if "combined_instrumentals" in separation_result:
+            for model, combined_path in separation_result["combined_instrumentals"].items():
+                base, ext = os.path.splitext(combined_path)
+                padded_combined = f"{base} (Padded){ext}"
+                
+                if not self._file_exists(padded_combined):
+                    self.logger.info(f"Padding combined instrumental ({model}): {combined_path}")
+                    self.pad_audio_file(combined_path, padded_combined, padding_seconds)
+                
+                padded_result["combined_instrumentals"][model] = padded_combined
+        
+        # Copy over other stems and backing vocals without padding
+        # (these are typically not used in final output, but preserve the structure)
+        padded_result["other_stems"] = separation_result.get("other_stems", {})
+        padded_result["backing_vocals"] = separation_result.get("backing_vocals", {})
+        
+        self.logger.info(
+            f"✓ Countdown padding applied to {len(padded_result['combined_instrumentals']) + 1} instrumental file(s)"
+        )
+        
+        return padded_result

{karaoke_gen-0.63.1 → karaoke_gen-0.65.0}/karaoke_gen/karaoke_gen.py

@@ -392,6 +392,10 @@ class KaraokePrep:
                 self.logger.info("Skipping lyrics fetch as requested.")
                 processed_track["lyrics"] = None
                 processed_track["processed_lyrics"] = None
+                # No countdown padding when lyrics are skipped
+                processed_track["countdown_padding_added"] = False
+                processed_track["countdown_padding_seconds"] = 0.0
+                processed_track["padded_vocals_audio"] = None
             else:
                 lyrics_artist = self.lyrics_artist or self.artist
                 lyrics_title = self.lyrics_title or self.title
@@ -483,6 +487,20 @@ class KaraokePrep:
                             if isinstance(transcriber_outputs, dict):
                                 self.lyrics = transcriber_outputs.get("corrected_lyrics_text")
                                 processed_track["lyrics"] = transcriber_outputs.get("corrected_lyrics_text_filepath")
+                                
+                                # Capture countdown padding information
+                                processed_track["countdown_padding_added"] = transcriber_outputs.get("countdown_padding_added", False)
+                                processed_track["countdown_padding_seconds"] = transcriber_outputs.get("countdown_padding_seconds", 0.0)
+                                processed_track["padded_vocals_audio"] = transcriber_outputs.get("padded_audio_filepath")
+                                
+                                if processed_track["countdown_padding_added"]:
+                                    self.logger.info(
+                                        f"=== COUNTDOWN PADDING DETECTED ==="
+                                    )
+                                    self.logger.info(
+                                        f"Vocals have been padded with {processed_track['countdown_padding_seconds']}s of silence. "
+                                        f"Instrumental tracks will be padded after separation to maintain synchronization."
+                                    )
                             else:
                                 self.logger.warning(f"Unexpected type for transcriber_outputs: {type(transcriber_outputs)}, value: {transcriber_outputs}")
                         else:
@@ -586,6 +604,23 @@ class KaraokePrep:
                     "instrumental": instrumental_path,
                     "vocals": None,
                 }
+                
+                # If countdown padding was added to vocals, pad the custom instrumental too
+                if processed_track.get("countdown_padding_added", False):
+                    padding_seconds = processed_track["countdown_padding_seconds"]
+                    self.logger.info(
+                        f"Countdown padding detected - applying {padding_seconds}s padding to custom instrumental"
+                    )
+                    
+                    base, ext = os.path.splitext(instrumental_path)
+                    padded_instrumental_path = f"{base} (Padded){ext}"
+                    
+                    if not self.file_handler._file_exists(padded_instrumental_path):
+                        self.audio_processor.pad_audio_file(instrumental_path, padded_instrumental_path, padding_seconds)
+                    
+                    # Update the path to use the padded version
+                    processed_track["separated_audio"]["Custom"]["instrumental"] = padded_instrumental_path
+                    self.logger.info(f"✓ Custom instrumental has been padded and synchronized with vocals")
             elif "separated_audio" not in processed_track or not processed_track["separated_audio"]:
                 # Only run separation if it wasn't already done in parallel processing
                 self.logger.info(f"Separation was not completed in parallel processing, running separation for track: {self.title} by {self.artist}")
@@ -597,6 +632,31 @@ class KaraokePrep:
             else:
                 self.logger.info("Audio separation was already completed in parallel processing, skipping duplicate separation.")
 
+            # Apply countdown padding to instrumental files if needed
+            if processed_track.get("countdown_padding_added", False):
+                padding_seconds = processed_track["countdown_padding_seconds"]
+                self.logger.info(
+                    f"=== APPLYING COUNTDOWN PADDING TO INSTRUMENTALS ==="
+                )
+                self.logger.info(
+                    f"Applying {padding_seconds}s padding to all instrumental files to sync with vocal countdown"
+                )
+                
+                # Apply padding using AudioProcessor
+                padded_separation_result = self.audio_processor.apply_countdown_padding_to_instrumentals(
+                    separation_result=processed_track["separated_audio"],
+                    padding_seconds=padding_seconds,
+                    artist_title=artist_title,
+                    track_output_dir=track_output_dir,
+                )
+                
+                # Update processed_track with padded file paths
+                processed_track["separated_audio"] = padded_separation_result
+                
+                self.logger.info(
+                    f"✓ All instrumental files have been padded and are now synchronized with vocals"
+                )
+
             self.logger.info("Script finished, audio downloaded, lyrics fetched and audio separated!")
 
             return processed_track

{karaoke_gen-0.63.1 → karaoke_gen-0.65.0}/karaoke_gen/lyrics_processor.py

@@ -286,6 +286,17 @@ class LyricsProcessor:
             
             self.logger.info(f"Saved correction data to {corrections_filepath}")
 
+        # Capture countdown padding information for syncing with instrumental audio
+        transcriber_outputs["countdown_padding_added"] = getattr(results, "countdown_padding_added", False)
+        transcriber_outputs["countdown_padding_seconds"] = getattr(results, "countdown_padding_seconds", 0.0)
+        transcriber_outputs["padded_audio_filepath"] = getattr(results, "padded_audio_filepath", None)
+        
+        if transcriber_outputs["countdown_padding_added"]:
+            self.logger.info(
+                f"Countdown padding detected: {transcriber_outputs['countdown_padding_seconds']}s added to vocals. "
+                f"Instrumental audio will need to be padded accordingly."
+            )
+
         if transcriber_outputs:
             self.logger.info(f"*** Transcriber Filepath Outputs: ***")
             for key, value in transcriber_outputs.items():

{karaoke_gen-0.63.1 → karaoke_gen-0.65.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "karaoke-gen"
-version = "0.63.1"
+version = "0.65.0"
 description = "Generate karaoke videos with synchronized lyrics. Handles the entire process from downloading audio and lyrics to creating the final video with title screens."
 authors = ["Andrew Beveridge <andrew@beveridge.uk>"]
 license = "MIT"
@@ -28,7 +28,7 @@ thefuzz = ">=0.22"
 numpy = ">=2"
 audio-separator = { version = ">=0.34.0", extras = ["cpu"] }
 lyrics-converter = ">=0.2.1"
-lyrics-transcriber = ">=0.69"
+lyrics-transcriber = ">=0.72"
 kbputils = "^0.0.16"
 attrs = ">=24.2.0"
 cattrs = ">=24.1.2"