mrwnslz
ae72b1d67a
Die statische ffmpeg-Build stürzt im Container beim Auflösen von Hostnamen ab (SIGSEGV). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
113 lines
4.1 KiB
Python
113 lines
4.1 KiB
Python
"""Skip silence in the browser: the pauses of an episode, found once on the server.
|
|
|
|
Android's player skips silence itself. A browser can't listen to the audio of
|
|
most podcast servers (no CORS: Web Audio hears only zeros), so the server
|
|
reads the file once with ffmpeg's silencedetect and keeps the pauses on the
|
|
episode (PodcastEpisode.silences); the browser then jumps over them while it
|
|
plays (podcasts-web.js).
|
|
"""
|
|
import logging
|
|
import os
|
|
import re
|
|
import subprocess
|
|
import tempfile
|
|
import threading
|
|
|
|
import requests
|
|
|
|
from django.db import close_old_connections
|
|
|
|
log = logging.getLogger(__name__)
|
|
|
|
NOISE = '-35dB' # quieter than this counts as silence
|
|
MIN_SILENCE = 0.4 # seconds; shorter pauses stay (they belong to speech)
|
|
TIMEOUT = 900 # seconds for decoding one episode
|
|
MAX_BYTES = 800 * 1024 * 1024 # a larger file isn't an episode to analyse
|
|
MAX_RUNNING = 2 # episodes analysed at the same time
|
|
|
|
_START = re.compile(r'silence_start: (-?[\d.]+)')
|
|
_END = re.compile(r'silence_end: ([\d.]+)')
|
|
|
|
_running = set()
|
|
_lock = threading.Lock()
|
|
_slots = threading.BoundedSemaphore(MAX_RUNNING)
|
|
|
|
|
|
def parse(stderr):
|
|
"""ffmpeg's silencedetect output -> [[start, end], …] in seconds (2 decimals)."""
|
|
spans = []
|
|
start = None
|
|
for line in stderr.splitlines():
|
|
m = _START.search(line)
|
|
if m:
|
|
start = max(0.0, float(m.group(1)))
|
|
continue
|
|
m = _END.search(line)
|
|
if m and start is not None:
|
|
end = float(m.group(1))
|
|
if end - start >= MIN_SILENCE:
|
|
spans.append([round(start, 2), round(end, 2)])
|
|
start = None
|
|
return spans
|
|
|
|
|
|
def analyze(url):
|
|
"""The pauses of the audio at `url`. Downloaded here first: the static ffmpeg
|
|
build can't look up host names (it crashes doing so), it reads a local file."""
|
|
import imageio_ffmpeg
|
|
fd, path = tempfile.mkstemp(suffix='.audio')
|
|
try:
|
|
with os.fdopen(fd, 'wb') as out, requests.get(
|
|
url, stream=True, timeout=(10, 60), headers={'User-Agent': 'diora podcast silence'}) as r:
|
|
if r.status_code >= 400:
|
|
raise RuntimeError(f'HTTP {r.status_code}')
|
|
size = 0
|
|
for chunk in r.iter_content(1 << 20):
|
|
size += len(chunk)
|
|
if size > MAX_BYTES:
|
|
raise RuntimeError('file too large')
|
|
out.write(chunk)
|
|
proc = subprocess.run(
|
|
[imageio_ffmpeg.get_ffmpeg_exe(), '-nostdin', '-hide_banner', '-nostats',
|
|
'-vn', '-sn', '-dn', '-i', path,
|
|
'-af', f'silencedetect=noise={NOISE}:d={MIN_SILENCE}', '-f', 'null', '-'],
|
|
capture_output=True, text=True, timeout=TIMEOUT,
|
|
)
|
|
if proc.returncode != 0:
|
|
tail = (proc.stderr or '').strip().splitlines()[-1:] or [f'ffmpeg failed ({proc.returncode})']
|
|
raise RuntimeError(tail[0][:200])
|
|
return parse(proc.stderr)
|
|
finally:
|
|
try:
|
|
os.remove(path)
|
|
except OSError:
|
|
pass
|
|
|
|
|
|
def ensure(episode_id):
|
|
"""Find the episode's pauses in the background, unless that runs already."""
|
|
with _lock:
|
|
if episode_id in _running:
|
|
return
|
|
_running.add(episode_id)
|
|
threading.Thread(target=_work, args=(episode_id,), daemon=True).start()
|
|
|
|
|
|
def _work(episode_id):
|
|
from .models import PodcastEpisode
|
|
try:
|
|
with _slots:
|
|
close_old_connections()
|
|
ep = PodcastEpisode.objects.filter(pk=episode_id).only('id', 'audio_url').first()
|
|
if ep is None:
|
|
return
|
|
try:
|
|
result = {'spans': analyze(ep.audio_url)}
|
|
except Exception as e: # unreachable file, timeout, not audio: remembered, not retried
|
|
log.warning('silences of episode %s failed: %s', episode_id, e)
|
|
result = {'spans': [], 'error': str(e)[:200] or type(e).__name__}
|
|
PodcastEpisode.objects.filter(pk=episode_id).update(silences=result)
|
|
finally:
|
|
with _lock:
|
|
_running.discard(episode_id)
|
|
close_old_connections()
|