app.py

import os
import uuid
import moviepy.editor as mp
from PIL import Image
import gradio as gr

# ----------------------------------
# 공통적으로 사용할 로그 리스트
# ----------------------------------
global_logs = []

def add_log(message: str):
    """
    로그 메시지를 저장하는 함수
    """
    global_logs.append(message)
    print(message)

def parse_time_to_seconds(time_str: str):
    """
    시:분:초 형태의 문자열(예: '00:00:10' 또는 '00:01:02')을 초 단위(float)로 변환
    """
    try:
        h, m, s = time_str.split(":")
        total_seconds = int(h) * 3600 + int(m) * 60 + float(s)
        return total_seconds
    except Exception:
        return 0.0

def generate_thumbnail(video_clip, time_point):
    """
    특정 시점의 프레임을 썸네일로 생성하여 PIL.Image로 반환
    """
    try:
        frame = video_clip.get_frame(time_point)
        thumbnail_img = Image.fromarray(frame)
        return thumbnail_img
    except:
        # 만약 time_point가 재생시간 범위를 벗어나면 첫 프레임을 썸네일로
        frame = video_clip.get_frame(0)
        thumbnail_img = Image.fromarray(frame)
        return thumbnail_img

def process_video(video,
                  start_time_str,
                  end_time_str,
                  resolution_factor,
                  frame_rate_factor,
                  speed_factor,
                  repeat_count):
    """
    전체 GIF 변환 과정을 수행하는 함수
    """
    global global_logs
    global_logs = []  # 호출 시마다 로그를 초기화

    # 로그 1: 업로드된 파일 확인
    add_log("[LOG 1] 비디오 업로드 및 처리 시작")

    # 비디오 불러오기
    add_log("[LOG 2] 비디오 로드 중...")
    input_video = mp.VideoFileClip(video.name)

    # 재생시간 출력
    duration = input_video.duration
    add_log(f"[LOG 3] 업로드된 영상의 재생시간: {duration:.2f}초")

    # 시작/끝 시간 parse
    add_log("[LOG 4] 시작/끝 시간 파싱 중...")
    start_sec = parse_time_to_seconds(start_time_str)
    end_sec = parse_time_to_seconds(end_time_str)

    # 잘못된 입력 혹은 범위 벗어나면 자동 보정
    if start_sec < 0:
        start_sec = 0
    if end_sec <= 0 or end_sec > duration:
        end_sec = duration
    if start_sec >= end_sec:
        start_sec = 0
        end_sec = duration

    add_log(f"[LOG 5] 적용된 시작 시간: {start_sec}초, 종료 시간: {end_sec}초")

    # 해당 구간 자르기(subclip)
    add_log("[LOG 6] 영상 자르기 작업 진행...")
    clip = input_video.subclip(start_sec, end_sec)

    # 속도 조절
    if abs(speed_factor - 1.0) > 1e-3:
        add_log(f"[LOG 7] 속도 {speed_factor}배로 조절 중...")
        clip = clip.fx(mp.vfx.speedx, speed_factor)

    # 해상도 조절 (기본 1.0 = 원본)
    if abs(resolution_factor - 1.0) > 1e-3:
        add_log(f"[LOG 8] 해상도 {resolution_factor*100:.1f}%로 조절 중...")
        clip = clip.resize(resolution_factor)

    # 프레임 레이트 조절 (기본 원본 fps)
    original_fps = clip.fps
    target_fps = original_fps * frame_rate_factor
    add_log(f"[LOG 9] 프레임 레이트를 {target_fps:.2f}로 조절 중... (원본 {original_fps} FPS)")
    clip = clip.set_fps(target_fps)

    # 반복 회수 (최대 10회)
    repeat_count = min(max(int(repeat_count), 1), 10)
    add_log(f"[LOG 10] 반복 회수: {repeat_count}회")

    repeated_clips = [clip] * repeat_count
    final_clip = mp.concatenate_videoclips(repeated_clips)

    # GIF 생성
    add_log("[LOG 11] GIF 생성 중...")
    # 임시 파일 이름 생성
    output_filename = f"temp_{uuid.uuid4().hex}.gif"

    final_clip.write_gif(output_filename, fps=target_fps)

    add_log("[LOG 12] GIF 생성 완료! 파일명: " + output_filename)

    # GIF 미리보기용 이미지 반환 (첫 프레임)
    gif_preview = Image.open(output_filename)

    return gif_preview, output_filename, "\n".join(global_logs)

def update_thumbnails(video, start_time_str, end_time_str):
    """
    시작/끝 썸네일을 업데이트하기 위한 함수
    """
    input_video = mp.VideoFileClip(video.name)
    duration = input_video.duration

    start_sec = parse_time_to_seconds(start_time_str)
    end_sec = parse_time_to_seconds(end_time_str)
    # 범위 보정
    if start_sec < 0:
        start_sec = 0
    if end_sec <= 0 or end_sec > duration:
        end_sec = duration
    if start_sec >= end_sec:
        start_sec = 0
        end_sec = duration

    start_thumb = generate_thumbnail(input_video, start_sec)
    end_thumb = generate_thumbnail(input_video, end_sec)

    return start_thumb, end_thumb

# ------------------------------
# Gradio 인터페이스 구성 (Blocks)
# ------------------------------
with gr.Blocks() as demo:
    gr.Markdown("## 동영상을 GIF로 변환하기 데모")

    with gr.Tab("GIF 변환"):
        # 1. 업로드 입력창
        video_input = gr.Video(label="동영상 업로드", type="file")  # type="file"로 업로드 시 'video.name' 접근 가능

        # 4. 시작/끝 부분 시간 입력
        start_time = gr.Textbox(label="시작 시간 (예: 00:00:05)", value="00:00:00")
        end_time = gr.Textbox(label="종료 시간 (예: 00:00:10)", value="00:00:05")

        # 미리보기 썸네일 (시작, 종료)
        start_thumb_output = gr.Image(label="시작 썸네일 미리보기")
        end_thumb_output = gr.Image(label="종료 썸네일 미리보기")

        # 6. 해상도 조절 슬라이더(기본 1.0)
        resolution_slider = gr.Slider(label="해상도 비율 조절(0.1 ~ 1.0)", minimum=0.1, maximum=1.0, step=0.1, value=1.0)

        # 7. 프레임 속도 조절 슬라이더(기본 1.0)
        fps_slider = gr.Slider(label="프레임 레이트 배율 조절(0.1 ~ 2.0)", minimum=0.1, maximum=2.0, step=0.1, value=1.0)

        # 8. 속도 조절 슬라이더(기본 1배)
        speed_slider = gr.Slider(label="재생 속도 조절(0.5 ~ 2.0)", minimum=0.5, maximum=2.0, step=0.1, value=1.0)

        # 9. 반복 횟수
        repeat_slider = gr.Slider(label="GIF 반복 횟수(1 ~ 10)", minimum=1, maximum=10, step=1, value=1)

        # 10. GIF 생성 버튼
        generate_button = gr.Button("GIF 생성하기")

        # 11, 12. 결과 미리보기(이미지), 다운로드(링크)
        gif_preview_output = gr.Image(label="완성된 GIF 미리보기")
        download_output = gr.File(label="GIF 다운로드 링크")

        # 로그 출력
        logs_output = gr.Textbox(label="로그 출력", lines=10)

        # 썸네일 업데이트 이벤트
        # (입력 시간이 변할 때마다 자동으로 썸네일 갱신)
        start_time.change(
            fn=update_thumbnails,
            inputs=[video_input, start_time, end_time],
            outputs=[start_thumb_output, end_thumb_output]
        )
        end_time.change(
            fn=update_thumbnails,
            inputs=[video_input, start_time, end_time],
            outputs=[start_thumb_output, end_thumb_output]
        )

        # 영상 업로드될 때도 썸네일 자동 생성
        video_input.change(
            fn=update_thumbnails,
            inputs=[video_input, start_time, end_time],
            outputs=[start_thumb_output, end_thumb_output]
        )

        # GIF 생성 버튼 동작
        generate_button.click(
            fn=process_video,
            inputs=[
                video_input,
                start_time,
                end_time,
                resolution_slider,
                fps_slider,
                speed_slider,
                repeat_slider
            ],
            outputs=[
                gif_preview_output,
                download_output,
                logs_output
            ]
        )

    gr.Markdown("### [사용 가이드]\n1. 동영상을 업로드하세요.\n2. 시작/끝 시간을 적절히 입력하세요.\n3. 해상도, 프레임 속도, 재생 속도, 반복 횟수를 조절한 뒤 `GIF 생성하기` 버튼을 누르면 GIF가 생성됩니다.\n4. 결과 미리보기와 다운로드 링크를 통해 GIF를 확인할 수 있습니다.")

# 실행 (Spaces에서는 demo.launch()를 생략하거나 그대로 두어도 됩니다)
if __name__ == "__main__":
    demo.launch()