Kategorie: Allgemein

Veröffentlicht am

Licht und Video vereint: DMX-Farbwerte aus jeder Software live als OBS-Filter nutzen

Ich habe vor Kurzem mein Setup um ein 65″-Display im DJ-Pult erweitert. Für mich war von Anfang an klar, dass die gezeigten Bildinhalte (meist Visuals) farblich zur Beleuchtung passen müssen. Die in meinem Fall über den Maestro DMX gesteuert wird.

Auf der Suche nach einer passenden Lösung habe ich allerdings kein kostenfreies oder günstiges Tool gefunden, das das out of the box mitbringt. Zwar kann man mit Resolume Arena Art-Net-Farbwerte empfangen und verarbeiten, dafür wird aber zwingend die große Arena-Lizenz für 799 € benötigt – was für mein Setup schlicht überdimensioniert ist.

Durch ein Gespräch mit einem Kollegen bin ich schließlich bei OBS gelandet. OBS unterstützt das von Haus aus zwar nicht, lässt sich über Python-Skripte jedoch beliebig erweitern. In diesem Beitrag beschreibe ich, welche Schritte notwendig sind, um genau das umzusetzen. Bitte beachte diese Anleitung basiert auf der Installation auf einem Mac OS Betriebssystem.

Schritt 1 OBS Studio Installieren

OBS Studio (Open Broadcaster Software) ist eine kostenlose, quelloffene Software zur Videoaufzeichnung und für Live-Streams. Das Programm ermöglicht es, verschiedene Bild- und Tonquellen wie Bildschirme, Kameras oder Mikrofone flexibel in Echtzeit zusammenzuführen. Dank seiner hohen Anpassungsfähigkeit und der Erweiterbarkeit durch Plugins sowie Skripte ist OBS der weltweite Standard für Content Creator, Gamer und DJs.

Lade dir OBS Studio einfach über den unten genannten Link herunter und installiere es.

https://obsproject.com

Schritt 2 Python installieren

Python ist eine vielseitige und leicht verständliche Programmiersprache, die sich durch ihre besonders klare Syntax auszeichnet. Sie wird benötigt, um Prozesse zu automatisieren, Daten zu verarbeiten und Programme wie OBS Studio flexibel um eigene, maßgeschneiderte Funktionen zu erweitern.

Ladet euch Python herunter (prüft in der OBS-Dokumentation, welche Version für eure aktuelle OBS-Version empfohlen wird – auf dem Mac ist das meistens Python 3.10 oder 3.11).

Ich habe bei mir Python 3.11.9 verwendet, diese Version lässt sich unter folgendem Link direkt auf der Python Seite downloaden:

https://www.python.org/ftp/python/3.11.9/python-3.11.9-macos11.pkg

Schritt 3 Python Instanz OBS Hinzufügen

Öffne OBS Studio

Unter dem Reiter Werkzeuge – Skripte verstecken sich die Python Einstellungen, hier bitte den Installationspfad von Python angeben. Wenn Python richtig hinzugefügt ist wird die Geladene Python Version unten angezeigt.

Schritt 4 Python Skript Hinzufügen

Nun benötigen wir das Skript, das permanent im Hintergrund lauscht, ob Art-Net-Signale im Netzwerk ankommen, und diese dann an OBS weiterreicht.

Da ich selbst kein Programmierer bin habe ich mich hier von Gemini Unterstützen lassen.

Das Skript könnt ihr hier herauskopieren:

mport obspython as obs
import socket
import struct
import time

sock = None
source_name = ""
filter_name = ""
dmx_universe = 0
start_channel = 1
dimmer_channel = 0
debug_mode = False
smoothing_factor = 0.2  # Standard-Wert für weiches Fading

# Farb-Speicher für das Fading
target_r, target_g, target_b = 0, 0, 0
current_r, current_g, current_b = -1.0, -1.0, -1.0  # -1 erzwingt einen direkten Startwert

last_update_time = 0.0
last_debug_time = 0.0
UPDATE_INTERVAL = 0.033  # Auf 30 FPS erhöht für weichere Animationen

def init_socket():
    global sock
    if sock:
        try:
            sock.close()
        except:
            pass
        sock = None
        
    try:
        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        
        try:
            s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
        except Exception as e:
            print(f"Art-Net: Konnte SO_BROADCAST nicht setzen: {e}")
            
        s.bind(('0.0.0.0', 6454))
        s.setblocking(False)
        sock = s
        print("Art-Net Listener erfolgreich auf Port 6454 gestartet.")
    except Exception as e:
        print(f"Fehler beim Socket-Bind: {e}")
        sock = None

def script_description():
    return "Art-Net zu OBS Farbfilter\nOptimiert | Fehlerresistent | Weiches Fading"

def script_properties():
    props = obs.obs_properties_create()
    obs.obs_properties_add_text(props, "source_name", "Name der VLC Playlist Quelle", obs.OBS_TEXT_DEFAULT)
    obs.obs_properties_add_text(props, "filter_name", "Name des Farbkorrektur-Filters", obs.OBS_TEXT_DEFAULT)
    obs.obs_properties_add_int(props, "dmx_universe", "Art-Net Universe", 0, 32767, 1)
    obs.obs_properties_add_int(props, "start_channel", "Start Channel (R)", 1, 510, 1)
    obs.obs_properties_add_int(props, "dimmer_channel", "Dimmer Channel (0 = aus)", 0, 512, 1)
    
    # NEU: Slider für das Fading
    obs.obs_properties_add_float_slider(props, "smoothing_factor", "Glättung (0.01 = weich, 1.0 = aus)", 0.01, 1.0, 0.01)
    
    obs.obs_properties_add_bool(props, "debug_mode", "Debug-Ausgabe im Skript-Log aktivieren")
    return props

def script_update(settings):
    global source_name, filter_name, dmx_universe, start_channel, dimmer_channel, debug_mode, smoothing_factor
    source_name = obs.obs_data_get_string(settings, "source_name")
    filter_name = obs.obs_data_get_string(settings, "filter_name")
    dmx_universe = obs.obs_data_get_int(settings, "dmx_universe")
    start_channel = obs.obs_data_get_int(settings, "start_channel")
    dimmer_channel = obs.obs_data_get_int(settings, "dimmer_channel")
    smoothing_factor = obs.obs_data_get_double(settings, "smoothing_factor")
    debug_mode = obs.obs_data_get_bool(settings, "debug_mode")
    init_socket()

def script_unload():
    global sock
    if sock:
        try:
            sock.close()
        except:
            pass
        sock = None

def script_tick(seconds):
    global sock, start_channel, dmx_universe, dimmer_channel
    global last_update_time, last_debug_time, debug_mode, smoothing_factor
    global target_r, target_g, target_b
    global current_r, current_g, current_b
    
    if not sock:
        return

    latest_dmx_data = None
    packets_read = 0
    max_packets = 50

    try:
        while packets_read < max_packets:
            data, addr = sock.recvfrom(2048)
            packets_read += 1
            
            if len(data) < 18 or data[:8] != b'Art-Net\x00':
                continue
                
            opcode = struct.unpack('<H', data[8:10])[0]
            if opcode != 0x5000:
                continue

            universe = struct.unpack('<H', data[14:16])[0]
            if universe != dmx_universe:
                continue

            length = struct.unpack('>H', data[16:18])[0]
            latest_dmx_data = data[18:18+length]

    except BlockingIOError:
        pass
    except OSError as e:
        print(f"Art-Net Socket-Fehler erkannt, reinitialisiere... ({e})")
        init_socket()
        return
    except Exception as e:
        print(f"Art-Net Tick Fehler: {e}")

    # 1. Zielwerte (Target) aus dem DMX-Signal aktualisieren
    if latest_dmx_data:
        idx = start_channel - 1
        if idx + 2 < len(latest_dmx_data):
            raw_r = latest_dmx_data[idx]
            raw_g = latest_dmx_data[idx+1]
            raw_b = latest_dmx_data[idx+2]
            
            dimmer = latest_dmx_data[dimmer_channel - 1] if dimmer_channel > 0 and (dimmer_channel - 1) < len(latest_dmx_data) else 255
            dim_factor = dimmer / 255.0
            
            target_r = raw_r * dim_factor
            target_g = raw_g * dim_factor
            target_b = raw_b * dim_factor
            
            current_time = time.time()
            if debug_mode and (current_time - last_debug_time) >= 1.0:
                print(f"[Art-Net Debug] Ziel-Farbe: R:{int(target_r)} G:{int(target_g)} B:{int(target_b)} | Dimmer roh: {dimmer}")
                last_debug_time = current_time

    # 2. Weiches Fading anwenden und OBS updaten (max 30x pro Sekunde)
    current_time = time.time()
    if (current_time - last_update_time) >= UPDATE_INTERVAL:
        
        # Beim allerersten Start direkt auf die Farbe springen, statt von Schwarz hochzufaden
        if current_r < 0:
            current_r, current_g, current_b = target_r, target_g, target_b
            
        # Distanz zur Zielfarbe berechnen
        diff_r = target_r - current_r
        diff_g = target_g - current_g
        diff_b = target_b - current_b
        
        # Nur updaten, wenn es einen sichtbaren Unterschied gibt (spart CPU)
        if abs(diff_r) > 0.5 or abs(diff_g) > 0.5 or abs(diff_b) > 0.5:
            
            # Annäherung an die Zielwerte (Lerp)
            current_r += diff_r * smoothing_factor
            current_g += diff_g * smoothing_factor
            current_b += diff_b * smoothing_factor
            
            update_obs_filter(int(current_r), int(current_g), int(current_b))
            
        last_update_time = current_time

def update_obs_filter(r, g, b):
    global source_name, filter_name
    
    if not source_name or not filter_name:
        return

    # RGBA Konvertierung für OBS
    color_val = (255 << 24) | (b << 16) | (g << 8) | r

    source = obs.obs_get_source_by_name(source_name)
    if not source:
        return

    filt = obs.obs_source_get_filter_by_name(source, filter_name)
    if not filt:
        obs.obs_source_release(source)
        return

    settings = obs.obs_data_create()
    obs.obs_data_set_int(settings, "color_multiply", color_val)
    obs.obs_source_update(filt, settings)

    obs.obs_data_release(settings)
    obs.obs_source_release(filt)
    obs.obs_source_release(source)

Bonus Help: So speicherst du den Code für OBS:

  1. Code kopieren: Markiere den gesamten Code im Feld oben und kopiere ihn in deine Zwischenablage.
  2. Editor öffnen: Öffne einen Texteditor (z. B. Notepad++, VS Code oder den Standard-Editor) und füge den Code ein.
  3. Als .py-Datei speichern: Speichere die Datei unter dem Namen obs_artnet_color.py ab. Achte beim Speichern darauf, als Dateityp „Alle Dateien (.)“ und als Codierung UTF-8 auszuwählen, damit nicht aus Versehen eine .py.txt-Datei entsteht.

Gehe nun in OBS wieder auf Werkzeuge, Skripte und füge über das + das Skript in OBS hinzu:

Schritt 5 Die Video Playlist anlegen

Bevor wir gleich zum eigentlichen Code kommen, möchte ich noch einen extrem praktischen Tipp mit euch teilen, der wunderbar zu diesem Setup passt. Wenn ihrim Hintergrund verschiedene Visuals, Loops oder Animationen abspielen wollt, ist die VLC-Videoquelle in OBS eine spannende Lösung.

Sie ist die mit Abstand einfachste Möglichkeit, mehrere Videodateien automatisch und nahtlos nacheinander abspielen zu lassen. Allerdings gibt es dabei – gerade für Mac-Nutzer einen entscheidenden Stolperstein:

Die Option „VLC-Videoquelle“ taucht in euren OBS-Quellen erst dann auf, wenn der reguläre VLC Media Player auf eurem Mac installiert ist!

Ohne das installierte Hauptprogramm fehlt OBS die nötige Bibliothek im Hintergrund, um diese Funktion anzubieten. So richtet ihr es ein:

  1. Ladet euch den kostenlosen VLC Media Player herunter und installiert ihn regulär auf eurem Mac.
  2. Schließt OBS Studio einmal komplett und startet es neu.
  3. Wenn ihr nun im Quellen-Fenster auf das + (Plus-Symbol) klickt, findet ihr dort den neuen Eintrag VLC-Videoquelle.
  4. Fügt diese Quelle hinzu. In den Eigenschaften könnt ihr nun unter „Wiedergabeliste“ über das Plus-Symbol ganz einfach mehrere Videodateien oder sogar komplette Ordner hinzufügen.

OBS spielt diese Liste nun völlig autark als Playlist ab. Ihr müsst euch während eures DJ-Sets um nichts mehr kümmern und habt eine dynamische Video-Ebene im Hintergrund. Legt ihr nun unseren DMX-Farbfilter auf genau diese VLC-Quelle, verschmelzen eure Visuals in Echtzeit mit dem Raumlicht eurer Maestro DMX Steuerung.

Schritt 6 Skript Konfigurieren

Nachdem ihr das Skript in OBS (unter Werkzeuge > Skripte) hinzugefügt habt, müsst ihr es auf der rechten Seite konfigurieren. Damit das Skript weiß, wo es zuhören und wo es die Farben ändern soll, gibt es diese zentralen Parameter:

  • Name der VLC Playlist Quelle: Der exakte Name eurer VLC Playlist in OBS, auf der der Farbfilter liegt (z.B. „Visual“).
  • Filter Name: Der genaue Name des Farbkorrektur-Filters, den ihr auf die Quelle angewendet habt (z.B. „Farbkorrektur“). Das Skript sucht exakt nach diesem Text.
  • Art-Net Universe: Das DMX-Universum, auf dem eure Lichtsoftware die Art-Net Daten sendet (Standard ist oft 0 oder 1).
  • DMX Start Address: Der erste der drei DMX-Kanäle, die euer angelegtes virtuelles OBS-Fixture in der Lichtsoftware nutzt (z.B. 321). Das Skript nutzt dann diesen Kanal für Rot, den nächsten (+1) für Grün und den übernächsten (+2) für Blau.
  • Dimmer Channel Der Kanal auf dem euer Fixture Dimmer liegt

Sobald diese Parameter mit eurem Setup in Maestro DMX und euren Quellen in OBS übereinstimmen, arbeitet das System vollautomatisch im Hintergrund.

Schritt 7 Konfiguration in deiner DMX Software (in diesem Fall beschreibe ich es für Maestro DMX).

Damit unser OBS-Skript weiß, welche Farbe und Helligkeit gerade im Raum herrscht, müssen wir Maestro DMX dazu bringen, diese Daten explizit in unser Netzwerk zu senden. Das machen wir, indem wir ein „virtuelles“ Fixture (also einen Scheinwerfer, der physisch gar nicht existiert) in der Software anlegen.

Da wir in OBS nicht nur die reinen Farbwerte (Rot, Grün, Blau), sondern auch die Intensität (Helligkeit) der Visuals steuern möchten benötigen wir ein 4-Kanal-Fixture: RGB + Dimmer.

So legt ihr dieses Fixture in Maestro DMX Schritt für Schritt an:

Ein eigenes Fixture-Profil erstellen

Oft gibt es bereits Standard-Profile, aber um ganz sicherzugehen, dass die Kanalbelegung exakt zu unserem Python-Skript passt, legen wir schnell ein eigenes an.

  1. Öffnet das Web-Interface von Maestro DMX.
  2. Navigiert in den Bereich Profiles (oder Fixture Builder).
  3. Erstellt ein neues Profil und gebt ihm einen eindeutigen Namen (z. B. „OBS Filter RGB-D“).
  4. Fügt genau vier Kanäle hinzu und achtet auf diese Reihenfolge:
    • Kanal 1: Red (Rot)
    • Kanal 2: Green (Grün)
    • Kanal 3: Blue (Blau)
    • Kanal 4: Dimmer (Master-Helligkeit)
  5. Speichert das Profil ab.

Das Fixture patchen (ins System einbinden)

Jetzt müssen wir diesen virtuellen Scheinwerfer auf unsere virtuelle DMX-Bühne stellen.

  1. Wechselt im Maestro DMX Menü auf den Reiter Patch.
  2. Klickt auf Add Fixture und sucht nach eurem gerade erstellten Profil („OBS Filter RGB-D“).
  3. Wählt als Netzwerk-Protokoll Art-Net aus.
  4. Ganz wichtig: Weist dem Fixture ein Universum (z. B. 0 oder 1) und eine Startadresse (z. B. 100) zu. Diese beiden Werte müsst ihr euch unbedingt merken, da sie exakt so im OBS Python-Skript eingetragen werden müssen!
  5. Klickt auf Patchen, um das Fixture hinzuzufügen.

Bitte beachtet das euer Artnet knoten dann der Mac ist auf dem OBS läuft, hier müsst ihr als IP Adresse die des Macs eintragen.

Schritt 8 Die passenden Filter-Einstellungen in OBS auf der VLC-Playlist

Wir haben nun unsere VLC-Playlist mit den Visuals in OBS und Maestro DMX sendet fleißig unsere 4 DMX-Kanäle (Rot, Grün, Blau und Dimmer) ins Netzwerk. Jetzt fehlt nur noch die „Leinwand“, auf der das Skript diese Werte anwendet.

Dafür nutzen wir den Standard-Farbkorrektur-Filter in OBS. Dieser Filter ist perfekt für unser Vorhaben, da er sowohl die Farbe des Videos einfärben als auch die Sichtbarkeit (über die Deckkraft oder Helligkeit) steuern kann – genau das, was wir für unsere 4 Kanäle brauchen.

So richtest du den Filter auf deiner VLC-Quelle ein:

Den Filter-Dialog öffnen

Mache in OBS unter deinen Quellen einen Rechtsklick auf deine angelegte VLC-Videoquelle (bzw. deine Playlist) und klicke im Kontextmenü auf Filter.

Farbkorrektur hinzufügen

Klicke im neuen Fenster unten links im Bereich Effektfilter auf das + (Plus-Symbol) und wähle Farbkorrektur (Color Correction) aus.

Den Filter exakt benennen

Der wichtigste Schritt für das Skript

OBS fordert dich nun auf, dem Filter einen Namen zu geben. Hier musst du extrem genau sein! Nenne den Filter beispielsweise Farbkorrektur.

Wichtig: Dieser Name muss später auf den Buchstaben genau (inklusive Groß-/Kleinschreibung) im Python-Skript eingetragen werden. Nur über diesen Namen weiß das Skript, an welchem Rädchen es drehen muss.

Die Parameter dem Skript überlassen

Sobald der Filter erstellt ist, siehst du auf der rechten Seite verschiedene Schieberegler wie Gamma, Kontrast, Farbe und Deckkraft.

Das Geniale an unserem Setup: Du musst hier überhaupt nichts manuell einstellen! Sobald das Python-Skript läuft, übernimmt es automatisch die Kontrolle:

  • Die Parameter für Rot, Grün und Blau aus Maestro DMX mischt das Skript zu einem Farbcode zusammen und überschreibt damit den Parameter „Farbe“ im Filter.
  • Den Dimmer-Kanal (Kanal 4) aus Maestro DMX nutzt das Skript, um den Schieberegler „Deckkraft“ (Opacity) dynamisch hoch- und runterzuziehen.

Wenn euer virtuelles Fixture in Maestro DMX nun also voll aufgedreht ist und auf Rot steht, färbt sich euer Visual in OBS rot und wird komplett sichtbar. Fährt Maestro DMX einen langsamen Fade-Out (Dimmer geht auf 0), blendet sich eure VLC-Playlist in OBS sanft aus.

Schritt 9 Testing und Debug Funktion

Integrierte Debug-Funktion zur einfachen Fehlersuche:

Damit du beim Einrichten nicht im Dunkeln tappst, habe ich eine Debug-Funktion direkt in das Skript eingebaut. Sie hilft dir zu überprüfen, ob die Art-Net-Signale sauber bei OBS ankommen und wie die Farbwerte verarbeitet werden.

Licht und Video vereint: DMX-Farbwerte aus jeder Software live als OBS-Filter nutzen

  • Was die Funktion macht: Wenn du den Haken bei „Debug-Modus aktivieren“ in den Skript-Einstellungen setzt, schreibt das Skript fortlaufend Informationen über die empfangenen DMX-Signale, berechneten RGB-Farbwerte und eventuelle Verbindungsfehler in die OBS-Konsole.
  • Warum das hilft: Du siehst auf einen Blick, ob dein Maestro DMX überhaupt Daten sendet, ob die IP-Adresse und das Universum stimmen und ob die Farbanpassung korrekt ausgelöst wird – ohne raten zu müssen, woran es liegt, wenn ein Visual sich nicht verfärbt.
  • So liest du die Daten aus: Klicke im OBS-Skript-Fenster (Werkzeuge → Skripte) einfach unten rechts auf den Button „Log öffnen“. Dort wird dir der Datenstrom in Echtzeit angezeigt.
  • Bitte beachte das du nach dem Debugger den Haken wieder entfernst sonst überläuft dein Skriptlog

Schritt 10 Wiedergabe auf einem Externen Display oder Projektor

Um das farblich angepasste Bildsignal schließlich auf das 65″-Display im DJ-Pult zu übertragen, nutzt du die eingebaute Projektor-Funktion von OBS:

  1. Klicke mit der rechten Maustaste direkt in den Vorschaubereich von OBS.
  2. Wähle im Kontextmenü den Punkt „Vollbild-Projektor (Vorschau)“ (oder „Vollbild-Projektor (Programm)“).
  3. Klicke in der Liste auf dein angeschlossenes 65″-Display. OBS zeigt die Szene nun nahtlos im Vollbild ohne störende Steuer Elemente auf dem Screen an.

Hinweis & Schlusswort

Beachte bitte, dass sich das Skript aktuell noch in der Beta-Phase befindet. Es läuft in meinem Setup wie gewünscht, kann aber in einzelnen Umgebungen noch feinschliff gebrauchen. Wenn du auf Fehler stößt oder Ideen für Optimierungen hast, schreibe sie mir gerne in die Kommentare.

Ich hoffe, diese Anleitung hilft dir bei deinem eigenen Setup weiter und spart dir die Investition in eine teure Software-Lizenz. Viel Erfolg beim Ausprobieren!