fix: animation output types now render turntable mp4 via Celery

- render_order_line_task: detect is_animation flag, branch to turntable
  pipeline instead of still-image pipeline
- render_blender: add render_turntable_to_file() — STL conversion,
  blender turntable_render.py for frames, ffmpeg compose to mp4
- render-worker/Dockerfile: add ffmpeg package
- Fix: Turntable Video_White was producing a .jpg still instead of .mp4

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

backend/app/services/render_blender.py

@@ -332,3 +332,216 @@ def render_still(
         "engine_used": engine_used,
         "log_lines": log_lines,
     }
+
+
+def render_turntable_to_file(
+    step_path: Path,
+    output_path: Path,
+    frame_count: int = 24,
+    fps: int = 25,
+    width: int = 1920,
+    height: int = 1920,
+    engine: str = "cycles",
+    samples: int = 128,
+    stl_quality: str = "low",
+    smooth_angle: int = 30,
+    cycles_device: str = "auto",
+    transparent_bg: bool = False,
+    bg_color: str = "",
+    turntable_axis: str = "world_z",
+    part_colors: dict | None = None,
+    template_path: str | None = None,
+    target_collection: str = "Product",
+    material_library_path: str | None = None,
+    material_map: dict | None = None,
+    part_names_ordered: list | None = None,
+    lighting_only: bool = False,
+    shadow_catcher: bool = False,
+    rotation_x: float = 0.0,
+    rotation_y: float = 0.0,
+    rotation_z: float = 0.0,
+) -> dict:
+    """Render a turntable animation: STEP → STL → N frames (Blender) → mp4 (ffmpeg).
+
+    Returns a dict with timing, frame count, engine_used, log_lines.
+    Raises RuntimeError on failure.
+    """
+    import shutil as _shutil
+    import tempfile
+    import time
+
+    blender_bin = find_blender()
+    if not blender_bin:
+        raise RuntimeError("Blender binary not found — check BLENDER_BIN env or PATH")
+
+    script_path = Path(os.environ.get("RENDER_SCRIPTS_DIR", "/render-scripts")) / "turntable_render.py"
+    if not script_path.exists():
+        alt = Path(__file__).parent.parent.parent.parent / "render-worker" / "scripts" / "turntable_render.py"
+        if alt.exists():
+            script_path = alt
+        else:
+            raise RuntimeError(f"turntable_render.py not found at {script_path}")
+
+    ffmpeg_bin = _shutil.which("ffmpeg")
+    if not ffmpeg_bin:
+        raise RuntimeError("ffmpeg not found — install ffmpeg in the render-worker container")
+
+    t0 = time.monotonic()
+
+    # 1. STL conversion
+    stl_path = step_path.parent / f"{step_path.stem}_{stl_quality}.stl"
+    parts_dir = step_path.parent / f"{step_path.stem}_{stl_quality}_parts"
+
+    t_stl = time.monotonic()
+    if not stl_path.exists() or stl_path.stat().st_size == 0:
+        logger.info("STL cache miss — converting: %s", step_path.name)
+        convert_step_to_stl(step_path, stl_path, stl_quality)
+    else:
+        logger.info("STL cache hit: %s (%d KB)", stl_path.name, stl_path.stat().st_size // 1024)
+    stl_size_bytes = stl_path.stat().st_size if stl_path.exists() else 0
+
+    if not (parts_dir / "manifest.json").exists():
+        try:
+            export_per_part_stls(step_path, parts_dir, stl_quality)
+        except Exception as exc:
+            logger.warning("per-part STL export failed (non-fatal): %s", exc)
+
+    stl_duration_s = round(time.monotonic() - t_stl, 2)
+
+    # 2. Render frames with Blender
+    frames_dir = output_path.parent / f"_frames_{output_path.stem}"
+    frames_dir.mkdir(parents=True, exist_ok=True)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    env = dict(os.environ)
+    env["EGL_PLATFORM"] = "surfaceless"
+
+    cmd = [
+        blender_bin,
+        "--background",
+        "--python", str(script_path),
+        "--",
+        str(stl_path),
+        str(frames_dir),
+        str(frame_count),
+        "360",  # degrees
+        str(width), str(height),
+        engine, str(samples),
+        json.dumps(part_colors or {}),
+        template_path or "",
+        target_collection,
+        material_library_path or "",
+        json.dumps(material_map) if material_map else "{}",
+        json.dumps(part_names_ordered) if part_names_ordered else "[]",
+        "1" if lighting_only else "0",
+        cycles_device,
+        "1" if shadow_catcher else "0",
+        str(rotation_x), str(rotation_y), str(rotation_z),
+        turntable_axis,
+        bg_color or "",
+        "1" if transparent_bg else "0",
+    ]
+
+    log_lines: list[str] = []
+
+    t_render = time.monotonic()
+    proc = subprocess.Popen(
+        cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+        text=True, env=env, start_new_session=True,
+    )
+    try:
+        stdout, stderr = proc.communicate(timeout=3600)  # 1hr max for full animation
+    except subprocess.TimeoutExpired:
+        try:
+            os.killpg(os.getpgid(proc.pid), signal.SIGTERM)
+        except (ProcessLookupError, OSError):
+            pass
+        stdout, stderr = proc.communicate()
+
+    for line in (stdout or "").splitlines():
+        logger.info("[turntable] %s", line)
+        if "[turntable_render]" in line:
+            log_lines.append(line)
+    for line in (stderr or "").splitlines():
+        logger.warning("[turntable stderr] %s", line)
+
+    if proc.returncode != 0:
+        raise RuntimeError(
+            f"turntable_render.py exited with code {proc.returncode}.\n"
+            f"stdout: {(stdout or '')[-2000:]}\n"
+            f"stderr: {(stderr or '')[-500:]}"
+        )
+
+    render_duration_s = round(time.monotonic() - t_render, 2)
+
+    # Check frames were written
+    frame_files = sorted(frames_dir.glob("frame_*.png"))
+    if not frame_files:
+        raise RuntimeError(f"No frames rendered in {frames_dir}")
+    logger.info("Rendered %d frames in %.1fs", len(frame_files), render_duration_s)
+
+    # 3. Compose frames → mp4 with ffmpeg
+    t_ffmpeg = time.monotonic()
+
+    ffmpeg_cmd = [
+        ffmpeg_bin,
+        "-y",
+        "-framerate", str(fps),
+        "-i", str(frames_dir / "frame_%04d.png"),
+        "-vcodec", "libx264",
+        "-pix_fmt", "yuv420p",
+        "-crf", "18",
+        "-movflags", "+faststart",
+        str(output_path),
+    ]
+
+    # If bg_color is set and transparent_bg is True, overlay frames on solid bg
+    if bg_color and transparent_bg:
+        hex_color = bg_color.lstrip("#")
+        r, g, b = int(hex_color[0:2], 16), int(hex_color[2:4], 16), int(hex_color[4:6], 16)
+        ffmpeg_cmd = [
+            ffmpeg_bin, "-y",
+            "-framerate", str(fps),
+            "-i", str(frames_dir / "frame_%04d.png"),
+            "-f", "lavfi", "-i", f"color=c=0x{hex_color}:size={width}x{height}:rate={fps}",
+            "-filter_complex", "[1:v][0:v]overlay=0:0",
+            "-vcodec", "libx264",
+            "-pix_fmt", "yuv420p",
+            "-crf", "18",
+            "-movflags", "+faststart",
+            str(output_path),
+        ]
+
+    ffmpeg_proc = subprocess.run(
+        ffmpeg_cmd, capture_output=True, text=True, timeout=300
+    )
+    ffmpeg_duration_s = round(time.monotonic() - t_ffmpeg, 2)
+
+    for line in (ffmpeg_proc.stdout or "").splitlines():
+        logger.info("[ffmpeg] %s", line)
+    for line in (ffmpeg_proc.stderr or "").splitlines():
+        logger.debug("[ffmpeg stderr] %s", line)
+
+    if ffmpeg_proc.returncode != 0:
+        raise RuntimeError(
+            f"ffmpeg exited with code {ffmpeg_proc.returncode}.\n"
+            f"stderr: {(ffmpeg_proc.stderr or '')[-1000:]}"
+        )
+
+    # Clean up frames directory
+    try:
+        _shutil.rmtree(frames_dir)
+    except Exception:
+        pass
+
+    return {
+        "total_duration_s": round(time.monotonic() - t0, 2),
+        "stl_duration_s": stl_duration_s,
+        "render_duration_s": render_duration_s,
+        "ffmpeg_duration_s": ffmpeg_duration_s,
+        "stl_size_bytes": stl_size_bytes,
+        "output_size_bytes": output_path.stat().st_size if output_path.exists() else 0,
+        "frame_count": len(frame_files),
+        "engine_used": engine,
+        "log_lines": log_lines,
+    }