Spaces:

build-small-hackathon
/

tiny-trigger

Running

App Files Files Community

Javier Montalvo commited on 29 days ago

Commit

20905e1

1 Parent(s): 498b1c6

updated ui, and video generation

Browse files

Files changed (13) hide show

DEMO.md +6 -2
README.md +6 -5
frontend/dist/assets/{index-BNhsKA1b.js → index-CLWJR9Mi.js} +0 -0
frontend/dist/index.html +1 -1
frontend/src/lib/api.ts +1 -1
frontend/src/lib/dashboard.tsx +18 -4
frontend/src/lib/types.ts +3 -1
frontend/src/modules/detector/DetectorPanel.tsx +37 -17
server.py +5 -1
tests/test_video.py +104 -4
tiny_trigger/llm.py +2 -0
tiny_trigger/models.py +2 -0
tiny_trigger/video.py +76 -56

DEMO.md CHANGED Viewed

@@ -51,11 +51,15 @@ Recommended starting detector settings:
 - Classes: leave defaults, or add obvious objects from the video.
 - Confidence: `0.15` for normal objects, `0.05` if detections are missing.
-- Frame stride: `5`.
 - Max frames: `120`.
-- Model: `yoloe-26s-seg.pt` for speed, `yoloe-26l-seg.pt` for a stronger demo.
 Rules automatically add their referenced labels to the detector class list.
 ## Prompts To Try

 - Classes: leave defaults, or add obvious objects from the video.
 - Confidence: `0.15` for normal objects, `0.05` if detections are missing.
+- Sample interval: `1.0s`.
 - Max frames: `120`.
+- Model size: Small for speed, Large/XLarge for a stronger demo.
+- Resolution: `640` by default, `960` or `1280` if detections are missing.
 Rules automatically add their referenced labels to the detector class list.
+Rules are frame-local for now. Presence, count, near, far, enter, exit, change,
+and cooldown are supported; object identity, movement, speed, direction, and
+trajectories are not tracked yet.
 ## Prompts To Try

README.md CHANGED Viewed

@@ -39,9 +39,9 @@ poetry install
 poetry run python server.py
 ```
-The detector defaults to `yoloe-26s-seg.pt`, which Ultralytics downloads on
-first use if it is not already cached. Model weights are not checked into the
-repo.
 For small or background objects, use a larger model such as `yoloe-26l-seg.pt`,
 set device to `cuda:0`, lower confidence to `0.05`-`0.15`, and raise image size
@@ -90,7 +90,8 @@ Initial video conditions include presence, count, near, and far. Near/far use th
 minimum horizontal/vertical gap between detection boxes in normalized frame
 percent. Gates include enabled state and cooldown. Triggers can fire while a
 condition is true, when it becomes true, when it becomes false, or on either
-change. Initial actions are simulated events and optional webhooks.
 ```yaml
 rules:
@@ -132,7 +133,7 @@ Example `.local/config.yaml`:
 webhook_url: "http://127.0.0.1:8123/api/webhook/example"
 default_detector_model: "yoloe-26x-seg.pt"
 default_device: "cuda:0"
-default_image_size: 1280
 default_max_detections: 300
 llm_provider: "anthropic"
 replicate_model: "openai/gpt-5.2"

 poetry run python server.py
 ```
+The detector defaults to the Small YOLOE model (`yoloe-26s-seg.pt`) at 640px,
+which Ultralytics downloads on first use if it is not already cached. Model
+weights are not checked into the repo.
 For small or background objects, use a larger model such as `yoloe-26l-seg.pt`,
 set device to `cuda:0`, lower confidence to `0.05`-`0.15`, and raise image size
 minimum horizontal/vertical gap between detection boxes in normalized frame
 percent. Gates include enabled state and cooldown. Triggers can fire while a
 condition is true, when it becomes true, when it becomes false, or on either
+change. Rules are frame-local: Tiny Trigger does not yet track object identities,
+movement, speed, direction, or trajectories across frames.
 ```yaml
 rules:
 webhook_url: "http://127.0.0.1:8123/api/webhook/example"
 default_detector_model: "yoloe-26x-seg.pt"
 default_device: "cuda:0"
+default_image_size: 640
 default_max_detections: 300
 llm_provider: "anthropic"
 replicate_model: "openai/gpt-5.2"

frontend/dist/assets/{index-BNhsKA1b.js → index-CLWJR9Mi.js} RENAMED Viewed

The diff for this file is too large to render. See raw diff

frontend/dist/index.html CHANGED Viewed

@@ -16,7 +16,7 @@
       href="https://fonts.googleapis.com/css2?family=Hanken+Grotesk:wght@400;500;600&family=JetBrains+Mono:wght@400;500;600&display=swap"
       rel="stylesheet"
     />
-    <script type="module" crossorigin src="/assets/index-BNhsKA1b.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-DpGaJEG3.css">
   </head>
   <body>

       href="https://fonts.googleapis.com/css2?family=Hanken+Grotesk:wght@400;500;600&family=JetBrains+Mono:wght@400;500;600&display=swap"
       rel="stylesheet"
     />
+    <script type="module" crossorigin src="/assets/index-CLWJR9Mi.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-DpGaJEG3.css">
   </head>
   <body>

frontend/src/lib/api.ts CHANGED Viewed

@@ -39,7 +39,7 @@ export async function detectAndAutomate(
     classes: params.classes,
     rules_text: rulesText,
     confidence: params.confidence,
-    frame_stride: params.frameStride,
     max_frames: params.maxFrames,
     model_name: params.modelName,
     image_size: params.imageSize,

     classes: params.classes,
     rules_text: rulesText,
     confidence: params.confidence,
+    sample_interval_sec: params.sampleIntervalSec,
     max_frames: params.maxFrames,
     model_name: params.modelName,
     image_size: params.imageSize,

frontend/src/lib/dashboard.tsx CHANGED Viewed

@@ -20,6 +20,14 @@ import type {
 } from "./types"
 const DEFAULT_CLASSES = "person, cat, dog, car, chair, cup"
 const DEFAULT_RULES = `rules:
   - name: example-person-enters-lights
@@ -38,10 +46,10 @@ const DEFAULT_RULES = `rules:
 const DEFAULT_PARAMS: DetectParams = {
   classes: DEFAULT_CLASSES,
   confidence: 0.25,
-  frameStride: 5,
   maxFrames: 120,
   modelName: "yoloe-26s-seg.pt",
-  imageSize: 0,
   device: "auto",
   maxDetections: 0,
   enableWebhooks: false,
@@ -121,9 +129,15 @@ export function DashboardProvider({ children }: { children: ReactNode }) {
         setParams((p) => ({
           ...p,
           classes: cfg.default_classes ?? p.classes,
-          modelName: cfg.default_detector_model ?? p.modelName,
           device: cfg.default_device ?? p.device,
-          imageSize: cfg.default_image_size ?? p.imageSize,
           maxDetections: cfg.default_max_detections ?? p.maxDetections,
           webhookUrl: cfg.webhook_url ?? p.webhookUrl,
         }))

 } from "./types"
 const DEFAULT_CLASSES = "person, cat, dog, car, chair, cup"
+const DETECTOR_MODEL_VALUES = new Set([
+  "yoloe-26n-seg.pt",
+  "yoloe-26s-seg.pt",
+  "yoloe-26m-seg.pt",
+  "yoloe-26l-seg.pt",
+  "yoloe-26x-seg.pt",
+])
+const IMAGE_SIZE_VALUES = new Set([320, 640, 960, 1280])
 const DEFAULT_RULES = `rules:
   - name: example-person-enters-lights
 const DEFAULT_PARAMS: DetectParams = {
   classes: DEFAULT_CLASSES,
   confidence: 0.25,
+  sampleIntervalSec: 1.0,
   maxFrames: 120,
   modelName: "yoloe-26s-seg.pt",
+  imageSize: 640,
   device: "auto",
   maxDetections: 0,
   enableWebhooks: false,
         setParams((p) => ({
           ...p,
           classes: cfg.default_classes ?? p.classes,
+          modelName:
+            cfg.default_detector_model && DETECTOR_MODEL_VALUES.has(cfg.default_detector_model)
+              ? cfg.default_detector_model
+              : p.modelName,
           device: cfg.default_device ?? p.device,
+          imageSize:
+            cfg.default_image_size && IMAGE_SIZE_VALUES.has(cfg.default_image_size)
+              ? cfg.default_image_size
+              : p.imageSize,
           maxDetections: cfg.default_max_detections ?? p.maxDetections,
           webhookUrl: cfg.webhook_url ?? p.webhookUrl,
         }))

frontend/src/lib/types.ts CHANGED Viewed

@@ -26,6 +26,8 @@ export interface RunStats {
   processed_frames: number
   source_fps: number
   output_fps: number
 }
 export interface RunResult {
@@ -94,7 +96,7 @@ export interface LocalConfig {
 export interface DetectParams {
   classes: string
   confidence: number
-  frameStride: number
   maxFrames: number
   modelName: string
   imageSize: number

   processed_frames: number
   source_fps: number
   output_fps: number
+  frame_stride: number
+  sample_interval_sec: number | null
 }
 export interface RunResult {
 export interface DetectParams {
   classes: string
   confidence: number
+  sampleIntervalSec: number
   maxFrames: number
   modelName: string
   imageSize: number

frontend/src/modules/detector/DetectorPanel.tsx CHANGED Viewed

@@ -9,6 +9,16 @@ import { Slider } from "@/components/ui/slider"
 import { Separator } from "@/components/ui/separator"
 import { cn } from "@/lib/utils"
 function SliderRow({
   label,
   value,
@@ -110,12 +120,18 @@ export function DetectorPanel() {
       <div className="space-y-2">
         <Label htmlFor="model">Detector model</Label>
-        <Input
           id="model"
           value={params.modelName}
           onChange={(e) => setParam("modelName", e.target.value)}
-          className="font-mono text-xs"
-        />
       </div>
       <div className="space-y-4">
@@ -129,13 +145,13 @@ export function DetectorPanel() {
           onChange={(v) => setParam("confidence", Number(v.toFixed(2)))}
         />
         <SliderRow
-          label="Frame stride"
-          value={params.frameStride}
-          display={`${params.frameStride}`}
-          min={1}
-          max={30}
-          step={1}
-          onChange={(v) => setParam("frameStride", v)}
         />
         <SliderRow
           label="Max frames"
@@ -171,14 +187,18 @@ export function DetectorPanel() {
               </div>
               <div className="space-y-1.5">
                 <Label htmlFor="imgsz">Image size</Label>
-                <Input
                   id="imgsz"
-                  type="number"
-                  value={params.imageSize || ""}
-                  onChange={(e) => setParam("imageSize", Number(e.target.value) || 0)}
-                  className="font-mono text-xs"
-                  placeholder="auto"
-                />
               </div>
             </div>
             <div className="space-y-1.5">

 import { Separator } from "@/components/ui/separator"
 import { cn } from "@/lib/utils"
+const DETECTOR_MODELS = [
+  { label: "Nano", value: "yoloe-26n-seg.pt" },
+  { label: "Small", value: "yoloe-26s-seg.pt" },
+  { label: "Medium", value: "yoloe-26m-seg.pt" },
+  { label: "Large", value: "yoloe-26l-seg.pt" },
+  { label: "XLarge", value: "yoloe-26x-seg.pt" },
+]
+const IMAGE_SIZES = [320, 640, 960, 1280]
 function SliderRow({
   label,
   value,
       <div className="space-y-2">
         <Label htmlFor="model">Detector model</Label>
+        <select
           id="model"
           value={params.modelName}
           onChange={(e) => setParam("modelName", e.target.value)}
+          className="h-10 w-full rounded-md border border-input bg-background px-3 py-2 text-sm text-foreground ring-offset-background focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2"
+        >
+          {DETECTOR_MODELS.map((model) => (
+            <option key={model.value} value={model.value}>
+              {model.label}
+            </option>
+          ))}
+        </select>
       </div>
       <div className="space-y-4">
           onChange={(v) => setParam("confidence", Number(v.toFixed(2)))}
         />
         <SliderRow
+          label="Sample interval"
+          value={params.sampleIntervalSec}
+          display={`${params.sampleIntervalSec.toFixed(1)}s`}
+          min={0.1}
+          max={5}
+          step={0.1}
+          onChange={(v) => setParam("sampleIntervalSec", Number(v.toFixed(1)))}
         />
         <SliderRow
           label="Max frames"
               </div>
               <div className="space-y-1.5">
                 <Label htmlFor="imgsz">Image size</Label>
+                <select
                   id="imgsz"
+                  value={params.imageSize}
+                  onChange={(e) => setParam("imageSize", Number(e.target.value))}
+                  className="h-10 w-full rounded-md border border-input bg-background px-3 py-2 text-sm text-foreground ring-offset-background focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2"
+                >
+                  {IMAGE_SIZES.map((size) => (
+                    <option key={size} value={size}>
+                      {size}
+                    </option>
+                  ))}
+                </select>
               </div>
             </div>
             <div className="space-y-1.5">

server.py CHANGED Viewed

@@ -103,6 +103,7 @@ def detect_and_automate(
     rules_text: str,
     confidence: float = 0.25,
     frame_stride: int = 5,
     max_frames: int = 120,
     model_name: str = DEFAULT_MODEL,
     image_size: int = 0,
@@ -124,6 +125,7 @@ def detect_and_automate(
         class_prompt=detection_classes,
         confidence=confidence,
         frame_stride=frame_stride,
         max_frames=max_frames,
         model_name=model_name or DEFAULT_MODEL,
         image_size=image_size or None,
@@ -149,7 +151,7 @@ def detect_and_automate(
         source_video_path=video_path,
         detections=result.detections,
         events=dispatched,
-        frame_stride=frame_stride,
         max_frames=max_frames,
         output_dir=str(RENDERS),
     )
@@ -167,6 +169,8 @@ def detect_and_automate(
             "processed_frames": result.processed_frames,
             "source_fps": round(result.source_fps, 2),
             "output_fps": round(result.output_fps, 2),
         },
         "detections": [_detection_dict(d) for d in result.detections],
         "events": [_event_dict(e) for e in dispatched],

     rules_text: str,
     confidence: float = 0.25,
     frame_stride: int = 5,
+    sample_interval_sec: float | None = None,
     max_frames: int = 120,
     model_name: str = DEFAULT_MODEL,
     image_size: int = 0,
         class_prompt=detection_classes,
         confidence=confidence,
         frame_stride=frame_stride,
+        sample_interval_sec=sample_interval_sec,
         max_frames=max_frames,
         model_name=model_name or DEFAULT_MODEL,
         image_size=image_size or None,
         source_video_path=video_path,
         detections=result.detections,
         events=dispatched,
+        frame_stride=result.frame_stride,
         max_frames=max_frames,
         output_dir=str(RENDERS),
     )
             "processed_frames": result.processed_frames,
             "source_fps": round(result.source_fps, 2),
             "output_fps": round(result.output_fps, 2),
+            "frame_stride": result.frame_stride,
+            "sample_interval_sec": result.sample_interval_sec,
         },
         "detections": [_detection_dict(d) for d in result.detections],
         "events": [_event_dict(e) for e in dispatched],

tests/test_video.py CHANGED Viewed

@@ -4,7 +4,7 @@ from pathlib import Path
 from typing import Any
 from tiny_trigger.models import ActionEvent, Detection
-from tiny_trigger.video import process_video, render_automation_video
 class FakeDetector:
@@ -35,6 +35,7 @@ class FakeDetector:
 def test_process_video_with_fake_detector(tmp_path: Path) -> None:
     video_path = _make_video(tmp_path)
     result = process_video(
@@ -51,6 +52,52 @@ def test_process_video_with_fake_detector(tmp_path: Path) -> None:
     assert Path(result.output_video_path).exists()
     assert result.processed_frames == 2
     assert [item.frame_index for item in result.detections] == [0, 2]
 def test_render_automation_video_with_fired_event(tmp_path: Path) -> None:
@@ -89,7 +136,32 @@ def test_render_automation_video_with_fired_event(tmp_path: Path) -> None:
     assert output_path.endswith("-automated.mp4")
-def test_process_video_repeats_low_fps_sampled_frames_for_playback(tmp_path: Path) -> None:
     cv2 = __import__("cv2")
     video_path = _make_video(tmp_path, fps=5.0, frames=15)
@@ -106,8 +178,8 @@ def test_process_video_repeats_low_fps_sampled_frames_for_playback(tmp_path: Pat
     capture = cv2.VideoCapture(result.output_video_path)
     try:
-        assert capture.get(cv2.CAP_PROP_FPS) == 8.0
-        assert capture.get(cv2.CAP_PROP_FRAME_COUNT) == 24
     finally:
         capture.release()
@@ -130,6 +202,34 @@ def test_process_video_writes_faststart_mp4(tmp_path: Path) -> None:
     assert data.find(b"moov") < data.find(b"mdat")
 def _make_video(tmp_path: Path, *, fps: float = 10.0, frames: int = 4) -> Path:
     cv2 = __import__("cv2")
     video_path = tmp_path / "input.mp4"

 from typing import Any
 from tiny_trigger.models import ActionEvent, Detection
+from tiny_trigger.video import _create_browser_mp4_writer, process_video, render_automation_video
 class FakeDetector:
 def test_process_video_with_fake_detector(tmp_path: Path) -> None:
+    cv2 = __import__("cv2")
     video_path = _make_video(tmp_path)
     result = process_video(
     assert Path(result.output_video_path).exists()
     assert result.processed_frames == 2
     assert [item.frame_index for item in result.detections] == [0, 2]
+    assert result.frame_stride == 2
+    assert result.sample_interval_sec is None
+    capture = cv2.VideoCapture(result.output_video_path)
+    try:
+        assert capture.get(cv2.CAP_PROP_FRAME_COUNT) == 4
+        assert capture.get(cv2.CAP_PROP_FPS) == 10.0
+    finally:
+        capture.release()
+def test_process_video_samples_once_per_second(tmp_path: Path) -> None:
+    video_path = _make_video(tmp_path, fps=30.0, frames=95)
+    result = process_video(
+        video_path=str(video_path),
+        class_prompt="cat",
+        frame_stride=2,
+        sample_interval_sec=1.0,
+        max_frames=3,
+        image_size=960,
+        max_detections=20,
+        detector=FakeDetector(),
+        output_dir=str(tmp_path),
+    )
+    assert result.frame_stride == 30
+    assert result.sample_interval_sec == 1.0
+    assert [item.frame_index for item in result.detections] == [0, 30, 60]
+def test_process_video_samples_half_second_intervals(tmp_path: Path) -> None:
+    video_path = _make_video(tmp_path, fps=10.0, frames=16)
+    result = process_video(
+        video_path=str(video_path),
+        class_prompt="cat",
+        sample_interval_sec=0.5,
+        max_frames=3,
+        image_size=960,
+        max_detections=20,
+        detector=FakeDetector(),
+        output_dir=str(tmp_path),
+    )
+    assert result.frame_stride == 5
+    assert [item.frame_index for item in result.detections] == [0, 5, 10]
 def test_render_automation_video_with_fired_event(tmp_path: Path) -> None:
     assert output_path.endswith("-automated.mp4")
+def test_render_automation_video_uses_computed_stride(tmp_path: Path) -> None:
+    video_path = _make_video(tmp_path, fps=30.0, frames=95)
+    result = process_video(
+        video_path=str(video_path),
+        class_prompt="cat",
+        sample_interval_sec=1.0,
+        max_frames=3,
+        image_size=960,
+        max_detections=20,
+        detector=FakeDetector(),
+        output_dir=str(tmp_path),
+    )
+    output_path = render_automation_video(
+        source_video_path=str(video_path),
+        detections=result.detections,
+        events=[],
+        frame_stride=result.frame_stride,
+        max_frames=3,
+        output_dir=str(tmp_path),
+    )
+    assert Path(output_path).exists()
+def test_process_video_writes_full_motion_clip_with_sampled_overlays(tmp_path: Path) -> None:
     cv2 = __import__("cv2")
     video_path = _make_video(tmp_path, fps=5.0, frames=15)
     capture = cv2.VideoCapture(result.output_video_path)
     try:
+        assert capture.get(cv2.CAP_PROP_FPS) == 5.0
+        assert capture.get(cv2.CAP_PROP_FRAME_COUNT) == 15
     finally:
         capture.release()
     assert data.find(b"moov") < data.find(b"mdat")
+def test_browser_mp4_writer_uses_mp4v_only(monkeypatch, tmp_path: Path) -> None:
+    calls: list[str] = []
+    class Writer:
+        def isOpened(self) -> bool:
+            return True
+        def release(self) -> None:
+            return None
+    class CV2:
+        @staticmethod
+        def VideoWriter_fourcc(*codec):
+            calls.append("".join(codec))
+            return 1234
+        @staticmethod
+        def VideoWriter(path, fourcc, fps, frame_size):
+            return Writer()
+    monkeypatch.setitem(__import__("sys").modules, "cv2", CV2)
+    writer = _create_browser_mp4_writer(tmp_path / "out.mp4", 8.0, (32, 32))
+    assert writer is not None
+    assert calls == ["mp4v"]
 def _make_video(tmp_path: Path, *, fps: float = 10.0, frames: int = 4) -> Path:
     cv2 = __import__("cv2")
     video_path = tmp_path / "input.mp4"

tiny_trigger/llm.py CHANGED Viewed

@@ -22,6 +22,8 @@ Use trigger.on="while" only when the user explicitly wants repeated actions whil
 When the request says one object is near, next to, beside, at, by, close to, or in front of another object, you MUST emit a near condition.
 Do not replace a near relation with two present conditions.
 Use max_gap_percent for near/far box-edge distance. It is the largest horizontal/vertical edge gap between boxes in normalized frame percent; touching or overlapping boxes have gap 0.
 If the user mentions elapsed time since an action or limiting repeat fires, encode it as gate.cooldown.
 If the user asks for one action when a condition starts and another action when it stops, use trigger.on="change" and then.enter / then.exit.
 """

 When the request says one object is near, next to, beside, at, by, close to, or in front of another object, you MUST emit a near condition.
 Do not replace a near relation with two present conditions.
 Use max_gap_percent for near/far box-edge distance. It is the largest horizontal/vertical edge gap between boxes in normalized frame percent; touching or overlapping boxes have gap 0.
+Do not generate motion, movement, speed, direction, trajectory, tracking, same-object, or identity rules. Tiny Trigger does not yet track identities across frames.
+For requests like "car moving", "person walks", "object moved", or "same car", return a simple presence/near/far approximation only if the request can still be useful without motion; otherwise return JSON with no rules.
 If the user mentions elapsed time since an action or limiting repeat fires, encode it as gate.cooldown.
 If the user asks for one action when a condition starts and another action when it stops, use trigger.on="change" and then.enter / then.exit.
 """

tiny_trigger/models.py CHANGED Viewed

@@ -27,6 +27,8 @@ class VideoProcessResult(BaseModel):
     processed_frames: int
     source_fps: float
     output_fps: float
 class ActionEvent(BaseModel):

     processed_frames: int
     source_fps: float
     output_fps: float
+    frame_stride: int
+    sample_interval_sec: float | None = None
 class ActionEvent(BaseModel):

tiny_trigger/video.py CHANGED Viewed

@@ -13,9 +13,7 @@ from .models import ActionEvent, Detection, FrameSample, VideoProcessResult
 ProgressCallback = Callable[[int, int | None], None]
-MIN_PREVIEW_FPS = 8.0
-MAX_PREVIEW_FPS = 30.0
-MP4_CODEC_CANDIDATES = ("avc1", "H264", "h264", "mp4v")
 def process_video(
@@ -24,6 +22,7 @@ def process_video(
     class_prompt: str | list[str],
     confidence: float = 0.25,
     frame_stride: int = 5,
     max_frames: int = 120,
     model_name: str = "yoloe-26s-seg.pt",
     image_size: int | None = None,
@@ -44,6 +43,8 @@ def process_video(
         raise ValueError("At least one class prompt is required.")
     if frame_stride < 1:
         raise ValueError("frame_stride must be at least 1.")
     if max_frames < 1:
         raise ValueError("max_frames must be at least 1.")
     if image_size is not None and image_size < 32:
@@ -57,9 +58,14 @@ def process_video(
         raise ValueError(f"Could not open video: {video_path}")
     source_fps = float(capture.get(cv2.CAP_PROP_FPS) or 30.0)
     width = int(capture.get(cv2.CAP_PROP_FRAME_WIDTH) or 0)
     height = int(capture.get(cv2.CAP_PROP_FRAME_HEIGHT) or 0)
-    output_fps, repeat_count = _preview_timing(source_fps, frame_stride)
     output_size = _browser_frame_size(width, height)
     output_path = _output_path(video_path, output_dir)
     writer = _create_browser_mp4_writer(output_path, output_fps, output_size)
@@ -71,33 +77,33 @@ def process_video(
     frames: list[FrameSample] = []
     processed_frames = 0
     frame_index = -1
     try:
         while True:
             ok, frame = capture.read()
             if not ok:
                 break
             frame_index += 1
-            if frame_index % frame_stride != 0:
-                continue
-            if processed_frames >= max_frames:
-                break
-            timestamp_sec = frame_index / source_fps
-            frames.append(FrameSample(frame_index=frame_index, timestamp_sec=timestamp_sec))
-            frame_detections = detector.detect(
-                frame,
-                frame_index=frame_index,
-                timestamp_sec=timestamp_sec,
-                confidence=confidence,
-                image_size=image_size,
-                max_detections=max_detections,
-            )
-            detections.extend(frame_detections)
-            _draw_detections(frame, frame_detections)
-            _write_preview_frame(writer, _fit_frame_to_output(frame, output_size), repeat_count)
-            processed_frames += 1
-            if progress:
-                progress(processed_frames, max_frames)
     finally:
         writer.release()
         capture.release()
@@ -111,6 +117,8 @@ def process_video(
         processed_frames=processed_frames,
         source_fps=source_fps,
         output_fps=output_fps,
     )
@@ -120,6 +128,7 @@ def render_automation_video(
     detections: list[Detection],
     events: list[ActionEvent],
     frame_stride: int,
     max_frames: int,
     output_dir: str | None = None,
 ) -> str:
@@ -131,6 +140,8 @@ def render_automation_video(
     if frame_stride < 1:
         raise ValueError("frame_stride must be at least 1.")
     if max_frames < 1:
         raise ValueError("max_frames must be at least 1.")
@@ -139,9 +150,14 @@ def render_automation_video(
         raise ValueError(f"Could not open video: {source_video_path}")
     source_fps = float(capture.get(cv2.CAP_PROP_FPS) or 30.0)
     width = int(capture.get(cv2.CAP_PROP_FRAME_WIDTH) or 0)
     height = int(capture.get(cv2.CAP_PROP_FRAME_HEIGHT) or 0)
-    output_fps, repeat_count = _preview_timing(source_fps, frame_stride)
     output_size = _browser_frame_size(width, height)
     output_path = _output_path(source_video_path, output_dir, suffix="automated")
     writer = _create_browser_mp4_writer(output_path, output_fps, output_size)
@@ -153,23 +169,25 @@ def render_automation_video(
     events_by_frame = _group_events_by_frame(events)
     processed_frames = 0
     frame_index = -1
     try:
         while True:
             ok, frame = capture.read()
             if not ok:
                 break
             frame_index += 1
-            if frame_index % frame_stride != 0:
-                continue
-            if processed_frames >= max_frames:
-                break
-            _draw_detections(frame, detections_by_frame.get(frame_index, []))
-            frame_events = events_by_frame.get(frame_index, [])
-            if frame_events:
-                _draw_action_events(frame, frame_events)
-            _write_preview_frame(writer, _fit_frame_to_output(frame, output_size), repeat_count)
-            processed_frames += 1
     finally:
         writer.release()
         capture.release()
@@ -184,15 +202,15 @@ def _output_path(video_path: str, output_dir: str | None, *, suffix: str = "anno
     return base_dir / f"{Path(video_path).stem}-{uuid4().hex[:8]}-{suffix}.mp4"
-def _preview_timing(source_fps: float, frame_stride: int) -> tuple[float, int]:
-    sampled_fps = source_fps / frame_stride if frame_stride else source_fps
-    output_fps = min(MAX_PREVIEW_FPS, max(MIN_PREVIEW_FPS, sampled_fps or MIN_PREVIEW_FPS))
-    repeat_count = max(1, round(output_fps / sampled_fps)) if sampled_fps > 0 else 1
-    return output_fps, repeat_count
-def _preview_fps(source_fps: float, frame_stride: int) -> float:
-    return _preview_timing(source_fps, frame_stride)[0]
 def _browser_frame_size(width: int, height: int) -> tuple[int, int]:
@@ -206,11 +224,10 @@ def _browser_frame_size(width: int, height: int) -> tuple[int, int]:
 def _create_browser_mp4_writer(output_path: Path, fps: float, frame_size: tuple[int, int]):
     import cv2
-    for codec in MP4_CODEC_CANDIDATES:
-        writer = cv2.VideoWriter(str(output_path), cv2.VideoWriter_fourcc(*codec), fps, frame_size)
-        if writer.isOpened():
-            return writer
-        writer.release()
     return None
@@ -229,8 +246,12 @@ def _finalize_browser_mp4(output_path: Path) -> None:
                 "error",
                 "-i",
                 str(output_path),
-                "-c",
-                "copy",
                 "-movflags",
                 "+faststart",
                 str(faststart_path),
@@ -263,9 +284,8 @@ def _fit_frame_to_output(frame, output_size: tuple[int, int]):
     return frame[:output_height, :output_width]
-def _write_preview_frame(writer, frame, repeat_count: int) -> None:
-    for _ in range(repeat_count):
-        writer.write(frame)
 def _draw_detections(frame, detections: list[Detection]) -> None:

 ProgressCallback = Callable[[int, int | None], None]
+MP4_CODEC = "mp4v"
 def process_video(
     class_prompt: str | list[str],
     confidence: float = 0.25,
     frame_stride: int = 5,
+    sample_interval_sec: float | None = None,
     max_frames: int = 120,
     model_name: str = "yoloe-26s-seg.pt",
     image_size: int | None = None,
         raise ValueError("At least one class prompt is required.")
     if frame_stride < 1:
         raise ValueError("frame_stride must be at least 1.")
+    if sample_interval_sec is not None and sample_interval_sec <= 0:
+        raise ValueError("sample_interval_sec must be greater than 0.")
     if max_frames < 1:
         raise ValueError("max_frames must be at least 1.")
     if image_size is not None and image_size < 32:
         raise ValueError(f"Could not open video: {video_path}")
     source_fps = float(capture.get(cv2.CAP_PROP_FPS) or 30.0)
+    effective_frame_stride = _sampling_frame_stride(
+        source_fps=source_fps,
+        frame_stride=frame_stride,
+        sample_interval_sec=sample_interval_sec,
+    )
     width = int(capture.get(cv2.CAP_PROP_FRAME_WIDTH) or 0)
     height = int(capture.get(cv2.CAP_PROP_FRAME_HEIGHT) or 0)
+    output_fps = source_fps
     output_size = _browser_frame_size(width, height)
     output_path = _output_path(video_path, output_dir)
     writer = _create_browser_mp4_writer(output_path, output_fps, output_size)
     frames: list[FrameSample] = []
     processed_frames = 0
     frame_index = -1
+    latest_detections: list[Detection] = []
     try:
         while True:
             ok, frame = capture.read()
             if not ok:
                 break
             frame_index += 1
+            if frame_index % effective_frame_stride == 0:
+                if processed_frames >= max_frames:
+                    break
+                timestamp_sec = frame_index / source_fps
+                frames.append(FrameSample(frame_index=frame_index, timestamp_sec=timestamp_sec))
+                latest_detections = detector.detect(
+                    frame,
+                    frame_index=frame_index,
+                    timestamp_sec=timestamp_sec,
+                    confidence=confidence,
+                    image_size=image_size,
+                    max_detections=max_detections,
+                )
+                detections.extend(latest_detections)
+                processed_frames += 1
+                if progress:
+                    progress(processed_frames, max_frames)
+            _draw_detections(frame, latest_detections)
+            _write_frame(writer, _fit_frame_to_output(frame, output_size))
     finally:
         writer.release()
         capture.release()
         processed_frames=processed_frames,
         source_fps=source_fps,
         output_fps=output_fps,
+        frame_stride=effective_frame_stride,
+        sample_interval_sec=sample_interval_sec,
     )
     detections: list[Detection],
     events: list[ActionEvent],
     frame_stride: int,
+    sample_interval_sec: float | None = None,
     max_frames: int,
     output_dir: str | None = None,
 ) -> str:
     if frame_stride < 1:
         raise ValueError("frame_stride must be at least 1.")
+    if sample_interval_sec is not None and sample_interval_sec <= 0:
+        raise ValueError("sample_interval_sec must be greater than 0.")
     if max_frames < 1:
         raise ValueError("max_frames must be at least 1.")
         raise ValueError(f"Could not open video: {source_video_path}")
     source_fps = float(capture.get(cv2.CAP_PROP_FPS) or 30.0)
+    effective_frame_stride = _sampling_frame_stride(
+        source_fps=source_fps,
+        frame_stride=frame_stride,
+        sample_interval_sec=sample_interval_sec,
+    )
     width = int(capture.get(cv2.CAP_PROP_FRAME_WIDTH) or 0)
     height = int(capture.get(cv2.CAP_PROP_FRAME_HEIGHT) or 0)
+    output_fps = source_fps
     output_size = _browser_frame_size(width, height)
     output_path = _output_path(source_video_path, output_dir, suffix="automated")
     writer = _create_browser_mp4_writer(output_path, output_fps, output_size)
     events_by_frame = _group_events_by_frame(events)
     processed_frames = 0
     frame_index = -1
+    latest_detections: list[Detection] = []
+    latest_events: list[ActionEvent] = []
     try:
         while True:
             ok, frame = capture.read()
             if not ok:
                 break
             frame_index += 1
+            if frame_index % effective_frame_stride == 0:
+                if processed_frames >= max_frames:
+                    break
+                latest_detections = detections_by_frame.get(frame_index, [])
+                latest_events = events_by_frame.get(frame_index, [])
+                processed_frames += 1
+            _draw_detections(frame, latest_detections)
+            if latest_events:
+                _draw_action_events(frame, latest_events)
+            _write_frame(writer, _fit_frame_to_output(frame, output_size))
     finally:
         writer.release()
         capture.release()
     return base_dir / f"{Path(video_path).stem}-{uuid4().hex[:8]}-{suffix}.mp4"
+def _sampling_frame_stride(
+    *,
+    source_fps: float,
+    frame_stride: int,
+    sample_interval_sec: float | None,
+) -> int:
+    if sample_interval_sec is None:
+        return frame_stride
+    return max(1, round(source_fps * sample_interval_sec))
 def _browser_frame_size(width: int, height: int) -> tuple[int, int]:
 def _create_browser_mp4_writer(output_path: Path, fps: float, frame_size: tuple[int, int]):
     import cv2
+    writer = cv2.VideoWriter(str(output_path), cv2.VideoWriter_fourcc(*MP4_CODEC), fps, frame_size)
+    if writer.isOpened():
+        return writer
+    writer.release()
     return None
                 "error",
                 "-i",
                 str(output_path),
+                "-c:v",
+                "libx264",
+                "-pix_fmt",
+                "yuv420p",
+                "-preset",
+                "veryfast",
                 "-movflags",
                 "+faststart",
                 str(faststart_path),
     return frame[:output_height, :output_width]
+def _write_frame(writer, frame) -> None:
+    writer.write(frame)
 def _draw_detections(frame, detections: list[Detection]) -> None: