使用PySide6-Fluent-Widgets重构整套UI

添加任务列表组件并优化视频加载逻辑
支持可视化显示字幕区域
整理所有模型, 分别为STTN智能擦除, STTN字幕检测, LAMA, ProPainter, OpenCV
提高处理性能
新增CPU运行模式并优化多语言支持
修复Propainter模式部分视频报错

本次提交新增了CPU运行模式，适用于无GPU加速的场景。同时，优化了多语言支持，新增了日语、韩语、越南语等语言配置文件，并更新了README文档以反映新的运行模式和多语言支持。此外，修复了部分代码逻辑，提升了系统的稳定性和兼容性。

.github/workflows/build-docker.yml

@@ -36,6 +36,8 @@ jobs:
             version: "12.8"
           - type: directml
             version: "latest"
+          - type: cpu
+            version: "latest"
 
     steps:
     
@@ -94,4 +96,5 @@ jobs:
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
-          repository: ${{ secrets.DOCKERHUB_USERNAME }}/video-subtitle-remover
+          repository: ${{ secrets.DOCKERHUB_USERNAME }}/video-subtitle-remover
+          enable-url-completion: true

.github/workflows/build-windows-cpu.yml

@@ -0,0 +1,98 @@
+name: Build Windows CPU
+
+on: 
+  push:
+    branches:
+      - '**'
+  workflow_dispatch:
+    inputs:
+      ssh:
+        description: 'SSH connection to Actions'
+        required: false
+        default: false
+
+permissions:
+  contents: write
+
+jobs:
+  build:
+    runs-on: windows-2019
+    steps:
+    - uses: actions/checkout@v4
+    - name: 读取 VERSION
+      id: version
+      run: |
+        VERSION=$(sed -n 's/^VERSION = "\(.*\)"/\1/p' backend/config.py)
+        echo "VERSION=$VERSION" >> $GITHUB_ENV
+        echo "VERSION=$VERSION" >> $GITHUB_OUTPUT
+      shell: bash
+    # - name: 检查 tag 是否已存在
+    #   run: |
+    #     TAG_NAME="${VERSION}"
+    #     if git ls-remote --tags origin | grep -q "refs/tags/$TAG_NAME"; then
+    #       echo "Tag $TAG_NAME 已存在，发布中止"
+    #       exit 1
+    #     fi
+    #   shell: bash
+    - uses: actions/setup-python@v5
+      with:
+        python-version: '3.12'
+        cache: 'pip' # caching pip dependencies
+    - name: 禁用硬件加速
+      run: sed -i 's/HARDWARD_ACCELERATION_OPTION *= *.*/HARDWARD_ACCELERATION_OPTION = False/g' backend/config.py
+      shell: bash
+    - run: pip install paddlepaddle==3.0.0
+    - run: pip install torch==2.7.0 torchvision==0.22.0
+    - run: pip install -r requirements.txt
+    - run: pip freeze > requirements.txt
+    - run: pip install QPT==1.0b8 setuptools
+    - name: 获取 site-packages 路径
+      shell: bash
+      run: |
+        SITE_PACKAGES=$(python -c "import site, os; print(os.path.join(site.getsitepackages()[0], 'Lib', 'site-packages'))")
+        SITE_PACKAGES_UNIX=$(cygpath -u "$SITE_PACKAGES")
+        echo "site-packages路径: $SITE_PACKAGES"
+        echo "site-packages UNIX路径: $SITE_PACKAGES_UNIX"
+        echo "SITE_PACKAGES_UNIX=$SITE_PACKAGES_UNIX" >> $GITHUB_ENV
+        echo "SITE_PACKAGES=$SITE_PACKAGES" >> $GITHUB_ENV
+    - name: 修复QPT内部错误
+      run: sed -i '98c\        try:\n            dep = pkg.requires()\n        except TypeError:\n            continue' ${SITE_PACKAGES_UNIX}/qpt/kernel/qpackage.py
+      shell: bash
+    - name: Start SSH via tmate
+      if: (github.event.inputs.ssh == 'true' && github.event.inputs.ssh  != 'false') || contains(github.event.action, 'ssh')
+      uses: mxschmitt/action-tmate@v3
+    - run: |
+        python backend/tools/makedist.py && \
+        mv ../vsr_out ./vsr_out && \
+        cp ./vsr_out/Debug/Debug-进入虚拟环境.cmd ./vsr_out/Release/ && \
+        sed -i 's/force=False)/force=False)\n            exit(-1)/g' ./vsr_out/*/Python/Lib/site-packages/qpt/executor.py
+      env:
+        QPT_Action: "True"
+      shell: bash
+    - name: 上传 Debug 文件夹到 Artifacts
+      uses: actions/upload-artifact@v4
+      with:
+        name: vsr-v${{ env.VERSION }}-windows-cpu-debug
+        path: vsr_out/Debug/
+    - name: 上传 Release 文件夹到 Artifacts
+      uses: actions/upload-artifact@v4
+      with:
+        name: vsr-v${{ env.VERSION }}-windows-cpu-release
+        path: vsr_out/Release/
+    - name: 打包 Release 文件夹
+      run: |
+        cd vsr_out/Release
+        7z a -t7z -mx=9 -m0=LZMA2 -ms=on -mfb=64 -md=32m -mmt=on -v2000m vsr-v${{ env.VERSION }}-windows-cpu.7z * && \
+        # 检测是否只有一个分卷
+        if [ -f vsr-v${{ env.VERSION }}-windows-cpu.7z.001 ] && [ ! -f vsr-v${{ env.VERSION }}-windows-cpu.7z.002 ]; then \
+          mv vsr-v${{ env.VERSION }}-windows-cpu.7z.001 vsr-v${{ env.VERSION }}-windows-cpu.7z; fi
+      shell: bash
+    - name: Release
+      uses: softprops/action-gh-release@v1
+      with:
+        prerelease: true
+        tag_name: ${{ env.VERSION }}
+        target_commitish: ${{ github.sha }}
+        name: 硬字幕去除器 v${{ env.VERSION }}
+        files: |
+          vsr_out/Release/vsr-v${{ env.VERSION }}-windows-cpu.7z*

.github/workflows/build-windows-cuda-11.8.yml

@@ -61,7 +61,8 @@ jobs:
     - run: |
         python backend/tools/makedist.py --cuda 11.8 && \
         mv ../vsr_out ./vsr_out && \
-        cp ./vsr_out/Debug/Debug-进入虚拟环境.cmd ./vsr_out/Release/
+        cp ./vsr_out/Debug/Debug-进入虚拟环境.cmd ./vsr_out/Release/ && \
+        sed -i 's/force=False)/force=False)\n            exit(-1)/g' ./vsr_out/*/Python/Lib/site-packages/qpt/executor.py
       env:
         QPT_Action: "True"
       shell: bash

.github/workflows/build-windows-cuda-12.6.yml

@@ -61,7 +61,8 @@ jobs:
     - run: |
         python backend/tools/makedist.py --cuda 12.6 && \
         mv ../vsr_out ./vsr_out && \
-        cp ./vsr_out/Debug/Debug-进入虚拟环境.cmd ./vsr_out/Release/
+        cp ./vsr_out/Debug/Debug-进入虚拟环境.cmd ./vsr_out/Release/ && \
+        sed -i 's/force=False)/force=False)\n            exit(-1)/g' ./vsr_out/*/Python/Lib/site-packages/qpt/executor.py
       env:
         QPT_Action: "True"
       shell: bash

.github/workflows/build-windows-cuda-12.8.yml

@@ -61,7 +61,8 @@ jobs:
     - run: |
         python backend/tools/makedist.py --cuda 12.8 && \
         mv ../vsr_out ./vsr_out && \
-        cp ./vsr_out/Debug/Debug-进入虚拟环境.cmd ./vsr_out/Release/
+        cp ./vsr_out/Debug/Debug-进入虚拟环境.cmd ./vsr_out/Release/ && \
+        sed -i 's/force=False)/force=False)\n            exit(-1)/g' ./vsr_out/*/Python/Lib/site-packages/qpt/executor.py
       env:
         QPT_Action: "True"
       shell: bash

.github/workflows/build-windows-directml.yml

@@ -61,7 +61,8 @@ jobs:
     - run: |
         python backend/tools/makedist.py --directml && \
         mv ../vsr_out ./vsr_out && \
-        cp ./vsr_out/Debug/Debug-进入虚拟环境.cmd ./vsr_out/Release/
+        cp ./vsr_out/Debug/Debug-进入虚拟环境.cmd ./vsr_out/Release/ && \
+        sed -i 's/force=False)/force=False)\n            exit(-1)/g' ./vsr_out/*/Python/Lib/site-packages/qpt/executor.py
       env:
         QPT_Action: "True"
       shell: bash

.gitignore

@@ -369,8 +369,9 @@ test_*.mp4
 test*_no_sub*.mp4
 /test/coods/
 /local_test/
-/backend/models/video/ProPainter.pth
+/backend/models/propainter/ProPainter.pth
 /backend/models/big-lama/big-lama.pt
 /test/debug/
 /backend/tools/train/release_model/
-model.onnx
+model.onnx
+/config/config.json

README.md

@@ -4,7 +4,8 @@
 
 ![License](https://img.shields.io/badge/License-Apache%202-red.svg)
 ![python version](https://img.shields.io/badge/Python-3.11+-blue.svg)
-![support os](https://img.shields.io/badge/OS-Windows/macOS/Linux-green.svg)  
+![support os](https://img.shields.io/badge/OS-Windows/macOS/Linux-green.svg)
+[![Docker](https://img.shields.io/badge/Docker-Image-blue?logo=docker)](https://hub.docker.com/r/eritpchy/video-subtitle-remover)
 
 Video-subtitle-remover (VSR) 是一款基于AI技术，将视频中的硬字幕去除的软件。
 主要实现了以下功能：
@@ -14,7 +15,7 @@ Video-subtitle-remover (VSR) 是一款基于AI技术，将视频中的硬字幕
 - 支持全视频自动去除所有文本（不传入位置）
 - 支持多选图片批量去除水印文本
 
-<p style="text-align:center;"><img src="https://github.com/YaoFANGUK/video-subtitle-remover/raw/main/design/demo.png" alt="demo.png"/></p>
+![demo.png](design/demo.png)
 
 **使用说明：**
 
@@ -32,32 +33,52 @@ Windows GPU版本v1.1.0（GPU）：
 **预构建包对比说明**：
 |       预构建包名          | Python  | Paddle | Torch | 环境                          | 支持的计算能力范围|
 |---------------|------------|--------------|--------------|-----------------------------|----------|
-| `vsr-windows-directml.7z`  | 3.12       | 3.0.0       | 2.4.1       | Windows 非Nvidia显卡             | 通用 |
+| `vsr-windows-cpu.7z`              | 3.12 | 3.0.0 | 2.7.0 | 通用                 | 通用       |
-| `vsr-windows-nvidia-cuda-11.8.7z` | 3.12       | 3.0.0        | 2.7.0       | CUDA 11.8   | 3.5 – 8.9 |
+| `vsr-windows-directml.7z`         | 3.12 | 3.0.0 | 2.4.1 | Windows 非Nvidia显卡 | 通用       |
-| `vsr-windows-nvidia-cuda-12.6.7z` | 3.12       | 3.0.0       | 2.7.0       | CUDA 12.6   | 5.0 – 8.9 |
+| `vsr-windows-nvidia-cuda-11.8.7z` | 3.12 | 3.0.0 | 2.7.0 | CUDA 11.8           | 3.5 – 8.9  |
-| `vsr-windows-nvidia-cuda-12.8.7z` | 3.12       | 3.0.0       | 2.7.0       | CUDA 12.8   | 5.0 – 9.0+ |
+| `vsr-windows-nvidia-cuda-12.6.7z` | 3.12 | 3.0.0 | 2.7.0 | CUDA 12.6           | 5.0 – 8.9  |
+| `vsr-windows-nvidia-cuda-12.8.7z` | 3.12 | 3.0.0 | 2.7.0 | CUDA 12.8           | 5.0 – 9.0+ |
 
 > NVIDIA官方提供了各GPU型号的计算能力列表，您可以参考链接: [CUDA GPUs](https://developer.nvidia.com/cuda-gpus) 查看你的GPU适合哪个CUDA版本
 
 **Docker版本：**
 ```shell
   # Nvidia 10 20 30系显卡
-  docker run -it --name vsr --gpus all eritpchy/video-subtitle-remover:1.1.1-cuda11.8 
+  docker run -it --name vsr --gpus all eritpchy/video-subtitle-remover:1.2.0-cuda11.8 python backend/main.py -i test/test.mp4 -o test/test_no_sub.mp4
 
   # Nvidia 40系显卡
-  docker run -it --name vsr --gpus all eritpchy/video-subtitle-remover:1.1.1-cuda12.6 
+  docker run -it --name vsr --gpus all eritpchy/video-subtitle-remover:1.2.0-cuda12.6 python backend/main.py -i test/test.mp4 -o test/test_no_sub.mp4
 
   # Nvidia 50系显卡
-  docker run -it --name vsr --gpus all eritpchy/video-subtitle-remover:1.1.1-cuda12.8 
+  docker run -it --name vsr --gpus all eritpchy/video-subtitle-remover:1.2.0-cuda12.8 python backend/main.py -i test/test.mp4 -o test/test_no_sub.mp4
 
   # AMD / Intel 独显 集显
-  docker run -it --name vsr --gpus all eritpchy/video-subtitle-remover:1.1.1-directml 
+  docker run -it --name vsr --gpus all eritpchy/video-subtitle-remover:1.2.0-directml python backend/main.py -i test/test.mp4 -o test/test_no_sub.mp4
 
-  # 演示视频, 输入
+  # CPU
-  /vsr/test/test.mp4
+  docker run -it --name vsr --gpus all eritpchy/video-subtitle-remover:1.2.0-cpu python backend/main.py -i test/test.mp4 -o test/test_no_sub.mp4
+
+  # 导出视频
   docker cp vsr:/vsr/test/test_no_sub.mp4 ./
 ```
 
+**命令行参数：**
+```
+Video Subtitle Remover Command Line Tool
+
+options:
+  -h, --help            show this help message and exit
+  --input INPUT, -i INPUT
+                        Input video file path
+  --output OUTPUT, -o OUTPUT
+                        Output video file path (optional)
+  --ymin YMIN           Subtitle area ymin (optional)
+  --ymax YMAX           Subtitle area ymax (optional)
+  --xmin XMIN           Subtitle area xmin (optional)
+  --xmax XMAX           Subtitle area xmax (optional)
+  --inpaint-mode {sttn-auto,sttn-det,lama,propainter,opencv}
+                        Inpaint mode, default is sttn-auto
+```
 ## 演示
 
 - GUI版：
@@ -116,7 +137,7 @@ cd <源码所在目录>
 
 #### 4. 安装合适的运行环境
 
-本项目支持 CUDA（NVIDIA显卡加速）和 DirectML（AMD、Intel等GPU/APU加速）两种运行模式。
+本项目支持 CUDA（NVIDIA显卡加速）、CPU（无 GPU）和 DirectML（AMD、Intel等GPU/APU加速）三种运行模式。
 
 ##### (1) CUDA（NVIDIA 显卡用户）
 
@@ -152,6 +173,16 @@ cd <源码所在目录>
   pip install -r requirements.txt
   ```
 
+- Linux系统还需要安装
+
+  ```shell
+  # for cuda 12.x
+  pip install onnxruntime-gpu==1.22.0
+  # for cuda 11.x
+  pip install onnxruntime-gpu==1.20.1 --index-url https://aiinfra.pkgs.visualstudio.com/PublicPackages/_packaging/onnxruntime-cuda-11/pypi/simple/
+  ```
+  > 详情见: [Install ONNX Runtime](https://onnxruntime.ai/docs/install/#install-onnx-runtime-gpu-cuda-12x)
+
 ##### (2) DirectML（AMD、Intel等GPU/APU加速卡用户）
 
 - 适用于 Windows 设备的 AMD/NVIDIA/Intel GPU。
@@ -161,7 +192,14 @@ cd <源码所在目录>
   pip install -r requirements.txt
   pip install torch_directml==0.2.5.dev240914
   ```
+##### (3) CPU 运行（无 GPU 加速）
 
+- 适用于没有 GPU 或不希望使用 GPU 的情况。
+  ```shell
+  pip install paddlepaddle==3.0.0 -i https://www.paddlepaddle.org.cn/packages/stable/cpu/
+  pip install torch==2.7.0 torchvision==0.22.0
+  pip install -r requirements.txt
+  ```
 
 #### 4. 运行程序
 

README_en.md

@@ -5,6 +5,7 @@
 ![License](https://img.shields.io/badge/License-Apache%202-red.svg)
 ![python version](https://img.shields.io/badge/Python-3.11+-blue.svg)
 ![support os](https://img.shields.io/badge/OS-Windows/macOS/Linux-green.svg)
+[![Docker](https://img.shields.io/badge/Docker-Image-blue?logo=docker)](https://hub.docker.com/r/eritpchy/video-subtitle-remover)
 
 Video-subtitle-remover (VSR) is an AI-based software that removes hardcoded subtitles from videos. It mainly implements the following functionalities:
 
@@ -14,7 +15,7 @@ Video-subtitle-remover (VSR) is an AI-based software that removes hardcoded subt
 - Supports automatic removal of all text throughout the entire video (without inputting a position).
 - Supports multi-selection of images for batch removal of watermark text.
 
-<p style="text-align:center;"><img src="https://github.com/YaoFANGUK/video-subtitle-remover/raw/main/design/demo.png" alt="demo.png"/></p>
+![demo.png](design/demo.png)
 
 > Download the .zip package directly, extract, and run it. If it cannot run, follow the tutorial below to try installing the conda environment and running the source code.
 
@@ -30,33 +31,53 @@ Windows GPU Version v1.1.0 (GPU):
 **Pre-built Package Comparison**:
 
 | Pre-built Package Name          | Python | Paddle | Torch | Environment                       | Supported Compute Capability Range |
-|----------------------------------|--------|--------|--------|-----------------------------------|------------------------------------|
+|----------------------------------|------|-------|--------|-----------------------------------|------------------------------------|
-| `vse-windows-directml.7z`        | 3.12   | 3.0.0 | 2.4.1 | Windows without Nvidia GPU         | Universal                         |
+| `vse-windows-cpu.7z`             | 3.12 | 3.0.0 | 2.7.0 | Universal                  | Universal                         |
-| `vse-windows-nvidia-cuda-11.8.7z`| 3.12   | 3.0.0 | 2.7.0 | CUDA 11.8                         | 3.5 – 8.9                          |
+| `vse-windows-directml.7z`        | 3.12 | 3.0.0 | 2.4.1 | Windows without Nvidia GPU | Universal                         |
-| `vse-windows-nvidia-cuda-12.6.7z`| 3.12   | 3.0.0 | 2.7.0 | CUDA 12.6                         | 5.0 – 8.9                          |
+| `vse-windows-nvidia-cuda-11.8.7z`| 3.12 | 3.0.0 | 2.7.0 | CUDA 11.8                  | 3.5 – 8.9                         |
-| `vse-windows-nvidia-cuda-12.8.7z`| 3.12   | 3.0.0 | 2.7.0 | CUDA 12.8                         | 5.0 – 9.0+                          |
+| `vse-windows-nvidia-cuda-12.6.7z`| 3.12 | 3.0.0 | 2.7.0 | CUDA 12.6                  | 5.0 – 8.9                         |
+| `vse-windows-nvidia-cuda-12.8.7z`| 3.12 | 3.0.0 | 2.7.0 | CUDA 12.8                  | 5.0 – 9.0+                        |
 
 > NVIDIA provides a list of supported compute capabilities for each GPU model. You can refer to the following link: [CUDA GPUs](https://developer.nvidia.com/cuda-gpus) to check which CUDA version is compatible with your GPU.
 
 **Docker Versions:**
 ```shell
   # Nvidia 10, 20, 30 Series Graphics Cards
-  docker run -it --name vsr --gpus all eritpchy/video-subtitle-remover:1.1.1-cuda11.8 
+  docker run -it --name vsr --gpus all eritpchy/video-subtitle-remover:1.2.0-cuda11.8 python backend/main.py -i test/test.mp4 -o test/test_no_sub.mp4
 
   # Nvidia 40 Series Graphics Cards
-  docker run -it --name vsr --gpus all eritpchy/video-subtitle-remover:1.1.1-cuda12.6 
+  docker run -it --name vsr --gpus all eritpchy/video-subtitle-remover:1.2.0-cuda12.6 python backend/main.py -i test/test.mp4 -o test/test_no_sub.mp4 
 
   # Nvidia 50 Series Graphics Cards
-  docker run -it --name vsr --gpus all eritpchy/video-subtitle-remover:1.1.1-cuda12.8 
+  docker run -it --name vsr --gpus all eritpchy/video-subtitle-remover:1.2.0-cuda12.8 python backend/main.py -i test/test.mp4 -o test/test_no_sub.mp4
 
   # AMD / Intel Dedicated or Integrated Graphics
-  docker run -it --name vsr --gpus all eritpchy/video-subtitle-remover:1.1.1-directml 
+  docker run -it --name vsr --gpus all eritpchy/video-subtitle-remover:1.2.0-directml python backend/main.py -i test/test.mp4 -o test/test_no_sub.mp4
 
-  # Demo video, input
+  # CPU
-  /vsr/test/test.mp4
+  docker run -it --name vsr --gpus all eritpchy/video-subtitle-remover:1.2.0-cpu python backend/main.py -i test/test.mp4 -o test/test_no_sub.mp4
+
+  # Copy to host
   docker cp vsr:/vsr/test/test_no_sub.mp4 ./
 ```
 
+**Commandline:**
+```
+Video Subtitle Remover Command Line Tool
+
+options:
+  -h, --help            show this help message and exit
+  --input INPUT, -i INPUT
+                        Input video file path
+  --output OUTPUT, -o OUTPUT
+                        Output video file path (optional)
+  --ymin YMIN           Subtitle area ymin (optional)
+  --ymax YMAX           Subtitle area ymax (optional)
+  --xmin XMIN           Subtitle area xmin (optional)
+  --xmax XMAX           Subtitle area xmax (optional)
+  --inpaint-mode {sttn-auto,sttn-det,lama,propainter,opencv}
+                        Inpaint mode, default is sttn-auto
+```
 ## Demonstration
 
 - GUI:
@@ -114,7 +135,7 @@ cd <source_code_directory>
 
 #### 4. Install the Appropriate Runtime Environment
 
-This project supports two runtime modes: CUDA (NVIDIA GPU acceleration) and DirectML (AMD, Intel, and other GPUs/APUs).
+This project supports three runtime modes: CUDA (NVIDIA GPU acceleration), CPU (no GPU) and DirectML (AMD, Intel, and other GPUs/APUs).
 
 ##### (1) CUDA (For NVIDIA GPU users)
 
@@ -151,6 +172,16 @@ This project supports two runtime modes: CUDA (NVIDIA GPU acceleration) and Dire
   pip install -r requirements.txt
   ```
 
+- For Linux systems, you also need to install
+
+  ```shell
+  # for cuda 12.x
+  pip install onnxruntime-gpu==1.22.0
+  # for cuda 11.x
+  pip install onnxruntime-gpu==1.20.1 --index-url https://aiinfra.pkgs.visualstudio.com/PublicPackages/_packaging/onnxruntime-cuda-11/pypi/simple/
+  ```
+  > For more details, see: [Install ONNX Runtime](https://onnxruntime.ai/docs/install/#install-onnx-runtime-gpu-cuda-12x)
+
 ##### (2) DirectML (For AMD, Intel, and other GPU/APU users)
 
 - Suitable for Windows devices with AMD/NVIDIA/Intel GPUs.
@@ -161,6 +192,14 @@ This project supports two runtime modes: CUDA (NVIDIA GPU acceleration) and Dire
   pip install -r requirements_directml.txt
   ```
 
+##### (3) CPU Only (For systems without GPU or those not wanting to use GPU acceleration)
+
+- Suitable for systems without GPU or those that do not wish to use GPU.
+  ```shell
+  pip install paddlepaddle==3.0.0 -i https://www.paddlepaddle.org.cn/packages/stable/cpu/
+  pip install torch==2.7.0 torchvision==0.22.0
+  pip install -r requirements.txt
+  ```
 
 #### 4. Run the program
 

backend/config.py

@@ -1,162 +1,122 @@
-import warnings
+
-from enum import Enum, unique
-warnings.filterwarnings('ignore')
 import os
-import torch
+from pathlib import Path
-import logging
+from qfluentwidgets import (qconfig, ConfigItem, QConfig, OptionsValidator, BoolValidator, OptionsConfigItem, 
-import platform
+                            EnumSerializer, RangeValidator, RangeConfigItem)
-import stat
+from backend.tools.constant import InpaintMode, SubtitleDetectMode
-from fsplit.filesplit import Filesplit
+import configparser
-import onnxruntime as ort
 
 # 项目版本号
-VERSION = "1.1.1"
+VERSION = "1.2.2"
-# ×××××××××××××××××××× [不要改] start ××××××××××××××××××××
+PROJECT_HOME_URL = "https://github.com/YaoFANGUK/video-subtitle-remover"
-logging.disable(logging.DEBUG)  # 关闭DEBUG日志的打印
+PROJECT_ISSUES_URL = PROJECT_HOME_URL + "/issues"
-logging.disable(logging.WARNING)  # 关闭WARNING日志的打印
+PROJECT_RELEASES_URL = PROJECT_HOME_URL + "/releases"
-try:
+PROJECT_UPDATE_URLS = [
-    import torch_directml
+    "https://api.github.com/repos/YaoFANGUK/video-subtitle-remover/releases/latest",
-    device = torch_directml.device(torch_directml.default_device())
+    "https://accelerate.xdow.net/api/repos/YaoFANGUK/video-subtitle-remover/releases/latest",
-    USE_DML = True
+] 
-except:
-    USE_DML = False
-    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
-BASE_DIR = os.path.dirname(os.path.abspath(__file__))
-LAMA_MODEL_PATH = os.path.join(BASE_DIR, 'models', 'big-lama')
-STTN_MODEL_PATH = os.path.join(BASE_DIR, 'models', 'sttn', 'infer_model.pth')
-VIDEO_INPAINT_MODEL_PATH = os.path.join(BASE_DIR, 'models', 'video')
-MODEL_VERSION = 'V4'
-DET_MODEL_BASE = os.path.join(BASE_DIR, 'models')
-DET_MODEL_PATH = os.path.join(DET_MODEL_BASE, MODEL_VERSION, 'ch_det')
 
-# 查看该路径下是否有模型完整文件，没有的话合并小文件生成完整文件
+# 硬件加速选项开关
-if 'big-lama.pt' not in (os.listdir(LAMA_MODEL_PATH)):
+HARDWARD_ACCELERATION_OPTION = True
-    fs = Filesplit()
-    fs.merge(input_dir=LAMA_MODEL_PATH)
 
-if 'inference.pdiparams' not in os.listdir(DET_MODEL_PATH):
+class Config(QConfig):
-    fs = Filesplit()
+    # 界面语言设置
-    fs.merge(input_dir=DET_MODEL_PATH)
+    intefaceTexts = {
+        '简体中文': 'ch',
+        '繁體中文': 'chinese_cht',
+        'English': 'en',
+        '한국어': 'ko',
+        '日本語': 'japan',
+        'Tiếng Việt': 'vi',
+        'Español': 'es'
+    }
+    interface = OptionsConfigItem("Window", "Interface", "ChineseSimplified", OptionsValidator(intefaceTexts.values()), restart = True)
+    
+    # 窗口位置和大小
+    windowX = ConfigItem("Window", "X", None)
+    windowY = ConfigItem("Window", "Y", None)
+    windowW = ConfigItem("Window", "Width", 1200)
+    windowH = ConfigItem("Window", "Height", 1200)
 
-if 'ProPainter.pth' not in os.listdir(VIDEO_INPAINT_MODEL_PATH):
+    subtitleSelectionAreaX = ConfigItem("Main", "SubtitleSelectionAreaX", 0.15)
-    fs = Filesplit()
+    subtitleSelectionAreaY = ConfigItem("Main", "SubtitleSelectionAreaY", 0.88)
-    fs.merge(input_dir=VIDEO_INPAINT_MODEL_PATH)
+    subtitleSelectionAreaW = ConfigItem("Main", "SubtitleSelectionAreaW", 0.70)
+    subtitleSelectionAreaH = ConfigItem("Main", "SubtitleSelectionAreaH", 0.11)
 
-# 指定ffmpeg可执行程序路径
-sys_str = platform.system()
-if sys_str == "Windows":
-    ffmpeg_bin = os.path.join('win_x64', 'ffmpeg.exe')
-elif sys_str == "Linux":
-    ffmpeg_bin = os.path.join('linux_x64', 'ffmpeg')
-else:
-    ffmpeg_bin = os.path.join('macos', 'ffmpeg')
-FFMPEG_PATH = os.path.join(BASE_DIR, '', 'ffmpeg', ffmpeg_bin)
-
-if 'ffmpeg.exe' not in os.listdir(os.path.join(BASE_DIR, '', 'ffmpeg', 'win_x64')):
-    fs = Filesplit()
-    fs.merge(input_dir=os.path.join(BASE_DIR, '', 'ffmpeg', 'win_x64'))
-# 将ffmpeg添加可执行权限
-os.chmod(FFMPEG_PATH, stat.S_IRWXU + stat.S_IRWXG + stat.S_IRWXO)
-os.environ['KMP_DUPLICATE_LIB_OK'] = 'True'
-
-# 是否使用ONNX(DirectML/AMD/Intel)
-ONNX_PROVIDERS = []
-available_providers = ort.get_available_providers()
-for provider in available_providers:
-    if provider in [
-        "CPUExecutionProvider"
-    ]:
-        continue
-    if provider not in [
-        "DmlExecutionProvider",         # DirectML，适用于 Windows GPU
-        "ROCMExecutionProvider",        # AMD ROCm
-        "MIGraphXExecutionProvider",    # AMD MIGraphX
-        "VitisAIExecutionProvider",     # AMD VitisAI，适用于 RyzenAI & Windows, 实测和DirectML性能似乎差不多
-        "OpenVINOExecutionProvider",    # Intel GPU
-        "MetalExecutionProvider",       # Apple macOS
-        "CoreMLExecutionProvider",      # Apple macOS
-        "CUDAExecutionProvider",        # Nvidia GPU
-    ]:
-        continue
-    ONNX_PROVIDERS.append(provider)
-# ×××××××××××××××××××× [不要改] end ××××××××××××××××××××
-
-
-@unique
-class InpaintMode(Enum):
     """
-    图像重绘算法枚举
+    MODE可选算法类型
+    - InpaintMode.STTN_AUTO 智能擦除版
+    - InpaintMode.STTN_DET 带字幕检测版, 无智能擦除
+    - InpaintMode.LAMA 算法：对于动画类视频效果好，速度一般，不可以跳过字幕检测
+    - InpaintMode.PROPAINTER 算法： 需要消耗大量显存，速度较慢，对运动非常剧烈的视频效果较好
     """
-    STTN = 'sttn'
+    # 【设置inpaint算法】
-    LAMA = 'lama'
+    inpaintMode = OptionsConfigItem("Main", "InpaintMode", InpaintMode.STTN_AUTO, OptionsValidator(InpaintMode), EnumSerializer(InpaintMode))
-    PROPAINTER = 'propainter'
+    
+    subtitleDetectMode =  OptionsConfigItem("Main", "SubtitleDetectMode", SubtitleDetectMode.Accurate, OptionsValidator(SubtitleDetectMode), EnumSerializer(SubtitleDetectMode))
 
+    # 【设置像素点偏差】
+    # 用于判断是不是非字幕区域(一般认为字幕文本框的长度是要大于宽度的，如果字幕框的高大于宽，且大于的幅度超过指定像素点大小，则认为是错误检测)
+    subtitleYXAxisDifferencePixel = RangeConfigItem("Main", "SubtitleYXAxisDifferencePixel", 10, RangeValidator(0, 300))
+    # 用于放大mask大小，防止自动检测的文本框过小，inpaint阶段出现文字边，有残留
+    subtitleAreaDeviationPixel = RangeConfigItem("Main", "SubtitleAreaDeviationPixel", 10, RangeValidator(1, 300))
+    # 同于判断两个文本框是否为同一行字幕，高度差距指定像素点以内认为是同一行
+    subtitleAreaYAxisDifferencePixel = RangeConfigItem("Main", "SubtitleAreaYAxisDifferencePixel", 20, RangeValidator(0, 300))
+    # 用于判断两个字幕文本的矩形框是否相似，如果X轴和Y轴偏差都在指定阈值内，则认为时同一个文本框
+    subtitleAreaPixelToleranceYPixel = RangeConfigItem("Main", "SubtitleAreaPixelToleranceYPixel", 20, RangeValidator(0, 300))
+    subtitleAreaPixelToleranceXPixel = RangeConfigItem("Main", "SubtitleAreaPixelToleranceXPixel", 20, RangeValidator(0, 300))
+    subtitleTimelineBackwardFrameCount = RangeConfigItem("Main", "SubtitleTimelineBackwardFrameCount", 3, RangeValidator(0, 300))
+    subtitleTimelineForwardFrameCount = RangeConfigItem("Main", "subtitleTimelineForwardFrameCount", 3, RangeValidator(0, 300))
+    # 以下参数仅适用STTN算法时，才生效
+    """
+    1. STTN_SKIP_DETECTION
+    含义：是否使用跳过检测
+    效果：设置为True跳过字幕检测，会省去很大时间，但是可能误伤无字幕的视频帧或者会导致去除的字幕漏了
 
-# ×××××××××××××××××××× [可以改] start ××××××××××××××××××××
+    2. STTN_NEIGHBOR_STRIDE
-# 是否使用h264编码，如果需要安卓手机分享生成的视频，请打开该选项
+    含义：相邻帧数步长, 如果需要为第50帧填充缺失的区域，STTN_NEIGHBOR_STRIDE=5，那么算法会使用第45帧、第40帧等作为参照。
-USE_H264 = True
+    效果：用于控制参考帧选择的密度，较大的步长意味着使用更少、更分散的参考帧，较小的步长意味着使用更多、更集中的参考帧。
 
-# ×××××××××× 通用设置 start ××××××××××
+    3. STTN_REFERENCE_LENGTH
-"""
+    含义：参数帧数量，STTN算法会查看每个待修复帧的前后若干帧来获得用于修复的上下文信息
-MODE可选算法类型
+    效果：调大会增加显存占用，处理效果变好，但是处理速度变慢
-- InpaintMode.STTN 算法：对于真人视频效果较好，速度快，可以跳过字幕检测
-- InpaintMode.LAMA 算法：对于动画类视频效果好，速度一般，不可以跳过字幕检测
-- InpaintMode.PROPAINTER 算法： 需要消耗大量显存，速度较慢，对运动非常剧烈的视频效果较好
-"""
-# 【设置inpaint算法】
-MODE = InpaintMode.STTN
-# 【设置像素点偏差】
-# 用于判断是不是非字幕区域(一般认为字幕文本框的长度是要大于宽度的，如果字幕框的高大于宽，且大于的幅度超过指定像素点大小，则认为是错误检测)
-THRESHOLD_HEIGHT_WIDTH_DIFFERENCE = 10
-# 用于放大mask大小，防止自动检测的文本框过小，inpaint阶段出现文字边，有残留
-SUBTITLE_AREA_DEVIATION_PIXEL = 20
-# 同于判断两个文本框是否为同一行字幕，高度差距指定像素点以内认为是同一行
-THRESHOLD_HEIGHT_DIFFERENCE = 20
-# 用于判断两个字幕文本的矩形框是否相似，如果X轴和Y轴偏差都在指定阈值内，则认为时同一个文本框
-PIXEL_TOLERANCE_Y = 20  # 允许检测框纵向偏差的像素点数
-PIXEL_TOLERANCE_X = 20  # 允许检测框横向偏差的像素点数
-# ×××××××××× 通用设置 end ××××××××××
 
-# ×××××××××× InpaintMode.STTN算法设置 start ××××××××××
+    4. STTN_MAX_LOAD_NUM
-# 以下参数仅适用STTN算法时，才生效
+    含义：STTN算法每次最多加载的视频帧数量
-"""
+    效果：设置越大速度越慢，但效果越好
-1. STTN_SKIP_DETECTION
+    注意：要保证STTN_MAX_LOAD_NUM大于STTN_NEIGHBOR_STRIDE和STTN_REFERENCE_LENGTH
-含义：是否使用跳过检测
+    """
-效果：设置为True跳过字幕检测，会省去很大时间，但是可能误伤无字幕的视频帧或者会导致去除的字幕漏了
+    # 参考帧步长
+    sttnNeighborStride = RangeConfigItem("Sttn", "NeighborStride", 5, RangeValidator(1, 100))
+    # 参考帧数量
+    sttnReferenceLength = RangeConfigItem("Sttn", "ReferenceLength", 10, RangeValidator(1, 100))
+    # 设置STTN算法最大同时处理的帧数量
+    sttnMaxLoadNum = RangeConfigItem("Sttn", "MaxLoadNum", 50, RangeValidator(1, 300))
+    getSttnMaxLoadNum = lambda self: max(self.sttnMaxLoadNum.value, self.sttnNeighborStride.value * self.sttnReferenceLength.value)
+    
+    # 以下参数仅适用PROPAINTER算法时，才生效
+    # 【根据自己的GPU显存大小设置】最大同时处理的图片数量，设置越大处理效果越好，但是要求显存越高
+    # 1280x720p视频设置80需要25G显存，设置50需要19G显存
+    # 720x480p视频设置80需要8G显存，设置50需要7G显存
+    propainterMaxLoadNum = RangeConfigItem("ProPainter", "MaxLoadNum", 70, RangeValidator(1, 300))
 
-2. STTN_NEIGHBOR_STRIDE
+    # 是否使用硬件加速
-含义：相邻帧数步长, 如果需要为第50帧填充缺失的区域，STTN_NEIGHBOR_STRIDE=5，那么算法会使用第45帧、第40帧等作为参照。
+    hardwareAcceleration = ConfigItem("Main", "HardwareAcceleration", HARDWARD_ACCELERATION_OPTION, BoolValidator())
-效果：用于控制参考帧选择的密度，较大的步长意味着使用更少、更分散的参考帧，较小的步长意味着使用更多、更集中的参考帧。
+    
+    # 启动时检查应用更新
+    checkUpdateOnStartup = ConfigItem("Main", "CheckUpdateOnStartup", True, BoolValidator())
 
-3. STTN_REFERENCE_LENGTH
+CONFIG_FILE = 'config/config.json'
-含义：参数帧数量，STTN算法会查看每个待修复帧的前后若干帧来获得用于修复的上下文信息
+config = Config()
-效果：调大会增加显存占用，处理效果变好，但是处理速度变慢
+qconfig.load(CONFIG_FILE, config)
 
-4. STTN_MAX_LOAD_NUM
+# 读取界面语言配置
-含义：STTN算法每次最多加载的视频帧数量
+tr = configparser.ConfigParser()
-效果：设置越大速度越慢，但效果越好
-注意：要保证STTN_MAX_LOAD_NUM大于STTN_NEIGHBOR_STRIDE和STTN_REFERENCE_LENGTH
-"""
-STTN_SKIP_DETECTION = True
-# 参考帧步长
-STTN_NEIGHBOR_STRIDE = 5
-# 参考帧长度（数量）
-STTN_REFERENCE_LENGTH = 10
-# 设置STTN算法最大同时处理的帧数量
-STTN_MAX_LOAD_NUM = 50
-if STTN_MAX_LOAD_NUM < STTN_REFERENCE_LENGTH * STTN_NEIGHBOR_STRIDE:
-    STTN_MAX_LOAD_NUM = STTN_REFERENCE_LENGTH * STTN_NEIGHBOR_STRIDE
-# ×××××××××× InpaintMode.STTN算法设置 end ××××××××××
 
-# ×××××××××× InpaintMode.PROPAINTER算法设置 start ××××××××××
+TRANSLATION_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'interface', f"{config.interface.value}.ini")
-# 【根据自己的GPU显存大小设置】最大同时处理的图片数量，设置越大处理效果越好，但是要求显存越高
+tr.read(TRANSLATION_FILE, encoding='utf-8')
-# 1280x720p视频设置80需要25G显存，设置50需要19G显存
-# 720x480p视频设置80需要8G显存，设置50需要7G显存
-PROPAINTER_MAX_LOAD_NUM = 70
-# ×××××××××× InpaintMode.PROPAINTER算法设置 end ××××××××××
 
-# ×××××××××× InpaintMode.LAMA算法设置 start ××××××××××
+# 项目的base目录
-# 是否开启极速模式，开启后不保证inpaint效果，仅仅对包含文本的区域文本进行去除
+BASE_DIR = str(Path(os.path.abspath(__file__)).parent)
-LAMA_SUPER_FAST = False
+
-# ×××××××××× InpaintMode.LAMA算法设置 end ××××××××××
+os.environ['KMP_DUPLICATE_LIB_OK'] = 'True'
-# ×××××××××××××××××××× [可以改] end ××××××××××××××××××××

backend/inpaint/lama_inpaint.py

@@ -1,22 +1,20 @@
 import os
-from typing import Union
+import copy
+from typing import Union, List
 import torch
 import numpy as np
 from PIL import Image
 from backend.inpaint.utils.lama_util import prepare_img_and_mask
 from backend import config
-
+from backend.tools.inpaint_tools import get_inpaint_area_by_mask
 
 class LamaInpaint:
-    def __init__(self, device: torch.device = torch.device("cuda" if torch.cuda.is_available() else "cpu"), model_path=None) -> None:
+    def __init__(self, device: torch.device = torch.device("cuda" if torch.cuda.is_available() else "cpu"), model_path='big-lama.pt') -> None:
-        if model_path is None:
-            model_path = os.path.join(config.LAMA_MODEL_PATH, 'big-lama.pt')
         self.model = torch.jit.load(model_path, map_location=device)
         self.model.eval()
-        self.model.to(device)
         self.device = device
 
-    def __call__(self, image: Union[Image.Image, np.ndarray], mask: Union[Image.Image, np.ndarray]):
+    def inpaint(self, image: Union[Image.Image, np.ndarray], mask: Union[Image.Image, np.ndarray]):
         if isinstance(image, np.ndarray):
             orig_height, orig_width = image.shape[:2]
         else:
@@ -29,3 +27,60 @@ class LamaInpaint:
             cur_res = cur_res[:orig_height, :orig_width]
             return cur_res
 
+    def __call__(self, input_frames: List[np.ndarray], input_mask: np.ndarray):
+        """
+        :param input_frames: 原视频帧
+        :param input_mask: 字幕区域mask
+        """
+        mask = input_mask[:, :, None]
+        H_ori, W_ori = mask.shape[:2]
+        H_ori = int(H_ori + 0.5)
+        W_ori = int(W_ori + 0.5)
+        # 确定去字幕的垂直高度部分
+        split_h = int(W_ori * 3 / 16)
+        inpaint_area = get_inpaint_area_by_mask(W_ori, H_ori, split_h, mask)
+        # 初始化帧存储变量
+        # 高分辨率帧存储列表
+        frames_hr = copy.deepcopy(input_frames)
+        frames_scaled = {}  # 存放缩放后帧的字典
+        masks_scaled = {}  # 存放缩放后遮罩的字典
+        comps = {}  # 存放补全后帧的字典
+        # 存储最终的视频帧
+        inpainted_frames = []
+        for k in range(len(inpaint_area)):
+            frames_scaled[k] = []  # 为每个去除部分初始化一个列表
+            masks_scaled[k] = []  # 为每个去除部分初始化一个列表
+
+        # 读取并缩放帧
+        for j in range(len(frames_hr)):
+            image = frames_hr[j]
+            # 对每个去除部分进行切割和缩放
+            for k in range(len(inpaint_area)):
+                image_crop = image[inpaint_area[k][0]:inpaint_area[k][1], :, :]  # 切割
+                mask_crop = mask[inpaint_area[k][0]:inpaint_area[k][1], :, :]  # 切割
+                frames_scaled[k].append(image_crop)  # 将切割后的帧添加到对应列表
+                masks_scaled[k].append(mask_crop)  # 将切割后的遮罩添加到对应列表
+
+        # 处理每一个去除部分
+        for k in range(len(inpaint_area)):
+            # 调用inpaint函数逐帧处理
+            comps[k] = []
+            for i in range(len(frames_scaled[k])):
+                inpainted_frame = self.inpaint(frames_scaled[k][i], masks_scaled[k][i])
+                comps[k].append(inpainted_frame)
+
+        # 如果存在去除部分
+        if inpaint_area:
+            for j in range(len(frames_hr)):
+                frame = frames_hr[j]  # 取出原始帧
+                # 对于模式中的每一个段落
+                for k in range(len(inpaint_area)):
+                    comp = comps[k][j]  # 获取补全后的帧
+                    # 实现遮罩区域内的图像融合
+                    frame[inpaint_area[k][0]:inpaint_area[k][1], :, :] = comp
+                # 将最终帧添加到列表
+                inpainted_frames.append(frame)
+                # print(f'processing frame, {len(frames_hr) - j} left')
+        return inpainted_frames
+
+

backend/inpaint/opencv_inpaint.py

@@ -0,0 +1,15 @@
+import cv2
+
+class OpenCVInpaint:
+
+    def __init__(self):
+        pass
+
+    def inpaint(self, frame, mask):
+        return cv2.inpaint(frame, mask, 3, cv2.INTER_LINEAR)
+
+    def __call__(self, frames, mask):
+        comp = []
+        for frame in frames:
+            comp.append(self.inpaint(frame, mask))
+        return comp

backend/inpaint/propainter_inpaint.py

@@ -1,9 +1,11 @@
 # -*- coding: utf-8 -*-
 import os
 import cv2
+import copy
 import numpy as np
 import scipy.ndimage
 from PIL import Image
+from typing import List
 
 import torch
 import torchvision
@@ -14,12 +16,12 @@ from backend.inpaint.video.model.recurrent_flow_completion import RecurrentFlowC
 from backend.inpaint.video.model.propainter import InpaintGenerator
 from backend.inpaint.video.core.utils import to_tensors
 from backend.inpaint.video.model.misc import get_device
+from backend.tools.inpaint_tools import get_inpaint_area_by_mask
 
 import warnings
 
 warnings.filterwarnings("ignore")
 
-
 def binary_mask(mask, th=0.1):
     mask[mask > th] = 1
     mask[mask <= th] = 0
@@ -33,6 +35,11 @@ def read_mask(mpath, length, size, flow_mask_dilates=8, mask_dilates=5):
     flow_masks = []
     # 如果传入的直接为numpy array
     if isinstance(mpath, np.ndarray):
+        if mpath.ndim == 3 and mpath.shape[2] == 1:
+            mpath = mpath.squeeze(2)  # 从 (H,W,1) 转为 (H,W)
+        elif mpath.ndim == 3 and mpath.shape[2] == 3:
+            # 如果是彩色图像，转为灰度
+            mpath = cv2.cvtColor(mpath, cv2.COLOR_BGR2GRAY)
         masks_img = [Image.fromarray(mpath)]
     # input single img path
     else:
@@ -129,9 +136,10 @@ def get_ref_index(mid_neighbor_id, neighbor_ids, length, ref_stride=10, ref_num=
     return ref_index
 
 
-class VideoInpaint:
+class PropainterInpaint:
-    def __init__(self, sub_video_length=config.PROPAINTER_MAX_LOAD_NUM, use_fp16=True):
+    def __init__(self, device, model_dir, sub_video_length=80, use_fp16=True):
-        self.device = get_device()
+        self.device = device
+        self.model_dir = model_dir
         self.use_fp16 = use_fp16
         self.use_half = True if self.use_fp16 else False
         if self.device == torch.device('cpu'):
@@ -157,21 +165,27 @@ class VideoInpaint:
 
     def init_raft_model(self):
         # set up RAFT and flow competition model
-        return RAFT_bi(os.path.join(config.VIDEO_INPAINT_MODEL_PATH, 'raft-things.pth'), self.device)
+        return RAFT_bi(os.path.join(self.model_dir, 'raft-things.pth'), self.device)
 
     def init_fix_flow_model(self):
         fix_flow_complete_model = RecurrentFlowCompleteNet(
-            os.path.join(config.VIDEO_INPAINT_MODEL_PATH, 'recurrent_flow_completion.pth'))
+            os.path.join(self.model_dir, 'recurrent_flow_completion.pth'))
         for p in fix_flow_complete_model.parameters():
             p.requires_grad = False
+            
+        if self.use_half:
+            fix_flow_complete_model = fix_flow_complete_model.half()
         fix_flow_complete_model.to(self.device)
         fix_flow_complete_model.eval()
         return fix_flow_complete_model
 
     def init_inpaint_model(self):
         # set up ProPainter model
-        return InpaintGenerator(model_path=os.path.join(config.VIDEO_INPAINT_MODEL_PATH, 'ProPainter.pth')).to(
+        model = InpaintGenerator(model_path=os.path.join(self.model_dir, 'ProPainter.pth'))
-            self.device).eval()
+        if self.use_half:
+            model = model.half()
+        model = model.to(self.device).eval()
+        return model
 
     def inpaint(self, frames, mask):
         if isinstance(frames[0], np.ndarray):
@@ -235,8 +249,6 @@ class VideoInpaint:
             if self.use_half:
                 frames, flow_masks, masks_dilated = frames.half(), flow_masks.half(), masks_dilated.half()
                 gt_flows_bi = (gt_flows_bi[0].half(), gt_flows_bi[1].half())
-                fix_flow_complete = self.fix_flow_complete.half()
-                self.model = self.model.half()
 
             # ---- complete flow ----
             flow_length = gt_flows_bi[0].size(1)
@@ -248,10 +260,10 @@ class VideoInpaint:
                     e_f = min(flow_length, f + self.sub_video_length + pad_len)
                     pad_len_s = max(0, f) - s_f
                     pad_len_e = e_f - min(flow_length, f + self.sub_video_length)
-                    pred_flows_bi_sub, _ = fix_flow_complete.forward_bidirect_flow(
+                    pred_flows_bi_sub, _ = self.fix_flow_complete.forward_bidirect_flow(
                         (gt_flows_bi[0][:, s_f:e_f], gt_flows_bi[1][:, s_f:e_f]),
                         flow_masks[:, s_f:e_f + 1])
-                    pred_flows_bi_sub = fix_flow_complete.combine_flow(
+                    pred_flows_bi_sub = self.fix_flow_complete.combine_flow(
                         (gt_flows_bi[0][:, s_f:e_f], gt_flows_bi[1][:, s_f:e_f]),
                         pred_flows_bi_sub,
                         flow_masks[:, s_f:e_f + 1])
@@ -264,8 +276,8 @@ class VideoInpaint:
                 pred_flows_b = torch.cat(pred_flows_b, dim=1)
                 pred_flows_bi = (pred_flows_f, pred_flows_b)
             else:
-                pred_flows_bi, _ = fix_flow_complete.forward_bidirect_flow(gt_flows_bi, flow_masks)
+                pred_flows_bi, _ = self.fix_flow_complete.forward_bidirect_flow(gt_flows_bi, flow_masks)
-                pred_flows_bi = fix_flow_complete.combine_flow(gt_flows_bi, pred_flows_bi, flow_masks)
+                pred_flows_bi = self.fix_flow_complete.combine_flow(gt_flows_bi, pred_flows_bi, flow_masks)
                 torch.cuda.empty_cache()
 
             # ---- image propagation ----
@@ -348,6 +360,59 @@ class VideoInpaint:
         comp_frames = [cv2.cvtColor(i, cv2.COLOR_RGB2BGR) for i in comp_frames]
         return comp_frames
 
+    def __call__(self, input_frames: List[np.ndarray], input_mask: np.ndarray):
+        """
+        :param input_frames: 原视频帧
+        :param input_mask: 字幕区域mask
+        """
+        mask = input_mask[:, :, None]
+        H_ori, W_ori = mask.shape[:2]
+        H_ori = int(H_ori + 0.5)
+        W_ori = int(W_ori + 0.5)
+        # 确定去字幕的垂直高度部分
+        split_h = int(W_ori * 3 / 16)
+        inpaint_area = get_inpaint_area_by_mask(W_ori, H_ori, split_h, mask, multiple=8)
+        # 初始化帧存储变量
+        # 高分辨率帧存储列表
+        frames_hr = copy.deepcopy(input_frames)
+        frames_scaled = {}  # 存放缩放后帧的字典
+        masks_scaled = {}  # 存放缩放后遮罩的字典
+        comps = {}  # 存放补全后帧的字典
+        # 存储最终的视频帧
+        inpainted_frames = []
+        for k in range(len(inpaint_area)):
+            frames_scaled[k] = []  # 为每个去除部分初始化一个列表
+            masks_scaled[k] = []  # 为每个去除部分初始化一个列表
+
+        # 读取并缩放帧
+        for j in range(len(frames_hr)):
+            image = frames_hr[j]
+            # 对每个去除部分进行切割和缩放
+            for k in range(len(inpaint_area)):
+                image_crop = image[inpaint_area[k][0]:inpaint_area[k][1], inpaint_area[k][2]:inpaint_area[k][3], :]  # 切割
+                mask_crop = mask[inpaint_area[k][0]:inpaint_area[k][1], inpaint_area[k][2]:inpaint_area[k][3], :]  # 切割
+                frames_scaled[k].append(image_crop)  # 将缩放后的帧添加到对应列表
+                masks_scaled[k].append(mask_crop)  # 将缩放后的遮罩添加到对应列表
+
+        # 处理每一个去除部分
+        for k in range(len(inpaint_area)):
+            # 调用inpaint函数进行处理
+            comps[k] = self.inpaint(frames_scaled[k], masks_scaled[k][0])
+
+        # 如果存在去除部分
+        if inpaint_area:
+            for j in range(len(frames_hr)):
+                frame = frames_hr[j]  # 取出原始帧
+                # 对于模式中的每一个段落
+                for k in range(len(inpaint_area)):
+                    comp = comps[k][j]  # 获取补全后的帧
+                    # 实现遮罩区域内的图像融合
+                    frame[inpaint_area[k][0]:inpaint_area[k][1], inpaint_area[k][2]:inpaint_area[k][3], :] = comp
+                # 将最终帧添加到列表
+                inpainted_frames.append(frame)
+                # print(f'processing frame, {len(frames_hr) - j} left')
+        return inpainted_frames
+
 
 def read_frames(v_path):
     video_cap = cv2.VideoCapture(v_path)
@@ -362,11 +427,11 @@ def read_frames(v_path):
 
 
 if __name__ == '__main__':
-    # VideoInpaint
+    # PropainterInpaint
-    video_inpaint = VideoInpaint(sub_video_length=80)
+    propainter_inpaint = PropainterInpaint(get_device(), ModelConfig().PROPAINTER_MODEL_DIR, sub_video_length=80)
     frames = read_frames('/home/yao/Documents/Project/video-subtitle-remover/local_test/test1.mp4')
     mask = cv2.imread('/home/yao/Documents/Project/video-subtitle-remover/local_test/test1_mask.png')
-    inpainted_frames = video_inpaint.inpaint(frames, mask)
+    inpainted_frames = propainter_inpaint.inpaint(frames, mask)
     save_root = '/home/yao/Documents/Project/video-subtitle-remover/local_test/'
     video_out_path = os.path.join(save_root, 'inpaint_out.mp4')
     print("size: ", inpainted_frames[0].shape)

backend/inpaint/sttn/network_sttn.py

@@ -1,9 +1,11 @@
 ''' Spatial-Temporal Transformer Networks
 '''
+import numpy as np
 import math
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
+import torchvision.models as models
 from backend.inpaint.utils.spectral_norm import spectral_norm as _spectral_norm
 
 
@@ -61,7 +63,7 @@ class BaseNetwork(nn.Module):
 
 
 class InpaintGenerator(BaseNetwork):
-    def __init__(self, init_weights=True):  # 1046
+    def __init__(self, init_weights=True):
         super(InpaintGenerator, self).__init__()
         channel = 256
         stack_num = 8
@@ -82,7 +84,7 @@ class InpaintGenerator(BaseNetwork):
             nn.LeakyReLU(0.2, inplace=True),
         )
 
-        # decoder: decode image from features
+        # decoder: decode frames from features
         self.decoder = nn.Sequential(
             deconv(channel, 128, kernel_size=3, padding=1),
             nn.LeakyReLU(0.2, inplace=True),
@@ -114,11 +116,9 @@ class InpaintGenerator(BaseNetwork):
         masks = masks.view(t, c, h, w)
         masks = F.interpolate(masks, scale_factor=1.0/4)
         t, c, _, _ = feat.size()
-        output = self.transformer({'x': feat, 'm': masks, 'b': 1, 'c': c})
+        enc_feat = self.transformer(
-        enc_feat = output['x']
+            {'x': feat, 'm': masks, 'b': 1, 'c': c})['x']
-        attn = output['attn']
+        return enc_feat
-        mm = output['smm']
-        return enc_feat, attn, mm
 
 
 class deconv(nn.Module):
@@ -133,8 +133,9 @@ class deconv(nn.Module):
         return self.conv(x)
 
 
-# ##################################################
+# #############################################################################
-# ################## Transformer ####################
+# ############################# Transformer  ##################################
+# #############################################################################
 
 
 class Attention(nn.Module):
@@ -205,22 +206,14 @@ class MultiHeadedAttention(nn.Module):
                 tmp1.append(y)
             y = torch.cat(tmp1,1)
             '''
-            y, attn = self.attention(query, key, value, mm)
+            y, _ = self.attention(query, key, value, mm)
-
-            # return attention value for visualization 
-            # here we return the attention value of patchsize=18 
-            if width == 18:
-                select_attn = attn.view(t, out_h*out_w, t, out_h, out_w)[0]
-                # mm, [b, thw, thw]
-                select_mm = mm[0].view(t*out_h*out_w, t, out_h, out_w)[0]
-
             # 3) "Concat" using a view and apply a final linear.
             y = y.view(b, t, out_h, out_w, d_k, height, width)
             y = y.permute(0, 1, 4, 2, 5, 3, 6).contiguous().view(bt, d_k, h, w)
             output.append(y)
         output = torch.cat(output, 1)
         x = self.output_linear(output)
-        return x, select_attn, select_mm
+        return x
 
 
 # Standard 2 layerd FFN of transformer
@@ -251,10 +244,9 @@ class TransformerBlock(nn.Module):
 
     def forward(self, x):
         x, m, b, c = x['x'], x['m'], x['b'], x['c']
-        val, attn, mm = self.attention(x, m, b, c)
+        x = x + self.attention(x, m, b, c)
-        x = x + val
         x = x + self.feed_forward(x)
-        return {'x': x, 'm': m, 'b': b, 'c': c, 'attn': attn, 'smm': mm}
+        return {'x': x, 'm': m, 'b': b, 'c': c}
 
 
 # ######################################################################
@@ -309,4 +301,4 @@ class Discriminator(BaseNetwork):
 def spectral_norm(module, mode=True):
     if mode:
         return _spectral_norm(module)
-    return module
+    return module

backend/inpaint/sttn_auto_inpaint.py

@@ -10,9 +10,10 @@ import sys
 import os
 sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
-from backend import config
+from backend.config import config
 from backend.inpaint.sttn.auto_sttn import InpaintGenerator
 from backend.inpaint.utils.sttn_utils import Stack, ToTorchFormatTensor
+from backend.tools.inpaint_tools import get_inpaint_area_by_mask
 
 # 定义图像预处理方式
 _to_tensors = transforms.Compose([
@@ -20,21 +21,20 @@ _to_tensors = transforms.Compose([
     ToTorchFormatTensor()  # 将堆叠的图像转化为PyTorch张量
 ])
 
-
 class STTNInpaint:
-    def __init__(self):
+    def __init__(self, device, model_path):
-        self.device = config.device
+        self.device = device
         # 1. 创建InpaintGenerator模型实例并装载到选择的设备上
         self.model = InpaintGenerator().to(self.device)
         # 2. 载入预训练模型的权重，转载模型的状态字典
-        self.model.load_state_dict(torch.load(config.STTN_MODEL_PATH, map_location='cpu')['netG'])
+        self.model.load_state_dict(torch.load(model_path, map_location='cpu')['netG'])
         # 3. # 将模型设置为评估模式
         self.model.eval()
         # 模型输入用的宽和高
         self.model_input_width, self.model_input_height = 640, 120
         # 2. 设置相连帧数
-        self.neighbor_stride = config.STTN_NEIGHBOR_STRIDE
+        self.neighbor_stride = config.sttnNeighborStride.value
-        self.ref_length = config.STTN_REFERENCE_LENGTH
+        self.ref_length = config.sttnReferenceLength.value
 
     def __call__(self, input_frames: List[np.ndarray], input_mask: np.ndarray):
         """
@@ -48,7 +48,7 @@ class STTNInpaint:
         W_ori = int(W_ori + 0.5)
         # 确定去字幕的垂直高度部分
         split_h = int(W_ori * 3 / 16)
-        inpaint_area = self.get_inpaint_area_by_mask(H_ori, split_h, mask)
+        inpaint_area = get_inpaint_area_by_mask(W_ori, H_ori, split_h, mask)
         # 初始化帧存储变量
         # 高分辨率帧存储列表
         frames_hr = copy.deepcopy(input_frames)
@@ -87,7 +87,7 @@ class STTNInpaint:
                     frame[inpaint_area[k][0]:inpaint_area[k][1], :, :] = mask_area * comp + (1 - mask_area) * frame[inpaint_area[k][0]:inpaint_area[k][1], :, :]
                 # 将最终帧添加到列表
                 inpainted_frames.append(frame)
-                print(f'processing frame, {len(frames_hr) - j} left')
+                # print(f'processing frame, {len(frames_hr) - j} left')
         return inpainted_frames
 
     @staticmethod
@@ -163,64 +163,8 @@ class STTNInpaint:
         # 返回处理完成的帧序列
         return comp_frames
 
-    @staticmethod
-    def get_inpaint_area_by_mask(H, h, mask):
-        """
-        获取字幕去除区域，根据mask来确定需要填补的区域和高度
-        """
-        # 存储绘画区域的列表
-        inpaint_area = []
-        # 从视频底部的字幕位置开始，假设字幕通常位于底部
-        to_H = from_H = H
-        # 从底部向上遍历遮罩
-        while from_H != 0:
-            if to_H - h < 0:
-                # 如果下一段会超出顶端，则从顶端开始
-                from_H = 0
-                to_H = h
-            else:
-                # 确定段的上边界
-                from_H = to_H - h
-            # 检查当前段落是否包含遮罩像素
-            if not np.all(mask[from_H:to_H, :] == 0) and np.sum(mask[from_H:to_H, :]) > 10:
-                # 如果不是第一个段落，向下移动以确保没遗漏遮罩区域
-                if to_H != H:
-                    move = 0
-                    while to_H + move < H and not np.all(mask[to_H + move, :] == 0):
-                        move += 1
-                    # 确保没有越过底部
-                    if to_H + move < H and move < h:
-                        to_H += move
-                        from_H += move
-                # 将该段落添加到列表中
-                if (from_H, to_H) not in inpaint_area:
-                    inpaint_area.append((from_H, to_H))
-                else:
-                    break
-            # 移动到下一个段落
-            to_H -= h
-        return inpaint_area  # 返回绘画区域列表
 
-    @staticmethod
+class STTNAutoInpaint:
-    def get_inpaint_area_by_selection(input_sub_area, mask):
-        print('use selection area for inpainting')
-        height, width = mask.shape[:2]
-        ymin, ymax, _, _ = input_sub_area
-        interval_size = 135
-        # 存储结果的列表
-        inpaint_area = []
-        # 计算并存储标准区间
-        for i in range(ymin, ymax, interval_size):
-            inpaint_area.append((i, i + interval_size))
-        # 检查最后一个区间是否达到了最大值
-        if inpaint_area[-1][1] != ymax:
-            # 如果没有，则创建一个新的区间，开始于最后一个区间的结束，结束于扩大后的值
-            if inpaint_area[-1][1] + interval_size <= height:
-                inpaint_area.append((inpaint_area[-1][1], inpaint_area[-1][1] + interval_size))
-        return inpaint_area  # 返回绘画区域列表
-
-
-class STTNVideoInpaint:
 
     def read_frame_info_from_video(self):
         # 使用opencv读取视频
@@ -235,9 +179,9 @@ class STTNVideoInpaint:
         # 返回视频读取对象、帧信息和视频写入对象
         return reader, frame_info
 
-    def __init__(self, video_path, mask_path=None, clip_gap=None):
+    def __init__(self, device, model_path, video_path, mask_path=None, clip_gap=None):
         # STTNInpaint视频修复实例初始化
-        self.sttn_inpaint = STTNInpaint()
+        self.sttn_inpaint = STTNInpaint(device, model_path)
         # 视频和掩码路径
         self.video_path = video_path
         self.mask_path = mask_path
@@ -248,7 +192,7 @@ class STTNVideoInpaint:
         )
         # 配置可在一次处理中加载的最大帧数
         if clip_gap is None:
-            self.clip_gap = config.STTN_MAX_LOAD_NUM
+            self.clip_gap = config.getSttnMaxLoadNum()
         else:
             self.clip_gap = clip_gap
 
@@ -277,8 +221,7 @@ class STTNVideoInpaint:
                 mask = mask[:, :, None]
                 
             # 得到修复区域位置
-            inpaint_area = self.sttn_inpaint.get_inpaint_area_by_mask(frame_info['H_ori'], split_h, mask)
+            inpaint_area = get_inpaint_area_by_mask(frame_info['W_ori'], frame_info['H_ori'], split_h, mask)
-            
             # 遍历每一次的迭代次数
             for i in range(rec_time):
                 start_f = i * self.clip_gap  # 起始帧位置
@@ -346,7 +289,7 @@ class STTNVideoInpaint:
                             if tbar is not None:
                                 input_sub_remover.update_progress(tbar, increment=1)
                             if original_frame is not None and input_sub_remover.gui_mode:
-                                input_sub_remover.preview_frame = cv2.hconcat([original_frame, frame])
+                                input_sub_remover.update_preview_with_comp(original_frame, frame)
         except Exception as e:
             print(f"Error during video processing: {str(e)}")
             # 不抛出异常，允许程序继续执行
@@ -360,7 +303,7 @@ if __name__ == '__main__':
     video_path = '../../test/test.mp4'
     # 记录开始时间
     start = time.time()
-    sttn_video_inpaint = STTNVideoInpaint(video_path, mask_path, clip_gap=config.STTN_MAX_LOAD_NUM)
+    sttn_video_inpaint = STTNAutoInpaint(video_path, mask_path, clip_gap=config.getSttnMaxLoadNum())
     sttn_video_inpaint()
     print(f'video generated at {sttn_video_inpaint.video_out_path}')
     print(f'time cost: {time.time() - start}')

backend/inpaint/sttn_det_inpaint.py

@@ -0,0 +1,179 @@
+import copy
+import time
+
+import cv2
+import numpy as np
+import torch
+from torchvision import transforms
+from typing import List
+import sys
+import os
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+from backend.config import config
+from backend.inpaint.sttn.network_sttn import InpaintGenerator
+from backend.inpaint.utils.sttn_utils import Stack, ToTorchFormatTensor
+from backend.tools.inpaint_tools import get_inpaint_area_by_mask
+
+# 定义图像预处理方式
+_to_tensors = transforms.Compose([
+    Stack(),  # 将图像堆叠为序列
+    ToTorchFormatTensor()  # 将堆叠的图像转化为PyTorch张量
+])
+
+class STTNDetInpaint:
+    def __init__(self, device, model_path):
+        self.device = device
+        # 1. 创建InpaintGenerator模型实例并装载到选择的设备上
+        self.model = InpaintGenerator().to(self.device)
+        # 2. 载入预训练模型的权重，转载模型的状态字典
+        self.model.load_state_dict(torch.load(model_path, map_location='cpu')['netG'])
+        # 3. # 将模型设置为评估模式
+        self.model.eval()
+        # 模型输入用的宽和高
+        self.model_input_width, self.model_input_height = 432, 240
+        # 2. 设置相连帧数
+        self.neighbor_stride = config.sttnNeighborStride.value
+        self.ref_length = config.sttnReferenceLength.value
+
+    def __call__(self, input_frames: List[np.ndarray], input_mask: np.ndarray):
+        """
+        :param input_frames: 原视频帧
+        :param mask: 字幕区域mask
+        """
+        mask = input_mask[:, :, None]
+        H_ori, W_ori = mask.shape[:2]
+        H_ori = int(H_ori + 0.5)
+        W_ori = int(W_ori + 0.5)
+        # 确定去字幕的垂直高度部分
+        if H_ori > W_ori:
+            split_h = int(H_ori * 5 / 9)
+        else:
+            split_h = int(W_ori * 5 / 18)
+        inpaint_area = get_inpaint_area_by_mask(W_ori, H_ori, split_h, mask)
+        # 初始化帧存储变量
+        # 高分辨率帧存储列表
+        frames_hr = copy.deepcopy(input_frames)
+        frames_scaled = {}  # 存放缩放后帧的字典
+        masks_scaled = {}  # 存放缩放后遮罩的字典
+        comps = {}  # 存放补全后帧的字典
+        # 存储最终的视频帧
+        inpainted_frames = []
+        for k in range(len(inpaint_area)):
+            frames_scaled[k] = []  # 为每个去除部分初始化一个列表
+            masks_scaled[k] = []  # 为每个去除部分初始化一个列表
+
+        # 读取并缩放帧
+        for j in range(len(frames_hr)):
+            image = frames_hr[j]
+            # 对每个去除部分进行切割和缩放
+            for k in range(len(inpaint_area)):
+                image_crop = image[inpaint_area[k][0]:inpaint_area[k][1], :, :]  # 切割
+                mask_crop = mask[inpaint_area[k][0]:inpaint_area[k][1], :, :]  # 切割
+                image_resize = cv2.resize(image_crop, (self.model_input_width, self.model_input_height))  # 缩放
+                mask_resize = cv2.resize(mask_crop, (self.model_input_width, self.model_input_height))  # 缩放
+                frames_scaled[k].append(image_resize)  # 将缩放后的帧添加到对应列表
+                masks_scaled[k].append(mask_resize)  # 将缩放后的遮罩添加到对应列表
+
+        # 处理每一个去除部分
+        for k in range(len(inpaint_area)):
+            # 调用inpaint函数进行处理
+            comps[k] = self.inpaint(frames_scaled[k], masks_scaled[k])
+
+        # 如果存在去除部分
+        if inpaint_area:
+            for j in range(len(frames_hr)):
+                frame = frames_hr[j]  # 取出原始帧
+                # 对于模式中的每一个段落
+                for k in range(len(inpaint_area)):
+                    comp = cv2.resize(comps[k][j], (W_ori, split_h))  # 将补全帧缩放回原大小
+                    comp = cv2.cvtColor(np.array(comp).astype(np.uint8), cv2.COLOR_BGR2RGB)  # 转换颜色空间
+                    # 获取遮罩区域并进行图像合成
+                    mask_area = mask[inpaint_area[k][0]:inpaint_area[k][1], :]  # 取出遮罩区域
+                    # 实现遮罩区域内的图像融合
+                    frame[inpaint_area[k][0]:inpaint_area[k][1], :, :] = comp
+                # 将最终帧添加到列表
+                inpainted_frames.append(frame)
+                # print(f'processing frame, {len(frames_hr) - j} left')
+        return inpainted_frames
+
+    @staticmethod
+    def read_mask(path):
+        img = cv2.imread(path, 0)
+        # 转为binary mask
+        ret, img = cv2.threshold(img, 127, 1, cv2.THRESH_BINARY)
+        img = img[:, :, None]
+        return img
+
+    def get_ref_index(self, neighbor_ids, length):
+        """
+        采样整个视频的参考帧
+        """
+        # 初始化参考帧的索引列表
+        ref_index = []
+        # 在视频长度范围内根据ref_length逐步迭代
+        for i in range(0, length, self.ref_length):
+            # 如果当前帧不在近邻帧中
+            if i not in neighbor_ids:
+                # 将它添加到参考帧列表
+                ref_index.append(i)
+        # 返回参考帧索引列表
+        return ref_index
+
+    def inpaint(self, frames: List[np.ndarray], masks: List[np.ndarray]):
+        """
+        使用STTN完成空洞填充（空洞即被遮罩的区域）
+        """
+        frame_length = len(frames)
+        # 对帧进行预处理转换为张量，并进行归一化
+        feats = _to_tensors(frames).unsqueeze(0) * 2 - 1
+        
+        binary_masks = [np.expand_dims((np.array(m) > 0.5).astype(np.uint8), 2) for m in masks]
+        # 将掩码转换为张量
+        masks = (_to_tensors(masks).unsqueeze(0) > 0.5).float()
+        
+        # 把特征张量转移到指定的设备（CPU或GPU）
+        feats, masks = feats.to(self.device), masks.to(self.device)
+        # 初始化一个与视频长度相同的列表，用于存储处理完成的帧
+        comp_frames = [None] * frame_length
+        # 关闭梯度计算，用于推理阶段节省内存并加速
+        with torch.no_grad():
+            # 将处理好的帧通过编码器，产生特征表示
+            feats = self.model.encoder((feats*(1-masks).float()).view(frame_length, 3, self.model_input_height, self.model_input_width))
+            # 获取特征维度信息
+            _, c, feat_h, feat_w = feats.size()
+            # 调整特征形状以匹配模型的期望输入
+            feats = feats.view(1, frame_length, c, feat_h, feat_w)
+        # 获取重绘区域
+        # 在设定的邻居帧步幅内循环处理视频
+        for f in range(0, frame_length, self.neighbor_stride):
+            # 计算邻近帧的ID
+            neighbor_ids = [i for i in range(max(0, f - self.neighbor_stride), min(frame_length, f + self.neighbor_stride + 1))]
+            # 获取参考帧的索引
+            ref_ids = self.get_ref_index(neighbor_ids, frame_length)
+            # 同样关闭梯度计算
+            with torch.no_grad():
+                # 通过模型推断特征并传递给解码器以生成完成的帧
+                pred_feat = self.model.infer(
+                    feats[0, neighbor_ids + ref_ids, :, :, :], masks[0, neighbor_ids + ref_ids, :, :, :])
+
+                # 将预测的特征通过解码器生成图片，并应用激活函数tanh，然后分离出张量
+                pred_img = torch.tanh(self.model.decoder(pred_feat[:len(neighbor_ids), :, :, :])).detach()
+                # 将结果张量重新缩放到0到255的范围内（图像像素值）
+                pred_img = (pred_img + 1) / 2
+                # 将张量移动回CPU并转为NumPy数组
+                pred_img = pred_img.cpu().permute(0, 2, 3, 1).numpy() * 255
+                # 遍历邻近帧
+                for i in range(len(neighbor_ids)):
+                    idx = neighbor_ids[i]
+                    # 将预测的图片转换为无符号8位整数格式
+                    img = np.array(pred_img[i]).astype(
+                        np.uint8)*binary_masks[idx] + frames[idx] * (1-binary_masks[idx])
+                    if comp_frames[idx] is None:
+                        # 如果该位置为空，则赋值为新计算出的图片
+                        comp_frames[idx] = img
+                    else:
+                        # 如果此位置之前已有图片，则将新旧图片混合以提高质量
+                        comp_frames[idx] = comp_frames[idx].astype(np.float32) * 0.5 + img.astype(np.float32) * 0.5
+        # 返回处理完成的帧序列
+        return comp_frames

backend/interface/ch.ini

@@ -0,0 +1,129 @@
+[Setting]
+FeedbackButton = 提供反馈
+FeedbackTitle = 提供反馈
+FeedbackDesc = 通过提供反馈帮助我们改进
+CopyrightButton = 检查更新
+CopyrightTitle = 关于
+CopyrightDesc = ©版权所有 2023, YaoFANGUK, Jason Eric (界面设计), 当前版本: {}
+ProjectLinkTitle = 字幕去除器
+ProjectLinkDesc = 基于AI的图片/视频硬字幕去除、文本水印去除，无损分辨率生成去字幕、去水印后的图片/视频文件。无需申请第三方API，本地实现。
+BasicSetting = 基础设置
+AdvancedSetting = 高级设置
+SubtitleDetectionSetting = 字幕检测设置
+SttnSetting = STTN设置
+ProPainterSetting = ProPainter设置
+AboutSetting = 关于
+HardwareAcceleration = 硬件加速
+HardwareAccelerationDesc = 使用GPU或ONNX后端进行加速处理
+SubtitleYXAxisDifferencePixel = 高宽像素差阈值
+SubtitleYXAxisDifferencePixelDesc = 用于判断是不是非字幕区域，默认为10 (一般认为字幕文本框的长度是要大于宽度的，如果字幕框的高大于宽，且大于的幅度超过指定像素点大小，则认为是错误检测)
+SubtitleAreaDeviationPixel = 允许的像素偏移量
+SubtitleAreaDeviationPixelDesc = 用于放大mask大小，防止自动检测的文本框过小，inpaint阶段出现文字边，有残留，默认为10
+SubtitleAreaYAxisDifferencePixel = 同行字幕高度差阈值
+SubtitleAreaYAxisDifferencePixelDesc = 同于判断两个文本框是否为同一行字幕，高度差距指定像素点以内认为是同一行，默认为20
+SubtitleAreaPixelToleranceYPixel = Y轴容忍像素偏差
+SubtitleAreaPixelToleranceYPixelDesc = 用于判断两个字幕文本的矩形框是否相似，如果Y轴偏差都在指定阈值内，则认为时同一个文本框，默认为20
+SubtitleAreaPixelToleranceXPixel = X轴容忍像素偏差
+SubtitleAreaPixelToleranceXPixelDesc = 用于判断两个字幕文本的矩形框是否相似，如果X轴偏差都在指定阈值内，则认为时同一个文本框，默认为20
+SubtitleTimelineBackwardFrameCount = 字幕时间轴回退帧数
+SubtitleTimelineBackwardFrameCountDesc = 用于在时间轴上在检测到字幕的基础上往前增加的处理帧数, 增加这个可以处理更加缓慢渐入的字幕, 默认为3帧
+subtitleTimelineForwardFrameCount = 字幕时间轴前进帧数
+subtitleTimelineForwardFrameCountDesc = 用于在时间轴上在检测到字幕的基础上往后增加的处理帧数, 增加这个可以处理更加缓慢渐出的字幕, 默认为3帧
+SttnNeighborStride = 参考帧步长
+SttnNeighborStrideDesc = 默认为5
+SttnReferenceLength = 参考帧数量
+SttnReferenceLengthDesc = 默认为10
+SttnMaxLoadNum = 最大同时处理的帧数量
+SttnMaxLoadNumDesc = 设置越大处理效果越好，但是要求显存越高，默认为50
+PropainterMaxLoadNum = 最大同时处理的帧数量
+PropainterMaxLoadNumDesc = 设置越大处理效果越好，但是要求显存越高，默认为70
+CheckUpdateOnStartup = 在应用程序启动时检查更新
+CheckUpdateOnStartupDesc = 新版本将更加稳定, 并拥有更多功能(建议启用此选项)
+UpdatesAvailableTitle = 有可用更新
+UpdatesAvailableDesc = 发现新版本 {}, 是否更新？
+NoUpdatesAvailableTitle = 无可用更新
+NoUpdatesAvailableDesc = 软件已是最新版本
+
+[SubtitleExtractorGUI]
+Title = 字幕去除器
+Open = 打开
+AllFile = 所有文件
+Vertical = 垂直方向
+Horizontal = 水平方向
+Run = 运行
+Stop = 停止
+Setting = 设置
+OpenVideoSuccess = 成功打开视频
+OpenVideoFailed = 无法打开视频: {}, 格式不兼容或文件损坏
+OpenVideoFirst = 请先打开视频
+SubtitleArea = 字幕区域
+VideoPreview = 视频预览
+InterfaceLanguage = 界面语言
+InpaintMode = 处理模型
+SelectSubtitleArea = 请在视频预览中框选处理区域
+InpaintModeDesc = STTN智能擦除, 对于真人视频效果较好，速度快, 智能擦除(最低4GB显存)
+    STTN字幕检测 带字幕检测版, 无智能擦除(最低4GB显存)
+    LAMA: 对于动画类视频效果好，速度一般(显存要求较低)
+    ProPainter: 需要消耗大量显存，速度较慢，对运动非常剧烈的视频效果较好(最低8GB显存)
+    OpenCV: 极速模式, 不保证inpaint效果，仅仅对包含文本的区域文本进行去除(显存要求较低)
+SubtitleDetectMode = 字幕检测
+ErrorDuringProcessing = 处理过程中发生错误: {}
+
+[Main]
+SubtitleDetectionAcceleratorON = 字幕检测使用{}进行加速
+OnnxExectionProviderNotSupportedSkipped = ONNX 执行提供程序: {} 不支持，已跳过。
+OnnxExecutionProviderDetected=检测到 ONNX 执行提供程序: {}
+OnnxRuntimeNotInstall = ONNX 运行环境未安装，已跳过。
+NoSubtitleDetected = 未检测到任何字幕, 请检查文件{}是否正确
+DirectMLWarning = 警告: DirectML 加速仅适用于 STTN 模型，其他模型将使用 CPU 运行。
+ProcessingStartFindingSubtitles = [处理中] 开始查找字幕...
+FinishedFindingSubtitles = [结束] 查找字幕完成...
+ProcessingStartRemovingSubtitles = [处理中] 开始移除字幕...
+UseModel = 去除字幕使用模型: {}
+FullScreenProcessingNote = 未设置字幕区域，将对全屏进行处理，最终效果可能不理想
+ReadFileFailed = 读取文件 {} 失败
+FinishedProcessing = [完成] 字幕移除成功, 文件已保存到 {}
+ProcessingTime = 处理时间: {}秒
+FailToMergeAudio = 合并音频失败: {}
+FailToExtractAudio = 提取音频失败: {}
+CopyFileFailed = 复制文件 {} 到 {} 失败, 原因: {}
+
+[TaskList]
+Pending = 待处理
+Processing = 处理中
+Completed = 已完成
+Failed = 失败
+Name = 名称
+Progress = ⠀进度⠀
+Status = ㅤ状态ㅤ
+OpenSourceVideoLocation = 打开原始视频位置
+OpenTargetVideoLocation = 打开目标视频位置
+ResetTaskStatus = 重置任务状态
+DeleteTask = 删除任务
+Warning = 警告
+UnableToLocateFile = 找不到文件，可能已被移动或删除
+TargetFileNotFound = 文件尚未生成，请先等待任务完成
+
+[VersionService]
+VersionInfo = 当前版本: {} 最新版本: {}
+RequestError = 尝试访问 {} 失败, 原因: {}
+
+[InpaintMode]
+SttnAuto = STTN智能擦除
+SttnDet = STTN字幕检测
+LAMA = LAMA
+ProPainter = ProPainter
+OpenCV = OpenCV
+
+[SubtitleDetectMode]
+Fast = 快速
+Accurate = 精准
+
+[InterfaceLanguage]
+ChineseSimplified = 简体中文
+ChineseTraditional = 繁體中文
+English = English
+Japanese = 日本語
+Korean = 한국어
+Vietnamese = Tiếng Việt
+Español = Español

backend/interface/chinese_cht.ini

@@ -0,0 +1,129 @@
+[Setting]  
+FeedbackButton = 提供反饋  
+FeedbackTitle = 提供反饋  
+FeedbackDesc = 透過提供反饋幫助我們改進  
+CopyrightButton = 檢查更新  
+CopyrightTitle = 關於  
+CopyrightDesc = ©版權所有 2023, YaoFANGUK, Jason Eric (介面設計), 當前版本: {}  
+ProjectLinkTitle = 字幕去除器  
+ProjectLinkDesc = 基於AI的圖片/影片硬字幕去除、文字浮水印去除，無損解析度生成去字幕、去浮水印後的圖片/影片檔案。無需申請第三方API，本地實現。  
+BasicSetting = 基礎設定  
+AdvancedSetting = 進階設定  
+SubtitleDetectionSetting = 字幕檢測設定  
+SttnSetting = STTN設定  
+ProPainterSetting = ProPainter設定  
+AboutSetting = 關於  
+HardwareAcceleration = 硬體加速  
+HardwareAccelerationDesc = 使用GPU或ONNX後端進行加速處理  
+SubtitleYXAxisDifferencePixel = 高寬像素差閾值  
+SubtitleYXAxisDifferencePixelDesc = 用於判斷是否為非字幕區域，預設為10 (一般認為字幕文字框的長度大於寬度，若字幕框的高大於寬，且幅度超過指定像素點大小，則視為錯誤檢測)  
+SubtitleAreaDeviationPixel = 允許的像素偏移量  
+SubtitleAreaDeviationPixelDesc = 用於放大遮罩大小，防止自動檢測的文字框過小，inpaint階段出現文字邊緣殘留，預設為10  
+SubtitleAreaYAxisDifferencePixel = 同行字幕高度差閾值  
+SubtitleAreaYAxisDifferencePixelDesc = 用於判斷兩個文字框是否為同一行字幕，高度差距在指定像素點內視為同一行，預設為20  
+SubtitleAreaPixelToleranceYPixel = Y軸容忍像素偏差  
+SubtitleAreaPixelToleranceYPixelDesc = 用於判斷兩個字幕文字框是否相似，若Y軸偏差均在指定閾值內，則視為同一個文字框，預設為20  
+SubtitleAreaPixelToleranceXPixel = X軸容忍像素偏差  
+SubtitleAreaPixelToleranceXPixelDesc = 用於判斷兩個字幕文字框是否相似，若X軸偏差均在指定閾值內，則視為同一個文字框，預設為20  
+SubtitleTimelineBackwardFrameCount = 字幕時間軸回退影格數  
+SubtitleTimelineBackwardFrameCountDesc = 用於在時間軸上於檢測到字幕的基礎上往前增加的處理影格數，可處理漸入較慢的字幕，預設為3影格  
+subtitleTimelineForwardFrameCount = 字幕時間軸前進影格數  
+subtitleTimelineForwardFrameCountDesc = 用於在時間軸上於檢測到字幕的基礎上往後增加的處理影格數，可處理漸出較慢的字幕，預設為3影格  
+SttnNeighborStride = 參考影格步長  
+SttnNeighborStrideDesc = 預設為5  
+SttnReferenceLength = 參考影格數量  
+SttnReferenceLengthDesc = 預設為10  
+SttnMaxLoadNum = 最大同時處理的影格數量  
+SttnMaxLoadNumDesc = 數值越大處理效果越好，但需更高顯示記憶體，預設為50  
+PropainterMaxLoadNum = 最大同時處理的影格數量  
+PropainterMaxLoadNumDesc = 數值越大處理效果越好，但需更高顯示記憶體，預設為70  
+CheckUpdateOnStartup = 在應用程式啟動時檢查更新  
+CheckUpdateOnStartupDesc = 新版本將更穩定並提供更多功能（建議啟用此選項）  
+UpdatesAvailableTitle = 有可用更新  
+UpdatesAvailableDesc = 發現新版本 {}，是否更新？  
+NoUpdatesAvailableTitle = 無可用更新  
+NoUpdatesAvailableDesc = 軟體已是最新版本  
+
+[SubtitleExtractorGUI]  
+Title = 字幕去除器  
+Open = 開啟  
+AllFile = 所有檔案  
+Vertical = 垂直方向  
+Horizontal = 水平方向  
+Run = 執行  
+Stop = 停止  
+Setting = 設定  
+OpenVideoSuccess = 成功開啟影片  
+OpenVideoFailed = 無法開啟影片: {}，格式不相容或檔案損毀  
+OpenVideoFirst = 請先開啟影片  
+SubtitleArea = 字幕區域  
+VideoPreview = 影片預覽  
+InterfaceLanguage = 介面語言  
+InpaintMode = 處理模型  
+SelectSubtitleArea = 請在影片預覽中框選處理區域  
+InpaintModeDesc = STTN智能擦除，對於真人視頻效果較好，速度快，智能擦除（最低4GB顯存） 
+    STTN字幕檢測 帶字幕檢測版，無智能擦除（最低4GB顯存） 
+    LAMA：對於動畫類視頻效果好，速度一般（顯存要求較低） 
+    ProPainter：需要消耗大量顯存，速度較慢，對運動非常劇烈的視頻效果較好（最低8GB顯存） 
+    OpenCV：極速模式，不保證inpaint效果，僅僅對包含文本的區域文本進行去除（顯存要求較低）  
+SubtitleDetectMode = 字幕檢測模式 
+ErrorDuringProcessing = 處理過程中發生錯誤: {} 
+
+[Main]  
+SubtitleDetectionAcceleratorON = 字幕檢測使用{}進行加速
+OnnxExectionProviderNotSupportedSkipped = ONNX 執行提供者: {} 不支援，已略過。  
+OnnxExecutionProviderDetected = 偵測到 ONNX 執行提供者: {}  
+OnnxRuntimeNotInstall = ONNX 執行環境未安裝，已略過。  
+NoSubtitleDetected = 未檢測到任何字幕，請檢查檔案{}是否正確  
+DirectMLWarning = 警告：DirectML 加速僅適用於 STTN 模型，其他模型將使用 CPU 執行。  
+ProcessingStartFindingSubtitles = [處理中] 開始搜尋字幕...  
+FinishedFindingSubtitles = [結束] 搜尋字幕完成...  
+ProcessingStartRemovingSubtitles = [處理中] 開始移除字幕...  
+UseModel = 去除字幕使用模型: {}
+FullScreenProcessingNote = 未設定字幕區域，將對全螢幕進行處理，最終效果可能不理想  
+ReadFileFailed = 讀取檔案 {} 失敗  
+FinishedProcessing = [完成] 字幕移除成功，檔案已儲存至 {}  
+ProcessingTime = 處理時間: {}秒  
+FailToMergeAudio = 合併音訊失敗: {}  
+FailToExtractAudio = 提取音訊失敗: {}  
+CopyFileFailed = 複製檔案 {} 至 {} 失敗，原因: {}  
+
+[TaskList]  
+Pending = 待處理  
+Processing = 處理中  
+Completed = 已完成  
+Failed = 失敗  
+Name = 名稱  
+Progress = ⠀進度⠀  
+Status = ㅤ狀態ㅤ  
+OpenSourceVideoLocation = 開啟原始影片位置  
+OpenTargetVideoLocation = 開啟目標影片位置  
+ResetTaskStatus = 重設任務狀態  
+DeleteTask = 刪除任務  
+Warning = 警告  
+UnableToLocateFile = 找不到檔案，可能已被移動或刪除  
+TargetFileNotFound = 檔案尚未生成，請先等待任務完成  
+
+[VersionService]  
+VersionInfo = 當前版本: {} 最新版本: {}  
+RequestError = 嘗試存取 {} 失敗，原因: {}  
+
+[InpaintMode]  
+SttnAuto = STTN智慧擦除  
+SttnDet = STTN字幕檢測  
+LAMA = LAMA  
+ProPainter = ProPainter  
+OpenCV = OpenCV  
+
+[SubtitleDetectMode]  
+Fast = 快速  
+Accurate = 精準  
+
+[InterfaceLanguage]  
+ChineseSimplified = 简体中文  
+ChineseTraditional = 繁體中文  
+English = English  
+Japanese = 日本語  
+Korean = 한국어  
+Vietnamese = Tiếng Việt  
+Español = Español

backend/interface/en.ini

@@ -0,0 +1,129 @@
+[Setting]  
+FeedbackButton = Provide Feedback  
+FeedbackTitle = Provide Feedback  
+FeedbackDesc = Help us improve by providing feedback  
+CopyrightButton = Check Updates  
+CopyrightTitle = About  
+CopyrightDesc = © Copyright 2023, YaoFANGUK, Jason Eric (UI Design), Current Version: {}  
+ProjectLinkTitle = Subtitle Remover  
+ProjectLinkDesc = AI-based image/video hard subtitle removal and text watermark removal, generating output files with original resolution. No third-party API required, locally implemented.  
+BasicSetting = Basic Settings  
+AdvancedSetting = Advanced Settings  
+SubtitleDetectionSetting = Subtitle Detection Settings  
+SttnSetting = STTN Settings  
+ProPainterSetting = ProPainter Settings  
+AboutSetting = About  
+HardwareAcceleration = Hardware Acceleration  
+HardwareAccelerationDesc = Accelerate processing using GPU or ONNX backend  
+SubtitleYXAxisDifferencePixel = Height-Width Pixel Difference Threshold  
+SubtitleYXAxisDifferencePixelDesc = Determines non-subtitle regions (default 10). Subtitles generally have longer text boxes; if height exceeds width beyond this threshold, considered false detection.  
+SubtitleAreaDeviationPixel = Allowed Pixel Offset  
+SubtitleAreaDeviationPixelDesc = Enlarge mask size to prevent residual text edges during inpaint (default 10).  
+SubtitleAreaYAxisDifferencePixel = Same-line Subtitle Height Difference Threshold  
+SubtitleAreaYAxisDifferencePixelDesc = Determines if two text boxes belong to the same subtitle line (default 20 pixels).  
+SubtitleAreaPixelToleranceYPixel = Y-axis Pixel Tolerance  
+SubtitleAreaPixelToleranceYPixelDesc = Determines similarity between subtitle boxes on Y-axis (default 20 pixels).  
+SubtitleAreaPixelToleranceXPixel = X-axis Pixel Tolerance  
+SubtitleAreaPixelToleranceXPixelDesc = Determines similarity between subtitle boxes on X-axis (default 20 pixels).  
+SubtitleTimelineBackwardFrameCount = Timeline Backward Frames  
+SubtitleTimelineBackwardFrameCountDesc = Add frames before detected subtitles to handle slow fade-ins (default 3 frames).  
+subtitleTimelineForwardFrameCount = Timeline Forward Frames  
+subtitleTimelineForwardFrameCountDesc = Add frames after detected subtitles to handle slow fade-outs (default 3 frames).  
+SttnNeighborStride = Reference Frame Stride  
+SttnNeighborStrideDesc = Default: 5  
+SttnReferenceLength = Reference Frame Count  
+SttnReferenceLengthDesc = Default: 10  
+SttnMaxLoadNum = Max Concurrent Processing Frames  
+SttnMaxLoadNumDesc = Higher values improve quality but require more VRAM (default 50).  
+PropainterMaxLoadNum = Max Concurrent Processing Frames  
+PropainterMaxLoadNumDesc = Higher values improve quality but require more VRAM (default 70).  
+CheckUpdateOnStartup = Check Updates on Startup  
+CheckUpdateOnStartupDesc = New versions offer improved stability and features (recommended).  
+UpdatesAvailableTitle = Update Available  
+UpdatesAvailableDesc = New version {} found. Update now?  
+NoUpdatesAvailableTitle = No Updates Available  
+NoUpdatesAvailableDesc = Software is up-to-date.  
+
+[SubtitleExtractorGUI]  
+Title = Subtitle Remover  
+Open = Open  
+AllFile = All Files  
+Vertical = Vertical  
+Horizontal = Horizontal  
+Run = Run  
+Stop = Stop  
+Setting = Settings  
+OpenVideoSuccess = Video opened successfully  
+OpenVideoFailed = Failed to open video: {} (invalid format or corrupted file)  
+OpenVideoFirst = Please open a video first  
+SubtitleArea = Subtitle Area  
+VideoPreview = Video Preview  
+InterfaceLanguage = Interface Language  
+InpaintMode = Processing Model  
+SelectSubtitleArea = Select processing area in video preview  
+InpaintModeDesc = STTN Smart Inpainting: Best for real-person videos, fast speed, smart inpainting (minimum 4GB VRAM)
+    STTN Subtitle Detection: With subtitle detection, no smart inpainting (minimum 4GB VRAM)
+    LAMA: Good for animation videos, moderate speed (low VRAM requirement)
+    ProPainter: Consumes a lot of VRAM, slower speed, best for videos with intense motion (minimum 8GB VRAM)
+    OpenCV: Ultra-fast mode, inpainting effect not guaranteed, only removes text in detected regions (low VRAM requirement)
+SubtitleDetectMode = Subtitle Detection  
+ErrorDuringProcessing = Error during processing: {}
+
+[Main]  
+SubtitleDetectionAcceleratorON = Subtitle detection accelerated with {}
+OnnxExectionProviderNotSupportedSkipped = ONNX provider: {} not supported, skipped.  
+OnnxExecutionProviderDetected = Detected ONNX provider: {}  
+OnnxRuntimeNotInstall = ONNX runtime not installed, skipped.  
+NoSubtitleDetected = No subtitles detected. Check file: {}  
+DirectMLWarning = Warning: DirectML acceleration only works with STTN model.  
+ProcessingStartFindingSubtitles = [Processing] Detecting subtitles...  
+FinishedFindingSubtitles = [Complete] Subtitle detection finished.  
+ProcessingStartRemovingSubtitles = [Processing] Removing subtitles...  
+UseModel = Use model for subtitle removal: {}
+FullScreenProcessingNote = Processing full screen (no area selected). Quality may vary.  
+ReadFileFailed = Failed to read file: {}  
+FinishedProcessing = [Complete] Subtitles removed. Output saved to: {}  
+ProcessingTime = Processing time: {} seconds  
+FailToMergeAudio = Audio merge failed: {}  
+FailToExtractAudio = Audio extraction failed: {}  
+CopyFileFailed = Failed to copy {} to {}. Reason: {}  
+
+[TaskList]  
+Pending = Pending  
+Processing = Processing  
+Completed = Completed  
+Failed = Failed  
+Name = Name  
+Progress = ⠀Progress⠀  
+Status = ㅤStatusㅤ  
+OpenSourceVideoLocation = Open Source File  
+OpenTargetVideoLocation = Open Output File  
+ResetTaskStatus = Reset Task  
+DeleteTask = Delete Task  
+Warning = Warning  
+UnableToLocateFile = File not found (may be moved/deleted)  
+TargetFileNotFound = Output file not generated. Wait for completion.  
+
+[VersionService]  
+VersionInfo = Current: {} Latest: {}  
+RequestError = Failed to access {}. Reason: {}  
+
+[InpaintMode]  
+SttnAuto = STTN Smart Erase  
+SttnDet = STTN Detection  
+LAMA = LAMA  
+ProPainter = ProPainter  
+OpenCV = OpenCV  
+
+[SubtitleDetectMode]  
+Fast = Fast  
+Accurate = Accurate  
+
+[InterfaceLanguage]  
+ChineseSimplified = 简体中文  
+ChineseTraditional = 繁體中文  
+English = English  
+Japanese = 日本語  
+Korean = 한국어  
+Vietnamese = Tiếng Việt  
+Español = Español

backend/interface/es.ini

@@ -0,0 +1,129 @@
+[Setting]  
+FeedbackButton = Proporcionar comentarios  
+FeedbackTitle = Proporcionar comentarios  
+FeedbackDesc = Ayúdanos a mejorar enviando tus comentarios  
+CopyrightButton = Buscar actualizaciones  
+CopyrightTitle = Acerca de  
+CopyrightDesc = © Derechos reservados 2023, YaoFANGUK, Jason Eric (Diseño UI), Versión actual: {}  
+ProjectLinkTitle = Eliminador de subtítulos  
+ProjectLinkDesc = Eliminación IA de subtítulos duros y marcas de agua en imágenes/videos, genera archivos en resolución original. Implementación local sin APIs externas.  
+BasicSetting = Configuración básica  
+AdvancedSetting = Configuración avanzada  
+SubtitleDetectionSetting = Detección de subtítulos  
+SttnSetting = Configuración STTN  
+ProPainterSetting = Configuración ProPainter  
+AboutSetting = Acerca de  
+HardwareAcceleration = Aceleración hardware  
+HardwareAccelerationDesc = Usar GPU o backend ONNX para acelerar el procesamiento  
+SubtitleYXAxisDifferencePixel = Umbral diferencia alto/ancho  
+SubtitleYXAxisDifferencePixelDesc = Determina áreas no subtituladas (valor predeterminado 10). Los subtítulos suelen ser rectángulos horizontales.  
+SubtitleAreaDeviationPixel = Margen de píxeles permitido  
+SubtitleAreaDeviationPixelDesc = Amplía la máscara para evitar bordes residuales (valor predeterminado 10).  
+SubtitleAreaYAxisDifferencePixel = Umbral altura misma línea  
+SubtitleAreaYAxisDifferencePixelDesc = Determina si dos cuadros están en la misma línea (valor predeterminado 20 píxeles).  
+SubtitleAreaPixelToleranceYPixel = Tolerancia eje Y  
+SubtitleAreaPixelToleranceYPixelDesc = Determina similitud vertical entre subtítulos (valor predeterminado 20).  
+SubtitleAreaPixelToleranceXPixel = Tolerancia eje X  
+SubtitleAreaPixelToleranceXPixelDesc = Determina similitud horizontal entre subtítulos (valor predeterminado 20).  
+SubtitleTimelineBackwardFrameCount = Retroceso en línea temporal  
+SubtitleTimelineBackwardFrameCountDesc = Añade fotogramas antes de subtítulos detectados (valor predeterminado 3).  
+subtitleTimelineForwardFrameCount = Avance en línea temporal  
+subtitleTimelineForwardFrameCountDesc = Añade fotogramas después de subtítulos detectados (valor predeterminado 3).  
+SttnNeighborStride = Intervalo de referencia  
+SttnNeighborStrideDesc = Valor predeterminado: 5  
+SttnReferenceLength = Cantidad de referencias  
+SttnReferenceLengthDesc = Valor predeterminado: 10  
+SttnMaxLoadNum = Máx. fotogramas simultáneos  
+SttnMaxLoadNumDesc = Mayor valor mejora calidad pero requiere más VRAM (valor predeterminado 50).  
+PropainterMaxLoadNum = Máx. fotogramas simultáneos  
+PropainterMaxLoadNumDesc = Mayor valor mejora calidad pero requiere más VRAM (valor predeterminado 70).  
+CheckUpdateOnStartup = Buscar actualizaciones al iniciar  
+CheckUpdateOnStartupDesc = Versiones nuevas ofrecen mejor estabilidad y funciones (recomendado).  
+UpdatesAvailableTitle = Actualización disponible  
+UpdatesAvailableDesc = Nueva versión {} disponible. ¿Actualizar ahora?  
+NoUpdatesAvailableTitle = Sin actualizaciones  
+NoUpdatesAvailableDesc = El software está actualizado.  
+
+[SubtitleExtractorGUI]  
+Title = Eliminador de subtítulos  
+Open = Abrir  
+AllFile = Todos los archivos  
+Vertical = Vertical  
+Horizontal = Horizontal  
+Run = Ejecutar  
+Stop = Detener  
+Setting = Configuración  
+OpenVideoSuccess = Video abierto correctamente  
+OpenVideoFailed = Error al abrir video: {} (formato incompatible o archivo dañado)  
+OpenVideoFirst = Abre un video primero  
+SubtitleArea = Área de subtítulos  
+VideoPreview = Vista previa  
+InterfaceLanguage = Idioma de interfaz  
+InpaintMode = Modelo de procesamiento  
+SelectSubtitleArea = Selecciona área en vista previa  
+InpaintModeDesc = STTN Borrado inteligente: Mejor para videos de personas reales, velocidad rápida, borrado inteligente (mínimo 4GB de VRAM) 
+    STTN Detección de subtítulos: Con detección de subtítulos, sin borrado inteligente (mínimo 4GB de VRAM) 
+    LAMA: Bueno para videos animados, velocidad media (bajo requerimiento de VRAM) 
+    ProPainter: Consume mucha VRAM, velocidad lenta, mejor para videos con mucho movimiento (mínimo 8GB de VRAM) 
+    OpenCV: Modo ultra rápido, el efecto de borrado no está garantizado, solo elimina texto en las áreas detectadas (bajo requerimiento de VRAM)
+SubtitleDetectMode = Detección de subtítulos  
+ErrorDuringProcessing = Error durante el procesamiento: {}
+
+[Main]  
+SubtitleDetectionAcceleratorON = Detección de subtítulos acelerada con {}
+OnnxExectionProviderNotSupportedSkipped = Proveedor ONNX: {} no soportado, omitido.  
+OnnxExecutionProviderDetected = Proveedor ONNX detectado: {}  
+OnnxRuntimeNotInstall = Entorno ONNX no instalado, omitido.  
+NoSubtitleDetected = Sin subtítulos detectados. Verifica archivo: {}  
+DirectMLWarning = Advertencia: Aceleración DirectML solo funciona con modelo STTN.  
+ProcessingStartFindingSubtitles = [Procesando] Detectando subtítulos...  
+FinishedFindingSubtitles = [Completo] Detección finalizada.  
+ProcessingStartRemovingSubtitles = [Procesando] Eliminando subtítulos...  
+UseModel = Usar modelo para eliminar subtítulos: {}
+FullScreenProcessingNote = Procesando pantalla completa (área no seleccionada).  
+ReadFileFailed = Error al leer archivo: {}  
+FinishedProcessing = [Completo] Subtítulos eliminados. Guardado en: {}  
+ProcessingTime = Tiempo procesamiento: {} segundos  
+FailToMergeAudio = Error mezclando audio: {}  
+FailToExtractAudio = Error extrayendo audio: {}  
+CopyFileFailed = Error copiando {} a {}. Razón: {}  
+
+[TaskList]  
+Pending = Pendiente  
+Processing = Procesando  
+Completed = Completado  
+Failed = Fallado  
+Name = Nombre  
+Progress = ⠀Progreso⠀  
+Status = ㅤEstadoㅤ  
+OpenSourceVideoLocation = Abrir ubicación original  
+OpenTargetVideoLocation = Abrir archivo resultante  
+ResetTaskStatus = Reiniciar tarea  
+DeleteTask = Eliminar tarea  
+Warning = Advertencia  
+UnableToLocateFile = Archivo no encontrado (posiblemente movido/eliminado)  
+TargetFileNotFound = Archivo resultado no generado. Espera a completar.  
+
+[VersionService]  
+VersionInfo = Versión actual: {} Última versión: {}  
+RequestError = Error accediendo {}. Razón: {}  
+
+[InpaintMode]  
+SttnAuto = STTN borrado inteligente  
+SttnDet = STTN detección  
+LAMA = LAMA  
+ProPainter = ProPainter  
+OpenCV = OpenCV  
+
+[SubtitleDetectMode]  
+Fast = Rápido  
+Accurate = Preciso  
+
+[InterfaceLanguage]  
+ChineseSimplified = 简体中文  
+ChineseTraditional = 繁體中文  
+English = English  
+Japanese = 日本語  
+Korean = 한국어  
+Vietnamese = Tiếng Việt  
+Español = Español

backend/interface/japan.ini

@@ -0,0 +1,129 @@
+[Setting]
+FeedbackButton = フィードバック
+FeedbackTitle = フィードバック提供
+FeedbackDesc = フィードバックを通じて改善にご協力ください
+CopyrightButton = アップデート確認
+CopyrightTitle = バージョン情報
+CopyrightDesc = ©著作権 2023, YaoFANGUK, Jason Eric (UIデザイン), 現在のバージョン: {}
+ProjectLinkTitle = 字幕除去ツール
+ProjectLinkDesc = AIベースの画像/動画ハード字幕除去、テキスト透かし除去。解像度を維持したまま字幕・透かしを除去したファイルを生成。サードパーティAPI不要のローカル実装。
+BasicSetting = 基本設定
+AdvancedSetting = 高度設定
+SubtitleDetectionSetting = 字幕検出設定
+SttnSetting = STTN設定
+ProPainterSetting = ProPainter設定
+AboutSetting = 情報
+HardwareAcceleration = ハードウェアアクセラレーション
+HardwareAccelerationDesc = GPUまたはONNXバックエンドを使用した高速処理
+SubtitleYXAxisDifferencePixel = 高さ/幅ピクセル差しきい値
+SubtitleYXAxisDifferencePixelDesc = 非字幕領域判定基準（デフォルト10）。字幕ボックスは通常幅より高さが短い
+SubtitleAreaDeviationPixel = 許容ピクセル偏差
+SubtitleAreaDeviationPixelDesc = マスクサイズ拡張（デフォルト10）。小さなテキストボックス防止
+SubtitleAreaYAxisDifferencePixel = 同行字幕高さ差しきい値
+SubtitleAreaYAxisDifferencePixelDesc = 同一行字幕判定基準（デフォルト20ピクセル）
+SubtitleAreaPixelToleranceYPixel = Y軸許容偏差
+SubtitleAreaPixelToleranceYPixelDesc = 類似字幕ボックスY軸偏差基準（デフォルト20）
+SubtitleAreaPixelToleranceXPixel = X軸許容偏差
+SubtitleAreaPixelToleranceXPixelDesc = 類似字幕ボックスX軸偏差基準（デフォルト20）
+SubtitleTimelineBackwardFrameCount = 字幕タイムライン後退フレーム数
+SubtitleTimelineBackwardFrameCountDesc = 徐々に出現する字幕処理用追加フレーム（デフォルト3）
+subtitleTimelineForwardFrameCount = 字幕タイムライン前進フレーム数
+subtitleTimelineForwardFrameCountDesc = 徐々に消える字幕処理用追加フレーム（デフォルト3）
+SttnNeighborStride = 参照フレーム間隔
+SttnNeighborStrideDesc = デフォルト: 5
+SttnReferenceLength = 参照フレーム数
+SttnReferenceLengthDesc = デフォルト: 10
+SttnMaxLoadNum = 最大同時処理フレーム数
+SttnMaxLoadNumDesc = 値が大きいほど高品質（VRAM要求増加、デフォルト50）
+PropainterMaxLoadNum = 最大同時処理フレーム数
+PropainterMaxLoadNumDesc = 値が大きいほど高品質（VRAM要求増加、デフォルト70）
+CheckUpdateOnStartup = 起動時アップデート確認
+CheckUpdateOnStartupDesc = 新バージョンは安定性/機能向上（推奨）
+UpdatesAvailableTitle = 利用可能なアップデート
+UpdatesAvailableDesc = 新バージョン {} を発見。更新しますか？
+NoUpdatesAvailableTitle = 利用可能なアップデートなし
+NoUpdatesAvailableDesc = 最新バージョンです
+
+[SubtitleExtractorGUI]
+Title = 字幕除去ツール
+Open = 開く
+AllFile = 全てのファイル
+Vertical = 垂直方向
+Horizontal = 水平方向
+Run = 実行
+Stop = 停止
+Setting = 設定
+OpenVideoSuccess = 動画を正常に開きました
+OpenVideoFailed = 動画を開けません: {}（形式非対応/ファイル破損）
+OpenVideoFirst = 動画を先に開いてください
+SubtitleArea = 字幕領域
+VideoPreview = 動画プレビュー
+InterfaceLanguage = インターフェース言語
+InpaintMode = 処理モデル
+SelectSubtitleArea = プレビューで処理領域を選択
+InpaintModeDesc = STTNスマート消去：実写動画に最適、高速、スマート消去（最低4GB VRAM）
+    STTN字幕検出：字幕検出付き、スマート消去なし（最低4GB VRAM）
+    LAMA：アニメ動画に最適、速度は普通（VRAM要件低め）
+    ProPainter：大量のVRAMを消費、速度は遅い、激しい動きの動画に最適（最低8GB VRAM）
+    OpenCV：超高速モード、消去効果は保証されません、検出されたテキスト領域のみ削除（VRAM要件低め）
+SubtitleDetectMode = 字幕検出
+ErrorDuringProcessing = 処理中にエラーが発生しました: {}
+
+[Main]
+SubtitleDetectionAcceleratorON = 字幕検出を{}で加速
+OnnxExectionProviderNotSupportedSkipped = ONNXプロバイダ: {} 非対応
+OnnxExecutionProviderDetected=ONNXプロバイダ検出: {}
+OnnxRuntimeNotInstall = ONNXランタイム未インストール
+NoSubtitleDetected = 字幕未検出。ファイル確認: {}
+DirectMLWarning = 警告: DirectML加速はSTTNモデルのみ
+ProcessingStartFindingSubtitles = [処理中] 字幕検索開始...
+FinishedFindingSubtitles = [完了] 字幕検索終了
+ProcessingStartRemovingSubtitles = [処理中] 字幕削除開始...
+UseModel = 字幕除去用モデル: {}
+FullScreenProcessingNote = 全画面処理（領域未選択）
+ReadFileFailed = ファイル読み込み失敗: {}
+FinishedProcessing = [完了] 字幕削除成功。保存先: {}
+ProcessingTime = 処理時間: {}秒
+FailToMergeAudio = 音声統合失敗: {}
+FailToExtractAudio = 音声抽出失敗: {}
+CopyFileFailed = ファイルコピー失敗 {} → {}。理由: {}
+
+[TaskList]
+Pending = 待機中
+Processing = 処理中
+Completed = 完了
+Failed = 失敗
+Name = 名称
+Progress = ⠀進捗⠀
+Status = ㅤ状態ㅤ
+OpenSourceVideoLocation = 元動画場所を開く
+OpenTargetVideoLocation = 結果動画場所を開く
+ResetTaskStatus = タスク状態リセット
+DeleteTask = タスク削除
+Warning = 警告
+UnableToLocateFile = ファイルが見つかりません
+TargetFileNotFound = ファイル未生成（処理完了待機）
+
+[VersionService]
+VersionInfo = 現在バージョン: {} 最新バージョン: {}
+RequestError = {} へのアクセス失敗。理由: {}
+
+[InpaintMode]
+SttnAuto = STTNインテリジェント消去
+SttnDet = STTN字幕検出
+LAMA = LAMA
+ProPainter = ProPainter
+OpenCV = OpenCV
+
+[SubtitleDetectMode]
+Fast = 高速
+Accurate = 高精度
+
+[InterfaceLanguage]
+ChineseSimplified = 简体中文
+ChineseTraditional = 繁體中文
+English = English
+Japanese = 日本語
+Korean = 한국어
+Vietnamese = Tiếng Việt
+Español = Español

backend/interface/ko.ini

@@ -0,0 +1,129 @@
+[Setting]
+FeedbackButton = 피드백
+FeedbackTitle = 피드백 제공
+FeedbackDesc = 피드백을 통해 개선에 도움을 주세요
+CopyrightButton = 업데이트 확인
+CopyrightTitle = 정보
+CopyrightDesc = ©저작권 2023, YaoFANGUK, Jason Eric (UI 디자인), 현재 버전: {}
+ProjectLinkTitle = 자막 제거 도구
+ProjectLinkDesc = AI 기반 이미지/동영상 하드 자막 제거, 텍스트 워터마크 제거. 원본 해상도 유지하며 자막 및 워터마크 제거된 파일 생성. 타사 API 불필요, 로컬 처리 구현.
+BasicSetting = 기본 설정
+AdvancedSetting = 고급 설정
+SubtitleDetectionSetting = 자막 감지 설정
+SttnSetting = STTN 설정
+ProPainterSetting = ProPainter 설정
+AboutSetting = 정보
+HardwareAcceleration = 하드웨어 가속
+HardwareAccelerationDesc = GPU 또는 ONNX 백엔드 사용 가속 처리
+SubtitleYXAxisDifferencePixel = 높이-너비 픽셀 차이 임계값
+SubtitleYXAxisDifferencePixelDesc = 비자막 영역 판단 기준 (기본값 10). 자막 상자는 일반적으로 가로 길이가 세로보다 큽니다.
+SubtitleAreaDeviationPixel = 허용 픽셀 편차
+SubtitleAreaDeviationPixelDesc = 마스크 크기 확장 (기본값 10). 작은 텍스트 상자 방지
+SubtitleAreaYAxisDifferencePixel = 동일 행 자막 높이 차 임계값
+SubtitleAreaYAxisDifferencePixelDesc = 동일 행 자막 판단 기준 (기본값 20픽셀)
+SubtitleAreaPixelToleranceYPixel = Y축 허용 편차
+SubtitleAreaPixelToleranceYPixelDesc = 유사 자막 상자 Y축 편차 기준 (기본값 20)
+SubtitleAreaPixelToleranceXPixel = X축 허용 편차
+SubtitleAreaPixelToleranceXPixelDesc = 유사 자막 상자 X축 편차 기준 (기본값 20)
+SubtitleTimelineBackwardFrameCount = 타임라인 역방향 프레임 수
+SubtitleTimelineBackwardFrameCountDesc = 점진적 시작 자막 처리용 추가 프레임 (기본값 3)
+subtitleTimelineForwardFrameCount = 타임라인 순방향 프레임 수
+subtitleTimelineForwardFrameCountDesc = 점진적 종료 자막 처리용 추가 프레임 (기본값 3)
+SttnNeighborStride = 참조 프레임 간격
+SttnNeighborStrideDesc = 기본값: 5
+SttnReferenceLength = 참조 프레임 수
+SttnReferenceLengthDesc = 기본값: 10
+SttnMaxLoadNum = 최대 동시 처리 프레임
+SttnMaxLoadNumDesc = 값 클수록 품질 향상 (VRAM 요구 증가, 기본값 50)
+PropainterMaxLoadNum = 최대 동시 처리 프레임
+PropainterMaxLoadNumDesc = 값 클수록 품질 향상 (VRAM 요구 증가, 기본값 70)
+CheckUpdateOnStartup = 시작시 업데이트 확인
+CheckUpdateOnStartupDesc = 새 버전은 안정성/기능 개선 포함 (권장)
+UpdatesAvailableTitle = 업데이트 가능
+UpdatesAvailableDesc = 새 버전 {} 발견. 업데이트할까요?
+NoUpdatesAvailableTitle = 사용 가능한 업데이트 없음
+NoUpdatesAvailableDesc = 최신 버전입니다.
+
+[SubtitleExtractorGUI]
+Title = 자막 제거 도구
+Open = 열기
+AllFile = 모든 파일
+Vertical = 수직
+Horizontal = 수평
+Run = 실행
+Stop = 중지
+Setting = 설정
+OpenVideoSuccess = 동영상 열기 성공
+OpenVideoFailed = 동영상 열기 실패: {} (형식 불일치/파일 손상)
+OpenVideoFirst = 동영상을 먼저 열어주세요
+SubtitleArea = 자막 영역
+VideoPreview = 동영상 미리보기
+InterfaceLanguage = 인터페이스 언어
+InpaintMode = 처리 모델
+SelectSubtitleArea = 미리보기에서 처리 영역 선택
+InpaintModeDesc = STTN 스마트 지우기: 실제 인물 영상에 적합, 빠른 속도, 스마트 지우기(최소 4GB VRAM) 
+    STTN 자막 감지: 자막 감지 버전, 스마트 지우기 없음(최소 4GB VRAM) 
+    LAMA: 애니메이션 영상에 적합, 보통 속도(VRAM 요구량 낮음) 
+    ProPainter: 많은 VRAM 소모, 느린 속도, 격렬한 움직임 영상에 적합(최소 8GB VRAM) 
+    OpenCV: 초고속 모드, 인페인트 효과 보장 안 됨, 텍스트 영역만 제거(VRAM 요구량 낮음)
+SubtitleDetectMode = 자막 감지
+ErrorDuringProcessing = 처리 중 오류: {}
+
+[Main]
+SubtitleDetectionAcceleratorON = 자막 감지 {} 가속 사용
+OnnxExectionProviderNotSupportedSkipped = ONNX 공급자: {} 지원 안됨
+OnnxExecutionProviderDetected=ONNX 공급자 감지: {}
+OnnxRuntimeNotInstall = ONNX 런타임 미설치
+NoSubtitleDetected = 자막 없음. 파일 확인: {}
+DirectMLWarning = 경고: DirectML 가속은 STTN 모델 전용
+ProcessingStartFindingSubtitles = [진행중] 자막 검색 시작...
+FinishedFindingSubtitles = [완료] 자막 검색 완료
+ProcessingStartRemovingSubtitles = [진행중] 자막 제거 시작...
+UseModel = 자막 제거 모델 사용: {}
+FullScreenProcessingNote = 전체 화면 처리 (영역 미선택)
+ReadFileFailed = 파일 읽기 실패: {}
+FinishedProcessing = [완료] 자막 제거 완료. 저장 위치: {}
+ProcessingTime = 처리 시간: {}초
+FailToMergeAudio = 오디오 병합 실패: {}
+FailToExtractAudio = 오디오 추출 실패: {}
+CopyFileFailed = 파일 복사 실패 {} → {}. 이유: {}
+
+[TaskList]
+Pending = 대기중
+Processing = 처리중
+Completed = 완료됨
+Failed = 실패
+Name = 이름
+Progress = ⠀진행률⠀
+Status = ㅤ상태ㅤ
+OpenSourceVideoLocation = 원본 파일 위치 열기
+OpenTargetVideoLocation = 결과 파일 위치 열기
+ResetTaskStatus = 작업 상태 재설정
+DeleteTask = 작업 삭제
+Warning = 경고
+UnableToLocateFile = 파일 찾을 수 없음
+TargetFileNotFound = 결과 파일 미생성 (작업 완료 대기)
+
+[VersionService]
+VersionInfo = 현재 버전: {} 최신 버전: {}
+RequestError = {} 접근 실패. 이유: {}
+
+[InpaintMode]
+SttnAuto = STTN 지능형 제거
+SttnDet = STTN 자막 감지
+LAMA = LAMA
+ProPainter = ProPainter
+OpenCV = OpenCV
+
+[SubtitleDetectMode]
+Fast = 빠름
+Accurate = 정확
+
+[InterfaceLanguage]
+ChineseSimplified = 简体中文
+ChineseTraditional = 繁體中文
+English = English
+Japanese = 日本語
+Korean = 한국어
+Vietnamese = Tiếng Việt
+Español = Español

backend/interface/vi.ini

@@ -0,0 +1,129 @@
+[Setting]
+FeedbackButton = Gửi phản hồi
+FeedbackTitle = Gửi phản hồi
+FeedbackDesc = Giúp chúng tôi cải thiện bằng cách gửi phản hồi
+CopyrightButton = Kiểm tra cập nhật
+CopyrightTitle = Giới thiệu
+CopyrightDesc = ©Bản quyền 2023, YaoFANGUK, Jason Eric (Thiết kế UI), Phiên bản hiện tại: {}
+ProjectLinkTitle = Công cụ xóa phụ đề
+ProjectLinkDesc = Xóa phụ đề cứng và watermark văn bản từ ảnh/video bằng AI, tạo file đầu ra giữ nguyên độ phân giải. Không cần API bên thứ ba, xử lý cục bộ.
+BasicSetting = Cài đặt cơ bản
+AdvancedSetting = Cài đặt nâng cao
+SubtitleDetectionSetting = Cài đặt phát hiện phụ đề
+SttnSetting = Cài đặt STTN
+ProPainterSetting = Cài đặt ProPainter
+AboutSetting = Giới thiệu
+HardwareAcceleration = Tăng tốc phần cứng
+HardwareAccelerationDesc = Sử dụng GPU hoặc backend ONNX để tăng tốc xử lý
+SubtitleYXAxisDifferencePixel = Ngưỡng chênh lệch chiều cao/rộng
+SubtitleYXAxisDifferencePixelDesc = Xác định vùng không phải phụ đề (mặc định 10). Hộp phụ đề thường có chiều dài lớn hơn chiều rộng.
+SubtitleAreaDeviationPixel = Độ lệch pixel cho phép
+SubtitleAreaDeviationPixelDesc = Mở rộng kích thước mask (mặc định 10), tránh hộp văn bản quá nhỏ
+SubtitleAreaYAxisDifferencePixel = Ngưỡng chênh lệch chiều cao cùng dòng
+SubtitleAreaYAxisDifferencePixelDesc = Xác định phụ đề cùng dòng (mặc định 20 pixel)
+SubtitleAreaPixelToleranceYPixel = Dung sai trục Y
+SubtitleAreaPixelToleranceYPixelDesc = Xác định hộp phụ đề tương tự theo trục Y (mặc định 20)
+SubtitleAreaPixelToleranceXPixel = Dung sai trục X
+SubtitleAreaPixelToleranceXPixelDesc = Xác định hộp phụ đề tương tự theo trục X (mặc định 20)
+SubtitleTimelineBackwardFrameCount = Số khung lùi timeline
+SubtitleTimelineBackwardFrameCountDesc = Thêm khung xử lý cho phụ đề xuất hiện dần (mặc định 3)
+subtitleTimelineForwardFrameCount = Số khung tiến timeline
+subtitleTimelineForwardFrameCountDesc = Thêm khung xử lý cho phụ đề biến mất dần (mặc định 3)
+SttnNeighborStride = Bước khung tham chiếu
+SttnNeighborStrideDesc = Mặc định: 5
+SttnReferenceLength = Số khung tham chiếu
+SttnReferenceLengthDesc = Mặc định: 10
+SttnMaxLoadNum = Số khung xử lý tối đa
+SttnMaxLoadNumDesc = Càng cao càng tốt (yêu cầu nhiều VRAM, mặc định 50)
+PropainterMaxLoadNum = Số khung xử lý tối đa
+PropainterMaxLoadNumDesc = Càng cao càng tốt (yêu cầu nhiều VRAM, mặc định 70)
+CheckUpdateOnStartup = Kiểm tra cập nhật khi khởi động
+CheckUpdateOnStartupDesc = Phiên bản mới ổn định hơn (khuyến nghị bật)
+UpdatesAvailableTitle = Có bản cập nhật
+UpdatesAvailableDesc = Phát hiện phiên bản mới {}, cập nhật?
+NoUpdatesAvailableTitle = Không có cập nhật
+NoUpdatesAvailableDesc = Đang dùng phiên bản mới nhất
+
+[SubtitleExtractorGUI]
+Title = Công cụ xóa phụ đề
+Open = Mở
+AllFile = Tất cả file
+Vertical = Dọc
+Horizontal = Ngang
+Run = Chạy
+Stop = Dừng
+Setting = Cài đặt
+OpenVideoSuccess = Mở video thành công
+OpenVideoFailed = Lỗi mở video: {} (định dạng không hỗ trợ)
+OpenVideoFirst = Vui lòng mở video trước
+SubtitleArea = Vùng phụ đề
+VideoPreview = Xem trước video
+InterfaceLanguage = Ngôn ngữ giao diện
+InpaintMode = Chế độ xử lý
+SelectSubtitleArea = Chọn vùng xử lý trong preview
+InpaintModeDesc = STTN Xóa thông minh: Phù hợp cho video người thật, tốc độ nhanh, xóa thông minh (tối thiểu 4GB VRAM)
+    STTN Phát hiện phụ đề: Có phát hiện phụ đề, không xóa thông minh (tối thiểu 4GB VRAM)
+    LAMA: Phù hợp cho video hoạt hình, tốc độ trung bình (yêu cầu VRAM thấp)
+    ProPainter: Tiêu tốn nhiều VRAM, tốc độ chậm, phù hợp cho video chuyển động mạnh (tối thiểu 8GB VRAM)
+    OpenCV: Chế độ siêu nhanh, không đảm bảo hiệu quả xóa, chỉ xóa vùng chứa văn bản (yêu cầu VRAM thấp)
+SubtitleDetectMode = Chế độ phát hiện
+ErrorDuringProcessing = Lỗi khi xử lý: {}
+
+[Main]
+SubtitleDetectionAcceleratorON = Phát hiện phụ đề được tăng tốc bằng {}
+OnnxExectionProviderNotSupportedSkipped = ONNX provider: {} không hỗ trợ
+OnnxExecutionProviderDetected= Phát hiện ONNX provider: {}
+OnnxRuntimeNotInstall = Chưa cài đặt ONNX Runtime
+NoSubtitleDetected = Không phát hiện phụ đề, kiểm tra file: {}
+DirectMLWarning = Cảnh báo: DirectML chỉ hỗ trợ STTN
+ProcessingStartFindingSubtitles = [Đang xử lý] Bắt đầu tìm phụ đề...
+FinishedFindingSubtitles = [Hoàn thành] Tìm phụ đề xong
+ProcessingStartRemovingSubtitles = [Đang xử lý] Bắt đầu xóa phụ đề...
+UseModel = Sử dụng mô hình xóa phụ đề: {}
+FullScreenProcessingNote = Xử lý toàn màn hình (không chọn vùng)
+ReadFileFailed = Lỗi đọc file: {}
+FinishedProcessing = [Hoàn thành] Xóa phụ đề thành công, lưu tại: {}
+ProcessingTime = Thời gian xử lý: {} giây
+FailToMergeAudio = Lỗi ghép audio: {}
+FailToExtractAudio = Lỗi trích xuất audio: {}
+CopyFileFailed = Lỗi sao chép {} → {}, lý do: {}
+
+[TaskList]
+Pending = Đang chờ
+Processing = Đang xử lý
+Completed = Hoàn thành
+Failed = Thất bại
+Name = Tên
+Progress = ⠀Tiến trình⠀
+Status = ㅤTrạng tháiㅤ
+OpenSourceVideoLocation = Mở vị trí video gốc
+OpenTargetVideoLocation = Mở vị trí file kết quả
+ResetTaskStatus = Đặt lại trạng thái
+DeleteTask = Xóa task
+Warning = Cảnh báo
+UnableToLocateFile = Không tìm thấy file
+TargetFileNotFound = File chưa được tạo
+
+[VersionService]
+VersionInfo = Phiên bản hiện tại: {} Mới nhất: {}
+RequestError = Lỗi truy cập {}, lý do: {}
+
+[InpaintMode]
+SttnAuto = STTN xóa thông minh
+SttnDet = STTN phát hiện
+LAMA = LAMA
+ProPainter = ProPainter
+OpenCV = OpenCV
+
+[SubtitleDetectMode]
+Fast = Nhanh
+Accurate = Chính xác
+
+[InterfaceLanguage]
+ChineseSimplified = 简体中文
+ChineseTraditional = 繁體中文
+English = English
+Japanese = 日本語
+Korean = 한국어
+Vietnamese = Tiếng Việt
+Español = Español

backend/tools/args_handler.py

@@ -0,0 +1,41 @@
+import argparse
+from enum import Enum
+
+from .constant import InpaintMode
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Video Subtitle Remover Command Line Tool"
+    )
+    parser.add_argument(
+        "--input", "-i", required=True, type=str,
+        help="Input video file path"
+    )
+    parser.add_argument(
+        "--output", "-o", required=False, type=str, default=None,
+        help="Output video file path (optional)"
+    )
+    parser.add_argument(
+        "--ymin", type=int, default=None,
+        help="Subtitle area ymin (optional)"
+    )
+    parser.add_argument(
+        "--ymax", type=int, default=None,
+        help="Subtitle area ymax (optional)"
+    )
+    parser.add_argument(
+        "--xmin", type=int, default=None,
+        help="Subtitle area xmin (optional)"
+    )
+    parser.add_argument(
+        "--xmax", type=int, default=None,
+        help="Subtitle area xmax (optional)"
+    )
+    parser.add_argument(
+        "--inpaint-mode", type=str, default="sttn-auto",
+        choices=[mode.name.lower().replace('_','-') for mode in InpaintMode],
+        help="Inpaint mode, default is sttn-auto"
+    )
+    args = parser.parse_args()
+    args.inpaint_mode = InpaintMode[args.inpaint_mode.replace('-','_').upper()]
+    return args

backend/tools/common_tools.py

@@ -1,4 +1,10 @@
 import os
+import sys
+import ctypes
+
+import cv2
+import numpy as np
+from fsplit.filesplit import Filesplit
 
 video_extensions = {
     '.mp4', '.m4a', '.m4v', '.f4v', '.f4a', '.m4b', '.m4r', '.f4b', '.mov',
@@ -30,3 +36,24 @@ def is_video_or_image(filename):
     file_extension = os.path.splitext(filename)[-1].lower()
     # 检查扩展名是否在定义的视频或图片文件后缀集合中
     return file_extension in video_extensions or file_extension in image_extensions
+
+def merge_big_file_if_not_exists(dir, file):
+    if file not in os.listdir(dir):
+        fs = Filesplit()
+        fs.merge(input_dir=dir)
+
+def get_readable_path(path):
+    if sys.platform != 'win32':
+        return path
+    buf = ctypes.create_unicode_buffer(4096)
+    ctypes.windll.kernel32.GetShortPathNameW(path, buf, 4096)
+    return buf.value
+
+def read_image(path):
+    if os.path.getsize(path) > 100*1024*1024: # 100MB
+        print(f"Image {path} is too large, skip")
+        return None
+    img = cv2.imdecode(np.fromfile(path, dtype=np.uint8), -1)
+    if img is not None and img.shape[-1] == 4:
+        img = cv2.cvtColor(img, cv2.COLOR_BGRA2BGR)
+    return img

backend/tools/concurrent/__init__.py

@@ -0,0 +1 @@
+from .task_manager import TaskExecutor, Future

backend/tools/concurrent/future.py

@@ -0,0 +1,248 @@
+from typing import List, Optional, Callable, Iterable, Sized, Tuple, Union
+
+from PySide6.QtCore import QObject, Signal, QMutex, QSemaphore
+
+
+class FutureError(BaseException):
+    pass
+
+
+class FutureFailed(FutureError):
+    def __init__(self, _exception: Optional[BaseException]):
+        super().__init__()
+        self.exception = _exception
+
+    def __repr__(self):
+        return f"FutureFailed({self.exception})"
+
+    def __str__(self):
+        return f"FutureFailed({self.exception})"
+
+
+class GatheredFutureFailed(FutureError):
+    def __init__(self, failures: List[Tuple['Future', BaseException]]):
+        super().__init__()
+        self.failures = failures
+
+    def __repr__(self):
+        return f"GatheredFutureFailed({self.failures})"
+
+    def __str__(self):
+        return f"GatheredFutureFailed({self.failures})"
+
+    def __iter__(self):
+        return iter(self.failures)
+
+    def __len__(self):
+        return len(self.failures)
+
+
+class FutureCancelled(FutureError):
+    def __init__(self):
+        super().__init__()
+
+    def __repr__(self):
+        return f"FutureCanceled()"
+
+    def __str__(self):
+        return f"FutureCanceled()"
+
+
+class Future(QObject):
+    result = Signal(object)  # self
+    done = Signal(object)  # self
+    failed = Signal(object)  # self
+    partialDone = Signal(object)  # child future
+    childrenDone = Signal(object)  # self
+
+    def __init__(self, semaphore=0):
+        super().__init__()
+        self._taskID = None
+        self._failedCallback = lambda e: None
+        self._done = False
+        self._failed = False
+        self._result = None
+        self._exception = None
+        self._children = []
+        self._counter = 0
+        self._parent = None
+        self._callback = lambda _: None
+        self._mutex = QMutex()
+        self._extra = {}
+        self._semaphore = QSemaphore(semaphore)
+
+    def __onChildDone(self, childFuture: 'Future') -> None:
+        self._mutex.lock()
+        if childFuture.isFailed():
+            self._failed = True
+        self._counter += 1
+        self.partialDone.emit(childFuture)
+        try:
+            idx = getattr(childFuture, "_idx")
+            self._result[idx] = childFuture._result
+            self._mutex.unlock()
+        except AttributeError:
+            self._mutex.unlock()
+            raise RuntimeError(
+                "Invalid child future: please ensure that the child future is created by method 'Future.setChildren'")
+
+        if self._counter == len(self._children):
+            if self._failed:  # set failed
+                l = []
+
+                for i, child in enumerate(self._children):
+                    if isinstance(e := child.getException(), FutureError):
+                        l.append((self._children[i], e))
+
+                self.setFailed(GatheredFutureFailed(l))
+            else:
+                self.setResult(self._result)
+
+    def __setChildren(self, children: List['Future']) -> None:
+        self._children = children
+        self._result = [None] * len(children)
+
+        for i, fut in enumerate(self._children):
+            setattr(fut, f"_idx", i)
+            fut.childrenDone.connect(self.__onChildDone)
+            fut._parent = self
+
+        for i, fut in enumerate(self._children):  # check if child is done
+            if fut.isDone():
+                self.__onChildDone(fut)
+
+    def setResult(self, result) -> None:
+        """
+        :param result: The result to set
+        :return: None
+
+        do not set result in thread pool,or it may not set correctly
+        please use in main thread,or use signal-slot to set result !!!
+        """
+        if self._done:
+            raise RuntimeError("Future already done")
+
+        self._result = result
+        self._done = True
+
+        if self._parent:
+            self.childrenDone.emit(self)
+
+        if self._callback:
+            self._callback(result)
+
+        self.result.emit(result)
+        self.done.emit(self)
+
+    def setFailed(self, exception) -> None:
+        """
+        :param exception: The exception to set
+        :return: None
+        """
+        if self._done:
+            raise RuntimeError("Future already done")
+
+        self._exception = FutureFailed(exception)
+        self._done = True
+        self._failed = True
+
+        if self._parent:
+            self.childrenDone.emit(self)
+
+        if self._failedCallback:
+            self._failedCallback(self)
+
+        self.failed.emit(self._exception)
+        self.done.emit(self)
+
+    def setCallback(self, callback: Callable[[object, ], None]) -> None:
+        self._callback = callback
+
+    def setFailedCallback(self, callback: Callable[['Future', ], None]) -> None:
+        self._failedCallback = lambda e: callback(self)
+
+    def hasException(self) -> bool:
+        if self._children:
+            return any([fut.hasException() for fut in self._children])
+        else:
+            return self._exception is not None
+
+    def hasChildren(self) -> bool:
+        return bool(self._children)
+
+    def getException(self) -> Optional[BaseException]:
+        return self._exception
+
+    def setTaskID(self, _id: int) -> None:
+        self._taskID = _id
+
+    def getTaskID(self) -> int:
+        return self._taskID
+
+    def getChildren(self) -> List['Future']:
+        return self._children
+
+    @staticmethod
+    def gather(futures: {Iterable, Sized}) -> 'Future':
+        """
+        :param futures: An iterable of Future objects
+        :return: A Future object that will be done when all futures are done
+        """
+        future = Future()
+        future.__setChildren(futures)
+        return future
+
+    @property
+    def semaphore(self):
+        return self._semaphore
+
+    def wait(self):
+        if self.hasChildren():
+            for child in self.getChildren():
+                child.wait()
+        else:
+            self.semaphore.acquire(1)
+
+    def synchronize(self):
+        self.wait()
+
+    def isDone(self) -> bool:
+        return self._done
+
+    def isFailed(self) -> bool:
+        return self._failed
+
+    def getResult(self) -> Union[object, List[object]]:
+        return self._result
+
+    def setExtra(self, key, value):
+        self._extra[key] = value
+
+    def getExtra(self, key):
+        return self._extra.get(key, None)
+
+    def hasExtra(self, key):
+        return key in self._extra
+
+    def then(self, onSuccess: Callable, onFailed: Callable = None, onFinished : Callable = None):
+        self.result.connect(onSuccess)
+
+        if onFailed:
+            self.failed.connect(onFailed)
+
+        if onFinished:
+            self.done.connect(onFinished)
+
+        return self
+
+    def __getattr__(self, item):
+        return self.getExtra(item)
+
+    def __repr__(self):
+        return f"Future:({self._result})"
+
+    def __str__(self):
+        return f"Future({self._result})"
+
+    def __eq__(self, other):
+        return self._result == other._result

backend/tools/concurrent/task.py

@@ -0,0 +1,48 @@
+import functools
+from typing import Optional
+
+from PySide6.QtCore import QObject, Signal, QRunnable
+
+from .future import Future
+
+
+class WorkerSignal(QObject):
+    finished = Signal(object)
+
+
+class BaseTask(QRunnable):
+    def __init__(self, _id: int, future: Future):
+        super().__init__()
+        self._signal = WorkerSignal()  # Signal(object)
+        self._future = future
+        self._id = _id
+        self._exception: Optional[BaseException] = None
+        self._semaphore = future.semaphore
+
+    @property
+    def finished(self):
+        return self._signal.finished
+
+    @property
+    def signal(self):
+        return self._signal
+
+    def _taskDone(self, **data):
+        for d in data.items():
+            self._future.setExtra(*d)
+        self._signal.finished.emit(self._future)
+        self._semaphore.release(1)
+
+
+class Task(BaseTask):
+    def __init__(self, _id: int, future: Future, target: functools.partial, args, kwargs):
+        super().__init__(_id=_id, future=future)
+        self._target = target
+        self._kwargs = kwargs
+        self._args = args
+
+    def run(self) -> None:
+        try:
+            self._taskDone(result=self._target(*self._args, **self._kwargs))
+        except Exception as exception:
+            self._taskDone(exception=exception)

backend/tools/concurrent/task_manager.py

@@ -0,0 +1,111 @@
+import functools
+import warnings
+from typing import Dict, List, Callable
+
+from PySide6 import QtCore
+from PySide6.QtCore import QThreadPool, QObject, QRunnable
+
+from .future import Future, FutureCancelled
+from .task import BaseTask, Task
+
+
+def cpu_count():
+    return 8
+
+
+class BaseTaskExecutor(QObject):
+    def __init__(self, useGlobalThreadPool=True):
+        super().__init__()
+        self.useGlobalThreadPool = useGlobalThreadPool
+
+        if useGlobalThreadPool:
+            self.threadPool = QThreadPool.globalInstance()
+        else:
+            self.threadPool = QThreadPool()
+            self.threadPool.setMaxThreadCount(2 * cpu_count())  # IO-Bound = 2*N, CPU-Bound = N + 1
+
+        self.taskMap = {}
+        self.tasks: Dict[int, BaseTask] = {}
+        self.taskCounter = 0
+
+    def deleteLater(self) -> None:
+        if not self.useGlobalThreadPool:
+            self.threadPool.clear()
+            self.threadPool.waitForDone()
+            self.threadPool.deleteLater()
+
+        super().deleteLater()
+
+    def _taskRun(self, task: BaseTask, future: Future, **kwargs):
+        self.tasks[self.taskCounter] = task
+        future.setTaskID(self.taskCounter)
+        task.signal.finished.connect(self._taskDone, type=QtCore.Qt.ConnectionType.QueuedConnection)
+        self.threadPool.start(task)
+        self.taskCounter += 1
+
+    def _taskDone(self, fut: Future):
+        """
+        need manually set Future.setFailed() or Future.setResult() to be called!!!
+        """
+        self.tasks.pop(fut.getTaskID())
+        if isinstance(e := fut.getExtra("exception"), Exception):
+            fut.setFailed(e)
+        else:
+            fut.setResult(fut.getExtra("result"))
+
+    def _taskCancel(self, fut: Future):
+        stack: List[Future] = [fut]
+        while stack:
+            f = stack.pop()
+
+            if not f.hasChildren() and not f.isDone():
+                self._taskSingleCancel(f)
+                f.setFailed(FutureCancelled())
+
+            stack.extend(f.getChildren())
+
+    def _taskSingleCancel(self, fut: Future):
+        _id = fut.getTaskID()
+        taskRef: BaseTask = self.tasks[_id]
+
+        if taskRef is not None:
+            try:
+                taskRef.setAutoDelete(False)
+                self.threadPool.cancel(taskRef)
+                taskRef.setAutoDelete(True)
+            except RuntimeError:
+                print("wrapped C/C++ object of type FetchImageTask has been deleted")
+
+        del taskRef
+
+    def cancelTask(self, fut: Future):
+        warnings.warn("BaseTaskExecutor.cancelTask: 目前好像不能正常工作...", DeprecationWarning)
+        self._taskCancel(fut)
+
+
+class TaskExecutor(BaseTaskExecutor):
+
+    globalInstance = None
+
+    def asyncRun(self, target: Callable, *args, **kwargs) -> Future:
+        future = Future()
+        task = Task(
+            _id=self.taskCounter,
+            future=future,
+            target=target if target is functools.partial else functools.partial(target),
+            args=args,
+            kwargs=kwargs
+        )
+        self._taskRun(task, future)
+        return future
+
+    @classmethod
+    def instance(cls):
+        if cls.globalInstance is None:
+            cls.globalInstance = TaskExecutor()
+
+        return cls.globalInstance
+
+    @classmethod
+    def runTask(cls, task: Callable, *args, **kwargs) -> Future:
+        return cls.instance().asyncRun(task, *args, **kwargs)

backend/tools/constant.py

@@ -0,0 +1,20 @@
+from enum import Enum, unique
+
+@unique
+class InpaintMode(Enum):
+    """
+    图像重绘算法枚举
+    """
+    STTN_AUTO = "sttn-auto"
+    STTN_DET = "sttn-det"
+    LAMA = "lama"
+    PROPAINTER = "propainter"
+    OPENCV = "opencv"
+
+@unique
+class SubtitleDetectMode(Enum):
+    """
+    字幕检测算法枚举
+    """
+    Fast = 0
+    Accurate = 1

backend/tools/ffmpeg_cli.py

@@ -0,0 +1,36 @@
+import os
+import stat
+
+import platform
+from .common_tools import merge_big_file_if_not_exists
+from backend.config import BASE_DIR
+
+class FFmpegCLI:
+    
+    """
+    进程管理器类，用于管理子进程的生命周期
+    使用弱引用避免内存泄漏
+    """
+    _instance = None
+    
+    @classmethod
+    def instance(cls):
+        """单例模式获取实例"""
+        if cls._instance is None:
+            cls._instance = FFmpegCLI()
+        return cls._instance
+    
+    def __init__(self):
+        os.chmod(self.ffmpeg_path, stat.S_IRWXU + stat.S_IRWXG + stat.S_IRWXO)
+        
+    @property
+    def ffmpeg_path(self):
+        system = platform.system()
+        if system == "Windows":
+            ffmpeg_dir = os.path.join(BASE_DIR, 'ffmpeg', 'win_x64')
+            merge_big_file_if_not_exists(ffmpeg_dir, 'ffmpeg.exe')
+            return os.path.join(ffmpeg_dir, 'ffmpeg.exe')
+        elif system == "Linux":
+            return os.path.join(BASE_DIR, 'ffmpeg',  'linux_x64', 'ffmpeg')
+        else:
+            return os.path.join(BASE_DIR, 'ffmpeg', 'macos', 'ffmpeg')

backend/tools/hardware_accelerator.py

@@ -0,0 +1,120 @@
+import traceback
+import importlib.util
+
+import torch
+
+from backend.config import tr
+
+class HardwareAccelerator:
+
+    # 类变量，用于存储单例实例
+    _instance = None
+
+    @classmethod
+    def instance(cls):
+        """获取单例实例"""
+        if cls._instance is None:
+            cls._instance = HardwareAccelerator()
+            cls._instance.initialize()
+        return cls._instance
+
+    def __init__(self):
+        self.__cuda = False
+        self.__dml = False
+        self.__onnx_providers = []
+        self.__enabled = True
+        self.__device = None
+
+    def initialize(self):
+        self.check_directml_available()
+        self.check_cuda_available()
+        self.load_onnx_providers()
+
+    def check_directml_available(self):
+        self.__dml = importlib.util.find_spec("torch_directml")
+
+    def check_cuda_available(self):
+        self.__cuda = torch.cuda.is_available()
+
+    def load_onnx_providers(self):
+        try:
+            import onnxruntime as ort
+            available_providers = ort.get_available_providers()
+            for provider in available_providers:
+                if provider in [
+                    "CPUExecutionProvider"
+                ]:
+                    continue
+                if provider not in [
+                    "DmlExecutionProvider",         # DirectML，适用于 Windows GPU
+                    "ROCMExecutionProvider",        # AMD ROCm
+                    "MIGraphXExecutionProvider",    # AMD MIGraphX
+                    "VitisAIExecutionProvider",     # AMD VitisAI，适用于 RyzenAI & Windows, 实测和DirectML性能似乎差不多
+                    "OpenVINOExecutionProvider",    # Intel GPU
+                    "MetalExecutionProvider",       # Apple macOS
+                    "CoreMLExecutionProvider",      # Apple macOS
+                    "CUDAExecutionProvider",        # Nvidia GPU
+                ]:
+                    print(tr['Main']['OnnxExectionProviderNotSupportedSkipped'].format(provider))
+                    continue
+                print(tr['Main']['OnnxExecutionProviderDetected'].format(provider))
+                self.__onnx_providers.append(provider)
+        except ModuleNotFoundError as e:
+            print(tr['Main']['OnnxRuntimeNotInstall'])
+
+    def has_accelerator(self):
+        if not self.__enabled:
+            return False
+        return self.__cuda or self.__dml or len(self.__onnx_providers) > 0
+
+    @property
+    def accelerator_name(self):
+        if not self.__enabled:
+            return "CPU"
+        if self.__dml:
+            return "DirectML"
+        if self.__cuda:
+            return "GPU"
+        elif len(self.__onnx_providers) > 0:
+            return ", ".join(self.__onnx_providers)
+        else:
+            return "CPU"
+
+    @property
+    def onnx_providers(self):
+        if not self.__enabled:
+            return []
+        return self.__onnx_providers
+
+    def has_cuda(self):
+        if not self.__enabled:
+            return False
+        return self.__cuda
+    
+    def set_enabled(self, enable):
+        self.__enabled = enable
+
+    @property
+    def device(self):
+        """
+        onnxruntime-directml 1.21.1-1.22.0(往上未测试) 和 torch-directml 不能同时初始化, 会相互影响
+        提示site-packages/onnxruntime/capi/onnxruntime_inference_collection.py", line 266, in run
+                return self._sess.run(output_names, input_feed, run_options)
+                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+            UnicodeDecodeError: 'utf-8' codec can't decode byte 0xb2 in position 344: invalid start bn 344: invalid start byte
+        onnxruntime-directml 1.21.1 则正常, 但Win10跑不起来, Win11正常
+        为了避免冲突以及避免重写一个QPT智能部署流程, 这里采用延迟初始化的方式+继续使用onnxruntime-directml 1.20.1
+        当然SubtitleDetect放到一个独立进程去操作也是可以的
+        """
+        if self.__enabled:
+            if self.__dml:
+                try:
+                    import torch_directml
+                    return torch_directml.device(torch_directml.default_device())
+                    self.__dml = True
+                except:
+                    traceback.print_exc()
+                    self.__dml = False
+            if self.__cuda:
+                return torch.device("cuda:0")
+        return torch.device("cpu")

backend/tools/inpaint_tools.py

@@ -2,9 +2,7 @@ import multiprocessing
 import cv2
 import numpy as np
 
-from backend import config
+from backend.config import config
-from backend.inpaint.lama_inpaint import LamaInpaint
-
 
 def batch_generator(data, max_batch_size):
     """
@@ -30,88 +28,277 @@ def batch_generator(data, max_batch_size):
     if last_batch_start < n_samples:
         yield data[last_batch_start:]
 
-
-def inference_task(batch_data):
-    inpainted_frame_dict = dict()
-    for data in batch_data:
-        index, original_frame, coords_list = data
-        mask_size = original_frame.shape[:2]
-        mask = create_mask(mask_size, coords_list)
-        inpaint_frame = inpaint(original_frame, mask)
-        inpainted_frame_dict[index] = inpaint_frame
-    return inpainted_frame_dict
-
-
-def parallel_inference(inputs, batch_size=None, pool_size=None):
-    """
-    并行推理，同时保持结果顺序
-    """
-    if pool_size is None:
-        pool_size = multiprocessing.cpu_count()
-    # 使用上下文管理器自动管理进程池
-    with multiprocessing.Pool(processes=pool_size) as pool:
-        batched_inputs = list(batch_generator(inputs, batch_size))
-        # 使用map函数保证输入输出的顺序是一致的
-        batch_results = pool.map(inference_task, batched_inputs)
-    # 将批推理结果展平
-    index_inpainted_frames = [item for sublist in batch_results for item in sublist]
-    return index_inpainted_frames
-
-
-def inpaint(img, mask):
-    lama_inpaint_instance = LamaInpaint()
-    img_inpainted = lama_inpaint_instance(img, mask)
-    return img_inpainted
-
-
-def inpaint_with_multiple_masks(censored_img, mask_list):
-    inpainted_frame = censored_img
-    if mask_list:
-        for mask in mask_list:
-            inpainted_frame = inpaint(inpainted_frame, mask)
-    return inpainted_frame
-
-
 def create_mask(size, coords_list):
     mask = np.zeros(size, dtype="uint8")
     if coords_list:
         for coords in coords_list:
             xmin, xmax, ymin, ymax = coords
             # 为了避免框过小，放大10个像素
-            x1 = xmin - config.SUBTITLE_AREA_DEVIATION_PIXEL
+            x1 = xmin - config.subtitleAreaDeviationPixel.value
             if x1 < 0:
                 x1 = 0
-            y1 = ymin - config.SUBTITLE_AREA_DEVIATION_PIXEL
+            y1 = ymin - config.subtitleAreaDeviationPixel.value
             if y1 < 0:
                 y1 = 0
-            x2 = xmax + config.SUBTITLE_AREA_DEVIATION_PIXEL
+            x2 = xmax + config.subtitleAreaDeviationPixel.value
-            y2 = ymax + config.SUBTITLE_AREA_DEVIATION_PIXEL
+            y2 = ymax + config.subtitleAreaDeviationPixel.value
             cv2.rectangle(mask, (x1, y1),
                           (x2, y2), (255, 255, 255), thickness=-1)
     return mask
 
-
+def get_inpaint_area_by_mask(W, H, h, mask, multiple=1):
-def inpaint_video(video_path, sub_list):
+    """
-    index = 0
+    获取字幕去除区域，根据mask来确定需要填补的区域和高度，
-    frame_to_inpaint_list = []
+    并根据模型要求调整区域大小为指定倍数
-    video_cap = cv2.VideoCapture(video_path)
+    
-    while True:
+    Args:
-        # 读取视频帧
+        W: 图像宽度
-        ret, frame = video_cap.read()
+        H: 图像高度
-        if not ret:
+        h: 检测区域高度
-            break
+        mask: 遮罩图像
-        index += 1
+        multiple: 区域尺寸需要满足的倍数，默认为1
-        if index in sub_list.keys():
+    
-            frame_to_inpaint_list.append((index, frame, sub_list[index]))
+    Returns:
-        if len(frame_to_inpaint_list) > config.PROPAINTER_MAX_LOAD_NUM:
+        调整后的绘画区域列表，格式为[(ymin, ymax, xmin, xmax), ...]
-            batch_results = parallel_inference(frame_to_inpaint_list)
+    """
-            for index, frame in batch_results:
+    # 存储绘画区域的列表
-                file_name = f'/home/yao/Documents/Project/video-subtitle-remover/test/temp/{index}.png'
+    inpaint_area = []
-                cv2.imwrite(file_name, frame)
+    
-                print(f"success write: {file_name}")
+    # 如果mask全为0，直接返回空列表
-            frame_to_inpaint_list.clear()
+    if np.all(mask == 0):
-    print(f'finished')
+        return inpaint_area
-
+    
+    # 使用连通组件分析找出mask中的所有孤岛
+    # 首先确保mask是二值图像
+    binary_mask = (mask > 0).astype(np.uint8) * 255
+    
+    # 查找连通组件
+    num_labels, labels, stats, centroids = cv2.connectedComponentsWithStats(binary_mask, connectivity=8)
+    
+    # 跳过背景（标签0）
+    island_info = []
+    for i in range(1, num_labels):
+        # 获取当前孤岛的统计信息
+        x = stats[i, cv2.CC_STAT_LEFT]
+        y = stats[i, cv2.CC_STAT_TOP]
+        w = stats[i, cv2.CC_STAT_WIDTH]
+        height = stats[i, cv2.CC_STAT_HEIGHT]
+        area = stats[i, cv2.CC_STAT_AREA]
+        
+        # 忽略太小的区域（可能是噪点）
+        if area < 10:
+            continue
+        
+        # 保存孤岛信息：顶部y坐标，底部y坐标，中心点y坐标，面积，标签
+        center_y = int(centroids[i][1])
+        island_info.append((y, y + height, center_y, area, i))
+    
+    # 如果没有有效孤岛，返回空列表
+    if not island_info:
+        return inpaint_area
+    
+    # 按中心点y坐标排序孤岛
+    island_info.sort(key=lambda x: x[2])
+    
+    # 尝试合并孤岛
+    merged_islands = []
+    current_group = [island_info[0]]
+    
+    for i in range(1, len(island_info)):
+        # 当前组的范围
+        min_y = min([island[0] for island in current_group])
+        max_y = max([island[1] for island in current_group])
+        
+        # 当前孤岛
+        top_y, bottom_y, center_y, _, _ = island_info[i]
+        
+        # 计算如果添加当前孤岛，新组的范围
+        new_min_y = min(min_y, top_y)
+        new_max_y = max(max_y, bottom_y)
+        
+        # 检查是否有mask连接当前组和新孤岛
+        has_connection = False
+        if max_y < top_y:  # 只有当前组在新孤岛上方时才需要检查连接
+            # 检查两个区域之间是否有mask像素
+            middle_region = binary_mask[max_y:top_y, :]
+            if np.any(middle_region > 0):
+                has_connection = True
+        else:  # 重叠或相邻
+            has_connection = True
+        
+        # 检查合并后的高度是否在h范围内，并且有连接
+        if new_max_y - new_min_y <= h and has_connection:
+            # 可以合并
+            current_group.append(island_info[i])
+        else:
+            # 无法合并，保存当前组并开始新组
+            merged_islands.append(current_group)
+            current_group = [island_info[i]]
+    
+    # 添加最后一个组
+    merged_islands.append(current_group)
+    
+    # 为每个合并后的组创建区域
+    for group in merged_islands:
+        # 获取组内所有孤岛的范围
+        min_y = min([island[0] for island in group])
+        max_y = max([island[1] for island in group])
+        
+        # 计算组的中心点
+        center_y = sum([island[2] for island in group]) // len(group)
+        
+        # 确保区域高度精确等于h
+        half_h = h // 2
+        
+        # 从中心点向上下扩展，确保高度为h
+        ymin = max(0, center_y - half_h)
+        ymax = ymin + h  # 确保高度精确等于h
+        
+        # 如果超出图像底部，从底部向上调整
+        if ymax > H:
+            ymax = H
+            ymin = max(0, H - h)  # 确保高度为h
+        
+        # 检查是否包含了所有孤岛
+        if ymin > min_y or ymax < max_y:
+            # 如果区域不能完全包含所有孤岛，尝试调整位置但保持高度为h
+            if max_y - min_y <= h:
+                # 孤岛总高度不超过h，可以调整位置使其完全包含
+                ymin = min_y
+                ymax = ymin + h
+                # 如果超出底部，从底部向上调整
+                if ymax > H:
+                    ymax = H
+                    ymin = max(0, H - h)
+            else:
+                # 孤岛总高度超过h，无法完全包含，优先包含中心区域
+                # 计算孤岛的中心
+                island_center = (min_y + max_y) // 2
+                ymin = max(0, island_center - half_h)
+                ymax = ymin + h
+                # 如果超出底部，从底部向上调整
+                if ymax > H:
+                    ymax = H
+                    ymin = max(0, H - h)
+        
+        # 使用完整宽度
+        xmin = 0
+        xmax = W
+        
+        # 调整区域大小为指定倍数
+        if multiple > 1:
+            # 计算区域高度
+            height = ymax - ymin
+            # 计算需要调整的高度，使其成为multiple的倍数
+            remainder = height % multiple
+            
+            if remainder != 0:
+                # 需要调整的像素数
+                adjust_pixels = multiple - remainder
+                
+                # 计算区域中心点
+                center_y = (ymin + ymax) / 2
+                
+                # 优先对称扩展
+                if ymin - adjust_pixels/2 >= 0 and ymax + adjust_pixels/2 <= H:
+                    # 对称扩展
+                    ymin = int(center_y - height/2 - adjust_pixels/2)
+                    ymax = int(center_y + height/2 + adjust_pixels/2)
+                # 如果对称扩展会超出边界，尝试对称缩小
+                elif height > multiple:  # 确保缩小后高度至少为multiple
+                    # 对称缩小
+                    ymin = int(center_y - (height - remainder)/2)
+                    ymax = int(center_y + (height - remainder)/2)
+                # 如果无法对称调整，则尝试单边调整
+                else:
+                    # 向下扩展
+                    if ymax + adjust_pixels <= H:
+                        ymax += adjust_pixels
+                    # 向上扩展
+                    elif ymin - adjust_pixels >= 0:
+                        ymin -= adjust_pixels
+                    # 如果都不行，则尝试缩小区域
+                    elif height > multiple:
+                        ymax = ymin + height - remainder
+            
+            # 调整宽度，确保是multiple的倍数
+            width = xmax - xmin
+            remainder_w = width % multiple
+            
+            if remainder_w != 0:
+                # 需要调整的像素数
+                adjust_pixels_w = multiple - remainder_w
+                
+                # 计算中心点，对称缩小
+                center_x = (xmin + xmax) / 2
+                xmin = int(center_x - (width - remainder_w)/2)
+                xmax = int(center_x + (width - remainder_w)/2)
+        
+        # 将该区域添加到列表中，格式为(ymin, ymax, xmin, xmax)
+        area = (int(ymin), int(ymax), int(xmin), int(xmax))
+        if area not in inpaint_area:
+            inpaint_area.append(area)
+    
+    return inpaint_area  # 返回绘画区域列表，格式为[(ymin, ymax, xmin, xmax), ...]
+    
+def expand_frame_ranges(frame_ranges, backward_frame_count, forward_frame_count):
+    """
+    扩展帧区间列表，向前和向后扩展指定的帧数，并确保区间连续性
+    
+    Args:
+        frame_ranges: 帧区间列表，格式为[(start1, end1), (start2, end2), ...]
+        backward_frame_count: 向前扩展的帧数
+        forward_frame_count: 向后扩展的帧数
+        
+    Returns:
+        扩展后的帧区间列表，保证连续性
+    """
+    if not frame_ranges:
+        return []
+    
+    # 按起始帧排序
+    sorted_ranges = sorted(frame_ranges)
+    expanded_ranges = []
+    
+    for i, (start, end) in enumerate(sorted_ranges):
+        # 向前扩展，但不能小于1
+        new_start = max(1, start - backward_frame_count)
+        
+        # 向后扩展
+        new_end = end + forward_frame_count
+        
+        # 检查是否与下一个区间重叠
+        if i < len(sorted_ranges) - 1:
+            next_start = sorted_ranges[i + 1][0]
+            
+            # 如果扩展后的结束帧超过了下一个区间的起始帧
+            if new_end >= next_start:
+                # 计算中点
+                mid_point = (end + next_start) // 2
+                
+                # 如果区间是连续的(相差1)，则对半平分
+                if next_start - end == 1:
+                    new_end = end  # 保持原结束帧
+                else:
+                    # 非连续区间，限制扩展到下一个区间起始帧减去backward_frame_count
+                    max_expand = next_start - 1  # 确保不会与下一个区间重叠
+                    new_end = min(new_end, max_expand)
+        
+        # 确保与前一个区间不重叠
+        if expanded_ranges:
+            prev_end = expanded_ranges[-1][1]
+            if new_start <= prev_end:
+                # 如果新区间的开始小于等于前一个区间的结束，调整开始位置
+                new_start = prev_end + 1
+        
+        # 确保区间有效（开始不大于结束）
+        if new_start <= new_end:
+            expanded_ranges.append((new_start, new_end))
+        else:
+            # 如果调整后区间无效，保留原始区间
+            expanded_ranges.append((start, end))
+    
+    return expanded_ranges
 
 if __name__ == '__main__':
     multiprocessing.set_start_method("spawn")

backend/tools/model_config.py

@@ -0,0 +1,63 @@
+import os
+from backend.config import config, BASE_DIR
+from backend.tools.common_tools import merge_big_file_if_not_exists
+from backend.tools.constant import SubtitleDetectMode
+
+class ModelConfig:
+    def __init__(self):
+        self.LAMA_MODEL_DIR = os.path.join(BASE_DIR, 'models', 'big-lama')
+        self.STTN_AUTO_MODEL_PATH = os.path.join(BASE_DIR, 'models', 'sttn-auto', 'infer_model.pth')
+        self.STTN_DET_MODEL_PATH = os.path.join(BASE_DIR, 'models', 'sttn-det', 'sttn.pth')
+        self.PROPAINTER_MODEL_DIR = os.path.join(BASE_DIR,'models', 'propainter')
+        if config.subtitleDetectMode.value == SubtitleDetectMode.Fast:
+            self.DET_MODEL_DIR = os.path.join(BASE_DIR,'models', 'V4', 'ch_det_fast')
+        elif config.subtitleDetectMode.value == SubtitleDetectMode.Accurate:
+            self.DET_MODEL_DIR = os.path.join(BASE_DIR, 'models', 'V4', 'ch_det')
+        else:
+            raise ValueError(f"Invalid subtitle detect mode: {config.subtitleDetectMode.value}")
+
+        merge_big_file_if_not_exists(self.LAMA_MODEL_DIR, 'bit-lama.pt')
+        merge_big_file_if_not_exists(self.PROPAINTER_MODEL_DIR, 'ProPainter.pth')
+        merge_big_file_if_not_exists(self.DET_MODEL_DIR, 'inference.pdiparams')
+    
+    def convertToOnnxModelIfNeeded(self, model_dir, model_filename="inference.pdmodel", params_filename="inference.pdiparams", opset_version=14):
+        """Converts a Paddle model to ONNX if ONNX providers are available and the model does not already exist."""
+        
+        onnx_model_path = os.path.join(model_dir, "model.onnx")
+
+        if os.path.exists(onnx_model_path):
+            print(f"ONNX model already exists: {onnx_model_path}. Skipping conversion.")
+            return onnx_model_path
+        
+        print(f"Converting Paddle model {model_dir} to ONNX...")
+        model_file = os.path.join(model_dir, model_filename)
+        params_file = os.path.join(model_dir, params_filename) if params_filename else ""
+
+        try:
+            import paddle2onnx
+            # Ensure the target directory exists
+            os.makedirs(os.path.dirname(onnx_model_path), exist_ok=True)
+
+            # Convert and save the model
+            onnx_model = paddle2onnx.export(
+                model_filename=model_file,
+                params_filename=params_file,
+                save_file=onnx_model_path,
+                opset_version=opset_version,
+                auto_upgrade_opset=True,
+                verbose=True,
+                enable_onnx_checker=True,
+                enable_experimental_op=True,
+                enable_optimize=True,
+                custom_op_info={},
+                deploy_backend="onnxruntime",
+                calibration_file="calibration.cache",
+                external_file=os.path.join(model_dir, "external_data"),
+                export_fp16_model=False,
+            )
+
+            print(f"Conversion successful. ONNX model saved to: {onnx_model_path}")
+            return onnx_model_path
+        except Exception as e:
+            print(f"Error during conversion: {e}")
+            return model_dir

backend/tools/ocr.py

@@ -0,0 +1,20 @@
+def get_coordinates(dt_box):
+    """
+    从返回的检测框中获取坐标
+    :param dt_box 检测框返回结果
+    :return list 坐标点列表
+    """
+    coordinate_list = list()
+    if isinstance(dt_box, list):
+        for i in dt_box:
+            i = list(i)
+            (x1, y1) = int(i[0][0]), int(i[0][1])
+            (x2, y2) = int(i[1][0]), int(i[1][1])
+            (x3, y3) = int(i[2][0]), int(i[2][1])
+            (x4, y4) = int(i[3][0]), int(i[3][1])
+            xmin = max(x1, x4)
+            xmax = min(x2, x3)
+            ymin = max(y1, y2)
+            ymax = min(y3, y4)
+            coordinate_list.append((xmin, xmax, ymin, ymax))
+    return coordinate_list

backend/tools/process_manager.py

@@ -0,0 +1,128 @@
+# -*- coding: utf-8 -*-
+"""
+@desc: 进程管理器，用于管理和终止子进程
+"""
+import weakref
+import signal
+import os
+import platform
+import logging
+import atexit
+import subprocess
+import concurrent.futures
+
+class ProcessManager:
+    """
+    进程管理器类，用于管理子进程的生命周期
+    使用弱引用避免内存泄漏
+    """
+    _instance = None
+    
+    @classmethod
+    def instance(cls):
+        """单例模式获取实例"""
+        if cls._instance is None:
+            cls._instance = ProcessManager()
+        return cls._instance
+    
+    def __init__(self):
+        """初始化进程管理器"""
+        self.processes = {}
+        self.logger = logging.getLogger(__name__)
+        
+        # 注册退出处理函数
+        atexit.register(self.terminate_all)
+    
+    def add_process(self, process, name=None):
+        """
+        添加进程到管理器
+        
+        Args:
+            process: 要添加的进程对象 (subprocess.Popen实例)
+            name: 进程名称，如果不提供则使用进程ID
+        """
+        if process is None:
+            return
+            
+        process_id = name or f"Process:{id(process)}"
+        self.processes[process_id] = process
+        print(f"Added process: {process_id}, PID: {process.pid if hasattr(process, 'pid') else 'unknown'}")
+        return process_id
+
+    def add_pid(self, pid, name=None):
+        process_id = name or f"Pid:{pid}"
+        self.processes[process_id] = pid
+        print(f"Added process: {process_id}, PID: {pid}")
+        return process_id
+    
+    def remove_process(self, process_id):
+        """
+        从管理器中移除进程
+        
+        Args:
+            process_id: 进程ID或名称
+        """
+        if process_id in self.processes:
+            del self.processes[process_id]
+            print(f"Removed process: {process_id}")
+            return True
+        return False
+    
+    def terminate_all(self):
+        """并发终止所有管理的进程"""
+        with concurrent.futures.ThreadPoolExecutor() as executor:
+            futures = []
+            for process_id, process in list(self.processes.items()):
+                if isinstance(process, int):
+                    futures.append(executor.submit(self.terminate_by_pid, process))
+                else:
+                    futures.append(executor.submit(self.terminate_by_process, process))
+            
+            # 等待所有终止操作完成
+            concurrent.futures.wait(futures)
+        
+        # 清空进程字典
+        self.processes.clear()
+    
+    def terminate_by_process(self, process):
+        if process is None:
+            return
+        try:
+            print(f"Terminating process: pid: {process.pid}")
+            if hasattr(process, 'poll') and process.poll() is not None:
+                # 进程已经结束，直接返回
+                return
+                
+            # 进程还在运行
+            process.terminate()
+            if hasattr(process, 'join'):
+                try:
+                    process.join(timeout=3)
+                except:
+                    pass
+            if hasattr(process, 'wait'):
+                try:
+                    process.wait(timeout=3)
+                except:
+                    pass
+            # 进程未能正常终止，尝试强制终止
+            if hasattr(process, 'kill'):
+                process.kill()
+        except Exception as e:
+            # print(f"Error terminating process: {str(e)}")
+            pass
+        self.terminate_by_pid(process.pid)
+
+    def terminate_by_pid(self, pid):
+        try:
+            # 使用系统命令强制终止进程
+            if platform.system() == 'Windows':
+                subprocess.run(['taskkill', '/F', '/T', '/PID', str(pid)], 
+                    stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=3)
+            else:
+                subprocess.run(['pkill', '-9', '-P', str(pid)], 
+                            stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=2)
+                subprocess.run(['kill', '-9', str(pid)], 
+                    stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=3)
+        except Exception as e:
+            print(f"Error forcibly terminating process with PID {pid}: {str(e)}")

backend/tools/subtitle_detect.py

@@ -0,0 +1,258 @@
+import sys
+from functools import cached_property
+
+import cv2
+from tqdm import tqdm
+
+from .model_config import ModelConfig
+from .hardware_accelerator import HardwareAccelerator
+from .common_tools import get_readable_path
+from .ocr import get_coordinates
+from backend.config import config, tr
+from backend.scenedetect import scene_detect
+from backend.scenedetect.detectors import ContentDetector
+
+class SubtitleDetect:
+    """
+    文本框检测类，用于检测视频帧中是否存在文本框
+    """
+
+    def __init__(self, video_path, sub_area=None):
+        self.video_path = video_path
+        self.sub_area = sub_area
+
+    @cached_property
+    def text_detector(self):
+        import paddle
+        paddle.disable_signal_handler()
+        from paddleocr.tools.infer import utility
+        from paddleocr.tools.infer.predict_det import TextDetector
+        hardware_accelerator = HardwareAccelerator.instance()
+        onnx_providers = hardware_accelerator.onnx_providers
+        model_config = ModelConfig()
+        parser = utility.init_args()
+        args = parser.parse_args([])
+        args.det_algorithm = 'DB'
+        args.det_model_dir = model_config.convertToOnnxModelIfNeeded(model_config.DET_MODEL_DIR) if len(onnx_providers) > 0 else model_config.DET_MODEL_DIR
+        args.use_gpu=hardware_accelerator.has_cuda()
+        args.use_onnx=len(onnx_providers) > 0
+        args.onnx_providers=onnx_providers
+        return TextDetector(args)
+
+    def detect_subtitle(self, img):
+        temp_list = []
+        dt_boxes, elapse = self.text_detector(img)
+        coordinate_list = get_coordinates(dt_boxes.tolist())
+        if coordinate_list:
+            for coordinate in coordinate_list:
+                xmin, xmax, ymin, ymax = coordinate
+                if self.sub_area is not None:
+                    s_ymin, s_ymax, s_xmin, s_xmax = self.sub_area
+                    if (s_xmin <= xmin and xmax <= s_xmax
+                            and s_ymin <= ymin
+                            and ymax <= s_ymax):
+                        temp_list.append((xmin, xmax, ymin, ymax))
+                else:
+                    temp_list.append((xmin, xmax, ymin, ymax))
+        return temp_list
+
+    def find_subtitle_frame_no(self, sub_remover=None):
+        video_cap = cv2.VideoCapture(get_readable_path(self.video_path))
+        frame_count = video_cap.get(cv2.CAP_PROP_FRAME_COUNT)
+        tbar = tqdm(total=int(frame_count), unit='frame', position=0, file=sys.__stdout__, desc='Subtitle Finding')
+        current_frame_no = 0
+        subtitle_frame_no_box_dict = {}
+        if sub_remover:
+            sub_remover.append_output(tr['Main']['ProcessingStartFindingSubtitles'])
+        while video_cap.isOpened():
+            ret, frame = video_cap.read()
+            # 如果读取视频帧失败（视频读到最后一帧）
+            if not ret:
+                break
+            # 读取视频帧成功
+            current_frame_no += 1
+            temp_list = self.detect_subtitle(frame)
+            if len(temp_list) > 0:
+                subtitle_frame_no_box_dict[current_frame_no] = temp_list
+            tbar.update(1)
+            if sub_remover:
+                sub_remover.progress_total = (100 * float(current_frame_no) / float(frame_count)) // 2
+        subtitle_frame_no_box_dict = self.unify_regions(subtitle_frame_no_box_dict)
+        if sub_remover:
+            sub_remover.append_output(tr['Main']['FinishedFindingSubtitles'])
+        new_subtitle_frame_no_box_dict = dict()
+        for key in subtitle_frame_no_box_dict.keys():
+            if len(subtitle_frame_no_box_dict[key]) > 0:
+                new_subtitle_frame_no_box_dict[key] = subtitle_frame_no_box_dict[key]
+        return new_subtitle_frame_no_box_dict
+
+    @staticmethod
+    def split_range_by_scene(intervals, points):
+        # 确保离散值列表是有序的
+        points.sort()
+        # 用于存储结果区间的列表
+        result_intervals = []
+        # 遍历区间
+        for start, end in intervals:
+            # 在当前区间内的点
+            current_points = [p for p in points if start <= p <= end]
+
+            # 遍历当前区间内的离散点
+            for p in current_points:
+                # 如果当前离散点不是区间的起始点，添加从区间开始到离散点前一个数字的区间
+                if start < p:
+                    result_intervals.append((start, p - 1))
+                # 更新区间开始为当前离散点
+                start = p
+            # 添加从最后一个离散点或区间开始到区间结束的区间
+            result_intervals.append((start, end))
+        # 输出结果
+        return result_intervals
+
+    @staticmethod
+    def get_scene_div_frame_no(v_path):
+        """
+        获取发生场景切换的帧号
+        """
+        scene_div_frame_no_list = []
+        scene_list = scene_detect(v_path, ContentDetector())
+        for scene in scene_list:
+            start, end = scene
+            if start.frame_num == 0:
+                pass
+            else:
+                scene_div_frame_no_list.append(start.frame_num + 1)
+        return scene_div_frame_no_list
+
+    @staticmethod
+    def are_similar(region1, region2):
+        """判断两个区域是否相似。"""
+        xmin1, xmax1, ymin1, ymax1 = region1
+        xmin2, xmax2, ymin2, ymax2 = region2
+
+        return abs(xmin1 - xmin2) <= config.subtitleAreaPixelToleranceXPixel.value and abs(xmax1 - xmax2) <= config.subtitleAreaPixelToleranceXPixel.value and \
+            abs(ymin1 - ymin2) <= config.subtitleAreaPixelToleranceYPixel.value and abs(ymax1 - ymax2) <= config.subtitleAreaPixelToleranceYPixel.value
+
+    def unify_regions(self, raw_regions):
+        """将连续相似的区域统一，保持列表结构。"""
+        if len(raw_regions) > 0:
+            keys = sorted(raw_regions.keys())  # 对键进行排序以确保它们是连续的
+            unified_regions = {}
+
+            # 初始化
+            last_key = keys[0]
+            unify_value_map = {last_key: raw_regions[last_key]}
+
+            for key in keys[1:]:
+                current_regions = raw_regions[key]
+
+                # 新增一个列表来存放匹配过的标准区间
+                new_unify_values = []
+
+                for idx, region in enumerate(current_regions):
+                    last_standard_region = unify_value_map[last_key][idx] if idx < len(unify_value_map[last_key]) else None
+
+                    # 如果当前的区间与前一个键的对应区间相似，我们统一它们
+                    if last_standard_region and self.are_similar(region, last_standard_region):
+                        new_unify_values.append(last_standard_region)
+                    else:
+                        new_unify_values.append(region)
+
+                # 更新unify_value_map为最新的区间值
+                unify_value_map[key] = new_unify_values
+                last_key = key
+
+            # 将最终统一后的结果传递给unified_regions
+            for key in keys:
+                unified_regions[key] = unify_value_map[key]
+            return unified_regions
+        else:
+            return raw_regions
+
+    @staticmethod
+    def find_continuous_ranges(subtitle_frame_no_box_dict):
+        """
+        获取字幕出现的起始帧号与结束帧号
+        """
+        numbers = sorted(list(subtitle_frame_no_box_dict.keys()))
+        ranges = []
+        start = numbers[0]  # 初始区间开始值
+
+        for i in range(1, len(numbers)):
+            # 如果当前数字与前一个数字间隔超过1，
+            # 则上一个区间结束，记录当前区间的开始与结束
+            if numbers[i] - numbers[i - 1] != 1:
+                end = numbers[i - 1]  # 则该数字是当前连续区间的终点
+                ranges.append((start, end))
+                start = numbers[i]  # 开始下一个连续区间
+        # 添加最后一个区间
+        ranges.append((start, numbers[-1]))
+        return ranges
+
+    @staticmethod
+    def find_continuous_ranges_with_same_mask(subtitle_frame_no_box_dict):
+        numbers = sorted(list(subtitle_frame_no_box_dict.keys()))
+        ranges = []
+        start = numbers[0]  # 初始区间开始值
+        for i in range(1, len(numbers)):
+            # 如果当前帧号与前一个帧号间隔超过1，
+            # 则上一个区间结束，记录当前区间的开始与结束
+            if numbers[i] - numbers[i - 1] != 1:
+                end = numbers[i - 1]  # 则该数字是当前连续区间的终点
+                ranges.append((start, end))
+                start = numbers[i]  # 开始下一个连续区间
+            # 如果当前帧号与前一个帧号间隔为1，且当前帧号对应的坐标点与上一帧号对应的坐标点不一致
+            # 记录当前区间的开始与结束
+            if numbers[i] - numbers[i - 1] == 1:
+                if subtitle_frame_no_box_dict[numbers[i]] != subtitle_frame_no_box_dict[numbers[i - 1]]:
+                    end = numbers[i - 1]  # 则该数字是当前连续区间的终点
+                    ranges.append((start, end))
+                    start = numbers[i]  # 开始下一个连续区间
+        # 添加最后一个区间
+        ranges.append((start, numbers[-1]))
+        return ranges
+
+    @staticmethod
+    def filter_and_merge_intervals(intervals, target_length):
+        """
+        合并传入的字幕起始区间，确保区间大小最低为STTN_REFERENCE_LENGTH
+        """
+        expanded = []
+        # 首先单独处理单点区间以扩展它们
+        for start, end in intervals:
+            if start == end:  # 单点区间
+                # 扩展到接近的目标长度，但保证前后不重叠
+                prev_end = expanded[-1][1] if expanded else float('-inf')
+                next_start = float('inf')
+                # 查找下一个区间的起始点
+                for ns, ne in intervals:
+                    if ns > end:
+                        next_start = ns
+                        break
+                # 确定新的扩展起点和终点
+                new_start = max(start - (target_length - 1) // 2, prev_end + 1)
+                new_end = min(start + (target_length - 1) // 2, next_start - 1)
+                # 如果新的扩展终点在起点前面，说明没有足够空间来进行扩展
+                if new_end < new_start:
+                    new_start, new_end = start, start  # 保持原样
+                expanded.append((new_start, new_end))
+            else:
+                # 非单点区间直接保留，稍后处理任何可能的重叠
+                expanded.append((start, end))
+        # 排序以合并那些因扩展导致重叠的区间
+        expanded.sort(key=lambda x: x[0])
+        # 合并重叠的区间，但仅当它们之间真正重叠且小于目标长度时
+        merged = [expanded[0]]
+        for start, end in expanded[1:]:
+            last_start, last_end = merged[-1]
+            # 检查是否重叠
+            if start <= last_end and (end - last_start + 1 < target_length or last_end - last_start + 1 < target_length):
+                # 需要合并
+                merged[-1] = (last_start, max(last_end, end))  # 合并区间
+            elif start == last_end + 1 and (end - last_start + 1 < target_length or last_end - last_start + 1 < target_length):
+                # 相邻区间也需要合并的场景
+                merged[-1] = (last_start, end)
+            else:
+                # 如果没有重叠且都大于目标长度，则直接保留
+                merged.append((start, end))
+        return merged

backend/tools/subtitle_remover_remote_call.py

@@ -0,0 +1,75 @@
+import multiprocessing
+import threading
+from enum import Enum
+
+class Command(Enum):
+    FINISH = 0,
+    PROGRESS = 1,
+    LOG = 2,
+    MANAGE_PROCESS = 3,
+    ERROR = 4,
+    UPDATE_PREVIEW_WITH_COMP = 5,
+
+class SubtitleRemoverRemoteCall:
+    """
+    远程回调函数类，用于在多进程环境中传递回调函数
+    """
+    def __init__(self):
+        self.queue = multiprocessing.Queue()
+        self.callbacks = {}
+        self.running = True
+        threading.Thread(target=self.run, daemon=True).start()
+    
+    def run(self):
+        try:
+            while self.running:
+                cmd, args = self.queue.get(block=True)
+                if cmd == Command.FINISH:
+                    break
+                callback = self.callbacks.get(cmd)
+                if callback:
+                    callback(*args)
+        finally:
+            self.running = False
+
+    def stop(self):
+        self.running = False
+
+    def register_update_progress_callback(self, callback):
+        self.callbacks[Command.PROGRESS] = callback
+
+    def register_log_callback(self, callback):
+        self.callbacks[Command.LOG] = callback
+    
+    def register_manage_process_callback(self, callback):
+        self.callbacks[Command.MANAGE_PROCESS] = callback
+
+    def register_update_preview_with_comp_callback(self, callback):
+        self.callbacks[Command.UPDATE_PREVIEW_WITH_COMP] = callback
+
+    def register_error_callback(self, callback):
+        self.callbacks[Command.ERROR] = callback
+
+    @staticmethod
+    def remote_call_update_progress(queue, progress, isFinished):
+        queue.put((Command.PROGRESS, (progress, isFinished,)))
+
+    @staticmethod
+    def remote_call_append_log(queue, *args):
+        queue.put((Command.LOG, (*args,)))
+
+    @staticmethod
+    def remote_call_finish(queue, *args):
+        queue.put((Command.FINISH, (None,)))
+
+    @staticmethod
+    def remote_call_catch_error(queue, e):
+        queue.put((Command.ERROR, (e,)))
+
+    @staticmethod
+    def remote_call_manage_process(queue, pid):
+        queue.put((Command.MANAGE_PROCESS, (pid,)))
+
+    @staticmethod
+    def remote_call_update_preview_with_comp(queue, *args):
+        queue.put((Command.UPDATE_PREVIEW_WITH_COMP, (*args,)))

backend/tools/theme_listener.py

@@ -0,0 +1,26 @@
+from PySide6 import QtCore, QtWidgets, QtGui
+
+from qfluentwidgets import setTheme, qconfig, Theme
+import darkdetect
+
+
+class SystemThemeListener(QtCore.QThread):
+    """ System theme listener """
+
+    systemThemeChanged = QtCore.Signal()
+
+    def __init__(self, parent=None):
+        super().__init__(parent=parent)
+
+    def run(self):
+        darkdetect.listener(self._onThemeChanged)
+
+    def _onThemeChanged(self, theme: str):
+        theme = Theme.DARK if theme.lower() == "dark" else Theme.LIGHT
+        setTheme(theme)
+        if qconfig.themeMode.value != Theme.AUTO or theme == qconfig.theme:
+            return
+
+        qconfig.theme = Theme.AUTO
+        qconfig._cfg.themeChanged.emit(Theme.AUTO)
+        self.systemThemeChanged.emit()

backend/tools/version_service.py

@@ -0,0 +1,83 @@
+# coding: utf-8
+import re
+import os
+import sys
+import requests
+
+from PySide6.QtCore import QVersionNumber
+
+from backend.config import VERSION, PROJECT_UPDATE_URLS, tr
+
+
+class VersionService:
+    """ Version service """
+
+    def __init__(self):
+        self.current_version = VERSION
+        self.lastest_version = VERSION
+        self.version_pattern = re.compile(r'v*((\d+)\.(\d+)\.(\d+))')
+        self.api_endpoints = PROJECT_UPDATE_URLS
+
+    def get_latest_version(self):
+        """ get latest version """
+        headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36 Edg/112.0.1722.64"
+        }
+
+        proxy = self.get_system_proxy()
+        proxies = {
+            "http": proxy,
+            "https": proxy
+        }
+
+        # 依次尝试不同的API端点
+        for url in self.api_endpoints:
+            try:
+                response = requests.get(url, headers=headers, timeout=5, allow_redirects=True, proxies=proxies)
+                response.raise_for_status()
+                
+                # 解析版本
+                version = response.json()['tag_name']  # type:str
+                match = self.version_pattern.search(version)
+                if not match:
+                    continue  # 如果版本格式不匹配，尝试下一个API
+
+                self.lastest_version = match.group(1)
+                print(tr['VersionService']['VersionInfo'].format(VERSION, self.lastest_version))
+                return self.lastest_version
+            except Exception as e:
+                print(tr['VersionService']['RequestError'].format(url, str(e)))
+                continue  # 出错时尝试下一个API
+        
+        # 所有API都失败时返回当前版本
+        return VERSION
+
+    def has_new_version(self) -> bool:
+        """ check whether there is a new version """
+        version = QVersionNumber.fromString(self.get_latest_version())
+        current_version = QVersionNumber.fromString(self.current_version)
+        return version > current_version
+
+    def get_system_proxy(self):
+        """ get system proxy """
+        if sys.platform == "win32":
+            try:
+                import winreg
+
+                with winreg.OpenKey(winreg.HKEY_CURRENT_USER, r'Software\Microsoft\Windows\CurrentVersion\Internet Settings') as key:
+                    enabled, _ = winreg.QueryValueEx(key, 'ProxyEnable')
+
+                    if enabled:
+                        return "http://" + winreg.QueryValueEx(key, 'ProxyServer')
+            except:
+                pass
+        elif sys.platform == "darwin":
+            s = os.popen('scutil --proxy').read()
+            info = dict(re.findall(r'(?m)^\s+([A-Z]\w+)\s+:\s+(\S+)', s))
+
+            if info.get('HTTPEnable') == '1':
+                return f"http://{info['HTTPProxy']}:{info['HTTPPort']}"
+            elif info.get('ProxyAutoConfigEnable') == '1':
+                return info['ProxyAutoConfigURLString']
+
+        return os.environ.get("http_proxy")

docker/Dockerfile

@@ -2,29 +2,53 @@ FROM python:3.12
 
 RUN --mount=type=cache,target=/root/.cache,sharing=private \
     apt update && \
-    apt install -y libgl1-mesa-glx && \
+    apt install -y libgl1-mesa-glx \
+        # pyside6
+        libegl1 libxkbcommon0 libdbus-1-3 && \
     true
 
 ADD . /vsr
 ARG CUDA_VERSION=11.8
-ARG USE_DIRECTML=0
+ARG HARDWARD_ACCELERATOR="cuda"
 
-# 如果是 CUDA 版本，执行 CUDA 特定设置
+# 如果是 CUDA 12.x 版本，执行 CUDA 12.x 特定设置
 RUN --mount=type=cache,target=/root/.cache,sharing=private \
-    if [ "${USE_DIRECTML:-0}" != "1" ]; then \
+    if [ "${HARDWARD_ACCELERATOR}" = "cuda" ] && [ "${CUDA_VERSION}" != "11.8" ]; then \
         pip install paddlepaddle==3.0 && \
         pip install torch==2.7.0 torchvision==0.22.0 --index-url https://download.pytorch.org/whl/cu$(echo ${CUDA_VERSION} | tr -d '.') && \
         pip install -r /vsr/requirements.txt; \
     fi
 
+# 如果是 CUDA 11.8 版本，执行 CUDA 11.8 特定设置
+RUN --mount=type=cache,target=/root/.cache,sharing=private \
+if [ "${HARDWARD_ACCELERATOR}" = "cuda" ] && [ "${CUDA_VERSION}" = "11.8" ]; then \
+    pip install paddlepaddle==3.0 && \
+    pip install torch==2.3.1 torchvision==0.18.1 --index-url https://download.pytorch.org/whl/cu$(echo ${CUDA_VERSION} | tr -d '.') && \
+    pip install -r /vsr/requirements.txt && \
+    pip uninstall -y onnxruntime-gpu && \
+    pip install onnxruntime-gpu==1.20.1 --index-url https://aiinfra.pkgs.visualstudio.com/PublicPackages/_packaging/onnxruntime-cuda-11/pypi/simple/ && \
+    # for paddle
+    pip install setuptools==80.4.0; \
+fi
+
 # 如果是 DirectML 版本，执行 DirectML 特定设置
 RUN --mount=type=cache,target=/root/.cache,sharing=private \
-    if [ "${USE_DIRECTML:-0}" = "1" ]; then \
+    if [ "${HARDWARD_ACCELERATOR}" = "directml" ]; then \
         pip install paddlepaddle==3.0 && \
         pip install torch_directml==0.2.5.dev240914 && \
         pip install -r /vsr/requirements.txt; \
     fi
 
+# 如果是 CPU 版本，执行 CPU 特定设置
+RUN --mount=type=cache,target=/root/.cache,sharing=private \
+    if [ "${HARDWARD_ACCELERATOR}" = "cpu" ]; then \
+        pip install paddlepaddle==3.0 && \
+        pip install -r /vsr/requirements.txt && \
+        sed -i 's/HARDWARD_ACCELERATION_OPTION *= *.*/HARDWARD_ACCELERATION_OPTION = False/g' /vsr/backend/config.py; \
+    fi
+
 ENV LD_LIBRARY_PATH=/usr/local/lib/python3.12/site-packages/nvidia/cudnn/lib/
+ENV LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/lib/python3.12/site-packages/nvidia/cuda_runtime/lib/
+ENV LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/lib/python3.12/site-packages/nvidia/cuda_nvrtc/lib/
 WORKDIR /vsr
 CMD ["python", "/vsr/backend/main.py"]

gui.py

@@ -1,405 +1,184 @@
 # -*- coding: utf-8 -*-
 """
-@Author  : Fang Yao
+@Author  : Fang Yao（原作者） / 改写：Jason Eric
-@Time    : 2023/4/1 6:07 下午
+@Time    : 2023/4/1 6:07 下午（原始时间）
 @FileName: gui.py
-@desc: 字幕去除器图形化界面
+@desc: 字幕去除器图形化界面（由 PySimpleGUI 改写为 PySide6）
 """
+
+import sys
 import os
 import configparser
-import PySimpleGUI as sg
 import cv2
-import sys
-from threading import Thread
 import multiprocessing
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from PySide6.QtCore import Qt, QTranslator
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from PySide6 import QtCore, QtWidgets, QtGui
-import backend.main
+from PySide6.QtWidgets import QApplication, QFrame, QStackedWidget, QHBoxLayout, QLabel
-from backend.tools.common_tools import is_image_file
+from qfluentwidgets import (FluentWindow, PushButton, Slider, ProgressBar, PlainTextEdit,
+                          setTheme, Theme, FluentIcon, CardWidget, SettingCardGroup,
+                          ComboBoxSettingCard, SwitchSettingCard, setThemeColor, OptionsConfigItem,
+                          OptionsValidator, SubtitleLabel, HollowHandleStyle, qconfig, ConfigItem, QConfig,
+                          NavigationWidget, NavigationItemPosition, isDarkTheme, InfoBar)
+
+from qframelesswindow.utils import getSystemAccentColor
+from backend.config import config, tr, VERSION
+from backend.tools.theme_listener import SystemThemeListener
+from backend.tools.process_manager import ProcessManager
+from ui.advanced_setting_interface import AdvancedSettingInterface
+from ui.home_interface import HomeInterface
 
 
-class SubtitleRemoverGUI:
+class SubtitleExtractorGUI(FluentWindow): 
-
     def __init__(self):
-        self.font = 'Arial 10'
+        super().__init__()
-        self.theme = 'LightBrown12'
+        # 禁用云母效果
-        sg.theme(self.theme)
+        self.setMicaEffectEnabled(False)
-        self.icon = os.path.join(os.path.dirname(__file__), 'design', 'vsr.ico')
+        # 设置深色主题并跟随系统主题色
-        self.screen_width, self.screen_height = sg.Window.get_screen_size()
+        # setTheme(Theme.LIGHT)
-        self.subtitle_config_file = os.path.join(os.path.dirname(__file__), 'subtitle.ini')
+        # setThemeColor(getSystemAccentColor(), save=True)
-        print(self.screen_width, self.screen_height)
-        # 设置视频预览区域大小
-        self.video_preview_width = 960
-        self.video_preview_height = self.video_preview_width * 9 // 16
-        # 默认组件大小
-        self.horizontal_slider_size = (120, 20)
-        self.output_size = (100, 10)
-        self.progressbar_size = (60, 20)
-        # 分辨率低于1080
-        if self.screen_width // 2 < 960:
-            self.video_preview_width = 640
-            self.video_preview_height = self.video_preview_width * 9 // 16
-            self.horizontal_slider_size = (60, 20)
-            self.output_size = (58, 10)
-            self.progressbar_size = (28, 20)
-        # 字幕提取器布局
-        self.layout = None
-        # 字幕提取其窗口
-        self.window = None
-        # 视频路径
-        self.video_path = None
-        # 视频cap
-        self.video_cap = None
-        # 视频的帧率
-        self.fps = None
-        # 视频的帧数
-        self.frame_count = None
-        # 视频的宽
-        self.frame_width = None
-        # 视频的高
-        self.frame_height = None
-        # 设置字幕区域高宽
-        self.xmin = None
-        self.xmax = None
-        self.ymin = None
-        self.ymax = None
-        # 字幕提取器
-        self.sr = None
 
-    def run(self):
+        # 初始化系统主题监听器并连接信号
-        # 创建布局
+        # self.themeListener = SystemThemeListener(self)
+        # self.themeListener.start()
+ 
+        # 设置窗口图标
+        self.setWindowIcon(QtGui.QIcon("design/vsr.ico"))
+        self.setWindowTitle(tr['SubtitleExtractorGUI']['Title'] + " v" + VERSION)
+        # 创建界面布局
         self._create_layout()
-        # 创建窗口
+        self._connectSignalToSlot()
-        self.window = sg.Window(title=f'Video Subtitle Remover v{backend.main.config.VERSION}' , layout=self.layout,
+        self._lazy_check_update()
-                                icon=self.icon)
+
-        while True:
+    def _lazy_check_update(self):
-            # 循环读取事件
+        """ 延迟检查更新 """
-            event, values = self.window.read(timeout=10)
+        if not config.checkUpdateOnStartup.value:
-            # 处理【打开】事件
+            return
-            self._file_event_handler(event, values)
+        self.check_update_timer = QtCore.QTimer(self)
-            # 处理【滑动】事件
+        self.check_update_timer.setSingleShot(True)
-            self._slide_event_handler(event, values)
+        self.check_update_timer.timeout.connect(lambda: self.advancedSettingInterface.check_update(ignore=True))
-            # 处理【运行】事件
+        self.check_update_timer.start(2000)
-            self._run_event_handler(event, values)
+
-            # 如果关闭软件，退出
+    def _connectSignalToSlot(self):
-            if event == sg.WIN_CLOSED:
+        config.appRestartSig.connect(self._showRestartTooltip)
-                break
+
-            # 更新进度条
+    def _showRestartTooltip(self):
-            if self.sr is not None:
+        """ show restart tooltip """
-                self.window['-PROG-'].update(self.sr.progress_total)
+        InfoBar.success(
-                if self.sr.preview_frame is not None:
+            'Updated successfully',
-                    self.window['-DISPLAY-'].update(data=cv2.imencode('.png', self._img_resize(self.sr.preview_frame))[1].tobytes())
+            'Configuration takes effect after restart',
-                if self.sr.isFinished:
+            duration=5000,
-                    # 1) 打开修改字幕滑块区域按钮
+            parent=self
-                    self.window['-Y-SLIDER-'].update(disabled=False)
+        )
-                    self.window['-X-SLIDER-'].update(disabled=False)
-                    self.window['-Y-SLIDER-H-'].update(disabled=False)
-                    self.window['-X-SLIDER-W-'].update(disabled=False)
-                    # 2) 打开【运行】、【打开】和【识别语言】按钮
-                    self.window['-RUN-'].update(disabled=False)
-                    self.window['-FILE-'].update(disabled=False)
-                    self.window['-FILE_BTN-'].update(disabled=False)
-                    self.sr = None
-                if len(self.video_paths) >= 1:
-                    # 1) 关闭修改字幕滑块区域按钮
-                    self.window['-Y-SLIDER-'].update(disabled=True)
-                    self.window['-X-SLIDER-'].update(disabled=True)
-                    self.window['-Y-SLIDER-H-'].update(disabled=True)
-                    self.window['-X-SLIDER-W-'].update(disabled=True)
-                    # 2) 关闭【运行】、【打开】和【识别语言】按钮
-                    self.window['-RUN-'].update(disabled=True)
-                    self.window['-FILE-'].update(disabled=True)
-                    self.window['-FILE_BTN-'].update(disabled=True)
 
     def _create_layout(self):
-        """
+        # 创建主页面和高级设置页面
-        创建字幕提取器布局
+        self.homeInterface = HomeInterface(self)
-        """
+        self.homeInterface.setObjectName("HomeInterface")
-        garbage = os.path.join(os.path.dirname(__file__), 'output')
+        self.advancedSettingInterface = AdvancedSettingInterface(self)
-        if os.path.exists(garbage):
+        self.advancedSettingInterface.setObjectName("AdvancedSettingInterface")
-            import shutil
+        
-            shutil.rmtree(garbage, True)
+        # 添加到主窗口作为子界面
-        self.layout = [
+        self.addSubInterface(self.homeInterface,FluentIcon.HOME, tr['SubtitleExtractorGUI']['Title'])
-            # 显示视频预览
+        self.addSubInterface(self.advancedSettingInterface, FluentIcon.SETTING, tr['Setting']['AdvancedSetting'], NavigationItemPosition.BOTTOM)
-            [sg.Image(size=(self.video_preview_width, self.video_preview_height), background_color='black',
-                      key='-DISPLAY-')],
-            # 打开按钮 + 快进快退条
-            [sg.Input(key='-FILE-', visible=False, enable_events=True),
-             sg.FilesBrowse(button_text='Open', file_types=((
-                            'All Files', '*.*'), ('mp4', '*.mp4'),
-                            ('flv', '*.flv'),
-                            ('wmv', '*.wmv'),
-                            ('avi', '*.avi')),
-                            key='-FILE_BTN-', size=(10, 1), font=self.font),
-             sg.Slider(size=self.horizontal_slider_size, range=(1, 1), key='-SLIDER-', orientation='h',
-                       enable_events=True, font=self.font,
-                       disable_number_display=True),
-             ],
-            # 输出区域
-            [sg.Output(size=self.output_size, font=self.font),
-             sg.Frame(title='Vertical', font=self.font, key='-FRAME1-',
-             layout=[[
-                 sg.Slider(range=(0, 0), orientation='v', size=(10, 20),
-                           disable_number_display=True,
-                           enable_events=True, font=self.font,
-                           pad=((10, 10), (20, 20)),
-                           default_value=0, key='-Y-SLIDER-'),
-                 sg.Slider(range=(0, 0), orientation='v', size=(10, 20),
-                           disable_number_display=True,
-                           enable_events=True, font=self.font,
-                           pad=((10, 10), (20, 20)),
-                           default_value=0, key='-Y-SLIDER-H-'),
-             ]], pad=((15, 5), (0, 0))),
-             sg.Frame(title='Horizontal', font=self.font, key='-FRAME2-',
-             layout=[[
-                 sg.Slider(range=(0, 0), orientation='v', size=(10, 20),
-                           disable_number_display=True,
-                           pad=((10, 10), (20, 20)),
-                           enable_events=True, font=self.font,
-                           default_value=0, key='-X-SLIDER-'),
-                 sg.Slider(range=(0, 0), orientation='v', size=(10, 20),
-                           disable_number_display=True,
-                           pad=((10, 10), (20, 20)),
-                           enable_events=True, font=self.font,
-                           default_value=0, key='-X-SLIDER-W-'),
-             ]], pad=((15, 5), (0, 0)))
-             ],
 
-            # 运行按钮 + 进度条
+    def on_navigation_item_changed(self, key):
-            [sg.Button(button_text='Run', key='-RUN-',
+        """导航项变更时的处理函数"""
-                       font=self.font, size=(20, 1)),
+        if key == 'main':
-             sg.ProgressBar(100, orientation='h', size=self.progressbar_size, key='-PROG-', auto_size_text=True)
+            self.stackWidget.setCurrentIndex(0)
-             ],
+        elif key == 'advanced':
-        ]
+            self.stackWidget.setCurrentIndex(1)
 
-    def _file_event_handler(self, event, values):
+    def closeEvent(self, event):
-        """
+        """程序关闭时保存窗口位置并恢复标准输出和标准错误"""
-        当点击打开按钮时：
+        self.save_window_position()
-        1）打开视频文件，将画布显示视频帧
+        # 断开信号连接
-        2）获取视频信息，初始化进度条滑块范围
+        # self.themeListener.terminate()
-        """
+        # self.themeListener.deleteLater()
-        if event == '-FILE-':
+        ProcessManager.instance().terminate_all()
-            self.video_paths = values['-FILE-'].split(';')
+        super().closeEvent(event)
-            self.video_path = self.video_paths[0]
-            if self.video_path != '':
-                self.video_cap = cv2.VideoCapture(self.video_path)
-            if self.video_cap is None:
-                return
-            if self.video_cap.isOpened():
-                ret, frame = self.video_cap.read()
-                if ret:
-                    for video in self.video_paths:
-                        print(f"Open Video Success：{video}")
-                    # 获取视频的帧数
-                    self.frame_count = self.video_cap.get(cv2.CAP_PROP_FRAME_COUNT)
-                    # 获取视频的高度
-                    self.frame_height = self.video_cap.get(cv2.CAP_PROP_FRAME_HEIGHT)
-                    # 获取视频的宽度
-                    self.frame_width = self.video_cap.get(cv2.CAP_PROP_FRAME_WIDTH)
-                    # 获取视频的帧率
-                    self.fps = self.video_cap.get(cv2.CAP_PROP_FPS)
-                    # 调整视频帧大小，使播放器能够显示
-                    resized_frame = self._img_resize(frame)
-                    # resized_frame = cv2.resize(src=frame, dsize=(self.video_preview_width, self.video_preview_height))
-                    # 显示视频帧
-                    self.window['-DISPLAY-'].update(data=cv2.imencode('.png', resized_frame)[1].tobytes())
-                    # 更新视频进度条滑块range
-                    self.window['-SLIDER-'].update(range=(1, self.frame_count))
-                    self.window['-SLIDER-'].update(1)
-                    # 预设字幕区域位置
-                    y_p, h_p, x_p, w_p = self.parse_subtitle_config()
-                    y = self.frame_height * y_p
-                    h = self.frame_height * h_p
-                    x = self.frame_width * x_p
-                    w = self.frame_width * w_p
-                    # 更新视频字幕位置滑块range
-                    # 更新Y-SLIDER范围
-                    self.window['-Y-SLIDER-'].update(range=(0, self.frame_height), disabled=False)
-                    # 更新Y-SLIDER默认值
-                    self.window['-Y-SLIDER-'].update(y)
-                    # 更新X-SLIDER范围
-                    self.window['-X-SLIDER-'].update(range=(0, self.frame_width), disabled=False)
-                    # 更新X-SLIDER默认值
-                    self.window['-X-SLIDER-'].update(x)
-                    # 更新Y-SLIDER-H范围
-                    self.window['-Y-SLIDER-H-'].update(range=(0, self.frame_height - y))
-                    # 更新Y-SLIDER-H默认值
-                    self.window['-Y-SLIDER-H-'].update(h)
-                    # 更新X-SLIDER-W范围
-                    self.window['-X-SLIDER-W-'].update(range=(0, self.frame_width - x))
-                    # 更新X-SLIDER-W默认值
-                    self.window['-X-SLIDER-W-'].update(w)
-                    self._update_preview(frame, (y, h, x, w))
 
-    def __disable_button(self):
+    def _onThemeChangedFinished(self):
-        # 1) 禁止修改字幕滑块区域
+        super()._onThemeChangedFinished()
-        self.window['-Y-SLIDER-'].update(disabled=True)
-        self.window['-X-SLIDER-'].update(disabled=True)
-        self.window['-Y-SLIDER-H-'].update(disabled=True)
-        self.window['-X-SLIDER-W-'].update(disabled=True)
-        # 2) 禁止再次点击【运行】、【打开】和【识别语言】按钮
-        self.window['-RUN-'].update(disabled=True)
-        self.window['-FILE-'].update(disabled=True)
-        self.window['-FILE_BTN-'].update(disabled=True)
 
-    def _run_event_handler(self, event, values):
+    def save_window_position(self):
-        """
+        """保存窗口位置到配置文件"""
-        当点击运行按钮时：
+        # 保存窗口位置和大小
-        1) 禁止修改字幕滑块区域
+        config.set(config.windowX, self.x())
-        2) 禁止再次点击【运行】和【打开】按钮
+        config.set(config.windowY, self.y())
-        3) 设定字幕区域位置
+        config.set(config.windowW, self.width())
-        """
+        config.set(config.windowH, self.height())
-        if event == '-RUN-':
-            if self.video_cap is None:
-                print('Please Open Video First')
-            else:
-                # 禁用按钮
-                self.__disable_button()
-                # 3) 设定字幕区域位置
-                self.xmin = int(values['-X-SLIDER-'])
-                self.xmax = int(values['-X-SLIDER-'] + values['-X-SLIDER-W-'])
-                self.ymin = int(values['-Y-SLIDER-'])
-                self.ymax = int(values['-Y-SLIDER-'] + values['-Y-SLIDER-H-'])
-                if self.ymax > self.frame_height:
-                    self.ymax = self.frame_height
-                if self.xmax > self.frame_width:
-                    self.xmax = self.frame_width
-                if len(self.video_paths) <= 1:
-                    subtitle_area = (self.ymin, self.ymax, self.xmin, self.xmax)
-                else:
-                    print(f"{'Processing multiple videos or images'}")
-                    # 先判断每个视频的分辨率是否一致，一致的话设置相同的字幕区域，否则设置为None
-                    global_size = None
-                    for temp_video_path in self.video_paths:
-                        temp_cap = cv2.VideoCapture(temp_video_path)
-                        if global_size is None:
-                            global_size = (int(temp_cap.get(cv2.CAP_PROP_FRAME_WIDTH)), int(temp_cap.get(cv2.CAP_PROP_FRAME_HEIGHT)))
-                        else:
-                            temp_size = (int(temp_cap.get(cv2.CAP_PROP_FRAME_WIDTH)), int(temp_cap.get(cv2.CAP_PROP_FRAME_HEIGHT)))
-                            if temp_size != global_size:
-                                print('not all video/images in same size, processing in full screen')
-                                subtitle_area = None
-                    else:
-                        subtitle_area = (self.ymin, self.ymax, self.xmin, self.xmax)
-                y_p = self.ymin / self.frame_height
-                h_p = (self.ymax - self.ymin) / self.frame_height
-                x_p = self.xmin / self.frame_width
-                w_p = (self.xmax - self.xmin) / self.frame_width
-                self.set_subtitle_config(y_p, h_p, x_p, w_p)
 
-                def task():
+    def update_progress(self):
-                    while self.video_paths:
+        # 定时器轮询更新进度（现在更新到视频滑块上）
-                        video_path = self.video_paths.pop()
+        if self.se is not None:
-                        if subtitle_area is not None:
-                            print(f"{'SubtitleArea'}：({self.ymin},{self.ymax},{self.xmin},{self.xmax})")
-                        self.sr = backend.main.SubtitleRemover(video_path, subtitle_area, True)
-                        self.__disable_button()
-                        self.sr.run()
-                Thread(target=task, daemon=True).start()
-                self.video_cap.release()
-                self.video_cap = None
-
-    def _slide_event_handler(self, event, values):
-        """
-        当滑动视频进度条/滑动字幕选择区域滑块时：
-        1) 判断视频是否存在，如果存在则显示对应的视频帧
-        2) 绘制rectangle
-        """
-        if event == '-SLIDER-' or event == '-Y-SLIDER-' or event == '-Y-SLIDER-H-' or event == '-X-SLIDER-' or event \
-                == '-X-SLIDER-W-':
-            # 判断是否时单张图片
-            if is_image_file(self.video_path):
-                img = cv2.imread(self.video_path)
-                self.window['-Y-SLIDER-H-'].update(range=(0, self.frame_height - values['-Y-SLIDER-']))
-                self.window['-X-SLIDER-W-'].update(range=(0, self.frame_width - values['-X-SLIDER-']))
-                # 画字幕框
-                y = int(values['-Y-SLIDER-'])
-                h = int(values['-Y-SLIDER-H-'])
-                x = int(values['-X-SLIDER-'])
-                w = int(values['-X-SLIDER-W-'])
-                self._update_preview(img, (y, h, x, w))
-            elif self.video_cap is not None and self.video_cap.isOpened():
-                frame_no = int(values['-SLIDER-'])
-                self.video_cap.set(cv2.CAP_PROP_POS_FRAMES, frame_no)
-                ret, frame = self.video_cap.read()
-                if ret:
-                    self.window['-Y-SLIDER-H-'].update(range=(0, self.frame_height-values['-Y-SLIDER-']))
-                    self.window['-X-SLIDER-W-'].update(range=(0, self.frame_width-values['-X-SLIDER-']))
-                    # 画字幕框
-                    y = int(values['-Y-SLIDER-'])
-                    h = int(values['-Y-SLIDER-H-'])
-                    x = int(values['-X-SLIDER-'])
-                    w = int(values['-X-SLIDER-W-'])
-                    self._update_preview(frame, (y, h, x, w))
-
-    def _update_preview(self, frame, y_h_x_w):
-        y, h, x, w = y_h_x_w
-        # 画字幕框
-        draw = cv2.rectangle(img=frame, pt1=(int(x), int(y)), pt2=(int(x) + int(w), int(y) + int(h)),
-                             color=(0, 255, 0), thickness=3)
-        # 调整视频帧大小，使播放器能够显示
-        resized_frame = self._img_resize(draw)
-        # 显示视频帧
-        self.window['-DISPLAY-'].update(data=cv2.imencode('.png', resized_frame)[1].tobytes())
-
-    def _img_resize(self, image):
-        top, bottom, left, right = (0, 0, 0, 0)
-        height, width = image.shape[0], image.shape[1]
-        # 对长短不想等的图片，找到最长的一边
-        longest_edge = height
-        # 计算短边需要增加多少像素宽度使其与长边等长
-        if width < longest_edge:
-            dw = longest_edge - width
-            left = dw // 2
-            right = dw - left
-        else:
-            pass
-        # 给图像增加边界
-        constant = cv2.copyMakeBorder(image, top, bottom, left, right, cv2.BORDER_CONSTANT, value=[0, 0, 0])
-        return cv2.resize(constant, (self.video_preview_width, self.video_preview_height))
-
-    def set_subtitle_config(self, y, h, x, w):
-        # 写入配置文件
-        with open(self.subtitle_config_file, mode='w', encoding='utf-8') as f:
-            f.write('[AREA]\n')
-            f.write(f'Y = {y}\n')
-            f.write(f'H = {h}\n')
-            f.write(f'X = {x}\n')
-            f.write(f'W = {w}\n')
-
-    def parse_subtitle_config(self):
-        y_p, h_p, x_p, w_p = .78, .21, .05, .9
-        # 如果配置文件不存在，则写入配置文件
-        if not os.path.exists(self.subtitle_config_file):
-            self.set_subtitle_config(y_p, h_p, x_p, w_p)
-            return y_p, h_p, x_p, w_p
-        else:
             try:
-                config = configparser.ConfigParser()
+                pos = min(self.frame_count - 1, int(self.se.progress_total / 100 * self.frame_count))
-                config.read(self.subtitle_config_file, encoding='utf-8')
+                if pos != self.video_slider.value():
-                conf_y_p, conf_h_p, conf_x_p, conf_w_p = float(config['AREA']['Y']), float(config['AREA']['H']), float(config['AREA']['X']), float(config['AREA']['W'])
+                    self.video_slider.setValue(pos)
-                return conf_y_p, conf_h_p, conf_x_p, conf_w_p
+                # 检查是否完成
-            except Exception:
+                if self.se.isFinished:
-                self.set_subtitle_config(y_p, h_p, x_p, w_p)
+                    self.processing_finished()
-                return y_p, h_p, x_p, w_p
+            except Exception as e:
+                # 捕获任何异常，防止崩溃
+                print(f"更新进度时出错: {str(e)}")
+
+    def load_window_position(self):
+        # 尝试读取窗口位置
+        try:
+            x = config.windowX.value
+            y = config.windowY.value
+            width = config.windowW.value
+            height = config.windowH.value
+
+            if not x or not y:
+                self.center_window()
+                return
+
+            # 确保窗口在屏幕内
+            screen_rect = QtWidgets.QApplication.primaryScreen().availableGeometry()
+            if (x >= 0 and y >= 0 and 
+                x + width <= screen_rect.width() and 
+                y + height <= screen_rect.height()):
+                self.setGeometry(x, y, width, height)
+            else:
+                self.center_window()
+        except Exception as e:
+            print(e)
+            self.center_window()
+    
+    def center_window(self):
+        """将窗口居中显示"""
+        screen_rect = QtWidgets.QApplication.primaryScreen().availableGeometry()
+        window_rect = self.frameGeometry()
+        center_point = screen_rect.center()
+        window_rect.moveCenter(center_point)
+        self.move(window_rect.topLeft())
+
+    def keyPressEvent(self, event):
+        """处理键盘事件"""
+        # 检测Ctrl+C组合键
+        if event.key() == QtCore.Qt.Key_C and event.modifiers() == QtCore.Qt.ControlModifier:
+            print("\n程序被用户中断(Ctrl+C)，正在退出...")
+            self.close()
+        else:
+            super().keyPressEvent(event)
 
 
 if __name__ == '__main__':
-    try:
+    multiprocessing.set_start_method("spawn")
-        multiprocessing.set_start_method("spawn")
+    QApplication.setHighDpiScaleFactorRoundingPolicy(
-        # 运行图形化界面
+    Qt.HighDpiScaleFactorRoundingPolicy.PassThrough)
-        subtitleRemoverGUI = SubtitleRemoverGUI()
+    app = QtWidgets.QApplication(sys.argv)
-        subtitleRemoverGUI.run()
+    app.setAttribute(Qt.AA_DontCreateNativeWidgetSiblings)
-    except Exception as e:
+    window = SubtitleExtractorGUI()
-        print(f'[{type(e)}] {e}')
+    # 先设置透明, 再显示, 否则会有闪烁的效果
-        import traceback
+    window.setWindowOpacity(0.0)
-        traceback.print_exc()
+    window.show()
-        msg = traceback.format_exc()
+    window.load_window_position()
-        err_log_path = os.path.join(os.path.expanduser('~'), 'VSR-Error-Message.log')
+    # 使用动画效果逐渐显示窗口
-        with open(err_log_path, 'w', encoding='utf-8') as f:
+    animation = QtCore.QPropertyAnimation(window, b"windowOpacity")
-            f.writelines(msg)
+    animation.setDuration(300)  # 300毫秒的动画
-        import platform
+    animation.setStartValue(0.0)
-        if platform.system() == 'Windows':
+    animation.setEndValue(1.0)
-            os.system('pause')
+    animation.start()
-        else:
+    app.exec()
-            input()

requirements.txt

@@ -8,7 +8,7 @@ lmdb==1.6.2
 PyYAML==6.0.2
 omegaconf==2.3.0
 tqdm==4.67.1
-PySimpleGUI-4-foss==4.60.4.1
+pyside6-fluent-widgets==1.7.7
 easydict==1.13
 scikit-learn==1.6.1
 pandas==2.2.3
@@ -19,5 +19,8 @@ av==14.3.0
 einops==0.8.1
 paddleocr==2.10.0
 paddle2onnx==1.3.1
-onnxruntime-gpu==1.20.1
+onnxruntime-gpu==1.20.1; sys_platform == 'linux'
-onnxruntime-directml==1.20.1;  sys_platform == 'win32'
+# do not upgrade, windows 10/11 compatable issues, check hardware_acclerator.py:100
+onnxruntime-directml==1.20.1; sys_platform == 'win32'
+onnxruntime-coreml==1.13.1; sys_platform == 'darwin'
+je-showinfilemanager==1.1.6a4

ui/advanced_setting_interface.py

@@ -0,0 +1,247 @@
+"""
+@desc: 高级设置页面
+"""
+
+from PySide6 import QtWidgets, QtCore, QtGui
+from qfluentwidgets import (ScrollArea, ExpandLayout, CardWidget, SubtitleLabel,
+                           FluentIcon, NavigationWidget, NavigationItemPosition,
+                           SettingCardGroup, RangeSettingCard, SwitchSettingCard,
+                           HyperlinkCard, PrimaryPushSettingCard, ComboBoxSettingCard,
+                           MessageBox)
+from backend.config import config, tr, VERSION, PROJECT_HOME_URL, PROJECT_ISSUES_URL, PROJECT_RELEASES_URL
+from backend.tools.version_service import VersionService
+from backend.tools.concurrent import TaskExecutor
+
+class AdvancedSettingInterface(ScrollArea):
+    """高级设置页面"""
+    
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.parent = parent
+        self.version_manager = VersionService()
+        self.__initWidget()
+
+    def __initWidget(self):
+        # 创建滚动内容的容器
+        self.scrollWidget = QtWidgets.QWidget(self)
+        self.expandLayout = ExpandLayout(self.scrollWidget)
+        
+        # 设置滚动区域属性
+        self.setWidget(self.scrollWidget)
+        self.enableTransparentBackground()
+        self.setWidgetResizable(True)
+        self.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
+        self.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAsNeeded)
+        
+        # 设置滚动区域样式以适应主题
+        self.setAttribute(QtCore.Qt.WA_StyledBackground)
+        
+        # 设置UI
+        self.setup_ui()
+        self.setup_layout()
+
+    def setup_layout(self):
+        self.subtitle_detection_group.addSettingCard(self.subtitle_yx_axis_difference_pixel)
+        self.subtitle_detection_group.addSettingCard(self.subtitle_area_deviation_pixel)
+        self.subtitle_detection_group.addSettingCard(self.subtitle_area_y_axis_difference_pixel)
+        self.subtitle_detection_group.addSettingCard(self.subtitle_area_pixel_tolerance_y_pixel)
+        self.subtitle_detection_group.addSettingCard(self.subtitle_area_pixel_tolerance_x_pixel)
+        self.subtitle_detection_group.addSettingCard(self.subtitle_timeline_backward_frame_count)
+        self.subtitle_detection_group.addSettingCard(self.subtitle_timeline_forward_frame_count)
+        self.expandLayout.addWidget(self.subtitle_detection_group)
+
+        self.sttn_group.addSettingCard(self.sttn_neighbor_stride)
+        self.sttn_group.addSettingCard(self.sttn_reference_length)
+        self.sttn_group.addSettingCard(self.sttn_max_load_num)
+        self.expandLayout.addWidget(self.sttn_group)
+
+        self.propainter_group.addSettingCard(self.propainter_max_load_num)
+        self.expandLayout.addWidget(self.propainter_group)
+
+        self.advanced_group.addSettingCard(self.check_update_on_startup)
+        self.expandLayout.addWidget(self.advanced_group)
+
+        self.about_group.addSettingCard(self.feedback)
+        self.about_group.addSettingCard(self.copyright)
+        self.about_group.addSettingCard(self.project_link)
+        
+        self.expandLayout.addWidget(self.about_group)
+        self.expandLayout.setSpacing(16)
+        self.expandLayout.setContentsMargins(16, 16, 16, 48)
+        
+    def setup_ui(self):
+        """设置UI"""
+        # 字幕检测设置组
+        self.subtitle_detection_group = SettingCardGroup(tr["Setting"]["SubtitleDetectionSetting"], self.scrollWidget)
+        # STTN设置组
+        self.sttn_group = SettingCardGroup(tr["Setting"]["SttnSetting"], self.scrollWidget)
+        # Propainter设置组
+        self.propainter_group = SettingCardGroup(tr["Setting"]["ProPainterSetting"], self.scrollWidget)
+        # 高级设置组
+        self.advanced_group = SettingCardGroup(tr["Setting"]["AdvancedSetting"], self.scrollWidget)
+        # 关于设置组
+        self.about_group = SettingCardGroup(tr["Setting"]["AboutSetting"], self.scrollWidget)
+        
+        self.subtitle_yx_axis_difference_pixel = RangeSettingCard(
+            configItem=config.subtitleYXAxisDifferencePixel,
+            icon=FluentIcon.ZOOM,
+            title=tr["Setting"]["SubtitleYXAxisDifferencePixel"],
+            content=tr["Setting"]["SubtitleYXAxisDifferencePixelDesc"],
+            parent=self.subtitle_detection_group
+        )
+        
+        self.subtitle_area_deviation_pixel = RangeSettingCard(
+            configItem=config.subtitleAreaDeviationPixel,
+            icon=FluentIcon.ZOOM_IN,
+            title=tr["Setting"]["SubtitleAreaDeviationPixel"],
+            content=tr["Setting"]["SubtitleAreaDeviationPixelDesc"],
+            parent=self.subtitle_detection_group
+        )
+        
+        self.subtitle_area_y_axis_difference_pixel = RangeSettingCard(
+            configItem=config.subtitleAreaYAxisDifferencePixel,
+            icon=FluentIcon.ALIGNMENT,
+            title=tr["Setting"]["SubtitleAreaYAxisDifferencePixel"],
+            content=tr["Setting"]["SubtitleAreaYAxisDifferencePixelDesc"],
+            parent=self.subtitle_detection_group
+        )
+
+        self.subtitle_area_pixel_tolerance_y_pixel = RangeSettingCard(
+            configItem=config.subtitleAreaPixelToleranceYPixel,
+            icon=FluentIcon.UP,
+            title=tr["Setting"]["SubtitleAreaPixelToleranceYPixel"],
+            content=tr["Setting"]["SubtitleAreaPixelToleranceYPixelDesc"],
+            parent=self.subtitle_detection_group
+        )
+
+        self.subtitle_area_pixel_tolerance_x_pixel = RangeSettingCard(
+            configItem=config.subtitleAreaPixelToleranceXPixel,
+            icon=FluentIcon.RIGHT_ARROW,
+            title=tr["Setting"]["SubtitleAreaPixelToleranceXPixel"],
+            content=tr["Setting"]["SubtitleAreaPixelToleranceXPixelDesc"],
+            parent=self.subtitle_detection_group
+        )
+
+        self.subtitle_timeline_backward_frame_count = RangeSettingCard(
+            configItem=config.subtitleTimelineBackwardFrameCount,
+            icon=FluentIcon.PAGE_LEFT,
+            title=tr["Setting"]["SubtitleTimelineBackwardFrameCount"],
+            content=tr["Setting"]["SubtitleTimelineBackwardFrameCountDesc"],
+            parent=self.subtitle_detection_group
+        )
+
+        self.subtitle_timeline_forward_frame_count = RangeSettingCard(
+            configItem=config.subtitleTimelineForwardFrameCount,
+            icon=FluentIcon.PAGE_RIGHT,
+            title=tr["Setting"]["subtitleTimelineForwardFrameCount"],
+            content=tr["Setting"]["subtitleTimelineForwardFrameCountDesc"],
+            parent=self.subtitle_detection_group
+        )
+
+        self.sttn_neighbor_stride = RangeSettingCard(
+            configItem=config.sttnNeighborStride,
+            icon=FluentIcon.UNIT,
+            title=tr["Setting"]["SttnNeighborStride"],
+            content=tr["Setting"]["SttnNeighborStrideDesc"],
+            parent=self.sttn_group
+        )
+
+        self.sttn_reference_length = RangeSettingCard(
+            configItem=config.sttnReferenceLength,
+            icon=FluentIcon.MORE,
+            title=tr["Setting"]["SttnReferenceLength"],
+            content=tr["Setting"]["SttnReferenceLengthDesc"],
+            parent=self.sttn_group
+        )
+
+        self.sttn_max_load_num = RangeSettingCard(
+            configItem=config.sttnMaxLoadNum,
+            icon=FluentIcon.DICTIONARY,
+            title=tr["Setting"]["SttnMaxLoadNum"],
+            content=tr["Setting"]["SttnMaxLoadNumDesc"],
+            parent=self.sttn_group
+        )
+
+        self.propainter_max_load_num = RangeSettingCard(
+            configItem=config.propainterMaxLoadNum,
+            icon=FluentIcon.DICTIONARY,
+            title=tr["Setting"]["PropainterMaxLoadNum"],
+            content=tr["Setting"]["PropainterMaxLoadNumDesc"],
+            parent=self.propainter_group
+        )
+
+        self.check_update_on_startup = SwitchSettingCard(
+            configItem=config.checkUpdateOnStartup,
+            icon=FluentIcon.UPDATE,
+            title=tr["Setting"]["CheckUpdateOnStartup"],
+            content=tr["Setting"]["CheckUpdateOnStartupDesc"],
+            parent=self.advanced_group
+        )
+
+        # 添加反馈链接
+        self.feedback = PrimaryPushSettingCard(
+            text=tr["Setting"]["FeedbackButton"],
+            icon=FluentIcon.MAIL,
+            title=tr["Setting"]["FeedbackTitle"],
+            content=tr["Setting"]["FeedbackDesc"],
+            parent=self.about_group
+        )
+        self.feedback.clicked.connect(lambda: QtGui.QDesktopServices.openUrl(
+            QtCore.QUrl(PROJECT_ISSUES_URL)
+        ))
+        # 添加版权信息
+        self.copyright = PrimaryPushSettingCard(
+            text=tr["Setting"]["CopyrightButton"],
+            icon=FluentIcon.MAIL,
+            title=tr["Setting"]["CopyrightTitle"],
+            content=tr["Setting"]["CopyrightDesc"].format(VERSION),
+            parent=self.about_group
+        )
+        self.copyright.clicked.connect(lambda: self.check_update())
+        # 添加项目链接
+        self.project_link = HyperlinkCard(
+            url=PROJECT_HOME_URL,
+            text=PROJECT_HOME_URL,
+            icon=FluentIcon.GITHUB,
+            title=tr["Setting"]["ProjectLinkTitle"],
+            content=tr["Setting"]["ProjectLinkDesc"],
+            parent=self.about_group
+        )
+
+    def show_message_box(self, title: str, content: str, showYesButton=False, yesSlot=None):
+        """ show message box """
+        w = MessageBox(title, content, self)
+        if not showYesButton:
+            w.cancelButton.setText(self.tr('Close'))
+            w.yesButton.hide()
+            w.buttonLayout.insertStretch(0, 1)
+
+        if w.exec() and yesSlot is not None:
+            yesSlot()
+
+    def check_update(self, ignore=False):
+        """ check software update
+
+        Parameters
+        ----------
+        ignore: bool
+            ignore message box when no updates are available
+        """
+        TaskExecutor.runTask(self.version_manager.has_new_version).then(
+            lambda success: self.on_version_info_fetched(success, ignore))
+
+    def on_version_info_fetched(self, success, ignore=False):
+        if success:
+            self.show_message_box(
+                tr["Setting"]["UpdatesAvailableTitle"],
+                tr["Setting"]["UpdatesAvailableDesc"].format(self.version_manager.lastest_version),
+                True,
+                lambda: QtGui.QDesktopServices.openUrl(
+                    QtCore.QUrl(PROJECT_RELEASES_URL)
+                )
+            )
+        elif not ignore:
+            self.show_message_box(
+                tr["Setting"]["NoUpdatesAvailableTitle"],
+                tr["Setting"]["NoUpdatesAvailableDesc"],
+            )

ui/component/task_list_component.py

@@ -0,0 +1,331 @@
+import os
+from enum import Enum
+from dataclasses import dataclass
+from PySide6.QtWidgets import QWidget, QVBoxLayout, QMenu, QAbstractItemView, QTableWidgetItem, QHeaderView
+from PySide6.QtCore import Qt, Signal, QModelIndex, QUrl
+from qfluentwidgets import TableWidget, BodyLabel, FluentIcon, InfoBar, InfoBarPosition
+from PySide6.QtGui import QAction, QColor, QBrush
+from showinfm import show_in_file_manager
+
+from backend.config import tr
+
+class TaskStatus(Enum):
+    PENDING = tr['TaskList']['Pending']
+    PROCESSING = tr['TaskList']['Processing']
+    COMPLETED = tr['TaskList']['Completed']
+    FAILED = tr['TaskList']['Failed']
+
+@dataclass
+class Task:
+    path: str
+    name: str
+    progress: int
+    status: TaskStatus
+    output_path: str
+
+class TaskListComponent(QWidget):
+    """任务列表组件"""
+    
+    # 定义信号
+    task_selected = Signal(int, str)  # 任务被选中时发出信号，参数为任务索引和视频路径
+    task_deleted = Signal(int)  # 任务被删除时发出信号，参数为任务索引
+    
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setObjectName("TaskListComponent")
+        
+        # 初始化变量
+        self.tasks = []  # 存储任务列表
+        self.current_task_index = -1  # 当前选中的任务索引
+        
+        # 创建布局
+        self.__initWidget()
+        
+    def __initWidget(self):
+        """初始化组件"""
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(0)
+        
+        # 创建表格
+        self.table = TableWidget(self)
+        self.table.setColumnCount(3)
+        self.table.setHorizontalHeaderLabels([tr['TaskList']['Name'], tr['TaskList']['Progress'], tr['TaskList']['Status']])
+        
+        # 设置表格样式
+        self.table.setShowGrid(False)
+        self.table.setAlternatingRowColors(True)
+        
+        # 设置列宽模式
+        header = self.table.horizontalHeader()
+        header.setSectionResizeMode(0, QHeaderView.Stretch)           # 名称列拉伸填充
+        header.setSectionResizeMode(1, QHeaderView.ResizeToContents)  # 进度列自适应内容宽度
+        header.setSectionResizeMode(2, QHeaderView.ResizeToContents)  # 状态列自适应内容宽度
+        
+        self.table.setSelectionBehavior(QAbstractItemView.SelectRows)
+        self.table.setSelectionMode(QAbstractItemView.SingleSelection)
+        self.table.setEditTriggers(QAbstractItemView.NoEditTriggers)
+        
+        # 连接信号
+        self.table.setContextMenuPolicy(Qt.CustomContextMenu)
+        self.table.customContextMenuRequested.connect(self.show_context_menu)
+        self.table.clicked.connect(self.on_task_clicked)
+        
+        layout.addWidget(self.table)
+        
+    def add_task(self, video_path, output_path):
+        """添加任务到列表
+        
+        Args:
+            video_path: 视频文件路径
+        """
+        # 覆盖相同路径的任务
+        for row, task in enumerate(self.tasks[:]):
+            if task.path == video_path:
+                self.delete_task(row)
+                continue
+                
+        # 获取文件名
+        file_name = os.path.basename(video_path)
+        
+        # 添加到任务列表
+        task = Task(
+            path=video_path,
+            name=file_name,
+            progress=0,
+            status=TaskStatus.PENDING,
+            output_path=output_path,
+        )
+        self.tasks.append(task)
+        
+        # 更新表格
+        row = len(self.tasks) - 1
+        self.table.setRowCount(len(self.tasks))
+        
+        item0 = QTableWidgetItem(file_name)
+        item1 = QTableWidgetItem("0%")
+        item2 = QTableWidgetItem(TaskStatus.PENDING.value)
+        
+        # 设置文件名单元格的省略模式为中间省略
+        item0.setTextAlignment(Qt.AlignVCenter | Qt.AlignLeft)
+        item0.setToolTip(video_path)  # 设置完整路径为工具提示
+        # 设置表格的文本省略模式
+        self.table.setTextElideMode(Qt.ElideMiddle)
+        
+        item1.setTextAlignment(Qt.AlignCenter)
+        item2.setTextAlignment(Qt.AlignCenter)
+        
+        self.table.setItem(row, 0, item0)
+        self.table.setItem(row, 1, item1)
+        self.table.setItem(row, 2, item2)
+        
+        # 滚动到最新添加的行
+        self.table.scrollToBottom()
+        return True
+        
+    def update_task_progress(self, index, progress):
+        """更新任务进度
+        
+        Args:
+            index: 任务索引
+            progress: 进度值(0-100)
+        """
+        if 0 <= index < len(self.tasks):
+            self.tasks[index].progress = progress
+            
+            # 更新进度单元格
+            progress_item = self.table.item(index, 1)
+            if progress_item:
+                progress_item.setText(f"{progress}%")
+            
+            # 如果是当前处理的任务，滚动到可见区域
+            if index == self.current_task_index:
+                self.table.scrollTo(self.table.model().index(index, 0))
+                
+    def update_task_status(self, index, status):
+        """更新任务状态
+        
+        Args:
+            index: 任务索引
+            status: 任务状态
+        """
+        if 0 <= index < len(self.tasks):
+            self.tasks[index].status = status
+            status_item = self.table.item(index, 2)
+            if status_item:
+                status_item.setText(status.value)
+                
+                # 根据状态设置不同颜色
+                if status == TaskStatus.COMPLETED:
+                    status_item.setForeground(QBrush(QColor("#2ecc71")))  # 绿色
+                elif status == TaskStatus.PROCESSING:
+                    status_item.setForeground(QBrush(QColor("#3498db")))  # 蓝色
+                elif status == TaskStatus.FAILED:
+                    status_item.setForeground(QBrush(QColor("#e74c3c")))  # 红色
+            
+            # 如果是当前处理的任务，滚动到可见区域
+            if index == self.current_task_index:
+                self.table.scrollTo(self.table.model().index(index, 0))
+                
+            # 选中当前行
+            self.table.selectRow(index)
+    
+    def get_pending_tasks(self):
+        """获取所有待处理的任务
+        
+        Returns:
+            list: 待处理任务列表，每项为 (索引, 任务) 元组
+        """
+        return [(i, task) for i, task in enumerate(self.tasks) if task.status == TaskStatus.PENDING]
+    
+    def get_all_tasks(self):
+        """获取所有任务
+        
+        Returns:
+            list: 所有任务列表
+        """
+        return self.tasks
+
+    def get_task(self, index):
+        """获取指定索引的任务
+
+        Args:
+            index: 任务索引
+
+        Returns:
+            Task: 任务对象
+        """
+        if 0 <= index < len(self.tasks):
+            return self.tasks[index]
+        return None
+    
+    def find_task_index_by_path(self, path):
+        tasks = self.get_all_tasks()
+        for idx, task in enumerate(tasks):
+            if task.path == path:
+                return idx
+        return -1  # 没找到返回-1
+        
+    def show_context_menu(self, pos):
+        """显示右键菜单
+        
+        Args:
+            pos: 鼠标位置
+        """
+        index = self.table.indexAt(pos)
+        if index.isValid():
+            menu = QMenu(self)
+            
+            # 打开视频文件位置
+            open_video_location_action = QAction(tr['TaskList']['OpenSourceVideoLocation'], self)
+            open_video_location_action.triggered.connect(lambda: self.open_file_location(self.tasks[index.row()].path))
+            menu.addAction(open_video_location_action)
+            
+            # 打开目标文件位置
+            def open_target_location():
+                task = self.tasks[index.row()]
+                path = task.output_path
+                if task.status != TaskStatus.COMPLETED:
+                    InfoBar.warning(
+                        title=tr['TaskList']['Warning'],
+                        content=tr['TaskList']['TargetFileNotFound'],
+                        parent=self.get_root_parent(),
+                        duration=3000
+                    )
+                    return
+                self.open_file_location(path)
+            open_target_location_action = QAction(tr['TaskList']['OpenTargetVideoLocation'], self)
+            open_target_location_action.triggered.connect(open_target_location)
+            menu.addAction(open_target_location_action)
+
+            reset_task_status_action = QAction(tr['TaskList']['ResetTaskStatus'], self)
+            reset_task_status_action.triggered.connect((lambda: (
+                    self.update_task_status(index.row(), TaskStatus.PENDING), 
+                    self.update_task_progress(index.row(), 0)
+                )
+            ))
+            menu.addAction(reset_task_status_action)
+            
+            # 删除任务
+            delete_action = QAction(tr['TaskList']['DeleteTask'], self)
+            delete_action.triggered.connect(lambda: self.delete_task(index.row()))
+            menu.addAction(delete_action)
+            
+            # 显示菜单
+            menu.exec_(self.table.viewport().mapToGlobal(pos))
+    
+    def delete_task(self, row):
+        """删除任务
+        
+        Args:
+            row: 行索引
+        """
+        if 0 <= row < len(self.tasks):
+            # 从列表中删除
+            del self.tasks[row]
+            
+            # 从表格中删除
+            self.table.removeRow(row)
+                
+            # 如果删除的是当前任务，重置当前任务索引
+            if row == self.current_task_index:
+                self.current_task_index = -1
+                
+            # 发出任务删除信号
+            self.task_deleted.emit(row)
+    
+    def on_task_clicked(self, index):
+        """任务被点击时的处理
+        
+        Args:
+            index: 索引
+        """
+        row = index.row()
+        if 0 <= row < len(self.tasks):
+            self.current_task_index = row
+            # 发出信号，通知外部加载对应视频
+            self.task_selected.emit(row, self.tasks[row].path)
+            
+    def set_current_task(self, index):
+        """设置当前处理的任务
+        
+        Args:
+            index: 任务索引
+        """
+        if 0 <= index < len(self.tasks):
+            self.current_task_index = index
+            self.table.selectRow(index)
+            self.table.scrollTo(self.table.model().index(index, 0))
+            
+    def select_task(self, index):
+        """选中指定任务
+        
+        Args:
+            index: 任务索引
+        """
+        self.set_current_task(index)
+
+    def open_file_location(self, path):
+        """打开文件所在位置
+        
+        Args:
+            row: 行索引
+            path: 目标路径
+        """                
+        # 检查视频文件是否存在
+        if not os.path.exists(path):
+            InfoBar.warning(
+                title=tr['TaskList']['Warning'],
+                content=tr['TaskList']['UnableToLocateFile'],
+                parent=self.get_root_parent(),
+                duration=3000
+            )
+            return
+            
+        show_in_file_manager(os.path.abspath(path))
+
+    def get_root_parent(self):
+        parent = self
+        while parent.parent():
+            parent = parent.parent()
+        return parent

ui/component/video_display_component.py

@@ -0,0 +1,566 @@
+import cv2
+from PySide6.QtWidgets import QWidget, QVBoxLayout, QLabel, QSizePolicy
+from PySide6.QtCore import Qt, Signal, QRect, QRectF, QTimer, QObject, QEvent
+from PySide6 import QtCore, QtWidgets, QtGui
+from qfluentwidgets import qconfig, CardWidget, HollowHandleStyle
+
+from backend.config import config, tr
+
+class VideoDisplayComponent(QWidget):
+    """视频显示组件，包含视频预览和选择框功能"""
+    
+    # 定义信号
+    selection_changed = Signal(QRect)  # 选择框变化信号
+    
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.parent = parent
+        
+        # 初始化变量
+        self.is_drawing = False
+        self.selection_rect = QRect()
+        self.drag_start_pos = None
+        self.resize_edge = None
+        self.edge_size = 10  # 调整大小的边缘区域
+        self.enable_mouse_events = True  # 控制是否启用鼠标事件
+        
+        # 获取屏幕大小
+        screen = QtWidgets.QApplication.primaryScreen().size()
+        self.screen_width = screen.width()
+        self.screen_height = screen.height()
+        
+        # 设置视频预览区域大小（根据屏幕宽度动态调整）
+        self.video_preview_width = 960
+        self.video_preview_height = self.video_preview_width * 9 // 16
+        if self.screen_width // 2 < 960:
+            self.video_preview_width = 640
+            self.video_preview_height = self.video_preview_width * 9 // 16
+            
+        # 视频相关参数
+        self.frame_width = None
+        self.frame_height = None
+        self.scaled_width = None
+        self.scaled_height = None
+        self.border_left = 0
+        self.border_top = 0
+        
+        # 保存选择框的相对位置和大小（相对于实际视频的比例）
+        self.selection_ratio = None
+
+        self.__initWidget()
+        
+    def __initWidget(self):
+        """初始化组件"""
+        main_layout = QVBoxLayout(self)
+        main_layout.setSpacing(0)
+        main_layout.setContentsMargins(0, 0, 0, 0)
+        
+        # 视频预览区域和进度条容器
+        self.video_container = CardWidget(self)
+        self.video_container.setObjectName('videoContainer')
+        video_layout = QVBoxLayout()
+        video_layout.setSpacing(0)
+        video_layout.setContentsMargins(2, 2, 2, 2)
+        video_layout.setAlignment(Qt.AlignCenter)
+        
+        # 创建内部黑色背景容器
+        self.black_container = QWidget(self)
+        self.black_container.setObjectName('blackContainer')
+        self.black_container.setStyleSheet("""
+            #blackContainer {
+                background-color: black;
+                border-radius: 10px;
+                border: 0px solid transparent;
+            }
+        """)
+        black_layout = QVBoxLayout()
+        black_layout.setContentsMargins(0, 0, 0, 0)
+        black_layout.setSpacing(0)
+        black_layout.setAlignment(Qt.AlignCenter)
+        
+        # 视频显示标签
+        self.video_display = QtWidgets.QLabel()
+        self.video_display.setStyleSheet("""
+            background-color: black;
+            border-top-left-radius: 10px;
+            border-top-right-radius: 10px;
+            border: 0px solid transparent;
+        """)
+        self.video_display.setMinimumSize(self.video_preview_width, self.video_preview_height)
+        
+        self.video_display.setMouseTracking(True)
+        self.video_display.setScaledContents(True)
+        self.video_display.setAlignment(Qt.AlignCenter)
+        self.video_display.mousePressEvent = self.selection_mouse_press
+        self.video_display.mouseMoveEvent = self.selection_mouse_move
+        self.video_display.mouseReleaseEvent = self.selection_mouse_release
+        
+        # 视频滑块
+        self.video_slider = QtWidgets.QSlider(Qt.Horizontal)
+        self.video_slider.setMinimum(1)
+        self.video_slider.setFixedHeight(22)
+        self.video_slider.setMaximum(100)  # 默认最大值设为100，与进度百分比一致
+        self.video_slider.setValue(1)
+        self.video_slider.setStyle(HollowHandleStyle({
+            "handle.color": QtGui.QColor(255, 255, 255),
+            "handle.ring-width": 4,
+            "handle.hollow-radius": 6,
+            "handle.margin": 1
+        }))
+        
+        # 视频预览区域
+        self.video_display.setObjectName('videoDisplay')
+        # black_layout.addWidget(self.video_display, 0, Qt.AlignCenter)
+        # 创建一个容器来保持比例
+        ratio_container = QWidget()
+        ratio_layout = QVBoxLayout(ratio_container)
+        ratio_layout.setContentsMargins(0, 0, 0, 0)
+        ratio_layout.addWidget(self.video_display)
+
+        # 设置固定的宽高比
+        ratio_container.setFixedHeight(ratio_container.width() * 9 // 16)
+        ratio_container.setMinimumWidth(self.video_preview_width)
+
+        # 添加到布局
+        black_layout.addWidget(ratio_container)
+
+        # 添加一个事件过滤器来处理大小变化
+        class RatioEventFilter(QObject):
+            def eventFilter(self, obj, event):
+                if event.type() == QEvent.Resize:
+                    obj.setFixedHeight(obj.width() * 9 // 16)
+                return False
+
+        ratio_filter = RatioEventFilter(ratio_container)
+        ratio_container.installEventFilter(ratio_filter)
+
+        # 进度条和滑块容器
+        control_container = QWidget(self)
+        control_layout = QVBoxLayout()
+        control_layout.setContentsMargins(8, 8, 8, 8)
+        control_layout.addWidget(self.video_slider)
+        
+        control_container.setLayout(control_layout)
+        control_container.setStyleSheet("""
+            background-color: black;
+            border-bottom-left-radius: 8px;
+            border-bottom-right-radius: 8px;        
+        """)
+        black_layout.addWidget(control_container)
+        
+        self.black_container.setLayout(black_layout)
+        video_layout.addWidget(self.black_container)
+        self.video_container.setLayout(video_layout)
+        main_layout.addWidget(self.video_container)
+    
+    def update_video_display(self, frame, draw_selection=True):
+        """更新视频显示"""
+        if frame is None:
+            return
+
+        # 调整视频帧大小以适应视频预览区域
+        frame = cv2.resize(frame, (self.video_preview_width, self.video_preview_height))
+        # 将 OpenCV 帧（BGR 格式）转换为 QImage 并显示在 QLabel 上
+        rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        h, w, ch = rgb_frame.shape
+        bytes_per_line = ch * w
+        image = QtGui.QImage(rgb_frame.data, w, h, bytes_per_line, QtGui.QImage.Format_RGB888)
+        pix = QtGui.QPixmap.fromImage(image)
+        
+        # 创建带圆角的图像
+        rounded_pix = QtGui.QPixmap(pix.size())
+        rounded_pix.fill(Qt.transparent)  # 填充透明背景
+        
+        painter = QtGui.QPainter(rounded_pix)
+        painter.setRenderHint(QtGui.QPainter.Antialiasing)  # 抗锯齿
+        painter.setRenderHint(QtGui.QPainter.SmoothPixmapTransform, True)
+        
+        # 创建圆角路径
+        path = QtGui.QPainterPath()
+        rect = QRectF(0, 0, pix.width(), pix.height())
+        
+        # 手动创建只有左上和右上圆角的路径
+        radius = 8
+        path.moveTo(radius, 0)
+        path.lineTo(pix.width() - radius, 0)
+        path.arcTo(pix.width() - radius * 2, 0, radius * 2, radius * 2, 90, -90)
+        path.lineTo(pix.width(), pix.height())
+        path.lineTo(0, pix.height())
+        path.lineTo(0, radius)
+        path.arcTo(0, 0, radius * 2, radius * 2, 180, -90)
+        path.closeSubpath()
+        
+        painter.setClipPath(path)
+        painter.drawPixmap(0, 0, pix)
+        painter.end()
+        
+        # 保存当前的pixmap用于绘制选择框
+        self.current_pixmap = rounded_pix.copy()
+        
+        self.video_display.setPixmap(rounded_pix)
+        
+        # 如果有保存的选择框比例，根据新视频尺寸重新计算选择框
+        if draw_selection and self.selection_ratio is not None and self.scaled_width and self.scaled_height:
+            x_ratio, y_ratio, w_ratio, h_ratio = self.selection_ratio
+            
+            # 计算新的选择框坐标和大小
+            x = int(x_ratio * self.scaled_width) + self.border_left
+            y = int(y_ratio * self.scaled_height) + self.border_top
+            w = int(w_ratio * self.scaled_width)
+            h = int(h_ratio * self.scaled_height)
+            
+            # 创建新的选择框
+            self.selection_rect = QRect(x, y, w, h)
+            
+            # 更新视频显示
+            self.update_preview_with_rect()
+    
+    def update_preview_with_rect(self, rect=None):
+        """更新带有选择框的预览"""
+        if not hasattr(self, 'current_pixmap') or self.current_pixmap is None:
+            return
+            
+        # 如果提供了新的矩形，使用它
+        if rect is not None:
+            self.selection_rect = rect
+            
+        # 创建一个副本用于绘制
+        pixmap_copy = self.current_pixmap.copy()
+        painter = QtGui.QPainter(pixmap_copy)
+        
+        # 设置选择框样式
+        pen = QtGui.QPen(QtGui.QColor(0, 255, 0))  # 绿色
+        pen.setWidth(2)
+        painter.setPen(pen)
+        
+        # 绘制选择框
+        painter.drawRect(self.selection_rect)
+        painter.end()
+        
+        # 更新显示
+        self.video_display.setPixmap(pixmap_copy)
+    
+    def selection_mouse_press(self, event):
+        """鼠标按下事件处理"""
+        if not self.enable_mouse_events:
+            return
+        pos = event.pos()
+
+        # 检测双击或三击，重置选择框
+        if event.type() == QtCore.QEvent.MouseButtonDblClick:
+            self.selection_rect = QRect(pos, pos)
+            self.resize_edge = None
+            self.is_drawing = True
+            self.drag_start_pos = pos
+            return
+        
+        # 检查是否在选择框边缘（用于调整大小）
+        if self.selection_rect.isValid():
+            # 右下角
+            if abs(pos.x() - self.selection_rect.right()) <= self.edge_size and abs(pos.y() - self.selection_rect.bottom()) <= self.edge_size:
+                self.resize_edge = "bottomright"
+                self.drag_start_pos = pos
+                return
+            # 右上角
+            elif abs(pos.x() - self.selection_rect.right()) <= self.edge_size and abs(pos.y() - self.selection_rect.top()) <= self.edge_size:
+                self.resize_edge = "topright"
+                self.drag_start_pos = pos
+                return
+            # 左下角
+            elif abs(pos.x() - self.selection_rect.left()) <= self.edge_size and abs(pos.y() - self.selection_rect.bottom()) <= self.edge_size:
+                self.resize_edge = "bottomleft"
+                self.drag_start_pos = pos
+                return
+            # 左边缘
+            elif abs(pos.x() - self.selection_rect.left()) <= self.edge_size and self.selection_rect.top() <= pos.y() <= self.selection_rect.bottom():
+                self.resize_edge = "left"
+                self.drag_start_pos = pos
+                return
+            # 右边缘
+            elif abs(pos.x() - self.selection_rect.right()) <= self.edge_size and self.selection_rect.top() <= pos.y() <= self.selection_rect.bottom():
+                self.resize_edge = "right"
+                self.drag_start_pos = pos
+                return
+            # 上边缘
+            elif abs(pos.y() - self.selection_rect.top()) <= self.edge_size and self.selection_rect.left() <= pos.x() <= self.selection_rect.right():
+                self.resize_edge = "top"
+                self.drag_start_pos = pos
+                return
+            # 下边缘
+            elif abs(pos.y() - self.selection_rect.bottom()) <= self.edge_size and self.selection_rect.left() <= pos.x() <= self.selection_rect.right():
+                self.resize_edge = "bottom"
+                self.drag_start_pos = pos
+                return
+            # 左上角
+            elif abs(pos.x() - self.selection_rect.left()) <= self.edge_size and abs(pos.y() - self.selection_rect.top()) <= self.edge_size:
+                self.resize_edge = "topleft"
+                self.drag_start_pos = pos
+                return
+            # 在选择框内部（用于移动）
+            elif self.selection_rect.contains(pos):
+                self.resize_edge = "move"
+                self.drag_start_pos = pos
+                return
+        
+        # 开始新的选择
+        self.is_drawing = True
+        self.selection_rect = QRect(pos, pos)
+        self.drag_start_pos = pos
+        self.resize_edge = None
+    
+    def selection_mouse_move(self, event):
+        """鼠标移动事件处理"""
+        if not self.enable_mouse_events:
+            return
+        pos = event.pos()
+        
+        # 根据不同的操作模式处理鼠标移动
+        if self.is_drawing:  # 绘制新选择框
+            self.selection_rect.setBottomRight(pos)
+            self.update_preview_with_rect()
+        elif self.resize_edge:  # 调整选择框大小或位置
+            if self.resize_edge == "move":
+                # 移动整个选择框
+                dx = pos.x() - self.drag_start_pos.x()
+                dy = pos.y() - self.drag_start_pos.y()
+                
+                # 保存原始选择框尺寸
+                original_width = self.selection_rect.width()
+                original_height = self.selection_rect.height()
+                
+                # 计算新位置
+                new_rect = self.selection_rect.translated(dx, dy)
+                
+                # 获取视频显示区域
+                display_rect = self.video_display.rect()
+                
+                # 检查是否超出边界，如果超出则调整位置但保持尺寸
+                if new_rect.left() < 0:
+                    new_rect.moveLeft(0)
+                if new_rect.top() < 0:
+                    new_rect.moveTop(0)
+                if new_rect.right() > display_rect.width():
+                    new_rect.moveRight(display_rect.width())
+                if new_rect.bottom() > display_rect.height():
+                    new_rect.moveBottom(display_rect.height())
+                    
+                # 确保尺寸不变
+                if new_rect.width() != original_width or new_rect.height() != original_height:
+                    # 如果尺寸变了，恢复原始尺寸
+                    if new_rect.left() == 0:
+                        new_rect.setWidth(original_width)
+                    if new_rect.top() == 0:
+                        new_rect.setHeight(original_height)
+                    if new_rect.right() == display_rect.width():
+                        new_rect.setLeft(new_rect.right() - original_width)
+                    if new_rect.bottom() == display_rect.height():
+                        new_rect.setTop(new_rect.bottom() - original_height)
+                    
+                self.selection_rect = new_rect
+                self.drag_start_pos = pos
+            else:
+                # 调整选择框大小
+                if "left" in self.resize_edge:
+                    self.selection_rect.setLeft(pos.x())
+                if "right" in self.resize_edge:
+                    self.selection_rect.setRight(pos.x())
+                if "top" in self.resize_edge:
+                    self.selection_rect.setTop(pos.y())
+                if "bottom" in self.resize_edge:
+                    self.selection_rect.setBottom(pos.y())
+                
+                # 确保选择框在视频显示区域内
+                display_rect = self.video_display.rect()
+                if self.selection_rect.left() < 0:
+                    self.selection_rect.setLeft(0)
+                if self.selection_rect.top() < 0:
+                    self.selection_rect.setTop(0)
+                if self.selection_rect.right() > display_rect.width():
+                    self.selection_rect.setRight(display_rect.width())
+                if self.selection_rect.bottom() > display_rect.height():
+                    self.selection_rect.setBottom(display_rect.height())
+                    
+            self.update_preview_with_rect()
+        else:
+            # 更新鼠标指针形状
+            self.update_cursor_shape(pos)
+    
+    def selection_mouse_release(self, event):
+        """鼠标释放事件处理"""
+        if not self.enable_mouse_events:
+            return
+        # 结束绘制或调整
+        self.is_drawing = False
+        self.resize_edge = None
+        
+        # 标准化选择框（确保宽度和高度为正）
+        self.selection_rect = self.selection_rect.normalized()
+        
+        # 保存选择框的相对位置和大小
+        self.save_selection_ratio()
+        
+        # 发送选择框变化信号
+        self.selection_changed.emit(self.selection_rect)
+        
+    def update_cursor_shape(self, pos):
+        """根据鼠标位置更新光标形状"""
+        if not self.selection_rect.isValid():
+            self.video_display.setCursor(Qt.ArrowCursor)
+            return
+            
+        # 检查鼠标是否在选择框边缘
+        if (abs(pos.x() - self.selection_rect.left()) <= self.edge_size and 
+            self.selection_rect.top() <= pos.y() <= self.selection_rect.bottom()):
+            self.video_display.setCursor(Qt.SizeHorCursor)
+        elif (abs(pos.x() - self.selection_rect.right()) <= self.edge_size and 
+              self.selection_rect.top() <= pos.y() <= self.selection_rect.bottom()):
+            self.video_display.setCursor(Qt.SizeHorCursor)
+        elif (abs(pos.y() - self.selection_rect.top()) <= self.edge_size and 
+              self.selection_rect.left() <= pos.x() <= self.selection_rect.right()):
+            self.video_display.setCursor(Qt.SizeVerCursor)
+        elif (abs(pos.y() - self.selection_rect.bottom()) <= self.edge_size and 
+              self.selection_rect.left() <= pos.x() <= self.selection_rect.right()):
+            self.video_display.setCursor(Qt.SizeVerCursor)
+        elif (abs(pos.x() - self.selection_rect.left()) <= self.edge_size and 
+              abs(pos.y() - self.selection_rect.top()) <= self.edge_size):
+            self.video_display.setCursor(Qt.SizeFDiagCursor)
+        elif (abs(pos.x() - self.selection_rect.right()) <= self.edge_size and 
+              abs(pos.y() - self.selection_rect.top()) <= self.edge_size):
+            self.video_display.setCursor(Qt.SizeBDiagCursor)
+        elif (abs(pos.x() - self.selection_rect.left()) <= self.edge_size and 
+              abs(pos.y() - self.selection_rect.bottom()) <= self.edge_size):
+            self.video_display.setCursor(Qt.SizeBDiagCursor)
+        elif (abs(pos.x() - self.selection_rect.right()) <= self.edge_size and 
+              abs(pos.y() - self.selection_rect.bottom()) <= self.edge_size):
+            self.video_display.setCursor(Qt.SizeFDiagCursor)
+        elif self.selection_rect.contains(pos):
+            self.video_display.setCursor(Qt.SizeAllCursor)
+        else:
+            self.video_display.setCursor(Qt.ArrowCursor)
+    
+    def set_video_parameters(self, frame_width, frame_height, scaled_width=None, scaled_height=None, border_left=0, border_top=0):
+        """设置视频参数"""
+        self.frame_width = frame_width
+        self.frame_height = frame_height
+        self.scaled_width = scaled_width
+        self.scaled_height = scaled_height
+        self.border_left = border_left
+        self.border_top = border_top
+    
+    def get_selection_coordinates(self):
+        """获取选择框坐标"""
+        return self.selection_rect
+    
+    def set_selection_rect(self, rect):
+        """设置选择框"""
+        self.selection_rect = rect
+        self.save_selection_ratio()
+        self.update_preview_with_rect()
+    
+    def load_selection_ratio(self):
+        """从配置中加载选择框的相对位置和大小"""
+        # 检查是否有有效的视频尺寸
+        if not self.scaled_width or not self.scaled_height:
+            return False
+            
+        # 从配置中读取选择框的相对位置和大小
+        x_ratio = config.subtitleSelectionAreaX.value
+        y_ratio = config.subtitleSelectionAreaY.value
+        w_ratio = config.subtitleSelectionAreaW.value
+        h_ratio = config.subtitleSelectionAreaH.value
+        
+        # 检查配置值是否有效
+        if x_ratio is None or y_ratio is None or w_ratio is None or h_ratio is None:
+            return False
+
+        # 检查配置值是否在有效范围内
+        if w_ratio <= 0.01 or h_ratio <= 0.005:
+            config.set(config.subtitleSelectionAreaX, config.subtitleSelectionAreaX.defaultValue)
+            config.set(config.subtitleSelectionAreaY, config.subtitleSelectionAreaY.defaultValue)
+            config.set(config.subtitleSelectionAreaW, config.subtitleSelectionAreaW.defaultValue)
+            config.set(config.subtitleSelectionAreaH, config.subtitleSelectionAreaH.defaultValue)
+            x_ratio = config.subtitleSelectionAreaX.value
+            y_ratio = config.subtitleSelectionAreaY.value
+            w_ratio = config.subtitleSelectionAreaW.value
+            h_ratio = config.subtitleSelectionAreaH.value
+
+        # 保存选择框比例
+        self.selection_ratio = (x_ratio, y_ratio, w_ratio, h_ratio)
+        
+        # 计算实际像素坐标
+        x = int(x_ratio * self.scaled_width) + self.border_left
+        y = int(y_ratio * self.scaled_height) + self.border_top
+        w = int(w_ratio * self.scaled_width)
+        h = int(h_ratio * self.scaled_height)
+        
+        # 创建选择框
+        self.selection_rect = QRect(x, y, w, h)
+        
+        # 更新预览
+        self.update_preview_with_rect()
+        
+        return True
+        
+    def save_selection_ratio(self):
+        """保存选择框的相对位置和大小（相对于实际视频的比例）"""
+        if not self.selection_rect.isValid() or not self.scaled_width or not self.scaled_height:
+            return
+            
+        # 调整选择框坐标，考虑黑边偏移
+        x_adjusted = max(0, self.selection_rect.x() - self.border_left)
+        y_adjusted = max(0, self.selection_rect.y() - self.border_top)
+        
+        # 如果选择框超出了实际视频区域，需要调整宽度和高度
+        w_adjusted = min(self.selection_rect.width(), self.scaled_width - x_adjusted)
+        h_adjusted = min(self.selection_rect.height(), self.scaled_height - y_adjusted)
+        
+        # 转换为相对比例
+        x_ratio = x_adjusted / self.scaled_width
+        y_ratio = y_adjusted / self.scaled_height
+        w_ratio = w_adjusted / self.scaled_width
+        h_ratio = h_adjusted / self.scaled_height
+        
+        self.selection_ratio = (x_ratio, y_ratio, w_ratio, h_ratio)
+    
+        config.subtitleSelectionAreaY.value = y_ratio
+        config.subtitleSelectionAreaH.value = h_ratio
+        config.subtitleSelectionAreaX.value = x_ratio
+        config.subtitleSelectionAreaW.value = w_ratio
+        
+        qconfig.save()
+    
+    def get_original_coordinates(self):
+        """获取选择框在原始视频中的坐标"""
+        if not self.selection_rect.isValid() or not self.scaled_width or not self.scaled_height:
+            return None
+            
+        # 调整选择框坐标，考虑黑边偏移
+        x_adjusted = max(0, self.selection_rect.x() - self.border_left)
+        y_adjusted = max(0, self.selection_rect.y() - self.border_top)
+        
+        # 如果选择框超出了实际视频区域，需要调整宽度和高度
+        w_adjusted = min(self.selection_rect.width(), self.scaled_width - x_adjusted)
+        h_adjusted = min(self.selection_rect.height(), self.scaled_height - y_adjusted)
+        
+        # 转换为原始视频坐标
+        scale_x = self.frame_width / self.scaled_width
+        scale_y = self.frame_height / self.scaled_height
+        
+        xmin = int(x_adjusted * scale_x)
+        xmax = int((x_adjusted + w_adjusted) * scale_x)
+        ymin = int(y_adjusted * scale_y)
+        ymax = int((y_adjusted + h_adjusted) * scale_y)
+        
+        # 确保坐标在有效范围内
+        xmin = max(0, min(xmin, self.frame_width))
+        xmax = max(0, min(xmax, self.frame_width))
+        ymin = max(0, min(ymin, self.frame_height))
+        ymax = max(0, min(ymax, self.frame_height))
+        
+        return (ymin, ymax, xmin, xmax)
+
+    def set_dragger_enabled(self, enabled):
+        """设置拖动器是否可用"""
+        self.enable_mouse_events = enabled
+        self.video_display.setMouseTracking(enabled)
+        self.video_display.setCursor(Qt.ArrowCursor)

ui/home_interface.py

@@ -0,0 +1,586 @@
+import os
+import cv2
+import threading
+import atexit
+import multiprocessing
+import time
+import traceback
+from pathlib import Path
+from multiprocessing import managers
+from PySide6.QtWidgets import QWidget, QHBoxLayout, QVBoxLayout, QLabel, QPushButton, QFileDialog
+from PySide6.QtCore import Qt, Slot, QTimer, QRect, QRectF, Signal
+from PySide6 import QtCore, QtWidgets, QtGui
+from qfluentwidgets import (qconfig, PushButton, CardWidget, SubtitleLabel, PlainTextEdit,
+                           FluentIcon, HollowHandleStyle)
+from ui.setting_interface import SettingInterface
+from ui.component.video_display_component import VideoDisplayComponent
+from ui.component.task_list_component import TaskListComponent, TaskStatus
+from ui.icon.my_fluent_icon import MyFluentIcon
+from backend.config import config, tr
+from backend.tools.subtitle_remover_remote_call import SubtitleRemoverRemoteCall
+from backend.tools.process_manager import ProcessManager
+from backend.tools.common_tools import get_readable_path, is_image_file, read_image
+
+class HomeInterface(QWidget):
+    progress_signal = Signal(int, bool) 
+    append_log_signal = Signal(list)
+    update_preview_with_comp_signal = Signal(list)
+    task_error_signal = Signal(object)
+    def __init__(self, parent=None):
+        super().__init__(parent=parent)
+        self.setObjectName("HomeInterface")
+        # 初始化一些变量
+        self.video_path = None
+        self.video_cap = None
+        self.fps = None
+        self.frame_count = None
+        self.frame_width = None
+        self.frame_height = None
+        self.se = None  # 后台字幕提取器
+
+        # 字幕区域参数
+        self.xmin = None
+        self.xmax = None
+        self.ymin = None
+        self.ymax = None
+
+        # 添加自动滚动控制标志
+        self.auto_scroll = True
+        self.running_task = False
+        self.running_process = None
+        
+        # 当前正在处理的任务索引
+        self.current_processing_task_index = -1
+
+        self.__initWidget()
+        self.progress_signal.connect(self.update_progress)
+        self.append_log_signal.connect(self.append_log)
+        self.update_preview_with_comp_signal.connect(self.update_preview_with_comp)
+        self.task_error_signal.connect(self.on_task_error)
+
+    def __initWidget(self):
+        """创建主页面"""
+        main_layout = QHBoxLayout(self)
+        main_layout.setSpacing(8)
+        main_layout.setContentsMargins(16, 16, 16, 16)
+
+        # 左侧视频区域
+        left_layout = QVBoxLayout()
+        left_layout.setSpacing(8)
+        
+        # 创建视频显示组件
+        self.video_display_component = VideoDisplayComponent(self)
+        left_layout.addWidget(self.video_display_component)
+        
+        # 获取视频显示和滑块的引用
+        self.video_display = self.video_display_component.video_display
+        self.video_slider = self.video_display_component.video_slider
+        self.video_slider.valueChanged.connect(self.slider_changed)
+        
+        # 输出文本区域
+        self.output_text = PlainTextEdit()
+        self.output_text.setMinimumHeight(150)
+        self.output_text.setReadOnly(True)
+        self.output_text.document().setDocumentMargin(10)        
+        # 连接滚动条值变化信号
+        self.output_text.verticalScrollBar().valueChanged.connect(self.on_scroll_change)
+        
+        output_container = CardWidget(self)
+        output_layout = QVBoxLayout()
+        output_layout.setContentsMargins(0, 0, 0, 0)
+        output_layout.addWidget(self.output_text)
+        output_container.setLayout(output_layout)
+        left_layout.addWidget(output_container)
+
+        main_layout.addLayout(left_layout, 2)
+
+        # 右侧设置区域
+        right_layout = QVBoxLayout()
+        right_layout.setSpacing(10)
+
+        # 设置容器
+        settings_container = CardWidget(self)
+        settings_container.setLayout(SettingInterface(settings_container))
+        right_layout.addWidget(settings_container)
+        
+        # 添加任务列表容器
+        task_list_container = CardWidget(self)
+        task_list_layout = QHBoxLayout()
+        task_list_layout.setContentsMargins(0, 0, 0, 0)
+        task_list_layout.setSpacing(0)
+        self.task_list_component = TaskListComponent(self)
+        self.task_list_component.task_selected.connect(self.on_task_selected)
+        self.task_list_component.task_deleted.connect(self.on_task_deleted)
+        task_list_layout.addWidget(self.task_list_component)
+        task_list_container.setLayout(task_list_layout)
+        right_layout.addWidget(task_list_container, 1)  # 占满剩余空间
+        
+        # 操作按钮容器
+        button_container = CardWidget(self)
+        button_layout = QHBoxLayout()
+        button_layout.setContentsMargins(16, 16, 16, 16)
+        button_layout.setSpacing(8)
+        
+        self.file_button = PushButton(tr['SubtitleExtractorGUI']['Open'], self)
+        self.file_button.setIcon(FluentIcon.FOLDER)
+        self.file_button.clicked.connect(self.open_file)
+        button_layout.addWidget(self.file_button)
+        
+        self.run_button = PushButton(tr['SubtitleExtractorGUI']['Run'], self)
+        self.run_button.setIcon(FluentIcon.PLAY)
+        self.run_button.clicked.connect(self.run_button_clicked)
+        button_layout.addWidget(self.run_button)
+        
+        self.stop_button = PushButton(tr['SubtitleExtractorGUI']['Stop'], self)
+        self.stop_button.setIcon(MyFluentIcon.Stop)
+        self.stop_button.setVisible(False)
+        self.stop_button.clicked.connect(self.stop_button_clicked)
+        
+        button_layout.addWidget(self.stop_button)
+        
+        button_container.setLayout(button_layout)
+        right_layout.addWidget(button_container)
+
+        main_layout.addLayout(right_layout, 1)
+    
+    def on_scroll_change(self, value):
+        """监控滚动条位置变化"""
+        scrollbar = self.output_text.verticalScrollBar()
+        # 如果滚动到底部，启用自动滚动
+        if value == scrollbar.maximum():
+            self.auto_scroll = True
+        # 如果用户向上滚动，禁用自动滚动
+        elif self.auto_scroll and value < scrollbar.maximum():
+            self.auto_scroll = False
+
+    
+    def slider_changed(self, value):
+        if self.video_cap is not None and self.video_cap.isOpened():
+            frame_no = self.video_slider.value()
+            self.video_cap.set(cv2.CAP_PROP_POS_FRAMES, frame_no)
+            ret, frame = self.video_cap.read()
+            if ret:
+                # 更新预览图像
+                self.update_preview(frame)
+        
+    def on_task_selected(self, index, file_path):
+        """处理任务被选中事件
+        
+        Args:
+            index: 任务索引
+            file_path: 文件路径
+        """
+        # 加载选中的视频进行预览
+        self.load_video(file_path)
+    
+    def on_task_deleted(self, index):
+        """处理任务被删除事件
+        
+        Args:
+            index: 任务索引
+        """
+        # 如果删除的是正在处理的任务，则需要更新状态
+        if index == self.current_processing_task_index:
+            self.current_processing_task_index = -1
+        
+        task = self.task_list_component.get_task(0)
+        if task:
+            # 如果还有任务，选中第一个
+            self.load_video(task.path)
+            self.task_list_component.select_task(0)
+
+    def update_preview(self, frame):
+        # 先缩放图像
+        resized_frame = self._img_resize(frame)
+
+        # 设置视频参数
+        self.video_display_component.set_video_parameters(
+            self.frame_width, self.frame_height, 
+            self.scaled_width if hasattr(self, 'scaled_width') else None,
+            self.scaled_height if hasattr(self, 'scaled_height') else None,
+            self.border_left if hasattr(self, 'border_left') else 0,
+            self.border_top if hasattr(self, 'border_top') else 0
+        )
+        
+        # 更新视频显示（这会同时保存current_pixmap）
+        self.video_display_component.update_video_display(resized_frame)
+
+    def _img_resize(self, image):
+        height, width = image.shape[:2]
+        
+        video_preview_width = self.video_display_component.video_preview_width
+        video_preview_height = self.video_display_component.video_preview_height
+        # 计算等比缩放后的尺寸
+        target_ratio = video_preview_width / video_preview_height
+        image_ratio = width / height
+        
+        if image_ratio > target_ratio:
+            # 宽度适配，高度按比例缩放
+            new_width = video_preview_width
+            new_height = int(new_width / image_ratio)
+            top_border = (video_preview_height - new_height) // 2
+            bottom_border = video_preview_height - new_height - top_border
+            left_border = 0
+            right_border = 0
+        else:
+            # 高度适配，宽度按比例缩放
+            new_height = video_preview_height
+            new_width = int(new_height * image_ratio)
+            left_border = (video_preview_width - new_width) // 2
+            right_border = video_preview_width - new_width - left_border
+            top_border = 0
+            bottom_border = 0
+        
+        # 先缩放图像
+        resized = cv2.resize(image, (new_width, new_height))
+        
+        # 添加黑边以填充到目标尺寸
+        padded = cv2.copyMakeBorder(
+            resized, 
+            top_border, bottom_border, 
+            left_border, right_border, 
+            cv2.BORDER_CONSTANT, 
+            value=[0, 0, 0]
+        )
+        
+        # 保存边框信息，用于坐标转换
+        self.border_left = left_border
+        self.border_right = right_border
+        self.border_top = top_border
+        self.border_bottom = bottom_border
+        self.original_width = width
+        self.original_height = height
+        self.is_vertical = width < height
+        self.scaled_width = new_width
+        self.scaled_height = new_height
+        
+        return padded
+
+    def stop_button_clicked(self):
+        try:
+            self.running_task = False
+            running_process = self.running_process
+            if running_process:
+                ProcessManager.instance().terminate_by_process(running_process)
+            # 更新任务状态为待处理
+            if self.current_processing_task_index >= 0:
+                self.task_list_component.update_task_status(self.current_processing_task_index, TaskStatus.PENDING)
+        finally:    
+            self.running_process = None
+            self.run_button.setVisible(True)
+            self.stop_button.setVisible(False)
+
+    def run_button_clicked(self):
+        if not self.task_list_component.get_pending_tasks():
+            self.append_output(tr['SubtitleExtractorGUI']['OpenVideoFirst'])
+            return
+            
+        try:
+            # 获取所有待执行的任务
+            pending_tasks = self.task_list_component.get_pending_tasks()
+            if not pending_tasks:
+                return
+            
+            self.run_button.setVisible(False)
+            self.stop_button.setVisible(True)
+            # 开启后台线程处理视频
+            def task():
+                self.running_task = True
+                try:
+                    while self.running_task:
+                        try:
+                            pending_tasks = self.task_list_component.get_pending_tasks()
+                            if not pending_tasks:
+                                break
+                            pending_task = pending_tasks[0]
+                            # 更新当前处理的任务索引
+                            self.current_processing_task_index, task = pending_task
+                            if not self.load_video(task.path):
+                                self.append_output(tr['SubtitleExtractorGUI']['OpenVideoFailed'].format(task.path))
+                                self.task_list_component.update_task_status(self.current_processing_task_index, TaskStatus.FAILED)
+                                continue
+                            
+                            # 更新任务状态为运行中
+                            self.task_list_component.update_task_progress(self.current_processing_task_index, 1)
+                            
+                            # 选中当前任务
+                            self.task_list_component.select_task(self.current_processing_task_index)
+                            
+                            if self.video_cap:
+                                self.video_cap.release()
+                                self.video_cap = None
+                            
+                            
+                            # 获取字幕区域坐标（直接从视频显示组件获取）
+                            subtitle_area = self.video_display_component.get_original_coordinates()
+                            if not subtitle_area:
+                                self.append_output(tr['SubtitleExtractorGUI']['SelectSubtitleArea'])
+                                return
+                            self.append_output(f"{tr['SubtitleExtractorGUI']['SubtitleArea']}: {subtitle_area}")
+                            
+                            self.task_list_component.update_task_status(self.current_processing_task_index, TaskStatus.PROCESSING)
+                            process = self.run_subtitle_remover_process(task.path, task.output_path, subtitle_area)
+                            
+                            # 更新任务状态为已完成
+                            task = self.task_list_component.get_task(self.current_processing_task_index)
+                            if process.exitcode == 0 and task and task.status == TaskStatus.PROCESSING:
+                                self.progress_signal.emit(100, True)
+                                self.task_list_component.update_task_status(self.current_processing_task_index, TaskStatus.COMPLETED)
+                            else:
+                                self.task_list_component.update_task_status(self.current_processing_task_index, TaskStatus.FAILED)
+                            
+                        except Exception as e:
+                            print(e)
+                            self.append_output(f"Error: {e}")
+                            # 更新任务状态为失败
+                            if self.current_processing_task_index >= 0:
+                                self.task_list_component.update_task_status(self.current_processing_task_index, TaskStatus.FAILED)
+                            break
+                        finally:
+                            if self.video_cap:
+                                self.video_cap.release()
+                                self.video_cap = None
+                            time.sleep(1)
+                finally:
+                    self.running_task = False
+                    self.run_button.setVisible(True)
+                    self.stop_button.setVisible(False)
+
+            threading.Thread(target=task, daemon=True).start()
+        except Exception as e:
+            print(traceback.format_exc())
+            self.append_output(f"Error: {e}")
+            # 没有待执行的任务，恢复按钮状态
+            self.run_button.setVisible(True)
+            self.stop_button.setVisible(False)
+
+    @staticmethod
+    def remover_process(queue, video_path, output_path, subtitle_area):
+        """
+        在子进程中执行字幕提取的函数
+        
+        Args:
+            video_path: 视频文件路径
+            output_path: 输出文件路径
+            subtitle_area: 字幕区域坐标 (ymin, ymax, xmin, xmax)
+        """
+        sr = None
+        try:
+            from backend.main import SubtitleRemover
+            sr = SubtitleRemover(video_path, subtitle_area, True)
+            sr.video_out_path = output_path
+            sr.add_progress_listener(lambda progress, isFinished: SubtitleRemoverRemoteCall.remote_call_update_progress(queue, progress, isFinished))
+            sr.append_output = lambda *args: SubtitleRemoverRemoteCall.remote_call_append_log(queue, args)
+            sr.manage_process = lambda pid: SubtitleRemoverRemoteCall.remote_call_manage_process(queue, pid)
+            sr.update_preview_with_comp = lambda *args: SubtitleRemoverRemoteCall.remote_call_update_preview_with_comp(queue, args)
+            sr.run()
+        except Exception as e:
+            traceback.print_exc()
+            SubtitleRemoverRemoteCall.remote_call_catch_error(queue, e)
+        finally:
+            if sr:
+                sr.isFinished = True
+                sr.vsf_running = False
+            SubtitleRemoverRemoteCall.remote_call_finish(queue)
+            
+
+    # 修改run_subtitle_remover_process方法
+    def run_subtitle_remover_process(self, video_path, output_path, subtitle_area):
+        """
+        使用多进程执行字幕提取，并等待进程完成
+        
+        Args:
+            video_path: 视频文件路径
+            output_path: 输出文件路径
+            subtitle_area: 字幕区域坐标 (ymin, ymax, xmin, xmax)
+        """
+        subtitle_remover_remote_caller = SubtitleRemoverRemoteCall()
+        subtitle_remover_remote_caller.register_update_progress_callback(self.progress_signal.emit)
+        subtitle_remover_remote_caller.register_log_callback(self.append_log_signal.emit)
+        subtitle_remover_remote_caller.register_update_preview_with_comp_callback(self.update_preview_with_comp_signal.emit)
+        subtitle_remover_remote_caller.register_error_callback(self.task_error_signal.emit)
+        process = multiprocessing.Process(
+            target=HomeInterface.remover_process,
+            args=(subtitle_remover_remote_caller.queue, video_path, output_path, subtitle_area)
+        )
+        try:
+            if not self.running_task:
+                return process
+            process.start()
+            ProcessManager.instance().add_process(process)
+            self.running_process = process
+            process.join()
+            print(f"Process exited with code {process.exitcode}")
+        finally:
+            subtitle_remover_remote_caller.stop()
+        return process
+
+    @Slot()
+    def processing_finished(self):
+        pending_tasks = self.task_list_component.get_pending_tasks()
+        if pending_tasks:
+            # 还有待执行任务, 忽略
+            return
+        # 处理完成后恢复界面可用性
+        self.run_button.setVisible(True)
+        self.stop_button.setVisible(False)
+        self.se = None
+        # 重置视频滑块
+        self.video_slider.setValue(1)
+        # 重置当前处理任务索引
+        self.current_processing_task_index = -1
+
+    @Slot(int, bool)
+    def update_progress(self, progress_total, isFinished):
+        try:
+            pos = min(self.frame_count - 1, int(progress_total / 100 * self.frame_count))
+            if pos != self.video_slider.value():
+                self.video_slider.blockSignals(True)
+                self.video_slider.setValue(pos)
+                self.video_slider.blockSignals(False)
+            
+            # 更新任务进度
+            if self.current_processing_task_index >= 0:
+                self.task_list_component.update_task_progress(
+                    self.current_processing_task_index, 
+                    progress_total,
+                )
+            
+            # 检查是否完成
+            if isFinished:
+                self.processing_finished()
+        except Exception as e:
+            # 捕获任何异常，防止崩溃
+            print(f"更新进度时出错: {str(e)}")
+
+    @Slot(list)
+    def append_log(self, log):
+        self.append_output(*log)
+
+    def append_output(self, *args):
+        """添加文本到输出区域并控制滚动
+        Args:
+            *args: 要输出的内容，多个参数将用空格连接
+        """
+        # 将所有参数转换为字符串并用空格连接
+        text = ' '.join(str(arg) for arg in args).rstrip()
+        self.output_text.appendPlainText(text)
+        print(*args)  # 保持原始的 print 行为
+        # 如果启用了自动滚动，则滚动到底部
+        if self.auto_scroll:
+            scrollbar = self.output_text.verticalScrollBar()
+            scrollbar.setValue(scrollbar.maximum())
+
+    @Slot(list)
+    def update_preview_with_comp(self, args):
+        """更新执行时预览"""
+        frame_ori, frame_comp = args
+            
+        subtitle_area = self.video_display_component.get_original_coordinates()
+        if subtitle_area:
+            ymin, ymax, xmin, xmax = subtitle_area
+            if frame_ori is frame_comp:
+                frame_ori = frame_ori.copy()
+            cv2.rectangle(frame_ori, (xmin, ymin), (xmax, ymax), (0, 255, 0), 2)
+        preview_frame = cv2.hconcat([frame_ori, frame_comp])
+        # 先缩放图像
+        resized_frame = self._img_resize(preview_frame)
+        # 更新视频显示（这会同时保存current_pixmap）
+        self.video_display_component.update_video_display(resized_frame, draw_selection=False)
+        self.video_display_component.set_dragger_enabled(False)
+
+    @Slot(object)
+    def on_task_error(self, e):
+        self.append_output(tr['SubtitleExtractorGUI']['ErrorDuringProcessing'].format(str(e)))
+        if self.current_processing_task_index >= 0:
+            self.task_list_component.update_task_status(self.current_processing_task_index, TaskStatus.FAILED)
+
+    def load_video(self, video_path):
+        self.video_path = video_path
+        if self.video_cap:
+            self.video_cap.release()
+            self.video_cap = None
+        self.video_cap = cv2.VideoCapture(get_readable_path(self.video_path))
+        if not self.video_cap.isOpened():
+            return self.load_as_picture(video_path)
+        ret, frame = self.video_cap.read()
+        if not ret:
+            return self.load_as_picture(video_path)
+        self.frame_count = int(self.video_cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        self.frame_height = int(self.video_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        self.frame_width = int(self.video_cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        self.fps = self.video_cap.get(cv2.CAP_PROP_FPS)
+        
+        self.update_preview(frame)
+        self.video_display_component.load_selection_ratio()
+        self.video_slider.setMaximum(self.frame_count)
+        self.video_slider.setValue(1)
+        self.video_display_component.set_dragger_enabled(True)
+        return True
+
+    def load_as_picture(self, path):
+        if not is_image_file(path):
+            return False
+        self.video_path = path
+        self.video_cap = None
+        frame = read_image(get_readable_path(path))
+        if frame is None:
+            return False
+        self.frame_count = 1
+        self.frame_height = frame.shape[0]
+        self.frame_width = frame.shape[1]
+        self.fps = 1
+        self.update_preview(frame)
+        self.video_display_component.load_selection_ratio()
+        self.video_slider.setMaximum(self.frame_count)
+        self.video_slider.setValue(1)
+        self.video_display_component.set_dragger_enabled(True)
+        return True
+
+
+    def open_file(self):
+        files, _ = QtWidgets.QFileDialog.getOpenFileNames(
+            self,
+            tr['SubtitleExtractorGUI']['Open'],
+            "",
+            "All Files (*.*);;MP4 Files (*.mp4);;FLV Files (*.flv);;WMV Files (*.wmv);;AVI Files (*.avi)"
+        )
+        if files:
+            files_loaded = []
+            # 倒序打开, 确保第一个视频截图显示在屏幕上
+            for path in reversed(files):
+                if self.load_video(path):
+                    self.append_output(f"{tr['SubtitleExtractorGUI']['OpenVideoSuccess']}: {path}")
+                    files_loaded.append(path)
+                else:
+                    self.append_output(f"{tr['SubtitleExtractorGUI']['OpenVideoFailed']}: {path}")
+            # 正序添加, 确保任务列表顺序一致
+            for path in reversed(files_loaded):
+                # 添加到任务列表
+                if is_image_file(path):
+                    output_path = os.path.abspath(os.path.join(os.path.dirname(path), f'{Path(path).stem}_no_sub.png'))
+                else:
+                    output_path = os.path.abspath(os.path.join(os.path.dirname(path), f'{Path(path).stem}_no_sub.mp4'))
+                self.task_list_component.add_task(path, output_path)
+            self.task_list_component.select_task(max(0, self.task_list_component.find_task_index_by_path(path)))
+
+    def closeEvent(self, event):
+        """窗口关闭时断开信号连接"""
+        try:
+            # 断开信号连接
+            self.progress_signal.disconnect(self.update_progress)
+            self.append_log_signal.disconnect(self.append_log)
+            self.update_preview_with_comp_signal.disconnect(self.update_preview_with_comp)
+            self.task_error_signal.disconnect(self.on_task_error)
+            
+            # 释放视频资源
+            if self.video_cap:
+                self.video_cap.release()
+                self.video_cap = None
+                
+            # 确保所有子进程都已终止
+            ProcessManager.instance().terminate_all()
+        except Exception as e:
+            print(f"关闭窗口时出错: {str(e)}")
+        super().closeEvent(event)
+    

ui/icon/my_fluent_icon.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+from qfluentwidgets import getIconColor, Theme, FluentIconBase
+
+
+class MyFluentIcon(FluentIconBase, Enum):
+    Stop = "stop"
+
+    def path(self, theme=Theme.AUTO):
+        # getIconColor() return "white" or "black" according to current theme
+        return f'./ui/icon/{self.value}_{getIconColor(theme)}.svg'

ui/icon/stop_black.svg

@@ -0,0 +1 @@
+<?xml version="1.0" standalone="no"?><!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd"><svg t="1747016366598" class="icon" viewBox="0 0 1024 1024" version="1.1" xmlns="http://www.w3.org/2000/svg" p-id="2793" xmlns:xlink="http://www.w3.org/1999/xlink" width="200" height="200"><path d="M832 992H192a160 160 0 0 1-160-160V192a160 160 0 0 1 160-160h640a160 160 0 0 1 160 160v640a160 160 0 0 1-160 160zM192 96a96 96 0 0 0-96 96v640a96 96 0 0 0 96 96h640a96 96 0 0 0 96-96V192a96 96 0 0 0-96-96z" fill="#000000" p-id="2794"></path></svg>

ui/icon/stop_white.svg

@@ -0,0 +1 @@
+<?xml version="1.0" standalone="no"?><!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd"><svg t="1747016366598" class="icon" viewBox="0 0 1024 1024" version="1.1" xmlns="http://www.w3.org/2000/svg" p-id="2793" xmlns:xlink="http://www.w3.org/1999/xlink" width="200" height="200"><path d="M832 992H192a160 160 0 0 1-160-160V192a160 160 0 0 1 160-160h640a160 160 0 0 1 160 160v640a160 160 0 0 1-160 160zM192 96a96 96 0 0 0-96 96v640a96 96 0 0 0 96 96h640a96 96 0 0 0 96-96V192a96 96 0 0 0-96-96z" fill="#ffffff" p-id="2794"></path></svg>

ui/setting_interface.py

@@ -0,0 +1,70 @@
+from PySide6 import QtWidgets
+from qfluentwidgets import (FluentWindow, PushButton, Slider, ProgressBar, PlainTextEdit,
+                          setTheme, Theme, FluentIcon, CardWidget, SettingCardGroup,
+                          ComboBoxSettingCard, SwitchSettingCard, RangeSettingCard,
+                          PushSettingCard, PrimaryPushSettingCard, OptionsSettingCard,
+                          FolderListSettingCard, HyperlinkCard, ColorSettingCard, 
+                          CustomColorSettingCard)
+from backend.config import config, tr, HARDWARD_ACCELERATION_OPTION
+from backend.tools.constant import InpaintMode, SubtitleDetectMode
+
+class SettingInterface(QtWidgets.QVBoxLayout):
+
+    def __init__(self, parent):
+        super().__init__()
+        self.setContentsMargins(16, 16, 16, 16)
+        
+        # 界面语言设置
+        self.interface_combo = ComboBoxSettingCard(
+            configItem=config.interface,
+            icon=FluentIcon.LANGUAGE,
+            title=tr["SubtitleExtractorGUI"]["InterfaceLanguage"],
+            content="",
+            parent=parent,
+            texts=config.intefaceTexts.keys(),
+        )
+        self.addWidget(self.interface_combo)
+        
+        # 处理模式设置
+        self.inpaint_mode_combo = ComboBoxSettingCard(
+            configItem=config.inpaintMode,
+            icon=FluentIcon.GLOBE,
+            title=tr["SubtitleExtractorGUI"]["InpaintMode"],
+            content="",
+            parent=parent,
+            texts=[list(tr['InpaintMode'].values())[i] for i,_ in enumerate(config.inpaintMode.validator.options)],
+        )
+        self.inpaint_mode_combo.setToolTip(tr["SubtitleExtractorGUI"]["InpaintModeDesc"])
+        self.addWidget(self.inpaint_mode_combo)
+
+        self.subtitle_detect_model_combo = ComboBoxSettingCard(
+            configItem=config.subtitleDetectMode,
+            icon=FluentIcon.SEARCH,
+            title=tr["SubtitleExtractorGUI"]["SubtitleDetectMode"],
+            content="",
+            parent=parent,
+            texts=[list(tr['SubtitleDetectMode'].values())[i] for i,_ in enumerate(config.subtitleDetectMode.validator.options)],
+        )
+        self.addWidget(self.subtitle_detect_model_combo)
+
+        # 是否启用硬件加速
+        self.hardware_acceleration = SwitchSettingCard(
+            configItem=config.hardwareAcceleration,
+            icon=FluentIcon.SPEED_HIGH, 
+            title=tr["Setting"]["HardwareAcceleration"],
+            content=tr["Setting"]["HardwareAccelerationDesc"],
+            parent=parent
+        )
+        self.addWidget(self.hardware_acceleration)
+        # 如果硬件加速选项被禁用, 设置硬件加速为False并只读
+        if not HARDWARD_ACCELERATION_OPTION:
+            self.hardware_acceleration.switchButton.setChecked(False)
+            self.hardware_acceleration.switchButton.setEnabled(False)
+            config.set(config.hardwareAcceleration, False)
+        # 添加一些空间
+        self.addStretch(1)
+    
+    def reset_setting(self):
+        """重置所有设置为默认值"""
+        # 这里需要实现重置逻辑
+        pass