742 lines
29 KiB
Python
742 lines
29 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
WebRTC and Jingle handling module.
|
|
|
|
This module provides the core logic for establishing Audio/Video sessions via
|
|
XMPP Jingle (XEP-0166) and WebRTC. It manages the RTCPeerConnections,
|
|
ICE candidate negotiation, and audio broadcasting.
|
|
|
|
Key features:
|
|
- Shared memory audio broadcasting to multiple subscribers.
|
|
- Synchronization of audio streams.
|
|
- Explicit cleanup routines to prevent memory leaks with aiortc objects.
|
|
"""
|
|
|
|
import asyncio
|
|
import gc
|
|
import random
|
|
import logging
|
|
import os
|
|
import re
|
|
import weakref
|
|
from typing import Optional, Dict, List, Any, Callable
|
|
from dataclasses import dataclass, field
|
|
from enum import Enum
|
|
from fractions import Fraction
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
AIORTC_AVAILABLE = False
|
|
try:
|
|
from aiortc import RTCPeerConnection, RTCSessionDescription, RTCConfiguration, RTCIceServer
|
|
from aiortc import MediaStreamTrack, RTCIceCandidate
|
|
from aiortc.contrib.media import MediaPlayer
|
|
import av
|
|
AIORTC_AVAILABLE = True
|
|
except ImportError as e:
|
|
logger.error(f"aiortc import failed: {e}")
|
|
|
|
|
|
class CallState(Enum):
|
|
"""Represents the lifecycle state of a Jingle session."""
|
|
IDLE = "idle"
|
|
ACTIVE = "active"
|
|
ENDED = "ended"
|
|
|
|
|
|
@dataclass(slots=True)
|
|
class JingleSession:
|
|
"""
|
|
Stores state for a single WebRTC session.
|
|
|
|
Attributes:
|
|
sid: Session ID.
|
|
peer_jid: JID of the remote peer.
|
|
pc: The RTCPeerConnection object.
|
|
audio_track: The specific audio track associated with this session.
|
|
state: Current call state.
|
|
pending_candidates: ICE candidates received before remote description was set.
|
|
local_candidates: ICE candidates generated locally.
|
|
ice_gathering_complete: Event signaling completion of ICE gathering.
|
|
"""
|
|
sid: str
|
|
peer_jid: str
|
|
pc: Any = None
|
|
audio_track: Any = None
|
|
state: CallState = CallState.IDLE
|
|
pending_candidates: List[Any] = field(default_factory=list)
|
|
local_candidates: List[Dict] = field(default_factory=list)
|
|
ice_gathering_complete: asyncio.Event = field(default_factory=asyncio.Event)
|
|
|
|
def cleanup(self):
|
|
"""Releases references to heavy objects to aid garbage collection."""
|
|
self.pending_candidates.clear()
|
|
self.local_candidates.clear()
|
|
self.pc = None
|
|
self.audio_track = None
|
|
|
|
|
|
class SynchronizedRadioBroadcaster:
|
|
"""
|
|
Central audio broadcaster using a producer-consumer model.
|
|
|
|
This class decodes a single audio stream and distributes the frames to
|
|
multiple subscribers (SynchronizedAudioTrack instances) simultaneously.
|
|
It uses weak references to subscribers to avoid reference cycles.
|
|
"""
|
|
|
|
MAX_SUBSCRIBERS = 10
|
|
SAMPLES_PER_FRAME = 960
|
|
CLEANUP_INTERVAL = 200
|
|
|
|
def __init__(self, on_track_end_callback: Optional[Callable] = None):
|
|
self._player: Optional[MediaPlayer] = None
|
|
self._current_source: Optional[str] = None
|
|
self._lock = asyncio.Lock()
|
|
# Use weakrefs to allow tracks to be GC'd if the connection drops unexpectedly.
|
|
self._subscribers: List[weakref.ref] = []
|
|
self._broadcast_task: Optional[asyncio.Task] = None
|
|
self._pts = 0
|
|
self._time_base = Fraction(1, 48000)
|
|
self.on_track_end = on_track_end_callback
|
|
self._shutdown = False
|
|
self._track_end_fired = False
|
|
self._stopped = False
|
|
self._frame_counter = 0
|
|
|
|
# Persist resampler to avoid high CPU usage from constant reallocation.
|
|
self._resampler = None
|
|
|
|
def _get_silence_frame(self) -> 'av.AudioFrame':
|
|
"""Generates a silent audio frame to keep the RTP stream alive."""
|
|
frame = av.AudioFrame(format='s16', layout='stereo', samples=self.SAMPLES_PER_FRAME)
|
|
frame.sample_rate = 48000
|
|
frame.time_base = self._time_base
|
|
for plane in frame.planes:
|
|
plane.update(bytes(plane.buffer_size))
|
|
frame.pts = self._pts
|
|
self._pts += self.SAMPLES_PER_FRAME
|
|
return frame
|
|
|
|
async def set_source(self, source: str, force_restart: bool = False):
|
|
"""
|
|
Updates the audio source, restarting the broadcast loop if necessary.
|
|
|
|
Args:
|
|
source: URI or path to the audio file.
|
|
force_restart: If True, restarts player even if source is identical.
|
|
"""
|
|
async with self._lock:
|
|
normalized_source = source
|
|
if source and not source.startswith(('http:', 'https:', 'rtmp:', 'rtsp:')):
|
|
normalized_source = os.path.abspath(source)
|
|
|
|
broadcast_is_running = (
|
|
self._broadcast_task and
|
|
not self._broadcast_task.done()
|
|
)
|
|
|
|
if (normalized_source == self._current_source and
|
|
self._player and
|
|
broadcast_is_running and
|
|
not force_restart):
|
|
return
|
|
|
|
logger.info(f"Changing broadcast: {os.path.basename(normalized_source) if normalized_source else 'None'}")
|
|
|
|
await self._stop_broadcast_task()
|
|
await self._close_player()
|
|
|
|
self._current_source = normalized_source
|
|
self._pts = 0
|
|
self._track_end_fired = False
|
|
self._stopped = False
|
|
self._frame_counter = 0
|
|
|
|
# Reset resampler context to prevent timestamp drift or format mismatch.
|
|
self._resampler = None
|
|
|
|
if not source:
|
|
return
|
|
|
|
try:
|
|
logger.info(f"Starting broadcast: {source}")
|
|
# Use a buffer for network streams to reduce jitter.
|
|
options = {'rtbufsize': '8M'} if source.startswith(('http', 'rtmp', 'rtsp')) else {}
|
|
self._player = MediaPlayer(source, options=options)
|
|
self._broadcast_task = asyncio.create_task(self._broadcast_loop())
|
|
|
|
except Exception as e:
|
|
logger.error(f"MediaPlayer Error: {e}")
|
|
self._player = None
|
|
|
|
async def _stop_broadcast_task(self):
|
|
"""Cancels and awaits the broadcast task."""
|
|
if self._broadcast_task:
|
|
self._broadcast_task.cancel()
|
|
try:
|
|
await asyncio.wait_for(self._broadcast_task, timeout=2.0)
|
|
except (asyncio.CancelledError, asyncio.TimeoutError):
|
|
pass
|
|
self._broadcast_task = None
|
|
|
|
async def _close_player(self):
|
|
"""Safely closes the media player and underlying container."""
|
|
self._resampler = None
|
|
|
|
if self._player:
|
|
try:
|
|
old_player = self._player
|
|
self._player = None
|
|
|
|
if hasattr(old_player, 'audio') and old_player.audio:
|
|
try: old_player.audio.stop()
|
|
except: pass
|
|
|
|
if hasattr(old_player, '_container') and old_player._container:
|
|
try: old_player._container.close()
|
|
except: pass
|
|
|
|
del old_player
|
|
except Exception as e:
|
|
logger.debug(f"Error closing player: {e}")
|
|
|
|
gc.collect()
|
|
|
|
async def stop_playback(self):
|
|
"""Stops the broadcast and clears the current source."""
|
|
async with self._lock:
|
|
self._stopped = True
|
|
await self._stop_broadcast_task()
|
|
await self._close_player()
|
|
self._current_source = None
|
|
logger.info("Playback stopped")
|
|
|
|
async def _broadcast_loop(self):
|
|
"""
|
|
Main loop: decodes frames, resamples them, and distributes to subscribers.
|
|
Handles errors and End-Of-File (EOF) events.
|
|
"""
|
|
last_error_time = 0
|
|
error_count_window = 0
|
|
|
|
try:
|
|
while self._player and not self._shutdown and not self._stopped:
|
|
self._frame_counter += 1
|
|
|
|
# Periodically clean up dead weak references.
|
|
if self._frame_counter % self.CLEANUP_INTERVAL == 0:
|
|
self._cleanup_subscribers()
|
|
|
|
# Pause decoding if no one is listening to save CPU.
|
|
if not self._get_active_subscribers():
|
|
await asyncio.sleep(0.1)
|
|
continue
|
|
|
|
frame = None
|
|
try:
|
|
if not self._player or not self._player.audio:
|
|
break
|
|
|
|
frame = await asyncio.wait_for(
|
|
self._player.audio.recv(),
|
|
timeout=0.5
|
|
)
|
|
|
|
current_time = asyncio.get_event_loop().time()
|
|
if current_time - last_error_time > 5.0:
|
|
error_count_window = 0
|
|
|
|
# Ensure audio is standard stereo 48kHz.
|
|
if frame.format.name != 's16' or frame.sample_rate != 48000:
|
|
if self._resampler is None:
|
|
self._resampler = av.AudioResampler(format='s16', layout='stereo', rate=48000)
|
|
|
|
resampled_frames = self._resampler.resample(frame)
|
|
|
|
# Explicitly release the original frame to free C-level memory.
|
|
del frame
|
|
|
|
if resampled_frames:
|
|
frame = resampled_frames[0]
|
|
else:
|
|
continue
|
|
|
|
# Rewrite timestamps for the continuous stream.
|
|
frame.pts = self._pts
|
|
frame.time_base = self._time_base
|
|
self._pts += frame.samples
|
|
|
|
await self._distribute_frame(frame)
|
|
|
|
except asyncio.TimeoutError:
|
|
# Send silence on network timeout to prevent RTP timeout.
|
|
s_frame = self._get_silence_frame()
|
|
await self._distribute_frame(s_frame)
|
|
del s_frame
|
|
|
|
except (av.error.EOFError, StopIteration, StopAsyncIteration):
|
|
logger.info("Track ended (EOF)")
|
|
break
|
|
|
|
except Exception as e:
|
|
error_msg = str(e)
|
|
if "MediaStreamError" in str(type(e).__name__):
|
|
break
|
|
|
|
logger.debug(f"Broadcast frame warning: {e}")
|
|
error_count_window += 1
|
|
if error_count_window >= 20:
|
|
logger.error("Too many errors, stopping broadcast")
|
|
break
|
|
|
|
await asyncio.sleep(0.1)
|
|
|
|
finally:
|
|
if frame is not None:
|
|
del frame
|
|
|
|
# Notify the main bot that the track finished.
|
|
if self.on_track_end and not self._shutdown and not self._track_end_fired and not self._stopped:
|
|
self._track_end_fired = True
|
|
try:
|
|
result = self.on_track_end()
|
|
if asyncio.iscoroutine(result):
|
|
asyncio.create_task(result)
|
|
except Exception as e:
|
|
logger.error(f"Track end callback error: {e}")
|
|
|
|
except asyncio.CancelledError:
|
|
pass
|
|
except Exception as e:
|
|
logger.error(f"Broadcast loop error: {e}")
|
|
finally:
|
|
self._resampler = None
|
|
gc.collect()
|
|
|
|
def _cleanup_subscribers(self):
|
|
self._subscribers = [ref for ref in self._subscribers if ref() is not None]
|
|
|
|
def _get_active_subscribers(self) -> List['SynchronizedAudioTrack']:
|
|
active = []
|
|
for ref in self._subscribers:
|
|
track = ref()
|
|
if track is not None and track._active:
|
|
active.append(track)
|
|
return active
|
|
|
|
async def _distribute_frame(self, frame: 'av.AudioFrame'):
|
|
subscribers = self._get_active_subscribers()
|
|
if not subscribers:
|
|
return
|
|
|
|
# Dispatch frames to all tracks concurrently.
|
|
tasks = [sub._receive_frame(frame) for sub in subscribers]
|
|
if tasks:
|
|
await asyncio.gather(*tasks, return_exceptions=True)
|
|
|
|
def subscribe(self, track: 'SynchronizedAudioTrack'):
|
|
self._cleanup_subscribers()
|
|
if len(self._subscribers) >= self.MAX_SUBSCRIBERS:
|
|
return
|
|
self._subscribers.append(weakref.ref(track))
|
|
|
|
def unsubscribe(self, track: 'SynchronizedAudioTrack'):
|
|
self._subscribers = [ref for ref in self._subscribers
|
|
if ref() is not None and ref() is not track]
|
|
|
|
def shutdown(self):
|
|
self._shutdown = True
|
|
self._resampler = None
|
|
gc.collect()
|
|
|
|
|
|
class SynchronizedAudioTrack(MediaStreamTrack):
|
|
"""
|
|
A MediaStreamTrack that receives frames from the broadcaster queue.
|
|
"""
|
|
kind = "audio"
|
|
MAX_QUEUE_SIZE = 3
|
|
|
|
def __init__(self, broadcaster: SynchronizedRadioBroadcaster):
|
|
super().__init__()
|
|
self._broadcaster = broadcaster
|
|
self._frame_queue: asyncio.Queue = asyncio.Queue(maxsize=self.MAX_QUEUE_SIZE)
|
|
self._active = True
|
|
|
|
self._silence_frame: Optional[av.AudioFrame] = None
|
|
self._silence_pts = 0
|
|
|
|
self._broadcaster.subscribe(self)
|
|
|
|
def _get_silence_frame(self) -> 'av.AudioFrame':
|
|
"""Lazily creates and reuses a silence frame."""
|
|
if self._silence_frame is None:
|
|
self._silence_frame = av.AudioFrame(format='s16', layout='stereo', samples=960)
|
|
self._silence_frame.sample_rate = 48000
|
|
self._silence_frame.time_base = Fraction(1, 48000)
|
|
for plane in self._silence_frame.planes:
|
|
plane.update(bytes(plane.buffer_size))
|
|
|
|
self._silence_frame.pts = self._silence_pts
|
|
self._silence_pts += 960
|
|
return self._silence_frame
|
|
|
|
async def _receive_frame(self, frame: 'av.AudioFrame'):
|
|
if not self._active:
|
|
return
|
|
|
|
try:
|
|
# If the queue is full, drop the oldest frame to reduce latency.
|
|
if self._frame_queue.full():
|
|
try:
|
|
old_frame = self._frame_queue.get_nowait()
|
|
del old_frame
|
|
except asyncio.QueueEmpty:
|
|
pass
|
|
|
|
self._frame_queue.put_nowait(frame)
|
|
except Exception:
|
|
pass
|
|
|
|
async def recv(self):
|
|
"""Called by aiortc to pull the next frame."""
|
|
if not self._active:
|
|
raise Exception("Track stopped")
|
|
|
|
try:
|
|
frame = await asyncio.wait_for(
|
|
self._frame_queue.get(),
|
|
timeout=0.05
|
|
)
|
|
return frame
|
|
except asyncio.TimeoutError:
|
|
return self._get_silence_frame()
|
|
|
|
def stop(self):
|
|
self._active = False
|
|
self._broadcaster.unsubscribe(self)
|
|
|
|
# Drain queue to release frame references.
|
|
while not self._frame_queue.empty():
|
|
try:
|
|
frame = self._frame_queue.get_nowait()
|
|
del frame
|
|
except asyncio.QueueEmpty:
|
|
break
|
|
|
|
if self._silence_frame is not None:
|
|
del self._silence_frame
|
|
self._silence_frame = None
|
|
|
|
super().stop()
|
|
|
|
|
|
class JingleWebRTCHandler:
|
|
"""
|
|
Manages the XMPP Jingle negotiation and WebRTC sessions.
|
|
Translates between Jingle XML stanzas and SDP.
|
|
"""
|
|
NS_JINGLE = "urn:xmpp:jingle:1"
|
|
NS_JINGLE_ICE = "urn:xmpp:jingle:transports:ice-udp:1"
|
|
|
|
MAX_SESSIONS = 20
|
|
SESSION_CLEANUP_INTERVAL = 60
|
|
|
|
def __init__(self, stun_server: str, send_transport_info_callback: Optional[Callable] = None, on_track_end: Optional[Callable] = None):
|
|
if stun_server and not stun_server.startswith(('stun:', 'turn:', 'stuns:')):
|
|
self.stun_server = f"stun:{stun_server}"
|
|
else:
|
|
self.stun_server = stun_server
|
|
|
|
self.sessions: Dict[str, JingleSession] = {}
|
|
self._proposed_sessions: Dict[str, str] = {}
|
|
|
|
self._broadcaster = SynchronizedRadioBroadcaster(on_track_end_callback=on_track_end)
|
|
self.send_transport_info = send_transport_info_callback
|
|
|
|
self._cleanup_task: Optional[asyncio.Task] = None
|
|
self._shutdown = False
|
|
|
|
async def start_cleanup_task(self):
|
|
self._cleanup_task = asyncio.create_task(self._periodic_cleanup())
|
|
|
|
async def _periodic_cleanup(self):
|
|
"""Periodically removes ended sessions to recover memory."""
|
|
while not self._shutdown:
|
|
await asyncio.sleep(self.SESSION_CLEANUP_INTERVAL)
|
|
try:
|
|
await self._cleanup_dead_sessions()
|
|
gc.collect()
|
|
except Exception as e:
|
|
logger.error(f"Cleanup error: {e}")
|
|
|
|
async def _cleanup_dead_sessions(self):
|
|
dead_sessions = [
|
|
sid for sid, session in self.sessions.items()
|
|
if session.state == CallState.ENDED
|
|
]
|
|
for sid in dead_sessions:
|
|
await self.stop_session(sid)
|
|
|
|
def register_proposed_session(self, sid: str, peer_jid: str):
|
|
# Limit the proposed session cache to prevent memory exhaustion attacks.
|
|
if len(self._proposed_sessions) > 50:
|
|
oldest = list(self._proposed_sessions.keys())[:25]
|
|
for key in oldest:
|
|
del self._proposed_sessions[key]
|
|
self._proposed_sessions[sid] = peer_jid
|
|
|
|
def clear_proposed_session(self, sid: str):
|
|
self._proposed_sessions.pop(sid, None)
|
|
|
|
def set_audio_source(self, source: str, force_restart: bool = False):
|
|
asyncio.create_task(self._broadcaster.set_source(source, force_restart))
|
|
|
|
async def stop_playback(self):
|
|
await self._broadcaster.stop_playback()
|
|
|
|
def get_session(self, sid: str):
|
|
return self.sessions.get(sid)
|
|
|
|
async def create_session(self, sid, peer_jid) -> JingleSession:
|
|
if len(self.sessions) >= self.MAX_SESSIONS:
|
|
await self._cleanup_dead_sessions()
|
|
if len(self.sessions) >= self.MAX_SESSIONS:
|
|
oldest = list(self.sessions.keys())[0]
|
|
await self.stop_session(oldest)
|
|
|
|
servers = []
|
|
if self.stun_server:
|
|
servers.append(RTCIceServer(urls=self.stun_server))
|
|
|
|
config = RTCConfiguration(iceServers=servers)
|
|
pc = RTCPeerConnection(configuration=config)
|
|
|
|
session = JingleSession(sid=sid, peer_jid=peer_jid, pc=pc)
|
|
self.sessions[sid] = session
|
|
|
|
@pc.on("icegatheringstatechange")
|
|
async def on_gathering_state():
|
|
if pc.iceGatheringState == "complete":
|
|
session.ice_gathering_complete.set()
|
|
|
|
@pc.on("connectionstatechange")
|
|
async def on_state():
|
|
if pc.connectionState == "connected":
|
|
session.state = CallState.ACTIVE
|
|
elif pc.connectionState in ["failed", "closed", "disconnected"]:
|
|
session.state = CallState.ENDED
|
|
asyncio.create_task(self._cleanup_session(sid))
|
|
|
|
return session
|
|
|
|
async def _cleanup_session(self, sid: str):
|
|
await asyncio.sleep(1)
|
|
if sid in self.sessions:
|
|
session = self.sessions[sid]
|
|
if session.state == CallState.ENDED:
|
|
await self.stop_session(sid)
|
|
|
|
def _extract_candidates_from_sdp(self, sdp: str) -> List[Dict]:
|
|
"""Parses SDP string to extract ICE candidates as dictionaries."""
|
|
candidates = []
|
|
for line in sdp.splitlines():
|
|
if line.startswith('a=candidate:'):
|
|
match = re.match(
|
|
r'a=candidate:(\S+)\s+(\d+)\s+(\w+)\s+(\d+)\s+(\S+)\s+(\d+)\s+typ\s+(\w+)(?:\s+raddr\s+(\S+))?\s*(?:rport\s+(\d+))?',
|
|
line
|
|
)
|
|
if match:
|
|
foundation, component, protocol, priority, ip, port, typ, raddr, rport = match.groups()
|
|
cand = {
|
|
'foundation': foundation,
|
|
'component': component,
|
|
'protocol': protocol.lower(),
|
|
'priority': priority,
|
|
'ip': ip,
|
|
'port': port,
|
|
'type': typ,
|
|
'generation': '0',
|
|
'id': f"cand-{random.randint(1000, 9999)}"
|
|
}
|
|
if raddr: cand['rel-addr'] = raddr
|
|
if rport: cand['rel-port'] = rport
|
|
candidates.append(cand)
|
|
return candidates
|
|
|
|
async def handle_session_initiate(self, jingle_xml, peer_jid, our_jid):
|
|
"""Handles incoming Jingle session-initiate, creating the WebRTC answer."""
|
|
sid = jingle_xml.get('sid')
|
|
session = await self.create_session(sid, peer_jid)
|
|
|
|
sdp = self._jingle_to_sdp(jingle_xml)
|
|
offer = RTCSessionDescription(sdp=sdp, type="offer")
|
|
|
|
track = SynchronizedAudioTrack(self._broadcaster)
|
|
session.audio_track = track
|
|
session.pc.addTrack(track)
|
|
|
|
await session.pc.setRemoteDescription(offer)
|
|
|
|
if session.pending_candidates:
|
|
for cand in session.pending_candidates:
|
|
try: await session.pc.addIceCandidate(cand)
|
|
except: pass
|
|
session.pending_candidates.clear()
|
|
|
|
answer = await session.pc.createAnswer()
|
|
# Set to passive to let the other side act as DTLS server if needed.
|
|
answer_sdp = answer.sdp.replace('a=setup:active', 'a=setup:passive')
|
|
answer = RTCSessionDescription(sdp=answer_sdp, type="answer")
|
|
|
|
await session.pc.setLocalDescription(answer)
|
|
|
|
try:
|
|
await asyncio.wait_for(session.ice_gathering_complete.wait(), timeout=5.0)
|
|
except asyncio.TimeoutError:
|
|
pass
|
|
|
|
if session.pc.localDescription:
|
|
session.local_candidates = self._extract_candidates_from_sdp(
|
|
session.pc.localDescription.sdp
|
|
)
|
|
|
|
jingle_xml = self._build_session_accept(session, sid, our_jid)
|
|
return session, jingle_xml
|
|
|
|
def _build_session_accept(self, session: JingleSession, sid: str, responder: str) -> str:
|
|
"""Constructs the session-accept Jingle XML stanza."""
|
|
import xml.etree.ElementTree as ET
|
|
root = ET.Element('jingle', {'xmlns': self.NS_JINGLE, 'action': 'session-accept', 'sid': sid, 'responder': responder})
|
|
content = ET.SubElement(root, 'content', {'creator': 'initiator', 'name': '0', 'senders': 'both'})
|
|
desc = ET.SubElement(content, 'description', {'xmlns': 'urn:xmpp:jingle:apps:rtp:1', 'media': 'audio'})
|
|
|
|
sdp = session.pc.localDescription.sdp
|
|
codecs = {}
|
|
for line in sdp.splitlines():
|
|
if line.startswith("a=rtpmap:"):
|
|
match = re.match(r'a=rtpmap:(\d+)\s+(\S+)/(\d+)(?:/(\d+))?', line)
|
|
if match:
|
|
codec_id = match.group(1)
|
|
codecs[codec_id] = {'name': match.group(2), 'clockrate': match.group(3), 'channels': match.group(4) or '1', 'fmtp': {}}
|
|
elif line.startswith("a=fmtp:"):
|
|
match = re.match(r'a=fmtp:(\d+)\s+(.+)', line)
|
|
if match:
|
|
codec_id = match.group(1)
|
|
fmtp_params = {}
|
|
for param in match.group(2).split(';'):
|
|
if '=' in param:
|
|
key, val = param.strip().split('=', 1)
|
|
fmtp_params[key.strip()] = val.strip()
|
|
if codec_id in codecs:
|
|
codecs[codec_id]['fmtp'] = fmtp_params
|
|
|
|
for codec_id, codec_info in codecs.items():
|
|
pt_attrs = {'id': codec_id, 'name': codec_info['name'], 'clockrate': codec_info['clockrate']}
|
|
if codec_info['channels'] != '1': pt_attrs['channels'] = codec_info['channels']
|
|
pt = ET.SubElement(desc, 'payload-type', pt_attrs)
|
|
for param_name, param_value in codec_info['fmtp'].items():
|
|
ET.SubElement(pt, 'parameter', {'name': param_name, 'value': param_value})
|
|
|
|
ET.SubElement(desc, 'rtcp-mux')
|
|
trans = ET.SubElement(content, 'transport', {'xmlns': self.NS_JINGLE_ICE})
|
|
|
|
for line in sdp.splitlines():
|
|
if line.startswith("a=ice-ufrag:"): trans.set('ufrag', line.split(':')[1].strip())
|
|
if line.startswith("a=ice-pwd:"): trans.set('pwd', line.split(':')[1].strip())
|
|
if line.startswith("a=fingerprint:"):
|
|
parts = line.split(':', 1)[1].strip().split(None, 1)
|
|
if len(parts) == 2:
|
|
fp = ET.SubElement(trans, 'fingerprint', {'xmlns': 'urn:xmpp:jingle:apps:dtls:0', 'hash': parts[0], 'setup': 'passive'})
|
|
fp.text = parts[1]
|
|
|
|
for cand in session.local_candidates:
|
|
cand_elem = ET.SubElement(trans, 'candidate', {
|
|
'component': str(cand.get('component', '1')), 'foundation': str(cand.get('foundation', '1')),
|
|
'generation': str(cand.get('generation', '0')), 'id': cand.get('id', 'cand-0'),
|
|
'ip': cand.get('ip', ''), 'port': str(cand.get('port', '0')),
|
|
'priority': str(cand.get('priority', '1')), 'protocol': cand.get('protocol', 'udp'),
|
|
'type': cand.get('type', 'host')
|
|
})
|
|
if 'rel-addr' in cand: cand_elem.set('rel-addr', cand['rel-addr'])
|
|
if 'rel-port' in cand: cand_elem.set('rel-port', str(cand['rel-port']))
|
|
|
|
return ET.tostring(root, encoding='unicode')
|
|
|
|
async def add_ice_candidate(self, session: JingleSession, xml_cand):
|
|
try:
|
|
cand = RTCIceCandidate(
|
|
foundation=xml_cand.get('foundation', '1'), component=int(xml_cand.get('component', '1')),
|
|
protocol=xml_cand.get('protocol', 'udp'), priority=int(xml_cand.get('priority', '1')),
|
|
ip=xml_cand.get('ip'), port=int(xml_cand.get('port')), type=xml_cand.get('type', 'host'),
|
|
sdpMid="0", sdpMLineIndex=0
|
|
)
|
|
if session.pc.remoteDescription: await session.pc.addIceCandidate(cand)
|
|
else: session.pending_candidates.append(cand)
|
|
except Exception as e:
|
|
logger.debug(f"Candidate error: {e}")
|
|
|
|
async def stop_session(self, sid):
|
|
if sid in self.sessions:
|
|
s = self.sessions.pop(sid)
|
|
if s.audio_track:
|
|
try: s.audio_track.stop()
|
|
except: pass
|
|
s.audio_track = None
|
|
if s.pc:
|
|
try: await s.pc.close()
|
|
except: pass
|
|
s.pc = None
|
|
s.cleanup()
|
|
del s
|
|
logger.info(f"Stopped session {sid}")
|
|
self.clear_proposed_session(sid)
|
|
gc.collect()
|
|
|
|
async def end_all_sessions(self):
|
|
"""Terminates all active sessions and shuts down the broadcaster."""
|
|
self._shutdown = True
|
|
self._broadcaster.shutdown()
|
|
if self._cleanup_task:
|
|
self._cleanup_task.cancel()
|
|
try: await self._cleanup_task
|
|
except asyncio.CancelledError: pass
|
|
self._cleanup_task = None
|
|
for sid in list(self.sessions.keys()):
|
|
await self.stop_session(sid)
|
|
self._proposed_sessions.clear()
|
|
gc.collect()
|
|
|
|
def get_active_sessions(self):
|
|
return [s for s in self.sessions.values() if s.state == CallState.ACTIVE]
|
|
|
|
def _jingle_to_sdp(self, xml):
|
|
"""Converts Jingle XML format to standard SDP text."""
|
|
lines = ["v=0", "o=- 0 0 IN IP4 0.0.0.0", "s=-", "t=0 0", "a=group:BUNDLE 0", "a=msid-semantic: WMS *"]
|
|
content = xml.find(f"{{urn:xmpp:jingle:1}}content")
|
|
desc = content.find(f"{{urn:xmpp:jingle:apps:rtp:1}}description")
|
|
trans = content.find(f"{{urn:xmpp:jingle:transports:ice-udp:1}}transport")
|
|
|
|
payloads = [pt.get('id') for pt in desc.findall(f"{{urn:xmpp:jingle:apps:rtp:1}}payload-type")]
|
|
lines.append(f"m=audio 9 UDP/TLS/RTP/SAVPF {' '.join(payloads)}")
|
|
lines.append("c=IN IP4 0.0.0.0")
|
|
lines.append("a=rtcp:9 IN IP4 0.0.0.0")
|
|
lines.append(f"a=ice-ufrag:{trans.get('ufrag')}")
|
|
lines.append(f"a=ice-pwd:{trans.get('pwd')}")
|
|
|
|
fp = trans.find(f"{{urn:xmpp:jingle:apps:dtls:0}}fingerprint")
|
|
if fp is not None:
|
|
lines.append(f"a=fingerprint:{fp.get('hash')} {fp.text}")
|
|
setup = fp.get('setup', 'actpass')
|
|
if setup == 'actpass': setup = 'active'
|
|
lines.append(f"a=setup:{setup}")
|
|
|
|
lines.append("a=mid:0")
|
|
lines.append("a=sendrecv")
|
|
lines.append("a=rtcp-mux")
|
|
|
|
for pt in desc.findall(f"{{urn:xmpp:jingle:apps:rtp:1}}payload-type"):
|
|
lines.append(f"a=rtpmap:{pt.get('id')} {pt.get('name')}/{pt.get('clockrate')}/{pt.get('channels', '1')}")
|
|
|
|
return "\r\n".join(lines) |