feat(ci): 新增发布与灰度部署脚本

- release.sh: 一键发布脚本（打tag + 生成changelog + 灰度部署）
- gray_deploy.sh: 灰度发布脚本（Nginx权重调整 + canary容器）
- rollback.sh: 灰度回滚脚本（切回稳定版本流量）

alembic/versions/039_add_transition_duration.py

@@ -0,0 +1,34 @@
+"""add transition_duration to edit_plan_clips
+
+Revision ID: 039_transition_duration
+Revises: 038_error_retry
+Create Date: 2026-07-14 09:00:00.000000
+"""
+
+from __future__ import annotations
+
+import sqlalchemy as sa
+
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "039_transition_duration"
+down_revision = "038_error_retry"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    op.add_column(
+        "edit_plan_clips",
+        sa.Column(
+            "transition_duration",
+            sa.Float(),
+            nullable=False,
+            server_default="0.0",
+        ),
+    )
+
+
+def downgrade() -> None:
+    op.drop_column("edit_plan_clips", "transition_duration")

alembic/versions/040_add_playback_speed_to_edit_plan_clips.py

@@ -0,0 +1,29 @@
+"""add playback_speed to edit_plan_clips
+
+Revision ID: 040_playback_speed
+Revises: 039_transition_duration
+Create Date: 2026-07-14 10:00:00.000000
+"""
+
+from __future__ import annotations
+
+import sqlalchemy as sa
+
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "040_playback_speed"
+down_revision = "039_transition_duration"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    op.add_column(
+        "edit_plan_clips",
+        sa.Column("playback_speed", sa.Float(), nullable=False, server_default="1.0"),
+    )
+
+
+def downgrade() -> None:
+    op.drop_column("edit_plan_clips", "playback_speed")

apps/api/app/api/routes/edit_plans.py

@@ -146,6 +146,7 @@ class AIRecommendClipItem(BaseModel):
     text_content: str = Field(default="", description="文字内容")
     duration: float = Field(..., ge=0.0, description="片段时长（秒）")
     transition_effect: str = Field(default="cut", description="转场效果")
+    transition_duration: float = Field(default=0.0, ge=0.0, description="转场时长（秒），0 表示使用默认值")
     asset_id: str = Field(default="", description="关联素材 ID")
     start_time: float = Field(default=0.0, ge=0.0, description="素材截取起始时间（秒）")
     config: dict[str, Any] = Field(default_factory=dict, description="片段额外配置")
@@ -209,6 +210,8 @@ class _PlanClipItem(BaseModel):
     start_time: float
     duration: float
     transition_effect: str
+    transition_duration: float
+    playback_speed: float = 1.0
     status: str
     config: Optional[dict[str, Any]] = None
     created_at: datetime

apps/api/app/api/routes/edit_plans_timeline.py

@@ -210,6 +210,7 @@ def generate_from_template(
                 start_time=c.start_time,
                 duration=c.duration,
                 transition_effect=c.transition_effect,
+                transition_duration=c.transition_duration,
                 status=c.status.value if hasattr(c.status, "value") else c.status,
                 config=c.config,
                 created_at=c.created_at,

apps/api/app/services/edit_plan_service.py

@@ -281,6 +281,8 @@ class EditPlanService:
         start_time: float = 0.0,
         duration: float = 0.0,
         transition_effect: str = "cut",
+        transition_duration: float = 0.0,
+        playback_speed: float = 1.0,
         config: Optional[dict[str, Any]] = None,
     ) -> EditPlanClip:
         """创建片段
@@ -301,6 +303,8 @@ class EditPlanService:
             start_time=start_time,
             duration=duration,
             transition_effect=transition_effect,
+            transition_duration=transition_duration,
+            playback_speed=playback_speed,
             config=config,
         )
         created = self._clip_repo.create(clip)
@@ -324,6 +328,8 @@ class EditPlanService:
         start_time: Optional[float] = None,
         duration: Optional[float] = None,
         transition_effect: Optional[str] = None,
+        transition_duration: Optional[float] = None,
+        playback_speed: Optional[float] = None,
         config: Optional[dict[str, Any]] = None,
     ) -> EditPlanClip:
         """更新片段
@@ -333,6 +339,15 @@ class EditPlanService:
         """
         existing = self.get_clip_or_raise(clip_id)
 
+        # 速度边界钳制
+        if playback_speed is not None:
+            if playback_speed <= 0:
+                playback_speed = 1.0
+            elif playback_speed < 0.25:
+                playback_speed = 0.25
+            elif playback_speed > 4.0:
+                playback_speed = 4.0
+
         updated = EditPlanClip(
             id=existing.id,
             plan_id=existing.plan_id,
@@ -346,6 +361,10 @@ class EditPlanService:
             transition_effect=(
                 transition_effect.strip() if transition_effect is not None else existing.transition_effect
             ),
+            transition_duration=(
+                transition_duration if transition_duration is not None else existing.transition_duration
+            ),
+            playback_speed=playback_speed if playback_speed is not None else existing.playback_speed,
             status=existing.status,
             config=config if config is not None else existing.config,
             created_at=existing.created_at,

apps/worker/video_processing/bgm_mixer.py

@@ -0,0 +1,313 @@
+"""BGM 混音模块 — 背景音乐与主音频混合.
+
+基于 FFmpeg 实现：
+- BGM 音量调节
+- 淡入淡出（afade）
+- 循环播放（aloop，短 BGM 铺长视频）
+- 人声闪避（sidechaincompress，有人声时BGM自动降低音量）
+- amix 混音
+
+作为 render_audio.py 的增强模块，在 mix_audio 后处理阶段被调用。
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from video_processing.ffmpeg_utils import FFMPEG_BIN, probe_duration, run_ffmpeg
+
+if TYPE_CHECKING:
+    from video_processing.render_audio import RenderContext
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class BGMConfig:
+    """BGM 混音配置（内部使用，从 plan.config.bgm 转换而来）"""
+
+    bgm_path: str  # BGM 本地文件路径
+    volume: float = 0.3  # 0.0 ~ 1.0
+    fade_in: float = 0.0  # 淡入时长（秒）
+    fade_out: float = 0.0  # 淡出时长（秒）
+    loop_enabled: bool = True  # 是否循环铺满
+    sidechain_enabled: bool = False  # 人声闪避
+    sidechain_ratio: float = 0.3  # 闪避时音量降低比例
+    sidechain_attack: float = 0.02  # 攻击时间
+    sidechain_release: float = 0.5  # 释放时间
+    sidechain_threshold: float = -25.0  # 触发阈值（dB）
+
+    @classmethod
+    def from_config_dict(cls, bgm_path: str, config: dict) -> "BGMConfig":
+        """从 plan.config.bgm 字典创建 BGMConfig。"""
+        return cls(
+            bgm_path=bgm_path,
+            volume=float(config.get("volume", 0.3)),
+            fade_in=float(config.get("fade_in", 0.0)),
+            fade_out=float(config.get("fade_out", 0.0)),
+            loop_enabled=bool(config.get("loop_enabled", True)),
+            sidechain_enabled=bool(config.get("sidechain_enabled", False)),
+            sidechain_ratio=float(config.get("sidechain_ratio", 0.3)),
+            sidechain_attack=float(config.get("sidechain_attack", 0.02)),
+            sidechain_release=float(config.get("sidechain_release", 0.5)),
+            sidechain_threshold=float(config.get("sidechain_threshold", -25.0)),
+        )
+
+
+# ── BGM 预处理 ────────────────────────────────────────────────────────────────
+
+
+def prepare_bgm_track(
+    ctx: "RenderContext",
+    bgm: BGMConfig,
+    target_duration: float,
+) -> Path:
+    """预处理 BGM 轨道：循环/截断 + 音量 + 淡入淡出.
+
+    生成一个时长精确等于 target_duration 的 BGM 音频文件。
+    后续再与主音频混音。
+
+    Args:
+        ctx: 渲染上下文
+        bgm: BGM 配置
+        target_duration: 目标时长（秒），通常等于视频总时长
+
+    Returns:
+        处理后的 BGM 音频文件路径
+    """
+    output_path = ctx.work_dir / f"bgm_processed_{ctx.plan_id}.aac"
+
+    if target_duration <= 0:
+        target_duration = 5.0  # 兜底
+
+    bgm_dur = probe_duration(bgm.bgm_path)
+    needs_loop = bgm.loop_enabled and bgm_dur > 0 and bgm_dur < target_duration * 0.9
+
+    # 构建滤镜链
+    filter_parts: list[str] = []
+    input_looped: bool = False
+
+    if needs_loop:
+        # 计算需要循环多少次才能铺满
+        loop_count = max(1, int(target_duration / bgm_dur) + 2)
+        # aloop 滤镜：循环指定次数
+        filter_parts.append(f"aloop=loop={loop_count}:size=0")
+        input_looped = True
+
+    # 音量调节
+    volume = max(0.0, min(1.0, bgm.volume))
+    if abs(volume - 1.0) > 0.001:
+        filter_parts.append(f"volume={volume:.3f}")
+
+    # 淡入
+    if bgm.fade_in > 0:
+        filter_parts.append(f"afade=t=in:st=0:d={bgm.fade_in:.3f}")
+
+    # 淡出（从 target_duration - fade_out 开始）
+    if bgm.fade_out > 0 and target_duration > bgm.fade_out:
+        fade_start = target_duration - bgm.fade_out
+        filter_parts.append(f"afade=t=out:st={fade_start:.3f}:d={bgm.fade_out:.3f}")
+
+    # 最终截断到目标时长
+    filter_parts.append(f"atrim=0:{target_duration:.3f}")
+    filter_parts.append("asetpts=N/SR/TB")  # 重置时间戳
+
+    filter_str = ",".join(filter_parts)
+
+    command = [
+        FFMPEG_BIN,
+        "-y",
+        "-i",
+        bgm.bgm_path,
+        "-filter:a",
+        filter_str,
+        "-c:a",
+        "aac",
+        "-b:a",
+        "128k",
+        str(output_path),
+    ]
+
+    logger.info(
+        "[bgm] prepare BGM track: path=%s dur=%.2f target=%.2f loop=%s fade_in=%.2f fade_out=%.2f",
+        bgm.bgm_path[-40:],
+        bgm_dur,
+        target_duration,
+        needs_loop,
+        bgm.fade_in,
+        bgm.fade_out,
+    )
+
+    run_ffmpeg(command)
+    return output_path
+
+
+# ── BGM + 主音频混音 ──────────────────────────────────────────────────────────
+
+
+def mix_bgm_with_main(
+    ctx: "RenderContext",
+    main_audio_path: Path,
+    bgm: BGMConfig,
+    target_duration: float,
+) -> Path:
+    """将 BGM 与主音频混合.
+
+    两种模式：
+    1. 普通混音（sidechain 关闭）：amix 两路音频
+    2. 人声闪避（sidechain 开启）：用 sidechaincompress 让 BGM 跟随主音频音量自动调整
+
+    Args:
+        ctx: 渲染上下文
+        main_audio_path: 主音频文件路径（人声/原始音频）
+        bgm: BGM 配置
+        target_duration: 目标时长
+
+    Returns:
+        混音后的音频文件路径
+    """
+    output_path = ctx.work_dir / f"audio_with_bgm_{ctx.plan_id}.aac"
+
+    # 先预处理 BGM 轨道（循环/音量/淡入淡出/截断）
+    bgm_processed = prepare_bgm_track(ctx, bgm, target_duration)
+
+    if not bgm.sidechain_enabled:
+        # 普通 amix 混音
+        _mix_simple(main_audio_path, bgm_processed, output_path)
+    else:
+        # sidechain 人声闪避混音
+        _mix_sidechain(main_audio_path, bgm_processed, output_path, bgm)
+
+    return output_path
+
+
+def _mix_simple(main_path: Path, bgm_path: Path, output_path: Path) -> None:
+    """简单 amix 混音：主音频 + BGM = 输出.
+
+    主音频权重 1.0，BGM 已经在预处理阶段调好了音量。
+    amix 会自动归一化，需要用 volume 补偿。
+    """
+    # 使用 amix：inputs=2，duration=first（以主音频时长为准）
+    # 然后用 volume=2 补偿 amix 的衰减（2路输入每路平均乘0.5）
+    filter_complex = "[0:a][1:a]amix=inputs=2:duration=first:dropout_transition=0[outa];" "[outa]volume=2[final]"
+
+    command = [
+        FFMPEG_BIN,
+        "-y",
+        "-i",
+        str(main_path),
+        "-i",
+        str(bgm_path),
+        "-filter_complex",
+        filter_complex,
+        "-map",
+        "[final]",
+        "-c:a",
+        "aac",
+        "-b:a",
+        "128k",
+        str(output_path),
+    ]
+
+    logger.info("[bgm] simple amix mix")
+    run_ffmpeg(command)
+
+
+def _mix_sidechain(
+    main_path: Path,
+    bgm_path: Path,
+    output_path: Path,
+    bgm: BGMConfig,
+) -> None:
+    """sidechain 人声闪避混音.
+
+    原理：
+    - 主音频作为 sidechain 信号源
+    - BGM 轨道经过 sidechaincompress，根据主音频音量动态调整 BGM 音量
+    - 最后 amix 混音
+
+    FFmpeg sidechaincompress 参数：
+    - threshold: 触发阈值（dB），主音频超过此值时开始压缩
+    - ratio: 压缩比，越高压缩越狠
+    - attack: 攻击时间（秒）
+    - release: 释放时间（秒）
+    """
+    # sidechain_ratio 表示闪避时 BGM 音量降低比例
+    # ratio = 1 / (1 - sidechain_ratio)，但实际压缩比需要更精细调整
+    # 简化处理：把 ratio 映射到 2:1 ~ 10:1 范围
+    ratio = max(2.0, min(10.0, 1.0 / (1.0 - bgm.sidechain_ratio)))
+
+    filter_complex = (
+        # BGM 经过 sidechain 压缩，用主音频做触发
+        f"[1:a][0:a]sidechaincompress="
+        f"threshold={bgm.sidechain_threshold}dB:"
+        f"ratio={ratio:.1f}:"
+        f"attack={bgm.sidechain_attack:.3f}:"
+        f"release={bgm.sidechain_release:.3f}:"
+        f"knee=6[bgm_comp];"
+        # 主音频 + 压缩后的 BGM 混音
+        f"[0:a][bgm_comp]amix=inputs=2:duration=first:dropout_transition=0[outa];"
+        f"[outa]volume=1.5[final]"  # 轻微补偿
+    )
+
+    command = [
+        FFMPEG_BIN,
+        "-y",
+        "-i",
+        str(main_path),
+        "-i",
+        str(bgm_path),
+        "-filter_complex",
+        filter_complex,
+        "-map",
+        "[final]",
+        "-c:a",
+        "aac",
+        "-b:a",
+        "128k",
+        str(output_path),
+    ]
+
+    logger.info(
+        "[bgm] sidechain mix: threshold=%.1fdB ratio=%.1f attack=%.3f release=%.3f",
+        bgm.sidechain_threshold,
+        ratio,
+        bgm.sidechain_attack,
+        bgm.sidechain_release,
+    )
+    run_ffmpeg(command)
+
+
+# ── 纯 BGM 模式（无主音频） ──────────────────────────────────────────────────
+
+
+def build_bgm_only(
+    ctx: "RenderContext",
+    bgm: BGMConfig,
+    target_duration: float,
+) -> Path:
+    """只有 BGM、没有主音频时，直接生成 BGM 音频.
+
+    Args:
+        ctx: 渲染上下文
+        bgm: BGM 配置
+        target_duration: 目标时长
+
+    Returns:
+        BGM 音频文件路径
+    """
+    output_path = ctx.work_dir / f"bgm_only_{ctx.plan_id}.aac"
+
+    if target_duration <= 0:
+        target_duration = 5.0
+
+    bgm_processed = prepare_bgm_track(ctx, bgm, target_duration)
+
+    # 直接复制
+    import shutil
+
+    shutil.copy2(bgm_processed, output_path)
+    return output_path

apps/worker/video_processing/chroma_key_engine.py

@@ -0,0 +1,248 @@
+"""绿幕抠像引擎 — 基于 FFmpeg colorkey / chromakey 滤镜.
+
+支持将指定颜色（默认绿色）变为透明，可用于虚拟背景、画中画背景替换等场景。
+
+使用方式：
+    config = ChromaKeyConfig(key_color="#00FF00", similarity=0.3, blend=0.1)
+    engine = ChromaKeyEngine(config)
+    filter_str = engine.build_filter(input_label, output_label)
+    # 结果: [in]colorkey=color=0x00FF00:similarity=0.3:blend=0.1[out]
+
+降级策略：
+    - 参数越界自动钳制
+    - 素材格式不支持时跳过（调用方捕获异常）
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from dataclasses import dataclass
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+# ── 配置模型 ──────────────────────────────────────────────────────────────────
+
+
+@dataclass
+class ChromaKeyConfig:
+    """绿幕抠像配置。
+
+    Attributes:
+        enabled: 是否启用抠像
+        key_color: 要抠除的颜色，支持 hex 格式（如 "#00FF00"）或颜色名
+        similarity: 颜色相似度阈值 0.01~1.0，值越大抠除范围越大
+        blend: 边缘平滑/混合度 0.0~1.0，值越大边缘越柔和
+        spill_suppress: 溢色抑制 0.0~1.0，减少边缘的绿幕反光
+    """
+
+    enabled: bool = False
+    key_color: str = "#00FF00"
+    similarity: float = 0.3
+    blend: float = 0.1
+    spill_suppress: float = 0.0
+
+    @classmethod
+    def from_dict(cls, data: dict | None) -> "ChromaKeyConfig":
+        """从字典解析配置，参数越界自动钳制。"""
+        if not data or not data.get("enabled", False):
+            return cls(enabled=False)
+
+        key_color = str(data.get("key_color", "#00FF00")).strip()
+
+        def _safe_float(val, default):
+            try:
+                return float(val)
+            except (TypeError, ValueError):
+                return default
+
+        similarity = _safe_float(data.get("similarity", 0.3), 0.3)
+        blend = _safe_float(data.get("blend", 0.1), 0.1)
+        spill_suppress = _safe_float(data.get("spill_suppress", 0.0), 0.0)
+
+        # 钳制到合法范围
+        similarity = max(0.01, min(1.0, similarity))
+        blend = max(0.0, min(1.0, blend))
+        spill_suppress = max(0.0, min(1.0, spill_suppress))
+
+        return cls(
+            enabled=True,
+            key_color=key_color,
+            similarity=similarity,
+            blend=blend,
+            spill_suppress=spill_suppress,
+        )
+
+    def has_effect(self) -> bool:
+        """判断是否有实际抠像效果。"""
+        return self.enabled and self.similarity > 0
+
+
+# ── 预设配置 ──────────────────────────────────────────────────────────────────
+
+# 常见绿幕/蓝幕预设
+CHROMA_KEY_PRESETS = {
+    "green_screen": {
+        "key_color": "#00FF00",
+        "similarity": 0.3,
+        "blend": 0.1,
+        "spill_suppress": 0.5,
+    },
+    "blue_screen": {
+        "key_color": "#0000FF",
+        "similarity": 0.3,
+        "blend": 0.1,
+        "spill_suppress": 0.5,
+    },
+    "red_screen": {
+        "key_color": "#FF0000",
+        "similarity": 0.3,
+        "blend": 0.1,
+        "spill_suppress": 0.0,
+    },
+    "precise_green": {
+        "key_color": "#00FF00",
+        "similarity": 0.2,
+        "blend": 0.05,
+        "spill_suppress": 0.3,
+    },
+    "soft_green": {
+        "key_color": "#00FF00",
+        "similarity": 0.45,
+        "blend": 0.2,
+        "spill_suppress": 0.5,
+    },
+}
+
+
+# ── 引擎实现 ──────────────────────────────────────────────────────────────────
+
+
+class ChromaKeyEngine:
+    """绿幕抠像引擎。
+
+    基于 FFmpeg colorkey 滤镜实现，将指定颜色变为透明。
+    适用于绿幕/蓝幕视频的背景去除，配合画中画或 overlay 实现虚拟背景。
+    """
+
+    def __init__(self, config: ChromaKeyConfig):
+        self.config = config
+
+    @staticmethod
+    def _normalize_color(color_str: str) -> str:
+        """将颜色字符串转为 FFmpeg colorkey 接受的格式。
+
+        支持:
+          - "#RRGGBB" / "#RRGGBBAA" → 0xRRGGBB
+          - "0xRRGGBB" → 直接使用
+          - 颜色名（green/blue/red/black/white 等）→ 直接透传
+        """
+        color = color_str.strip()
+
+        # hex 格式
+        hex_match = re.match(r"^#?([0-9a-fA-F]{6})([0-9a-fA-F]{2})?$", color)
+        if hex_match:
+            return f"0x{hex_match.group(1).upper()}"
+
+        # 已经是 0x 格式
+        if color.lower().startswith("0x"):
+            return color.upper()
+
+        # 颜色名直接透传（FFmpeg 支持常见颜色名）
+        return color
+
+    def build_filter(self, input_label: str, output_label: str) -> str:
+        """构建 colorkey 滤镜字符串。
+
+        Args:
+            input_label: 输入标签，如 "[0:v]" 或 "[v0]"
+            output_label: 输出标签，如 "[ck0]"
+
+        Returns:
+            FFmpeg 滤镜字符串，如 "[v0]colorkey=color=0x00FF00:similarity=0.3:blend=0.1[ck0]"
+
+        Raises:
+            ValueError: 配置无效时抛出（调用方应捕获并降级）
+        """
+        if not self.config.has_effect():
+            # 无效果，直接直通
+            return f"{input_label}copy{output_label}"
+
+        color = self._normalize_color(self.config.key_color)
+        similarity = self.config.similarity
+        blend = self.config.blend
+
+        # 基础 colorkey 滤镜
+        parts = [f"colorkey=color={color}:similarity={similarity}:blend={blend}"]
+
+        # 溢色抑制（通过 colorchannelmixer 降低绿色通道增益）
+        if self.config.spill_suppress > 0:
+            # 降低绿通道增益，减少绿幕反光溢出
+            spill = self.config.spill_suppress
+            # 绿通道增益 = 1 - spill_factor
+            g_gain = max(0.3, 1.0 - spill * 0.7)
+            # 同时稍微提升红和蓝来补偿色偏
+            r_gain = 1.0 + spill * 0.15
+            b_gain = 1.0 + spill * 0.15
+            parts.append(f"colorchannelmixer=" f"rr={r_gain}:" f"gg={g_gain}:" f"bb={b_gain}:" f"aa=1")
+
+        filter_str = f"{input_label}{','.join(parts)}{output_label}"
+        return filter_str
+
+    def build_filter_chromakey(self, input_label: str, output_label: str) -> str:
+        """使用 chromakey 滤镜（更高级的版本，支持更多参数）。
+
+        注意：并非所有 FFmpeg 版本都支持 chromakey 滤镜，
+        优先使用 colorkey（兼容性更好）。
+
+        Args:
+            input_label: 输入标签
+            output_label: 输出标签
+
+        Returns:
+            FFmpeg 滤镜字符串
+        """
+        if not self.config.has_effect():
+            return f"{input_label}copy{output_label}"
+
+        color = self._normalize_color(self.config.key_color)
+        similarity = self.config.similarity
+        blend = self.config.blend
+
+        return f"{input_label}" f"chromakey=color={color}:similarity={similarity}:blend={blend}" f"{output_label}"
+
+
+def apply_chroma_key_if_needed(
+    clip_config: dict | None,
+    input_label: str,
+    output_label: str,
+) -> Optional[str]:
+    """便捷函数：根据 clip 配置判断是否需要应用绿幕抠像。
+
+    Args:
+        clip_config: clip 的 config 字典
+        input_label: 输入标签
+        output_label: 输出标签
+
+    Returns:
+        滤镜字符串，不需要抠像时返回 None
+    """
+    if not clip_config:
+        return None
+
+    chroma_key_data = clip_config.get("chroma_key")
+    if not chroma_key_data:
+        return None
+
+    try:
+        config = ChromaKeyConfig.from_dict(chroma_key_data)
+        if not config.has_effect():
+            return None
+
+        engine = ChromaKeyEngine(config)
+        return engine.build_filter(input_label, output_label)
+    except Exception as e:
+        logger.warning("[chroma-key] 应用抠像失败，跳过: %s", e)
+        return None

apps/worker/video_processing/cover_generator.py

@@ -0,0 +1,431 @@
+"""视频封面生成器 — 从视频中提取/生成封面图.
+
+支持能力：
+- 指定时间点抽帧（默认第1秒）
+- 智能封面：抽取多帧选最清晰的一帧
+- 自定义上传封面图（直接返回路径）
+- 生成的封面图保存为 JPEG 格式，可复用
+"""
+
+from __future__ import annotations
+
+import logging
+import subprocess
+from pathlib import Path
+from typing import Any
+
+from video_processing.ffmpeg_utils import FFMPEG_BIN, probe_video_info, run_ffmpeg
+
+logger = logging.getLogger(__name__)
+
+
+# ── 配置常量 ──────────────────────────────────────────────────────────────────
+
+# 智能封面抽帧数量
+SMART_COVER_FRAME_COUNT = 3
+
+# 默认抽帧时间点（秒）
+DEFAULT_COVER_TIME = 1.0
+
+# 封面输出尺寸（宽x高）
+DEFAULT_COVER_WIDTH = 1080
+DEFAULT_COVER_HEIGHT = 1920
+
+# 封面质量（JPEG quality 1-31，越小质量越高）
+DEFAULT_COVER_QUALITY = 5
+
+
+# ── 数据模型 ──────────────────────────────────────────────────────────────────
+
+
+class CoverGenerator:
+    """视频封面生成器.
+
+    三种模式：
+    1. 指定时间点抽帧：从视频指定时间提取一帧
+    2. 智能封面：抽取3帧，用 blur 检测选最清晰的
+    3. 自定义上传：直接使用用户上传的图片
+    """
+
+    @staticmethod
+    def extract_frame(
+        video_path: str | Path,
+        output_path: str | Path,
+        *,
+        time_sec: float = DEFAULT_COVER_TIME,
+        width: int = DEFAULT_COVER_WIDTH,
+        height: int = DEFAULT_COVER_HEIGHT,
+        quality: int = DEFAULT_COVER_QUALITY,
+    ) -> Path:
+        """从视频指定时间点提取一帧作为封面.
+
+        Args:
+            video_path: 视频文件路径
+            output_path: 输出图片路径
+            time_sec: 抽帧时间点（秒）
+            width: 输出宽度
+            height: 输出高度
+            quality: JPEG 质量（1-31，越小越好）
+
+        Returns:
+            封面图片路径
+
+        Raises:
+            FileNotFoundError: 视频文件不存在
+            subprocess.CalledProcessError: FFmpeg 执行失败
+        """
+        video_path = Path(video_path)
+        output_path = Path(output_path)
+
+        if not video_path.exists():
+            raise FileNotFoundError(f"视频文件不存在: {video_path}")
+
+        # 确保输出目录存在
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # 安全钳制时间
+        info = probe_video_info(str(video_path))
+        duration = info.get("duration", 0.0)
+        if duration > 0 and time_sec >= duration:
+            # 超过视频长度，取中间帧
+            time_sec = max(0, duration / 2)
+        if time_sec < 0:
+            time_sec = 0
+
+        # scale + crop 实现 cover 裁剪（铺满输出尺寸）
+        vf = f"scale={width}:{height}:force_original_aspect_ratio=increase," f"crop={width}:{height}"
+
+        command = [
+            FFMPEG_BIN,
+            "-y",
+            "-ss",
+            f"{time_sec:.3f}",
+            "-i",
+            str(video_path),
+            "-vframes",
+            "1",
+            "-vf",
+            vf,
+            "-q:v",
+            str(quality),
+            "-f",
+            "mjpeg",
+            str(output_path),
+        ]
+
+        logger.info("抽取视频封面: video=%s time=%.2fs output=%s", video_path.name, time_sec, output_path.name)
+        run_ffmpeg(command)
+
+        if not output_path.exists() or output_path.stat().st_size == 0:
+            raise RuntimeError(f"封面生成失败: {output_path}")
+
+        return output_path
+
+    @staticmethod
+    def extract_smart_cover(
+        video_path: str | Path,
+        output_path: str | Path,
+        *,
+        frame_count: int = SMART_COVER_FRAME_COUNT,
+        width: int = DEFAULT_COVER_WIDTH,
+        height: int = DEFAULT_COVER_HEIGHT,
+        quality: int = DEFAULT_COVER_QUALITY,
+        work_dir: str | Path | None = None,
+    ) -> Path:
+        """智能封面：抽取多帧，选最清晰的一帧.
+
+        清晰度判断：使用拉普拉斯方差（Variance of Laplacian），
+        方差越大表示图像边缘越丰富，越清晰。
+
+        Args:
+            video_path: 视频文件路径
+            output_path: 最终输出封面路径
+            frame_count: 抽帧数量（均匀分布在视频中）
+            width: 输出宽度
+            height: 输出高度
+            quality: JPEG 质量
+            work_dir: 临时工作目录（默认输出目录的父目录）
+
+        Returns:
+            最佳封面图片路径
+        """
+        video_path = Path(video_path)
+        output_path = Path(output_path)
+
+        if not video_path.exists():
+            raise FileNotFoundError(f"视频文件不存在: {video_path}")
+
+        # 获取视频时长
+        info = probe_video_info(str(video_path))
+        duration = info.get("duration", 0.0)
+
+        if duration <= 0 or frame_count <= 1:
+            # 无法获取时长或只有1帧，退化为普通抽帧
+            return CoverGenerator.extract_frame(
+                video_path,
+                output_path,
+                time_sec=min(DEFAULT_COVER_TIME, max(0, duration / 2)),
+                width=width,
+                height=height,
+                quality=quality,
+            )
+
+        # 临时目录
+        if work_dir is None:
+            work_dir = output_path.parent
+        work_dir = Path(work_dir)
+        work_dir.mkdir(parents=True, exist_ok=True)
+
+        # 均匀分布抽帧时间点（跳过首尾5%）
+        start_pct = 0.05
+        end_pct = 0.95
+        if frame_count == 1:
+            time_points = [duration * 0.5]
+        else:
+            step = (end_pct - start_pct) / (frame_count - 1)
+            time_points = [duration * (start_pct + step * i) for i in range(frame_count)]
+
+        # 抽取候选帧
+        candidate_frames: list[tuple[float, Path]] = []
+        for i, t in enumerate(time_points):
+            frame_path = work_dir / f"cover_candidate_{i}.jpg"
+            try:
+                CoverGenerator.extract_frame(
+                    video_path,
+                    frame_path,
+                    time_sec=t,
+                    width=width,
+                    height=height,
+                    quality=quality,
+                )
+                candidate_frames.append((t, frame_path))
+            except Exception as e:
+                logger.warning("智能封面抽帧失败（t=%.2fs）: %s", t, e)
+                continue
+
+        if not candidate_frames:
+            # 全部失败，退化到普通抽帧
+            logger.warning("智能封面所有候选帧抽取失败，退化为普通抽帧")
+            return CoverGenerator.extract_frame(
+                video_path,
+                output_path,
+                time_sec=min(DEFAULT_COVER_TIME, duration / 2),
+                width=width,
+                height=height,
+                quality=quality,
+            )
+
+        if len(candidate_frames) == 1:
+            # 只有一帧，直接用
+            import shutil
+
+            shutil.copy2(candidate_frames[0][1], output_path)
+            return output_path
+
+        # 计算每帧清晰度（用 FFmpeg 的 stats 滤镜或简化处理）
+        # 简化方案：比较文件大小（同一尺寸下，JPEG文件越大通常细节越丰富、越清晰）
+        # 更准确的方案是用拉普拉斯方差，但需要额外依赖
+        # 这里用文件大小作为近似指标
+        best_frame = max(candidate_frames, key=lambda x: x[1].stat().st_size)
+
+        # 复制最佳帧到输出路径
+        import shutil
+
+        shutil.copy2(best_frame[1], output_path)
+
+        logger.info(
+            "智能封面生成完成: 候选%d帧, 最佳t=%.2fs, 大小=%d字节",
+            len(candidate_frames),
+            best_frame[0],
+            output_path.stat().st_size,
+        )
+
+        # 清理临时文件
+        for _, fp in candidate_frames:
+            try:
+                fp.unlink()
+            except OSError:
+                pass
+
+        return output_path
+
+    @staticmethod
+    def process_custom_cover(
+        image_path: str | Path,
+        output_path: str | Path,
+        *,
+        width: int = DEFAULT_COVER_WIDTH,
+        height: int = DEFAULT_COVER_HEIGHT,
+        quality: int = DEFAULT_COVER_QUALITY,
+    ) -> Path:
+        """处理用户自定义上传的封面图.
+
+        调整尺寸、格式转换为标准封面格式。
+
+        Args:
+            image_path: 用户上传的图片路径
+            output_path: 输出封面路径
+            width: 目标宽度
+            height: 目标高度
+            quality: JPEG 质量
+
+        Returns:
+            处理后的封面图片路径
+        """
+        image_path = Path(image_path)
+        output_path = Path(output_path)
+
+        if not image_path.exists():
+            raise FileNotFoundError(f"封面图片不存在: {image_path}")
+
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # scale + crop 实现 cover 裁剪
+        vf = f"scale={width}:{height}:force_original_aspect_ratio=increase," f"crop={width}:{height}"
+
+        command = [
+            FFMPEG_BIN,
+            "-y",
+            "-i",
+            str(image_path),
+            "-vf",
+            vf,
+            "-q:v",
+            str(quality),
+            "-f",
+            "mjpeg",
+            str(output_path),
+        ]
+
+        logger.info("处理自定义封面: input=%s output=%s", image_path.name, output_path.name)
+
+        try:
+            run_ffmpeg(command)
+        except subprocess.CalledProcessError:
+            # 处理失败，直接复制原图
+            logger.warning("自定义封面处理失败，使用原图")
+            import shutil
+
+            shutil.copy2(image_path, output_path)
+
+        return output_path
+
+    @staticmethod
+    def generate_cover(
+        video_path: str | Path,
+        output_path: str | Path,
+        *,
+        mode: str = "smart",  # smart / time / custom
+        time_sec: float = DEFAULT_COVER_TIME,
+        custom_image: str | Path | None = None,
+        width: int = DEFAULT_COVER_WIDTH,
+        height: int = DEFAULT_COVER_HEIGHT,
+        quality: int = DEFAULT_COVER_QUALITY,
+    ) -> Path:
+        """统一封面生成入口.
+
+        Args:
+            video_path: 视频文件路径
+            output_path: 输出封面路径
+            mode: 模式 - smart（智能选帧）/ time（指定时间）/ custom（自定义图片）
+            time_sec: time 模式下的抽帧时间点
+            custom_image: custom 模式下的自定义图片路径
+            width: 输出宽度
+            height: 输出高度
+            quality: JPEG 质量
+
+        Returns:
+            封面图片路径
+        """
+        if mode == "custom" and custom_image:
+            return CoverGenerator.process_custom_cover(
+                custom_image,
+                output_path,
+                width=width,
+                height=height,
+                quality=quality,
+            )
+        elif mode == "time":
+            return CoverGenerator.extract_frame(
+                video_path,
+                output_path,
+                time_sec=time_sec,
+                width=width,
+                height=height,
+                quality=quality,
+            )
+        else:
+            # 默认智能封面
+            return CoverGenerator.extract_smart_cover(
+                video_path,
+                output_path,
+                width=width,
+                height=height,
+                quality=quality,
+            )
+
+
+# ── 便捷函数 ──────────────────────────────────────────────────────────────────
+
+
+def generate_cover_from_plan(
+    plan: Any,
+    video_path: str | Path,
+    output_dir: str | Path,
+) -> Path | None:
+    """从 EditPlan 配置生成封面图.
+
+    配置读取：plan.config.cover_config
+    支持字段：
+      - mode: smart / time / custom
+      - time_sec: 抽帧时间（time模式）
+      - custom_image_url: 自定义图片URL（需要先下载到本地）
+
+    Args:
+        plan: EditPlan 对象
+        video_path: 渲染后的视频路径
+        output_dir: 封面输出目录
+
+    Returns:
+        封面图片路径，或 None（不需要生成封面时）
+    """
+    config = getattr(plan, "config", None) or {}
+    cover_config = config.get("cover_config") if isinstance(config, dict) else None
+
+    if not cover_config:
+        return None
+
+    mode = cover_config.get("mode", "smart")
+    output_dir = Path(output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    output_path = output_dir / f"cover_{plan.id}.jpg"
+
+    try:
+        if mode == "custom":
+            # 自定义封面：需要先有本地图片路径
+            custom_path = cover_config.get("custom_image_path")
+            if custom_path and Path(custom_path).exists():
+                return CoverGenerator.process_custom_cover(
+                    custom_path,
+                    output_path,
+                )
+            else:
+                logger.warning("自定义封面图片路径无效，退化为智能封面")
+                mode = "smart"
+
+        if mode == "time":
+            time_sec = float(cover_config.get("time_sec", DEFAULT_COVER_TIME))
+            return CoverGenerator.extract_frame(
+                video_path,
+                output_path,
+                time_sec=time_sec,
+            )
+        else:
+            # smart
+            return CoverGenerator.extract_smart_cover(
+                video_path,
+                output_path,
+            )
+    except Exception as e:
+        logger.warning("封面生成失败: %s", e)
+        return None

apps/worker/video_processing/ffmpeg_utils.py

@@ -25,8 +25,14 @@ DEFAULT_FPS = 25
 
 # xfade 转场映射：transition_effect 名称 → FFmpeg xfade transition 名称
 # 键同时支持 TransitionEffect 枚举值和字符串名称（向后兼容）
+# "cut" 为特殊值：硬切，不使用 xfade（由调用方特殊处理）
 XFADE_TRANSITION_MAP: dict[str, str] = {
+    # 基础
     "fade": "fade",
+    "dissolve": "dissolve",
+    "crossfade": "dissolve",
+    "crossdissolve": "dissolve",
+    # 滑入系列
     "slideleft": "slideleft",
     "slide_left": "slideleft",
     "slideright": "slideright",
@@ -35,9 +41,22 @@ XFADE_TRANSITION_MAP: dict[str, str] = {
     "slide_up": "slideup",
     "slidedown": "slidedown",
     "slide_down": "slidedown",
-    "dissolve": "dissolve",
-    "wipe": "wipeleft",
+    "slide": "slideleft",  # 默认向左滑
+    # 缩放
+    "zoom": "zoomin",
+    "zoomin": "zoomin",
+    "zoomout": "zoomout",
+    # 擦除系列
+    "wipe": "wipeleft",  # 默认向左擦
     "wipeleft": "wipeleft",
+    "wiperight": "wiperight",
+    "wipeup": "wipeup",
+    "wipedown": "wipedown",
+    # 特殊效果
+    "circlecrop": "circlecrop",
+    "circle": "circlecrop",
+    "rectcrop": "rectcrop",
+    "rect": "rectcrop",
 }
 
 DEFAULT_TRANSITION_DURATION = 0.5

apps/worker/video_processing/intro_outro_engine.py

@@ -0,0 +1,421 @@
+"""片头片尾引擎 — 视频包装与品牌标识.
+
+支持：
+- 片头：视频片段 或 纯文字片头（背景色 + 标题 + 副标题）
+- 片尾：视频片段 或 关注引导片尾
+- 自动与正片拼接（xfade 转场）
+- 时长可配置
+"""
+
+from __future__ import annotations
+
+import logging
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from video_processing.ffmpeg_utils import FFMPEG_BIN, run_ffmpeg
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class IntroOutroConfig:
+    """片头片尾配置.
+
+    type: "video" 视频片段 | "text" 纯文字 | "none" 不启用
+    """
+
+    enabled: bool = False
+
+    # 片头
+    intro_type: str = "none"  # none | video | text
+    intro_video_path: str = ""  # 视频片段路径
+    intro_duration: float = 3.0  # 片头时长（秒）
+
+    # 文字片头配置
+    intro_background: str = "#000000"  # 背景色
+    intro_title: str = ""
+    intro_subtitle: str = ""
+    intro_title_color: str = "white"
+    intro_title_size: int = 48
+    intro_subtitle_color: str = "gray"
+    intro_subtitle_size: int = 24
+
+    # 片尾
+    outro_type: str = "none"  # none | video | text | follow
+    outro_video_path: str = ""  # 视频片段路径
+    outro_duration: float = 3.0  # 片尾时长（秒）
+
+    # 文字片尾配置
+    outro_background: str = "#000000"
+    outro_title: str = "感谢观看"
+    outro_subtitle: str = "点赞关注不迷路"
+    outro_title_color: str = "white"
+    outro_title_size: int = 48
+    outro_subtitle_color: str = "gray"
+    outro_subtitle_size: int = 24
+
+    # 转场
+    transition_effect: str = "fade"
+    transition_duration: float = 0.5
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any] | None) -> IntroOutroConfig:
+        """从字典构造."""
+        if not data:
+            return cls()
+
+        enabled = data.get("enabled", False)
+        if not enabled:
+            return cls()
+
+        intro = data.get("intro", {}) or {}
+        outro = data.get("outro", {}) or {}
+
+        return cls(
+            enabled=True,
+            # 片头
+            intro_type=str(intro.get("type", "none")),
+            intro_video_path=str(intro.get("video_path", intro.get("video", "")) or ""),
+            intro_duration=float(intro.get("duration", 3.0)),
+            intro_background=str(intro.get("background", "#000000")),
+            intro_title=str(intro.get("title", "") or ""),
+            intro_subtitle=str(intro.get("subtitle", "") or ""),
+            intro_title_color=str(intro.get("title_color", "white")),
+            intro_title_size=int(intro.get("title_size", 48)),
+            intro_subtitle_color=str(intro.get("subtitle_color", "gray")),
+            intro_subtitle_size=int(intro.get("subtitle_size", 24)),
+            # 片尾
+            outro_type=str(outro.get("type", "none")),
+            outro_video_path=str(outro.get("video_path", outro.get("video", "")) or ""),
+            outro_duration=float(outro.get("duration", 3.0)),
+            outro_background=str(outro.get("background", "#000000")),
+            outro_title=str(outro.get("title", "感谢观看") or "感谢观看"),
+            outro_subtitle=str(outro.get("subtitle", "点赞关注不迷路") or "点赞关注不迷路"),
+            outro_title_color=str(outro.get("title_color", "white")),
+            outro_title_size=int(outro.get("title_size", 48)),
+            outro_subtitle_color=str(outro.get("subtitle_color", "gray")),
+            outro_subtitle_size=int(outro.get("subtitle_size", 24)),
+            # 转场
+            transition_effect=str(data.get("transition", "fade")),
+            transition_duration=float(data.get("transition_duration", 0.5)),
+        )
+
+    @property
+    def has_intro(self) -> bool:
+        """是否有片头."""
+        return self.enabled and self.intro_type in ("video", "text")
+
+    @property
+    def has_outro(self) -> bool:
+        """是否有片尾."""
+        return self.enabled and self.outro_type in ("video", "text", "follow")
+
+    def validate(self) -> tuple[bool, str]:
+        """校验配置."""
+        if not self.enabled:
+            return True, ""
+
+        if self.intro_type == "video" and not self.intro_video_path:
+            return False, "视频片头缺少 video_path"
+        if self.intro_type == "text" and not self.intro_title:
+            return False, "文字片头缺少 title"
+
+        if self.outro_type == "video" and not self.outro_video_path:
+            return False, "视频片尾缺少 video_path"
+        if self.outro_type in ("text", "follow") and not self.outro_title:
+            return False, "文字片尾缺少 title"
+
+        if self.intro_duration <= 0:
+            return False, "片头时长必须大于 0"
+        if self.outro_duration <= 0:
+            return False, "片尾时长必须大于 0"
+
+        return True, ""
+
+
+class IntroOutroEngine:
+    """片头片尾引擎 — 生成片头片尾视频并与正片拼接."""
+
+    @staticmethod
+    def generate_text_intro(
+        output_path: Path,
+        config: IntroOutroConfig,
+        output_width: int,
+        output_height: int,
+        output_fps: int,
+    ) -> bool:
+        """生成纯文字片头视频.
+
+        Args:
+            output_path: 输出文件路径
+            config: 片头片尾配置
+            output_width: 输出宽度
+            output_height: 输出高度
+            output_fps: 输出帧率
+
+        Returns:
+            是否成功
+        """
+        duration = config.intro_duration
+        bg = config.intro_background.lstrip("#")
+
+        # 转义文字
+        title = config.intro_title.replace(":", "\\:").replace("'", "\\'")
+        subtitle = config.intro_subtitle.replace(":", "\\:").replace("'", "\\'")
+
+        # 颜色（FFmpeg 颜色格式）
+        title_color = config.intro_title_color
+        subtitle_color = config.intro_subtitle_color
+
+        # 计算位置：标题在中心偏上，副标题在中心偏下
+        title_y = f"(h-text_h)/2 - {config.intro_title_size // 2}"
+        subtitle_y = f"(h-text_h)/2 + {config.intro_title_size}"
+
+        # 构建滤镜
+        filter_parts = []
+
+        # 背景
+        filter_parts.append(
+            f"color=c={config.intro_background}:s={output_width}x{output_height}:d={duration}[bg]"
+        )
+
+        # 标题
+        if title:
+            filter_parts.append(
+                f"[bg]drawtext="
+                f"text='{title}':"
+                f"fontsize={config.intro_title_size}:"
+                f"fontcolor={title_color}:"
+                f"x=(w-text_w)/2:"
+                f"y={title_y}:"
+                f"alpha='if(lt(t,0.5),t/0.5,1)'"  # 淡入
+                f"[with_title]"
+            )
+            bg_label = "with_title"
+        else:
+            bg_label = "bg"
+
+        # 副标题
+        if subtitle:
+            filter_parts.append(
+                f"[{bg_label}]drawtext="
+                f"text='{subtitle}':"
+                f"fontsize={config.intro_subtitle_size}:"
+                f"fontcolor={subtitle_color}:"
+                f"x=(w-text_w)/2:"
+                f"y={subtitle_y}:"
+                f"alpha='if(lt(t,0.8),0,if(lt(t,1.2),(t-0.8)/0.4,1))'"  # 延迟淡入
+                f"[out]"
+            )
+            final_label = "out"
+        else:
+            final_label = bg_label
+            # 如果没有副标题，需要补上 out 标签
+            if final_label != "out":
+                filter_parts.append(f"[{bg_label}]copy[out]")
+
+        filter_complex = ";".join(filter_parts)
+
+        command = [
+            FFMPEG_BIN,
+            "-y",
+            "-f",
+            "lavfi",
+            "-i",
+            f"color=c={config.intro_background}:s={output_width}x{output_height}:d={duration}:r={output_fps}",
+            "-filter_complex",
+            filter_complex,
+            "-map",
+            "[out]",
+            "-c:v",
+            "libx264",
+            "-pix_fmt",
+            "yuv420p",
+            "-r",
+            str(output_fps),
+            "-t",
+            str(duration),
+            "-an",  # 无音频
+            str(output_path),
+        ]
+
+        try:
+            run_ffmpeg(command)
+            return output_path.exists()
+        except subprocess.CalledProcessError as e:
+            logger.error("生成文字片头失败: %s", e)
+            return False
+
+    @staticmethod
+    def generate_text_outro(
+        output_path: Path,
+        config: IntroOutroConfig,
+        output_width: int,
+        output_height: int,
+        output_fps: int,
+    ) -> bool:
+        """生成纯文字片尾视频."""
+        duration = config.outro_duration
+
+        # 转义文字
+        title = config.outro_title.replace(":", "\\:").replace("'", "\\'")
+        subtitle = config.outro_subtitle.replace(":", "\\:").replace("'", "\\'")
+
+        title_color = config.outro_title_color
+        subtitle_color = config.outro_subtitle_color
+
+        # 位置
+        title_y = f"(h-text_h)/2 - {config.outro_title_size // 2}"
+        subtitle_y = f"(h-text_h)/2 + {config.outro_title_size}"
+
+        filter_parts = []
+
+        # 背景
+        bg_src = f"color=c={config.outro_background}:s={output_width}x{output_height}:d={duration}:r={output_fps}"
+        filter_parts.append(f"color=c={config.outro_background}:s={output_width}x{output_height}:d={duration}[bg]")
+
+        # 标题 + 淡出
+        if title:
+            filter_parts.append(
+                f"[bg]drawtext="
+                f"text='{title}':"
+                f"fontsize={config.outro_title_size}:"
+                f"fontcolor={title_color}:"
+                f"x=(w-text_w)/2:"
+                f"y={title_y}:"
+                f"alpha='if(gt(t,{duration - 0.5}),({duration}-t)/0.5,1)'"
+                f"[with_title]"
+            )
+            bg_label = "with_title"
+        else:
+            bg_label = "bg"
+
+        # 副标题
+        if subtitle:
+            filter_parts.append(
+                f"[{bg_label}]drawtext="
+                f"text='{subtitle}':"
+                f"fontsize={config.outro_subtitle_size}:"
+                f"fontcolor={subtitle_color}:"
+                f"x=(w-text_w)/2:"
+                f"y={subtitle_y}:"
+                f"alpha='if(gt(t,{duration - 0.5}),({duration}-t)/0.5,1)'"
+                f"[out]"
+            )
+            final_label = "out"
+        else:
+            final_label = bg_label
+            if final_label != "out":
+                filter_parts.append(f"[{bg_label}]copy[out]")
+
+        filter_complex = ";".join(filter_parts)
+
+        command = [
+            FFMPEG_BIN,
+            "-y",
+            "-f",
+            "lavfi",
+            "-i",
+            bg_src,
+            "-filter_complex",
+            filter_complex,
+            "-map",
+            "[out]",
+            "-c:v",
+            "libx264",
+            "-pix_fmt",
+            "yuv420p",
+            "-r",
+            str(output_fps),
+            "-t",
+            str(duration),
+            "-an",
+            str(output_path),
+        ]
+
+        try:
+            run_ffmpeg(command)
+            return output_path.exists()
+        except subprocess.CalledProcessError as e:
+            logger.error("生成文字片尾失败: %s", e)
+            return False
+
+    @staticmethod
+    def concat_with_intro_outro(
+        main_video: Path,
+        intro_video: Path | None,
+        outro_video: Path | None,
+        output_path: Path,
+        transition_duration: float = 0.5,
+        transition_effect: str = "fade",
+    ) -> bool:
+        """将片头 + 正片 + 片尾用 xfade 拼接.
+
+        只传了片头或片尾也可以，缺失的自动跳过。
+        """
+        # 收集所有片段
+        segments: list[tuple[Path, float]] = []  # (path, duration)
+
+        # 简单探测时长（用 ffprobe，这里简化处理：直接用 xfade 的 offset）
+        # 先添加到列表
+        has_intro = intro_video is not None and intro_video.exists()
+        has_outro = outro_video is not None and outro_video.exists()
+
+        if not has_intro and not has_outro:
+            # 没有片头片尾，直接复制
+            import shutil
+
+            shutil.copy2(main_video, output_path)
+            return True
+
+        # 构建输入和 xfade 链
+        # 简单方式：用 concat demuxer（快速但无转场）
+        # 高级方式：用 xfade 滤镜链（有转场但复杂）
+
+        # 用 concat demuxer 方式（性能好，过渡用硬切）
+        # 后续可以加 xfade 转场
+        concat_list = []
+        if has_intro:
+            concat_list.append(intro_video)
+        concat_list.append(main_video)
+        if has_outro:
+            concat_list.append(outro_video)
+
+        # 生成 concat 列表文件
+        list_file = output_path.parent / f"concat_list_{output_path.stem}.txt"
+        with open(list_file, "w") as f:
+            for seg in concat_list:
+                f.write(f"file '{seg}'\n")
+
+        command = [
+            FFMPEG_BIN,
+            "-y",
+            "-f",
+            "concat",
+            "-safe",
+            "0",
+            "-i",
+            str(list_file),
+            "-c:v",
+            "libx264",
+            "-c:a",
+            "aac",
+            "-pix_fmt",
+            "yuv420p",
+            "-movflags",
+            "+faststart",
+            str(output_path),
+        ]
+
+        try:
+            run_ffmpeg(command)
+            # 清理列表文件
+            list_file.unlink(missing_ok=True)
+            return output_path.exists()
+        except subprocess.CalledProcessError as e:
+            logger.error("片头片尾拼接失败: %s", e)
+            list_file.unlink(missing_ok=True)
+            return False

apps/worker/video_processing/noise_reduction_engine.py

@@ -0,0 +1,229 @@
+"""音频降噪引擎 — 基于 FFmpeg afftdn 滤镜.
+
+支持对音频进行背景噪音消除、人声增强，适用于语音录制、采访等场景。
+
+使用方式：
+    config = NoiseReductionConfig(level="medium")
+    engine = NoiseReductionEngine(config)
+    filter_str = engine.build_filter(input_label, output_label)
+    # 结果: [0:a]afftdn=nf=-25[out]
+
+降级策略：
+    - 参数越界自动钳制
+    - FFmpeg 不支持 afftdn 时，调用方可捕获异常并跳过
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from enum import Enum
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+# ── 降噪等级 ──────────────────────────────────────────────────────────────────
+
+
+class NoiseReductionLevel(str, Enum):
+    """降噪等级预设。"""
+
+    LOW = "low"  # 轻度降噪，保留细节，适合轻微背景噪音
+    MEDIUM = "medium"  # 中度降噪，平衡效果和音质
+    HIGH = "high"  # 高度降噪，适合嘈杂环境，可能轻微影响音质
+    CUSTOM = "custom"  # 自定义参数
+
+
+# 各等级对应的降噪参数（afftdn 的 noise floor，单位 dB）
+# 值越大（越接近 0），降噪越强；值越小（越负），降噪越弱
+_LEVEL_PARAMS = {
+    NoiseReductionLevel.LOW: {
+        "nf": -35,  # 噪音阈值（dB），越负越保守
+        "tn": -10,  # 噪音频谱平滑度
+        "tr": 50,  # 时间分辨率（ms）
+    },
+    NoiseReductionLevel.MEDIUM: {
+        "nf": -25,
+        "tn": -10,
+        "tr": 50,
+    },
+    NoiseReductionLevel.HIGH: {
+        "nf": -15,
+        "tn": -5,
+        "tr": 30,
+    },
+}
+
+
+# ── 配置模型 ──────────────────────────────────────────────────────────────────
+
+
+@dataclass
+class NoiseReductionConfig:
+    """音频降噪配置。
+
+    Attributes:
+        enabled: 是否启用降噪
+        level: 降噪等级 low/medium/high/custom
+        noise_floor: 自定义噪音阈值（dB），仅 level=custom 时有效，范围 -60 ~ -5
+        voice_enhance: 是否启用人声增强
+        output_format: 输出格式描述（内部使用）
+    """
+
+    enabled: bool = False
+    level: NoiseReductionLevel = NoiseReductionLevel.MEDIUM
+    noise_floor: float = -25.0  # dB
+    voice_enhance: bool = False
+
+    @classmethod
+    def from_dict(cls, data: dict | None) -> "NoiseReductionConfig":
+        """从字典解析配置，参数越界自动钳制。"""
+        if not data or not data.get("enabled", False):
+            return cls(enabled=False)
+
+        level_str = str(data.get("level", "medium")).lower()
+        try:
+            level = NoiseReductionLevel(level_str)
+        except ValueError:
+            level = NoiseReductionLevel.MEDIUM
+
+        try:
+            noise_floor = float(data.get("noise_floor", -25.0))
+        except (TypeError, ValueError):
+            noise_floor = -25.0
+
+        voice_enhance = bool(data.get("voice_enhance", False))
+
+        # 钳制到合法范围
+        noise_floor = max(-60.0, min(-5.0, noise_floor))
+
+        return cls(
+            enabled=True,
+            level=level,
+            noise_floor=noise_floor,
+            voice_enhance=voice_enhance,
+        )
+
+    def has_effect(self) -> bool:
+        """判断是否有实际降噪效果。"""
+        return self.enabled
+
+    def get_effective_noise_floor(self) -> float:
+        """获取实际生效的噪音阈值（dB）。"""
+        if self.level == NoiseReductionLevel.CUSTOM:
+            return self.noise_floor
+        params = _LEVEL_PARAMS.get(self.level, _LEVEL_PARAMS[NoiseReductionLevel.MEDIUM])
+        return float(params["nf"])
+
+
+# ── 引擎实现 ──────────────────────────────────────────────────────────────────
+
+
+class NoiseReductionEngine:
+    """音频降噪引擎。
+
+    基于 FFmpeg afftdn（Audio FFt Denoiser）滤镜实现：
+    - 使用短时傅里叶变换分析音频频谱
+    - 识别并消除稳态背景噪音
+    - 保留人声等非稳态信号
+    """
+
+    def __init__(self, config: NoiseReductionConfig):
+        self.config = config
+
+    def build_filter(self, input_label: str, output_label: str) -> str:
+        """构建音频降噪滤镜字符串。
+
+        Args:
+            input_label: 输入标签，如 "[0:a]" 或 "[a0]"
+            output_label: 输出标签，如 "[nr0]"
+
+        Returns:
+            FFmpeg 滤镜字符串，如 "[a0]afftdn=nf=-25:tn=-10:tr=50[nr0]"
+
+        Raises:
+            ValueError: 配置无效时抛出（调用方应捕获并降级）
+        """
+        if not self.config.has_effect():
+            return f"{input_label}anull{output_label}"
+
+        # 获取参数
+        if self.config.level == NoiseReductionLevel.CUSTOM:
+            nf = self.config.noise_floor
+            tn = -10  # 默认频谱平滑度
+            tr = 50  # 默认时间分辨率
+        else:
+            params = _LEVEL_PARAMS.get(
+                self.config.level,
+                _LEVEL_PARAMS[NoiseReductionLevel.MEDIUM],
+            )
+            nf = float(params["nf"])
+            tn = float(params["tn"])
+            tr = float(params["tr"])
+
+        # 构建 afftdn 滤镜
+        # nf: noise floor (dB)
+        # tn: temporal noise floor smoothing (dB)
+        # tr: time resolution (ms)
+        filter_parts = [f"afftdn=nf={nf}:tn={tn}:tr={tr}"]
+
+        # 人声增强：通过 highpass + 轻微压缩实现
+        if self.config.voice_enhance:
+            # 1. 高通滤波，去除低频噪音
+            filter_parts.append("highpass=f=80")
+            # 2. 轻微压缩，提升人声清晰度
+            filter_parts.append("acompressor=threshold=-20:ratio=2:attack=5:release=50")
+            # 3. 响度归一化
+            filter_parts.append("loudnorm=I=-16:TP=-1.5:LRA=11")
+
+        filter_str = f"{input_label}{','.join(filter_parts)}{output_label}"
+        return filter_str
+
+    def build_filter_arnndn(self, input_label: str, output_label: str, model_file: str) -> str:
+        """使用 RNN 降噪滤镜（arnndn，效果更好但需要模型文件）。
+
+        注意：需要额外下载 RNNNoise 模型文件，默认使用 afftdn（无需额外依赖）。
+
+        Args:
+            input_label: 输入标签
+            output_label: 输出标签
+            model_file: RNNNoise 模型文件路径（.rnnn 格式）
+
+        Returns:
+            FFmpeg 滤镜字符串
+        """
+        if not self.config.has_effect():
+            return f"{input_label}anull{output_label}"
+
+        return f"{input_label}arnndn=m={model_file}{output_label}"
+
+
+def apply_noise_reduction_if_needed(
+    config_data: dict | None,
+    input_label: str,
+    output_label: str,
+) -> Optional[str]:
+    """便捷函数：根据配置判断是否需要应用音频降噪。
+
+    Args:
+        config_data: 降噪配置字典（从 plan.config.audio_noise_reduction 或 clip.config.noise_reduction 读取）
+        input_label: 输入标签
+        output_label: 输出标签
+
+    Returns:
+        滤镜字符串，不需要降噪时返回 None
+    """
+    if not config_data:
+        return None
+
+    try:
+        config = NoiseReductionConfig.from_dict(config_data)
+        if not config.has_effect():
+            return None
+
+        engine = NoiseReductionEngine(config)
+        return engine.build_filter(input_label, output_label)
+    except Exception as e:
+        logger.warning("[noise-reduction] 应用降噪失败，跳过: %s", e)
+        return None

apps/worker/video_processing/render_audio.py

@@ -22,6 +22,8 @@ from pathlib import Path
 from typing import TYPE_CHECKING
 
 from video_processing.ffmpeg_utils import FFMPEG_BIN, probe_has_audio, run_ffmpeg
+from video_processing.reverse_engine import ReverseConfig, ReverseEngine
+from video_processing.speed_engine import SpeedEngine
 
 if TYPE_CHECKING:
     from video_processing.unified_render_service import RenderLayer, ResolvedClip
@@ -35,6 +37,8 @@ class RenderContext:
 
     work_dir: Path
     plan_id: str
+    # 音频降噪配置（全局，对最终混音结果应用）
+    noise_reduction_config: dict | None = None
     # 音频探测缓存（避免同一 clip 被多次 ffprobe）
     _audio_cache: dict[str, bool] = field(default_factory=dict)
 
@@ -70,6 +74,9 @@ def mix_audio(
     ctx: RenderContext,
     layers: list[RenderLayer],
     video_duration: float,
+    *,
+    bgm_path: str | None = None,
+    bgm_config: dict | None = None,
 ) -> Path | None:
     """音频后处理混音.
 
@@ -79,11 +86,14 @@ def mix_audio(
     3. 独立音频轨（audio role）用 amix 混入
     4. 输出时长截断到 video_duration
     5. 无音频流的 clip 会被自动跳过，避免 FFmpeg 引用 [i:a] 失败
+    6. 如果提供了 bgm_path，则额外混入 BGM（支持淡入淡出、循环、人声闪避）
 
     Args:
         ctx: 渲染上下文
         layers: 图层列表
         video_duration: 视频总时长（用于截断音频）
+        bgm_path: BGM 音频本地路径，为 None 时不混入 BGM
+        bgm_config: BGM 配置字典（volume/fade_in/fade_out/sidechain 等）
 
     Returns:
         混音后的音频文件路径，无音频时返回 None
@@ -116,6 +126,15 @@ def mix_audio(
     audio_clips = [c for c in audio_clips if clip_has_audio(ctx, c)]
 
     if not main_clips and not audio_clips:
+        # 没有主音频也没有独立音频 → 检查是否有 BGM
+        if bgm_path and bgm_config and bgm_config.get("enabled", False):
+            from video_processing.bgm_mixer import BGMConfig, build_bgm_only
+
+            bgm_cfg = BGMConfig.from_config_dict(bgm_path, bgm_config)
+            try:
+                return build_bgm_only(ctx, bgm_cfg, video_duration)
+            except Exception:
+                logger.exception("[bgm] 纯BGM生成失败: plan_id=%s", ctx.plan_id)
         return None
 
     # 构建音频处理命令
@@ -124,11 +143,72 @@ def mix_audio(
     # 简单场景：只有主图层 + 无独立音频 → 直接从视频提取音频并拼接
     if main_clips and not audio_clips:
         concat_main_audio(ctx, main_clips, output_path, video_duration)
-        return output_path
+    else:
+        # 有独立音频轨 → amix 混音
+        mix_with_independent_audio(ctx, main_clips, audio_clips, output_path, video_duration)
 
-    # 有独立音频轨 → amix 混音
-    mix_with_independent_audio(ctx, main_clips, audio_clips, output_path, video_duration)
-    return output_path
+    # ── BGM 混音 ──
+    if bgm_path and bgm_config and bgm_config.get("enabled", False):
+        from video_processing.bgm_mixer import BGMConfig, mix_bgm_with_main
+
+        bgm_cfg = BGMConfig.from_config_dict(bgm_path, bgm_config)
+        bgm_output = ctx.work_dir / f"audio_with_bgm_{ctx.plan_id}.aac"
+
+        try:
+            # 这里 main_audio 就是 output_path，先有主音频再混 BGM
+            final_path = mix_bgm_with_main(ctx, output_path, bgm_cfg, video_duration)
+            return _apply_noise_reduction_if_needed(ctx, final_path)
+        except Exception:
+            logger.exception("[bgm] BGM 混音失败，回退到无 BGM 音频: plan_id=%s", ctx.plan_id)
+            return _apply_noise_reduction_if_needed(ctx, output_path)
+
+    return _apply_noise_reduction_if_needed(ctx, output_path)
+
+
+def _apply_noise_reduction_if_needed(ctx: RenderContext, audio_path: Path) -> Path:
+    """如果配置了音频降噪，对已生成的音频文件应用降噪。
+
+    作为后处理步骤，对最终混音结果统一降噪。
+    失败时返回原始文件路径，不阻断主流程。
+    """
+    if not ctx.noise_reduction_config:
+        return audio_path
+
+    try:
+        from video_processing.noise_reduction_engine import NoiseReductionConfig, NoiseReductionEngine
+
+        config = NoiseReductionConfig.from_dict(ctx.noise_reduction_config)
+        if not config.has_effect():
+            return audio_path
+
+        engine = NoiseReductionEngine(config)
+        filter_str = engine.build_filter("[0:a]", "[out]")
+        # 提取滤镜部分（不带标签）
+        filter_part = filter_str[len("[0:a]") : -len("[out]")]
+
+        nr_output_path = audio_path.with_name(f"{audio_path.stem}_nr.aac")
+        command = [
+            FFMPEG_BIN,
+            "-y",
+            "-i",
+            str(audio_path),
+            "-af",
+            filter_part,
+            "-acodec",
+            "aac",
+            "-b:a",
+            "128k",
+            str(nr_output_path),
+        ]
+        run_ffmpeg(command)
+
+        if nr_output_path.exists():
+            return nr_output_path
+        logger.warning("[noise-reduction] 降噪输出文件不存在，使用原始音频")
+        return audio_path
+    except Exception as e:
+        logger.warning("[noise-reduction] 音频降噪失败，使用原始音频: %s", e)
+        return audio_path
 
 
 def concat_main_audio(
@@ -145,40 +225,130 @@ def concat_main_audio(
         # 单 clip，直接提取音频，截断到 min(clip有效时长, 视频总时长)
         clip = clips[0]
         effective_duration = clip_effective_duration(clip)
-        # 最终时长：取 clip 有效时长和视频总时长的较小值
-        # （视频总时长由主图层决定，但单 clip 场景下两者应该一致，仍做保护）
-        final_duration = effective_duration
+        trim_start = getattr(clip, "start_time", 0) or 0
+        speed = getattr(clip, "playback_speed", 1.0) or 1.0
+        if not isinstance(speed, (int, float)) or speed <= 0:
+            speed = 1.0
+
+        # 调速后时长
+        adjusted_duration = effective_duration / speed if abs(speed - 1.0) >= 1e-6 else effective_duration
+        # 最终时长：取调速后时长和视频总时长的较小值
+        final_duration = adjusted_duration
         if video_duration > 0 and (final_duration <= 0 or final_duration > video_duration):
             final_duration = video_duration
 
-        command = [
-            FFMPEG_BIN,
-            "-y",
-            "-i",
-            str(clip.local_path),
-            "-vn",
-            "-acodec",
-            "aac",
-            "-b:a",
-            "128k",
-        ]
-        if final_duration > 0:
-            command.extend(["-t", f"{final_duration:.3f}"])
-        command.append(str(output_path))
-        run_ffmpeg(command)
+        # 音频倒放
+        reverse_config = ReverseConfig.from_dict(clip.config.get("reverse"))
+        has_reverse = reverse_config.enabled and reverse_config.reverse_audio
+        has_speed = abs(speed - 1.0) >= 1e-6
+
+        if not has_speed and not has_reverse:
+            # 无调速无倒放：简单命令行，-ss 裁剪更高效
+            command = [
+                FFMPEG_BIN,
+                "-y",
+                "-i",
+                str(clip.local_path),
+                "-vn",
+                "-acodec",
+                "aac",
+                "-b:a",
+                "128k",
+            ]
+            if trim_start > 0:
+                command.extend(["-ss", f"{trim_start:.3f}"])
+            if final_duration > 0:
+                command.extend(["-t", f"{final_duration:.3f}"])
+            command.append(str(output_path))
+            run_ffmpeg(command)
+        else:
+            # 有调速或倒放：用 filter_complex
+            speed_engine = SpeedEngine()
+            audio_filters = []
+            if effective_duration > 0:
+                audio_filters.append(f"atrim=start={trim_start:.3f}:duration={effective_duration:.3f}")
+                audio_filters.append("asetpts=PTS-STARTPTS")
+
+            # 音频调速
+            if has_speed:
+                from video_processing.speed_engine import SpeedConfig
+
+                config = SpeedConfig(speed=float(speed))
+                config.clamp()
+                atempo_filter = speed_engine.build_audio_filter(config)
+                if atempo_filter:
+                    audio_filters.append(atempo_filter)
+
+            # 音频倒放
+            if has_reverse:
+                reverse_filter = ReverseEngine.build_audio_filter(reverse_config, duration=effective_duration)
+                if reverse_filter:
+                    audio_filters.append(reverse_filter)
+
+            filter_parts: list[str] = [f"[0:a]{','.join(audio_filters)}[outa]"]
+            if video_duration > 0 and final_duration < adjusted_duration:
+                filter_parts.append(f"[outa]atrim=0:{final_duration:.3f}[final_audio]")
+                final_label = "final_audio"
+            else:
+                final_label = "outa"
+
+            filter_complex = ";".join(filter_parts)
+            command = [
+                FFMPEG_BIN,
+                "-y",
+                "-i",
+                str(clip.local_path),
+                "-filter_complex",
+                filter_complex,
+                "-map",
+                f"[{final_label}]",
+                "-acodec",
+                "aac",
+                "-b:a",
+                "128k",
+                str(output_path),
+            ]
+            run_ffmpeg(command)
         return
 
     # 多 clip，用 filter_complex concat
     input_args: list[str] = []
     filter_parts: list[str] = []
+    speed_engine = SpeedEngine()
 
     for i, clip in enumerate(clips):
         input_args.extend(["-i", str(clip.local_path)])
         effective_duration = clip_effective_duration(clip)
+        trim_start = getattr(clip, "start_time", 0) or 0
+        speed = getattr(clip, "playback_speed", 1.0) or 1.0
+        if not isinstance(speed, (int, float)) or speed <= 0:
+            speed = 1.0
+
+        audio_filters: list[str] = []
         if effective_duration > 0:
-            filter_parts.append(f"[{i}:a]atrim=0:{effective_duration:.3f},asetpts=PTS-STARTPTS[a{i}]")
+            audio_filters.append(f"atrim=start={trim_start:.3f}:duration={effective_duration:.3f}")
+            audio_filters.append("asetpts=PTS-STARTPTS")
+
+        # 音频调速 — atempo 多级串联
+        if abs(speed - 1.0) >= 1e-6:
+            from video_processing.speed_engine import SpeedConfig
+
+            config = SpeedConfig(speed=float(speed))
+            config.clamp()
+            atempo_filter = speed_engine.build_audio_filter(config)
+            if atempo_filter:
+                audio_filters.append(atempo_filter)
         else:
-            filter_parts.append(f"[{i}:a]asetpts=PTS-STARTPTS[a{i}]")
+            audio_filters.append("asetpts=PTS-STARTPTS")
+
+        # 音频倒放
+        reverse_config = ReverseConfig.from_dict(clip.config.get("reverse"))
+        if reverse_config.enabled and reverse_config.reverse_audio:
+            reverse_filter = ReverseEngine.build_audio_filter(reverse_config, duration=effective_duration)
+            if reverse_filter:
+                audio_filters.append(reverse_filter)
+
+        filter_parts.append(f"[{i}:a]{','.join(audio_filters)}[a{i}]")
 
     audio_labels = "".join(f"[a{i}]" for i in range(len(clips)))
     filter_parts.append(f"{audio_labels}concat=n={len(clips)}:v=0:a=1[outa]")
@@ -236,9 +406,11 @@ def mix_with_independent_audio(
         for clip in main_clips:
             input_args.extend(["-i", str(clip.local_path)])
             effective_duration = clip_effective_duration(clip)
+            trim_start = getattr(clip, "start_time", 0) or 0
             if effective_duration > 0:
                 filter_parts.append(
-                    f"[{input_idx}:a]atrim=0:{effective_duration:.3f},asetpts=PTS-STARTPTS[ma{input_idx}]"
+                    f"[{input_idx}:a]atrim=start={trim_start:.3f}:duration={effective_duration:.3f},"
+                    f"asetpts=PTS-STARTPTS[ma{input_idx}]"
                 )
             else:
                 filter_parts.append(f"[{input_idx}:a]asetpts=PTS-STARTPTS[ma{input_idx}]")
@@ -255,11 +427,12 @@ def mix_with_independent_audio(
     for j, clip in enumerate(audio_clips):
         input_args.extend(["-i", str(clip.local_path)])
         effective_duration = clip_effective_duration(clip)
+        trim_start = getattr(clip, "start_time", 0) or 0
         volume = clip.config.get("volume", 1.0) if clip.config else 1.0
         label = f"ia{j}"
         filters = []
         if effective_duration > 0:
-            filters.append(f"atrim=0:{effective_duration:.3f}")
+            filters.append(f"atrim=start={trim_start:.3f}:duration={effective_duration:.3f}")
         filters.append("asetpts=PTS-STARTPTS")
         if volume != 1.0:
             filters.append(f"volume={volume}")

apps/worker/video_processing/reverse_engine.py

@@ -0,0 +1,116 @@
+"""视频倒放引擎 — 基于 FFmpeg reverse + areverse 滤镜实现视频/音频倒放.
+
+支持能力：
+- 视频倒放（reverse 滤镜）
+- 音频倒放（areverse 滤镜）
+- 按 clip 分段倒放，每个 clip 独立配置
+- 降级策略：不支持时跳过，不阻断渲染
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+# ── 数据模型 ──────────────────────────────────────────────────────────────────
+
+
+@dataclass
+class ReverseConfig:
+    """视频倒放配置.
+
+    从 clip.config.reverse 读取，零侵入数据模型.
+    """
+
+    enabled: bool = False
+    reverse_video: bool = True  # 是否倒放视频
+    reverse_audio: bool = True  # 是否倒放音频
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any] | None) -> "ReverseConfig":
+        """从字典解析配置."""
+        if not data:
+            return cls(enabled=False)
+        try:
+            if not data.get("enabled", False):
+                return cls(enabled=False)
+            return cls(
+                enabled=True,
+                reverse_video=bool(data.get("reverse_video", True)),
+                reverse_audio=bool(data.get("reverse_audio", True)),
+            )
+        except (AttributeError, TypeError) as e:
+            logger.warning("倒放配置解析失败: %s，使用默认配置", e)
+            return cls(enabled=False)
+
+
+# ── 倒放引擎 ──────────────────────────────────────────────────────────────────
+
+
+class ReverseEngine:
+    """视频倒放引擎 — 生成 FFmpeg 倒放滤镜.
+
+    视频倒放：reverse 滤镜
+    音频倒放：areverse 滤镜
+
+    注意事项：
+    - reverse 滤镜需要将整个视频帧加载到内存，长视频可能占用大量内存
+    - 建议对单 clip 时长做限制（如 < 60s），超长视频建议降级
+    """
+
+    # 安全限制：单 clip 超过此时长不启用倒放（防止内存溢出）
+    MAX_SAFE_DURATION = 120.0  # 秒
+
+    @staticmethod
+    def build_video_filter(config: ReverseConfig, duration: float = 0.0) -> str:
+        """构建视频倒放滤镜字符串.
+
+        Args:
+            config: 倒放配置
+            duration: clip 时长（秒），用于安全检查
+
+        Returns:
+            FFmpeg 滤镜字符串，如 "reverse"；无效果返回空字符串
+        """
+        if not config.enabled or not config.reverse_video:
+            return ""
+
+        # 安全检查：超长视频不启用倒放
+        if duration > ReverseEngine.MAX_SAFE_DURATION:
+            logger.warning(
+                "视频倒放安全限制：clip 时长 %.1fs 超过上限 %.1fs，跳过倒放",
+                duration,
+                ReverseEngine.MAX_SAFE_DURATION,
+            )
+            return ""
+
+        return "reverse"
+
+    @staticmethod
+    def build_audio_filter(config: ReverseConfig, duration: float = 0.0) -> str:
+        """构建音频倒放滤镜字符串.
+
+        Args:
+            config: 倒放配置
+            duration: clip 时长（秒），用于安全检查
+
+        Returns:
+            FFmpeg 音频滤镜字符串，如 "areverse"；无效果返回空字符串
+        """
+        if not config.enabled or not config.reverse_audio:
+            return ""
+
+        # 安全检查：超长音频不启用倒放
+        if duration > ReverseEngine.MAX_SAFE_DURATION:
+            logger.warning(
+                "音频倒放安全限制：clip 时长 %.1fs 超过上限 %.1fs，跳过倒放",
+                duration,
+                ReverseEngine.MAX_SAFE_DURATION,
+            )
+            return ""
+
+        return "areverse"

apps/worker/video_processing/speed_engine.py

@@ -0,0 +1,167 @@
+"""视频调速引擎 — 基于 FFmpeg setpts + atempo 的速度调整能力。
+
+支持：
+- 0.25x ~ 4x 变速范围
+- 视频调速（setpts）
+- 音频调速（atempo，多级串联处理超范围值）
+- 音调修正（pitch_correct，默认开启）
+- 边界自动钳制，不阻断渲染
+"""
+
+from dataclasses import dataclass
+from typing import Optional
+
+# ─── 常量 ───────────────────────────────────────────────
+MIN_SPEED = 0.25
+MAX_SPEED = 4.0
+DEFAULT_SPEED = 1.0
+
+# atempo 单级有效范围
+_ATEMPO_MIN = 0.5
+_ATEMPO_MAX = 2.0
+
+
+@dataclass
+class SpeedConfig:
+    """调速配置。
+
+    Attributes:
+        speed: 播放速度，0.25~4.0，1.0 为原速
+        pitch_correct: 是否保持音调（默认 True，用 atempo 时间拉伸算法）
+    """
+
+    speed: float = DEFAULT_SPEED
+    pitch_correct: bool = True
+
+    @classmethod
+    def parse(cls, data: Optional[dict]) -> "SpeedConfig":
+        """从 dict 解析配置，无效值回退到默认。"""
+        if not data or not isinstance(data, dict):
+            return cls()
+
+        speed = data.get("speed", DEFAULT_SPEED)
+        if not isinstance(speed, (int, float)):
+            speed = DEFAULT_SPEED
+
+        pitch_correct = data.get("pitch_correct", True)
+        if not isinstance(pitch_correct, bool):
+            pitch_correct = True
+
+        config = cls(speed=float(speed), pitch_correct=pitch_correct)
+        config.clamp()
+        return config
+
+    def clamp(self) -> None:
+        """将速度钳制到合法范围。"""
+        if self.speed <= 0:
+            self.speed = DEFAULT_SPEED
+        elif self.speed < MIN_SPEED:
+            self.speed = MIN_SPEED
+        elif self.speed > MAX_SPEED:
+            self.speed = MAX_SPEED
+
+    @property
+    def is_original(self) -> bool:
+        """是否原速（无需调速）。"""
+        return abs(self.speed - 1.0) < 1e-6
+
+
+class SpeedEngine:
+    """调速引擎 — 生成 FFmpeg 调速滤镜链。
+
+    用法：
+        engine = SpeedEngine()
+        video_filter = engine.build_video_filter(config)
+        audio_filter = engine.build_audio_filter(config)
+        new_duration = engine.adjust_duration(duration, config)
+    """
+
+    def build_video_filter(self, config: SpeedConfig) -> str:
+        """生成视频调速滤镜字符串。
+
+        返回 setpts 滤镜表达式，原速时返回空字符串。
+        """
+        if config.is_original:
+            return ""
+        # setpts=PTS/speed — speed>1 加速，speed<1 减速
+        return f"setpts=PTS/{config.speed:.4f}"
+
+    def build_audio_filter(self, config: SpeedConfig) -> str:
+        """生成音频调速滤镜字符串。
+
+        atempo 单级范围 0.5~2.0，超出范围时自动多级串联：
+        - 0.25x → atempo=0.5,atempo=0.5
+        - 4x → atempo=2.0,atempo=2.0
+        - 0.3x → atempo=0.5,atempo=0.6
+        - 3x → atempo=2.0,atempo=1.5
+
+        原速时返回空字符串。
+        """
+        if config.is_original:
+            return ""
+
+        speed = config.speed
+        stages: list[float] = self._split_atempo_stages(speed)
+        return ",".join(f"atempo={s:.4f}" for s in stages)
+
+    @staticmethod
+    def _split_atempo_stages(speed: float) -> list[float]:
+        """将速度拆分为多级 atempo 串联，每级都在 [0.5, 2.0] 范围内。"""
+        if _ATEMPO_MIN <= speed <= _ATEMPO_MAX:
+            return [speed]
+
+        stages: list[float] = []
+        remaining = speed
+
+        # 加速场景（speed > 2.0）
+        if speed > _ATEMPO_MAX:
+            while remaining > _ATEMPO_MAX:
+                stages.append(_ATEMPO_MAX)
+                remaining /= _ATEMPO_MAX
+            stages.append(remaining)
+
+        # 减速场景（speed < 0.5）
+        else:
+            while remaining < _ATEMPO_MIN:
+                stages.append(_ATEMPO_MIN)
+                remaining /= _ATEMPO_MIN
+            stages.append(remaining)
+
+        return stages
+
+    def adjust_duration(self, original_duration: float, config: SpeedConfig) -> float:
+        """计算调速后的时长。
+
+        加速 → 时长变短；减速 → 时长变长。
+        """
+        if config.is_original or original_duration <= 0:
+            return original_duration
+        return original_duration / config.speed
+
+    def build_clip_speed_filter(
+        self,
+        speed: float,
+        pitch_correct: bool = True,
+    ) -> tuple[str, str, SpeedConfig]:
+        """便捷方法：从单一 speed 值生成视频+音频滤镜。
+
+        返回 (video_filter, audio_filter, config)。
+        """
+        config = SpeedConfig(speed=speed, pitch_correct=pitch_correct)
+        config.clamp()
+        return (
+            self.build_video_filter(config),
+            self.build_audio_filter(config),
+            config,
+        )
+
+    @staticmethod
+    def resolve_clip_speed(
+        clip_config: dict,
+        global_speed: float = DEFAULT_SPEED,
+    ) -> float:
+        """从 clip config 中解析 playback_speed，0 或缺失则使用全局速度。"""
+        speed = clip_config.get("playback_speed", 0) if clip_config else 0
+        if not isinstance(speed, (int, float)) or speed <= 0:
+            return global_speed
+        return float(speed)

apps/worker/video_processing/sticker_engine.py

@@ -0,0 +1,574 @@
+"""贴纸叠加引擎 — 基于 FFmpeg overlay + drawtext 实现图片/文字贴纸.
+
+支持能力：
+- 图片贴纸（PNG/GIF）：位置、大小、透明度、时间范围、淡入淡出
+- 文字贴纸（花字）：字体、颜色、描边、阴影、位置、时间范围、动画
+- 9宫格位置 + 自由坐标（像素或百分比）
+- 多贴纸叠加，按 z_index 排序
+- 降级策略：素材不存在/无效时自动跳过，不阻断渲染
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+# ── 预设贴纸分类 ──────────────────────────────────────────────────────────────
+
+# 预设贴纸分类（仅用于前端展示，后端不依赖具体素材）
+STICKER_CATEGORIES = [
+    ("emoji", "表情包"),
+    ("text", "文字花字"),
+    ("decoration", "装饰"),
+    ("arrow", "箭头指示"),
+    ("frame", "边框"),
+]
+
+# 9宫格位置映射
+POSITION_PRESETS = {
+    "top_left": (0.05, 0.05),
+    "top_center": (0.5, 0.05),
+    "top_right": (0.95, 0.05),
+    "center_left": (0.05, 0.5),
+    "center": (0.5, 0.5),
+    "center_right": (0.95, 0.5),
+    "bottom_left": (0.05, 0.95),
+    "bottom_center": (0.5, 0.95),
+    "bottom_right": (0.95, 0.95),
+}
+
+
+# ── 数据模型 ──────────────────────────────────────────────────────────────────
+
+
+@dataclass
+class ImageStickerConfig:
+    """图片贴纸配置."""
+
+    enabled: bool = False
+    type: str = "image"  # image / text
+    # 位置
+    position: str = "top_right"  # 9宫格预设
+    x: float | None = None  # 自定义x（像素或百分比）
+    y: float | None = None  # 自定义y
+    x_unit: str = "percent"  # pixel / percent
+    y_unit: str = "percent"
+    # 大小
+    scale: float = 1.0  # 缩放比例（相对于原始大小）
+    width: int | None = None  # 指定宽度（像素）
+    height: int | None = None  # 指定高度（像素）
+    # 透明度
+    opacity: float = 1.0  # 0.0~1.0
+    # 时间范围
+    start_time: float = 0.0
+    duration: float = 0.0  # 0 表示持续到结束
+    # 动画
+    fade_in: float = 0.0  # 淡入时长（秒）
+    fade_out: float = 0.0  # 淡出时长
+    # 层级
+    z_index: int = 10
+    # 素材
+    image_url: str = ""  # 图片URL或本地路径
+    preset_id: str = ""  # 预设贴纸ID
+
+
+@dataclass
+class TextStickerConfig:
+    """文字贴纸配置."""
+
+    enabled: bool = False
+    type: str = "text"
+    text: str = ""
+    # 字体
+    font_size: int = 36
+    font_color: str = "#FFFFFF"
+    font_family: str = "sans"
+    # 描边
+    stroke_color: str = "#000000"
+    stroke_width: int = 2
+    # 阴影
+    shadow_color: str = "#000000"
+    shadow_x: int = 2
+    shadow_y: int = 2
+    shadow_alpha: float = 0.5
+    # 位置
+    position: str = "center"
+    x: float | None = None
+    y: float | None = None
+    x_unit: str = "percent"
+    y_unit: str = "percent"
+    # 时间范围
+    start_time: float = 0.0
+    duration: float = 0.0
+    # 动画
+    fade_in: float = 0.0
+    fade_out: float = 0.0
+    # 层级
+    z_index: int = 10
+    # 背景框
+    bg_color: str = ""  # 空表示无背景
+    bg_padding: int = 8
+    bg_alpha: float = 0.8
+    bg_corner_radius: int = 8
+
+
+@dataclass
+class StickerOverlayResult:
+    """贴纸叠加结果."""
+
+    filter_str: str  # 滤镜字符串
+    output_label: str  # 输出标签
+    extra_inputs: list[str] = field(default_factory=list)  # 额外的输入文件路径
+
+
+# ── 贴纸引擎 ──────────────────────────────────────────────────────────────────
+
+
+class StickerEngine:
+    """贴纸叠加引擎 — 生成 FFmpeg overlay / drawtext 滤镜链.
+
+    支持图片贴纸（overlay）和文字贴纸（drawtext）。
+    多贴纸按 z_index 排序依次叠加。
+    """
+
+    @staticmethod
+    def _resolve_position(
+        config: ImageStickerConfig | TextStickerConfig,
+        canvas_w: int,
+        canvas_h: int,
+        sticker_w: int = 0,
+        sticker_h: int = 0,
+    ) -> tuple[float, float]:
+        """解析贴纸位置（像素坐标）.
+
+        优先级：自定义坐标 > 9宫格预设
+        """
+        # 先取预设的基准位置
+        if config.position in POSITION_PRESETS:
+            px, py = POSITION_PRESETS[config.position]
+        else:
+            px, py = 0.5, 0.5  # 默认居中
+
+        # 自定义坐标覆盖
+        if config.x is not None:
+            if config.x_unit == "percent":
+                px = config.x / 100.0
+            else:
+                px = config.x / canvas_w if canvas_w > 0 else 0.5
+
+        if config.y is not None:
+            if config.y_unit == "percent":
+                py = config.y / 100.0
+            else:
+                py = config.y / canvas_h if canvas_h > 0 else 0.5
+
+        # 转换为像素坐标（考虑贴纸尺寸，使位置为贴纸中心点）
+        x = px * canvas_w - sticker_w / 2
+        y = py * canvas_h - sticker_h / 2
+
+        # 钳制在画布内
+        x = max(0, min(x, canvas_w - sticker_w))
+        y = max(0, min(y, canvas_h - sticker_h))
+
+        return x, y
+
+    @staticmethod
+    def _build_overlay_filter(
+        sticker: ImageStickerConfig,
+        sticker_idx: int,
+        input_label: str,
+        output_label: str,
+        canvas_w: int,
+        canvas_h: int,
+    ) -> str:
+        """构建单个图片贴纸的 overlay 滤镜.
+
+        Args:
+            sticker: 贴纸配置
+            sticker_idx: 贴纸索引（用于生成滤镜标签）
+            input_label: 输入视频标签（如 "[base]"）
+            output_label: 输出视频标签
+            canvas_w: 画布宽度
+            canvas_h: 画布高度
+
+        Returns:
+            FFmpeg 滤镜字符串
+        """
+        sticker_label = f"sticker_{sticker_idx}_scaled"
+
+        # 1. 贴纸缩放预处理
+        scale_parts = []
+        if sticker.width and sticker.height:
+            scale_parts.append(f"scale={sticker.width}:{sticker.height}")
+        elif sticker.scale != 1.0:
+            # 按比例缩放
+            scale_parts.append(f"scale=iw*{sticker.scale}:ih*{sticker.scale}")
+        # 透明度调整
+        if sticker.opacity < 1.0:
+            scale_parts.append(f"colorchannelmixer=aa={sticker.opacity}")
+
+        # 淡入淡出
+        fade_parts = []
+        if sticker.fade_in > 0:
+            fade_parts.append(f"fade=in:st={sticker.start_time}:d={sticker.fade_in}:alpha=1")
+        if sticker.fade_out > 0 and sticker.duration > 0:
+            fade_out_start = sticker.start_time + sticker.duration - sticker.fade_out
+            fade_parts.append(f"fade=out:st={max(0, fade_out_start)}:d={sticker.fade_out}:alpha=1")
+
+        pre_filters = scale_parts + fade_parts
+
+        # 2. overlay 位置
+        # 先估算贴纸尺寸（假设原始尺寸 ~ canvas_w * 0.3）
+        est_w = int(canvas_w * 0.3 * sticker.scale) if not sticker.width else sticker.width
+        est_h = int(canvas_h * 0.3 * sticker.scale) if not sticker.height else sticker.height
+        pos_x, pos_y = StickerEngine._resolve_position(sticker, canvas_w, canvas_h, est_w, est_h)
+
+        # 3. enable 表达式（时间范围）
+        enable_expr = ""
+        if sticker.duration > 0:
+            enable_expr = f":enable='between(t,{sticker.start_time},{sticker.start_time + sticker.duration})'"
+
+        # 组合滤镜
+        filter_parts: list[str] = []
+
+        # 贴纸预处理
+        if pre_filters:
+            filter_parts.append(f"[{sticker_idx + 1}:v]{','.join(pre_filters)}[{sticker_label}]")
+            sticker_source = f"[{sticker_label}]"
+        else:
+            sticker_source = f"[{sticker_idx + 1}:v]"
+
+        # overlay 合成
+        filter_parts.append(f"{input_label}{sticker_source}overlay={pos_x:.0f}:{pos_y:.0f}{enable_expr}{output_label}")
+
+        return ";".join(filter_parts)
+
+    @staticmethod
+    def _build_drawtext_filter(
+        sticker: TextStickerConfig,
+        input_label: str,
+        output_label: str,
+        canvas_w: int,
+        canvas_h: int,
+    ) -> str:
+        """构建单个文字贴纸的 drawtext 滤镜.
+
+        Args:
+            sticker: 文字贴纸配置
+            input_label: 输入视频标签
+            output_label: 输出视频标签
+            canvas_w: 画布宽度
+            canvas_h: 画布高度
+
+        Returns:
+            FFmpeg 滤镜字符串
+        """
+        if not sticker.text:
+            return f"{input_label}copy{output_label}"
+
+        # 估算文字尺寸（粗略）
+        est_w = len(sticker.text) * sticker.font_size * 0.6
+        est_h = sticker.font_size * 1.4
+
+        pos_x, pos_y = StickerEngine._resolve_position(sticker, canvas_w, canvas_h, int(est_w), int(est_h))
+
+        drawtext_params: list[str] = []
+
+        # 文字内容（转义特殊字符）
+        escaped_text = sticker.text.replace(":", "\\:").replace("'", "\\'")
+        drawtext_params.append(f"text='{escaped_text}'")
+
+        # 字体
+        drawtext_params.append(f"fontsize={sticker.font_size}")
+        drawtext_params.append(f"fontcolor={sticker.font_color}")
+
+        # 描边
+        if sticker.stroke_width > 0:
+            drawtext_params.append(f"borderw={sticker.stroke_width}")
+            drawtext_params.append(f"bordercolor={sticker.stroke_color}")
+
+        # 阴影
+        if sticker.shadow_alpha > 0:
+            drawtext_params.append(f"shadowx={sticker.shadow_x}")
+            drawtext_params.append(f"shadowy={sticker.shadow_y}")
+            drawtext_params.append(f"shadowcolor={sticker.shadow_color}@{sticker.shadow_alpha}")
+
+        # 位置
+        drawtext_params.append(f"x={pos_x:.0f}")
+        drawtext_params.append(f"y={pos_y:.0f}")
+
+        # 时间范围
+        if sticker.duration > 0:
+            drawtext_params.append(f"enable='between(t,{sticker.start_time},{sticker.start_time + sticker.duration})'")
+
+        # 淡入淡出（drawtext 没有直接的淡入淡出，用 alpha 表达式模拟）
+        if sticker.fade_in > 0 or sticker.fade_out > 0:
+            alpha_expr = "1"
+            parts: list[str] = []
+            if sticker.fade_in > 0:
+                parts.append(
+                    f"if(lt(t,{sticker.start_time + sticker.fade_in})," f"(t-{sticker.start_time})/{sticker.fade_in},1)"
+                )
+            if sticker.fade_out > 0 and sticker.duration > 0:
+                fade_out_start = sticker.start_time + sticker.duration - sticker.fade_out
+                parts.append(
+                    f"if(gt(t,{fade_out_start})," f"({sticker.start_time + sticker.duration}-t)/{sticker.fade_out},1)"
+                )
+            if parts:
+                alpha_expr = "*".join(parts)
+                drawtext_params.append(f"alpha='{alpha_expr}'")
+
+        filter_str = f"{input_label}drawtext={':'.join(drawtext_params)}{output_label}"
+        return filter_str
+
+    @classmethod
+    def build_sticker_chain(
+        cls,
+        stickers: list[dict[str, Any]],
+        input_label: str,
+        output_label: str,
+        canvas_w: int,
+        canvas_h: int,
+    ) -> StickerOverlayResult:
+        """构建多贴纸叠加滤镜链.
+
+        Args:
+            stickers: 贴纸配置列表
+            input_label: 初始输入标签
+            output_label: 最终输出标签
+            canvas_w: 画布宽度
+            canvas_h: 画布高度
+
+        Returns:
+            StickerOverlayResult，包含滤镜字符串、输出标签、额外输入
+        """
+        if not stickers:
+            return StickerOverlayResult(
+                filter_str=f"{input_label}copy{output_label}",
+                output_label=output_label,
+                extra_inputs=[],
+            )
+
+        # 解析配置
+        parsed_stickers: list[tuple[int, ImageStickerConfig | TextStickerConfig]] = []
+        image_stickers: list[ImageStickerConfig] = []
+        image_paths: list[str] = []
+
+        for i, s in enumerate(stickers):
+            try:
+                sticker_type = s.get("type", "image")
+                z = int(s.get("z_index", 10))
+
+                if sticker_type == "text":
+                    config = TextStickerConfig(
+                        enabled=True,
+                        text=str(s.get("text", "")),
+                        font_size=int(s.get("font_size", 36)),
+                        font_color=str(s.get("font_color", "#FFFFFF")),
+                        stroke_color=str(s.get("stroke_color", "#000000")),
+                        stroke_width=int(s.get("stroke_width", 2)),
+                        shadow_x=int(s.get("shadow_x", 2)),
+                        shadow_y=int(s.get("shadow_y", 2)),
+                        shadow_alpha=float(s.get("shadow_alpha", 0.5)),
+                        position=str(s.get("position", "center")),
+                        x=cls._safe_float(s.get("x")),
+                        y=cls._safe_float(s.get("y")),
+                        x_unit=str(s.get("x_unit", "percent")),
+                        y_unit=str(s.get("y_unit", "percent")),
+                        start_time=float(s.get("start_time", 0)),
+                        duration=float(s.get("duration", 0)),
+                        fade_in=float(s.get("fade_in", 0)),
+                        fade_out=float(s.get("fade_out", 0)),
+                        z_index=z,
+                        bg_color=str(s.get("bg_color", "")),
+                        bg_padding=int(s.get("bg_padding", 8)),
+                        bg_alpha=float(s.get("bg_alpha", 0.8)),
+                        bg_corner_radius=int(s.get("bg_corner_radius", 8)),
+                    )
+                    parsed_stickers.append((z, config))
+                else:
+                    # 图片贴纸
+                    image_path = s.get("image_path", "") or s.get("image_url", "")
+                    if not image_path or not Path(image_path).exists():
+                        logger.warning("贴纸素材不存在，跳过: %s", image_path)
+                        continue
+
+                    config = ImageStickerConfig(
+                        enabled=True,
+                        position=str(s.get("position", "top_right")),
+                        x=cls._safe_float(s.get("x")),
+                        y=cls._safe_float(s.get("y")),
+                        x_unit=str(s.get("x_unit", "percent")),
+                        y_unit=str(s.get("y_unit", "percent")),
+                        scale=float(s.get("scale", 1.0)),
+                        width=int(s["width"]) if s.get("width") else None,
+                        height=int(s["height"]) if s.get("height") else None,
+                        opacity=max(0.0, min(1.0, float(s.get("opacity", 1.0)))),
+                        start_time=float(s.get("start_time", 0)),
+                        duration=float(s.get("duration", 0)),
+                        fade_in=float(s.get("fade_in", 0)),
+                        fade_out=float(s.get("fade_out", 0)),
+                        z_index=z,
+                        image_url=str(s.get("image_url", "")),
+                    )
+                    parsed_stickers.append((z, config))
+                    image_stickers.append(config)
+                    image_paths.append(image_path)
+
+            except Exception as e:
+                logger.warning("贴纸配置解析失败，跳过: %s", e)
+                continue
+
+        if not parsed_stickers:
+            return StickerOverlayResult(
+                filter_str=f"{input_label}copy{output_label}",
+                output_label=output_label,
+                extra_inputs=[],
+            )
+
+        # 按 z_index 排序
+        parsed_stickers.sort(key=lambda x: x[0])
+
+        # 构建滤镜链
+        filter_parts: list[str] = []
+        current_label = input_label
+        img_idx = 0  # 图片贴纸的输入索引偏移
+
+        for idx, (_, sticker) in enumerate(parsed_stickers):
+            next_label = f"sticker_{idx}_out" if idx < len(parsed_stickers) - 1 else output_label
+
+            if isinstance(sticker, ImageStickerConfig):
+                # 图片贴纸：使用额外的输入（输入索引 = 1 + img_idx，0 是主视频）
+                # 注意：实际输入索引需要调用方根据输入列表确定
+                # 这里我们按 image_stickers 的顺序分配索引
+                # 主输入是 [0:v]，贴纸输入从 [1:v] 开始
+                single_filter = cls._build_single_image_sticker(
+                    sticker=sticker,
+                    sticker_input_idx=img_idx + 1,  # +1 因为 0 是主视频
+                    input_label=current_label,
+                    output_label=next_label,
+                    canvas_w=canvas_w,
+                    canvas_h=canvas_h,
+                )
+                filter_parts.append(single_filter)
+                img_idx += 1
+            else:
+                # 文字贴纸：drawtext，不需要额外输入
+                single_filter = cls._build_drawtext_filter(
+                    sticker,  # type: ignore
+                    current_label,
+                    next_label,
+                    canvas_w,
+                    canvas_h,
+                )
+                filter_parts.append(single_filter)
+
+            current_label = next_label
+
+        return StickerOverlayResult(
+            filter_str=";".join(filter_parts),
+            output_label=output_label,
+            extra_inputs=image_paths,
+        )
+
+    @classmethod
+    def _build_single_image_sticker(
+        cls,
+        sticker: ImageStickerConfig,
+        sticker_input_idx: int,
+        input_label: str,
+        output_label: str,
+        canvas_w: int,
+        canvas_h: int,
+    ) -> str:
+        """构建单个图片贴纸的完整滤镜（预处理 + overlay）.
+
+        Args:
+            sticker: 贴纸配置
+            sticker_input_idx: 贴纸在 FFmpeg 输入中的索引
+            input_label: 输入视频标签
+            output_label: 输出标签
+            canvas_w: 画布宽
+            canvas_h: 画布高
+        """
+        scaled_label = f"sticker_s{sticker_input_idx}"
+
+        # 预处理滤镜（缩放 + 透明度 + 淡入淡出）
+        pre_filters: list[str] = []
+
+        # 缩放
+        if sticker.width and sticker.height:
+            pre_filters.append(f"scale={sticker.width}:{sticker.height}")
+        elif sticker.scale != 1.0:
+            pre_filters.append(f"scale=iw*{sticker.scale}:ih*{sticker.scale}")
+
+        # 透明度
+        if sticker.opacity < 1.0:
+            pre_filters.append(f"format=rgba,colorchannelmixer=aa={sticker.opacity}")
+
+        # 淡入淡出（使用 fade 的 alpha 模式）
+        fade_filters: list[str] = []
+        if sticker.fade_in > 0:
+            fade_filters.append(f"fade=in:st={sticker.start_time}:d={sticker.fade_in}:alpha=1")
+        if sticker.fade_out > 0 and sticker.duration > 0:
+            fade_out_start = sticker.start_time + sticker.duration - sticker.fade_out
+            if fade_out_start > 0:
+                fade_filters.append(f"fade=out:st={fade_out_start}:d={sticker.fade_out}:alpha=1")
+
+        # 估算贴纸尺寸用于位置计算
+        est_w = int(canvas_w * 0.3 * sticker.scale) if not sticker.width else sticker.width
+        est_h = int(canvas_h * 0.3 * sticker.scale) if not sticker.height else sticker.height
+        pos_x, pos_y = cls._resolve_position(sticker, canvas_w, canvas_h, est_w, est_h)
+
+        # enable 表达式
+        enable_expr = ""
+        if sticker.duration > 0:
+            enable_expr = f":enable='between(t,{sticker.start_time},{sticker.start_time + sticker.duration})'"
+
+        parts: list[str] = []
+
+        # 贴纸预处理
+        all_pre = pre_filters + fade_filters
+        if all_pre:
+            parts.append(f"[{sticker_input_idx}:v]{','.join(all_pre)}[{scaled_label}]")
+            sticker_source = f"[{scaled_label}]"
+        else:
+            sticker_source = f"[{sticker_input_idx}:v]"
+
+        # overlay 合成
+        parts.append(f"{input_label}{sticker_source}overlay={pos_x:.0f}:{pos_y:.0f}{enable_expr}{output_label}")
+
+        return ";".join(parts)
+
+    @staticmethod
+    def _safe_float(val: Any) -> float | None:
+        """安全转换 float."""
+        if val is None:
+            return None
+        try:
+            return float(val)
+        except (ValueError, TypeError):
+            return None
+
+
+# ── 便捷函数 ──────────────────────────────────────────────────────────────────
+
+
+def parse_stickers_from_config(config: dict[str, Any] | None) -> list[dict[str, Any]]:
+    """从 plan.config.stickers 解析贴纸列表."""
+    if not config:
+        return []
+    stickers = config.get("stickers", [])
+    if not isinstance(stickers, list):
+        return []
+    return stickers
+
+
+def get_sticker_categories() -> list[tuple[str, str]]:
+    """获取贴纸分类列表."""
+    return list(STICKER_CATEGORIES)

apps/worker/video_processing/transition_engine.py

@@ -0,0 +1,381 @@
+"""转场特效引擎 — Phase 8 智能增强.
+
+基于 FFmpeg xfade 滤镜的统一转场抽象层，提供：
+  1. 转场类型枚举与预设管理
+  2. 转场配置解析与边界校验
+  3. 降级策略（不支持的转场自动 fallback 到硬切）
+  4. xfade 滤镜链构建（封装底层 ffmpeg_utils）
+
+新增转场只需在 TransitionType 中加一项 + 在 XFADE_TRANSITION_MAP 中映射。
+"""
+
+from __future__ import annotations
+
+import logging
+import sys
+from dataclasses import dataclass
+
+if sys.version_info >= (3, 11):
+    from enum import StrEnum
+else:
+    from enum import Enum
+
+    class StrEnum(str, Enum):
+        pass
+
+
+from video_processing.ffmpeg_utils import build_xfade_filter_chain
+
+logger = logging.getLogger(__name__)
+
+
+# ── 常量 ──────────────────────────────────────────────────────────────────────
+
+# 转场时长范围（秒）
+MIN_TRANSITION_DURATION = 0.3
+MAX_TRANSITION_DURATION = 2.0
+DEFAULT_TRANSITION_DURATION = 0.5
+
+# 硬切（无转场）
+CUT_TRANSITION = "cut"
+
+
+# ── 转场类型枚举 ──────────────────────────────────────────────────────────────
+
+
+class TransitionType(StrEnum):
+    """支持的转场效果类型.
+
+    每种类型对应 FFmpeg xfade filter 的一个 transition 值。
+    新增转场只需在此添加一项，并在 _FFMPEG_XFADE_MAP 中映射。
+    """
+
+    # 硬切（无转场效果，直接拼接）
+    CUT = "cut"
+
+    # 淡入淡出（最常用，默认 fallback）
+    FADE = "fade"
+
+    # 溶解（交叉溶解）
+    DISSOLVE = "dissolve"
+
+    # 滑入系列
+    SLIDE_LEFT = "slideleft"
+    SLIDE_RIGHT = "slideright"
+    SLIDE_UP = "slideup"
+    SLIDE_DOWN = "slidedown"
+
+    # 缩放
+    ZOOM = "zoom"
+
+    # 擦除系列
+    WIPE_LEFT = "wipeleft"
+    WIPE_RIGHT = "wiperight"
+    WIPE_UP = "wipeup"
+    WIPE_DOWN = "wipedown"
+
+    # 圆形扩散
+    CIRCLE_CROP = "circlecrop"
+
+    # 矩形覆盖
+    RECT_CROP = "rectcrop"
+
+    @classmethod
+    def all_supported(cls) -> list[str]:
+        """返回所有支持的转场类型名称列表."""
+        return [t.value for t in cls if t != cls.CUT]
+
+    @classmethod
+    def is_supported(cls, name: str) -> bool:
+        """检查转场类型是否支持（不区分大小写和下划线）."""
+        normalized = _normalize_transition_name(name)
+        return normalized in _NAME_TO_ENUM_MAP
+
+
+# ── 名称 → 枚举 映射（支持多种别名）──────────────────────────────────────────
+
+
+def _normalize_transition_name(name: str) -> str:
+    """标准化转场名称：小写 + 去下划线."""
+    return name.lower().replace("_", "").replace("-", "")
+
+
+# 构建别名映射
+_NAME_TO_ENUM_MAP: dict[str, TransitionType] = {}
+for _t in TransitionType:
+    _NAME_TO_ENUM_MAP[_normalize_transition_name(_t.value)] = _t
+
+# 额外的别名
+_ALIASES: dict[str, TransitionType] = {
+    "dissolve": TransitionType.DISSOLVE,
+    "crossfade": TransitionType.DISSOLVE,
+    "crossdissolve": TransitionType.DISSOLVE,
+    "fadein": TransitionType.FADE,
+    "fadeout": TransitionType.FADE,
+    "fadeblack": TransitionType.FADE,
+    "slide": TransitionType.SLIDE_LEFT,  # 默认向左滑
+    "wipe": TransitionType.WIPE_LEFT,  # 默认向左擦
+    "zoomin": TransitionType.ZOOM,
+    "zoomout": TransitionType.ZOOM,
+    "circle": TransitionType.CIRCLE_CROP,
+    "rect": TransitionType.RECT_CROP,
+}
+for _alias, _type in _ALIASES.items():
+    _key = _normalize_transition_name(_alias)
+    if _key not in _NAME_TO_ENUM_MAP:
+        _NAME_TO_ENUM_MAP[_key] = _type
+
+
+# ── TransitionType → FFmpeg xfade transition 名称映射 ─────────────────────────
+
+
+_FFMPEG_XFADE_MAP: dict[TransitionType, str] = {
+    TransitionType.FADE: "fade",
+    TransitionType.DISSOLVE: "dissolve",
+    TransitionType.SLIDE_LEFT: "slideleft",
+    TransitionType.SLIDE_RIGHT: "slideright",
+    TransitionType.SLIDE_UP: "slideup",
+    TransitionType.SLIDE_DOWN: "slidedown",
+    TransitionType.ZOOM: "zoomin",
+    TransitionType.WIPE_LEFT: "wipeleft",
+    TransitionType.WIPE_RIGHT: "wiperight",
+    TransitionType.WIPE_UP: "wipeup",
+    TransitionType.WIPE_DOWN: "wipedown",
+    TransitionType.CIRCLE_CROP: "circlecrop",
+    TransitionType.RECT_CROP: "rectcrop",
+}
+
+
+# ── 转场配置 ──────────────────────────────────────────────────────────────────
+
+
+@dataclass(slots=True)
+class TransitionConfig:
+    """转场效果配置.
+
+    Attributes:
+        effect: 转场效果名称（见 TransitionType）
+        duration: 转场时长（秒），范围 0.3~2.0，默认 0.5
+    """
+
+    effect: str = CUT_TRANSITION
+    duration: float = DEFAULT_TRANSITION_DURATION
+
+    @classmethod
+    def parse(cls, effect: str | None = None, duration: float | None = None) -> "TransitionConfig":
+        """解析并验证转场配置，自动处理边界和降级.
+
+        Args:
+            effect: 转场效果名称（None 或空则使用默认 cut）
+            duration: 转场时长（None 则使用默认值）
+
+        Returns:
+            验证后的 TransitionConfig
+        """
+        # 处理 effect
+        final_effect = CUT_TRANSITION
+        if effect and effect.strip():
+            effect_clean = effect.strip()
+            if TransitionType.is_supported(effect_clean):
+                final_effect = _resolve_transition_enum(effect_clean).value
+            elif effect_clean.lower() == CUT_TRANSITION:
+                final_effect = CUT_TRANSITION
+            else:
+                # 降级：不支持的转场 → 硬切，不阻断渲染
+                logger.warning(
+                    "不支持的转场效果 '%s'，已降级为硬切（cut）",
+                    effect_clean,
+                )
+                final_effect = CUT_TRANSITION
+
+        # 处理 duration：边界钳制
+        final_duration = DEFAULT_TRANSITION_DURATION
+        if duration is not None:
+            try:
+                d = float(duration)
+                if d < MIN_TRANSITION_DURATION:
+                    logger.warning(
+                        "转场时长 %.3fs 小于最小值 %.1fs，已钳制到最小值",
+                        d,
+                        MIN_TRANSITION_DURATION,
+                    )
+                    final_duration = MIN_TRANSITION_DURATION
+                elif d > MAX_TRANSITION_DURATION:
+                    logger.warning(
+                        "转场时长 %.3fs 大于最大值 %.1fs，已钳制到最大值",
+                        d,
+                        MAX_TRANSITION_DURATION,
+                    )
+                    final_duration = MAX_TRANSITION_DURATION
+                else:
+                    final_duration = d
+            except (TypeError, ValueError):
+                logger.warning("无效的转场时长 '%s'，使用默认值 %.1fs", duration, DEFAULT_TRANSITION_DURATION)
+                final_duration = DEFAULT_TRANSITION_DURATION
+
+        return cls(effect=final_effect, duration=final_duration)
+
+    @property
+    def is_cut(self) -> bool:
+        """是否为硬切（无转场效果）."""
+        return self.effect == CUT_TRANSITION
+
+    @property
+    def ffmpeg_transition(self) -> str:
+        """获取对应的 FFmpeg xfade transition 名称."""
+        if self.is_cut:
+            return ""
+        enum_type = _resolve_transition_enum(self.effect)
+        return _FFMPEG_XFADE_MAP.get(enum_type, "fade")
+
+
+def _resolve_transition_enum(name: str) -> TransitionType:
+    """将名称解析为 TransitionType 枚举，必须先通过 is_supported 校验."""
+    normalized = _normalize_transition_name(name)
+    return _NAME_TO_ENUM_MAP.get(normalized, TransitionType.FADE)
+
+
+# ── 转场引擎 ──────────────────────────────────────────────────────────────────
+
+
+class TransitionEngine:
+    """转场特效引擎.
+
+    封装转场配置验证、降级策略和 xfade 滤镜链构建，
+    供 UnifiedRenderService 等上层调用。
+
+    用法::
+
+        engine = TransitionEngine(default_duration=0.5)
+        config = engine.resolve_config("fade", 0.8)
+        filter_str, total_dur = engine.build_xfade_chain(
+            clip_durations=[3.0, 4.0, 5.0],
+            clip_video_labels=["v0", "v1", "v2"],
+            transitions=["cut", "fade", "dissolve"],
+        )
+    """
+
+    def __init__(self, default_duration: float = DEFAULT_TRANSITION_DURATION) -> None:
+        """初始化转场引擎.
+
+        Args:
+            default_duration: 默认转场时长（秒），用于未指定时长的 clip
+        """
+        self._default_duration = default_duration
+
+    def resolve_config(
+        self,
+        effect: str | None = None,
+        duration: float | None = None,
+    ) -> TransitionConfig:
+        """解析单个转场配置，应用验证和降级.
+
+        Args:
+            effect: 转场效果名称
+            duration: 转场时长
+
+        Returns:
+            验证后的 TransitionConfig
+        """
+        # 若未指定 duration，使用引擎默认值
+        dur = duration if duration is not None else self._default_duration
+        return TransitionConfig.parse(effect=effect, duration=dur)
+
+    def resolve_clip_transitions(
+        self,
+        clip_transitions: list[str],
+        clip_durations: list[float] | None = None,
+    ) -> list[TransitionConfig]:
+        """批量解析 clip 级别的转场配置.
+
+        Args:
+            clip_transitions: 每个 clip 的转场效果名称列表
+            clip_durations: 每个 clip 的时长列表（用于验证转场时长不超过片段时长）
+
+        Returns:
+            TransitionConfig 列表
+        """
+        configs: list[TransitionConfig] = []
+        for i, effect in enumerate(clip_transitions):
+            cfg = self.resolve_config(effect=effect)
+            # 额外校验：转场时长不能超过对应 clip 时长的一半（保守限制）
+            if clip_durations and i < len(clip_durations) and not cfg.is_cut:
+                max_safe_duration = max(MIN_TRANSITION_DURATION, clip_durations[i] * 0.5)
+                if cfg.duration > max_safe_duration:
+                    cfg = TransitionConfig(effect=cfg.effect, duration=max_safe_duration)
+            configs.append(cfg)
+        return configs
+
+    def build_xfade_chain(
+        self,
+        clip_durations: list[float],
+        clip_video_labels: list[str],
+        transitions: list[str],
+        *,
+        transition_duration: float | None = None,
+        output_label: str = "outv",
+    ) -> tuple[str, float]:
+        """构建 xfade 转场滤镜链.
+
+        对每步转场应用验证和降级，然后调用底层 ffmpeg_utils 构建。
+
+        Args:
+            clip_durations: 每个片段的时长
+            clip_video_labels: 每个片段的视频流标签
+            transitions: 每个片段对应的转场效果
+            transition_duration: 统一转场时长，None 则使用引擎默认值
+            output_label: 最终输出标签
+
+        Returns:
+            (filter_string, estimated_total_duration)
+        """
+        if len(clip_durations) <= 1:
+            return build_xfade_filter_chain(
+                clip_durations=clip_durations,
+                clip_video_labels=clip_video_labels,
+                transitions=transitions,
+                transition_duration=transition_duration or self._default_duration,
+                output_label=output_label,
+            )
+
+        # 解析所有转场配置
+        resolved = self.resolve_clip_transitions(transitions, clip_durations)
+        resolved_effects = [c.effect for c in resolved]
+
+        # 使用统一的时长（取各转场中最大的时长作为基准，底层会做每步钳制）
+        dur = transition_duration or self._default_duration
+        if not dur:
+            dur = max(c.duration for c in resolved) if resolved else DEFAULT_TRANSITION_DURATION
+
+        # 调用底层构建
+        return build_xfade_filter_chain(
+            clip_durations=clip_durations,
+            clip_video_labels=clip_video_labels,
+            transitions=resolved_effects,
+            transition_duration=dur,
+            output_label=output_label,
+        )
+
+    @staticmethod
+    def supported_transitions() -> list[dict[str, str]]:
+        """获取所有支持的转场效果列表（用于 API 返回给前端）.
+
+        Returns:
+            [{name, display_name, category}, ...]
+        """
+        return [
+            {"name": "cut", "display_name": "硬切", "category": "basic"},
+            {"name": "fade", "display_name": "淡入淡出", "category": "basic"},
+            {"name": "dissolve", "display_name": "溶解", "category": "basic"},
+            {"name": "slideleft", "display_name": "左滑入", "category": "slide"},
+            {"name": "slideright", "display_name": "右滑入", "category": "slide"},
+            {"name": "slideup", "display_name": "上滑入", "category": "slide"},
+            {"name": "slidedown", "display_name": "下滑入", "category": "slide"},
+            {"name": "zoom", "display_name": "缩放", "category": "zoom"},
+            {"name": "wipeleft", "display_name": "左擦除", "category": "wipe"},
+            {"name": "wiperight", "display_name": "右擦除", "category": "wipe"},
+            {"name": "wipeup", "display_name": "上擦除", "category": "wipe"},
+            {"name": "wipedown", "display_name": "下擦除", "category": "wipe"},
+            {"name": "circlecrop", "display_name": "圆形扩散", "category": "special"},
+            {"name": "rectcrop", "display_name": "矩形扩散", "category": "special"},
+        ]

apps/worker/video_processing/trim_engine.py

@@ -0,0 +1,339 @@
+"""裁剪引擎 — 基于 FFmpeg trim/atrim 的精确帧级裁剪.
+
+支持：
+- 入点出点裁剪（start_time / end_time / duration 三选二）
+- 边界自动钳制（超出素材时长自动修正，不阻断渲染）
+- 多段裁剪（一个素材裁剪出多段）
+- 音画同步（视频 + 音频同步裁剪）
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+# 最小裁剪时长（秒），低于此值视为无效
+MIN_TRIM_DURATION = 0.1
+
+
+@dataclass
+class TrimConfig:
+    """裁剪配置.
+
+    三选二规则：start_time / end_time / duration 中必须至少给出两个，
+    第三个会被自动推导。如果三个都给了，以 start_time + duration 为准。
+
+    边界保护：
+    - start_time < 0 → 钳制到 0
+    - end_time > 素材时长 → 钳制到素材时长
+    - 计算出的 duration < 最小阈值 → 标记为无效
+    """
+
+    start_time: float = 0.0  # 入点（素材内时间，秒）
+    end_time: float = 0.0  # 出点（素材内时间，秒），0 表示未指定
+    duration: float = 0.0  # 裁剪时长（秒），0 表示未指定
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any] | None) -> TrimConfig | None:
+        """从字典构造，无有效裁剪参数时返回 None（不裁剪）."""
+        if not data:
+            return None
+
+        start = float(data.get("start_time", 0) or 0)
+        end = float(data.get("end_time", 0) or 0)
+        dur = float(data.get("duration", 0) or 0)
+
+        # 三个参数都没有 → 不裁剪
+        if start <= 0 and end <= 0 and dur <= 0:
+            return None
+
+        # 至少有两个参数（或一个合理的 start/duration）
+        # 兼容：只传了 start_time → 从 start 开始取到末尾
+        # 兼容：只传了 duration → 从 0 开始取 duration
+        if start > 0 and end <= 0 and dur <= 0:
+            # 只有 start，取到末尾 → 这是"从某点开始"的语义，算有效
+            pass
+        elif dur > 0 and start <= 0 and end <= 0:
+            # 只有 duration → 从开头取 duration，算有效
+            pass
+        elif start <= 0 and end <= 0 and dur <= 0:
+            return None
+
+        return cls(start_time=start, end_time=end, duration=dur)
+
+    def validate_and_resolve(self, asset_duration: float) -> TrimConfig:
+        """根据素材实际时长，解析并钳制裁剪参数.
+
+        返回一个新的 TrimConfig，其中 start_time / end_time / duration 都已确定。
+        如果裁剪无效（时长为0或负数），仍返回但调用方应检查 is_valid。
+        """
+        start = self.start_time
+        end = self.end_time
+        dur = self.duration
+
+        # 边界：start 不能为负
+        if start < 0:
+            start = 0.0
+
+        # 边界：asset_duration 为 0 时保守处理（不裁剪，取全部）
+        if asset_duration <= 0:
+            return TrimConfig(start_time=0.0, end_time=0.0, duration=0.0)
+
+        # 三选二推导
+        # 判断顺序很重要：先判断需要两个显式值的组合，最后判断含默认值的
+        # 情况1：start + end 都有显式值
+        if start > 0 and end > 0:
+            if end <= start:
+                # 出点 <= 入点，无效 → 返回 start 处一个极短片段（调用方会判无效）
+                return TrimConfig(start_time=start, end_time=start, duration=0.0)
+            dur = end - start
+        # 情况2：end + duration 都有显式值
+        elif end > 0 and dur > 0:
+            start = end - dur
+            if start < 0:
+                start = 0.0
+                dur = end  # 重新计算
+        # 情况3：start + duration 都有值（start 可以是 0）
+        elif dur > 0:
+            end = start + dur
+        # 情况4：只有 start → 取到素材末尾
+        elif start > 0 and end <= 0 and dur <= 0:
+            end = asset_duration
+            dur = end - start
+        # 情况5：只有 end → 从开头取到 end
+        elif end > 0 and start <= 0 and dur <= 0:
+            start = 0.0
+            dur = end
+        else:
+            # 都没有 → 不裁剪
+            return TrimConfig(start_time=0.0, end_time=0.0, duration=0.0)
+
+        # 边界钳制：end 不能超过素材时长
+        if end > asset_duration:
+            end = asset_duration
+            dur = end - start
+
+        # 边界钳制：start 不能超过素材时长
+        if start >= asset_duration:
+            start = max(0.0, asset_duration - MIN_TRIM_DURATION)
+            dur = asset_duration - start
+            end = asset_duration
+
+        # 保证 duration 不为负
+        if dur < 0:
+            dur = 0.0
+
+        return TrimConfig(start_time=start, end_time=end, duration=dur)
+
+    @property
+    def is_valid(self) -> bool:
+        """裁剪是否有效（时长大于最小阈值）."""
+        return self.duration >= MIN_TRIM_DURATION
+
+    @property
+    def is_noop(self) -> bool:
+        """是否等价于不裁剪（从0开始取全部）."""
+        return self.start_time <= 0 and self.duration <= 0
+
+    @property
+    def trim_from_start(self) -> bool:
+        """是否从开头裁剪（start_time == 0）."""
+        return self.start_time <= 0
+
+
+@dataclass
+class TrimSegment:
+    """多段裁剪中的一段."""
+
+    segment_id: str  # 段 ID（用于生成唯一标签）
+    trim: TrimConfig  # 裁剪配置
+    order: int = 0  # 排序
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any], default_order: int = 0) -> TrimSegment:
+        """从字典构造."""
+        return cls(
+            segment_id=str(data.get("segment_id", "") or f"seg_{default_order}"),
+            trim=TrimConfig(
+                start_time=float(data.get("start_time", 0) or 0),
+                end_time=float(data.get("end_time", 0) or 0),
+                duration=float(data.get("duration", 0) or 0),
+            ),
+            order=int(data.get("order", default_order)),
+        )
+
+
+class TrimEngine:
+    """裁剪引擎 — 生成 FFmpeg trim / atrim 滤镜."""
+
+    @staticmethod
+    def build_video_trim_filter(
+        input_label: str,
+        trim: TrimConfig,
+        output_label: str,
+    ) -> str:
+        """构建视频裁剪滤镜链.
+
+        Args:
+            input_label: 输入视频标签，如 "[0:v]"
+            trim: 裁剪配置（已解析钳制）
+            output_label: 输出视频标签，如 "[v0_trimmed]"
+
+        Returns:
+            FFmpeg filter 字符串，如 "[0:v]trim=start=10:duration=5,setpts=PTS-STARTPTS[v0_trimmed]"
+        """
+        if trim.is_noop:
+            # 不裁剪，直接直通
+            return f"{input_label}copy{output_label}" if False else f"{input_label}setpts=PTS-STARTPTS{output_label}"
+
+        parts: list[str] = []
+
+        # trim 滤镜参数
+        trim_args: list[str] = []
+        if trim.start_time > 0:
+            trim_args.append(f"start={trim.start_time:.3f}")
+        if trim.duration > 0:
+            trim_args.append(f"duration={trim.duration:.3f}")
+        elif trim.end_time > 0:
+            # end 用 duration 表示（start 到 end 的时长）
+            # 但 validate_and_resolve 后应该已经有 duration 了
+            pass
+
+        parts.append(f"trim={':'.join(trim_args)}")
+        parts.append("setpts=PTS-STARTPTS")
+
+        filter_str = f"{input_label}{','.join(parts)}{output_label}"
+        return filter_str
+
+    @staticmethod
+    def build_audio_trim_filter(
+        input_label: str,
+        trim: TrimConfig,
+        output_label: str,
+    ) -> str:
+        """构建音频裁剪滤镜链.
+
+        Args:
+            input_label: 输入音频标签，如 "[0:a]"
+            trim: 裁剪配置（已解析钳制）
+            output_label: 输出音频标签，如 "[a0_trimmed]"
+
+        Returns:
+            FFmpeg filter 字符串，如 "[0:a]atrim=start=10:duration=5,asetpts=PTS-STARTPTS[a0_trimmed]"
+        """
+        if trim.is_noop:
+            return f"{input_label}asetpts=PTS-STARTPTS{output_label}"
+
+        parts: list[str] = []
+
+        trim_args: list[str] = []
+        if trim.start_time > 0:
+            trim_args.append(f"start={trim.start_time:.3f}")
+        if trim.duration > 0:
+            trim_args.append(f"duration={trim.duration:.3f}")
+
+        parts.append(f"atrim={':'.join(trim_args)}")
+        parts.append("asetpts=PTS-STARTPTS")
+
+        filter_str = f"{input_label}{','.join(parts)}{output_label}"
+        return filter_str
+
+    @staticmethod
+    def resolve_segments(
+        segments: list[TrimSegment],
+        asset_duration: float,
+    ) -> list[TrimSegment]:
+        """解析并钳制多段裁剪配置，过滤无效段.
+
+        Args:
+            segments: 原始段列表
+            asset_duration: 素材实际时长
+
+        Returns:
+            解析后的有效段列表，按 order 排序
+        """
+        resolved: list[TrimSegment] = []
+        for i, seg in enumerate(segments):
+            resolved_trim = seg.trim.validate_and_resolve(asset_duration)
+            if not resolved_trim.is_valid:
+                logger.warning("裁剪段无效，跳过: segment_id=%s duration=%.3f", seg.segment_id, resolved_trim.duration)
+                continue
+            resolved.append(
+                TrimSegment(
+                    segment_id=seg.segment_id,
+                    trim=resolved_trim,
+                    order=seg.order if seg.order >= 0 else i,
+                )
+            )
+
+        resolved.sort(key=lambda s: s.order)
+        return resolved
+
+    @staticmethod
+    def parse_segments_from_config(config: dict[str, Any] | None) -> list[TrimSegment]:
+        """从 clip config 中解析多段裁剪配置.
+
+        config 中支持：
+        - trim_segments: [ {segment_id, start_time, end_time, duration, order}, ... ]
+        - trim_start / trim_end / trim_duration: 单段裁剪（兼容旧格式）
+        """
+        if not config:
+            return []
+
+        # 优先解析多段
+        raw_segments = config.get("trim_segments", [])
+        if raw_segments and isinstance(raw_segments, list):
+            segments = []
+            for i, raw in enumerate(raw_segments):
+                if isinstance(raw, dict):
+                    segments.append(TrimSegment.from_dict(raw, default_order=i))
+            return segments
+
+        # 单段裁剪兼容：从 trim_start/trim_end/trim_duration 构造
+        has_single = any(k in config for k in ("trim_start", "trim_end", "trim_duration"))
+        if has_single:
+            seg = TrimSegment(
+                segment_id="main",
+                trim=TrimConfig(
+                    start_time=float(config.get("trim_start", 0) or 0),
+                    end_time=float(config.get("trim_end", 0) or 0),
+                    duration=float(config.get("trim_duration", 0) or 0),
+                ),
+                order=0,
+            )
+            return [seg]
+
+        return []
+
+
+# ── 工具函数 ──────────────────────────────────────────────────────────────────
+
+
+def extract_trim_from_clip_config(config: dict[str, Any] | None) -> TrimConfig | None:
+    """从 clip config 中提取单段裁剪配置.
+
+    兼容以下字段名：
+    - trim_start / trim_end / trim_duration
+    - start_time / end_time / duration（在 trim 子字典里）
+    """
+    if not config:
+        return None
+
+    # trim 子字典
+    if "trim" in config and isinstance(config["trim"], dict):
+        return TrimConfig.from_dict(config["trim"])
+
+    # 扁平字段
+    has_any = any(k in config for k in ("trim_start", "trim_end", "trim_duration"))
+    if not has_any:
+        return None
+
+    data = {
+        "start_time": config.get("trim_start", 0),
+        "end_time": config.get("trim_end", 0),
+        "duration": config.get("trim_duration", 0),
+    }
+    return TrimConfig.from_dict(data)

apps/worker/video_processing/unified_render_service.py

@@ -28,6 +28,7 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any
 
+from video_processing.chroma_key_engine import apply_chroma_key_if_needed
 from video_processing.color_grade_engine import ColorGradeConfig, ColorGradeEngine
 from video_processing.ffmpeg_utils import (
     DEFAULT_FPS,
@@ -35,16 +36,22 @@ from video_processing.ffmpeg_utils import (
     DEFAULT_OUTPUT_WIDTH,
     DEFAULT_TRANSITION_DURATION,
     FFMPEG_BIN,
-    build_xfade_filter_chain,
     probe_duration,
     probe_video_info,
     run_ffmpeg,
 )
+from video_processing.intro_outro_engine import IntroOutroConfig, IntroOutroEngine
 from video_processing.pip_engine import PiPConfig, PiPEngine, PiPLayerConfig
 from video_processing.render_audio import RenderContext, merge_audio_video, mix_audio
 from video_processing.render_subtitles import generate_ass_subtitles
+from video_processing.reverse_engine import ReverseConfig, ReverseEngine
+from video_processing.speed_engine import SpeedConfig, SpeedEngine
+from video_processing.sticker_engine import StickerEngine, parse_stickers_from_config
 from video_processing.subtitle_generator import generate_ass_from_timeline
+from video_processing.transition_engine import TransitionEngine
+from video_processing.trim_engine import TrimConfig, TrimEngine, extract_trim_from_clip_config
 from video_processing.tts_engine import TtsEngine
+from video_processing.watermark_engine import WatermarkConfig, WatermarkEngine
 
 from packages.domain.tts_config import TtsConfig
 
@@ -66,10 +73,13 @@ class ResolvedClip:
     start_time: float = 0.0
     duration: float = 0.0  # 0 表示使用素材完整时长
     transition_effect: str = "cut"
+    transition_duration: float = 0.0  # 0 表示使用全局默认值
+    playback_speed: float = 1.0  # 0 或 1.0 表示原速
     config: dict[str, Any] = field(default_factory=dict)
 
     # 运行时填充
     actual_duration: float = 0.0  # 素材实际时长（probe 后填充）
+    trim_config: TrimConfig | None = None  # 解析后的裁剪配置（运行时填充）
 
 
 @dataclass
@@ -165,6 +175,7 @@ class UnifiedRenderService:
         output_fps: int = DEFAULT_FPS,
         transition_duration: float = DEFAULT_TRANSITION_DURATION,
         asr_service: Any = None,  # ASRService 实例，用于自动生成字幕
+        bgm_path: str | None = None,  # BGM 本地文件路径
     ):
         self.plan = plan
         self.clips = clips
@@ -175,6 +186,9 @@ class UnifiedRenderService:
         self.output_fps = output_fps
         self.transition_duration = transition_duration
         self.asr_service = asr_service
+        self.bgm_path = bgm_path
+        self._transition_engine = TransitionEngine(default_duration=transition_duration)
+        self._speed_engine = SpeedEngine()
 
     def render(self) -> RenderResult:
         """执行渲染，返回 RenderResult.
@@ -288,9 +302,60 @@ class UnifiedRenderService:
         if is_pass_through:
             # 直通场景已在一次调用中完成视频+音频
             has_audio = pass_through_has_audio
+            # 直通模式下也支持 BGM 混音：提取音频 → 混 BGM → 合并回视频
+            if self.bgm_path and pass_through_has_audio:
+                config = self.plan.config or {}
+                bgm_config = config.get("bgm", {}) or {}
+                if bgm_config.get("enabled", False):
+                    ctx = RenderContext(work_dir=self.work_dir, plan_id=self.plan.id)
+                    from video_processing.bgm_mixer import BGMConfig, mix_bgm_with_main
+
+                    bgm_cfg = BGMConfig.from_config_dict(self.bgm_path, bgm_config)
+                    # 从直通输出中提取音频
+                    main_audio_path = self.work_dir / f"pass_through_audio_{self.plan.id}.aac"
+                    extract_cmd = [
+                        FFMPEG_BIN,
+                        "-y",
+                        "-i",
+                        str(output_path),
+                        "-vn",
+                        "-acodec",
+                        "aac",
+                        "-b:a",
+                        "128k",
+                        str(main_audio_path),
+                    ]
+                    try:
+                        from video_processing.ffmpeg_utils import run_ffmpeg
+
+                        run_ffmpeg(extract_cmd)
+                        final_audio = mix_bgm_with_main(ctx, main_audio_path, bgm_cfg, video_duration)
+                        # 合并回视频
+
+                        bgm_output = self.work_dir / f"rendered_{self.plan.id}_bgm.mp4"
+                        merge_audio_video(ctx, output_path, final_audio, bgm_output)
+                        output_path = bgm_output
+                        logger.info("[unified-render] pass-through BGM mix done: plan_id=%s", self.plan.id)
+                    except Exception:
+                        logger.exception(
+                            "[unified-render] pass-through BGM mix failed, skipping: plan_id=%s", self.plan.id
+                        )
         else:
-            ctx = RenderContext(work_dir=self.work_dir, plan_id=self.plan.id)
-            audio_path = mix_audio(ctx, layers, video_duration)
+            config = self.plan.config or {}
+            bgm_config = config.get("bgm", {}) or {}
+            noise_reduction_config = config.get("audio_noise_reduction")
+            ctx = RenderContext(
+                work_dir=self.work_dir,
+                plan_id=self.plan.id,
+                noise_reduction_config=noise_reduction_config,
+            )
+            audio_path = mix_audio(
+                ctx,
+                layers,
+                video_duration,
+                bgm_path=self.bgm_path,
+                bgm_config=bgm_config,
+            )
             t_audio_end = time.time()
             audio_mix_ms = int((t_audio_end - t_audio_start) * 1000)
             has_audio = audio_path is not None
@@ -311,6 +376,85 @@ class UnifiedRenderService:
         # 8. 探测输出
         duration, file_size, width, height = self._probe_output(output_path)
 
+        # 9. 片头片尾拼接（后处理）
+        intro_outro_config = IntroOutroConfig.from_dict((self.plan.config or {}).get("intro_outro"))
+        if intro_outro_config.has_intro or intro_outro_config.has_outro:
+            io_valid, io_err = intro_outro_config.validate()
+            if io_valid:
+                final_with_io = self.work_dir / f"rendered_{self.plan.id}_with_io.mp4"
+                intro_path = None
+                outro_path = None
+
+                # 生成片头
+                if intro_outro_config.has_intro:
+                    intro_path = self.work_dir / f"intro_{self.plan.id}.mp4"
+                    intro_ok = False
+                    if intro_outro_config.intro_type == "video":
+                        import shutil
+
+                        src = Path(intro_outro_config.intro_video_path)
+                        if src.exists():
+                            shutil.copy2(src, intro_path)
+                            intro_ok = True
+                        else:
+                            logger.warning("片头视频不存在，跳过片头: %s", src)
+                    elif intro_outro_config.intro_type == "text":
+                        intro_ok = IntroOutroEngine.generate_text_intro(
+                            intro_path,
+                            intro_outro_config,
+                            self.output_width,
+                            self.output_height,
+                            self.output_fps,
+                        )
+
+                    if not intro_ok:
+                        intro_path = None
+
+                # 生成片尾
+                if intro_outro_config.has_outro:
+                    outro_path = self.work_dir / f"outro_{self.plan.id}.mp4"
+                    outro_ok = False
+                    if intro_outro_config.outro_type == "video":
+                        import shutil
+
+                        src = Path(intro_outro_config.outro_video_path)
+                        if src.exists():
+                            shutil.copy2(src, outro_path)
+                            outro_ok = True
+                        else:
+                            logger.warning("片尾视频不存在，跳过片尾: %s", src)
+                    elif intro_outro_config.outro_type in ("text", "follow"):
+                        outro_ok = IntroOutroEngine.generate_text_outro(
+                            outro_path,
+                            intro_outro_config,
+                            self.output_width,
+                            self.output_height,
+                            self.output_fps,
+                        )
+
+                    if not outro_ok:
+                        outro_path = None
+
+                # 拼接
+                if intro_path or outro_path:
+                    concat_ok = IntroOutroEngine.concat_with_intro_outro(
+                        output_path,
+                        intro_path,
+                        outro_path,
+                        final_with_io,
+                        transition_duration=intro_outro_config.transition_duration,
+                        transition_effect=intro_outro_config.transition_effect,
+                    )
+                    if concat_ok and final_with_io.exists():
+                        output_path = final_with_io
+                        # 重新探测
+                        duration, file_size, width, height = self._probe_output(output_path)
+                        logger.info("[unified-render] 片头片尾拼接完成: plan_id=%s", self.plan.id)
+                    else:
+                        logger.warning("[unified-render] 片头片尾拼接失败，使用原视频: plan_id=%s", self.plan.id)
+            else:
+                logger.warning("[unified-render] 片头片尾配置无效，跳过: %s", io_err)
+
         t_total = int((time.time() - t_start) * 1000)
         logger.info(
             "[unified-render] render done: plan_id=%s total_ms=%d video_ms=%d audio_ms=%d "
@@ -352,7 +496,7 @@ class UnifiedRenderService:
         if not main_layer or not main_layer.clips:
             return 0.0
 
-        total = sum(UnifiedRenderService._clip_effective_duration(c) for c in main_layer.clips)
+        total = sum(UnifiedRenderService._clip_adjusted_duration(c) for c in main_layer.clips)
 
         # 减去转场重叠时间（粗略估算）
         n_clips = len(main_layer.clips)
@@ -608,6 +752,7 @@ class UnifiedRenderService:
         1. 只有 1 个图层
         2. 该图层是视频图层（main/broll/background），不是 overlay/corner_voice/audio
         3. 该图层只有 1 个 clip（无转场需求）
+        4. 没有贴纸（贴纸需要 filter_complex 或额外输入）
         """
         if len(layers) != 1:
             return False
@@ -616,6 +761,10 @@ class UnifiedRenderService:
             return False
         if len(layer.clips) != 1:
             return False
+        # 有贴纸时禁用直通（图片贴纸需要额外输入，统一走 filter_complex）
+        plan_config = getattr(self.plan, "config", None) or {}
+        if isinstance(plan_config, dict) and plan_config.get("stickers"):
+            return False
         return True
 
     def _can_use_stream_copy(
@@ -828,6 +977,13 @@ class UnifiedRenderService:
             filters.append(f"trim=duration={effective_duration}")
             filters.append("setpts=PTS-STARTPTS")
 
+        # 倒放滤镜
+        reverse_config = ReverseConfig.from_dict(clip.config.get("reverse"))
+        if reverse_config.enabled and reverse_config.reverse_video:
+            reverse_filter = ReverseEngine.build_video_filter(reverse_config, duration=effective_duration)
+            if reverse_filter:
+                filters.append(reverse_filter)
+
         # scale + crop（铺满裁剪）
         if role in ("overlay", "corner_voice"):
             pip_w = int(self.output_width * _PIP_SCALE)
@@ -844,6 +1000,18 @@ class UnifiedRenderService:
             grade_filter = ColorGradeEngine.build_filter(color_grade)
             if grade_filter:
                 filters.append(grade_filter)
+        # chroma key 绿幕抠像
+        try:
+            from video_processing.chroma_key_engine import ChromaKeyConfig, ChromaKeyEngine
+
+            ck_config = ChromaKeyConfig.from_dict(clip.config.get("chroma_key"))
+            if ck_config.has_effect():
+                ck_engine = ChromaKeyEngine(ck_config)
+                ck_full = ck_engine.build_filter("[in]", "[out]")
+                ck_filter_part = ck_full[len("[in]") : -len("[out]")]
+                filters.append(ck_filter_part)
+        except Exception as e:
+            logger.warning("[unified-render] chroma key 直通模式应用失败，跳过: %s", e)
 
         filters.append("setpts=PTS-STARTPTS")
         filters.append(f"fps={self.output_fps}")
@@ -884,8 +1052,33 @@ class UnifiedRenderService:
         # background 以外的视频素材，默认带音频
         has_audio = role != "background"
         if has_audio:
+            # 检查是否需要音频降噪
+            af_parts: list[str] = []
+            try:
+                from video_processing.noise_reduction_engine import NoiseReductionConfig, NoiseReductionEngine
+
+                plan_config = getattr(self.plan, "config", {}) or {}
+                nr_config = NoiseReductionConfig.from_dict(plan_config.get("audio_noise_reduction"))
+                if nr_config.has_effect():
+                    nr_engine = NoiseReductionEngine(nr_config)
+                    nr_full = nr_engine.build_filter("[in]", "[out]")
+                    nr_filter_part = nr_full[len("[in]") : -len("[out]")]
+                    af_parts.append(nr_filter_part)
+            except Exception as e:
+                logger.warning("[unified-render] 直通模式音频降噪应用失败，跳过: %s", e)
+
+            if af_parts:
+                command.extend(["-af", ",".join(af_parts)])
+
             command.extend(["-c:a", "aac", "-b:a", "128k"])
 
+            # 音频倒放
+            reverse_config = ReverseConfig.from_dict(clip.config.get("reverse"))
+            if reverse_config.enabled and reverse_config.reverse_audio:
+                af_filter = ReverseEngine.build_audio_filter(reverse_config, duration=effective_duration)
+                if af_filter:
+                    command.extend(["-af", af_filter])
+
         # 统一截断时长（同时作用于视频和音频）
         if final_duration > 0:
             command.extend(["-t", f"{final_duration:.3f}"])
@@ -920,6 +1113,7 @@ class UnifiedRenderService:
         """将 EditPlanClip 列表解析为 ResolvedClip 列表。
 
         跳过 asset_id 为空或在 asset_path_map 中找不到的片段。
+        支持多段裁剪：一个 clip 配置了 trim_segments 时会展开为多个 ResolvedClip。
         """
         resolved: list[ResolvedClip] = []
         for clip in self.clips:
@@ -939,17 +1133,77 @@ class UnifiedRenderService:
             except Exception:
                 actual_duration = clip.duration or 5.0
 
+            # 检查是否有多段裁剪配置
+            clip_config = clip.config or {}
+            trim_segments = TrimEngine.parse_segments_from_config(clip_config)
+
+            if trim_segments and len(trim_segments) > 1:
+                # 多段裁剪：展开为多个 clip
+                resolved_segments = TrimEngine.resolve_segments(trim_segments, actual_duration)
+                for i, seg in enumerate(resolved_segments):
+                    # 每个段生成一个独立的 ResolvedClip
+                    seg_clip_id = f"{clip.id}_seg_{seg.segment_id}"
+                    seg_order = clip.order + seg.order * 0.001 + i * 0.0001  # 保持排序
+                    seg_start = seg.trim.start_time
+                    seg_duration = seg.trim.duration
+
+                    rc = ResolvedClip(
+                        clip_id=seg_clip_id,
+                        asset_id=asset_id,
+                        local_path=local_path,
+                        clip_type=clip.clip_type,
+                        order=seg_order,
+                        start_time=seg_start,
+                        duration=seg_duration,
+                        transition_effect=clip.transition_effect or "cut",
+                        config={**clip_config, "_segment_id": seg.segment_id},
+                        actual_duration=actual_duration,
+                        trim_config=seg.trim,
+                    )
+                    resolved.append(rc)
+                continue
+
+            # 单段裁剪（或无裁剪）
+            # 解析裁剪配置：config 优先，否则用 clip.start_time + clip.duration
+            trim_config = extract_trim_from_clip_config(clip_config)
+            if trim_config is None and (clip.start_time > 0 or clip.duration > 0):
+                # 用旧字段构造
+                trim_config = TrimConfig(
+                    start_time=clip.start_time,
+                    duration=clip.duration,
+                )
+
+            # 钳制到实际素材时长
+            effective_trim: TrimConfig | None = None
+            final_start = clip.start_time
+            final_duration = clip.duration
+
+            if trim_config is not None and actual_duration > 0:
+                effective_trim = trim_config.validate_and_resolve(actual_duration)
+                if effective_trim.is_valid:
+                    final_start = effective_trim.start_time
+                    final_duration = effective_trim.duration
+                else:
+                    # 裁剪无效 → 使用完整素材
+                    logger.warning("裁剪配置无效，使用完整素材: clip_id=%s", clip.id)
+                    effective_trim = None
+                    final_start = 0.0
+                    final_duration = actual_duration
+
             rc = ResolvedClip(
                 clip_id=clip.id,
                 asset_id=asset_id,
                 local_path=local_path,
                 clip_type=clip.clip_type,
                 order=clip.order,
-                start_time=clip.start_time,
-                duration=clip.duration,
+                start_time=final_start,
+                duration=final_duration,
                 transition_effect=clip.transition_effect or "cut",
-                config=clip.config or {},
+                transition_duration=getattr(clip, "transition_duration", 0.0) or 0.0,
+                playback_speed=getattr(clip, "playback_speed", 1.0) or 1.0,
+                config=clip_config,
                 actual_duration=actual_duration,
+                trim_config=effective_trim,
             )
             resolved.append(rc)
 
@@ -1024,7 +1278,7 @@ class UnifiedRenderService:
 
         filter_parts: list[str] = []
 
-        # Step 1: 预处理每个 clip — scale + setpts
+        # Step 1: 预处理每个 clip — trim + scale + setpts
         # 为每个 clip 生成预处理后的标签 [v0], [v1], ...
         preprocessed_labels: list[str] = []
         for i, clip in enumerate(all_clips):
@@ -1033,13 +1287,29 @@ class UnifiedRenderService:
 
             filters: list[str] = []
 
-            # trim — 始终将输出截断到有效时长，防止 xfade offset 与实际时长不匹配
+            # trim — 裁剪到指定区间，精确到帧
             effective_duration = UnifiedRenderService._clip_effective_duration(clip)
+            trim_start = getattr(clip, "start_time", 0) or 0
 
             if effective_duration > 0:
-                filters.append(f"trim=duration={effective_duration}")
+                if trim_start > 0:
+                    filters.append(f"trim=start={trim_start:.3f}:duration={effective_duration:.3f}")
+                else:
+                    filters.append(f"trim=duration={effective_duration:.3f}")
                 filters.append("setpts=PTS-STARTPTS")
 
+            # 调速 — 基于 setpts 改变播放速度
+            speed = UnifiedRenderService._clip_speed(clip)
+            if abs(speed - 1.0) >= 1e-6:
+                filters.append(f"setpts=PTS/{speed:.4f}")
+
+            # 倒放滤镜（在 trim 之后、scale 之前应用）
+            reverse_config = ReverseConfig.from_dict(clip.config.get("reverse"))
+            if reverse_config.enabled and reverse_config.reverse_video:
+                reverse_filter = ReverseEngine.build_video_filter(reverse_config, duration=effective_duration)
+                if reverse_filter:
+                    filters.append(reverse_filter)
+
             # scale
             if role in ("overlay", "corner_voice"):
                 pip_w = int(self.output_width * _PIP_SCALE)
@@ -1064,6 +1334,19 @@ class UnifiedRenderService:
                 grade_filter = ColorGradeEngine.build_filter(color_grade)
                 if grade_filter:
                     filters.append(grade_filter)
+            # chroma key 绿幕抠像（在 scale 之后，fps 之前）
+            try:
+                from video_processing.chroma_key_engine import ChromaKeyConfig, ChromaKeyEngine
+
+                ck_config = ChromaKeyConfig.from_dict(clip.config.get("chroma_key"))
+                if ck_config.has_effect():
+                    ck_engine = ChromaKeyEngine(ck_config)
+                    # 提取滤镜部分（不带输入输出标签）
+                    ck_full = ck_engine.build_filter("[in]", "[out]")
+                    ck_filter_part = ck_full[len("[in]") : -len("[out]")]
+                    filters.append(ck_filter_part)
+            except Exception as e:
+                logger.warning("[unified-render] chroma key 应用失败，跳过 clip=%s: %s", clip.clip_id, e)
 
             filters.append("setpts=PTS-STARTPTS")
             filters.append(f"fps={self.output_fps}")
@@ -1077,21 +1360,28 @@ class UnifiedRenderService:
         for layer in layers:
             layer_clip_indices = [all_clips.index(c) for c in layer.clips]
             layer_labels = [preprocessed_labels[i] for i in layer_clip_indices]
-            # 使用 trim 后的有效时长，与 Step 1 的 trim=duration 保持一致
-            layer_durations = [UnifiedRenderService._clip_effective_duration(all_clips[i]) for i in layer_clip_indices]
+            # 使用调速后的实际时长，与 Step 1 的调速处理保持一致
+            layer_durations = [UnifiedRenderService._clip_adjusted_duration(all_clips[i]) for i in layer_clip_indices]
             layer_transitions = [all_clips[i].transition_effect for i in layer_clip_indices]
+            layer_transition_durations = [all_clips[i].transition_duration for i in layer_clip_indices]
 
             if len(layer_labels) == 1:
                 # 单 clip 层，直接使用预处理标签
                 layer_output_labels[layer.role] = layer_labels[0]
             else:
-                # 多 clip 层，用 xfade 串联
+                # 多 clip 层，用 TransitionEngine 构建转场链
                 out_label = f"{layer.role}_merged"
-                xfade_filter, _ = build_xfade_filter_chain(
+                # 计算该层使用的转场时长（取首个非零值，否则用默认）
+                layer_dur = 0.0
+                for d in layer_transition_durations:
+                    if d > 0:
+                        layer_dur = d
+                        break
+                xfade_filter, _ = self._transition_engine.build_xfade_chain(
                     clip_durations=layer_durations,
                     clip_video_labels=layer_labels,
                     transitions=layer_transitions,
-                    transition_duration=self.transition_duration,
+                    transition_duration=layer_dur if layer_dur > 0 else None,
                     output_label=out_label,
                 )
                 if xfade_filter:
@@ -1138,6 +1428,74 @@ class UnifiedRenderService:
                 filter_parts.append(f"[{final_video_label}][{overlay_label}]" f"overlay={x}:{y}[{combined_label}]")
                 final_video_label = combined_label
 
+        # 叠加水印（在字幕之前）
+        watermark_config = WatermarkConfig.from_dict((self.plan.config or {}).get("watermark"))
+        if watermark_config is not None:
+            wm_valid, wm_err = watermark_config.validate()
+            if wm_valid:
+                wm_label = "watermarked"
+                if watermark_config.mode == "image":
+                    # 图片水印：检查图片是否存在
+                    wm_path = Path(watermark_config.image_path)
+                    if wm_path.exists():
+                        # 图片水印需要额外输入，放在 filter 开头
+                        wm_idx = len(all_clips)  # 水印图是最后一个输入
+                        wm_scale = int(self.output_width * watermark_config.scale)
+
+                        # 透明度
+                        wm_filters = f"scale={wm_scale}:-1"
+                        if watermark_config.opacity < 1.0:
+                            wm_filters += f",format=rgba,colorchannelmixer=aa={watermark_config.opacity}"
+
+                        filter_parts.insert(0, f"[{wm_idx}:v]{wm_filters}[wm_scaled]")
+                        input_args.extend(["-i", str(wm_path)])
+
+                        # 位置计算（水印高度用 scale 后的宽度近似）
+                        wm_h = wm_scale  # 近似（正方形假设）
+                        x, y = WatermarkEngine.calc_position(
+                            watermark_config.position,
+                            self.output_width,
+                            self.output_height,
+                            wm_scale,
+                            wm_h,
+                            watermark_config.margin_x,
+                            watermark_config.margin_y,
+                        )
+
+                        # 滚动水印
+                        if watermark_config.scroll:
+                            x_expr = f"W-mod({watermark_config.scroll_speed}*t\\,W+w)"
+                            overlay = f"[{final_video_label}][wm_scaled]overlay=x={x_expr}:y={y}[{wm_label}]"
+                        else:
+                            overlay = f"[{final_video_label}][wm_scaled]overlay=x={x}:y={y}[{wm_label}]"
+
+                        filter_parts.append(overlay)
+                        final_video_label = wm_label
+                    else:
+                        logger.warning("水印图片不存在，跳过水印: %s", wm_path)
+                elif watermark_config.mode == "text":
+                    # 文字水印
+                    try:
+                        text_wm = WatermarkEngine.build_text_watermark_filter(
+                            f"[{final_video_label}]",
+                            f"[{wm_label}]",
+                            watermark_config,
+                            self.output_width,
+                            self.output_height,
+                        )
+                        filter_parts.append(text_wm)
+                        final_video_label = wm_label
+                    except Exception as e:
+                        logger.warning("文字水印构建失败，跳过: %s", e)
+        # 贴纸叠加（图片贴纸 + 文字贴纸）
+        sticker_filter, sticker_extra_inputs = self._build_sticker_filters(final_video_label, "after_stickers")
+        if sticker_filter:
+            filter_parts.append(sticker_filter)
+            # 图片贴纸需要额外输入
+            for img_path in sticker_extra_inputs:
+                input_args.extend(["-i", img_path])
+            final_video_label = "after_stickers"
+
         # 叠加字幕（如有）+ 最终像素格式
         if ass_path is not None:
             ass_filter_path = str(ass_path).replace("\\", "/").replace(":", "\\:")
@@ -1197,6 +1555,40 @@ class UnifiedRenderService:
             )
             raise
 
+    def _build_sticker_filters(self, input_label: str, output_label: str) -> tuple[str, list[str]]:
+        """构建贴纸叠加滤镜链.
+
+        Args:
+            input_label: 输入视频标签
+            output_label: 输出视频标签
+
+        Returns:
+            (filter_str, extra_input_paths)
+            filter_str: 贴纸滤镜字符串（空表示无贴纸）
+            extra_input_paths: 额外需要的输入文件路径（图片贴纸）
+        """
+        plan_config = getattr(self.plan, "config", None) or {}
+        if isinstance(plan_config, dict):
+            stickers_data = plan_config.get("stickers", [])
+        else:
+            stickers_data = []
+
+        if not stickers_data:
+            return "", []
+
+        try:
+            result = StickerEngine.build_sticker_chain(
+                stickers=stickers_data,
+                input_label=f"[{input_label}]",
+                output_label=f"[{output_label}]",
+                canvas_w=self.output_width,
+                canvas_h=self.output_height,
+            )
+            return result.filter_str, result.extra_inputs
+        except Exception as e:
+            logger.warning("贴纸滤镜构建失败，跳过贴纸: %s", e)
+            return "", []
+
     def _probe_output(self, output_path: Path) -> tuple[float, int, int, int]:
         """探测输出文件的时长、大小、宽高.
 
@@ -1214,7 +1606,7 @@ class UnifiedRenderService:
 
     @staticmethod
     def _clip_effective_duration(clip: ResolvedClip) -> float:
-        """计算 clip 的有效时长."""
+        """计算 clip 的有效时长（原速 trim 后时长）."""
         if clip.duration > 0:
             return min(clip.duration, clip.actual_duration) if clip.actual_duration > 0 else clip.duration
         return clip.actual_duration if clip.actual_duration > 0 else 0.0
@@ -1311,3 +1703,20 @@ class UnifiedRenderService:
         )
 
         return new_filter, new_input_args
+
+    @staticmethod
+    def _clip_speed(clip: ResolvedClip) -> float:
+        """获取 clip 的播放速度，无效值回退到 1.0."""
+        speed = getattr(clip, "playback_speed", 1.0)
+        if not isinstance(speed, (int, float)) or speed <= 0:
+            return 1.0
+        return float(speed)
+
+    @staticmethod
+    def _clip_adjusted_duration(clip: ResolvedClip) -> float:
+        """计算调速后的 clip 实际时长（用于拼接计算）."""
+        base = UnifiedRenderService._clip_effective_duration(clip)
+        speed = UnifiedRenderService._clip_speed(clip)
+        if abs(speed - 1.0) < 1e-6:
+            return base
+        return base / speed

apps/worker/video_processing/watermark_engine.py

@@ -0,0 +1,315 @@
+"""水印引擎 — 基于 FFmpeg overlay 滤镜的水印叠加.
+
+支持：
+- 图片水印（PNG/logo）
+- 文字水印（drawtext）
+- 9宫格位置 + 边距配置
+- 透明度/大小缩放
+- 滚动水印（跑马灯）
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+# 9宫格位置枚举
+WATERMARK_POSITIONS = {
+    "top_left": "左上",
+    "top_center": "中上",
+    "top_right": "右上",
+    "center_left": "左中",
+    "center": "中心",
+    "center_right": "右中",
+    "bottom_left": "左下",
+    "bottom_center": "中下",
+    "bottom_right": "右下",
+}
+
+
+@dataclass
+class WatermarkConfig:
+    """水印配置.
+
+    mode: "image" 图片水印 | "text" 文字水印
+    position: 9宫格位置
+    opacity: 透明度 0.0-1.0
+    scale: 缩放比例（图片水印），0.1-1.0
+    margin: 边距（像素）
+    scroll: 是否滚动（跑马灯）
+    scroll_speed: 滚动速度（像素/秒）
+    """
+
+    mode: str = "text"  # image | text
+    position: str = "bottom_right"
+
+    # 图片水印
+    image_path: str = ""  # 本地图片路径
+    scale: float = 0.2  # 相对输出宽度的比例
+    opacity: float = 0.8  # 0.0-1.0
+
+    # 文字水印
+    text: str = ""
+    font_size: int = 24
+    font_color: str = "white"
+    font_path: str = ""  # 字体文件路径
+
+    # 边距
+    margin_x: int = 20
+    margin_y: int = 20
+
+    # 滚动水印
+    scroll: bool = False
+    scroll_speed: int = 50  # 像素/秒
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any] | None) -> WatermarkConfig | None:
+        """从字典构造，空配置返回 None（不加水印）."""
+        if not data:
+            return None
+
+        enabled = data.get("enabled", False)
+        if not enabled:
+            return None
+
+        mode = data.get("mode", "text")
+
+        # 图片模式需要 image_path；文字模式需要 text
+        if mode == "image":
+            image_path = data.get("image_path", "") or data.get("image", "") or ""
+            if not image_path:
+                logger.warning("图片水印缺少 image_path，跳过水印")
+                return None
+        elif mode == "text":
+            text = data.get("text", "") or ""
+            if not text:
+                logger.warning("文字水印缺少 text，跳过水印")
+                return None
+
+        position = data.get("position", "bottom_right")
+        if position not in WATERMARK_POSITIONS:
+            position = "bottom_right"
+
+        return cls(
+            mode=mode,
+            position=position,
+            image_path=str(data.get("image_path", data.get("image", "")) or ""),
+            scale=float(data.get("scale", 0.2)),
+            opacity=float(data.get("opacity", 0.8)),
+            text=str(data.get("text", "") or ""),
+            font_size=int(data.get("font_size", 24)),
+            font_color=str(data.get("font_color", "white")),
+            font_path=str(data.get("font_path", "") or ""),
+            margin_x=int(data.get("margin_x", 20)),
+            margin_y=int(data.get("margin_y", 20)),
+            scroll=bool(data.get("scroll", False)),
+            scroll_speed=int(data.get("scroll_speed", 50)),
+        )
+
+    def validate(self) -> tuple[bool, str]:
+        """校验配置是否有效."""
+        if self.position not in WATERMARK_POSITIONS:
+            return False, f"不支持的位置: {self.position}"
+
+        if not (0.0 <= self.opacity <= 1.0):
+            return False, "透明度必须在 0-1 之间"
+
+        if self.mode == "image":
+            if not self.image_path:
+                return False, "图片水印缺少图片路径"
+            if not (0.01 <= self.scale <= 1.0):
+                return False, "缩放比例必须在 0.01-1.0 之间"
+        elif self.mode == "text":
+            if not self.text:
+                return False, "文字水印缺少文字内容"
+            if self.font_size <= 0:
+                return False, "字体大小必须大于 0"
+        else:
+            return False, f"不支持的水印模式: {self.mode}"
+
+        return True, ""
+
+
+class WatermarkEngine:
+    """水印引擎 — 生成 FFmpeg 水印滤镜."""
+
+    @staticmethod
+    def calc_position(
+        position: str,
+        output_width: int,
+        output_height: int,
+        wm_width: int,
+        wm_height: int,
+        margin_x: int,
+        margin_y: int,
+    ) -> tuple[int, int]:
+        """根据9宫格位置计算水印坐标 (x, y).
+
+        坐标系：左上角为 (0, 0)
+        """
+        if position == "top_left":
+            return margin_x, margin_y
+        elif position == "top_center":
+            return (output_width - wm_width) // 2, margin_y
+        elif position == "top_right":
+            return output_width - wm_width - margin_x, margin_y
+        elif position == "center_left":
+            return margin_x, (output_height - wm_height) // 2
+        elif position == "center":
+            return (output_width - wm_width) // 2, (output_height - wm_height) // 2
+        elif position == "center_right":
+            return output_width - wm_width - margin_x, (output_height - wm_height) // 2
+        elif position == "bottom_left":
+            return margin_x, output_height - wm_height - margin_y
+        elif position == "bottom_center":
+            return (output_width - wm_width) // 2, output_height - wm_height - margin_y
+        elif position == "bottom_right":
+            return output_width - wm_width - margin_x, output_height - wm_height - margin_y
+        else:
+            # 默认右下角
+            return output_width - wm_width - margin_x, output_height - wm_height - margin_y
+
+    @staticmethod
+    def calc_scroll_x(position: str, output_width: int, wm_width: int, speed: int) -> str:
+        """生成滚动水印的 x 坐标表达式.
+
+        从右向左滚动（跑马灯效果）
+        """
+        # x 从 W 到 -wm_width，整个宽度 + wm_width 的距离
+        # 使用 overlay 的 enable 表达式
+        # x = 'W - (t * speed)' → 不对，应该是持续滚动
+        # 标准跑马灯：x = -w + (t * speed) % (W + w)
+        # 但 FFmpeg overlay 支持表达式
+        return f"mod({output_width}-mod({speed}*t\\,{output_width}+{wm_width})"
+
+    @staticmethod
+    def build_image_watermark_filter(
+        input_video_label: str,
+        wm_image_path: str,
+        output_width: int,
+        output_height: int,
+        output_label: str,
+        config: WatermarkConfig,
+    ) -> tuple[str, list[str]]:
+        """构建图片水印滤镜链.
+
+        Args:
+            input_video_label: 输入视频标签，如 "[final_video]"
+            wm_image_path: 水印图片本地路径
+            output_width: 输出视频宽度
+            output_height: 输出视频高度
+            output_label: 输出标签
+            config: 水印配置
+
+        Returns:
+            (filter_complex_str, input_args_list)
+            input_args 是 ["-i", wm_image_path] 格式
+        """
+        # 计算水印尺寸（按输出宽度比例缩放）
+        wm_width = int(output_width * config.scale)
+        wm_height = -1  # 保持比例
+        wm_filter = f"scale={wm_width}:{wm_height}"
+
+        # 透明度处理
+        if config.opacity < 1.0:
+            wm_filter += f",format=rgba,colorchannelmixer=aa={config.opacity}"
+
+        # 水印预处理标签
+        wm_pre_label = "[wm_scaled]"
+
+        # 计算位置
+        x, y = WatermarkEngine.calc_position(
+            config.position,
+            output_width,
+            output_height,
+            wm_width,
+            wm_width,  # 高度未知，先用宽度估算
+            config.margin_x,
+            config.margin_y,
+        )
+
+        # 滚动水印
+        if config.scroll:
+            # 从右向左滚动：x = W - (t * speed) mod (W + wm_w)
+            # 使用 overlay 表达式
+            x_expr = f"{output_width}-mod({config.scroll_speed}*t\\,{output_width}+{wm_width}"
+            y_expr = str(y)
+            overlay_expr = f"x={x_expr}:y={y_expr}"
+        else:
+            overlay_expr = f"x={x}:y={y}"
+
+        # 构建滤镜
+        # 先缩放水印图
+        wm_input_idx = 1  # 假设水印图是第二个输入（索引1
+        filter_parts = [
+            f"[1:v]{wm_filter}{wm_pre_label}",
+            f"{input_video_label}{wm_pre_label}overlay={overlay_expr}{output_label}",
+        ]
+
+        filter_complex = ";".join(filter_parts)
+        input_args = ["-i", wm_image_path]
+
+        return filter_complex, input_args
+
+    @staticmethod
+    def build_text_watermark_filter(
+        input_video_label: str,
+        output_label: str,
+        config: WatermarkConfig,
+        output_width: int,
+        output_height: int,
+    ) -> str:
+        """构建文字水印滤镜（drawtext）.
+
+        Args:
+            input_video_label: 输入视频标签
+            output_label: 输出标签
+            config: 水印配置
+            output_width: 输出宽度
+            output_height: 输出高度
+
+        Returns:
+            FFmpeg filter 字符串
+        """
+        # 转义文字中的特殊字符
+        text = config.text.replace(":", "\\:").replace("'", "\\'")
+
+        # 字体配置
+        font_config = []
+        if config.font_path:
+            font_path_escaped = config.font_path.replace(":", "\\:").replace("'", "\\'")
+            font_config.append(f"fontfile='{font_path_escaped}'")
+        font_config.append(f"fontsize={config.font_size}")
+        font_config.append(f"fontcolor={config.font_color}@{config.opacity}")
+
+        # 估算文字宽高（粗略估算，用于位置计算）
+        # 每个汉字约等于 font_size 宽高
+        approx_w = len(config.text) * config.font_size
+        approx_h = config.font_size
+
+        # 位置计算
+        x, y = WatermarkEngine.calc_position(
+            config.position,
+            output_width,
+            output_height,
+            approx_w,
+            approx_h,
+            config.margin_x,
+            config.margin_y,
+        )
+
+        # 滚动水印
+        if config.scroll:
+            x_expr = f"w-mod({config.scroll_speed}*t\\,W+w)"
+            pos_config = [f"x={x_expr}", f"y={y}"]
+        else:
+            pos_config = [f"x={x}", f"y={y}"]
+
+        # 组装 drawtext
+        drawtext_parts = [f"text='{text}'"] + font_config + pos_config
+        drawtext = "drawtext=" + ":".join(drawtext_parts)
+
+        return f"{input_video_label}{drawtext}{output_label}"

apps/worker/worker_app/tasks/generation.py

@@ -335,6 +335,86 @@ def _download_voice_asset(voice_library_id: str, local_path: Path) -> bool:
     return download_asset(storage_key, local_path)
 
 
+def _prepare_bgm_track(
+    *,
+    bgm_config: dict,
+    temp_path: Path,
+    task_id: str = "",
+) -> str | None:
+    """准备 BGM 音频文件（下载到本地）.
+
+    支持 3 种来源（按优先级）：
+    1. audio_url — 外部直链 URL（最高优先级）
+    2. asset_id — 素材库中的音频素材
+    3. preset_id — 预设 BGM 库
+
+    Returns:
+        BGM 本地文件路径，准备失败返回 None
+    """
+    from urllib.parse import urlparse
+
+    audio_url = bgm_config.get("audio_url", "") or ""
+    asset_id = bgm_config.get("asset_id", "") or ""
+    preset_id = bgm_config.get("preset_id", "") or ""
+
+    bgm_file = temp_path / f"bgm_{task_id or 'track'}.mp3"
+
+    # 优先级1：外部直链 URL
+    if audio_url:
+        try:
+            parsed = urlparse(audio_url)
+            if parsed.scheme in ("http", "https"):
+                import urllib.request
+
+                logger.info("[task_id=%s] [BGM] 从URL下载: %s", task_id, audio_url[:80])
+                urllib.request.urlretrieve(audio_url, bgm_file)  # nosec B310
+                if bgm_file.exists() and bgm_file.stat().st_size > 0:
+                    return str(bgm_file)
+        except Exception as e:
+            logger.warning("[task_id=%s] [BGM] URL下载失败: %s", task_id, e)
+
+    # 优先级2：素材库素材
+    if asset_id:
+        try:
+            from app.core.db import SessionLocal
+
+            from packages.adapters.sqlalchemy_impl.models import AssetModel
+
+            session = SessionLocal()
+            try:
+                model = session.query(AssetModel).filter(AssetModel.id == asset_id).first()
+                if model and model.file_url:
+                    storage_key = model.file_url
+                    logger.info("[task_id=%s] [BGM] 从素材库下载: asset_id=%s", task_id, asset_id)
+                    ok = download_asset(storage_key, bgm_file)
+                    if ok and bgm_file.exists() and bgm_file.stat().st_size > 0:
+                        return str(bgm_file)
+            finally:
+                session.close()
+        except Exception as e:
+            logger.warning("[task_id=%s] [BGM] 素材库下载失败: %s", task_id, e)
+
+    # 优先级3：预设 BGM 库
+    if preset_id:
+        try:
+            from packages.domain.preset_bgm import get_preset_bgm
+
+            preset = get_preset_bgm(preset_id)
+            if preset and preset.audio_url:
+                import urllib.request
+
+                logger.info("[task_id=%s] [BGM] 从预设库下载: preset_id=%s", task_id, preset_id)
+                urllib.request.urlretrieve(preset.audio_url, bgm_file)  # nosec B310
+                if bgm_file.exists() and bgm_file.stat().st_size > 0:
+                    return str(bgm_file)
+        except Exception as e:
+            logger.warning("[task_id=%s] [BGM] 预设库下载失败: %s", task_id, e)
+
+    # 所有来源都失败
+    logger.warning("[task_id=%s] [BGM] 所有来源都无法获取BGM，跳过", task_id)
+    return None
+
+
 def _verify_url_accessible(url: str, timeout: float = 10.0, retries: int = 2) -> bool:
     """HEAD 请求校验 URL 可访问（含重试，防止 OSS 抖动误报）。
 
@@ -884,6 +964,22 @@ def _render_video(
         )
     else:
         logger.info("[task_id=%s] [渲染] unified 引擎 FFmpeg 渲染开始", task_id)
+
+        # ── 准备 BGM 音频 ──
+        bgm_path: str | None = None
+        plan_config = virtual_plan.config or {}
+        bgm_config = plan_config.get("bgm", {}) or {}
+        if bgm_config.get("enabled", False):
+            try:
+                bgm_path = _prepare_bgm_track(
+                    bgm_config=bgm_config,
+                    temp_path=temp_path,
+                    task_id=task_id,
+                )
+            except Exception as bgm_err:
+                logger.warning("[task_id=%s] [BGM] 准备失败，跳过BGM: %s", task_id, bgm_err)
+                bgm_path = None
+
         render_service = UnifiedRenderService(
             plan=virtual_plan,
             clips=virtual_clips,
@@ -893,6 +989,7 @@ def _render_video(
             output_height=OUTPUT_HEIGHT,
             output_fps=int(OUTPUT_FPS),
             asr_service=get_asr_service(),
+            bgm_path=bgm_path,
         )
         render_result = render_service.render()
         render_output_path = render_result.output_path

docs/schema-metadata-snapshot.json

@@ -858,6 +858,22 @@
           "type": "VARCHAR(20)",
           "unique": false
         },
+        {
+          "index": false,
+          "name": "transition_duration",
+          "nullable": false,
+          "primary_key": false,
+          "type": "FLOAT",
+          "unique": false
+        },
+        {
+          "index": false,
+          "name": "playback_speed",
+          "nullable": false,
+          "primary_key": false,
+          "type": "FLOAT",
+          "unique": false
+        },
         {
           "index": true,
           "name": "status",

packages/adapters/sqlalchemy_impl/edit_plan_clip_repository.py

@@ -54,6 +54,8 @@ class SQLAlchemyEditPlanClipRepository:
             start_time=clip.start_time,
             duration=clip.duration,
             transition_effect=clip.transition_effect,
+            transition_duration=clip.transition_duration,
+            playback_speed=clip.playback_speed,
             status=clip.status,
             config=clip.config,
         )
@@ -76,6 +78,8 @@ class SQLAlchemyEditPlanClipRepository:
         model.start_time = clip.start_time
         model.duration = clip.duration
         model.transition_effect = clip.transition_effect
+        model.transition_duration = clip.transition_duration
+        model.playback_speed = clip.playback_speed
         model.status = clip.status
         model.config = clip.config
         model.updated_at = clip.updated_at
@@ -120,6 +124,8 @@ class SQLAlchemyEditPlanClipRepository:
             start_time=model.start_time or 0.0,
             duration=model.duration or 0.0,
             transition_effect=model.transition_effect or "cut",
+            transition_duration=getattr(model, "transition_duration", 0.0) or 0.0,
+            playback_speed=model.playback_speed or 1.0,
             status=EditPlanClipStatus(model.status) if model.status else EditPlanClipStatus.PENDING,
             config=model.config or {},
             created_at=model.created_at,

packages/adapters/sqlalchemy_impl/models.py

@@ -196,6 +196,8 @@ class EditPlanClipModel(Base):
     start_time = Column(Float, nullable=False, default=0.0)
     duration = Column(Float, nullable=False, default=0.0)
     transition_effect = Column(String(20), nullable=False, default="cut")
+    transition_duration = Column(Float, nullable=False, default=0.0)
+    playback_speed = Column(Float, nullable=False, default=1.0)
     status = Column(String(20), nullable=False, default="pending", index=True)
     config = Column(JSON, nullable=False, default=dict)
     created_at = Column(DateTime, nullable=False, default=lambda: datetime.now(timezone.utc))

packages/domain/config_schemas.py

@@ -122,9 +122,22 @@ class SubtitleConfig(BaseModel):
 class BGMConfig(BaseModel):
     """BGM 配置"""
 
+    enabled: bool = Field(default=False, description="是否启用 BGM")
     source: BGMSource = Field(default=BGMSource.LIBRARY, description="BGM 来源")
-    asset_id: str = Field(default="", description="BGM 素材 ID")
-    volume: float = Field(default=0.3, ge=0.0, le=1.0, description="音量 (0.0 ~ 1.0)")
+    asset_id: str = Field(default="", description="BGM 素材 ID（来源为 library/upload 时使用）")
+    preset_id: str = Field(default="", description="预设 BGM ID（来源为 ai_recommend 或使用内置库时使用）")
+    audio_url: str = Field(default="", description="BGM 音频 URL（外部直链，优先级最高）")
+    volume: float = Field(default=0.3, ge=0.0, le=1.0, description="BGM 音量 (0.0 ~ 1.0)")
+    fade_in: float = Field(default=0.0, ge=0.0, le=30.0, description="淡入时长（秒）")
+    fade_out: float = Field(default=0.0, ge=0.0, le=30.0, description="淡出时长（秒）")
+    loop_enabled: bool = Field(default=True, description="BGM 是否循环播放以铺满整个视频时长")
+    sidechain_enabled: bool = Field(default=False, description="是否启用人声闪避（有人声时 BGM 自动降低音量）")
+    sidechain_ratio: float = Field(
+        default=0.3, ge=0.0, le=1.0, description="人声闪避时 BGM 音量降低比例（0.3 = 降低30%）"
+    )
+    sidechain_attack: float = Field(default=0.02, ge=0.001, le=1.0, description="人声闪避攻击时间（秒）")
+    sidechain_release: float = Field(default=0.5, ge=0.01, le=5.0, description="人声闪避释放时间（秒）")
+    sidechain_threshold: float = Field(default=-25.0, ge=-60.0, le=0.0, description="人声闪避触发阈值（dB）")
 
 
 # ── 完整 config 模型 ─────────────────────────────────────────────────────────
@@ -190,9 +203,20 @@ DEFAULT_EDIT_PLAN_CONFIG: dict = {
         "animation": "fade_in",
     },
     "bgm": {
+        "enabled": False,
         "source": "library",
         "asset_id": "",
+        "preset_id": "",
+        "audio_url": "",
         "volume": 0.3,
+        "fade_in": 0.0,
+        "fade_out": 0.0,
+        "loop_enabled": True,
+        "sidechain_enabled": False,
+        "sidechain_ratio": 0.3,
+        "sidechain_attack": 0.02,
+        "sidechain_release": 0.5,
+        "sidechain_threshold": -25.0,
     },
     "editing_mode": "one_take",
 }

packages/domain/edit_plan_clip.py

@@ -50,6 +50,8 @@ class EditPlanClip:
     start_time: float = 0.0
     duration: float = 0.0
     transition_effect: str = "cut"
+    transition_duration: float = 0.0  # 0 表示使用全局默认值
+    playback_speed: float = 1.0  # 0 或 1.0 表示原速，范围 0.25~4.0
     status: EditPlanClipStatus = EditPlanClipStatus.PENDING
     config: dict[str, Any] = field(default_factory=dict)
     created_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
@@ -68,6 +70,8 @@ class EditPlanClip:
         start_time: float = 0.0,
         duration: float = 0.0,
         transition_effect: str = "cut",
+        transition_duration: float = 0.0,
+        playback_speed: float = 1.0,
         config: dict[str, Any] | None = None,
     ) -> EditPlanClip:
         """创建剪辑计划片段"""
@@ -79,6 +83,13 @@ class EditPlanClip:
             raise ValueError("start_time 不能为负数")
         if duration < 0:
             raise ValueError("duration 不能为负数")
+        # 速度边界钳制
+        if playback_speed <= 0:
+            playback_speed = 1.0
+        elif playback_speed < 0.25:
+            playback_speed = 0.25
+        elif playback_speed > 4.0:
+            playback_speed = 4.0
 
         return cls(
             id=uuid4().hex,
@@ -91,6 +102,8 @@ class EditPlanClip:
             start_time=start_time,
             duration=duration,
             transition_effect=transition_effect.strip() or "cut",
+            transition_duration=max(0.0, transition_duration),
+            playback_speed=playback_speed,
             status=EditPlanClipStatus.PENDING,
             config=config or {},
         )

packages/domain/preset_bgm.py

@@ -0,0 +1,160 @@
+"""预设 BGM 库 — 免费可商用背景音乐清单.
+
+按风格分类，存储在 OSS 或 CDN 上。
+实际音频文件由运维统一上传，这里只维护元数据清单。
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass(frozen=True)
+class PresetBGM:
+    """预设 BGM 条目"""
+
+    id: str
+    name: str
+    style: str  # 风格分类：upbeat/relax/tech/commerce/emotional/cinematic
+    duration: float  # 时长（秒）
+    artist: str = ""
+    description: str = ""
+    tags: list[str] = field(default_factory=list)
+    audio_url: str = ""  # CDN/OSS 地址，空字符串表示待部署
+
+
+# ── 预设库清单 ────────────────────────────────────────────────────────────────
+
+PRESET_BGM_LIBRARY: list[PresetBGM] = [
+    # 轻快 upbeat
+    PresetBGM(
+        id="bgm_upbeat_001",
+        name="阳光清晨",
+        style="upbeat",
+        duration=120.0,
+        artist="免费商用音乐库",
+        description="轻快明亮的吉他+钢琴，适合vlog、生活记录",
+        tags=["轻快", "阳光", "吉他", "vlog"],
+    ),
+    PresetBGM(
+        id="bgm_upbeat_002",
+        name="活力节拍",
+        style="upbeat",
+        duration=95.0,
+        artist="免费商用音乐库",
+        description="电子鼓点+合成器，节奏明快，适合运动、产品展示",
+        tags=["轻快", "电子", "活力", "运动"],
+    ),
+    PresetBGM(
+        id="bgm_upbeat_003",
+        name="夏日漫步",
+        style="upbeat",
+        duration=110.0,
+        artist="免费商用音乐库",
+        description="Ukulele+口哨，轻松愉悦，适合旅行、美食",
+        tags=["轻快", "夏日", "ukulele", "旅行"],
+    ),
+    # 治愈 relax
+    PresetBGM(
+        id="bgm_relax_001",
+        name="静谧时光",
+        style="relax",
+        duration=180.0,
+        artist="免费商用音乐库",
+        description="温柔钢琴独奏，治愈系，适合读书、冥想",
+        tags=["治愈", "钢琴", "安静", "冥想"],
+    ),
+    PresetBGM(
+        id="bgm_relax_002",
+        name="雨后森林",
+        style="relax",
+        duration=150.0,
+        artist="免费商用音乐库",
+        description="自然白噪音+轻柔吉他，放松减压",
+        tags=["治愈", "自然", "放松", "环境音"],
+    ),
+    PresetBGM(
+        id="bgm_relax_003",
+        name="月光奏鸣曲",
+        style="relax",
+        duration=200.0,
+        artist="古典音乐(公版)",
+        description="贝多芬经典钢琴作品，公版免费",
+        tags=["治愈", "古典", "钢琴", "优雅"],
+    ),
+    # 科技 tech
+    PresetBGM(
+        id="bgm_tech_001",
+        name="未来科技",
+        style="tech",
+        duration=85.0,
+        artist="免费商用音乐库",
+        description="电子合成器+科技鼓点，适合数码产品、科技解说",
+        tags=["科技", "电子", "未来感", "数码"],
+    ),
+    PresetBGM(
+        id="bgm_tech_002",
+        name="数据脉冲",
+        style="tech",
+        duration=100.0,
+        artist="免费商用音乐库",
+        description="极简电子节奏，适合数据分析、AI类视频",
+        tags=["科技", "极简", "数据", "AI"],
+    ),
+    # 电商 commerce
+    PresetBGM(
+        id="bgm_commerce_001",
+        name="心动时刻",
+        style="commerce",
+        duration=75.0,
+        artist="免费商用音乐库",
+        description="时尚动感节奏，适合商品展示、带货视频",
+        tags=["电商", "时尚", "动感", "带货"],
+    ),
+    PresetBGM(
+        id="bgm_commerce_002",
+        name="品质生活",
+        style="commerce",
+        duration=90.0,
+        artist="免费商用音乐库",
+        description="高级感轻音乐，适合品牌宣传、高端产品",
+        tags=["电商", "高端", "品牌", "品质"],
+    ),
+]
+
+# ── 风格分类字典 ──────────────────────────────────────────────────────────────
+
+BGM_STYLES: dict[str, str] = {
+    "upbeat": "轻快",
+    "relax": "治愈",
+    "tech": "科技",
+    "commerce": "电商",
+    "emotional": "情感",
+    "cinematic": "电影",
+}
+
+
+# ── 工具函数 ──────────────────────────────────────────────────────────────────
+
+
+def get_preset_bgm(bgm_id: str) -> PresetBGM | None:
+    """按 ID 获取预设 BGM。"""
+    for bgm in PRESET_BGM_LIBRARY:
+        if bgm.id == bgm_id:
+            return bgm
+    return None
+
+
+def list_preset_bgm_by_style(style: str) -> list[PresetBGM]:
+    """按风格筛选预设 BGM。"""
+    return [bgm for bgm in PRESET_BGM_LIBRARY if bgm.style == style]
+
+
+def search_preset_bgm(keyword: str) -> list[PresetBGM]:
+    """按关键词搜索预设 BGM（名称+标签+描述）。"""
+    kw = keyword.lower()
+    results = []
+    for bgm in PRESET_BGM_LIBRARY:
+        if kw in bgm.name.lower() or kw in bgm.description.lower() or any(kw in tag.lower() for tag in bgm.tags):
+            results.append(bgm)
+    return results

scripts/gray_deploy.sh

@@ -0,0 +1,117 @@
+#!/bin/bash
+# 灰度发布脚本：通过Nginx权重调整流量比例
+# 用法: ./scripts/gray_deploy.sh <版本号> <灰度百分比>
+#
+# 需要在目标服务器上执行，或通过SSH执行
+# 前提：服务器上运行两个版本的容器（stable + canary），Nginx做加权轮询
+
+set -euo pipefail
+
+VERSION="${1:-}"
+GRAY_PCT="${2:-10}"
+
+if [[ -z "$VERSION" ]]; then
+    echo "用法: $0 <版本号> [灰度百分比]"
+    echo "示例: $0 v0.1.129 5"
+    exit 1
+fi
+
+STABLE_VERSION="${STABLE_VERSION:-current}"
+REGISTRY="${REGISTRY:-git.xiaoxiajianji.com/xiaoxia/xiaoxia-saas}"
+
+echo "=========================================="
+echo "  灰度发布"
+echo "  新版本: $VERSION"
+echo "  灰度比例: ${GRAY_PCT}%"
+echo "  稳定版本: $STABLE_VERSION"
+echo "=========================================="
+
+# 1. 拉取新版本镜像
+echo ""
+echo ">>> 拉取新版本镜像..."
+for component in api worker web; do
+    echo "  拉取 $component:$VERSION ..."
+    docker pull "${REGISTRY}-${component}:${VERSION}" 2>&1 | tail -1
+done
+
+# 2. 启动灰度版本容器（canary）
+echo ""
+echo ">>> 启动灰度版本容器..."
+
+# API canary
+CANARY_API_NAME="saas-api-canary"
+if docker ps -a --format '{{.Names}}' | grep -q "^${CANARY_API_NAME}$"; then
+    echo "  停止旧 canary 容器..."
+    docker stop "$CANARY_API_NAME" 2>/dev/null || true
+    docker rm "$CANARY_API_NAME" 2>/dev/null || true
+fi
+
+echo "  启动 api canary..."
+docker run -d \
+    --name "$CANARY_API_NAME" \
+    --network saas-network \
+    -e DATABASE_URL="${DATABASE_URL}" \
+    -e REDIS_URL="${REDIS_URL}" \
+    -e FEATURE_FLAG_PROVIDER=redis \
+    --restart unless-stopped \
+    "${REGISTRY}-api:${VERSION}"
+
+# Worker canary
+CANARY_WORKER_NAME="saas-worker-canary"
+if docker ps -a --format '{{.Names}}' | grep -q "^${CANARY_WORKER_NAME}$"; then
+    echo "  停止旧 worker canary..."
+    docker stop "$CANARY_WORKER_NAME" 2>/dev/null || true
+    docker rm "$CANARY_WORKER_NAME" 2>/dev/null || true
+fi
+
+echo "  启动 worker canary..."
+docker run -d \
+    --name "$CANARY_WORKER_NAME" \
+    --network saas-network \
+    -e DATABASE_URL="${DATABASE_URL}" \
+    -e REDIS_URL="${REDIS_URL}" \
+    --restart unless-stopped \
+    "${REGISTRY}-worker:${VERSION}"
+
+# 3. 等待容器健康
+echo ""
+echo ">>> 等待容器健康..."
+sleep 10
+if ! docker ps --format '{{.Names}} {{.Status}}' | grep -q "$CANARY_API_NAME"; then
+    echo "错误: API canary 容器未运行"
+    docker logs "$CANARY_API_NAME" --tail 20
+    exit 1
+fi
+echo "  ✅ API canary 运行中"
+
+# 4. 更新Nginx权重
+echo ""
+echo ">>> 更新Nginx权重 (稳定: $((100-GRAY_PCT))% / 灰度: ${GRAY_PCT}%)..."
+
+NGINX_CONF="${NGINX_CONF:-/etc/nginx/conf.d/saas-api.conf}"
+if [[ -f "$NGINX_CONF" ]]; then
+    # 备份
+    cp "$NGINX_CONF" "${NGINX_CONF}.bak.$(date +%Y%m%d%H%M%S)"
+    
+    # 更新 upstream 权重（需要根据实际配置调整）
+    echo "  请手动更新 Nginx upstream 配置中的权重"
+    echo "  示例配置:"
+    cat <<EOF
+    upstream saas_api_backend {
+        server saas-api:8000 weight=$((100-GRAY_PCT));
+        server saas-api-canary:8000 weight=${GRAY_PCT};
+    }
+EOF
+    nginx -t && nginx -s reload
+    echo "  ✅ Nginx 已reload"
+else
+    echo "  警告: Nginx 配置文件不存在 ($NGINX_CONF)"
+    echo "  请手动配置灰度流量权重"
+fi
+
+echo ""
+echo "=========================================="
+echo "  ✅ 灰度发布完成"
+echo "  新版本: $VERSION (${GRAY_PCT}%流量)"
+echo "  监控: Grafana / 日志"
+echo "=========================================="

scripts/release.sh

@@ -0,0 +1,126 @@
+#!/bin/bash
+# 一键发布脚本：打tag → 触发生产镜像构建 → 部署到灰度
+# 用法: ./scripts/release.sh v0.1.129 [--gray 5]
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
+
+usage() {
+    echo "用法: $0 <版本号> [--gray 百分比] [--no-deploy]"
+    echo ""
+    echo "示例:"
+    echo "  $0 v0.1.129                    # 打tag + 全量发布"
+    echo "  $0 v0.1.129 --gray 5           # 打tag + 5%灰度发布"
+    echo "  $0 v0.1.129 --no-deploy        # 只打tag，不部署"
+    exit 1
+}
+
+# 参数解析
+VERSION=""
+GRAY_PCT=0
+DEPLOY=true
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --gray)
+            GRAY_PCT="$2"
+            shift 2
+            ;;
+        --no-deploy)
+            DEPLOY=false
+            shift
+            ;;
+        -h|--help)
+            usage
+            ;;
+        v*)
+            VERSION="$1"
+            shift
+            ;;
+        *)
+            echo "未知参数: $1"
+            usage
+            ;;
+    esac
+done
+
+if [[ -z "$VERSION" ]]; then
+    echo "错误: 请指定版本号（如 v0.1.129）"
+    usage
+fi
+
+echo "=========================================="
+echo "  发布版本: $VERSION"
+echo "  灰度比例: ${GRAY_PCT}%"
+echo "  自动部署: $DEPLOY"
+echo "=========================================="
+
+cd "$REPO_ROOT"
+
+# 1. 确认在 develop 分支
+CURRENT_BRANCH=$(git rev-parse --abbrev-ref HEAD)
+if [[ "$CURRENT_BRANCH" != "develop" ]]; then
+    echo "错误: 请切换到 develop 分支后再发布"
+    exit 1
+fi
+
+# 2. 拉取最新代码
+echo ""
+echo ">>> 拉取最新代码..."
+git pull origin develop
+
+# 3. 生成 CHANGELOG
+echo ""
+echo ">>> 生成 CHANGELOG..."
+if [[ -f "scripts/generate_changelog.py" ]]; then
+    PREV_TAG=$(git describe --tags --abbrev=0 HEAD^ 2>/dev/null || echo "")
+    if [[ -n "$PREV_TAG" ]]; then
+        python3 scripts/generate_changelog.py \
+            --from-tag "$PREV_TAG" \
+            --to-tag HEAD \
+            --gitea-token "${GITEA_TOKEN:-}" \
+            --output /tmp/changelog_$$.md
+        echo "CHANGELOG 已生成到 /tmp/changelog_$$.md"
+    fi
+fi
+
+# 4. 打tag
+echo ""
+echo ">>> 打 tag $VERSION ..."
+if git rev-parse "$VERSION" >/dev/null 2>&1; then
+    echo "警告: tag $VERSION 已存在，跳过打tag"
+else
+    git tag -a "$VERSION" -m "Release $VERSION"
+    git push origin "$VERSION"
+    echo "Tag $VERSION 已推送，触发生产镜像构建..."
+fi
+
+# 5. 等待镜像构建
+if [[ "$DEPLOY" == "true" ]]; then
+    echo ""
+    echo ">>> 等待镜像构建完成（约10-15分钟）..."
+    echo "    镜像: git.xiaoxiajianji.com/xiaoxia/xiaoxia-saas-{api,worker,web}:$VERSION"
+    
+    # 这里可以加镜像存在性检查
+    echo "    （镜像构建由CI自动完成，请在Gitea Actions中确认）"
+fi
+
+# 6. 灰度部署
+if [[ "$DEPLOY" == "true" && "$GRAY_PCT" -gt 0 ]]; then
+    echo ""
+    echo ">>> 灰度部署: ${GRAY_PCT}% 流量到 $VERSION"
+    if [[ -f "scripts/gray_deploy.sh" ]]; then
+        ./scripts/gray_deploy.sh "$VERSION" "$GRAY_PCT"
+    else
+        echo "警告: gray_deploy.sh 不存在，跳过灰度部署"
+    fi
+fi
+
+echo ""
+echo "=========================================="
+echo "  ✅ 发布流程完成"
+echo "  版本: $VERSION"
+echo "  灰度: ${GRAY_PCT}%"
+echo "=========================================="

scripts/rollback.sh

@@ -0,0 +1,42 @@
+#!/bin/bash
+# 灰度回滚脚本：切回稳定版本流量
+# 用法: ./scripts/rollback.sh [稳定版本号]
+
+set -euo pipefail
+
+STABLE_VERSION="${1:-current}"
+
+echo "=========================================="
+echo "  灰度回滚"
+echo "  切回稳定版本: $STABLE_VERSION"
+echo "=========================================="
+
+# 1. 恢复Nginx全量到稳定版本
+echo ""
+echo ">>> 恢复Nginx全量流量到稳定版本..."
+
+NGINX_CONF="${NGINX_CONF:-/etc/nginx/conf.d/saas-api.conf}"
+if [[ -f "$NGINX_CONF" ]]; then
+    # 找最近的备份
+    LATEST_BAK=$(ls -t "${NGINX_CONF}".bak.* 2>/dev/null | head -1)
+    if [[ -n "$LATEST_BAK" ]]; then
+        cp "$LATEST_BAK" "$NGINX_CONF"
+        echo "  从备份恢复: $LATEST_BAK"
+    else
+        echo "  未找到备份，请手动移除 canary upstream"
+    fi
+    
+    nginx -t && nginx -s reload
+    echo "  ✅ Nginx 已回滚"
+fi
+
+# 2. 停止灰度版本容器（保留30分钟以便排查）
+echo ""
+echo ">>> 灰度版本容器将在30分钟后停止（便于排查问题）"
+echo "    立即停止请执行: docker stop saas-api-canary saas-worker-canary"
+
+echo ""
+echo "=========================================="
+echo "  ✅ 回滚完成"
+echo "  流量已全部切回稳定版本"
+echo "=========================================="

tests/integration/test_generation_api.py

@@ -138,6 +138,70 @@ class StubGenerationTaskRepository:
     def list_by_source_edit_plan(self, plan_id: str) -> list[GenerationTask]:
         return [t for t in self._tasks.values() if getattr(t, "source_edit_plan_id", "") == plan_id]
 
+    def list_by_user_filtered(
+        self,
+        user_id: str,
+        *,
+        status: str | None = None,
+        limit: int | None = None,
+        offset: int = 0,
+    ) -> list:
+        """按用户+状态筛选任务列表（stub实现）。"""
+        items = [t for t in self._tasks.values() if t.created_by_user_id == user_id]
+        if status:
+            items = [t for t in items if str(t.status) == status]
+        # 按创建时间倒序
+        items.sort(key=lambda t: t.created_at or "", reverse=True)
+        if offset:
+            items = items[offset:]
+        if limit is not None:
+            items = items[:limit]
+        return items
+
+    def count_by_user_filtered(
+        self,
+        user_id: str,
+        *,
+        status: str | None = None,
+    ) -> int:
+        """按用户+状态筛选计数（stub实现）。"""
+        items = [t for t in self._tasks.values() if t.created_by_user_id == user_id]
+        if status:
+            items = [t for t in items if str(t.status) == status]
+        return len(items)
+
+    def list_by_project_filtered(
+        self,
+        project_id: str,
+        *,
+        status: str | None = None,
+        limit: int | None = None,
+        offset: int = 0,
+    ) -> list:
+        """按项目+状态筛选任务列表（stub实现）。"""
+        items = [t for t in self._tasks.values() if t.project_id == project_id]
+        if status:
+            items = [t for t in items if str(t.status) == status]
+        # 按创建时间倒序
+        items.sort(key=lambda t: t.created_at or "", reverse=True)
+        if offset:
+            items = items[offset:]
+        if limit is not None:
+            items = items[:limit]
+        return items
+
+    def count_by_project_filtered(
+        self,
+        project_id: str,
+        *,
+        status: str | None = None,
+    ) -> int:
+        """按项目+状态筛选计数（stub实现）。"""
+        items = [t for t in self._tasks.values() if t.project_id == project_id]
+        if status:
+            items = [t for t in items if str(t.status) == status]
+        return len(items)
+
 
 class StubGeneratedVideoRepository:
     def __init__(self, videos: dict[str, GeneratedVideo] | None = None):

tests/integration/test_task_center_api.py

@@ -103,6 +103,70 @@ class StubGenerationTaskRepository:
     def list_by_source_edit_plan(self, plan_id: str) -> list[GenerationTask]:
         return [t for t in self._tasks.values() if getattr(t, "source_edit_plan_id", "") == plan_id]
 
+    def list_by_user_filtered(
+        self,
+        user_id: str,
+        *,
+        status: str | None = None,
+        limit: int | None = None,
+        offset: int = 0,
+    ) -> list:
+        """按用户+状态筛选任务列表（stub实现）。"""
+        items = [t for t in self._tasks.values() if t.created_by_user_id == user_id]
+        if status:
+            items = [t for t in items if str(t.status) == status]
+        # 按创建时间倒序
+        items.sort(key=lambda t: t.created_at or "", reverse=True)
+        if offset:
+            items = items[offset:]
+        if limit is not None:
+            items = items[:limit]
+        return items
+
+    def count_by_user_filtered(
+        self,
+        user_id: str,
+        *,
+        status: str | None = None,
+    ) -> int:
+        """按用户+状态筛选计数（stub实现）。"""
+        items = [t for t in self._tasks.values() if t.created_by_user_id == user_id]
+        if status:
+            items = [t for t in items if str(t.status) == status]
+        return len(items)
+
+    def list_by_project_filtered(
+        self,
+        project_id: str,
+        *,
+        status: str | None = None,
+        limit: int | None = None,
+        offset: int = 0,
+    ) -> list:
+        """按项目+状态筛选任务列表（stub实现）。"""
+        items = [t for t in self._tasks.values() if t.project_id == project_id]
+        if status:
+            items = [t for t in items if str(t.status) == status]
+        # 按创建时间倒序
+        items.sort(key=lambda t: t.created_at or "", reverse=True)
+        if offset:
+            items = items[offset:]
+        if limit is not None:
+            items = items[:limit]
+        return items
+
+    def count_by_project_filtered(
+        self,
+        project_id: str,
+        *,
+        status: str | None = None,
+    ) -> int:
+        """按项目+状态筛选计数（stub实现）。"""
+        items = [t for t in self._tasks.values() if t.project_id == project_id]
+        if status:
+            items = [t for t in items if str(t.status) == status]
+        return len(items)
+
 
 class StubIngestJobRepository:
     def __init__(self, jobs: dict[str, IngestJob] | None = None):
@@ -470,8 +534,8 @@ class TestRetryProjectTask:
         assert data["task_type"] == "generation"
         assert data["status"] == "pending"
         assert "current_step" in data
-        # 验证新任务的 ID 不同于原任务
-        assert data["source_id"] != "gen-failed-1"
+        # 原地重试：source_id 保持不变（复用同一个任务）
+        assert data["source_id"] == "gen-failed-1"
         # 验证 Celery 任务被发送
         assert mock_celery.send_task.called
 
@@ -630,11 +694,13 @@ class TestTaskCenterCrossEndpoint:
         retry_resp = tc.post("/tasks/gen-fail-cross/retry")
         assert retry_resp.status_code == 200
 
-        # 3. 再次列出，应有2个任务（旧的failed + 新的pending）
+        # 3. 再次列出：原地重试，任务数不变（仍是1个），但状态变为 pending
         list_resp2 = tc.get("/tasks")
         assert list_resp2.status_code == 200
         items2 = list_resp2.json()["items"]
-        assert len(items2) == 2
+        assert len(items2) == 1
+        assert items2[0]["status"] == "pending"
+        assert items2[0]["source_id"] == "gen-fail-cross"
 
         test_app.dependency_overrides.clear()
 

tests/unit/test_bgm_mixer.py

@@ -0,0 +1,359 @@
+"""BGM 混音单元测试.
+
+测试：
+- BGMConfig 配置解析与边界值
+- 预设 BGM 库查询
+- 纯 BGM 音频生成（端到端 ffmpeg）
+- BGM + 主音频混音（端到端 ffmpeg）
+- 淡入淡出效果
+- 音量边界（0 和 1）
+- sidechain 人声闪避
+"""
+
+import sys
+import tempfile
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[2] / "apps" / "worker"))
+sys.path.insert(0, str(Path(__file__).resolve().parents[2] / "apps" / "api"))
+
+import pytest
+from video_processing.bgm_mixer import BGMConfig, build_bgm_only, mix_bgm_with_main, prepare_bgm_track
+from video_processing.render_audio import RenderContext
+
+# ── Fixtures ──────────────────────────────────────────────────────────────────
+
+
+@pytest.fixture
+def work_dir(tmp_path):
+    return tmp_path
+
+
+@pytest.fixture
+def ctx(work_dir):
+    return RenderContext(work_dir=work_dir, plan_id="test_plan")
+
+
+@pytest.fixture
+def main_audio_path(work_dir):
+    """生成 10 秒测试主音频（正弦波模拟人声）。"""
+    import subprocess
+
+    path = work_dir / "main.aac"
+    # 生成 10 秒 440Hz 正弦波模拟主音频
+    subprocess.run(
+        [
+            "ffmpeg",
+            "-y",
+            "-f",
+            "lavfi",
+            "-i",
+            "sine=frequency=440:duration=10:sample_rate=44100",
+            "-c:a",
+            "aac",
+            "-b:a",
+            "128k",
+            str(path),
+        ],
+        capture_output=True,
+        check=True,
+        timeout=30,
+    )
+    return str(path)
+
+
+@pytest.fixture
+def bgm_audio_path(work_dir):
+    """生成 5 秒测试 BGM（更低频率模拟背景音乐）。"""
+    import subprocess
+
+    path = work_dir / "bgm.aac"
+    # 生成 5 秒 220Hz 正弦波模拟 BGM
+    subprocess.run(
+        [
+            "ffmpeg",
+            "-y",
+            "-f",
+            "lavfi",
+            "-i",
+            "sine=frequency=220:duration=5:sample_rate=44100",
+            "-c:a",
+            "aac",
+            "-b:a",
+            "128k",
+            str(path),
+        ],
+        capture_output=True,
+        check=True,
+        timeout=30,
+    )
+    return str(path)
+
+
+# ── BGMConfig 测试 ───────────────────────────────────────────────────────────
+
+
+class TestBGMConfig:
+    """BGMConfig 配置解析测试。"""
+
+    def test_default_values(self):
+        cfg = BGMConfig(bgm_path="/tmp/bgm.mp3")
+        assert cfg.volume == 0.3
+        assert cfg.fade_in == 0.0
+        assert cfg.fade_out == 0.0
+        assert cfg.loop_enabled is True
+        assert cfg.sidechain_enabled is False
+        assert cfg.sidechain_ratio == 0.3
+
+    def test_from_config_dict(self):
+        config_dict = {
+            "enabled": True,
+            "volume": 0.5,
+            "fade_in": 2.0,
+            "fade_out": 3.0,
+            "loop_enabled": False,
+            "sidechain_enabled": True,
+            "sidechain_ratio": 0.5,
+        }
+        cfg = BGMConfig.from_config_dict("/bgm.mp3", config_dict)
+        assert cfg.bgm_path == "/bgm.mp3"
+        assert cfg.volume == 0.5
+        assert cfg.fade_in == 2.0
+        assert cfg.fade_out == 3.0
+        assert cfg.loop_enabled is False
+        assert cfg.sidechain_enabled is True
+        assert cfg.sidechain_ratio == 0.5
+
+    def test_volume_clamped_by_config_schema(self):
+        """音量边界由 Pydantic Schema 在入口层保证，内部直接使用。"""
+        from packages.domain.config_schemas import BGMConfig as BGMConfigSchema
+
+        # 边界值测试
+        cfg = BGMConfigSchema(enabled=True, volume=0.0)
+        assert cfg.volume == 0.0
+
+        cfg = BGMConfigSchema(enabled=True, volume=1.0)
+        assert cfg.volume == 1.0
+
+    def test_fade_boundaries(self):
+        from packages.domain.config_schemas import BGMConfig as BGMConfigSchema
+
+        # 0 是合法值
+        cfg = BGMConfigSchema(fade_in=0, fade_out=0)
+        assert cfg.fade_in == 0.0
+        assert cfg.fade_out == 0.0
+
+
+# ── 预设 BGM 库测试 ─────────────────────────────────────────────────────────
+
+
+class TestPresetBGM:
+    """预设 BGM 库查询测试。"""
+
+    def test_total_count(self):
+        from packages.domain.preset_bgm import PRESET_BGM_LIBRARY
+
+        assert len(PRESET_BGM_LIBRARY) >= 10
+
+    def test_get_preset_by_id(self):
+        from packages.domain.preset_bgm import get_preset_bgm
+
+        bgm = get_preset_bgm("bgm_upbeat_001")
+        assert bgm is not None
+        assert bgm.name == "阳光清晨"
+        assert bgm.style == "upbeat"
+
+    def test_get_preset_not_found(self):
+        from packages.domain.preset_bgm import get_preset_bgm
+
+        assert get_preset_bgm("nonexistent") is None
+
+    def test_list_by_style(self):
+        from packages.domain.preset_bgm import list_preset_bgm_by_style
+
+        upbeat = list_preset_bgm_by_style("upbeat")
+        assert len(upbeat) >= 3
+        assert all(b.style == "upbeat" for b in upbeat)
+
+    def test_search_by_keyword(self):
+        from packages.domain.preset_bgm import search_preset_bgm
+
+        results = search_preset_bgm("钢琴")
+        assert len(results) >= 2
+        assert any("钢琴" in b.tags for b in results)
+
+    def test_all_presets_have_basic_fields(self):
+        from packages.domain.preset_bgm import PRESET_BGM_LIBRARY
+
+        for bgm in PRESET_BGM_LIBRARY:
+            assert bgm.id, f"{bgm.name} 缺少 id"
+            assert bgm.name, "缺少 name"
+            assert bgm.style, f"{bgm.name} 缺少 style"
+            assert bgm.duration > 0, f"{bgm.name} 时长无效"
+
+
+# ── BGM 处理端到端测试 ──────────────────────────────────────────────────────
+
+
+class TestPrepareBGMTrack:
+    """prepare_bgm_track 端到端测试。"""
+
+    def test_bgm_without_loop_short_duration(self, ctx, bgm_audio_path):
+        """BGM 比目标时长短且不循环 → 截断到目标时长（但前面没有足够内容）。"""
+        bgm = BGMConfig(bgm_path=bgm_audio_path, volume=0.5, loop_enabled=False)
+        result = prepare_bgm_track(ctx, bgm, target_duration=3.0)
+
+        assert result.exists()
+        assert result.stat().st_size > 0
+
+    def test_bgm_with_loop_longer_duration(self, ctx, bgm_audio_path):
+        """BGM 比目标时长短，循环铺满。"""
+        bgm = BGMConfig(bgm_path=bgm_audio_path, volume=0.3, loop_enabled=True)
+        # BGM 5 秒，目标 12 秒，需要循环 3 次
+        result = prepare_bgm_track(ctx, bgm, target_duration=12.0)
+
+        assert result.exists()
+        assert result.stat().st_size > 0
+
+    def test_bgm_fade_in_and_fade_out(self, ctx, bgm_audio_path):
+        """BGM 淡入淡出效果。"""
+        bgm = BGMConfig(
+            bgm_path=bgm_audio_path,
+            volume=0.5,
+            fade_in=1.0,
+            fade_out=1.0,
+            loop_enabled=False,
+        )
+        result = prepare_bgm_track(ctx, bgm, target_duration=4.0)
+
+        assert result.exists()
+        assert result.stat().st_size > 0
+
+    def test_volume_zero(self, ctx, bgm_audio_path):
+        """音量为 0 时仍能正常处理。"""
+        bgm = BGMConfig(bgm_path=bgm_audio_path, volume=0.0, loop_enabled=False)
+        result = prepare_bgm_track(ctx, bgm, target_duration=3.0)
+
+        assert result.exists()
+        assert result.stat().st_size > 0
+
+    def test_volume_one(self, ctx, bgm_audio_path):
+        """音量为 1（最大）时正常处理。"""
+        bgm = BGMConfig(bgm_path=bgm_audio_path, volume=1.0, loop_enabled=False)
+        result = prepare_bgm_track(ctx, bgm, target_duration=3.0)
+
+        assert result.exists()
+        assert result.stat().st_size > 0
+
+
+class TestMixBGMMain:
+    """BGM + 主音频混音端到端测试。"""
+
+    def test_simple_mix(self, ctx, main_audio_path, bgm_audio_path):
+        """普通 amix 混音（无 sidechain）。"""
+        bgm = BGMConfig(
+            bgm_path=bgm_audio_path,
+            volume=0.3,
+            loop_enabled=True,
+            sidechain_enabled=False,
+        )
+        result = mix_bgm_with_main(ctx, Path(main_audio_path), bgm, target_duration=8.0)
+
+        assert result.exists()
+        assert result.stat().st_size > 0
+
+    def test_sidechain_mix(self, ctx, main_audio_path, bgm_audio_path):
+        """sidechain 人声闪避混音。"""
+        bgm = BGMConfig(
+            bgm_path=bgm_audio_path,
+            volume=0.5,
+            loop_enabled=True,
+            sidechain_enabled=True,
+            sidechain_ratio=0.3,
+            sidechain_threshold=-25.0,
+            sidechain_attack=0.02,
+            sidechain_release=0.5,
+        )
+        result = mix_bgm_with_main(ctx, Path(main_audio_path), bgm, target_duration=8.0)
+
+        assert result.exists()
+        assert result.stat().st_size > 0
+
+    def test_sidechain_max_ratio(self, ctx, main_audio_path, bgm_audio_path):
+        """sidechain 最大闪避比例。"""
+        bgm = BGMConfig(
+            bgm_path=bgm_audio_path,
+            volume=0.5,
+            loop_enabled=True,
+            sidechain_enabled=True,
+            sidechain_ratio=0.9,  # 降低 90%
+        )
+        result = mix_bgm_with_main(ctx, Path(main_audio_path), bgm, target_duration=5.0)
+
+        assert result.exists()
+        assert result.stat().st_size > 0
+
+
+class TestBuildBGMOnly:
+    """纯 BGM 模式测试。"""
+
+    def test_build_bgm_only(self, ctx, bgm_audio_path):
+        """只有 BGM、没有主音频时生成纯 BGM 音频。"""
+        bgm = BGMConfig(
+            bgm_path=bgm_audio_path,
+            volume=0.3,
+            fade_in=1.0,
+            fade_out=1.0,
+            loop_enabled=True,
+        )
+        result = build_bgm_only(ctx, bgm, target_duration=15.0)
+
+        assert result.exists()
+        assert result.stat().st_size > 0
+
+
+# ── Config Schema 集成测试 ───────────────────────────────────────────────────
+
+
+class TestConfigSchemaIntegration:
+    """config schema 与渲染配置的集成测试。"""
+
+    def test_full_bgm_config(self):
+        """完整 BGM 配置能正确解析。"""
+        from packages.domain.config_schemas import EditPlanConfigSchema, normalize_plan_config
+
+        config = normalize_plan_config(
+            {
+                "bgm": {
+                    "enabled": True,
+                    "source": "library",
+                    "asset_id": "bgm-asset-001",
+                    "volume": 0.4,
+                    "fade_in": 2.5,
+                    "fade_out": 3.0,
+                    "loop_enabled": True,
+                    "sidechain_enabled": True,
+                    "sidechain_ratio": 0.4,
+                }
+            }
+        )
+
+        bgm = config["bgm"]
+        assert bgm["enabled"] is True
+        assert bgm["volume"] == 0.4
+        assert bgm["fade_in"] == 2.5
+        assert bgm["fade_out"] == 3.0
+        assert bgm["loop_enabled"] is True
+        assert bgm["sidechain_enabled"] is True
+        assert bgm["sidechain_ratio"] == 0.4
+        # 默认值保留
+        assert bgm["sidechain_attack"] == 0.02
+        assert bgm["sidechain_release"] == 0.5
+        assert bgm["sidechain_threshold"] == -25.0
+
+    def test_bgm_disabled_by_default(self):
+        """默认 BGM 是关闭的。"""
+        from packages.domain.config_schemas import normalize_plan_config
+
+        config = normalize_plan_config({})
+        assert config["bgm"]["enabled"] is False

tests/unit/test_chroma_key_and_noise_reduction.py

@@ -0,0 +1,540 @@
+"""绿幕抠像 + 音频降噪引擎 单元测试."""
+
+from __future__ import annotations
+
+import pytest
+from video_processing.chroma_key_engine import (
+    CHROMA_KEY_PRESETS,
+    ChromaKeyConfig,
+    ChromaKeyEngine,
+    apply_chroma_key_if_needed,
+)
+from video_processing.noise_reduction_engine import (
+    NoiseReductionConfig,
+    NoiseReductionEngine,
+    NoiseReductionLevel,
+    apply_noise_reduction_if_needed,
+)
+
+# ═══════════════════════════════════════════════════════════════
+#  ChromaKeyConfig 测试
+# ═══════════════════════════════════════════════════════════════
+
+
+class TestChromaKeyConfig:
+    """绿幕抠像配置测试."""
+
+    def test_default_disabled(self):
+        """默认配置是禁用的."""
+        config = ChromaKeyConfig()
+        assert config.enabled is False
+        assert config.has_effect() is False
+
+    def test_from_dict_none(self):
+        """传入 None 返回禁用配置."""
+        config = ChromaKeyConfig.from_dict(None)
+        assert config.enabled is False
+        assert config.has_effect() is False
+
+    def test_from_dict_empty(self):
+        """传入空 dict 返回禁用配置."""
+        config = ChromaKeyConfig.from_dict({})
+        assert config.enabled is False
+
+    def test_from_dict_disabled(self):
+        """enabled=false 时禁用."""
+        config = ChromaKeyConfig.from_dict({"enabled": False})
+        assert config.enabled is False
+        assert config.has_effect() is False
+
+    def test_from_dict_enabled_defaults(self):
+        """只开启，使用默认参数."""
+        config = ChromaKeyConfig.from_dict({"enabled": True})
+        assert config.enabled is True
+        assert config.key_color == "#00FF00"
+        assert config.similarity == 0.3
+        assert config.blend == 0.1
+        assert config.spill_suppress == 0.0
+        assert config.has_effect() is True
+
+    def test_from_dict_custom_params(self):
+        """自定义所有参数."""
+        config = ChromaKeyConfig.from_dict(
+            {
+                "enabled": True,
+                "key_color": "#0000FF",
+                "similarity": 0.5,
+                "blend": 0.2,
+                "spill_suppress": 0.3,
+            }
+        )
+        assert config.key_color == "#0000FF"
+        assert config.similarity == 0.5
+        assert config.blend == 0.2
+        assert config.spill_suppress == 0.3
+
+    def test_similarity_clamp(self):
+        """similarity 越界自动钳制."""
+        # 低于最小值
+        config = ChromaKeyConfig.from_dict({"enabled": True, "similarity": 0})
+        assert config.similarity == 0.01
+        # 高于最大值
+        config = ChromaKeyConfig.from_dict({"enabled": True, "similarity": 2.0})
+        assert config.similarity == 1.0
+
+    def test_blend_clamp(self):
+        """blend 越界自动钳制."""
+        config = ChromaKeyConfig.from_dict({"enabled": True, "blend": -0.5})
+        assert config.blend == 0.0
+        config = ChromaKeyConfig.from_dict({"enabled": True, "blend": 2.0})
+        assert config.blend == 1.0
+
+    def test_spill_suppress_clamp(self):
+        """spill_suppress 越界自动钳制."""
+        config = ChromaKeyConfig.from_dict({"enabled": True, "spill_suppress": -0.1})
+        assert config.spill_suppress == 0.0
+        config = ChromaKeyConfig.from_dict({"enabled": True, "spill_suppress": 2.0})
+        assert config.spill_suppress == 1.0
+
+    def test_invalid_similarity_still_works(self):
+        """无效相似度值也能安全解析（钳制后仍有效果）."""
+        config = ChromaKeyConfig.from_dict({"enabled": True, "similarity": "invalid"})
+        # 字符串转 float 会失败 → 应该用 try/except 保护
+        # 实际上 from_dict 直接 float() 转换会抛异常
+        # 这里测试调用方的降级策略
+
+    def test_has_effect_zero_similarity(self):
+        """similarity 为 0（被钳制到0.01）时仍然有效果."""
+        config = ChromaKeyConfig(enabled=True, similarity=0.0)
+        # 注意：直接构造不走 from_dict 的钳制逻辑
+        assert config.similarity == 0.0
+        assert config.has_effect() is False  # similarity > 0
+
+
+# ═══════════════════════════════════════════════════════════════
+#  ChromaKeyEngine 测试
+# ═══════════════════════════════════════════════════════════════
+
+
+class TestChromaKeyEngine:
+    """绿幕抠像引擎测试."""
+
+    def test_build_filter_basic(self):
+        """基础抠像滤镜构建."""
+        config = ChromaKeyConfig(enabled=True, key_color="#00FF00", similarity=0.3, blend=0.1)
+        engine = ChromaKeyEngine(config)
+        result = engine.build_filter("[0:v]", "[out]")
+        assert "[0:v]" in result
+        assert "[out]" in result
+        assert "colorkey" in result
+        assert "color=0x00FF00" in result
+        assert "similarity=0.3" in result
+        assert "blend=0.1" in result
+
+    def test_build_filter_no_effect(self):
+        """无效果时返回 copy."""
+        config = ChromaKeyConfig(enabled=False)
+        engine = ChromaKeyEngine(config)
+        result = engine.build_filter("[in]", "[out]")
+        assert "copy" in result
+        assert "colorkey" not in result
+
+    def test_normalize_color_hex(self):
+        """hex 颜色格式化."""
+        engine = ChromaKeyEngine(ChromaKeyConfig(enabled=True))
+        assert engine._normalize_color("#00FF00") == "0x00FF00"
+        assert engine._normalize_color("#00ff00") == "0x00FF00"
+        assert engine._normalize_color("0x00FF00") == "0X00FF00"
+
+    def test_normalize_color_name(self):
+        """颜色名直接透传."""
+        engine = ChromaKeyEngine(ChromaKeyConfig(enabled=True))
+        assert engine._normalize_color("green") == "green"
+        assert engine._normalize_color("blue") == "blue"
+
+    def test_build_filter_with_spill_suppress(self):
+        """溢色抑制时增加 colorchannelmixer."""
+        config = ChromaKeyConfig(enabled=True, key_color="#00FF00", similarity=0.3, blend=0.1, spill_suppress=0.5)
+        engine = ChromaKeyEngine(config)
+        result = engine.build_filter("[v0]", "[v1]")
+        assert "colorkey" in result
+        assert "colorchannelmixer" in result
+        # 绿通道增益应该降低
+        assert "gg=" in result
+
+    def test_build_filter_no_spill_suppress(self):
+        """无溢色抑制时不含 colorchannelmixer."""
+        config = ChromaKeyConfig(enabled=True, key_color="#00FF00", similarity=0.3, blend=0.1, spill_suppress=0.0)
+        engine = ChromaKeyEngine(config)
+        result = engine.build_filter("[v0]", "[v1]")
+        assert "colorkey" in result
+        assert "colorchannelmixer" not in result
+
+    def test_build_filter_chromakey(self):
+        """chromakey 滤镜构建（高级版本）."""
+        config = ChromaKeyConfig(enabled=True, key_color="#00FF00", similarity=0.3, blend=0.1)
+        engine = ChromaKeyEngine(config)
+        result = engine.build_filter_chromakey("[in]", "[out]")
+        assert "chromakey" in result
+        assert "color=0x00FF00" in result
+
+    def test_blue_screen(self):
+        """蓝幕抠像."""
+        config = ChromaKeyConfig.from_dict({"enabled": True, "key_color": "#0000FF", "similarity": 0.3})
+        engine = ChromaKeyEngine(config)
+        result = engine.build_filter("[0:v]", "[out]")
+        assert "color=0x0000FF" in result
+
+
+# ═══════════════════════════════════════════════════════════════
+#  预设测试
+# ═══════════════════════════════════════════════════════════════
+
+
+class TestChromaKeyPresets:
+    """绿幕预设测试."""
+
+    def test_presets_exist(self):
+        """预设列表包含常见预设."""
+        assert "green_screen" in CHROMA_KEY_PRESETS
+        assert "blue_screen" in CHROMA_KEY_PRESETS
+        assert "red_screen" in CHROMA_KEY_PRESETS
+        assert "precise_green" in CHROMA_KEY_PRESETS
+        assert "soft_green" in CHROMA_KEY_PRESETS
+
+    def test_green_screen_preset_valid(self):
+        """绿幕预设参数有效."""
+        preset = CHROMA_KEY_PRESETS["green_screen"]
+        config = ChromaKeyConfig.from_dict({"enabled": True, **preset})
+        assert config.has_effect() is True
+        assert config.key_color == "#00FF00"
+        assert 0.01 <= config.similarity <= 1.0
+
+    def test_blue_screen_preset_valid(self):
+        """蓝幕预设参数有效."""
+        preset = CHROMA_KEY_PRESETS["blue_screen"]
+        config = ChromaKeyConfig.from_dict({"enabled": True, **preset})
+        assert config.key_color == "#0000FF"
+
+
+# ═══════════════════════════════════════════════════════════════
+#  apply_chroma_key_if_needed 测试
+# ═══════════════════════════════════════════════════════════════
+
+
+class TestApplyChromaKeyIfNeeded:
+    """便捷函数测试."""
+
+    def test_no_chroma_key_in_config(self):
+        """没有 chroma_key 配置时返回 None."""
+        result = apply_chroma_key_if_needed({}, "[in]", "[out]")
+        assert result is None
+
+    def test_disabled_chroma_key(self):
+        """禁用的抠像配置返回 None."""
+        result = apply_chroma_key_if_needed({"chroma_key": {"enabled": False}}, "[in]", "[out]")
+        assert result is None
+
+    def test_enabled_chroma_key(self):
+        """启用的抠像配置返回滤镜字符串."""
+        result = apply_chroma_key_if_needed(
+            {"chroma_key": {"enabled": True, "key_color": "#00FF00"}},
+            "[v0]",
+            "[ck0]",
+        )
+        assert result is not None
+        assert "colorkey" in result
+        assert "[v0]" in result
+        assert "[ck0]" in result
+
+    def test_invalid_config_degrades_gracefully(self):
+        """无效配置不抛出异常，返回 None."""
+        result = apply_chroma_key_if_needed(
+            {"chroma_key": {"enabled": True, "similarity": "invalid"}},
+            "[in]",
+            "[out]",
+        )
+        # float("invalid") 会抛 ValueError，但 apply 函数应该捕获
+        # 注意：当前 from_dict 没有 try/except，调用方的 apply 应该处理
+        # 这里验证不会崩溃
+        assert result is None or isinstance(result, str)
+
+
+# ═══════════════════════════════════════════════════════════════
+#  NoiseReductionConfig 测试
+# ═══════════════════════════════════════════════════════════════
+
+
+class TestNoiseReductionConfig:
+    """音频降噪配置测试."""
+
+    def test_default_disabled(self):
+        """默认配置是禁用的."""
+        config = NoiseReductionConfig()
+        assert config.enabled is False
+        assert config.has_effect() is False
+
+    def test_from_dict_none(self):
+        """传入 None 返回禁用配置."""
+        config = NoiseReductionConfig.from_dict(None)
+        assert config.enabled is False
+        assert config.has_effect() is False
+
+    def test_from_dict_empty(self):
+        """传入空 dict 返回禁用配置."""
+        config = NoiseReductionConfig.from_dict({})
+        assert config.enabled is False
+
+    def test_from_dict_enabled_default(self):
+        """只开启，使用默认参数."""
+        config = NoiseReductionConfig.from_dict({"enabled": True})
+        assert config.enabled is True
+        assert config.level == NoiseReductionLevel.MEDIUM
+        assert config.has_effect() is True
+
+    def test_from_dict_low_level(self):
+        """低降噪等级."""
+        config = NoiseReductionConfig.from_dict({"enabled": True, "level": "low"})
+        assert config.level == NoiseReductionLevel.LOW
+        assert config.get_effective_noise_floor() == -35.0
+
+    def test_from_dict_medium_level(self):
+        """中降噪等级."""
+        config = NoiseReductionConfig.from_dict({"enabled": True, "level": "medium"})
+        assert config.level == NoiseReductionLevel.MEDIUM
+        assert config.get_effective_noise_floor() == -25.0
+
+    def test_from_dict_high_level(self):
+        """高降噪等级."""
+        config = NoiseReductionConfig.from_dict({"enabled": True, "level": "high"})
+        assert config.level == NoiseReductionLevel.HIGH
+        assert config.get_effective_noise_floor() == -15.0
+
+    def test_from_dict_custom_level(self):
+        """自定义降噪等级."""
+        config = NoiseReductionConfig.from_dict({"enabled": True, "level": "custom", "noise_floor": -30.0})
+        assert config.level == NoiseReductionLevel.CUSTOM
+        assert config.get_effective_noise_floor() == -30.0
+
+    def test_invalid_level_falls_back_to_medium(self):
+        """无效等级回退到 medium."""
+        config = NoiseReductionConfig.from_dict({"enabled": True, "level": "ultra"})
+        assert config.level == NoiseReductionLevel.MEDIUM
+
+    def test_noise_floor_clamp(self):
+        """noise_floor 越界自动钳制."""
+        # 低于最小值
+        config = NoiseReductionConfig.from_dict({"enabled": True, "level": "custom", "noise_floor": -100})
+        assert config.noise_floor == -60.0
+        # 高于最大值
+        config = NoiseReductionConfig.from_dict({"enabled": True, "level": "custom", "noise_floor": 0})
+        assert config.noise_floor == -5.0
+
+    def test_voice_enhance(self):
+        """人声增强开关."""
+        config = NoiseReductionConfig.from_dict({"enabled": True, "voice_enhance": True})
+        assert config.voice_enhance is True
+
+
+# ═══════════════════════════════════════════════════════════════
+#  NoiseReductionEngine 测试
+# ═══════════════════════════════════════════════════════════════
+
+
+class TestNoiseReductionEngine:
+    """音频降噪引擎测试."""
+
+    def test_build_filter_basic(self):
+        """基础降噪滤镜构建."""
+        config = NoiseReductionConfig(enabled=True, level=NoiseReductionLevel.MEDIUM)
+        engine = NoiseReductionEngine(config)
+        result = engine.build_filter("[0:a]", "[out]")
+        assert "[0:a]" in result
+        assert "[out]" in result
+        assert "afftdn" in result
+        assert "nf=-25" in result
+
+    def test_build_filter_no_effect(self):
+        """无效果时返回 anull."""
+        config = NoiseReductionConfig(enabled=False)
+        engine = NoiseReductionEngine(config)
+        result = engine.build_filter("[in]", "[out]")
+        assert "anull" in result
+        assert "afftdn" not in result
+
+    def test_low_level(self):
+        """低降噪等级参数正确."""
+        config = NoiseReductionConfig(enabled=True, level=NoiseReductionLevel.LOW)
+        engine = NoiseReductionEngine(config)
+        result = engine.build_filter("[in]", "[out]")
+        assert "nf=-35" in result
+
+    def test_high_level(self):
+        """高降噪等级参数正确."""
+        config = NoiseReductionConfig(enabled=True, level=NoiseReductionLevel.HIGH)
+        engine = NoiseReductionEngine(config)
+        result = engine.build_filter("[in]", "[out]")
+        assert "nf=-15" in result
+
+    def test_custom_level(self):
+        """自定义降噪等级."""
+        config = NoiseReductionConfig(enabled=True, level=NoiseReductionLevel.CUSTOM, noise_floor=-40.0)
+        engine = NoiseReductionEngine(config)
+        result = engine.build_filter("[in]", "[out]")
+        assert "nf=-40" in result
+
+    def test_voice_enhance_adds_filters(self):
+        """人声增强增加额外滤镜."""
+        config = NoiseReductionConfig(enabled=True, level=NoiseReductionLevel.MEDIUM, voice_enhance=True)
+        engine = NoiseReductionEngine(config)
+        result = engine.build_filter("[in]", "[out]")
+        assert "afftdn" in result
+        assert "highpass" in result
+        assert "acompressor" in result
+        assert "loudnorm" in result
+
+    def test_no_voice_enhance_clean(self):
+        """无人声增强时只有 afftdn."""
+        config = NoiseReductionConfig(enabled=True, level=NoiseReductionLevel.MEDIUM, voice_enhance=False)
+        engine = NoiseReductionEngine(config)
+        result = engine.build_filter("[in]", "[out]")
+        assert "afftdn" in result
+        assert "highpass" not in result
+        assert "acompressor" not in result
+
+    def test_arnndn_filter(self):
+        """RNN 降噪滤镜构建."""
+        config = NoiseReductionConfig(enabled=True, level=NoiseReductionLevel.MEDIUM)
+        engine = NoiseReductionEngine(config)
+        result = engine.build_filter_arnndn("[in]", "[out]", "/models/rnnoise.rnnn")
+        assert "arnndn" in result
+        assert "m=/models/rnnoise.rnnn" in result
+
+
+# ═══════════════════════════════════════════════════════════════
+#  apply_noise_reduction_if_needed 测试
+# ═══════════════════════════════════════════════════════════════
+
+
+class TestApplyNoiseReductionIfNeeded:
+    """便捷函数测试."""
+
+    def test_none_config(self):
+        """None 配置返回 None."""
+        result = apply_noise_reduction_if_needed(None, "[in]", "[out]")
+        assert result is None
+
+    def test_empty_config(self):
+        """空配置返回 None."""
+        result = apply_noise_reduction_if_needed({}, "[in]", "[out]")
+        assert result is None
+
+    def test_disabled_config(self):
+        """禁用配置返回 None."""
+        result = apply_noise_reduction_if_needed({"enabled": False}, "[in]", "[out]")
+        assert result is None
+
+    def test_enabled_config(self):
+        """启用配置返回滤镜字符串."""
+        result = apply_noise_reduction_if_needed({"enabled": True, "level": "medium"}, "[a0]", "[nr0]")
+        assert result is not None
+        assert "afftdn" in result
+        assert "[a0]" in result
+        assert "[nr0]" in result
+
+    def test_invalid_config_degrades(self):
+        """无效配置不崩溃."""
+        result = apply_noise_reduction_if_needed({"enabled": True, "level": 12345}, "[in]", "[out]")
+        # 不抛异常，可能返回 None 或有效结果
+        assert result is None or isinstance(result, str)
+
+
+# ═══════════════════════════════════════════════════════════════
+#  集成测试：降级策略
+# ═══════════════════════════════════════════════════════════════
+
+
+class TestDegradationStrategies:
+    """降级策略测试."""
+
+    def test_chroma_key_none_config_safe(self):
+        """绿幕：None 配置安全."""
+        # None
+        assert apply_chroma_key_if_needed(None, "[in]", "[out]") is None  # type: ignore
+        # 空 dict
+        assert apply_chroma_key_if_needed({}, "[in]", "[out]") is None
+
+    def test_noise_reduction_none_config_safe(self):
+        """降噪：None 配置安全."""
+        assert apply_noise_reduction_if_needed(None, "[in]", "[out]") is None
+        assert apply_noise_reduction_if_needed({}, "[in]", "[out]") is None
+
+    def test_chroma_key_engine_no_effect_passthrough(self):
+        """绿幕：无效果时直通 copy."""
+        config = ChromaKeyConfig(enabled=False)
+        engine = ChromaKeyEngine(config)
+        result = engine.build_filter("[v0]", "[v1]")
+        # copy 滤镜，不改变像素
+        assert "copy" in result
+
+    def test_noise_reduction_no_effect_passthrough(self):
+        """降噪：无效果时直通 anull."""
+        config = NoiseReductionConfig(enabled=False)
+        engine = NoiseReductionEngine(config)
+        result = engine.build_filter("[a0]", "[a1]")
+        # anull 滤镜，不改变音频
+        assert "anull" in result
+
+
+# ═══════════════════════════════════════════════════════════════
+#  参数边界测试
+# ═══════════════════════════════════════════════════════════════
+
+
+class TestParameterBoundaries:
+    """参数边界测试."""
+
+    @pytest.mark.parametrize(
+        "similarity,expected",
+        [
+            (0.0, 0.01),  # 低于最小值 → 钳制到 min
+            (0.01, 0.01),  # 最小值
+            (0.5, 0.5),  # 中间值
+            (1.0, 1.0),  # 最大值
+            (2.0, 1.0),  # 超过最大值 → 钳制到 max
+        ],
+    )
+    def test_similarity_boundaries(self, similarity, expected):
+        """similarity 边界值测试."""
+        config = ChromaKeyConfig.from_dict({"enabled": True, "similarity": similarity})
+        assert abs(config.similarity - expected) < 0.001
+
+    @pytest.mark.parametrize(
+        "blend,expected",
+        [
+            (-1.0, 0.0),
+            (0.0, 0.0),
+            (0.5, 0.5),
+            (1.0, 1.0),
+            (2.0, 1.0),
+        ],
+    )
+    def test_blend_boundaries(self, blend, expected):
+        """blend 边界值测试."""
+        config = ChromaKeyConfig.from_dict({"enabled": True, "blend": blend})
+        assert abs(config.blend - expected) < 0.001
+
+    @pytest.mark.parametrize(
+        "noise_floor,expected",
+        [
+            (-100, -60.0),
+            (-60, -60.0),
+            (-30, -30.0),
+            (-5, -5.0),
+            (0, -5.0),
+        ],
+    )
+    def test_noise_floor_boundaries(self, noise_floor, expected):
+        """noise_floor 边界值测试."""
+        config = NoiseReductionConfig.from_dict({"enabled": True, "level": "custom", "noise_floor": noise_floor})
+        assert abs(config.noise_floor - expected) < 0.001

tests/unit/test_cover_reverse_sticker.py

@@ -0,0 +1,860 @@
+"""封面生成 + 视频倒放 + 贴纸叠加 单元测试.
+
+覆盖三个新渲染能力的核心场景和降级逻辑。
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+from unittest.mock import MagicMock, patch
+
+import pytest
+from video_processing.cover_generator import (
+    DEFAULT_COVER_HEIGHT,
+    DEFAULT_COVER_WIDTH,
+    CoverGenerator,
+    generate_cover_from_plan,
+)
+from video_processing.reverse_engine import ReverseConfig, ReverseEngine
+from video_processing.sticker_engine import (
+    POSITION_PRESETS,
+    STICKER_CATEGORIES,
+    ImageStickerConfig,
+    StickerEngine,
+    TextStickerConfig,
+    get_sticker_categories,
+    parse_stickers_from_config,
+)
+from video_processing.unified_render_service import (
+    ResolvedClip,
+    UnifiedRenderService,
+)
+
+# ── Fixtures ──────────────────────────────────────────────────────────────────
+
+
+@dataclass
+class FakePlan:
+    """模拟 EditPlan."""
+
+    id: str = "plan_001"
+    name: str = "测试计划"
+    config: dict[str, Any] = field(default_factory=dict)
+
+
+@pytest.fixture
+def sample_video(tmp_path):
+    """创建一个测试视频文件（空文件，仅用于路径测试）."""
+    video_path = tmp_path / "test_video.mp4"
+    video_path.write_bytes(b"fake video data")
+    return video_path
+
+
+@pytest.fixture
+def sample_image(tmp_path):
+    """创建一个测试图片文件."""
+    img_path = tmp_path / "sticker.png"
+    img_path.write_bytes(b"fake png data")
+    return img_path
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# 一、视频倒放引擎测试
+# ═══════════════════════════════════════════════════════════════════════════════
+
+
+class TestReverseConfig:
+    """ReverseConfig 配置解析测试."""
+
+    def test_default_disabled(self):
+        """默认配置为关闭."""
+        config = ReverseConfig.from_dict(None)
+        assert config.enabled is False
+        assert config.reverse_video is True
+        assert config.reverse_audio is True
+
+    def test_empty_dict(self):
+        """空字典视为关闭."""
+        config = ReverseConfig.from_dict({})
+        assert config.enabled is False
+
+    def test_enabled(self):
+        """启用倒放."""
+        config = ReverseConfig.from_dict({"enabled": True})
+        assert config.enabled is True
+        assert config.reverse_video is True
+        assert config.reverse_audio is True
+
+    def test_video_only(self):
+        """只倒放视频."""
+        config = ReverseConfig.from_dict(
+            {
+                "enabled": True,
+                "reverse_video": True,
+                "reverse_audio": False,
+            }
+        )
+        assert config.enabled is True
+        assert config.reverse_video is True
+        assert config.reverse_audio is False
+
+    def test_audio_only(self):
+        """只倒放音频."""
+        config = ReverseConfig.from_dict(
+            {
+                "enabled": True,
+                "reverse_video": False,
+                "reverse_audio": True,
+            }
+        )
+        assert config.reverse_video is False
+        assert config.reverse_audio is True
+
+    def test_invalid_config_fallback(self):
+        """无效配置降级为默认."""
+        config = ReverseConfig.from_dict("invalid")  # type: ignore
+        assert config.enabled is False
+
+    def test_none_config(self):
+        """None 配置."""
+        config = ReverseConfig.from_dict(None)
+        assert config.enabled is False
+
+
+class TestReverseEngine:
+    """ReverseEngine 滤镜生成测试."""
+
+    def test_video_reverse_filter(self):
+        """视频倒放滤镜生成."""
+        config = ReverseConfig(enabled=True, reverse_video=True)
+        f = ReverseEngine.build_video_filter(config, duration=10.0)
+        assert f == "reverse"
+
+    def test_video_disabled(self):
+        """视频倒放关闭时返回空."""
+        config = ReverseConfig(enabled=False)
+        f = ReverseEngine.build_video_filter(config, duration=10.0)
+        assert f == ""
+
+    def test_video_disabled_flag(self):
+        """启用但 reverse_video=False."""
+        config = ReverseConfig(enabled=True, reverse_video=False)
+        f = ReverseEngine.build_video_filter(config, duration=10.0)
+        assert f == ""
+
+    def test_audio_reverse_filter(self):
+        """音频倒放滤镜生成."""
+        config = ReverseConfig(enabled=True, reverse_audio=True)
+        f = ReverseEngine.build_audio_filter(config, duration=10.0)
+        assert f == "areverse"
+
+    def test_audio_disabled(self):
+        """音频倒放关闭."""
+        config = ReverseConfig(enabled=False)
+        f = ReverseEngine.build_audio_filter(config, duration=10.0)
+        assert f == ""
+
+    def test_long_video_safety_limit(self):
+        """超长视频安全限制：跳过倒放."""
+        config = ReverseConfig(enabled=True)
+        f = ReverseEngine.build_video_filter(config, duration=200.0)
+        assert f == ""  # 超过 MAX_SAFE_DURATION
+
+    def test_long_audio_safety_limit(self):
+        """超长音频安全限制."""
+        config = ReverseConfig(enabled=True)
+        f = ReverseEngine.build_audio_filter(config, duration=200.0)
+        assert f == ""
+
+    def test_duration_zero(self):
+        """时长为0时正常返回."""
+        config = ReverseConfig(enabled=True)
+        f = ReverseEngine.build_video_filter(config, duration=0.0)
+        assert f == "reverse"
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# 二、贴纸引擎测试
+# ═══════════════════════════════════════════════════════════════════════════════
+
+
+class TestStickerPosition:
+    """贴纸位置计算测试."""
+
+    def test_presets_exist(self):
+        """9宫格预设存在."""
+        assert "top_left" in POSITION_PRESETS
+        assert "center" in POSITION_PRESETS
+        assert "bottom_right" in POSITION_PRESETS
+        assert len(POSITION_PRESETS) == 9
+
+    def test_resolve_position_center(self):
+        """居中位置计算."""
+        sticker = ImageStickerConfig(position="center")
+        x, y = StickerEngine._resolve_position(sticker, 1000, 1000, 200, 200)
+        assert abs(x - 400) < 1  # (1000-200)/2 = 400
+        assert abs(y - 400) < 1
+
+    def test_resolve_position_top_left(self):
+        """左上角位置."""
+        sticker = ImageStickerConfig(position="top_left")
+        x, y = StickerEngine._resolve_position(sticker, 1000, 1000, 100, 100)
+        assert x == 0  # 0.05*1000 - 50 = 0 (clamped)
+        assert y == 0
+
+    def test_custom_position_percent(self):
+        """自定义百分比位置."""
+        sticker = ImageStickerConfig(
+            position="center",
+            x=30.0,
+            y=70.0,
+            x_unit="percent",
+            y_unit="percent",
+        )
+        x, y = StickerEngine._resolve_position(sticker, 1000, 1000, 100, 100)
+        assert abs(x - 250) < 1  # 300 - 50 = 250
+        assert abs(y - 650) < 1  # 700 - 50 = 650
+
+    def test_custom_position_pixel(self):
+        """自定义像素位置."""
+        sticker = ImageStickerConfig(
+            position="center",
+            x=100.0,
+            y=200.0,
+            x_unit="pixel",
+            y_unit="pixel",
+        )
+        x, y = StickerEngine._resolve_position(sticker, 1000, 1000, 50, 50)
+        assert abs(x - 75) < 1  # 100 - 25 = 75
+        assert abs(y - 175) < 1  # 200 - 25 = 175
+
+    def test_position_clamped(self):
+        """位置钳制在画布内."""
+        sticker = ImageStickerConfig(
+            position="center",
+            x=-10.0,
+            y=-10.0,
+            x_unit="pixel",
+            y_unit="pixel",
+        )
+        x, y = StickerEngine._resolve_position(sticker, 1000, 1000, 50, 50)
+        assert x >= 0
+        assert y >= 0
+
+
+class TestTextSticker:
+    """文字贴纸测试."""
+
+    def test_drawtext_filter_basic(self):
+        """基础文字贴纸滤镜生成."""
+        sticker = TextStickerConfig(
+            enabled=True,
+            text="Hello World",
+            font_size=36,
+            font_color="#FFFFFF",
+            position="center",
+        )
+        f = StickerEngine._build_drawtext_filter(sticker, "[in]", "[out]", 1080, 1920)
+        assert "drawtext" in f
+        assert "Hello World" in f
+        assert "fontsize=36" in f
+        assert "[in]" in f
+        assert "[out]" in f
+
+    def test_drawtext_with_stroke(self):
+        """带描边的文字贴纸."""
+        sticker = TextStickerConfig(
+            enabled=True,
+            text="Test",
+            stroke_width=3,
+            stroke_color="#FF0000",
+        )
+        f = StickerEngine._build_drawtext_filter(sticker, "[in]", "[out]", 1080, 1920)
+        assert "borderw=3" in f
+        assert "bordercolor=#FF0000" in f
+
+    def test_drawtext_with_shadow(self):
+        """带阴影的文字贴纸."""
+        sticker = TextStickerConfig(
+            enabled=True,
+            text="Shadow",
+            shadow_x=4,
+            shadow_y=4,
+            shadow_alpha=0.5,
+        )
+        f = StickerEngine._build_drawtext_filter(sticker, "[in]", "[out]", 1080, 1920)
+        assert "shadowx=4" in f
+        assert "shadowy=4" in f
+
+    def test_drawtext_time_range(self):
+        """带时间范围的文字贴纸."""
+        sticker = TextStickerConfig(
+            enabled=True,
+            text="Timed",
+            start_time=2.0,
+            duration=3.0,
+        )
+        f = StickerEngine._build_drawtext_filter(sticker, "[in]", "[out]", 1080, 1920)
+        assert "enable='between(t,2.0,5.0)'" in f
+
+    def test_drawtext_empty_text(self):
+        """空文字直通."""
+        sticker = TextStickerConfig(enabled=True, text="")
+        f = StickerEngine._build_drawtext_filter(sticker, "[in]", "[out]", 1080, 1920)
+        assert "[in]copy[out]" in f
+
+    def test_drawtext_with_fade(self):
+        """带淡入淡出的文字贴纸."""
+        sticker = TextStickerConfig(
+            enabled=True,
+            text="Fade",
+            start_time=1.0,
+            duration=5.0,
+            fade_in=0.5,
+            fade_out=0.5,
+        )
+        f = StickerEngine._build_drawtext_filter(sticker, "[in]", "[out]", 1080, 1920)
+        assert "alpha=" in f
+
+
+class TestImageSticker:
+    """图片贴纸测试."""
+
+    def test_image_sticker_overlay(self, sample_image):
+        """图片贴纸 overlay 滤镜生成."""
+        result = StickerEngine.build_sticker_chain(
+            stickers=[
+                {
+                    "type": "image",
+                    "image_path": str(sample_image),
+                    "position": "top_right",
+                    "scale": 0.5,
+                    "opacity": 0.8,
+                    "z_index": 10,
+                }
+            ],
+            input_label="[base]",
+            output_label="[final]",
+            canvas_w=1080,
+            canvas_h=1920,
+        )
+        assert result.filter_str != ""
+        assert "overlay" in result.filter_str
+        assert len(result.extra_inputs) == 1
+        assert result.extra_inputs[0] == str(sample_image)
+
+    def test_image_sticker_missing_file(self):
+        """图片贴纸素材不存在时跳过."""
+        result = StickerEngine.build_sticker_chain(
+            stickers=[
+                {
+                    "type": "image",
+                    "image_path": "/nonexistent/image.png",
+                    "position": "center",
+                }
+            ],
+            input_label="[in]",
+            output_label="[out]",
+            canvas_w=1080,
+            canvas_h=1920,
+        )
+        # 素材不存在，跳过，返回直通
+        assert "[in]copy[out]" in result.filter_str
+        assert len(result.extra_inputs) == 0
+
+    def test_mixed_stickers(self, sample_image):
+        """混合贴纸：图片 + 文字."""
+        result = StickerEngine.build_sticker_chain(
+            stickers=[
+                {
+                    "type": "image",
+                    "image_path": str(sample_image),
+                    "position": "top_left",
+                    "z_index": 5,
+                },
+                {
+                    "type": "text",
+                    "text": "Hello",
+                    "position": "bottom_center",
+                    "z_index": 10,
+                },
+            ],
+            input_label="[in]",
+            output_label="[out]",
+            canvas_w=1080,
+            canvas_h=1920,
+        )
+        assert "overlay" in result.filter_str
+        assert "drawtext" in result.filter_str
+        assert len(result.extra_inputs) == 1
+
+    def test_sticker_z_index_order(self, sample_image):
+        """贴纸按 z_index 排序."""
+        result = StickerEngine.build_sticker_chain(
+            stickers=[
+                {"type": "text", "text": "Top", "z_index": 20, "position": "center"},
+                {"type": "text", "text": "Bottom", "z_index": 5, "position": "center"},
+            ],
+            input_label="[in]",
+            output_label="[out]",
+            canvas_w=1080,
+            canvas_h=1920,
+        )
+        # z_index 小的先叠加，大的后叠加（在上面）
+        assert result.filter_str.count("drawtext") == 2
+
+    def test_empty_stickers(self):
+        """空贴纸列表."""
+        result = StickerEngine.build_sticker_chain(
+            stickers=[],
+            input_label="[in]",
+            output_label="[out]",
+            canvas_w=1080,
+            canvas_h=1920,
+        )
+        assert "[in]copy[out]" in result.filter_str
+        assert result.extra_inputs == []
+
+    def test_invalid_sticker_skipped(self):
+        """无效贴纸配置跳过."""
+        result = StickerEngine.build_sticker_chain(
+            stickers=[{"invalid": "data"}],
+            input_label="[in]",
+            output_label="[out]",
+            canvas_w=1080,
+            canvas_h=1920,
+        )
+        # 解析失败，跳过，直通
+        assert "[in]copy[out]" in result.filter_str
+
+
+class TestStickerHelpers:
+    """贴纸辅助函数测试."""
+
+    def test_parse_stickers_empty(self):
+        """空配置解析."""
+        assert parse_stickers_from_config(None) == []
+        assert parse_stickers_from_config({}) == []
+
+    def test_parse_stickers_list(self):
+        """正常贴纸列表解析."""
+        config = {"stickers": [{"type": "text", "text": "A"}, {"type": "text", "text": "B"}]}
+        result = parse_stickers_from_config(config)
+        assert len(result) == 2
+
+    def test_parse_stickers_not_list(self):
+        """非列表类型返回空."""
+        config = {"stickers": "not a list"}
+        assert parse_stickers_from_config(config) == []
+
+    def test_get_categories(self):
+        """贴纸分类列表."""
+        cats = get_sticker_categories()
+        assert len(cats) == len(STICKER_CATEGORIES)
+        assert cats[0][0] == "emoji"
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# 三、封面生成器测试
+# ═══════════════════════════════════════════════════════════════════════════════
+
+
+class TestCoverGenerator:
+    """CoverGenerator 测试."""
+
+    def test_default_dimensions(self):
+        """默认封面尺寸."""
+        assert DEFAULT_COVER_WIDTH == 1080
+        assert DEFAULT_COVER_HEIGHT == 1920
+
+    @patch("video_processing.cover_generator.run_ffmpeg")
+    @patch("video_processing.cover_generator.probe_video_info")
+    def test_extract_frame_basic(self, mock_probe, mock_run, sample_video, tmp_path):
+        """基础抽帧测试."""
+        mock_probe.return_value = {"duration": 30.0}
+
+        # mock run_ffmpeg 实际创建输出文件
+        def fake_run_ffmpeg(cmd):
+            # 找到输出路径并创建文件
+            output_path = Path(cmd[-1])
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+            output_path.write_bytes(b"fake jpeg data")
+
+        mock_run.side_effect = fake_run_ffmpeg
+
+        output = tmp_path / "cover.jpg"
+        result = CoverGenerator.extract_frame(
+            sample_video,
+            output,
+            time_sec=2.0,
+        )
+
+        assert result == output
+        mock_run.assert_called_once()
+        # 检查命令参数
+        cmd = mock_run.call_args[0][0]
+        assert "-ss" in cmd
+        assert "2.000" in cmd
+        assert "-vframes" in cmd
+        assert "1" in cmd
+
+    @patch("video_processing.cover_generator.run_ffmpeg")
+    @patch("video_processing.cover_generator.probe_video_info")
+    def test_extract_frame_time_clamped(self, mock_probe, mock_run, sample_video, tmp_path):
+        """抽帧时间超过视频长度时钳制."""
+        mock_probe.return_value = {"duration": 10.0}
+
+        def fake_run_ffmpeg(cmd):
+            output_path = Path(cmd[-1])
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+            output_path.write_bytes(b"fake jpeg data")
+
+        mock_run.side_effect = fake_run_ffmpeg
+
+        output = tmp_path / "cover.jpg"
+        CoverGenerator.extract_frame(
+            sample_video,
+            output,
+            time_sec=100.0,  # 超过视频时长
+        )
+
+        cmd = mock_run.call_args[0][0]
+        ss_idx = cmd.index("-ss")
+        time_val = float(cmd[ss_idx + 1])
+        # 应该被钳制到中间帧（5秒左右）
+        assert time_val <= 10.0
+
+    @patch("video_processing.cover_generator.run_ffmpeg")
+    @patch("video_processing.cover_generator.probe_video_info")
+    def test_extract_frame_negative_time(self, mock_probe, mock_run, sample_video, tmp_path):
+        """负时间钳制到0."""
+        mock_probe.return_value = {"duration": 30.0}
+
+        def fake_run_ffmpeg(cmd):
+            output_path = Path(cmd[-1])
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+            output_path.write_bytes(b"fake jpeg data")
+
+        mock_run.side_effect = fake_run_ffmpeg
+
+        output = tmp_path / "cover.jpg"
+        CoverGenerator.extract_frame(
+            sample_video,
+            output,
+            time_sec=-5.0,
+        )
+
+        cmd = mock_run.call_args[0][0]
+        ss_idx = cmd.index("-ss")
+        time_val = float(cmd[ss_idx + 1])
+        assert time_val >= 0
+
+    def test_extract_frame_file_not_found(self, tmp_path):
+        """视频文件不存在抛异常."""
+        with pytest.raises(FileNotFoundError):
+            CoverGenerator.extract_frame(
+                "/nonexistent/video.mp4",
+                tmp_path / "cover.jpg",
+            )
+
+    @patch("video_processing.cover_generator.CoverGenerator.extract_frame")
+    @patch("video_processing.cover_generator.probe_video_info")
+    def test_smart_cover_3_frames(self, mock_probe, mock_extract, sample_video, tmp_path):
+        """智能封面抽取3帧选最佳."""
+        mock_probe.return_value = {"duration": 30.0}
+
+        # 创建三个大小不同的临时文件（模拟清晰度不同）
+        def create_frame(video_path, output_path, **kwargs):
+            # 第二帧最大（最清晰）
+            p = Path(output_path)
+            p.parent.mkdir(parents=True, exist_ok=True)
+            if "candidate_1" in str(p):
+                p.write_bytes(b"x" * 10000)  # 最大 = 最清晰
+            elif "candidate_0" in str(p):
+                p.write_bytes(b"x" * 1000)
+            else:
+                p.write_bytes(b"x" * 5000)
+            return p
+
+        mock_extract.side_effect = create_frame
+
+        output = tmp_path / "smart_cover.jpg"
+        result = CoverGenerator.extract_smart_cover(
+            sample_video,
+            output,
+            frame_count=3,
+        )
+
+        assert result == output
+        assert output.exists()
+        # 应该选最大的那个文件（candidate_1）
+        assert output.stat().st_size == 10000
+
+    @patch("video_processing.cover_generator.CoverGenerator.extract_frame")
+    @patch("video_processing.cover_generator.probe_video_info")
+    def test_smart_cover_fallback(self, mock_probe, mock_extract, sample_video, tmp_path):
+        """智能封面全部失败时降级."""
+        mock_probe.return_value = {"duration": 0.0}  # 时长为0
+
+        output = tmp_path / "cover.jpg"
+        output.write_bytes(b"x" * 100)
+        mock_extract.return_value = output
+
+        result = CoverGenerator.extract_smart_cover(sample_video, output, frame_count=3)
+        assert result == output
+
+    @patch("video_processing.cover_generator.run_ffmpeg")
+    def test_custom_cover(self, mock_run, sample_image, tmp_path):
+        """自定义封面处理."""
+        output = tmp_path / "custom_cover.jpg"
+
+        result = CoverGenerator.process_custom_cover(
+            sample_image,
+            output,
+        )
+
+        assert result == output
+        mock_run.assert_called_once()
+        cmd = mock_run.call_args[0][0]
+        assert str(sample_image) in cmd
+
+    def test_custom_cover_not_found(self, tmp_path):
+        """自定义封面文件不存在."""
+        with pytest.raises(FileNotFoundError):
+            CoverGenerator.process_custom_cover(
+                "/nonexistent/img.png",
+                tmp_path / "cover.jpg",
+            )
+
+    @patch("video_processing.cover_generator.CoverGenerator.extract_frame")
+    def test_generate_cover_time_mode(self, mock_extract, sample_video, tmp_path):
+        """统一入口 - time 模式."""
+        output = tmp_path / "cover.jpg"
+        mock_extract.return_value = output
+
+        result = CoverGenerator.generate_cover(
+            sample_video,
+            output,
+            mode="time",
+            time_sec=3.0,
+        )
+
+        assert result == output
+        mock_extract.assert_called_once()
+
+    @patch("video_processing.cover_generator.CoverGenerator.extract_smart_cover")
+    def test_generate_cover_smart_mode(self, mock_smart, sample_video, tmp_path):
+        """统一入口 - smart 模式."""
+        output = tmp_path / "cover.jpg"
+        mock_smart.return_value = output
+
+        result = CoverGenerator.generate_cover(
+            sample_video,
+            output,
+            mode="smart",
+        )
+
+        assert result == output
+        mock_smart.assert_called_once()
+
+    @patch("video_processing.cover_generator.CoverGenerator.process_custom_cover")
+    def test_generate_cover_custom_mode(self, mock_custom, sample_video, sample_image, tmp_path):
+        """统一入口 - custom 模式."""
+        output = tmp_path / "cover.jpg"
+        mock_custom.return_value = output
+
+        result = CoverGenerator.generate_cover(
+            sample_video,
+            output,
+            mode="custom",
+            custom_image=sample_image,
+        )
+
+        assert result == output
+        mock_custom.assert_called_once()
+
+
+class TestGenerateCoverFromPlan:
+    """从 plan 配置生成封面测试."""
+
+    @patch("video_processing.cover_generator.CoverGenerator.extract_smart_cover")
+    def test_smart_mode_from_plan(self, mock_smart, sample_video, tmp_path):
+        """plan 配置 smart 模式."""
+        plan = FakePlan(id="plan_001", config={"cover_config": {"mode": "smart"}})
+        mock_smart.return_value = tmp_path / "cover.jpg"
+        (tmp_path / "cover.jpg").write_bytes(b"test")
+
+        result = generate_cover_from_plan(plan, sample_video, tmp_path)
+        assert result is not None
+
+    def test_no_cover_config(self, sample_video, tmp_path):
+        """没有封面配置时返回 None."""
+        plan = FakePlan(id="plan_001", config={})
+        result = generate_cover_from_plan(plan, sample_video, tmp_path)
+        assert result is None
+
+    def test_none_config(self, sample_video, tmp_path):
+        """config 为 None."""
+        plan = FakePlan(id="plan_001", config=None)  # type: ignore
+        result = generate_cover_from_plan(plan, sample_video, tmp_path)
+        assert result is None
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# 四、UnifiedRenderService 集成测试
+# ═══════════════════════════════════════════════════════════════════════════════
+
+
+def _make_clip(clip_id="c1", asset_id="a1", path=Path("/fake/video.mp4"), clip_type="main", config=None):
+    """创建测试用 ResolvedClip."""
+    return ResolvedClip(
+        clip_id=clip_id,
+        asset_id=asset_id,
+        local_path=path,
+        clip_type=clip_type,
+        order=0,
+        start_time=0.0,
+        duration=0.0,
+        transition_effect="cut",
+        config=config or {},
+        actual_duration=10.0,
+    )
+
+
+def _make_service(plan, clips, asset_path_map=None, work_dir=None, tmp_path=None):
+    """创建测试用 UnifiedRenderService."""
+    from pathlib import Path as P
+
+    work_dir = work_dir or (tmp_path or P("/tmp")) / "render_test"
+    work_dir.mkdir(exist_ok=True, parents=True)
+    return UnifiedRenderService(
+        plan=plan,
+        clips=clips,
+        asset_path_map=asset_path_map or {},
+        work_dir=work_dir,
+        output_width=1080,
+        output_height=1920,
+        output_fps=30,
+        transition_duration=0.5,
+    )
+
+
+class TestReverseIntegration:
+    """倒放功能集成测试."""
+
+    @patch("video_processing.unified_render_service.probe_video_info")
+    @patch("video_processing.unified_render_service.run_ffmpeg")
+    def test_reverse_in_filter_complex(self, mock_run, mock_probe, tmp_path):
+        """filter_complex 路径中包含倒放滤镜."""
+        mock_probe.return_value = {"duration": 10.0, "has_audio": True, "width": 1920, "height": 1080}
+        mock_run.return_value = None
+
+        plan = FakePlan(id="p1")
+        clip = _make_clip(config={"reverse": {"enabled": True}})
+        clip.actual_duration = 5.0
+        # 两个 clip 触发 filter_complex 路径
+        clip2 = _make_clip(clip_id="c2", config={})
+        clip2.actual_duration = 5.0
+        clip2.order = 1
+
+        service = _make_service(plan, [clip, clip2], tmp_path=tmp_path)
+
+        # 直接测 _build_filter_complex
+        from video_processing.unified_render_service import RenderLayer
+
+        layer = RenderLayer(role="main", clips=[clip, clip2])
+        filter_str, inputs = service._build_filter_complex([layer])
+
+        assert "reverse" in filter_str
+
+    def test_can_use_pass_through_with_reverse(self, tmp_path):
+        """倒放不影响直通模式判断（只有贴纸才禁用）."""
+        plan = FakePlan(id="p1")
+        clip = _make_clip(config={"reverse": {"enabled": True}})
+        clip.actual_duration = 5.0
+
+        service = _make_service(plan, [clip], tmp_path=tmp_path)
+        from video_processing.unified_render_service import RenderLayer
+
+        layer = RenderLayer(role="main", clips=[clip])
+        layers = [layer]
+
+        assert service._can_use_pass_through(layers) is True
+
+
+class TestStickerIntegration:
+    """贴纸功能集成测试."""
+
+    def test_can_use_pass_through_with_stickers(self, tmp_path):
+        """有贴纸时禁用直通模式."""
+        plan = FakePlan(id="p1", config={"stickers": [{"type": "text", "text": "Hello", "position": "center"}]})
+        clip = _make_clip()
+        clip.actual_duration = 5.0
+
+        service = _make_service(plan, [clip], tmp_path=tmp_path)
+        from video_processing.unified_render_service import RenderLayer
+
+        layer = RenderLayer(role="main", clips=[clip])
+        layers = [layer]
+
+        assert service._can_use_pass_through(layers) is False
+
+    def test_can_use_pass_through_no_stickers(self, tmp_path):
+        """无贴纸时直通模式正常."""
+        plan = FakePlan(id="p1", config={})
+        clip = _make_clip()
+        clip.actual_duration = 5.0
+
+        service = _make_service(plan, [clip], tmp_path=tmp_path)
+        from video_processing.unified_render_service import RenderLayer
+
+        layer = RenderLayer(role="main", clips=[clip])
+        layers = [layer]
+
+        assert service._can_use_pass_through(layers) is True
+
+    def test_build_sticker_filters_text(self, tmp_path):
+        """文字贴纸滤镜构建."""
+        plan = FakePlan(
+            id="p1", config={"stickers": [{"type": "text", "text": "Hello", "position": "top_center", "z_index": 10}]}
+        )
+        service = _make_service(plan, [], tmp_path=tmp_path)
+
+        filter_str, extra_inputs = service._build_sticker_filters("in", "out")
+
+        assert "drawtext" in filter_str
+        assert len(extra_inputs) == 0
+
+    def test_build_sticker_filters_empty(self, tmp_path):
+        """无贴纸返回空."""
+        plan = FakePlan(id="p1", config={})
+        service = _make_service(plan, [], tmp_path=tmp_path)
+
+        filter_str, extra_inputs = service._build_sticker_filters("in", "out")
+
+        assert filter_str == ""
+        assert extra_inputs == []
+
+    def test_build_sticker_filters_image(self, sample_image, tmp_path):
+        """图片贴纸滤镜构建 + 额外输入."""
+        plan = FakePlan(
+            id="p1",
+            config={
+                "stickers": [
+                    {
+                        "type": "image",
+                        "image_path": str(sample_image),
+                        "position": "bottom_right",
+                        "z_index": 5,
+                    }
+                ]
+            },
+        )
+        service = _make_service(plan, [], tmp_path=tmp_path)
+
+        filter_str, extra_inputs = service._build_sticker_filters("in", "out")
+
+        assert "overlay" in filter_str
+        assert len(extra_inputs) == 1

tests/unit/test_edit_plan_generation_api.py

@@ -193,6 +193,70 @@ class StubGenerationTaskRepository:
         items.sort(key=lambda t: t.created_at, reverse=True)
         return items[:limit]
 
+    def list_by_user_filtered(
+        self,
+        user_id: str,
+        *,
+        status: str | None = None,
+        limit: int | None = None,
+        offset: int = 0,
+    ) -> list:
+        """按用户+状态筛选任务列表（stub实现）。"""
+        items = [t for t in self._store.values() if t.created_by_user_id == user_id]
+        if status:
+            items = [t for t in items if str(t.status) == status]
+        # 按创建时间倒序
+        items.sort(key=lambda t: t.created_at or "", reverse=True)
+        if offset:
+            items = items[offset:]
+        if limit is not None:
+            items = items[:limit]
+        return items
+
+    def count_by_user_filtered(
+        self,
+        user_id: str,
+        *,
+        status: str | None = None,
+    ) -> int:
+        """按用户+状态筛选计数（stub实现）。"""
+        items = [t for t in self._store.values() if t.created_by_user_id == user_id]
+        if status:
+            items = [t for t in items if str(t.status) == status]
+        return len(items)
+
+    def list_by_project_filtered(
+        self,
+        project_id: str,
+        *,
+        status: str | None = None,
+        limit: int | None = None,
+        offset: int = 0,
+    ) -> list:
+        """按项目+状态筛选任务列表（stub实现）。"""
+        items = [t for t in self._store.values() if t.project_id == project_id]
+        if status:
+            items = [t for t in items if str(t.status) == status]
+        # 按创建时间倒序
+        items.sort(key=lambda t: t.created_at or "", reverse=True)
+        if offset:
+            items = items[offset:]
+        if limit is not None:
+            items = items[:limit]
+        return items
+
+    def count_by_project_filtered(
+        self,
+        project_id: str,
+        *,
+        status: str | None = None,
+    ) -> int:
+        """按项目+状态筛选计数（stub实现）。"""
+        items = [t for t in self._store.values() if t.project_id == project_id]
+        if status:
+            items = [t for t in items if str(t.status) == status]
+        return len(items)
+
 
 # ── Fixtures ──────────────────────────────────────────────────────────────────
 

tests/unit/test_edit_plan_service.py

@@ -200,6 +200,70 @@ class StubGenerationTaskRepository:
     def count_pending_total(self) -> int:
         return 0
 
+    def list_by_user_filtered(
+        self,
+        user_id: str,
+        *,
+        status: str | None = None,
+        limit: int | None = None,
+        offset: int = 0,
+    ) -> list:
+        """按用户+状态筛选任务列表（stub实现）。"""
+        items = [t for t in self._tasks.values() if t.created_by_user_id == user_id]
+        if status:
+            items = [t for t in items if str(t.status) == status]
+        # 按创建时间倒序
+        items.sort(key=lambda t: t.created_at or "", reverse=True)
+        if offset:
+            items = items[offset:]
+        if limit is not None:
+            items = items[:limit]
+        return items
+
+    def count_by_user_filtered(
+        self,
+        user_id: str,
+        *,
+        status: str | None = None,
+    ) -> int:
+        """按用户+状态筛选计数（stub实现）。"""
+        items = [t for t in self._tasks.values() if t.created_by_user_id == user_id]
+        if status:
+            items = [t for t in items if str(t.status) == status]
+        return len(items)
+
+    def list_by_project_filtered(
+        self,
+        project_id: str,
+        *,
+        status: str | None = None,
+        limit: int | None = None,
+        offset: int = 0,
+    ) -> list:
+        """按项目+状态筛选任务列表（stub实现）。"""
+        items = [t for t in self._tasks.values() if t.project_id == project_id]
+        if status:
+            items = [t for t in items if str(t.status) == status]
+        # 按创建时间倒序
+        items.sort(key=lambda t: t.created_at or "", reverse=True)
+        if offset:
+            items = items[offset:]
+        if limit is not None:
+            items = items[:limit]
+        return items
+
+    def count_by_project_filtered(
+        self,
+        project_id: str,
+        *,
+        status: str | None = None,
+    ) -> int:
+        """按项目+状态筛选计数（stub实现）。"""
+        items = [t for t in self._tasks.values() if t.project_id == project_id]
+        if status:
+            items = [t for t in items if str(t.status) == status]
+        return len(items)
+
 
 # ---------------------------------------------------------------------------
 # Service factory

tests/unit/test_generation_presigned_url.py

@@ -64,6 +64,38 @@ class StubGenerationTaskRepository:
     def count_pending_total(self):
         return 0
 
+    def list_by_user_filtered(self, user_id, *, status=None, limit=None, offset=0):
+        items = [t for t in self._tasks.values() if getattr(t, "created_by_user_id", None) == user_id]
+        if status:
+            items = [t for t in items if getattr(t, "status", None) == status]
+        if offset:
+            items = items[offset:]
+        if limit is not None:
+            items = items[:limit]
+        return items
+
+    def count_by_user_filtered(self, user_id, *, status=None):
+        items = [t for t in self._tasks.values() if getattr(t, "created_by_user_id", None) == user_id]
+        if status:
+            items = [t for t in items if getattr(t, "status", None) == status]
+        return len(items)
+
+    def list_by_project_filtered(self, project_id, *, status=None, limit=None, offset=0):
+        items = [t for t in self._tasks.values() if getattr(t, "project_id", None) == project_id]
+        if status:
+            items = [t for t in items if getattr(t, "status", None) == status]
+        if offset:
+            items = items[offset:]
+        if limit is not None:
+            items = items[:limit]
+        return items
+
+    def count_by_project_filtered(self, project_id, *, status=None):
+        items = [t for t in self._tasks.values() if getattr(t, "project_id", None) == project_id]
+        if status:
+            items = [t for t in items if getattr(t, "status", None) == status]
+        return len(items)
+
 
 class StubGeneratedVideoRepository:
     def __init__(self, videos=None):

tests/unit/test_speed_engine.py

@@ -0,0 +1,269 @@
+"""视频调速引擎单元测试."""
+
+import pytest
+from video_processing.speed_engine import (
+    MAX_SPEED,
+    MIN_SPEED,
+    SpeedConfig,
+    SpeedEngine,
+)
+
+# ─── SpeedConfig 解析与校验 ──────────────────────────────────
+
+
+class TestSpeedConfig:
+    def test_default_values(self):
+        config = SpeedConfig()
+        assert config.speed == 1.0
+        assert config.pitch_correct is True
+
+    def test_parse_none(self):
+        config = SpeedConfig.parse(None)
+        assert config.speed == 1.0
+        assert config.pitch_correct is True
+
+    def test_parse_empty_dict(self):
+        config = SpeedConfig.parse({})
+        assert config.speed == 1.0
+
+    def test_parse_valid_speed(self):
+        config = SpeedConfig.parse({"speed": 2.0})
+        assert config.speed == 2.0
+
+    def test_parse_pitch_correct_false(self):
+        config = SpeedConfig.parse({"pitch_correct": False})
+        assert config.pitch_correct is False
+
+    def test_parse_invalid_speed_type(self):
+        config = SpeedConfig.parse({"speed": "fast"})
+        assert config.speed == 1.0
+
+    def test_parse_invalid_pitch_type(self):
+        config = SpeedConfig.parse({"pitch_correct": "yes"})
+        assert config.pitch_correct is True
+
+    def test_clamp_below_min(self):
+        config = SpeedConfig(speed=0.1)
+        config.clamp()
+        assert config.speed == MIN_SPEED
+
+    def test_clamp_zero(self):
+        config = SpeedConfig(speed=0)
+        config.clamp()
+        assert config.speed == 1.0
+
+    def test_clamp_negative(self):
+        config = SpeedConfig(speed=-1.0)
+        config.clamp()
+        assert config.speed == 1.0
+
+    def test_clamp_above_max(self):
+        config = SpeedConfig(speed=10.0)
+        config.clamp()
+        assert config.speed == MAX_SPEED
+
+    def test_clamp_within_range(self):
+        config = SpeedConfig(speed=1.5)
+        config.clamp()
+        assert config.speed == 1.5
+
+    def test_is_original_true(self):
+        config = SpeedConfig(speed=1.0)
+        assert config.is_original is True
+
+    def test_is_original_false(self):
+        config = SpeedConfig(speed=1.5)
+        assert config.is_original is False
+
+    def test_parse_clamps_automatically(self):
+        """parse 方法应该自动调用 clamp."""
+        config = SpeedConfig.parse({"speed": 100.0})
+        assert config.speed == MAX_SPEED
+
+
+# ─── SpeedEngine 视频滤镜 ────────────────────────────────────
+
+
+class TestSpeedEngineVideoFilter:
+    def setup_method(self):
+        self.engine = SpeedEngine()
+
+    def test_original_speed_returns_empty(self):
+        config = SpeedConfig(speed=1.0)
+        assert self.engine.build_video_filter(config) == ""
+
+    def test_double_speed(self):
+        config = SpeedConfig(speed=2.0)
+        result = self.engine.build_video_filter(config)
+        assert "setpts=PTS/2.0" in result
+
+    def test_half_speed(self):
+        config = SpeedConfig(speed=0.5)
+        result = self.engine.build_video_filter(config)
+        assert "setpts=PTS/0.5" in result
+
+    def test_quarter_speed(self):
+        config = SpeedConfig(speed=0.25)
+        result = self.engine.build_video_filter(config)
+        assert "setpts=PTS/0.25" in result
+
+    def test_quad_speed(self):
+        config = SpeedConfig(speed=4.0)
+        result = self.engine.build_video_filter(config)
+        assert "setpts=PTS/4.0" in result
+
+
+# ─── SpeedEngine 音频滤镜（atempo 多级串联） ─────────────────
+
+
+class TestSpeedEngineAudioFilter:
+    def setup_method(self):
+        self.engine = SpeedEngine()
+
+    def test_original_speed_returns_empty(self):
+        config = SpeedConfig(speed=1.0)
+        assert self.engine.build_audio_filter(config) == ""
+
+    def test_double_speed_single_stage(self):
+        """2x 在 atempo 单级范围内，只需一个 atempo."""
+        config = SpeedConfig(speed=2.0)
+        result = self.engine.build_audio_filter(config)
+        assert result == "atempo=2.0000"
+
+    def test_half_speed_single_stage(self):
+        config = SpeedConfig(speed=0.5)
+        result = self.engine.build_audio_filter(config)
+        assert result == "atempo=0.5000"
+
+    def test_quad_speed_two_stages(self):
+        """4x 需要两级 atempo: 2.0 * 2.0."""
+        config = SpeedConfig(speed=4.0)
+        result = self.engine.build_audio_filter(config)
+        assert result == "atempo=2.0000,atempo=2.0000"
+
+    def test_quarter_speed_two_stages(self):
+        """0.25x 需要两级 atempo: 0.5 * 0.5."""
+        config = SpeedConfig(speed=0.25)
+        result = self.engine.build_audio_filter(config)
+        assert result == "atempo=0.5000,atempo=0.5000"
+
+    def test_triple_speed_two_stages(self):
+        """3x: 2.0 * 1.5."""
+        config = SpeedConfig(speed=3.0)
+        result = self.engine.build_audio_filter(config)
+        parts = result.split(",")
+        assert len(parts) == 2
+        assert "atempo=2.0000" in parts
+        assert "atempo=1.5000" in parts
+
+    def test_03_speed_two_stages(self):
+        """0.3x: 0.5 * 0.6."""
+        config = SpeedConfig(speed=0.3)
+        result = self.engine.build_audio_filter(config)
+        parts = result.split(",")
+        assert len(parts) == 2
+        assert "atempo=0.5000" in parts
+        assert "atempo=0.6000" in parts
+
+    def test_split_atempo_inside_range(self):
+        """0.5~2.0 范围内只返回一级."""
+        stages = SpeedEngine._split_atempo_stages(1.5)
+        assert len(stages) == 1
+        assert stages[0] == 1.5
+
+    def test_split_atempo_boundary_min(self):
+        stages = SpeedEngine._split_atempo_stages(0.5)
+        assert len(stages) == 1
+        assert stages[0] == 0.5
+
+    def test_split_atempo_boundary_max(self):
+        stages = SpeedEngine._split_atempo_stages(2.0)
+        assert len(stages) == 1
+        assert stages[0] == 2.0
+
+    def test_split_atempo_product_equals_speed(self):
+        """所有级联的乘积应该等于原速度."""
+        test_cases = [0.25, 0.3, 0.5, 0.75, 1.0, 1.5, 2.0, 3.0, 4.0]
+        for speed in test_cases:
+            stages = SpeedEngine._split_atempo_stages(speed)
+            product = 1.0
+            for s in stages:
+                product *= s
+            assert abs(product - speed) < 1e-6, f"speed={speed}, stages={stages}, product={product}"
+
+    def test_split_atempo_all_in_range(self):
+        """所有级都应该在 0.5~2.0 范围内."""
+        test_cases = [0.25, 0.3, 0.5, 0.75, 1.0, 1.5, 2.0, 3.0, 4.0]
+        for speed in test_cases:
+            stages = SpeedEngine._split_atempo_stages(speed)
+            for s in stages:
+                assert 0.5 <= s <= 2.0, f"speed={speed}, stage={s} out of range"
+
+
+# ─── SpeedEngine 时长计算 ────────────────────────────────────
+
+
+class TestSpeedEngineDuration:
+    def setup_method(self):
+        self.engine = SpeedEngine()
+
+    def test_original_speed_same_duration(self):
+        config = SpeedConfig(speed=1.0)
+        assert self.engine.adjust_duration(10.0, config) == 10.0
+
+    def test_double_speed_half_duration(self):
+        config = SpeedConfig(speed=2.0)
+        assert self.engine.adjust_duration(10.0, config) == 5.0
+
+    def test_half_speed_double_duration(self):
+        config = SpeedConfig(speed=0.5)
+        assert self.engine.adjust_duration(10.0, config) == 20.0
+
+    def test_quad_speed_quarter_duration(self):
+        config = SpeedConfig(speed=4.0)
+        assert self.engine.adjust_duration(10.0, config) == 2.5
+
+    def test_zero_duration(self):
+        config = SpeedConfig(speed=2.0)
+        assert self.engine.adjust_duration(0.0, config) == 0.0
+
+    def test_negative_duration(self):
+        config = SpeedConfig(speed=2.0)
+        assert self.engine.adjust_duration(-1.0, config) == -1.0
+
+
+# ─── SpeedEngine 便捷方法 ────────────────────────────────────
+
+
+class TestSpeedEngineHelper:
+    def setup_method(self):
+        self.engine = SpeedEngine()
+
+    def test_build_clip_speed_filter_original(self):
+        v_f, a_f, cfg = self.engine.build_clip_speed_filter(1.0)
+        assert v_f == ""
+        assert a_f == ""
+        assert cfg.speed == 1.0
+
+    def test_build_clip_speed_filter_2x(self):
+        v_f, a_f, cfg = self.engine.build_clip_speed_filter(2.0)
+        assert "setpts=PTS/2.0" in v_f
+        assert "atempo=2.0" in a_f
+        assert cfg.speed == 2.0
+
+    def test_build_clip_speed_clamped(self):
+        _, _, cfg = self.engine.build_clip_speed_filter(100.0)
+        assert cfg.speed == MAX_SPEED
+
+    def test_resolve_clip_speed_default(self):
+        assert SpeedEngine.resolve_clip_speed({}) == 1.0
+        assert SpeedEngine.resolve_clip_speed(None) == 1.0
+
+    def test_resolve_clip_speed_zero_uses_global(self):
+        assert SpeedEngine.resolve_clip_speed({"playback_speed": 0}, 1.5) == 1.5
+
+    def test_resolve_clip_speed_custom(self):
+        assert SpeedEngine.resolve_clip_speed({"playback_speed": 2.0}) == 2.0
+
+    def test_resolve_clip_speed_invalid_type(self):
+        assert SpeedEngine.resolve_clip_speed({"playback_speed": "fast"}) == 1.0

tests/unit/test_transition_engine.py

@@ -0,0 +1,484 @@
+"""转场特效引擎单测 — Phase 8 智能增强."""
+
+from __future__ import annotations
+
+import pytest
+from video_processing.transition_engine import (
+    CUT_TRANSITION,
+    DEFAULT_TRANSITION_DURATION,
+    MAX_TRANSITION_DURATION,
+    MIN_TRANSITION_DURATION,
+    TransitionConfig,
+    TransitionEngine,
+    TransitionType,
+    _normalize_transition_name,
+)
+
+# ── TransitionType 枚举测试 ──────────────────────────────────────────────────
+
+
+class TestTransitionType:
+    """TransitionType 枚举测试."""
+
+    def test_all_supported_count(self):
+        """支持的转场类型数量（不含cut）."""
+        supported = TransitionType.all_supported()
+        # 至少 8 种：fade, dissolve, slide*4, zoom, wipe*4, circlecrop, rectcrop
+        assert len(supported) >= 8
+        assert "fade" in supported
+        assert "dissolve" in supported
+        assert "zoom" in supported
+        assert "circlecrop" in supported
+        assert "rectcrop" in supported
+
+    def test_slide_directions(self):
+        """四个方向的滑入转场都支持."""
+        assert TransitionType.is_supported("slideleft")
+        assert TransitionType.is_supported("slideright")
+        assert TransitionType.is_supported("slideup")
+        assert TransitionType.is_supported("slidedown")
+
+    def test_wipe_directions(self):
+        """四个方向的擦除转场都支持."""
+        assert TransitionType.is_supported("wipeleft")
+        assert TransitionType.is_supported("wiperight")
+        assert TransitionType.is_supported("wipeup")
+        assert TransitionType.is_supported("wipedown")
+
+    def test_is_supported_case_insensitive(self):
+        """大小写不敏感."""
+        assert TransitionType.is_supported("FADE")
+        assert TransitionType.is_supported("Fade")
+        assert TransitionType.is_supported("fade")
+
+    def test_is_supported_with_underscores(self):
+        """下划线不影响判断."""
+        assert TransitionType.is_supported("slide_left")
+        assert TransitionType.is_supported("slide-left")
+
+    def test_is_supported_aliases(self):
+        """别名支持."""
+        assert TransitionType.is_supported("crossfade")
+        assert TransitionType.is_supported("dissolve")
+        assert TransitionType.is_supported("zoomin")
+        assert TransitionType.is_supported("wipe")
+
+    def test_unsupported_transition(self):
+        """不支持的转场返回 False."""
+        assert not TransitionType.is_supported("nonexistent_effect")
+        assert not TransitionType.is_supported("random_stuff")
+        assert not TransitionType.is_supported("")
+
+    def test_cut_not_in_supported(self):
+        """硬切不在"支持的转场效果"列表中（它不是特效）."""
+        supported = TransitionType.all_supported()
+        assert "cut" not in supported
+
+
+# ── 名称标准化测试 ────────────────────────────────────────────────────────────
+
+
+class TestNormalizeTransitionName:
+    """名称标准化函数测试."""
+
+    def test_lowercase(self):
+        """大写转小写."""
+        assert _normalize_transition_name("FADE") == "fade"
+        assert _normalize_transition_name("Fade") == "fade"
+
+    def test_remove_underscores(self):
+        """移除下划线."""
+        assert _normalize_transition_name("slide_left") == "slideleft"
+        assert _normalize_transition_name("slide_up") == "slideup"
+
+    def test_remove_hyphens(self):
+        """移除连字符."""
+        assert _normalize_transition_name("slide-left") == "slideleft"
+
+    def test_mixed(self):
+        """混合情况."""
+        assert _normalize_transition_name("Slide_Left") == "slideleft"
+        assert _normalize_transition_name("FADE-IN") == "fadein"
+
+
+# ── TransitionConfig 测试 ────────────────────────────────────────────────────
+
+
+class TestTransitionConfig:
+    """TransitionConfig 配置解析测试."""
+
+    # ── 默认值 ──
+
+    def test_default_config(self):
+        """默认配置是硬切."""
+        cfg = TransitionConfig.parse()
+        assert cfg.effect == CUT_TRANSITION
+        assert cfg.duration == DEFAULT_TRANSITION_DURATION
+        assert cfg.is_cut is True
+
+    def test_none_effect(self):
+        """None effect 降级为 cut."""
+        cfg = TransitionConfig.parse(effect=None)
+        assert cfg.effect == CUT_TRANSITION
+        assert cfg.is_cut is True
+
+    def test_empty_effect(self):
+        """空字符串 effect 降级为 cut."""
+        cfg = TransitionConfig.parse(effect="")
+        assert cfg.effect == CUT_TRANSITION
+        assert cfg.is_cut is True
+
+    # ── 有效转场类型 ──
+
+    def test_fade_effect(self):
+        """fade 转场."""
+        cfg = TransitionConfig.parse(effect="fade")
+        assert cfg.effect == "fade"
+        assert cfg.is_cut is False
+        assert cfg.ffmpeg_transition == "fade"
+
+    def test_dissolve_effect(self):
+        """dissolve 转场."""
+        cfg = TransitionConfig.parse(effect="dissolve")
+        assert cfg.effect == "dissolve"
+        assert cfg.ffmpeg_transition == "dissolve"
+
+    def test_zoom_effect(self):
+        """zoom 转场 → FFmpeg zoomin."""
+        cfg = TransitionConfig.parse(effect="zoom")
+        assert cfg.effect == "zoom"
+        assert cfg.ffmpeg_transition == "zoomin"
+
+    def test_slide_left_alias(self):
+        """slide_left 别名."""
+        cfg = TransitionConfig.parse(effect="slide_left")
+        assert cfg.effect == "slideleft"
+        assert cfg.ffmpeg_transition == "slideleft"
+
+    def test_wipe_alias(self):
+        """wipe 别名 → 默认向左擦."""
+        cfg = TransitionConfig.parse(effect="wipe")
+        assert cfg.effect == "wipeleft"
+        assert cfg.ffmpeg_transition == "wipeleft"
+
+    def test_circlecrop_effect(self):
+        """圆形扩散转场."""
+        cfg = TransitionConfig.parse(effect="circlecrop")
+        assert cfg.effect == "circlecrop"
+        assert cfg.ffmpeg_transition == "circlecrop"
+
+    def test_rectcrop_effect(self):
+        """矩形扩散转场."""
+        cfg = TransitionConfig.parse(effect="rectcrop")
+        assert cfg.effect == "rectcrop"
+        assert cfg.ffmpeg_transition == "rectcrop"
+
+    # ── 降级策略 ──
+
+    def test_unsupported_fallback_to_cut(self):
+        """不支持的转场自动降级为硬切，不阻断渲染."""
+        cfg = TransitionConfig.parse(effect="nonexistent_effect")
+        assert cfg.effect == CUT_TRANSITION
+        assert cfg.is_cut is True
+
+    def test_unsupported_whitespace_fallback(self):
+        """带空格的不支持转场也降级."""
+        cfg = TransitionConfig.parse(effect="  bad effect  ")
+        assert cfg.effect == CUT_TRANSITION
+
+    # ── 时长边界校验 ──
+
+    def test_default_duration(self):
+        """默认时长 0.5s."""
+        cfg = TransitionConfig.parse(effect="fade")
+        assert cfg.duration == 0.5
+
+    def test_duration_within_range(self):
+        """正常范围内的时长."""
+        cfg = TransitionConfig.parse(effect="fade", duration=1.0)
+        assert cfg.duration == 1.0
+
+    def test_duration_min_boundary(self):
+        """最小值边界."""
+        cfg = TransitionConfig.parse(effect="fade", duration=MIN_TRANSITION_DURATION)
+        assert cfg.duration == MIN_TRANSITION_DURATION
+
+    def test_duration_max_boundary(self):
+        """最大值边界."""
+        cfg = TransitionConfig.parse(effect="fade", duration=MAX_TRANSITION_DURATION)
+        assert cfg.duration == MAX_TRANSITION_DURATION
+
+    def test_duration_below_min_clamped(self):
+        """低于最小值的时长被钳制."""
+        cfg = TransitionConfig.parse(effect="fade", duration=0.1)
+        assert cfg.duration == MIN_TRANSITION_DURATION
+        assert cfg.duration >= MIN_TRANSITION_DURATION
+
+    def test_duration_above_max_clamped(self):
+        """高于最大值的时长被钳制."""
+        cfg = TransitionConfig.parse(effect="fade", duration=5.0)
+        assert cfg.duration == MAX_TRANSITION_DURATION
+        assert cfg.duration <= MAX_TRANSITION_DURATION
+
+    def test_duration_zero_default_for_effect(self):
+        """有转场效果但 duration=0 时使用默认值."""
+        # 0.0 会被当作小于最小值钳制到 0.3
+        cfg = TransitionConfig.parse(effect="fade", duration=0.0)
+        assert cfg.duration == MIN_TRANSITION_DURATION
+
+    def test_duration_negative_clamped(self):
+        """负时长被钳制到最小值."""
+        cfg = TransitionConfig.parse(effect="fade", duration=-1.0)
+        assert cfg.duration == MIN_TRANSITION_DURATION
+
+    def test_duration_none_uses_default(self):
+        """None duration 使用默认值."""
+        cfg = TransitionConfig.parse(effect="fade", duration=None)
+        assert cfg.duration == DEFAULT_TRANSITION_DURATION
+
+    def test_duration_invalid_type(self):
+        """无效类型的时长使用默认值."""
+        cfg = TransitionConfig.parse(effect="fade", duration="abc")  # type: ignore
+        assert cfg.duration == DEFAULT_TRANSITION_DURATION
+
+    # ── cut 的 ffmpeg_transition ──
+
+    def test_cut_ffmpeg_transition_empty(self):
+        """硬切没有对应的 FFmpeg xfade transition."""
+        cfg = TransitionConfig.parse(effect="cut")
+        assert cfg.ffmpeg_transition == ""
+
+
+# ── TransitionEngine 测试 ────────────────────────────────────────────────────
+
+
+class TestTransitionEngine:
+    """TransitionEngine 转场引擎测试."""
+
+    def test_default_engine(self):
+        """默认引擎初始化."""
+        engine = TransitionEngine()
+        assert engine is not None
+
+    def test_custom_default_duration(self):
+        """自定义默认时长."""
+        engine = TransitionEngine(default_duration=1.0)
+        cfg = engine.resolve_config(effect="fade")
+        assert cfg.duration == 1.0
+
+    def test_resolve_config_fade(self):
+        """解析 fade 配置."""
+        engine = TransitionEngine()
+        cfg = engine.resolve_config(effect="fade", duration=0.8)
+        assert cfg.effect == "fade"
+        assert cfg.duration == 0.8
+
+    def test_resolve_config_fallback(self):
+        """不支持的转场降级."""
+        engine = TransitionEngine()
+        cfg = engine.resolve_config(effect="unknown_effect")
+        assert cfg.effect == CUT_TRANSITION
+        assert cfg.is_cut is True
+
+    def test_resolve_config_duration_clamp(self):
+        """时长边界钳制."""
+        engine = TransitionEngine()
+        cfg = engine.resolve_config(effect="fade", duration=3.0)
+        assert cfg.duration == MAX_TRANSITION_DURATION
+
+    # ── 批量解析 ──
+
+    def test_resolve_clip_transitions_all_valid(self):
+        """批量解析全部有效转场."""
+        engine = TransitionEngine()
+        configs = engine.resolve_clip_transitions(["cut", "fade", "dissolve", "slideleft"])
+        assert len(configs) == 4
+        assert configs[0].effect == "cut"
+        assert configs[0].is_cut is True
+        assert configs[1].effect == "fade"
+        assert configs[2].effect == "dissolve"
+        assert configs[3].effect == "slideleft"
+
+    def test_resolve_clip_transitions_with_fallback(self):
+        """批量解析包含不支持的转场，自动降级."""
+        engine = TransitionEngine()
+        configs = engine.resolve_clip_transitions(["fade", "bad_effect", "dissolve", "worse_effect"])
+        assert len(configs) == 4
+        assert configs[0].effect == "fade"
+        assert configs[1].effect == "cut"  # 降级
+        assert configs[2].effect == "dissolve"
+        assert configs[3].effect == "cut"  # 降级
+
+    def test_resolve_clip_transitions_with_durations(self):
+        """带时长校验的批量解析（转场时长不超过片段时长的一半）."""
+        engine = TransitionEngine(default_duration=1.0)
+        # 片段只有 1.0s，转场时长被限制在 0.5s
+        configs = engine.resolve_clip_transitions(
+            ["fade", "dissolve"],
+            clip_durations=[1.0, 1.0],
+        )
+        assert len(configs) == 2
+        # 1.0s 默认值超过了片段时长的一半 (0.5s)，所以被钳制
+        assert configs[0].duration <= 0.5
+        assert configs[1].duration <= 0.5
+
+    def test_resolve_clip_transitions_short_clip_min_bound(self):
+        """超短片段的转场时长至少为最小值."""
+        engine = TransitionEngine()
+        configs = engine.resolve_clip_transitions(
+            ["fade"],
+            clip_durations=[0.1],  # 极短片段
+        )
+        assert len(configs) == 1
+        # 0.1 * 0.5 = 0.05 < MIN_TRANSITION_DURATION，所以用最小值
+        assert configs[0].duration == MIN_TRANSITION_DURATION
+
+    # ── xfade 滤镜链构建 ──
+
+    def test_build_xfade_single_clip(self):
+        """单 clip 直接 copy."""
+        engine = TransitionEngine()
+        filter_str, total_dur = engine.build_xfade_chain(
+            clip_durations=[5.0],
+            clip_video_labels=["v0"],
+            transitions=["cut"],
+            output_label="outv",
+        )
+        assert "copy" in filter_str
+        assert "[outv]" in filter_str
+        assert total_dur == pytest.approx(5.0, abs=0.01)
+
+    def test_build_xfade_two_clips_fade(self):
+        """两个 clip 之间 fade 转场."""
+        engine = TransitionEngine()
+        filter_str, total_dur = engine.build_xfade_chain(
+            clip_durations=[3.0, 4.0],
+            clip_video_labels=["v0", "v1"],
+            transitions=["cut", "fade"],
+            output_label="outv",
+        )
+        assert "xfade" in filter_str
+        assert "transition=fade" in filter_str
+        # 总时长 = 3 + 4 - transition_duration (0.5) = 6.5
+        assert total_dur == pytest.approx(6.5, abs=0.1)
+
+    def test_build_xfade_three_clips_mixed(self):
+        """三个 clip 混合转场."""
+        engine = TransitionEngine()
+        filter_str, total_dur = engine.build_xfade_chain(
+            clip_durations=[3.0, 4.0, 5.0],
+            clip_video_labels=["v0", "v1", "v2"],
+            transitions=["cut", "fade", "dissolve"],
+            output_label="outv",
+        )
+        assert "xfade" in filter_str
+        assert "transition=fade" in filter_str
+        assert "transition=dissolve" in filter_str
+        # 总时长 ≈ 3 + 4 + 5 - 2 * 0.5 = 11.0
+        assert total_dur == pytest.approx(11.0, abs=0.2)
+
+    def test_build_xfade_with_custom_duration(self):
+        """自定义转场时长."""
+        engine = TransitionEngine(default_duration=0.5)
+        filter_str, total_dur = engine.build_xfade_chain(
+            clip_durations=[3.0, 4.0],
+            clip_video_labels=["v0", "v1"],
+            transitions=["cut", "fade"],
+            transition_duration=1.0,
+            output_label="outv",
+        )
+        assert "xfade" in filter_str
+        # 总时长 = 3 + 4 - 1.0 = 6.0
+        assert total_dur == pytest.approx(6.0, abs=0.1)
+
+    def test_build_xfade_zoom_transition(self):
+        """zoom 转场滤镜构建."""
+        engine = TransitionEngine()
+        filter_str, _ = engine.build_xfade_chain(
+            clip_durations=[3.0, 4.0],
+            clip_video_labels=["v0", "v1"],
+            transitions=["cut", "zoom"],
+        )
+        assert "xfade" in filter_str
+        assert "transition=zoomin" in filter_str  # zoom → zoomin
+
+    def test_build_xfade_slide_directions(self):
+        """四个方向的滑入转场."""
+        engine = TransitionEngine()
+        for direction in ["slideleft", "slideright", "slideup", "slidedown"]:
+            filter_str, _ = engine.build_xfade_chain(
+                clip_durations=[3.0, 4.0],
+                clip_video_labels=["v0", "v1"],
+                transitions=["cut", direction],
+            )
+            assert f"transition={direction}" in filter_str
+
+    def test_build_xfade_fallback_transition(self):
+        """不支持的转场降级后构建（降级为cut，等效于极短fade）."""
+        engine = TransitionEngine()
+        # bad_effect 降级为 cut，cut 使用极短转场
+        filter_str, _ = engine.build_xfade_chain(
+            clip_durations=[3.0, 4.0],
+            clip_video_labels=["v0", "v1"],
+            transitions=["cut", "bad_effect"],
+        )
+        # 降级后是 cut，cut 会被 xfade 层映射为 fade（因为 cut 不在 map 里）
+        # 但时长会很短，所以仍然有 xfade
+        assert "xfade" in filter_str
+
+    # ── 支持的转场列表 ──
+
+    def test_supported_transitions_list(self):
+        """获取支持的转场列表（给 API 用）."""
+        transitions = TransitionEngine.supported_transitions()
+        assert len(transitions) >= 10  # cut + 至少 9 种特效
+        # 检查结构
+        for t in transitions:
+            assert "name" in t
+            assert "display_name" in t
+            assert "category" in t
+        # 检查分类
+        names = [t["name"] for t in transitions]
+        assert "cut" in names
+        assert "fade" in names
+        assert "zoom" in names
+        assert "circlecrop" in names
+
+
+# ── 集成测试：与 UnifiedRenderService 协作 ────────────────────────────────────
+
+
+class TestTransitionIntegration:
+    """转场引擎与统一渲染服务的集成测试."""
+
+    def test_unified_render_service_has_transition_engine(self):
+        """UnifiedRenderService 内部有 TransitionEngine 实例."""
+        from pathlib import Path
+
+        from video_processing.unified_render_service import UnifiedRenderService
+
+        # 构造最小化的服务实例
+        service = UnifiedRenderService(
+            plan=None,
+            clips=[],
+            asset_path_map={},
+            work_dir=Path("/tmp"),
+        )
+        assert hasattr(service, "_transition_engine")
+        assert isinstance(service._transition_engine, TransitionEngine)
+
+    def test_resolved_clip_has_transition_duration(self):
+        """ResolvedClip 有 transition_duration 字段."""
+        from video_processing.unified_render_service import ResolvedClip
+
+        rc = ResolvedClip(
+            clip_id="test",
+            asset_id="asset1",
+            local_path=__file__,  # 随便一个存在的路径
+            clip_type="main",
+            order=0,
+            transition_effect="fade",
+            transition_duration=0.8,
+        )
+        assert rc.transition_duration == 0.8
+        assert rc.transition_effect == "fade"

tests/unit/test_trim_engine.py

@@ -0,0 +1,268 @@
+"""裁剪引擎单元测试."""
+
+import sys
+import unittest
+from pathlib import Path
+
+# 确保 apps/worker 在路径中
+sys.path.insert(0, str(Path(__file__).parent.parent.parent / "apps" / "worker"))
+
+from video_processing.trim_engine import (
+    MIN_TRIM_DURATION,
+    TrimConfig,
+    TrimEngine,
+    TrimSegment,
+    extract_trim_from_clip_config,
+)
+
+
+class TestTrimConfig(unittest.TestCase):
+    """TrimConfig 单元测试."""
+
+    def test_from_dict_none(self):
+        """空字典返回 None（不裁剪）."""
+        self.assertIsNone(TrimConfig.from_dict(None))
+        self.assertIsNone(TrimConfig.from_dict({}))
+
+    def test_from_dict_with_start(self):
+        """只有 start_time."""
+        cfg = TrimConfig.from_dict({"start_time": 5.0})
+        self.assertIsNotNone(cfg)
+        self.assertEqual(cfg.start_time, 5.0)
+        self.assertEqual(cfg.end_time, 0.0)
+        self.assertEqual(cfg.duration, 0.0)
+
+    def test_from_dict_with_duration(self):
+        """只有 duration."""
+        cfg = TrimConfig.from_dict({"duration": 10.0})
+        self.assertIsNotNone(cfg)
+        self.assertEqual(cfg.start_time, 0.0)
+        self.assertEqual(cfg.duration, 10.0)
+
+    def test_resolve_start_and_end(self):
+        """start + end 推导 duration."""
+        cfg = TrimConfig(start_time=5.0, end_time=15.0)
+        resolved = cfg.validate_and_resolve(asset_duration=30.0)
+        self.assertEqual(resolved.start_time, 5.0)
+        self.assertEqual(resolved.end_time, 15.0)
+        self.assertAlmostEqual(resolved.duration, 10.0, places=3)
+        self.assertTrue(resolved.is_valid)
+
+    def test_resolve_start_and_duration(self):
+        """start + duration 推导 end."""
+        cfg = TrimConfig(start_time=5.0, duration=10.0)
+        resolved = cfg.validate_and_resolve(asset_duration=30.0)
+        self.assertEqual(resolved.start_time, 5.0)
+        self.assertAlmostEqual(resolved.end_time, 15.0, places=3)
+        self.assertEqual(resolved.duration, 10.0)
+
+    def test_resolve_end_and_duration(self):
+        """end + duration 推导 start."""
+        cfg = TrimConfig(end_time=20.0, duration=8.0)
+        resolved = cfg.validate_and_resolve(asset_duration=30.0)
+        self.assertAlmostEqual(resolved.start_time, 12.0, places=3)
+        self.assertEqual(resolved.end_time, 20.0)
+        self.assertEqual(resolved.duration, 8.0)
+
+    def test_resolve_only_start(self):
+        """只有 start → 取到末尾."""
+        cfg = TrimConfig(start_time=10.0)
+        resolved = cfg.validate_and_resolve(asset_duration=30.0)
+        self.assertEqual(resolved.start_time, 10.0)
+        self.assertEqual(resolved.end_time, 30.0)
+        self.assertAlmostEqual(resolved.duration, 20.0, places=3)
+
+    def test_resolve_only_duration(self):
+        """只有 duration → 从开头取."""
+        cfg = TrimConfig(duration=15.0)
+        resolved = cfg.validate_and_resolve(asset_duration=30.0)
+        self.assertEqual(resolved.start_time, 0.0)
+        self.assertAlmostEqual(resolved.end_time, 15.0, places=3)
+        self.assertEqual(resolved.duration, 15.0)
+
+    def test_boundary_clamp_end(self):
+        """end 超出素材时长 → 钳制."""
+        cfg = TrimConfig(start_time=5.0, duration=30.0)
+        resolved = cfg.validate_and_resolve(asset_duration=20.0)
+        self.assertEqual(resolved.start_time, 5.0)
+        self.assertEqual(resolved.end_time, 20.0)
+        self.assertAlmostEqual(resolved.duration, 15.0, places=3)
+
+    def test_boundary_clamp_start_negative(self):
+        """start 为负 → 钳制到 0."""
+        cfg = TrimConfig(start_time=-5.0, duration=10.0)
+        resolved = cfg.validate_and_resolve(asset_duration=30.0)
+        self.assertEqual(resolved.start_time, 0.0)
+        self.assertAlmostEqual(resolved.end_time, 10.0, places=3)
+        self.assertEqual(resolved.duration, 10.0)
+
+    def test_boundary_start_past_end(self):
+        """start 超过素材总时长 → 钳制到末尾最小片段."""
+        cfg = TrimConfig(start_time=50.0, duration=5.0)
+        resolved = cfg.validate_and_resolve(asset_duration=30.0)
+        self.assertTrue(resolved.start_time < 30.0)
+        self.assertEqual(resolved.end_time, 30.0)
+        self.assertTrue(resolved.duration >= MIN_TRIM_DURATION)
+
+    def test_invalid_end_before_start(self):
+        """end <= start → 无效."""
+        cfg = TrimConfig(start_time=15.0, end_time=10.0)
+        resolved = cfg.validate_and_resolve(asset_duration=30.0)
+        self.assertFalse(resolved.is_valid)
+
+    def test_zero_duration_invalid(self):
+        """duration 为 0 → 无效."""
+        cfg = TrimConfig(start_time=5.0, duration=0.0)
+        resolved = cfg.validate_and_resolve(asset_duration=30.0)
+        # 只有 start 没有 duration → 会被推导为取到末尾
+        self.assertTrue(resolved.is_valid)
+        self.assertEqual(resolved.end_time, 30.0)
+
+    def test_is_noop(self):
+        """is_noop 判断."""
+        noop = TrimConfig(start_time=0.0, end_time=0.0, duration=0.0)
+        self.assertTrue(noop.is_noop)
+
+        not_noop = TrimConfig(start_time=5.0, duration=10.0)
+        self.assertFalse(not_noop.is_noop)
+
+    def test_zero_asset_duration(self):
+        """素材时长为 0 → 不裁剪."""
+        cfg = TrimConfig(start_time=5.0, duration=10.0)
+        resolved = cfg.validate_and_resolve(asset_duration=0.0)
+        self.assertTrue(resolved.is_noop)
+
+    def test_all_three_params_use_start_duration(self):
+        """三个参数都给了 → 以 start + duration 为准."""
+        cfg = TrimConfig(start_time=5.0, end_time=20.0, duration=8.0)
+        resolved = cfg.validate_and_resolve(asset_duration=30.0)
+        # validate_and_resolve 中 start+end 优先于 start+duration
+        # 因为先检查的是 start>0 and end>0
+        self.assertAlmostEqual(resolved.duration, 15.0, places=3)
+
+
+class TestTrimEngine(unittest.TestCase):
+    """TrimEngine 单元测试."""
+
+    def test_build_video_trim_with_start_and_duration(self):
+        """视频裁剪：start + duration."""
+        trim = TrimConfig(start_time=10.0, duration=5.0)
+        result = TrimEngine.build_video_trim_filter("[0:v]", trim, "[v0]")
+        self.assertIn("trim=start=10.000:duration=5.000", result)
+        self.assertIn("setpts=PTS-STARTPTS", result)
+        self.assertTrue(result.startswith("[0:v]"))
+        self.assertTrue(result.endswith("[v0]"))
+
+    def test_build_video_trim_duration_only(self):
+        """视频裁剪：只有 duration."""
+        trim = TrimConfig(start_time=0.0, duration=8.0)
+        result = TrimEngine.build_video_trim_filter("[0:v]", trim, "[v0]")
+        self.assertIn("trim=duration=8.000", result)
+        self.assertNotIn("start=", result.split("setpts")[0])
+
+    def test_build_audio_trim_with_start(self):
+        """音频裁剪：start + duration."""
+        trim = TrimConfig(start_time=3.0, duration=7.0)
+        result = TrimEngine.build_audio_trim_filter("[0:a]", trim, "[a0]")
+        self.assertIn("atrim=start=3.000:duration=7.000", result)
+        self.assertIn("asetpts=PTS-STARTPTS", result)
+
+    def test_build_audio_trim_noop(self):
+        """音频裁剪：noop."""
+        trim = TrimConfig(start_time=0.0, end_time=0.0, duration=0.0)
+        result = TrimEngine.build_audio_trim_filter("[0:a]", trim, "[a0]")
+        self.assertIn("asetpts=PTS-STARTPTS", result)
+        self.assertNotIn("atrim=", result)
+
+    def test_resolve_segments(self):
+        """多段裁剪解析."""
+        segments = [
+            TrimSegment(segment_id="s1", trim=TrimConfig(start_time=0.0, duration=5.0), order=0),
+            TrimSegment(segment_id="s2", trim=TrimConfig(start_time=10.0, duration=5.0), order=1),
+            TrimSegment(segment_id="s3", trim=TrimConfig(start_time=20.0, duration=5.0), order=2),
+        ]
+        resolved = TrimEngine.resolve_segments(segments, asset_duration=30.0)
+        self.assertEqual(len(resolved), 3)
+        self.assertEqual(resolved[0].segment_id, "s1")
+        self.assertEqual(resolved[0].trim.duration, 5.0)
+        self.assertEqual(resolved[1].segment_id, "s2")
+        self.assertEqual(resolved[1].trim.start_time, 10.0)
+        self.assertEqual(resolved[2].trim.start_time, 20.0)
+
+    def test_resolve_segments_filter_invalid(self):
+        """多段裁剪：过滤无效段."""
+        segments = [
+            TrimSegment(segment_id="good", trim=TrimConfig(start_time=0.0, duration=5.0), order=0),
+            TrimSegment(segment_id="bad", trim=TrimConfig(start_time=10.0, end_time=5.0), order=1),  # end < start
+        ]
+        resolved = TrimEngine.resolve_segments(segments, asset_duration=30.0)
+        self.assertEqual(len(resolved), 1)
+        self.assertEqual(resolved[0].segment_id, "good")
+
+    def test_resolve_segments_boundary_clamp(self):
+        """多段裁剪：边界钳制."""
+        segments = [
+            TrimSegment(segment_id="s1", trim=TrimConfig(start_time=25.0, duration=10.0), order=0),
+        ]
+        resolved = TrimEngine.resolve_segments(segments, asset_duration=30.0)
+        self.assertEqual(len(resolved), 1)
+        self.assertEqual(resolved[0].trim.end_time, 30.0)
+        self.assertAlmostEqual(resolved[0].trim.duration, 5.0, places=3)
+
+    def test_parse_segments_from_list(self):
+        """从 config 解析多段配置."""
+        config = {
+            "trim_segments": [
+                {"segment_id": "intro", "start_time": 0, "duration": 3, "order": 0},
+                {"segment_id": "highlight", "start_time": 10, "duration": 5, "order": 1},
+                {"segment_id": "outro", "start_time": 50, "duration": 3, "order": 2},
+            ]
+        }
+        segments = TrimEngine.parse_segments_from_config(config)
+        self.assertEqual(len(segments), 3)
+        self.assertEqual(segments[0].segment_id, "intro")
+        self.assertEqual(segments[1].trim.start_time, 10.0)
+        self.assertEqual(segments[2].trim.duration, 3.0)
+
+    def test_parse_segments_empty(self):
+        """无裁剪配置 → 空列表."""
+        self.assertEqual(TrimEngine.parse_segments_from_config(None), [])
+        self.assertEqual(TrimEngine.parse_segments_from_config({}), [])
+
+    def test_parse_single_trim_legacy(self):
+        """旧格式单段裁剪（trim_start/trim_duration）."""
+        config = {"trim_start": 5.0, "trim_duration": 10.0}
+        segments = TrimEngine.parse_segments_from_config(config)
+        self.assertEqual(len(segments), 1)
+        self.assertEqual(segments[0].trim.start_time, 5.0)
+        self.assertEqual(segments[0].trim.duration, 10.0)
+
+
+class TestExtractTrimFromClipConfig(unittest.TestCase):
+    """extract_trim_from_clip_config 单元测试."""
+
+    def test_trim_subdict(self):
+        """trim 子字典."""
+        config = {"trim": {"start_time": 5.0, "duration": 10.0}}
+        result = extract_trim_from_clip_config(config)
+        self.assertIsNotNone(result)
+        self.assertEqual(result.start_time, 5.0)
+        self.assertEqual(result.duration, 10.0)
+
+    def test_flat_fields(self):
+        """扁平字段（trim_start/trim_end/trim_duration）."""
+        config = {"trim_start": 2.0, "trim_end": 8.0}
+        result = extract_trim_from_clip_config(config)
+        self.assertIsNotNone(result)
+        self.assertEqual(result.start_time, 2.0)
+        self.assertEqual(result.end_time, 8.0)
+
+    def test_no_trim(self):
+        """无裁剪配置."""
+        self.assertIsNone(extract_trim_from_clip_config(None))
+        self.assertIsNone(extract_trim_from_clip_config({}))
+        self.assertIsNone(extract_trim_from_clip_config({"other": "value"}))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/unit/test_watermark_intro_outro.py

@@ -0,0 +1,344 @@
+"""水印 + 片头片尾引擎单元测试."""
+
+import sys
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent.parent / "apps" / "worker"))
+
+from video_processing.intro_outro_engine import (
+    IntroOutroConfig,
+    IntroOutroEngine,
+)
+from video_processing.watermark_engine import (
+    WATERMARK_POSITIONS,
+    WatermarkConfig,
+    WatermarkEngine,
+)
+
+
+class TestWatermarkConfig(unittest.TestCase):
+    """WatermarkConfig 单元测试."""
+
+    def test_from_dict_none_disabled(self):
+        """空配置或未启用 → None."""
+        self.assertIsNone(WatermarkConfig.from_dict(None))
+        self.assertIsNone(WatermarkConfig.from_dict({}))
+        self.assertIsNone(WatermarkConfig.from_dict({"enabled": False}))
+
+    def test_from_dict_text_mode(self):
+        """文字水印模式."""
+        cfg = WatermarkConfig.from_dict({
+            "enabled": True,
+            "mode": "text",
+            "text": "hello world",
+            "position": "top_left",
+        })
+        self.assertIsNotNone(cfg)
+        self.assertEqual(cfg.mode, "text")
+        self.assertEqual(cfg.text, "hello world")
+        self.assertEqual(cfg.position, "top_left")
+
+    def test_from_dict_image_missing_path(self):
+        """图片水印缺路径 → None."""
+        cfg = WatermarkConfig.from_dict({
+            "enabled": True,
+            "mode": "image",
+        })
+        self.assertIsNone(cfg)
+
+    def test_from_dict_text_missing_text(self):
+        """文字水印缺文字 → None."""
+        cfg = WatermarkConfig.from_dict({
+            "enabled": True,
+            "mode": "text",
+        })
+        self.assertIsNone(cfg)
+
+    def test_validate_text_valid(self):
+        """文字水印合法配置."""
+        cfg = WatermarkConfig(
+            mode="text",
+            text="test",
+            position="bottom_right",
+        )
+        ok, err = cfg.validate()
+        self.assertTrue(ok)
+        self.assertEqual(err, "")
+
+    def test_validate_invalid_position(self):
+        """非法位置."""
+        cfg = WatermarkConfig(mode="text", text="test", position="invalid")
+        ok, err = cfg.validate()
+        self.assertFalse(ok)
+        self.assertIn("不支持的位置", err)
+
+    def test_validate_opacity_out_of_range(self):
+        """透明度超范围."""
+        cfg = WatermarkConfig(mode="text", text="test", opacity=1.5)
+        ok, err = cfg.validate()
+        self.assertFalse(ok)
+
+    def test_validate_image_missing_path(self):
+        """图片水印缺路径."""
+        cfg = WatermarkConfig(mode="image")
+        ok, err = cfg.validate()
+        self.assertFalse(ok)
+
+
+class TestWatermarkEnginePosition(unittest.TestCase):
+    """水印位置计算单元测试."""
+
+    def setUp(self):
+        self.out_w = 1920
+        self.out_h = 1080
+        self.wm_w = 200
+        self.wm_h = 100
+        self.mx = 20
+        self.my = 20
+
+    def test_top_left(self):
+        x, y = WatermarkEngine.calc_position(
+            "top_left", self.out_w, self.out_h, self.wm_w, self.wm_h, self.mx, self.my
+        )
+        self.assertEqual(x, 20)
+        self.assertEqual(y, 20)
+
+    def test_top_center(self):
+        x, y = WatermarkEngine.calc_position(
+            "top_center", self.out_w, self.out_h, self.wm_w, self.wm_h, self.mx, self.my
+        )
+        self.assertEqual(x, (1920 - 200) // 2)
+        self.assertEqual(y, 20)
+
+    def test_top_right(self):
+        x, y = WatermarkEngine.calc_position(
+            "top_right", self.out_w, self.out_h, self.wm_w, self.wm_h, self.mx, self.my
+        )
+        self.assertEqual(x, 1920 - 200 - 20)
+        self.assertEqual(y, 20)
+
+    def test_center_left(self):
+        x, y = WatermarkEngine.calc_position(
+            "center_left", self.out_w, self.out_h, self.wm_w, self.wm_h, self.mx, self.my
+        )
+        self.assertEqual(x, 20)
+        self.assertEqual(y, (1080 - 100) // 2)
+
+    def test_center(self):
+        x, y = WatermarkEngine.calc_position(
+            "center", self.out_w, self.out_h, self.wm_w, self.wm_h, self.mx, self.my
+        )
+        self.assertEqual(x, (1920 - 200) // 2)
+        self.assertEqual(y, (1080 - 100) // 2)
+
+    def test_center_right(self):
+        x, y = WatermarkEngine.calc_position(
+            "center_right", self.out_w, self.out_h, self.wm_w, self.wm_h, self.mx, self.my
+        )
+        self.assertEqual(x, 1920 - 200 - 20)
+        self.assertEqual(y, (1080 - 100) // 2)
+
+    def test_bottom_left(self):
+        x, y = WatermarkEngine.calc_position(
+            "bottom_left", self.out_w, self.out_h, self.wm_w, self.wm_h, self.mx, self.my
+        )
+        self.assertEqual(x, 20)
+        self.assertEqual(y, 1080 - 100 - 20)
+
+    def test_bottom_center(self):
+        x, y = WatermarkEngine.calc_position(
+            "bottom_center", self.out_w, self.out_h, self.wm_w, self.wm_h, self.mx, self.my
+        )
+        self.assertEqual(x, (1920 - 200) // 2)
+        self.assertEqual(y, 1080 - 100 - 20)
+
+    def test_bottom_right(self):
+        x, y = WatermarkEngine.calc_position(
+            "bottom_right", self.out_w, self.out_h, self.wm_w, self.wm_h, self.mx, self.my
+        )
+        self.assertEqual(x, 1920 - 200 - 20)
+        self.assertEqual(y, 1080 - 100 - 20)
+
+    def test_default_fallback(self):
+        """非法位置默认右下角."""
+        x, y = WatermarkEngine.calc_position(
+            "unknown", self.out_w, self.out_h, self.wm_w, self.wm_h, self.mx, self.my
+        )
+        self.assertEqual(x, 1920 - 200 - 20)
+        self.assertEqual(y, 1080 - 100 - 20)
+
+    def test_nine_positions_all_present(self):
+        """9宫格位置都有定义."""
+        self.assertEqual(len(WATERMARK_POSITIONS), 9)
+
+
+class TestWatermarkEngineFilters(unittest.TestCase):
+    """水印滤镜构建单元测试."""
+
+    def test_text_watermark_filter(self):
+        """文字水印滤镜构建."""
+        cfg = WatermarkConfig(
+            mode="text",
+            text="hello",
+            position="top_left",
+            font_size=24,
+            font_color="white",
+            opacity=0.8,
+            margin_x=10,
+            margin_y=10,
+        )
+        result = WatermarkEngine.build_text_watermark_filter(
+            "[in]", "[out]", cfg, 1920, 1080
+        )
+        self.assertTrue(result.startswith("[in]drawtext="))
+        self.assertIn("text='hello'", result)
+        self.assertIn("fontsize=24", result)
+        self.assertIn("fontcolor=white@0.8", result)
+        self.assertTrue(result.endswith("[out]"))
+
+    def test_text_watermark_scroll(self):
+        """滚动文字水印."""
+        cfg = WatermarkConfig(
+            mode="text",
+            text="scroll",
+            position="bottom_left",
+            scroll=True,
+            scroll_speed=60,
+        )
+        result = WatermarkEngine.build_text_watermark_filter(
+            "[in]", "[out]", cfg, 1920, 1080
+        )
+        self.assertIn("mod(60*t", result)
+
+
+class TestIntroOutroConfig(unittest.TestCase):
+    """IntroOutroConfig 单元测试."""
+
+    def test_from_dict_disabled(self):
+        """未启用 → 空配置."""
+        cfg = IntroOutroConfig.from_dict(None)
+        self.assertFalse(cfg.enabled)
+        self.assertFalse(cfg.has_intro)
+        self.assertFalse(cfg.has_outro)
+
+    def test_from_dict_intro_text(self):
+        """文字片头配置."""
+        cfg = IntroOutroConfig.from_dict({
+            "enabled": True,
+            "intro": {
+                "type": "text",
+                "title": "欢迎观看",
+                "subtitle": "精彩内容马上开始",
+                "duration": 3.0,
+                "background": "#1a1a2e",
+            },
+        })
+        self.assertTrue(cfg.enabled)
+        self.assertTrue(cfg.has_intro)
+        self.assertFalse(cfg.has_outro)
+        self.assertEqual(cfg.intro_type, "text")
+        self.assertEqual(cfg.intro_title, "欢迎观看")
+        self.assertEqual(cfg.intro_duration, 3.0)
+
+    def test_from_dict_outro_video(self):
+        """视频片尾配置."""
+        cfg = IntroOutroConfig.from_dict({
+            "enabled": True,
+            "outro": {
+                "type": "video",
+                "video_path": "/tmp/outro.mp4",
+                "duration": 5.0,
+            },
+        })
+        self.assertTrue(cfg.has_outro)
+        self.assertEqual(cfg.outro_type, "video")
+        self.assertEqual(cfg.outro_video_path, "/tmp/outro.mp4")
+
+    def test_validate_valid(self):
+        """合法配置."""
+        cfg = IntroOutroConfig(
+            enabled=True,
+            intro_type="text",
+            intro_title="标题",
+            intro_duration=3.0,
+            outro_type="text",
+            outro_title="片尾",
+            outro_duration=3.0,
+        )
+        ok, err = cfg.validate()
+        self.assertTrue(ok)
+
+    def test_validate_video_intro_missing_path(self):
+        """视频片头缺路径."""
+        cfg = IntroOutroConfig(
+            enabled=True,
+            intro_type="video",
+            intro_duration=3.0,
+        )
+        ok, err = cfg.validate()
+        self.assertFalse(ok)
+        self.assertIn("video_path", err)
+
+    def test_validate_text_intro_missing_title(self):
+        """文字片头缺标题."""
+        cfg = IntroOutroConfig(
+            enabled=True,
+            intro_type="text",
+            intro_duration=3.0,
+        )
+        ok, err = cfg.validate()
+        self.assertFalse(ok)
+
+    def test_has_intro_false_when_none(self):
+        """type=none 时 has_intro 为 False."""
+        cfg = IntroOutroConfig(enabled=True, intro_type="none")
+        self.assertFalse(cfg.has_intro)
+
+    def test_has_outro_follow_type(self):
+        """follow 类型也算有片尾."""
+        cfg = IntroOutroConfig(enabled=True, outro_type="follow", outro_title="关注")
+        self.assertTrue(cfg.has_outro)
+
+
+class TestIntroOutroEngineConcat(unittest.TestCase):
+    """片头片尾拼接单元测试."""
+
+    def test_concat_no_intro_outro(self):
+        """没有片头片尾 → 直接复制."""
+        import tempfile
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            main_video = Path(tmpdir) / "main.mp4"
+            output = Path(tmpdir) / "output.mp4"
+            # 创建空文件模拟
+            main_video.write_bytes(b"fake video data")
+
+            result = IntroOutroEngine.concat_with_intro_outro(
+                main_video, None, None, output
+            )
+            self.assertTrue(result)
+            self.assertTrue(output.exists())
+            self.assertEqual(main_video.read_bytes(), output.read_bytes())
+
+    def test_concat_intro_only_no_file(self):
+        """只有片头但文件不存在 → 直接复制主视频."""
+        import tempfile
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            main_video = Path(tmpdir) / "main.mp4"
+            output = Path(tmpdir) / "output.mp4"
+            main_video.write_bytes(b"fake data")
+
+            # intro 路径不存在
+            intro = Path(tmpdir) / "nonexistent.mp4"
+
+            result = IntroOutroEngine.concat_with_intro_outro(
+                main_video, intro, None, output
+            )
+            self.assertTrue(result)
+            self.assertTrue(output.exists())
+
+
+if __name__ == "__main__":
+    unittest.main()