def video_to_audio(self, video_path: str, audio_path: str) -> bool:
    try:
        with VideoFileClip(video_path) as video:
            total_duration = video.duration
            audio = video.audio
            
            # 記錄音頻轉(zhuǎn)換開始時(shí)間
            self.audio_start_time = datetime.now()
            
            # 寫入音頻（logger=None關(guān)閉冗余輸出）
            audio.write_audiofile(audio_path, logger=None)
            # 強(qiáng)制進(jìn)度到100%
            self.update_audio_progress(100.0)
        return True
    except Exception as e:
        messagebox.showerror("錯(cuò)誤", f"音視頻轉(zhuǎn)音頻失敗：{str(e)}")
        return False

def load_whisper_model(self) -> Optional[whisper.Whisper]:
    try:
        model_name = self.model_var.get()
        self.update_transcribe_progress(10)
        # 加載指定模型，使用CPU運(yùn)行（可改為"cuda"啟用GPU加速）
        model = whisper.load_model(model_name, device="cpu") 
        self.update_transcribe_progress(20)
        return model
    except Exception as e:
        messagebox.showerror("錯(cuò)誤", f"模型加載失?。簕str(e)}")
        return None

def transcribe_audio(self, audio_path: str) -> Optional[dict]:
    global is_running
    self.model = self.load_whisper_model()
    if not self.model or not is_running:
        return None

    try:
        # 記錄字幕識(shí)別開始時(shí)間
        self.transcribe_start_time = datetime.now()
        
        # 分段識(shí)別模擬進(jìn)度
        self.update_transcribe_progress(30)
        result = self.model.transcribe(
            audio_path,
            language="zh",  # 指定中文識(shí)別
            temperature=self.temp_var.get(),  # 控制輸出隨機(jī)性
        )
        self.update_transcribe_progress(80)
        
        if not is_running:
            return None
        
        self.update_transcribe_progress(100)
        return result
    except Exception as e:
        messagebox.showerror("錯(cuò)誤", f"字幕識(shí)別失敗：{str(e)}")
        return None

def format_srt(self, result: dict) -> str:
    srt_content = ""
    for i, segment in enumerate(result["segments"], 1):
        start = self.format_time(segment["start"])
        end = self.format_time(segment["end"])
        # 繁簡(jiǎn)轉(zhuǎn)換（將可能的繁體轉(zhuǎn)為簡(jiǎn)體）
        text = self.cc.convert(segment["text"].strip())
        srt_content += f"{i}\n{start} --> {end}\n{text}\n\n"
    return srt_content

@staticmethod
def format_time(seconds: float) -> str:
    """將秒數(shù)格式化為SRT時(shí)間格式（hh:mm:ss,fff）"""
    hours = math.floor(seconds / 3600)
    minutes = math.floor((seconds % 3600) / 60)
    secs = math.floor(seconds % 60)
    millis = math.floor((seconds % 1) * 1000)
    return f"{hours:02d}:{minutes:02d}:{secs:02d},{millis:03d}"

def start_convert(self):
    """啟動(dòng)轉(zhuǎn)換線程"""
    thread = threading.Thread(target=self.convert_thread, daemon=True)
    thread.start()

def convert_thread(self):
    """轉(zhuǎn)換線程（避免UI卡頓）"""
    global is_running
    is_running = True
    self.start_btn.config(state=tk.DISABLED)
    self.stop_btn.config(state=tk.NORMAL)
    
    # 重置進(jìn)度和時(shí)間
    self.update_audio_progress(0.0)
    self.update_transcribe_progress(0.0)
    self.result_text.delete(1.0, tk.END)
    self.total_start_time = datetime.now()
    
    # 核心處理流程
    input_path = self.file_path_var.get()
    # 音頻提取 -> 語(yǔ)音識(shí)別 -> 字幕格式化 -> 保存文件
    # ...（省略具體步驟）

import tkinter as tk
from tkinter import ttk, filedialog, messagebox
import os
from moviepy import VideoFileClip
import whisper
import threading
import time
from datetime import datetime, timedelta
from typing import Optional
import math
from opencc import OpenCC

# 全局變量用于控制進(jìn)度和線程
audio_convert_progress = 0.0
transcribe_progress = 0.0
is_running = False

class AudioVideoToSubtitle:
    def __init__(self, root):
        self.root = root
        self.root.title("音視頻轉(zhuǎn)字幕工具")
        self.root.geometry("900x650")  # 擴(kuò)大窗口以容納時(shí)間顯示
        
        # 初始化繁簡(jiǎn)轉(zhuǎn)換器
        self.cc = OpenCC('t2s')
        
        # 時(shí)間跟蹤變量
        self.total_start_time = None  # 總處理開始時(shí)間
        self.audio_start_time = None  # 音頻轉(zhuǎn)換開始時(shí)間
        self.transcribe_start_time = None  # 字幕識(shí)別開始時(shí)間
        self.time_update_id = None  # 時(shí)間更新定時(shí)器ID
        
        # 初始化模型
        self.model = None
        self.model_path = None
        
        self.init_ui()

    def init_ui(self):
        # 1. 文件選擇區(qū)域
        file_frame = ttk.LabelFrame(self.root, text="文件設(shè)置")
        file_frame.pack(fill=tk.X, padx=10, pady=5)
        
        self.file_path_var = tk.StringVar()
        ttk.Entry(file_frame, textvariable=self.file_path_var, width=70).pack(side=tk.LEFT, padx=5, pady=5)
        ttk.Button(file_frame, text="選擇文件", command=self.select_file).pack(side=tk.LEFT, padx=5, pady=5)

        # 2. 速度調(diào)節(jié)參數(shù)區(qū)域
        param_frame = ttk.LabelFrame(self.root, text="速度調(diào)節(jié)參數(shù)")
        param_frame.pack(fill=tk.X, padx=10, pady=5)
        
        ttk.Label(param_frame, text="模型選擇:").pack(side=tk.LEFT, padx=5, pady=5)
        self.model_var = tk.StringVar(value="base")
        model_options = ["tiny", "base", "small", "medium", "large"]
        ttk.Combobox(param_frame, textvariable=self.model_var, values=model_options, width=10).pack(side=tk.LEFT, padx=5, pady=5)
        
        ttk.Label(param_frame, text="線程數(shù):").pack(side=tk.LEFT, padx=5, pady=5)
        self.thread_var = tk.IntVar(value=4)
        ttk.Spinbox(param_frame, from_=1, to=16, textvariable=self.thread_var, width=5).pack(side=tk.LEFT, padx=5, pady=5)
        
        ttk.Label(param_frame, text="溫度值:").pack(side=tk.LEFT, padx=5, pady=5)
        self.temp_var = tk.DoubleVar(value=0.0)
        ttk.Spinbox(param_frame, from_=0.0, to=1.0, increment=0.1, textvariable=self.temp_var, width=5).pack(side=tk.LEFT, padx=5, pady=5)

        # 3. 進(jìn)度條和時(shí)間顯示區(qū)域
        progress_frame = ttk.LabelFrame(self.root, text="處理進(jìn)度與時(shí)間")
        progress_frame.pack(fill=tk.X, padx=10, pady=5)
        
        # 音視頻轉(zhuǎn)音頻進(jìn)度條
        ttk.Label(progress_frame, text="音視頻轉(zhuǎn)音頻:").pack(side=tk.LEFT, padx=5)
        self.audio_progress = ttk.Progressbar(progress_frame, orient=tk.HORIZONTAL, length=300, mode='determinate')
        self.audio_progress.pack(side=tk.LEFT, padx=5, pady=5)
        self.audio_progress_label = ttk.Label(progress_frame, text="0%")
        self.audio_progress_label.pack(side=tk.LEFT, padx=5)
        
        # 字幕識(shí)別進(jìn)度條
        ttk.Label(progress_frame, text="字幕識(shí)別:").pack(side=tk.LEFT, padx=5)
        self.transcribe_progress = ttk.Progressbar(progress_frame, orient=tk.HORIZONTAL, length=300, mode='determinate')
        self.transcribe_progress.pack(side=tk.LEFT, padx=5, pady=5)
        self.transcribe_progress_label = ttk.Label(progress_frame, text="0%")
        self.transcribe_progress_label.pack(side=tk.LEFT, padx=5)

        # 時(shí)間顯示區(qū)域
        time_frame = ttk.LabelFrame(self.root, text="時(shí)間信息")
        time_frame.pack(fill=tk.X, padx=10, pady=5)
        
        self.elapsed_time_var = tk.StringVar(value="已處理時(shí)間: 00:00:00")
        ttk.Label(time_frame, textvariable=self.elapsed_time_var).pack(side=tk.LEFT, padx=20, pady=5)
        
        self.estimated_time_var = tk.StringVar(value="預(yù)計(jì)剩余時(shí)間: --:--:--")
        ttk.Label(time_frame, textvariable=self.estimated_time_var).pack(side=tk.LEFT, padx=20, pady=5)

        # 4. 控制按鈕區(qū)域
        btn_frame = ttk.Frame(self.root)
        btn_frame.pack(pady=10)
        
        self.start_btn = ttk.Button(btn_frame, text="開始轉(zhuǎn)換", command=self.start_convert)
        self.start_btn.pack(side=tk.LEFT, padx=10)
        self.stop_btn = ttk.Button(btn_frame, text="停止轉(zhuǎn)換", command=self.stop_convert, state=tk.DISABLED)
        self.stop_btn.pack(side=tk.LEFT, padx=10)

        # 5. 結(jié)果顯示區(qū)域
        result_frame = ttk.LabelFrame(self.root, text="識(shí)別結(jié)果預(yù)覽")
        result_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=5)
        
        self.result_text = tk.Text(result_frame, height=15)
        scrollbar = ttk.Scrollbar(result_frame, command=self.result_text.yview)
        self.result_text.configure(yscrollcommand=scrollbar.set)
        self.result_text.pack(side=tk.LEFT, fill=tk.BOTH, expand=True, padx=5, pady=5)
        scrollbar.pack(side=tk.RIGHT, fill=tk.Y, padx=5, pady=5)

    def select_file(self):
        """選擇音視頻文件"""
        file_types = [
            ("音視頻文件", "*.mp4 *.avi *.mov *.mkv *.flv *.mp3 *.wav *.m4a"),
            ("所有文件", "*.*")
        ]
        file_path = filedialog.askopenfilename(filetypes=file_types)
        if file_path:
            self.file_path_var.set(file_path)

    def update_audio_progress(self, value: float):
        """更新音頻轉(zhuǎn)換進(jìn)度條"""
        global audio_convert_progress
        audio_convert_progress = min(value, 100.0)
        self.audio_progress["value"] = audio_convert_progress
        self.audio_progress_label.config(text=f"{int(audio_convert_progress)}%")
        self.root.update_idletasks()

    def update_transcribe_progress(self, value: float):
        """更新字幕識(shí)別進(jìn)度條"""
        global transcribe_progress
        transcribe_progress = min(value, 100.0)
        self.transcribe_progress["value"] = transcribe_progress
        self.transcribe_progress_label.config(text=f"{int(transcribe_progress)}%")
        self.root.update_idletasks()

    def format_time_display(self, seconds: float) -> str:
        """將秒數(shù)格式化為時(shí)分秒顯示"""
        hours, remainder = divmod(int(seconds), 3600)
        minutes, seconds = divmod(remainder, 60)
        return f"{hours:02d}:{minutes:02d}:{seconds:02d}"

    def update_time_display(self):
        """更新時(shí)間顯示信息"""
        if not is_running or not self.total_start_time:
            return

        # 計(jì)算已處理時(shí)間
        elapsed_seconds = (datetime.now() - self.total_start_time).total_seconds()
        self.elapsed_time_var.set(f"已處理時(shí)間: {self.format_time_display(elapsed_seconds)}")

        # 計(jì)算預(yù)計(jì)剩余時(shí)間
        try:
            if audio_convert_progress < 100:
                # 音頻轉(zhuǎn)換階段
                if self.audio_start_time and audio_convert_progress > 0:
                    audio_elapsed = (datetime.now() - self.audio_start_time).total_seconds()
                    total_audio_estimated = audio_elapsed / (audio_convert_progress / 100)
                    audio_remaining = total_audio_estimated - audio_elapsed
                    
                    # 假設(shè)轉(zhuǎn)錄時(shí)間與音頻時(shí)間相當(dāng)（簡(jiǎn)單估算）
                    total_estimated = total_audio_estimated * 2
                    remaining = total_estimated - elapsed_seconds
                    self.estimated_time_var.set(f"預(yù)計(jì)剩余時(shí)間: {self.format_time_display(remaining)}")
            else:
                # 字幕識(shí)別階段
                if self.transcribe_start_time and transcribe_progress > 0 and transcribe_progress < 100:
                    transcribe_elapsed = (datetime.now() - self.transcribe_start_time).total_seconds()
                    total_transcribe_estimated = transcribe_elapsed / (transcribe_progress / 100)
                    transcribe_remaining = total_transcribe_estimated - transcribe_elapsed
                    self.estimated_time_var.set(f"預(yù)計(jì)剩余時(shí)間: {self.format_time_display(transcribe_remaining)}")
                elif transcribe_progress >= 100:
                    self.estimated_time_var.set(f"預(yù)計(jì)剩余時(shí)間: 00:00:00")
        except (ZeroDivisionError, Exception):
            self.estimated_time_var.set(f"預(yù)計(jì)剩余時(shí)間: 計(jì)算中...")

        # 繼續(xù)定時(shí)更新
        self.time_update_id = self.root.after(1000, self.update_time_display)

    def video_to_audio(self, video_path: str, audio_path: str) -> bool:
        """音視頻轉(zhuǎn)音頻，帶進(jìn)度更新"""
        try:
            with VideoFileClip(video_path) as video:
                total_duration = video.duration
                audio = video.audio

                # 記錄音頻轉(zhuǎn)換開始時(shí)間
                self.audio_start_time = datetime.now()
                
                # 寫入音頻
                audio.write_audiofile(audio_path, logger=None)
                # 強(qiáng)制進(jìn)度到100%
                self.update_audio_progress(100.0)
            return True
        except Exception as e:
            messagebox.showerror("錯(cuò)誤", f"音視頻轉(zhuǎn)音頻失?。簕str(e)}")
            return False

    def load_whisper_model(self) -> Optional[whisper.Whisper]:
        """加載whisper模型"""
        try:
            model_name = self.model_var.get()
            self.update_transcribe_progress(10)
            model = whisper.load_model(model_name, device="cpu") 
            self.update_transcribe_progress(20)
            return model
        except Exception as e:
            messagebox.showerror("錯(cuò)誤", f"模型加載失敗：{str(e)}")
            return None

    def transcribe_audio(self, audio_path: str) -> Optional[dict]:
        """音頻轉(zhuǎn)字幕，帶進(jìn)度更新"""
        global is_running
        self.model = self.load_whisper_model()
        if not self.model or not is_running:
            return None

        try:
            # 記錄字幕識(shí)別開始時(shí)間
            self.transcribe_start_time = datetime.now()
            
            # 分段識(shí)別模擬進(jìn)度
            self.update_transcribe_progress(30)
            result = self.model.transcribe(
                audio_path,
                language="zh",
                temperature=self.temp_var.get(),
            )
            self.update_transcribe_progress(80)
            
            if not is_running:
                return None
            
            self.update_transcribe_progress(100)
            return result
        except Exception as e:
            messagebox.showerror("錯(cuò)誤", f"字幕識(shí)別失?。簕str(e)}")
            return None

    def format_srt(self, result: dict) -> str:
        """將識(shí)別結(jié)果格式化為SRT字幕格式"""
        srt_content = ""
        for i, segment in enumerate(result["segments"], 1):
            start = self.format_time(segment["start"])
            end = self.format_time(segment["end"])
            text = self.cc.convert(segment["text"].strip())
            srt_content += f"{i}\n{start} --> {end}\n{text}\n\n"
        return srt_content

    @staticmethod
    def format_time(seconds: float) -> str:
        """將秒數(shù)格式化為SRT時(shí)間格式（hh:mm:ss,fff）"""
        hours = math.floor(seconds / 3600)
        minutes = math.floor((seconds % 3600) / 60)
        secs = math.floor(seconds % 60)
        millis = math.floor((seconds % 1) * 1000)
        return f"{hours:02d}:{minutes:02d}:{secs:02d},{millis:03d}"

    def save_subtitle(self, srt_content: str, input_path: str):
        """保存字幕文件"""
        save_path = os.path.splitext(input_path)[0] + ".srt"
        try:
            with open(save_path, "w", encoding="utf-8") as f:
                f.write(srt_content)
            messagebox.showinfo("成功", f"字幕已保存至：\n{save_path}")
            return save_path
        except Exception as e:
            messagebox.showerror("錯(cuò)誤", f"字幕保存失?。簕str(e)}")
            return None

    def convert_thread(self):
        """轉(zhuǎn)換線程（避免UI卡頓）"""
        global is_running
        is_running = True
        self.start_btn.config(state=tk.DISABLED)
        self.stop_btn.config(state=tk.NORMAL)
        
        # 重置進(jìn)度和時(shí)間
        self.update_audio_progress(0.0)
        self.update_transcribe_progress(0.0)
        self.result_text.delete(1.0, tk.END)
        self.total_start_time = datetime.now()
        self.audio_start_time = None
        self.transcribe_start_time = None
        
        # 啟動(dòng)時(shí)間更新
        self.root.after(0, self.update_time_display)

        input_path = self.file_path_var.get()
        if not os.path.exists(input_path):
            messagebox.showwarning("警告", "請(qǐng)選擇有效的音視頻文件！")
            self.reset_ui()
            return

        # 臨時(shí)音頻文件路徑
        temp_audio = "temp_audio.wav"
        try:
            # 步驟1：音視頻轉(zhuǎn)音頻
            if not is_running:
                return
            if input_path.lower().endswith(("mp3", "wav", "m4a")):
                # 已是音頻文件，跳過轉(zhuǎn)換
                self.update_audio_progress(100.0)
                audio_path = input_path
                self.audio_start_time = datetime.now()  # 標(biāo)記音頻處理完成時(shí)間
            else:
                if not self.video_to_audio(input_path, temp_audio):
                    return
                audio_path = temp_audio

            # 步驟2：音頻轉(zhuǎn)字幕
            if not is_running:
                return
            result = self.transcribe_audio(audio_path)
            if not result or not is_running:
                return

            # 步驟3：格式化并顯示結(jié)果
            srt_content = self.format_srt(result)
            self.result_text.insert(1.0, srt_content)

            # 步驟4：保存字幕
            self.save_subtitle(srt_content, input_path)

        finally:
            # 清理臨時(shí)文件
            if os.path.exists(temp_audio) and not input_path.lower().endswith(("mp3", "wav", "m4a")):
                os.remove(temp_audio)
            self.reset_ui()

    def start_convert(self):
        """啟動(dòng)轉(zhuǎn)換線程"""
        thread = threading.Thread(target=self.convert_thread, daemon=True)
        thread.start()

    def stop_convert(self):
        """停止轉(zhuǎn)換"""
        global is_running
        is_running = False
        self.stop_btn.config(state=tk.DISABLED)
        self.result_text.insert(tk.END, "\n\n轉(zhuǎn)換已停止！")

    def reset_ui(self):
        """重置UI狀態(tài)"""
        global is_running
        is_running = False
        self.start_btn.config(state=tk.NORMAL)
        self.stop_btn.config(state=tk.DISABLED)
        
        # 停止時(shí)間更新
        if self.time_update_id:
            self.root.after_cancel(self.time_update_id)
            self.time_update_id = None
        
        # 重置時(shí)間顯示
        self.elapsed_time_var.set("已處理時(shí)間: 00:00:00")
        self.estimated_time_var.set("預(yù)計(jì)剩余時(shí)間: --:--:--")

if __name__ == "__main__":
    # 提示安裝依賴
    try:
        import torch
        import opencc
    except ImportError as e:
        missing = str(e).split("'")[1]
        messagebox.showwarning("提示", f"請(qǐng)先安裝依賴庫(kù)：\npip install torch moviepy openai-whisper ffmpeg-python opencc-python-reimplemented")
        exit()

    root = tk.Tk()
    app = AudioVideoToSubtitle(root)
    root.mainloop()

pip install torch

pip install moviepy

pip install openai-whisper

pip install ffmpeg-python

pip install opencc-python-reimplemented

pip install torch moviepy openai-whisper ffmpeg-python opencc-python-reimplemented -i https://pypi.tuna.tsinghua.edu.cn/simple