mx-remote 2.0.0__py3-none-any.whl

mx_remote/proto/FrameAmpDolbySettings.py

@@ -0,0 +1,51 @@
+##################################################
+##         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, AmpDolbySettings
+from ..Uid import MxrDeviceUid
+import logging
+
+_LOGGER = logging.getLogger(__name__)
+
+class FrameAmpDolbySettings(FrameBase):
+    def __init__(self, header:FrameHeader):
+        super().__init__(header)
+
+    @property
+    def target_device(self) -> DeviceBase:
+        if self.target_uid.empty:
+            return self.mxr.get_by_uid(self.header.remote_id)
+        return self.mxr.get_by_uid(self.target_uid)
+
+    @property
+    def target_uid(self) -> MxrDeviceUid:
+        return MxrDeviceUid(self.payload[0:16])
+
+    @property
+    def dolby_mode(self) -> int:
+        return self.payload[16]
+
+    @property
+    def pcm_upmix(self) -> bool:
+        return (self.payload[17] != 0)
+
+    def as_settings(self) -> AmpDolbySettings:
+        settings = AmpDolbySettings()
+        settings.mode = self.dolby_mode
+        settings.pcm_upmix = self.pcm_upmix
+        return settings
+
+    def process(self):
+        # update the local cache
+        device = self.target_device
+        if device is not None:
+            device.dolby_settings = self.as_settings()
+
+    def __str__(self) -> str:
+        return f"amp dolby settings {self.target_device}: mode={self.dolby_mode} upmix={self.pcm_upmix}"

mx_remote/proto/FrameAmpZoneSettings.py

@@ -0,0 +1,123 @@
+##################################################
+##         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, AmpZoneSettings
+from ..Uid import MxrDeviceUid
+import logging
+
+_LOGGER = logging.getLogger(__name__)
+
+class FrameAmpZoneSettings(FrameBase):
+    def __init__(self, header:FrameHeader):
+        super().__init__(header)
+
+    @property
+    def target_device(self) -> DeviceBase:
+        if self.target_uid.empty:
+            return self.mxr.get_by_uid(self.header.remote_id)
+        return self.mxr.get_by_uid(self.target_uid)
+
+    @property
+    def target_uid(self) -> MxrDeviceUid:
+        return MxrDeviceUid(self.payload[0:16])
+
+    @property
+    def zone(self) -> int:
+        return int.from_bytes(self.payload[16:17], "little")
+
+    @property
+    def bay(self) -> BayBase|None:
+        target_device = self.target_device
+        if target_device is None:
+            _LOGGER.warning(f"amp zone settings no target uid = {self.target_uid}")
+            return None
+        return target_device.get_by_portnum(self.zone)
+
+    @property
+    def gain_left(self) -> int:
+        return self.payload[18]
+
+    @property
+    def gain_right(self) -> int:
+        return self.payload[19]
+
+    @property
+    def volume_min(self) -> int:
+        return self.payload[20]
+
+    @property
+    def volume_max(self) -> int:
+        return self.payload[21]
+
+    @property
+    def delay_left(self) -> int:
+        return int.from_bytes(self.payload[22:26], "little")
+
+    @property
+    def delay_right(self) -> int:
+        return int.from_bytes(self.payload[26:30], "little")
+
+    @property
+    def bass(self) -> int:
+        return self.payload[30]
+
+    @property
+    def treble(self) -> int:
+        return self.payload[31]
+
+    @property
+    def bridged(self) -> int:
+        return self.payload[32]
+
+    @property
+    def power_mode(self) -> int:
+        return self.payload[33]
+
+    @property
+    def power_level(self) -> int:
+        return self.payload[34]
+
+    @property
+    def power_timeout(self) -> int:
+        return int.from_bytes(self.payload[35:39], "little")
+
+    @property
+    def eq_left(self) -> list[int]:
+        return [int(x) for x in self.payload[39:44]]
+
+    @property
+    def eq_right(self) -> list[int]:
+        return [int(x) for x in self.payload[44:49]]
+
+    def as_settings(self) -> AmpZoneSettings:
+        settings = AmpZoneSettings()
+        settings.gain_left = self.gain_left
+        settings.gain_right = self.gain_right
+        settings.volume_min = self.volume_min
+        settings.volume_max = self.volume_max
+        settings.delay_left = self.delay_left
+        settings.delay_right = self.delay_right
+        settings.bass = self.bass
+        settings.treble = self.treble
+        settings.bridged = self.bridged
+        settings.power_mode = self.power_mode
+        settings.power_level = self.power_level
+        settings.power_timeout = self.power_timeout
+        settings.eq_left = self.eq_left
+        settings.eq_right = self.eq_right
+        return settings
+
+    def process(self):
+        # update the local cache
+        bay = self.bay
+        if bay is not None:
+            bay.amp_settings = self.as_settings()
+
+    def __str__(self) -> str:
+        return f"amp zone settings {self.bay} size {len(self.payload)}: volume_range={self.volume_min}-{self.volume_max} bridged={self.bridged} power={self.power_mode} level={self.power_level} timeout={self.power_timeout} delay={self.delay_left}/{self.delay_right} gain={self.gain_left}/{self.gain_right} bass={self.bass} treble={self.treble} eq_left={self.eq_left} eq_right={self.eq_right}"

mx_remote/proto/FrameBase.py

@@ -0,0 +1,80 @@
+##################################################
+##         MX Remote Python Interface           ##
+##                                              ##
+## author: Lars Op den Kamp (lars@opdenkamp.eu) ##
+## copyright (c) 2024 Op den Kamp IT Solutions  ##
+##################################################
+
+from .Constants import MXR_PROTOCOL_VERSION
+from .FrameHeader import FrameHeader
+from ..Interface import DeviceBase, DeviceRegistry
+from ..Uid import MxrDeviceUid
+
+def append_payload_str(payload:list[int], value:str, sz:int) -> list[int]:
+    value = value[0:16]
+    return payload + list(value.encode('ascii')) + [ 0 for _ in range(sz - len(value))]
+class FrameBase:
+    ''' Base class for decoded mx_remote frames '''
+    def __init__(self, header:FrameHeader):
+        assert(isinstance(header, FrameHeader))
+        self.header = header
+
+    def construct_frame(mxr:DeviceRegistry, opcode:int, protocol:int=MXR_PROTOCOL_VERSION, payload:bytes=bytes([]), size:int|None=None) -> 'FrameBase':
+        rv = FrameBase(FrameHeader.construct(mxr=mxr, opcode=opcode, protocol=protocol))
+        if (size is not None):
+            if len(payload) > size:
+                payload = payload[:size]
+            elif len(payload) < size:
+                payload += bytes([0 for _ in range(size - len(rv))])
+        rv.payload = payload
+        return rv
+
+    @property
+    def mxr(self) -> DeviceRegistry:
+        # remote instance
+        return self.header.mxr
+
+    @property
+    def address(self) -> str:
+        # address that sent this frame
+        (addr, _) = self.header.addr
+        return addr
+
+    @property
+    def protocol(self) -> int:
+        # frame protocol version
+        return self.header.protocol
+
+    @property
+    def remote_id(self) -> MxrDeviceUid:
+        # unique id of the device that sent this frame
+        return self.header.remote_id
+
+    @property
+    def remote_device(self) -> DeviceBase:
+        # device instance for the device that sent this frame
+        return self.mxr.get_by_uid(self.remote_id)
+
+    @property
+    def payload(self) -> bytes:
+        # frame payload bytes
+        return self.header.payload
+
+    @payload.setter
+    def payload(self, val:bytes) -> None:
+        self.header.payload = val
+
+    @property
+    def frame(self) -> bytes:
+        return self.header.data
+
+    def process(self) -> None:
+        # update the local cache with the new data that was received in this frame
+        pass
+
+    def __len__(self) -> int:
+        # number of payload bytes
+        return self.header.payload_len
+
+    def __str__(self) -> str:
+        return f"generic frame opcode {self.header.opcode:X}"

mx_remote/proto/FrameBayConfig.py

@@ -0,0 +1,47 @@
+##################################################
+##         MX Remote Python Interface           ##
+##                                              ##
+## author: Lars Op den Kamp (lars@opdenkamp.eu) ##
+## copyright (c) 2024 Op den Kamp IT Solutions  ##
+##################################################
+
+from .BayConfig import BayConfig
+from .FrameBase import FrameBase
+from .FrameHeader import FrameHeader
+import logging
+
+_LOGGER = logging.getLogger(__name__)
+
+class FrameBayConfig(FrameBase):
+    ''' Bay configuration and information for all bays that are available on a remote device '''
+    def __init__(self, header:FrameHeader):
+        super().__init__(header)
+
+    @property
+    def nb_bays(self) -> int:
+        # total number of bay descriptors in this frame
+        return len(self) / 61
+
+    @property
+    def bays(self) -> list[BayConfig]:
+        # get a list of bay configurations defined in this frame
+        rv = []
+        baynum = 0
+        while baynum < self.nb_bays:
+            bay = BayConfig(self.payload[(baynum*61):((baynum+1)*61)])
+            rv.append(bay)
+            baynum += 1
+        return rv
+
+    def process(self) -> None:
+        # register or update all bays in the local cache
+        dev = self.remote_device
+        if dev is None:
+            _LOGGER.debug("not processing bay config - hello not received")
+            return
+        for bayconfig in self.bays:
+            _LOGGER.debug(f"process {bayconfig}")
+            dev.on_mxr_bay_config(bayconfig)
+
+    def __str__(self) -> str:
+        return f"{self.remote_device} bay config: {len(self.bays)} bays"

mx_remote/proto/FrameBayConfigSecondary.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 .BayConfig import BayConfig
+from .FrameBase import FrameBase
+from .FrameHeader import FrameHeader
+import logging
+
+class FrameBayConfigSecondary(FrameBase):
+    ''' Bay configuration and information for all bays that are available on a remote device '''
+    def __init__(self, header:FrameHeader):
+        super().__init__(header)
+
+    @property
+    def nb_bays(self) -> int:
+        # total number of bay descriptors in this frame
+        return len(self) / 61
+
+    @property
+    def bays(self) -> list[BayConfig]:
+        # get a list of bay configurations defined in this frame
+        rv = []
+        baynum = 0
+        while baynum < self.nb_bays:
+            bay = BayConfig(self.payload[(baynum*61):((baynum+1)*61)])
+            rv.append(bay)
+            baynum += 1
+        return rv
+
+    def process(self) -> None:
+        # register or update bay in the local cache
+        dev = self.remote_device
+        if dev is None:
+            logging.debug("not processing secondary bay config - hello not received")
+            return
+        dev.on_mxr_bay_config(BayConfig(self.payload))
+
+    def __str__(self) -> str:
+        return f"{self.remote_device} secondary bay config: {len(self.bays)} bays"

mx_remote/proto/FrameBayHide.py

@@ -0,0 +1,53 @@
+##################################################
+##         MX Remote Python Interface           ##
+##                                              ##
+## author: Lars Op den Kamp (lars@opdenkamp.eu) ##
+## copyright (c) 2024 Op den Kamp IT Solutions  ##
+##################################################
+
+from .Constants import BayStatusMask
+from .FrameBase import FrameBase
+from .FrameHeader import FrameHeader
+from ..Interface import BayBase, DeviceRegistry, DeviceBase, MxrDeviceUid
+import logging
+import struct
+
+_LOGGER = logging.getLogger(__name__)
+
+class FrameBayHide(FrameBase):
+    def __init__(self, header:FrameHeader):
+        super().__init__(header)
+
+    def construct(mxr:DeviceRegistry, target:BayBase, hidden:bool) -> FrameBase:
+        payload = target.device.remote_id.byte_value + \
+            bytes([(target.port >> 0) & 0xFF, (target.port >> 8) & 0xFF]) + \
+            bytes([0 for _ in range(6)]) + \
+            bytes([1 if hidden else 0]) + \
+            bytes([0 for _ in range(7)])
+        return FrameBase.construct_frame(mxr=mxr, opcode=0x27, payload=payload)
+
+    @property
+    def target_uid(self) -> DeviceBase:
+        return MxrDeviceUid(self.payload[0:16])
+
+    @property
+    def target(self) -> DeviceBase:
+        return self.remote_device.registry.get_by_uid(self.target_uid)
+
+    @property
+    def bay(self)  -> BayBase:
+        target = self.target
+        if target is None:
+            return None
+        portnum = ((self.payload[17] << 8) | self.payload[18])
+        return target.get_by_portnum(portnum)
+
+    @property
+    def hidden(self) -> bool:
+        return (self.payload[24] == 1)
+
+    def process(self) -> None:
+        pass
+
+    def __str__(self) -> str:
+        return f"bay hide {self.bay} hidden={self.hidden}"

mx_remote/proto/FrameBayStatus.py

@@ -0,0 +1,51 @@
+##################################################
+##         MX Remote Python Interface           ##
+##                                              ##
+## author: Lars Op den Kamp (lars@opdenkamp.eu) ##
+## copyright (c) 2024 Op den Kamp IT Solutions  ##
+##################################################
+
+from .Constants import BayStatusMask
+from .FrameBase import FrameBase
+from .FrameHeader import FrameHeader
+from ..Interface import BayBase
+import logging
+import struct
+
+_LOGGER = logging.getLogger(__name__)
+
+class FrameBayStatus(FrameBase):
+    def __init__(self, header:FrameHeader):
+        super().__init__(header)
+
+    @property
+    def bay(self)  -> BayBase:
+        portnum = ((self.payload[1] << 8) | self.payload[0])
+        dev = self.remote_device
+        if dev is None:
+            return None
+        return dev.get_by_portnum(portnum)
+
+    @property
+    def signal_type(self) -> str:
+        return self.payload[2:18].split(b'\0',1)[0].decode('ascii')
+
+    @property
+    def status(self) -> BayStatusMask:
+        return BayStatusMask(struct.unpack('<L', self.payload[20:24])[0])
+
+    @property
+    def features(self) -> int:
+        return struct.unpack('<L', self.payload[24:28])[0]
+
+    def process(self) -> None:
+        if self.bay is None:
+            _LOGGER.warning("bay not registered yet")
+        else:
+            self.bay.features_mask = self.features
+            self.bay.on_mxr_bay_status(self.status)
+            if not self.status.signal_detected or not self.bay.device.is_v2ip:
+                self.bay.signal_type = self.signal_type
+
+    def __str__(self) -> str:
+        return f"bay status {self.bay} signal '{self.signal_type}' status {self.status} features {self.features}"

mx_remote/proto/FrameConnectStatus.py

@@ -0,0 +1,38 @@
+##################################################
+##         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 BayBase
+
+class FrameConnectStatus(FrameBase):
+    ''' Device was connected or disconnected. For sources, this means that an input signal was detected '''
+    def __init__(self, header:FrameHeader):
+        super().__init__(header)
+
+    @property
+    def bay(self) -> BayBase:
+        # bay that changed
+        portnum = self.payload[0]
+        dev = self.remote_device
+        if dev is None:
+            return None
+        return dev.get_by_portnum(portnum)
+
+    @property
+    def connected(self) -> bool:
+        # new connected / signal detect status
+        return (self.payload[1] == 1)
+
+    def process(self) -> None:
+        # update the cached connected status for this bay
+        bay = self.bay
+        if bay is not None:
+            bay.connected = self.connected
+
+    def __str__(self) -> str:
+        return "connect status {}: {}".format(str(self.bay), str(self.connected))

mx_remote/proto/FrameDiscover.py

@@ -0,0 +1,21 @@
+##################################################
+##         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 DeviceRegistry
+
+class FrameDiscover(FrameBase):
+    ''' Discovery, ask all devices on the network to send their info '''
+    def __init__(self, header:FrameHeader):
+        super().__init__(header)
+
+    def construct(mxr:DeviceRegistry) -> FrameBase:
+        return FrameBase.construct_frame(mxr=mxr, opcode=1, protocol=1)
+
+    def __str__(self) -> str:
+        return "discover devices"

mx_remote/proto/FrameEDID.py

@@ -0,0 +1,20 @@
+##################################################
+##         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 FrameEDID(FrameBase):
+    def __init__(self, header:FrameHeader):
+        super().__init__(header)
+
+    @property
+    def port(self):
+        return "Output" if self.payload[0] == 1 else "Input"
+
+    def __str__(self) -> str:
+        return f"EDID data {self.port}"

mx_remote/proto/FrameEDIDProfile.py

@@ -0,0 +1,24 @@
+##################################################
+##         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 DeviceRegistry, DeviceBase, EdidProfile
+
+class FrameEDIDProfile(FrameBase):
+    ''' Change an EDID profile '''
+    def __init__(self, header:FrameHeader):
+        super().__init__(header)
+
+    def construct(mxr:DeviceRegistry, target:DeviceBase, profile:EdidProfile) -> FrameBase:
+        payload = target.remote_id.byte_value + \
+            bytes([(profile.value >> 0) & 0xFF, (profile.value >> 8) & 0xFF]) + \
+            bytes([0 for _ in range(6)])
+        return FrameBase.construct_frame(mxr=mxr, opcode=0x34, payload=payload)
+
+    def __str__(self) -> str:
+        return f"EDID profile change"

mx_remote/proto/FrameFilterStatus.py

@@ -0,0 +1,39 @@
+##################################################
+##         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
+
+class FrameFilterStatus(FrameBase):
+    def __init__(self, header:FrameHeader):
+        super().__init__(header)
+
+    @property
+    def filtered(self) -> list[MxrDeviceUid]:
+        filtered = []
+        data = self.payload[16:]
+        while len(data) >= 16:
+            filtered.append(MxrDeviceUid(data[0:16]))
+            data = data[16:]
+        return filtered
+
+    @property
+    def target_uid(self) -> MxrDeviceUid:
+        return MxrDeviceUid(self.payload[0:16])
+
+    def process(self) -> None:
+        dev = self.remote_device
+        if dev is None:
+            return
+        if len (dev.outputs) < 1:
+            return
+        first_out = dev.outputs[list(dev.outputs.keys())[0]]
+        first_out.filtered = self.filtered
+
+    def __str__(self) -> str:
+        return f"bay filter status: {len(self.filtered)} sources filtered"

mx_remote/proto/FrameFirmwareVersion.py

@@ -0,0 +1,40 @@
+##################################################
+##         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
+import struct
+
+class FrameFirmwareVersion(FrameBase):
+    def __init__(self, header:FrameHeader):
+        super().__init__(header)
+        self._type = self.payload[0]
+        self._hash = struct.unpack('<L', self.payload[4:8])[0]
+        self._timestamp = struct.unpack('<L', self.payload[8:12])[0]
+        self._name = self.payload[12:].split(b'\0',1)[0].decode('ascii')
+
+    @property
+    def fw_type(self):
+        return self._type
+
+    @property
+    def name(self):
+        return self._name
+
+    @property
+    def hash(self):
+        return self._hash
+
+    @property
+    def timestamp(self):
+        return self._timestamp
+
+    def __str__(self) -> str:
+        return f"firmware version: type {self.fw_type}: '{self.name}' hash: {hex(self.hash)} timestamp: {self.timestamp}"
+
+    def __repr__(self) -> str:
+        return str(self)