Logan Cusano
b0a8ed2a5a
Measured six recordings off a live P25 node and found two independent defects causing lost audio at the end of calls: - stop_recording() sliced the ring buffer immediately, so if the MP3 muxer had not yet delivered the tail the file was silently short. Now waits (bounded, 2s) until buffered audio covers the end epoch. - TGID-change closes used the new grant's epoch as the end with no pad at all, guaranteeing truncation on every split. Tail pad is now a setting, default raised 0.5s -> 1.0s. The ring buffer also capped maximum call length: a call longer than the buffer had its front silently clamped. The ring now serves the pre-roll only, with a per-call accumulator for the rest, bounded at 4.8MB. Clamping is loudly warned rather than silent. Uploads averaged 63% silence, which inflates STT cost and is a known Whisper hallucination trigger. Leading/trailing silence is now trimmed conservatively (-40dB, 0.25s guard, internal pauses untouched). started_at/ended_at still describe the call; new audio_* fields carry the trimmed audio bounds so playback can map back to wall clock. All-silence recordings are skipped and logged instead of uploaded. Also: log measured control-channel idle on idle-timeout closes so CALL_IDLE_TIMEOUT can be tuned from data, and quiet the httpx logger which emitted ~170k lines/day of poll noise. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
579 lines
23 KiB
Python
579 lines
23 KiB
Python
"""
|
||
Continuous PulseAudio capture: a ring buffer for PRE-ROLL, a per-call
|
||
accumulator for the call itself.
|
||
|
||
A persistent capture process runs for the lifetime of the node. Spawning FFmpeg
|
||
per call used to lose the first 1-2 s to process startup, which meant short
|
||
transmissions produced empty files, so capture never stops.
|
||
|
||
TWO BUFFERS, TWO JOBS — this split is load-bearing:
|
||
|
||
RING BUFFER holds the last RING_BUFFER_SECONDS of audio at all times. Its
|
||
only job is PRE-ROLL: however late we notice a grant, we can
|
||
still seek back to OP25's exact timestamp. It is sized for
|
||
detection latency, nothing else.
|
||
|
||
ACCUMULATOR opened by start_recording(), fed by every subsequent chunk, and
|
||
closed by stop_recording(). Call length is therefore bounded by
|
||
MAX_RECORDING_SECONDS alone — NOT by the ring buffer size. The
|
||
old design sliced the finished call back out of the ring buffer,
|
||
which silently clamped the front of any call longer than
|
||
RING_BUFFER_SECONDS.
|
||
|
||
Why not Icecast: it lags ~1 s at connect and drifts progressively to 100 s+, so
|
||
slice timestamps and audio content diverge without bound. Icecast stays in the
|
||
stack for frontend/mobile live listening; it is not an accuracy path.
|
||
|
||
CLOCK DOMAIN: chunks are stamped with time.time(), the host wall clock. OP25's
|
||
call_log timestamps are time.time() from inside the op25 container. All client
|
||
containers run network_mode: host and share the host kernel clock, so the two are
|
||
the same clock and the pre-roll arithmetic below is a direct subtraction with no
|
||
offset mapping. (A wall-clock STEP — e.g. a large NTP correction — would corrupt
|
||
at most the calls in flight at that instant; the buffer self-heals within
|
||
RING_BUFFER_SECONDS.)
|
||
"""
|
||
import asyncio
|
||
import time
|
||
from collections import deque
|
||
from dataclasses import dataclass, field
|
||
from datetime import datetime, timezone
|
||
from pathlib import Path
|
||
from typing import List, Optional, Tuple
|
||
|
||
import httpx
|
||
from app.config import settings
|
||
from app.internal import audio_trim, credentials, pulse
|
||
from app.internal.logger import logger
|
||
|
||
# Safety cap on a single recording; mirrors MAX_SEGMENT_SECONDS in metadata_watcher.
|
||
MAX_RECORDING_SECONDS = 600
|
||
|
||
# Audio included ahead of OP25's call_log timestamp. The grant is logged when the
|
||
# channel is granted, so the first syllable can land marginally before it.
|
||
#
|
||
# Kept small on purpose: measurement on a live node shows 1.71–2.45 s of real
|
||
# grant→speech delay on every call, so there is no clipping risk at the head and
|
||
# a larger pre-roll would only add dead air.
|
||
PRE_ROLL_SECONDS = 0.25
|
||
|
||
# Rolling history kept for PRE-ROLL ONLY. Budget for the worst realistic
|
||
# detection latency: 0.5 s poll interval + ~0.2 s http_server blocking floor +
|
||
# up to 3 s httpx timeout on a stalled poll + callback work ≈ 4 s from grant to
|
||
# start_recording(). 30 s is ~7x that margin, and at 16 kbps costs only ~60 KB of
|
||
# RAM. This value does NOT bound call length — the accumulator does.
|
||
RING_BUFFER_SECONDS = 30
|
||
|
||
# ~128 ms of audio per chunk at 16 kbps. Chunk size IS the timestamp resolution of
|
||
# the ring buffer, so it must stay well under PRE_ROLL_SECONDS — the old 4096-byte
|
||
# reads were ~2 s per chunk, which made sub-second slicing meaningless.
|
||
READ_CHUNK_BYTES = 256
|
||
|
||
# Encoder settings, matched on purpose to what Liquidsoap already pushes to
|
||
# Icecast — %mp3(bitrate=16, samplerate=22050, stereo=false) — so the C2 /upload
|
||
# endpoint keeps receiving exactly the kind of MP3 it has always received
|
||
# (multipart "audio/mpeg", stored to GCS as .mp3, then fed to Whisper).
|
||
# Change both of these together if you ever want higher-fidelity uploads.
|
||
MP3_BITRATE = "16k"
|
||
MP3_SAMPLE_RATE = "22050"
|
||
|
||
# Hard memory ceiling for one call's accumulator. 16 kbps is 2 KB/s, so 600 s of
|
||
# call is ~1.2 MB; 4x that is the ceiling, which both leaves room for encoder
|
||
# overshoot and guarantees a runaway call can never eat a Pi's RAM.
|
||
_MP3_BYTES_PER_SECOND = 16_000 // 8
|
||
MAX_RECORDING_BYTES = MAX_RECORDING_SECONDS * _MP3_BYTES_PER_SECOND * 4
|
||
|
||
# How long stop_recording() will wait for captured audio to actually reach the
|
||
# call's end timestamp. PulseAudio → FFmpeg → MP3 encoder → muxer → our pipe read
|
||
# is a pipeline with latency, so at the instant a call ends the newest buffered
|
||
# chunk is typically a few hundred ms OLDER than the end epoch. Slicing
|
||
# immediately therefore cuts the tail short — which costs the last word of the
|
||
# transmission, usually the disposition or the address. Bounded so a dead capture
|
||
# can never hang the upload path.
|
||
TAIL_WAIT_TIMEOUT_SECONDS = 2.0
|
||
TAIL_WAIT_POLL_SECONDS = 0.05
|
||
|
||
# Backoff bounds for restarting a dead capture process.
|
||
RESTART_BACKOFF_MIN = 1.0
|
||
RESTART_BACKOFF_MAX = 15.0
|
||
|
||
|
||
@dataclass
|
||
class _ActiveRecording:
|
||
"""Audio accumulating for the call currently being recorded."""
|
||
|
||
call_id: str
|
||
call_start: float # OP25 grant epoch
|
||
slice_start: float # call_start - PRE_ROLL_SECONDS
|
||
chunks: List[Tuple[float, bytes]] = field(default_factory=list)
|
||
total_bytes: int = 0
|
||
# Seconds of requested pre-roll that were not in the buffer at open time.
|
||
clamped_seconds: float = 0.0
|
||
# True once the byte ceiling was hit and audio started being dropped.
|
||
truncated_by_cap: bool = False
|
||
|
||
|
||
@dataclass
|
||
class Recording:
|
||
"""
|
||
A finished recording plus the timing metadata needed to map audio position
|
||
back to wall clock.
|
||
|
||
`started_at`/`ended_at` upstream keep meaning the CALL's bounds. These are
|
||
the AUDIO's bounds, which differ once silence is trimmed:
|
||
|
||
wall_clock_of(audio_offset_t) == audio_start_epoch + t
|
||
|
||
Bounds are accurate to ±one capture chunk (~128 ms).
|
||
"""
|
||
|
||
call_id: str
|
||
path: Optional[Path]
|
||
audio_start_epoch: float
|
||
audio_end_epoch: float
|
||
lead_trimmed: float = 0.0
|
||
tail_trimmed: float = 0.0
|
||
clamped_seconds: float = 0.0
|
||
all_silence: bool = False
|
||
|
||
|
||
class CallRecorder:
|
||
"""Continuous PulseAudio capture: ring buffer for pre-roll, accumulator per call."""
|
||
|
||
def __init__(self):
|
||
self._recordings_dir = Path(settings.recordings_path)
|
||
|
||
# Ring buffer: deque of (wall_clock_epoch_at_arrival, mp3_bytes).
|
||
# Pre-roll only — see the module docstring.
|
||
self._buffer: deque[Tuple[float, bytes]] = deque()
|
||
self._buffer_bytes: int = 0
|
||
|
||
self._stream_task: Optional[asyncio.Task] = None
|
||
self._proc: Optional[asyncio.subprocess.Process] = None
|
||
self._capturing: bool = False
|
||
|
||
# Active recording state (None when idle)
|
||
self._active: Optional[_ActiveRecording] = None
|
||
|
||
# ------------------------------------------------------------------
|
||
# Lifecycle
|
||
# ------------------------------------------------------------------
|
||
|
||
async def start(self) -> None:
|
||
"""Start the persistent capture. Call once from app lifespan."""
|
||
self._stream_task = asyncio.create_task(self._capture_loop())
|
||
logger.info("PulseAudio ring-buffer starting.")
|
||
|
||
async def stop(self) -> None:
|
||
if self._stream_task:
|
||
self._stream_task.cancel()
|
||
try:
|
||
await self._stream_task
|
||
except asyncio.CancelledError:
|
||
pass
|
||
self._stream_task = None
|
||
await self._terminate_proc()
|
||
|
||
# ------------------------------------------------------------------
|
||
# Capture
|
||
# ------------------------------------------------------------------
|
||
|
||
def _ffmpeg_command(self) -> List[str]:
|
||
return [
|
||
"ffmpeg",
|
||
"-hide_banner", "-nostdin", "-nostats",
|
||
"-loglevel", "warning",
|
||
"-f", "pulse", "-i", settings.pulse_source,
|
||
"-ac", "1",
|
||
"-ar", MP3_SAMPLE_RATE,
|
||
"-b:a", MP3_BITRATE,
|
||
# Without this, the MP3 muxer fills its 32 KB AVIO buffer before
|
||
# writing anything — 16 s of audio per burst at 16 kbps, which would
|
||
# destroy the arrival timestamps the slicing depends on.
|
||
"-flush_packets", "1",
|
||
"-f", "mp3", "-",
|
||
]
|
||
|
||
async def _capture_loop(self) -> None:
|
||
backoff = RESTART_BACKOFF_MIN
|
||
while True:
|
||
try:
|
||
# The original bug this path was abandoned for: FFmpeg was launched
|
||
# with -f pulse before the shared socket existed, failed instantly,
|
||
# and never recovered. Wait for it, bounded, every time.
|
||
if not await pulse.wait_until_ready():
|
||
await asyncio.sleep(backoff)
|
||
backoff = min(backoff * 2, RESTART_BACKOFF_MAX)
|
||
continue
|
||
|
||
await self._run_capture()
|
||
logger.warning("PulseAudio capture process exited — restarting.")
|
||
except asyncio.CancelledError:
|
||
await self._terminate_proc()
|
||
raise
|
||
except Exception as e:
|
||
logger.warning(f"PulseAudio capture error ({e}) — restarting.")
|
||
|
||
self._capturing = False
|
||
await asyncio.sleep(backoff)
|
||
backoff = min(backoff * 2, RESTART_BACKOFF_MAX)
|
||
|
||
async def _run_capture(self) -> None:
|
||
cmd = self._ffmpeg_command()
|
||
logger.info(f"Starting capture: ffmpeg -f pulse -i {settings.pulse_source}")
|
||
proc = await asyncio.create_subprocess_exec(
|
||
*cmd,
|
||
stdout=asyncio.subprocess.PIPE,
|
||
stderr=asyncio.subprocess.PIPE,
|
||
)
|
||
self._proc = proc
|
||
stderr_task = asyncio.create_task(self._drain_stderr(proc))
|
||
try:
|
||
assert proc.stdout is not None
|
||
while True:
|
||
chunk = await proc.stdout.read(READ_CHUNK_BYTES)
|
||
if not chunk:
|
||
break # EOF — FFmpeg died or the source went away
|
||
if not self._capturing:
|
||
self._capturing = True
|
||
logger.info("PulseAudio capture is producing audio.")
|
||
self._ingest(chunk)
|
||
finally:
|
||
self._capturing = False
|
||
# _drain_stderr swallows its own CancelledError, so it finishes cleanly
|
||
# and never needs awaiting here.
|
||
stderr_task.cancel()
|
||
await self._terminate_proc()
|
||
|
||
async def _drain_stderr(self, proc: asyncio.subprocess.Process) -> None:
|
||
"""Surface FFmpeg's diagnostics instead of letting the pipe fill and block."""
|
||
if proc.stderr is None:
|
||
return
|
||
try:
|
||
while True:
|
||
line = await proc.stderr.readline()
|
||
if not line:
|
||
return
|
||
logger.warning(f"ffmpeg(pulse): {line.decode(errors='replace').strip()}")
|
||
except asyncio.CancelledError:
|
||
return
|
||
except Exception:
|
||
return
|
||
|
||
async def _terminate_proc(self) -> None:
|
||
proc, self._proc = self._proc, None
|
||
if proc is None or proc.returncode is not None:
|
||
return
|
||
try:
|
||
# Synchronous, so the signal lands even if we are being cancelled and
|
||
# the reap below never gets to run.
|
||
proc.terminate()
|
||
except Exception:
|
||
return
|
||
try:
|
||
await asyncio.wait_for(proc.wait(), timeout=5)
|
||
except asyncio.TimeoutError:
|
||
try:
|
||
proc.kill()
|
||
except Exception:
|
||
pass
|
||
except asyncio.CancelledError:
|
||
raise
|
||
except Exception:
|
||
pass
|
||
|
||
def _ingest(self, chunk: bytes) -> None:
|
||
"""Append a chunk to the ring buffer and, if recording, the accumulator."""
|
||
now = time.time()
|
||
self._buffer.append((now, chunk))
|
||
self._buffer_bytes += len(chunk)
|
||
|
||
# The ring buffer serves pre-roll only, so it is trimmed to a fixed
|
||
# window unconditionally — an open recording no longer pins it, because
|
||
# the accumulator owns that audio.
|
||
keep_from = now - RING_BUFFER_SECONDS
|
||
while self._buffer and self._buffer[0][0] < keep_from:
|
||
_, old = self._buffer.popleft()
|
||
self._buffer_bytes -= len(old)
|
||
|
||
active = self._active
|
||
if active is None:
|
||
return
|
||
|
||
if active.total_bytes + len(chunk) > MAX_RECORDING_BYTES:
|
||
if not active.truncated_by_cap:
|
||
active.truncated_by_cap = True
|
||
logger.warning(
|
||
f"Recording {active.call_id} hit the {MAX_RECORDING_BYTES} byte memory ceiling "
|
||
f"after {now - active.slice_start:.1f}s — further audio is being dropped."
|
||
)
|
||
return
|
||
|
||
active.chunks.append((now, chunk))
|
||
active.total_bytes += len(chunk)
|
||
|
||
# ------------------------------------------------------------------
|
||
# Recording API
|
||
# ------------------------------------------------------------------
|
||
|
||
async def start_recording(self, call_id: str, start_epoch: Optional[float] = None) -> bool:
|
||
"""
|
||
Open a recording. `start_epoch` is OP25's call_log timestamp (host wall
|
||
clock); the slice begins PRE_ROLL_SECONDS before it. Omit it only when no
|
||
OP25 timestamp is available — then we fall back to "now", losing precision.
|
||
"""
|
||
if self._active is not None:
|
||
logger.warning(f"Recording already active ({self._active.call_id}) — ignoring start for {call_id}.")
|
||
return False
|
||
|
||
call_start = start_epoch if start_epoch else time.time()
|
||
slice_start = call_start - PRE_ROLL_SECONDS
|
||
|
||
if not self._capturing:
|
||
logger.warning(f"Recording {call_id} opened while PulseAudio capture is down — audio may be missing.")
|
||
|
||
# Seed the accumulator with the pre-roll already sitting in the ring
|
||
# buffer. No await between reading the buffer and publishing _active, so
|
||
# the capture task cannot slip a chunk in between and double-count it.
|
||
clamped = 0.0
|
||
oldest = self._buffer[0][0] if self._buffer else None
|
||
if oldest is not None and slice_start < oldest:
|
||
# Pre-roll predates the buffer: node just started, capture restarted,
|
||
# or OP25's timestamp is far in the past. Clamp and say so LOUDLY —
|
||
# this is silent audio loss otherwise.
|
||
clamped = oldest - slice_start
|
||
logger.warning(
|
||
f"BUFFER CLAMP: pre-roll for call {call_id} predates buffered audio by "
|
||
f"{clamped:.2f}s — recording starts at the buffer head and that audio is lost."
|
||
)
|
||
|
||
seeded = [(ts, chunk) for ts, chunk in self._buffer if ts >= slice_start]
|
||
self._active = _ActiveRecording(
|
||
call_id=call_id,
|
||
call_start=call_start,
|
||
slice_start=slice_start,
|
||
chunks=seeded,
|
||
total_bytes=sum(len(c) for _, c in seeded),
|
||
clamped_seconds=clamped,
|
||
)
|
||
|
||
logger.info(f"Recording started: {call_id} (slice from {slice_start:.3f})")
|
||
return True
|
||
|
||
async def stop_recording(self, end_epoch: Optional[float] = None) -> Optional[Recording]:
|
||
"""
|
||
Close the recording and write the file. `end_epoch` is host wall clock.
|
||
|
||
Waits (bounded) for captured audio to actually cover `end_epoch` before
|
||
slicing — see TAIL_WAIT_TIMEOUT_SECONDS. Returns None only when there was
|
||
no recording open or no audio at all.
|
||
"""
|
||
active = self._active
|
||
if active is None:
|
||
return None
|
||
|
||
call_id = active.call_id
|
||
slice_start = active.slice_start
|
||
|
||
end = end_epoch if end_epoch else time.time()
|
||
end = min(end, active.call_start + MAX_RECORDING_SECONDS)
|
||
|
||
# The accumulator keeps filling during this wait — that is the point.
|
||
await self._await_tail(end, call_id)
|
||
self._active = None
|
||
|
||
chunks: List[bytes] = []
|
||
last_ts = slice_start
|
||
for ts, chunk in active.chunks:
|
||
if ts < slice_start:
|
||
continue
|
||
chunks.append(chunk)
|
||
last_ts = ts
|
||
if ts >= end:
|
||
# Include the chunk straddling `end` so the tail is never clipped,
|
||
# then stop.
|
||
break
|
||
|
||
if not chunks:
|
||
logger.warning(
|
||
f"No buffered audio for call {call_id} "
|
||
f"(window {slice_start:.3f}–{end:.3f}) — PulseAudio capture may be down."
|
||
)
|
||
return None
|
||
|
||
if last_ts < end - TAIL_WAIT_POLL_SECONDS:
|
||
logger.warning(
|
||
f"BUFFER CLAMP: call {call_id} ends {end - last_ts:.2f}s after the newest captured "
|
||
"audio — the tail is short. Capture may be stalled or restarting."
|
||
)
|
||
|
||
self._recordings_dir.mkdir(parents=True, exist_ok=True)
|
||
ts_str = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
|
||
output_path = self._recordings_dir / f"{ts_str}_{call_id}.mp3"
|
||
|
||
output_path.write_bytes(b"".join(chunks))
|
||
|
||
size = output_path.stat().st_size
|
||
if size <= 0:
|
||
output_path.unlink(missing_ok=True)
|
||
logger.warning(f"Recording for call {call_id} produced an empty file.")
|
||
return None
|
||
|
||
audio_end = min(end, last_ts)
|
||
logger.info(f"Recording saved: {output_path.name} ({size} bytes, {audio_end - slice_start:.2f}s window)")
|
||
|
||
recording = Recording(
|
||
call_id=call_id,
|
||
path=output_path,
|
||
audio_start_epoch=slice_start,
|
||
audio_end_epoch=audio_end,
|
||
clamped_seconds=active.clamped_seconds,
|
||
)
|
||
return await self._apply_trim(recording)
|
||
|
||
async def _await_tail(self, end: float, call_id: str) -> float:
|
||
"""
|
||
Block until captured audio reaches `end`, or the bounded timeout expires.
|
||
|
||
Returns seconds waited. Logs whenever a wait was actually needed so the
|
||
real pipeline latency is observable in the field.
|
||
"""
|
||
if not self._buffer:
|
||
return 0.0
|
||
if self._buffer[-1][0] >= end:
|
||
return 0.0
|
||
|
||
started = time.monotonic()
|
||
deadline = started + TAIL_WAIT_TIMEOUT_SECONDS
|
||
while time.monotonic() < deadline:
|
||
await asyncio.sleep(TAIL_WAIT_POLL_SECONDS)
|
||
if self._buffer and self._buffer[-1][0] >= end:
|
||
waited = time.monotonic() - started
|
||
logger.info(f"Waited {waited:.2f}s for the tail of call {call_id} to reach the buffer.")
|
||
return waited
|
||
if not self._capturing:
|
||
break # capture died mid-wait; nothing more is coming
|
||
|
||
waited = time.monotonic() - started
|
||
newest = self._buffer[-1][0] if self._buffer else end
|
||
logger.warning(
|
||
f"Tail wait for call {call_id} gave up after {waited:.2f}s — captured audio is still "
|
||
f"{max(0.0, end - newest):.2f}s short of the call end. Tail may be clipped."
|
||
)
|
||
return waited
|
||
|
||
async def _apply_trim(self, recording: Recording) -> Recording:
|
||
"""
|
||
Strip leading/trailing dead air and keep the timing metadata honest.
|
||
|
||
An all-silence recording is NOT uploaded: it carries no information and
|
||
silence is exactly what makes Whisper hallucinate. It is logged instead,
|
||
because it also means something is wrong with the audio path.
|
||
"""
|
||
if not settings.trim_silence or recording.path is None:
|
||
return recording
|
||
|
||
result = await audio_trim.trim_silence(
|
||
recording.path,
|
||
sample_rate=MP3_SAMPLE_RATE,
|
||
bitrate=MP3_BITRATE,
|
||
)
|
||
|
||
if result.all_silence:
|
||
logger.warning(
|
||
f"Call {recording.call_id} contains no speech at all — skipping upload. "
|
||
"Check squelch, the Liquidsoap output and the drb_sink monitor."
|
||
)
|
||
recording.path.unlink(missing_ok=True)
|
||
recording.path = None
|
||
recording.all_silence = True
|
||
return recording
|
||
|
||
if result.applied:
|
||
recording.lead_trimmed = result.lead
|
||
recording.tail_trimmed = result.tail
|
||
# Wall clock of the trimmed audio's first and last sample.
|
||
recording.audio_start_epoch += result.lead
|
||
recording.audio_end_epoch -= result.tail
|
||
return recording
|
||
|
||
# ------------------------------------------------------------------
|
||
# Upload (unchanged interface)
|
||
# ------------------------------------------------------------------
|
||
|
||
async def upload_recording(
|
||
self,
|
||
file_path: Path,
|
||
call_id: str,
|
||
talkgroup_id: Optional[int] = None,
|
||
talkgroup_name: Optional[str] = None,
|
||
system_id: Optional[str] = None,
|
||
audio_start_epoch: Optional[float] = None,
|
||
audio_end_epoch: Optional[float] = None,
|
||
) -> Optional[str]:
|
||
if not settings.c2_url:
|
||
logger.info("No C2_URL configured — skipping upload.")
|
||
return None
|
||
|
||
upload_url = f"{settings.c2_url}/upload"
|
||
api_key = credentials.get_api_key()
|
||
headers = {"Authorization": f"Bearer {api_key}"} if api_key else {}
|
||
|
||
form: dict = {"call_id": call_id, "node_id": settings.node_id}
|
||
if talkgroup_id is not None:
|
||
form["talkgroup_id"] = str(talkgroup_id)
|
||
if talkgroup_name:
|
||
form["talkgroup_name"] = talkgroup_name
|
||
if system_id:
|
||
form["system_id"] = system_id
|
||
# Where this audio really sits on the wall clock once silence is trimmed.
|
||
# C2 does not declare these Form fields yet, so FastAPI ignores them —
|
||
# they cost nothing and are here for when playback/correlation want them.
|
||
if audio_start_epoch is not None:
|
||
form["audio_start_epoch"] = f"{audio_start_epoch:.3f}"
|
||
if audio_end_epoch is not None:
|
||
form["audio_end_epoch"] = f"{audio_end_epoch:.3f}"
|
||
|
||
try:
|
||
async with httpx.AsyncClient(timeout=120) as client:
|
||
with open(file_path, "rb") as f:
|
||
r = await client.post(
|
||
upload_url,
|
||
files={"file": (file_path.name, f, "audio/mpeg")},
|
||
data=form,
|
||
headers=headers,
|
||
)
|
||
r.raise_for_status()
|
||
audio_url = r.json().get("url")
|
||
logger.info(f"Upload complete: {audio_url}")
|
||
return audio_url
|
||
except Exception as e:
|
||
logger.error(f"Upload failed: {e}")
|
||
return None
|
||
finally:
|
||
try:
|
||
file_path.unlink()
|
||
except Exception:
|
||
pass
|
||
|
||
# ------------------------------------------------------------------
|
||
# State
|
||
# ------------------------------------------------------------------
|
||
|
||
@property
|
||
def is_recording(self) -> bool:
|
||
return self._active is not None
|
||
|
||
@property
|
||
def is_capturing(self) -> bool:
|
||
"""True when FFmpeg is alive and audio is actually arriving."""
|
||
return self._capturing
|
||
|
||
@property
|
||
def buffered_seconds(self) -> float:
|
||
if len(self._buffer) < 2:
|
||
return 0.0
|
||
return self._buffer[-1][0] - self._buffer[0][0]
|
||
|
||
|
||
call_recorder = CallRecorder()
|