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
This commit is contained in:
Levi Woodard
@@ -7,6 +7,7 @@ import (
|
||||
"os"
|
||||
"os/exec"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"sync"
|
||||
"syscall"
|
||||
"time"
|
||||
@@ -15,18 +16,27 @@ import (
|
||||
)
|
||||
|
||||
// Clock is a small always-on-top mpv window that renders the current local
|
||||
// time. The window plays a fully transparent lavfi canvas (so the camera video
|
||||
// shows through) and the time is drawn as an ASS overlay pushed over mpv's IPC
|
||||
// once a second: white glyphs with a black outline, which stay legible over
|
||||
// both bright (day) and dark (night) scenes without sampling the picture. The
|
||||
// time is formatted in Go against a fixed timezone, so it does not depend on
|
||||
// the host clock's zone and gets DST right.
|
||||
// time: white glyphs with a black outline, which stay legible over both bright
|
||||
// (day) and dark (night) scenes without sampling the picture. The time is
|
||||
// formatted in Go against a fixed timezone, so it does not depend on the host
|
||||
// clock's zone and gets DST right.
|
||||
//
|
||||
// The text is baked into the canvas by an ffmpeg drawtext filter reading
|
||||
// textPath, which the ticker rewrites once a second (drawtext's reload=1 re-reads
|
||||
// the file every frame). It is deliberately NOT drawn as an mpv OSD overlay:
|
||||
// on mpv 0.35 + Mesa/V3D + sway, osd-overlay renders only on the single frame
|
||||
// where its content changes, so an IPC-pushed clock appears for ~200ms a second
|
||||
// and reads as a flashing clock. Baking the text into every frame is stable.
|
||||
//
|
||||
// Because the text is rendered when a frame is *generated*, the canvas must not
|
||||
// be buffered ahead of display or the visible time lags — see args() for the
|
||||
// cache flags that keep generation just-in-time.
|
||||
type Clock struct {
|
||||
cfg config.Clock
|
||||
loc *time.Location
|
||||
runDir string
|
||||
ipcPath string
|
||||
log *slog.Logger
|
||||
cfg config.Clock
|
||||
loc *time.Location
|
||||
runDir string
|
||||
textPath string
|
||||
log *slog.Logger
|
||||
|
||||
mu sync.Mutex
|
||||
cmd *exec.Cmd
|
||||
@@ -39,13 +49,35 @@ func NewClock(cfg config.Clock, runDir string, log *slog.Logger) (*Clock, error)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("clock timezone %q: %w", cfg.Timezone, err)
|
||||
}
|
||||
return &Clock{
|
||||
cfg: cfg,
|
||||
loc: loc,
|
||||
runDir: runDir,
|
||||
ipcPath: filepath.Join(runDir, "mpv-clock.sock"),
|
||||
log: log.With("comp", "clock"),
|
||||
}, nil
|
||||
textPath := filepath.Join(runDir, "clock-text.txt")
|
||||
// A ':' or '\' in the path would be read as filtergraph syntax and break the
|
||||
// drawtext option rather than pointing at the file.
|
||||
if strings.ContainsAny(textPath, `:\`) {
|
||||
return nil, fmt.Errorf("clock text path %q contains a character that cannot be escaped in a filtergraph", textPath)
|
||||
}
|
||||
c := &Clock{
|
||||
cfg: cfg,
|
||||
loc: loc,
|
||||
runDir: runDir,
|
||||
textPath: textPath,
|
||||
log: log.With("comp", "clock"),
|
||||
}
|
||||
// drawtext fails to initialise if the file is missing, which would take the
|
||||
// whole window down, so seed it before mpv ever starts.
|
||||
if err := c.writeText(); err != nil {
|
||||
return nil, fmt.Errorf("seeding clock text: %w", err)
|
||||
}
|
||||
return c, nil
|
||||
}
|
||||
|
||||
// writeText renders the current time and replaces textPath atomically, so
|
||||
// drawtext never reads a half-written file.
|
||||
func (c *Clock) writeText() error {
|
||||
tmp := c.textPath + ".tmp"
|
||||
if err := os.WriteFile(tmp, []byte(time.Now().In(c.loc).Format(c.cfg.Format)), 0o644); err != nil {
|
||||
return err
|
||||
}
|
||||
return os.Rename(tmp, c.textPath)
|
||||
}
|
||||
|
||||
// Title is the window title, so the compositor can match the clock by title.
|
||||
@@ -62,12 +94,31 @@ func (c *Clock) PID() int {
|
||||
}
|
||||
|
||||
func (c *Clock) args() []string {
|
||||
// A transparent RGBA canvas at a few fps; the text is drawn via osd-overlay,
|
||||
// so nothing needs to be escaped into the filtergraph. --alpha=yes lets the
|
||||
// transparent areas composite over the camera windows behind it (if the
|
||||
// compositor can't do alpha, the canvas is black and the outlined white
|
||||
// text is still perfectly readable — it just gains a dark backing).
|
||||
src := fmt.Sprintf("av://lavfi:color=c=black@0.0:s=%dx%d:r=4,format=rgba", c.cfg.Width, c.cfg.Height)
|
||||
// A mostly-transparent RGBA canvas at a few fps; the text is drawn via
|
||||
// osd-overlay, so nothing needs to be escaped into the filtergraph.
|
||||
// --alpha=yes lets the canvas composite over the camera windows behind it.
|
||||
//
|
||||
// The canvas alpha must stay > 0. mpv blends the OSD into the canvas, and
|
||||
// on a fully transparent one the text inherits alpha 0, so the compositor
|
||||
// draws nothing at all and the clock silently vanishes (observed on
|
||||
// Mesa/V3D + sway). BackgroundOpacity is clamped to a non-zero default in
|
||||
// config; the dark backing it produces also keeps the white text legible
|
||||
// against bright daytime scenes.
|
||||
// Clamped here too, not just in config, so a Clock built by any other path
|
||||
// still cannot render itself invisible.
|
||||
opacity := c.cfg.BackgroundOpacity
|
||||
if opacity <= 0 {
|
||||
opacity = 0.45
|
||||
} else if opacity > 1 {
|
||||
opacity = 1
|
||||
}
|
||||
// borderw draws the black outline that keeps white glyphs readable against a
|
||||
// bright scene; the text is centred on the canvas.
|
||||
src := fmt.Sprintf(
|
||||
"av://lavfi:color=c=black@%.3f:s=%dx%d:r=4,format=rgba,"+
|
||||
"drawtext=textfile=%s:reload=1:fontsize=%d:fontcolor=white:"+
|
||||
"borderw=3:bordercolor=black:x=(w-text_w)/2:y=(h-text_h)/2",
|
||||
opacity, c.cfg.Width, c.cfg.Height, c.textPath, c.cfg.FontSize)
|
||||
return []string{
|
||||
"--no-config",
|
||||
"--force-window=yes",
|
||||
@@ -83,15 +134,23 @@ func (c *Clock) args() []string {
|
||||
"--no-audio",
|
||||
"--keepaspect=no",
|
||||
"--alpha=yes",
|
||||
// drawtext stamps the time when a frame is GENERATED, so any readahead
|
||||
// shows a stale clock (buffering a few seconds ahead made the displayed
|
||||
// time lag by that much and swallowed text updates entirely). Keep
|
||||
// generation just-in-time.
|
||||
"--cache=no",
|
||||
"--demuxer-readahead-secs=0",
|
||||
"--demuxer-max-bytes=64KiB",
|
||||
"--profile=low-latency",
|
||||
"--title=" + c.Title(),
|
||||
"--input-ipc-server=" + c.ipcPath,
|
||||
fmt.Sprintf("--geometry=%dx%d", c.cfg.Width, c.cfg.Height),
|
||||
src,
|
||||
}
|
||||
}
|
||||
|
||||
// start launches the clock mpv. It needs no IPC socket: the time reaches the
|
||||
// window through textPath, which drawtext re-reads every frame.
|
||||
func (c *Clock) start(ctx context.Context) error {
|
||||
_ = os.Remove(c.ipcPath)
|
||||
cmd := exec.CommandContext(ctx, "mpv", c.args()...)
|
||||
cmd.Cancel = func() error { return cmd.Process.Signal(syscall.SIGTERM) }
|
||||
cmd.WaitDelay = 2 * time.Second
|
||||
@@ -162,30 +221,11 @@ func (c *Clock) tick(ctx context.Context, done <-chan struct{}) {
|
||||
}
|
||||
}
|
||||
|
||||
// push renders the current time as ASS and sends it as an OSD overlay. an5
|
||||
// centers it in the window; \bord gives the black outline, \1c/\3c set the
|
||||
// white fill and black outline colors (ASS is &HBBGGRR&).
|
||||
// push publishes the current time for the drawtext filter to pick up on its
|
||||
// next frame. Failures are logged at warn, not debug: a clock that stops
|
||||
// updating is silently wrong, which is worse than one that is visibly absent.
|
||||
func (c *Clock) push() {
|
||||
text := assEscape(time.Now().In(c.loc).Format(c.cfg.Format))
|
||||
data := fmt.Sprintf(
|
||||
`{\an5\fs%d\bord3\shad1\1c&HFFFFFF&\3c&H000000&\4c&H000000&\b1}%s`,
|
||||
c.cfg.FontSize, text,
|
||||
)
|
||||
if _, err := ipcCommand(c.ipcPath, "osd-overlay", 1, "ass-events", data, 0, c.cfg.Height, 0, false, false); err != nil {
|
||||
c.log.Debug("clock overlay update failed", "err", err)
|
||||
if err := c.writeText(); err != nil {
|
||||
c.log.Warn("clock text update failed", "path", c.textPath, "err", err)
|
||||
}
|
||||
}
|
||||
|
||||
// assEscape drops the few characters that are special in ASS override text, so
|
||||
// an unusual time format string can't break rendering. These never appear in a
|
||||
// rendered time, so dropping them is harmless.
|
||||
func assEscape(s string) string {
|
||||
r := make([]rune, 0, len(s))
|
||||
for _, ch := range s {
|
||||
if ch == '{' || ch == '}' || ch == '\\' {
|
||||
continue
|
||||
}
|
||||
r = append(r, ch)
|
||||
}
|
||||
return string(r)
|
||||
}
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user