Update app.py

app.py

@@ -5,6 +5,8 @@ import re
 import time
 import shutil
 import glob
+import base64
+import tempfile
 
 # ---------------------------------------------------------
 # 1. Helper Functions
@@ -185,18 +187,12 @@ def render_video_from_code(code, orientation, quality, timeout, preview_factor):
         return None, f"Rendering failed: {str(e)}", gr.Button(visible=True)
 
 # ---------------------------------------------------------
-# NEW: Audio Merging Functions
+# NEW: Audio Merging Functions (API-Safe)
 # ---------------------------------------------------------
 
 def get_media_duration(file_path):
     """Uses ffprobe to get the duration of a media file."""
-    cmd = [
-        "ffprobe",
-        "-v", "error",
-        "-show_entries", "format=duration",
-        "-of", "default=noprint_wrappers=1:nokey=1",
-        file_path
-    ]
+    cmd = ["ffprobe", "-v", "error", "-show_entries", "format=duration", "-of", "default=noprint_wrappers=1:nokey=1", file_path]
     try:
         result = subprocess.run(cmd, capture_output=True, text=True, check=True)
         return float(result.stdout.strip())
@@ -209,80 +205,110 @@ def build_atempo_filter(factor):
     filters = []
     # FFmpeg's atempo filter is limited to the range [0.5, 100.0]
     while factor > 100.0:
-        filters.append("atempo=100.0")
-        factor /= 100.0
+        filters.append("atempo=100.0"); factor /= 100.0
     while factor < 0.5:
-        filters.append("atempo=0.5")
-        factor /= 0.5
-    
+        filters.append("atempo=0.5"); factor /= 0.5
     if 0.5 <= factor <= 100.0:
         filters.append(f"atempo={factor}")
-    
     return ",".join(filters)
 
-def merge_audio_to_video(video_path, audio_path):
-    """Merges audio into a video, stretching the audio to match the video's duration."""
-    if not video_path or not audio_path:
-        return None, "Error: Please provide both a video and an audio file."
-
-    gr.Info("Merging audio...")
-    video_duration = get_media_duration(video_path)
-    audio_duration = get_media_duration(audio_path)
-
-    if video_duration is None or audio_duration is None:
-        return None, "Error: Could not determine media durations. Check server logs."
-
-    if video_duration == 0:
-        return None, "Error: Input video has zero duration."
-
-    speed_factor = audio_duration / video_duration
-    atempo_filter = build_atempo_filter(speed_factor)
+def decode_base64_to_tempfile(data_obj):
+    """Decodes a base64 string from a Gradio file object and saves to a temp file."""
+    if not data_obj or 'data' not in data_obj:
+        return None
     
-    print(f"Video Duration: {video_duration}s, Audio Duration: {audio_duration}s, Speed Factor: {speed_factor}", flush=True)
-    print(f"Applying FFmpeg atempo filter: '{atempo_filter}'", flush=True)
-
-    output_dir = "temp_outputs"
-    os.makedirs(output_dir, exist_ok=True)
-    timestamp = int(time.time())
-    output_path = os.path.join(output_dir, f"merged_video_{timestamp}.mp4")
-
-    ffmpeg_cmd = [
-        "ffmpeg",
-        "-y",                   # Overwrite output file if it exists
-        "-i", video_path,       # Input video
-        "-i", audio_path,       # Input audio
-        "-c:v", "copy",         # Copy video stream (no re-encoding, preserves quality)
-        "-filter:a", atempo_filter, # Apply speed change to audio
-        "-map", "0:v:0",        # Select video from the first input
-        "-map", "1:a:0",        # Select audio from the second input
-        "-shortest",            # Ensure output duration matches the shortest stream (video)
-        output_path
-    ]
+    # Gradio sends base64 data in the format "data:video/mp4;base64,xxxx..."
+    header, encoded_data = data_obj['data'].split(",", 1)
+    file_extension = header.split('/')[1].split(';')[0]
     
-    process = subprocess.run(ffmpeg_cmd, capture_output=True, text=True)
+    decoded_data = base64.b64decode(encoded_data)
     
-    if process.returncode != 0:
-        error_message = f"FFmpeg Error:\n{process.stderr}"
-        print(error_message, flush=True)
-        return None, error_message
+    with tempfile.NamedTemporaryFile(delete=False, suffix=f".{file_extension}") as tmp_file:
+        tmp_file.write(decoded_data)
+        return tmp_file.name
 
-    print(f"✅ Audio merged successfully: {output_path}", flush=True)
-    return output_path, "✅ Audio merged successfully!"
+def merge_audio_to_video(video_input, audio_input):
+    """
+    Merges audio into a video. Handles both file paths (from UI) and 
+    base64 dictionaries (from API) as inputs.
+    """
+    video_path, audio_path = None, None
+    temp_files_to_clean = []
+
+    try:
+        # --- Handle UI call (inputs are file paths) ---
+        if isinstance(video_input, str) and os.path.exists(video_input):
+            video_path = video_input
+        # --- Handle API call (inputs are base64 dictionaries) ---
+        elif isinstance(video_input, dict):
+            print("API call detected: Decoding video from base64.", flush=True)
+            video_path = decode_base64_to_tempfile(video_input)
+            if video_path: temp_files_to_clean.append(video_path)
+
+        if isinstance(audio_input, str) and os.path.exists(audio_input):
+            audio_path = audio_input
+        elif isinstance(audio_input, dict):
+            print("API call detected: Decoding audio from base64.", flush=True)
+            audio_path = decode_base64_to_tempfile(audio_input)
+            if audio_path: temp_files_to_clean.append(audio_path)
+
+        # --- Validation ---
+        if not video_path or not audio_path:
+            return None, "Error: Missing video or audio file. Please provide both."
+
+        gr.Info("Merging audio...")
+        video_duration = get_media_duration(video_path)
+        audio_duration = get_media_duration(audio_path)
+
+        if video_duration is None or audio_duration is None:
+            return None, "Error: Could not determine media durations."
+        if video_duration == 0:
+            return None, "Error: Input video has zero duration."
+
+        # --- Core FFmpeg Logic ---
+        speed_factor = audio_duration / video_duration
+        atempo_filter = build_atempo_filter(speed_factor)
+        
+        output_dir = "temp_outputs"; os.makedirs(output_dir, exist_ok=True)
+        timestamp = int(time.time())
+        output_path = os.path.join(output_dir, f"merged_video_{timestamp}.mp4")
+
+        ffmpeg_cmd = [
+            "ffmpeg", "-y",
+            "-i", video_path,
+            "-i", audio_path,
+            "-c:v", "copy",
+            "-filter:a", atempo_filter,
+            "-map", "0:v:0",
+            "-map", "1:a:0",
+            "-shortest",
+            output_path
+        ]
+        
+        process = subprocess.run(ffmpeg_cmd, capture_output=True, text=True)
+        
+        if process.returncode != 0:
+            error_message = f"FFmpeg Error:\n{process.stderr}"
+            print(error_message, flush=True)
+            return None, error_message
+
+        print(f"✅ Audio merged successfully: {output_path}", flush=True)
+        return output_path, "✅ Audio merged successfully!"
+
+    finally:
+        # --- Cleanup ---
+        print(f"Cleaning up {len(temp_files_to_clean)} temporary files...", flush=True)
+        for f in temp_files_to_clean:
+            try:
+                os.remove(f)
+            except OSError as e:
+                print(f"Error removing temp file {f}: {e}", flush=True)
 
 # ---------------------------------------------------------
 # 3. Gradio Interface
 # ---------------------------------------------------------
 
-DEFAULT_CODE = """from manim import *
-
-class GenScene(Scene):
-    def construct(self):
-        c = Circle(color=BLUE, fill_opacity=0.5)
-        self.play(Create(c))
-        self.wait(1)
-"""
-
-with gr.Blocks(title="Manim Render API") as demo:
+with gr.Blocks(title="Manim Render & Audio Tool") as demo:
     with gr.Tab("🎬 Manim Video Renderer"):
         with gr.Row():
             with gr.Column(scale=1):
@@ -310,6 +336,7 @@ with gr.Blocks(title="Manim Render API") as demo:
         with gr.Row():
             with gr.Column():
                 video_input_audio_tab = gr.Video(label="Input Video (MP4)")
+                # For the API, this audio component will accept base64 data
                 audio_input_audio_tab = gr.Audio(label="Input Audio", type="filepath")
                 merge_audio_btn = gr.Button("Merge Audio", variant="primary")
             with gr.Column():