mx-remote 4.7.8__tar.gz → 5.0.0__tar.gz

{mx_remote-4.7.8 → mx_remote-5.0.0}/CLAUDE.md

@@ -21,10 +21,44 @@ mxr                            # console app: discover devices, log frames live
 mxr -l <local_ip>              # bind to a specific interface
 mxr -b                         # broadcast mode instead of multicast
 mxr -i <capture> [-f <ip>]     # parse a MatrixOS/Wireshark capture file offline
+python tests/run.py            # run every protocol test
+python tests/run.py e2e stats  # run named suites only
 ```
 
-There is **no test suite** and no lint config in this repo. Validate protocol changes by
-running `mxr` against live hardware or by replaying a capture file with `mxr -i`.
+There is no lint config in this repo.
+
+`tests/` holds standalone scripts with no test framework behind it — each builds
+frames, feeds them through `Remote.process_frame`, and asserts what was decoded.
+A suite prints what it decoded and ends with `ALL OK`, so it can be run on its
+own as well as through `run.py`.
+
+Two things they pin that code review does not catch:
+
+- **Struct sizes, not just field offsets.** The V2IP stats blocks are 20 and 44
+  bytes only because the firmware's `ALIGN(8)` sits where GCC ignores it. Writing
+  that declaration the other way round shifts every block after the first, and a
+  wrong split still totals 128.
+- **Field widths.** Padding in the fixtures is filled with recognisable bytes, so
+  a field read at the right offset with the wrong width returns a wrong value. A
+  zero-filled fixture cannot catch that: the widened read returns the same
+  answer.
+- **Which handlers run at all.** `tests/handlers.py` reports how many frame
+  `process()` methods the other suites execute and fails if one loses its
+  coverage. A handler nothing calls is invisible to every other check here,
+  since they all measure tests that run.
+
+`tests/capture.py` holds real frames off a live mesh, with the device uids
+replaced. Its expected values come from firmware behaviour rather than from this
+decoder, which is the property a synthetic fixture cannot have — assert against
+something external, or a fixture only proves the decoder agrees with itself.
+
+Validate wire changes against live hardware as well, by running `mxr` or
+replaying a capture file with `mxr -i`.
+
+A client's uid is persisted at `~/.mxr-uid`, one file per account, and
+`process_frame` drops any frame carrying our own uid. Two clients run from one
+account are a single identity to the mesh and each discards everything the other
+sends, so a second one needs its own `uid_path`.
 
 ### Versioning
 Version is single-sourced in `mx_remote/const.py` (`VERSION = '...'`); `pyproject.toml`
@@ -67,8 +101,17 @@ Three layers, decoupled by abstract base classes:
 `remote_id == self.uid` (our own echoes) are skipped.
 
 ### Frame wire format
-`[0x50, 0x38, protocol, 0x00]` ("P8" magic + protocol version) + opcode (u16 LE) +
-length (u16 LE) + payload. Built by `proto/Factory.py::create_mxr_frame`.
+A 24-byte header, then the payload:
+
+```
+0   [0x50, 0x38, protocol, 0x00]   "P8" magic + protocol version
+4   sender uid                     16 bytes, the device that sent this frame
+20  opcode                         u16 LE
+22  payload length                 u16 LE
+24  payload
+```
+
+Built by `proto/Factory.py::create_mxr_frame`, decoded by `proto/FrameHeader.py`.
 
 ## Working on the protocol
 

{mx_remote-4.7.8 → mx_remote-5.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: mx_remote
-Version: 4.7.8
+Version: 5.0.0
 Summary: Python 3 library for interfacing with MX Remote compatible devices
 Project-URL: Homepage, https://github.com/opdenkamp/mx-remote/
 Project-URL: Documentation, https://github.com/opdenkamp/mx-remote/
@@ -30,14 +30,39 @@ Requires-Dist: aiohttp>=3.10.5
 Requires-Dist: netifaces>=0.11.0
 Description-Content-Type: text/markdown
 
-# MX Remote Interface
+# MX Remote — Pulse-Eight device interface
 
-Python 3 library for interfacing with [MX Remote](https://github.com/opdenkamp/mx-remote/) compatible devices over a local network. Supports device discovery, video/audio routing, volume control, remote control key passthrough, V2IP (OneIP) streaming, and more.
+Python 3 library for discovering and controlling [Pulse-Eight](https://www.pulse-eight.com/)
+AV distribution hardware over a local network: video/audio matrices, HDMI-over-IP
+encoders/decoders, multiviewers, and audio amplifiers. Supports device discovery,
+video/audio routing, volume control, remote-control key passthrough, HDMI-over-IP
+streaming, multiviewer control, and more.
+
+If you are looking to integrate Pulse-Eight **neo**, **OneIP**, or **ProAmp8** devices into
+your own software or home-automation system, this is the library for it.
+
+## What is MX Remote?
+
+MX Remote is the network protocol these Pulse-Eight devices use to discover and control one
+another over UDP (multicast or broadcast). All of them run the shared **MatrixOS** firmware,
+which speaks this protocol natively. This library is a client implementation of that
+protocol — its purpose is to expose the devices to third-party software.
+
+## Supported devices
+
+All devices below run MatrixOS and are controlled through the same protocol:
+
+- **[Pulse-Eight neo](https://www.pulse-eight.com/)** — HDBaseT video/audio matrices
+  (neo:4, neo:8, neo:X, and splitters)
+- **[Pulse-Eight OneIP](https://www.pulse-eight.com/p/248/oneip-tx)** — HDMI-over-IP
+  units: Transmitter (TX), Receiver (RX), Transceiver (TZ), and Multiviewer
+- **[Pulse-Eight ProAmp8](https://www.pulse-eight.com/p/219/proamp-8)** — 8-zone audio amplifier with
+  Dolby support
 
 ## Requirements
 
 - Python 3.11 or later
-- Network access to MX Remote compatible devices (multicast or broadcast)
+- Network access to one or more of the Pulse-Eight devices above (multicast or broadcast)
 
 ## Installation
 
@@ -91,11 +116,19 @@ mx = mx_remote.Remote(target_ip="10.8.8.255", port=8811)
 
 # offline mode for processing capture files
 mx = mx_remote.Remote(open_connection=False)
+
+# separate identity, to run concurrent clients from one account
+mx = mx_remote.Remote(uid_path="/var/lib/myapp/.mxr-uid")
 ```
 
+The uid at `uid_path` (default `~/.mxr-uid`) is this client's identity on the mesh:
+addressing is by uid in the payload, and a frame carrying our own uid is dropped as
+an echo. Two clients sharing a uid are one peer to every device and each silently
+discards everything the other sends, so give concurrent clients separate paths.
+
 ### Device
 
-A `DeviceBase` represents a physical device on the network (matrix, OneIP unit, amplifier). Devices are automatically registered when they respond to discovery requests.
+A `DeviceBase` represents a physical device on the network (a Pulse-Eight neo matrix, OneIP unit, or ProAmp8 amplifier). Devices are automatically registered when they respond to discovery requests.
 
 ```python
 # look up a device by serial number or unique ID
@@ -111,17 +144,23 @@ device.version         # firmware version
 device.online          # True if responding
 device.status          # DeviceStatus enum (ONLINE, OFFLINE, REBOOTING, BOOTING, INACTIVE)
 device.features        # DeviceFeatures bitmask
+device.config_initialised  # False if the device broadcasts config blocks built from
+                           # uninitialised memory; scaling, bay 0 addresses and the
+                           # rc target padding are unreliable from it
 device.temperatures    # dict of temperature sensor readings
 
 # device type checks
-device.is_v2ip             # OneIP device
-device.is_video_matrix     # video matrix
+device.is_v2ip             # Pulse-Eight OneIP HDMI-over-IP device
+device.is_video_matrix     # neo video matrix
 device.is_audio_matrix     # audio-only matrix
-device.is_amp              # audio amplifier
+device.is_amp              # ProAmp8 audio amplifier
 device.is_oneip_tx         # OneIP transmitter
 device.is_oneip_rx         # OneIP receiver
 device.is_oneip_tz         # OneIP transceiver
 device.is_oneip_multiviewer # OneIP multiviewer
+device.supports_video_wall  # sink can crop its source to a video wall window
+                            # (advertised ~1s after boot by the v2ipwall module,
+                            #  and never withdrawn once advertised)
 
 # iterate bays
 for port, bay in device.bays.items():
@@ -336,24 +375,28 @@ log = await device.get_log()
 result = await device.get_api("system/status")
 ```
 
-## OneIP (V2IP) Devices
+## Pulse-Eight OneIP Devices
 
-OneIP devices expose additional streaming properties:
+[Pulse-Eight OneIP](https://www.pulse-eight.com/p/248/oneip-tx) HDMI-over-IP devices expose additional streaming properties:
 
 ```python
-# V2IP stream source addresses
+# stream source addresses
 if device.is_v2ip and device.v2ip_sources:
     for source in device.v2ip_sources:
         print(f"Video: {source.video.ip}:{source.video.port}")
         print(f"Audio: {source.audio.ip}:{source.audio.port}")
 
-# V2IP device details (encoder/decoder config)
+# stream details (encoder/decoder config)
 if device.v2ip_details:
     details = device.v2ip_details
     print(f"Video: {details.video}")
-    print(f"TX rate: {details.tx_rate}")
+    print(f"TX rate: {details.tx_rate}")   # None when the sender offered no rate
+
+    # per-stream DSCP marking (None from peers that predate it)
+    if details.dscp and details.dscp.complete:
+        print(f"DSCP: {details.dscp}")     # video / audio / anc, 0..63
 
-# V2IP statistics
+# streaming statistics
 await device.read_stats(enable=True)   # start collecting
 # ... later ...
 stats = device.v2ip_stats
@@ -368,9 +411,9 @@ if device.v2ip_firmware_versions:
         print(f"{fw_type}: {fw.version}")
 ```
 
-## OneIP Multiviewer
+## Pulse-Eight OneIP Multiviewer
 
-Control multiviewer-specific settings:
+Control [OneIP Multiviewer](https://www.pulse-eight.com/p/248/oneip-tx)-specific settings:
 
 ```python
 from mx_remote import (

{mx_remote-4.7.8 → mx_remote-5.0.0}/README.md

@@ -1,11 +1,36 @@
-# MX Remote Interface
+# MX Remote — Pulse-Eight device interface
 
-Python 3 library for interfacing with [MX Remote](https://github.com/opdenkamp/mx-remote/) compatible devices over a local network. Supports device discovery, video/audio routing, volume control, remote control key passthrough, V2IP (OneIP) streaming, and more.
+Python 3 library for discovering and controlling [Pulse-Eight](https://www.pulse-eight.com/)
+AV distribution hardware over a local network: video/audio matrices, HDMI-over-IP
+encoders/decoders, multiviewers, and audio amplifiers. Supports device discovery,
+video/audio routing, volume control, remote-control key passthrough, HDMI-over-IP
+streaming, multiviewer control, and more.
+
+If you are looking to integrate Pulse-Eight **neo**, **OneIP**, or **ProAmp8** devices into
+your own software or home-automation system, this is the library for it.
+
+## What is MX Remote?
+
+MX Remote is the network protocol these Pulse-Eight devices use to discover and control one
+another over UDP (multicast or broadcast). All of them run the shared **MatrixOS** firmware,
+which speaks this protocol natively. This library is a client implementation of that
+protocol — its purpose is to expose the devices to third-party software.
+
+## Supported devices
+
+All devices below run MatrixOS and are controlled through the same protocol:
+
+- **[Pulse-Eight neo](https://www.pulse-eight.com/)** — HDBaseT video/audio matrices
+  (neo:4, neo:8, neo:X, and splitters)
+- **[Pulse-Eight OneIP](https://www.pulse-eight.com/p/248/oneip-tx)** — HDMI-over-IP
+  units: Transmitter (TX), Receiver (RX), Transceiver (TZ), and Multiviewer
+- **[Pulse-Eight ProAmp8](https://www.pulse-eight.com/p/219/proamp-8)** — 8-zone audio amplifier with
+  Dolby support
 
 ## Requirements
 
 - Python 3.11 or later
-- Network access to MX Remote compatible devices (multicast or broadcast)
+- Network access to one or more of the Pulse-Eight devices above (multicast or broadcast)
 
 ## Installation
 
@@ -59,11 +84,19 @@ mx = mx_remote.Remote(target_ip="10.8.8.255", port=8811)
 
 # offline mode for processing capture files
 mx = mx_remote.Remote(open_connection=False)
+
+# separate identity, to run concurrent clients from one account
+mx = mx_remote.Remote(uid_path="/var/lib/myapp/.mxr-uid")
 ```
 
+The uid at `uid_path` (default `~/.mxr-uid`) is this client's identity on the mesh:
+addressing is by uid in the payload, and a frame carrying our own uid is dropped as
+an echo. Two clients sharing a uid are one peer to every device and each silently
+discards everything the other sends, so give concurrent clients separate paths.
+
 ### Device
 
-A `DeviceBase` represents a physical device on the network (matrix, OneIP unit, amplifier). Devices are automatically registered when they respond to discovery requests.
+A `DeviceBase` represents a physical device on the network (a Pulse-Eight neo matrix, OneIP unit, or ProAmp8 amplifier). Devices are automatically registered when they respond to discovery requests.
 
 ```python
 # look up a device by serial number or unique ID
@@ -79,17 +112,23 @@ device.version         # firmware version
 device.online          # True if responding
 device.status          # DeviceStatus enum (ONLINE, OFFLINE, REBOOTING, BOOTING, INACTIVE)
 device.features        # DeviceFeatures bitmask
+device.config_initialised  # False if the device broadcasts config blocks built from
+                           # uninitialised memory; scaling, bay 0 addresses and the
+                           # rc target padding are unreliable from it
 device.temperatures    # dict of temperature sensor readings
 
 # device type checks
-device.is_v2ip             # OneIP device
-device.is_video_matrix     # video matrix
+device.is_v2ip             # Pulse-Eight OneIP HDMI-over-IP device
+device.is_video_matrix     # neo video matrix
 device.is_audio_matrix     # audio-only matrix
-device.is_amp              # audio amplifier
+device.is_amp              # ProAmp8 audio amplifier
 device.is_oneip_tx         # OneIP transmitter
 device.is_oneip_rx         # OneIP receiver
 device.is_oneip_tz         # OneIP transceiver
 device.is_oneip_multiviewer # OneIP multiviewer
+device.supports_video_wall  # sink can crop its source to a video wall window
+                            # (advertised ~1s after boot by the v2ipwall module,
+                            #  and never withdrawn once advertised)
 
 # iterate bays
 for port, bay in device.bays.items():
@@ -304,24 +343,28 @@ log = await device.get_log()
 result = await device.get_api("system/status")
 ```
 
-## OneIP (V2IP) Devices
+## Pulse-Eight OneIP Devices
 
-OneIP devices expose additional streaming properties:
+[Pulse-Eight OneIP](https://www.pulse-eight.com/p/248/oneip-tx) HDMI-over-IP devices expose additional streaming properties:
 
 ```python
-# V2IP stream source addresses
+# stream source addresses
 if device.is_v2ip and device.v2ip_sources:
     for source in device.v2ip_sources:
         print(f"Video: {source.video.ip}:{source.video.port}")
         print(f"Audio: {source.audio.ip}:{source.audio.port}")
 
-# V2IP device details (encoder/decoder config)
+# stream details (encoder/decoder config)
 if device.v2ip_details:
     details = device.v2ip_details
     print(f"Video: {details.video}")
-    print(f"TX rate: {details.tx_rate}")
+    print(f"TX rate: {details.tx_rate}")   # None when the sender offered no rate
+
+    # per-stream DSCP marking (None from peers that predate it)
+    if details.dscp and details.dscp.complete:
+        print(f"DSCP: {details.dscp}")     # video / audio / anc, 0..63
 
-# V2IP statistics
+# streaming statistics
 await device.read_stats(enable=True)   # start collecting
 # ... later ...
 stats = device.v2ip_stats
@@ -336,9 +379,9 @@ if device.v2ip_firmware_versions:
         print(f"{fw_type}: {fw.version}")
 ```
 
-## OneIP Multiviewer
+## Pulse-Eight OneIP Multiviewer
 
-Control multiviewer-specific settings:
+Control [OneIP Multiviewer](https://www.pulse-eight.com/p/248/oneip-tx)-specific settings:
 
 ```python
 from mx_remote import (

{mx_remote-4.7.8 → mx_remote-5.0.0}/mx_remote/Interface.py

@@ -357,6 +357,31 @@ class V2IPStreamSources:
     def arc(self) -> V2IPStreamSource|None:
         ''' audio return stream source '''
 
+    @property
+    def valid(self) -> bool:
+        """
+        True when this entry carries a usable address.
+
+        Video and anc must both be multicast with a non-zero port; audio is
+        optional and rides along. A sender without MXR_FEATURE_CONFIG_INITIALISED
+        can put stack contents in bay 0's addresses under its own uid, which
+        rarely satisfy both halves of this test.
+        """
+        return v2ip_av_source_valid(self.video, self.anc)
+
+    @property
+    def cleared(self) -> bool:
+        """
+        True when every stream is zeroed, which reports that the source is gone.
+
+        Distinct from an entry that is neither valid nor cleared, which is
+        malformed. Treating a cleared entry as unusable discards the only signal
+        that a source went away.
+        """
+        return (v2ip_stream_cleared(self.video)
+                and v2ip_stream_cleared(self.audio)
+                and v2ip_stream_cleared(self.anc))
+
 class V2IPStreamSourcesList(list[V2IPStreamSources]):
     ''' list of V2IP sources '''
 
@@ -1183,27 +1208,154 @@ class DeviceV2IPScalingSettings(ABC):
     @property
     @abstractmethod
     def mode(self) -> int:
-        pass
+        '''Scaling mode, carried only when flags has MXR_SCALING_FLAG_MODE_VALID'''
 
     @property
     @abstractmethod
     def refresh(self) -> int:
-        pass
+        '''Refresh rate paired with mode, under the same MXR_SCALING_FLAG_MODE_VALID marker'''
 
     @property
     @abstractmethod
     def flags(self) -> int:
-        pass
+        '''mxr_scaling_config.flags.
+
+        MXR_SCALING_FLAG_MODE_VALID and MXR_SCALING_FLAG_OPTIONS_VALID mark
+        which half a sender meant to send, and are separately valid; a sender
+        setting neither is offering no scaling at all. MXR_SCALING_FLAG_AUTO_SCALING
+        is the only option bit with a defined meaning.
+        '''
+
+def v2ip_stream_valid(stream:'V2IPStreamSource|None') -> bool:
+    """
+    True when a stream source carries an address a frame actually meant to send.
+
+    Mirrors mxr_v2ip_stream_valid(): a multicast ip and a non-zero port. A
+    controller write that offers no addresses leaves the block zeroed, which
+    fails both tests.
+    """
+    if (stream is None):
+        return False
+    try:
+        return ipaddress.IPv4Address(stream.ip).is_multicast and (stream.port != 0)
+    except ValueError:
+        return False
+
+def v2ip_av_source_valid(video:'V2IPStreamSource|None', anc:'V2IPStreamSource|None') -> bool:
+    """
+    True when an av source block carries addresses a frame meant to send.
+
+    Mirrors mxr_v2ip_av_source_valid(): video and anc must both be valid, audio
+    is optional and is carried along with them.
+    """
+    return v2ip_stream_valid(video) and v2ip_stream_valid(anc)
+
+def v2ip_stream_cleared(stream:'V2IPStreamSource|None') -> bool:
+    """True when a stream source is zeroed, which is how "no source" is spelled."""
+    return (stream is not None) and (stream.ip == '0.0.0.0') and (stream.port == 0)
+
+class V2IPScalingSettings(DeviceV2IPScalingSettings):
+    """Plain holder for a merged mxr_scaling_config."""
+    def __init__(self, mode:int, refresh:int, flags:int) -> None:
+        self._mode = mode
+        self._refresh = refresh
+        self._flags = flags
+
+    @property
+    def mode(self) -> int:
+        return self._mode
+
+    @property
+    def refresh(self) -> int:
+        return self._refresh
+
+    @property
+    def flags(self) -> int:
+        return self._flags
+
+    def __str__(self) -> str:
+        return f"mode:{self._mode} refresh:{self._refresh} flags:{self._flags:02X}"
+
+    def __repr__(self) -> str:
+        return str(self)
+
+class V2IPDscpConfig:
+    """
+    Per-stream DSCP marking carried in a V2IP device configuration.
+
+    DSCP 0 (CS0) is a legal marking, so each wire byte carries a set bit
+    alongside its value and a stream whose byte is unset reads back as None
+    here. Firmware treats the marking as all-or-nothing: it only applies one
+    when all three streams carry a value, and otherwise falls back to CS2
+    (``V2IP_DSCP_DEFAULT``) - ``complete`` reports which case a frame is in.
+    """
+    def __init__(self, video:int|None, audio:int|None, anc:int|None) -> None:
+        self._video = video
+        self._audio = audio
+        self._anc = anc
+
+    @property
+    def video(self) -> int|None:
+        return self._video
+
+    @property
+    def audio(self) -> int|None:
+        return self._audio
+
+    @property
+    def anc(self) -> int|None:
+        return self._anc
+
+    @property
+    def carried(self) -> bool:
+        """
+        True when this frame carried a marking at all.
+
+        Gated on the video byte alone, matching the firmware cache, which stores
+        all three bytes verbatim. Not ``complete``: a partial set does overwrite
+        a peer's marking, so treating it as absent would report a marking the
+        peer does not hold.
+        """
+        return (self._video is not None)
+
+    @property
+    def complete(self) -> bool:
+        """
+        True when all three streams carry a marking.
+
+        Whether a marking is applied, as opposed to carried: firmware falls back
+        to CS2 on all three streams unless every byte is set, so a partial set is
+        cached and reported but never applied.
+        """
+        return (self._video is not None) and (self._audio is not None) and (self._anc is not None)
+
+    def __eq__(self, other:Any) -> bool:
+        if not isinstance(other, V2IPDscpConfig):
+            return False
+        return (self._video == other._video) and (self._audio == other._audio) and (self._anc == other._anc)
+
+    def __str__(self) -> str:
+        if not self.carried:
+            return "no marking"
+        def one(v:int|None) -> str:
+            return str(v) if (v is not None) else "unset"
+        rv = f"video:{one(self._video)} audio:{one(self._audio)} anc:{one(self._anc)}"
+        # a partial set is cached and reported, but firmware will not apply it
+        return rv if self.complete else (rv + " (partial, not applied)")
+
+    def __repr__(self) -> str:
+        return str(self)
 
 class DeviceV2IPDetails:
     """ V2IP stream source details for a device """
-    def __init__(self, video:V2IPStreamSource|None, audio:V2IPStreamSource|None, anc:V2IPStreamSource|None, arc:V2IPStreamSource|None, tx_rate:int|None, scaling:DeviceV2IPScalingSettings|None) -> None:
+    def __init__(self, video:V2IPStreamSource|None, audio:V2IPStreamSource|None, anc:V2IPStreamSource|None, arc:V2IPStreamSource|None, tx_rate:int|None, scaling:DeviceV2IPScalingSettings|None, dscp:V2IPDscpConfig|None=None) -> None:
         self._video = video
         self._audio = audio
         self._anc = anc
         self._arc = arc
         self._tx_rate = tx_rate
         self._scaling = scaling
+        self._dscp = dscp
 
     @property
     def has_config(self) -> bool:
@@ -1227,12 +1379,81 @@ class DeviceV2IPDetails:
 
     @property
     def tx_rate(self) -> int|None:
+        '''Source rate this device transmits at, or None if none is known.
+
+        Only a rate within V2IP_SOURCE_RATE_MIN..MAX is one a sender meant to
+        send; anything else is an absent offer rather than a rate, and merge()
+        keeps the previously known value instead of caching what was on the wire.
+        '''
         return self._tx_rate
 
     @property
     def scaling(self) -> DeviceV2IPScalingSettings|None:
         return self._scaling
 
+    @property
+    def dscp(self) -> V2IPDscpConfig|None:
+        """Per-stream DSCP marking, or None from peers that predate it."""
+        return self._dscp
+
+    def merge(self, previous:'DeviceV2IPDetails|None') -> 'DeviceV2IPDetails':
+        """
+        Carry forward every field this frame did not carry.
+
+        A controller writing one field of a peer's config leaves the others
+        zeroed on the wire, so each is applied only behind its own validity
+        marker. See FrameV2IPDeviceConfiguration for the markers.
+        """
+        if (previous is None):
+            return self
+
+        if v2ip_av_source_valid(self._video, self._anc):
+            video, audio, anc = self._video, self._audio, self._anc
+        else:
+            video, audio, anc = previous._video, previous._audio, previous._anc
+        arc = self._arc if v2ip_stream_valid(self._arc) else previous._arc
+        tx_rate = self._tx_rate if v2ip_rate_valid(self._tx_rate) else previous._tx_rate
+        dscp = self._dscp if ((self._dscp is not None) and self._dscp.carried) else previous._dscp
+        scaling = self._merge_scaling(previous._scaling)
+
+        if (video is self._video) and (audio is self._audio) and (anc is self._anc)                 and (arc is self._arc) and (tx_rate == self._tx_rate)                 and (dscp is self._dscp) and (scaling is self._scaling):
+            return self
+        return DeviceV2IPDetails(video=video, audio=audio, anc=anc, arc=arc,
+                                 tx_rate=tx_rate, scaling=scaling, dscp=dscp)
+
+    def _merge_scaling(self, previous:DeviceV2IPScalingSettings|None) -> DeviceV2IPScalingSettings|None:
+        """
+        Merge a scaling config field by field, the way firmware applies it.
+
+        The mode/refresh pair and the options nibble are separately valid, so a
+        write carrying only one of them must leave the other as it was.
+        """
+        incoming = self._scaling
+        if (incoming is None) or (previous is None):
+            return incoming if (incoming is not None) else previous
+        mode_valid = ((incoming.flags & MXR_SCALING_FLAG_MODE_VALID) != 0)
+        options_valid = ((incoming.flags & MXR_SCALING_FLAG_OPTIONS_VALID) != 0)
+        if not mode_valid and not options_valid:
+            # carries no scaling at all
+            return previous
+        if mode_valid and options_valid:
+            return incoming
+        mode = incoming.mode if mode_valid else previous.mode
+        refresh = incoming.refresh if mode_valid else previous.refresh
+        flags = previous.flags
+        if mode_valid:
+            flags |= MXR_SCALING_FLAG_MODE_VALID
+        else:
+            # Options only. Carry AUTO_SCALING alone rather than the whole upper
+            # nibble: bits 4..6 have no defined meaning, and on a receiver-capable
+            # unit running firmware before the scaling-config initialisation fix
+            # they are stack noise - the sender declares mxr_scaling_config
+            # uninitialised and only ever |= flags onto it. Masking to the bit we
+            # mean cannot lose information even on fixed firmware, and stops the
+            # noise at this boundary instead of caching it as a peer's config.
+            flags = (flags & 0x0F) | MXR_SCALING_FLAG_OPTIONS_VALID                     | (incoming.flags & MXR_SCALING_FLAG_AUTO_SCALING)
+        return V2IPScalingSettings(mode=mode, refresh=refresh, flags=flags)
+
 class DeviceV2IPSink:
     """
     A V2IP sink's effective multicast subscriptions and resolved audio format.
@@ -1591,6 +1812,23 @@ class DeviceBase(ABC):
     def is_oneip_multiviewer(self) -> bool:
         '''True if this device is a OneIP Multiviewer'''
 
+    @property
+    @abstractmethod
+    def supports_video_wall(self) -> bool:
+        '''True if this sink can crop its source to a video wall window (MXR_FEATURE_VIDEO_WALL)'''
+
+    @property
+    @abstractmethod
+    def config_initialised(self) -> bool:
+        '''True if every configuration block this device broadcasts is fully written.
+
+        A device without MXR_FEATURE_CONFIG_INITIALISED builds some config
+        payloads from stack locals it never zeroes, so these are unreliable from
+        it: the scaling block in V2IP_DEVICE_CFG, bay 0's addresses in
+        SYS_BAY_V2IP_SOURCES, and the padding beside the rc target in
+        RC_SETTINGS. None of that is detectable within a frame.
+        '''
+
     @property
     @abstractmethod
     def is_oneip_tz(self) -> bool: