Add video processing features: create video from images and audio, concatenate clips, and adjust audio volume

main.py

@@ -1,11 +1,13 @@
 from fastapi import FastAPI, HTTPException
 from fastapi.staticfiles import StaticFiles
+from fastapi.responses import FileResponse
 from pydantic import BaseModel, HttpUrl
 from typing import List
 import os
 import asyncio
 import uuid
 import aiohttp
+import traceback
 import re
 from urllib.parse import urlparse
 import shutil
@@ -25,6 +27,10 @@ class SlideshowRequest(BaseModel):
     duration: int
     zoom: bool = False
 
+class MakeVideoInput(BaseModel):
+    assets: dict
+    volume_adjustment: float = 1.0
+
 def extract_google_drive_id(url):
     """Extract file ID from a Google Drive URL"""
     pattern = r'(?:/file/d/|id=|/open\?id=)([^/&]+)'
@@ -197,6 +203,170 @@ async def make_slideshow(request: SlideshowRequest):
             shutil.rmtree(request_dir)
         raise HTTPException(status_code=500, detail=f"Error: {str(e)}")
 
+
+async def download_file_with_extension(url, extension, output_dir):
+    """Download file and save with the provided extension"""
+    file_id = str(uuid.uuid4())
+    file_path = os.path.join(output_dir, f"{file_id}{extension}")
+    success = await download_file(url, file_path)
+    if not success:
+        raise HTTPException(status_code=400, detail=f"Failed to download file from {url}")
+    return file_path
+
+async def add_audio_to_image(image_path, audio_path, output_dir):
+    """Create a video from an image and audio file"""
+    output_id = str(uuid.uuid4())
+    output_path = os.path.join(output_dir, f"{output_id}.mp4")
+    
+    cmd = [
+        "ffmpeg", "-y",
+        "-loop", "1",
+        "-i", image_path,
+        "-i", audio_path,
+        "-c:v", "libx264",
+        "-tune", "stillimage",
+        "-c:a", "aac",
+        "-pix_fmt", "yuv420p",
+        "-shortest",
+        output_path
+    ]
+    
+    process = await asyncio.create_subprocess_exec(
+        *cmd, 
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE
+    )
+    stdout, stderr = await process.communicate()
+    
+    if process.returncode != 0:
+        print(f"FFmpeg error: {stderr.decode()}")
+        raise HTTPException(status_code=500, detail="Failed to add audio to image")
+    
+    return {"output_path": output_path}
+
+async def concatenate_videos(clip_paths, output_dir):
+    """Concatenate multiple video clips"""
+    output_id = str(uuid.uuid4())
+    output_path = os.path.join(output_dir, f"{output_id}.mp4")
+    
+    # Create temporary file list for ffmpeg concat
+    concat_file = os.path.join(output_dir, "concat_list.txt")
+    
+    async with aiofiles.open(concat_file, "w") as f:
+        for clip in clip_paths:
+            await f.write(f"file '{clip}'\n")
+    
+    cmd = [
+        "ffmpeg", "-y",
+        "-f", "concat",
+        "-safe", "0",
+        "-i", concat_file,
+        "-c", "copy",
+        output_path
+    ]
+    
+    process = await asyncio.create_subprocess_exec(
+        *cmd, 
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE
+    )
+    stdout, stderr = await process.communicate()
+    
+    # Clean up
+    if os.path.exists(concat_file):
+        os.remove(concat_file)
+    
+    if process.returncode != 0:
+        print(f"FFmpeg error: {stderr.decode()}")
+        raise HTTPException(status_code=500, detail="Failed to concatenate videos")
+    
+    return {"output_path": output_path}
+
+async def add_audio_to_video(video_path, audio_path, volume_adjustment, output_dir):
+    """Add background music to video with volume adjustment"""
+    output_filename = f"final_video_{str(uuid.uuid4())}.mp4"
+    output_path = os.path.join(output_dir, output_filename)
+    
+    cmd = [
+        "ffmpeg", "-y",
+        "-i", video_path,
+        "-i", audio_path,
+        "-filter_complex", f"[1:a]volume={volume_adjustment}[a1];[0:a][a1]amix=inputs=2:duration=longest[a]",
+        "-map", "0:v",
+        "-map", "[a]",
+        "-c:v", "copy",
+        "-c:a", "aac",
+        "-b:a", "192k",
+        output_path
+    ]
+    
+    process = await asyncio.create_subprocess_exec(
+        *cmd, 
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE
+    )
+    stdout, stderr = await process.communicate()
+    
+    if process.returncode != 0:
+        print(f"FFmpeg error: {stderr.decode()}")
+        raise HTTPException(status_code=500, detail="Failed to add audio to video")
+    
+    return {"output_path": output_path, "output_filename": output_filename}
+
+@app.post("/make_video")
+async def make_video(input_data: MakeVideoInput):
+    try:
+        # Create unique directory for this request
+        request_id = str(uuid.uuid4())
+        request_dir = os.path.join("staticfiles", request_id)
+        os.makedirs(request_dir, exist_ok=True)
+        
+        assets = input_data.assets
+        volume_adjustment = input_data.volume_adjustment
+        
+        # Download music
+        music_url = assets["music_url"]
+        music_path = await download_file_with_extension(music_url, ".mp3", request_dir)
+
+        # Process each clip
+        clips = []
+        for clip_data in assets["clips"]:
+            image_url = clip_data["image_url"]
+            audio_url = clip_data["audio_url"]
+
+            image_path = await download_file_with_extension(image_url, ".png", request_dir)
+            audio_path = await download_file_with_extension(audio_url, ".mp3", request_dir)
+
+            add_audio_to_image_result = await add_audio_to_image(image_path, audio_path, request_dir)
+
+            clips.append(add_audio_to_image_result["output_path"])
+
+        # Concatenate all the clips
+        concatenate_videos_result = await concatenate_videos(clips, request_dir)
+        concatenate_videos_output_path = concatenate_videos_result["output_path"]
+
+        # Add background music
+        add_audio_to_video_result = await add_audio_to_video(
+            concatenate_videos_output_path, 
+            music_path, 
+            volume_adjustment,
+            request_dir
+        )
+
+        # Return the final video
+        return FileResponse(
+            add_audio_to_video_result["output_path"], 
+            media_type="video/mp4", 
+            filename=add_audio_to_video_result["output_filename"]
+        )
+    except Exception as e:
+        # Clean up on error
+        if os.path.exists(request_dir):
+            shutil.rmtree(request_dir)
+        print(f"An error occurred: {str(e)}")
+        print(traceback.format_exc())
+        raise HTTPException(status_code=500, detail=f"An unexpected error occurred: {str(e)}")
+
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=7860)