Video Composition

def combine_videos(
    video_paths: List[str], 
    max_duration: int, 
    max_clip_duration: int, 
    threads: int
) -> str:
    """
    Combines a list of videos into one video and returns the path to the combined video.
    
    Args:
        video_paths (List): A list of paths to the videos to combine.
        max_duration (int): The maximum duration of the combined video.
        max_clip_duration (int): The maximum duration of each clip.
        threads (int): The number of threads to use for video processing.
    
    Returns:
        str: The path to the combined video.
    """

def generate_video(
    combined_video_path: str,
    tts_path: str,
    subtitles_path: str,
    threads: int,
    subtitles_position: str,
    text_color: str,
) -> str:
    """
    This function creates the final video, with subtitles and audio.
    
    Args:
        combined_video_path (str): The path to the combined video.
        tts_path (str): The path to the text-to-speech audio.
        subtitles_path (str): The path to the subtitles.
        threads (int): The number of threads to use for video processing.
        subtitles_position (str): The position of the subtitles.
        text_color (str): The color of subtitle text.
    
    Returns:
        str: The path to the final video.
    """

def save_video(video_url: str, directory: str = str(TEMP_DIR)) -> str:
    """
    Saves a video from a given URL and returns the path to the video.
    
    Args:
        video_url (str): The URL of the video to save.
        directory (str): The path of the temporary directory to save the video to.
    
    Returns:
        str: The path to the saved video.
    """
    destination = Path(directory).expanduser().resolve()
    destination.mkdir(parents=True, exist_ok=True)
    video_id = uuid.uuid4()
    video_path = destination / f"{video_id}.mp4"
    with open(video_path, "wb") as f:
        f.write(requests.get(video_url).content)
    return str(video_path)

# Required duration of each clip
req_dur = max_duration / len(video_paths)

log("[+] Combining videos...", "info")
log(f"[+] Each clip will be maximum {req_dur} seconds long.", "info")

# Not all videos are same size, so we need to resize them
if round((clip.w / clip.h), 4) < 0.5625:
    # Video is too tall, crop height
    clip = clip.cropped(
        width=clip.w,
        height=round(clip.w / 0.5625),
        x_center=clip.w / 2,
        y_center=clip.h / 2,
    )
else:
    # Video is too wide, crop width
    clip = clip.cropped(
        width=round(0.5625 * clip.h),
        height=clip.h,
        x_center=clip.w / 2,
        y_center=clip.h / 2,
    )
# Resize to standard 1080x1920
clip = clip.resized(new_size=(1080, 1920))

clips = []
tot_dur = 0

# Add downloaded clips over and over until the duration of the audio has been reached
while tot_dur < (max_duration - FRAME_EPSILON):
    progressed = False
    for video_path in video_paths:
        remaining = max_duration - tot_dur
        if remaining <= FRAME_EPSILON:
            break
        
        clip = VideoFileClip(video_path)
        clip = clip.without_audio()
        
        # Calculate target duration
        target_duration = min(req_dur, max_clip_duration, remaining)
        target_duration = min(target_duration, clip.duration - FRAME_EPSILON)
        
        if target_duration > 0:
            if target_duration < clip.duration:
                clip = clip.subclipped(0, target_duration)
            clips.append(clip)
            tot_dur += clip.duration
            progressed = True
    
    if not progressed:
        raise RuntimeError("Could not reach target duration from source videos.")

FRAME_EPSILON = 1 / 120  # ~0.008 seconds

final_clip = concatenate_videoclips(clips, method="compose")
final_clip = final_clip.with_fps(30).with_duration(max_duration)

final_clip.write_videofile(
    str(combined_video_path),
    threads=threads,
    fps=30,
    codec="libx264",
    preset="medium",
    audio=False,
)

# Make a generator that returns a TextClip when called with consecutive subtitles
font_path = str((FONTS_DIR / "bold_font.ttf").resolve())
generator = lambda txt: TextClip(
    font=font_path,
    text=txt,
    font_size=100,
    color=text_color,
    stroke_color="black",
    stroke_width=5,
)

# Split the subtitles position into horizontal and vertical
horizontal_subtitles_position, vertical_subtitles_position = (
    subtitles_position.split(",")
)

# Burn the subtitles into the video
subtitles = SubtitlesClip(subtitles_path, make_textclip=generator)
subtitle_vertical_position = vertical_subtitles_position
if vertical_subtitles_position == "top":
    subtitle_vertical_position = 80

base_video = VideoFileClip(str(combined_video_path))
audio = AudioFileClip(tts_path)
target_duration = min(base_video.duration, audio.duration)

result = CompositeVideoClip(
    [
        base_video.subclipped(0, target_duration),
        subtitles.with_position(
            (horizontal_subtitles_position, subtitle_vertical_position)
        ).with_duration(target_duration),
    ]
)

# Add audio track
result = result.with_audio(audio.subclipped(0, target_duration)).with_duration(
    target_duration
)

result.write_videofile(
    str(output_path),
    threads=threads or 2,
    fps=30,
    codec="libx264",
    audio_codec="aac",
    preset="medium",
)

from Backend.video import combine_videos, generate_video
from Backend.search import search_for_stock_videos
from Backend.tiktokvoice import tts
from Backend.video import save_video, generate_subtitles

# 1. Search and download videos
video_urls = search_for_stock_videos(
    query="space exploration",
    api_key="YOUR_API_KEY",
    it=3,
    min_dur=5
)

video_paths = [save_video(url) for url in video_urls]

# 2. Generate TTS audio
tts(
    text="Welcome to this video about space exploration.",
    voice="en_us_001",
    filename="audio.mp3"
)

# 3. Combine videos
combined_video = combine_videos(
    video_paths=video_paths,
    max_duration=30,
    max_clip_duration=10,
    threads=4
)

# 4. Generate subtitles
subtitles_path = generate_subtitles(
    audio_path="audio.mp3",
    sentences=["Welcome to this video about space exploration."],
    audio_clips=[AudioFileClip("audio.mp3")],
    voice="en_us_001"
)

# 5. Generate final video
final_video = generate_video(
    combined_video_path=combined_video,
    tts_path="audio.mp3",
    subtitles_path=subtitles_path,
    threads=4,
    subtitles_position="center,bottom",
    text_color="white"
)

print(f"Final video: {final_video}")

try:
    final_clip.write_videofile(...)
finally:
    final_clip.close()
    for clip in clips:
        clip.close()

target_duration = min(base_video.duration, audio.duration)