Update app.py

app.py

@@ -4,8 +4,8 @@ import static_ffmpeg
 import os
 import tempfile
 import requests
+import re
 from datetime import datetime
-from pathlib import Path
 
 # Add static ffmpeg to PATH
 static_ffmpeg.add_paths()
@@ -26,47 +26,27 @@ def download_file_from_url(url, output_dir, filename):
         raise Exception(f"Failed to download file from URL: {str(e)}")
 
 def validate_and_get_file(uploaded_file, url_string, file_type, temp_dir):
-    """
-    Validate that only one input method is used and return the file path.
-
-    Args:
-        uploaded_file: Uploaded file object (or None)
-        url_string: URL string (or empty)
-        file_type: Type of file (for naming downloaded files)
-        temp_dir: Temporary directory to store downloaded files
-        
-    Returns:
-        tuple: (file_path, error_message)
-    """
+    """Validate that only one input method is used and return the file path."""
     has_upload = uploaded_file is not None
     has_url = url_string and url_string.strip()
 
-    # Validation: Must have exactly one input method
     if not has_upload and not has_url:
         return None, f"❌ Please provide {file_type} either by upload or URL"
 
     if has_upload and has_url:
         return None, f"❌ Please use only ONE method for {file_type}: either upload OR URL (not both)"
 
-    # Handle uploaded file
     if has_upload:
         file_path = uploaded_file.name if hasattr(uploaded_file, 'name') else uploaded_file
         return file_path, None
 
-    # Handle URL download
     if has_url:
         try:
-            # Get file extension from URL or use default
             url_parts = url_string.strip().split('/')
             original_filename = url_parts[-1] if url_parts else f"{file_type}_file"
             
-            # Add extension if missing
             if '.' not in original_filename:
-                ext_map = {
-                    'video': '.mp4',
-                    'audio': '.wav',
-                    'subtitle': '.srt'
-                }
+                ext_map = {'video': '.mp4', 'audio': '.wav', 'subtitle': '.srt'}
                 original_filename += ext_map.get(file_type, '.tmp')
             
             timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
@@ -80,15 +60,158 @@ def validate_and_get_file(uploaded_file, url_string, file_type, temp_dir):
 
     return None, f"❌ Unknown error processing {file_type}"
 
+def srt_time_to_ms(time_str):
+    """Convert SRT timestamp to milliseconds."""
+    time_str = time_str.strip()
+    hours, minutes, seconds = time_str.split(':')
+    seconds, milliseconds = seconds.split(',')
+
+    total_ms = (
+        int(hours) * 3600000 +
+        int(minutes) * 60000 +
+        int(seconds) * 1000 +
+        int(milliseconds)
+    )
+    return total_ms
+
+def ms_to_ass_time(ms):
+    """Convert milliseconds to ASS timestamp format."""
+    hours = ms // 3600000
+    ms %= 3600000
+    minutes = ms // 60000
+    ms %= 60000
+    seconds = ms // 1000
+    centiseconds = (ms % 1000) // 10
+
+    return f"{hours}:{minutes:02d}:{seconds:02d}.{centiseconds:02d}"
+
+def create_word_by_word_highlight_ass(srt_path, output_dir, highlight_color='yellow'):
+    """
+    Convert SRT to ASS with word-by-word highlighting.
+    Uses NON-OVERLAPPING time windows to ensure only one word is highlighted at a time.
+
+    Example:
+    Text: "How are you?" (duration 1.5s)
+
+    Event 1: 0.000s - 0.500s → [How] are you?     (only "How" highlighted)
+    Event 2: 0.500s - 1.000s → How [are] you?     (only "are" highlighted)
+    Event 3: 1.000s - 1.500s → How are [you?]     (only "you?" highlighted)
+
+    NO OVERLAP = Clean highlighting!
+    """
+
+    # Color mapping for highlight background (ASS format: AABBGGRR)
+    color_map = {
+        'yellow': ('&H0000FFFF', '&H00000000'),    # Yellow bg, black text
+        'orange': ('&H0000A5FF', '&H00000000'),    # Orange bg, black text
+        'green': ('&H0000FF00', '&H00000000'),     # Green bg, black text
+        'cyan': ('&H00FFFF00', '&H00000000'),      # Cyan bg, black text
+        'pink': ('&H00FF69B4', '&H00000000'),      # Pink bg, black text
+        'red': ('&H000000FF', '&H00FFFFFF'),       # Red bg, white text
+        'blue': ('&H00FF0000', '&H00FFFFFF'),      # Blue bg, white text
+    }
+
+    highlight_bg, highlight_text = color_map.get(highlight_color.lower(), ('&H0000FFFF', '&H00000000'))
+
+    # Read SRT file
+    with open(srt_path, 'r', encoding='utf-8') as f:
+        srt_content = f.read()
+
+    # ASS file path
+    ass_path = os.path.join(output_dir, 'word_highlight_subtitles.ass')
+
+    # ASS header with styles
+    ass_header = f"""[Script Info]
+    Title: Word-by-Word Highlight Subtitles
+    ScriptType: v4.00+
+    Collisions: Normal
+    PlayDepth: 0
+
+    [V4+ Styles]
+    Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
+    Style: Default,Arial,28,&H00FFFFFF,&H00FFFFFF,&H00000000,&H80000000,0,0,0,0,100,100,0,0,1,2,1,2,30,30,40,1
+
+    [Events]
+    Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
+    """
+
+    # Parse SRT blocks
+    srt_blocks = re.split(r'\n\s*\n', srt_content.strip())
+    ass_events = []
+
+    for block in srt_blocks:
+        lines = block.strip().split('\n')
+        if len(lines) >= 3:
+            # Parse timestamp
+            timestamp_line = lines[1]
+            times = timestamp_line.split(' --> ')
+            if len(times) == 2:
+                start_ms = srt_time_to_ms(times[0])
+                end_ms = srt_time_to_ms(times[1])
+                
+                # Get subtitle text
+                text = ' '.join(lines[2:])
+                
+                # Split text into words
+                words = text.split()
+                
+                if not words:
+                    continue
+                
+                # Calculate time per word with precise boundaries
+                total_duration = end_ms - start_ms
+                time_per_word = total_duration / len(words)
+                
+                # Create NON-OVERLAPPING events for each word
+                for i, word in enumerate(words):
+                    # Calculate precise, non-overlapping time boundaries
+                    word_start_ms = start_ms + int(i * time_per_word)
+                    word_end_ms = start_ms + int((i + 1) * time_per_word)
+                    
+                    # Ensure last word ends exactly at subtitle end time
+                    if i == len(words) - 1:
+                        word_end_ms = end_ms
+                    
+                    # Build the full text with inline color override for current word
+                    text_parts = []
+                    for j, w in enumerate(words):
+                        if j == i:
+                            # Current word: Apply highlight with inline override tags
+                            # {\3c} = outline color (used as background in BorderStyle 3)
+                            # {\c} = primary color (text color)
+                            text_parts.append(f"{{\\c{highlight_text}\\3c{highlight_bg}\\bord5}}{w}{{\\r}}")
+                        else:
+                            # Other words: Normal style
+                            text_parts.append(w)
+                    
+                    styled_text = ' '.join(text_parts)
+                    
+                    # Convert times to ASS format
+                    start_time = ms_to_ass_time(word_start_ms)
+                    end_time = ms_to_ass_time(word_end_ms)
+                    
+                    # Create ASS dialogue line with strict timing
+                    ass_line = f"Dialogue: 0,{start_time},{end_time},Default,,0,0,0,,{styled_text}"
+                    ass_events.append(ass_line)
+
+    # Write ASS file
+    with open(ass_path, 'w', encoding='utf-8') as f:
+        f.write(ass_header)
+        f.write('\n'.join(ass_events))
+
+    return ass_path
+
 def stitch_media(
-video_file, video_url,
-audio_file, audio_url,
-subtitle_file, subtitle_url,
-crf_quality=23
-):
+    video_file, video_url,
+    audio_file, audio_url,
+    subtitle_file, subtitle_url,
+    enable_highlight,
+    highlight_color,
+    crf_quality=23
+    ):
     """
     Stitch video, audio, and subtitle files together using ffmpeg.
-    Files can be uploaded or fetched from URLs.
+    Optionally applies word-by-word highlighting with non-overlapping timing.
     """
     temp_dir = tempfile.mkdtemp()
 
@@ -123,6 +246,18 @@ crf_quality=23
         status_msg += f"  • Video: {'Downloaded from URL' if video_url else 'Uploaded file'}\n"
         status_msg += f"  • Audio: {'Downloaded from URL' if audio_url else 'Uploaded file'}\n"
         status_msg += f"  • Subtitle: {'Downloaded from URL' if subtitle_url else 'Uploaded file'}\n"
+        
+        # Process subtitles with word highlighting if enabled
+        if enable_highlight:
+            status_msg += f"\n✨ Creating word-by-word highlights ({highlight_color})...\n"
+            status_msg += "⏱️ Using non-overlapping timing for clean highlighting...\n"
+            subtitle_to_use = create_word_by_word_highlight_ass(subtitle_path, temp_dir, highlight_color)
+            subtitle_filter = f"ass={subtitle_to_use.replace(':', '\\:').replace('\\\\', '/').replace('\\', '/')}"
+        else:
+            status_msg += "\n📝 Using standard subtitles...\n"
+            subtitle_to_use = subtitle_path
+            subtitle_filter = f"subtitles={subtitle_to_use.replace(':', '\\:')}"
+        
         status_msg += "\n🎬 Stitching video..."
         
         # FFmpeg command
@@ -130,7 +265,7 @@ crf_quality=23
             "ffmpeg",
             "-i", video_path,
             "-i", audio_path,
-            "-vf", f"subtitles={subtitle_path}",
+            "-vf", subtitle_filter,
             "-map", "0:v",
             "-map", "1:a",
             "-c:v", "libx264",
@@ -150,11 +285,14 @@ crf_quality=23
         
         # Check if output file was created
         if os.path.exists(output_path):
-            file_size = os.path.getsize(output_path) / (1024 * 1024)  # Size in MB
+            file_size = os.path.getsize(output_path) / (1024 * 1024)
             success_msg = f"✅ Video stitched successfully!\n\n"
             success_msg += f"📊 Output size: {file_size:.2f} MB\n"
             success_msg += f"🎨 Quality: CRF {crf_quality}\n"
-            success_msg += status_msg.split("🎬")[0]  # Include source info
+            if enable_highlight:
+                success_msg += f"✨ Word-by-word highlighting: {highlight_color}\n"
+                success_msg += f"⏱️ Non-overlapping timing: Clean highlights!\n"
+            success_msg += "\n" + status_msg.split("🎬")[0]
             return output_path, success_msg
         else:
             return None, "❌ Output file was not created"
@@ -165,13 +303,15 @@ crf_quality=23
     except Exception as e:
         return None, f"❌ Error: {str(e)}"
 
-# Create Gradio interface
-with gr.Blocks(title="Video Audio Subtitle Stitcher", theme=gr.themes.Soft()) as app:
+    # Create Gradio interface
+with gr.Blocks(title="Video Stitcher - Word Highlighting", theme=gr.themes.Soft()) as app:
     gr.Markdown(
         """
-        # 🎬 Video Audio Subtitle Stitcher
+        # 🎬 Video Audio Subtitle Stitcher with Word-by-Word Highlighting ✨
+        
+        **Precise word-by-word highlighting with non-overlapping timing!**
         
-        **Stitch video, audio, and subtitles together with FFmpeg**
+        Only ONE word is highlighted at a time - clean and professional!
         
         📤 Upload files directly **OR** 🌐 provide URLs to download them
         
@@ -223,7 +363,21 @@ with gr.Blocks(title="Video Audio Subtitle Stitcher", theme=gr.themes.Soft()) as
                     lines=1
                 )
             
-            gr.Markdown("### ⚙️ Settings")
+            gr.Markdown("### ✨ Word Highlighting Settings")
+            with gr.Group():
+                enable_highlight = gr.Checkbox(
+                    label="Enable Word-by-Word Highlighting",
+                    value=True,
+                    info="Only ONE word highlighted at a time (no overlap)"
+                )
+                highlight_color = gr.Dropdown(
+                    choices=['yellow', 'orange', 'green', 'cyan', 'pink', 'red', 'blue'],
+                    value='yellow',
+                    label="Highlight Color",
+                    info="Background color for the active word"
+                )
+            
+            gr.Markdown("### ⚙️ Video Settings")
             crf_input = gr.Slider(
                 minimum=18,
                 maximum=28,
@@ -241,7 +395,7 @@ with gr.Blocks(title="Video Audio Subtitle Stitcher", theme=gr.themes.Soft()) as
             status_output = gr.Textbox(
                 label="Status",
                 placeholder="Provide inputs and click 'Stitch Video' to begin...",
-                lines=8
+                lines=10
             )
             video_output = gr.Video(
                 label="Result Video",
@@ -251,7 +405,6 @@ with gr.Blocks(title="Video Audio Subtitle Stitcher", theme=gr.themes.Soft()) as
             gr.Markdown(
                 """
                 **💾 Download:** Click the download button on the video player
-                or right-click and "Save video as..."
                 """
             )
 
@@ -259,46 +412,78 @@ with gr.Blocks(title="Video Audio Subtitle Stitcher", theme=gr.themes.Soft()) as
         with gr.Column():
             gr.Markdown(
                 """
-                ### 📖 Instructions:
+                ### 📖 How It Works (Non-Overlapping Timing):
+                
+                **Example:** "How are you?" (1.5s duration)
+                
+                ```
+                Event 1: 0.000s - 0.500s → [How] are you?
+                Event 2: 0.500s - 1.000s → How [are] you?
+                Event 3: 1.000s - 1.500s → How are [you?]
+                ```
                 
-                **For each file (video, audio, subtitle):**
-                1. **Either** upload a file from your computer
-                2. **OR** paste a URL to download it
-                3. ⚠️ **Don't use both!** Choose one method per file
+                ✅ **No time overlap** between events  
+                ✅ **Only one event active** at any moment  
+                ✅ **Clean highlighting** - one word at a time  
+                ✅ **Full context** - all words visible  
                 
-                ### 💡 Quality Settings:
-                - **CRF 18-20:** Excellent quality (larger files)
-                - **CRF 23:** Balanced (recommended) ⭐
-                - **CRF 26-28:** Good quality (smaller files)
+                ### 🎨 Available Colors:
+                - 🟡 **Yellow** - Classic (recommended)
+                - 🟠 **Orange** - Warm & visible
+                - 🟢 **Green** - Easy on eyes
+                - 🩵 **Cyan** - Modern
+                - 🩷 **Pink** - Playful
+                - 🔴 **Red** - Bold
+                - 🔵 **Blue** - Professional
                 """
             )
         
         with gr.Column():
             gr.Markdown(
                 """
-                ### 🎯 Example URLs:
-                You can use direct links to files:
-                - Video: `.mp4`, `.mov`, `.avi`, `.mkv`
-                - Audio: `.wav`, `.mp3`, `.aac`, `.m4a`
-                - Subtitle: `.srt`
+                ### 💡 Best For:
+                
+                - 📚 **Tutorial videos** - Emphasize key terms
+                - 🎓 **Educational content** - Focus attention
+                - 🌍 **Language learning** - Word-by-word reading
+                - 📱 **Social media** - Engaging captions
+                - 🎤 **Presentations** - Highlight key points
                 
                 ### 🔧 Technical Details:
-                - **Video codec:** H.264 (libx264)
-                - **Audio codec:** AAC
-                - **Output length:** Matches shortest stream
-                - **Subtitles:** Burned into video
+                
+                **Timing Strategy:**
+                - Calculates duration per word
+                - Creates strict time boundaries
+                - Prevents event overlap
+                - Ensures clean rendering
+                
+                **Implementation:**
+                - Python: SRT → ASS conversion
+                - ASS: Inline color override tags
+                - FFmpeg: libass rendering
+                - Result: Perfect highlighting!
                 """
             )
 
     gr.Markdown(
         """
         ---
-        ### ⚡ Features:
-        ✅ Upload files or fetch from URLs  
-        ✅ Automatic validation (no mixing methods)  
-        ✅ Progress tracking  
-        ✅ Instant preview  
-        ✅ Cloud deployment ready  
+        ### ⚡ Key Features:
+        
+        ✅ **Non-overlapping timing** - No visual conflicts  
+        ✅ **One word at a time** - Clean, professional look  
+        ✅ **Full subtitle visible** - Context maintained  
+        ✅ **Multiple colors** - 7 highlight options  
+        ✅ **Upload or URL** - Flexible input  
+        ✅ **Automatic timing** - Smart word distribution  
+        
+        ### 🔄 Process Flow:
+        
+        1. **Parse SRT** → Extract text & timing
+        2. **Split words** → Calculate per-word duration
+        3. **Create ASS** → Non-overlapping events
+        4. **FFmpeg render** → Clean word highlighting
+        5. **Output video** → Professional result!
         """
     )
 
@@ -309,11 +494,13 @@ with gr.Blocks(title="Video Audio Subtitle Stitcher", theme=gr.themes.Soft()) as
             video_input, video_url_input,
             audio_input, audio_url_input,
             subtitle_input, subtitle_url_input,
+            enable_highlight,
+            highlight_color,
             crf_input
         ],
         outputs=[video_output, status_output]
     )
 
-# Launch the app
+    # Launch the app
 if __name__ == "__main__":
     app.launch()