Update app.py

app.py

@@ -58,7 +58,7 @@ os.makedirs(TEMP_DIR, exist_ok=True)
 model_load_lock = Lock()
 loaded_detectors = {}
 whisper_model = None
-whisper_model_name = "" # <-- ADD THIS LINE
+whisper_model_name = ""
 
 # --- Default Presets for Transfer Tab (Flat Dictionary) ---
 DEFAULT_LINK_PRESETS = {
@@ -238,14 +238,13 @@ def get_detector(name):
         return loaded_detectors[name]
 
 def load_whisper_model(model_name="base"):
-    global whisper_model, whisper_model_name # <-- Add whisper_model_name here
+    global whisper_model, whisper_model_name
     if whisper:
         with model_load_lock:
-            # The check now uses our own variable instead of the model's property
             if whisper_model is None or whisper_model_name != model_name:
                 print(f"Loading Whisper model '{model_name}'... (This may download files on first run)")
                 whisper_model = whisper.load_model(model_name)
-                whisper_model_name = model_name # <-- Set our variable after loading
+                whisper_model_name = model_name
                 print("Whisper model loaded.")
         return whisper_model
     return None
@@ -267,10 +266,8 @@ def parse_color(color_str):
     if color_str.startswith('rgba'):
         parts = re.findall(r"[\d\.]+", color_str)
         if len(parts) >= 3:
-            # Convert float parts to integers
             return (int(float(parts[0])), int(float(parts[1])), int(float(parts[2])))
             
-    # If it's a hex string or a named color, PIL can handle it directly.
     return color_str
 
 
@@ -600,7 +597,7 @@ def create_zoom_videos(files, duration, zoom_ratio, zoom_direction, combine_vide
         if audio_for_clip:
             cmd.extend(["-i", audio_for_clip, "-c:a", "aac", "-shortest"])
 
-        cmd.extend(["-vf", zoom_filter, "-c:v", "libx264", "-t", str(duration), "-pix_fmt", "yuv420p", "-b:v", "5M", "-y", output_path])
+        cmd.extend(["-vf", zoom_filter, "-c:v", "libx264", "-t", str(duration), "-pix_fmt", "yuv420p", "-b:v", "5M", "-y", output_video_path])
         run_ffmpeg_command(cmd, f"Creating zoom video for {os.path.basename(input_path)}")
 
     batch_kwargs = {}
@@ -794,11 +791,9 @@ def remove_video_background(video_path):
     return output_video_path
 
 def transcribe_media(media_path, model_name):
-    if media_path is None:
-        raise gr.Error("Please upload a video or audio file first.")
+    if media_path is None: raise gr.Error("Please upload a video or audio file first.")
     model = load_whisper_model(model_name)
-    if model is None:
-        raise gr.Error("Whisper model is not available.")
+    if model is None: raise gr.Error("Whisper model is not available.")
     audio_path = media_path.name
     base_name = os.path.splitext(os.path.basename(media_path.name))[0]
     
@@ -808,16 +803,13 @@ def transcribe_media(media_path, model_name):
             run_ffmpeg_command(["ffmpeg", "-i", audio_path, "-q:a", "0", "-map", "a", "-y", audio_path_temp])
             audio_path = audio_path_temp
         except gr.Error as e:
-            if "does not contain any stream" in str(e):
-                raise gr.Error("The uploaded video has no audio track.")
-            else:
-                raise e
+            if "does not contain any stream" in str(e): raise gr.Error("The uploaded video has no audio track.")
+            else: raise e
     
     result = model.transcribe(audio_path, verbose=False) 
     
     def format_ts(s):
-        h, r = divmod(s, 3600)
-        m, s = divmod(r, 60)
+        h, r = divmod(s, 3600); m, s = divmod(r, 60)
         return f"{int(h):02}:{int(m):02}:{int(s):02},{int((s-int(s))*1000):03}"
         
     srt_path = os.path.join(TEMP_DIR, f"{base_name}.srt")
@@ -830,127 +822,95 @@ def transcribe_media(media_path, model_name):
             srt_f.write(f"{i + 1}\n{format_ts(start)} --> {format_ts(end)}\n{text}\n\n")
             vtt_f.write(f"{format_ts(start).replace(',', '.')} --> {format_ts(end).replace(',', '.')}\n{text}\n\n")
             
-    return result["text"], [srt_path, vtt_path], result.get("segments", [])
+    return result["text"], [srt_path, vtt_path]
 
 def transcribe_and_prep_burn(media_file, model_name):
-    if not media_file: 
-        raise gr.Error("Please upload a file first.")
-    
+    if not media_file: raise gr.Error("Please upload a file first.")
     is_video = media_file.name.lower().endswith(('.mp4', '.mov', '.mkv', '.avi', '.webm'))
-    
-    full_text, subtitle_files, segments = transcribe_media(media_file, model_name)
-    
-    df_data = []
-    if segments:
-        for i, seg in enumerate(segments):
-            df_data.append([i+1, f"{seg['start']:.2f}", f"{seg['end']:.2f}", seg['text']])
+    text, files = transcribe_media(media_file, model_name)
+    if is_video: return text, files, media_file.name, gr.update(visible=True)
+    else: return text, files, None, gr.update(visible=False)
 
-    if is_video:
-        return full_text, subtitle_files, media_file.name, segments, df_data, gr.update(visible=True)
-    else:
-        return full_text, subtitle_files, None, segments, df_data, gr.update(visible=False)
+def reformat_srt_for_word_wrap(original_srt_path, words_per_line):
+    """
+    Reads an SRT file and adds line breaks to the text blocks without changing timestamps,
+    then writes the result to a new temporary SRT file.
+    """
+    if not original_srt_path or not os.path.exists(original_srt_path):
+        return None
 
-def burn_subtitles(video_path, srt_file_obj, font_size_scale, font_color):
-    if not video_path: raise gr.Error("Original video path not found. Please re-transcribe.")
-    if not srt_file_obj or not srt_file_obj[0].name: raise gr.Error("SRT file not found. Please re-transcribe.")
-    srt_path = srt_file_obj[0].name 
     timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-    output_video_path = os.path.join(TEMP_DIR, f"subtitled_video_{timestamp}.mp4")
-    _, video_h = get_video_dimensions(video_path)
-    if video_h == 0: video_h = 720
-    divisor = 32 - (font_size_scale * 2) 
-    calculated_font_size = int(video_h / divisor)
-    color_bgr = font_color[5:7] + font_color[3:5] + font_color[1:3]
-    ffmpeg_color = f"&H00{color_bgr.upper()}"
-    escaped_srt_path = srt_path.replace('\\', '/').replace(':', r'\:')
-    vf_filter = f"subtitles='{escaped_srt_path}':force_style='Fontsize={calculated_font_size},PrimaryColour={ffmpeg_color},BorderStyle=1,Outline=1,Shadow=0.5,MarginV=15'"
-    cmd = ["ffmpeg", "-i", video_path, "-vf", vf_filter, "-c:a", "copy", "-c:v", "libx264", "-pix_fmt", "yuv420p", "-y", output_video_path]
-    run_ffmpeg_command(cmd, "Burning subtitles into video...")
-    return output_video_path
-
-def generate_ass_from_df(df_data, font_size_scale, font_color, outline_color, video_h):
-    """Generates an .ass subtitle file content from a DataFrame and style settings."""
-    if video_h == 0: video_h = 720
-    
-    # Calculate font sizes and margins based on video height
-    divisor = 32 - (font_size_scale * 2) 
-    font_size = int(video_h / divisor)
-    outline_width = max(1.0, font_size / 10.0)
-    margin_v = int(video_h * 0.05)
-
-    # Convert hex colors to ASS format (#RRGGBB -> &HBBGGRR)
-    primary_bgr = font_color[5:7] + font_color[3:5] + font_color[1:3]
-    primary_ass_color = f"&H00{primary_bgr.upper()}"
-    
-    outline_bgr = outline_color[5:7] + outline_color[3:5] + outline_color[1:3]
-    outline_ass_color = f"&H00{outline_bgr.upper()}"
-
-    # .ass file header
-    header = f"""[Script Info]
-Title: Generated by Skriptz
-ScriptType: v4.00+
-WrapStyle: 0
-ScaledBorderAndShadow: yes
-YCbCr Matrix: None
-
-[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,{font_size},{primary_ass_color},&H000000FF,{outline_ass_color},&H00000000,0,0,0,0,100,100,0,0,1,{outline_width},1,2,10,10,{margin_v},1
-
-[Events]
-Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
-"""
+    reformatted_path = os.path.join(TEMP_DIR, f"reformatted_{timestamp}.srt")
     
-    # Format each line from the dataframe
-    dialogue_lines = []
-    for _, row in enumerate(df_data):
-        # row format is [index, start_time, end_time, text]
-        start_time_str = str(row[1])
-        end_time_str = str(row[2])
-        text = str(row[3]).replace('\n', '\\N') # Replace newlines with ASS newline character
-
-        # Convert float seconds to H:MM:SS.ss format
-        def format_ass_time(s):
-            s = float(s)
-            h, r = divmod(s, 3600)
-            m, s = divmod(r, 60)
-            return f"{int(h):d}:{int(m):02d}:{s:05.2f}"
-
-        start_formatted = format_ass_time(start_time_str)
-        end_formatted = format_ass_time(end_time_str)
+    with open(original_srt_path, 'r', encoding='utf-8') as f_in, \
+         open(reformatted_path, 'w', encoding='utf-8') as f_out:
         
-        dialogue_lines.append(f"Dialogue: 0,{start_formatted},{end_formatted},Default,,0,0,0,,{text}")
+        content = f_in.read()
+        blocks = content.strip().split('\n\n')
+        
+        for block in blocks:
+            lines = block.split('\n')
+            if len(lines) < 3: # Not a valid block (e.g., just a number and timestamp)
+                f_out.write(block + '\n\n')
+                continue
 
-    return header + "\n".join(dialogue_lines)
+            text_lines = lines[2:]
+            full_text = ' '.join(text_lines)
+            words = full_text.split()
+            
+            new_text_lines = []
+            current_line = []
+            for word in words:
+                current_line.append(word)
+                if len(current_line) >= words_per_line:
+                    new_text_lines.append(' '.join(current_line))
+                    current_line = []
+            
+            if current_line: # Add any remaining words
+                new_text_lines.append(' '.join(current_line))
+                
+            # Reconstruct the block with the new text formatting
+            f_out.write(lines[0] + '\n') # Index
+            f_out.write(lines[1] + '\n') # Timestamp
+            f_out.write('\n'.join(new_text_lines) + '\n\n')
 
-def burn_subtitles_from_df(video_path, df_data, font_size_scale, font_color, outline_color):
-    """Burns subtitles directly from DataFrame data onto the video."""
-    if not video_path: raise gr.Error("Original video path not found. Please re-transcribe.")
-    
-    # Convert DataFrame object to list of lists if it's not already
-    if hasattr(df_data, 'values'):
-        df_data = df_data.values.tolist()
-        
-    if not df_data: raise gr.Error("No subtitle data to burn.")
+    return reformatted_path
 
-    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-    output_video_path = os.path.join(TEMP_DIR, f"subtitled_video_{timestamp}.mp4")
-    ass_path = os.path.join(TEMP_DIR, f"temp_subs_{timestamp}.ass")
+def burn_subtitles(video_path, srt_file_obj, font_size_scale, font_color, words_per_line):
+    if not video_path: raise gr.Error("Original video path not found. Please re-transcribe.")
+    if not srt_file_obj or not srt_file_obj[0].name: raise gr.Error("SRT file not found. Please re-transcribe.")
     
-    _, video_h = get_video_dimensions(video_path)
-    ass_content = generate_ass_from_df(df_data, font_size_scale, font_color, outline_color, video_h)
-
-    with open(ass_path, 'w', encoding='utf-8') as f:
-        f.write(ass_content)
+    original_srt_path = srt_file_obj[0].name
+    reformatted_srt_path = None
     
-    # Use ffmpeg to burn the .ass file
-    escaped_ass_path = ass_path.replace('\\', '/').replace(':', r'\:')
-    vf_filter = f"subtitles='{escaped_ass_path}'"
-    cmd = ["ffmpeg", "-i", video_path, "-vf", vf_filter, "-c:a", "copy", "-c:v", "libx264", "-pix_fmt", "yuv420p", "-y", output_video_path]
-    run_ffmpeg_command(cmd, "Burning subtitles into video...")
-
-    os.remove(ass_path)
-    return output_video_path
+    try:
+        # Reformat the SRT file based on the slider value
+        reformatted_srt_path = reformat_srt_for_word_wrap(original_srt_path, words_per_line)
+        if not reformatted_srt_path:
+            raise gr.Error("Failed to reformat subtitle file.")
+        
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        output_video_path = os.path.join(TEMP_DIR, f"subtitled_video_{timestamp}.mp4")
+        _, video_h = get_video_dimensions(video_path)
+        if video_h == 0: video_h = 720
+        divisor = 32 - (font_size_scale * 2) 
+        calculated_font_size = int(video_h / divisor)
+        color_bgr = font_color[5:7] + font_color[3:5] + font_color[1:3]
+        ffmpeg_color = f"&H00{color_bgr.upper()}"
+        
+        # Use the new, reformatted path and escape it for FFMPEG
+        escaped_srt_path = reformatted_srt_path.replace('\\', '/').replace(':', r'\:')
+        
+        vf_filter = f"subtitles='{escaped_srt_path}':force_style='Fontsize={calculated_font_size},PrimaryColour={ffmpeg_color},BorderStyle=1,Outline=1,Shadow=0.5,MarginV=15'"
+        cmd = ["ffmpeg", "-i", video_path, "-vf", vf_filter, "-c:a", "copy", "-c:v", "libx264", "-pix_fmt", "yuv420p", "-y", output_video_path]
+        run_ffmpeg_command(cmd, "Burning subtitles into video...")
+        
+        return output_video_path
+        
+    finally:
+        # Clean up the temporary reformatted file
+        if reformatted_srt_path and os.path.exists(reformatted_srt_path):
+            os.remove(reformatted_srt_path)
 
 def remove_background_single(input_path, output_path, **kwargs):
     with Image.open(input_path) as img:
@@ -1096,18 +1056,16 @@ def preview_color_grading_ffmpeg(image_np, brightness, contrast, saturation, sha
         
         subprocess.run(cmd, capture_output=True, text=True, check=False)
 
-        # FIX: Use a 'with' statement to properly open and close the file handle, preventing file lock errors on Windows.
         if os.path.exists(output_path):
             with Image.open(output_path) as img:
-                return img.copy()  # Load into memory and return a copy
+                return img.copy()
         else:
-            return Image.fromarray(image_np) # Fallback
+            return Image.fromarray(image_np)
 
     except Exception as e:
         print(f"Error in FFMPEG preview: {e}")
         return Image.fromarray(image_np)
     finally:
-        # This will now execute after the file handle from Image.open() is closed.
         if os.path.exists(input_path): os.remove(input_path)
         if os.path.exists(output_path): os.remove(output_path)
 
@@ -1396,6 +1354,7 @@ def auto_jump_cut(video_path, silence_threshold, min_silence_duration, resolutio
     
     return output_video_path
 
+
 # --- STORYBOARD / ANIMATIC CREATOR FUNCTIONS ---
 
 def get_file_type(file_path):
@@ -1625,7 +1584,7 @@ def set_resolution_from_first_asset(timeline_state):
         gr.Warning(f"Could not get dimensions for the first asset: '{first_item['name']}'.")
         return gr.update(), gr.update()
 
-def create_animatic(timeline_data, audio_path, out_w, out_h):
+def create_animatic(timeline_data, audio_path, out_w, out_h, keep_original_audio):
     if not timeline_data:
         raise gr.Error("Timeline is empty. Please add assets to the timeline.")
     
@@ -1645,25 +1604,48 @@ def create_animatic(timeline_data, audio_path, out_w, out_h):
     for i, item in enumerate(timeline_data):
         item_path, item_type, item_duration = item['path'], item['type'], item['duration']
         output_clip_path = os.path.join(job_temp_dir, f"clip_{i:04d}.mp4")
-        vf_filter = f"scale={output_res_str}:force_original_aspect_ratio=decrease,pad={output_res_str}:(ow-iw)/2:(oh-ih)/2"
+        vf_filter = f"scale={output_res_str}:force_original_aspect_ratio=decrease,pad={output_res_str}:(ow-iw)/2:(oh-ih)/2,setsar=1"
 
         cmd = ["ffmpeg"]
-        if item_type == "image":
-            cmd.extend(["-loop", "1"])
-        elif item_type == "video":
+        
+        # --- Input Handling ---
+        # For images, we might need a silent audio source for concat to work
+        if item_type == "image" and keep_original_audio:
+            cmd.extend(["-f", "lavfi", "-i", "anullsrc=channel_layout=stereo:sample_rate=44100"])
+        
+        # For videos, handle the start time trim
+        if item_type == "video":
             start_time = item.get('start_time', 0)
             if start_time > 0:
                 cmd.extend(["-ss", str(start_time)])
         
         cmd.extend(["-i", item_path])
         
-        cmd.extend([
-            "-t", str(item_duration), "-c:v", "libx264",
-            "-pix_fmt", "yuv420p", "-vf", vf_filter,
-            "-an", "-y", output_clip_path
-        ])
+        # --- Output Options ---
+        output_options = [
+            "-t", str(item_duration),
+            "-c:v", "libx264",
+            "-pix_fmt", "yuv420p",
+            "-vf", vf_filter
+        ]
+        
+        # --- CORRECTED AUDIO LOGIC ---
+        if keep_original_audio:
+            # If it's an image, map the silent audio source we added.
+            if item_type == "image":
+                 cmd.extend(["-c:v", "libx264", "-t", str(item_duration), "-pix_fmt", "yuv420p", "-vf", vf_filter])
+                 output_options = ["-shortest", "-c:a", "aac"]
+            # For videos, just re-encode the existing audio to a standard format.
+            else:
+                 output_options.extend(["-c:a", "aac"])
+        else:
+            # If we don't keep audio, make the clip silent.
+            output_options.append("-an")
+
+        cmd.extend(output_options)
+        cmd.extend(["-y", output_clip_path])
         
-        run_ffmpeg_command(cmd, f"Processing clip {i+1}")
+        run_ffmpeg_command(cmd, f"Processing clip {i+1}/{len(timeline_data)}")
         clip_paths.append(output_clip_path)
 
     file_list_path = os.path.join(job_temp_dir, "files.txt")
@@ -1671,18 +1653,22 @@ def create_animatic(timeline_data, audio_path, out_w, out_h):
         for path in clip_paths:
             f.write(f"file '{os.path.abspath(path)}'\n")
     
-    silent_animatic_path = os.path.join(job_temp_dir, "silent_final.mp4")
-    run_ffmpeg_command(["ffmpeg", "-f", "concat", "-safe", "0", "-i", file_list_path, "-c", "copy", "-y", silent_animatic_path], "Joining video clips")
+    # This path now contains the final video, either silent or with original audio
+    combined_video_path = os.path.join(job_temp_dir, "combined_video.mp4")
+    run_ffmpeg_command(["ffmpeg", "-f", "concat", "-safe", "0", "-i", file_list_path, "-c", "copy", "-y", combined_video_path], "Joining clips...")
 
     final_output_path = os.path.join(TEMP_DIR, f"animatic_final_{timestamp}.mp4")
-    if audio_path:
-        run_ffmpeg_command(["ffmpeg", "-i", silent_animatic_path, "-i", audio_path, "-c:v", "copy", "-c:a", "aac", "-shortest", "-y", final_output_path], "Muxing audio")
+    
+    # Decide what to do with the audio
+    if not keep_original_audio and audio_path:
+        # Mux the project audio track onto the silent video
+        run_ffmpeg_command(["ffmpeg", "-i", combined_video_path, "-i", audio_path, "-c:v", "copy", "-c:a", "aac", "-shortest", "-y", final_output_path], "Muxing audio")
     else:
-        shutil.move(silent_animatic_path, final_output_path)
+        # Either we kept original audio, or there's no project audio, so just use the combined video as-is
+        shutil.move(combined_video_path, final_output_path)
         
     shutil.rmtree(job_temp_dir)
     return final_output_path
-
 def detect_bpm(audio_path):
     if not audio_path:
         return "Please upload an audio track first."
@@ -1740,7 +1726,8 @@ def create_rhythmic_animatic(timeline_data, audio_path, measure_choice, out_w, o
         
     gr.Info(f"Re-timed {len(rhythmic_timeline)} clips to ~{clip_duration:.2f}s each based on {tempo:.2f} BPM.")
     
-    return create_animatic(rhythmic_timeline, audio_path, out_w, out_h)
+    # The rhythmic animatic will always use the project audio, so keep_original_audio is False
+    return create_animatic(rhythmic_timeline, audio_path, out_w, out_h, keep_original_audio=False)
 
 # --- NEW CREATIVE FUNCTIONS ---
 
@@ -2632,6 +2619,7 @@ with gr.Blocks(
                             clear_timeline_btn = gr.Button("💥 Clear Timeline")
                         
                         gr.Markdown("### 3. Output Settings")
+                        keep_audio_checkbox = gr.Checkbox(label="Keep Original Audio from Video Clips", value=False, info="If checked, the Project Audio Track below will be ignored.")
                         animatic_audio = gr.Audio(label="Project Audio Track (Narration/Music)", type="filepath")
                         with gr.Row():
                             animatic_out_w = gr.Number(label="Output Width", value=1920)
@@ -2650,13 +2638,13 @@ with gr.Blocks(
                             )
                             generate_rhythmic_btn = gr.Button("🎶 Generate Rhythmic Animatic", variant="primary")
                         
-                        animatic_output_video = gr.Video(label="Final Video Output", interactive=True, show_download_button=True)
+                        animatic_output_video = gr.Video(label="Final Video Output", interactive=True, show_download_button=True, height=480)
                     
                 with gr.Column(scale=2, min_width=300):
                     with gr.Group():
                         gr.Markdown("### 4. Clip Properties")
                         gr.Info("Select a clip in the timeline table to edit it.")
-                        clip_preview = gr.Video(label="Selected Clip Preview", interactive=True, elem_id="storyboard_clip_preview")
+                        clip_preview = gr.Video(label="Selected Clip Preview", interactive=True, elem_id="storyboard_clip_preview", height=480)
                         clip_duration_input = gr.Number(label="Set Duration (seconds)", interactive=True, precision=2)
                         update_clip_btn = gr.Button("🔄 Update Clip Duration")
 
@@ -2700,7 +2688,9 @@ with gr.Blocks(
             clear_assets_btn.click(lambda: ([], gr.update(value=None), None), outputs=[assets_state, asset_gallery, asset_preview_gallery])
             clear_timeline_btn.click(lambda: [], outputs=[timeline_state])
 
-            generate_animatic_btn.click(fn=create_animatic, inputs=[timeline_state, animatic_audio, animatic_out_w, animatic_out_h], outputs=animatic_output_video).then(fn=None, js=fire_confetti_and_sound_js)
+            keep_audio_checkbox.change(fn=lambda x: gr.update(interactive=not x), inputs=keep_audio_checkbox, outputs=animatic_audio)
+
+            generate_animatic_btn.click(fn=create_animatic, inputs=[timeline_state, animatic_audio, animatic_out_w, animatic_out_h, keep_audio_checkbox], outputs=animatic_output_video).then(fn=None, js=fire_confetti_and_sound_js)
             
             analyze_bpm_btn.click(detect_bpm, animatic_audio, bpm_display)
             
@@ -2729,7 +2719,7 @@ with gr.Blocks(
                             
                             slideshow_generate_btn = gr.Button("🚀 Generate Slideshow", variant="primary")
                         with gr.Column(scale=3):
-                            slideshow_output_video = gr.Video(label="Generated Slideshow Video", show_download_button=True)
+                            slideshow_output_video = gr.Video(label="Generated Slideshow Video", show_download_button=True, height=480)
 
                     slideshow_generate_btn.click(
                         fn=slideshow_wrapper,
@@ -2742,7 +2732,7 @@ with gr.Blocks(
                     gr.Info("Automatically cuts a source video to the beat of a music track, creating a dynamic music video.")
                     with gr.Row():
                         with gr.Column(scale=2):
-                            remix_input_video = gr.Video(label="Upload Source Video")
+                            remix_input_video = gr.Video(label="Upload Source Video", height=480)
                             remix_audio = gr.Audio(label="Upload Music Track", type="filepath")
                             
                             with gr.Accordion("⚙️ Remix Settings", open=True):
@@ -2768,7 +2758,7 @@ with gr.Blocks(
                             
                             remix_generate_btn = gr.Button("🎤 Generate Music Video", variant="primary")
                         with gr.Column(scale=3):
-                            remix_output_video = gr.Video(label="Generated Music Video", show_download_button=True)
+                            remix_output_video = gr.Video(label="Generated Music Video", show_download_button=True, height=480)
                     
                     remix_resolution.change(
                         fn=lambda choice: gr.update(visible=(choice == "Custom")),
@@ -2787,7 +2777,7 @@ with gr.Blocks(
                     gr.Info("Upload a long video, and this tool will find the most action-packed moments to create a short, dynamic trailer.")
                     with gr.Row():
                         with gr.Column(scale=2):
-                            trailer_input_video = gr.Video(label="Upload Source Video")
+                            trailer_input_video = gr.Video(label="Upload Source Video", height=480)
                             trailer_music = gr.Audio(label="Add Background Music (Optional)", type="filepath")
                             
                             with gr.Accordion("⚙️ Trailer Settings", open=True):
@@ -2802,7 +2792,7 @@ with gr.Blocks(
                             
                             trailer_generate_btn = gr.Button("🚀 Generate Trailer", variant="primary")
                         with gr.Column(scale=3):
-                            trailer_output_video = gr.Video(label="Generated Trailer Video", show_download_button=True)
+                            trailer_output_video = gr.Video(label="Generated Trailer Video", show_download_button=True, height=480)
 
                     trailer_generate_btn.click(
                         fn=auto_trailer_wrapper,
@@ -2819,7 +2809,7 @@ with gr.Blocks(
                     gr.Info("Upload a video with an audio track to generate a dynamic waveform visualization.")
                     with gr.Row():
                         with gr.Column():
-                            waveform_input_video = gr.Video(label="Input Video")
+                            waveform_input_video = gr.Video(label="Input Video", height=480)
                             with gr.Row():
                                 waveform_style = gr.Dropdown(["line", "p2p", "point"], value="line", label="Waveform Style")
                                 waveform_size = gr.Textbox(value="800x200", label="Size (WxH)")
@@ -2828,7 +2818,7 @@ with gr.Blocks(
                                 waveform_color = gr.ColorPicker(value="#38bdf8", label="Color")
                             waveform_btn = gr.Button("🎶 Generate Waveform Video", variant="primary")
                         with gr.Column():
-                            waveform_output_video = gr.Video(label="Output Video with Waveform", show_download_button=True)
+                            waveform_output_video = gr.Video(label="Output Video with Waveform", show_download_button=True, height=480)
                     waveform_btn.click(
                         fn=generate_waveform_video,
                         inputs=[waveform_input_video, waveform_style, waveform_size, waveform_position, waveform_color],
@@ -2840,7 +2830,7 @@ with gr.Blocks(
                     gr.Info("Upload a main video and an overlay (video or image). The overlay will be placed on top of the main video.")
                     with gr.Row():
                         with gr.Column():
-                            pip_main_video = gr.Video(label="Main Video (Background)")
+                            pip_main_video = gr.Video(label="Main Video (Background)", height=480)
                             pip_overlay_media = gr.File(label="Overlay Media (Video or Image)", file_types=["video", "image"])
                             with gr.Row():
                                 pip_position = gr.Dropdown(
@@ -2850,7 +2840,7 @@ with gr.Blocks(
                                 pip_scale = gr.Slider(0.01, 0.75, 0.25, step=0.01, label="Overlay Size")
                             pip_btn = gr.Button("✨ Create PiP Video", variant="primary")
                         with gr.Column():
-                            pip_output_video = gr.Video(label="Output PiP Video", show_download_button=True)
+                            pip_output_video = gr.Video(label="Output PiP Video", show_download_button=True, height=480)
                     pip_btn.click(
                         fn=create_pip_video,
                         inputs=[pip_main_video, pip_overlay_media, pip_position, pip_scale],
@@ -2909,7 +2899,7 @@ with gr.Blocks(
                             input_audio_i2v = gr.Audio(label="Add Music (Optional)", type="filepath")
                             compile_i2v_btn = gr.Button("🎬 Create Looping Video", variant="primary")
                         with gr.Column():
-                            output_video_i2v = gr.Video(label="Output Looping Video", interactive=True, show_download_button=True)
+                            output_video_i2v = gr.Video(label="Output Looping Video", interactive=True, show_download_button=True, height=480)
                     compile_i2v_btn.click(image_to_looping_video, [input_image_i2v, duration_slider_i2v, input_audio_i2v], output_video_i2v).then(fn=None, js=fire_confetti_and_sound_js)
                 
                 with gr.TabItem("🔎 Zoom Video"):
@@ -2929,7 +2919,7 @@ with gr.Blocks(
                             i2zv_btn = gr.Button("✨ Create Zoom Video(s)", variant="primary")
                         with gr.Column():
                             i2zv_output_gallery = gr.Gallery(label="Output Video Previews", columns=2, object_fit="contain", visible=True)
-                            i2zv_output_video = gr.Video(label="Combined Output Video", interactive=True, visible=False, show_download_button=True)
+                            i2zv_output_video = gr.Video(label="Combined Output Video", interactive=True, visible=False, show_download_button=True, height=480)
                             i2zv_output_zip = gr.File(label="Download All as .zip", interactive=False)
                     
                     i2zv_combine.change(
@@ -3019,7 +3009,7 @@ with gr.Blocks(
                             gr.Markdown("### Extract the very first and very last frames of a video.")
                             with gr.Row():
                                 with gr.Column():
-                                    input_video_fl = gr.Video(label="Input Video")
+                                    input_video_fl = gr.Video(label="Input Video", height=480)
                                     extract_fl_btn = gr.Button("🎬 Extract Frames", variant="primary")
                                 with gr.Column():
                                     output_gallery_fl = gr.Gallery(label="Output Frames (First, Last)", columns=2, object_fit="contain", height="auto")
@@ -3029,7 +3019,7 @@ with gr.Blocks(
                             gr.Markdown("### Extract all individual frames from a video file.")
                             with gr.Row():
                                 with gr.Column():
-                                    input_video_v2f = gr.Video(label="Input Video")
+                                    input_video_v2f = gr.Video(label="Input Video", height=480)
                                     v2f_fps_display = gr.Textbox(label="Detected FPS", interactive=False, value="N/A")
                                     with gr.Accordion("⚙️ Advanced Options", open=False):
                                         v2f_skip_rate = gr.Slider(1, 30, 1, step=1, label="Extract Every Nth Frame")
@@ -3063,7 +3053,7 @@ with gr.Blocks(
                                             f2v_height = gr.Number(label="Output Height", value=576, interactive=False)
                                     compile_f2v_btn = gr.Button("📽️ Create Video", variant="primary")
                                 with gr.Column():
-                                    output_video_f2v = gr.Video(label="Compiled Video", interactive=True, show_download_button=True)
+                                    output_video_f2v = gr.Video(label="Compiled Video", interactive=True, show_download_button=True, height=480)
                             f2v_resize.change(lambda x: [gr.update(interactive=x), gr.update(interactive=x)], f2v_resize, [f2v_width, f2v_height])
                             compile_f2v_btn.click(create_video_from_frames, [input_frames_f2v, fps_slider_f2v, f2v_rotation, f2v_resize, f2v_width, f2v_height], output_video_f2v).then(fn=None, js=fire_confetti_and_sound_js)
                 
@@ -3074,7 +3064,7 @@ with gr.Blocks(
                             gr.Info("1. Upload a video. A waveform will appear. 2. Adjust the 'Silence Threshold' slider so it's above the thin 'noise floor' line but below your voice peaks. 3. Process the video!")
                             with gr.Row():
                                 with gr.Column(scale=2):
-                                    jumpcut_input_video = gr.Video(label="Input Video (with audio)")
+                                    jumpcut_input_video = gr.Video(label="Input Video (with audio)", height=480)
                                     jc_waveform_preview = gr.Image(label="Audio Waveform Preview", interactive=False)
                                     with gr.Accordion("⚙️ Cut Settings", open=True):
                                         jumpcut_threshold = gr.Slider(minimum=-60, maximum=-20, value=-30, step=1, label="Silence Threshold (dB)", info="Anything quieter than this is 'silence'. Lower values are more strict.")
@@ -3089,7 +3079,7 @@ with gr.Blocks(
                                             jc_custom_h = gr.Number(label="Custom Height", value=1080)
                                     jumpcut_btn = gr.Button("🔪 Perform Jump-Cut", variant="primary")
                                 with gr.Column(scale=3):
-                                    jumpcut_output_video = gr.Video(label="Edited Video Output", show_download_button=True)
+                                    jumpcut_output_video = gr.Video(label="Edited Video Output", show_download_button=True, height=480)
                             
                             jumpcut_input_video.upload(fn=generate_waveform_preview, inputs=jumpcut_input_video, outputs=jc_waveform_preview)
                             
@@ -3110,14 +3100,14 @@ with gr.Blocks(
                             gr.Info("Apply a single transformation like inverting colors, flipping, or rotating to every frame of a video.")
                             with gr.Row():
                                 with gr.Column():
-                                    vmanip_input_video = gr.Video(label="Input Video")
+                                    vmanip_input_video = gr.Video(label="Input Video", height=480)
                                     vmanip_operation_radio = gr.Radio(
                                         ["Invert Colors", "Flip Horizontal", "Flip Vertical", "Rotate 90° Right", "Rotate 90° Left"],
                                         label="Select Operation", value="Invert Colors"
                                     )
                                     vmanip_apply_btn = gr.Button("✨ Apply Manipulation", variant="primary")
                                 with gr.Column():
-                                    vmanip_output_video = gr.Video(label="Output Video", interactive=True, show_download_button=True)
+                                    vmanip_output_video = gr.Video(label="Output Video", interactive=True, show_download_button=True, height=480)
                             
                             vmanip_apply_btn.click(fn=manipulate_video, inputs=[vmanip_input_video, vmanip_operation_radio], outputs=vmanip_output_video).then(fn=None, js=fire_confetti_and_sound_js)
                         
@@ -3125,22 +3115,22 @@ with gr.Blocks(
                             gr.Markdown("### Create a forward-then-reverse video loop (Boomerang).")
                             with gr.Row():
                                 with gr.Column():
-                                    input_video_pingpong = gr.Video(label="Input Video")
+                                    input_video_pingpong = gr.Video(label="Input Video", height=480)
                                     audio_option_pingpong = gr.Radio(["Remove Audio", "Original Audio Only", "Reverse Audio"], value="Remove Audio", label="Audio Handling")
                                     pingpong_btn = gr.Button("🏓 Create Ping-Pong Video", variant="primary")
                                 with gr.Column():
-                                    output_video_pingpong = gr.Video(label="Ping-Pong Video", interactive=True, show_download_button=True)
+                                    output_video_pingpong = gr.Video(label="Ping-Pong Video", interactive=True, show_download_button=True, height=480)
                             pingpong_btn.click(fn=ping_pong_video, inputs=[input_video_pingpong, audio_option_pingpong], outputs=output_video_pingpong).then(fn=None, js=fire_confetti_and_sound_js)
                         
                         with gr.TabItem("Reverse"):
                             gr.Markdown("### Reverse a video clip.")
                             with gr.Row():
                                 with gr.Column():
-                                    input_video_reverse = gr.Video(label="Input Video")
+                                    input_video_reverse = gr.Video(label="Input Video", height=480)
                                     audio_option_reverse = gr.Radio(["Remove Audio", "Reverse Audio"], value="Remove Audio", label="Audio Handling")
                                     reverse_btn = gr.Button("🔄 Reverse Video", variant="primary")
                                 with gr.Column():
-                                    output_video_reverse = gr.Video(label="Reversed Video", interactive=True, show_download_button=True)
+                                    output_video_reverse = gr.Video(label="Reversed Video", interactive=True, show_download_button=True, height=480)
                             reverse_btn.click(fn=reverse_video, inputs=[input_video_reverse, audio_option_reverse], outputs=output_video_reverse).then(fn=None, js=fire_confetti_and_sound_js)
                         
                         with gr.TabItem("Merger"):
@@ -3151,7 +3141,7 @@ with gr.Blocks(
                                     merger_input_videos = gr.File(label="Upload Videos (2 or more)", file_count="multiple", file_types=["video"])
                                     merger_btn = gr.Button("🔗 Merge Videos", variant="primary")
                                 with gr.Column():
-                                    merger_output_video = gr.Video(label="Merged Video", show_download_button=True)
+                                    merger_output_video = gr.Video(label="Merged Video", show_download_button=True, height=480)
                             merger_btn.click(
                                 fn=merge_videos,
                                 inputs=merger_input_videos,
@@ -3163,12 +3153,12 @@ with gr.Blocks(
                             gr.Info("This tool uses a two-pass process to analyze and stabilize shaky videos. Higher 'Shakiness' values are for very unstable footage. Higher 'Smoothing' creates a more fluid, gliding look but can introduce slight cropping/warping.")
                             with gr.Row():
                                 with gr.Column():
-                                    stab_input_video = gr.Video(label="Input Shaky Video")
+                                    stab_input_video = gr.Video(label="Input Shaky Video", height=480)
                                     stab_shakiness = gr.Slider(minimum=1, maximum=10, value=5, step=1, label="Shakiness Level", info="How shaky is the source video? (1=low, 10=high)")
                                     stab_smoothing = gr.Slider(minimum=1, maximum=50, value=10, step=1, label="Smoothing Amount", info="How much smoothing to apply. (More = smoother but might feel 'floaty')")
                                     stab_btn = gr.Button("✨ Stabilize Video", variant="primary")
                                 with gr.Column():
-                                    stab_output_video = gr.Video(label="Stabilized Output Video", show_download_button=True)
+                                    stab_output_video = gr.Video(label="Stabilized Output Video", show_download_button=True, height=480)
                             stab_btn.click(
                                 fn=stabilize_video,
                                 inputs=[stab_input_video, stab_shakiness, stab_smoothing],
@@ -3180,7 +3170,7 @@ with gr.Blocks(
                             gr.Info("Keyboard hotkeys enabled: K = Play/Pause, J = Back 1 Frame, L = Forward 1 Frame (hover mouse over video)")
                             with gr.Row():
                                 with gr.Column(scale=2):
-                                    input_video_trim = gr.Video(label="Input Video", elem_id="video-trim-input")
+                                    input_video_trim = gr.Video(label="Input Video", elem_id="video-trim-input", height=480)
                                     with gr.Row():
                                         set_start_btn = gr.Button("Set Current Frame as START")
                                         set_end_btn = gr.Button("Set Current Frame as END")
@@ -3194,7 +3184,7 @@ with gr.Blocks(
                                     trim_start_time = gr.Number(value=0, visible=False)
                                     trim_end_time = gr.Number(value=0, visible=False)
                             with gr.Row():
-                                output_video_trim = gr.Video(label="Trimmed Video", interactive=True, show_download_button=True)
+                                output_video_trim = gr.Video(label="Trimmed Video", interactive=True, show_download_button=True, height=480)
                             get_current_time_js = """()=>{const e=document.querySelector("#video-trim-input video");return e?e.currentTime:0}"""
                             def get_frame_from_time_wrapper(v,t): return get_frame_at_time(v,t), f"{t:.3f}"
                             set_start_btn.click(fn=None, js=get_current_time_js, outputs=[trim_start_time])
@@ -3208,7 +3198,7 @@ with gr.Blocks(
                             gr.Markdown("### Visually crop a video.")
                             with gr.Row():
                                 with gr.Column(scale=2):
-                                    crop_input_video = gr.Video(label="Input Video")
+                                    crop_input_video = gr.Video(label="Input Video", height=480)
                                     crop_preview_image = gr.Image(label="Frame Preview", interactive=False)
                                 with gr.Column(scale=1):
                                     gr.Markdown("#### Crop Settings")
@@ -3224,7 +3214,7 @@ with gr.Blocks(
                                         crop_do_resize = gr.Checkbox(label="Enable Resizing", value=False)
                                         crop_resize_w = gr.Number(label="Output Width", value=1024, interactive=False)
                                         crop_resize_h = gr.Number(label="Output Height", value=576, interactive=False)
-                                    output_video_crop = gr.Video(label="Cropped Video", interactive=True, show_download_button=True)
+                                    output_video_crop = gr.Video(label="Cropped Video", interactive=True, show_download_button=True, height=480)
                             crop_input_video.upload(fn=get_frame_at_time, inputs=crop_input_video, outputs=crop_preview_image)
                             crop_do_resize.change(lambda x: [gr.update(interactive=x), gr.update(interactive=x)], inputs=crop_do_resize, outputs=[crop_resize_w, crop_resize_h])
                             crop_btn.click(fn=crop_video, inputs=[crop_input_video, crop_x, crop_y, crop_w, crop_h, crop_do_resize, crop_resize_w, crop_resize_h], outputs=output_video_crop).then(fn=None, js=fire_confetti_and_sound_js)
@@ -3233,11 +3223,11 @@ with gr.Blocks(
                             gr.Markdown("### Create slow-motion or fast-forward videos.")
                             with gr.Row():
                                 with gr.Column():
-                                    input_video_speed = gr.Video(label="Input Video")
+                                    input_video_speed = gr.Video(label="Input Video", height=480)
                                     speed_multiplier = gr.Slider(0.1, 10.0, 1.0, step=0.1, label="Speed Multiplier")
                                     speed_btn = gr.Button("🏃 Change Speed", variant="primary")
                                 with gr.Column():
-                                    output_video_speed = gr.Video(label="Modified Video", interactive=True, show_download_button=True)
+                                    output_video_speed = gr.Video(label="Modified Video", interactive=True, show_download_button=True, height=480)
                             speed_btn.click(fn=change_video_speed, inputs=[input_video_speed, speed_multiplier], outputs=output_video_speed).then(fn=None, js=fire_confetti_and_sound_js)
                 
                 with gr.TabItem("🎨 Effects & Overlays"):
@@ -3246,13 +3236,13 @@ with gr.Blocks(
                             gr.Markdown("### Apply Fade-In and/or Fade-Out to a Video")
                             with gr.Row():
                                 with gr.Column():
-                                    fade_input_video = gr.Video(label="Input Video")
+                                    fade_input_video = gr.Video(label="Input Video", height=480)
                                     with gr.Row():
                                         fade_in_slider = gr.Slider(0.0, 10.0, 1.0, step=0.1, label="Fade-In Duration (s)")
                                         fade_out_slider = gr.Slider(0.0, 10.0, 1.0, step=0.1, label="Fade-Out Duration (s)")
                                     fade_video_btn = gr.Button("✨ Apply Fade", variant="primary")
                                 with gr.Column():
-                                    fade_output_video = gr.Video(label="Faded Video", interactive=True, show_download_button=True)
+                                    fade_output_video = gr.Video(label="Faded Video", interactive=True, show_download_button=True, height=480)
                             fade_video_btn.click(apply_video_fade, [fade_input_video, fade_in_slider, fade_out_slider], fade_output_video).then(fn=None, js=fire_confetti_and_sound_js)
 
                         with gr.TabItem("🎨 Color Grading"):
@@ -3260,7 +3250,7 @@ with gr.Blocks(
                             gr.Info("Upload a video, load a preview frame, adjust the sliders for a live preview, and then apply the changes to the full video. The preview is 100% accurate to the final render.")
                             with gr.Row(equal_height=False):
                                 with gr.Column(scale=1):
-                                    color_grade_input_video = gr.Video(label="Input Video")
+                                    color_grade_input_video = gr.Video(label="Input Video", height=480)
                                     load_preview_btn = gr.Button("🖼️ Load/Reset Preview Frame")
                                     
                                     gr.Markdown("#### Adjustments")
@@ -3275,7 +3265,7 @@ with gr.Blocks(
                                     with gr.Row():
                                         cg_before_preview = gr.Image(label="Before", type="numpy", interactive=False)
                                         cg_after_preview = gr.Image(label="After (Accurate Preview)", type="pil", interactive=False)
-                                    color_grade_output_video = gr.Video(label="Graded Video Output", interactive=True, show_download_button=True)
+                                    color_grade_output_video = gr.Video(label="Graded Video Output", interactive=True, show_download_button=True, height=480)
                             
                             grading_inputs = [cg_before_preview, cg_brightness, cg_contrast, cg_saturation, cg_sharpness]
                             
@@ -3314,17 +3304,17 @@ with gr.Blocks(
                             gr.Warning("This is a very slow process. A short video can take several minutes. Output is a .webm file.")
                             with gr.Row():
                                 with gr.Column():
-                                    vbg_input_video = gr.Video(label="Input Video")
+                                    vbg_input_video = gr.Video(label="Input Video", height=480)
                                     vbg_btn = gr.Button("✂️ Remove Video Background", variant="primary")
                                 with gr.Column():
-                                    vbg_output_video = gr.Video(label="Output Video with Transparency (.webm)", interactive=True, show_download_button=True)
+                                    vbg_output_video = gr.Video(label="Output Video with Transparency (.webm)", interactive=True, show_download_button=True, height=480)
                             vbg_btn.click(remove_video_background, vbg_input_video, vbg_output_video).then(fn=None, js=fire_confetti_and_sound_js)
                         
                         with gr.TabItem("Watermark"):
                             gr.Markdown("### Apply a text watermark to a video.")
                             with gr.Row():
                                 with gr.Column():
-                                    wm_input_video = gr.Video(label="Input Video")
+                                    wm_input_video = gr.Video(label="Input Video", height=480)
                                     wm_text = gr.Textbox(label="Watermark Text", placeholder="(c) My Video 2025")
                                     wm_pos = gr.Radio(["Top-Left", "Top-Right", "Bottom-Left", "Bottom-Right", "Center"], value="Bottom-Right", label="Position")
                                     wm_opacity = gr.Slider(0, 100, 70, step=1, label="Opacity (%)")
@@ -3333,14 +3323,14 @@ with gr.Blocks(
                                         wm_color = gr.ColorPicker(value="#FFFFFF", label="Font Color")
                                     wm_btn = gr.Button("🖋️ Apply Watermark", variant="primary")
                                 with gr.Column():
-                                    wm_output_video = gr.Video(label="Watermarked Video", interactive=True, show_download_button=True)
+                                    wm_output_video = gr.Video(label="Watermarked Video", interactive=True, show_download_button=True, height=480)
                             wm_btn.click(apply_video_watermark, [wm_input_video, wm_text, wm_pos, wm_opacity, wm_size, wm_color], wm_output_video).then(fn=None, js=fire_confetti_and_sound_js)
 
                         with gr.TabItem("Create GIF"):
                             gr.Markdown("### Convert a video clip into a high-quality animated GIF.")
                             with gr.Row():
                                 with gr.Column():
-                                    input_video_gif = gr.Video(label="Input Video")
+                                    input_video_gif = gr.Video(label="Input Video", height=480)
                                     with gr.Row():
                                         gif_start_time = gr.Number(value=0, label="Start Time (s)")
                                         gif_end_time = gr.Number(value=0, label="End Time (s)", info="Set to 0 for full duration")
@@ -3350,23 +3340,23 @@ with gr.Blocks(
                             gif_btn.click(create_gif_from_video, [input_video_gif, gif_start_time, gif_end_time], output_gif).then(fn=None, js=fire_confetti_and_sound_js)
                 
                 with gr.TabItem("🔊 Audio & Transcription"):
-                     with gr.Tabs():
+                    with gr.Tabs():
                         with gr.TabItem("Add Audio"):
                             gr.Markdown("### Combine a silent video with an audio file.")
                             with gr.Row():
                                 with gr.Column():
-                                    input_video_audio = gr.Video(label="Input Video")
+                                    input_video_audio = gr.Video(label="Input Video", height=480)
                                     input_audio = gr.Audio(type="filepath", label="Input Audio")
                                     add_audio_btn = gr.Button("🎶 Add Audio", variant="primary")
                                 with gr.Column():
-                                    output_video_audio = gr.Video(label="Final Video with Audio", interactive=True, show_download_button=True)
+                                    output_video_audio = gr.Video(label="Final Video with Audio", interactive=True, show_download_button=True, height=480)
                             add_audio_btn.click(add_audio_to_video, [input_video_audio, input_audio], output_video_audio).then(fn=None, js=fire_confetti_and_sound_js)
                         
                         with gr.TabItem("Extract Audio"):
                             gr.Markdown("### Strip the audio track from a video file.")
                             with gr.Row():
                                 with gr.Column():
-                                    extract_audio_input_video = gr.Video(label="Input Video")
+                                    extract_audio_input_video = gr.Video(label="Input Video", height=480)
                                     extract_audio_format = gr.Dropdown(["mp3", "wav", "aac"], value="mp3", label="Output Audio Format")
                                     extract_audio_btn = gr.Button("🎵 Extract Audio", variant="primary")
                                 with gr.Column():
@@ -3390,69 +3380,40 @@ with gr.Blocks(
                                     audio_trim_output = gr.Audio(label="Processed Audio", type="filepath")
                             audio_trim_fade_btn.click(trim_and_fade_audio, [audio_trim_input, audio_start_time, audio_end_time, audio_fade_in, audio_fade_out], audio_trim_output).then(fn=None, js=fire_confetti_and_sound_js)
                         
-                        with gr.TabItem("Transcription & Subtitles", visible=(whisper is not None)):
-                            gr.Markdown("## Transcribe Speech and Edit Subtitles")
-                            gr.Info("1. Transcribe your media. 2. Edit timings or text in the table. 3. Click 'Update Preview' to see your changes. 4. Click 'Burn Final Subtitles' for the final video.")
-                            
+                        with gr.TabItem("Transcription", visible=(whisper is not None)):
+                            gr.Markdown("## Transcribe Speech and Burn Subtitles")
+                            gr.Info("Uses OpenAI's Whisper model. First run will download model files. After transcribing a video, options to burn subtitles will appear.")
                             transcribed_video_path_state = gr.State(None)
-                            transcribed_segments_state = gr.State(None)
-
                             with gr.Row():
-                                with gr.Column(scale=1):
+                                with gr.Column():
                                     transcribe_input = gr.File(label="Upload Video or Audio File", file_types=["video", "audio"])
                                     transcribe_model = gr.Dropdown(["tiny", "base", "small", "medium", "large"], value="base", label="Whisper Model Size")
-                                    transcribe_btn = gr.Button("🎙️ 1. Transcribe Media", variant="primary")
-                                    
-                                    with gr.Accordion("📜 Full Transcript & Downloads", open=False):
-                                        with gr.Row():
-                                            transcribe_text = gr.Textbox(label="Full Transcription", lines=10, interactive=True, elem_id="transcription_textbox")
-                                            copy_transcription_btn = gr.Button("📋 Copy")
-                                        transcribe_files = gr.File(label="Download Subtitle Files (.srt, .vtt)", file_count="multiple", interactive=False)
-                                
-                                with gr.Column(scale=2, visible=False) as editor_column:
-                                    gr.Markdown("### Subtitle Editor & Preview")
-                                    subtitle_df = gr.DataFrame(
-                                        headers=["#", "Start (s)", "End (s)", "Text"],
-                                        datatype=["number", "str", "str", "str"],
-                                        label="Edit Subtitles",
-                                        interactive=True,
-                                        row_count=(10, "fixed")
-                                    )
-                                    with gr.Accordion("🎨 Styling & Rendering", open=True):
-                                        with gr.Row():
-                                            burn_font_size = gr.Slider(1, 10, 5, step=1, label="Font Size")
-                                            burn_font_color = gr.ColorPicker(value="#FFFFFF", label="Font Color")
-                                            burn_outline_color = gr.ColorPicker(value="#000000", label="Outline Color")
-                                        update_preview_btn = gr.Button("🔄 2. Update Preview", variant="secondary")
-                                        burn_final_btn = gr.Button("🔥 3. Burn Final Subtitles", variant="primary")
-                                    
-                                    subtitle_preview_video = gr.Video(label="Video Preview with Subtitles", show_download_button=True)
+                                    transcribe_btn = gr.Button("🎙️ Transcribe", variant="primary")
+                                with gr.Column():
+                                    with gr.Row():
+                                        transcribe_text = gr.Textbox(label="Transcription Result", lines=10, interactive=True, elem_id="transcription_textbox")
+                                        copy_transcription_btn = gr.Button("📋 Copy")
+                                    transcribe_files = gr.File(label="Download Subtitle Files (.srt, .vtt)", file_count="multiple", interactive=False)
                             
-                            copy_transcription_btn.click(fn=None, js=copy_transcription_js)
+                            with gr.Accordion("🔥 Burn Subtitles onto Video", open=True, visible=False) as burn_accordion:
+                                gr.Markdown("Set styling and burn the generated subtitles into the video.")
+                                with gr.Row():
+                                    burn_font_size = gr.Slider(1, 10, 5, step=1, label="Relative Font Size")
+                                    burn_words_per_line = gr.Slider(1, 20, 7, step=1, label="Max Words Per Line", info="Splits long subtitle lines for better readability.")
+                                    burn_font_color = gr.ColorPicker(value="#FFFFFF", label="Font Color")
+                                burn_btn = gr.Button("🔥 Burn Subtitles", variant="primary")
+                                burn_output_video = gr.Video(label="Video with Burned-in Subtitles", interactive=True, show_download_button=True, height=480)
                             
+                            copy_transcription_btn.click(fn=None, js=copy_transcription_js)
                             transcribe_btn.click(
                                 fn=transcribe_and_prep_burn, 
                                 inputs=[transcribe_input, transcribe_model], 
-                                outputs=[
-                                    transcribe_text, 
-                                    transcribe_files, 
-                                    transcribed_video_path_state, 
-                                    transcribed_segments_state,
-                                    subtitle_df,
-                                    editor_column
-                                ]
+                                outputs=[transcribe_text, transcribe_files, transcribed_video_path_state, burn_accordion]
                             ).then(fn=None, js=fire_confetti_and_sound_js)
-                            
-                            update_preview_btn.click(
-                                fn=burn_subtitles_from_df,
-                                inputs=[transcribed_video_path_state, subtitle_df, burn_font_size, burn_font_color, burn_outline_color],
-                                outputs=subtitle_preview_video
-                            )
-                            
-                            burn_final_btn.click(
-                                fn=burn_subtitles_from_df,
-                                inputs=[transcribed_video_path_state, subtitle_df, burn_font_size, burn_font_color, burn_outline_color],
-                                outputs=subtitle_preview_video
+                            burn_btn.click(
+                                fn=burn_subtitles,
+                                inputs=[transcribed_video_path_state, transcribe_files, burn_font_size, burn_font_color, burn_words_per_line],
+                                outputs=burn_output_video
                             ).then(fn=None, js=fire_confetti_and_sound_js)
 
         with gr.TabItem("🧠 ControlNet", elem_id="controlnet_tab"):
@@ -3462,11 +3423,11 @@ with gr.Blocks(
                     gr.Markdown("### Convert a Video into a ControlNet-Ready Map")
                     with gr.Row():
                         with gr.Column():
-                            input_video_cn = gr.Video(label="Input Video")
+                            input_video_cn = gr.Video(label="Input Video", height=480)
                             detector_dropdown_cn = gr.Dropdown(choices=list(DETECTOR_CONFIG.keys()), value="Canny", label="Choose Detector")
                             process_btn_cn = gr.Button("✨ Process Video", variant="primary")
                         with gr.Column():
-                            output_video_cn = gr.Video(label="Output ControlNet Video", interactive=True, show_download_button=True)
+                            output_video_cn = gr.Video(label="Output ControlNet Video", interactive=True, show_download_button=True, height=480)
                     process_btn_cn.click(fn=process_video_with_detector, inputs=[input_video_cn, detector_dropdown_cn], outputs=output_video_cn).then(fn=None, js=fire_confetti_and_sound_js)
                 with gr.TabItem("Process Batch Images"):
                     gr.Markdown("### Generate ControlNet Maps from one or more images.")
@@ -3485,9 +3446,9 @@ with gr.Blocks(
             gr.Info("Convert your video to a different format, change the codec, reduce the quality to save space, or downscale the resolution.")
             with gr.Row():
                 with gr.Column():
-                    conv_input_video = gr.Video(label="Input Video")
+                    conv_input_video = gr.Video(label="Input Video", height=480)
                     conv_btn = gr.Button("⚙️ Convert & Compress", variant="primary")
-                    conv_output_video = gr.Video(label="Converted Video", interactive=True, show_download_button=True)
+                    conv_output_video = gr.Video(label="Converted Video", interactive=True, show_download_button=True, height=480)
                 with gr.Column():
                     gr.Markdown("#### Output Settings")
                     with gr.Row():
@@ -3548,4 +3509,4 @@ if __name__ == "__main__":
         try: shutil.rmtree(TEMP_DIR)
         except OSError as e: print(f"Error removing temp directory {TEMP_DIR}: {e}")
     os.makedirs(TEMP_DIR, exist_ok=True)
-    demo.launch(inbrowser=True)
+    demo.launch(inbrowser=True)