Sergey Krashevich
78ef8fc064
Replace time.Now() calls in hot path with frame-based timing: - Pre-compute triggerLevel (integer comparison instead of float division) - Calibrate hold/cooldown budgets from FPS (default 30fps) - Periodic FPS recalibration every 150 frames for accuracy - Active motion path: 47ns → 3.6ns (13x faster) Update schema.json with detect mode and motion_threshold. Add threshold tuning guide to README.
511 lines
12 KiB
Go
511 lines
12 KiB
Go
package homekit
|
|
|
|
import (
|
|
"encoding/binary"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/AlexxIT/go2rtc/pkg/h264"
|
|
"github.com/pion/rtp"
|
|
)
|
|
|
|
// makeAVCC creates a fake AVCC packet with the given NAL type and total size.
|
|
func makeAVCC(nalType byte, totalSize int) []byte {
|
|
if totalSize < 5 {
|
|
totalSize = 5
|
|
}
|
|
b := make([]byte, totalSize)
|
|
binary.BigEndian.PutUint32(b[:4], uint32(totalSize-4))
|
|
b[4] = nalType
|
|
return b
|
|
}
|
|
|
|
func makePFrame(size int) *rtp.Packet {
|
|
return &rtp.Packet{Payload: makeAVCC(h264.NALUTypePFrame, size)}
|
|
}
|
|
|
|
func makeIFrame(size int) *rtp.Packet {
|
|
return &rtp.Packet{Payload: makeAVCC(h264.NALUTypeIFrame, size)}
|
|
}
|
|
|
|
type mockClock struct {
|
|
t time.Time
|
|
}
|
|
|
|
func (c *mockClock) now() time.Time { return c.t }
|
|
|
|
func (c *mockClock) advance(d time.Duration) { c.t = c.t.Add(d) }
|
|
|
|
type motionRecorder struct {
|
|
calls []bool
|
|
}
|
|
|
|
func (r *motionRecorder) onMotion(detected bool) {
|
|
r.calls = append(r.calls, detected)
|
|
}
|
|
|
|
func (r *motionRecorder) lastCall() (bool, bool) {
|
|
if len(r.calls) == 0 {
|
|
return false, false
|
|
}
|
|
return r.calls[len(r.calls)-1], true
|
|
}
|
|
|
|
func newTestDetector() (*motionDetector, *mockClock, *motionRecorder) {
|
|
det := newMotionDetector(nil)
|
|
clock := &mockClock{t: time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC)}
|
|
rec := &motionRecorder{}
|
|
det.now = clock.now
|
|
det.onMotion = rec.onMotion
|
|
return det, clock, rec
|
|
}
|
|
|
|
// warmup feeds the detector with small P-frames to build baseline.
|
|
func warmup(det *motionDetector, clock *mockClock, size int) {
|
|
for i := 0; i < motionWarmupFrames; i++ {
|
|
det.handlePacket(makePFrame(size))
|
|
clock.advance(33 * time.Millisecond) // ~30fps
|
|
}
|
|
}
|
|
|
|
// warmupWithBudgets performs warmup then sets test-friendly hold/cooldown budgets.
|
|
func warmupWithBudgets(det *motionDetector, clock *mockClock, size, hold, cooldown int) {
|
|
warmup(det, clock, size)
|
|
det.holdBudget = hold
|
|
det.cooldownBudget = cooldown
|
|
}
|
|
|
|
func TestMotionDetector_NoMotion(t *testing.T) {
|
|
det, clock, rec := newTestDetector()
|
|
|
|
warmup(det, clock, 500)
|
|
|
|
// feed same-size P-frames — no motion
|
|
for i := 0; i < 100; i++ {
|
|
det.handlePacket(makePFrame(500))
|
|
}
|
|
|
|
if len(rec.calls) != 0 {
|
|
t.Fatalf("expected no motion calls, got %d: %v", len(rec.calls), rec.calls)
|
|
}
|
|
}
|
|
|
|
func TestMotionDetector_MotionDetected(t *testing.T) {
|
|
det, clock, rec := newTestDetector()
|
|
|
|
warmup(det, clock, 500)
|
|
|
|
// large P-frame triggers motion
|
|
det.handlePacket(makePFrame(5000))
|
|
|
|
last, ok := rec.lastCall()
|
|
if !ok || !last {
|
|
t.Fatal("expected motion detected")
|
|
}
|
|
}
|
|
|
|
func TestMotionDetector_HoldTime(t *testing.T) {
|
|
det, clock, rec := newTestDetector()
|
|
|
|
warmupWithBudgets(det, clock, 500, 30, 5)
|
|
|
|
// trigger motion
|
|
det.handlePacket(makePFrame(5000))
|
|
|
|
if len(rec.calls) != 1 || !rec.calls[0] {
|
|
t.Fatal("expected motion ON")
|
|
}
|
|
|
|
// send 20 non-triggered frames — still active (< holdBudget=30)
|
|
for i := 0; i < 20; i++ {
|
|
det.handlePacket(makePFrame(500))
|
|
}
|
|
|
|
if len(rec.calls) != 1 {
|
|
t.Fatalf("expected only ON call during hold, got %v", rec.calls)
|
|
}
|
|
|
|
// send 15 more (total 35 > holdBudget=30) — should turn OFF
|
|
for i := 0; i < 15; i++ {
|
|
det.handlePacket(makePFrame(500))
|
|
}
|
|
|
|
last, _ := rec.lastCall()
|
|
if last {
|
|
t.Fatal("expected motion OFF after hold budget exhausted")
|
|
}
|
|
}
|
|
|
|
func TestMotionDetector_Cooldown(t *testing.T) {
|
|
det, clock, rec := newTestDetector()
|
|
|
|
warmupWithBudgets(det, clock, 500, 30, 5)
|
|
|
|
// trigger and expire motion
|
|
det.handlePacket(makePFrame(5000))
|
|
for i := 0; i < 30; i++ {
|
|
det.handlePacket(makePFrame(500))
|
|
}
|
|
if len(rec.calls) != 2 || rec.calls[1] != false {
|
|
t.Fatalf("expected ON then OFF, got %v", rec.calls)
|
|
}
|
|
|
|
// try to trigger again immediately — should be blocked by cooldown
|
|
det.handlePacket(makePFrame(5000))
|
|
if len(rec.calls) != 2 {
|
|
t.Fatalf("expected cooldown to block re-trigger, got %v", rec.calls)
|
|
}
|
|
|
|
// send frames to expire cooldown (blocked trigger consumed 1 decrement)
|
|
for i := 0; i < 5; i++ {
|
|
det.handlePacket(makePFrame(500))
|
|
}
|
|
|
|
// now re-trigger should work
|
|
det.handlePacket(makePFrame(5000))
|
|
if len(rec.calls) != 3 || !rec.calls[2] {
|
|
t.Fatalf("expected motion ON after cooldown, got %v", rec.calls)
|
|
}
|
|
}
|
|
|
|
func TestMotionDetector_SkipsKeyframes(t *testing.T) {
|
|
det, clock, rec := newTestDetector()
|
|
|
|
warmup(det, clock, 500)
|
|
|
|
// huge keyframe should not trigger motion
|
|
det.handlePacket(makeIFrame(50000))
|
|
|
|
if len(rec.calls) != 0 {
|
|
t.Fatal("keyframes should not trigger motion")
|
|
}
|
|
|
|
// verify baseline didn't change
|
|
det.handlePacket(makePFrame(500))
|
|
if len(rec.calls) != 0 {
|
|
t.Fatal("baseline should be unaffected by keyframes")
|
|
}
|
|
}
|
|
|
|
func TestMotionDetector_Warmup(t *testing.T) {
|
|
det, clock, rec := newTestDetector()
|
|
|
|
// during warmup, even large frames should not trigger
|
|
for i := 0; i < motionWarmupFrames; i++ {
|
|
det.handlePacket(makePFrame(5000))
|
|
clock.advance(33 * time.Millisecond)
|
|
}
|
|
|
|
if len(rec.calls) != 0 {
|
|
t.Fatal("warmup should not trigger motion")
|
|
}
|
|
}
|
|
|
|
func TestMotionDetector_BaselineFreeze(t *testing.T) {
|
|
det, clock, rec := newTestDetector()
|
|
|
|
warmup(det, clock, 500)
|
|
baselineBefore := det.baseline
|
|
|
|
// trigger motion
|
|
det.handlePacket(makePFrame(5000))
|
|
|
|
if len(rec.calls) != 1 || !rec.calls[0] {
|
|
t.Fatal("expected motion ON")
|
|
}
|
|
|
|
// feed large frames during motion — baseline should not change
|
|
for i := 0; i < 50; i++ {
|
|
det.handlePacket(makePFrame(5000))
|
|
}
|
|
|
|
if det.baseline != baselineBefore {
|
|
t.Fatalf("baseline changed during motion: %f -> %f", baselineBefore, det.baseline)
|
|
}
|
|
}
|
|
|
|
func TestMotionDetector_CustomThreshold(t *testing.T) {
|
|
det, clock, rec := newTestDetector()
|
|
det.threshold = 1.5
|
|
|
|
warmup(det, clock, 500)
|
|
|
|
// 1.6x — below default 2.0 but above custom 1.5
|
|
det.handlePacket(makePFrame(800))
|
|
|
|
if len(rec.calls) != 1 || !rec.calls[0] {
|
|
t.Fatalf("expected motion ON with custom threshold 1.5, got %v", rec.calls)
|
|
}
|
|
}
|
|
|
|
func TestMotionDetector_CustomThresholdNoFalsePositive(t *testing.T) {
|
|
det, clock, rec := newTestDetector()
|
|
det.threshold = 3.0
|
|
|
|
warmup(det, clock, 500)
|
|
|
|
// 2.5x — above default 2.0 but below custom 3.0
|
|
det.handlePacket(makePFrame(1250))
|
|
|
|
if len(rec.calls) != 0 {
|
|
t.Fatalf("expected no motion with high threshold 3.0, got %v", rec.calls)
|
|
}
|
|
}
|
|
|
|
func TestMotionDetector_HoldTimeExtended(t *testing.T) {
|
|
det, clock, rec := newTestDetector()
|
|
|
|
warmupWithBudgets(det, clock, 500, 30, 5)
|
|
|
|
// trigger motion
|
|
det.handlePacket(makePFrame(5000))
|
|
|
|
if len(rec.calls) != 1 || !rec.calls[0] {
|
|
t.Fatal("expected motion ON")
|
|
}
|
|
|
|
// send 25 non-triggered frames (remainingHold 30→5)
|
|
for i := 0; i < 25; i++ {
|
|
det.handlePacket(makePFrame(500))
|
|
}
|
|
|
|
// re-trigger — remainingHold resets to 30
|
|
det.handlePacket(makePFrame(5000))
|
|
|
|
// send 25 more non-triggered (remainingHold 30→5)
|
|
for i := 0; i < 25; i++ {
|
|
det.handlePacket(makePFrame(500))
|
|
}
|
|
|
|
// should still be ON
|
|
if len(rec.calls) != 1 {
|
|
t.Fatalf("expected hold time to be extended by re-trigger, got %v", rec.calls)
|
|
}
|
|
|
|
// send 10 more to exhaust hold
|
|
for i := 0; i < 10; i++ {
|
|
det.handlePacket(makePFrame(500))
|
|
}
|
|
|
|
last, _ := rec.lastCall()
|
|
if last {
|
|
t.Fatal("expected motion OFF after extended hold expired")
|
|
}
|
|
}
|
|
|
|
func TestMotionDetector_SmallPayloadIgnored(t *testing.T) {
|
|
det, clock, rec := newTestDetector()
|
|
|
|
warmup(det, clock, 500)
|
|
|
|
det.handlePacket(&rtp.Packet{Payload: []byte{1, 2, 3, 4}})
|
|
det.handlePacket(&rtp.Packet{Payload: nil})
|
|
det.handlePacket(&rtp.Packet{Payload: []byte{}})
|
|
|
|
if len(rec.calls) != 0 {
|
|
t.Fatalf("small payloads should be ignored, got %v", rec.calls)
|
|
}
|
|
}
|
|
|
|
func TestMotionDetector_BaselineAdapts(t *testing.T) {
|
|
det, clock, _ := newTestDetector()
|
|
|
|
warmup(det, clock, 500)
|
|
baselineAfterWarmup := det.baseline
|
|
|
|
// feed gradually larger frames — baseline should drift up
|
|
for i := 0; i < 200; i++ {
|
|
det.handlePacket(makePFrame(700))
|
|
}
|
|
|
|
if det.baseline <= baselineAfterWarmup {
|
|
t.Fatalf("baseline should adapt upward: before=%f after=%f", baselineAfterWarmup, det.baseline)
|
|
}
|
|
}
|
|
|
|
func TestMotionDetector_DoubleStopSafe(t *testing.T) {
|
|
det, clock, rec := newTestDetector()
|
|
|
|
warmup(det, clock, 500)
|
|
det.handlePacket(makePFrame(5000))
|
|
|
|
_ = det.Stop()
|
|
_ = det.Stop() // second stop should not panic
|
|
|
|
if len(rec.calls) != 2 {
|
|
t.Fatalf("expected ON+OFF, got %v", rec.calls)
|
|
}
|
|
}
|
|
|
|
func TestMotionDetector_StopWithoutMotion(t *testing.T) {
|
|
det, clock, _ := newTestDetector()
|
|
|
|
warmup(det, clock, 500)
|
|
|
|
rec := &motionRecorder{}
|
|
det.onMotion = rec.onMotion
|
|
_ = det.Stop()
|
|
|
|
if len(rec.calls) != 0 {
|
|
t.Fatalf("stop without motion should not call onMotion, got %v", rec.calls)
|
|
}
|
|
}
|
|
|
|
func TestMotionDetector_StopClearsMotion(t *testing.T) {
|
|
det, clock, rec := newTestDetector()
|
|
|
|
warmup(det, clock, 500)
|
|
|
|
det.handlePacket(makePFrame(5000))
|
|
if len(rec.calls) != 1 || !rec.calls[0] {
|
|
t.Fatal("expected motion ON")
|
|
}
|
|
|
|
_ = det.Stop()
|
|
|
|
if len(rec.calls) != 2 || rec.calls[1] != false {
|
|
t.Fatalf("expected Stop to clear motion, got %v", rec.calls)
|
|
}
|
|
}
|
|
|
|
func TestMotionDetector_WarmupBaseline(t *testing.T) {
|
|
det, clock, _ := newTestDetector()
|
|
|
|
for i := 0; i < motionWarmupFrames; i++ {
|
|
size := 400 + (i%5)*50
|
|
det.handlePacket(makePFrame(size))
|
|
clock.advance(33 * time.Millisecond)
|
|
}
|
|
|
|
if det.baseline < 400 || det.baseline > 600 {
|
|
t.Fatalf("baseline should be in 400-600 range, got %f", det.baseline)
|
|
}
|
|
}
|
|
|
|
func TestMotionDetector_MultipleCycles(t *testing.T) {
|
|
det, clock, rec := newTestDetector()
|
|
|
|
warmupWithBudgets(det, clock, 500, 30, 5)
|
|
|
|
for cycle := 0; cycle < 3; cycle++ {
|
|
det.handlePacket(makePFrame(5000)) // trigger ON
|
|
for i := 0; i < 30; i++ { // expire hold
|
|
det.handlePacket(makePFrame(500))
|
|
}
|
|
for i := 0; i < 6; i++ { // expire cooldown
|
|
det.handlePacket(makePFrame(500))
|
|
}
|
|
}
|
|
|
|
if len(rec.calls) != 6 {
|
|
t.Fatalf("expected 6 calls (3 cycles), got %d: %v", len(rec.calls), rec.calls)
|
|
}
|
|
for i, v := range rec.calls {
|
|
expected := i%2 == 0
|
|
if v != expected {
|
|
t.Fatalf("call[%d] = %v, expected %v", i, v, expected)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestMotionDetector_TriggerLevel(t *testing.T) {
|
|
det, clock, _ := newTestDetector()
|
|
|
|
warmup(det, clock, 500)
|
|
|
|
expected := int(det.baseline * det.threshold)
|
|
if det.triggerLevel != expected {
|
|
t.Fatalf("triggerLevel = %d, expected %d", det.triggerLevel, expected)
|
|
}
|
|
}
|
|
|
|
func TestMotionDetector_DefaultFPSCalibration(t *testing.T) {
|
|
det, clock, _ := newTestDetector()
|
|
|
|
warmup(det, clock, 500)
|
|
|
|
// calibrate uses default 30fps
|
|
expectedHold := int(motionHoldTime.Seconds() * motionDefaultFPS)
|
|
expectedCooldown := int(motionCooldown.Seconds() * motionDefaultFPS)
|
|
if det.holdBudget != expectedHold {
|
|
t.Fatalf("holdBudget = %d, expected %d", det.holdBudget, expectedHold)
|
|
}
|
|
if det.cooldownBudget != expectedCooldown {
|
|
t.Fatalf("cooldownBudget = %d, expected %d", det.cooldownBudget, expectedCooldown)
|
|
}
|
|
}
|
|
|
|
func TestMotionDetector_FPSRecalibration(t *testing.T) {
|
|
det, clock, _ := newTestDetector()
|
|
|
|
warmup(det, clock, 500)
|
|
|
|
// initial budgets use default 30fps
|
|
initialHold := det.holdBudget
|
|
|
|
// send motionTraceFrames frames with 100ms intervals → FPS=10
|
|
for i := 0; i < motionTraceFrames; i++ {
|
|
clock.advance(100 * time.Millisecond)
|
|
det.handlePacket(makePFrame(500))
|
|
}
|
|
|
|
// after recalibration, holdBudget should reflect ~10fps (±5% due to warmup tail)
|
|
expectedHold := int(motionHoldTime.Seconds() * 10.0) // ~300
|
|
if det.holdBudget < expectedHold-20 || det.holdBudget > expectedHold+20 {
|
|
t.Fatalf("holdBudget after recalibration = %d, expected ~%d (was %d)", det.holdBudget, expectedHold, initialHold)
|
|
}
|
|
}
|
|
|
|
func BenchmarkMotionDetector_HandlePacket(b *testing.B) {
|
|
det, clock, _ := newTestDetector()
|
|
warmup(det, clock, 500)
|
|
|
|
pkt := makePFrame(600)
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
det.handlePacket(pkt)
|
|
}
|
|
}
|
|
|
|
func BenchmarkMotionDetector_WithKeyframes(b *testing.B) {
|
|
det, clock, _ := newTestDetector()
|
|
warmup(det, clock, 500)
|
|
|
|
pFrame := makePFrame(600)
|
|
iFrame := makeIFrame(10000)
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
if i%30 == 0 {
|
|
det.handlePacket(iFrame)
|
|
} else {
|
|
det.handlePacket(pFrame)
|
|
}
|
|
}
|
|
}
|
|
|
|
func BenchmarkMotionDetector_MotionActive(b *testing.B) {
|
|
det, clock, _ := newTestDetector()
|
|
warmup(det, clock, 500)
|
|
|
|
// trigger motion and keep it active
|
|
det.handlePacket(makePFrame(5000))
|
|
pkt := makePFrame(5000)
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
det.handlePacket(pkt)
|
|
}
|
|
}
|
|
|
|
func BenchmarkMotionDetector_Warmup(b *testing.B) {
|
|
pkt := makePFrame(500)
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
det := newMotionDetector(nil)
|
|
det.onMotion = func(bool) {}
|
|
det.now = time.Now
|
|
for j := 0; j < motionWarmupFrames; j++ {
|
|
det.handlePacket(pkt)
|
|
}
|
|
}
|
|
}
|