Add stuff

animate.py

@@ -164,24 +164,25 @@ def resize(width, img):
     return img
 
 
-def resize_img(img1, img2):
-    img_target_size = Image.open(img1)
+def resize_img(cv2_images[0], cv2_images[1]):
+    img_target_size = Image.open(cv2_images[0])
     img_to_resize = resize_and_crop(
-        img2,
+        cv2_images[1],
         (
             img_target_size.size[0],
             img_target_size.size[1],
-        ),  # set width and height to match img1
+        ),  # set width and height to match cv2_images[0]
         crop_origin="middle",
     )
-    img_to_resize.save("resized_img2.png")
+    img_to_resize.save("resized_cv2_images[1].png")
 
 
-def predict(frame1, frame2, times_to_interpolate, model_name):
-    model = models[model_name]
+def get_video_frames(images, times_to_interpolate=6, model_name_index=0):
+    frame1 = images[0]
+    frame2 = images[1]
 
-    img1 = cv2.imread(frame1)
-    img2 = cv2.imread(frame2)
+    model = models[model_name_index]
+    cv2_images = [cv2.imread(frame1), cv2.imread(frame2)]
 
     frame1 = resize(256, frame1)
     frame2 = resize(256, frame2)
@@ -190,26 +191,30 @@ def predict(frame1, frame2, times_to_interpolate, model_name):
     frame2.save("test2.png")
 
     resize_img("test1.png", "test2.png")
-    input_frames = ["test1.png", "resized_img2.png"]
+    input_frames = ["test1.png", "resized_cv2_images[1].png"]
 
     frames = list(
         util.interpolate_recursively_from_files(
             input_frames, times_to_interpolate, model
         )
     )
+    return frames, cv2_images
 
-    mediapy.write_video("out.mp4", frames, fps=5)
 
-    print(f"TYPES....{type(img1)},{type(img2)} SHAPES{img1.shape} Img {img1}")
-    clip1, clip3 = contourfinder(img1, img2)  # has a third text option
+def create_mp4_with_audio(frames, cv2_images, duration, audio, output_path):
+    temp_vid_path = "TEMP.mp4"
+    mediapy.write_video(temp_vid_path, frames, fps=5)
+    print(f"TYPES....{type(cv2_images[0])},{type(cv2_images[1])} SHAPES{cv2_images[0].shape} Img {cv2_images[0]}")
+    clip1, clip3 = contourfinder(cv2_images[0], cv2_images[1])  # has a third text option
 
     # Use open CV and moviepy code
     # So we move from open CV video 1 to out.mp4 to open CV video2
     clip1 = clip1
-    clip2 = vfc("out.mp4").resize(8).set_start(clip1.duration - 0.5).crossfadein(2)
+    clip2 = vfc(temp_vid_path).resize(8).set_start(clip1.duration - 0.5).crossfadein(2)
     clip3 = clip3.set_start((clip1.duration - 0.5) + (clip2.duration)).crossfadein(2)
 
     new_clip = CompositeVideoClip([clip1, clip2, clip3])
-    new_clip.write_videofile("out.mp4")
-
-    return "out.mp4"
+    new_clip.set_audio(audio)
+    new_clip.set_duration(duration)
+    new_clip.write_videofile(output_path, audio_codec="aac")
+    return output_path

app.py

@@ -4,8 +4,9 @@ import subprocess
 import uuid
 from pathlib import Path
 
-import gradio as gr
-from moviepy.editor import AudioFileClip, ImageClip
+from moviepy.editor import AudioFileClip
+
+from animate import create_mp4_with_audio, get_video_frames
 
 output_dir = Path("temp/").absolute()
 output_dir.mkdir(exist_ok=True, parents=True)
@@ -14,8 +15,6 @@ os.chdir(
     output_dir
 )  # change working directory to output_dir because the hf spaces model has no option to specify output directory ¯\_(ツ)_/¯
 
-# TODO: Add an if statement that checks if a gpu is available, if one is then do weird stable diffusion stuff, if one isn't, then just use the regular hugging face api
-
 
 class SpotifyApi:
     spotify_directory = Path("spotify")
@@ -81,38 +80,26 @@ def process_inputs(
     return video
 
 
-def add_static_image_to_audio(image, audio_input) -> str:
-    """Create and save a video file to `output_path` after
-    combining a static image that is located in `image_path`
-    with an audio file in `audio_path`"""
+def animate_images(image_paths: list[str], audio_input: str) -> str:
     # Generate a random folder name and change directories to there
     foldername = str(uuid.uuid4())[:8]
     vid_output_dir = Path(output_dir / foldername)
     vid_output_dir.mkdir(exist_ok=True, parents=True)
     audio_clip = AudioFileClip(audio_input.path)
-    # Make the audio clip start at the specified time and set the duration to the specified duration
     audio_clip = audio_clip.subclip(
         audio_input.start_time, audio_input.start_time + audio_input.run_for
     )
-    image_clip = ImageClip(image)
-    video_clip = image_clip.set_audio(audio_clip)
-    video_clip.duration = (
-        audio_clip.duration
-    )  # The duration here is the cut duration from above
-    video_clip.fps = 1
+    video_frames, cv2_images = get_video_frames(image_paths)
     path = Path(vid_output_dir / "output.mp4").as_posix()
-    video_clip.write_videofile(path, audio_codec="aac")
-    return path
-
-def add_openv_animation_to_audio(image_paths: list[str], audio_path: str) -> str:
-    
-
+    return create_mp4_with_audio(
+        video_frames, cv2_images, audio_clip.duration, audio_clip, path
+    )
 
 
 def get_stable_diffusion_image(prompt) -> str:
     stable_diffusion = gr.Blocks.load(name="spaces/stabilityai/stable-diffusion")
     gallery_dir = stable_diffusion(prompt, fn_index=2)
-    return [os.path.join(gallery_dir, img) for img in os.listdir(gallery_dir)][0]
+    return [os.path.join(gallery_dir, img) for img in os.listdir(gallery_dir)][:2]
 
 
 iface = gr.Interface(
@@ -128,4 +115,4 @@ iface = gr.Interface(
 )
 
 
-iface.launch()
+iface.launch()