slm_open_api_package 0.2.10__py3-none-any.whl

slm_api/helpers/sequence_handler.py

@@ -0,0 +1,43 @@
+from . import https_requests
+
+def find_sequence(sequenceId, sequences):
+    """Iterations through the different sequences on the device to find the wanted one"""
+    res = None
+    if isinstance(sequences, dict):
+        if str(sequenceId) in sequences:
+            return sequences[str(sequenceId)]
+        else:
+            for _, subseq in sequences.items():
+                if isinstance(subseq, dict):
+                    res = find_sequence(sequenceId, subseq)
+                if res is not None:
+                    return res
+
+def find_sequence_by_name(sequenceName, sequences):
+    if isinstance(sequences, dict):
+        if "Name" in sequences:
+            return True if sequences["Name"] == sequenceName else False
+        else:
+            for count, subtree in sequences.items():
+                test = find_sequence_by_name(sequenceName, subtree)
+                if isinstance(test, bool) and test:
+                    return int(count)
+                elif isinstance(test, int) and test:
+                    return test
+
+def getSequenceID(host, sequenceName):
+    sequences = https_requests.get(host, "/webxi/sequences?recursive").json()
+    return find_sequence_by_name(sequenceName, sequences)    
+        
+
+def get_sequence(hostID,ID):
+    """This function checks if the ID exists"""
+    response = https_requests.get(hostID, "/webxi/sequences?recursive")
+    sequences = response.json()
+    sequence = find_sequence(ID, sequences)
+    if sequence == None:
+        raise Exception("No such sequence: " + str(ID))
+    else:
+        print(sequence)
+        return ID, sequence
+

slm_api/helpers/stream_handler.py

@@ -0,0 +1,105 @@
+from . import https_requests
+import asyncio
+from . import websocket_handler
+from . import measurment_handler
+
+def setup_stream(host, sequenceID, StreamName):
+    """Initilize a stream and start it. Returns the URI for the stream"""
+
+    # This line checks if only one sequenceID is given and converts it to a list. Otherwise it will keep the list given
+    sequenceID = [sequenceID] if isinstance(sequenceID, int) else sequenceID
+
+    body = {
+                "ConnectionType": "WebSocket",
+                "Sequences": sequenceID,
+                "MessageTypes": ["SequenceData"],
+                "Name": StreamName
+            }
+    response = https_requests.post(host, "/WebXi/Streams", json = body)
+    print(response)
+    if not (response.status_code == 201):  
+        print(response.text)
+        raise Exception("Cannot start stream, could be bacause of to many streams open on the device")
+    https = https_requests.UseHttps.use_https
+    websocket_host = host.removeprefix("https://").removeprefix("http://")
+    if https:
+        return 'wss://' + websocket_host + response.json()["URI"][0]
+    else:
+        return 'ws://' + websocket_host + response.json()["URI"][0]
+    
+def get_stream_ID(host, streamName):
+    """This function shows how to find the ID of a specific stream with specific name"""
+    streams = https_requests.get(host, "/WebXi/Streams?recursive").json()
+    # The keys are the stream IDs and are not renumbered when a stream is deleted
+    matches = [int(ID) for ID, subtree in streams.items() if subtree["Name"] == streamName]
+    return max(matches) if matches else None
+
+def delete_stream(host, streamName):
+    """Look up a stream by name and delete it, cleaning up the device resources used"""
+    streamID = get_stream_ID(host, streamName)
+    if streamID is not None:
+        response = https_requests.delete(host, "/WebXi/Streams/" + str(streamID), timeout=10)
+        response.raise_for_status()
+
+def data_type_conv(data_type, value, vector_length):
+    """Convert the byte data retrived from BK2245 to Int16 format\n
+       The byte format is in 'little'"""
+    if data_type == "Int16":
+        if vector_length == None:
+            return int.from_bytes(value, "little", signed=True)
+        else:
+            value_array = []
+            for i in range(0, vector_length*2, 2):
+                value_array.append(int.from_bytes(value[i:i+2], "little", signed=True))
+            # print(len(value_array))
+            return value_array
+    elif data_type == "BKTimeSpan":
+        return int.from_bytes(value[-4:], "little", signed=True)
+
+
+class StreamHandler:
+    """Base class managing the asyncio lifecycle of a WebXi websocket stream.
+    Subclasses must implement streamInit() (setting self.host and self.uri) and
+    msg_func(msg) to handle each incoming message. streamName is used to look up
+    and delete the stream on the device when stopped."""
+
+    def __init__(self, streamName):
+        self.streamName = streamName
+        self._stop_event = None
+        self._stop_requested = False
+
+    def streamInit(self):
+        raise NotImplementedError
+
+    def msg_func(self, msg):
+        raise NotImplementedError
+
+    def startStream(self):
+        asyncio.run(self.runStream())
+
+    async def runStream(self):
+        self._stop_event = asyncio.Event()
+        self.loop = asyncio.get_running_loop()
+        task = self.loop.create_task(websocket_handler.next_async_websocket(self.uri, self.msg_func))
+        task.add_done_callback(self._report_task_failure)
+        if self._stop_requested:
+            self._stop_event.set()
+        await self._stop_event.wait()
+        task.cancel()
+
+    def _report_task_failure(self, task):
+        if task.cancelled():
+            return
+        exception = task.exception()
+        if exception is not None:
+            print(f"[{self.streamName}] Stream task failed: {exception!r}")
+
+    def request_stop(self):
+        self._stop_requested = True
+        if self._stop_event is not None and not self.loop.is_closed():
+            self.loop.call_soon_threadsafe(self._stop_event.set)
+
+    def stopStream(self):
+        measurment_handler.stop_measurement(self.host)
+        self.request_stop()
+        delete_stream(self.host, self.streamName) # Cleaning up and deleting the stream used

slm_api/helpers/stream_handlers.py

@@ -0,0 +1,434 @@
+"""A single, configurable StreamHandler covering common WebXi streaming use
+cases (single Leq sequence, CPB, multiple sequences, FLAC/mp3 audio). The mode
+is picked with boolean flags (cpb, multi, flac, mp3) instead of subclassing."""
+
+from . import https_requests
+import time
+import re
+from datetime import datetime
+from timeit import default_timer as timer
+import numpy as np
+import miniaudio
+import threading
+
+from . import sequence_handler as seq
+from . import stream_handler as stream
+from . import measurment_handler as meas
+from .buffer import DataBuffer
+from . import flac_stream_2_samples as flac2samples
+from .tmpFileStateMachine import TmpfileStateMachine
+from ..webxi import webxi_stream
+from slm_api.enums.fast_log_intervals_enum import FastLogInterval
+from .data_handler import MultiDataHandler, JsonDataHandler, CsvDataHandler, PickleDataHandler
+
+_SAVING_HANDLERS = {
+    "json": JsonDataHandler,
+    "csv": CsvDataHandler,
+    "pickle": PickleDataHandler,
+}
+_SAVING_DEFAULT_EXTENSIONS = {"json": "json", "csv": "csv", "pickle": "pkl"}
+
+# WebXi header timestamps are 64-bit fixed-point seconds since the Unix epoch
+# (Q32.32): upper 32 bits = whole seconds, lower 32 bits = fraction of a second.
+_WEBXI_TICKS_PER_SECOND = 2 ** 32
+
+# ControlBBFastLoggingInterval enum -> milliseconds between fast-logged samples.
+# Derived from FastLogInterval so it stays in sync if that enum changes
+# (member value = device index, member name = "interval_<ms>ms").
+_FAST_LOGGING_INTERVAL_MS = {
+    member.value: int(member.name.removeprefix("interval_").removesuffix("ms"))
+    for member in FastLogInterval
+}
+
+
+def _webxi_time_to_epoch(header_time):
+    """Convert a WebXi header time (Q32.32 fixed-point) to Unix epoch seconds."""
+    return header_time / _WEBXI_TICKS_PER_SECOND
+
+
+def _get_fast_logging_interval_s(host):
+    """Read the configured broadband fast-logging interval and return it in seconds."""
+    enum = https_requests.get(host, "/WebXi/Applications/SLM/Setup/ControlBBFastLoggingInterval").json()
+    if enum not in _FAST_LOGGING_INTERVAL_MS:
+        raise ValueError(f"Unexpected ControlBBFastLoggingInterval value: {enum!r}")
+    return _FAST_LOGGING_INTERVAL_MS[enum] / 1000.0
+
+
+def _set_fast_logging_interval(host, enum_value):
+    """Configure the device's broadband fast-logging interval from an enum index (0-10)."""
+    if enum_value not in _FAST_LOGGING_INTERVAL_MS:
+        raise ValueError(f"Invalid ControlBBFastLoggingInterval enum: {enum_value!r}, must be one of {sorted(_FAST_LOGGING_INTERVAL_MS)}")
+    response = https_requests.put(host, "/WebXi/Applications/SLM/Setup/ControlBBFastLoggingInterval", json=enum_value)
+    response.raise_for_status()
+
+
+def _get_slm_utc_offset_seconds(host):
+    """Read the SLM's own configured time zone offset from UTC, in seconds.
+    The device reports it as a string like 'GMT+02:00'."""
+    response = https_requests.get(host, "/WebXi/Applications/SLM/Outputs/TimeZone")
+    response.raise_for_status()
+    value = str(response.json()).strip()
+    match = re.search(r"([+-])(\d{2}):?(\d{2})", value)
+    if not match:
+        raise ValueError(f"Unexpected TimeZone value: {value!r}")
+    sign, hours, minutes = match.groups()
+    offset = int(hours) * 3600 + int(minutes) * 60
+    return -offset if sign == "-" else offset
+
+
+class _TimeStamps:
+    """Tracks a stream's StartTime plus a rolling ElapsedTime buffer to derive a
+    wall-clock timestamp for each incoming data sample."""
+
+    def __init__(self, buffer_size=101, utc_offset_seconds=None):
+        self._start_time = None
+        self._time_buffer = np.zeros(buffer_size)
+        self._utc_offset_seconds = utc_offset_seconds
+
+    @property
+    def StartTime(self):
+        return self._start_time
+
+    @StartTime.setter
+    def StartTime(self, value):
+        if self._start_time is None:
+            # Prefer the SLM's own UTC offset; fall back to the local PC clock's
+            # offset (accounts for DST, unlike time.timezone) if none was given.
+            offset = (
+                self._utc_offset_seconds if self._utc_offset_seconds is not None
+                else datetime.now().astimezone().utcoffset().total_seconds()
+            )
+            self._start_time = value + offset
+
+    @property
+    def lastTime(self):
+        return datetime.utcfromtimestamp(self._time_buffer[-1]).strftime("%H:%M:%S")
+
+    def move(self, new_value):
+        new_value = new_value + self.StartTime
+        self._time_buffer = np.append(self._time_buffer[1:], new_value)
+        return self.lastTime
+
+def start_all_synced(streams):
+    """For handlers constructed with multi_device=True: open each device's stream/websocket,
+    then trigger start_pause_measurement on all of them at (nearly) the same instant."""
+    for s in streams:
+        s.uri = stream.setup_stream(s.host, s.stream_ids, s.streamName)
+        threading.Thread(target=s.startStream, daemon=True).start()
+
+    barrier = threading.Barrier(len(streams))
+
+    def _start_one(s):
+        barrier.wait()
+        https_requests.put(s.host, "/WebXi/Applications/SLM?Action=StartPause")
+
+    start_threads = [threading.Thread(target=_start_one, args=(s,)) for s in streams]
+    for t in start_threads:
+        t.start()
+    for t in start_threads:
+        t.join()
+
+
+def stop_all(streams):
+    """Stop local websocket loops, synchronize measurement stops, then remove streams."""
+    for s in streams:
+        s.request_stop()
+
+    barrier = threading.Barrier(len(streams))
+
+    def _stop_one(s):
+        barrier.wait()
+        meas.stop_measurement(s.host)
+
+    stop_threads = [threading.Thread(target=_stop_one, args=(s,)) for s in streams]
+    for t in stop_threads:
+        t.start()
+    for t in stop_threads:
+        t.join()
+
+    for s in streams:
+        if s.data_handler is not None and hasattr(s.data_handler, "close"):
+            s.data_handler.close()
+        stream.delete_stream(s.host, s.streamName)
+
+
+class WebXiStreamHandler(stream.StreamHandler):
+    """Configurable WebXi stream handler.
+
+    mode= is the preferred way to pick the stream type. Valid values are
+    "leq", "cpb", "multi", "flac", "mp3", "fast_logging", and
+    "screen_record". Legacy Boolean mode flags remain supported for backwards
+    compatibility, but only one mode can be selected.
+
+    - mode="leq" (or no mode): single Leq sequence (e.g. LAeq) given by `sequenceID`,
+      printing the instantaneous value and a moving average over `leq_window_sec`.
+    - mode="cpb": CPB (constant percentage bandwidth) sequence looked up by the
+      first entry of `sequenceNames`.
+    - mode="multi": several sequences at once, given by `sequenceNames`
+      (default ["LAeq", "LCeq"]), each tracked with its own moving average
+      (`leq_window_sec`, `windowSize`).
+    - mode="flac": FLAC-encoded audio (`sequenceID`) decoded into DataBuffer.
+    - mode="mp3": mp3-encoded audio (`sequenceID`) decoded into DataBuffer.
+    - mode="fast_logging": broadband fast-logged Leq sequence (`sequenceID`), pretty-printed
+      with a per-sample timestamp. `fast_logging_interval` is the ControlBBFastLoggingInterval
+      enum index (0-10) to configure on the device before streaming; if omitted, the device's
+      current setting is read instead.
+    - mode="screen_record": streams the device's ScreenImage sequence, keeping the latest
+      received PNG in `self.image_bytes`.
+
+    time=True additionally subscribes the device's StartTime/ElapsedTime sequences and
+    prefixes each printed line (laeq/cpb/multi modes) with the resolved wall-clock time.
+    """
+
+    def __init__(self, host, sequenceID=None, sequenceNames=None,
+                 streamName="Stream", cpb=False, multi=False, flac=False, mp3=False, fast_logging=False,
+                 time=False, screen_record=False, multi_device=False, fast_logging_interval=None,
+                 saving=None, saving_path=None, mode=None):
+        super().__init__(streamName)
+        legacy_modes = {
+            "cpb": cpb,
+            "multi": multi,
+            "flac": flac,
+            "mp3": mp3,
+            "fast_logging": fast_logging,
+            "screen_record": screen_record,
+        }
+        selected_legacy_modes = [name for name, enabled in legacy_modes.items() if enabled]
+        valid_modes = {"leq", *legacy_modes}
+        if mode is not None and mode not in valid_modes:
+            raise ValueError(f"Invalid mode: {mode!r}, must be one of {sorted(valid_modes)}")
+        if len(selected_legacy_modes) > 1:
+            raise ValueError(f"Only one legacy mode flag can be enabled; got {', '.join(selected_legacy_modes)}")
+        if mode is not None and selected_legacy_modes and mode != selected_legacy_modes[0]:
+            raise ValueError(f"mode={mode!r} conflicts with {selected_legacy_modes[0]}=True")
+        self.mode = mode or (selected_legacy_modes[0] if selected_legacy_modes else "leq")
+        self.host = host
+        self.sequenceID = sequenceID
+        self.sequenceNames = sequenceNames
+        self.cpb = self.mode == "cpb"
+        self.multi = self.mode == "multi"
+        self.flac = self.mode == "flac"
+        self.mp3 = self.mode == "mp3"
+        self.multi_device = multi_device
+        self.fast_logging = self.mode == "fast_logging"
+        self.time = time
+        self.screen_record = self.mode == "screen_record"
+        self.image_bytes = None
+        self.fast_logging_interval = fast_logging_interval
+        self.max_input = 15.6263 / np.sqrt(2)
+        self._saving_handler = None
+        if saving is not None:
+            if saving.lower() not in _SAVING_HANDLERS:
+                raise ValueError(f"Invalid saving format: {saving!r}, must be one of {list(_SAVING_HANDLERS)}")
+            if saving_path is None:
+                saving_path = "stream_data"
+            self._saving_handler = _SAVING_HANDLERS[saving.lower()](saving_path)
+        self.data_handler = self._saving_handler
+        if self.mp3:
+            self.tmpFileSM = TmpfileStateMachine()
+        self.streamInit()
+
+    def setDataHandler(self, data_handler):
+        """Attach a DataHandler (see data_handler.py) before calling startStream().
+        Without one, WebXiStreamHandler stays silent and does nothing with decoded values.
+        If saving=... was set, data_handler is combined with the saving handler instead
+        of replacing it."""
+        if self._saving_handler is not None:
+            self.data_handler = MultiDataHandler(data_handler, self._saving_handler)
+        else:
+            self.data_handler = data_handler
+
+    def get_calibration_factor(self):
+        # Calculate calibration factor from the microphone sensitivity
+        response = https_requests.get(self.host, "/WebXi/Applications/SLM/Outputs/Sensitivity")
+        assert response.status_code == 200
+        mic_sens = float(response.text)  # V/Pa
+        max_lvl = 20 * np.log10((self.max_input / mic_sens) / 20e-6)  # dB SPL re 20 uPa
+        self.calibrationFactor = (20e-6 * 10 ** (max_lvl / 20)) / (2 ** 23 - 1) * np.sqrt(2)
+
+    def streamInit(self):
+        if self.mp3 or self.flac:
+            quality_setting = "AudioRecordingListenQuality" if self.mp3 else "AudioRecordingAnalysisQuality"
+            response = https_requests.put(self.host, f"/WebXi/Applications/SLM/setup/{quality_setting}", json=1)
+            assert response.status_code == 200
+            time.sleep(3) # gives the slm time to actually enable audioRecording
+            self.get_calibration_factor()
+            self.ID, self.sequence = seq.get_sequence(self.host, self.sequenceID)
+        elif self.cpb:
+            name = self.sequenceNames[0] if self.sequenceNames else "CPBLAeq"
+            self.ID, self.sequence = seq.get_sequence(self.host, seq.getSequenceID(self.host, name))
+            self.CPB_values = np.zeros(self.sequence["VectorLength"])
+        elif self.multi:
+            self.IDs, self.sequences = [], []
+            for name in (self.sequenceNames or ["LAeq", "LCeq"]):
+                ID, sequence = seq.get_sequence(self.host, seq.getSequenceID(self.host, name))
+                self.IDs.append(ID)
+                self.sequences.append(sequence)
+            self.ID = self.IDs
+        elif self.fast_logging:
+            self.ID, self.sequence = seq.get_sequence(self.host, self.sequenceID)
+            if self.fast_logging_interval is not None:
+                _set_fast_logging_interval(self.host, self.fast_logging_interval)
+                self.fast_logging_interval_s = _FAST_LOGGING_INTERVAL_MS[self.fast_logging_interval] / 1000.0
+            else:
+                self.fast_logging_interval_s = _get_fast_logging_interval_s(self.host)
+            print("=" * 60)
+            print(f"  Streaming: {self.sequence.get('Name', 'FastLAeq')}")
+            print(f"  Sequence:  {self.sequenceID}")
+            print(f"  Weighting: {self.sequence.get('AcousticalWeighting', 'A')}")
+            print(f"  Unit:      {self.sequence.get('Unit', 'dB re 20uPa')}")
+            print(f"  Interval:  {self.fast_logging_interval_s * 1000:.0f} ms/sample")
+            print("=" * 60)
+        elif self.screen_record:
+            self.ID, self.sequence = seq.get_sequence(self.host, seq.getSequenceID(self.host, "ScreenImage"))
+        else:
+            self.ID, self.sequence = seq.get_sequence(self.host, self.sequenceID)
+            self.data_type = self.sequence["DataType"]
+
+        stream_ids = list(self.ID) if isinstance(self.ID, list) else [self.ID]
+        self.stream_ids = stream_ids  # saved for start_all_synced() when multi_device=True
+        if self.multi_device:
+            return
+
+        if self.time:
+            utc_offset_seconds = _get_slm_utc_offset_seconds(self.host)
+            self._time_stamps = _TimeStamps(utc_offset_seconds=utc_offset_seconds)
+            start_id, _ = seq.get_sequence(self.host, seq.getSequenceID(self.host, "StartTime"))
+            elapsed_id, _ = seq.get_sequence(self.host, seq.getSequenceID(self.host, "ElapsedTime"))
+            self._time_ids = {"StartTime": start_id, "ElapsedTime": elapsed_id}
+            stream_ids += [start_id, elapsed_id]
+        self.uri = stream.setup_stream(self.host, stream_ids, self.streamName)
+        meas.start_pause_measurement(self.host, True)
+
+    def msg_func(self, message):
+        if self.time:
+            self._handle_time_blocks(message)
+        if self.mp3 or self.flac:
+            self._msg_func_audio(message)
+        elif self.cpb:
+            self._msg_func_cpb(message)
+        elif self.multi:
+            self._msg_func_multi(message)
+        elif self.fast_logging:
+            self._msg_func_fast_logging(message)
+        elif self.screen_record:
+            self._msg_func_screen_record(message)
+        else:
+            self._msg_func_laeq(message)
+
+    def _handle_time_blocks(self, message):
+        package = webxi_stream.WebxiStream.from_bytes(message)
+        if package.header.message_type != webxi_stream.WebxiStream.Header.EMessageType.e_sequence_data:
+            return
+        for block in package.content.sequence_blocks:
+            if block.sequence_id == self._time_ids["StartTime"]:
+                self._time_stamps.StartTime = stream.data_type_conv("BKTimeSpan", block.values, None)
+            elif block.sequence_id == self._time_ids["ElapsedTime"] and self._time_stamps.StartTime is not None:
+                self._time_stamps.move(stream.data_type_conv("BKTimeSpan", block.values, None))
+
+    def _time_prefix(self):
+        return f"{self._time_stamps.lastTime}  " if self.time else ""
+
+    def _handle_data(self, **data):
+        """Deliver a stream record with the host it originated from."""
+        if self.data_handler is not None:
+            self.data_handler.handle(host=self.host, **data)
+
+    def _msg_func_laeq(self, message):
+        package = webxi_stream.WebxiStream.from_bytes(message)
+        if package.header.message_type == webxi_stream.WebxiStream.Header.EMessageType.e_sequence_data:
+            value = package.content.sequence_blocks[0].values
+            leq_value = stream.data_type_conv(self.data_type, value, None) / 100
+            self._handle_data(timestamp=self._time_prefix(), value=leq_value)
+
+    def _msg_func_cpb(self, message):
+        package = webxi_stream.WebxiStream.from_bytes(message)
+        if package.header.message_type == webxi_stream.WebxiStream.Header.EMessageType.e_sequence_data:
+            value = package.content.sequence_blocks[0].values
+            self.CPB_values = np.array(stream.data_type_conv(self.sequence["DataType"], value, self.sequence["VectorLength"])) / 100
+            self._handle_data(timestamp=self._time_prefix(), value=self.CPB_values)
+
+    def calcFreqBands(self):
+        """Only meaningful when cpb=True."""
+        octaveRange = np.arange(12, 44, 3) if self.sequence["VectorLength"] == 11 else np.arange(11, 44)
+        bb = lambda x: np.round(x * 2) / 2 if x < 70 else bb(x / 10) * 10
+        octaves = 10 ** (0.1 * octaveRange)
+        return [bb(i) for i in octaves]
+
+    def _msg_func_multi(self, message):
+        package = webxi_stream.WebxiStream.from_bytes(message)
+        if package.header.message_type == webxi_stream.WebxiStream.Header.EMessageType.e_sequence_data:
+            for ID, sequence in zip(self.IDs, self.sequences):
+                for data in package.content.sequence_blocks:
+                    if data.sequence_id == ID:
+                        value = stream.data_type_conv(sequence["DataType"], data.values, None)
+                        value = (np.array(value) if isinstance(value, list) else value) / 100
+                        seqName = sequence["Name"]
+                        self._handle_data(timestamp=self._time_prefix(), name=seqName, value=value)
+
+    def _msg_func_fast_logging(self, message):
+        package = webxi_stream.WebxiStream.from_bytes(message)
+        if package.header.message_type != webxi_stream.WebxiStream.Header.EMessageType.e_sequence_data:
+            return
+
+        # The header time is the time of the first sample; fall back to wall clock if
+        # it is not in the expected Q32.32 format/epoch.
+        start = _webxi_time_to_epoch(package.header.time)
+        if abs(start - time.time()) > 86400:
+            start = time.time()
+
+        # A 1-second package batches many fast-logged samples.
+        samples = []
+        for block in package.content.sequence_blocks:
+            if block.sequence_id != self.ID:
+                continue
+            vector_length = self.sequence.get("VectorLength")
+            if vector_length is None and self.sequence["DataType"] == "Int16":
+                vector_length = len(block.values) // 2
+            raw = stream.data_type_conv(self.sequence["DataType"], block.values, vector_length if vector_length and vector_length > 1 else None)
+            scale = self.sequence.get("Scale", 0.01)
+            if isinstance(raw, list):
+                samples.extend(v * scale for v in raw)
+            else:
+                samples.append(raw * scale)
+
+        if not samples:
+            return
+
+        name = self.sequence.get("Name", "FastLAeq")
+        local = self.sequence.get("LocalName", "LAeq")
+        unit = self.sequence.get("Unit", "dB re 20uPa")
+        for n, v in enumerate(samples):
+            self._handle_data(timestamp=self._time_prefix(), name=name, local=local, value=v, unit=unit)
+
+    def _msg_func_screen_record(self, message):
+        package = webxi_stream.WebxiStream.from_bytes(message)
+        if package.header.message_type != webxi_stream.WebxiStream.Header.EMessageType.e_sequence_data:
+            return
+        for block in package.content.sequence_blocks:
+            if block.sequence_id == self.ID and block.values:
+                # Keep only the most recently received image; older ones are discarded
+                self.image_bytes = bytes(block.values)
+
+    def _msg_func_audio(self, message):
+        start = timer()
+        package = webxi_stream.WebxiStream.from_bytes(message)
+        if package.header.message_type == webxi_stream.WebxiStream.Header.EMessageType.e_sequence_data:
+            block = package.content.sequence_blocks[0]
+            if self.mp3:
+                data = self.tmpFileSM.runStateMachine(block.frame)
+                mp3DecodedData = miniaudio.mp3_read_s16(data)
+                samples = mp3DecodedData.samples[-mp3DecodedData.num_frames:]
+                decoded = (np.asarray(samples, dtype=np.int32) << 8) * self.calibrationFactor
+            else:
+                decoded = flac2samples.decode(block, self.calibrationFactor)
+            DataBuffer.append(decoded)
+            self._handle_data(samples=decoded)
+            total = timer() - start
+            if 0.0625 < total:
+                print(f"TotalTime: {total}")
+
+    def stopStream(self):
+        if self.data_handler is not None and hasattr(self.data_handler, "close"):
+            self.data_handler.close()
+        super().stopStream()

slm_api/helpers/tmpFileStateMachine.py

@@ -0,0 +1,93 @@
+import enum
+import tempfile
+
+# a dual bufferfile stores the data which is used for decoding the mp3 stream.
+class TmpfileStateMachine:
+    # tmpfiles are used to store the mp3 data which are used for decoding.
+    class State(enum.Enum):
+        init = 0
+        file1 = 1
+        preFile2 = 2
+        file2 = 3
+        preFile1 = 4
+
+    def __init__(self):
+        self.tempFile1 = None
+        self.tempFile2 = None
+        self.state = self.State.init
+
+    def runStateMachine(self, mp3Data):
+        readData = None
+        match self.state:
+            case self.State.init:
+                readData = self.on_init(mp3Data)
+            case self.State.file1:
+                readData = self.on_file1(mp3Data)
+            case self.State.preFile2:
+                readData = self.on_preFile2(mp3Data)
+            case self.State.file2:
+                readData = self.on_file2(mp3Data)
+            case self.State.preFile1:
+                readData = self.on_preFile1(mp3Data)
+        return readData
+
+    def on_init(self, mp3Data):
+        if not self.tempFile1:
+            self.tempFile1 = tempfile.SpooledTemporaryFile(max_size=1 * 1024 * 1024, mode='w+b', suffix=".mp3",
+                                                           prefix="tmp1")
+        self.tempFile1.write(bytes(mp3Data))
+        self.tempFile1.seek(0)
+        dataFromFile = self.tempFile1.read()
+        if (len(dataFromFile) > 20 * 1024):
+            self.state = self.State.preFile2
+        return dataFromFile
+
+    def on_file1(self, mp3Data):
+        if self.tempFile2:
+            self.tempFile2.close()
+            self.tempFile2 = None
+        self.tempFile1.seek(0)
+        dataFromFile = self.tempFile1.read()
+        self.tempFile1.write(bytes(mp3Data))
+        if (len(dataFromFile) > 20 * 1024):
+            self.state = self.State.preFile2
+        return dataFromFile
+
+    def on_preFile2(self, mp3Data):
+        if not self.tempFile2:
+            self.tempFile2 = tempfile.SpooledTemporaryFile(max_size=1 * 1024 * 1024, mode='w+b', suffix=".mp3",
+                                                           prefix="tmp2")
+        self.tempFile1.seek(0)
+        self.tempFile2.seek(0)
+        dataFromFile = self.tempFile1.read()
+        tmp = self.tempFile2.read()
+        self.tempFile1.write(bytes(mp3Data))
+        self.tempFile2.write(bytes(mp3Data))
+        if (len(dataFromFile) > 30 * 1024):
+            self.state = self.State.file2
+        return dataFromFile
+
+    def on_file2(self, mp3Data):
+        if self.tempFile1:
+            self.tempFile1.close()
+            self.tempFile1 = None
+        self.tempFile2.seek(0)
+        dataFromFile = self.tempFile2.read()
+        self.tempFile2.write(bytes(mp3Data))
+        if (len(dataFromFile) > 20 * 1024):
+            self.state = self.State.preFile1
+        return dataFromFile
+
+    def on_preFile1(self, mp3Data):
+        if not self.tempFile1:
+            self.tempFile1 = tempfile.SpooledTemporaryFile(max_size=1 * 1024 * 1024, mode='w+b', suffix=".mp3",
+                                                           prefix="tmp1")
+        self.tempFile1.seek(0)
+        self.tempFile2.seek(0)
+        dataFromFile = self.tempFile2.read()
+        tmp = self.tempFile1.read()
+        self.tempFile1.write(bytes(mp3Data))
+        self.tempFile2.write(bytes(mp3Data))
+        if (len(dataFromFile) > 30 * 1024):
+            self.state = self.State.file1
+        return dataFromFile