| **Haken** | Ohne Haken bleibt die Datei liegen, wird auf der Wand aber übersprungen |

Reihenfolge, Haken und Einstellungen bleiben über einen Neustart hinweg

erhalten (`order.json`, `disabled.json`, `settings.json` im Datenverzeichnis).

Ausgeblendete Einträge stehen weiter im Webinterface, sind grau hinterlegt und

mit „ausgeblendet" gekennzeichnet — sie landen nur nicht in der `playlist.m3u`,

die mpv abspielt. Die Änderung greift am nächsten Dateiübergang, ein laufendes

Video wird also nicht unterbrochen.

scripts/silent-boot.sh    Textkonsole beim Starten unterdruecken

| `/api/enabled` | POST | `{"name":"a.jpg","enabled":false}` — aus der Wiedergabe nehmen |

# --- Startlogo --------------------------------------------------------------

# Bild, das beim Start zuerst gezeigt wird, bevor die Playliste beginnt.

# Leer = aus. Wird von scripts/set-splash.sh automatisch eingetragen.

#

# Warum ueber den Player und nicht ueber den System-Startbildschirm: Viele

# Fernseher wachen erst auf, wenn mpv den Bildmodus setzt - bis dahin ist der

# Startbildschirm des Systems gar nicht zu sehen.

BOOT_LOGO=""

# Wie lange das Startlogo stehen bleibt (Sekunden).

BOOT_LOGO_SECONDS="8"

	DisplayMode  string // "auto", "drm" oder "desktop"

	RunUser      string

	MpvExtraArgs string

	MpvHwdec     string

	MpvGpuAPI    string

	BootLogo        string  // Bild, das beim Start zuerst gezeigt wird

	BootLogoSeconds float64 // wie lange

	FreshForVideo   bool    // mpv vor jedem Video neu starten

	StallTimeout    int     // Sekunden ohne Fortschritt, bevor ein Video uebersprungen wird

		APSSID:          "TVWall-01",

		APPassword:      "tvwall1234",

		APCountry:       "DE",

		APIP:            "192.168.4.1",

		APChannel:       "7",

		Hostname:        "tvwall-01",

		WebPort:         80,

		MaxUploadMB:     2048,

		ImageDuration:   5,

		Audio:           true,

		ScanInterval:    10,

		DisplayMode:     "auto",

		MpvHwdec:        "no",

		MpvGpuAPI:       "opengl",

		BootLogoSeconds: 8,

		StallTimeout:    30,

		RunUser:         "tvwall",

		StateDir:        "/var/lib/tvwall",

		SocketPath:      "/run/tvwall/mpv.sock",

func (c *Config) DisabledFile() string { return filepath.Join(c.StateDir, "disabled.json") }

		case "BOOT_LOGO":

			c.BootLogo = val

		case "BOOT_LOGO_SECONDS":

			if f, err := strconv.ParseFloat(val, 64); err == nil && f >= 0 {

				c.BootLogoSeconds = f

			}

	bootLogoDone bool // Startlogo wurde in dieser Dienstlaufzeit schon gezeigt

	// Die Playliste wird mpv direkt auf der Kommandozeile mitgegeben. Sonst

	// muesste erst die IPC-Verbindung stehen, bevor ueberhaupt etwas zu sehen

	// ist - das kostet beim Start rund eine Sekunde, in der die Textkonsole

	// sichtbar wird.

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

	// Startlogo: beim ersten mpv-Start dieser Dienstlaufzeit bekommt mpv das

	// Logo als erste Datei. So ist es das allererste Bild auf dem Schirm.

	startLogo := ""

	p.mu.RLock()

	logoGezeigt := p.bootLogoDone

	p.mu.RUnlock()

	if !logoGezeigt && p.cfg.BootLogo != "" && p.cfg.BootLogoSeconds > 0 {

		if _, err := os.Stat(p.cfg.BootLogo); err == nil {

			startLogo = p.cfg.BootLogo

		} else {

			log.Printf("player: startlogo %q nicht lesbar: %v", p.cfg.BootLogo, err)

		}

	}

	aktive := p.pl.ActiveCount()

	args := p.mpvArgs(disp, aktive, startLogo)

	var logoTimer *time.Timer

	switch {

	case startLogo != "":

		// mpv zeigt das Logo bereits - nur den Zeitpunkt merken, an dem auf

		// die Playliste umgeschaltet wird. applySettings kaeme der

		// Anzeigedauer des Logos in die Quere und folgt deshalb spaeter.

		p.mu.Lock()

		p.bootLogoDone = true

		p.status.Current = filepath.Base(startLogo)

		p.mu.Unlock()

		logoTimer = time.NewTimer(time.Duration(p.cfg.BootLogoSeconds * float64(time.Second)))

		log.Printf("player: startlogo %s fuer %.0f s", filepath.Base(startLogo), p.cfg.BootLogoSeconds)

	case aktive > 0:

		// Playliste lief schon beim Start von mpv mit - nur den Stand merken.

		p.applySettings(client)

		p.mu.Lock()

		p.loadedID = version

		p.pending = false

		p.mu.Unlock()

		log.Printf("player: playliste beim start uebergeben (%d von %d eintraegen aktiv)",

			aktive, len(entries))

	default:

		p.applySettings(client)

		p.loadPlaylist(client)

	}

		case <-timerC(logoTimer):

			logoTimer.Stop()

			logoTimer = nil

			p.applySettings(client) // Anzeigedauer wieder auf den Normalwert

			p.loadPlaylist(client)

// timerC liefert den Kanal eines Timers - oder nil, wenn keiner laeuft.

// Ein nil-Kanal blockiert im select-Zweig fuer immer, genau wie gewuenscht.

func timerC(t *time.Timer) <-chan time.Time {

	if t == nil {

		return nil

	}

	return t.C

}

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

	aktive := p.pl.ActiveCount()

	if aktive == 0 {

	log.Printf("player: playliste geladen (%d eintraege)", aktive)

func (p *Player) mpvArgs(disp display, aktive int, startLogo string) []string {

	anzeigedauer := s.ImageDuration

	if startLogo != "" {

		// Etwas laenger als bis zum Umschalten, damit keine Luecke entsteht.

		anzeigedauer = p.cfg.BootLogoSeconds + 2

	}

		"--image-display-duration=" + strconv.FormatFloat(anzeigedauer, 'f', -1, 64),

	// Die erste Datei bekommt mpv direkt mit: so erscheint das Bild, sobald

	// mpv den Bildschirm hat, ohne Umweg ueber die IPC-Verbindung.

	switch {

	case startLogo != "":

		args = append(args, startLogo)

	case aktive > 0:

		args = append(args, "--playlist="+p.pl.PlaylistFile())

	}

	// Enabled=false: Die Datei bleibt liegen und steht im Webinterface, wird

	// auf der Wand aber nicht gezeigt.

	Enabled bool `json:"enabled"`

	disabledFile string

		disabledFile: cfg.DisabledFile(),

	ausgeblendet := m.readDisabled()

		e := Entry{

			Name: name, Kind: Kind(name),

			Size: info.Size(), MTime: info.ModTime().Unix(),

			Enabled: !ausgeblendet[name],

		}

// SetEnabled blendet einen Eintrag auf der Wand ein oder aus. Die Datei bleibt

// dabei liegen und im Webinterface sichtbar.

func (m *Manager) SetEnabled(name string, enabled bool) error {

	safe, err := SafeName(name)

	if err != nil {

		return err

	}

	ausgeblendet := m.readDisabled()

	if enabled {

		delete(ausgeblendet, safe)

	} else {

		ausgeblendet[safe] = true

	}

	namen := make([]string, 0, len(ausgeblendet))

	for n := range ausgeblendet {

		namen = append(namen, n)

	}

	sort.Strings(namen)

	data, err := json.MarshalIndent(namen, "", "  ")

	if err != nil {

		return err

	}

	if err := config.WriteFileAtomic(m.disabledFile, append(data, '\n'), 0o664); err != nil {

		return fmt.Errorf("ausgeblendete eintraege speichern: %w", err)

	}

	_, err = m.Scan()

	return err

}

func (m *Manager) readDisabled() map[string]bool {

	out := map[string]bool{}

	data, err := os.ReadFile(m.disabledFile)

	if err != nil {

		return out

	}

	var namen []string

	if json.Unmarshal(data, &namen) != nil {

		return out

	}

	for _, n := range namen {

		out[n] = true

	}

	return out

}

// ActiveCount liefert die Anzahl der Eintraege, die tatsaechlich gezeigt werden.

func (m *Manager) ActiveCount() int {

	m.mu.RLock()

	defer m.mu.RUnlock()

	n := 0

	for _, e := range m.entries {

		if e.Enabled {

			n++

		}

	}

	return n

}

		if !e.Enabled {

			continue // bleibt in der Liste, wird aber nicht abgespielt

		}

		if a[i].Name != b[i].Name || a[i].MTime != b[i].MTime ||

			a[i].Size != b[i].Size || a[i].Enabled != b[i].Enabled {

  if (!state.entries.length) {

    el.counter.textContent = '';

  } else if (d.active === state.entries.length) {

    el.counter.textContent = `${state.entries.length} Einträge · ${d.images} Bilder · ${d.videos} Videos`;

  } else {

    el.counter.textContent = `${d.active} von ${state.entries.length} aktiv · ${d.images} Bilder · ${d.videos} Videos`;

  }

    const toggle = document.createElement('label');

    toggle.className = 'toggle';

    toggle.title = entry.enabled ? 'Wird auf der Wand gezeigt' : 'Wird uebersprungen';

    const box = document.createElement('input');

    box.type = 'checkbox';

    box.checked = entry.enabled;

    box.setAttribute('aria-label', 'Auf der Wand zeigen');

    box.addEventListener('change', () => setEnabled(entry.name, box.checked, li));

    toggle.appendChild(box);

    if (!entry.enabled) {

      const off = document.createElement('span');

      off.className = 'badge off';

      off.textContent = 'ausgeblendet';

      tags.append(off);

    }

    li.classList.toggle('off', !entry.enabled);

    li.append(grip, toggle, img, meta, actions);

//

// Bewusst OHNE setPointerCapture und ohne Ereignisse am Griff selbst: Beim

// Umsortieren wird die Zeile im DOM verschoben, dabei verliert der Griff die

// Zeigererfassung und es kommen keine weiteren Ereignisse mehr an. Die

// Ereignisse haengen deshalb am Dokument, das sich nie bewegt.

let dragState = null;

  dragState = { li: li, id: ev.pointerId };

  document.addEventListener('pointermove', onDragMove, { passive: false });

  document.addEventListener('pointerup', endDrag);

  document.addEventListener('pointercancel', endDrag);

// Zielposition aus der Zeigerhoehe bestimmen, statt das Element unter dem

// Zeiger zu suchen: unabhaengig davon, was gerade darueber liegt.

  if (!dragState) return;

  if (ev.pointerId !== dragState.id) return;

  const y = ev.clientY;

  let eingefuegt = false;

  for (const item of Array.from(el.list.children)) {

    if (item === dragState.li) continue;

    const r = item.getBoundingClientRect();

    if (y < r.top + r.height / 2) {

      el.list.insertBefore(dragState.li, item);

      eingefuegt = true;

      break;

    }

  }

  if (!eingefuegt) el.list.appendChild(dragState.li);

  if (!dragState) return;

  if (ev && ev.pointerId !== undefined && ev.pointerId !== dragState.id) return;

  document.removeEventListener('pointermove', onDragMove);

  document.removeEventListener('pointerup', endDrag);

  document.removeEventListener('pointercancel', endDrag);

  dragState.li.classList.remove('dragging');

  dragState = null;

async function setEnabled(name, enabled, li) {

  li.classList.toggle('off', !enabled);

  try {

    await api('/api/enabled', { name: name, enabled: enabled });

    renderedVersion = -1;

    toast(enabled ? name + ' wird wieder gezeigt' : name + ' wird übersprungen', 'ok');

  } catch (e) {

    li.classList.toggle('off', enabled);

    toast('Änderung fehlgeschlagen: ' + e.message, 'err');

  }

}

  grid-template-columns: auto auto 84px 1fr auto;

/* Haken: bestimmt, ob der Eintrag auf der Wand erscheint */

.toggle { display: grid; place-items: center; padding: .2rem; cursor: pointer; }

.toggle input { width: 22px; height: 22px; accent-color: var(--accent); cursor: pointer; }

.item.off { opacity: .55; }

.item.off .thumb { filter: grayscale(1); }

.badge.off { background: #3a2a1e; color: #e0b088; }

  .item { grid-template-columns: auto auto 64px 1fr auto; }

	mux.HandleFunc("/api/enabled", s.handleEnabled)

	Active    int    `json:"active"`

	var images, videos, active int

		if e.Enabled {

			active++

		}

			Active:    active,

func (s *Server) handleEnabled(w http.ResponseWriter, r *http.Request) {

	if r.Method != http.MethodPost {

		httpError(w, http.StatusMethodNotAllowed, "nur POST")

		return

	}

	var req struct {

		Name    string `json:"name"`

		Enabled bool   `json:"enabled"`

	}

	if err := json.NewDecoder(io.LimitReader(r.Body, 1<<16)).Decode(&req); err != nil {

		httpError(w, http.StatusBadRequest, "ungueltige Anfrage")

		return

	}

	if err := s.pl.SetEnabled(req.Name, req.Enabled); err != nil {

		httpError(w, http.StatusBadRequest, err.Error())

		return

	}

	writeJSON(w, http.StatusOK, map[string]any{"ok": true})

}

#  Dasselbe Bild wird ausserdem als Startlogo des Players hinterlegt

#  (BOOT_LOGO). Das ist der zuverlaessige Teil: Viele Fernseher wachen erst

#  auf, wenn mpv den Bildmodus setzt - der Startbildschirm des Systems ist bis

#  dahin gar nicht zu sehen, beim Herunterfahren dagegen schon.

#

#  --dauer N haelt zusaetzlich den System-Startbildschirm bis N Sekunden nach

#  dem Einschalten (0 = aus, Standard 0).

TVWALL_CONF="/etc/tvwall/tvwall.conf"

BOOT_LOGO="/var/lib/tvwall/boot-logo.png"

DAUER=0

  if [[ -f "$TVWALL_CONF" ]]; then

    sed -i 's|^BOOT_LOGO=.*|BOOT_LOGO=""|' "$TVWALL_CONF"

    systemctl restart tvwall 2>/dev/null || true

    ok "Startlogo des Players abgeschaltet"

  fi

  rm -f "$BOOT_LOGO"

# --- dasselbe Bild als Startlogo des Players -------------------------------

# Der zuverlaessige Teil: mpv schaltet den Bildschirm ein, also sieht man

# dieses Bild garantiert - unabhaengig davon, wann der Fernseher aufwacht.

if [[ -d "$(dirname "$BOOT_LOGO")" ]]; then

  install -m 0644 "$TMP/splash.png" "$BOOT_LOGO"

  RUN_USER="$(sed -n 's/^RUN_USER="\(.*\)"/\1/p' "$TVWALL_CONF" 2>/dev/null | head -1)"

  [[ -n "${RUN_USER:-}" ]] && chown "$RUN_USER" "$BOOT_LOGO" 2>/dev/null || true

  ok "Startlogo des Players: $BOOT_LOGO"

  if [[ -f "$TVWALL_CONF" ]]; then

    if grep -q "^BOOT_LOGO=" "$TVWALL_CONF"; then

      sed -i "s|^BOOT_LOGO=.*|BOOT_LOGO=\"$BOOT_LOGO\"|" "$TVWALL_CONF"

    else

      printf '\n# Startlogo, von set-splash.sh eingetragen\nBOOT_LOGO="%s"\nBOOT_LOGO_SECONDS="8"\n' \

        "$BOOT_LOGO" >> "$TVWALL_CONF"

    fi

    ok "BOOT_LOGO in $TVWALL_CONF eingetragen"

    systemctl restart tvwall 2>/dev/null && ok "Dienst neu gestartet - das Logo ist sofort zu sehen" || true

  fi

else

  warn "$(dirname "$BOOT_LOGO") fehlt - Startlogo des Players nicht gesetzt"

fi

if [[ "$DAUER" == "0" ]]; then

  if [[ -f "$HOLD_UNIT" ]]; then

    systemctl disable --now tvwall-splash.service >/dev/null 2>&1 || true

    rm -f "$HOLD_UNIT" "$HOLD_BIN"

    systemctl daemon-reload

    ok "Halten des System-Startbildes entfernt (--dauer 0)"

  fi

elif [[ -x /usr/bin/plymouth ]]; then

  info "System-Startbild bis $DAUER s nach dem Einschalten halten"

 Fertig.

   - Der Player zeigt das Logo beim Start 8 Sekunden lang, bevor die

     Playliste beginnt. Das sieht man sicher, weil mpv den Bildschirm

     einschaltet.

   - Beim Herunterfahren zeigt das System denselben Bildschirm.

 Anzeigedauer aendern:  BOOT_LOGO_SECONDS in $TVWALL_CONF

 Zurueck zum Original:  sudo $0 --zurueck

#!/usr/bin/env bash

# ===========================================================================

#  Entfernt den Textbildschirm zwischen Startlogo und Wiedergabe.

#

#  Drei Aenderungen:

#    1. Konsolenmeldungen auf tty3 umleiten - tty1 bleibt sauber

#    2. Plymouth wird erst beendet, wenn tvwall startet - und zwar von tvwall

#       selbst, direkt bevor mpv losgeht. Mit --retain-splash bleibt das Logo

#       dabei stehen, bis mpv das erste Mal malt.

#    3. tvwall raeumt tty1 nicht mehr auf (das hat das Bild geloescht),

#       leert aber einmal dessen Textpuffer - sonst taucht Plymouths

#       Statustext wieder auf, sobald die Wiedergabe endet

#

#  Aufruf:  sudo ~/silent-boot.sh            einschalten

#           sudo ~/silent-boot.sh --zurueck  rueckgaengig

# ===========================================================================

set -euo pipefail

CMDLINE="/boot/firmware/cmdline.txt"; [[ -f "$CMDLINE" ]] || CMDLINE="/boot/cmdline.txt"

QUIT_DIR="/etc/systemd/system/plymouth-quit.service.d"

TVWALL_DIR="/etc/systemd/system/tvwall.service.d"

EXTRA=(loglevel=3 logo.nologo vt.global_cursor_default=0 consoleblank=0)

ok()   { printf '\033[1;32m  ✓\033[0m %s\n' "$*"; }

info() { printf '\033[1;36m==>\033[0m %s\n' "$*"; }

die()  { printf '\033[1;31mFehler:\033[0m %s\n' "$*" >&2; exit 1; }

[[ $EUID -eq 0 ]] || die "bitte mit sudo starten"

schreibe_cmdline() {

  local zeile="$1"

  cp -f "$CMDLINE" "$CMDLINE.tvwall-backup"

  printf '%s\n' "$zeile" > "$CMDLINE"

  if [[ "$(grep -c . "$CMDLINE")" != "1" ]] || ! grep -q "root=" "$CMDLINE"; then

    cp -f "$CMDLINE.tvwall-backup" "$CMDLINE"

    die "cmdline.txt sah falsch aus - Sicherung zurueckgespielt"

  fi

}

if [[ "${1:-}" == "--zurueck" ]]; then

  zeile="$(tr -d '\n' < "$CMDLINE")"

  zeile="${zeile//console=tty3/console=tty1}"

  for e in "${EXTRA[@]}"; do zeile="${zeile// $e/}"; done

  schreibe_cmdline "$zeile"

  rm -rf "$QUIT_DIR" "$TVWALL_DIR/silent.conf" /usr/local/bin/tvwall-clear-tty

  systemctl daemon-reload

  ok "rueckgaengig gemacht - bitte neu starten"

  exit 0

fi

# --- 1) Konsole von tty1 wegnehmen ----------------------------------------

info "Konsolenmeldungen auf tty3 umleiten"

zeile="$(tr -d '\n' < "$CMDLINE")"

zeile="${zeile//console=tty1/console=tty3}"

for e in "${EXTRA[@]}"; do

  zeile="${zeile// $e/}"      # doppelte Eintraege vermeiden

  zeile="$zeile $e"

done

schreibe_cmdline "$zeile"

ok "console=tty3 ${EXTRA[*]}"

echo "    ($(grep -c . "$CMDLINE") Zeile, root= vorhanden)"

# --- 2) Logo stehen lassen, bis mpv malt ----------------------------------

info "Plymouth soll das Bild beim Beenden stehen lassen"

install -d -m 0755 "$QUIT_DIR"

cat > "$QUIT_DIR/retain-splash.conf" <<'UNIT'

# Von tvwall silent-boot.sh:

#  - --retain-splash laesst das Startbild auf dem Schirm stehen, bis mpv das

#    erste Mal malt. Ohne das gibt Plymouth den Bildschirm frei und die

#    Textkonsole blitzt auf.

#  - After=tvwall.service: nicht schon beenden, waehrend die Wiedergabe noch

#    startet. tvwall beendet Plymouth selbst, direkt bevor mpv losgeht.

[Unit]

After=tvwall.service

[Service]

ExecStart=

ExecStart=-/usr/bin/plymouth quit --retain-splash

UNIT

ok "$QUIT_DIR/retain-splash.conf"

# --- 3) tvwall soll tty1 nicht mehr loeschen ------------------------------

info "Textpuffer von tty1 leeren"

cat > /usr/local/bin/tvwall-clear-tty <<'CLR'

#!/bin/sh

# Leert den Textpuffer der virtuellen Konsole tty1.

# Plymouth legt dort neben der Grafikausgabe eine Textanzeige an und schreibt

# seine Statuszeilen hinein. Sichtbar wird das erst, wenn die Wiedergabe endet

# und die Konsole ihren Inhalt neu zeichnet - dann steht dort alter Text.

# Wird ausgefuehrt, solange Plymouth den Bildschirm noch im Grafikmodus haelt:

# der Puffer wird geleert, ohne dass davon etwas zu sehen ist.

printf '' > /dev/tty1 2>/dev/null

exit 0

CLR

chmod 0755 /usr/local/bin/tvwall-clear-tty

ok "/usr/local/bin/tvwall-clear-tty"

info "tvwall raeumt tty1 nicht mehr auf"

install -d -m 0755 "$TVWALL_DIR"

cat > "$TVWALL_DIR/silent.conf" <<'UNIT'

# Von tvwall silent-boot.sh:

#  - TTYVTDisallocate/setterm haben das stehengelassene Startbild geloescht.

#    Der Bildschirmschoner der Konsole wird jetzt ueber consoleblank=0

#    im Bootparameter abgeschaltet.

#  - ExecStartPre uebergibt den Bildschirm: Plymouth gibt ihn frei (das Bild

#    bleibt dank --retain-splash stehen), direkt danach uebernimmt mpv.

#    Das "+" laesst diesen einen Schritt mit vollen Rechten laufen.

[Service]

TTYVTDisallocate=no

NoNewPrivileges=no

ExecStartPre=

ExecStartPre=+/usr/local/bin/tvwall-clear-tty

ExecStartPre=+/bin/sh -c '/usr/bin/plymouth quit --retain-splash 2>/dev/null || true'

ExecStopPost=+/usr/local/bin/tvwall-clear-tty

UNIT

ok "$TVWALL_DIR/silent.conf"

systemctl daemon-reload

ok "systemd neu eingelesen"

cat <<EOF

===========================================================================

 Jetzt neu starten:  sudo reboot

 Erwartet: Logo erscheint - bleibt stehen - Wiedergabe uebernimmt.

 Kein Text mehr dazwischen.

 Zur Kontrolle danach:

   systemd-analyze critical-chain tvwall.service | head -5

   journalctl -b -o short-monotonic | grep -E "plymouth-quit|starte mpv"

   -> die beiden Zeitpunkte sollten dicht beieinander liegen

 Rueckgaengig:  sudo ~/silent-boot.sh --zurueck && sudo reboot

 Hinweis: Startmeldungen liegen danach auf tty3 (Strg+Alt+F3) und

 weiterhin vollstaendig im Journal:  journalctl -b

===========================================================================

EOF