mx-remote 2.0.0__py3-none-any.whl

mx_remote/proto/FrameRCKey.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
+from .Constants import RCKey
+from ..Interface import BayBase
+class FrameRCKey(FrameBase):
+    ''' remote control key press or action '''
+    def __init__(self, header:FrameHeader):
+        super().__init__(header)
+
+    @property
+    def bay(self) -> BayBase:
+        # bay that received the key press
+        dev = self.remote_device
+        if dev is None:
+            return None
+        portnum = ((int(self.payload[1]) << 8) | int(self.payload[0])) if (dev.protocol >= 6) else self.payload[0]
+        return dev.get_by_portnum(portnum)
+
+    @property
+    def key(self) -> RCKey:
+        # key that was received
+        dev = self.remote_device
+        if dev is None:
+            return None
+        return RCKey((int(self.payload[3]) << 8) | int(self.payload[2])) if (dev.protocol >= 6) else RCKey((int(self.payload[2]) << 8) | int(self.payload[1]))
+
+    def process(self) -> None:
+        bay = self.bay
+        if bay is not None:
+            bay.on_key_pressed(self.key)
+
+    def __str__(self) -> str:
+        return "{} key pressed: {}".format(str(self.bay), repr(self.key))

mx_remote/proto/FrameReboot.py

@@ -0,0 +1,26 @@
+##################################################
+##         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, DeviceRegistry
+
+class FrameReboot(FrameBase):
+    ''' remote control key press or action '''
+    def __init__(self, header:FrameHeader):
+        super().__init__(header)
+
+    def construct(mxr:DeviceRegistry, target:DeviceBase) -> FrameBase:
+        frame:FrameBase = FrameBase.construct_frame(mxr=mxr, opcode=0x28)
+        frame.payload = target.remote_id.byte_value
+        return frame
+
+    def process(self) -> None:
+        pass
+
+    def __str__(self) -> str:
+        return "reboot"

mx_remote/proto/FrameRoutingChange.py

@@ -0,0 +1,66 @@
+##################################################
+##         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 FrameRoutingChange(FrameBase):
+    ''' Routing change information frame '''
+    def __init__(self, header:FrameHeader):
+        super().__init__(header)
+
+    @property
+    def sink_bay(self) -> BayBase:
+        # the sink bay that changed routing
+        portnum = self.payload[0]
+        dev = self.remote_device
+        if dev is None:
+            return
+        return dev.get_by_portnum(portnum)
+
+    @property
+    def selected_bay(self) -> BayBase:
+        # the (video) bay that was selected
+        portnum = self.payload[1]
+        dev = self.remote_device
+        if dev is None:
+            return
+        return dev.get_by_portnum(portnum)
+
+    @property
+    def video_bay(self) -> BayBase:
+        # the new video source bay
+        portnum = self.payload[2]
+        dev = self.remote_device
+        if dev is None:
+            return
+        return dev.get_by_portnum(portnum)
+
+    @property
+    def audio_bay(self) -> BayBase:
+        # the new audio source bay
+        portnum = self.payload[4]
+        dev = self.remote_device
+        if dev is None:
+            return
+        return dev.get_by_portnum(portnum)
+
+    @property
+    def scrambled(self):
+        # signal scrambled or not
+        return (self.payload[3] == 1)
+
+    def process(self):
+        # update the local cache
+        sink_bay = self.sink_bay
+        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"routing change {self.sink_bay} to {self.video_bay}"

mx_remote/proto/FrameSetName.py

@@ -0,0 +1,27 @@
+##################################################
+##         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, BayBase
+
+class FrameSetName(FrameBase):
+    ''' Change a bay name '''
+    def __init__(self, header:FrameHeader):
+        super().__init__(header)
+
+    def construct(mxr:DeviceRegistry, target:BayBase, name:str) -> FrameBase:
+        if len(name) > 16:
+            name = name[:16]
+        name = name.encode(encoding='ascii')
+        payload = target.device.remote_id.byte_value + \
+            bytes([(target.port >> 0) & 0xFF, (target.port >> 8) & 0xFF]) + \
+            name
+        return FrameBase.construct_frame(mxr=mxr, opcode=0x22, payload=payload, size=40)
+
+    def __str__(self) -> str:
+        return f"Name change"

mx_remote/proto/FrameSignalStatus.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 .FrameBase import FrameBase
+from .FrameHeader import FrameHeader
+from ..Interface import BayBase
+
+class FrameSignalStatus(FrameBase):
+    ''' signal status changed '''
+    def __init__(self, header:FrameHeader):
+        super().__init__(header)
+
+    @property
+    def bay(self)  -> BayBase:
+        portnum = self.payload[0]
+        dev = self.remote_device
+        if dev is None:
+            return None
+        return dev.get_by_portnum(portnum)
+
+    @property
+    def signal(self) -> bool:
+        # signal detected
+        return (self.payload[1] == 1)
+
+    @property
+    def signal_type(self) -> str:
+        # signal type description
+        if len(self) <= 2:
+            return None
+        return self.payload[2:].split(b'\0',1)[0].decode('ascii')
+
+    def process(self) -> None:
+        # update the local cache
+        bay = self.bay
+        if bay is None:
+            return
+        bay.signal_detected = self.signal
+        bay.signal_type = self.signal_type
+
+    def __str__(self) -> str:
+        return f"signal status {str(self.bay)} - detected={self.signal} type={self.signal_type}"

mx_remote/proto/FrameSignalStatusNew.py

@@ -0,0 +1,285 @@
+##################################################
+##         MX Remote Python Interface           ##
+##                                              ##
+## author: Lars Op den Kamp (lars@opdenkamp.eu) ##
+## copyright (c) 2024 Op den Kamp IT Solutions  ##
+##################################################
+
+from enum import Enum
+from .FrameBase import FrameBase
+from .FrameHeader import FrameHeader
+from ..Interface import BayBase
+from ..Uid import MxrDeviceUid
+import struct
+from .Svd import SvdMap, Svd
+
+SVD = SvdMap()
+
+class VideoColourSpace(Enum):
+    RGB = 0
+    YUV444 = 1
+    YUV422 = 2
+    YUV420 = 3
+
+    def __str__(self) -> str:
+        if self.value == 0:
+            return 'RGB'
+        if self.value == 1:
+            return '4:4:4'
+        if self.value == 2:
+            return '4:2:2'
+        if self.value == 3:
+            return '4:2:0'
+        return 'unknown'
+
+class AvDetailsSupportFlags:
+    def __init__(self, data:int) -> None:
+        self.data = data & 0xFF
+
+    @property
+    def stream_detected(self) -> bool:
+        return (self.data & (1 << 0) != 0)
+
+    @property
+    def stream_valid(self) -> bool:
+        return (self.data & (1 << 1) != 0)
+
+    @property
+    def have_colour_depth(self) -> bool:
+        return (self.data & (1 << 2) != 0)
+
+    @property
+    def have_avi_infoframe(self) -> bool:
+        return (self.data & (1 << 3) != 0)
+
+    @property
+    def have_audio_infoframe(self) -> bool:
+        return (self.data & (1 << 4) != 0)
+
+    @property
+    def have_audio_details(self) -> bool:
+        return (self.data & (1 << 5) != 0)
+
+    @property
+    def have_video_details(self) -> bool:
+        return (self.data & (1 << 6) != 0)
+
+    @property
+    def have_link_errors(self) -> bool:
+        return (self.data & (1 << 7) != 0)
+
+class AvDetailsStreamFlags:
+    def __init__(self, data:int) -> None:
+        self.data = data & 0xFF
+
+    @property
+    def video_scrambled(self) -> bool:
+        return (self.data & (1 << 0) != 0)
+
+    @property
+    def video_interlaced(self) -> bool:
+        return (self.data & (1 << 1) != 0)
+
+    @property
+    def video_3d(self) -> bool:
+        return (self.data & (1 << 2) != 0)
+
+    @property
+    def video_non_int_clock(self) -> bool:
+        return (self.data & (1 << 3) != 0)
+
+    @property
+    def video_hdr(self) -> bool:
+        return (self.data & (1 << 4) != 0)
+
+    @property
+    def avmute_set(self) -> bool:
+        return (self.data & (1 << 5) != 0)
+
+    @property
+    def avmute_clear(self) -> bool:
+        return (self.data & (1 << 6) != 0)
+
+    @property
+    def reserved(self) -> bool:
+        return (self.data & (1 << 7) != 0)
+
+class SignalStatusAvDetailsVideo:
+    def __init__(self, data:bytes) -> None:
+        if len(data) != 16:
+            raise Exception(f"invalid length: {len(data)}")
+        self._data = data
+
+    @property
+    def svd(self) -> Svd:
+        return SVD.svd[self._data[0]] if self._data[0] != 0 else None
+
+    @property
+    def colour_space(self) -> VideoColourSpace:
+        return VideoColourSpace(self._data[1])
+
+    @property
+    def colour_depth(self) -> int:
+        return self._data[2]
+
+    @property
+    def pixels_per_clock(self) -> int:
+        return self._data[3]
+
+    @property
+    def aspect_ratio(self) -> int:
+        return self._data[4]
+
+    @property
+    def format_3d(self) -> int:
+        return self._data[5]
+
+    @property
+    def samping_3d(self) -> int:
+        return self._data[6]
+
+    @property
+    def samping_position(self) -> int:
+        return self._data[7]
+
+    @property
+    def frame_rate(self) -> int:
+        return int.from_bytes(self._data[8:9], "little")
+
+    @property
+    def tmds_clock(self) -> int:
+        return int.from_bytes(self._data[10:13], "little")
+
+    def __str__(self) -> str:
+        return f"{self.svd}, rate {self.frame_rate}, tmds = {self.tmds_clock}"
+
+class FrameSignalStatusNew(FrameBase):
+    ''' signal status changed '''
+    def __init__(self, header:FrameHeader):
+        super().__init__(header)
+
+    @property
+    def signal_header(self) -> bytes:
+        return self.payload[0:8]
+
+    @property
+    def signal_header_version(self) -> int:
+        if len(self.payload) < 8:
+            return 0
+        return int(self.signal_header[1]) << 8 | int(self.signal_header[0])
+
+    @property
+    def support_flags(self) -> AvDetailsSupportFlags:
+        if len(self.payload) < 8:
+            return 0
+        return AvDetailsSupportFlags(self.signal_header[2])
+
+    @property
+    def stream_flags(self) -> AvDetailsStreamFlags:
+        if len(self.payload) < 8:
+            return 0
+        return AvDetailsStreamFlags(self.signal_header[3])
+
+    @property
+    def infoframe(self) -> bytes:
+        if len(self.payload) < 24:
+            return bytes()
+        return self.payload[8:24]
+
+    @property
+    def audio(self) -> bytes:
+        if len(self.payload) < 40:
+            return bytes()
+        return self.payload[24:40]
+
+    @property
+    def video(self) -> SignalStatusAvDetailsVideo:
+        if len(self.payload) < 56:
+            return None
+        return SignalStatusAvDetailsVideo(self.payload[40:56])
+
+    @property
+    def vsync(self) -> bytes:
+        if len(self.payload) < 88:
+            return bytes()
+        return self.payload[56:88]
+
+    @property
+    def errors(self) -> bytes:
+        if len(self.payload) < 100:
+            return bytes()
+        pl = self.payload[88:100]
+        return [struct.unpack('<L', pl[0:4])[0], struct.unpack('<L', pl[4:8])[0], struct.unpack('<L', pl[8:12])[0]]
+
+    @property
+    def bay_details(self) -> bytes:
+        if len(self.payload) < 112:
+            return bytes()
+        return self.payload[100:112]
+
+    @property
+    def port_number(self) -> int:
+        if len(self.payload) < 8:
+            return 0xFF
+        #return struct.unpack('<L', self.payload[57:61])[0]
+        return (self.bay_details[1] << 8) | (self.bay_details[0])
+
+    @property
+    def bay(self)  -> BayBase:
+        dev = self.remote_device
+        if dev is None:
+            return None
+        return dev.get_by_portnum(self.port_number)
+
+    @property
+    def bay_name(self) -> str:
+        bay = self.bay
+        return str(bay) if bay is not None else "(Waiting For HELLO)"
+
+    @property
+    def stream_detected(self) -> bool:
+        return self.support_flags.stream_detected
+
+    @property
+    def stream_valid(self) -> bool:
+        return self.support_flags.stream_valid
+
+    @property
+    def frame_rate(self) -> float:
+        if self.stream_flags.video_non_int_clock:
+            return round(self.video.frame_rate * 1000 / 1001, 2)
+        return self.video.frame_rate
+
+    def process(self) -> None:
+        if len(self.payload) < 8:
+            return
+        if len(self.payload) < 112:
+            return
+        # update the local cache
+        bay = self.bay
+        if bay is None:
+            return
+        bay.signal_detected = self.stream_valid
+        if self.stream_valid:
+            signal_type = f'{self.video.svd.horizontal_active}x{self.video.svd.vertical_active} / {self.video.colour_space} / {self.video.colour_depth}bpp'
+            if self.stream_flags.video_interlaced:
+                signal_type += ' interlaced'
+            if self.stream_flags.video_hdr:
+                signal_type += ' HDR'
+            signal_type += f' / {self.frame_rate}Hz'
+            bay.signal_type = signal_type
+        else:
+            bay.signal_type = 'No Signal'
+
+    def __str__(self) -> str:
+        if len(self.payload) < 8:
+            return "signal status request"
+        if len(self.payload) == 16:
+            return f"signal status request for {MxrDeviceUid(self.payload)}"
+        if len(self.payload) < 112:
+            return f"signal status request len {len(self.payload)}"
+        if self.stream_valid:
+            return f"{self.bay_name} signal status - {self.video}, errors = {self.errors}"
+        if self.stream_detected:
+            return f"{self.bay_name} signal status - invalid signal detected"
+        return f"{self.bay_name} signal status - no signal"

mx_remote/proto/FrameSysTemperature.py

@@ -0,0 +1,50 @@
+##################################################
+##         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 typing import Any
+
+class FrameSysTemperature(FrameBase):
+    ''' system temperature frame, sent every minute by devices on the network '''
+    def __init__(self, header:FrameHeader):
+        super().__init__(header)
+
+    @property
+    def nb_sensors(self) -> int:
+        # number of temperature sensor readings
+        return int(self.payload[0])
+
+    @property
+    def temperature(self) -> list[int]:
+        # list of all readings in this frame
+        rv = []
+        ptr = 0
+        while ptr < self.nb_sensors:
+            ptr = ptr + 1
+            rv.append(int(self.payload[ptr]))
+        return rv
+
+    def process(self) -> None:
+        # update the local cache
+        dev = self.mxr.get_by_uid(self.remote_id)
+        if dev is not None:
+            dev.on_mxr_temperature(self)
+
+    def __eq__(self, other: Any) -> bool:
+        return isinstance(other, FrameSysTemperature) and \
+                (self.nb_sensors == other.nb_sensors) and \
+                (self.temperature == other.temperature)
+
+    def __ne__(self, other: Any) -> bool:
+        return not isinstance(other, FrameSysTemperature) or \
+                (self.nb_sensors != other.nb_sensors) or \
+                (self.temperature != other.temperature)
+
+    def __str__(self) -> str:
+        return "temperature: {}".format(str(self.temperature))
+

mx_remote/proto/FrameTXRCAction.py

@@ -0,0 +1,58 @@
+##################################################
+##         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 .Constants import RCAction
+from ..Interface import BayBase, DeviceBase, DeviceRegistry
+from ..Uid import MxrDeviceUid
+import logging
+
+_LOGGER = logging.getLogger(__name__)
+
+class FrameTXRCAction(FrameBase):
+    def __init__(self, header:FrameHeader):
+        super().__init__(header)
+
+    def construct(mxr:DeviceRegistry, target:BayBase, action:RCAction) -> FrameBase:
+        payload = target.device.remote_id.byte_value
+        payload += bytes([(target.port & 0xFF), ((target.port >> 8) & 0xFF), (int(action.value) & 0xFF), ((int(action.value) >> 8) & 0xFF)])
+        frame:FrameBase = FrameBase.construct_frame(mxr=mxr, opcode=0x0E)
+        frame.payload = 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 that received the key press
+        dev = self.remote_device
+        if dev is None:
+            return None
+        portnum = ((int(self.payload[17]) << 8) | int(self.payload[16]))
+        return dev.get_by_portnum(portnum)
+
+    @property
+    def action(self) -> RCAction:
+        dev = self.remote_device
+        if dev is None:
+            return None
+        return RCAction(int(self.payload[20]))
+
+    def process(self) -> None:
+        bay = self.bay
+        if bay is not None:
+            bay.on_action_received(self.action)
+
+    def __str__(self) -> str:
+        return f"{self.bay} action receive: {self.action}"

mx_remote/proto/FrameTopology.py

@@ -0,0 +1,36 @@
+##################################################
+##         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 TopologyEntry:
+    def __init__(self, uid:MxrDeviceUid, mask:int):
+        self.uid = uid
+        self.mask = mask
+
+    def __str__(self):
+        return f"{self.uid} mask {self.mask}"
+
+class FrameTopology(FrameBase):
+    def __init__(self, header:FrameHeader):
+        super().__init__(header)
+
+    @property
+    def topology(self):
+        topo = []
+        if self.header.payload_len < 20:
+            return []
+        data = self.payload
+        while len(data) >= 20:
+            topo.append(TopologyEntry(MxrDeviceUid(data[0:16]), struct.unpack('<L', data[16:20])[0]))
+            data = data[20:]
+        return topo
+
+    def __str__(self) -> str:
+        return f"{self.remote_device} topology data: {self.topology}"