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

karaoke_gen/karaoke_finalise/karaoke_finalise.py

@@ -46,6 +46,7 @@ class KaraokeFinalise:
         non_interactive=False,
         user_youtube_credentials=None,  # Add support for pre-stored credentials
         server_side_mode=False,  # New parameter for server-side deployment
+        selected_instrumental_file=None,  # Add support for pre-selected instrumental file
     ):
         self.log_level = log_level
         self.log_formatter = log_formatter
@@ -103,6 +104,7 @@ class KaraokeFinalise:
         self.non_interactive = non_interactive
         self.user_youtube_credentials = user_youtube_credentials
         self.server_side_mode = server_side_mode
+        self.selected_instrumental_file = selected_instrumental_file
 
         self.suffixes = {
             "title_mov": " (Title).mov",
@@ -151,7 +153,8 @@ class KaraokeFinalise:
             self.ffmpeg_base_command += " -y"
 
         # Detect and configure hardware acceleration
-        self.nvenc_available = self.detect_nvenc_support()
+        # TODO: Re-enable this once we figure out why the resulting MP4s are 10x larger than when encoded with x264...
+        self.nvenc_available = False # self.detect_nvenc_support()
         self.configure_hardware_acceleration()
 
     def check_input_files_exist(self, base_name, with_vocals_file, instrumental_audio_file):
@@ -254,9 +257,19 @@ class KaraokeFinalise:
 
             self.logger.debug(f"YouTube upload checks passed, enabling YouTube upload")
             self.youtube_upload_enabled = True
+        
+        # Also enable YouTube upload if pre-stored credentials are provided (server-side mode)
+        elif self.user_youtube_credentials is not None and self.youtube_description_file is not None:
+            if not os.path.isfile(self.youtube_description_file):
+                raise Exception(f"YouTube description file does not exist: {self.youtube_description_file}")
+            
+            self.logger.debug(f"Pre-stored YouTube credentials provided, enabling YouTube upload")
+            self.youtube_upload_enabled = True
 
         # Enable discord notifications if webhook URL is provided and is valid URL
         if self.discord_webhook_url is not None:
+            # Strip whitespace/newlines that may have been introduced from environment variables or secrets
+            self.discord_webhook_url = self.discord_webhook_url.strip()
             if not self.discord_webhook_url.startswith("https://discord.com/api/webhooks/"):
                 raise Exception(f"Discord webhook URL is not valid: {self.discord_webhook_url}")
 
@@ -409,26 +422,33 @@ class KaraokeFinalise:
         if "items" in response and len(response["items"]) > 0:
             for item in response["items"]:
                 found_title = item["snippet"]["title"]
-                similarity_score = fuzz.ratio(youtube_title.lower(), found_title.lower())
-                if similarity_score >= 70:  # 70% similarity
+
+                # In server-side mode, require an exact match to avoid false positives.
+                # Otherwise, use fuzzy matching for interactive CLI usage.
+                if self.server_side_mode:
+                    is_match = youtube_title.lower() == found_title.lower()
+                    similarity_score = 100 if is_match else 0
+                else:
+                    similarity_score = fuzz.ratio(youtube_title.lower(), found_title.lower())
+                    is_match = similarity_score >= 70
+
+                if is_match:
                     found_id = item["id"]["videoId"]
                     self.logger.info(
                         f"Potential match found on YouTube channel with ID: {found_id} and title: {found_title} (similarity: {similarity_score}%)"
                     )
-                    
-                    # In non-interactive mode, automatically confirm if similarity is high enough
+
+                    # In non-interactive mode (server mode), we don't prompt. Just record the match and return.
                     if self.non_interactive:
-                        self.logger.info(f"Non-interactive mode, automatically confirming match with similarity score {similarity_score}%")
+                        self.logger.info(f"Non-interactive mode, found a match.")
                         self.youtube_video_id = found_id
                         self.youtube_url = f"{self.youtube_url_prefix}{self.youtube_video_id}"
-                        self.skip_notifications = True
                         return True
-                    
+
                     confirmation = input(f"Is '{found_title}' the video you are finalising? (y/n): ").strip().lower()
                     if confirmation == "y":
                         self.youtube_video_id = found_id
                         self.youtube_url = f"{self.youtube_url_prefix}{self.youtube_video_id}"
-                        self.skip_notifications = True
                         return True
 
         self.logger.info(f"No matching video found with title: {youtube_title}")
@@ -480,8 +500,12 @@ class KaraokeFinalise:
             max_length = 95
             youtube_title = self.truncate_to_nearest_word(youtube_title, max_length)
 
+            # In server-side mode, we should always replace videos if an exact match is found.
+            # Otherwise, respect the replace_existing flag from CLI.
+            should_replace = True if self.server_side_mode else replace_existing
+
             if self.check_if_video_title_exists_on_youtube_channel(youtube_title):
-                if replace_existing:
+                if should_replace:
                     self.logger.info(f"Video already exists on YouTube, deleting before re-upload: {self.youtube_url}")
                     if self.delete_youtube_video(self.youtube_video_id):
                         self.logger.info(f"Successfully deleted existing video, proceeding with upload")
@@ -530,10 +554,17 @@ class KaraokeFinalise:
             self.logger.info(f"Uploaded video to YouTube: {self.youtube_url}")
 
             # Uploading the thumbnail
-            if input_files["title_jpg"]:
-                media_thumbnail = MediaFileUpload(input_files["title_jpg"], mimetype="image/jpeg")
-                youtube.thumbnails().set(videoId=self.youtube_video_id, media_body=media_thumbnail).execute()
-                self.logger.info(f"Uploaded thumbnail for video ID {self.youtube_video_id}")
+            if input_files.get("title_jpg") and os.path.isfile(input_files["title_jpg"]):
+                try:
+                    self.logger.info(f"Uploading thumbnail from: {input_files['title_jpg']}")
+                    media_thumbnail = MediaFileUpload(input_files["title_jpg"], mimetype="image/jpeg")
+                    youtube.thumbnails().set(videoId=self.youtube_video_id, media_body=media_thumbnail).execute()
+                    self.logger.info(f"Uploaded thumbnail for video ID {self.youtube_video_id}")
+                except Exception as e:
+                    self.logger.error(f"Failed to upload thumbnail: {e}")
+                    self.logger.warning("Video uploaded but thumbnail not set. You may need to set it manually on YouTube.")
+            else:
+                self.logger.warning(f"Thumbnail file not found, skipping thumbnail upload: {input_files.get('title_jpg')}")
 
     def get_next_brand_code(self):
         """
@@ -746,13 +777,13 @@ class KaraokeFinalise:
         # Hardware-accelerated version
         gpu_command = (
             f'{self.ffmpeg_base_command} {self.hwaccel_decode_flags} -i "{input_file}" '
-            f'-c:v {self.video_encoder} {self.get_nvenc_quality_settings("high")} -c:a {self.aac_codec} {self.mp4_flags} "{output_file}"'
+            f'-c:v {self.video_encoder} {self.get_nvenc_quality_settings("high")} -c:a {self.aac_codec} -ar 48000 {self.mp4_flags} "{output_file}"'
         )
         
         # Software fallback version
         cpu_command = (
             f'{self.ffmpeg_base_command} -i "{input_file}" '
-            f'-c:v libx264 -c:a {self.aac_codec} {self.mp4_flags} "{output_file}"'
+            f'-c:v libx264 -c:a {self.aac_codec} -ar 48000 {self.mp4_flags} "{output_file}"'
         )
         
         self.execute_command_with_fallback(gpu_command, cpu_command, "Converting MOV video to MP4")
@@ -782,7 +813,7 @@ class KaraokeFinalise:
         # Hardware acceleration doesn't provide significant benefit for copy operations
         ffmpeg_command = (
             f'{self.ffmpeg_base_command} -i "{input_file}" '
-            f'-c:v copy -c:a {self.aac_codec} -b:a 320k {self.mp4_flags} "{output_file}"'
+            f'-c:v copy -c:a {self.aac_codec} -ar 48000 -b:a 320k {self.mp4_flags} "{output_file}"'
         )
         self.execute_command(ffmpeg_command, "Creating MP4 version with AAC audio")
 
@@ -803,14 +834,14 @@ class KaraokeFinalise:
             f'{self.ffmpeg_base_command} {self.hwaccel_decode_flags} -i "{input_file}" '
             f'-c:v {self.video_encoder} -vf "{self.scale_filter}=1280:720" '
             f'{self.get_nvenc_quality_settings("medium")} -b:v 2000k '
-            f'-c:a {self.aac_codec} -b:a 128k {self.mp4_flags} "{output_file}"'
+            f'-c:a {self.aac_codec} -ar 48000 -b:a 128k {self.mp4_flags} "{output_file}"'
         )
         
         # Software fallback version
         cpu_command = (
             f'{self.ffmpeg_base_command} -i "{input_file}" '
             f'-c:v libx264 -vf "scale=1280:720" -b:v 2000k -preset medium -tune animation '
-            f'-c:a {self.aac_codec} -b:a 128k {self.mp4_flags} "{output_file}"'
+            f'-c:a {self.aac_codec} -ar 48000 -b:a 128k {self.mp4_flags} "{output_file}"'
         )
         
         self.execute_command_with_fallback(gpu_command, cpu_command, "Encoding 720p version of the final video")
@@ -829,7 +860,7 @@ class KaraokeFinalise:
         return env_mov_input, ffmpeg_filter
 
     def remux_and_encode_output_video_files(self, with_vocals_file, input_files, output_files):
-        self.logger.info(f"Remuxing and encoding output video files...")
+        self.logger.info(f"Remuxing and encoding output video files (4 formats, ~15-20 minutes total)...")
 
         # Check if output files already exist
         if os.path.isfile(output_files["final_karaoke_lossless_mp4"]) and os.path.isfile(output_files["final_karaoke_lossless_mkv"]):
@@ -840,16 +871,20 @@ class KaraokeFinalise:
                 return
 
         # Create karaoke version with instrumental audio
+        self.logger.info(f"[Step 1/6] Remuxing video with instrumental audio...")
         self.remux_with_instrumental(with_vocals_file, input_files["instrumental_audio"], output_files["karaoke_mp4"])
 
         # Convert the with vocals video to MP4 if needed
         if not with_vocals_file.endswith(".mp4"):
+            self.logger.info(f"[Step 2/6] Converting karaoke video to MP4...")
             self.convert_mov_to_mp4(with_vocals_file, output_files["with_vocals_mp4"])
 
             # Delete the with vocals mov after successfully converting it to mp4
             if not self.dry_run and os.path.isfile(with_vocals_file):
                 self.logger.info(f"Deleting with vocals MOV file: {with_vocals_file}")
                 os.remove(with_vocals_file)
+        else:
+            self.logger.info(f"[Step 2/6] Skipped - video already in MP4 format")
 
         # Quote file paths to handle special characters
         title_mov_file = shlex.quote(os.path.abspath(input_files["title_mov"]))
@@ -858,10 +893,17 @@ class KaraokeFinalise:
         # Prepare concat filter for combining videos
         env_mov_input, ffmpeg_filter = self.prepare_concat_filter(input_files)
 
-        # Create all output versions
+        # Create all output versions with progress logging
+        self.logger.info(f"[Step 3/6] Encoding lossless 4K MP4 (title + karaoke + end, ~5 minutes)...")
         self.encode_lossless_mp4(title_mov_file, karaoke_mp4_file, env_mov_input, ffmpeg_filter, output_files["final_karaoke_lossless_mp4"])
+        
+        self.logger.info(f"[Step 4/6] Encoding lossy 4K MP4 with AAC audio (~1 minute)...")
         self.encode_lossy_mp4(output_files["final_karaoke_lossless_mp4"], output_files["final_karaoke_lossy_mp4"])
+        
+        self.logger.info(f"[Step 5/6] Creating MKV with FLAC audio for YouTube (~1 minute)...")
         self.encode_lossless_mkv(output_files["final_karaoke_lossless_mp4"], output_files["final_karaoke_lossless_mkv"])
+        
+        self.logger.info(f"[Step 6/6] Encoding 720p version (~3 minutes)...")
         self.encode_720p_version(output_files["final_karaoke_lossless_mp4"], output_files["final_karaoke_lossy_720p_mp4"])
 
         # Skip user confirmation in non-interactive mode for Modal deployment
@@ -1064,7 +1106,7 @@ class KaraokeFinalise:
                     os.remove(file_path)
                     self.logger.info(f"Deleted .DS_Store file: {file_path}")
 
-        rclone_cmd = f"rclone copy -v {shlex.quote(self.public_share_dir)} {shlex.quote(self.rclone_destination)}"
+        rclone_cmd = f"rclone copy -v --ignore-existing {shlex.quote(self.public_share_dir)} {shlex.quote(self.rclone_destination)}"
         self.execute_command(rclone_cmd, "Copying to cloud destination")
 
     def post_discord_notification(self):
@@ -1073,6 +1115,11 @@ class KaraokeFinalise:
         if self.skip_notifications:
             self.logger.info(f"Skipping Discord notification as video was previously uploaded to YouTube")
             return
+        
+        # Only post if we have a YouTube URL
+        if not self.youtube_url:
+            self.logger.info(f"Skipping Discord notification - no YouTube URL available")
+            return
 
         if self.dry_run:
             self.logger.info(
@@ -1189,7 +1236,7 @@ class KaraokeFinalise:
         current_dir = os.getcwd()
         
         # Use rclone copy to upload the entire current directory to the remote destination
-        rclone_upload_cmd = f"rclone copy -v {shlex.quote(current_dir)} {shlex.quote(remote_dest)}"
+        rclone_upload_cmd = f"rclone copy -v --ignore-existing {shlex.quote(current_dir)} {shlex.quote(remote_dest)}"
         
         if self.dry_run:
             self.logger.info(f"DRY RUN: Would upload current directory to: {remote_dest}")
@@ -1254,14 +1301,23 @@ class KaraokeFinalise:
                 self.upload_final_mp4_to_youtube_with_title_thumbnail(artist, title, input_files, output_files, replace_existing)
             except Exception as e:
                 self.logger.error(f"Failed to upload video to YouTube: {e}")
-                print("Please manually upload the video to YouTube.")
-                print()
-                self.youtube_video_id = input("Enter the manually uploaded YouTube video ID: ").strip()
-                self.youtube_url = f"{self.youtube_url_prefix}{self.youtube_video_id}"
-                self.logger.info(f"Using manually provided YouTube video ID: {self.youtube_video_id}")
+                if not self.non_interactive:
+                    print("Please manually upload the video to YouTube.")
+                    print()
+                    self.youtube_video_id = input("Enter the manually uploaded YouTube video ID: ").strip()
+                    self.youtube_url = f"{self.youtube_url_prefix}{self.youtube_video_id}"
+                    self.logger.info(f"Using manually provided YouTube video ID: {self.youtube_video_id}")
+                else:
+                    self.logger.error("YouTube upload failed in non-interactive mode, skipping")
 
-            if self.discord_notication_enabled:
+        # Discord notification - runs independently of YouTube upload
+        # Wrapped in try/except so failures don't crash the entire job
+        if self.discord_notication_enabled:
+            try:
                 self.post_discord_notification()
+            except Exception as e:
+                self.logger.error(f"Failed to send Discord notification: {e}")
+                self.logger.warning("Continuing without Discord notification - this is non-fatal")
 
         # Handle folder organization - different logic for server-side vs local mode
         if self.server_side_mode and self.brand_prefix and self.organised_dir_rclone_root:
@@ -1362,6 +1418,12 @@ class KaraokeFinalise:
             self.logger.info("Email template file not provided, skipping email draft creation.")
             return
 
+        if not self.youtube_client_secrets_file:
+            self.logger.error("Email template file was provided, but youtube_client_secrets_file is required for Gmail authentication.")
+            self.logger.error("Please provide --youtube_client_secrets_file parameter to enable email draft creation.")
+            self.logger.info("Skipping email draft creation.")
+            return
+
         with open(self.email_template_file, "r") as f:
             template = f.read()
 
@@ -1416,89 +1478,87 @@ class KaraokeFinalise:
             return "aac"
 
     def detect_nvenc_support(self):
-        """Detect if NVENC hardware encoding is available with comprehensive checks."""
+        """Detect if NVENC hardware encoding is available."""
         try:
-            self.logger.info("🔍 Detecting NVENC hardware acceleration support...")
+            self.logger.info("🔍 Detecting NVENC hardware acceleration...")
             
             if self.dry_run:
-                self.logger.info("DRY RUN: Assuming NVENC is available")
+                self.logger.info("  DRY RUN: Assuming NVENC is available")
                 return True
             
             import subprocess
             import os
             import shutil
             
-            # Step 1: Check for nvidia-smi (indicates NVIDIA driver presence)
+            # Check for nvidia-smi (indicates NVIDIA driver presence)
             try:
                 nvidia_smi_result = subprocess.run(["nvidia-smi", "--query-gpu=name,driver_version", "--format=csv,noheader"], 
                                                   capture_output=True, text=True, timeout=10)
                 if nvidia_smi_result.returncode == 0:
                     gpu_info = nvidia_smi_result.stdout.strip()
-                    self.logger.info(f"✓ NVIDIA GPU detected: {gpu_info}")
+                    self.logger.info(f"  ✓ NVIDIA GPU detected: {gpu_info}")
                 else:
-                    self.logger.warning("⚠️ nvidia-smi not available or no NVIDIA GPU detected")
+                    self.logger.debug(f"nvidia-smi failed: {nvidia_smi_result.stderr}")
+                    self.logger.info("  ✗ NVENC not available (no NVIDIA GPU)")
                     return False
-            except (subprocess.TimeoutExpired, FileNotFoundError, subprocess.CalledProcessError):
-                self.logger.warning("⚠️ nvidia-smi not available or failed")
+            except (subprocess.TimeoutExpired, FileNotFoundError, subprocess.CalledProcessError) as e:
+                self.logger.debug(f"nvidia-smi not available: {e}")
+                self.logger.info("  ✗ NVENC not available (no NVIDIA GPU)")
                 return False
             
-            # Step 2: Check for NVENC encoders in FFmpeg
+            # Check for NVENC encoders in FFmpeg
             try:
                 encoders_cmd = f"{self.ffmpeg_base_command} -hide_banner -encoders 2>/dev/null | grep nvenc"
                 encoders_result = subprocess.run(encoders_cmd, shell=True, capture_output=True, text=True, timeout=10)
                 if encoders_result.returncode == 0 and "nvenc" in encoders_result.stdout:
                     nvenc_encoders = [line.strip() for line in encoders_result.stdout.split('\n') if 'nvenc' in line]
-                    self.logger.info("✓ Found NVENC encoders in FFmpeg:")
-                    for encoder in nvenc_encoders:
-                        if encoder:
-                            self.logger.info(f"  {encoder}")
+                    self.logger.debug(f"Found NVENC encoders: {nvenc_encoders}")
                 else:
-                    self.logger.warning("⚠️ No NVENC encoders found in FFmpeg")
+                    self.logger.debug("No NVENC encoders found in FFmpeg")
+                    self.logger.info("  ✗ NVENC not available (no FFmpeg support)")
                     return False
             except Exception as e:
-                self.logger.warning(f"⚠️ Failed to check FFmpeg NVENC encoders: {e}")
+                self.logger.debug(f"Failed to check FFmpeg NVENC encoders: {e}")
+                self.logger.info("  ✗ NVENC not available")
                 return False
             
-            # Step 3: Check for libcuda.so.1 (critical for NVENC)
+            # Check for libcuda.so.1 (critical for NVENC)
             try:
                 libcuda_check = subprocess.run(["ldconfig", "-p"], capture_output=True, text=True, timeout=10)
                 if libcuda_check.returncode == 0 and "libcuda.so.1" in libcuda_check.stdout:
-                    self.logger.info("✅ libcuda.so.1 found in system libraries")
+                    self.logger.debug("libcuda.so.1 found in system libraries")
                 else:
-                    self.logger.warning("❌ libcuda.so.1 NOT found in system libraries")
-                    self.logger.warning("💡 This usually indicates the CUDA runtime image is needed instead of devel")
+                    self.logger.debug("libcuda.so.1 NOT found - may need nvidia/cuda:*-devel image")
+                    self.logger.info("  ✗ NVENC not available (missing CUDA libraries)")
                     return False
             except Exception as e:
-                self.logger.warning(f"⚠️ Failed to check for libcuda.so.1: {e}")
+                self.logger.debug(f"Failed to check for libcuda.so.1: {e}")
+                self.logger.info("  ✗ NVENC not available")
                 return False
             
-            # Step 4: Test h264_nvenc encoder with simple test
-            self.logger.info("🧪 Testing h264_nvenc encoder...")
-            test_cmd = f"{self.ffmpeg_base_command} -hide_banner -loglevel warning -f lavfi -i testsrc=duration=1:size=320x240:rate=1 -c:v h264_nvenc -f null -"
-            self.logger.debug(f"Running test command: {test_cmd}")
+            # Test h264_nvenc encoder
+            test_cmd = f"{self.ffmpeg_base_command} -hide_banner -loglevel error -f lavfi -i testsrc=duration=1:size=320x240:rate=1 -c:v h264_nvenc -f null -"
+            self.logger.debug(f"Testing NVENC: {test_cmd}")
             
             try:
                 result = subprocess.run(test_cmd, shell=True, capture_output=True, text=True, timeout=30)
                 
                 if result.returncode == 0:
-                    self.logger.info("✅ NVENC hardware encoding available for video generation")
-                    self.logger.info(f"Test command succeeded. Output: {result.stderr if result.stderr else '...'}")
+                    self.logger.info("  ✓ NVENC encoding available")
                     return True
                 else:
-                    self.logger.warning(f"❌ NVENC test failed with exit code {result.returncode}")
-                    if result.stderr:
-                        self.logger.warning(f"Error output: {result.stderr}")
-                        if "Cannot load libcuda.so.1" in result.stderr:
-                            self.logger.warning("💡 Root cause: libcuda.so.1 cannot be loaded by NVENC")
-                            self.logger.warning("💡 Solution: Use nvidia/cuda:*-devel-* image instead of runtime")
+                    self.logger.debug(f"NVENC test failed (exit code {result.returncode}): {result.stderr}")
+                    self.logger.info("  ✗ NVENC not available")
                     return False
                     
             except subprocess.TimeoutExpired:
-                self.logger.warning("❌ NVENC test timed out")
+                self.logger.debug("NVENC test timed out")
+                self.logger.info("  ✗ NVENC not available (timeout)")
                 return False
                 
         except Exception as e:
-            self.logger.warning(f"❌ Failed to detect NVENC support: {e}, falling back to software encoding")
+            self.logger.debug(f"Failed to detect NVENC support: {e}")
+            self.logger.info("  ✗ NVENC not available (error)")
             return False
 
     def configure_hardware_acceleration(self):
@@ -1509,12 +1569,12 @@ class KaraokeFinalise:
             # Remove -hwaccel_output_format cuda as it causes pixel format conversion issues
             self.hwaccel_decode_flags = "-hwaccel cuda"
             self.scale_filter = "scale"  # Use CPU scaling for complex filter chains
-            self.logger.info("Configured for NVIDIA hardware acceleration (simplified for filter compatibility)")
+            self.logger.info("🚀 Using NVENC hardware acceleration for video encoding")
         else:
             self.video_encoder = "libx264"
             self.hwaccel_decode_flags = ""
             self.scale_filter = "scale"
-            self.logger.info("Configured for software encoding")
+            self.logger.info("🔧 Using software encoding (libx264) for video")
 
     def get_nvenc_quality_settings(self, quality_mode="high"):
         """Get NVENC settings based on quality requirements."""
@@ -1619,25 +1679,46 @@ class KaraokeFinalise:
         if self.dry_run:
             self.logger.warning("Dry run enabled. No actions will be performed.")
 
+        self.logger.info("=" * 60)
+        self.logger.info("Starting KaraokeFinalise processing pipeline")
+        self.logger.info("=" * 60)
+
         # Check required input files and parameters exist, get user to confirm features before proceeding
         self.validate_input_parameters_for_features()
 
         with_vocals_file = self.find_with_vocals_file()
         base_name, artist, title = self.get_names_from_withvocals(with_vocals_file)
-
-        instrumental_audio_file = self.choose_instrumental_audio_file(base_name)
+        
+        self.logger.info(f"Processing: {artist} - {title}")
+
+        # Use the selected instrumental file if provided, otherwise search for one
+        if self.selected_instrumental_file:
+            if not os.path.isfile(self.selected_instrumental_file):
+                raise Exception(f"Selected instrumental file not found: {self.selected_instrumental_file}")
+            instrumental_audio_file = self.selected_instrumental_file
+            self.logger.info(f"Using pre-selected instrumental file: {instrumental_audio_file}")
+        else:
+            self.logger.info("No instrumental file pre-selected, searching for instrumental files...")
+            instrumental_audio_file = self.choose_instrumental_audio_file(base_name)
 
         input_files = self.check_input_files_exist(base_name, with_vocals_file, instrumental_audio_file)
         output_files = self.prepare_output_filenames(base_name)
 
         if self.enable_cdg:
+            self.logger.info("Creating CDG package...")
             self.create_cdg_zip_file(input_files, output_files, artist, title)
+            self.logger.info("CDG package created successfully")
 
         if self.enable_txt:
+            self.logger.info("Creating TXT package...")
             self.create_txt_zip_file(input_files, output_files)
+            self.logger.info("TXT package created successfully")
 
+        self.logger.info("Starting video encoding (this is the longest step, ~15-20 minutes)...")
         self.remux_and_encode_output_video_files(with_vocals_file, input_files, output_files)
+        self.logger.info("Video encoding completed successfully")
 
+        self.logger.info("Executing distribution features (YouTube, Dropbox, Discord)...")
         self.execute_optional_features(artist, title, base_name, input_files, output_files, replace_existing)
 
         result = {