From 06a1252088396fa5173cc18729f5dff57402b74b Mon Sep 17 00:00:00 2001 From: cclohmar Date: Wed, 5 Aug 2026 12:28:29 +0100 Subject: [PATCH] =?UTF-8?q?feat:=20v0.3.2=20=E2=80=94=20disk-based=20snaps?= =?UTF-8?q?hot=20engine,=20no=20go2rtc=20polling=20for=20grid?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- main.go | 9 ++++ public/app.js | 36 ++++++---------- snapshot.go | 113 ++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 135 insertions(+), 23 deletions(-) create mode 100644 snapshot.go diff --git a/main.go b/main.go index b7d4fb3..dc007b0 100644 --- a/main.go +++ b/main.go @@ -57,6 +57,11 @@ func main() { app.go2rtc = go2rtc } + // Start snapshot engine for all enabled cameras. + snaps := NewSnapshotEngine(cfg.Storage) + snaps.StartAll(cfg.Cameras) + app.snapshots = snaps + // Start the HTTP server (blocks). errCh := make(chan error, 1) go func() { @@ -104,6 +109,7 @@ type App struct { ConfigPath string server *Server go2rtc *Go2RTCManager + snapshots *SnapshotEngine } // StartServer initializes and starts the HTTP server. @@ -118,6 +124,9 @@ func (a *App) StartServer() error { // Shutdown performs a graceful shutdown of all services. func (a *App) Shutdown() { + if a.snapshots != nil { + a.snapshots.StopAll() + } if a.go2rtc != nil { a.go2rtc.Stop() } diff --git a/public/app.js b/public/app.js index 14cd9b9..16db46a 100644 --- a/public/app.js +++ b/public/app.js @@ -64,7 +64,6 @@ async function loadCameras() { function renderLiveGrid() { const grid = document.getElementById('grid'); grid.innerHTML = ''; - const tiles = []; for (let i = 0; i < 8; i++) { const cam = cameras[i]; const tile = document.createElement('div'); @@ -72,38 +71,29 @@ function renderLiveGrid() { tile.dataset.camId = cam ? cam.id : ''; if (cam && cam.enabled) { - const snapshotURL = `http://${location.hostname}:1984/api/frame.jpeg?src=${cam.id}_sub`; + // Static snapshot from disk — updated every 2s by the backend. + // Cache-bust with timestamp to force refresh. + const snapURL = `/recordings/snapshots/${cam.id}.jpg?t=${Date.now()}`; tile.innerHTML = ` - ${cam.name} + ${cam.name} ${cam.name} `; + // Auto-refresh every 3 seconds — no flooding, simple reload. + setInterval(() => { + const img = tile.querySelector('img'); + if (img && !tile.classList.contains('offline')) { + img.src = `/recordings/snapshots/${cam.id}.jpg?t=${Date.now()}`; + } + }, 3000); tile.addEventListener('click', () => openFocus(cam)); - tiles.push({ tile, url: snapshotURL, cam }); } else { tile.innerHTML = 'No Camera'; } grid.appendChild(tile); } - - // Stagger snapshot loading — one every 300ms to avoid flooding go2rtc. - let idx = 0; - function loadNext() { - if (idx >= tiles.length) return; - const { tile, url } = tiles[idx]; - const img = tile.querySelector('img'); - if (img) { - img.src = url + '&t=' + Date.now(); - // Refresh this tile every 3 seconds (staggered per camera). - setInterval(() => { - img.src = url + '&t=' + Date.now(); - }, 3000 + idx * 200); - } - idx++; - setTimeout(loadNext, 300); - } - loadNext(); } // ── Focus Overlay ── diff --git a/snapshot.go b/snapshot.go new file mode 100644 index 0000000..97d5132 --- /dev/null +++ b/snapshot.go @@ -0,0 +1,113 @@ +// NextNVR v0.3.2 — Snapshot engine +// Grabs a single JPEG frame from each camera every 2 seconds. +// Writes to /mnt/recordings/snapshots/{cam_id}.jpg via atomic rename. +// The web UI loads these static images — no go2rtc polling, no CORS, no flooding. +package main + +import ( + "fmt" + "log" + "os" + "os/exec" + "path/filepath" + "sync" + "time" +) + +// SnapshotEngine manages per-camera snapshot goroutines. +type SnapshotEngine struct { + mu sync.Mutex + stopChs map[string]chan struct{} + config StorageConfig +} + +// NewSnapshotEngine creates a new snapshot engine. +func NewSnapshotEngine(cfg StorageConfig) *SnapshotEngine { + return &SnapshotEngine{ + stopChs: make(map[string]chan struct{}), + config: cfg, + } +} + +// StartAll launches a snapshot goroutine for each enabled camera. +func (se *SnapshotEngine) StartAll(cameras []CameraConfig) { + outDir := filepath.Join(se.config.RecordingsPath, "snapshots") + if err := os.MkdirAll(outDir, 0755); err != nil { + log.Printf("snapshot: mkdir %s failed: %v", outDir, err) + return + } + + for _, cam := range cameras { + if !cam.Enabled { + continue + } + stopCh := make(chan struct{}) + se.mu.Lock() + se.stopChs[cam.ID] = stopCh + se.mu.Unlock() + go se.snapshotLoop(cam, outDir, stopCh) + } + log.Printf("snapshot: %d cameras started → %s", len(se.stopChs), outDir) +} + +// StopAll terminates all snapshot goroutines. +func (se *SnapshotEngine) StopAll() { + se.mu.Lock() + defer se.mu.Unlock() + for id, ch := range se.stopChs { + close(ch) + log.Printf("snapshot: stopped camera %s", id) + } + se.stopChs = make(map[string]chan struct{}) +} + +// snapshotLoop grabs a JPEG frame every 2 seconds and writes it atomically. +func (se *SnapshotEngine) snapshotLoop(cam CameraConfig, outDir string, stopCh chan struct{}) { + rtspURL := cam.RTSPSub + if rtspURL == "" { + rtspURL = fmt.Sprintf("rtsp://%s:%s@%s:554/Streaming/Channels/102", + cam.Username, cam.Password, cam.IP) + } + + outFile := filepath.Join(outDir, cam.ID+".jpg") + tmpFile := outFile + ".tmp" + interval := 2 * time.Second + + log.Printf("snapshot: %s → %s (every %v)", cam.ID, outFile, interval) + + // Immediately grab the first frame. + se.grabFrame(rtspURL, tmpFile, outFile, cam.ID) + + ticker := time.NewTicker(interval) + defer ticker.Stop() + + for { + select { + case <-stopCh: + return + case <-ticker.C: + se.grabFrame(rtspURL, tmpFile, outFile, cam.ID) + } + } +} + +// grabFrame launches ffmpeg to capture a single JPEG frame. +func (se *SnapshotEngine) grabFrame(rtspURL, tmpFile, outFile, camID string) { + cmd := exec.Command("ffmpeg", + "-hide_banner", "-loglevel", "error", + "-rtsp_transport", "tcp", + "-i", rtspURL, + "-vframes", "1", // exactly one frame + "-q:v", "5", // good JPEG quality (2-31, lower=better) + "-f", "image2", + "-y", // overwrite + tmpFile, + ) + + cmd.Run() // ignore errors — camera may be offline + + // Atomic rename: if ffmpeg succeeded, tmpFile exists. + if _, err := os.Stat(tmpFile); err == nil { + os.Rename(tmpFile, outFile) + } +}