Fix invisible/flashing clock, map Protect's 8-camera preset, warn on gaps

Three separate faults made cameras "not load" and the clock misbehave.

Clock rendered as nothing, or flashed ~200ms/second. The time was drawn as
an ASS osd-overlay pushed over mpv IPC, but on mpv 0.35 + Mesa/V3D + sway an
OSD overlay is rendered only on the frame where its content *changes*. Every
layer reports success while this happens (mpv returns error:success,
vo-configured is true, and sway reports the window visible at the right
rect), so it looks like a stacking or font bug and is neither. Ruled out:
pushing at 20Hz (identical content is ignored, so it still only redrew when
the second flipped), osd-msg1, show-text, and --pause (mpv stops redrawing
entirely). Fonts were never the issue.

The time is now baked into every frame by a drawtext filter re-reading a
small file the ticker rewrites once a second, with two constraints that cost
real time to find and are pinned by tests:

- The canvas alpha must be > 0. A fully transparent canvas (black@0.0 with
  --alpha=yes) makes the glyphs inherit alpha 0 and the compositor draws
  nothing -- this was the original invisible clock. New clock
  background_opacity (default 0.45) is clamped in config *and* in args() so
  no code path can produce an invisible clock.
- Readahead must be off. drawtext stamps the time when a frame is
  *generated*, so buffering ahead makes the visible clock lag by the
  readahead and swallows text-file updates entirely.

Since the text now arrives through a file, the clock needs no IPC socket:
dropped --input-ipc-server, the ipcPath field, and the stale-socket removal.
assEscape goes with the ASS path.

`views import` produced layouts with holes. viewmap derived the grid from
the slot count alone and ignored Protect's `layout` field, so Protect's
asymmetric 8-camera preset (four 2x2 tiles plus a right column of four 1x1)
landed as 8 tiles in a 3x3 grid -- the bottom-right cell was simply empty
and rendered as a blank rectangle. That preset is now mapped exactly; other
counts keep the uniform GridForSlots fallback rather than guessing at
presets I have not observed. Import also warns when a mapping would leave
empty cells or references a camera missing from the config, so a silent hole
cannot reach the screen again.

Also:

- clock.corner gains bottom-center and top-center (centered horizontally,
  Margin still applies vertically).
- placeClock no longer re-issues `resize set` every tick. Re-asserting
  geometry on a correctly-sized window makes sway send a configure event,
  which makes mpv reallocate buffers and blank for a frame. New
  compositor.Raise re-asserts z-order only, which is all the 2s tick needs;
  geometry is re-placed only when it has actually drifted.
- README documents why the clock is drawn this way, the preset table and how
  to add another from `views dump`, and three troubleshooting entries for
  failure modes that all look like bugs: a blank tile whose mpv is running
  (a stale camera entry -- re-adopting a camera in Protect assigns a new id
  and often a slightly different name, and `discover` never prunes), cameras
  in `cameras:` not being on screen (only the active layout's tiles stream),
  and black bars inside tiles (non-16:9 grid cells; --panscan=1.0 crops to
  fill instead).

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LYhTnkp7VzJ67THeicgfAQ

internal/player/player_test.go

@@ -2,8 +2,13 @@ package player
 
 import (
 	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
 	"testing"
+	"time"
 
+	"github.com/lwoodard/rtsp-streamer/internal/config"
 	"github.com/lwoodard/rtsp-streamer/internal/logbuf"
 )
 
@@ -29,3 +34,90 @@ func TestLastLineNil(t *testing.T) {
 		t.Errorf("lastLine(nil) = %q, want empty", got)
 	}
 }
+
+func testClock(cfg config.Clock) *Clock {
+	return &Clock{cfg: cfg, textPath: "/run/user/1000/rtsp-streamer/clock-text.txt"}
+}
+
+// A zero-alpha canvas makes the drawn text inherit alpha 0, so the clock
+// renders as nothing at all. Config clamps the opacity, and args() must clamp
+// too rather than emitting a fully transparent canvas.
+func TestClockCanvasIsNeverFullyTransparent(t *testing.T) {
+	for _, opacity := range []float64{0, -1, 0.45, 1} {
+		c := testClock(config.Clock{Width: 300, Height: 72, BackgroundOpacity: opacity})
+		src := c.args()[len(c.args())-1]
+		if strings.Contains(src, "black@0.000") {
+			t.Errorf("opacity %v produced a fully transparent canvas: %s", opacity, src)
+		}
+		if !strings.Contains(src, "s=300x72") {
+			t.Errorf("opacity %v: size missing from %s", opacity, src)
+		}
+	}
+}
+
+// The configured opacity must reach the filtergraph verbatim.
+func TestClockCanvasUsesConfiguredOpacity(t *testing.T) {
+	src := testClock(config.Clock{Width: 300, Height: 72, BackgroundOpacity: 0.6}).args()
+	if got := src[len(src)-1]; !strings.Contains(got, "black@0.600") {
+		t.Errorf("got %s, want canvas alpha 0.600", got)
+	}
+}
+
+// The time must be baked into every frame by drawtext, reloading the text file
+// each frame. An mpv OSD overlay only renders on the frame where its content
+// changes, which showed up as a flashing clock.
+func TestClockDrawsTextIntoEveryFrame(t *testing.T) {
+	c := testClock(config.Clock{Width: 300, Height: 72, FontSize: 44})
+	src := c.args()[len(c.args())-1]
+	for _, want := range []string{
+		"drawtext=textfile=" + c.textPath,
+		"reload=1",    // re-read the file per frame, else the clock freezes
+		"fontsize=44", // from config, not hardcoded
+		"borderw=3",   // outline for legibility over bright scenes
+	} {
+		if !strings.Contains(src, want) {
+			t.Errorf("filtergraph missing %q:\n  %s", want, src)
+		}
+	}
+}
+
+// drawtext stamps the time when a frame is generated, so buffering ahead makes
+// the visible clock lag. These flags keep generation just-in-time.
+func TestClockDisablesReadahead(t *testing.T) {
+	args := testClock(config.Clock{Width: 300, Height: 72, FontSize: 44}).args()
+	joined := strings.Join(args, " ")
+	for _, want := range []string{"--cache=no", "--demuxer-readahead-secs=0"} {
+		if !strings.Contains(joined, want) {
+			t.Errorf("args missing %q", want)
+		}
+	}
+}
+
+// writeText must replace the file atomically so drawtext cannot read a
+// half-written time, and must honour the configured layout and zone.
+func TestClockWriteTextIsAtomicAndFormatted(t *testing.T) {
+	dir := t.TempDir()
+	loc, err := time.LoadLocation("America/Denver")
+	if err != nil {
+		t.Fatal(err)
+	}
+	c := &Clock{
+		cfg:      config.Clock{Format: "15:04:05"},
+		loc:      loc,
+		textPath: filepath.Join(dir, "clock-text.txt"),
+	}
+	if err := c.writeText(); err != nil {
+		t.Fatal(err)
+	}
+	b, err := os.ReadFile(c.textPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got := string(b); len(got) != len("15:04:05") {
+		t.Errorf("wrote %q, want an HH:MM:SS-shaped time", got)
+	}
+	// The temp file used for the atomic rename must not be left behind.
+	if _, err := os.Stat(c.textPath + ".tmp"); !os.IsNotExist(err) {
+		t.Errorf("temp file left behind: %v", err)
+	}
+}