import os
import sys
import tempfile
import shutil
import random
import cv2
import numpy as np
from PIL import Image, ImageDraw
import subprocess
from PyQt5.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout,
QHBoxLayout, QPushButton, QLabel, QFileDialog,
QMessageBox, QGroupBox, QProgressBar, QFrame, QComboBox)
from PyQt5.QtCore import Qt, QThread, pyqtSignal, QThreadPool, QRunnable
from PyQt5.QtGui import QPixmap, QIcon
# 定义需要替换的帧列表
REPLACE_FRAMES = [
10, 20, 30, 40, 50, 60, 250, 260, 270, 280, 290, 300,
490, 500, 510, 520, 530, 540, 730, 740, 750, 760, 770, 780,
970, 980, 990, 1000, 1010, 1020, 1210, 1220, 1230, 1240, 1250, 1260,
1450, 1460, 1470, 1480, 1490, 1500, 1690, 1700, 1710, 1720, 1730, 1740,
1930, 1940, 1950, 1960, 1970, 1980, 2170, 2180, 2190, 2200, 2210, 2220,
2410, 2420, 2430, 2440, 2450, 2460, 2650, 2660, 2670, 2680, 2690, 2700,
2890, 2900, 2910, 2920, 2930, 2940, 3130, 3140, 3150, 3160, 3170, 3180,
3370, 3380, 3390, 3400, 3410, 3420, 3610, 3620, 3630, 3640, 3650, 3660,
3850, 3860, 3870, 3880, 3890, 3900, 4090, 4100, 4110, 4120, 4130, 4140,
4330, 4340, 4350, 4360, 4370, 4380, 4570, 4580, 4590, 4600, 4610, 4620,
4810, 4820, 4830, 4840, 4850, 4860, 5050, 5060, 5070, 5080, 5090, 5100,
5290, 5300, 5310, 5320, 5330, 5340, 5530, 5540, 5550, 5560, 5570, 5580,
5770, 5780, 5790, 5800, 5810, 5820, 6010, 6020, 6030, 6040, 6050, 6060,
6250, 6260, 6270, 6280, 6290, 6300, 6490, 6500, 6510, 6520, 6530, 6540,
6730, 6740, 6750, 6760, 6770, 6780, 6970, 6980, 6990, 7000, 7010, 7020,
7210, 7220, 7230, 7240, 7250, 7260, 7450, 7460, 7470, 7480, 7490, 7500,
7690, 7700, 7710, 7720, 7730, 7740, 7930, 7940, 7950, 7960, 7970, 7980
]
class FrameProcessingTask(QRunnable):
"""处理单个帧的任务"""
def __init__(self, frame, frame_number, output_dir):
super().__init__()
self.frame = frame
self.frame_number = frame_number
self.output_dir = output_dir
def run(self):
# 调整分辨率为1080x1920
frame_resized = cv2.resize(self.frame, (1080, 1920))
frame_path = os.path.join(self.output_dir, f"{self.frame_number:04d}.jpg")
cv2.imwrite(frame_path, frame_resized, [cv2.IMWRITE_JPEG_QUALITY, 95])
class VideoProcessor(QThread):
progress_updated = pyqtSignal(int)
status_updated = pyqtSignal(str)
finished = pyqtSignal(bool, str)
error_occurred = pyqtSignal(str)
def __init__(self, mode, video_a_path, video_b_path=None, thread_count=4):
super().__init__()
self.mode = mode
self.video_a_path = video_a_path
self.video_b_path = video_b_path
self.temp_dir = tempfile.mkdtemp()
self.output_path = ""
self.total_frames = 0
self.fps = 0
self.duration = 0
self.cancel_requested = False
self.thread_count = thread_count
self.thread_pool = QThreadPool()
self.thread_pool.setMaxThreadCount(thread_count)
def run(self):
try:
# 获取视频基本信息
self.get_video_info(self.video_a_path)
if self.mode == "doodle":
self.process_doodle_mode()
elif self.mode == "shoot":
self.process_shoot_mode()
self.cleanup()
if not self.cancel_requested:
self.finished.emit(True, self.output_path)
except Exception as e:
self.status_updated.emit(f"错误: {str(e)}")
self.error_occurred.emit(str(e))
self.cleanup()
if not self.cancel_requested:
self.finished.emit(False, str(e))
def cancel_processing(self):
"""取消处理过程"""
self.cancel_requested = True
self.status_updated.emit("处理已取消")
self.cleanup()
def get_video_info(self, video_path):
"""获取视频的基本信息"""
cap = cv2.VideoCapture(video_path)
if not cap.isOpened():
raise Exception("无法打开视频文件")
self.fps = cap.get(cv2.CAP_PROP_FPS)
self.total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
self.duration = self.total_frames / self.fps if self.fps > 0 else 0
cap.release()
if self.total_frames == 0:
raise Exception("视频文件中没有帧")
def process_doodle_mode(self):
# 步骤1: 提取音频
self.status_updated.emit("提取音频...")
audio_path = os.path.join(self.temp_dir, "audio.aac")
self.extract_audio(self.video_a_path, audio_path)
if self.cancel_requested: return
self.progress_updated.emit(5)
# 步骤2: 处理视频帧
self.status_updated.emit("处理视频帧...")
frames_dir = os.path.join(self.temp_dir, "frames_a")
os.makedirs(frames_dir, exist_ok=True)
self.process_video_frames_optimized(self.video_a_path, frames_dir)
if self.cancel_requested: return
self.progress_updated.emit(30)
# 步骤3: 替换指定帧为涂鸦图片
self.status_updated.emit("替换指定帧...")
self.replace_frames_with_doodles(frames_dir)
if self.cancel_requested: return
self.progress_updated.emit(60)
# 步骤4: 合成视频B
self.status_updated.emit("合成视频...")
video_b_path = os.path.join(self.temp_dir, "video_b.mp4")
self.create_video_from_frames(frames_dir, video_b_path, self.fps)
if self.cancel_requested: return
self.progress_updated.emit(70)
# 步骤5: 生成背景视频并叠加
self.status_updated.emit("生成背景...")
bg_video_path = os.path.join(self.temp_dir, "background.mp4")
self.create_background_video(bg_video_path, self.duration)
if self.cancel_requested: return
self.progress_updated.emit(80)
# 步骤6: 最终处理
self.status_updated.emit("最终处理...")
self.output_path = self.get_output_path("OK.mp4")
self.overlay_videos(bg_video_path, video_b_path, self.output_path)
if self.cancel_requested: return
self.progress_updated.emit(90)
# 步骤7: 添加处理后的音频
self.status_updated.emit("添加音频...")
self.add_processed_audio(self.output_path, audio_path, self.output_path)
if self.cancel_requested: return
self.progress_updated.emit(95)
# 步骤8: 污染元数据
self.status_updated.emit("处理元数据...")
self.pollute_metadata(self.output_path)
if self.cancel_requested: return
self.progress_updated.emit(100)
self.status_updated.emit("处理完成!")
def process_shoot_mode(self):
# 步骤1: 提取音频
self.status_updated.emit("提取音频...")
audio_path = os.path.join(self.temp_dir, "audio.aac")
self.extract_audio(self.video_a_path, audio_path)
if self.cancel_requested: return
self.progress_updated.emit(5)
# 步骤2: 处理视频A帧
self.status_updated.emit("处理视频A...")
frames_dir_a = os.path.join(self.temp_dir, "frames_a")
os.makedirs(frames_dir_a, exist_ok=True)
self.process_video_frames_optimized(self.video_a_path, frames_dir_a)
if self.cancel_requested: return
self.progress_updated.emit(20)
# 步骤3: 处理视频B
self.status_updated.emit("处理视频B...")
frames_dir_b = os.path.join(self.temp_dir, "frames_b")
os.makedirs(frames_dir_b, exist_ok=True)
# 调整视频B时长与视频A一致
adjusted_b_path = os.path.join(self.temp_dir, "adjusted_b.mp4")
self.adjust_video_duration(self.video_b_path, adjusted_b_path, self.duration)
if self.cancel_requested: return
# 处理视频B帧
self.process_video_frames_optimized(adjusted_b_path, frames_dir_b)
if self.cancel_requested: return
self.progress_updated.emit(40)
# 步骤4: 替换指定帧
self.status_updated.emit("替换帧...")
self.replace_frames_from_b(frames_dir_a, frames_dir_b)
if self.cancel_requested: return
self.progress_updated.emit(70)
# 步骤5: 合成视频C
self.status_updated.emit("合成视频...")
video_c_path = os.path.join(self.temp_dir, "video_c.mp4")
self.create_video_from_frames(frames_dir_a, video_c_path, self.fps)
if self.cancel_requested: return
self.progress_updated.emit(80)
# 步骤6: 生成背景视频并叠加
self.status_updated.emit("生成背景...")
bg_video_path = os.path.join(self.temp_dir, "background.mp4")
self.create_background_video(bg_video_path, self.duration)
if self.cancel_requested: return
self.progress_updated.emit(85)
# 步骤7: 最终处理
self.status_updated.emit("最终处理...")
self.output_path = self.get_output_path("OK.mp4")
self.overlay_videos(bg_video_path, video_c_path, self.output_path)
if self.cancel_requested: return
self.progress_updated.emit(90)
# 步骤8: 添加处理后的音频
self.status_updated.emit("添加音频...")
self.add_processed_audio(self.output_path, audio_path, self.output_path)
if self.cancel_requested: return
self.progress_updated.emit(95)
# 步骤9: 污染元数据
self.status_updated.emit("处理元数据...")
self.pollute_metadata(self.output_path)
if self.cancel_requested: return
self.progress_updated.emit(100)
self.status_updated.emit("处理完成!")
def extract_audio(self, video_path, audio_path):
"""提取音频 - 避免黑框"""
if self.cancel_requested: return
try:
command = [
'ffmpeg', '-i', video_path, '-vn', '-acodec', 'copy', audio_path, '-y'
]
# 避免弹出黑框
startupinfo = None
if sys.platform == "win32":
startupinfo = subprocess.STARTUPINFO()
startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
startupinfo.wShowWindow = 0 # 0 = SW_HIDE
subprocess.run(command, check=True, capture_output=True, startupinfo=startupinfo)
except subprocess.CalledProcessError as e:
raise Exception(f"音频提取失败: {str(e)}")
except FileNotFoundError:
raise Exception("未找到FFmpeg，请确保已安装FFmpeg并添加到系统路径")
def process_video_frames_optimized(self, video_path, output_dir):
"""优化版的视频帧处理 - 使用多线程"""
if self.cancel_requested: return
cap = cv2.VideoCapture(video_path)
if not cap.isOpened():
raise Exception("无法打开视频文件")
frame_count = 0
success = True
# 确保输出目录存在
os.makedirs(output_dir, exist_ok=True)
while success and not self.cancel_requested:
success, frame = cap.read()
if not success:
break
frame_count += 1
# 创建任务
task = FrameProcessingTask(frame.copy(), frame_count, output_dir)
self.thread_pool.start(task)
# 每处理50帧更新一次进度
if frame_count % 50 == 0:
progress = int(frame_count * 100 / self.total_frames)
self.progress_updated.emit(progress)
# 等待所有任务完成
self.thread_pool.waitForDone()
cap.release()
if frame_count == 0 and not self.cancel_requested:
raise Exception("视频文件中没有帧")
else:
# 最后更新一次进度
self.progress_updated.emit(int(frame_count * 100 / self.total_frames))
def replace_frames_with_doodles(self, frames_dir):
"""用涂鸦图片替换指定帧"""
if self.cancel_requested: return
frame_files = sorted([f for f in os.listdir(frames_dir) if f.endswith('.jpg')],
key=lambda x: int(x.split('.')[0]))
# 只处理存在的帧
valid_frames = [f for f in REPLACE_FRAMES if f <= len(frame_files)]
if not valid_frames:
return
for i, frame_num in enumerate(valid_frames):
if self.cancel_requested: return
doodle_img = self.generate_doodle_image()
frame_path = os.path.join(frames_dir, f"{frame_num:04d}.jpg")
doodle_img.save(frame_path, quality=95)
# 更新进度
if i % 10 == 0: # 每10帧更新一次进度
progress = 30 + int((i + 1) * 30 / len(valid_frames))
self.progress_updated.emit(progress)
def replace_frames_from_b(self, frames_dir_a, frames_dir_b):
"""从视频B替换帧到视频A"""
if self.cancel_requested: return
frame_files_a = sorted([f for f in os.listdir(frames_dir_a) if f.endswith('.jpg')],
key=lambda x: int(x.split('.')[0]))
# 只处理存在的帧
valid_frames = [f for f in REPLACE_FRAMES if f <= len(frame_files_a)]
if not valid_frames:
return
for i, frame_num in enumerate(valid_frames):
if self.cancel_requested: return
# 从视频B获取对应帧
frame_b_path = os.path.join(frames_dir_b, f"{frame_num:04d}.jpg")
if os.path.exists(frame_b_path):
# 替换视频A的帧
frame_a_path = os.path.join(frames_dir_a, f"{frame_num:04d}.jpg")
shutil.copyfile(frame_b_path, frame_a_path)
# 更新进度
if i % 10 == 0: # 每10帧更新一次进度
progress = 40 + int((i + 1) * 30 / len(valid_frames))
self.progress_updated.emit(progress)
def generate_doodle_image(self):
"""生成随机涂鸦图片"""
width, height = 1080, 1920
img = Image.new('RGB', (width, height), color=(255, 255, 255))
draw = ImageDraw.Draw(img)
# 随机绘制一些线条和形状
for _ in range(random.randint(5, 15)):
x1 = random.randint(0, width)
y1 = random.randint(0, height)
x2 = random.randint(0, width)
y2 = random.randint(0, height)
color = (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255))
draw.line([(x1, y1), (x2, y2)], fill=color, width=random.randint(1, 5))
for _ in range(random.randint(3, 8)):
x = random.randint(0, width)
y = random.randint(0, height)
size = random.randint(20, 200)
color = (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255))
draw.rectangle([x, y, x+size, y+size], fill=color, outline=None)
for _ in range(random.randint(2, 5)):
x = random.randint(0, width)
y = random.randint(0, height)
radius = random.randint(10, 100)
color = (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255))
draw.ellipse([x, y, x+radius, y+radius], fill=color, outline=None)
return img
def create_video_from_frames(self, frames_dir, output_path, fps):
"""从帧创建视频 - 避免黑框"""
if self.cancel_requested: return
try:
frame_pattern = os.path.join(frames_dir, '%04d.jpg')
command = [
'ffmpeg', '-r', str(fps), '-i', frame_pattern,
'-c:v', 'libx264', '-pix_fmt', 'yuv420p', '-crf', '18',
'-preset', 'fast', output_path, '-y'
]
# 避免弹出黑框
startupinfo = None
if sys.platform == "win32":
startupinfo = subprocess.STARTUPINFO()
startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
startupinfo.wShowWindow = 0 # 0 = SW_HIDE
subprocess.run(command, check=True, capture_output=True, startupinfo=startupinfo)
except subprocess.CalledProcessError as e:
raise Exception(f"视频合成失败: {str(e)}")
def create_background_video(self, output_path, duration):
"""创建背景视频 - 避免黑框"""
if self.cancel_requested: return
try:
# 使用更简单可靠的背景生成方法
command = [
'ffmpeg', '-f', 'lavfi',
'-i', f'color=black:size=1080x2336:rate={self.fps}:duration={duration}',
'-c:v', 'libx264', '-pix_fmt', 'yuv420p', '-crf', '23',
'-preset', 'fast', output_path, '-y'
]
# 避免弹出黑框
startupinfo = None
if sys.platform == "win32":
startupinfo = subprocess.STARTUPINFO()
startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
startupinfo.wShowWindow = 0 # 0 = SW_HIDE
subprocess.run(command, check=True, capture_output=True, startupinfo=startupinfo)
except subprocess.CalledProcessError as e:
raise Exception(f"背景视频创建失败: {str(e)}")
def overlay_videos(self, bg_video_path, fg_video_path, output_path):
"""叠加视频 - 避免黑框"""
if self.cancel_requested: return
try:
command = [
'ffmpeg', '-i', bg_video_path, '-i', fg_video_path,
'-filter_complex',
'[1]scale=1080:1920:force_original_aspect_ratio=decrease[fg];' +
'[0][fg]overlay=(W-w)/2:(H-h)/2:format=auto:alpha=0.98',
'-c:v', 'libx264', '-pix_fmt', 'yuv420p', '-crf', '18',
'-preset', 'fast', output_path, '-y'
]
# 避免弹出黑框
startupinfo = None
if sys.platform == "win32":
startupinfo = subprocess.STARTUPINFO()
startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
startupinfo.wShowWindow = 0 # 0 = SW_HIDE
subprocess.run(command, check=True, capture_output=True, startupinfo=startupinfo)
except subprocess.CalledProcessError as e:
raise Exception(f"视频叠加失败: {str(e)}")
def add_processed_audio(self, video_path, audio_path, output_path):
"""添加处理后的音频 - 避免黑框"""
if self.cancel_requested: return
try:
temp_output = os.path.join(self.temp_dir, "temp_output.mp4")
command = [
'ffmpeg', '-i', video_path, '-i', audio_path,
'-c:v', 'copy', '-c:a', 'aac', '-b:a', '192k',
'-map', '0:v:0', '-map', '1:a:0', '-shortest',
temp_output, '-y'
]
# 避免弹出黑框
startupinfo = None
if sys.platform == "win32":
startupinfo = subprocess.STARTUPINFO()
startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
startupinfo.wShowWindow = 0 # 0 = SW_HIDE
subprocess.run(command, check=True, capture_output=True, startupinfo=startupinfo)
shutil.move(temp_output, output_path)
except subprocess.CalledProcessError as e:
raise Exception(f"音频添加失败: {str(e)}")
def adjust_video_duration(self, video_path, output_path, target_duration):
"""调整视频时长 - 避免黑框"""
if self.cancel_requested: return
try:
# 获取当前视频时长
cap = cv2.VideoCapture(video_path)
fps = cap.get(cv2.CAP_PROP_FPS)
frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
current_duration = frame_count / fps if fps > 0 else 0
cap.release()
if current_duration <= 0:
raise Exception("无法获取视频时长")
# 计算速度因子
speed_factor = current_duration / target_duration
command = [
'ffmpeg', '-i', video_path,
'-filter:v', f'setpts={speed_factor}*PTS',
'-an', output_path, '-y'
]
# 避免弹出黑框
startupinfo = None
if sys.platform == "win32":
startupinfo = subprocess.STARTUPINFO()
startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
startupinfo.wShowWindow = 0 # 0 = SW_HIDE
subprocess.run(command, check=True, capture_output=True, startupinfo=startupinfo)
except subprocess.CalledProcessError as e:
raise Exception(f"视频时长调整失败: {str(e)}")
def pollute_metadata(self, video_path):
"""污染元数据 - 避免黑框"""
if self.cancel_requested: return
try:
# 使用FFmpeg直接添加元数据
temp_output = os.path.join(self.temp_dir, "temp_metadata.mp4")
# 生成随机元数据
creation_time = self.random_date()
location = self.random_location()
command = [
'ffmpeg', '-i', video_path,
'-metadata', f'creation_time={creation_time}',
'-metadata', f'location={location}',
'-metadata', 'make=RandomCamera',
'-metadata', 'model=RandomModel',
'-metadata', 'software=Video Processor v1.0',
'-c', 'copy', temp_output, '-y'
]
# 避免弹出黑框
startupinfo = None
if sys.platform == "win32":
startupinfo = subprocess.STARTUPINFO()
startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
startupinfo.wShowWindow = 0 # 0 = SW_HIDE
subprocess.run(command, check=True, capture_output=True, startupinfo=startupinfo)
shutil.move(temp_output, video_path)
except (subprocess.CalledProcessError, FileNotFoundError):
# 如果失败，跳过元数据污染
pass
def random_date(self):
"""生成随机日期"""
year = random.randint(2010, 2023)
month = random.randint(1, 12)
day = random.randint(1, 28)
hour = random.randint(0, 23)
minute = random.randint(0, 59)
second = random.randint(0, 59)
return f"{year:04d}-{month:02d}-{day:02d}T{hour:02d}:{minute:02d}:{second:02d}Z"
def random_location(self):
"""生成随机位置"""
locations = [
"40.7128° N, 74.0060° W", # 纽约
"34.0522° N, 118.2437° W", # 洛杉矶
"51.5074° N, 0.1278° W", # 伦敦
"48.8566° N, 2.3522° E", # 巴黎
"35.6762° N, 139.6503° E", # 东京
"39.9042° N, 116.4074° E", # 北京
"-33.8688° N, 151.2093° E", # 悉尼
"55.7558° N, 37.6173° E" # 莫斯科
]
return random.choice(locations)
def get_output_path(self, base_name):
"""获取输出路径，避免重名"""
counter = 0
name, ext = os.path.splitext(base_name)
output_path = base_name
while os.path.exists(output_path):
counter += 1
output_path = f"{name}_{counter}{ext}"
return output_path
def cleanup(self):
"""清理临时文件"""
if os.path.exists(self.temp_dir):
try:
shutil.rmtree(self.temp_dir)
except:
pass # 忽略清理错误
class MainWindow(QMainWindow):
def __init__(self):
super().__init__()
self.setWindowTitle("视频处理工具")
self.setGeometry(100, 100, 800, 700)
# 设置图标
if hasattr(sys, '_MEIPASS'):
# 打包后的路径
icon_path = os.path.join(sys._MEIPASS, 'app.ico')
else:
# 开发时的路径
icon_path = 'app.ico'
if os.path.exists(icon_path):
self.setWindowIcon(QIcon(icon_path))
self.central_widget = QWidget()
self.setCentralWidget(self.central_widget)
self.layout = QVBoxLayout()
self.central_widget.setLayout(self.layout)
self.setup_ui()
self.video_a_path = ""
self.video_b_path = ""
self.processor = None
self.thread_count = 4 # 默认线程数
def setup_ui(self):
# 标题
title_label = QLabel("视频处理工具")
title_label.setAlignment(Qt.AlignCenter)
title_label.setStyleSheet("font-size: 20px; font-weight: bold; margin: 15px;")
self.layout.addWidget(title_label)
# 线程选择框
thread_layout = QHBoxLayout()
thread_label = QLabel("线程数量:")
thread_layout.addWidget(thread_label)
self.thread_combo = QComboBox()
self.thread_combo.addItems(["1", "2", "4", "8"])
self.thread_combo.setCurrentText("4")
self.thread_combo.currentIndexChanged.connect(self.update_thread_count)
thread_layout.addWidget(self.thread_combo)
self.layout.addLayout(thread_layout)
# 二维码区域
qr_frame = QFrame()
qr_frame.setFrameShape(QFrame.StyledPanel)
qr_layout = QVBoxLayout()
qr_label = QLabel("扫描二维码获取更多信息")
qr_label.setAlignment(Qt.AlignCenter)
qr_layout.addWidget(qr_label)
# 加载二维码图片
if hasattr(sys, '_MEIPASS'):
qr_path = os.path.join(sys._MEIPASS, 'qrcode.png')
else:
qr_path = 'qrcode.png'
if os.path.exists(qr_path):
qr_pixmap = QPixmap(qr_path)
qr_pixmap = qr_pixmap.scaled(150, 150, Qt.KeepAspectRatio, Qt.SmoothTransformation)
qr_image_label = QLabel()
qr_image_label.setPixmap(qr_pixmap)
qr_image_label.setAlignment(Qt.AlignCenter)
qr_layout.addWidget(qr_image_label)
qr_frame.setLayout(qr_layout)
qr_frame.setMaximumHeight(200)
self.layout.addWidget(qr_frame)
# 涂鸦模式组
doodle_group = QGroupBox("涂鸦模式")
doodle_group.setStyleSheet("QGroupBox { font-weight: bold; }")
doodle_layout = QVBoxLayout()
doodle_btn_layout = QHBoxLayout()
self.doodle_video_a_btn = QPushButton("选择视频A")
self.doodle_video_a_btn.clicked.connect(lambda: self.select_video("doodle_a"))
self.doodle_video_a_label = QLabel("未选择视频")
self.doodle_video_a_label.setWordWrap(True)
doodle_btn_layout.addWidget(self.doodle_video_a_btn)
doodle_btn_layout.addWidget(self.doodle_video_a_label)
doodle_layout.addLayout(doodle_btn_layout)
self.doodle_process_btn = QPushButton("开始处理")
self.doodle_process_btn.clicked.connect(lambda: self.start_processing("doodle"))
doodle_layout.addWidget(self.doodle_process_btn)
doodle_group.setLayout(doodle_layout)
self.layout.addWidget(doodle_group)
# 实拍模式组
shoot_group = QGroupBox("实拍模式")
shoot_group.setStyleSheet("QGroupBox { font-weight: bold; }")
shoot_layout = QVBoxLayout()
shoot_btn_layout_a = QHBoxLayout()
self.shoot_video_a_btn = QPushButton("选择视频A")
self.shoot_video_a_btn.clicked.connect(lambda: self.select_video("shoot_a"))
self.shoot_video_a_label = QLabel("未选择视频")
self.shoot_video_a_label.setWordWrap(True)
shoot_btn_layout_a.addWidget(self.shoot_video_a_btn)
shoot_btn_layout_a.addWidget(self.shoot_video_a_label)
shoot_layout.addLayout(shoot_btn_layout_a)
shoot_btn_layout_b = QHBoxLayout()
self.shoot_video_b_btn = QPushButton("选择视频B")
self.shoot_video_b_btn.clicked.connect(lambda: self.select_video("shoot_b"))
self.shoot_video_b_label = QLabel("未选择视频")
self.shoot_video_b_label.setWordWrap(True)
shoot_btn_layout_b.addWidget(self.shoot_video_b_btn)
shoot_btn_layout_b.addWidget(self.shoot_video_b_label)
shoot_layout.addLayout(shoot_btn_layout_b)
self.shoot_process_btn = QPushButton("开始处理")
self.shoot_process_btn.clicked.connect(lambda: self.start_processing("shoot"))
shoot_layout.addWidget(self.shoot_process_btn)
shoot_group.setLayout(shoot_layout)
self.layout.addWidget(shoot_group)
# 进度条
self.progress_bar = QProgressBar()
self.progress_bar.setVisible(False)
self.layout.addWidget(self.progress_bar)
# 状态标签
self.status_label = QLabel("就绪")
self.status_label.setAlignment(Qt.AlignCenter)
self.layout.addWidget(self.status_label)
# 取消按钮
self.cancel_btn = QPushButton("取消处理")
self.cancel_btn.setVisible(False)
self.cancel_btn.clicked.connect(self.cancel_processing)
self.layout.addWidget(self.cancel_btn)
# 底部信息
info_label = QLabel("© 2023 视频处理工具 | 支持格式: MP4, AVI, MOV, MKV")
info_label.setAlignment(Qt.AlignCenter)
info_label.setStyleSheet("color: gray; font-size: 10px; margin-top: 10px;")
self.layout.addWidget(info_label)
def update_thread_count(self):
"""更新线程数量设置"""
self.thread_count = int(self.thread_combo.currentText())
def select_video(self, mode):
file_path, _ = QFileDialog.getOpenFileName(
self, "选择视频文件", "",
"视频文件 (*.mp4 *.avi *.mov *.mkv);;所有文件 (*.*)"
)
if file_path:
if mode == "doodle_a":
self.video_a_path = file_path
self.doodle_video_a_label.setText(os.path.basename(file_path))
elif mode == "shoot_a":
self.video_a_path = file_path
self.shoot_video_a_label.setText(os.path.basename(file_path))
elif mode == "shoot_b":
self.video_b_path = file_path
self.shoot_video_b_label.setText(os.path.basename(file_path))
def start_processing(self, mode):
if mode == "doodle":
if not self.video_a_path:
QMessageBox.warning(self, "警告", "请先选择视频A!")
return
self.processor = VideoProcessor("doodle", self.video_a_path, thread_count=self.thread_count)
elif mode == "shoot":
if not self.video_a_path or not self.video_b_path:
QMessageBox.warning(self, "警告", "请先选择视频A和视频B!")
return
self.processor = VideoProcessor("shoot", self.video_a_path, self.video_b_path, thread_count=self.thread_count)
# 连接信号和槽
self.processor.progress_updated.connect(self.update_progress)
self.processor.status_updated.connect(self.update_status)
self.processor.finished.connect(self.processing_finished)
self.processor.error_occurred.connect(self.handle_error)
# 禁用按钮
self.set_buttons_enabled(False)
# 显示进度条和取消按钮
self.progress_bar.setVisible(True)
self.cancel_btn.setVisible(True)
self.progress_bar.setValue(0)
# 开始处理
self.processor.start()
def update_progress(self, value):
self.progress_bar.setValue(value)
def update_status(self, message):
# 只显示状态消息，不显示详细描述
self.status_label.setText(message)
def processing_finished(self, success, message):
self.set_buttons_enabled(True)
self.cancel_btn.setVisible(False)
if success:
self.status_label.setText("处理完成!")
QMessageBox.information(self, "成功", f"视频处理完成! 输出文件: {message}")
else:
self.status_label.setText("处理失败!")
def handle_error(self, error_message):
"""处理错误信号"""
QMessageBox.critical(self, "错误", f"处理过程中发生错误: {error_message}")
def cancel_processing(self):
"""取消处理"""
if self.processor and self.processor.isRunning():
self.processor.cancel_processing()
self.status_label.setText("正在取消处理...")
self.cancel_btn.setEnabled(False)
def set_buttons_enabled(self, enabled):
self.doodle_process_btn.setEnabled(enabled)
self.shoot_process_btn.setEnabled(enabled)
self.doodle_video_a_btn.setEnabled(enabled)
self.shoot_video_a_btn.setEnabled(enabled)
self.shoot_video_b_btn.setEnabled(enabled)
self.thread_combo.setEnabled(enabled)
if enabled:
self.progress_bar.setVisible(False)
if __name__ == "__main__":
# 确保程序单实例运行
try:
from PyQt5.QtCore import QSharedMemory
import sys
# 创建共享内存段，确保程序单实例运行
app_shared_memory = QSharedMemory("VideoProcessorTool")
if not app_shared_memory.create(512, QSharedMemory.ReadWrite):
QMessageBox.critical(None, "错误", "程序已经在运行中!")
sys.exit(1)
app = QApplication(sys.argv)
window = MainWindow()
window.show()
sys.exit(app.exec_())
except Exception as e:
QMessageBox.critical(None, "错误", f"程序启动失败: {str(e)}")
本文介绍了解决 PHP 中使用 cURL 出现的错误：无法创建临时文件。通过打印系统临时文件夹位置并调整文件夹的安全权限来解决问题。
扫一扫
1220
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
