| `FRESH_MPV_FOR_VIDEO` | `yes` startet mpv vor jedem Video neu (umgeht den `partial file`-Abbruch) |

**Ein Video bleibt nach ein paar Sekunden stehen.**

Seit Version 1.0.0 wird jede Datei einzeln an mpv übergeben; der früher

beobachtete Abbruch mit `partial file` beim Übergang Bild → Video ist damit

erledigt. Tritt trotzdem etwas auf, misst `scripts/bisect-mpv.sh` jede Variante

einzeln durch.

Zuerst `MPV_HWDEC="no"` prüfen (seit Version 1.0.0 die Voreinstellung). Der

scripts/probe-transition.py  prueft den Uebergang Bild -> Video im selben mpv

# mpv vor jedem Video frisch starten.

# Auf manchen Systemen bricht ein Video ab, wenn mpv vorher schon ein Bild

# angezeigt hat ("partial file" im Protokoll). Ein frischer Prozess je Video

# umgeht das; der Preis ist ein kurzer schwarzer Moment davor.

# Mit scripts/probe-transition.py laesst sich pruefen, ob "no" reicht.

FRESH_MPV_FOR_VIDEO="yes"

		FreshForVideo: true,

		case "FRESH_MPV_FOR_VIDEO":

			c.FreshForVideo = isTrue(val)

// Package player startet und ueberwacht mpv und steuert die Wiedergabe.

// mpv bekommt bewusst KEINE Playliste, sondern immer nur die eine Datei, die

// gerade laufen soll (loadfile ... replace). Die Reihenfolge fuehrt dieses

// Programm selbst. Grund: eine gemischte Playliste aus Bildern und Videos

// bringt den Demuxer durcheinander - eine Videodatei, die allein einwandfrei

// laeuft, bricht als zweiter Eintrag nach kurzer Zeit mit "partial file" ab.

// Als jeweils einzige geladene Datei tritt das nicht auf; nebenbei haben wir

// so die volle Kontrolle ueber Reihenfolge, Weiterschalten und Fehlerfaelle.

	"errors"

// Takt der Ueberwachung: haengende Dateien und leerer Bildschirm.

// Wartezeit, bevor nach lauter fehlerhaften Dateien erneut versucht wird.

const retryDelay = 15 * time.Second

// errFreshMpv ist kein Fehler, sondern der Wunsch nach einem frischen

// mpv-Prozess fuer die naechste Datei. Siehe FRESH_MPV_FOR_VIDEO.

var errFreshMpv = errors.New("frischer mpv-prozess fuer das naechste video")

// Player haelt genau einen mpv-Prozess am Leben und schaltet die Dateien weiter.

	mu     sync.RWMutex

	client *mpv.Client

	status Status

	playing     string    // Datei, die wir mpv zuletzt uebergeben haben

	index       int       // deren Platz in der Playliste

	errStreak   int       // Dateien in Folge, die sich nicht abspielen liessen

	lastAttempt time.Time // wann zuletzt eine Datei geladen wurde

	loadedCount int // Dateien, die dieser mpv-Prozess schon geladen hat

	advance   chan int

		advance:   make(chan int, 4),

	return p.status

		err := p.runOnce(ctx, settingsChanged)

		if errors.Is(err, errFreshMpv) {

			// Geplanter, kurzer Neustart - kein Grund zu warten.

			continue

		}

		if err != nil {

			log.Printf("player: %v", err)

			p.setError(err.Error())

		}

// runOnce startet mpv, verbindet sich mit dem IPC-Socket und bleibt, bis mpv

// endet oder ctx abgebrochen wird.

	// stdin durchreichen: bei --vo=gpu --gpu-context=drm braucht mpv das

	// Terminal der Konsole (tty1), um den Bildschirm uebernehmen zu duerfen.

	p.index = 0

	p.errStreak = 0

	p.loadedCount = 0

		propPath: "path", propPause: "pause",

	if err := p.step(client, 0); err != nil { // erste Datei laden

		return err

	}

			// Aenderungen greifen von selbst beim naechsten Dateiwechsel, weil

			// dort die Playliste neu gelesen wird. Nur wenn gerade nichts

			// laeuft, muss die Wiedergabe angestossen werden.

			p.mu.RLock()

			idleNow := p.playing == ""

			p.mu.RUnlock()

			if idleNow {

				if err := p.step(client, 0); err != nil {

					return err

				}

			}

		case delta := <-p.advance:

			if err := p.step(client, delta); err != nil {

				return err

			}

		case <-p.reloadNow:

			p.playing = ""

			p.index = 0

			p.errStreak = 0

			if err := p.step(client, 0); err != nil {

				return err

			if err := p.tick(client); err != nil {

				return err

			}

			if err := p.handleEvent(client, ev); err != nil {

				return err

			}

func (p *Player) handleEvent(client *mpv.Client, ev mpv.Event) error {

				// Eine Datei laeuft wieder - die Fehlerkette ist unterbrochen.

				p.errStreak = 0

	case "end-file":

		// "stop" kommt von unserem eigenen loadfile - das darf nicht

		// weiterschalten, sonst wird jede zweite Datei uebersprungen.

		var e struct {

			Reason    string `json:"reason"`

			FileError string `json:"file_error"`

		_ = json.Unmarshal(ev.Raw, &e)

		switch e.Reason {

		case "eof":

			return p.step(client, 1)

		case "error":

			p.mu.Lock()

			bad := p.playing

			p.errStreak++

			p.mu.Unlock()

			log.Printf("player: %q liess sich nicht abspielen (%s) - wird uebersprungen",

				bad, strings.TrimSpace(e.FileError))

			p.setError(fmt.Sprintf("%s liess sich nicht abspielen", bad))

			return p.step(client, 1)

	return nil

// step schaltet um delta Eintraege weiter und laedt die Datei in mpv.

// delta 0 laedt den aktuellen Eintrag (bzw. steigt neu ein).

func (p *Player) step(client *mpv.Client, delta int) error {

	entries, _ := p.pl.EntriesWithVersion()

		p.mu.Lock()

		p.playing, p.index = "", 0

		p.status.Current = ""

		p.mu.Unlock()

		return nil

	}

	p.mu.RLock()

	playing, index, errStreak := p.playing, p.index, p.errStreak

	loaded := p.loadedCount

	p.mu.RUnlock()

	// Lieber gar nichts tun als in einer Schleife lauter kaputte Dateien

	// durchzuhecheln - der naechste Takt versucht es in Ruhe erneut.

	if errStreak >= len(entries) {

		log.Printf("player: keine der %d Dateien liess sich abspielen - warte %s",

			len(entries), retryDelay)

		p.setError("keine abspielbare Datei in der Playliste")

		p.playing = ""

		p.lastAttempt = time.Now()

		p.mu.Unlock()

		return nil

	}

	// Position anhand des Dateinamens bestimmen: so bleibt die Reihenfolge

	// auch dann sinnvoll, wenn zwischendurch etwas hinzugekommen oder

	// weggefallen ist.

	base := index

	if playing != "" {

		if i := indexOf(entries, playing); i >= 0 {

			base = i

		}

	}

	next := ((base+delta)%len(entries) + len(entries)) % len(entries)

	entry := entries[next]

	path := filepath.Join(p.pl.MediaDir(), entry.Name)

	// Ein Video in einen mpv-Prozess zu laden, der vorher schon etwas anderes

	// angezeigt hat, endet auf manchen Systemen im Abbruch des Demuxers

	// ("partial file"). Deshalb bekommt jedes Video einen frischen Prozess.

	if p.cfg.FreshForVideo && entry.Kind == "video" && loaded > 0 {

		p.mu.Lock()

		p.playing = entry.Name // damit der neue Prozess genau hier einsteigt

		p.index = next

		log.Printf("player: starte mpv neu fuer %q", entry.Name)

		return errFreshMpv

	p.mu.Lock()

	p.playing = entry.Name

	p.index = next

	p.lastAttempt = time.Now()

	p.lastTimePos = -1

	p.lastProgressAt = time.Now()

	p.status.Position = next

	p.loadedCount++

	p.mu.Unlock()

	if _, err := client.Command("loadfile", path, "replace"); err != nil {

		log.Printf("player: %q laden: %v", entry.Name, err)

		p.setError("Laden von " + entry.Name + ": " + err.Error())

		p.mu.Lock()

		p.errStreak++

		p.mu.Unlock()

		return nil

	return nil

func indexOf(entries []playlist.Entry, name string) int {

	for i, e := range entries {

		if e.Name == name {

			return i

		}

	return -1

}

// tick prueft regelmaessig, ob die Wiedergabe noch laeuft.

func (p *Player) tick(client *mpv.Client) error {

	playing, paused := p.playing, p.status.Paused

	current := p.status.Current

	sinceAttempt := time.Since(p.lastAttempt)

	// Nichts geladen (leere Playliste oder lauter kaputte Dateien):

	// nach einer Weile erneut versuchen.

	if playing == "" {

		if len(p.pl.Entries()) > 0 && sinceAttempt > retryDelay {

			p.mu.Lock()

			p.errStreak = 0

			p.mu.Unlock()

			return p.step(client, 0)

		}

		return nil

	}

	// Haengendes Video: ueberspringen, damit nicht die ganze Wand steht.

	timeout := time.Duration(p.cfg.StallTimeout) * time.Second

	if timeout <= 0 || paused || current == "" || playlist.Kind(current) != "video" || since < timeout {

		return nil

	// Reagiert mpv nicht mehr, hilft nur noch ein Neustart des Prozesses.

	if _, err := client.Command("playlist-remove", "current"); err != nil {

		// playlist-remove ist nur ein billiger Lebenstest; scheitert er,

		// steht mpv wirklich.

		return fmt.Errorf("mpv reagiert nicht mehr: %w", err)

	return p.step(client, 1)

		// Kein --no-terminal: sonst verschluckt mpv seine eigenen

		// Fehlermeldungen, und im Journal steht nur, dass es beendet wurde.

		// Ohne Tonausgabe kann auch kein blockierendes Audiogeraet die

		// Wiedergabe anhalten - fuer eine reine Anzeigetafel der sichere Weg.

		args = append(args, "--vo=gpu", "--gpu-context=drm")

	} else {

		args = append(args, "--vo=gpu")

func (p *Player) running() bool {

	defer p.mu.RUnlock()

	return p.client != nil

}

func (p *Player) send(ch chan int, delta int) error {

	if !p.running() {

	select {

	case ch <- delta:

		return nil

	default:

		return fmt.Errorf("player ist beschaeftigt")

	}

func (p *Player) Next() error { return p.send(p.advance, 1) }

func (p *Player) Prev() error { return p.send(p.advance, -1) }

	p.mu.RLock()

	c := p.client

	p.mu.RUnlock()

	if c == nil {

		return fmt.Errorf("player laeuft gerade nicht")

	}

	_, err := c.Command("cycle", "pause")

	return err

// ReloadNow beginnt die Playliste sofort von vorn.

	if !p.running() {

		return fmt.Errorf("player laeuft gerade nicht")

	}

		// p.playing bleibt stehen: Daran erkennt der naechste mpv-Prozess,

		// wo er wieder einsteigen soll.

package player

import (

	"path/filepath"

	"strings"

	"ehc/tvwall/internal/config"

	"ehc/tvwall/internal/playlist"

)

// segment ist ein Stueck Playliste, das ein mpv-Prozess am Stueck abspielt:

// entweder eine Folge aufeinanderfolgender Bilder oder genau ein Video.

//

// Diese Aufteilung loest zwei beobachtete Fehler auf einmal:

//

//   - Ein Video, das in einen mpv-Prozess geladen wird, der vorher schon etwas

//     angezeigt hat, bricht mit "partial file" ab. Jedes Video bekommt deshalb

//     einen eigenen, frischen Prozess.

//   - Wird dagegen jedes einzelne Bild per loadfile nachgeladen, bleibt die

//     Bildausgabe nach etwa neun Wechseln stehen (mpv meldet weiter Wechsel,

//     der Bildschirm friert ein). Bilderfolgen laufen deshalb als Playliste

//     innerhalb eines Prozesses - mpv schaltet selbst weiter.

type segment struct {

	kind  string // "images" oder "video"

	names []string

}

// buildSegments fasst aufeinanderfolgende Bilder zusammen; jedes Video wird

// ein eigener Abschnitt.

func buildSegments(entries []playlist.Entry) []segment {

	var segs []segment

	for _, e := range entries {

		if e.Kind == "video" {

			segs = append(segs, segment{kind: "video", names: []string{e.Name}})

			continue

		}

		if n := len(segs); n > 0 && segs[n-1].kind == "images" {

			segs[n-1].names = append(segs[n-1].names, e.Name)

			continue

		}

		segs = append(segs, segment{kind: "images", names: []string{e.Name}})

	}

	return segs

}

func (s segment) equal(o segment) bool {

	if s.kind != o.kind || len(s.names) != len(o.names) {

		return false

	}

	for i := range s.names {

		if s.names[i] != o.names[i] {

			return false

		}

	}

	return true

}

func (s segment) label() string {

	if s.kind == "video" && len(s.names) == 1 {

		return "Video " + s.names[0]

	}

	return strings.Join(s.names, ", ")

}

// writePlaylist schreibt die Dateien des Abschnitts als m3u fuer mpv.

func (s segment) writePlaylist(cfg *config.Config, mediaDir string) (string, error) {

	var b strings.Builder

	b.WriteString("#EXTM3U\n")

	for _, n := range s.names {

		b.WriteString(filepath.Join(mediaDir, n))

		b.WriteByte('\n')

	}

	path := filepath.Join(cfg.StateDir, "segment.m3u")

	if err := config.WriteFileAtomic(path, []byte(b.String()), 0o664); err != nil {

		return "", err

	}

	return path, nil

}

func sameSegments(a, b []segment) bool {

	if len(a) != len(b) {

		return false

	}

	for i := range a {

		if !a[i].equal(b[i]) {

			return false

		}

	}

	return true

}

#!/usr/bin/env python3

"""

Prueft, ob ein Video in einem mpv-Prozess laeuft, der vorher ein Bild

angezeigt hat - und welche mpv-Option das gegebenenfalls behebt.

Genau dieser Uebergang ist der Grund, warum tvwall vor jedem Video einen

frischen mpv-Prozess startet (FRESH_MPV_FOR_VIDEO). Findet dieses Skript eine

Option, die den Uebergang heil macht, kann der Neustart entfallen.

Aufruf (Dienst vorher anhalten):

    sudo systemctl stop tvwall

    sudo -u rk XDG_RUNTIME_DIR=/run/user/1000 \\

         python3 probe-transition.py <bild> <video>

    sudo systemctl start tvwall

"""

import json

import os

import socket

import subprocess

import sys

import tempfile

import time

BASE = [

    "--fullscreen", "--idle=yes", "--force-window=yes", "--keep-open=no",

    "--image-display-duration=2", "--hwdec=no", "--no-osc", "--osd-level=0",

    "--cursor-autohide=always", "--no-input-default-bindings",

    "--input-vo-keyboard=no", "--no-input-terminal", "--msg-level=all=error",

    "--vo=gpu",

]

VARIANTEN = [

    ("Grundzustand (wie der Dienst)",        []),

    ("--demuxer-thread=no",                  ["--demuxer-thread=no"]),

    ("--cache=no",                           ["--cache=no"]),

    ("--cache=yes",                          ["--cache=yes"]),

    ("ohne Zusatzdateien-Suche",             ["--audio-file-auto=no", "--sub-auto=no",

                                              "--cover-art-auto=no"]),

    ("--vd-lavc-dr=no",                      ["--vd-lavc-dr=no"]),

    ("--demuxer-lavf-probe-info=nostreams",  ["--demuxer-lavf-probe-info=nostreams"]),

    ("--gapless-audio=no",                   ["--gapless-audio=no"]),

    ("--force-window=no",                    ["--force-window=no"]),

    ("--no-audio",                           ["--no-audio"]),

]

class Mpv:

    """Minimaler Client fuer den JSON-IPC-Socket von mpv."""

    def __init__(self, path):

        self.sock = socket.socket(socket.AF_UNIX)

        for _ in range(80):

            try:

                self.sock.connect(path)

                break

            except OSError:

                time.sleep(0.25)

        else:

            raise RuntimeError("mpv-Socket nicht erreichbar")

        self.buf = b""

        self.rid = 0

    def command(self, *args):

        self.rid += 1

        rid = self.rid

        self.sock.sendall(

            (json.dumps({"command": list(args), "request_id": rid}) + "\n").encode())

        deadline = time.time() + 5

        while time.time() < deadline:

            self.sock.settimeout(max(0.1, deadline - time.time()))

            try:

                chunk = self.sock.recv(65536)

            except (socket.timeout, OSError):

                break

            if not chunk:

                break

            self.buf += chunk

            while b"\n" in self.buf:

                line, self.buf = self.buf.split(b"\n", 1)

                try:

                    msg = json.loads(line)

                except ValueError:

                    continue

                if msg.get("request_id") == rid:

                    return msg.get("data")

        return None

    def close(self):

        try:

            self.sock.close()

        except OSError:

            pass

def probe(extra, image, video):

    """Bild laden, dann Video - und schauen, ob das Video wirklich laeuft."""

    tmp = tempfile.mkdtemp()

    sock = os.path.join(tmp, "s")

    proc = subprocess.Popen(

        ["mpv", "--input-ipc-server=" + sock] + BASE + extra,

        stdout=subprocess.DEVNULL, stderr=subprocess.PIPE)

    try:

        m = Mpv(sock)

        m.command("loadfile", image, "replace")

        time.sleep(2.5)

        m.command("loadfile", video, "replace")

        time.sleep(2.0)

        erst = m.command("get_property", "time-pos")

        time.sleep(3.0)

        spaeter = m.command("get_property", "time-pos")

        m.close()

        if not isinstance(erst, (int, float)) or not isinstance(spaeter, (int, float)):

            return False, "Video wurde gar nicht erst geladen"

        if spaeter - erst < 1.0:

            return False, "steht bei %.1f s" % spaeter

        return True, "laeuft bis %.1f s" % spaeter

    finally:

        proc.kill()

        try:

            err = proc.stderr.read().decode(errors="replace").strip()

        except Exception:

            err = ""

        proc.wait()

        if err:

            probe.last_error = err.splitlines()[-3:]

        else:

            probe.last_error = []

def main():

    if len(sys.argv) != 3:

        print(__doc__)

        sys.exit(1)