706 lines
26 KiB
Python
706 lines
26 KiB
Python
"""
|
||
FFmpeg视频切片服务
|
||
|
||
基于demo.py的VideoUtils.ffmpeg_slice_media方法封装的专业视频切片服务。
|
||
"""
|
||
|
||
import asyncio
|
||
import os
|
||
import json
|
||
import math
|
||
from typing import Dict, List, Any, Optional, Tuple
|
||
from pathlib import Path
|
||
from datetime import timedelta
|
||
from dataclasses import dataclass
|
||
from ffmpeg.asyncio import FFmpeg as AsyncFFmpeg
|
||
from loguru import logger
|
||
|
||
|
||
@dataclass
|
||
class SliceSegment:
|
||
"""切片段配置"""
|
||
start: float # 开始时间（秒）
|
||
end: float # 结束时间（秒）
|
||
|
||
@property
|
||
def duration(self) -> float:
|
||
"""片段时长"""
|
||
return self.end - self.start
|
||
|
||
def to_timedelta(self) -> Tuple[timedelta, timedelta]:
|
||
"""转换为timedelta格式"""
|
||
return (
|
||
timedelta(seconds=self.start),
|
||
timedelta(seconds=self.end)
|
||
)
|
||
|
||
|
||
@dataclass
|
||
class SliceOptions:
|
||
"""切片输出选项"""
|
||
width: Optional[int] = None # 输出宽度
|
||
height: Optional[int] = None # 输出高度
|
||
crf: int = 23 # 视频质量 (18-28, 越小质量越好)
|
||
fps: int = 30 # 输出帧率
|
||
bit_rate: Optional[str] = None # 比特率 (如 "2M")
|
||
limit_size: Optional[str] = None # 文件大小限制 (如 "10M")
|
||
preset: str = "medium" # 编码预设 (ultrafast, fast, medium, slow, veryslow)
|
||
|
||
@property
|
||
def pretty_bit_rate(self) -> str:
|
||
"""格式化的比特率"""
|
||
return self.bit_rate or "2M"
|
||
|
||
|
||
@dataclass
|
||
class VideoMetadata:
|
||
"""视频元数据"""
|
||
duration: float
|
||
width: int
|
||
height: int
|
||
fps: float
|
||
format_name: str
|
||
size: int
|
||
codec_name: str
|
||
audio_codec: str
|
||
|
||
@classmethod
|
||
def from_ffprobe(cls, metadata: dict) -> 'VideoMetadata':
|
||
"""从ffprobe结果创建元数据"""
|
||
format_info = metadata.get('format', {})
|
||
video_stream = None
|
||
audio_stream = None
|
||
|
||
for stream in metadata.get('streams', []):
|
||
if stream.get('codec_type') == 'video':
|
||
video_stream = stream
|
||
elif stream.get('codec_type') == 'audio':
|
||
audio_stream = stream
|
||
|
||
if not video_stream:
|
||
raise ValueError("No video stream found")
|
||
|
||
# 解析帧率
|
||
r_frame_rate = video_stream.get('r_frame_rate', '30/1')
|
||
if '/' in r_frame_rate:
|
||
num, den = map(int, r_frame_rate.split('/'))
|
||
fps = num / den if den != 0 else 30.0
|
||
else:
|
||
fps = float(r_frame_rate)
|
||
|
||
# 获取音频编码器信息
|
||
audio_codec = audio_stream.get('codec_name', '') if audio_stream else ''
|
||
|
||
return cls(
|
||
duration=float(format_info.get('duration', 0)),
|
||
width=int(video_stream.get('width', 0)),
|
||
height=int(video_stream.get('height', 0)),
|
||
fps=fps,
|
||
format_name=format_info.get('format_name', 'unknown'),
|
||
size=int(format_info.get('size', 0)),
|
||
codec_name=video_stream.get('codec_name', 'unknown'),
|
||
audio_codec=audio_codec
|
||
)
|
||
|
||
class FfmpegSliceService:
|
||
"""
|
||
FFmpeg视频切片服务
|
||
|
||
提供专业的视频切片功能，支持按时间段切割、质量控制、批量处理等。
|
||
"""
|
||
|
||
def __init__(self):
|
||
self.logger = logger
|
||
|
||
def _create_async_ffmpeg_cmd(self, quiet: bool = False) -> Optional[Any]:
|
||
"""创建异步FFmpeg命令对象"""
|
||
# 使用隐藏窗口的FFmpeg包装器
|
||
ffmpeg_cmd = AsyncFFmpeg(executable="ffmpeg").option('y').option('hide_banner')
|
||
|
||
@ffmpeg_cmd.on("start")
|
||
def on_start(arguments: list[str]):
|
||
try:
|
||
filter_index = arguments.index("-filter_complex")
|
||
filter_content = arguments[filter_index + 1]
|
||
arguments[filter_index + 1] = f'"{filter_content}"'
|
||
args = " ".join(arguments)
|
||
arguments[filter_index + 1] = filter_content
|
||
except ValueError:
|
||
args = " ".join(arguments)
|
||
logger.info(f"FFmpeg command: {args}")
|
||
|
||
@ffmpeg_cmd.on("progress")
|
||
def on_progress(progress):
|
||
if not quiet:
|
||
logger.info(f"处理进度: {progress}")
|
||
|
||
@ffmpeg_cmd.on("completed")
|
||
def on_completed(result=None):
|
||
logger.info(f"FFmpeg task completed.")
|
||
|
||
@ffmpeg_cmd.on("stderr")
|
||
def on_stderr(line: str):
|
||
if line.startswith('Error') and ".m3u8" not in line:
|
||
raise RuntimeError(line)
|
||
elif "Output file is empty" in line:
|
||
raise RuntimeError("输出是空文件")
|
||
else:
|
||
...
|
||
|
||
return ffmpeg_cmd
|
||
|
||
async def get_video_metadata(self, media_path: str) -> VideoMetadata:
|
||
"""
|
||
获取视频元数据
|
||
|
||
Args:
|
||
media_path: 视频文件路径
|
||
|
||
Returns:
|
||
VideoMetadata: 视频元数据对象
|
||
"""
|
||
ffprobe = AsyncFFmpeg(executable='ffprobe')
|
||
# 配置FFprobe参数
|
||
ffprobe.option("v", "quiet")
|
||
ffprobe.option("print_format", "json")
|
||
ffprobe.option("show_streams", None) # 明确指定None值
|
||
ffprobe.option("show_format", None) # 明确指定None值
|
||
|
||
# 首先验证文件是否存在和有效
|
||
media_file = Path(media_path)
|
||
if not media_file.exists():
|
||
raise FileNotFoundError(f"视频文件不存在: {media_path}")
|
||
|
||
if media_file.stat().st_size == 0:
|
||
raise RuntimeError(f"视频文件为空: {media_path}")
|
||
|
||
ffprobe.input(media_path)
|
||
logger.info(f"开始获取视频元数据: {media_path} (大小: {media_file.stat().st_size} 字节)")
|
||
|
||
try:
|
||
result = await ffprobe.execute()
|
||
|
||
# 详细的错误信息
|
||
if result.returncode != 0:
|
||
stderr_text = result.stderr.decode() if result.stderr else 'No error output'
|
||
stdout_text = result.stdout.decode() if result.stdout else 'No output'
|
||
logger.error(f"FFprobe failed with return code {result.returncode}")
|
||
logger.error(f"FFprobe stderr: {stderr_text}")
|
||
logger.error(f"FFprobe stdout: {stdout_text}")
|
||
|
||
# 如果是空JSON，说明文件可能不是有效的视频文件
|
||
if stdout_text.strip() in ['{}', '']:
|
||
raise RuntimeError(f"文件不是有效的视频文件或已损坏: {media_path}")
|
||
|
||
raise RuntimeError(f"FFprobe failed (code {result.returncode}): {stderr_text}")
|
||
|
||
# 检查输出是否为空
|
||
if not result.stdout:
|
||
raise RuntimeError("FFprobe returned empty output")
|
||
|
||
stdout_text = result.stdout.decode()
|
||
if not stdout_text.strip():
|
||
raise RuntimeError("FFprobe returned empty stdout")
|
||
|
||
# 解析JSON
|
||
try:
|
||
metadata_json = json.loads(stdout_text)
|
||
|
||
# 检查JSON是否包含有效数据
|
||
if not metadata_json or (not metadata_json.get('streams') and not metadata_json.get('format')):
|
||
raise RuntimeError(f"FFprobe返回空的元数据，文件可能已损坏: {media_path}")
|
||
|
||
except json.JSONDecodeError as e:
|
||
logger.error(f"Failed to parse FFprobe JSON output: {e}")
|
||
logger.error(f"Raw output: {stdout_text[:500]}...")
|
||
raise RuntimeError(f"Invalid JSON from FFprobe: {e}")
|
||
|
||
logger.info(f"成功获取视频元数据: {media_path}")
|
||
return VideoMetadata.from_ffprobe(metadata_json)
|
||
|
||
except Exception as e:
|
||
logger.error(f"Failed to get video metadata for {media_path}: {e}")
|
||
raise
|
||
|
||
def _validate_segments(self, segments: List[SliceSegment], video_duration: float) -> None:
|
||
"""
|
||
验证切片段配置
|
||
|
||
Args:
|
||
segments: 切片段列表
|
||
video_duration: 视频总时长
|
||
"""
|
||
diff_tolerance = 0.001
|
||
|
||
for i, segment in enumerate(segments):
|
||
if segment.start > video_duration or segment.start < 0:
|
||
raise ValueError(
|
||
f"第{i}个切割点起始点{segment.start}s超出视频时长[0-{video_duration}s]范围"
|
||
)
|
||
|
||
if segment.end > video_duration or segment.end < 0:
|
||
if segment.end > 0 and math.isclose(segment.end, video_duration, rel_tol=diff_tolerance):
|
||
# 允许小的误差
|
||
segment.end = video_duration
|
||
logger.warning(
|
||
f"第{i}个切割点结束点{segment.end}s接近视频时长，已调整为{video_duration}s"
|
||
)
|
||
else:
|
||
raise ValueError(
|
||
f"第{i}个切割点结束点{segment.end}s超出视频时长[0-{video_duration}s]范围"
|
||
)
|
||
|
||
if segment.start >= segment.end:
|
||
raise ValueError(
|
||
f"第{i}个切割点起始时间{segment.start}s必须小于结束时间{segment.end}s"
|
||
)
|
||
|
||
def _generate_output_path(self, base_path: str, index: int, extension: str = "mp4") -> str:
|
||
"""生成输出文件路径"""
|
||
base = Path(base_path)
|
||
return str(base.parent / f"{base.stem}_{index:03d}.{extension}")
|
||
|
||
async def slice_video(self,
|
||
media_path: str,
|
||
segments: List[SliceSegment],
|
||
options: SliceOptions,
|
||
output_path: Optional[str] = None) -> List[Tuple[str, VideoMetadata]]:
|
||
"""
|
||
使用本地视频文件按时间段切割出分段视频
|
||
|
||
Args:
|
||
media_path: 本地视频路径
|
||
segments: 分段起始结束时间标记列表
|
||
options: 输出切割质量选项
|
||
output_path: 最终输出文件路径，片段会根据指定路径附加_001.mp4等片段编号
|
||
|
||
Returns:
|
||
List[Tuple[str, VideoMetadata]]: 输出片段的本地路径和元数据
|
||
"""
|
||
if not segments:
|
||
raise ValueError("No segments provided")
|
||
|
||
# 获取视频元数据
|
||
metadata = await self.get_video_metadata(media_path)
|
||
logger.info(f"视频信息: {metadata.width}x{metadata.height}, {metadata.duration:.2f}s, {metadata.fps}fps")
|
||
|
||
# 验证切片段
|
||
self._validate_segments(segments, metadata.duration)
|
||
|
||
# 准备输出路径
|
||
if not output_path:
|
||
output_path = str(Path(media_path).with_suffix('_slice.mp4'))
|
||
|
||
os.makedirs(os.path.dirname(output_path), exist_ok=True)
|
||
|
||
# 创建FFmpeg命令
|
||
ffmpeg_cmd = self._create_async_ffmpeg_cmd()
|
||
if not ffmpeg_cmd:
|
||
raise RuntimeError("Failed to create FFmpeg command")
|
||
|
||
ffmpeg_cmd.input(media_path)
|
||
|
||
# 检查是否有音频流
|
||
has_audio = metadata.audio_codec is not None and metadata.audio_codec != ""
|
||
|
||
# 构建filter_complex
|
||
filter_complex = []
|
||
temp_outputs = []
|
||
|
||
for index, segment in enumerate(segments):
|
||
start = segment.start
|
||
end = segment.end
|
||
|
||
# 处理指定的输出分辨率
|
||
if options.width and options.height:
|
||
filter_complex.append(f"[v:0]trim=start={start}:end={end},scale={options.width}:{options.height},setpts=PTS-STARTPTS[cut{index}]")
|
||
if has_audio:
|
||
filter_complex.append(f"[a:0]atrim=start={start}:end={end},asetpts=PTS-STARTPTS[acut{index}]")
|
||
else:
|
||
filter_complex.append(f"[v:0]trim=start={start}:end={end},setpts=PTS-STARTPTS[cut{index}]")
|
||
if has_audio:
|
||
filter_complex.append(f"[a:0]atrim=start={start}:end={end},asetpts=PTS-STARTPTS[acut{index}]")
|
||
|
||
ffmpeg_cmd.option('filter_complex', ';'.join(filter_complex))
|
||
|
||
# 为每个片段配置输出
|
||
for i, segment in enumerate(segments):
|
||
segment_output_path = self._generate_output_path(output_path, i)
|
||
|
||
# 根据是否有音频流配置映射
|
||
if has_audio:
|
||
map_options = [f"[cut{i}]", f"[acut{i}]"]
|
||
else:
|
||
map_options = [f"[cut{i}]"]
|
||
|
||
ffmpeg_options = {
|
||
"map": map_options,
|
||
"reset_timestamps": "1",
|
||
"sc_threshold": "0",
|
||
"g": "1",
|
||
"force_key_frames": "expr:gte(t,n_forced*1)",
|
||
"vcodec": "libx264",
|
||
"crf": options.crf,
|
||
"r": options.fps,
|
||
"preset": options.preset
|
||
}
|
||
|
||
# 只有在有音频时才添加音频编码器
|
||
if has_audio:
|
||
ffmpeg_options["acodec"] = "aac"
|
||
|
||
if options.limit_size:
|
||
ffmpeg_options["fs"] = options.limit_size
|
||
elif options.bit_rate:
|
||
ffmpeg_options["b:v"] = options.pretty_bit_rate
|
||
|
||
ffmpeg_cmd.output(segment_output_path, options=ffmpeg_options)
|
||
temp_outputs.append(segment_output_path)
|
||
|
||
# 执行切片
|
||
try:
|
||
logger.info(f"开始执行FFmpeg切片命令...")
|
||
result = await ffmpeg_cmd.execute()
|
||
|
||
# 检查执行结果
|
||
if result.returncode != 0:
|
||
stderr_text = result.stderr.decode() if result.stderr else 'No error output'
|
||
stdout_text = result.stdout.decode() if result.stdout else 'No output'
|
||
logger.error(f"FFmpeg切片失败，返回码: {result.returncode}")
|
||
logger.error(f"FFmpeg stderr: {stderr_text}")
|
||
logger.error(f"FFmpeg stdout: {stdout_text}")
|
||
raise RuntimeError(f"FFmpeg切片失败 (返回码 {result.returncode}): {stderr_text}")
|
||
|
||
logger.info(f"FFmpeg执行成功，检查输出文件...")
|
||
|
||
# 验证输出文件是否真的被创建
|
||
missing_files = []
|
||
for output_file in temp_outputs:
|
||
if not Path(output_file).exists():
|
||
missing_files.append(output_file)
|
||
|
||
if missing_files:
|
||
logger.error(f"FFmpeg执行成功但输出文件未创建: {len(missing_files)} 个文件缺失")
|
||
for missing_file in missing_files[:5]: # 只显示前5个
|
||
logger.error(f" 缺失文件: {missing_file}")
|
||
raise RuntimeError(f"FFmpeg执行成功但未生成预期的输出文件，缺失 {len(missing_files)} 个文件")
|
||
|
||
logger.info(f"视频切片完成: 生成{len(temp_outputs)}个片段")
|
||
|
||
except Exception as e:
|
||
logger.error(f"视频切片失败: {e}")
|
||
raise
|
||
|
||
# 获取输出文件的元数据
|
||
outputs = []
|
||
for output_file in temp_outputs:
|
||
try:
|
||
output_metadata = await self.get_video_metadata(output_file)
|
||
outputs.append((output_file, output_metadata))
|
||
except Exception as e:
|
||
logger.warning(f"无法获取输出文件元数据 {output_file}: {e}")
|
||
# 创建一个基本的元数据对象
|
||
basic_metadata = VideoMetadata(
|
||
duration=0, width=0, height=0, fps=0,
|
||
format_name="mp4", size=0, codec_name="h264",
|
||
audio_codec="aac" # 添加缺少的audio_codec参数
|
||
)
|
||
outputs.append((output_file, basic_metadata))
|
||
|
||
return outputs
|
||
|
||
async def slice_video_by_duration(self,
|
||
media_path: str,
|
||
segment_duration: float,
|
||
options: SliceOptions,
|
||
output_dir: Optional[str] = None,
|
||
overlap: float = 0.0) -> List[Tuple[str, VideoMetadata]]:
|
||
"""
|
||
按固定时长切割视频
|
||
|
||
Args:
|
||
media_path: 输入视频路径
|
||
segment_duration: 每段时长（秒）
|
||
options: 输出选项
|
||
output_dir: 输出目录
|
||
overlap: 片段重叠时间（秒）
|
||
|
||
Returns:
|
||
输出片段列表
|
||
"""
|
||
metadata = await self.get_video_metadata(media_path)
|
||
|
||
if not output_dir:
|
||
output_dir = str(Path(media_path).parent / f"{Path(media_path).stem}_segments")
|
||
|
||
# 计算切片段
|
||
segments = []
|
||
current_start = 0.0
|
||
|
||
while current_start < metadata.duration:
|
||
end_time = min(current_start + segment_duration, metadata.duration)
|
||
|
||
if end_time - current_start >= 1.0: # 至少1秒的片段
|
||
segments.append(SliceSegment(start=current_start, end=end_time))
|
||
|
||
current_start += segment_duration - overlap
|
||
|
||
if current_start >= metadata.duration:
|
||
break
|
||
|
||
logger.info(f"按{segment_duration}s时长切割，生成{len(segments)}个片段")
|
||
|
||
# 使用基础切片方法
|
||
output_path = os.path.join(output_dir, f"{Path(media_path).stem}_segment.mp4")
|
||
return await self.slice_video(media_path, segments, options, output_path)
|
||
|
||
async def slice_video_by_count(self,
|
||
media_path: str,
|
||
segment_count: int,
|
||
options: SliceOptions,
|
||
output_dir: Optional[str] = None) -> List[Tuple[str, VideoMetadata]]:
|
||
"""
|
||
按片段数量平均切割视频
|
||
|
||
Args:
|
||
media_path: 输入视频路径
|
||
segment_count: 片段数量
|
||
options: 输出选项
|
||
output_dir: 输出目录
|
||
|
||
Returns:
|
||
输出片段列表
|
||
"""
|
||
if segment_count <= 0:
|
||
raise ValueError("Segment count must be positive")
|
||
|
||
metadata = await self.get_video_metadata(media_path)
|
||
segment_duration = metadata.duration / segment_count
|
||
|
||
if not output_dir:
|
||
output_dir = str(Path(media_path).parent / f"{Path(media_path).stem}_segments")
|
||
|
||
# 计算切片段
|
||
segments = []
|
||
for i in range(segment_count):
|
||
start_time = i * segment_duration
|
||
end_time = min((i + 1) * segment_duration, metadata.duration)
|
||
|
||
if end_time - start_time >= 0.5: # 至少0.5秒的片段
|
||
segments.append(SliceSegment(start=start_time, end=end_time))
|
||
|
||
logger.info(f"平均切割为{len(segments)}个片段，每段约{segment_duration:.2f}s")
|
||
|
||
# 使用基础切片方法
|
||
output_path = os.path.join(output_dir, f"{Path(media_path).stem}_segment.mp4")
|
||
return await self.slice_video(media_path, segments, options, output_path)
|
||
|
||
async def batch_slice_videos(self,
|
||
video_files: List[str],
|
||
segment_duration: float,
|
||
options: SliceOptions,
|
||
output_base_dir: str,
|
||
max_concurrent: int = 3) -> Dict[str, Any]:
|
||
"""
|
||
批量切割多个视频
|
||
|
||
Args:
|
||
video_files: 视频文件列表
|
||
segment_duration: 每段时长
|
||
options: 输出选项
|
||
output_base_dir: 输出基础目录
|
||
max_concurrent: 最大并发数
|
||
|
||
Returns:
|
||
批处理结果
|
||
"""
|
||
os.makedirs(output_base_dir, exist_ok=True)
|
||
|
||
# 创建任务
|
||
async def process_single_video(video_file: str):
|
||
try:
|
||
file_name = Path(video_file).stem
|
||
output_dir = os.path.join(output_base_dir, file_name)
|
||
|
||
results = await self.slice_video_by_duration(
|
||
media_path=video_file,
|
||
segment_duration=segment_duration,
|
||
options=options,
|
||
output_dir=output_dir
|
||
)
|
||
|
||
return {
|
||
"file": video_file,
|
||
"success": True,
|
||
"segments": len(results),
|
||
"outputs": [path for path, _ in results]
|
||
}
|
||
except Exception as e:
|
||
logger.error(f"处理视频失败 {video_file}: {e}")
|
||
return {
|
||
"file": video_file,
|
||
"success": False,
|
||
"error": str(e)
|
||
}
|
||
|
||
# 并发执行
|
||
semaphore = asyncio.Semaphore(max_concurrent)
|
||
|
||
async def limited_task(video_file):
|
||
async with semaphore:
|
||
return await process_single_video(video_file)
|
||
|
||
logger.info(f"开始批量处理{len(video_files)}个视频文件")
|
||
results = await asyncio.gather(
|
||
*[limited_task(video_file) for video_file in video_files],
|
||
return_exceptions=True
|
||
)
|
||
|
||
# 统计结果
|
||
success_count = 0
|
||
error_count = 0
|
||
total_segments = 0
|
||
errors = []
|
||
|
||
for result in results:
|
||
if isinstance(result, Exception):
|
||
error_count += 1
|
||
errors.append({"error": str(result)})
|
||
elif result["success"]:
|
||
success_count += 1
|
||
total_segments += result["segments"]
|
||
else:
|
||
error_count += 1
|
||
errors.append(result)
|
||
|
||
batch_result = {
|
||
"total_files": len(video_files),
|
||
"success_count": success_count,
|
||
"error_count": error_count,
|
||
"total_segments": total_segments,
|
||
"results": results,
|
||
"errors": errors
|
||
}
|
||
|
||
logger.info(f"批量处理完成: 成功{success_count}, 失败{error_count}, 总片段{total_segments}")
|
||
return batch_result
|
||
|
||
def create_slice_options(self,
|
||
quality: str = "medium",
|
||
width: Optional[int] = None,
|
||
height: Optional[int] = None,
|
||
fps: int = 30,
|
||
bit_rate: Optional[str] = None,
|
||
limit_size: Optional[str] = None) -> SliceOptions:
|
||
"""
|
||
创建切片选项的便捷方法
|
||
|
||
Args:
|
||
quality: 质量预设 (low, medium, high)
|
||
width: 输出宽度
|
||
height: 输出高度
|
||
fps: 帧率
|
||
bit_rate: 比特率
|
||
limit_size: 文件大小限制
|
||
|
||
Returns:
|
||
SliceOptions对象
|
||
"""
|
||
quality_presets = {
|
||
"low": {"crf": 28, "preset": "fast"},
|
||
"medium": {"crf": 23, "preset": "medium"},
|
||
"high": {"crf": 18, "preset": "slow"},
|
||
"ultra": {"crf": 15, "preset": "veryslow"}
|
||
}
|
||
|
||
preset_config = quality_presets.get(quality, quality_presets["medium"])
|
||
|
||
return SliceOptions(
|
||
width=width,
|
||
height=height,
|
||
crf=preset_config["crf"],
|
||
fps=fps,
|
||
bit_rate=bit_rate,
|
||
limit_size=limit_size,
|
||
preset=preset_config["preset"]
|
||
)
|
||
|
||
async def _slice_video_fallback(self, media_path: str, segments: List[SliceSegment], output_path: str = None) -> List[Tuple[str, VideoMetadata]]:
|
||
"""
|
||
备用的视频切片实现（当 FFmpeg Python 不可用时）
|
||
|
||
Args:
|
||
media_path: 输入视频路径
|
||
segments: 要切片的段落列表
|
||
output_path: 输出路径（可选）
|
||
|
||
Returns:
|
||
List[Tuple[str, VideoMetadata]]: 输出片段的本地路径和元数据
|
||
"""
|
||
logger.warning("FFmpeg Python 不可用，使用备用实现（仅返回原视频信息）")
|
||
|
||
try:
|
||
# 获取视频基本信息
|
||
import os
|
||
from pathlib import Path
|
||
|
||
if not os.path.exists(media_path):
|
||
raise FileNotFoundError(f"视频文件不存在: {media_path}")
|
||
|
||
# 创建基本的视频元数据
|
||
file_size = os.path.getsize(media_path)
|
||
file_name = Path(media_path).name
|
||
|
||
# 创建简化的元数据
|
||
metadata = VideoMetadata(
|
||
duration=60.0, # 默认值
|
||
width=1920, # 默认值
|
||
height=1080, # 默认值
|
||
fps=30.0, # 默认值
|
||
format_name="mp4", # 默认值
|
||
size=file_size,
|
||
codec_name="h264", # 默认值
|
||
audio_codec="aac" # 默认值
|
||
)
|
||
|
||
# 为每个段落创建结果（实际上返回原视频）
|
||
results = []
|
||
for i, segment in enumerate(segments):
|
||
# 创建输出文件名
|
||
output_dir = Path(media_path).parent / "segments"
|
||
output_dir.mkdir(exist_ok=True)
|
||
|
||
segment_filename = f"{Path(media_path).stem}_segment_{i+1}_{segment.start_time:.1f}s-{segment.end_time:.1f}s.mp4"
|
||
segment_path = output_dir / segment_filename
|
||
|
||
# 在备用模式下，我们只是复制原文件（或创建一个占位符）
|
||
try:
|
||
import shutil
|
||
shutil.copy2(media_path, segment_path)
|
||
logger.info(f"备用模式：复制原视频到 {segment_path}")
|
||
except Exception as e:
|
||
logger.warning(f"复制文件失败: {e}")
|
||
# 创建一个空文件作为占位符
|
||
segment_path.touch()
|
||
|
||
# 创建段落元数据
|
||
segment_metadata = VideoMetadata(
|
||
width=metadata.width,
|
||
height=metadata.height,
|
||
duration=segment.end_time - segment.start_time,
|
||
fps=metadata.fps,
|
||
bitrate=metadata.bitrate,
|
||
codec=metadata.codec,
|
||
file_size=file_size, # 简化处理
|
||
format=metadata.format
|
||
)
|
||
|
||
results.append((str(segment_path), segment_metadata))
|
||
|
||
logger.info(f"备用模式完成，生成了 {len(results)} 个段落")
|
||
return results
|
||
|
||
except Exception as e:
|
||
logger.error(f"备用视频切片失败: {e}")
|
||
raise RuntimeError(f"视频切片失败: {e}")
|