fix: black/isort formatting for generation.py and test file

问题：一键生成（generate_video）任务硬编码使用 UnifiedRenderService，
完全没有接入 render_engine Feature Flag，导致灰度开关形同虚设，
无法控制新旧引擎切换。

修复：
1. 新增 _resolve_render_engine(user_id) 函数，复用 RenderEngineResolver
2. 新增 _render_with_legacy_engine() 函数，实现旧引擎等价渲染
   - 使用 filter_complex + concat 模式
   - 保持原帧率（无 fps 归一化），与旧引擎行为一致
   - 音频 192k AAC，与旧引擎一致
   - 支持 one_take / pip / voice_over / voice_pip 全部模式
3. 在 generate_video 任务入口处根据 Feature Flag 选择引擎
4. 渲染日志新增 engine 字段，便于灰度观测

单测：8 个测试覆盖 flag 各场景 + legacy 渲染验证

apps/worker/worker_app/tasks/generation.py

@@ -113,6 +113,7 @@ from video_processing.oss_helpers import (
     get_signed_download_url,
     upload_to_oss,
 )
+from video_processing.render_engine_resolver import ENGINE_LEGACY, ENGINE_UNIFIED
 from video_processing.unified_render_service import UnifiedRenderService
 
 # ── 虚拟 Plan / Clip（内存中构建，不写数据库） ────────────────────────────────
@@ -573,6 +574,148 @@ def _validate_template_exists(template_id: str) -> None:
         session.close()
 
 
+# ── 渲染引擎选择 ─────────────────────────────────────────────────────────────
+
+
+def _resolve_render_engine(user_id: str) -> str:
+    """根据 Feature Flag 决定使用哪个渲染引擎。
+
+    Returns:
+        "legacy" 或 "unified"
+    """
+    try:
+        from video_processing.render_engine_resolver import get_render_engine_resolver
+
+        resolver = get_render_engine_resolver()
+        return resolver.get_engine(user_id=user_id)
+    except Exception as exc:
+        logger.warning("获取渲染引擎配置失败，fallback 到 unified: %s", exc)
+        return ENGINE_UNIFIED
+
+
+# ── 旧引擎渲染（FFmpeg filter_complex） ────────────────────────────────────────
+
+
+def _render_with_legacy_engine(
+    task_id: str,
+    virtual_clips: list[_VirtualClip],
+    asset_path_map: dict[str, Path],
+    work_dir: Path,
+    output_path: Path,
+) -> tuple[float, int]:
+    """旧引擎渲染路径：手动构建 FFmpeg filter_complex 命令。
+
+    说明：generate_video 任务使用虚拟 clips（无 EditPlan 数据库记录），
+    因此无法直接复用 VideoComposeService。这里手动构建等价的 filter_complex
+    命令，与旧引擎行为一致（scale → crop → setpts → trim → setpts，
+    无 fps 归一化，保持原帧率）。
+
+    支持模式：one_take / pip / voice_over / voice_pip
+    - 所有模式统一走 concat 滤镜（与旧引擎多片段逻辑一致）
+
+    Returns:
+        (duration_seconds, file_size_bytes)
+    """
+    import subprocess
+
+    main_clips = [
+        c
+        for c in virtual_clips
+        if c.clip_type in ("main", "b_roll", "background")
+        or (c.clip_type == "main" and c.config.get("role") == "b_roll")
+    ]
+    if not main_clips:
+        main_clips = virtual_clips[:1]
+
+    input_args: list[str] = []
+    video_filters: list[str] = []
+    audio_filters: list[str] = []
+
+    for i, clip in enumerate(main_clips):
+        local_path = asset_path_map.get(clip.asset_id)
+        if not local_path:
+            continue
+        input_args.extend(["-i", str(local_path)])
+
+        duration = clip.duration or 0.0
+
+        # 视频滤镜：scale → crop → setpts → trim → setpts（与旧引擎一致）
+        vf = (
+            f"[{i}:v]"
+            f"scale={OUTPUT_WIDTH}:{OUTPUT_HEIGHT}:force_original_aspect_ratio=increase,"
+            f"crop={OUTPUT_WIDTH}:{OUTPUT_HEIGHT},"
+            f"setpts=PTS-STARTPTS,"
+            f"trim=0:{duration:.3f},"
+            f"setpts=PTS-STARTPTS"
+            f"[v{i}]"
+        )
+        video_filters.append(vf)
+
+        # 音频滤镜：atrim → asetpts
+        af = f"[{i}:a]atrim=0:{duration:.3f},asetpts=PTS-STARTPTS[a{i}]"
+        audio_filters.append(af)
+
+    n = len(main_clips)
+
+    if n == 1:
+        video_label = "[v0]"
+        audio_label = "[a0]"
+    else:
+        # concat 视频
+        v_inputs = "".join(f"[v{i}]" for i in range(n))
+        video_filters.append(f"{v_inputs}concat=n={n}:v=1:a=0[outv]")
+        # concat 音频
+        a_inputs = "".join(f"[a{i}]" for i in range(n))
+        audio_filters.append(f"{a_inputs}concat=n={n}:v=0:a=1[outa]")
+        video_label = "[outv]"
+        audio_label = "[outa]"
+
+    # 组装 filter_complex
+    fc_parts = video_filters + audio_filters
+    filter_complex = ";".join(fc_parts)
+
+    command = [
+        FFMPEG_BIN,
+        "-y",
+        *input_args,
+        "-filter_complex",
+        filter_complex,
+        "-map",
+        video_label,
+        "-map",
+        audio_label,
+        "-c:v",
+        "libx264",
+        "-crf",
+        "23",
+        "-preset",
+        "medium",
+        "-c:a",
+        "aac",
+        "-b:a",
+        "192k",
+        "-movflags",
+        "+faststart",
+        str(output_path),
+    ]
+
+    logger.info("[task_id=%s] [渲染] legacy 引擎 FFmpeg 开始: clips=%d", task_id, n)
+    try:
+        run_ffmpeg(command)
+    except subprocess.CalledProcessError as e:
+        logger.error(
+            "[task_id=%s] [渲染] legacy 引擎 FFmpeg 失败: %s\nfilter_complex: %s",
+            task_id,
+            e,
+            filter_complex[:500],
+        )
+        raise
+
+    file_size = output_path.stat().st_size if output_path.exists() else 0
+    duration = probe_duration(output_path)
+    return duration, file_size
+
+
 # ── Celery Task ──────────────────────────────────────────────────────────────
 
 
@@ -730,31 +873,59 @@ def generate_video(self, task_id: str) -> dict:
                 )
                 _flush_logs(task_id, gen_task)
 
-            # 使用 UnifiedRenderService 渲染
-            logger.info("[task_id=%s] [渲染] FFmpeg 渲染开始", task_id)
+            # 3. 根据 Feature Flag 选择渲染引擎
+            user_id = getattr(gen_task, "created_by_user_id", "") if gen_task else ""
+            engine = _resolve_render_engine(user_id) if user_id else ENGINE_UNIFIED
+            logger.info("[task_id=%s] [渲染] 引擎选择: %s (user_id=%s)", task_id, engine, user_id)
+
             render_start = time.monotonic()
-            render_service = UnifiedRenderService(
-                plan=virtual_plan,
-                clips=virtual_clips,
-                asset_path_map=asset_path_map,
-                work_dir=temp_path,
-                output_width=OUTPUT_WIDTH,
-                output_height=OUTPUT_HEIGHT,
-                output_fps=int(OUTPUT_FPS),
-            )
-            render_result = render_service.render()
-            render_elapsed = time.monotonic() - render_start
-            logger.info(
-                "[task_id=%s] [渲染] FFmpeg 渲染完成: 耗时=%.1fs",
-                task_id,
-                render_elapsed,
-            )
+            render_output_path = temp_path / f"rendered-{task_id}.mp4"
+
+            if engine == ENGINE_LEGACY:
+                # 旧引擎：filter_complex + concat（保持原帧率，无 fps 归一化）
+                render_duration, render_file_size = _render_with_legacy_engine(
+                    task_id=task_id,
+                    virtual_clips=virtual_clips,
+                    asset_path_map=asset_path_map,
+                    work_dir=temp_path,
+                    output_path=render_output_path,
+                )
+                render_elapsed = time.monotonic() - render_start
+                logger.info(
+                    "[task_id=%s] [渲染] legacy 引擎完成: 耗时=%.1fs, 时长=%.2fs",
+                    task_id,
+                    render_elapsed,
+                    render_duration,
+                )
+            else:
+                # 新引擎：UnifiedRenderService 图层架构
+                logger.info("[task_id=%s] [渲染] unified 引擎 FFmpeg 渲染开始", task_id)
+                render_service = UnifiedRenderService(
+                    plan=virtual_plan,
+                    clips=virtual_clips,
+                    asset_path_map=asset_path_map,
+                    work_dir=temp_path,
+                    output_width=OUTPUT_WIDTH,
+                    output_height=OUTPUT_HEIGHT,
+                    output_fps=int(OUTPUT_FPS),
+                )
+                render_result = render_service.render()
+                render_output_path = render_result.output_path
+                render_duration = render_result.duration
+                render_file_size = render_result.file_size
+                render_elapsed = time.monotonic() - render_start
+                logger.info(
+                    "[task_id=%s] [渲染] unified 引擎完成: 耗时=%.1fs",
+                    task_id,
+                    render_elapsed,
+                )
 
             if gen_task:
                 gen_task.append_log(
                     "渲染",
-                    f"FFmpeg 渲染完成, 耗时={render_elapsed:.1f}s",
+                    f"引擎={engine}, 耗时={render_elapsed:.1f}s",
                     duration=round(render_elapsed, 2),
+                    engine=engine,
                 )
                 _flush_logs(task_id, gen_task)
 
@@ -762,14 +933,14 @@ def generate_video(self, task_id: str) -> dict:
             if audio_path:
                 final_path = temp_path / f"final-{task_id}.mp4"
                 try:
-                    _mux_audio_track(render_result.output_path, audio_path, final_path)
+                    _mux_audio_track(render_output_path, audio_path, final_path)
                     # 混音成功，使用混音后的文件
                     output_path = final_path
                 except Exception as mux_err:
                     logger.warning("[task_id=%s] [混音] 音频混合失败，使用无音频版本: %s", task_id, mux_err)
-                    output_path = render_result.output_path
+                    output_path = render_output_path
             else:
-                output_path = render_result.output_path
+                output_path = render_output_path
 
             file_size = output_path.stat().st_size
             duration = probe_duration(output_path)

tests/unit/test_generation_feature_flag.py

@@ -0,0 +1,338 @@
+"""generate_video 任务 Feature Flag 灰度引擎选择单元测试.
+
+覆盖：
+- _resolve_render_engine 正常返回 unified / legacy
+- Feature Flag 不可用时 fallback 到 unified
+- 白名单 / 百分比 / 全局开关各场景
+- _render_with_legacy_engine 命令构建与输出验证
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from datetime import datetime, timezone
+from types import ModuleType
+from typing import Any
+from unittest.mock import MagicMock, patch
+
+os.environ.setdefault("JWT_SECRET_KEY", "unit-test-secret-key-for-testing")
+os.environ.setdefault("DATABASE_URL", "sqlite:///test.db")
+
+from pathlib import Path
+
+import pytest
+
+# ── Mock worker 模块以避免数据库连接 ──────────────────────────────────────────
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "..", "apps", "worker"))
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", ".."))
+
+_mock_db_mod = ModuleType("worker_app.db")
+_mock_db_mod.SessionLocal = MagicMock()
+sys.modules.setdefault("worker_app.db", _mock_db_mod)
+
+_mock_celery_mod = ModuleType("worker_app.celery_app")
+_mock_celery_app = MagicMock()
+_mock_celery_app.task = lambda **kwargs: lambda fn: fn
+_mock_celery_mod.celery_app = _mock_celery_app
+sys.modules.setdefault("worker_app.celery_app", _mock_celery_mod)
+
+# Mock worker_app.core.config 避免 settings 加载
+_mock_config_mod = ModuleType("worker_app.core.config")
+_mock_settings = MagicMock()
+_mock_settings.redis_url = None
+_mock_settings.render_engine = "unified"
+_mock_config_mod.get_settings = lambda: _mock_settings
+sys.modules.setdefault("worker_app.core", ModuleType("worker_app.core"))
+sys.modules.setdefault("worker_app.core.config", _mock_config_mod)
+
+
+# ── 测试用数据类 ──────────────────────────────────────────────────────────────
+
+
+class _TestClip:
+    def __init__(self, asset_id, duration=30.0, clip_type="main", config=None, order=0):
+        self.id = f"clip_{asset_id}"
+        self.plan_id = "test-plan"
+        self.clip_type = clip_type
+        self.order = order
+        self.asset_id = asset_id
+        self.duration = duration
+        self.config = config or {}
+        self.start_time = 0.0
+        self.transition_effect = "cut"
+
+
+# ── RenderEngineResolver 基础行为测试 ───────────────────────────────────────
+
+
+def test_resolver_unified_when_enabled_100_percent():
+    """flag 全局开启（percentage=100）时，返回 unified。"""
+    from video_processing.render_engine_resolver import RenderEngineResolver
+
+    from packages.adapters.redis.feature_flag_store import (
+        FeatureFlagConfig,
+        InMemoryFeatureFlagStore,
+    )
+
+    store = InMemoryFeatureFlagStore()
+    store.set(FeatureFlagConfig(name="render_engine", enabled=True, percentage=100))
+    resolver = RenderEngineResolver(default_engine="legacy", store=store)
+
+    assert resolver.get_engine(user_id="user-123") == "unified"
+
+
+def test_resolver_legacy_when_flag_disabled():
+    """flag 全局关闭时，返回默认引擎 legacy。"""
+    from video_processing.render_engine_resolver import RenderEngineResolver
+
+    from packages.adapters.redis.feature_flag_store import (
+        FeatureFlagConfig,
+        InMemoryFeatureFlagStore,
+    )
+
+    store = InMemoryFeatureFlagStore()
+    store.set(FeatureFlagConfig(name="render_engine", enabled=False, percentage=100))
+    resolver = RenderEngineResolver(default_engine="legacy", store=store)
+
+    assert resolver.get_engine(user_id="user-123") == "legacy"
+
+
+def test_resolver_whitelist_overrides_percentage_0():
+    """白名单用户即使 percentage=0 也走 unified。"""
+    from video_processing.render_engine_resolver import RenderEngineResolver
+
+    from packages.adapters.redis.feature_flag_store import (
+        FeatureFlagConfig,
+        InMemoryFeatureFlagStore,
+    )
+
+    store = InMemoryFeatureFlagStore()
+    store.set(
+        FeatureFlagConfig(
+            name="render_engine",
+            enabled=True,
+            percentage=0,
+            whitelist={"user-vip"},
+        )
+    )
+    resolver = RenderEngineResolver(default_engine="legacy", store=store)
+
+    assert resolver.get_engine(user_id="user-vip") == "unified"
+    assert resolver.get_engine(user_id="user-other") == "legacy"
+
+
+def test_resolver_percentage_0_all_legacy():
+    """percentage=0 且无白名单时，全部走 legacy。"""
+    from video_processing.render_engine_resolver import RenderEngineResolver
+
+    from packages.adapters.redis.feature_flag_store import (
+        FeatureFlagConfig,
+        InMemoryFeatureFlagStore,
+    )
+
+    store = InMemoryFeatureFlagStore()
+    store.set(FeatureFlagConfig(name="render_engine", enabled=True, percentage=0))
+    resolver = RenderEngineResolver(default_engine="legacy", store=store)
+
+    for i in range(50):
+        assert resolver.get_engine(user_id=f"user-{i}") == "legacy"
+
+
+def test_resolver_default_unified_when_flag_off():
+    """默认引擎设为 unified 且 flag 关闭时，返回 unified。"""
+    from video_processing.render_engine_resolver import RenderEngineResolver
+
+    from packages.adapters.redis.feature_flag_store import (
+        FeatureFlagConfig,
+        InMemoryFeatureFlagStore,
+    )
+
+    store = InMemoryFeatureFlagStore()
+    store.set(FeatureFlagConfig(name="render_engine", enabled=False, percentage=0))
+    resolver = RenderEngineResolver(default_engine="unified", store=store)
+
+    assert resolver.get_engine(user_id="user-123") == "unified"
+
+
+# ── _render_with_legacy_engine 集成测试 ──────────────────────────────────────
+
+
+def test_legacy_engine_single_clip_keeps_original_fps():
+    """单 clip 场景：输出保持原帧率（不做 fps 归一化），分辨率缩放正确。"""
+    import subprocess
+    import tempfile
+
+    from video_processing.ffmpeg_utils import probe_video_info
+
+    from apps.worker.worker_app.tasks.generation import _render_with_legacy_engine
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        tmp_path = Path(tmpdir)
+        input_path = tmp_path / "input.mp4"
+        output_path = tmp_path / "output.mp4"
+
+        # 生成 1 秒 30fps 测试视频（带音频）
+        subprocess.run(
+            [
+                "ffmpeg",
+                "-y",
+                "-f",
+                "lavfi",
+                "-i",
+                "color=c=red:s=640x360:d=1:r=30",
+                "-f",
+                "lavfi",
+                "-i",
+                "anullsrc=r=44100:cl=stereo:d=1",
+                "-c:v",
+                "libx264",
+                "-pix_fmt",
+                "yuv420p",
+                "-c:a",
+                "aac",
+                "-shortest",
+                str(input_path),
+            ],
+            check=True,
+            capture_output=True,
+        )
+
+        clip = _TestClip(asset_id="asset-1", duration=1.0)
+        asset_path_map = {"asset-1": input_path}
+
+        duration, file_size = _render_with_legacy_engine(
+            task_id="test-task",
+            virtual_clips=[clip],
+            asset_path_map=asset_path_map,
+            work_dir=tmp_path,
+            output_path=output_path,
+        )
+
+        assert output_path.exists()
+        assert file_size > 0
+        assert duration > 0
+
+        # 旧引擎保持原帧率（30fps），不做 fps 归一化
+        info = probe_video_info(str(output_path))
+        assert abs(info.get("fps", 0) - 30.0) < 0.5
+        assert info.get("width") == 1280
+        assert info.get("height") == 720
+
+
+def test_legacy_engine_two_clips_concat_duration():
+    """多 clip 场景：concat 后时长为两片段之和。"""
+    import subprocess
+    import tempfile
+
+    from video_processing.ffmpeg_utils import probe_duration
+
+    from apps.worker.worker_app.tasks.generation import _render_with_legacy_engine
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        tmp_path = Path(tmpdir)
+        input1 = tmp_path / "input1.mp4"
+        input2 = tmp_path / "input2.mp4"
+        output_path = tmp_path / "output.mp4"
+
+        for idx, inp in enumerate([input1, input2]):
+            color = "red" if idx == 0 else "blue"
+            subprocess.run(
+                [
+                    "ffmpeg",
+                    "-y",
+                    "-f",
+                    "lavfi",
+                    "-i",
+                    f"color=c={color}:s=640x360:d=1:r=30",
+                    "-f",
+                    "lavfi",
+                    "-i",
+                    "anullsrc=r=44100:cl=stereo:d=1",
+                    "-c:v",
+                    "libx264",
+                    "-pix_fmt",
+                    "yuv420p",
+                    "-c:a",
+                    "aac",
+                    "-shortest",
+                    str(inp),
+                ],
+                check=True,
+                capture_output=True,
+            )
+
+        clip1 = _TestClip(asset_id="asset-1", duration=1.0, clip_type="main", order=0)
+        clip2 = _TestClip(asset_id="asset-2", duration=1.0, clip_type="main", order=1)
+        asset_path_map = {"asset-1": input1, "asset-2": input2}
+
+        duration, file_size = _render_with_legacy_engine(
+            task_id="test-task",
+            virtual_clips=[clip1, clip2],
+            asset_path_map=asset_path_map,
+            work_dir=tmp_path,
+            output_path=output_path,
+        )
+
+        assert output_path.exists()
+        assert file_size > 0
+        assert abs(duration - 2.0) < 0.2
+
+
+def test_legacy_engine_broll_mode_supported():
+    """b_roll 类型的 clip 也被正确识别为主图层并渲染。"""
+    import subprocess
+    import tempfile
+
+    from apps.worker.worker_app.tasks.generation import _render_with_legacy_engine
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        tmp_path = Path(tmpdir)
+        input_path = tmp_path / "input.mp4"
+        output_path = tmp_path / "output.mp4"
+
+        subprocess.run(
+            [
+                "ffmpeg",
+                "-y",
+                "-f",
+                "lavfi",
+                "-i",
+                "color=c=green:s=640x360:d=1:r=30",
+                "-f",
+                "lavfi",
+                "-i",
+                "anullsrc=r=44100:cl=stereo:d=1",
+                "-c:v",
+                "libx264",
+                "-pix_fmt",
+                "yuv420p",
+                "-c:a",
+                "aac",
+                "-shortest",
+                str(input_path),
+            ],
+            check=True,
+            capture_output=True,
+        )
+
+        clip = _TestClip(
+            asset_id="asset-1",
+            duration=1.0,
+            clip_type="main",
+            config={"role": "b_roll"},
+        )
+        asset_path_map = {"asset-1": input_path}
+
+        duration, file_size = _render_with_legacy_engine(
+            task_id="test-task",
+            virtual_clips=[clip],
+            asset_path_map=asset_path_map,
+            work_dir=tmp_path,
+            output_path=output_path,
+        )
+
+        assert output_path.exists()
+        assert file_size > 0
+        assert duration > 0