2f4d870b · ehc-tvwall

Küpper / ehc-tvwall öffentlich

fix: [vo/gpu/libplacebo] vk->CreateSwapchainKHR(...): VK_ERROR_OUT_OF_HOST_MEMORY [vo/gpu/libplacebo] Failed (re)creating swapchain!

R Rüdiger Küpper <rpr@9it.de> committete am 21.08.2026 02:33

2f4d870b5ab7c049d585aecd6833463f5366d04d

Eltern: 14518d05

Dateien zu diesem Stand

gelöscht EHC-Dienstag.jpeg

+0 −0

Binärdatei – kein Textvergleich möglich.

gelöscht EHC-Montag.jpeg

+0 −0

Binärdatei – kein Textvergleich möglich.

gelöscht EHC-Woche.jpeg

+0 −0

Binärdatei – kein Textvergleich möglich.

geändert README.md

+32 −8 Datei ansehen


| `SCAN_INTERVAL` | Takt, in dem der Ordner neu eingelesen wird |
| `DISPLAY_MODE` | `auto` (empfohlen), `drm` oder `desktop` |
| `RUN_USER` | Benutzer des Dienstes |
| `FRESH_MPV_FOR_VIDEO` | `yes` startet mpv vor jedem Video neu (umgeht den `partial file`-Abbruch) |
| `MPV_GPU_API` | `opengl` (Standard) oder `vulkan`/`auto` — siehe Fehlersuche |
| `MPV_HWDEC` | `no` (Standard, Software) oder `auto-safe` (Hardware, nur Pi 4) |
| `STALL_TIMEOUT` | Sekunden ohne Fortschritt, bevor ein Video übersprungen wird |
| `MPV_EXTRA_ARGS` | zusätzliche mpv-Optionen, z. B. `--video-rotate=90` |

Zuerst `http://192.168.4.1` probieren — Namen wie `tvwall.local` funktionieren
nicht auf allen Handys. Läuft der Dienst? `systemctl status tvwall`.

**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.
**Das Bild bleibt nach einigen Wechseln stehen, obwohl das Webinterface
weiterzählt.**
Das ist der Grund für die Voreinstellung `MPV_GPU_API="opengl"`. Über Vulkan
baut libplacebo bei jedem Bildwechsel die Swapchain neu auf und läuft nach rund
neun Wechseln in `VK_ERROR_OUT_OF_HOST_MEMORY`. mpv läuft dann weiter und meldet
auch weiter Dateiwechsel — nur gemalt wird nichts mehr. Im Journal steht:

```
[vo/gpu/libplacebo] vk->CreateSwapchainKHR(...): VK_ERROR_OUT_OF_HOST_MEMORY
[vo/gpu/libplacebo] Failed (re)creating swapchain!
```

Nachgemessen auf einem Pi 5 (Wayland/labwc, mpv 0.40), 20 Bildwechsel:

Zuerst `MPV_HWDEC="no"` prüfen (seit Version 1.0.0 die Voreinstellung). Der
| Renderer | Swapchain-Fehler |
|---|---|
| `--vo=gpu` (Vulkan) | 24 |
| `--vo=gpu --gpu-api=opengl` | **0** |
| `--vo=gpu-next` (Vulkan) | 84 |

Dasselbe galt für Videos: Mit Vulkan brach die Wiedergabe nach ein bis zwei
Sekunden ab, mit OpenGL lief derselbe Clip vollständig durch. `diagnose.sh`
prüft das mit.

**Ein Video bleibt nach ein paar Sekunden stehen.**
Zuerst `MPV_GPU_API="opengl"` prüfen (siehe oben), dann `MPV_HWDEC="no"`. Der
Raspberry Pi 5 hat *keinen* Hardware-Dekoder für H.264 mehr; mit `auto-safe`
läuft ein Video dort ein bis zwei Sekunden und friert dann ein — genau so lange,
wie der bereits gefüllte Puffer reicht. Zum Gegenprüfen hilft der direkte

internal/player/display.go  Wayland-/X11-/DRM-Erkennung
scripts/setup-ap.sh       Access Point per nmcli
scripts/diagnose.sh       Selbsttest bei Problemen
scripts/console-mode.sh   Desktop abschalten, direkt in die Anzeige booten
scripts/set-splash.sh     eigenes Logo als Startbildschirm setzen
scripts/bisect-mpv.sh     misst, welche mpv-Option einen Haenger ausloest
scripts/probe-transition.py  prueft den Uebergang Bild -> Video im selben mpv
install.sh                Installation auf dem Pi
```


* **Die Oberfläche kommt ohne externe Bibliotheken aus** und ist ins Programm
  eingebettet. Am Access Point gibt es kein Internet — alles, was von einem CDN
  nachgeladen werden müsste, wäre dort tot.
* **mpv rendert über OpenGL, nicht über Vulkan.** Auf dem Raspberry Pi 5 baut
  die Vulkan-Anbindung von libplacebo bei jedem Bildwechsel die Swapchain neu
  auf und läuft dabei nach rund neun Wechseln aus dem Speicher — der Bildschirm
  friert ein, während intern alles weiterläuft. Siehe Fehlersuche.
* **Uploads landen erst in einer temporären Datei** und werden nach vollem
  Empfang umbenannt. So gerät keine halbe Datei in die Wiedergabe.


geändert config/tvwall.conf

+9 −7 Datei ansehen


# Bei DISPLAY_MODE="auto" erkennt install.sh das und traegt es hier ein.
RUN_USER="tvwall"

# Grafik-Anbindung von mpv.
#   opengl = Standard und dringend empfohlen
#   vulkan = schneller, aber auf dem Raspberry Pi 5 fehlerhaft: libplacebo baut
#            bei jedem Bildwechsel die Swapchain neu auf und laeuft nach rund
#            neun Wechseln in VK_ERROR_OUT_OF_HOST_MEMORY - mpv laeuft dann
#            weiter, der Bildschirm friert ein.
#   auto   = mpv entscheidet (waehlt auf dem Pi 5 Vulkan - nicht empfohlen)
MPV_GPU_API="opengl"

# Hardwarebeschleunigte Videodekodierung.
#   no        = alles in Software dekodieren (Standard, mpvs eigene Vorgabe)
#   auto-safe = Hardware benutzen, wenn moeglich

# kann "auto-safe" dagegen Rechenzeit sparen.
MPV_HWDEC="no"

# 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"

# Laeuft ein Video so lange nicht weiter (Sekunden), wird es uebersprungen,
# damit eine einzelne Datei nicht die ganze Wiedergabe anhaelt. 0 = aus.
STALL_TIMEOUT="30"

hinzugefügt ehc-logo-v2..png

+0 −0 Datei ansehen

Binärdatei – kein Textvergleich möglich.

geändert internal/config/config.go

+6 −3 Datei ansehen


	RunUser       string
	MpvExtraArgs  string
	MpvHwdec      string
	MpvGpuAPI     string
	FreshForVideo bool // mpv vor jedem Video neu starten
	StallTimeout  int  // Sekunden ohne Fortschritt, bevor ein Video uebersprungen wird


		ScanInterval:  10,
		DisplayMode:   "auto",
		MpvHwdec:      "no",
		FreshForVideo: true,
		MpvGpuAPI:     "opengl",
		StallTimeout:  30,
		RunUser:       "tvwall",
		StateDir:      "/var/lib/tvwall",

			c.RunUser = val
		case "MPV_EXTRA_ARGS":
			c.MpvExtraArgs = val
		case "FRESH_MPV_FOR_VIDEO":
			c.FreshForVideo = isTrue(val)
		case "MPV_GPU_API":
			if val != "" {
				c.MpvGpuAPI = val
			}
		case "MPV_HWDEC":
			if val != "" {
				c.MpvHwdec = val

geändert internal/player/player.go

+117 −245 Datei ansehen


// Package player startet und ueberwacht mpv und steuert die Wiedergabe.
// Package player startet und ueberwacht mpv und haelt dessen Playliste aktuell.
//
// 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.
// mpv bekommt die komplette Playliste (Bilder und Videos gemischt) und schaltet
// selbst weiter; dieses Programm laedt sie nur nach, wenn sich der Medienordner
// geaendert hat - und zwar zwischen zwei Dateien, damit kein laufendes Video
// unterbrochen wird.
package player

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"log"
	"os"

const (
	propPath = iota + 1
	propPause
	propPlaylistPos
	propIdle
	propTimePos
)

// Takt der Ueberwachung: haengende Dateien und leerer Bildschirm.
const tickInterval = 5 * time.Second

// 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")

// Status beschreibt den Zustand der Wiedergabe fuer das Webinterface.
type Status struct {
	Running       bool   `json:"running"`

	LastError     string `json:"last_error"`
}

// Player haelt genau einen mpv-Prozess am Leben und schaltet die Dateien weiter.
// Player haelt genau einen mpv-Prozess am Leben.
type Player struct {
	cfg      *config.Config
	pl       *playlist.Manager
	settings *config.Store

	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
	mu       sync.RWMutex
	client   *mpv.Client
	status   Status
	pending  bool
	loadedID uint64 // Version der zuletzt an mpv uebergebenen Playliste

	lastTimePos    float64
	lastProgressAt time.Time

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

	advance   chan int
	reloadNow chan struct{}
	restart   chan struct{}
}

		cfg:       cfg,
		pl:        pl,
		settings:  settings,
		advance:   make(chan int, 4),
		reloadNow: make(chan struct{}, 1),
		restart:   make(chan struct{}, 1),
	}

func (p *Player) Status() Status {
	p.mu.RLock()
	defer p.mu.RUnlock()
	return p.status
	s := p.status
	s.PendingReload = p.pending
	return s
}

// Run laeuft bis ctx abgebrochen wird und startet mpv bei Bedarf neu.

	backoff := time.Second
	for ctx.Err() == nil {
		start := time.Now()
		err := p.runOnce(ctx, settingsChanged)
		if err := p.runOnce(ctx, settingsChanged); err != nil && ctx.Err() == nil {
			log.Printf("player: %v", err)
			p.setError(err.Error())
		}
		p.setRunning(false)
		if ctx.Err() != nil {
			return
		}
		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())
		}
		if time.Since(start) > time.Minute {
			backoff = time.Second
		} else if backoff < 15*time.Second {

	}
}

// runOnce startet mpv, verbindet sich mit dem IPC-Socket und bleibt, bis mpv
// endet oder ctx abgebrochen wird.
func (p *Player) runOnce(ctx context.Context, settingsChanged <-chan struct{}) error {
	disp, err := resolveDisplay(p.cfg.DisplayMode)
	if err != nil {

	log.Printf("player: starte mpv %s", strings.Join(args, " "))

	cmd := exec.Command("mpv", args...)
	// stdin durchreichen: bei --vo=gpu --gpu-context=drm braucht mpv das
	// Terminal der Konsole (tty1), um den Bildschirm uebernehmen zu duerfen.
	// stdin durchreichen: bei --gpu-context=drm braucht mpv das Terminal der
	// Konsole, um den Bildschirm uebernehmen zu duerfen.
	cmd.Stdin = os.Stdin
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr

		waitErr = cmd.Wait()
		close(exited)
	}()

	defer func() {
		if cmd.Process != nil {
			_ = cmd.Process.Kill()

	p.mu.Lock()
	p.client = client
	p.status = Status{Running: true, Display: disp.mode}
	p.index = 0
	p.errStreak = 0
	p.loadedCount = 0
	p.lastTimePos = -1
	p.lastProgressAt = time.Now()
	p.mu.Unlock()
	defer func() {
		p.mu.Lock()

	}()

	for id, name := range map[int]string{
		propPath: "path", propPause: "pause",
		propPath: "path", propPause: "pause", propPlaylistPos: "playlist-pos",
		propIdle: "idle-active", propTimePos: "time-pos",
	} {
		if err := client.ObserveProperty(id, name); err != nil {

	}

	p.applySettings(client)
	if err := p.step(client, 0); err != nil { // erste Datei laden
		return err
	}
	p.loadPlaylist(client)
	p.setError("")

	ticker := time.NewTicker(tickInterval)

			}

		case <-p.pl.Changed():
			// 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:
			// Nicht mitten in einer Datei neu laden - erst am Uebergang.
			p.mu.Lock()
			p.playing = ""
			p.index = 0
			p.errStreak = 0
			p.pending = p.pl.Version() != p.loadedID
			pending, idle := p.pending, p.status.Idle
			p.mu.Unlock()
			if err := p.step(client, 0); err != nil {
				return err
			if pending && idle {
				p.loadPlaylist(client)
			}

		case <-p.reloadNow:
			p.loadPlaylist(client)

		case <-p.restart:
			return fmt.Errorf("neustart angefordert")


			p.applySettings(client)

		case <-ticker.C:
			if err := p.tick(client); err != nil {
				return err
			}
			p.checkStalled(client)

		case ev, ok := <-client.Events():
			if !ok {
				return fmt.Errorf("ipc-verbindung beendet")
			}
			if err := p.handleEvent(client, ev); err != nil {
				return err
			}
			p.handleEvent(client, ev)
		}
	}
}

func (p *Player) handleEvent(client *mpv.Client, ev mpv.Event) error {
func (p *Player) handleEvent(client *mpv.Client, ev mpv.Event) {
	switch ev.Name {
	case "property-change":
		p.mu.Lock()

			var s string
			if json.Unmarshal(ev.Data, &s) == nil && s != "" {
				p.status.Current = filepath.Base(s)
				// Eine Datei laeuft wieder - die Fehlerkette ist unterbrochen.
				p.errStreak = 0
			} else {
				p.status.Current = ""
			}

			if json.Unmarshal(ev.Data, &b) == nil {
				p.status.Paused = b
			}
		case propPlaylistPos:
			var n float64
			if json.Unmarshal(ev.Data, &n) == nil {
				p.status.Position = int(n)
			}
		case propIdle:
			var b bool
			if json.Unmarshal(ev.Data, &b) == nil {

				p.lastProgressAt = time.Now()
			}
		}
		idle, pending := p.status.Idle, p.pending
		p.mu.Unlock()

	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"`
		if ev.ID == propIdle && idle && pending {
			p.loadPlaylist(client)
		}
		_ = 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)

	case "end-file":
		// Der beste Moment fuer eine neue Playliste: zwischen zwei Dateien.
		p.mu.RLock()
		pending := p.pending
		p.mu.RUnlock()
		if pending {
			p.loadPlaylist(client)
		}
	}
	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()
// loadPlaylist uebergibt mpv die aktuelle m3u-Datei.
func (p *Player) loadPlaylist(client *mpv.Client) {
	entries, version := p.pl.EntriesWithVersion()

	p.mu.Lock()
	p.pending = false
	p.loadedID = version
	p.mu.Unlock()

	if len(entries) == 0 {
		p.mu.Lock()
		p.playing, p.index = "", 0
		p.status.Current = ""
		p.mu.Unlock()
		if _, err := client.Command("playlist-clear"); err != nil {
			log.Printf("player: playlist-clear: %v", err)
		}
		if _, err := client.Command("stop"); err != nil {
			log.Printf("player: stop: %v", err)
		}
		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.mu.Lock()
		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
		p.status.Current = ""
		p.mu.Unlock()
		log.Printf("player: starte mpv neu fuer %q", entry.Name)
		return errFreshMpv
		return
	}

	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
	if _, err := client.Command("loadlist", p.pl.PlaylistFile(), "replace"); err != nil {
		log.Printf("player: playlist laden: %v", err)
		p.setError("Playliste laden: " + err.Error())
		return
	}
	if err := client.SetProperty("pause", false); err != nil {
		log.Printf("player: fortsetzen: %v", err)
	}
	return nil
	log.Printf("player: playliste geladen (%d eintraege)", len(entries))
}

func indexOf(entries []playlist.Entry, name string) int {
	for i, e := range entries {
		if e.Name == name {
			return i
		}
// checkStalled ueberspringt ein Video, das nicht mehr weiterlaeuft, damit eine
// einzelne Datei nicht die ganze Wiedergabe anhaelt.
func (p *Player) checkStalled(client *mpv.Client) {
	timeout := time.Duration(p.cfg.StallTimeout) * time.Second
	if timeout <= 0 {
		return
	}
	return -1
}

// tick prueft regelmaessig, ob die Wiedergabe noch laeuft.
func (p *Player) tick(client *mpv.Client) error {
	p.mu.RLock()
	playing, paused := p.playing, p.status.Paused
	current := p.status.Current
	current, paused, idle := p.status.Current, p.status.Paused, p.status.Idle
	since := time.Since(p.lastProgressAt)
	sinceAttempt := time.Since(p.lastAttempt)
	p.mu.RUnlock()

	// 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
	// Bilder haben keinen fortlaufenden Zeitstempel - nur Videos pruefen.
	if paused || idle || current == "" || playlist.Kind(current) != "video" || since < timeout {
		return
	}

	log.Printf("player: %q laeuft seit %s nicht weiter - wird uebersprungen",

	p.mu.Lock()
	p.lastProgressAt = time.Now()
	p.mu.Unlock()

	// 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)
	if _, err := client.Command("playlist-next", "force"); err != nil {
		log.Printf("player: weiterschalten: %v", err)
	}
	return p.step(client, 1)
}

// applySettings uebernimmt Anzeigedauer und Stummschaltung ohne mpv-Neustart.

		"--idle=yes",
		"--force-window=yes",
		"--keep-open=no",
		"--loop-playlist=inf",
		"--image-display-duration=" + strconv.FormatFloat(s.ImageDuration, 'f', -1, 64),
		"--hwdec=" + p.cfg.MpvHwdec,
		"--no-osc",

		"--no-input-default-bindings",
		"--input-vo-keyboard=no",
		"--stop-screensaver=yes",
		// Kein --no-terminal: sonst verschluckt mpv seine eigenen
		// Fehlermeldungen, und im Journal steht nur, dass es beendet wurde.
		// Kein --no-terminal: sonst verschluckt mpv seine Fehlermeldungen.
		"--msg-level=all=warn",
		"--no-input-terminal",
		"--vo=gpu",
	}
	// Die Vulkan-Anbindung von libplacebo baut bei jedem Bildwechsel die
	// Swapchain neu auf und laeuft dabei nach wenigen Wechseln in
	// VK_ERROR_OUT_OF_HOST_MEMORY: mpv laeuft weiter, der Bildschirm friert
	// ein. Mit OpenGL tritt das nicht auf (auf einem Pi 5 nachgemessen:
	// 0 statt 24 Fehlern in 20 Bildwechseln).
	if p.cfg.MpvGpuAPI != "" && p.cfg.MpvGpuAPI != "auto" {
		args = append(args, "--gpu-api="+p.cfg.MpvGpuAPI)
	}
	if p.cfg.Audio {
		args = append(args, "--mute="+yesNo(s.Mute))
	} else {
		// Ohne Tonausgabe kann auch kein blockierendes Audiogeraet die
		// Wiedergabe anhalten - fuer eine reine Anzeigetafel der sichere Weg.
		args = append(args, "--no-audio")
	}
	if disp.mode == "drm" {
		args = append(args, "--vo=gpu", "--gpu-context=drm")
	} else {
		args = append(args, "--vo=gpu")
		args = append(args, "--gpu-context=drm")
	}
	args = append(args, splitArgs(p.cfg.MpvExtraArgs)...)
	return args

// Steuerung aus dem Webinterface
// ---------------------------------------------------------------------------

func (p *Player) running() bool {
func (p *Player) withClient(fn func(*mpv.Client) error) error {
	p.mu.RLock()
	defer p.mu.RUnlock()
	return p.client != nil
}

func (p *Player) send(ch chan int, delta int) error {
	if !p.running() {
	c := p.client
	p.mu.RUnlock()
	if c == nil {
		return fmt.Errorf("player laeuft gerade nicht")
	}
	select {
	case ch <- delta:
		return nil
	default:
		return fmt.Errorf("player ist beschaeftigt")
	}
	return fn(c)
}

// Next springt zum naechsten Eintrag.
func (p *Player) Next() error { return p.send(p.advance, 1) }
func (p *Player) Next() error {
	return p.withClient(func(c *mpv.Client) error {
		_, err := c.Command("playlist-next", "force")
		return err
	})
}

// Prev springt zum vorherigen Eintrag.
func (p *Player) Prev() error { return p.send(p.advance, -1) }
func (p *Player) Prev() error {
	return p.withClient(func(c *mpv.Client) error {
		_, err := c.Command("playlist-prev", "force")
		return err
	})
}

// TogglePause haelt die Wiedergabe an oder setzt sie fort.
func (p *Player) TogglePause() error {
	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
	return p.withClient(func(c *mpv.Client) error {
		_, err := c.Command("cycle", "pause")
		return err
	})
}

// ReloadNow beginnt die Playliste sofort von vorn.
// ReloadNow laedt die Playliste sofort neu, auch mitten in einem Video.
func (p *Player) ReloadNow() error {
	if !p.running() {
		return fmt.Errorf("player laeuft gerade nicht")
	}
	select {
	case p.reloadNow <- struct{}{}:
	default:

	p.mu.Lock()
	p.status.Running = v
	if !v {
		// p.playing bleibt stehen: Daran erkennt der naechste mpv-Prozess,
		// wo er wieder einsteigen soll.
		p.status.Current = ""
	}
	p.mu.Unlock()

gelöscht internal/player/segment.go

+0 −90


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
}

hinzugefügt scripts/console-mode.sh

+81 −0 Datei ansehen

		@@ -0,0 +1,81 @@
	1	+ #!/usr/bin/env bash
	2	+ # ===========================================================================
	3	+ # Stellt den Pi auf reinen Anzeigebetrieb um: kein Desktop mehr, Start direkt
	4	+ # in die Konsole, tvwall malt ueber DRM/KMS unmittelbar auf den Bildschirm.
	5	+ #
	6	+ # Aufruf: sudo /opt/tvwall/scripts/console-mode.sh [--zurueck]
	7	+ #
	8	+ # --zurueck stellt den Desktop-Betrieb wieder her.
	9	+ # ===========================================================================
	10	+ set -euo pipefail
	11	+
	12	+ CONF="/etc/tvwall/tvwall.conf"
	13	+ INSTALLER="/opt/tvwall/install.sh"
	14	+
	15	+ info() { printf '\033[1;36m==>\033[0m %s\n' "$*"; }
	16	+ ok() { printf '\033[1;32m ✓\033[0m %s\n' "$*"; }
	17	+ warn() { printf '\033[1;33m !\033[0m %s\n' "$*"; }
	18	+ die() { printf '\033[1;31mFehler:\033[0m %s\n' "$*" >&2; exit 1; }
	19	+
	20	+ [[ $EUID -eq 0 ]] \|\| die "bitte mit sudo starten: sudo $0"
	21	+
	22	+ if [[ "${1:-}" == "--zurueck" ]]; then
	23	+ info "Stelle den Desktop-Betrieb wieder her"
	24	+ systemctl set-default graphical.target
	25	+ systemctl enable lightdm >/dev/null 2>&1 \|\| true
	26	+ systemctl enable getty@tty1.service >/dev/null 2>&1 \|\| true
	27	+ sed -i 's\|^DISPLAY_MODE=.*\|DISPLAY_MODE="auto"\|' "$CONF"
	28	+ [[ -x "$INSTALLER" ]] && "$INSTALLER" --no-ap --yes >/dev/null
	29	+ ok "Desktop wieder aktiv - bitte neu starten: sudo reboot"
	30	+ exit 0
	31	+ fi
	32	+
	33	+ info "Boot-Ziel auf Konsole umstellen"
	34	+ systemctl set-default multi-user.target >/dev/null
	35	+ ok "Standard-Ziel: $(systemctl get-default)"
	36	+
	37	+ info "Desktop-Anmeldung abschalten"
	38	+ for dm in lightdm gdm3 sddm; do
	39	+ if systemctl list-unit-files "$dm.service" >/dev/null 2>&1 &&
	40	+ systemctl is-enabled "$dm" >/dev/null 2>&1; then
	41	+ systemctl disable "$dm" >/dev/null 2>&1 \|\| true
	42	+ systemctl stop "$dm" \|\| true
	43	+ ok "$dm abgeschaltet"
	44	+ fi
	45	+ done
	46	+ sleep 1
	47	+ [[ "$(pgrep -c 'labwc\|wayfire\|Xorg' 2>/dev/null \|\| echo 0)" == "0" ]] \
	48	+ && ok "keine Desktop-Oberflaeche mehr aktiv" \
	49	+ \|\| warn "es laeuft noch eine Oberflaeche - nach dem Neustart ist sie weg"
	50	+
	51	+ info "Bildausgabe auf DRM festlegen"
	52	+ sed -i 's\|^DISPLAY_MODE=.*\|DISPLAY_MODE="drm"\|' "$CONF"
	53	+ ok 'DISPLAY_MODE="drm"'
	54	+
	55	+ # Der Benutzer des Dienstes braucht Zugriff auf Grafik und Konsole.
	56	+ RUN_USER="$(sed -n 's/^RUN_USER="$.*$"/\1/p' "$CONF" \| head -1)"
	57	+ RUN_USER="${RUN_USER:-tvwall}"
	58	+ for grp in video render input tty; do
	59	+ getent group "$grp" >/dev/null && usermod -aG "$grp" "$RUN_USER" 2>/dev/null \|\| true
	60	+ done
	61	+ ok "Benutzer $RUN_USER hat Zugriff auf Grafik und Konsole"
	62	+
	63	+ if [[ -x "$INSTALLER" ]]; then
	64	+ info "Dienst auf die Konsolen-Variante umstellen"
	65	+ "$INSTALLER" --no-ap --yes >/dev/null
	66	+ ok "systemd-Dienst neu eingerichtet"
	67	+ else
	68	+ warn "$INSTALLER fehlt - bitte install.sh aus dem Paket erneut ausfuehren"
	69	+ fi
	70	+
	71	+ cat <<EOF
	72	+
	73	+ ===========================================================================
	74	+ Fertig. Nach dem Neustart faehrt der Pi ohne Desktop hoch und zeigt
	75	+ sofort die Playliste.
	76	+
	77	+ sudo reboot
	78	+
	79	+ Zurueck zum Desktop: sudo $0 --zurueck
	80	+ ===========================================================================
	81	+ EOF

geändert scripts/diagnose.sh

+12 −0 Datei ansehen


    && ok "tvwall-ap aktiv" || warn "tvwall-ap nicht aktiv"
fi

hdr "Bildausgabe"
SWAP="$(journalctl -u tvwall --since "-30 min" --no-pager 2>/dev/null | grep -ci swapchain)"
if [[ "${SWAP:-0}" -gt 0 ]]; then
  bad "$SWAP Swapchain-Fehler in den letzten 30 Minuten"
  note "Die Vulkan-Anbindung von mpv laeuft auf dem Pi 5 nach wenigen"
  note "Bildwechseln aus dem Speicher: der Bildschirm friert ein, waehrend"
  note "das Webinterface weiterzaehlt."
  note "-> In $CONF setzen:  MPV_GPU_API=\"opengl\"  und Dienst neu starten"
else
  ok "keine Swapchain-Fehler (MPV_GPU_API=${MPV_GPU_API:-opengl})"
fi

hdr "Letzte Protokollzeilen"
journalctl -u tvwall -n 40 --no-pager 2>/dev/null | sed 's/^/  /'


gelöscht scripts/probe-transition.py

+0 −170


#!/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)
    image, video = sys.argv[1], sys.argv[2]
    for f in (image, video):
        if not os.path.isfile(f):
            print("Datei fehlt:", f)
            sys.exit(1)

    print("\nBild : %s\nVideo: %s\n" % (image, video))
    print("Uebergang Bild -> Video im selben mpv-Prozess:\n")

    gut = []
    for name, extra in VARIANTEN:
        ok, info = probe(extra, image, video)
        print("  %-38s %s  (%s)" % (name, "LAEUFT" if ok else "HAENGT", info))
        for zeile in getattr(probe, "last_error", []):
            print("      %s" % zeile)
        if ok:
            gut.append(name)

    print()
    if not gut:
        print("Keine Option hilft. Der Neustart vor jedem Video")
        print("(FRESH_MPV_FOR_VIDEO=\"yes\") bleibt die richtige Loesung.")
    elif gut == [n for n, _ in VARIANTEN]:
        print("Alle Varianten laufen - der Uebergang ist auf diesem System heil.")
        print("Dann kann FRESH_MPV_FOR_VIDEO=\"no\" gesetzt werden.")
    else:
        print("Diese Optionen beheben den Uebergang:")
        for n in gut:
            print("   ", n)
        print("\nTrag die passende in MPV_EXTRA_ARGS ein und setze")
        print("FRESH_MPV_FOR_VIDEO=\"no\" - dann entfaellt der Neustart.")


if __name__ == "__main__":
    main()

hinzugefügt scripts/set-splash.sh

+159 −0 Datei ansehen

		@@ -0,0 +1,159 @@
	1	+ #!/usr/bin/env bash
	2	+ # ===========================================================================
	3	+ # Ersetzt den Startbildschirm (Plymouth-Thema "pix") durch ein eigenes Logo.
	4	+ #
	5	+ # Aufruf: sudo /opt/tvwall/scripts/set-splash.sh /pfad/zum/logo.png [--dauer N]
	6	+ # sudo /opt/tvwall/scripts/set-splash.sh --zurueck
	7	+ #
	8	+ # Das Logo wird auf die Bildschirmgroesse zentriert auf schwarzem Grund
	9	+ # gesetzt - derselbe Hintergrund, den auch der Player verwendet, damit der
	10	+ # Uebergang vom Start in die Wiedergabe nicht springt.
	11	+ #
	12	+ # Zusaetzlich wird das Logo bis --dauer Sekunden nach dem Einschalten
	13	+ # stehengelassen (Standard 12). Ohne das ist es nach gut vier Sekunden schon
	14	+ # wieder weg - viele Fernseher brauchen laenger, um sich auf das HDMI-Signal
	15	+ # zu synchronisieren, und zeigen dann gar nichts davon.
	16	+ # ===========================================================================
	17	+ set -euo pipefail
	18	+
	19	+ THEME_DIR="/usr/share/plymouth/themes/pix"
	20	+ SPLASH="$THEME_DIR/splash.png"
	21	+ BACKUP="$THEME_DIR/splash.original.png"
	22	+ CONFIG_TXT="/boot/firmware/config.txt"
	23	+ [[ -f "$CONFIG_TXT" ]] \|\| CONFIG_TXT="/boot/config.txt"
	24	+ HOLD_BIN="/usr/local/bin/tvwall-splash-hold"
	25	+ HOLD_UNIT="/etc/systemd/system/tvwall-splash.service"
	26	+ DAUER=12
	27	+
	28	+ info() { printf '\033[1;36m==>\033[0m %s\n' "$*"; }
	29	+ ok() { printf '\033[1;32m ✓\033[0m %s\n' "$*"; }
	30	+ warn() { printf '\033[1;33m !\033[0m %s\n' "$*"; }
	31	+ die() { printf '\033[1;31mFehler:\033[0m %s\n' "$*" >&2; exit 1; }
	32	+
	33	+ [[ $EUID -eq 0 ]] \|\| die "bitte mit sudo starten: sudo $0 $*"
	34	+ [[ -d "$THEME_DIR" ]] \|\| die "Plymouth-Thema 'pix' nicht gefunden ($THEME_DIR)"
	35	+
	36	+ # --- Aufrufparameter -------------------------------------------------------
	37	+ ARGS=()
	38	+ while [[ $# -gt 0 ]]; do
	39	+ case "$1" in
	40	+ --dauer) DAUER="${2:-12}"; shift 2 ;;
	41	+ --zurueck) ARGS+=("--zurueck"); shift ;;
	42	+ *) ARGS+=("$1"); shift ;;
	43	+ esac
	44	+ done
	45	+ set -- "${ARGS[@]+"${ARGS[@]}"}"
	46	+
	47	+ # --- zuruecksetzen ---------------------------------------------------------
	48	+ if [[ "${1:-}" == "--zurueck" ]]; then
	49	+ [[ -f "$BACKUP" ]] \|\| die "keine Sicherung gefunden ($BACKUP)"
	50	+ cp -f "$BACKUP" "$SPLASH"
	51	+ ok "urspruenglicher Startbildschirm wiederhergestellt"
	52	+ systemctl disable --now tvwall-splash.service >/dev/null 2>&1 \|\| true
	53	+ rm -f "$HOLD_UNIT" "$HOLD_BIN"
	54	+ systemctl daemon-reload
	55	+ ok "Halten des Startbildes entfernt"
	56	+ update-initramfs -u >/dev/null 2>&1 \|\| true
	57	+ ok "fertig - beim naechsten Neustart wieder das Original"
	58	+ exit 0
	59	+ fi
	60	+
	61	+ LOGO="${1:-}"
	62	+ [[ -n "$LOGO" && -f "$LOGO" ]] \|\| die "Bilddatei angeben: sudo $0 /pfad/zum/logo.png"
	63	+ command -v ffmpeg >/dev/null \|\| die "ffmpeg fehlt: sudo apt install ffmpeg"
	64	+
	65	+ # --- Bildschirmaufloesung ermitteln ---------------------------------------
	66	+ MODE="$(head -1 /sys/class/drm/*/modes 2>/dev/null \| grep -m1 -E '^[0-9]+x[0-9]+' \|\| true)"
	67	+ W="${MODE%x}"; H="${MODE#x}"
	68	+ if [[ ! "$W" =~ ^[0-9]+$ \|\| ! "$H" =~ ^[0-9]+$ ]]; then
	69	+ W=1920; H=1080
	70	+ warn "Aufloesung nicht erkannt - nehme ${W}x${H}"
	71	+ else
	72	+ ok "Bildschirm: ${W}x${H}"
	73	+ fi
	74	+
	75	+ # --- Startbild bauen -------------------------------------------------------
	76	+ info "Baue Startbild aus $(basename "$LOGO")"
	77	+ LOGO_H=$(( H * 55 / 100 )) # Logo auf 55 % der Bildhoehe
	78	+ TMP="$(mktemp -d)"; trap 'rm -rf "$TMP"' EXIT
	79	+ ffmpeg -v error -y -f lavfi -i "color=c=black:s=${W}x${H}" -i "$LOGO" \
	80	+ -filter_complex "[1:v]scale=-1:${LOGO_H}:force_original_aspect_ratio=decrease[logo];\
	81	+ [0:v][logo]overlay=(W-w)/2:(H-h)/2:format=auto" \
	82	+ -frames:v 1 "$TMP/splash.png" \|\| die "ffmpeg konnte das Bild nicht erzeugen"
	83	+ ok "Startbild erzeugt ($(stat -c %s "$TMP/splash.png") Bytes)"
	84	+
	85	+ # --- einsetzen -------------------------------------------------------------
	86	+ [[ -f "$BACKUP" ]] \|\| { cp -f "$SPLASH" "$BACKUP"; ok "Original gesichert: $BACKUP"; }
	87	+ install -m 0644 "$TMP/splash.png" "$SPLASH"
	88	+ ok "eingesetzt: $SPLASH"
	89	+
	90	+ # --- Regenbogen-Quadrat der Firmware abschalten ---------------------------
	91	+ if [[ -w "$CONFIG_TXT" ]] && ! grep -q "^disable_splash=1" "$CONFIG_TXT"; then
	92	+ cp -f "$CONFIG_TXT" "$CONFIG_TXT.tvwall-backup"
	93	+ printf '\n# von tvwall set-splash.sh: kein Regenbogen-Quadrat beim Einschalten\ndisable_splash=1\n' >> "$CONFIG_TXT"
	94	+ ok "disable_splash=1 in $(basename "$CONFIG_TXT") eingetragen"
	95	+ fi
	96	+
	97	+ # --- Startbild stehenlassen, bis die Wiedergabe uebernimmt ----------------
	98	+ # Ohne das zeigt Plymouth das Logo nur etwa vier Sekunden; viele Fernseher
	99	+ # sind zu diesem Zeitpunkt noch gar nicht synchronisiert.
	100	+ if [[ -x /usr/bin/plymouth ]]; then
	101	+ info "Startbild bis $DAUER s nach dem Einschalten halten"
	102	+ cat > "$HOLD_BIN" <<'HOLD'
	103	+ #!/bin/sh
	104	+ # Haelt den Plymouth-Startbildschirm, bis die angegebene Zeit seit dem
	105	+ # Einschalten erreicht ist, und uebergibt ihn dann an die Wiedergabe.
	106	+ # --retain-splash laesst das Bild stehen, bis mpv das erste Mal malt - so
	107	+ # gibt es dazwischen keine schwarze Luecke.
	108	+ ZIEL="${1:-12}"
	109	+ UP="$(cut -d. -f1 /proc/uptime)"
	110	+ [ "$UP" -lt "$ZIEL" ] && sleep $(( ZIEL - UP ))
	111	+ [ -x /usr/bin/plymouth ] && /usr/bin/plymouth quit --retain-splash
	112	+ exit 0
	113	+ HOLD
	114	+ chmod 0755 "$HOLD_BIN"
	115	+
	116	+ cat > "$HOLD_UNIT" <<UNIT
	117	+ # Von tvwall set-splash.sh erzeugt.
	118	+ [Unit]
	119	+ Description=Startbild halten, bis die Wiedergabe uebernimmt
	120	+ After=plymouth-start.service
	121	+ Before=tvwall.service plymouth-quit.service plymouth-quit-wait.service
	122	+ ConditionPathExists=/usr/bin/plymouth
	123	+
	124	+ [Service]
	125	+ Type=oneshot
	126	+ ExecStart=$HOLD_BIN $DAUER
	127	+ TimeoutStartSec=60
	128	+ RemainAfterExit=yes
	129	+
	130	+ [Install]
	131	+ WantedBy=multi-user.target
	132	+ UNIT
	133	+ systemctl daemon-reload
	134	+ systemctl enable tvwall-splash.service >/dev/null 2>&1
	135	+ ok "tvwall-splash.service eingerichtet"
	136	+ else
	137	+ warn "/usr/bin/plymouth fehlt - Startbild laesst sich nicht halten"
	138	+ fi
	139	+
	140	+ # --- Plymouth liest das Bild aus der initramfs ----------------------------
	141	+ if command -v update-initramfs >/dev/null; then
	142	+ info "Aktualisiere initramfs (dauert einen Moment)"
	143	+ update-initramfs -u >/dev/null 2>&1 && ok "initramfs aktualisiert" \
	144	+ \|\| warn "initramfs liess sich nicht aktualisieren - meist trotzdem in Ordnung"
	145	+ fi
	146	+
	147	+ cat <<EOF
	148	+
	149	+ ===========================================================================
	150	+ Fertig. Beim naechsten Neustart erscheint dein Logo und bleibt bis
	151	+ $DAUER Sekunden nach dem Einschalten stehen - danach uebernimmt die
	152	+ Wiedergabe.
	153	+
	154	+ sudo reboot
	155	+
	156	+ Anders lange stehen lassen: sudo $0 <logo> --dauer 20
	157	+ Zurueck zum Original: sudo $0 --zurueck
	158	+ ===========================================================================
	159	+ EOF

		@@ -85,7 +85,7 @@ sudo systemctl restart tvwall
85	85	\| `SCAN_INTERVAL` \| Takt, in dem der Ordner neu eingelesen wird \|
86	86	\| `DISPLAY_MODE` \| `auto` (empfohlen), `drm` oder `desktop` \|
87	87	\| `RUN_USER` \| Benutzer des Dienstes \|
88		- \| `FRESH_MPV_FOR_VIDEO` \| `yes` startet mpv vor jedem Video neu (umgeht den `partial file`-Abbruch) \|
	88	+ \| `MPV_GPU_API` \| `opengl` (Standard) oder `vulkan`/`auto` — siehe Fehlersuche \|
89	89	\| `MPV_HWDEC` \| `no` (Standard, Software) oder `auto-safe` (Hardware, nur Pi 4) \|
90	90	\| `STALL_TIMEOUT` \| Sekunden ohne Fortschritt, bevor ein Video übersprungen wird \|
91	91	\| `MPV_EXTRA_ARGS` \| zusätzliche mpv-Optionen, z. B. `--video-rotate=90` \|
		@@ -241,13 +241,32 @@ abschalten. Zweithäufigste Ursache: fehlender Ländercode (`AP_COUNTRY`).
241	241	Zuerst `http://192.168.4.1` probieren — Namen wie `tvwall.local` funktionieren
242	242	nicht auf allen Handys. Läuft der Dienst? `systemctl status tvwall`.
243	243
244		- Ein Video bleibt nach ein paar Sekunden stehen.
245		- Seit Version 1.0.0 wird jede Datei einzeln an mpv übergeben; der früher
246		- beobachtete Abbruch mit `partial file` beim Übergang Bild → Video ist damit
247		- erledigt. Tritt trotzdem etwas auf, misst `scripts/bisect-mpv.sh` jede Variante
248		- einzeln durch.
	244	+ **Das Bild bleibt nach einigen Wechseln stehen, obwohl das Webinterface
	245	+ weiterzählt.**
	246	+ Das ist der Grund für die Voreinstellung `MPV_GPU_API="opengl"`. Über Vulkan
	247	+ baut libplacebo bei jedem Bildwechsel die Swapchain neu auf und läuft nach rund
	248	+ neun Wechseln in `VK_ERROR_OUT_OF_HOST_MEMORY`. mpv läuft dann weiter und meldet
	249	+ auch weiter Dateiwechsel — nur gemalt wird nichts mehr. Im Journal steht:
	250	+
	251	+ ```
	252	+ [vo/gpu/libplacebo] vk->CreateSwapchainKHR(...): VK_ERROR_OUT_OF_HOST_MEMORY
	253	+ [vo/gpu/libplacebo] Failed (re)creating swapchain!
	254	+ ```
	255	+
	256	+ Nachgemessen auf einem Pi 5 (Wayland/labwc, mpv 0.40), 20 Bildwechsel:
249	257
250		- Zuerst `MPV_HWDEC="no"` prüfen (seit Version 1.0.0 die Voreinstellung). Der
	258	+ \| Renderer \| Swapchain-Fehler \|
	259	+ \|---\|---\|
	260	+ \| `--vo=gpu` (Vulkan) \| 24 \|
	261	+ \| `--vo=gpu --gpu-api=opengl` \| 0 \|
	262	+ \| `--vo=gpu-next` (Vulkan) \| 84 \|
	263	+
	264	+ Dasselbe galt für Videos: Mit Vulkan brach die Wiedergabe nach ein bis zwei
	265	+ Sekunden ab, mit OpenGL lief derselbe Clip vollständig durch. `diagnose.sh`
	266	+ prüft das mit.
	267	+
	268	+ Ein Video bleibt nach ein paar Sekunden stehen.
	269	+ Zuerst `MPV_GPU_API="opengl"` prüfen (siehe oben), dann `MPV_HWDEC="no"`. Der
251	270	Raspberry Pi 5 hat keinen Hardware-Dekoder für H.264 mehr; mit `auto-safe`
252	271	läuft ein Video dort ein bis zwei Sekunden und friert dann ein — genau so lange,
253	272	wie der bereits gefüllte Puffer reicht. Zum Gegenprüfen hilft der direkte
		@@ -305,8 +324,9 @@ systemd/ Vorlagen für den Dienst (drm / desktop)
305	324	internal/player/display.go Wayland-/X11-/DRM-Erkennung
306	325	scripts/setup-ap.sh Access Point per nmcli
307	326	scripts/diagnose.sh Selbsttest bei Problemen
	327	+ scripts/console-mode.sh Desktop abschalten, direkt in die Anzeige booten
	328	+ scripts/set-splash.sh eigenes Logo als Startbildschirm setzen
308	329	scripts/bisect-mpv.sh misst, welche mpv-Option einen Haenger ausloest
309		- scripts/probe-transition.py prueft den Uebergang Bild -> Video im selben mpv
310	330	install.sh Installation auf dem Pi
311	331	```
312	332
		@@ -320,6 +340,10 @@ Ein paar Entscheidungen, die vielleicht nicht offensichtlich sind:
320	340	* Die Oberfläche kommt ohne externe Bibliotheken aus und ist ins Programm
321	341	eingebettet. Am Access Point gibt es kein Internet — alles, was von einem CDN
322	342	nachgeladen werden müsste, wäre dort tot.
	343	+ * mpv rendert über OpenGL, nicht über Vulkan. Auf dem Raspberry Pi 5 baut
	344	+ die Vulkan-Anbindung von libplacebo bei jedem Bildwechsel die Swapchain neu
	345	+ auf und läuft dabei nach rund neun Wechseln aus dem Speicher — der Bildschirm
	346	+ friert ein, während intern alles weiterläuft. Siehe Fehlersuche.
323	347	* Uploads landen erst in einer temporären Datei und werden nach vollem
324	348	Empfang umbenannt. So gerät keine halbe Datei in die Wiedergabe.
325	349

		@@ -1,90 +0,0 @@
1		- package player
2		-
3		- import (
4		- "path/filepath"
5		- "strings"
6		-
7		- "ehc/tvwall/internal/config"
8		- "ehc/tvwall/internal/playlist"
9		- )
10		-
11		- // segment ist ein Stueck Playliste, das ein mpv-Prozess am Stueck abspielt:
12		- // entweder eine Folge aufeinanderfolgender Bilder oder genau ein Video.
13		- //
14		- // Diese Aufteilung loest zwei beobachtete Fehler auf einmal:
15		- //
16		- // - Ein Video, das in einen mpv-Prozess geladen wird, der vorher schon etwas
17		- // angezeigt hat, bricht mit "partial file" ab. Jedes Video bekommt deshalb
18		- // einen eigenen, frischen Prozess.
19		- // - Wird dagegen jedes einzelne Bild per loadfile nachgeladen, bleibt die
20		- // Bildausgabe nach etwa neun Wechseln stehen (mpv meldet weiter Wechsel,
21		- // der Bildschirm friert ein). Bilderfolgen laufen deshalb als Playliste
22		- // innerhalb eines Prozesses - mpv schaltet selbst weiter.
23		- type segment struct {
24		- kind string // "images" oder "video"
25		- names []string
26		- }
27		-
28		- // buildSegments fasst aufeinanderfolgende Bilder zusammen; jedes Video wird
29		- // ein eigener Abschnitt.
30		- func buildSegments(entries []playlist.Entry) []segment {
31		- var segs []segment
32		- for _, e := range entries {
33		- if e.Kind == "video" {
34		- segs = append(segs, segment{kind: "video", names: []string{e.Name}})
35		- continue
36		- }
37		- if n := len(segs); n > 0 && segs[n-1].kind == "images" {
38		- segs[n-1].names = append(segs[n-1].names, e.Name)
39		- continue
40		- }
41		- segs = append(segs, segment{kind: "images", names: []string{e.Name}})
42		- }
43		- return segs
44		- }
45		-
46		- func (s segment) equal(o segment) bool {
47		- if s.kind != o.kind \|\| len(s.names) != len(o.names) {
48		- return false
49		- }
50		- for i := range s.names {
51		- if s.names[i] != o.names[i] {
52		- return false
53		- }
54		- }
55		- return true
56		- }
57		-
58		- func (s segment) label() string {
59		- if s.kind == "video" && len(s.names) == 1 {
60		- return "Video " + s.names[0]
61		- }
62		- return strings.Join(s.names, ", ")
63		- }
64		-
65		- // writePlaylist schreibt die Dateien des Abschnitts als m3u fuer mpv.
66		- func (s segment) writePlaylist(cfg *config.Config, mediaDir string) (string, error) {
67		- var b strings.Builder
68		- b.WriteString("#EXTM3U\n")
69		- for _, n := range s.names {
70		- b.WriteString(filepath.Join(mediaDir, n))
71		- b.WriteByte('\n')
72		- }
73		- path := filepath.Join(cfg.StateDir, "segment.m3u")
74		- if err := config.WriteFileAtomic(path, []byte(b.String()), 0o664); err != nil {
75		- return "", err
76		- }
77		- return path, nil
78		- }
79		-
80		- func sameSegments(a, b []segment) bool {
81		- if len(a) != len(b) {
82		- return false
83		- }
84		- for i := range a {
85		- if !a[i].equal(b[i]) {
86		- return false
87		- }
88		- }
89		- return true
90		- }

		@@ -163,6 +163,18 @@ if command -v nmcli >/dev/null; then
163	163	&& ok "tvwall-ap aktiv" \|\| warn "tvwall-ap nicht aktiv"
164	164	fi
165	165
	166	+ hdr "Bildausgabe"
	167	+ SWAP="$(journalctl -u tvwall --since "-30 min" --no-pager 2>/dev/null \| grep -ci swapchain)"
	168	+ if [[ "${SWAP:-0}" -gt 0 ]]; then
	169	+ bad "$SWAP Swapchain-Fehler in den letzten 30 Minuten"
	170	+ note "Die Vulkan-Anbindung von mpv laeuft auf dem Pi 5 nach wenigen"
	171	+ note "Bildwechseln aus dem Speicher: der Bildschirm friert ein, waehrend"
	172	+ note "das Webinterface weiterzaehlt."
	173	+ note "-> In $CONF setzen: MPV_GPU_API=\"opengl\" und Dienst neu starten"
	174	+ else
	175	+ ok "keine Swapchain-Fehler (MPV_GPU_API=${MPV_GPU_API:-opengl})"
	176	+ fi
	177	+
166	178	hdr "Letzte Protokollzeilen"
167	179	journalctl -u tvwall -n 40 --no-pager 2>/dev/null \| sed 's/^/ /'
168	180

		@@ -1,170 +0,0 @@
1		- #!/usr/bin/env python3
2		- """
3		- Prueft, ob ein Video in einem mpv-Prozess laeuft, der vorher ein Bild
4		- angezeigt hat - und welche mpv-Option das gegebenenfalls behebt.
5		-
6		- Genau dieser Uebergang ist der Grund, warum tvwall vor jedem Video einen
7		- frischen mpv-Prozess startet (FRESH_MPV_FOR_VIDEO). Findet dieses Skript eine
8		- Option, die den Uebergang heil macht, kann der Neustart entfallen.
9		-
10		- Aufruf (Dienst vorher anhalten):
11		-
12		- sudo systemctl stop tvwall
13		- sudo -u rk XDG_RUNTIME_DIR=/run/user/1000 \\
14		- python3 probe-transition.py <bild> <video>
15		- sudo systemctl start tvwall
16		- """
17		- import json
18		- import os
19		- import socket
20		- import subprocess
21		- import sys
22		- import tempfile
23		- import time
24		-
25		- BASE = [
26		- "--fullscreen", "--idle=yes", "--force-window=yes", "--keep-open=no",
27		- "--image-display-duration=2", "--hwdec=no", "--no-osc", "--osd-level=0",
28		- "--cursor-autohide=always", "--no-input-default-bindings",
29		- "--input-vo-keyboard=no", "--no-input-terminal", "--msg-level=all=error",
30		- "--vo=gpu",
31		- ]
32		-
33		- VARIANTEN = [
34		- ("Grundzustand (wie der Dienst)", []),
35		- ("--demuxer-thread=no", ["--demuxer-thread=no"]),
36		- ("--cache=no", ["--cache=no"]),
37		- ("--cache=yes", ["--cache=yes"]),
38		- ("ohne Zusatzdateien-Suche", ["--audio-file-auto=no", "--sub-auto=no",
39		- "--cover-art-auto=no"]),
40		- ("--vd-lavc-dr=no", ["--vd-lavc-dr=no"]),
41		- ("--demuxer-lavf-probe-info=nostreams", ["--demuxer-lavf-probe-info=nostreams"]),
42		- ("--gapless-audio=no", ["--gapless-audio=no"]),
43		- ("--force-window=no", ["--force-window=no"]),
44		- ("--no-audio", ["--no-audio"]),
45		- ]
46		-
47		-
48		- class Mpv:
49		- """Minimaler Client fuer den JSON-IPC-Socket von mpv."""
50		-
51		- def __init__(self, path):
52		- self.sock = socket.socket(socket.AF_UNIX)
53		- for _ in range(80):
54		- try:
55		- self.sock.connect(path)
56		- break
57		- except OSError:
58		- time.sleep(0.25)
59		- else:
60		- raise RuntimeError("mpv-Socket nicht erreichbar")
61		- self.buf = b""
62		- self.rid = 0
63		-
64		- def command(self, *args):
65		- self.rid += 1
66		- rid = self.rid
67		- self.sock.sendall(
68		- (json.dumps({"command": list(args), "request_id": rid}) + "\n").encode())
69		- deadline = time.time() + 5
70		- while time.time() < deadline:
71		- self.sock.settimeout(max(0.1, deadline - time.time()))
72		- try:
73		- chunk = self.sock.recv(65536)
74		- except (socket.timeout, OSError):
75		- break
76		- if not chunk:
77		- break
78		- self.buf += chunk
79		- while b"\n" in self.buf:
80		- line, self.buf = self.buf.split(b"\n", 1)
81		- try:
82		- msg = json.loads(line)
83		- except ValueError:
84		- continue
85		- if msg.get("request_id") == rid:
86		- return msg.get("data")
87		- return None
88		-
89		- def close(self):
90		- try:
91		- self.sock.close()
92		- except OSError:
93		- pass
94		-
95		-
96		- def probe(extra, image, video):
97		- """Bild laden, dann Video - und schauen, ob das Video wirklich laeuft."""
98		- tmp = tempfile.mkdtemp()
99		- sock = os.path.join(tmp, "s")
100		- proc = subprocess.Popen(
101		- ["mpv", "--input-ipc-server=" + sock] + BASE + extra,
102		- stdout=subprocess.DEVNULL, stderr=subprocess.PIPE)
103		- try:
104		- m = Mpv(sock)
105		- m.command("loadfile", image, "replace")
106		- time.sleep(2.5)
107		- m.command("loadfile", video, "replace")
108		- time.sleep(2.0)
109		- erst = m.command("get_property", "time-pos")
110		- time.sleep(3.0)
111		- spaeter = m.command("get_property", "time-pos")
112		- m.close()
113		-
114		- if not isinstance(erst, (int, float)) or not isinstance(spaeter, (int, float)):
115		- return False, "Video wurde gar nicht erst geladen"
116		- if spaeter - erst < 1.0:
117		- return False, "steht bei %.1f s" % spaeter
118		- return True, "laeuft bis %.1f s" % spaeter
119		- finally:
120		- proc.kill()
121		- try:
122		- err = proc.stderr.read().decode(errors="replace").strip()
123		- except Exception:
124		- err = ""
125		- proc.wait()
126		- if err:
127		- probe.last_error = err.splitlines()[-3:]
128		- else:
129		- probe.last_error = []
130		-
131		-
132		- def main():
133		- if len(sys.argv) != 3:
134		- print(__doc__)
135		- sys.exit(1)
136		- image, video = sys.argv[1], sys.argv[2]
137		- for f in (image, video):
138		- if not os.path.isfile(f):
139		- print("Datei fehlt:", f)
140		- sys.exit(1)
141		-
142		- print("\nBild : %s\nVideo: %s\n" % (image, video))
143		- print("Uebergang Bild -> Video im selben mpv-Prozess:\n")
144		-
145		- gut = []
146		- for name, extra in VARIANTEN:
147		- ok, info = probe(extra, image, video)
148		- print(" %-38s %s (%s)" % (name, "LAEUFT" if ok else "HAENGT", info))
149		- for zeile in getattr(probe, "last_error", []):
150		- print(" %s" % zeile)
151		- if ok:
152		- gut.append(name)
153		-
154		- print()
155		- if not gut:
156		- print("Keine Option hilft. Der Neustart vor jedem Video")
157		- print("(FRESH_MPV_FOR_VIDEO=\"yes\") bleibt die richtige Loesung.")
158		- elif gut == [n for n, _ in VARIANTEN]:
159		- print("Alle Varianten laufen - der Uebergang ist auf diesem System heil.")
160		- print("Dann kann FRESH_MPV_FOR_VIDEO=\"no\" gesetzt werden.")
161		- else:
162		- print("Diese Optionen beheben den Uebergang:")
163		- for n in gut:
164		- print(" ", n)
165		- print("\nTrag die passende in MPV_EXTRA_ARGS ein und setze")
166		- print("FRESH_MPV_FOR_VIDEO=\"no\" - dann entfaellt der Neustart.")
167		-
168		-
169		- if __name__ == "__main__":
170		- main()

		@@ -76,6 +76,15 @@ DISPLAY_MODE="auto"
76	76	# Bei DISPLAY_MODE="auto" erkennt install.sh das und traegt es hier ein.
77	77	RUN_USER="tvwall"
78	78
	79	+ # Grafik-Anbindung von mpv.
	80	+ # opengl = Standard und dringend empfohlen
	81	+ # vulkan = schneller, aber auf dem Raspberry Pi 5 fehlerhaft: libplacebo baut
	82	+ # bei jedem Bildwechsel die Swapchain neu auf und laeuft nach rund
	83	+ # neun Wechseln in VK_ERROR_OUT_OF_HOST_MEMORY - mpv laeuft dann
	84	+ # weiter, der Bildschirm friert ein.
	85	+ # auto = mpv entscheidet (waehlt auf dem Pi 5 Vulkan - nicht empfohlen)
	86	+ MPV_GPU_API="opengl"
	87	+
79	88	# Hardwarebeschleunigte Videodekodierung.
80	89	# no = alles in Software dekodieren (Standard, mpvs eigene Vorgabe)
81	90	# auto-safe = Hardware benutzen, wenn moeglich
		@@ -84,13 +93,6 @@ RUN_USER="tvwall"
84	93	# kann "auto-safe" dagegen Rechenzeit sparen.
85	94	MPV_HWDEC="no"
86	95
87		- # mpv vor jedem Video frisch starten.
88		- # Auf manchen Systemen bricht ein Video ab, wenn mpv vorher schon ein Bild
89		- # angezeigt hat ("partial file" im Protokoll). Ein frischer Prozess je Video
90		- # umgeht das; der Preis ist ein kurzer schwarzer Moment davor.
91		- # Mit scripts/probe-transition.py laesst sich pruefen, ob "no" reicht.
92		- FRESH_MPV_FOR_VIDEO="yes"
93		-
94	96	# Laeuft ein Video so lange nicht weiter (Sekunden), wird es uebersprungen,
95	97	# damit eine einzelne Datei nicht die ganze Wiedergabe anhaelt. 0 = aus.
96	98	STALL_TIMEOUT="30"

		@@ -37,6 +37,7 @@ type Config struct {
37	37	RunUser string
38	38	MpvExtraArgs string
39	39	MpvHwdec string
	40	+ MpvGpuAPI string
40	41	FreshForVideo bool // mpv vor jedem Video neu starten
41	42	StallTimeout int // Sekunden ohne Fortschritt, bevor ein Video uebersprungen wird
42	43
		@@ -60,7 +61,7 @@ func Default() *Config {
60	61	ScanInterval: 10,
61	62	DisplayMode: "auto",
62	63	MpvHwdec: "no",
63		- FreshForVideo: true,
	64	+ MpvGpuAPI: "opengl",
64	65	StallTimeout: 30,
65	66	RunUser: "tvwall",
66	67	StateDir: "/var/lib/tvwall",
		@@ -148,8 +149,10 @@ func Load(path string) (*Config, error) {
148	149	c.RunUser = val
149	150	case "MPV_EXTRA_ARGS":
150	151	c.MpvExtraArgs = val
151		- case "FRESH_MPV_FOR_VIDEO":
152		- c.FreshForVideo = isTrue(val)
	152	+ case "MPV_GPU_API":
	153	+ if val != "" {
	154	+ c.MpvGpuAPI = val
	155	+ }
153	156	case "MPV_HWDEC":
154	157	if val != "" {
155	158	c.MpvHwdec = val