Update app.py

app.py

@@ -106,28 +106,22 @@ def run_manim(code_str, orientation, quality, timeout):
     full_logs = ""
 
     try:
-        # check=False prevents Python from raising exception on error code automatically.
-        # We handle returncode manually below.
         process = subprocess.run(cmd, capture_output=True, timeout=timeout_sec, check=False)
         
         stdout_log = process.stdout.decode('utf-8', 'ignore')
         stderr_log = process.stderr.decode('utf-8', 'ignore')
         full_logs = f"--- MANIM STDOUT ---\n{stdout_log}\n\n--- MANIM STDERR ---\n{stderr_log}"
         
-        # --- STANDARD ERROR CHECK ---
         if process.returncode != 0:
             print(f"❌ Render Failed (Process Error). Return Code: {process.returncode}", flush=True)
-            # We do NOT stitch here. We just fall through to see if a file exists (unlikely).
 
     except subprocess.TimeoutExpired as e:
-        # --- TIMEOUT LOGIC ONLY ---
         print(f"⌛ Render timed out after {timeout_sec} seconds. Attempting recovery...", flush=True)
         stdout_log = e.stdout.decode('utf-8', 'ignore') if e.stdout else ""
         stderr_log = e.stderr.decode('utf-8', 'ignore') if e.stderr else ""
         timeout_logs = f"--- MANIM STDOUT ---\n{stdout_log}\n\n--- MANIM STDERR ---\n{stderr_log}"
         full_logs = timeout_logs
         
-        # 1. Parse logs for directory
         combined_log = stdout_log + "\n" + stderr_log
         path_matches = re.findall(r"movie file written in\s*'([^']+?)'", combined_log, flags=re.DOTALL)
         
@@ -135,7 +129,6 @@ def run_manim(code_str, orientation, quality, timeout):
             partial_files_dir = os.path.dirname("".join(path_matches[-1].split()))
             
             if os.path.exists(partial_files_dir):
-                # 2. Find partial chunks
                 partial_files = sorted(glob.glob(os.path.join(partial_files_dir, 'uncached_*.mp4')), 
                                        key=lambda f: int(re.search(r'(\d+)\.mp4$', f).group(1)))
                 
@@ -146,7 +139,6 @@ def run_manim(code_str, orientation, quality, timeout):
                         for pf in partial_files:
                             f.write(f"file '{os.path.abspath(pf)}'\n")
 
-                    # 3. Stitch
                     combined_video_path = os.path.join(os.path.dirname(partial_files_dir), f"combined_partial_{timestamp}.mp4")
                     ffmpeg_cmd = ["ffmpeg", "-y", "-f", "concat", "-safe", "0", "-i", list_file_path, "-c", "copy", combined_video_path]
                     
@@ -157,10 +149,7 @@ def run_manim(code_str, orientation, quality, timeout):
                         return combined_video_path, f"⚠️ WARNING: Render Timed Out. Recovered partial video.\n\n{timeout_logs}", True
         
         print("❌ Recovery failed or no partial files found.", flush=True)
-        # End of Timeout Logic. Falls through to final check.
 
-    # --- FINAL FILE CHECK ---
-    # Only returns success if the actual complete file exists.
     media_video_base = os.path.join("media", "videos", "scene")
     if os.path.exists(media_video_base):
         for root, _, files in os.walk(media_video_base):
@@ -195,6 +184,91 @@ def render_video_from_code(code, orientation, quality, timeout, preview_factor):
     except Exception as e:
         return None, f"Rendering failed: {str(e)}", gr.Button(visible=True)
 
+# ---------------------------------------------------------
+# NEW: Audio Merging Functions
+# ---------------------------------------------------------
+
+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
+    ]
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return float(result.stdout.strip())
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        print(f"⚠️ Could not get duration for {file_path}. Is ffprobe installed?", flush=True)
+        return None
+
+def build_atempo_filter(factor):
+    """Builds a chained atempo filter for FFmpeg to handle extreme speed changes."""
+    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
+    while 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)
+    
+    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
+    ]
+    
+    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!"
+
 # ---------------------------------------------------------
 # 3. Gradio Interface
 # ---------------------------------------------------------
@@ -209,23 +283,45 @@ class GenScene(Scene):
 """
 
 with gr.Blocks(title="Manim Render API") as demo:
-    code_input = gr.Code(label="Python Code", language="python", value=DEFAULT_CODE, visible=True)
-    orientation_opt = gr.Radio(choices=["Landscape (16:9)", "Portrait (9:16)"], value="Portrait (9:16)", label="Orientation", visible=True)
-    quality_opt = gr.Dropdown(choices=["Preview (360p)", "480p", "720p", "1080p", "4k"], value="Preview (360p)", label="Quality", visible=True)
-    timeout_input = gr.Number(label="Render Timeout (seconds)", value=60, visible=True)
-    preview_speed_factor_input = gr.Number(label="Preview Speed Factor", value=0.5, visible=True)
-    
-    video_output = gr.Video(label="Result")
-    status_output = gr.Textbox(label="Status/Logs")
-    fix_btn_output = gr.Button("Fix Error & Re-render", variant="stop", visible=True)
-    render_btn = gr.Button("Render")
-    
-    render_btn.click(
-        fn=render_video_from_code,
-        inputs=[code_input, orientation_opt, quality_opt, timeout_input, preview_speed_factor_input],
-        outputs=[video_output, status_output, fix_btn_output],
-        api_name="render"
-    )
+    with gr.Tab("🎬 Manim Video Renderer"):
+        with gr.Row():
+            with gr.Column(scale=1):
+                code_input = gr.Code(label="Python Code", language="python", value=DEFAULT_CODE, visible=True)
+                orientation_opt = gr.Radio(choices=["Landscape (16:9)", "Portrait (9:16)"], value="Portrait (9:16)", label="Orientation", visible=True)
+                quality_opt = gr.Dropdown(choices=["Preview (360p)", "480p", "720p", "1080p", "4k"], value="Preview (360p)", label="Quality", visible=True)
+                timeout_input = gr.Number(label="Render Timeout (seconds)", value=60, visible=True)
+                preview_speed_factor_input = gr.Number(label="Preview Speed Factor", value=0.5, visible=True)
+                render_btn = gr.Button("Render", variant="primary")
+            with gr.Column(scale=1):
+                video_output = gr.Video(label="Result")
+                status_output = gr.Textbox(label="Status/Logs")
+                fix_btn_output = gr.Button("Fix Error & Re-render", variant="stop", visible=True)
+        
+        render_btn.click(
+            fn=render_video_from_code,
+            inputs=[code_input, orientation_opt, quality_opt, timeout_input, preview_speed_factor_input],
+            outputs=[video_output, status_output, fix_btn_output],
+            api_name="render"
+        )
+
+    with gr.Tab("🎤 Add Audio to Video"):
+        gr.Markdown("## Merge Audio into Video")
+        gr.Markdown("Upload a video and an audio file. The audio will be automatically stretched or compressed to match the video's length, preserving original video quality.")
+        with gr.Row():
+            with gr.Column():
+                video_input_audio_tab = gr.Video(label="Input Video (MP4)")
+                audio_input_audio_tab = gr.Audio(label="Input Audio", type="filepath")
+                merge_audio_btn = gr.Button("Merge Audio", variant="primary")
+            with gr.Column():
+                video_output_audio_tab = gr.Video(label="Merged Video")
+                status_audio_tab = gr.Textbox(label="Status")
+
+        merge_audio_btn.click(
+            fn=merge_audio_to_video,
+            inputs=[video_input_audio_tab, audio_input_audio_tab],
+            outputs=[video_output_audio_tab, status_audio_tab],
+            api_name="add_audio"
+        )
 
 if __name__ == "__main__":
     demo.launch(server_name="0.0.0.0", server_port=7860)