Update app.py

app.py

@@ -26,20 +26,24 @@ mediapy.set_ffmpeg(ffmpeg_path)
 
 SECRET_TOKEN = os.getenv('SECRET_TOKEN', 'default_secret')
 
+
 def base64_to_video(base64_string, output_file):
     video_data = base64.b64decode(base64_string)
     with open(output_file, 'wb') as f:
         f.write(video_data)
-
-def do_interpolation(frame1, frame2, times_to_interpolate, interpolator):
+        
+def do_interpolation(frame1, frame2, times_to_interpolate):
+    print(frame1, frame2)
     input_frames = [frame1, frame2]
+    #times_to_interpolate = 2
     frames = list(
         util.interpolate_recursively_from_files(
             input_frames, times_to_interpolate, interpolator))
-    with tempfile.NamedTemporaryFile(delete=True, suffix=".mp4") as temp_file:
-        mediapy.write_video(temp_file.name, frames, fps=12) # I'm not sure about the 12 FPS here, seems pretty arbitrary
-        return temp_file.name
-        
+    
+    #print(frames)
+    mediapy.write_video(f"{frame1}_to_{frame2}_out.mp4", frames, fps=12)
+    return f"{frame1}_to_{frame2}_out.mp4"
+    
 def get_frames(video_in, step, name):
     frames = []
     #resize the video
@@ -74,9 +78,10 @@ def get_frames(video_in, step, name):
         ret, frame = cap.read()
         if ret == False:
             break
-        # use use png to avoid any compression artifact
-        cv2.imwrite(f"{name}_{step}{str(i)}.png",frame)
-        frames.append(f"{name}_{step}{str(i)}.png")
+        # we could use png to avoid any compression artifact, but it takes much more space!
+        # alternatively, let's just bump the quality from 95 to 98 for now
+        cv2.imwrite(f"{name}_{step}{str(i)}.jpg", frame, [int(cv2.IMWRITE_JPEG_QUALITY), 98])
+        frames.append(f"{name}_{step}{str(i)}.jpg")
         i+=1
     
     cap.release()
@@ -99,37 +104,54 @@ def infer(secret_token, video_in_base64, interpolation, fps_output):
     if secret_token != SECRET_TOKEN:
         raise gr.Error(f'Invalid secret token. Please fork the original space if you want to use it for yourself.')
 
-
-    with tempfile.NamedTemporaryFile(delete=True, suffix=".mp4") as temp_video_in:
-        # Decode the base64 string to a video file
-        base64_to_video(video_in_base64, temp_video_in.name)
-        
-        # 1. break video into frames and get FPS
-        break_vid = get_frames(temp_video_in.name, "vid_input_frame", "origin")
-        frames_list = break_vid[0]
-        fps = break_vid[1]
-
-        # print(f"ORIGIN FPS: {fps}")
-        n_frame = int(4 * fps) #limited to 4 seconds
-        #    #n_frame = len(frames_list)
-        if n_frame >= len(frames_list):
-            n_frame = len(frames_list)
-        
-        result_frames = []
-        for idx, frame in enumerate(frames_list[0:n_frame]):
-            if idx < len(frames_list) - 1:
-                next_frame = frames_list[idx + 1]
-                interpolated_frames = do_interpolation(frame, next_frame, interpolation, interpolator)
-                break_interpolated_video = get_frames(interpolated_frames, "interpol", f"{idx}_")
-                for j, img in enumerate(break_interpolated_video[0][:-1]):
-                    os.rename(img, f"{frame}_to_{next_frame}_{j}.png")
-                    result_frames.append(f"{frame}_to_{next_frame}_{j}.png")
         
-        result_frames.append(frames_list[n_frame - 1])
-        with tempfile.NamedTemporaryFile(delete=True, suffix=".mp4") as final_video:
-            final_vid = create_video(result_frames, fps_output, final_video.name)
-            encoded_string = base64.b64encode(open(final_vid, "rb").read()).decode('utf-8')
-            return f"data:video/mp4;base64,{encoded_string}"
+    # Decode the base64 string to a video file
+    video_in = "video_in.mp4"  # or choose any other filename/path
+    base64_to_video(video_in_base64, video_in)
+    
+    # 1. break video into frames and get FPS
+    break_vid = get_frames(video_in, "vid_input_frame", "origin")
+    frames_list= break_vid[0]
+    fps = break_vid[1]
+    print(f"ORIGIN FPS: {fps}")
+    n_frame = int(4*fps) #limited to 4 seconds
+    #n_frame = len(frames_list)
+    
+    if n_frame >= len(frames_list):
+        print("video is shorter than the cut value")
+        n_frame = len(frames_list)
+    
+    # 2. prepare frames result arrays
+    result_frames = []
+    # print("set stop frames to: " + str(n_frame))
+    
+    
+    for idx, frame in enumerate(frames_list[0:int(n_frame)]):
+        if idx < len(frames_list) - 1:
+            next_frame = frames_list[idx+1]
+            interpolated_frames = do_interpolation(frame, next_frame, interpolation) # should return a list of 3 interpolated frames
+            break_interpolated_video = get_frames(interpolated_frames, "interpol",f"{idx}_")
+            print(break_interpolated_video[0])
+            for j, img in enumerate(break_interpolated_video[0][0:len(break_interpolated_video[0])-1]):
+                #print(f"IMG:{img}")
+                # we could use png to avoid any compression artifact, but it takes much more space
+                # alternatively, let's just bump the quality from 95 to 98 for now
+                os.rename(img, f"{frame}_to_{next_frame}_{j}.jpg", [int(cv2.IMWRITE_JPEG_QUALITY), 98])
+                result_frames.append(f"{frame}_to_{next_frame}_{j}.jpg")
+            
+            print("frames " + str(idx) + " & " + str(idx+1) + "/" + str(n_frame) + ": done;")
+            #print(f"CURRENT FRAMES: {result_frames}")
+    result_frames.append(f"{frames_list[n_frame-1]}")
+    final_vid = create_video(result_frames, fps_output, "interpolated")
+
+    encoded_string = ""
+    
+     # Convert video to base64
+    with open(final_vid, "rb") as video_file:
+        encoded_string = base64.b64encode(video_file.read()).decode('utf-8')
+                   
+    return f"data:video/mp4;base64,{encoded_string}"
+    
 
 title="""test space"""