infinicode 2.8.76 → 2.8.78

package/packages/robopark/scheduler/robot_supervisor.py

@@ -458,7 +458,7 @@ SPEAKER_TEST_INPUT_DEVICE = None
 SPEAKER_TEST_PEAK_DB_THRESHOLD = -30.0
 
 
-def _resolve_audio_device(pa, selected: str, kind: str) -> Optional[int]:
+def _resolve_audio_device(pa, selected: str, kind: str) -> Optional[int]:
     """Resolve a free-form device name/index to a PyAudio device index.
 
     kind is "input" or "output". None / "default" picks the WASAPI
@@ -468,14 +468,14 @@ def _resolve_audio_device(pa, selected: str, kind: str) -> Optional[int]:
     result is recorded so the operator can see it."""
     if selected is None:
         selected = "default"
-    s = str(selected).strip()
-    if s == "" or s.lower() == "default":
-        try:
-            wasapi = pa.get_host_api_info_by_type(pyaudio.paWASAPI)
-            key = "defaultInputDevice" if kind == "input" else "defaultOutputDevice"
-            idx = wasapi.get(key)
-            if idx is not None and idx >= 0:
-                return idx
+    s = str(selected).strip()
+    if s == "" or s.lower() == "default":
+        try:
+            info = (pa.get_default_input_device_info() if kind == "input"
+                    else pa.get_default_output_device_info())
+            idx = info.get("index")
+            if idx is not None and idx >= 0:
+                return int(idx)
         except Exception:
             pass
         return None
@@ -491,9 +491,93 @@ def _resolve_audio_device(pa, selected: str, kind: str) -> Optional[int]:
             continue
         if needle in str(info.get("name", "")).lower():
             return i
-    return None
-
-
+    return None
+
+
+def _audio_rate_candidates(info: dict, requested_rate: int) -> list[int]:
+    """Return practical PCM rates with the device native rate first."""
+    rates = []
+    for value in (
+        info.get("defaultSampleRate"),
+        requested_rate,
+        48000,
+        44100,
+        32000,
+        24000,
+        16000,
+    ):
+        try:
+            rate = int(round(float(value)))
+        except (TypeError, ValueError):
+            continue
+        if rate > 0 and rate not in rates:
+            rates.append(rate)
+    return rates
+
+
+def _resample_pcm16_mono(raw: bytes, source_rate: int, target_rate: int) -> bytes:
+    """Linearly resample little-endian mono PCM16 without optional DSP deps."""
+    if source_rate == target_rate or not raw:
+        return raw
+    source_count = len(raw) // 2
+    target_count = max(1, int(round(source_count * target_rate / source_rate)))
+    source = struct.unpack(f"<{source_count}h", raw[:source_count * 2])
+    if source_count == 1:
+        return struct.pack("<h", source[0]) * target_count
+    scale = (source_count - 1) / max(1, target_count - 1)
+    result = bytearray(target_count * 2)
+    for index in range(target_count):
+        position = index * scale
+        left = int(position)
+        right = min(left + 1, source_count - 1)
+        fraction = position - left
+        value = int(round(source[left] + (source[right] - source[left]) * fraction))
+        struct.pack_into("<h", result, index * 2, value)
+    return bytes(result)
+
+
+def _open_pcm_stream(pa, pyaudio_module, kind: str, device_index: Optional[int],
+                     requested_rate: int):
+    """Open a PCM16 stream using the first format the device accepts."""
+    try:
+        if device_index is None:
+            info = (pa.get_default_output_device_info() if kind == "output"
+                    else pa.get_default_input_device_info())
+            device_index = int(info.get("index"))
+        else:
+            info = pa.get_device_info_by_index(device_index)
+    except Exception as exc:
+        raise OSError(f"selected {kind} device is unavailable: {exc}") from exc
+
+    channel_key = "maxOutputChannels" if kind == "output" else "maxInputChannels"
+    max_channels = int(info.get(channel_key, 0) or 0)
+    if max_channels < 1:
+        raise OSError(f"{info.get('name', device_index)} has no {kind} channels")
+    channels = [2, 1] if kind == "output" and max_channels >= 2 else [1]
+    errors = []
+    for rate in _audio_rate_candidates(info, requested_rate):
+        for channel_count in channels:
+            kwargs = {
+                "format": pyaudio_module.paInt16,
+                "channels": channel_count,
+                "rate": rate,
+                kind: True,
+                f"{kind}_device_index": device_index,
+            }
+            if kind == "input":
+                kwargs["frames_per_buffer"] = 1024
+            try:
+                stream = pa.open(**kwargs)
+                return stream, rate, channel_count, info
+            except Exception as exc:
+                errors.append(f"{rate}Hz/{channel_count}ch: {exc}")
+    attempts = "; ".join(errors[-4:])
+    raise OSError(
+        f"{info.get('name', device_index)} supports no usable PCM16 {kind} format"
+        + (f" ({attempts})" if attempts else "")
+    )
+
+
 def _speaker_roundtrip_test(params: dict) -> dict:
     """Play a test tone + record the mic simultaneously; return metrics.
 
@@ -508,9 +592,11 @@ def _speaker_roundtrip_test(params: dict) -> dict:
     dur = float(params.get("duration", SPEAKER_TEST_DURATION_S))
     amp = float(params.get("amplitude", SPEAKER_TEST_AMPLITUDE))
     threshold_db = float(params.get("threshold_db", SPEAKER_TEST_PEAK_DB_THRESHOLD))
-    out_name = params.get("output", os.environ.get("ROBOPARK_AUDIO_OUTPUT") or SPEAKER_TEST_OUTPUT_DEVICE)
-    in_name = params.get("input", os.environ.get("ROBOPARK_AUDIO_INPUT") or SPEAKER_TEST_INPUT_DEVICE)
-    sample_rate = int(params.get("sample_rate", SPEAKER_TEST_SAMPLE_RATE))
+    # RoboVision inventory indices belong to sounddevice and may not match
+    # PyAudio's index space. Prefer the reported hardware name for lookup.
+    out_name = params.get("output_name") or params.get("output", os.environ.get("ROBOPARK_AUDIO_OUTPUT") or SPEAKER_TEST_OUTPUT_DEVICE)
+    in_name = params.get("input_name") or params.get("input", os.environ.get("ROBOPARK_AUDIO_INPUT") or SPEAKER_TEST_INPUT_DEVICE)
+    source_rate = int(params.get("sample_rate", SPEAKER_TEST_SAMPLE_RATE))
     if mode not in ("tone", "tts"):
         return {"ok": False, "error": f"unsupported speaker test mode: {mode}"}
     if mode == "tone" and not (50.0 <= freq <= 8000.0):
@@ -527,8 +613,10 @@ def _speaker_roundtrip_test(params: dict) -> dict:
             return {"ok": False, "error": f"invalid cached TTS audio: {e}"}
         if len(mono_pcm) < 480 or len(mono_pcm) % 2:
             return {"ok": False, "error": "cached TTS audio is empty or malformed"}
-        dur = len(mono_pcm) / 2 / sample_rate
-    n_samples = int(sample_rate * dur)
+        dur = len(mono_pcm) / 2 / source_rate
+        if dur > 10.0:
+            return {"ok": False, "error": "cached TTS audio exceeds the 10 second test limit"}
+    n_samples = int(source_rate * dur)
     if n_samples < 480:
         return {"ok": False, "error": "duration too short"}
 
@@ -542,44 +630,49 @@ def _speaker_roundtrip_test(params: dict) -> dict:
     out_label = _dev_name(out_idx)
     in_label = _dev_name(in_idx)
 
-    if mono_pcm is not None:
-        frames = bytearray()
-        for pos in range(0, len(mono_pcm), 2):
-            sample = mono_pcm[pos:pos + 2]
-            frames.extend(sample + sample)
-        raw = bytes(frames)
-    else:
-        frames = bytearray()
-        peak_value = int(32767 * amp)
-        for n in range(n_samples):
-            env = min(1.0, n / (sample_rate * 0.004), (n_samples - n) / (sample_rate * 0.008))
-            value = int(peak_value * env * math.sin(2 * math.pi * freq * n / sample_rate))
-            frames.extend(struct.pack("<hh", value, value))
-        raw = bytes(frames)
-
-    recorded_peak = 0
-    recorded_rms = 0.0
-    err = None
-    t0 = time.monotonic()
-    try:
-        out_stream = pa.open(
-            format=pyaudio.paInt16,
-            channels=2,
-            rate=sample_rate,
-            output=True,
-            output_device_index=out_idx,
-        )
-        chunk = 1024
-        in_stream = pa.open(
-            format=pyaudio.paInt16,
-            channels=1,
-            rate=sample_rate,
-            input=True,
-            input_device_index=in_idx,
-            frames_per_buffer=chunk,
-        )
-        in_stream.start_stream()
-        chunk_bytes = chunk * 2 * 2
+    recorded_peak = 0
+    recorded_rms = 0.0
+    err = None
+    output_rate = None
+    input_rate = None
+    output_channels = None
+    input_channels = None
+    t0 = time.monotonic()
+    out_stream = None
+    in_stream = None
+    try:
+        out_stream, output_rate, output_channels, out_info = _open_pcm_stream(
+            pa, pyaudio, "output", out_idx, source_rate
+        )
+        in_stream, input_rate, input_channels, in_info = _open_pcm_stream(
+            pa, pyaudio, "input", in_idx, source_rate
+        )
+        out_label = str(out_info.get("name", out_label))
+        in_label = str(in_info.get("name", in_label))
+
+        if mono_pcm is not None:
+            output_mono = _resample_pcm16_mono(mono_pcm, source_rate, output_rate)
+        else:
+            output_samples = int(output_rate * dur)
+            frames = bytearray(output_samples * 2)
+            peak_value = int(32767 * amp)
+            for n in range(output_samples):
+                env = min(1.0, n / (output_rate * 0.004),
+                          (output_samples - n) / (output_rate * 0.008))
+                value = int(peak_value * env * math.sin(2 * math.pi * freq * n / output_rate))
+                struct.pack_into("<h", frames, n * 2, value)
+            output_mono = bytes(frames)
+        if output_channels == 2:
+            frames = bytearray(len(output_mono) * 2)
+            for pos in range(0, len(output_mono), 2):
+                frames[pos * 2:pos * 2 + 4] = output_mono[pos:pos + 2] * 2
+            raw = bytes(frames)
+        else:
+            raw = output_mono
+
+        chunk = 1024
+        in_stream.start_stream()
+        chunk_bytes = chunk * 2 * output_channels
         pos = 0
         peak_acc = 0
         rms_acc = 0.0
@@ -601,9 +694,10 @@ def _speaker_roundtrip_test(params: dict) -> dict:
                         n_samp += 1
             except Exception:
                 pass
-        out_stream.stop_stream(); out_stream.close()
-        try:
-            tail = in_stream.read(n_samples, exception_on_overflow=False)
+        out_stream.stop_stream(); out_stream.close(); out_stream = None
+        try:
+            tail_frames = min(int(input_rate * 0.35), max(0, in_stream.get_read_available()))
+            tail = in_stream.read(tail_frames, exception_on_overflow=False) if tail_frames else b""
             for s in range(0, len(tail) - 1, 2):
                 v = int.from_bytes(tail[s:s+2], "little", signed=True)
                 a = abs(v)
@@ -612,13 +706,19 @@ def _speaker_roundtrip_test(params: dict) -> dict:
                 n_samp += 1
         except Exception:
             pass
-        in_stream.stop_stream(); in_stream.close()
+        in_stream.stop_stream(); in_stream.close(); in_stream = None
         recorded_peak = peak_acc
         recorded_rms = (rms_acc / max(1, n_samp)) ** 0.5
-    except Exception as e:
-        err = f"{type(e).__name__}: {e}"
-    finally:
-        try: pa.terminate()
+    except Exception as e:
+        err = f"{type(e).__name__}: {e}"
+    finally:
+        for stream in (out_stream, in_stream):
+            if stream is not None:
+                try: stream.stop_stream()
+                except Exception: pass
+                try: stream.close()
+                except Exception: pass
+        try: pa.terminate()
         except Exception: pass
     duration_ms = int((time.monotonic() - t0) * 1000)
     if err:
@@ -645,7 +745,11 @@ def _speaker_roundtrip_test(params: dict) -> dict:
         "frequency": freq,
         "duration": dur,
         "duration_ms": duration_ms,
-        "sample_rate": sample_rate,
+        "sample_rate": source_rate,
+        "output_sample_rate": output_rate,
+        "input_sample_rate": input_rate,
+        "output_channels": output_channels,
+        "input_channels": input_channels,
         "amplitude": amp,
         "output_device": out_label,
         "input_device": in_label,