Update app.py

app.py

@@ -67,12 +67,13 @@ def export_to_video_file(video_frames, output_video_path=None, fps=10):
 # those are way too slow for a AiTube which needs things to be as fast as possible
 # -----------------------------------------------------------------------------------
 
-def interpolate_video_frames(file_path, output_fps=10, desired_duration=2):
+def interpolate_video_frames(input_file_path, output_file_path, output_fps=10, desired_duration=2):
     """
     Interpolates frames in a video file to adjust frame rate and duration using ffmpeg's minterpolate.
     
     Parameters:
-        file_path (str): Path to the input video file.
+        input_file_path (str): Path to the input video file.
+        output_file_path (str): Path to the output video file.
         output_fps (int): Target frames per second for the output video.
         desired_duration (int): Desired duration of the video in seconds.
     
@@ -80,7 +81,7 @@ def interpolate_video_frames(file_path, output_fps=10, desired_duration=2):
         str: The file path of the modified video.
     """
     # Calculate the input fps required to stretch the video to the desired duration
-    input_fps = find_input_fps(file_path, desired_duration)
+    input_fps = find_input_fps(input_file_path, desired_duration)
     
     # Construct the ffmpeg command for interpolation
     cmd = [
@@ -88,19 +89,18 @@ def interpolate_video_frames(file_path, output_fps=10, desired_duration=2):
         '-i', file_path,  # input file
         '-filter:v', f'minterpolate=fps={output_fps}',  # minterpolate filter options
         '-r', str(output_fps),  # output frame rate
-        '-y',  # Overwrite output files without asking
-        file_path  # Output file (Overwrites the original)
+        output_file_path  # Output file
     ]
     
     # Execute the command
     try:
         subprocess.run(cmd, check=True)
         print("Video interpolation successful.")
+        return input_file_path
     except subprocess.CalledProcessError as e:
         print("Failed to interpolate video. Error:", e)
+        return output_file_path
     
-    return file_path
-
 def find_input_fps(file_path, desired_duration):
     """
     Determine the input fps that, when stretched to the desired duration, matches the original video length.
@@ -168,28 +168,41 @@ def generate_image(secret_token, prompt, base, width, height, motion, step, desi
         guidance_scale=1.0,
         num_inference_steps=step,
     )
-
-    name = str(uuid.uuid4()).replace("-", "")
-    path = f"/tmp/{name}.webm"
     
-    # I think we are looking time here too, converting to webm is too slow, we should return
-    # the frames unencoded to the frontend renderer
-    path = export_to_video_file(output.frames[0], path, fps=10)
+    video_uuid = str(uuid.uuid4()).replace("-", "")
+    raw_video_path = f"/tmp/{video_uuid}_raw.webm"
+    enhanced_video_path = f"/tmp/{video_uuid}_enhanced.webm"
+    
 
-        # Optional frame interpolation
+    # note the fps is hardcoded, this is a limitation from AnimateDiff I think?
+    # (could we change this?)
+    #
+    # maybe to make things faster, we could *not* encode the video (as this uses files and external processes, which can be slow)
+    # and instead return the unencoded frames to the frontend renderer?
+    raw_video_path = export_to_video_file(output.frames[0], path, fps=10)
+
+    final_video_path = raw_video_path
+    
+    # Optional frame interpolation
     if desired_duration != 2 or desired_fps != 10:
-        path = interpolate_video_frames(path, output_fps=desired_fps, desired_duration=desired_duration)
+        final_video_path = interpolate_video_frames(raw_video_path, enhanced_video_path, output_fps=desired_fps, desired_duration=desired_duration)
 
     # Read the content of the video file and encode it to base64
-    with open(path, "rb") as video_file:
+    with open(final_video_path, "rb") as video_file:
         video_base64 = base64.b64encode(video_file.read()).decode('utf-8')
 
+    # clean-up (otherwise there is always a risk of "ghosting", eg. someone seeing the previous generated video,
+    # of one of the steps go wrong - also we need to absolutely delete videos as we generate random files,
+    # we can't afford to get a "tmp disk full" error)
+    try:
+        os.remove(raw_video_path):
+        if final_video_path != raw_video_path:
+            os.remove(final_video_path)
+    except Exception as e:
+        print("Failed to delete a video path:", e)
+    
     # Prepend the appropriate data URI header with MIME type
     video_data_uri = 'data:video/webm;base64,' + video_base64
-    
-    # clean-up (otherwise there is always a risk of "ghosting", eg. someone seeing the previous generated video",
-    # of one of the steps go wrong)
-    os.remove(path)
 
     return video_data_uri