#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ 字幕封面生成器 - 后端处理逻辑 """ import os import sys import json import time import tempfile import subprocess from pathlib import Path from typing import Dict, Any, Optional, List, Tuple import logging # ⚠️ 修复模块路径：确保 Python 能找到 modules 和其他本地模块 # 将脚本所在目录（python 目录）添加到 sys.path script_dir = os.path.dirname(os.path.abspath(__file__)) if script_dir not in sys.path: sys.path.insert(0, script_dir) print(f"[PATH] Added to sys.path: {script_dir}", file=sys.stderr) try: import cv2 import numpy as np from PIL import Image, ImageDraw, ImageFont, ImageFilter import jieba # import moviepy.editor # 暂时注释掉，需要时再启用 except ImportError as e: print(f"缺少必要的依赖库: {e}") print("请安装以下库:") print("pip install opencv-python pillow jieba") sys.exit(1) try: from modules.font_manager import get_font_manager FONT_MANAGER_AVAILABLE = True print("[PATH] font_manager loaded successfully", file=sys.stderr) except ImportError as e: FONT_MANAGER_AVAILABLE = False print(f"[PATH] Warning: font_manager module not available: {e}", file=sys.stderr) # 配置日志 logging.basicConfig( level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s' ) class VideoSubtitleCoverGenerator: """字幕封面生成器""" def __init__(self, config: Dict[str, Any]): self.config = config self.logger = logging.getLogger(__name__) # 字幕样式预设 self.subtitle_presets = { "classic": { "fontFamily": "Arial", "fontSize": 24, "fontColor": "#FFFFFF", "backgroundColor": "#000000", "backgroundColorOpacity": 0.7, "position": "bottom" }, "modern": { "fontFamily": "NotoSerifCJK-VF", "fontSize": 28, "fontColor": "#FFD700", "backgroundColor": "#1a1a1a", "backgroundColorOpacity": 0.8, "position": "bottom" }, "minimal": { "fontFamily": "NotoSerifCJK-VF", "fontSize": 22, "fontColor": "#FFFFFF", "backgroundColor": "", "backgroundColorOpacity": 0, "position": "center" }, "bold": { "fontFamily": "NotoSerifCJK-VF", "fontSize": 30, "fontColor": "#FF0000", "backgroundColor": "#FFFF00", "backgroundColorOpacity": 0.9, "position": "top" } } # 封面样式预设 self.cover_presets = { "big-text": { "timePointType": "random", "customTimePoint": 10, "textOverlay": "", "fontSize": 72, "fontColor": "white", "position": "center", "backgroundColor": True, "backgroundOpacity": 60, "maxWidth": 90, "effectType": "blur", "quality": 95 }, "search-card": { "timePointType": "middle", "customTimePoint": 50, "textOverlay": "", "fontSize": 48, "fontColor": "white", "position": "bottom-left", "backgroundColor": True, "backgroundOpacity": 80, "maxWidth": 70, "effectType": "none", "quality": 95 }, "cut-angle": { "timePointType": "start", "customTimePoint": 5, "textOverlay": "", "fontSize": 56, "fontColor": "yellow", "position": "bottom-right", "backgroundColor": False, "backgroundOpacity": 0, "maxWidth": 75, "effectType": "gradient", "quality": 95 }, "blur-person": { "timePointType": "random", "customTimePoint": 15, "textOverlay": "", "fontSize": 64, "fontColor": "white", "position": "bottom-center", "backgroundColor": True, "backgroundOpacity": 50, "maxWidth": 85, "effectType": "blur-person", "quality": 95 } } def get_subtitle_preset(self, preset_id: str) -> Dict[str, Any]: """获取字幕预设样式""" return self.subtitle_presets.get(preset_id, self.subtitle_presets["classic"]) def get_cover_preset(self, preset_id: str) -> Dict[str, Any]: """获取封面预设样式""" return self.cover_presets.get(preset_id, self.cover_presets["big-text"]) def extract_frame_at_time(self, video_path: str, time_seconds: float) -> Optional[np.ndarray]: """从视频中提取指定时间的帧""" try: cap = cv2.VideoCapture(video_path) if not cap.isOpened(): self.logger.error(f"无法打开视频文件: {video_path}") return None # 设置时间位置 cap.set(cv2.CAP_PROP_POS_MSEC, time_seconds * 1000) ret, frame = cap.read() cap.release() if ret: return frame else: self.logger.warning(f"无法读取视频帧: {time_seconds}s") return None except Exception as e: self.logger.error(f"提取视频帧失败: {e}") return None def get_video_duration(self, video_path: str) -> float: """获取视频时长""" try: cap = cv2.VideoCapture(video_path) if not cap.isOpened(): return 0 fps = cap.get(cv2.CAP_PROP_FPS) frame_count = cap.get(cv2.CAP_PROP_FRAME_COUNT) duration = frame_count / fps if fps > 0 else 0 cap.release() return duration except Exception as e: self.logger.error(f"获取视频时长失败: {e}") return 0 def get_optimal_frame_time(self, video_path: str, time_point_type: str, custom_time: float) -> float: """获取最佳帧时间点""" duration = self.get_video_duration(video_path) if time_point_type == "start": return min(custom_time, duration * 0.1) # 前10% elif time_point_type == "middle": return duration * (custom_time / 100) # 百分比位置 elif time_point_type == "end": return max(duration - custom_time, duration * 0.9) # 后10% elif time_point_type == "random": import random # 随机选择前60%的位置，避免片尾 return random.uniform(0, duration * 0.6) else: return min(custom_time, duration * 0.5) # 默认中间位置 def apply_cover_effect(self, image: Image.Image, effect_type: str) -> Image.Image: """应用封面特效""" if effect_type == "blur": # 高斯模糊背景 return image.filter(ImageFilter.GaussianBlur(radius=5)) elif effect_type == "blur-person": # 模拟人物虚化效果 (简单的中心区域保持清晰) width, height = image.size # 创建遮罩 mask = Image.new('L', (width, height), 128) # 中心区域清晰 center_x, center_y = width // 2, height // 2 radius = min(width, height) // 4 for x in range(width): for y in range(height): dist = ((x - center_x) ** 2 + (y - center_y) ** 2) ** 0.5 if dist < radius: mask.putpixel((x, y), 255) # 清晰 else: mask.putpixel((x, y), 64) # 模糊 blurred = image.filter(ImageFilter.GaussianBlur(radius=3)) return Image.composite(image, blurred, mask) elif effect_type == "gradient": # 渐变效果 width, height = image.size gradient = Image.new('L', (width, height), 0) draw = ImageDraw.Draw(gradient) # 创建对角线渐变 for x in range(width): for y in range(height): # 计算渐变值 factor = (x + y) / (width + height) value = int(255 * (0.3 + 0.7 * factor)) # 30%-100% 不透明度 gradient.putpixel((x, y), value) # 创建半透明图层 overlay = Image.new('RGBA', (width, height), (0, 0, 0, 0)) gradient_rgba = Image.new('RGBA', (width, height), (0, 0, 0, 128)) overlay = Image.composite(overlay, gradient_rgba, gradient) return Image.alpha_composite(image.convert('RGBA'), overlay).convert('RGB') else: return image def add_text_to_image(self, image: Image.Image, text: str, style_config: Dict[str, Any]) -> Image.Image: """在图片上添加文字""" if not text.strip(): return image img = image.copy() draw = ImageDraw.Draw(img) width, height = img.size # 获取字体（支持自定义字体） font_size = style_config.get('fontSize', 48) font_name = style_config.get('fontName', 'NotoSerifCJK-VF') # 从配置获取字体名称 font_weight = style_config.get('fontWeight', 400) font = self._load_font_safe(font_name, font_size, font_weight) # 计算文字尺寸 bbox = draw.textbbox((0, 0), text, font=font) text_width = bbox[2] - bbox[0] text_height = bbox[3] - bbox[1] # 限制最大宽度 max_width_percent = style_config.get('maxWidth', 80) / 100 max_width = int(width * max_width_percent) if text_width > max_width: # 如果文字太宽，需要调整字体大小 scale_factor = max_width / text_width new_font_size = int(font_size * scale_factor) try: font = ImageFont.truetype(font_family, new_font_size) except: font = ImageFont.load_default() # 重新计算文字尺寸 bbox = draw.textbbox((0, 0), text, font=font) text_width = bbox[2] - bbox[0] text_height = bbox[3] - bbox[1] # 计算位置 position = style_config.get('position', 'center') font_color = style_config.get('fontColor', 'white') # 解析颜色 if isinstance(font_color, str) and font_color.startswith('#'): r = int(font_color[1:3], 16) g = int(font_color[3:5], 16) b = int(font_color[5:7], 16) font_color = (r, g, b) elif font_color == 'white': font_color = (255, 255, 255) elif font_color == 'yellow': font_color = (255, 255, 0) else: font_color = (255, 255, 255) # 计算文字位置 if position == 'center': x = (width - text_width) // 2 y = (height - text_height) // 2 elif position == 'bottom-left': x = 50 y = height - text_height - 50 elif position == 'bottom-right': x = width - text_width - 50 y = height - text_height - 50 elif position == 'bottom-center': x = (width - text_width) // 2 y = height - text_height - 50 elif position == 'top-left': x = 50 y = 50 elif position == 'top-right': x = width - text_width - 50 y = 50 elif position == 'top-center': x = (width - text_width) // 2 y = 50 else: # 默认居中 x = (width - text_width) // 2 y = (height - text_height) // 2 # 添加背景 background_color = style_config.get('backgroundColor', True) background_opacity = style_config.get('backgroundOpacity', 70) if background_color and background_opacity > 0: # 创建半透明背景 padding = 20 bg_x1 = max(0, x - padding) bg_y1 = max(0, y - padding) bg_x2 = min(width, x + text_width + padding) bg_y2 = min(height, y + text_height + padding) # 创建半透明黑色背景 background = Image.new('RGBA', (width, height), (0, 0, 0, 0)) bg_draw = ImageDraw.Draw(background) # 计算背景颜色 (黑色半透明) alpha = int(255 * (background_opacity / 100)) bg_color = (0, 0, 0, alpha) bg_draw.rectangle([bg_x1, bg_y1, bg_x2, bg_y2], fill=bg_color) img = Image.alpha_composite(img.convert('RGBA'), background).convert('RGB') # 重新创建draw对象 draw = ImageDraw.Draw(img) # 绘制文字 draw.text((x, y), text, font=font, fill=font_color) return img def generate_cover_with_custom_template(self, video_path: str, output_path: str, template: Dict[str, Any]) -> bool: """使用自定义模板生成封面""" try: # 提取视频的中间帧 duration = self.get_video_duration(video_path) time_point = duration * 0.5 # 使用中间帧 frame = self.extract_frame_at_time(video_path, time_point) if frame is None: self.logger.error("无法提取视频帧") return False # 转换为PIL图像 image = Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)) width, height = image.size # 1. 应用背景模糊（如果启用） background_config = template.get('background', {}) if background_config.get('blurEnabled', False): blur_radius = background_config.get('blurRadius', 15) image = image.filter(ImageFilter.GaussianBlur(radius=blur_radius)) # 2. 处理人像描边（如果启用） portrait_config = template.get('portrait', {}) if portrait_config.get('strokeEnabled', False): # 创建绘图对象 draw = ImageDraw.Draw(image) # 获取人像位置和大小（百分比转换为像素） pos = portrait_config.get('position', {'x': 50, 'y': 50}) size = portrait_config.get('size', {'width': 50, 'height': 70}) portrait_x = int(pos['x'] / 100 * width) portrait_y = int(pos['y'] / 100 * height) portrait_width = int(size['width'] / 100 * width) portrait_height = int(size['height'] / 100 * height) # 绘制描边框 stroke_color = portrait_config.get('strokeColor', '#FFD700') stroke_width = portrait_config.get('strokeWidth', 3) stroke_type = portrait_config.get('strokeType', 'solid') # 计算矩形边界 left = portrait_x - portrait_width // 2 top = portrait_y - portrait_height // 2 right = portrait_x + portrait_width // 2 bottom = portrait_y + portrait_height // 2 if stroke_type == 'dashed': # 虚线描边 dash_pattern = portrait_config.get('strokeDashPattern', [10, 5]) # 简化实现：绘制虚线矩形 # 这里需要手动绘制虚线，PIL不直接支持 pass # 简化处理，暂时使用实线 # 绘制实线矩形 for i in range(stroke_width): draw.rectangle( [left - i, top - i, right + i, bottom + i], outline=stroke_color, width=1 ) # 3. 添加标题文字 titles_config = template.get('titles', {}) # 主标题 main_title = titles_config.get('main', {}) main_text = main_title.get('text', '') if main_text: self._draw_text_with_stroke( image, main_text, main_title, width, height ) # 副标题 sub_title = titles_config.get('sub', {}) sub_text = sub_title.get('text', '') if sub_text: self._draw_text_with_stroke( image, sub_text, sub_title, width, height ) # 4. 添加蒙版（如果有） mask_config = template.get('mask', {}) mask_path = mask_config.get('imagePath', '') if mask_path and os.path.exists(mask_path): try: mask_img = Image.open(mask_path).convert('RGBA') # 获取蒙版位置和大小 mask_pos = mask_config.get('position', {'x': 10, 'y': 10}) mask_size = mask_config.get('size', {'width': 30, 'height': 20}) mask_opacity = mask_config.get('opacity', 0.8) mask_width = int(mask_size['width'] / 100 * width) mask_height = int(mask_size['height'] / 100 * height) mask_x = int(mask_pos['x'] / 100 * width) mask_y = int(mask_pos['y'] / 100 * height) # 调整蒙版大小和透明度 mask_img = mask_img.resize((mask_width, mask_height), Image.Resampling.LANCZOS) if mask_opacity < 1.0: alpha = mask_img.split()[3] alpha = alpha.point(lambda p: int(p * mask_opacity)) mask_img.putalpha(alpha) # 将蒙版粘贴到图像上 image_rgba = image.convert('RGBA') image_rgba.paste(mask_img, (mask_x - mask_width // 2, mask_y - mask_height // 2), mask_img) image = image_rgba.convert('RGB') except Exception as e: self.logger.warning(f"添加蒙版失败: {e}") # 保存图片 image.save(output_path, 'JPEG', quality=95) self.logger.info(f"自定义模板封面生成成功: {output_path}") return True except Exception as e: self.logger.error(f"生成自定义模板封面失败: {e}") return False def _load_font_safe(self, font_name: str = None, font_size: int = 24, font_weight: int = 400) -> ImageFont.FreeTypeFont: """ 加载字体，支持自定义字体、ziti目录、系统字体 优先顺序：ziti目录 -> FontManager -> 系统字体 -> 默认字体 Args: font_name: 字体名称（如 "微软雅黑"、"墨趣古风体" 等） font_size: 字体大小 font_weight: 字体粗细 (100-1000) Returns: 字体对象 """ import platform # 1. 首先直接尝试在 ziti 目录查找字体文件 if font_name: # 多个可能的 ziti 目录路径（相对和绝对） possible_ziti_paths = [ os.path.join(os.getcwd(), 'ziti'), # 当前工作目录 os.path.join(os.path.dirname(__file__), '..', 'ziti'), # 相对于脚本 os.path.join(os.path.dirname(__file__), '..', '..', 'ziti'), # 项目根目录 'ziti', # 相对路径 os.path.expanduser('~/ziti'), # 用户主目录 ] # 尝试找到 ziti 目录 for ziti_dir in possible_ziti_paths: if os.path.isdir(ziti_dir): self.logger.info(f"Found ziti directory: {ziti_dir}") # 在 ziti 目录中查找字体文件 for ext in ['.ttf', '.otf', '.ttc']: # 直接按字体名称查找 font_path = os.path.join(ziti_dir, font_name + ext) if os.path.exists(font_path): try: return ImageFont.truetype(font_path, font_size) except Exception as e: self.logger.warning(f"Failed to load ziti font from {font_path}: {e}") # 如果没有找到，扫描目录中所有文件进行模糊匹配 try: for file in os.listdir(ziti_dir): if not file.startswith('.') and (file.endswith('.ttf') or file.endswith('.otf') or file.endswith('.ttc')): file_base = os.path.splitext(file)[0] # 检查是否匹配（精确或包含） if file_base == font_name or font_name in file_base: font_path = os.path.join(ziti_dir, file) try: return ImageFont.truetype(font_path, font_size) except Exception as e: self.logger.warning(f"Failed to load matched font {font_path}: {e}") except Exception as e: self.logger.warning(f"Error scanning ziti directory: {e}") # 2. 如果 ziti 目录查找失败，使用 FontManager if font_name and FONT_MANAGER_AVAILABLE: try: font_manager = get_font_manager() font_path = font_manager.find_font(font_name, font_weight) if font_path and os.path.exists(font_path): try: return ImageFont.truetype(font_path, font_size) except Exception as e: self.logger.warning(f"Failed to load custom font from {font_path}: {e}") except Exception as e: self.logger.warning(f"Font manager error: {e}") # 3. 降级：根据操作系统加载默认系统字体 system = platform.system() font_paths = [] if system == 'Windows': font_dir = None font_paths = [ os.path.join(font_dir, 'NotoSerifCJK-VF'), # 微软雅黑 '', # 微软雅黑 Bold '', # 黑体 '', # 宋体 ] elif system == 'Darwin': # macOS font_paths = [ '/Library/Fonts/PingFang.ttc', '/System/Library/Fonts/PingFang.ttc', ] else: # Linux font_paths = [ '/usr/share/fonts/truetype/wqy/wqy-zenhei.ttc', ] # 尝试加载每个字体 for font_path in font_paths: if os.path.exists(font_path): try: return ImageFont.truetype(font_path, font_size) except: continue return ImageFont.load_default() def _draw_text_with_stroke(self, image: Image.Image, text: str, config: Dict[str, Any], img_width: int, img_height: int): """在图片上绘制带描边的文字""" if not text: return # 获取配置 font_size = config.get('fontSize', 60) font_weight = config.get('fontWeight', 700) font_name = config.get('fontName', 'NotoSerifCJK-VF') # 从配置获取字体名称 color = config.get('color', '#FFFFFF') stroke_color = config.get('strokeColor', '#000000') stroke_width = config.get('strokeWidth', 2) position = config.get('position', {'x': 50, 'y': 20}) # 加载字体（使用改进的字体加载逻辑，支持自定义字体） font = self._load_font_safe(font_name, font_size, font_weight) # 计算文字位置 text_x = int(position['x'] / 100 * img_width) text_y = int(position['y'] / 100 * img_height) # 创建绘图对象 draw = ImageDraw.Draw(image) # 绘制描边（多次绘制以模拟描边效果） if stroke_width > 0: for adj_x in range(-stroke_width, stroke_width + 1): for adj_y in range(-stroke_width, stroke_width + 1): if adj_x != 0 or adj_y != 0: draw.text( (text_x + adj_x, text_y + adj_y), text, font=font, fill=stroke_color, anchor='mm' ) # 绘制主文字 draw.text( (text_x, text_y), text, font=font, fill=color, anchor='mm' ) def generate_cover(self, video_path: str, output_path: str, cover_config: Dict[str, Any]) -> bool: """生成封面图片""" try: # 获取最佳帧时间点 time_point = self.get_optimal_frame_time( video_path, cover_config.get('timePointType', 'random'), cover_config.get('customTimePoint', 10) ) # 提取帧 frame = self.extract_frame_at_time(video_path, time_point) if frame is None: self.logger.error("无法提取视频帧") return False # 转换为PIL图像 image = Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)) # 应用特效 effect_type = cover_config.get('effectType', 'none') if effect_type != 'none': image = self.apply_cover_effect(image, effect_type) # 添加文字 text_overlay = cover_config.get('textOverlay', '').strip() if text_overlay: image = self.add_text_to_image(image, text_overlay, cover_config) # 保存图片 quality = cover_config.get('quality', 95) image.save(output_path, 'JPEG', quality=quality) self.logger.info(f"封面生成成功: {output_path}") return True except Exception as e: self.logger.error(f"生成封面失败: {e}") return False def generate_subtitle_srt(self, text: str, video_duration: float) -> str: """生成字幕SRT文件内容""" try: # 使用jieba分词 words = list(jieba.cut(text.strip())) # 计算字幕时长分布 total_chars = len(text) if total_chars == 0: return "" # 平均每个字幕显示2-3秒 avg_duration = min(3.0, max(2.0, video_duration / max(1, total_chars / 10))) srt_lines = [] current_time = 1.0 # 从1秒开始 for i, word in enumerate(words): if not word.strip(): continue start_time = current_time end_time = min(current_time + avg_duration, video_duration - 0.5) # 格式化时间 (HH:MM:SS,mmm) def format_time(seconds): hours = int(seconds // 3600) minutes = int((seconds % 3600) // 60) secs = int(seconds % 60) ms = int((seconds % 1) * 1000) return "02d" start_str = format_time(start_time) end_str = format_time(end_time) srt_lines.append(f"{i+1}") srt_lines.append(f"{start_str} --> {end_str}") srt_lines.append(word) srt_lines.append("") # 空行 current_time = end_time return "\n".join(srt_lines) except Exception as e: self.logger.error(f"生成字幕SRT失败: {e}") return "" def add_subtitle_to_video(self, video_path: str, srt_path: str, output_path: str, subtitle_config: Dict[str, Any]) -> bool: """为视频添加字幕 - 简化的实现""" try: # 目前先复制原视频作为输出（字幕功能可以后续完善） # 实际项目中可以使用 ffmpeg 或其他视频处理库 import shutil shutil.copy2(video_path, output_path) self.logger.info(f"视频复制成功 (字幕功能待完善): {output_path}") return True except Exception as e: self.logger.error(f"复制视频失败: {e}") return False def parse_srt_time(self, time_str: str) -> float: """解析SRT时间格式""" try: # 格式: 00:00:01,000 parts = time_str.replace(',', ':').split(':') if len(parts) >= 3: hours = int(parts[0]) minutes = int(parts[1]) seconds = float(parts[2]) return hours * 3600 + minutes * 60 + seconds except: pass return 0.0 def process(self, progress_callback=None) -> Dict[str, Any]: """主处理流程""" try: # 检查是否使用自定义模板 if self.config.get('customTemplate', False): return self._process_with_custom_template(progress_callback) model_config = self.config.get('modelConfig', {}) video_path = model_config.get('video', '') if not video_path or not os.path.exists(video_path): return { 'code': -1, 'msg': f'视频文件不存在: {video_path}' } # 创建输出目录 output_dir = os.path.dirname(video_path) base_name = os.path.splitext(os.path.basename(video_path))[0] # 更新进度: 初始化 if progress_callback: progress_callback(0.1, "初始化处理...") # 获取字幕和封面配置 subtitle_template = model_config.get('subtitleTemplate', 'classic') cover_template = model_config.get('coverTemplate', 'big-text') subtitle_style = self.get_subtitle_preset(subtitle_template) cover_style = self.get_cover_preset(cover_template) # 如果配置中有自定义样式，覆盖预设 if 'subtitleStyle' in model_config: subtitle_style.update(model_config['subtitleStyle']) if 'coverStyle' in model_config: cover_style.update(model_config['coverStyle']) # 更新进度: 生成字幕 if progress_callback: progress_callback(0.2, "生成字幕文件...") # 生成字幕SRT video_duration = self.get_video_duration(video_path) reference_text = model_config.get('referenceText', '') srt_content = self.generate_subtitle_srt(reference_text, video_duration) # 保存SRT文件 srt_path = os.path.join(output_dir, f"{base_name}_subtitles.srt") with open(srt_path, 'w', encoding='utf-8') as f: f.write(srt_content) # 更新进度: 生成封面 if progress_callback: progress_callback(0.5, "生成视频封面...") # 生成封面 cover_path = os.path.join(output_dir, f"{base_name}_cover.jpg") cover_success = self.generate_cover(video_path, cover_path, cover_style) # 更新进度: 添加字幕到视频 if progress_callback: progress_callback(0.7, "为视频添加字幕...") # 生成带字幕的视频 video_with_subtitle_path = os.path.join(output_dir, f"{base_name}_with_subtitles.mp4") subtitle_success = self.add_subtitle_to_video(video_path, srt_path, video_with_subtitle_path, subtitle_style) # 更新进度: 完成 if progress_callback: progress_callback(1.0, "处理完成") result = { 'code': 0, 'msg': '处理成功', 'video': video_with_subtitle_path if subtitle_success else video_path, 'cover': cover_path if cover_success else None, 'srtPath': srt_path } return result except Exception as e: self.logger.error(f"处理失败: {e}") return { 'code': -1, 'msg': f'处理失败: {str(e)}' } def _process_with_custom_template(self, progress_callback=None) -> Dict[str, Any]: """使用自定义模板处理""" try: video_path = self.config.get('videoPath', '') template = self.config.get('template', {}) if not video_path or not os.path.exists(video_path): return { 'code': -1, 'msg': f'视频文件不存在: {video_path}' } if not template: return { 'code': -1, 'msg': '缺少自定义模板配置' } # 创建输出目录 output_dir = self.config.get('outputDir', os.path.dirname(video_path)) if not os.path.exists(output_dir): os.makedirs(output_dir, exist_ok=True) base_name = os.path.splitext(os.path.basename(video_path))[0] # 更新进度: 初始化 if progress_callback: progress_callback(0.1, "初始化自定义模板处理...") # 更新进度: 生成封面 if progress_callback: progress_callback(0.5, "使用自定义模板生成封面...") # 生成封面 cover_path = os.path.join(output_dir, f"{base_name}_custom_cover.jpg") cover_success = self.generate_cover_with_custom_template(video_path, cover_path, template) # 更新进度: 完成 if progress_callback: progress_callback(1.0, "处理完成") result = { 'success': cover_success, 'coverPath': cover_path if cover_success else None, 'message': '自定义模板处理成功' if cover_success else '自定义模板处理失败' } return result except Exception as e: self.logger.error(f"自定义模板处理失败: {e}") return { 'success': False, 'error': str(e), 'message': f'自定义模板处理失败: {str(e)}' } def main(): """命令行入口""" if len(sys.argv) < 2: print("用法: python video_subtitle_cover_generator.py ") sys.exit(1) config_path = sys.argv[1] try: with open(config_path, 'r', encoding='utf-8') as f: config = json.load(f) generator = VideoSubtitleCoverGenerator(config) result = generator.process() # 输出JSON结果（单行，以便Node.js解析） print(json.dumps(result, ensure_ascii=False)) except Exception as e: print(json.dumps({ 'success': False, 'error': str(e), 'message': f'执行失败: {str(e)}' }, ensure_ascii=False)) if __name__ == "__main__": main()