155 lines
4.7 KiB
Python
155 lines
4.7 KiB
Python
"""Utilities for Wyoming satellite."""
|
|
import array
|
|
import asyncio
|
|
import logging
|
|
import wave
|
|
from pathlib import Path
|
|
from typing import Iterable, Iterator, List, Optional, Union
|
|
|
|
from wyoming.audio import AudioChunk, AudioStart, AudioStop
|
|
from wyoming.event import Event
|
|
|
|
_LOGGER = logging.getLogger()
|
|
|
|
|
|
class AudioBuffer:
|
|
"""Fixed-sized audio buffer with variable internal length."""
|
|
|
|
def __init__(self, maxlen: int) -> None:
|
|
"""Initialize buffer."""
|
|
self._buffer = bytearray(maxlen)
|
|
self._length = 0
|
|
|
|
@property
|
|
def length(self) -> int:
|
|
"""Get number of bytes currently in the buffer."""
|
|
return self._length
|
|
|
|
def clear(self) -> None:
|
|
"""Clear the buffer."""
|
|
self._length = 0
|
|
|
|
def append(self, data: bytes) -> None:
|
|
"""Append bytes to the buffer, increasing the internal length."""
|
|
data_len = len(data)
|
|
if (self._length + data_len) > len(self._buffer):
|
|
raise ValueError("Length cannot be greater than buffer size")
|
|
|
|
self._buffer[self._length : self._length + data_len] = data
|
|
self._length += data_len
|
|
|
|
def to_bytes(self) -> bytes:
|
|
"""Convert written portion of buffer to bytes."""
|
|
return bytes(self._buffer[: self._length])
|
|
|
|
def __len__(self) -> int:
|
|
"""Get the number of bytes currently in the buffer."""
|
|
return self._length
|
|
|
|
def __bool__(self) -> bool:
|
|
"""Return True if there are bytes in the buffer."""
|
|
return self._length > 0
|
|
|
|
|
|
def multiply_volume(chunk: bytes, volume_multiplier: float) -> bytes:
|
|
"""Multiplies 16-bit PCM samples by a constant."""
|
|
|
|
def _clamp(val: float) -> float:
|
|
"""Clamp to signed 16-bit."""
|
|
return max(-32768, min(32767, val))
|
|
|
|
return array.array(
|
|
"h",
|
|
(int(_clamp(value * volume_multiplier)) for value in array.array("h", chunk)),
|
|
).tobytes()
|
|
|
|
|
|
def chunk_samples(
|
|
samples: bytes,
|
|
bytes_per_chunk: int,
|
|
leftover_chunk_buffer: AudioBuffer,
|
|
) -> Iterable[bytes]:
|
|
"""Yield fixed-sized chunks from samples, keeping leftover bytes from previous call(s)."""
|
|
|
|
if (len(leftover_chunk_buffer) + len(samples)) < bytes_per_chunk:
|
|
# Extend leftover chunk, but not enough samples to complete it
|
|
leftover_chunk_buffer.append(samples)
|
|
return
|
|
|
|
next_chunk_idx = 0
|
|
|
|
if leftover_chunk_buffer:
|
|
# Add to leftover chunk from previous call(s).
|
|
bytes_to_copy = bytes_per_chunk - len(leftover_chunk_buffer)
|
|
leftover_chunk_buffer.append(samples[:bytes_to_copy])
|
|
next_chunk_idx = bytes_to_copy
|
|
|
|
# Process full chunk in buffer
|
|
yield leftover_chunk_buffer.to_bytes()
|
|
leftover_chunk_buffer.clear()
|
|
|
|
while next_chunk_idx < len(samples) - bytes_per_chunk + 1:
|
|
# Process full chunk
|
|
yield samples[next_chunk_idx : next_chunk_idx + bytes_per_chunk]
|
|
next_chunk_idx += bytes_per_chunk
|
|
|
|
# Capture leftover chunks
|
|
if rest_samples := samples[next_chunk_idx:]:
|
|
leftover_chunk_buffer.append(rest_samples)
|
|
|
|
|
|
async def run_event_command(
|
|
command: Optional[List[str]], command_input: Optional[str] = None
|
|
) -> None:
|
|
"""Run a custom event command with optional input."""
|
|
if not command:
|
|
return
|
|
|
|
_LOGGER.debug("Running %s", command)
|
|
program, *program_args = command
|
|
proc = await asyncio.create_subprocess_exec(
|
|
program, *program_args, stdin=asyncio.subprocess.PIPE
|
|
)
|
|
assert proc.stdin is not None
|
|
|
|
if command_input:
|
|
await proc.communicate(input=command_input.encode("utf-8"))
|
|
else:
|
|
proc.stdin.close()
|
|
await proc.wait()
|
|
|
|
|
|
def wav_to_events(
|
|
wav_path: Union[str, Path],
|
|
samples_per_chunk: int = 1024,
|
|
volume_multiplier: float = 1.0,
|
|
) -> Iterator[Event]:
|
|
"""Load WAV audio for playback on an event (wake/done)."""
|
|
with wave.open(str(wav_path), "rb") as wav_file:
|
|
rate = wav_file.getframerate()
|
|
width = wav_file.getsampwidth()
|
|
channels = wav_file.getnchannels()
|
|
|
|
timestamp = 0
|
|
yield AudioStart(
|
|
rate=rate, width=width, channels=channels, timestamp=timestamp
|
|
).event()
|
|
|
|
audio_bytes = wav_file.readframes(samples_per_chunk)
|
|
while audio_bytes:
|
|
if volume_multiplier != 1.0:
|
|
audio_bytes = multiply_volume(audio_bytes, volume_multiplier)
|
|
|
|
chunk = AudioChunk(
|
|
rate=rate,
|
|
width=width,
|
|
channels=channels,
|
|
audio=audio_bytes,
|
|
timestamp=timestamp,
|
|
)
|
|
yield chunk.event()
|
|
timestamp += int(chunk.seconds * 1000)
|
|
audio_bytes = wav_file.readframes(samples_per_chunk)
|
|
|
|
yield AudioStop(timestamp=timestamp).event()
|