app.py

import tkinter as tk
from tkinter import filedialog, messagebox
from PIL import Image, ImageTk
import cv2
import os
from datetime import datetime
import traceback
import re
import time
from scenedetect import open_video, SceneManager
from scenedetect.detectors import ContentDetector
from ffpyplayer.player import MediaPlayer
from tkinterdnd2 import DND_FILES, TkinterDnD

class App(TkinterDnD.Tk):
    def __init__(self):
        TkinterDnD.Tk.__init__(self)
        self.title("MVシーン抽出ツール")
        self.geometry("1240x800")
        self.base_dir = os.path.dirname(os.path.abspath(__file__))
        
        # Video and Playback State
        self.video_path = None
        self.cap = None
        self.fps = 0
        self.total_frames = 0
        self.is_playing = False
        self.after_id = None
        self.audio_player = None

        # Scene Extraction State
        self.thumbnail_widgets = []
        self.selected_thumbnail_index = None
        self.extracted_frames = []
        self.checked_vars = []
        self.scene_threshold = 27 # Default threshold
        self.min_scene_len = 15 # Default minimum scene length
        self.luma_only = tk.BooleanVar(value=False) # Default to considering color

        # --- Main Layout ---
        main_frame = tk.Frame(self)
        main_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)

        left_frame = tk.Frame(main_frame)
        left_frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        left_frame.pack_propagate(False) # Prevent resizing

        right_frame = tk.Frame(main_frame, width=720)
        right_frame.pack(side=tk.RIGHT, fill=tk.Y, padx=(10, 0))

        # --- Left Frame: Video Preview and Controls ---
        self.video_frame = tk.Frame(left_frame)
        self.video_frame.pack(fill=tk.BOTH, expand=True)
        self.video_frame.pack_propagate(False)

        self.video_preview_label = tk.Label(self.video_frame, text="動画プレビュー", bg="black", fg="white")
        self.video_preview_label.pack(fill=tk.BOTH, expand=True)
        self.video_preview_label.drop_target_register(DND_FILES)
        self.video_preview_label.dnd_bind('<<Drop>>', self._on_drop)

        # Playback Controls
        playback_frame = tk.Frame(left_frame)
        playback_frame.pack(fill=tk.X, pady=5)
        self.play_btn = tk.Button(playback_frame, text="▶ 再生", command=self.toggle_play, state=tk.DISABLED)
        self.play_btn.pack(side=tk.LEFT, padx=5)
        self.seek_bar = tk.Scale(playback_frame, from_=0, to=100, orient=tk.HORIZONTAL, showvalue=False, state=tk.DISABLED)
        self.seek_bar.bind("<ButtonRelease-1>", self.on_seek_release)
        self.seek_bar.pack(fill=tk.X, expand=True, padx=5)
        self.time_label = tk.Label(playback_frame, text="00:00 / 00:00")
        self.time_label.pack(side=tk.RIGHT, padx=5)

        # Main Controls
        main_control_frame = tk.Frame(left_frame)
        main_control_frame.pack(fill=tk.X, pady=5)
        self.select_video_btn = tk.Button(main_control_frame, text="動画を選択", command=self.select_video)
        self.select_video_btn.pack(side=tk.LEFT, padx=5)
        self.detect_scenes_btn = tk.Button(main_control_frame, text="シーンを検出", command=self.detect_scenes, state=tk.DISABLED)
        self.detect_scenes_btn.pack(side=tk.LEFT, padx=5)

        # Scene Sensitivity Control
        scene_control_frame = tk.Frame(left_frame)
        scene_control_frame.pack(fill=tk.X, pady=5)
        self.threshold_label = tk.Label(scene_control_frame, text=f"感度: {self.scene_threshold}")
        self.threshold_label.pack(side=tk.LEFT, padx=5)
        self.threshold_scale = tk.Scale(scene_control_frame, from_=1, to=100, orient=tk.HORIZONTAL,
                                        command=self._update_threshold_label, showvalue=False, length=200) # Fixed length
        self.threshold_scale.set(self.scene_threshold)
        self.threshold_scale.pack(side=tk.LEFT, padx=5)

        # Minimum Scene Length Control
        self.min_scene_len_label = tk.Label(scene_control_frame, text=f"最小シーン長: {self.min_scene_len}")
        self.min_scene_len_label.pack(side=tk.LEFT, padx=5)
        self.min_scene_len_scale = tk.Scale(scene_control_frame, from_=1, to=100, orient=tk.HORIZONTAL,
                                            command=self._update_min_scene_len_label, showvalue=False, length=200) # Fixed length
        self.min_scene_len_scale.set(self.min_scene_len)
        self.min_scene_len_scale.pack(side=tk.LEFT, padx=5)

        # Luma Only Control
        self.luma_only_check = tk.Checkbutton(scene_control_frame, text="輝度のみ", variable=self.luma_only)
        self.luma_only_check.pack(side=tk.LEFT, padx=5)

        # --- Right Frame: Extracted Frames ---
        right_header_frame = tk.Frame(right_frame)
        right_header_frame.grid(row=0, column=0, columnspan=2, sticky=tk.EW)
        frames_header_label = tk.Label(right_header_frame, text="抽出したフレーム")
        frames_header_label.pack(side=tk.LEFT, expand=True)

        # New control frame for buttons
        right_control_frame = tk.Frame(right_frame)
        right_control_frame.grid(row=1, column=0, columnspan=2, sticky=tk.EW, pady=5)
        self.check_all_btn = tk.Button(right_control_frame, text="すべて選択/解除", command=self.toggle_check_all, state=tk.DISABLED)
        self.check_all_btn.pack(side=tk.LEFT, fill=tk.X, expand=True, padx=5)
        self.save_frame_btn = tk.Button(right_control_frame, text="チェックした画像を保存", command=self.save_checked_frames, state=tk.DISABLED)
        self.save_frame_btn.pack(side=tk.RIGHT, fill=tk.X, expand=True, padx=5)

        self.frames_canvas = tk.Canvas(right_frame, borderwidth=2, relief="sunken")
        self.frames_canvas.grid(row=2, column=0, sticky=tk.NSEW)
        self.frames_scrollbar = tk.Scrollbar(right_frame, orient="vertical", command=self.frames_canvas.yview)
        self.frames_scrollbar.grid(row=2, column=1, sticky=tk.NS)
        self.scrollable_frame = tk.Frame(self.frames_canvas)
        self.scrollable_frame.bind("<Configure>", lambda e: self.frames_canvas.configure(scrollregion=self.frames_canvas.bbox("all")))
        self.frames_canvas.create_window((0, 0), window=self.scrollable_frame, anchor="nw")
        self.frames_canvas.configure(yscrollcommand=self.frames_scrollbar.set)

        # Configure row and column weights for right_frame to make frames_canvas expand
        right_frame.grid_rowconfigure(2, weight=1)
        right_frame.grid_columnconfigure(0, weight=1)
        
        # --- Bottom Frame: Status and Warning ---
        bottom_frame = tk.Frame(self, height=30)
        bottom_frame.pack(side=tk.BOTTOM, fill=tk.X, padx=10, pady=(0, 5))
        warning_label = tk.Label(bottom_frame, text="注意: Soraで生成された動画は、著作権やウォーターマークの対象となる場合があります。", fg="gray")
        warning_label.pack(side=tk.LEFT)

        self.protocol("WM_DELETE_WINDOW", self.on_closing)

    def select_video(self):
        file_path = filedialog.askopenfilename(title="動画ファイルを選択", filetypes=(("MP4 ファイル", "*.mp4"), ("すべてのファイル", "*.*")))
        if not file_path:
            return
        self.select_video_from_path(os.path.abspath(file_path))

    def select_video_from_path(self, path):
        if self.is_playing:
            self.toggle_play()
        if self.cap is not None:
            self.cap.release()
        if self.audio_player is not None:
            self.audio_player.close_player()

        self.video_path = path
        os.chdir(self.base_dir)
        
        self.cap = cv2.VideoCapture(self.video_path)
        if not self.cap.isOpened():
            messagebox.showerror("エラー", "動画ファイルを開けませんでした。")
            self.cap = None
            return

        try:
            self.audio_player = MediaPlayer(self.video_path)
            self.audio_player.set_pause(True)
        except Exception as e:
            messagebox.showwarning("警告", f"音声ファイルの読み込みに失敗しました: {e}")
            self.audio_player = None

        self.fps = self.cap.get(cv2.CAP_PROP_FPS)
        self.total_frames = int(self.cap.get(cv2.CAP_PROP_FRAME_COUNT))
        
        # Reset and setup UI
        self.detect_scenes_btn.config(state=tk.NORMAL)
        self.play_btn.config(state=tk.NORMAL)
        self.seek_bar.config(state=tk.NORMAL, to=self.total_frames - 1)
        self.seek_bar.set(0)
        self._update_time_label()
        self.save_frame_btn.config(state=tk.DISABLED)
        self.check_all_btn.config(state=tk.DISABLED)
        self.selected_thumbnail_index = None
        self.extracted_frames.clear()
        self.checked_vars.clear()
        for widget in self.thumbnail_widgets:
            widget.destroy()
        self.thumbnail_widgets.clear()

        ret, frame = self.cap.read()
        if ret:
            self._display_main_preview(frame)

    def _on_drop(self, event):
        file_path = event.data
        if file_path.startswith('{') and file_path.endswith('}'):
            file_path = file_path[1:-1] # Remove curly braces

        if os.path.isfile(file_path):
            self.select_video_from_path(os.path.abspath(file_path))
        else:
            messagebox.showwarning("警告", "無効なファイルがドロップされました。")

    def on_closing(self):
        if self.is_playing:
            self.toggle_play()
        if self.cap is not None:
            self.cap.release()
        if self.audio_player is not None:
            self.audio_player.close_player()
        self.destroy()

    def _display_main_preview(self, frame):
        preview_width = self.video_frame.winfo_width()
        preview_height = self.video_frame.winfo_height()
        if preview_width < 50 or preview_height < 50: preview_width, preview_height = 640, 360 # Default if not yet rendered

        h, w, _ = frame.shape
        aspect_ratio = w / h
        if w > preview_width or h > preview_height:
            if (preview_width / aspect_ratio) <= preview_height: new_w, new_h = preview_width, int(preview_width / aspect_ratio)
            else: new_h, new_w = preview_height, int(preview_height * aspect_ratio)
            frame = cv2.resize(frame, (new_w, new_h), interpolation=cv2.INTER_AREA)

        img_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
        img_pil = Image.fromarray(img_rgb)
        img_tk = ImageTk.PhotoImage(image=img_pil)
        self.video_preview_label.config(image=img_tk, text="")
        self.video_preview_label.image = img_tk

    def toggle_play(self):
        self.is_playing = not self.is_playing
        if self.is_playing:
            self.play_btn.config(text="❚❚ 一時停止")
            if self.audio_player:
                self.audio_player.set_pause(False)
            self.play_video()
        else:
            self.play_btn.config(text="▶ 再生")
            if self.audio_player:
                self.audio_player.set_pause(True)
            if self.after_id:
                self.after_cancel(self.after_id)
                self.after_id = None

    def play_video(self):
        if not self.is_playing or self.cap is None:
            return

        start_time = time.time()
        
        # Audio synchronization
        if self.audio_player:
            audio_pts = self.audio_player.get_pts()
            if audio_pts is not None:
                # Calculate target frame based on audio PTS
                target_frame_num = int(audio_pts * self.fps)
                current_video_frame = int(self.cap.get(cv2.CAP_PROP_POS_FRAMES))
                
                # Only seek if the video is significantly out of sync
                if abs(target_frame_num - current_video_frame) > self.fps / 2: # If more than half a second off
                    self.cap.set(cv2.CAP_PROP_POS_FRAMES, target_frame_num)

        ret, frame = self.cap.read()
        if ret:
            current_frame = int(self.cap.get(cv2.CAP_PROP_POS_FRAMES))
            self._display_main_preview(frame)
            self.seek_bar.set(current_frame)
            self._update_time_label(current_frame)
            end_time = time.time()
            elapsed_time_ms = (end_time - start_time) * 1000
            ideal_delay_ms = 1000 / self.fps
            delay_ms = max(1, int(ideal_delay_ms - elapsed_time_ms))
            self.after_id = self.after(delay_ms, self.play_video)
        else:
            self.toggle_play()

    def on_seek_release(self, event):
        if self.cap is None:
            return
        
        was_playing = self.is_playing
        if was_playing:
            # Manually pause video and audio
            self.is_playing = False
            self.play_btn.config(text="▶ 再生")
            if self.audio_player:
                self.audio_player.set_pause(True)
            if self.after_id:
                self.after_cancel(self.after_id)
                self.after_id = None

        frame_num = self.seek_bar.get()
        
        # Calculate target time in milliseconds
        target_frame_num = self.seek_bar.get()
        current_frame_num = int(self.cap.get(cv2.CAP_PROP_POS_FRAMES))

        # If seeking backward or to the very beginning, re-initialize and fast-forward
        if target_frame_num < current_frame_num or target_frame_num == 0:
            # Close existing players
            if self.cap is not None:
                self.cap.release()
            if self.audio_player is not None:
                self.audio_player.close_player()
            
            # Re-initialize players
            self.cap = cv2.VideoCapture(self.video_path)
            if not self.cap.isOpened():
                messagebox.showerror("エラー", "動画ファイルを開けませんでした。")
                self.cap = None
                return

            try:
                self.audio_player = MediaPlayer(self.video_path)
                self.audio_player.set_pause(True) # Start paused
            except Exception as e:
                messagebox.showwarning("警告", f"音声ファイルの読み込みに失敗しました: {e}")
                self.audio_player = None

            # Fast-forward to target_frame_num
            for _ in range(target_frame_num):
                ret, frame = self.cap.read()
                if not ret:
                    break

            # After fast-forwarding video, seek audio player to the correct position
            if self.audio_player:
                try:
                    self.audio_player.seek(target_frame_num / self.fps)
                except Exception as e:
                    print(f"Error seeking audio during fast-forward: {e}")
                    messagebox.showwarning("警告", f"早送り中の音声シーク中にエラーが発生しました: {e}")
        else:
            # For forward seeking, use direct seek (current reliable method)
            target_time_ms = (target_frame_num / self.fps) * 1000
            self.cap.set(cv2.CAP_PROP_POS_MSEC, target_time_ms)
            if self.audio_player:
                try:
                    self.audio_player.seek(target_frame_num / self.fps)
                except Exception as e:
                    print(f"Error seeking audio: {e}")
                    messagebox.showwarning("警告", f"音声シーク中にエラーが発生しました: {e}")

        # Read and display the frame at the target position
        ret, frame = self.cap.read()
        if ret:
            self._display_main_preview(frame)
            self._update_time_label(target_frame_num) # Update time label with target frame
        else:
            messagebox.showwarning("警告", "シーク後にフレームを読み込めませんでした。")
            if was_playing:
                self.is_playing = False
                self.play_btn.config(text="▶ 再生")
                if self.audio_player:
                    self.audio_player.set_pause(True)
                if self.after_id:
                    self.after_cancel(self.after_id)
                    self.after_id = None
            return
        
        if was_playing:
            # Manually resume video and audio
            self.is_playing = True
            self.play_btn.config(text="❚❚ 一時停止")
            if self.audio_player:
                self.audio_player.set_pause(False)
            self.play_video()

    def _update_time_label(self, current_frame=0):
        if self.total_frames > 0 and self.fps > 0:
            current_time = datetime.utcfromtimestamp(current_frame / self.fps).strftime('%M:%S')
            total_time = datetime.utcfromtimestamp(self.total_frames / self.fps).strftime('%M:%S')
            self.time_label.config(text=f"{current_time} / {total_time}")

    def _update_threshold_label(self, value):
        self.scene_threshold = int(value)
        self.threshold_label.config(text=f"感度: {self.scene_threshold}")

    def _update_min_scene_len_label(self, value):
        self.min_scene_len = int(value)
        self.min_scene_len_label.config(text=f"最小シーン長: {self.min_scene_len}")

    def detect_scenes(self):
        if not self.video_path: messagebox.showwarning("警告", "最初に動画を選択してください。"); return
        if self.is_playing: self.toggle_play()

        self.config(cursor="watch"); self.update_idletasks()
        self.save_frame_btn.config(state=tk.DISABLED); self.check_all_btn.config(state=tk.DISABLED)
        self.selected_thumbnail_index = None; self.extracted_frames.clear(); self.checked_vars.clear()
        for widget in self.thumbnail_widgets: widget.destroy()
        self.thumbnail_widgets.clear()

        try:
            video_stream = open_video(self.video_path)
            scene_manager = SceneManager()
            scene_manager.add_detector(ContentDetector(threshold=self.scene_threshold,
                                                       min_scene_len=self.min_scene_len,
                                                       luma_only=self.luma_only.get()))
            scene_manager.detect_scenes(video=video_stream, show_progress=False)
            scene_list = scene_manager.get_scene_list()

            self.cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
            ret, first_frame = self.cap.read()
            if ret: self.extracted_frames.append(first_frame)

            if scene_list:
                for scene in scene_list:
                    start_frame_num = scene[0].get_frames()
                    if start_frame_num > 0:
                        self.cap.set(cv2.CAP_PROP_POS_FRAMES, start_frame_num)
                        ret, frame = self.cap.read()
                        if ret and not any((frame == ef).all() for ef in self.extracted_frames):
                            self.extracted_frames.append(frame)

            if not self.extracted_frames: messagebox.showinfo("情報", "ユニークなフレームを抽出できませんでした。"); return

            self._display_thumbnails()
            if self.extracted_frames: self.save_frame_btn.config(state=tk.NORMAL); self.check_all_btn.config(state=tk.NORMAL)

        except Exception as e: messagebox.showerror("シーン検出エラー", f"エラーが発生しました: {e}\n\nトレースバック:\n{traceback.format_exc()}")
        finally: self.config(cursor="")

    def _display_thumbnails(self):
        num_columns = 3; thumb_width = 120
        for i, frame in enumerate(self.extracted_frames):
            row, col = divmod(i, num_columns)
            h, w, _ = frame.shape; aspect_ratio = w / h; new_h = int(thumb_width / aspect_ratio)
            thumb = cv2.resize(frame, (thumb_width, new_h), interpolation=cv2.INTER_AREA)
            img_rgb = cv2.cvtColor(thumb, cv2.COLOR_BGR2RGB)
            img_pil = Image.fromarray(img_rgb)
            img_tk = ImageTk.PhotoImage(image=img_pil)
            thumb_frame = tk.Frame(self.scrollable_frame, bd=2, relief="solid", borderwidth=1, bg="gray")
            thumb_frame.grid(row=row, column=col, padx=5, pady=5)
            thumb_label = tk.Label(thumb_frame, image=img_tk); thumb_label.pack()
            check_var = tk.BooleanVar(value=False); check_button = tk.Checkbutton(thumb_frame, variable=check_var); check_button.pack()
            thumb_label.bind("<Button-1>", lambda e, index=i: self._on_thumbnail_click(index))
            self.thumbnail_widgets.append(thumb_frame); thumb_frame.image = img_tk; self.checked_vars.append(check_var)

    def toggle_check_all(self):
        new_state = any(not var.get() for var in self.checked_vars)
        for var in self.checked_vars: var.set(new_state)

    def _on_thumbnail_click(self, index):
        if self.is_playing: self.toggle_play()
        if self.selected_thumbnail_index is not None: self.thumbnail_widgets[self.selected_thumbnail_index].config(bg="gray", borderwidth=1)
        self.selected_thumbnail_index = index
        self.thumbnail_widgets[index].config(bg="dodgerblue", borderwidth=2)
        selected_frame = self.extracted_frames[index]
        self._display_main_preview(selected_frame)

    def save_checked_frames(self):
        if self.is_playing: self.toggle_play()
        checked_indices = [i for i, var in enumerate(self.checked_vars) if var.get()]
        if not checked_indices: messagebox.showwarning("警告", "保存するフレームにチェックを入れてください。"); return

        output_dir = os.path.join(self.base_dir, "output"); os.makedirs(output_dir, exist_ok=True)
        base_name = os.path.splitext(os.path.basename(self.video_path))[0]
        safe_base_name = re.sub(r'[\\/:*?"<>|]', '_', base_name)
        timestamp = datetime.now().strftime("%Y%m%d%H%M%S")
        
        saved_count = 0; failed_files = []
        try:
            for i, frame_index in enumerate(checked_indices):
                file_name = f"{safe_base_name}_{timestamp}_{i+1:03d}.png"
                file_path = os.path.abspath(os.path.join(output_dir, file_name))
                frame_to_save = self.extracted_frames[frame_index]
                result, encoded_image = cv2.imencode('.png', frame_to_save)
                if result:
                    try:
                        with open(file_path, 'wb') as f: f.write(encoded_image)
                        if os.path.exists(file_path): saved_count += 1
                        else: failed_files.append(file_name + " (書き込み後ファイル未検出)")
                    except IOError as e: failed_files.append(file_name + f" (IOエラー: {e})")
                else: failed_files.append(file_name + " (エンコード失敗)")
            
            if saved_count > 0: messagebox.showinfo("成功", f"{saved_count} フレームの保存に成功しました。\n場所: {output_dir}")
            if failed_files: messagebox.showerror("保存エラー", f"以下のファイルの保存に失敗しました:\n{', '.join(failed_files)}")
        except Exception as e: messagebox.showerror("エラー", f"保存中にエラーが発生しました: {e}")

if __name__ == "__main__":
    app = App()
    app.mainloop()