revideo 1.0.0__tar.gz

revideo-1.0.0/PKG-INFO

@@ -0,0 +1,144 @@
+Metadata-Version: 2.4
+Name: revideo
+Version: 1.0.0
+Summary: 视频伪原创工具 - 基于 ffmpeg 的视频去重处理
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: fastmcp>=0.4.0
+
+# revideo — 视频伪原创工具
+
+基于 ffmpeg 的视频去重处理工具，通过多种手段修改视频以应对平台原创检测。
+
+## 安装
+
+### 前置依赖
+
+- **Python ≥ 3.12**
+- **ffmpeg**（需在 PATH 中可用）
+
+```bash
+# 克隆项目
+git clone https://git.des8.com/heibai2006/revideo.git
+cd revideo
+
+# 安装依赖（uv 自动处理）
+uv sync
+```
+
+验证安装：
+```bash
+uv run revideo --help
+```
+
+## 快速开始
+
+```bash
+# 处理单个视频（输出到 output/ 目录）
+uv run revideo video.mp4 -o output/
+
+# 处理目录下所有 mp4
+uv run revideo ./videos/ -o output/
+
+# 多文件处理后拼合为一个视频
+uv run revideo a.mp4 b.mp4 c.mp4 -o output/ --concat
+
+# 添加片头片尾 + 背景音乐
+uv run revideo video.mp4 --intro 片头.mp4 --outro 片尾.mp4 --bgm music.mp3
+
+# MCP 模式（接入大模型）
+uv run revideo --mcp
+```
+
+## 输出格式
+
+处理完成后，单文件输出 `源文件_已处理.mp4`，合并输出 `源文件_合并.mp4`：
+
+```
+视频A.mp4→视频A_已处理.mp4
+视频B.mp4→视频B_已处理.mp4
+已合并到 视频A_合并.mp4
+```
+
+## 参数说明
+
+| 参数 | 说明 |
+|------|------|
+| `input` | 输入视频文件或目录（可多个） |
+| `-o, --output` | 输出目录，默认 `output` |
+| `--preset {light\|standard\|heavy}` | 预设力度，默认 `standard` |
+| `--no-video` | 禁用视频层面所有处理 |
+| `--no-audio` | 禁用音频层面所有处理 |
+| `--no-metadata` | 禁用元数据层面所有处理 |
+| `--only-video` | 仅启用视频层面（可叠加 `--only-audio`） |
+| `--only-audio` | 仅启用音频层面 |
+| `--only-metadata` | 仅启用元数据层面 |
+| `--concat` | 多文件处理完成后拼合为单个视频 |
+| `--intro` | 片头文件 |
+| `--outro` | 片尾文件 |
+| `--bgm` | 背景音乐文件 |
+| `--mcp` | 启动 MCP stdio 服务器 |
+| `--keep-original` | 保留中间文件（调试用） |
+
+## 预设说明
+
+| 预设 | 启用组 | 说明 |
+|------|--------|------|
+| `light` | video | 仅画面处理，快速去重 |
+| `standard` | video + audio + metadata | 全组启用（默认） |
+| `heavy` | 全部 | 全组启用 + 更激进参数 |
+
+## 伪原创手段详解
+
+### 1. 视频层面 (video) — 影响画面像素
+
+| 方法 | 说明 | 随机范围 |
+|------|------|----------|
+| 裁切 (crop) | 切除画面边缘像素 | 1%~3% 边缘 |
+| 缩放 (scale) | 轻微放大缩小 | 1.01x~1.05x |
+| 镜像翻转 (mirror) | 水平或垂直翻转 | 随机二选一 |
+| 旋转 (rotate) | 小角度倾斜 | ±0.5°~2° |
+| 色彩调整 (color) | 微调色相/饱和度/亮度 | 色相±10, 饱和度0.95~1.05 |
+| 锐化/模糊 (sharpen) | 轻微锐化或高斯模糊 | — |
+| 变速 (speed) | 微变速并补偿音频音调 | 0.95x~1.05x |
+| 帧率修改 (framerate) | 修改输出帧率后平滑 | — |
+| 场景分割重组 (scene-split) | 场景/静音检测→乱序→拼接 | 阈值可调 |
+| 片段倒放 (reverse) | 随机短片段倒放 | — |
+| 画中画 (pip) | 角落叠加缩小版画面 | 右下角 |
+| 水印/蒙版 (watermark) | 半透明图层 | — |
+| 边框特效 (border) | 装饰边框/模糊边框 | — |
+| 字幕/贴图 | 硬编码文字或贴图 | — |
+| 片头/片尾拼接 | 拼接指定素材到首尾 | — |
+| 片段插入 | 插入无关素材片段 | — |
+| 总时长修改 | 综合变速+抽帧 | — |
+
+### 2. 音频层面 (audio) — 音频流处理
+
+| 方法 | 说明 |
+|------|------|
+| 背景音乐 (bgm) | 叠加 BGM，自动降低原声音量 (ducking) |
+| 音调调整 (pitch) | 轻微升降调而不改变速度 |
+| 音量曲线 (volume) | 随机化音量变化包络 |
+| 静音检测分割 | 在静音处分割视频片段 |
+| 静音移除 | 去除静音段落，压缩节奏 |
+
+### 3. 元数据层面 (metadata) — 容器/编码/文件
+
+| 方法 | 说明 |
+|------|------|
+| 格式转换 | 更换容器格式 (mp4↔mkv↔avi↔mov) |
+| 编码器变更 | 更换视频编码 (H.264↔H.265↔VP9) |
+| 元数据擦除 | 清除旧元数据，写入随机新数据 |
+| 文件哈希修改 | 末尾添加填充字节改变 MD5 |
+
+## MCP 模式
+
+启动 MCP 服务器后，大模型可通过 STDIO 调用：
+
+```bash
+uv run revideo --mcp
+```
+
+可用工具：
+- `process_video` — 处理单个视频，支持所有参数
+- `process_directory` — 批量处理目录，支持 concat 合并

revideo-1.0.0/README.md

@@ -0,0 +1,136 @@
+# revideo — 视频伪原创工具
+
+基于 ffmpeg 的视频去重处理工具，通过多种手段修改视频以应对平台原创检测。
+
+## 安装
+
+### 前置依赖
+
+- **Python ≥ 3.12**
+- **ffmpeg**（需在 PATH 中可用）
+
+```bash
+# 克隆项目
+git clone https://git.des8.com/heibai2006/revideo.git
+cd revideo
+
+# 安装依赖（uv 自动处理）
+uv sync
+```
+
+验证安装：
+```bash
+uv run revideo --help
+```
+
+## 快速开始
+
+```bash
+# 处理单个视频（输出到 output/ 目录）
+uv run revideo video.mp4 -o output/
+
+# 处理目录下所有 mp4
+uv run revideo ./videos/ -o output/
+
+# 多文件处理后拼合为一个视频
+uv run revideo a.mp4 b.mp4 c.mp4 -o output/ --concat
+
+# 添加片头片尾 + 背景音乐
+uv run revideo video.mp4 --intro 片头.mp4 --outro 片尾.mp4 --bgm music.mp3
+
+# MCP 模式（接入大模型）
+uv run revideo --mcp
+```
+
+## 输出格式
+
+处理完成后，单文件输出 `源文件_已处理.mp4`，合并输出 `源文件_合并.mp4`：
+
+```
+视频A.mp4→视频A_已处理.mp4
+视频B.mp4→视频B_已处理.mp4
+已合并到 视频A_合并.mp4
+```
+
+## 参数说明
+
+| 参数 | 说明 |
+|------|------|
+| `input` | 输入视频文件或目录（可多个） |
+| `-o, --output` | 输出目录，默认 `output` |
+| `--preset {light\|standard\|heavy}` | 预设力度，默认 `standard` |
+| `--no-video` | 禁用视频层面所有处理 |
+| `--no-audio` | 禁用音频层面所有处理 |
+| `--no-metadata` | 禁用元数据层面所有处理 |
+| `--only-video` | 仅启用视频层面（可叠加 `--only-audio`） |
+| `--only-audio` | 仅启用音频层面 |
+| `--only-metadata` | 仅启用元数据层面 |
+| `--concat` | 多文件处理完成后拼合为单个视频 |
+| `--intro` | 片头文件 |
+| `--outro` | 片尾文件 |
+| `--bgm` | 背景音乐文件 |
+| `--mcp` | 启动 MCP stdio 服务器 |
+| `--keep-original` | 保留中间文件（调试用） |
+
+## 预设说明
+
+| 预设 | 启用组 | 说明 |
+|------|--------|------|
+| `light` | video | 仅画面处理，快速去重 |
+| `standard` | video + audio + metadata | 全组启用（默认） |
+| `heavy` | 全部 | 全组启用 + 更激进参数 |
+
+## 伪原创手段详解
+
+### 1. 视频层面 (video) — 影响画面像素
+
+| 方法 | 说明 | 随机范围 |
+|------|------|----------|
+| 裁切 (crop) | 切除画面边缘像素 | 1%~3% 边缘 |
+| 缩放 (scale) | 轻微放大缩小 | 1.01x~1.05x |
+| 镜像翻转 (mirror) | 水平或垂直翻转 | 随机二选一 |
+| 旋转 (rotate) | 小角度倾斜 | ±0.5°~2° |
+| 色彩调整 (color) | 微调色相/饱和度/亮度 | 色相±10, 饱和度0.95~1.05 |
+| 锐化/模糊 (sharpen) | 轻微锐化或高斯模糊 | — |
+| 变速 (speed) | 微变速并补偿音频音调 | 0.95x~1.05x |
+| 帧率修改 (framerate) | 修改输出帧率后平滑 | — |
+| 场景分割重组 (scene-split) | 场景/静音检测→乱序→拼接 | 阈值可调 |
+| 片段倒放 (reverse) | 随机短片段倒放 | — |
+| 画中画 (pip) | 角落叠加缩小版画面 | 右下角 |
+| 水印/蒙版 (watermark) | 半透明图层 | — |
+| 边框特效 (border) | 装饰边框/模糊边框 | — |
+| 字幕/贴图 | 硬编码文字或贴图 | — |
+| 片头/片尾拼接 | 拼接指定素材到首尾 | — |
+| 片段插入 | 插入无关素材片段 | — |
+| 总时长修改 | 综合变速+抽帧 | — |
+
+### 2. 音频层面 (audio) — 音频流处理
+
+| 方法 | 说明 |
+|------|------|
+| 背景音乐 (bgm) | 叠加 BGM，自动降低原声音量 (ducking) |
+| 音调调整 (pitch) | 轻微升降调而不改变速度 |
+| 音量曲线 (volume) | 随机化音量变化包络 |
+| 静音检测分割 | 在静音处分割视频片段 |
+| 静音移除 | 去除静音段落，压缩节奏 |
+
+### 3. 元数据层面 (metadata) — 容器/编码/文件
+
+| 方法 | 说明 |
+|------|------|
+| 格式转换 | 更换容器格式 (mp4↔mkv↔avi↔mov) |
+| 编码器变更 | 更换视频编码 (H.264↔H.265↔VP9) |
+| 元数据擦除 | 清除旧元数据，写入随机新数据 |
+| 文件哈希修改 | 末尾添加填充字节改变 MD5 |
+
+## MCP 模式
+
+启动 MCP 服务器后，大模型可通过 STDIO 调用：
+
+```bash
+uv run revideo --mcp
+```
+
+可用工具：
+- `process_video` — 处理单个视频，支持所有参数
+- `process_directory` — 批量处理目录，支持 concat 合并

revideo-1.0.0/pyproject.toml

@@ -0,0 +1,15 @@
+[project]
+name = "revideo"
+version = "1.0.0"
+description = "视频伪原创工具 - 基于 ffmpeg 的视频去重处理"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "fastmcp>=0.4.0",
+]
+
+[project.scripts]
+revideo = "revideo.cli:main"
+
+[tool.uv]
+package = true

revideo-1.0.0/revideo/__main__.py

@@ -0,0 +1,3 @@
+from revideo.cli import main
+
+main()

revideo-1.0.0/revideo/cli.py

@@ -0,0 +1,97 @@
+import argparse
+import sys
+from pathlib import Path
+
+from revideo.config import PRESET_MAP, ProcessingConfig, VideoGroupConfig, AudioGroupConfig, MetadataGroupConfig
+
+
+def parse_args(argv: list[str] | None = None) -> tuple[list[str], ProcessingConfig, bool, argparse.ArgumentParser]:
+    parser = argparse.ArgumentParser(
+        prog="revideo",
+        description="视频伪原创工具 — 基于 ffmpeg 的视频去重处理",
+        epilog="""模式说明:
+  CLI 模式    直接传入视频文件或目录进行伪原创处理，3组开关灵活控制
+  MCP 模式    通过 --mcp 启动 STDIO 服务器，供大模型调用
+
+示例:
+  uv run revideo video.mp4 -o output/
+  uv run revideo ./videos/ -o output/ --no-audio
+  uv run revideo a.mp4 b.mp4 -o output/ --concat
+  uv run revideo video.mp4 --intro 片头.mp4 --outro 片尾.mp4 --bgm music.mp3
+  uv run revideo --mcp""",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+
+    parser.add_argument("input", nargs="*", help="输入视频文件或目录")
+    parser.add_argument("-o", "--output", default="output", help="输出目录")
+    parser.add_argument("--preset", choices=["light", "standard", "heavy"], default="standard", help="预设力度")
+
+    parser.add_argument("--no-video", action="store_true", help="禁用视频层面所有处理")
+    parser.add_argument("--no-audio", action="store_true", help="禁用音频层面所有处理")
+    parser.add_argument("--no-metadata", action="store_true", help="禁用元数据层面所有处理")
+
+    parser.add_argument("--only-video", action="store_true", help="仅启用视频层面处理")
+    parser.add_argument("--only-audio", action="store_true", help="仅启用音频层面处理")
+    parser.add_argument("--only-metadata", action="store_true", help="仅启用元数据层面处理")
+
+    parser.add_argument("--intro", type=str, default=None, help="片头文件")
+    parser.add_argument("--outro", type=str, default=None, help="片尾文件")
+    parser.add_argument("--bgm", type=str, default=None, help="背景音乐文件")
+    parser.add_argument("--keep-original", action="store_true", help="保留中间文件")
+    parser.add_argument("--concat", action="store_true", help="多文件处理完成后拼合成一个视频")
+    parser.add_argument("--mcp", action="store_true", help="启动 MCP stdio 模式服务器")
+
+    args = parser.parse_args(argv)
+
+    config = ProcessingConfig(
+        output_dir=args.output,
+        intro=args.intro,
+        outro=args.outro,
+        bgm=args.bgm,
+        keep_original=args.keep_original,
+        concat=args.concat,
+        preset=args.preset,
+    )
+
+    # Apply preset
+    if args.preset in PRESET_MAP:
+        p = PRESET_MAP[args.preset]
+        if "video" in p:
+            config.video = VideoGroupConfig(**{**config.video.__dict__, **p["video"]})
+        if "audio" in p:
+            config.audio = AudioGroupConfig(**{**config.audio.__dict__, **p["audio"]})
+        if "metadata" in p:
+            config.metadata = MetadataGroupConfig(**{**config.metadata.__dict__, **p["metadata"]})
+
+    # --no-{group} overrides
+    if args.no_video:
+        config.video.enabled = False
+    if args.no_audio:
+        config.audio.enabled = False
+    if args.no_metadata:
+        config.metadata.enabled = False
+
+    # --only-{group} overrides: if any --only is set, disable groups not mentioned
+    only_set = [k for k in ("video", "audio", "metadata") if getattr(args, f"only_{k}")]
+    if only_set:
+        config.video.enabled = "video" in only_set
+        config.audio.enabled = "audio" in only_set
+        config.metadata.enabled = "metadata" in only_set
+
+    return args.input, config, args.mcp, parser
+
+
+def main():
+    inputs, config, mcp_mode, parser = parse_args()
+
+    if mcp_mode:
+        from revideo.mcp_server import run_mcp
+        run_mcp()
+        return
+
+    if not inputs:
+        parser.print_help()
+        sys.exit(0)
+
+    from revideo.pipeline import run_pipeline
+    run_pipeline(inputs, config)

revideo-1.0.0/revideo/config.py

@@ -0,0 +1,76 @@
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class VideoGroupConfig:
+    enabled: bool = True
+    crop: bool = True
+    scale: bool = True
+    mirror: bool = True
+    rotate: bool = True
+    color: bool = True
+    sharpen: bool = True
+    speed: bool = True
+    framerate: bool = True
+    scene_split: bool = True
+    reverse: bool = True
+    pip: bool = True
+    watermark: bool = True
+    border: bool = True
+    subtitle: bool = True
+    intro_outro: bool = True
+    insert: bool = True
+    duration: bool = True
+
+
+@dataclass
+class AudioGroupConfig:
+    enabled: bool = True
+    bgm: bool = True
+    pitch: bool = True
+    volume: bool = True
+    silence_split: bool = True
+    silence_remove: bool = True
+
+
+@dataclass
+class MetadataGroupConfig:
+    enabled: bool = True
+    format: bool = True
+    codec: bool = True
+    metadata: bool = True
+    file_hash: bool = True
+
+
+@dataclass
+class ProcessingConfig:
+    video: VideoGroupConfig = field(default_factory=VideoGroupConfig)
+    audio: AudioGroupConfig = field(default_factory=AudioGroupConfig)
+    metadata: MetadataGroupConfig = field(default_factory=MetadataGroupConfig)
+    output_dir: str = "output"
+    intro: Optional[str] = None
+    outro: Optional[str] = None
+    bgm: Optional[str] = None
+    keep_original: bool = False
+    concat: bool = False
+    preset: str = "standard"
+
+
+PRESET_MAP = {
+    "light": {
+        "video": {"enabled": True},
+        "audio": {"enabled": False},
+        "metadata": {"enabled": False},
+    },
+    "standard": {
+        "video": {"enabled": True},
+        "audio": {"enabled": True},
+        "metadata": {"enabled": True},
+    },
+    "heavy": {
+        "video": {"enabled": True},
+        "audio": {"enabled": True},
+        "metadata": {"enabled": True},
+    },
+}

revideo-1.0.0/revideo/mcp_server.py

@@ -0,0 +1,56 @@
+from fastmcp import FastMCP
+
+from revideo.config import ProcessingConfig
+from revideo.pipeline import run_pipeline
+
+mcp = FastMCP("revideo")
+
+
+@mcp.tool()
+def process_video(input_path: str, output_dir: str = "output",
+                  preset: str = "standard",
+                  no_video: bool = False, no_audio: bool = False,
+                  no_metadata: bool = False,
+                  only_video: bool = False, only_audio: bool = False,
+                  only_metadata: bool = False,
+                  intro: str | None = None, outro: str | None = None,
+                  bgm: str | None = None,
+                  concat: bool = False) -> str:
+    config = ProcessingConfig(
+        output_dir=output_dir,
+        preset=preset,
+        intro=intro,
+        outro=outro,
+        bgm=bgm,
+        concat=concat,
+    )
+    if no_video:
+        config.video.enabled = False
+    if no_audio:
+        config.audio.enabled = False
+    if no_metadata:
+        config.metadata.enabled = False
+    only_set = [k for k, v in [("video", only_video), ("audio", only_audio), ("metadata", only_metadata)] if v]
+    if only_set:
+        config.video.enabled = "video" in only_set
+        config.audio.enabled = "audio" in only_set
+        config.metadata.enabled = "metadata" in only_set
+
+    run_pipeline([input_path], config)
+    return f"处理完成: {input_path}"
+
+
+@mcp.tool()
+def process_directory(dir_path: str, output_dir: str = "output",
+                      preset: str = "standard",
+                      concat: bool = False) -> str:
+    import glob
+    from pathlib import Path
+    videos = sorted(glob.glob(str(Path(dir_path) / "*.mp4")))
+    config = ProcessingConfig(output_dir=output_dir, preset=preset, concat=concat)
+    run_pipeline(videos, config)
+    return f"批量处理完成: {len(videos)} 个文件"
+
+
+def run_mcp():
+    mcp.run(transport="stdio")

revideo-1.0.0/revideo/pipeline.py

@@ -0,0 +1,150 @@
+import shutil
+import sys
+from pathlib import Path
+
+from revideo.config import ProcessingConfig
+from revideo.utils.ffmpeg import run
+from revideo.utils.tempfile import TempDir
+
+
+def resolve_inputs(inputs: list[str]) -> tuple[list[Path], Path | None, Path | None]:
+    files: list[Path] = []
+    intro: Path | None = None
+    outro: Path | None = None
+
+    for name in inputs:
+        p = Path(name)
+        stem = p.stem
+        if stem == "片头":
+            intro = p
+        elif stem == "片尾":
+            outro = p
+        else:
+            files.append(p)
+
+    return files, intro, outro
+
+
+def concat_videos(video_paths: list[Path], output_path: Path):
+    n = len(video_paths)
+
+    # Probe first video for target dimensions
+    from revideo.utils.ffmpeg import probe
+    info = probe(str(video_paths[0]))
+    streams = info.get("streams", [])
+    vinfo = next((s for s in streams if s["codec_type"] == "video"), {})
+    tw = vinfo.get("width", 640)
+    th = vinfo.get("height", 360)
+    # Ensure even dimensions
+    tw += tw % 2
+    th += th % 2
+
+    inputs = []
+    for p in video_paths:
+        inputs += ["-i", str(p)]
+
+    filter_parts = []
+    for i in range(n):
+        filter_parts.append(
+            f"[{i}:v]scale={tw}:{th}:force_original_aspect_ratio=1,"
+            f"pad={tw}:{th}:(ow-iw)/2:(oh-ih)/2,setsar=1[v{i}];"
+            f"[{i}:a]aresample=44100[a{i}];"
+        )
+    filter_parts.append("".join(f"[v{i}][a{i}]" for i in range(n)) + f"concat=n={n}:v=1:a=1[outv][outa]")
+
+    run(inputs + [
+        "-filter_complex", "".join(filter_parts),
+        "-map", "[outv]", "-map", "[outa]",
+        "-crf", "18", str(output_path)
+    ])
+
+
+def process_single(input_path: Path, output_path: Path, config: ProcessingConfig):
+    print(f"{input_path.name}→{output_path.name}")
+
+    current = input_path
+    temp_files: list[Path] = []
+
+    if config.video.enabled:
+        from revideo.processors.crop import CropProcessor
+        from revideo.processors.scale import ScaleProcessor
+        from revideo.processors.mirror import MirrorProcessor
+        from revideo.processors.rotate import RotateProcessor
+        from revideo.processors.color import ColorProcessor
+        from revideo.processors.speed import SpeedProcessor
+
+        processors = []
+        if config.video.crop:
+            processors.append(CropProcessor(config))
+        if config.video.scale:
+            processors.append(ScaleProcessor(config))
+        if config.video.mirror:
+            processors.append(MirrorProcessor(config))
+        if config.video.rotate:
+            processors.append(RotateProcessor(config))
+        if config.video.color:
+            processors.append(ColorProcessor(config))
+        if config.video.speed:
+            processors.append(SpeedProcessor(config))
+
+        for processor in processors:
+            tmp = output_path.with_suffix(f".{processor.name}{output_path.suffix}")
+            current = processor.process(current, tmp)
+            temp_files.append(tmp)
+
+    if config.audio.enabled and config.bgm:
+        from revideo.processors.audio_bgm import BgmProcessor
+        if config.audio.bgm:
+            proc = BgmProcessor(config)
+            tmp = output_path.with_suffix(f".bgm{output_path.suffix}")
+            current = proc.process(current, tmp)
+            temp_files.append(tmp)
+
+    if config.metadata.enabled:
+        from revideo.processors.metadata import MetadataProcessor
+        from revideo.processors.file_hash import FileHashProcessor
+        if config.metadata.metadata:
+            proc = MetadataProcessor(config)
+            tmp = output_path.with_suffix(f".meta{output_path.suffix}")
+            current = proc.process(current, tmp)
+            temp_files.append(tmp)
+        if config.metadata.file_hash:
+            proc = FileHashProcessor(config)
+            current = proc.process(current, output_path)
+
+    if current != output_path:
+        shutil.move(str(current), str(output_path))
+
+    if not config.keep_original:
+        for f in temp_files:
+            if f.exists() and f != current:
+                f.unlink(missing_ok=True)
+
+    print(f"完成: {output_path}")
+
+
+def run_pipeline(inputs: list[str], config: ProcessingConfig):
+    files, intro, outro = resolve_inputs(inputs)
+
+    if not files:
+        print("错误: 未找到可处理的视频文件")
+        sys.exit(1)
+
+    out_dir = Path(config.output_dir)
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    if config.concat and len(files) > 1:
+        with TempDir(keep=config.keep_original) as tmp_dir:
+            processed = []
+            for f in files:
+                tmp_path = tmp_dir / f.name
+                process_single(f, tmp_path, config)
+                processed.append(tmp_path)
+            first_stem = files[0].stem
+            out_path = out_dir / f"{first_stem}_合并.mp4"
+            concat_videos(processed, out_path)
+            print(f"已合并到 {out_path.name}")
+    else:
+        for f in files:
+            out_path = out_dir / f"{f.stem}_已处理{f.suffix}"
+            process_single(f, out_path, config)

revideo-1.0.0/revideo/processors/audio_bgm.py

@@ -0,0 +1,18 @@
+from pathlib import Path
+from revideo.processors.base import Processor
+from revideo.utils.ffmpeg import run
+
+
+class BgmProcessor(Processor):
+    name = "bgm"
+
+    def process(self, input_path: Path, output_path: Path) -> Path:
+        bgm_path = self.config.bgm
+        if not bgm_path:
+            return input_path
+        run(["-i", str(input_path), "-i", str(bgm_path),
+             "-filter_complex",
+             "[1:a]volume=0.15[bgm];[0:a][bgm]amix=inputs=2:duration=first:dropout_transition=2[out]",
+             "-map", "0:v", "-map", "[out]", "-c:v", "copy",
+             "-crf", "18", str(output_path)])
+        return output_path

revideo-1.0.0/revideo/processors/base.py

@@ -0,0 +1,12 @@
+from pathlib import Path
+from revideo.utils.ffmpeg import run
+
+
+class Processor:
+    name: str = "base"
+
+    def __init__(self, config: object):
+        self.config = config
+
+    def process(self, input_path: Path, output_path: Path) -> Path:
+        raise NotImplementedError

revideo-1.0.0/revideo/processors/color.py

@@ -0,0 +1,17 @@
+import random
+from pathlib import Path
+from revideo.processors.base import Processor
+from revideo.utils.ffmpeg import run
+
+
+class ColorProcessor(Processor):
+    name = "color"
+
+    def process(self, input_path: Path, output_path: Path) -> Path:
+        h = random.uniform(-10, 10)
+        s = random.uniform(0.95, 1.05)
+        b = random.uniform(0.95, 1.05)
+        run(["-i", str(input_path),
+             "-vf", f"hue=h={h}:s={s},eq=brightness={b-1:.3f}",
+             "-c:a", "copy", "-crf", "18", str(output_path)])
+        return output_path

revideo-1.0.0/revideo/processors/crop.py

@@ -0,0 +1,15 @@
+import random
+from pathlib import Path
+from revideo.processors.base import Processor
+from revideo.utils.ffmpeg import run
+
+
+class CropProcessor(Processor):
+    name = "crop"
+
+    def process(self, input_path: Path, output_path: Path) -> Path:
+        crop_pct = random.uniform(0.01, 0.03)
+        run(["-i", str(input_path),
+             "-vf", f"crop=iw*(1-{crop_pct}):ih*(1-{crop_pct})",
+             "-c:a", "copy", "-crf", "18", str(output_path)])
+        return output_path

revideo-1.0.0/revideo/processors/file_hash.py

@@ -0,0 +1,15 @@
+import os
+from pathlib import Path
+from revideo.processors.base import Processor
+
+
+class FileHashProcessor(Processor):
+    name = "filehash"
+
+    def process(self, input_path: Path, output_path: Path) -> Path:
+        if input_path != output_path:
+            import shutil
+            shutil.copy2(input_path, output_path)
+        with open(output_path, "ab") as f:
+            f.write(b"\x00" * 1024)
+        return output_path

revideo-1.0.0/revideo/processors/metadata.py

@@ -0,0 +1,16 @@
+from pathlib import Path
+from revideo.processors.base import Processor
+from revideo.utils.ffmpeg import run
+
+
+class MetadataProcessor(Processor):
+    name = "metadata"
+
+    def process(self, input_path: Path, output_path: Path) -> Path:
+        run(["-i", str(input_path),
+             "-map_metadata", "-1",
+             "-metadata", "title=Video",
+             "-metadata", "artist=revideo",
+             "-metadata", "comment=processed by revideo",
+             "-c", "copy", str(output_path)])
+        return output_path

revideo-1.0.0/revideo/processors/mirror.py

@@ -0,0 +1,14 @@
+import random
+from pathlib import Path
+from revideo.processors.base import Processor
+from revideo.utils.ffmpeg import run
+
+
+class MirrorProcessor(Processor):
+    name = "mirror"
+
+    def process(self, input_path: Path, output_path: Path) -> Path:
+        flip = random.choice(["hflip", "vflip"])
+        run(["-i", str(input_path),
+             "-vf", flip, "-c:a", "copy", "-crf", "18", str(output_path)])
+        return output_path

revideo-1.0.0/revideo/processors/rotate.py

@@ -0,0 +1,17 @@
+import random
+import math
+from pathlib import Path
+from revideo.processors.base import Processor
+from revideo.utils.ffmpeg import run
+
+
+class RotateProcessor(Processor):
+    name = "rotate"
+
+    def process(self, input_path: Path, output_path: Path) -> Path:
+        angle = random.uniform(0.5, 2.0) * random.choice([-1, 1])
+        rad = angle * math.pi / 180
+        run(["-i", str(input_path),
+             "-vf", f"rotate={rad}:c=black@0",
+             "-c:a", "copy", "-crf", "18", str(output_path)])
+        return output_path

revideo-1.0.0/revideo/processors/scale.py

@@ -0,0 +1,15 @@
+import random
+from pathlib import Path
+from revideo.processors.base import Processor
+from revideo.utils.ffmpeg import run
+
+
+class ScaleProcessor(Processor):
+    name = "scale"
+
+    def process(self, input_path: Path, output_path: Path) -> Path:
+        factor = random.uniform(1.01, 1.05)
+        run(["-i", str(input_path),
+             "-vf", f"scale=iw*{factor}:ih*{factor}:flags=bilinear",
+             "-c:a", "copy", "-crf", "18", str(output_path)])
+        return output_path

revideo-1.0.0/revideo/processors/speed.py

@@ -0,0 +1,17 @@
+import random
+from pathlib import Path
+from revideo.processors.base import Processor
+from revideo.utils.ffmpeg import run
+
+
+class SpeedProcessor(Processor):
+    name = "speed"
+
+    def process(self, input_path: Path, output_path: Path) -> Path:
+        factor = random.uniform(0.95, 1.05)
+        audio_factor = 1.0 / factor
+        run(["-i", str(input_path),
+             "-vf", f"setpts={factor}*PTS",
+             "-af", f"atempo={audio_factor}",
+             "-crf", "18", str(output_path)])
+        return output_path

revideo-1.0.0/revideo/utils/ffmpeg.py

@@ -0,0 +1,27 @@
+import subprocess
+import json
+from pathlib import Path
+
+
+def probe(path: str | Path) -> dict:
+    result = subprocess.run(
+        ["ffprobe", "-v", "quiet", "-print_format", "json", "-show_format", "-show_streams", str(path)],
+        capture_output=True, text=True, check=True,
+    )
+    return json.loads(result.stdout)
+
+
+def run(args: list[str], capture_output: bool = False) -> subprocess.CompletedProcess:
+    return subprocess.run(
+        ["ffmpeg", "-y"] + args,
+        capture_output=capture_output, text=True, check=True,
+    )
+
+
+def build_filter(args: list[str], filter_str: str, filter_complex: str | None = None) -> list[str]:
+    result = args[:]
+    if filter_complex:
+        result += ["-filter_complex", filter_complex]
+    else:
+        result += ["-vf", filter_str]
+    return result

revideo-1.0.0/revideo/utils/scene_detect.py

@@ -0,0 +1,38 @@
+import re
+import subprocess
+import json
+from pathlib import Path
+
+
+def detect_scenes(path: str | Path, threshold: float = 0.4) -> list[float]:
+    result = subprocess.run(
+        ["ffmpeg", "-i", str(path), "-vf", f"select='gt(scene,{threshold})',showinfo",
+         "-vsync", "vfr", "-f", "null", "-"],
+        capture_output=True, text=True, check=True,
+    )
+    timestamps = []
+    for line in result.stderr.splitlines():
+        m = re.search(r"pts_time:([\d.]+)", line)
+        if m:
+            timestamps.append(float(m.group(1)))
+    return timestamps
+
+
+def detect_silence(path: str | Path, noise_db: str = "-30dB", duration: str = "0.5") -> list[dict]:
+    result = subprocess.run(
+        ["ffmpeg", "-i", str(path), "-af", f"silencedetect=noise={noise_db}:d={duration}", "-f", "null", "-"],
+        capture_output=True, text=True, check=True,
+    )
+    silences = []
+    start, end = None, None
+    for line in result.stderr.splitlines():
+        m = re.search(r"silence_start: ([\d.]+)", line)
+        if m:
+            start = float(m.group(1))
+        m = re.search(r"silence_end: ([\d.]+)", line)
+        if m:
+            end = float(m.group(1))
+            if start is not None:
+                silences.append({"start": start, "end": end})
+                start = None
+    return silences

revideo-1.0.0/revideo/utils/tempfile.py

@@ -0,0 +1,17 @@
+import tempfile
+import shutil
+from pathlib import Path
+
+
+class TempDir:
+    def __init__(self, keep: bool = False):
+        self._keep = keep
+        self._path: Path | None = None
+
+    def __enter__(self) -> Path:
+        self._path = Path(tempfile.mkdtemp(prefix="revideo_"))
+        return self._path
+
+    def __exit__(self, *args):
+        if not self._keep and self._path and self._path.exists():
+            shutil.rmtree(self._path)

revideo-1.0.0/revideo.egg-info/PKG-INFO

@@ -0,0 +1,144 @@
+Metadata-Version: 2.4
+Name: revideo
+Version: 1.0.0
+Summary: 视频伪原创工具 - 基于 ffmpeg 的视频去重处理
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: fastmcp>=0.4.0
+
+# revideo — 视频伪原创工具
+
+基于 ffmpeg 的视频去重处理工具，通过多种手段修改视频以应对平台原创检测。
+
+## 安装
+
+### 前置依赖
+
+- **Python ≥ 3.12**
+- **ffmpeg**（需在 PATH 中可用）
+
+```bash
+# 克隆项目
+git clone https://git.des8.com/heibai2006/revideo.git
+cd revideo
+
+# 安装依赖（uv 自动处理）
+uv sync
+```
+
+验证安装：
+```bash
+uv run revideo --help
+```
+
+## 快速开始
+
+```bash
+# 处理单个视频（输出到 output/ 目录）
+uv run revideo video.mp4 -o output/
+
+# 处理目录下所有 mp4
+uv run revideo ./videos/ -o output/
+
+# 多文件处理后拼合为一个视频
+uv run revideo a.mp4 b.mp4 c.mp4 -o output/ --concat
+
+# 添加片头片尾 + 背景音乐
+uv run revideo video.mp4 --intro 片头.mp4 --outro 片尾.mp4 --bgm music.mp3
+
+# MCP 模式（接入大模型）
+uv run revideo --mcp
+```
+
+## 输出格式
+
+处理完成后，单文件输出 `源文件_已处理.mp4`，合并输出 `源文件_合并.mp4`：
+
+```
+视频A.mp4→视频A_已处理.mp4
+视频B.mp4→视频B_已处理.mp4
+已合并到 视频A_合并.mp4
+```
+
+## 参数说明
+
+| 参数 | 说明 |
+|------|------|
+| `input` | 输入视频文件或目录（可多个） |
+| `-o, --output` | 输出目录，默认 `output` |
+| `--preset {light\|standard\|heavy}` | 预设力度，默认 `standard` |
+| `--no-video` | 禁用视频层面所有处理 |
+| `--no-audio` | 禁用音频层面所有处理 |
+| `--no-metadata` | 禁用元数据层面所有处理 |
+| `--only-video` | 仅启用视频层面（可叠加 `--only-audio`） |
+| `--only-audio` | 仅启用音频层面 |
+| `--only-metadata` | 仅启用元数据层面 |
+| `--concat` | 多文件处理完成后拼合为单个视频 |
+| `--intro` | 片头文件 |
+| `--outro` | 片尾文件 |
+| `--bgm` | 背景音乐文件 |
+| `--mcp` | 启动 MCP stdio 服务器 |
+| `--keep-original` | 保留中间文件（调试用） |
+
+## 预设说明
+
+| 预设 | 启用组 | 说明 |
+|------|--------|------|
+| `light` | video | 仅画面处理，快速去重 |
+| `standard` | video + audio + metadata | 全组启用（默认） |
+| `heavy` | 全部 | 全组启用 + 更激进参数 |
+
+## 伪原创手段详解
+
+### 1. 视频层面 (video) — 影响画面像素
+
+| 方法 | 说明 | 随机范围 |
+|------|------|----------|
+| 裁切 (crop) | 切除画面边缘像素 | 1%~3% 边缘 |
+| 缩放 (scale) | 轻微放大缩小 | 1.01x~1.05x |
+| 镜像翻转 (mirror) | 水平或垂直翻转 | 随机二选一 |
+| 旋转 (rotate) | 小角度倾斜 | ±0.5°~2° |
+| 色彩调整 (color) | 微调色相/饱和度/亮度 | 色相±10, 饱和度0.95~1.05 |
+| 锐化/模糊 (sharpen) | 轻微锐化或高斯模糊 | — |
+| 变速 (speed) | 微变速并补偿音频音调 | 0.95x~1.05x |
+| 帧率修改 (framerate) | 修改输出帧率后平滑 | — |
+| 场景分割重组 (scene-split) | 场景/静音检测→乱序→拼接 | 阈值可调 |
+| 片段倒放 (reverse) | 随机短片段倒放 | — |
+| 画中画 (pip) | 角落叠加缩小版画面 | 右下角 |
+| 水印/蒙版 (watermark) | 半透明图层 | — |
+| 边框特效 (border) | 装饰边框/模糊边框 | — |
+| 字幕/贴图 | 硬编码文字或贴图 | — |
+| 片头/片尾拼接 | 拼接指定素材到首尾 | — |
+| 片段插入 | 插入无关素材片段 | — |
+| 总时长修改 | 综合变速+抽帧 | — |
+
+### 2. 音频层面 (audio) — 音频流处理
+
+| 方法 | 说明 |
+|------|------|
+| 背景音乐 (bgm) | 叠加 BGM，自动降低原声音量 (ducking) |
+| 音调调整 (pitch) | 轻微升降调而不改变速度 |
+| 音量曲线 (volume) | 随机化音量变化包络 |
+| 静音检测分割 | 在静音处分割视频片段 |
+| 静音移除 | 去除静音段落，压缩节奏 |
+
+### 3. 元数据层面 (metadata) — 容器/编码/文件
+
+| 方法 | 说明 |
+|------|------|
+| 格式转换 | 更换容器格式 (mp4↔mkv↔avi↔mov) |
+| 编码器变更 | 更换视频编码 (H.264↔H.265↔VP9) |
+| 元数据擦除 | 清除旧元数据，写入随机新数据 |
+| 文件哈希修改 | 末尾添加填充字节改变 MD5 |
+
+## MCP 模式
+
+启动 MCP 服务器后，大模型可通过 STDIO 调用：
+
+```bash
+uv run revideo --mcp
+```
+
+可用工具：
+- `process_video` — 处理单个视频，支持所有参数
+- `process_directory` — 批量处理目录，支持 concat 合并

revideo-1.0.0/revideo.egg-info/SOURCES.txt

@@ -0,0 +1,29 @@
+README.md
+pyproject.toml
+revideo/__init__.py
+revideo/__main__.py
+revideo/cli.py
+revideo/config.py
+revideo/mcp_server.py
+revideo/pipeline.py
+revideo.egg-info/PKG-INFO
+revideo.egg-info/SOURCES.txt
+revideo.egg-info/dependency_links.txt
+revideo.egg-info/entry_points.txt
+revideo.egg-info/requires.txt
+revideo.egg-info/top_level.txt
+revideo/processors/__init__.py
+revideo/processors/audio_bgm.py
+revideo/processors/base.py
+revideo/processors/color.py
+revideo/processors/crop.py
+revideo/processors/file_hash.py
+revideo/processors/metadata.py
+revideo/processors/mirror.py
+revideo/processors/rotate.py
+revideo/processors/scale.py
+revideo/processors/speed.py
+revideo/utils/__init__.py
+revideo/utils/ffmpeg.py
+revideo/utils/scene_detect.py
+revideo/utils/tempfile.py

revideo-1.0.0/revideo.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

revideo-1.0.0/revideo.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+revideo = revideo.cli:main

revideo-1.0.0/revideo.egg-info/requires.txt

@@ -0,0 +1 @@
+fastmcp>=0.4.0

revideo-1.0.0/revideo.egg-info/top_level.txt

@@ -0,0 +1 @@
+revideo

revideo-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+