diff --git a/.gitignore b/.gitignore
index 93ba9b5..619f3db 100644
--- a/.gitignore
+++ b/.gitignore
@@ -15,6 +15,10 @@ data/presets-projectm/
data/videos/*
!data/videos/README.txt
+# Config de runtime (por instalacion): no va al repo
+data/mapping.json
+data/pm-favoritos.json
+
# Temporales
*.log
*.tmp
diff --git a/backend/server.py b/backend/server.py
index dd14f96..95a446f 100644
--- a/backend/server.py
+++ b/backend/server.py
@@ -14,6 +14,7 @@ Motores: projectm (nativo), butterchurn, hydra, shaders (GLSL) y mixer
import json
import os
+import re
import shutil
import socket
import subprocess
@@ -21,8 +22,9 @@ import threading
import time
from pathlib import Path
-from flask import Flask, send_from_directory
+from flask import Flask, request, send_from_directory
from flask_socketio import SocketIO
+from werkzeug.utils import secure_filename
# --------------------------------------------------------------------------
# Rutas y configuracion
@@ -32,6 +34,8 @@ WEB = BASE / "web"
DATA = BASE / "data"
VIDEOS = DATA / "videos"
VIDEO_EXT = (".mp4", ".webm", ".mov", ".m4v", ".ogv")
+IMAGE_EXT = (".jpg", ".jpeg", ".png", ".gif", ".webp")
+MEDIA_EXT = VIDEO_EXT + IMAGE_EXT # la galeria del mezclador admite ambos
def load_json(path, default):
@@ -51,6 +55,7 @@ PORT = int(os.environ.get("FOSFENO_PORT") or CFG.get("server", {}).get("port", 8
NO_KIOSK = bool(os.environ.get("FOSFENO_NO_KIOSK"))
app = Flask(__name__, static_folder=None)
+app.config["MAX_CONTENT_LENGTH"] = 4 * 1024 ** 3 # subidas de hasta 4 GB
socketio = SocketIO(app, async_mode="threading", cors_allowed_origins="*")
# --------------------------------------------------------------------------
@@ -73,7 +78,28 @@ def list_videos():
if not VIDEOS.is_dir():
return []
return sorted(f.name for f in VIDEOS.iterdir()
- if f.suffix.lower() in VIDEO_EXT)
+ if f.suffix.lower() in MEDIA_EXT)
+
+
+def list_projectm_presets():
+ """Categorias y visuales de data/presets-projectm. El pack se organiza
+ como categoria/visual/variante.milk: cada 'visual' (Aurora, Blobby...)
+ es una carpeta con variantes del mismo estilo. Devuelve
+ {categoria: [visuales]}. Las carpetas '!...' se saltan (transiciones)."""
+ base = DATA / "presets-projectm"
+ cats = {}
+ if not base.is_dir():
+ return cats
+ for d in sorted(base.iterdir()):
+ if not d.is_dir() or d.name.startswith(("!", ".")):
+ continue
+ visuals = sorted(
+ v.name for v in d.iterdir()
+ if v.is_dir() and any(f.suffix.lower() == ".milk"
+ for f in v.iterdir()))
+ if visuals:
+ cats[d.name] = visuals
+ return cats
# --------------------------------------------------------------------------
@@ -85,7 +111,9 @@ state = {
"engine": DEFAULTS.get("engine", "butterchurn"),
"power": True,
"sensitivity": float(DEFAULTS.get("sensitivity", 1.0)),
- "audio": {"device": "", "bpm": 0},
+ # source: "mic" (microfono de la sala) o "monitor" (lo que suena en el
+ # propio equipo: navegador, Spotify... captado por el monitor del sistema).
+ "audio": {"device": "", "bpm": 0, "source": "mic"},
"butterchurn": {
"preset": "", "shuffle": True,
"interval": 20, "intervalMode": "seconds", "blendTime": 2.7,
@@ -99,18 +127,40 @@ state = {
"code": first_code(SHADERS, DEFAULTS.get("shader", "")),
},
"mixer": {
- "source": "cam", "camOn": True, "cameraId": 0, "video": "",
- "mix": 0.5, "blendMode": "blend",
+ # fondo: capa de abajo de la mezcla ("cam" o "butter" = MilkDrop)
+ "source": "cam", "fondo": "cam", "camOn": True, "cameraId": 0,
+ "video": "", "mix": 0.5, "blendMode": "blend",
"hue": 0.0, "saturate": 1.0, "contrast": 1.0, "brightness": 0.0,
"colorama": 0.0, "posterize": 0, "pixelate": 0, "kaleid": 0,
"rotate": 0.0, "feedback": 0.0, "invert": False, "beatPulse": False,
},
- "projectm": {"available": False},
+ # projectM: categoria (subcarpeta de presets), preset concreto (fijo),
+ # segundos por visual y orden aleatorio. Cambiarlos relanza projectM.
+ # locked: visual congelado con la tecla de bloqueo (se pierde al relanzar).
+ # nowPlaying/nowCategory/nowVisual: lo que esta en pantalla ahora mismo,
+ # leido del log de projectM (~/.config/projectM/projectMSDL.log).
+ # monitor: "auto" (la pantalla del escenario) o el numero de monitor.
+ # variante: un .milk exacto elegido a dedo ("" = rota dentro del visual).
+ # favoritos: visuales guardados para pincharlos en directo (persisten
+ # en data/pm-favoritos.json).
+ "projectm": {"available": False, "category": "", "preset": "",
+ "duration": 60, "shuffle": True, "locked": False,
+ "nowPlaying": "", "nowCategory": "", "nowVisual": "",
+ "monitor": "auto", "variante": "",
+ "favoritos": load_json(DATA / "pm-favoritos.json", [])},
+ # mapping: projection mapping in-browser. enabled = deformar la salida;
+ # edit = mostrar los tiradores en el escenario para ajustarlo con el raton;
+ # surfaces = [{id, corners:[[x,y]x4]}] normalizado 0..1. Persiste en
+ # data/mapping.json.
+ "mapping": load_json(DATA / "mapping.json",
+ {"enabled": False, "edit": False, "surfaces": []}),
"meta": {
"butterchurnPresets": [],
"audioDevices": [],
"cameraDevices": [],
"videos": list_videos(),
+ "projectmPresets": {},
+ "monitors": [],
},
"status": {"label": ""},
"notifications": NOTIFY_HISTORY,
@@ -209,16 +259,135 @@ def stop_projectm():
procs["projectm"] = None
+def save_favoritos():
+ """Persiste los visuales favoritos de projectM en data/pm-favoritos.json."""
+ try:
+ with open(DATA / "pm-favoritos.json", "w", encoding="utf-8") as fh:
+ json.dump(state["projectm"]["favoritos"], fh,
+ ensure_ascii=False, indent=2)
+ except OSError as exc:
+ notify("warn", f"No pude guardar los favoritos: {exc}")
+
+
+def list_monitors():
+ """Monitores conectados segun xrandr, para el selector del panel.
+ Devuelve [{'id': 1, 'name': 'eDP-1 (1920x1080)'}, ...]; el id va en el
+ formato de projectMSDL (1 = primer monitor)."""
+ if not shutil.which("xrandr"):
+ return []
+ mons = []
+ try:
+ out = subprocess.run(
+ ["xrandr", "--listmonitors"], capture_output=True, text=True,
+ timeout=3, check=False).stdout
+ for line in out.splitlines():
+ m = re.search(r"^\s*(\d+):\s+\+?\*?(\S+)\s+(\d+)/\d+x(\d+)/\d+",
+ line)
+ if m:
+ idx, name, w, h = m.groups()
+ mons.append({"id": int(idx) + 1,
+ "name": f"{name} ({w}x{h})"})
+ except (OSError, subprocess.SubprocessError):
+ pass
+ return mons
+
+
+def monitor_of_stage():
+ """Numero de monitor (formato projectMSDL: 1 = primero) donde esta la
+ ventana del escenario. Con varias pantallas, projectM debe abrirse
+ siempre encima del escenario (el proyector) y no donde este el raton.
+ Devuelve 0 (posicion por defecto del SO) si no se puede averiguar."""
+ if not shutil.which("xdotool") or not shutil.which("xrandr"):
+ return 0
+ try:
+ geo = subprocess.run(
+ ["xdotool", "search", "--name", "FOSFENO :: Escenario",
+ "getwindowgeometry"], capture_output=True, text=True,
+ timeout=3, check=False).stdout
+ pos = re.search(r"Position: (-?\d+),(-?\d+)", geo)
+ if not pos:
+ return 0
+ wx, wy = int(pos.group(1)), int(pos.group(2))
+ mons = subprocess.run(
+ ["xrandr", "--listmonitors"], capture_output=True, text=True,
+ timeout=3, check=False).stdout
+ for line in mons.splitlines():
+ m = re.search(
+ r"^\s*(\d+):\s+\S+\s+(\d+)/\d+x(\d+)/\d+([+-]\d+)([+-]\d+)",
+ line)
+ if not m:
+ continue
+ idx, w, h, x, y = (int(v) for v in m.groups())
+ if x <= wx < x + w and y <= wy < y + h:
+ return idx + 1
+ except (OSError, subprocess.SubprocessError, ValueError):
+ pass
+ return 0
+
+
def start_projectm():
- """Lanza projectM nativo; su ventana se superpone a Chromium."""
+ """Lanza projectM nativo con los ajustes del panel (categoria, preset
+ fijo, duracion, aleatorio); su ventana se superpone a Chromium."""
stop_projectm()
script = BASE / "scripts" / "start-projectm.sh"
+ pm = state["projectm"]
+ base = DATA / "presets-projectm"
+ path = base
+ if pm.get("category") and (base / pm["category"]).is_dir():
+ path = base / pm["category"]
try:
- procs["projectm"] = subprocess.Popen(["bash", str(script)])
- print("[FOSFENO] projectM lanzado.")
+ duration = max(2, int(pm.get("duration") or 20))
+ except (TypeError, ValueError):
+ duration = 20
+ shuffle = "1" if pm.get("shuffle", True) else "0"
+ # Visual concreto elegido: cada visual es una carpeta con variantes del
+ # mismo estilo -> projectM rota solo dentro de ese look.
+ if pm.get("preset") and pm.get("category"):
+ vis = base / pm["category"] / pm["preset"]
+ if vis.is_dir():
+ path = vis
+ # Variante exacta elegida a dedo: projectM solo entiende carpetas, asi
+ # que se le prepara una carpeta con esa unica variante dentro.
+ if pm.get("variante") and pm.get("category") and pm.get("preset"):
+ origen = (base / pm["category"] / pm["preset"]
+ / (pm["variante"] + ".milk"))
+ if origen.is_file():
+ fijado = DATA / "pm-fijado"
+ shutil.rmtree(fijado, ignore_errors=True)
+ fijado.mkdir(parents=True, exist_ok=True)
+ shutil.copy(origen, fijado / origen.name)
+ path = fijado
+ # Pantalla elegida en el panel: "auto" sigue al escenario; un numero
+ # la fija aunque el escenario este en otra (o no exista la ventana).
+ try:
+ mon = int(pm.get("monitor"))
+ except (TypeError, ValueError):
+ mon = 0
+ if mon <= 0:
+ mon = monitor_of_stage()
+ env = dict(os.environ,
+ FOSFENO_PM_PATH=str(path),
+ FOSFENO_PM_DURATION=str(duration),
+ FOSFENO_PM_SHUFFLE=shuffle,
+ FOSFENO_PM_MONITOR=str(mon))
+ # El bloqueo con tecla no sobrevive al relanzamiento del proceso
+ pm["locked"] = False
+ try:
+ procs["projectm"] = subprocess.Popen(["bash", str(script)], env=env)
+ print(f"[FOSFENO] projectM lanzado (presets: {path.name}, "
+ f"{duration}s, shuffle={shuffle}).")
except OSError as exc:
notify("error", f"No se pudo lanzar projectM: {exc}. "
"Prueba con otro motor de visuales.")
+ return
+ # projectM (SDL) abre su captura en la entrada por defecto; si toca
+ # "audio del sistema", mover su stream en cuanto aparezca en pactl.
+ # En la Raspberry projectM tarda varios segundos en arrancar: se le da
+ # margen de sobra (2s + 30 intentos x 0.3s = ~11s).
+ if state["audio"]["source"] == "monitor":
+ threading.Timer(
+ 2.0, lambda: route_captures("monitor", quiet=True,
+ attempts=30)).start()
def projectm_key(key):
@@ -233,6 +402,53 @@ def projectm_key(key):
)
+# projectM escribe en su log cada visual que muestra, con la ruta completa:
+# es la forma fiable de saber que hay en pantalla en cada momento.
+PM_LOG = Path.home() / ".config" / "projectM" / "projectMSDL.log"
+
+
+def projectm_now_playing():
+ """Ultimo 'Displaying preset' del log -> (categoria, visual, variante)."""
+ try:
+ with open(PM_LOG, "rb") as fh:
+ fh.seek(0, os.SEEK_END)
+ fh.seek(max(0, fh.tell() - 8192))
+ tail = fh.read().decode("utf-8", "replace")
+ except OSError:
+ return "", "", ""
+ ruta = ""
+ for line in tail.splitlines():
+ if "Displaying preset:" in line:
+ ruta = line.split("Displaying preset:", 1)[1].strip()
+ if not ruta:
+ return "", "", ""
+ try:
+ cat, visual, variante = Path(ruta).relative_to(
+ DATA / "presets-projectm").parts
+ except ValueError:
+ return "", "", Path(ruta).stem # preset fuera del catalogo propio
+ return cat, visual, Path(variante).stem
+
+
+def watch_projectm_log():
+ """Bucle de fondo: refleja en el estado el visual que projectM muestra,
+ para que el panel ensene su nombre y pueda fijarlo con un boton."""
+ while True:
+ time.sleep(2)
+ if not (state["engine"] == "projectm" and state["power"]
+ and is_running(procs["projectm"])):
+ continue
+ cat, visual, variante = projectm_now_playing()
+ if not variante or variante == state["projectm"]["nowPlaying"]:
+ continue
+ with lock:
+ state["projectm"]["nowPlaying"] = variante
+ state["projectm"]["nowCategory"] = cat
+ state["projectm"]["nowVisual"] = visual
+ state["status"]["label"] = variante
+ broadcast()
+
+
def apply_engine():
"""Arranca o detiene projectM segun el motor y el estado de encendido."""
use_native = state["engine"] == "projectm" and state["power"]
@@ -279,6 +495,42 @@ def data_files(fname):
return send_from_directory(str(DATA), fname)
+@app.route("/pm/variantes")
+def pm_variantes():
+ """Lista las variantes (.milk) de un visual, para el selector del panel."""
+ base = (DATA / "presets-projectm").resolve()
+ d = (base / request.args.get("categoria", "")
+ / request.args.get("visual", "")).resolve()
+ if not str(d).startswith(str(base) + os.sep) or not d.is_dir():
+ return {"variantes": []}
+ return {"variantes": sorted(
+ f.stem for f in d.iterdir() if f.suffix.lower() == ".milk")}
+
+
+@app.route("/upload", methods=["POST"])
+def upload_media():
+ """Sube un video o una imagen a la galeria del mezclador (data/videos)."""
+ f = request.files.get("file")
+ if not f or not f.filename:
+ return {"ok": False, "error": "No llego ningun archivo."}, 400
+ name = secure_filename(f.filename)
+ if not name or not name.lower().endswith(MEDIA_EXT):
+ return {"ok": False,
+ "error": "Formato no valido. Sube video (mp4, webm, mov, "
+ "m4v, ogv) o imagen (jpg, png, gif, webp)."}, 400
+ try:
+ VIDEOS.mkdir(parents=True, exist_ok=True)
+ f.save(str(VIDEOS / name))
+ except OSError as exc:
+ notify("error", f"No se pudo guardar '{name}': {exc}")
+ return {"ok": False, "error": f"No se pudo guardar: {exc}"}, 500
+ with lock:
+ state["meta"]["videos"] = list_videos()
+ notify("info", f"'{name}' anadido a la galeria del mezclador.")
+ broadcast()
+ return {"ok": True, "name": name}
+
+
# --------------------------------------------------------------------------
# Eventos WebSocket
# --------------------------------------------------------------------------
@@ -343,12 +595,51 @@ def on_run_code(data):
@socketio.on("update_settings")
def on_update_settings(data):
- """Actualiza ajustes de un motor: butterchurn, mixer o audio."""
+ """Actualiza ajustes de un motor: butterchurn, mixer, audio o projectm."""
engine = (data or {}).get("engine")
patch = (data or {}).get("patch", {})
- if engine in ("butterchurn", "mixer", "audio") and isinstance(patch, dict):
+ if engine in ("butterchurn", "mixer", "audio", "projectm") \
+ and isinstance(patch, dict):
with lock:
state[engine].update(patch)
+ # Los ajustes de projectM se aplican relanzandolo (tarda ~1s)
+ if engine == "projectm" and state["engine"] == "projectm" \
+ and state["power"]:
+ start_projectm()
+ # Cambio de fuente de audio: ademas del reenganche que hara el
+ # escenario, enrutamos aqui por si esta cerrado o si projectM (que
+ # no pasa por el navegador) es el motor activo. Con un microfono
+ # concreto elegido no se toca nada: lo fija el propio navegador.
+ src = patch.get("source") if engine == "audio" else None
+ if src == "monitor" or (src == "mic" and not state["audio"]["device"]):
+ threading.Timer(
+ 1.5, lambda: route_captures(src, quiet=True)).start()
+ broadcast()
+
+
+def save_mapping():
+ try:
+ with open(DATA / "mapping.json", "w", encoding="utf-8") as fh:
+ json.dump(state["mapping"], fh, ensure_ascii=False, indent=2)
+ except OSError as e:
+ notify("warn", f"No se pudo guardar el mapping: {e}")
+
+
+@socketio.on("set_mapping")
+def on_set_mapping(data):
+ """Projection mapping: activar/editar y guardar las superficies.
+ Lo usan el escenario (al arrastrar esquinas) y el panel (activar, añadir,
+ borrar, reset). Guarda en data/mapping.json y difunde a todos."""
+ data = data or {}
+ with lock:
+ m = state["mapping"]
+ if "enabled" in data:
+ m["enabled"] = bool(data["enabled"])
+ if "edit" in data:
+ m["edit"] = bool(data["edit"])
+ if "surfaces" in data and isinstance(data["surfaces"], list):
+ m["surfaces"] = data["surfaces"]
+ save_mapping()
broadcast()
@@ -356,12 +647,69 @@ def on_update_settings(data):
def on_engine_command(data):
action = (data or {}).get("action")
if state["engine"] == "projectm":
- projectm_key({"next": "n", "prev": "p"}.get(action, "n"))
+ pm = state["projectm"]
+ if action in ("next", "prev"):
+ projectm_key({"next": "n", "prev": "p"}[action])
+ elif action == "lock":
+ # La tecla espacio congela/suelta el visual en pantalla al
+ # instante, sin relanzar projectM (el titulo pone [locked]).
+ projectm_key("space")
+ with lock:
+ pm["locked"] = not pm.get("locked")
+ broadcast()
+ elif action == "fix_current":
+ # Fija en las listas la categoria y el visual que se ven ahora:
+ # projectM se relanza rotando solo entre variantes de ese look.
+ if pm.get("nowCategory") and pm.get("nowVisual"):
+ with lock:
+ pm["category"] = pm["nowCategory"]
+ pm["preset"] = pm["nowVisual"]
+ pm["variante"] = ""
+ start_projectm()
+ broadcast()
+ else:
+ notify("warn", "Todavia no se que visual esta en pantalla: "
+ "espera un par de segundos y vuelve a probar.")
else:
socketio.emit("stage_command", {"action": action,
"value": (data or {}).get("value")})
+@socketio.on("pm_favorito")
+def on_pm_favorito(data):
+ """Favoritos de projectM: guardar el visual en pantalla, quitar uno,
+ o lanzar uno a dedo (para pinchar visuales en directo)."""
+ data = data or {}
+ action = data.get("action")
+ pm = state["projectm"]
+ if action == "add":
+ fav = {"categoria": pm.get("nowCategory"),
+ "visual": pm.get("nowVisual"),
+ "variante": pm.get("nowPlaying")}
+ if not all(fav.values()):
+ notify("warn", "Todavia no se que visual esta en pantalla: "
+ "espera un par de segundos y vuelve a probar.")
+ return
+ if fav not in pm["favoritos"]:
+ with lock:
+ pm["favoritos"].append(fav)
+ save_favoritos()
+ notify("info", f"Favorito guardado: {fav['variante']}")
+ elif action == "del":
+ fav = {k: data.get(k) for k in ("categoria", "visual", "variante")}
+ with lock:
+ pm["favoritos"] = [f for f in pm["favoritos"] if f != fav]
+ save_favoritos()
+ elif action == "play":
+ with lock:
+ pm["category"] = data.get("categoria") or ""
+ pm["preset"] = data.get("visual") or ""
+ pm["variante"] = data.get("variante") or ""
+ if state["engine"] == "projectm" and state["power"]:
+ start_projectm()
+ broadcast()
+
+
@socketio.on("stage_meta")
def on_stage_meta(data):
"""El escenario nos envia las listas que solo conoce el navegador."""
@@ -378,8 +726,12 @@ def on_stage_meta(data):
@socketio.on("rescan_devices")
def on_rescan_devices():
- """Pide al escenario que vuelva a buscar microfonos y camaras."""
+ """Pide al escenario que vuelva a buscar microfonos y camaras.
+ Aprovecha para refrescar la lista de pantallas conectadas."""
+ with lock:
+ state["meta"]["monitors"] = list_monitors()
socketio.emit("stage_rescan")
+ broadcast()
@socketio.on("reacquire_audio")
@@ -388,6 +740,96 @@ def on_reacquire_audio():
socketio.emit("stage_reacquire")
+def pactl_default(kind):
+ """Nombre del sink o source por defecto ('sink' | 'source'), o None."""
+ try:
+ out = subprocess.check_output(["pactl", f"get-default-{kind}"],
+ text=True, timeout=5).strip()
+ except (OSError, subprocess.SubprocessError):
+ return None
+ return out or None
+
+
+# Aplicaciones cuyos streams de captura enrutamos: el navegador de las
+# visuales (Chromium/Firefox) y projectM (SDL), que siempre abre la
+# entrada por defecto y no se puede configurar de otra forma.
+CAPTURE_APPS = ("chrom", "firefox", "projectm")
+
+
+def capture_streams():
+ """Indices de los streams de captura de las visuales, leidos de pactl."""
+ try:
+ out = subprocess.check_output(["pactl", "list", "source-outputs"],
+ text=True, timeout=5)
+ except (OSError, subprocess.SubprocessError):
+ return []
+ indices, current = [], None
+ for line in out.splitlines():
+ line = line.strip()
+ if line.startswith("Source Output #"):
+ current = line.split("#", 1)[1]
+ elif current and ("application.process.binary" in line
+ or "application.name" in line):
+ if any(app in line.lower() for app in CAPTURE_APPS):
+ indices.append(current)
+ current = None
+ return indices
+
+
+def route_captures(target, quiet=False, attempts=10):
+ """Mueve los streams de captura al 'monitor' de la salida por defecto
+ (target='monitor': lo que suena en el equipo) o los devuelve a la
+ entrada por defecto (target='mic').
+
+ Hace falta porque Chromium no lista los monitores de PulseAudio/PipeWire
+ al enumerar dispositivos y projectM (SDL) captura siempre la entrada por
+ defecto: la unica via fiable es mover sus streams con pactl. Requiere que
+ las visuales corran en esta misma maquina (kiosko o modo portatil)."""
+ if target == "monitor":
+ sink = pactl_default("sink")
+ dest = sink + ".monitor" if sink else None
+ else:
+ dest = pactl_default("source")
+ if not dest:
+ notify("warn", "pactl no pudo averiguar la salida/entrada por "
+ "defecto del sistema. Revisa el audio con 'pactl "
+ "info'; mientras tanto usa el microfono.")
+ return
+ # Los streams tardan un instante en aparecer tras abrir la captura.
+ streams = []
+ for _ in range(attempts):
+ streams = capture_streams()
+ if streams:
+ break
+ time.sleep(0.3)
+ if not streams:
+ if not quiet:
+ notify("warn", "No hay ningun stream de captura que mover (ni "
+ "navegador ni projectM). Recarga el escenario o "
+ "reinicia FOSFENO y vuelve a intentarlo.")
+ return
+ moved = all(
+ subprocess.run(["pactl", "move-source-output", idx, dest],
+ check=False).returncode == 0
+ for idx in streams)
+ if not moved:
+ notify("warn", f"pactl no pudo mover la captura a '{dest}'. Si la "
+ "salida acaba de cambiar (p. ej. bluetooth), pulsa "
+ "'Aplicar entrada' otra vez; si sigue fallando, "
+ "revisa 'pactl list sources short'.")
+ elif target == "monitor" and not quiet:
+ notify("info", f"Audio del sistema conectado ({dest}).")
+
+
+@socketio.on("audio_route")
+def on_audio_route(data):
+ """El escenario pide enrutar la captura: 'monitor' (lo que suena en el
+ equipo) o 'mic' (entrada por defecto)."""
+ target = (data or {}).get("target")
+ if target in ("monitor", "mic"):
+ route_captures(target)
+
+
@socketio.on("stage_status")
def on_stage_status(data):
if isinstance(data, dict):
@@ -418,9 +860,17 @@ def on_rescan_videos():
@socketio.on("system")
def on_system(data):
action = (data or {}).get("action")
+ if action not in ("reboot", "shutdown"):
+ return
+ # En modo portatil estos botones apagarian el ordenador de trabajo:
+ # solo tienen sentido en la Raspberry del kiosko.
+ if NO_KIOSK:
+ notify("warn", "Modo portatil: el boton de reiniciar/apagar es "
+ "para la Raspberry. En este equipo hazlo a mano.")
+ return
if action == "reboot":
subprocess.Popen(["sudo", "reboot"])
- elif action == "shutdown":
+ else:
subprocess.Popen(["sudo", "poweroff"])
@@ -429,6 +879,11 @@ def on_system(data):
# --------------------------------------------------------------------------
def setup_audio():
"""Marca el microfono USB como fuente de audio por defecto (best-effort)."""
+ # En modo portatil no hay micro USB dedicado y la fuente se elige en el
+ # panel (micro o "audio del navegador"). Evitamos forzar nada y el aviso
+ # de "no hay micro USB", que aqui solo confundiria.
+ if NO_KIOSK:
+ return
match = CFG.get("audio", {}).get("matchSource", "usb").lower()
try:
out = subprocess.check_output(["pactl", "list", "short", "sources"],
@@ -475,6 +930,8 @@ def check_install():
def main():
binary = CFG.get("projectm", {}).get("binary", "projectMSDL")
state["projectm"]["available"] = shutil.which(binary) is not None
+ state["meta"]["projectmPresets"] = list_projectm_presets()
+ state["meta"]["monitors"] = list_monitors()
print(f"[FOSFENO] projectM nativo: "
f"{'disponible' if state['projectm']['available'] else 'no instalado'}")
print(f"[FOSFENO] Videos encontrados: {len(state['meta']['videos'])}")
@@ -486,6 +943,7 @@ def main():
if not NO_KIOSK:
threading.Timer(3.0, start_chromium).start()
threading.Thread(target=watchdog, daemon=True).start()
+ threading.Thread(target=watch_projectm_log, daemon=True).start()
net = state["network"]
suffix = "" if PORT == 80 else f":{PORT}"
diff --git a/data/ayuda.json b/data/ayuda.json
index 5dc20b3..3bade4e 100644
--- a/data/ayuda.json
+++ b/data/ayuda.json
@@ -9,6 +9,16 @@
"Para apagar la Raspberry de verdad, usa los botones de Reiniciar y Apagar del final del panel."
]
},
+ "mapping": {
+ "title": "Mapping (projection mapping)",
+ "body": [
+ "Que es: deforma la salida de las visuales para encajarla en superficies fisicas (una pared en angulo, cajas, un objeto). En vez de un rectangulo plano, ajustas la imagen a la forma real.",
+ "Como se usa: marca 'Activar mapping' y 'Modo edicion'. En la ventana de las visuales (el proyector) veras cada superficie con sus cuatro esquinas: arrastralas con el raton para encajarla. Doble clic crea una superficie nueva; la tecla Supr borra la seleccionada.",
+ "Varias superficies: puedes crear varias (con 'Anadir superficie' o doble clic) y mapear la misma imagen en distintas zonas. Cada una se lista en el panel con su boton de borrar.",
+ "Se guarda solo en data/mapping.json y se mantiene al reiniciar. Quita 'Modo edicion' para ocultar los tiradores mientras pinchas.",
+ "Ojo: no deforma projectM (que va en su propia ventana nativa). Usa Butterchurn, Hydra, Shaders o el Mezclador para tener todo mapeable."
+ ]
+ },
"engines": {
"title": "Motor de visuales",
"body": [
@@ -20,9 +30,15 @@
"projectm": {
"title": "Motor projectM",
"body": [
- "Que es: el visualizador clasico de MilkDrop, compilado dentro de la Raspberry. Reacciona al audio por si solo y va rotando entre miles de presets.",
- "Requisitos: se compila durante la instalacion. Si la compilacion fallo, este motor sale como no disponible y hay que volver a compilarlo. Los otros cuatro motores funcionan sin el.",
- "Como se configura: projectM es un programa nativo, su ventana se pone por encima de las demas visuales. Los botones Anterior y Siguiente cambian de preset, pero eso solo funciona en sesion X11; en Wayland projectM rota presets automaticamente."
+ "Que es: el visualizador clasico MilkDrop en version nativa. Corre fuera del navegador, en su propia ventana, y reacciona a la musica igual que el resto de motores.",
+ "Probar y elegir: los botones Anterior/Siguiente saltan a mano y la linea 'En pantalla' dice como se llama lo que se esta viendo. Cuando aparezca uno que te guste, pulsa Congelar visual: se queda clavado al instante, sin cortes (vuelve a pulsar para soltarlo).",
+ "Fijar este estilo apunta en las listas la categoria y el visual que se ven ahora: projectM rotara solo entre las variantes de ese mismo look. Tambien puedes elegirlos a mano en las listas.",
+ "Elegir a dedo: cada visual es una carpeta con varias variantes .milk. Con categoria y visual elegidos, la tercera lista muestra las variantes: elige una y projectM se queda con esa exacta (y sobrevive a reinicios, al contrario que Congelar).",
+ "Favoritos: cuando aparezca un visual que te guste, pulsa 'Guardar el de pantalla' y se apunta en la lista de favoritos (se guardan en data/pm-favoritos.json, sobreviven a reinicios). En directo, cada favorito es un boton: tocalo y se lanza esa variante exacta. La X lo quita de la lista.",
+ "Ritmo de cambio: el deslizador de segundos por visual controla cada cuanto rota en automatico (de 5 segundos a 10 minutos), y la casilla de orden aleatorio decide si va en orden o barajado.",
+ "Pantalla: elige en que monitor se abre projectM. En Auto se abre siempre donde este el escenario (el proyector). Si conectas o quitas pantallas, pulsa Buscar dispositivos en el apartado Audio para refrescar la lista.",
+ "Cada cambio de listas o del deslizador relanza projectM y la pantalla queda en negro un segundo: es normal (Congelar y Anterior/Siguiente no relanzan). Al relanzar, el visual congelado se suelta.",
+ "El audio lo coge de la fuente elegida en el apartado Audio (microfono o audio del navegador), como los demas motores."
]
},
"butterchurn": {
@@ -53,8 +69,12 @@
"title": "Motor Mezclador VJ",
"body": [
"Que es: el modo de video. Mezcla la imagen de una camara web con clips de video y efectos de color. Es lo mas parecido a un programa de VJ como Resolume.",
- "Requisitos: una webcam USB que cumpla el estandar UVC, conectada antes de encender la Raspberry. Para los clips, copia tus archivos de video en la carpeta data/videos del proyecto.",
+ "Requisitos: una webcam USB que cumpla el estandar UVC. Para los clips, copia tus archivos de video en la carpeta data/videos del proyecto; van bien los .mp4 (H.264) y los .webm.",
+ "Anadir material: con el boton 'Subir video o imagen' del panel puedes mandar clips (mp4, webm...) e imagenes (jpg, png, gif, webp) a la galeria desde el movil o el ordenador, sin tocar carpetas. Tambien puedes generar clips automaticos de tus pelis con DETEKTION (carpeta VISUALES/DETEKTION).",
"Como se configura: elige la fuente (camara, video o mezcla de las dos), el modo de mezcla y los efectos de color con los controles deslizantes. La casilla de pulso al ritmo hace que la imagen lata con los graves.",
+ "Personajes sobre visuales: pon Fuente en Mezcla, Fondo en 'Visuales Butter', elige un clip _silueta-negro de la galeria (los de DETEKTION) y modo de mezcla 'Recorte'. El negro del clip se vuelve transparente y el personaje queda delante de MilkDrop latiendo con la musica. El deslizador de mezcla ajusta el umbral del recorte (subelo si queda halo oscuro en los bordes).",
+ "El preset de MilkDrop del fondo es el que estuviera elegido en el motor Butter: escogelo alli antes de entrar al Mezclador. projectM (el nativo) no puede ir de fondo: corre en una ventana aparte, fuera del navegador.",
+ "Si la pantalla se queda en negro, mira el aviso del panel: dice si falta elegir video, si la camara esta apagada o si algo fallo. La camara se reintenta apagando y encendiendo su casilla; un video que no carga se reintenta eligiendolo otra vez en la lista.",
"Si tienes mas de una camara, eligela en la lista de camaras del panel. El boton Actualizar lista de videos vuelve a leer la carpeta data/videos por si has copiado clips nuevos."
]
},
@@ -62,9 +82,11 @@
"title": "Audio y BPM",
"body": [
"Que es: aqui se elige por que entrada escucha FOSFENO la musica, y se ve el BPM que detecta.",
- "Requisitos: un microfono USB o una tarjeta de sonido USB con entrada. La Raspberry no tiene entrada de audio propia.",
- "Como se configura: por defecto FOSFENO coge el microfono USB automaticamente. Si tienes varias entradas, eligela en la lista. El BPM se calcula solo a partir del sonido y tarda unos segundos en estabilizarse.",
- "Si conectas el microfono o la camara con la Raspberry ya encendida, pulsa el boton Buscar dispositivos de nuevo y apareceran en sus listas sin tener que reiniciar."
+ "Dos fuentes: 'Microfono (sala)' escucha el ambiente con un micro; 'Audio del navegador' capta directamente lo que suena en el propio equipo (Spotify, YouTube, lo que reproduzcas) aunque lo oigas por los cascos, sin necesidad de micro.",
+ "Audio del navegador: al elegirlo, FOSFENO mueve solo la captura al 'monitor' del sistema (PulseAudio/PipeWire) con pactl. Vale para todos los motores, projectM incluido. Si cambias de salida (por ejemplo conectas o quitas unos cascos bluetooth), pulsa 'Aplicar entrada' para que se recoloque.",
+ "Si sale un aviso de que no se pudo mover la captura, comprueba que algo esta sonando y vuelve a pulsar 'Aplicar entrada'. Como ultimo recurso, revisa 'pactl list sources short' en una terminal.",
+ "Como se configura: por defecto FOSFENO coge el microfono. Si tienes varias entradas, eligela en la lista. El BPM se calcula solo a partir del sonido y tarda unos segundos en estabilizarse.",
+ "Si conectas el microfono o la camara con el equipo ya encendido, pulsa el boton Buscar dispositivos de nuevo y apareceran en sus listas sin tener que reiniciar."
]
},
"sensibilidad": {
@@ -83,4 +105,4 @@
]
}
}
-}
+}
\ No newline at end of file
diff --git a/data/hydra-sketches.json b/data/hydra-sketches.json
index bf12669..97537ec 100644
--- a/data/hydra-sketches.json
+++ b/data/hydra-sketches.json
@@ -18,5 +18,9 @@
"estrellas": {
"name": "Estrellas",
"code": "noise(() => 3 + a.fft[1]*6, 0.15).thresh(() => 0.62 - a.fft[0]*0.45).color(0.7,0.9,1.0).modulateRotate(osc(2), 0.2).out(o0)"
+ },
+ "piratas-recorte": {
+ "name": "PIRATAS: personaje sobre visuales",
+ "code": "/* personaje recortado (clip _silueta-negro) con visuales detras. Cambia el nombre del clip por cualquier otro _silueta-negro de la galeria. */ s1.initVideo(\"/data/videos/p3-duelo_silueta-negro.mp4\"); osc(8, 0.06, () => 1 + a.fft[0]*2).color(1.0, 0.45, 0.1).kaleid(3).modulate(noise(2), () => a.fft[1]*0.5).out(o1); src(o1).layer(src(s1).luma(0.12, 0.18)).out(o0)"
}
-}
+}
\ No newline at end of file
diff --git a/docs/problemas.md b/docs/problemas.md
index f493763..ff7b95f 100644
--- a/docs/problemas.md
+++ b/docs/problemas.md
@@ -37,24 +37,68 @@ El BPM en cero quiere decir que FOSFENO no está recibiendo audio, o que el
audio es demasiado flojo.
Comprueba que el micrófono USB está conectado. En el apartado Audio del panel,
-abre el desplegable y elige a mano la entrada correcta. Si tu micrófono no
-aparece, conéctalo y reinicia la Raspberry, porque la lista se hace al
-arrancar.
+pulsa «Buscar dispositivos», abre el desplegable, elige la entrada correcta y
+pulsa «Aplicar entrada». Ya no hace falta reiniciar para que aparezcan
+entradas nuevas.
Si el audio entra pero el BPM no se estabiliza, sube la sensibilidad. El
detector de ritmo necesita música con un pulso claro; con música muy suave o
sin percusión puede no encontrar el tempo, y a veces marca el doble o la
mitad del valor real.
+Si al arrancar sale el aviso «Sin entrada de audio», las visuales siguen
+funcionando pero no reaccionan a la música: conecta un micrófono (o elige
+«Audio del navegador») y pulsa «Buscar dispositivos» y «Aplicar entrada».
+
+## El audio del navegador (Spotify, YouTube) no mueve las visuales
+
+La fuente «Audio del navegador» captura lo que suena en el propio equipo
+usando el «monitor» de PulseAudio/PipeWire. Chromium no deja elegir ese
+monitor directamente, así que FOSFENO mueve la captura por su cuenta con
+`pactl`. Eso vale para todos los motores, projectM incluido (projectM captura
+siempre la entrada por defecto y FOSFENO recoloca su stream al lanzarlo).
+
+Si no reacciona:
+
+- Pon algo a sonar primero y pulsa «Aplicar entrada».
+- Si cambias de salida (conectas o quitas unos cascos bluetooth, cambias a
+ HDMI...), la captura se queda en la salida antigua: pulsa «Aplicar
+ entrada» otra vez para que se recoloque en la nueva.
+- Lee el aviso del panel: si dice que no pudo mover la captura o averiguar
+ la salida por defecto, revisa el audio del sistema con `pactl info` y
+ `pactl list sources short` en una terminal.
+- Al volver a «Micrófono (sala)», FOSFENO devuelve la captura a la entrada
+ por defecto. Si notas que sigue «escuchando» la música del equipo, pulsa
+ «Aplicar entrada» de nuevo.
+
## La cámara no funciona en el Mezclador
Tiene que ser una webcam USB que cumpla el estándar UVC. El módulo de cámara
con cable plano de la Raspberry no sirve en esta versión.
-Conecta la cámara antes de encender la Raspberry. Si la conectas con el
-sistema ya arrancado, reinicia. Si en el panel sale un aviso de que la cámara
-no responde, es que el sistema no la ve; pruébala en otro puerto USB o con
-otro cable.
+Si la conectas con el sistema ya arrancado, pulsa «Buscar dispositivos» en el
+panel para que aparezca en la lista. Cuando la cámara falla, el panel lo dice
+con un aviso (y el motivo: no conectada, ocupada por otro programa...); para
+reintentar, apaga y enciende la casilla «Cámara». Si aun así no responde,
+pruébala en otro puerto USB o con otro cable.
+
+Al salir del Mezclador la cámara se apaga (se le va el LED); se vuelve a
+encender sola al entrar de nuevo.
+
+## El Mezclador se queda en negro
+
+Mira el aviso del panel, que dice exactamente qué falta:
+
+- «La cámara está apagada»: activa la casilla «Cámara».
+- «No hay vídeo elegido»: selecciona un clip en la lista.
+- «No hay vídeos»: copia archivos a `data/videos` y pulsa el botón de
+ actualizar la lista.
+- «No se pudo cargar el vídeo»: el archivo está dañado o el códec no está
+ soportado. Convierte el clip a .mp4 (H.264) o .webm y vuelve a elegirlo
+ en la lista para reintentar.
+
+En el modo «mezcla» hacen falta las dos fuentes (cámara y vídeo); si solo
+hay una, la otra mitad de la mezcla se ve negra.
## projectM no está disponible
@@ -73,6 +117,11 @@ Ese script avisa en qué paso falla. Lo más habitual es que falte alguna
librería de desarrollo; vuelve a lanzar `bash install.sh` para reinstalar las
dependencias del sistema.
+Si projectM se ve pero no reacciona a la música: projectM escucha siempre la
+entrada por defecto del sistema. Con la fuente «Audio del navegador» activa,
+FOSFENO mueve su captura al monitor de la salida al lanzarlo; si acabas de
+cambiar de salida o de fuente, pulsa «Aplicar entrada» en el panel.
+
## Las visuales van a tirones
Suele ser calor. Una Raspberry sin disipador, después de un rato con visuales,
diff --git a/scripts/start-projectm.sh b/scripts/start-projectm.sh
index c99438b..24839f1 100755
--- a/scripts/start-projectm.sh
+++ b/scripts/start-projectm.sh
@@ -1,13 +1,29 @@
#!/usr/bin/env bash
# Lanza projectM nativo a pantalla completa. Lo invoca el servidor cuando
# se selecciona el motor "projectM" desde el panel.
+#
+# El servidor pasa los ajustes del panel por variables de entorno:
+# FOSFENO_PM_PATH carpeta de presets (categoria o preset fijo)
+# FOSFENO_PM_DURATION segundos por visual
+# FOSFENO_PM_SHUFFLE orden aleatorio (1/0)
DIR="$(cd "$(dirname "$0")/.." && pwd)"
-PRESETS="$DIR/data/presets-projectm"
+PRESETS="${FOSFENO_PM_PATH:-$DIR/data/presets-projectm}"
-# projectMSDL (frontend SDL2 de projectM v4). La ruta de presets se puede
-# fijar tambien en ~/.config/projectMSDL/projectMSDL.properties
+ARGS=()
if [ -d "$PRESETS" ]; then
- exec projectMSDL --presetPath "$PRESETS"
-else
- exec projectMSDL
+ ARGS+=(--presetPath "$PRESETS")
fi
+[ -n "${FOSFENO_PM_DURATION:-}" ] && ARGS+=(--presetDuration "$FOSFENO_PM_DURATION")
+[ -n "${FOSFENO_PM_SHUFFLE:-}" ] && ARGS+=(--shuffleEnabled "$FOSFENO_PM_SHUFFLE")
+
+# Pantalla completa sin bordes (sin cambiar la resolucion del proyector):
+# asi los relanzamientos no dejan una ventana flotante, solo un parpadeo.
+ARGS+=(--fullscreen 1 --exclusive 0)
+
+# Y siempre en el monitor donde esta el escenario (lo detecta el servidor):
+# sin esto, cada relanzamiento aterriza en la pantalla donde este el raton.
+if [ -n "${FOSFENO_PM_MONITOR:-}" ] && [ "$FOSFENO_PM_MONITOR" != "0" ]; then
+ ARGS+=(--monitor "$FOSFENO_PM_MONITOR")
+fi
+
+exec projectMSDL "${ARGS[@]}"
diff --git a/web/panel/index.html b/web/panel/index.html
index 0680559..45bfe3f 100644
--- a/web/panel/index.html
+++ b/web/panel/index.html
@@ -40,15 +40,21 @@
Audio
+
+
+
+
-
+
BPM detectado--
-
Si conectas el microfono o la camara con el equipo ya
- encendido, pulsa este boton para que aparezcan.
+
Con Audio del navegador las visuales reaccionan a
+ lo que suena en el equipo (Spotify, YouTube...) aunque lo oigas por los
+ cascos. Si conectas un microfono con el equipo ya encendido, pulsa
+ Buscar dispositivos de nuevo.
@@ -61,9 +67,9 @@
-
+
- Ahora suena
+ En pantalla
-
@@ -153,15 +159,29 @@
+
+ Fondo (capa de abajo)
+
+
-
+
+
+
+
+
+
Modo de mezcla
+
+
+
+
+
+
+
+
En pantalla: ...
+
+ Favoritos (para pinchar en directo)
+
+
+
+
+
+
+
+ Pantalla
+
+
+
+ Segundos por visual: 60 s
+
+
+
Congelar deja clavado el visual que se ve (al momento,
+ sin cortes). Fijar este estilo lo apunta en las listas y projectM
+ rota solo entre variantes de ese look. Cada cambio de listas o
+ deslizador relanza projectM (~1 s en negro).
+
+
+
+
+
+ Mapping
+
+
+
+
+
+
+
+
+ Previsualizacion (arrastra las esquinas)
+
+
+
1) Elige un motor que no sea projectM. 2) Pulsa
+ Anadir superficie. 3) Arrastra las esquinas aqui en la
+ previsualizacion (raton o dedo) para encajar la forma; se ve en el
+ proyector al instante. Cada superficie mapea la misma imagen. Se
+ guarda solo.