mx-remote 2.0.0__py3-none-any.whl

mx_remote/proto/FrameV2IPDeviceConfiguration.py

@@ -0,0 +1,86 @@
+##################################################
+##         MX Remote Python Interface           ##
+##                                              ##
+## author: Lars Op den Kamp (lars@opdenkamp.eu) ##
+## copyright (c) 2024 Op den Kamp IT Solutions  ##
+##################################################
+
+from .FrameBase import FrameBase
+from .FrameHeader import FrameHeader
+from ..Uid import MxrDeviceUid
+from .V2IPConfig import V2IPStreamSourcesData
+import socket
+import struct
+
+class V2IPStreamSource:
+    def __init__(self, label, data):
+        self._label = label
+        self._ip = int.from_bytes(data[0:4], "big")
+        self._port = int(data[5]) << 8 | int(data[4])
+
+    @property
+    def label(self):
+        return self._label
+
+    @property
+    def ip(self):
+        return socket.inet_ntoa(struct.pack('!L', self._ip))
+
+    @property
+    def port(self):
+        return self._port
+
+    def __str__(self):
+        return f"{self.label}={self.ip}:{self.port}"
+
+class V2IPDeviceOptions:
+    def __init__(self, data:bytes) -> None:
+        self._tx_rate = int.from_bytes(data[0:1], "little")
+
+    @property
+    def tx_rate(self) -> int:
+        return self._tx_rate
+
+    def __str__(self) -> str:
+        return f"tx rate: {self.tx_rate * 10}Mb/s"
+
+class V2IPScalingSettings:
+    def __init__(self, data):
+        self.mode = data[0:2]
+        self.refresh = (int(data[3]) << 8) | int(data[2])
+        self.flags = data[4]
+
+class FrameV2IPDeviceConfiguration(FrameBase):
+    def __init__(self, header:FrameHeader):
+        super().__init__(header)
+        if len(self.payload) < 61:
+            raise Exception(f"invalid device config len {len(self.payload)}")
+        self.video = V2IPStreamSource("video", self.payload[16:22])
+        self.audio = V2IPStreamSource("audio", self.payload[24:30])
+        self.anc = V2IPStreamSource("anc", self.payload[32:38])
+        self.options = V2IPDeviceOptions(self.payload[40:44])
+        self.arc = V2IPStreamSource("arc", self.payload[48:54])
+        self.scaling = V2IPScalingSettings(self.payload[56:61])
+
+    @property
+    def target_uid(self) -> str:
+        return MxrDeviceUid(self.payload[0:16])
+
+    @property
+    def target_self(self) -> bool:
+        return self.remote_id == self.target_uid
+
+    def process(self) -> None:
+        dev = self.remote_device
+        if dev is None:
+            return
+        dev.v2ip_details = self.options
+        if dev.v2ip_sources is None:
+            dev.v2ip_sources = [V2IPStreamSourcesData(video=self.video, audio=self.audio, anc=self.anc)]
+        else:
+            dev.v2ip_sources[0].video = self.video
+            dev.v2ip_sources[0].audio = self.audio
+            dev.v2ip_sources[0].anc = self.anc
+
+    def __str__(self) -> str:
+        return f"V2IP device configuration self={self.target_self} {self.video} {self.audio} {self.anc} {self.arc} options={self.options}"

mx_remote/proto/FrameV2IPLink.py

@@ -0,0 +1,16 @@
+##################################################
+##         MX Remote Python Interface           ##
+##                                              ##
+## author: Lars Op den Kamp (lars@opdenkamp.eu) ##
+## copyright (c) 2024 Op den Kamp IT Solutions  ##
+##################################################
+
+from .FrameBase import FrameBase
+from .FrameHeader import FrameHeader
+
+class FrameV2IPLinkStatus(FrameBase):
+    def __init__(self, header:FrameHeader):
+        super().__init__(header)
+
+    def __str__(self) -> str:
+        return f"v2ip r/c link status"

mx_remote/proto/FrameV2IPSetMaster.py

@@ -0,0 +1,16 @@
+##################################################
+##         MX Remote Python Interface           ##
+##                                              ##
+## author: Lars Op den Kamp (lars@opdenkamp.eu) ##
+## copyright (c) 2024 Op den Kamp IT Solutions  ##
+##################################################
+
+from .FrameBase import FrameBase
+from .FrameHeader import FrameHeader
+
+class FrameV2IPSetMaster(FrameBase):
+    def __init__(self, header:FrameHeader):
+        super().__init__(header)
+
+    def __str__(self) -> str:
+        return f"v2ip master status"

mx_remote/proto/FrameV2IPSourceSwitch.py

@@ -0,0 +1,84 @@
+##################################################
+##         MX Remote Python Interface           ##
+##                                              ##
+## author: Lars Op den Kamp (lars@opdenkamp.eu) ##
+## copyright (c) 2024 Op den Kamp IT Solutions  ##
+##################################################
+
+from .FrameBase import FrameBase
+from .FrameHeader import FrameHeader
+from ..Interface import DeviceBase, BayBase, DeviceRegistry
+from ..Uid import MxrDeviceUid
+import socket
+import struct
+import logging
+
+_LOGGER = logging.getLogger(__name__)
+
+class FrameV2IPSourceSwitch(FrameBase):
+    def __init__(self, header:FrameHeader):
+        super().__init__(header)
+
+    def construct(mxr:DeviceRegistry, target:BayBase, video:BayBase|str|None=None, audio:BayBase|str|None=None) -> FrameBase:
+        if video is not None:
+            if isinstance(audio, BayBase):
+                if not video.is_v2ip_source:
+                    raise Exception(f"{video} is not a v2ip source")
+            if video.v2ip_source is None:
+                raise Exception(f"{video} v2ip addresses not known")
+
+        if audio is not None:
+            if isinstance(audio, BayBase):
+                if not audio.is_v2ip_source:
+                    raise Exception(f"{audio} is not a v2ip source")
+                if audio.v2ip_source is None:
+                    raise Exception(f"{audio} v2ip addresses not known")
+
+        payload = target.device.remote_id.byte_value
+        if video is not None:
+            ip = socket.inet_aton(video.v2ip_source.video.ip if isinstance(video, BayBase) else video)
+            payload += bytes([int(ip[0]), int(ip[1]), int(ip[2]), int(ip[3])])
+        else:
+            payload += bytes([0, 0, 0, 0])
+        if audio is not None:
+            ip = socket.inet_aton(audio.v2ip_source.audio.ip if isinstance(audio, BayBase) else audio)
+            payload += bytes([int(ip[0]), int(ip[1]), int(ip[2]), int(ip[3])])
+        else:
+            payload += bytes([0, 0, 0, 0])
+        return FrameBase.construct_frame(mxr=mxr, opcode=0x1F, payload=payload)
+
+    @property
+    def target_device(self) -> DeviceBase:
+        return self.mxr.get_by_uid(self.target_uid)
+
+    @property
+    def target_uid(self) -> MxrDeviceUid:
+        return MxrDeviceUid(self.payload[0:16])
+
+    @property
+    def video(self) -> str:
+        ip = int.from_bytes(self.payload[16:20], "big")
+        return socket.inet_ntoa(struct.pack('!L', ip))
+
+    @property
+    def video_bay(self) -> BayBase:
+        return self.mxr.get_by_stream_ip(ip=self.video, audio=False)
+
+    @property
+    def audio(self) -> str:
+        ip = int.from_bytes(self.payload[20:24], "big")
+        return socket.inet_ntoa(struct.pack('!L', ip))
+
+    @property
+    def audio_bay(self) -> BayBase:
+        return self.mxr.get_by_stream_ip(ip=self.audio, audio=True)
+
+    def process(self):
+        # update the local cache
+        sink_bay = self.target_device.first_output
+        if sink_bay is not None:
+            sink_bay.video_source = self.video_bay
+            sink_bay.audio_source = self.audio_bay
+
+    def __str__(self) -> str:
+        return f"V2IP source switch: {self.target_device} -> {self.video}={self.video_bay}/{self.audio}={self.audio_bay}"

mx_remote/proto/FrameV2IPSources.py

@@ -0,0 +1,43 @@
+##################################################
+##         MX Remote Python Interface           ##
+##                                              ##
+## author: Lars Op den Kamp (lars@opdenkamp.eu) ##
+## copyright (c) 2024 Op den Kamp IT Solutions  ##
+##################################################
+
+from .V2IPConfig import V2IPConfig
+from .FrameBase import FrameBase
+from .FrameHeader import FrameHeader
+from .V2IPConfig import V2IPStreamSourcesData
+
+class FrameV2IPSources(FrameBase):
+    ''' All configured v2ip sources for the device that sent this frame '''
+    def __init__(self, header:FrameHeader):
+        super().__init__(header)
+
+    @property
+    def nb_sources(self) -> int:
+        # number of sources defined in this frame
+        return len(self) / 40
+
+    @property
+    def sources(self) -> list[V2IPStreamSourcesData]:
+        # list of all sources defined in this frame
+        rv = []
+        srcnum = 0
+        while srcnum < self.nb_sources:
+            cfg = V2IPConfig(self, srcnum, self.payload[(srcnum*40):((srcnum+1)*40)])
+            rv.append(V2IPStreamSourcesData(video=cfg.video, audio=cfg.audio, anc=cfg.anc))
+            srcnum += 1
+        return rv
+
+    def process(self) -> None:
+        dev = self.remote_device
+        if dev is None:
+            return
+        self.remote_device.v2ip_sources = self.sources
+
+    def __str__(self) -> str:
+        if len(self.sources) > 0:
+            return f"{str(self.remote_device)} {len(self.sources)} v2ip sources: {self.sources[0]}"
+        return f"{str(self.remote_device)} 0 v2ip sources"

mx_remote/proto/FrameV2IPStats.py

@@ -0,0 +1,55 @@
+##################################################
+##         MX Remote Python Interface           ##
+##                                              ##
+## author: Lars Op den Kamp (lars@opdenkamp.eu) ##
+## copyright (c) 2024 Op den Kamp IT Solutions  ##
+##################################################
+
+from .FrameBase import FrameBase
+from .FrameHeader import FrameHeader
+from .V2IPStats import V2IPRxStats, V2IPTxStats, V2IPDeviceStats
+from ..Interface import DeviceBase, DeviceRegistry
+
+class FrameV2IPStats(FrameBase):
+    ''' V2IP encoder/decoder statistics '''
+    def __init__(self, header:FrameHeader):
+        super().__init__(header)
+
+    def construct(registry:DeviceRegistry, device:DeviceBase, enable:bool) -> FrameBase:
+        payload = device.remote_id.byte_value
+        payload += bytes([1]) if enable else bytes([0])
+        frame:FrameBase = FrameBase.construct_frame(mxr=registry, opcode=0x3F)
+        frame.payload = payload
+        return frame
+
+    @property
+    def tx(self) -> V2IPTxStats:
+        return V2IPTxStats(self.payload[0:20])
+
+    @property
+    def tx_per_minute(self) -> V2IPTxStats:
+        return V2IPTxStats(self.payload[20:40])
+
+    @property
+    def rx(self) -> V2IPRxStats:
+        return V2IPRxStats(self.payload[40:84])
+
+    @property
+    def rx_per_minute(self) -> V2IPRxStats:
+        return V2IPRxStats(self.payload[84:128])
+
+    @property
+    def stats(self) -> V2IPDeviceStats:
+        rv = V2IPDeviceStats()
+        rv.tx = self.tx
+        rv.tx_per_minute = self.tx_per_minute
+        rv.rx = self.rx
+        rv.rx_per_minute = self.rx_per_minute
+        return rv
+
+    def process(self) -> None:
+        if self.remote_device is not None:
+            self.remote_device.v2ip_stats = self.stats
+
+    def __str__(self) -> str:
+        return f"{str(self.remote_device)} v2ip stats: {self.stats}"

mx_remote/proto/FrameV2IPStreamDetails.py

@@ -0,0 +1,46 @@
+##################################################
+##         MX Remote Python Interface           ##
+##                                              ##
+## author: Lars Op den Kamp (lars@opdenkamp.eu) ##
+## copyright (c) 2024 Op den Kamp IT Solutions  ##
+##################################################
+
+from .V2IPConfig import V2IPConfig
+from .FrameBase import FrameBase
+from .FrameHeader import FrameHeader
+from ..Interface import V2IPStreamSource
+
+class FrameV2IPStreamDetails(FrameBase):
+    ''' All configured v2ip sources for the device that sent this frame '''
+    def __init__(self, header:FrameHeader):
+        super().__init__(header)
+        self.video = V2IPStreamSource("video", self.payload[0:6])
+        self.audio = V2IPStreamSource("audio", self.payload[8:14])
+        self.anc = V2IPStreamSource("anc", self.payload[16:22])
+        self.arc = V2IPStreamSource("arc", self.payload[24:30])
+
+    @property
+    def sources(self) -> list[V2IPConfig]:
+        # list of all sources defined in this frame
+        rv = []
+        srcnum = 0
+        while srcnum < self.nb_sources:
+            cfg = V2IPConfig(self, srcnum, self.payload[(srcnum*56):((srcnum+1)*56)])
+            rv.append(cfg)
+            srcnum += 1
+        return rv
+
+    def process(self) -> None:
+        dev = self.remote_device
+        first_in = dev.first_input
+        if first_in is not None:
+            first_in.v2ip.video = self.video
+            first_in.v2ip.audio = self.audio
+            first_in.v2ip.anc = self.anc
+        first_out = dev.first_output
+        if first_out is not None:
+            first_out.v2ip.arc = self.arc
+        #dev.on_v2ip_source_config_received()
+
+    def __str__(self) -> str:
+        return f"{str(self.remote_device)} v2ip stream details: {self.video} {self.audio} {self.anc} {self.arc}"

mx_remote/proto/FrameVolume.py

@@ -0,0 +1,62 @@
+##################################################
+##         MX Remote Python Interface           ##
+##                                              ##
+## author: Lars Op den Kamp (lars@opdenkamp.eu) ##
+## copyright (c) 2024 Op den Kamp IT Solutions  ##
+##################################################
+
+from __future__ import annotations
+from .FrameBase import FrameBase
+from .FrameHeader import FrameHeader
+from .Data import VolumeMuteStatus, MuteStatus
+from ..Interface import BayBase
+
+class FrameVolume(FrameBase):
+    ''' bay volume change information frame '''
+    def __init__(self, header:FrameHeader):
+        super().__init__(header)
+
+    @property
+    def bay(self)  -> BayBase:
+        # bay on which the volume changed
+        portnum = self.payload[0]
+        dev = self.remote_device
+        if dev is None:
+            return
+        return dev.get_by_portnum(portnum)
+
+    @property
+    def volume_left(self) -> int:
+        # left channel volume %
+        r = int(self.payload[1])
+        if r > 100:
+            return None
+        return r
+
+    @property
+    def volume_right(self) -> int:
+        # right channel volume %
+        r = int(self.payload[2])
+        if r > 100:
+            return None
+        return r
+
+    @property
+    def muted(self) -> MuteStatus:
+        # mute status
+        if len(self) < 4:
+            return None
+        return MuteStatus(self.payload[3])
+
+    def process(self) -> None:
+        # update the local cache
+        bay = self.bay
+        if bay is None:
+            return
+        muted = self.muted
+        muted_left = muted.left if (muted is not None) else None
+        muted_right = muted.right if (muted is not None) else None
+        bay.on_mxr_volume_update(VolumeMuteStatus(self.volume_left, self.volume_right, muted_left, muted_right))
+
+    def __str__(self) -> str:
+        return f"volume bay:{str(self.bay)} volume:{self.volume_left}/{self.volume_right} muted:{self.muted}"

mx_remote/proto/FrameVolumeDown.py

@@ -0,0 +1,28 @@
+##################################################
+##         MX Remote Python Interface           ##
+##                                              ##
+## author: Lars Op den Kamp (lars@opdenkamp.eu) ##
+## copyright (c) 2024 Op den Kamp IT Solutions  ##
+##################################################
+
+from .FrameBase import FrameBase
+from .FrameHeader import FrameHeader
+
+class FrameVolumeDown(FrameBase):
+    ''' volume down pressed frame '''
+    def __init__(self, header:FrameHeader):
+        super().__init__(header)
+
+    @property
+    def bay(self):
+        portnum = self.payload[0]
+        dev = self.remote_device
+        if dev is None:
+            return
+        return dev.get_by_portnum(portnum)
+
+    def process(self):
+        pass
+
+    def __str__(self):
+        return f"volume down bay: {self.bay} (port {self.payload[0]})"

mx_remote/proto/FrameVolumeSet.py

@@ -0,0 +1,81 @@
+##################################################
+##         MX Remote Python Interface           ##
+##                                              ##
+## author: Lars Op den Kamp (lars@opdenkamp.eu) ##
+## copyright (c) 2024 Op den Kamp IT Solutions  ##
+##################################################
+
+from __future__ import annotations
+from .FrameBase import FrameBase
+from .FrameHeader import FrameHeader
+from .Data import VolumeMuteStatus, MuteStatus
+from ..Interface import BayBase, DeviceBase, DeviceRegistry
+from .FrameBase import append_payload_str
+from ..Uid import MxrDeviceUid
+
+class FrameVolumeSet(FrameBase):
+    ''' bay volume change information frame '''
+    def __init__(self, header:FrameHeader):
+        super().__init__(header)
+
+    def construct(mxr:DeviceRegistry, target:BayBase, volume:VolumeMuteStatus) -> FrameBase:
+        payload = bytearray()
+        payload += target.device.remote_id.byte_value
+        payload.append(target.port & 0xFF)
+        payload.append((target.port >> 8) & 0xFF)
+        payload += volume.value
+        payload += bytes([0, 0, 0]) # padding
+        frame:FrameBase = FrameBase.construct_frame(mxr=mxr, opcode=0x14, protocol=0x11)
+        frame.payload = bytes(payload)
+        return frame
+
+    @property
+    def target_device(self) -> DeviceBase:
+        return self.mxr.get_by_uid(self.target_uid)
+
+    @property
+    def target_uid(self) -> MxrDeviceUid:
+        return MxrDeviceUid(self.payload[0:16])
+
+    @property
+    def bay(self)  -> BayBase:
+        # bay on which the volume changed
+        portnum = ((self.payload[17] << 8) | self.payload[16])
+        dev = self.remote_device
+        if dev is None:
+            return
+        return dev.get_by_portnum(portnum)
+
+    @property
+    def volume_left(self) -> int:
+        # left channel volume %
+        r = int(self.payload[18])
+        if r > 100:
+            return None
+        return r
+
+    @property
+    def volume_right(self) -> int:
+        # right channel volume %
+        r = int(self.payload[19])
+        if r > 100:
+            return None
+        return r
+
+    @property
+    def muted(self) -> MuteStatus:
+        # mute status
+        return MuteStatus(self.payload[20])
+
+    def process(self) -> None:
+        # update the local cache
+        bay = self.bay
+        if bay is None:
+            return
+        muted = self.muted
+        muted_left = muted.left if (muted is not None) else None
+        muted_right = muted.right if (muted is not None) else None
+        bay.on_mxr_volume_update(VolumeMuteStatus(self.volume_left, self.volume_right, muted_left, muted_right))
+
+    def __str__(self) -> str:
+        return f"volume bay:{str(self.bay)} volume:{self.volume_left}/{self.volume_right} muted:{self.muted}"

mx_remote/proto/FrameVolumeUp.py

@@ -0,0 +1,28 @@
+##################################################
+##         MX Remote Python Interface           ##
+##                                              ##
+## author: Lars Op den Kamp (lars@opdenkamp.eu) ##
+## copyright (c) 2024 Op den Kamp IT Solutions  ##
+##################################################
+
+from .FrameBase import FrameBase
+from .FrameHeader import FrameHeader
+
+class FrameVolumeUp(FrameBase):
+    ''' volume up pressed frame '''
+    def __init__(self, header:FrameHeader):
+        super().__init__(header)
+
+    @property
+    def bay(self):
+        portnum = self.payload[0]
+        dev = self.remote_device
+        if dev is None:
+            return
+        return dev.get_by_portnum(portnum)
+
+    def process(self):
+        pass
+
+    def __str__(self):
+        return f"volume up bay: {self.bay} (port {self.payload[0]})"

mx_remote/proto/LinkConfig.py

@@ -0,0 +1,121 @@
+##################################################
+##         MX Remote Python Interface           ##
+##                                              ##
+## author: Lars Op den Kamp (lars@opdenkamp.eu) ##
+## copyright (c) 2024 Op den Kamp IT Solutions  ##
+##################################################
+
+from typing import List
+from .FrameBase import FrameBase
+from ..Interface import DeviceBase, BayBase
+import struct
+
+class LinkConfig:
+    ''' Single link configuration '''
+    def __init__(self, frame:FrameBase, payload:bytes):
+        self.frame = frame
+        self.payload = payload
+        self._confirm:'LinkConfig'|None = None
+
+    @property
+    def remote_device(self) -> DeviceBase:
+        # device instance of the device that sent this frame
+        return self.frame.remote_device
+
+    @property
+    def remote_port(self) -> int:
+        # remote port number
+        return int(self.payload[0])
+
+    @property
+    def remote_bay(self) -> BayBase:
+        # bay instance of the bay that sent this link configuration
+        dev = self.remote_device
+        if dev is None:
+            return
+        return dev.get_by_portnum(self.remote_port)
+
+    @property
+    def auto_config(self) -> bool:
+        # auto-configuration enabled
+        return (int(self.payload[1]) == 1)
+
+    @property
+    def linked_serial(self) -> str:
+        # serial number of the device linked to this bay, or an empty string if not linked
+        return self.payload[2:18].split(b'\0',1)[0].decode('ascii')
+
+    @property
+    def linked_bay_name(self) -> str:
+        # name of the bay linked to this bay, or an empty string if not linked
+        return self.payload[18:34].split(b'\0',1)[0].decode('ascii')
+
+    @property
+    def features(self) -> int:
+        # supported features bitmask for this link
+        return struct.unpack('<L', self.payload[34:38])[0]
+
+    @property
+    def is_linked(self) -> bool:
+        # bay linked or not
+        return (len(self.linked_serial) != 0) and (len(self.linked_bay_name) != 0)
+
+    @property
+    def linked_device(self) -> DeviceBase:
+        # device instance of the device that's linked to this bay
+        if not self.is_linked:
+            return None
+        return self.frame.mxr.get_by_serial(self.linked_serial)
+
+    @property
+    def linked_bay(self) -> BayBase:
+        # bay instance of the bay that's linked to this bay
+        dev = self.linked_device
+        if dev is None:
+            return None
+        return dev.get_by_portname(self.linked_bay_name)
+
+    @property
+    def bays(self) -> List[BayBase]:
+        linked_bay = self.linked_bay
+        if linked_bay is not None:
+            return [ self.remote_bay, linked_bay ]
+        return [ self.remote_bay ]
+
+    @property
+    def connected(self) -> bool:
+        if not self.is_linked:
+            return False
+        return self._confirm is not None
+
+    @property
+    def online(self) -> bool:
+        if not self.is_linked:
+            return False
+        if self._confirm is None:
+            return False
+        return self.remote_bay.online and self.linked_bay.online
+
+    def is_linked_to(self, bay:BayBase) -> bool:
+        if self.remote_bay == bay:
+            return True
+        linked_bay = self.linked_bay
+        if linked_bay is None:
+            return False
+        return linked_bay == bay
+
+    def other_bay(self, bay:BayBase) -> BayBase|None:
+        if not self.is_linked:
+            return None
+        if self.remote_bay == bay:
+            return self.linked_bay
+        return self.remote_bay
+
+    def process(self) -> None:
+        # register or update this link in the local cache
+        self.frame.mxr.links.update(bay=self.remote_bay, linked_serial=self.linked_serial, linked_bay=self.linked_bay_name, features=self.features)
+
+    def __str__(self) -> str:
+        if not self.is_linked:
+            return "{} not linked".format(str(self.remote_bay))
+        return "{} link serial:{} remote bay:{} features:{}".format(str(self.remote_bay), self.linked_serial, self.linked_bay_name, str(self.features))