0.2.66 - End Credits improvements / Gateway: 0.1.47 - End credits redesign

server/internal/credits/detector_test.go

@@ -160,3 +160,87 @@ func TestVisualConfidenceIsCapped(t *testing.T) {
 		t.Fatalf("a detection at the separation threshold scored %.2f, below the bar", score)
 	}
 }
+
+// The onset walk-back, tested on scores directly.
+//
+// It is pure and it is the only thing in the detector that can move a marker *earlier*, so
+// its two bounds matter more than the movement itself: a hard cut must not move at all, and
+// a long ramp must not drag the marker back into the programme.
+
+// establishedCredits is the score a fully-established roll produces, near enough — the
+// literal matters only as the thing onsetFraction is measured against.
+const establishedCredits = 0.90
+
+func TestBackOffWalksIntoTheFade(t *testing.T) {
+	// Forty frames of programme, three of fade, then the roll. The split arrives at the first
+	// fully-established frame; the fade before it is already the credits.
+	scores := make([]float64, 0, 60)
+	for range 40 {
+		scores = append(scores, 0.02)
+	}
+	scores = append(scores, 0.40, 0.55, 0.75)
+	for range 17 {
+		scores = append(scores, establishedCredits)
+	}
+
+	onset := backOffToOnset(scores, 43, establishedCredits, fineInterval)
+	if onset != 40 {
+		t.Fatalf("onset at frame %d, want 40 (the first frame of the fade)", onset)
+	}
+}
+
+// A cut straight from programme to credits has no fade to find, and the split was already
+// right. Moving it would be inventing a ramp that is not there.
+func TestBackOffStopsAtAHardCut(t *testing.T) {
+	scores := make([]float64, 0, 60)
+	for range 40 {
+		scores = append(scores, 0.02)
+	}
+	for range 20 {
+		scores = append(scores, establishedCredits)
+	}
+
+	if onset := backOffToOnset(scores, 40, establishedCredits, fineInterval); onset != 40 {
+		t.Fatalf("a hard cut moved from 40 to %d", onset)
+	}
+}
+
+// The bound is what stops a scene dimming gradually towards the credits pulling the marker
+// back through the last minute of the programme.
+func TestBackOffIsBounded(t *testing.T) {
+	// Everything qualifies, so only the bound can stop the walk.
+	scores := make([]float64, 80)
+	for index := range scores {
+		scores[index] = establishedCredits
+	}
+
+	onset := backOffToOnset(scores, 60, establishedCredits, fineInterval)
+	limit := int(float64(onsetBackoffMs) / float64(fineInterval.Milliseconds()))
+	if onset != 60-limit {
+		t.Fatalf("walked back to %d, want %d (%d frames)", onset, 60-limit, limit)
+	}
+	if travelled := (60 - onset) * int(fineInterval.Milliseconds()); travelled > onsetBackoffMs {
+		t.Fatalf("walked back %dms, past the %dms bound", travelled, onsetBackoffMs)
+	}
+}
+
+// A frame that is dark but not yet mostly credit-like is still the programme.
+func TestBackOffRefusesAFrameBelowTheOnsetFraction(t *testing.T) {
+	scores := []float64{0.02, 0.02, 0.10, establishedCredits, establishedCredits}
+	// 0.10 is well under onsetFraction of the established level.
+	if onset := backOffToOnset(scores, 3, establishedCredits, fineInterval); onset != 3 {
+		t.Fatalf("a below-threshold frame was walked into: onset %d, want 3", onset)
+	}
+}
+
+// Guarding the degenerate inputs rather than trusting callers, since this runs on whatever
+// the sampler produced.
+func TestBackOffHandlesDegenerateInput(t *testing.T) {
+	scores := []float64{establishedCredits, establishedCredits}
+	if onset := backOffToOnset(scores, 0, establishedCredits, fineInterval); onset != 0 {
+		t.Fatalf("a split at zero moved to %d", onset)
+	}
+	if onset := backOffToOnset(scores, 1, 0, fineInterval); onset != 1 {
+		t.Fatalf("an established level of zero moved the split to %d", onset)
+	}
+}