webatem 2.1.6__tar.gz → 2.2.0__tar.gz

{webatem-2.1.6 → webatem-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: webatem
-Version: 2.1.6
+Version: 2.2.0
 Summary: Browser-based control for Blackmagic ATEM switchers: run it, open the browser, your switchers are there
 Author: Lucas Romanenko
 License: MIT

{webatem-2.1.6 → webatem-2.2.0}/atem_control/control/commands.py

@@ -13,7 +13,13 @@ explicit guard against silent miss-imports — a new feature module must be
 added there to surface its ops through the dispatch table.
 
 Dispatch contract preserved for the consumer:
-    dispatch(connection, command: str, data: dict) -> (ok: bool, error: Optional[str])
+    dispatch(connection, command: str, data: dict, mixer=None)
+        -> (ok: bool, error: Optional[str])
+
+``mixer`` is the ``audio.mixer`` of the state last pushed for this
+connection (``'fairlight'``, ``'legacy'`` or ``'unknown'``; absent with
+bmdwire before 1.6). Only ``'legacy'`` changes anything: the audio verbs
+go to the classic mixer (``LEGACY_AUDIO_COMMAND_MAP``).
 
 On ok=False the consumer forwards ``error`` as the frontend message text.
 Operations that raise on invalid args are caught here and mapped to the
@@ -25,8 +31,9 @@ from types import SimpleNamespace
 from typing import Tuple, Optional
 
 from atemwire.messages import (
-    color_generator, downstream_keyer, fade_to_black, fairlight, hyperdeck,
-    input_video, macros, media, switching, transition, upstream_keyer,
+    audio_legacy, color_generator, downstream_keyer, fade_to_black, fairlight,
+    hyperdeck, input_video, macros, media, switching, transition,
+    upstream_keyer,
 )
 
 
@@ -37,6 +44,7 @@ from atemwire.messages import (
 _OPS_MODULES = (
     switching, color_generator, fade_to_black, media, input_video,
     upstream_keyer, macros, downstream_keyer, transition, fairlight, hyperdeck,
+    audio_legacy,
 )
 
 ops = SimpleNamespace()
@@ -452,13 +460,84 @@ ATEM_COMMAND_MAP = {
 }
 
 
-def dispatch(connection, command: str, data: dict) -> HandlerResult:
+# =========================================================================
+# Classic (legacy, pre-Fairlight) audio mixer
+# =========================================================================
+# A switcher whose state says ``audio.mixer == 'legacy'`` (Production
+# Studio 4K, Television Studio HD and their kin) gets these in place of the
+# Fairlight entries: the frontend sends the same verbs to either mixer. The
+# volume (dB, ``null`` = silenced) and the pan (±100) go through atemwire's
+# legacy_db_to_volume / legacy_pan_to_balance; ``channel`` is ignored, every
+# classic strip being stereo. Every other set_audio_* verb is refused on
+# this mixer, which has no EQ, dynamics, delay or input gain. Built from the
+# protocol docs; untested on a legacy switcher.
+
+_LEGACY_MIX_OPTIONS = {
+    'Off': {'on': False},
+    'On': {'on': True},
+    'AudioFollowVideo': {'afv': True},
+}
+
+
+def _legacy_mix_option(mix_type):
+    if mix_type not in _LEGACY_MIX_OPTIONS:
+        raise ValueError(f"unknown mix_type {mix_type!r}")
+    return _LEGACY_MIX_OPTIONS[mix_type]
+
+
+LEGACY_AUDIO_COMMAND_MAP = {
+    'set_audio_strip_volume': lambda c, d: ops.set_audio_input(
+        c, source=int(d['source']),
+        volume=ops.legacy_db_to_volume(d.get('volume_db'))),
+    'set_audio_strip_pan': lambda c, d: ops.set_audio_input(
+        c, source=int(d['source']),
+        balance=ops.legacy_pan_to_balance(d['pan'])),
+    'set_audio_strip_mix_type': lambda c, d: ops.set_audio_input(
+        c, source=int(d['source']), **_legacy_mix_option(d['mix_type'])),
+    'set_audio_master_volume': lambda c, d: ops.set_audio_master(
+        c, volume=ops.legacy_db_to_volume(d.get('volume_db'))),
+    'set_audio_master_afv': lambda c, d: ops.set_audio_master(
+        c, afv=bool(d['afv'])),
+    # The monitor bus, which the state shows as the headphones. Fairlight's
+    # headphones (FMHP) have no command in atemwire, so these two are
+    # classic-only.
+    'set_audio_headphones_volume': lambda c, d: ops.set_audio_monitor(
+        c, volume=ops.legacy_db_to_volume(d.get('volume_db'))),
+    'set_audio_headphones_mute': lambda c, d: ops.set_audio_monitor(
+        c, mute=bool(d['mute'])),
+}
+
+_LEGACY_ONLY_AUDIO = frozenset({'set_audio_headphones_volume',
+                                'set_audio_headphones_mute'})
+
+
+def _route(command: str, mixer):
+    """``(handler, None)`` for the command on this mixer, or
+    ``(None, error)``."""
+    if mixer == 'legacy':
+        handler = LEGACY_AUDIO_COMMAND_MAP.get(command)
+        if handler is not None:
+            return handler, None
+        if command.startswith('set_audio_'):
+            return None, (f"{command}: this switcher's classic audio mixer has "
+                          f"no EQ, dynamics, delay or input gain")
+    elif command in _LEGACY_ONLY_AUDIO:
+        return None, (f"{command}: the headphones can be set only on a classic "
+                      f"audio mixer; on Fairlight they are read-only here")
+    handler = ATEM_COMMAND_MAP.get(command)
+    if handler is None:
+        return None, f"unknown command: {command}"
+    return handler, None
+
+
+def dispatch(connection, command: str, data: dict, mixer=None) -> HandlerResult:
     """Look up the handler for a command name and execute it. Returns
     ``(ok, error)`` tuple. Consumer treats ok=False as a failed command and
-    emits ``error`` back to the frontend."""
-    handler = ATEM_COMMAND_MAP.get(command)
+    emits ``error`` back to the frontend. ``mixer`` is the state's
+    ``audio.mixer``; see the module docstring."""
+    handler, error = _route(command, mixer)
     if handler is None:
-        return False, f"unknown command: {command}"
+        return False, error
     try:
         handler(connection, data)
         return True, None

{webatem-2.1.6 → webatem-2.2.0}/atem_control/control/consumer.py

@@ -16,6 +16,7 @@ from channels.generic.websocket import AsyncWebsocketConsumer
 from asgiref.sync import sync_to_async
 from atem_control.media_pool import watcher as media_pool_service
 from atemwire.state import ATEMStateMixin
+from atemwire.messages.audio_legacy import enable_audio_levels
 from atemwire.messages.fairlight import enable_fairlight_levels
 from atemwire.messages.system_info import device_name
 from atemwire.pool import ATEMInstanceManager
@@ -141,6 +142,12 @@ class ATEMConsumer(ATEMConnectionLoggingMixin, ATEMStateMixin, AsyncWebsocketCon
         # worker died, builds a new protocol; the poll loop's identity
         # check re-registers the handlers on it.
         self._meter_protocol = None
+        # Which mixer's meters are armed: 'fairlight' (SFLN, FMLv/FDLv) or
+        # 'legacy' (SALN, AMLv), from the pushed state's audio.mixer. A
+        # subscribe that comes before the state names the mixer is pending
+        # and armed by the push that does (_arm_deferred_audio_meters).
+        self._meter_mixer = None
+        self._meter_pending = False
         self._meter_loop = None
         self._meter_batch_strips: dict = {}  # strip_id → latest payload this tick
         self._meter_batch_master: dict | None = None
@@ -339,8 +346,10 @@ class ATEMConsumer(ATEMConnectionLoggingMixin, ATEMStateMixin, AsyncWebsocketCon
         # the async consumer model and in case handlers grow to read state.
         # KI#13: dispatch is pure atemwire (no ORM) — off the shared
         # thread-sensitive lane so one slow call elsewhere can't queue
-        # every operator's commands behind it.
-        ok, err = await sync_to_async(dispatch_command, thread_sensitive=False)(self.connection, command, data)
+        # every operator's commands behind it. The audio verbs go to the
+        # mixer the last pushed state named (Fairlight or classic).
+        ok, err = await sync_to_async(dispatch_command, thread_sensitive=False)(
+            self.connection, command, data, self._audio_mixer())
 
         if not ok:
             logger.warning(f"Command {command} failed: {err}")
@@ -477,6 +486,9 @@ class ATEMConsumer(ATEMConnectionLoggingMixin, ATEMStateMixin, AsyncWebsocketCon
             # _audio_subscribed True so the new ATEM's subscribe no-oped.
             self._unsubscribe_audio_meters()
             await sync_to_async(self._release_pool_ref, thread_sensitive=False)()
+            # The old switcher's state, its audio mixer with it, must not
+            # route the new one's commands before its first push.
+            self.last_known_state = {}
 
         await sync_to_async(self._acquire_pool_ref, thread_sensitive=False)(ip_address)
 
@@ -755,6 +767,7 @@ class ATEMConsumer(ATEMConnectionLoggingMixin, ATEMStateMixin, AsyncWebsocketCon
                     t_send = time.monotonic() - t1
                     sent = True
                     self.last_known_state = current_state.copy()
+                    self._arm_deferred_audio_meters()
                     self.last_change_time = asyncio.get_event_loop().time()
                     consecutive_no_changes = 0
                 else:
@@ -941,6 +954,13 @@ class ATEMConsumer(ATEMConnectionLoggingMixin, ATEMStateMixin, AsyncWebsocketCon
         finally:
             await sync_to_async(media_pool_service.release, thread_sensitive=False)(ip)
 
+    def _audio_mixer(self):
+        """``audio.mixer`` of the state last pushed for this connection:
+        'fairlight', 'legacy' (the classic mixer) or 'unknown'. None before
+        the first push, and with a bmdwire older than 1.6, which has no
+        such key; both are treated as Fairlight, as before."""
+        return (self.last_known_state.get('audio') or {}).get('mixer')
+
     # =========================================================================
     # Audio meter subscription
     # =========================================================================
@@ -953,40 +973,80 @@ class ATEMConsumer(ATEMConnectionLoggingMixin, ATEMStateMixin, AsyncWebsocketCon
 
     METER_BATCH_INTERVAL_S = 0.04  # ~25 Hz total batch flush
 
+    def _meter_mixer_now(self):
+        """The mixer to arm meters for, from the last pushed state:
+        'fairlight' or 'legacy', or None while it hasn't said (no state yet,
+        'unknown', or a state without audio). A state with audio but no
+        ``mixer`` key comes from a bmdwire before 1.6: Fairlight, as
+        always."""
+        audio = (self.last_known_state or {}).get('audio')
+        if audio is None:
+            return None
+        mixer = audio.get('mixer', 'fairlight')
+        return mixer if mixer in ('fairlight', 'legacy') else None
+
+    def _arm_deferred_audio_meters(self):
+        """After each state push: a subscribe that came before the state
+        named the mixer is armed by the first push that does."""
+        if self._meter_pending and self._meter_mixer_now() is not None:
+            self._meter_pending = False
+            self._subscribe_audio_meters()
+
+    def _enable_meter_stream(self, enable):
+        """Start or stop the armed mixer's meters: SFLN for Fairlight, SALN
+        for the classic mixer."""
+        if self._meter_mixer == 'legacy':
+            enable_audio_levels(self.connection, enable=enable)
+        else:
+            enable_fairlight_levels(self.connection, enable=enable)
+
     def _subscribe_audio_meters(self):
         """Idempotent. Register per-consumer meter listeners and bump the
         per-IP subscriber refcount; send SFLN(enable=True) to the ATEM on
-        the 0→1 transition so it starts streaming FMLv/FDLv packets.
+        the 0→1 transition so it starts streaming FMLv/FDLv packets. On a
+        classic mixer (the pushed state's audio.mixer is 'legacy') it is
+        SALN and AMLv instead; until a push names the mixer the subscribe
+        waits (``_meter_pending``).
 
         Captures the current asyncio loop so the (sync) atemwire event
         callbacks can hand events back to the consumer's loop via
         ``call_soon_threadsafe``.
         """
-        if self._audio_subscribed:
+        if self._audio_subscribed or self._meter_pending:
             return
         protocol = getattr(self.connection, 'protocol', None)
         if protocol is None:
             return
+        mixer = self._meter_mixer_now()
+        if mixer is None:
+            self._meter_pending = True
+            return
+        self._meter_mixer = mixer
         self._meter_loop = asyncio.get_event_loop()
         self._meter_batch_strips = {}
         self._meter_batch_master = None
         self._meter_batch_pending = False
 
-        # Per-strip meter levels. NOTE: the wildcard ':*' is only emitted
-        # by AtemProtocol when the field is registered in
-        # FIELDNAME_UNIQUE — and 'fairlight-meter-levels' is NOT, despite
-        # being multi-strip. Each FMLv arrives as the bare event name
-        # carrying a single strip's data; the FMLv field has .strip_id
-        # so we discriminate inside the handler.
-        sid = protocol.on('change:fairlight-meter-levels',
-                          self._on_strip_meter)
-        self._meter_handler_ids.append(
-            ('change:fairlight-meter-levels', sid))
-
-        # Master bus meter levels.
-        mid = protocol.on('change:fairlight-master-levels',
-                          self._on_master_meter)
-        self._meter_handler_ids.append(('change:fairlight-master-levels', mid))
+        if mixer == 'legacy':
+            # One AMLv carries every input and the master (bare event).
+            lid = protocol.on('change:audio-meter-levels', self._on_legacy_meter)
+            self._meter_handler_ids.append(('change:audio-meter-levels', lid))
+        else:
+            # Per-strip meter levels. NOTE: the wildcard ':*' is only emitted
+            # by AtemProtocol when the field is registered in
+            # FIELDNAME_UNIQUE — and 'fairlight-meter-levels' is NOT, despite
+            # being multi-strip. Each FMLv arrives as the bare event name
+            # carrying a single strip's data; the FMLv field has .strip_id
+            # so we discriminate inside the handler.
+            sid = protocol.on('change:fairlight-meter-levels',
+                              self._on_strip_meter)
+            self._meter_handler_ids.append(
+                ('change:fairlight-meter-levels', sid))
+
+            # Master bus meter levels.
+            mid = protocol.on('change:fairlight-master-levels',
+                              self._on_master_meter)
+            self._meter_handler_ids.append(('change:fairlight-master-levels', mid))
 
         # A new switcher session (the transport re-handshaking after a
         # silence) has not had SFLN, so it streams no meters until it
@@ -1004,9 +1064,9 @@ class ATEMConsumer(ATEMConnectionLoggingMixin, ATEMStateMixin, AsyncWebsocketCon
             _meter_subscribers[ip] = prev + 1
             if prev == 0:
                 try:
-                    enable_fairlight_levels(self.connection, enable=True)
+                    self._enable_meter_stream(True)
                 except Exception as e:
-                    logger.warning(f"Failed to enable Fairlight meter stream: {e}")
+                    logger.warning(f"Failed to enable the {mixer} meter stream: {e}")
 
         self._audio_subscribed = True
         self._meter_protocol = protocol
@@ -1031,17 +1091,21 @@ class ATEMConsumer(ATEMConnectionLoggingMixin, ATEMStateMixin, AsyncWebsocketCon
         logger.info(
             f"Re-arming audio meters after in-place reconnect ({self.current_ip})")
         self._meter_handler_ids = []           # old ids died with the old protocol
-        sid = protocol.on('change:fairlight-meter-levels', self._on_strip_meter)
-        self._meter_handler_ids.append(('change:fairlight-meter-levels', sid))
-        mid = protocol.on('change:fairlight-master-levels', self._on_master_meter)
-        self._meter_handler_ids.append(('change:fairlight-master-levels', mid))
+        if self._meter_mixer == 'legacy':
+            lid = protocol.on('change:audio-meter-levels', self._on_legacy_meter)
+            self._meter_handler_ids.append(('change:audio-meter-levels', lid))
+        else:
+            sid = protocol.on('change:fairlight-meter-levels', self._on_strip_meter)
+            self._meter_handler_ids.append(('change:fairlight-meter-levels', sid))
+            mid = protocol.on('change:fairlight-master-levels', self._on_master_meter)
+            self._meter_handler_ids.append(('change:fairlight-master-levels', mid))
         cid = protocol.on('connected', self._on_session_connected)
         self._meter_handler_ids.append(('connected', cid))
         self._meter_protocol = protocol
         try:
-            enable_fairlight_levels(self.connection, enable=True)
+            self._enable_meter_stream(True)
         except Exception as e:
-            logger.warning(f"SFLN re-arm failed: {e}")
+            logger.warning(f"Meter re-arm failed: {e}")
 
     def _on_session_connected(self):
         """Handler for the protocol's 'connected' event, which fires when
@@ -1056,14 +1120,19 @@ class ATEMConsumer(ATEMConnectionLoggingMixin, ATEMStateMixin, AsyncWebsocketCon
             return
         logger.info(f"Re-arming audio meters for the new switcher session ({self.current_ip})")
         try:
-            enable_fairlight_levels(self.connection, enable=True)
+            self._enable_meter_stream(True)
         except Exception as e:
-            logger.warning(f"SFLN re-arm after reconnect failed: {e}")
+            logger.warning(f"Meter re-arm after reconnect failed: {e}")
 
     def _unsubscribe_audio_meters(self):
         """Idempotent. Unregister per-consumer meter listeners and
         decrement the per-IP refcount; send SFLN(enable=False) on 1→0
-        so the ATEM stops streaming once nobody's watching."""
+        so the ATEM stops streaming once nobody's watching (SALN on a
+        classic mixer). A subscribe still waiting for the mixer is just
+        dropped."""
+        if self._meter_pending:
+            self._meter_pending = False
+            return
         if not self._audio_subscribed:
             return
         protocol = getattr(self.connection, 'protocol', None) if self.connection else None
@@ -1087,12 +1156,13 @@ class ATEMConsumer(ATEMConnectionLoggingMixin, ATEMStateMixin, AsyncWebsocketCon
                 if prev == 1:
                     try:
                         if self.connection is not None:
-                            enable_fairlight_levels(self.connection, enable=False)
+                            self._enable_meter_stream(False)
                     except Exception as e:
-                        logger.warning(f"Failed to disable Fairlight meter stream: {e}")
+                        logger.warning(f"Failed to disable the {self._meter_mixer} meter stream: {e}")
                     _meter_subscribers.pop(ip, None)
 
         self._audio_subscribed = False
+        self._meter_mixer = None
 
     def _on_strip_meter(self, contents):
         """Handler for FMLv events — runs on the atemwire worker thread.
@@ -1119,6 +1189,51 @@ class ATEMConsumer(ATEMConnectionLoggingMixin, ATEMStateMixin, AsyncWebsocketCon
         except RuntimeError:
             pass  # loop closed
 
+    def _on_legacy_meter(self, contents):
+        """Handler for AMLv, the classic mixer's levels — runs on the
+        atemwire worker thread. One packet carries every input and the
+        master, each (L, R, peak L, peak R) in dB; they go into the batch
+        as the Fairlight strips and master do, input ``n`` as strip
+        ``"n.0"``. AMLv has one level per input where FMLv has three
+        stages, so it fills ``input`` (which the painter needs) and
+        ``level`` (which it paints); the dynamics fields have no
+        counterpart. Untested on a classic switcher."""
+        loop = self._meter_loop
+        if loop is None or loop.is_closed():
+            return
+        inputs = getattr(contents, 'input', None) or {}
+        strips = []
+        for src, levels in inputs.items():
+            m = self._legacy_meter_levels(levels)
+            strips.append((f'{src}.0', {'strip_id': f'{src}.0', 'input': m, 'level': m}))
+        m = self._legacy_meter_levels(getattr(contents, 'master', None))
+        master = {'input': m, 'level': m}
+        try:
+            loop.call_soon_threadsafe(self._enqueue_legacy_meters, strips, master)
+        except RuntimeError:
+            pass  # loop closed
+
+    @staticmethod
+    def _legacy_meter_levels(t):
+        """An AMLv (L, R, peak L, peak R) tuple in ``_meter_tuple``'s JSON
+        shape. Anything unreadable is silence (-60, AMLv's own floor), not
+        0 dB, which would paint full scale."""
+        try:
+            return {
+                'l': round(float(t[0]), 2),
+                'r': round(float(t[1]), 2),
+                'peak_l': round(float(t[2]), 2),
+                'peak_r': round(float(t[3]), 2),
+            }
+        except (IndexError, TypeError, ValueError):
+            return {'l': -60.0, 'r': -60.0, 'peak_l': -60.0, 'peak_r': -60.0}
+
+    def _enqueue_legacy_meters(self, strips, master):
+        for sid, payload in strips:
+            self._meter_batch_strips[sid] = payload
+        self._meter_batch_master = master
+        self._arm_meter_batch_flush()
+
     def _on_master_meter(self, contents):
         """Handler for FDLv — runs on atemwire worker thread."""
         loop = self._meter_loop

{webatem-2.1.6 → webatem-2.2.0}/atem_control/static/css/atem_control.css

@@ -494,6 +494,19 @@
     align-items: stretch;
 }
 
+/* The classic (pre-Fairlight) mixer has no input gain, EQ or dynamics: the
+   template leaves those three cells out (x-if), so their tracks go too. */
+.audio-strip-grid.is-classic {
+    grid-template-rows:
+        28px            /* header (name + on-bar)                 */
+        20px            /* dB readout                             */
+        minmax(0, 1fr)  /* channel (fader + meter) — flex-shrink  */
+        20px            /* fader value                            */
+        66px            /* pan knob + numeric                     */
+        26px            /* mix buttons                            */
+        24px;           /* phones                                 */
+}
+
 /* On-air indicator bar above the strip name */
 .audio-on-bar {
     height: 3px;

{webatem-2.1.6 → webatem-2.2.0}/atem_control/static/js/atem_control.js

@@ -1434,6 +1434,7 @@
           alpineInstance.connected = data.connected;
           alpineInstance.statusText = data.message;
           if (data.connected) {
+            alpineInstance.armAudioMixerWait();
             this.isReconnecting = false;
             this.connectingIP = null;
             this.isUserInitiatedConnection = false;
@@ -2815,12 +2816,15 @@
         // ``sourcesFor(ctx)`` can filter per dropdown context.
         // Empty until InPr arrives.
         sources: [],
-        // Fairlight audio. ``present: false`` is the loading-gate the
+        // Audio. ``present: false`` is the loading-gate the
         // template watches — the Fairlight handshake arrives ~hundreds
         // of ms after the rest of the state dump. Default empty
         // strips/master so the template can read fields safely before
-        // the first state push lands.
+        // the first state push lands. ``mixer`` is 'fairlight', 'legacy'
+        // (the classic mixer, which has no input gain, EQ or dynamics:
+        // see ``classicAudio``) or 'unknown' until FAMP or AMMO arrives.
         audio: {
+          mixer: "unknown",
           present: false,
           master: {
             present: false,
@@ -4110,6 +4114,27 @@
       send(command, params = {}) {
         ATEMControl.cmd(command, params);
       },
+      // The switcher has the classic (pre-Fairlight) audio mixer: the
+      // panel hides the input gain, EQ and dynamics it doesn't have.
+      get classicAudio() {
+        return this.state.audio?.mixer === "legacy";
+      },
+      // 10 s after each connect, a state that still names no audio mixer
+      // (neither FAMP nor AMMO arrived) is a switcher without one: the
+      // panel says so instead of waiting. A state without the key at all
+      // (bmdwire before 1.6) keeps waiting, as it always did.
+      audioMixerWaitOver: false,
+      _audioMixerWaitTimer: null,
+      armAudioMixerWait() {
+        clearTimeout(this._audioMixerWaitTimer);
+        this.audioMixerWaitOver = false;
+        this._audioMixerWaitTimer = setTimeout(() => {
+          this.audioMixerWaitOver = true;
+        }, 1e4);
+      },
+      get audioNoMixer() {
+        return this.audioMixerWaitOver && this.state.audio?.mixer === "unknown";
+      },
       // Audio meter subscription — tab-gated. The Fairlight meter stream
       // is ~375 msg/s sustained on a 14-strip mixer, which saturates the
       // WebSocket write buffer and causes the atem_state lag tracked as

{webatem-2.1.6 → webatem-2.2.0}/atem_control/templates/control/_fairlight.html

@@ -11,7 +11,12 @@
          AudioMeters in atem_control.js.
 
          EQ band detail / dynamics tuning aren't surfaced in this MVP
-         (per atemwire coverage: comp/lim/exp can't be written today). -->
+         (per atemwire coverage: comp/lim/exp can't be written today).
+
+         A classic (pre-Fairlight) mixer — state.audio.mixer 'legacy',
+         $store.atem.classicAudio — shows the same panel less the input
+         gain, EQ and dynamics rows it doesn't have; its faders top out at
+         +6 dB. Built from protocol docs, untested on a classic switcher. -->
     <div class="fixed inset-0 z-[200] pointer-events-none" x-show="audioPanelOpen" x-cloak
          @keydown.escape.window="if (!audioModal) audioPanelOpen = false">
         <!-- Backdrop. x-show on the backdrop is load-bearing — without it,
@@ -45,12 +50,12 @@
             <div class="flex items-center justify-between p-4 border-b border-base-300 flex-shrink-0">
                 <h2 class="text-lg font-semibold flex items-center gap-2">
                     <i class="bi bi-sliders"></i>
-                    Fairlight Audio Mixer
+                    <span x-text="['legacy', 'unknown'].includes($store.atem.state?.audio?.mixer) ? 'Audio Mixer' : 'Fairlight Audio Mixer'">Fairlight Audio Mixer</span>
                     <span class="text-sm text-base-content/50 font-normal ml-2"
                           x-show="$store.atem.state && $store.atem.state.audio && $store.atem.state.audio.present"
                           x-text="($store.atem.state?.audio?.strips?.length || 0) + ' strips'"></span>
                     <span class="text-sm text-base-content/50 font-normal ml-2"
-                          x-show="!$store.atem.state || !$store.atem.state.audio || !$store.atem.state.audio.present">
+                          x-show="(!$store.atem.state || !$store.atem.state.audio || !$store.atem.state.audio.present) && !$store.atem.audioNoMixer">
                         Loading…
                     </span>
                 </h2>
@@ -59,13 +64,20 @@
                 </button>
             </div>
 
-            <!-- Loading state -->
+            <!-- Loading state. A switcher whose state still names no audio
+                 mixer 10 s after connecting has none (store.audioNoMixer). -->
             <div x-show="!$store.atem.state || !$store.atem.state.audio || !$store.atem.state.audio.present"
                  class="flex-1 flex items-center justify-center">
-                <div class="flex flex-col items-center gap-3">
+                <div class="flex flex-col items-center gap-3" x-show="!$store.atem.audioNoMixer">
                     <span class="loading loading-spinner loading-lg"></span>
                     <span class="text-sm text-base-content/60">
-                        Waiting for Fairlight audio state…
+                        Waiting for audio state…
+                    </span>
+                </div>
+                <div class="flex flex-col items-center gap-3" x-show="$store.atem.audioNoMixer" x-cloak>
+                    <i class="bi bi-volume-mute text-3xl text-base-content/40"></i>
+                    <span class="text-sm text-base-content/60">
+                        This switcher reports no audio mixer
                     </span>
                 </div>
             </div>
@@ -86,14 +98,24 @@
             <div x-show="$store.atem.state && $store.atem.state.audio && $store.atem.state.audio.present"
                  class="flex-1 min-h-0 overflow-x-auto overflow-y-auto flex pb-3 audio-mixer-root">
 
-                <!-- Labels rail (sticky left) -->
+                <!-- Labels rail (sticky left). On the classic mixer
+                     (is-classic) the Input / EQ / Dyn rows are gone from
+                     every grid here: x-if, not x-show, so nothing in them
+                     reads the input gain, EQ or dynamics a classic strip
+                     doesn't carry, and the grid drops their tracks
+                     (.audio-strip-grid.is-classic). -->
                 <div class="audio-strip-grid sticky left-0 z-10 bg-base-200
                             text-[11px] text-base-content/60 border-r border-base-300
-                            w-[88px] min-w-[88px] flex-shrink-0 px-3 uppercase tracking-wider">
+                            w-[88px] min-w-[88px] flex-shrink-0 px-3 uppercase tracking-wider"
+                     :class="{'is-classic': $store.atem.classicAudio}">
                     <div class="row-header"></div>
-                    <div class="row-input flex items-center">Input</div>
-                    <div class="row-eq flex items-center">EQ</div>
-                    <div class="row-dyn flex items-center">Dyn</div>
+                    <template x-if="!$store.atem.classicAudio">
+                        <div class="contents">
+                            <div class="row-input flex items-center">Input</div>
+                            <div class="row-eq flex items-center">EQ</div>
+                            <div class="row-dyn flex items-center">Dyn</div>
+                        </div>
+                    </template>
                     <div class="row-db flex items-center">dB</div>
                     <div class="row-channel"></div>
                     <div class="row-fader-value"></div>
@@ -115,7 +137,8 @@
                         <div class="audio-strip-grid audio-strip-card flex-1 min-w-[100px]"
                              :class="{
                                 'is-on':  strip.mix_type === 'On',
-                                'is-afv': strip.mix_type === 'AudioFollowVideo'
+                                'is-afv': strip.mix_type === 'AudioFollowVideo',
+                                'is-classic': $store.atem.classicAudio
                              }">
                             <!-- Header: name + on indicator bar -->
                             <div class="row-header flex flex-col items-center justify-end pb-0.5">
@@ -129,6 +152,9 @@
                                      }"></div>
                             </div>
 
+                            <!-- Input gain, EQ and dynamics: Fairlight only. -->
+                            <template x-if="!$store.atem.classicAudio">
+                            <div class="contents">
                             <!-- Input gain: drag knob + numeric input.
                                  Drag vertically; Shift = ¼ sensitivity;
                                  dblclick = reset to 0 dB; wheel = ±2 dB
@@ -192,6 +218,8 @@
                                           stroke-width="1.2" fill="none"></path>
                                 </svg>
                             </div>
+                            </div>
+                            </template>
 
                             <!-- dB readout — live meter peak (text written
                                  by AudioMeters._paintLevelText, blank when
@@ -213,7 +241,8 @@
                                 <div class="audio-fader-track"
                                      x-init="AudioFader.attach($el, {
                                         stripId: strip.strip_id,
-                                        min: -100, max: 10, taper: 2,
+                                        /* The classic mixer tops out at +6 dB. */
+                                        min: -100, max: $store.atem.classicAudio ? 6 : 10, taper: 2,
                                         getValue: () => strip.volume_db ?? -100,
                                         send: (v) => ATEMControl.cmdAudio(
                                             'set_audio_strip_volume', strip,
@@ -306,6 +335,7 @@
                      more strips while master stays in view. -->
                 <div class="audio-strip-grid audio-master-card sticky right-0 z-10
                             w-[130px] min-w-[130px] flex-shrink-0"
+                     :class="{'is-classic': $store.atem.classicAudio}"
                      x-data="{master() { return $store.atem.state?.audio?.master ?? null; }}">
                     <template x-if="master()">
                         <div class="contents">
@@ -315,6 +345,9 @@
                                 <div class="audio-on-bar w-3/4 mt-0.5 is-on"></div>
                             </div>
 
+                            <!-- Input row, EQ and dynamics: Fairlight only. -->
+                            <template x-if="!$store.atem.classicAudio">
+                            <div class="contents">
                             <!-- Input row: empty on master -->
                             <div class="row-input"></div>
 
@@ -351,6 +384,8 @@
                                           stroke-width="1.2" fill="none"></path>
                                 </svg>
                             </div>
+                            </div>
+                            </template>
 
                             <!-- dB readout — live master peak; blank when silent -->
                             <div class="row-db flex items-center justify-center text-[11px] font-mono">
@@ -362,7 +397,7 @@
                                 <div class="audio-fader-track"
                                      x-init="AudioFader.attach($el, {
                                         stripId: '_master',
-                                        min: -100, max: 10, taper: 2,
+                                        min: -100, max: $store.atem.classicAudio ? 6 : 10, taper: 2,
                                         getValue: () => master().volume_db ?? -100,
                                         send: (v) => ATEMControl.cmd(
                                             'set_audio_master_volume',

{webatem-2.1.6 → webatem-2.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "webatem"
-version = "2.1.6"
+version = "2.2.0"
 description = "Browser-based control for Blackmagic ATEM switchers: run it, open the browser, your switchers are there"
 readme = "README.md"
 license = { text = "MIT" }

{webatem-2.1.6 → webatem-2.2.0}/webatem.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: webatem
-Version: 2.1.6
+Version: 2.2.0
 Summary: Browser-based control for Blackmagic ATEM switchers: run it, open the browser, your switchers are there
 Author: Lucas Romanenko
 License: MIT