【初心者歓迎】動画分割・結合ツールを作ろう（ffmpegで動画の切り出しと結合）

import os
import sys
os.add_dll_directory(os.getcwd())
sys.path.append(os.path.join(os.path. dirname(__file__), '../libs'))
import customtkinter as ctk  # カスタムウィジェットを提供するライブラリをインポート
import vlc  # VLCメディアプレーヤーライブラリをインポート
from datetime import datetime  # 日時操作のためのdatetimeモジュールをインポート
from customtkintercontrols import App,CenterWindow,FileSelectionControl,TextBoxControl,FolderSelectionControl
from appconfig import AppConfig
from videoclipoperator import VideoClipOperater 

class MediaPlayer:
    """
    VLCメディアプレーヤーをラップして、動画の再生や制御を行うクラス。
    """
    def __init__(self, root):
        # VLCプレーヤーのインスタンスを作成
        self.instance = vlc.Instance("--no-xlib")
        self.player = self.instance.media_player_new()
        self.media = None
        self.is_playing = False  # 再生中かどうかのフラグ
        self.root = root
        self.frame = ctk.CTkFrame(root)  # 動画を表示するためのフレームを作成
        self.frame.pack(fill="both", expand=True)  # フレームをウィンドウに配置
        self.root.after(100, self.set_window_handle)  # 100ms後にウィンドウハンドルを設定

    def set_window_handle(self):
        # VLCプレーヤーにウィンドウハンドルを設定
        self.player.set_hwnd(self.frame.winfo_id())
        self.root.after(1000, self.configure_slider)  # 1秒後にスライダーの設定を行う

    def load(self, filename):
        # メディアファイルを読み込み、VLCプレーヤーに設定
        self.media = self.instance.media_new(filename)
        self.player.set_media(self.media)
        self.root.after(1000, self.configure_slider)  # 1秒後にスライダーの設定を行う

    def toggle_play_pause(self):
        # 再生/一時停止ボタンが押されたときの動作を切り替え
        if self.is_playing:
            self.pause()  # 再生中なら一時停止
        else:
            self.start()  # 停止中なら再生

    def start(self):
        # 再生を開始し、開始時刻を記録
        if not self.is_playing:
            self.player.play()
            self.is_playing = True

    def stop(self):
        # 再生を停止し、スライダーと時刻ラベルをリセット
        self.player.stop()
        self.is_playing = False
        scale.set(0)  # スライダーを左端に戻す
        time_label.configure(text="00:00:00.00")  # 時刻ラベルをリセット
    
    def pause(self):
        # 再生を一時停止し、終了時刻を記録
        if self.is_playing:
            self.player.pause()
            self.is_playing = False

    def start_mark(self):
        # 開始時刻をラベルに表示
        start_time_label.configure(text=time_label.cget("text")) 
        self.pause()

    def end_mark(self):
        # 終了時刻をラベルに表示
        end_time_label.configure(text=time_label.cget("text")) 
        self.pause()

    def seek(self, value):
        # スライダーを移動して再生位置を設定
        self.player.set_time(int(value))

    def get_time(self):
        # 現在の再生位置を取得
        return self.player.get_time()

    def get_length(self):
        # 動画の長さを取得
        length = self.player.get_length()
        return length

    def configure_slider(self):
        """
        動画の長さに応じてスライダーを設定し、再生を自動的に開始する関数。
        動画の長さが取得できなかった場合、再試行を行う。
        """
        video_length = self.get_length()
        if video_length > 0:
            scale.configure(to=video_length)  # スライダーの最大値を動画の長さに設定
            scale.set(0)  # スライダーを左端に設定
            self.start()  # 自動再生開始
        else:
            self.root.after(1000, self.configure_slider)  # 動画長さ取得に失敗したら再試行

def update_slider():
    # スライダーと時刻ラベルを更新する関数
    length = mp.get_length()
    current_time = mp.get_time()
    if length > 0:
        scale_value = int(current_time)
        if scale_value != scale.get():
            scale.set(scale_value)
            update_time_label(scale_value)  # スライダー位置に応じた時刻を更新

    root.after(100, update_slider)  # 100ms後に再度更新

def on_scale_move(event):
    # スライダーが動かされた時の処理
    global scale_dragging
    if scale_dragging:
        scale_value = scale.get()
        mp.seek(scale_value)

def update_time_label(milliseconds):
    # ミリ秒単位の時間を時分秒およびミリ秒に変換してラベルに表示
    seconds = milliseconds // 1000
    minutes = seconds // 60
    hours = minutes // 60
    seconds = seconds % 60
    minutes = minutes % 60
    millis = milliseconds % 1000
    time_label.configure(text=f"{hours:02}:{minutes:02}:{seconds:02}.{millis:02}"[:11])

def on_scale_press(event):
    # スライダーが押された時の処理
    global scale_dragging
    scale_dragging = True

def on_scale_release(event):
    # スライダーが離された時の処理
    global scale_dragging
    scale_dragging = False
    scale_value = scale.get()
    mp.seek(scale_value)  # スライダーの位置に応じて再生位置を変更
    update_time_label(scale_value)  # スライダー位置に応じた時刻を更新

def on_volume_change(value):
    # ボリュームスライダーが変更されたときの処理
    mp.player.audio_set_volume(int(value))

def add_clip():
    input_file = movie_dialog.get()
    action_text.set(action_text.get() + f'+{input_file}\n')

def cut_clip():
    # 追加ボタンクリック時の処理（開始時刻と終了時刻をテキストボックスに記録）
    start_time = start_time_label.cget("text")
    end_time = end_time_label.cget("text")
    if start_time != end_time:
        prefix = f"{start_time}_{end_time}".replace(":","").replace(".","")
        input_file = movie_dialog.get()
        _,ext = os.path.splitext(os.path.basename(input_file))
        text = f'+{start_time},{end_time},{input_file}' + f',temp_{prefix}{ext}\n'
        lines = action_text.get().split("\n")
        if not text.strip() in lines:
            action_text.set(action_text.get() + text)
        start_time_label.configure(text="00:00:00.00")
        end_time_label.configure(text="00:00:00.00")

def join_movie():
    # 結合ボタンクリック時の処理（結合後の出力ファイルパスを生成）
    movie_file = movie_dialog.get()
    base = os.path.basename(movie_file)
    name,ext = os.path.splitext(base)
    sufix = datetime.now().strftime('%H%M%S') # 現在時刻をプレフィックスに設定
    path = os.path.join(output_folder.get(),name)
    action_text.set(action_text.get() + f'={path}_{sufix}{ext}\n')
    
def selected():
    # ファイル選択ダイアログでファイル選択時の処理
    mp.load(movie_dialog.get())

def time_diff_hhmmss(time1_str, time2_str):
  """
  2つの時間文字列（hh:mm:ss形式）の差を計算し、hh:mm:ss形式で返す関数

  Args:
    time1_str (str): 開始時刻を表す文字列
    time2_str (str): 終了時刻を表す文字列

  Returns:
    str: 時間差を表す文字列（hh:mm:ss形式）
  """

  # 時間文字列をdatetimeオブジェクトに変換
  time_format = "%H:%M:%S.%f"
  time1 = datetime.strptime(time1_str, time_format)
  time2 = datetime.strptime(time2_str, time_format)

  # 時間差を計算
  time_diff = time2 - time1

  # 時間差をhh:mm:ss.000 形式の文字列に変換
  return str(time_diff)

def execute():
    # テキストボックスに表示されているファイル分割／結合処理を実行
    os.makedirs(temp_folder,exist_ok=True)
    vco = VideoClipOperater()
    queue = []
    for line in action_text.get().split("\n") :
        if line.strip() == "":
            continue
        items = line.split(",")
        if line[0] == "+":
            if len(items) == 1:
                queue.append(line[1:])
            else:
                input_path = items[2]
                output_path = os.path.join(temp_folder,items[3])
                queue.append(os.path.abspath(output_path)) # 相対パスを絶対パスに変換
                cut_start = items[0][1:]
                cut_end = items[1]
                cut_len =  time_diff_hhmmss(cut_start,cut_end) 
                vco.cut_video(input_path,cut_start,cut_len,output_path)
        if line[0] == "=":
            output_file = line[1:].strip()
            vco.merge_videos(queue,output_file)
            queue.clear()

def skip_backward():
    # 左に0.1秒進める関数
    current_time = mp.get_time()
    new_time = max(0, current_time - 100)  # 0.1秒（100ミリ秒）後退
    mp.seek(new_time)
    update_time_label(new_time)

def skip_forward():
    # 右に0.1秒進める関数
    current_time = mp.get_time()
    length = mp.get_length()
    new_time = min(length, current_time + 100)  # 0.1秒（100ミリ秒）前進
    mp.seek(new_time)
    update_time_label(new_time)

# ウィンドウを閉じる時に呼ばれる関数
def close_window():
    # 画面入力値を保存
    conf.set("movie_dialog",movie_dialog.get())
    conf.set("output_folder",output_folder.get())
    conf.set("action_text",action_text.get())
    conf.write()
    # プログラムの終了
    root.quit()  

if __name__ == "__main__":

    # -----------------------------------------------------
    # 作業フォルダの設定
    # ------------------------------------------------------
    temp_folder = "./temp"

    # -----------------------------------------------------
    # ウィンドウの作成
    # ------------------------------------------------------
    
    # メインウィンドウの設定
    root = App()
    CenterWindow(root,800,600)
    root.title("Video Player")
    
    # ウィンドウを閉じる時に呼びたい関数を登録
    root.protocol("WM_DELETE_WINDOW", close_window)

    # -----------------------------------------------------
    # 画面にウィジェットを配置
    # ------------------------------------------------------

    # ファイル選択ダイアログの配置
    movie_dialog = FileSelectionControl(root,command=selected)
    movie_dialog.pack(fill="x")
    
    # メディアプレイヤーの配置
    mp = MediaPlayer(root)  # MediaPlayerクラスのインスタンスを作成
    scale_dragging = False  # スライダーがドラッグされているかを管理

    # フレームの開始
    fm = ctk.CTkFrame(root)

    # 現在の再生位置（時刻）表示ラベル
    time_label = ctk.CTkLabel(fm, text="00:00:00.00")  
    time_label.grid(row=0, column=0, padx=10, pady=10)

    # スライダーの最大値を仮の値に設定
    scale = ctk.CTkSlider(fm, from_=0, to=100)
    scale.set(0)
    scale.grid(row=0, column=1, padx=10, pady=10, sticky="ew")

    # スライダーにイベントバインド
    scale.bind("<ButtonPress-1>", on_scale_press)
    scale.bind("<B1-Motion>", on_scale_move)
    scale.bind("<ButtonRelease-1>", on_scale_release)

    # 音量スライダーの追加
    volume_slider = ctk.CTkSlider(fm, width=60, from_=0, to=100, command=on_volume_change)
    volume_slider.set(50)  # 初期値を100に設定
    volume_slider.grid(row=0, column=2, padx=10, pady=10)

    #フレームの終了
    fm.grid_columnconfigure(1, weight=1)
    fm.pack(fill="x")

    # フレームの開始
    fm = ctk.CTkFrame(root)

    # 範囲のラベル
    space = ctk.CTkLabel(fm,text = "範囲")
    space.pack(side="left",padx=10)

    # 開始時刻を表示するラベル
    start_time_label = ctk.CTkLabel(fm, text="00:00:00.00")
    start_time_label.pack(side="left", padx=2)
    space = ctk.CTkLabel(fm,text = " ～ ")
    space.pack(side="left",padx=0)

    # 終了時刻を表示するラベル
    end_time_label = ctk.CTkLabel(fm, text="00:00:00.00")
    end_time_label.pack(side="left", padx=2)
    space = ctk.CTkLabel(fm,text = "")
    space.pack(side="left",padx=5)

    #［ 範囲の開始設定ボタン
    start_button = ctk.CTkButton(fm, text="［", width=40,command=lambda: mp.start_mark())
    start_button.pack(side="left", padx=2)

    # 左スキップボタンの配置
    backward_button = ctk.CTkButton(fm, text="<<", width=30, command=skip_backward)
    backward_button.pack(side="left", padx=2)

    # 再生／停止ボタン
    button1 = ctk.CTkButton(fm, text="再生/停止", width=80,command=lambda: mp.toggle_play_pause())
    button1.pack(side="left",padx=2)

    # 右スキップボタンの配置
    forward_button = ctk.CTkButton(fm, text=">>", width=30, command=skip_forward)
    forward_button.pack(side="left", padx=2)

    # ］範囲の終了設定ボタン
    end_button = ctk.CTkButton(fm, text="］", width=40,command=lambda: mp.end_mark())
    end_button.pack(side="left", padx=2)

    # 余白の設定
    space = ctk.CTkLabel(fm,text = "")
    space.pack(side="left",padx=5)


    # 切り出しボタン（ファイル指定区間）
    record_button = ctk.CTkButton(fm, text="切出", width=40,command=cut_clip)
    record_button.pack(side="left", padx=2)

    # 追加ボタン（ファイル丸ごと）
    record_button = ctk.CTkButton(fm, text="追加", width=40,command=add_clip)
    record_button.pack(side="left", padx=2)

    # 結合ボタン
    record_button = ctk.CTkButton(fm, text="結合", width=40,command=join_movie)
    record_button.pack(side="left", padx=2)

    # 再生終了ボタン
    button3 = ctk.CTkButton(fm, text="終了", width=40, command=lambda: mp.stop())
    button3.pack(side="left",padx=2)

    # 分割実行ボタン
    button3 = ctk.CTkButton(fm, text="実行", width=60, command=execute)
    button3.pack(side="left",padx=10)

    # フレームの終了
    fm.pack(pady=10)

    # 保存先フォルダ選択ダイアログ
    output_folder = FolderSelectionControl(root)
    output_folder.pack(padx=10,pady=10,fill="x")

    # 記録を表示するテキストボックス
    action_text = TextBoxControl(root)
    action_text.pack(padx=10,pady=10,fill="x")

    # スライダーと時刻の更新を開始
    root.after(100, update_slider)

    # ------------------------------------------------------
    # 前回の入力内容を復元
    # ------------------------------------------------------

    # 画面の入力項目をファイルに保存する
    conf = AppConfig("./config.json")
    conf.read()
    movie_dialog.set(conf.get("movie_dialog",""))
    output_folder.set(conf.get("output_folder",""))
    action_text.set(conf.get("action_text",""))

    # -----------------------------------------------------
    # CustomTkinter のメインループを開始
    # ------------------------------------------------------
    root.mainloop()  

import subprocess
import os
import shutil
import tempfile

class VideoClipOperater:
    def __init__(self,cut_encode=True,merge_encode=True):
        self.cut_encode = "" if cut_encode else "-c copy"
        self.merge_encode = "" if merge_encode else "-c copy"        
                
    def cut_video(self, input_video, start_time, end_time, output_video):
        """
        動画の指定範囲を切り出す

        Args:
            input_video (str): 入力動画ファイルパス
            start_frame (int): 開始フレーム
            end_frame (int): 終了フレーム
            output_video (str): 出力動画ファイルパス
        """
        # ffmpegコマンドを作成
        command = f'ffmpeg -ss {start_time} -i "{input_video}" -to {end_time} -y {self.cut_encode} "{output_video}"'
        subprocess.call(command, shell=True)
        

    def merge_videos(self, input_videos, output_video):
        """
        複数の動画を結合する

        Args:
            input_videos (list): 入力動画ファイルパスのリスト
            output_video (str): 出力動画ファイルパス
        """
        if len(input_videos) == 1:
            shutil.copy(input_videos[0], output_video)
        else:
            # 結合対象のファイルリストを一時ファイルとして作成
            with tempfile.NamedTemporaryFile(mode='w', delete=False) as temp_file:
                temp_file.writelines(f"file '{video}'\n" for video in input_videos)
                temp_file_name = temp_file.name

            # ffmpegコマンドの実行    
            command = f'ffmpeg -f concat -safe 0 -i "{temp_file_name}" {self.merge_encode} -y "{output_video}"'    
            subprocess.call(command, shell=True)
        
            # 一時ファイルの削除
            os.remove(temp_file_name)
    
    def get_video_info(self,input_video):
        """
        動画ファイルのフレームレートとビットレートを取得します。

        Args:
            input_video (str): 入力動画ファイルパス

        Returns:
            tuple: フレームレート (float), ビットレート (int)
        """

        # ffprobeコマンドを作成 (フレームレートとビットレートを取得)
        get_info_cmd = f'ffprobe -v error -select_streams v:0 -show_entries stream=r_frame_rate,bit_rate -of default=noprint_wrappers=1:nokey=1 "{input_video}"'
        res = subprocess.check_output(get_info_cmd, shell=True).decode('utf-8')

        # 出力結果を解析して、フレームレートとビットレートを抽出
        fps, bitrate_str = res.strip().replace("\r","").split("\n")
        fps = eval(fps)
        bitrate = int(bitrate_str)

        return fps, bitrate

from videoclipoperator import VideoClipOperater 

vc = VideoClipOperater()

# 動画から指定範囲を切り出す
vc.cut_video("d:/hoge1.mp4","00:30:00","00:05:00","d:/output1.mp4")
vc.cut_video("d:/hoge2.mp4","00:30:00","00:05:00","d:/output2.mp4")

# 動画の音声を入れ替える
vc .merge_videos(["d:/output1.mp4","d:/output2.mp4"],"d:/join.mp4"):

# 動画から音声を抽出する
framerate,bitrate = vc.get_video_info("d:/join.mp4"):