119 lines
2.7 KiB
Go
119 lines
2.7 KiB
Go
// NextNVR — MIT License
|
|
// Copyright (c) 2026 NextNVR Contributors
|
|
// SPDX-License-Identifier: MIT
|
|
|
|
// Fetches JPEG frames from go2rtc's already-decoded stream buffer.
|
|
// go2rtc maintains persistent RTSP connections — frames are instant.
|
|
// Writes latest.jpg every 1s (live wall) and snap_*.jpg every 60s (archive).
|
|
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
"log"
|
|
"net/http"
|
|
"os"
|
|
"path/filepath"
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
var httpClient = &http.Client{Timeout: 5 * time.Second}
|
|
|
|
// SnapshotEngine manages per-camera snapshot goroutines.
|
|
type SnapshotEngine struct {
|
|
mu sync.Mutex
|
|
stopChs map[string]chan struct{}
|
|
config StorageConfig
|
|
}
|
|
|
|
func NewSnapshotEngine(cfg StorageConfig) *SnapshotEngine {
|
|
return &SnapshotEngine{
|
|
stopChs: make(map[string]chan struct{}),
|
|
config: cfg,
|
|
}
|
|
}
|
|
|
|
func (se *SnapshotEngine) StartAll(cameras []CameraConfig) {
|
|
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, stopCh)
|
|
}
|
|
log.Printf("snapshot: %d cameras started (via go2rtc)", len(se.stopChs))
|
|
}
|
|
|
|
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{})
|
|
}
|
|
|
|
func (se *SnapshotEngine) snapshotLoop(cam CameraConfig, stopCh chan struct{}) {
|
|
camDirName := cam.Name
|
|
if camDirName == "" {
|
|
camDirName = cam.ID
|
|
}
|
|
outDir := filepath.Join(se.config.RecordingsPath, camDirName)
|
|
os.MkdirAll(outDir, 0755)
|
|
|
|
latestFile := filepath.Join(outDir, "latest.jpg")
|
|
tmpFile := latestFile + ".tmp"
|
|
frameURL := fmt.Sprintf("http://127.0.0.1:1984/api/frame.jpeg?src=%s_sub", cam.ID)
|
|
lastArchive := time.Time{}
|
|
|
|
log.Printf("snapshot: %s → %s", cam.ID, outDir)
|
|
|
|
// Grab first frame immediately.
|
|
se.grab(frameURL, tmpFile, latestFile, outDir, cam.ID, &lastArchive)
|
|
|
|
ticker := time.NewTicker(1 * time.Second)
|
|
defer ticker.Stop()
|
|
|
|
for {
|
|
select {
|
|
case <-stopCh:
|
|
return
|
|
case <-ticker.C:
|
|
se.grab(frameURL, tmpFile, latestFile, outDir, cam.ID, &lastArchive)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (se *SnapshotEngine) grab(url, tmpFile, latestFile, outDir, camID string, lastArchive *time.Time) {
|
|
resp, err := httpClient.Get(url)
|
|
if err != nil {
|
|
return
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
return
|
|
}
|
|
|
|
data, err := io.ReadAll(resp.Body)
|
|
if err != nil || len(data) < 100 {
|
|
return
|
|
}
|
|
|
|
// Atomic write.
|
|
os.WriteFile(tmpFile, data, 0644)
|
|
os.Rename(tmpFile, latestFile)
|
|
|
|
// Archive every 60s.
|
|
now := time.Now()
|
|
if now.Sub(*lastArchive) >= 60*time.Second {
|
|
archiveFile := filepath.Join(outDir, "snap_"+now.Format("2006-01-02-15-04-05")+".jpg")
|
|
os.WriteFile(archiveFile, data, 0644)
|
|
*lastArchive = now
|
|
}
|
|
}
|